队栈和Hash的经典算法题

1. 用栈实现队列

仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作 (push、pop、peek、empty)

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false

思路:
将一个栈当作输入栈, 用于压入 push 传入的数据; 另一个栈当作输出栈, 用与 peek 和 pop 操作。
每次 peek 或 pop 时, 若输出栈为空则将输入栈的全部数据依次弹出并压入输出栈, 这样输出栈从栈顶往栈底的顺序就是队列从队首往队尾的顺序。

代码实现:

class MyQueue {
    Deque<Integer> inStack;
    Deque<Integer> outStack;
    public MyQueue() {
        inStack = new LinkedList<Integer>();
        outStack = new LinkedList<Integer>();
    }
    public void push(int x) {
        inStack.push(x);
    }
    public int pop() {
        if (outStack.isEmpty()) {
            in2out();
        }
        return outStack.pop();
    }
    public int peek() {
        if (outStack.isEmpty()) {
            in2out();
        }
        return outStack.peek();
    }
    public boolean empty() {
        return inStack.isEmpty() && outStack.isEmpty();
    }
    private void in2out() {
        while (!inStack.isEmpty()) {
            outStack.push(inStack.pop());
        }
    }
}

2. 用队列实现栈

仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

思路:

使用两个队列 queue1 和 queue2, 其中 queue1 用于存储栈内的元素, queue2 作为入栈操作的辅助队列。

入栈操作时, 首先将元素入队到 queue2 中, 然后将 queue1 的全部元素依次出队入队到 queue2 中, 此时 queue2 的队首元素即为新入栈的元素, 再将 queue1 和 queue2 互换, 则 queue1 的元素即为栈内的元素, queue1 的队首和队尾分别对应栈顶和栈底。

出栈操作时, 只需要将 queue1 的队首元素出队即可。

代码实现:

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;

    public MyStack_Mine() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }

    public void push(int value) {
        queue2.offer(value);
        while (!queue1.isEmpty()) {
            queue2.offer(queue1.poll());
        }
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;
    }

    public int pop() {
        return queue1.poll();
    }

    public int peek() {
        return queue1.peek();
    }
    
    public boolean isEmpty() {
        return queue1.isEmpty();
    }
}

3. n 数之和

3.1 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

示例1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

思路:
使用哈希表。 循环数组, 对于每一个元素 x, 首先查询哈希表的 key 中是否存在 target - x, 然后当前元素的元素值和索引分别作为 key 和 value 存入哈希表中, 保证不会让 x 和自己匹配。

代码实现:

public static int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        if (map.containsKey(target - nums[i])) {
            return new int[]{map.get(target - nums[i]), i};
        }
        map.put(nums[i], i);
    }
    return new int[0];
}

3.2 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。注意：答案中不可以包含重复的三元组。

示例1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]

思路:
使用 " 排序 + 双指针 "。先将数组进行排序, 然后固定一位元素 first, 定义两个指针 second 和 third 分别指向当前固定元素的下一个元素和数组最后一个元素; second指针向后遍历, 直到 nums[second] + nums[third] = -nums[first] 即为满足条件的三元组, 当 nums[second] + nums[third] > -nums[first] 时, third指针向前走一步; 依次循环遍历整个数组。