算法通关村第五关——队栈和Hash的经典算法题

1.用栈实现队列

栈的特点是后进先出，队的特点是先进先出。两个栈将底部拼接到一起就能实现队列的效果。

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(push、pop、peek、empty):
要实现的MyQueue类：
1.void push(intx)将元素x推到队列的末尾
2.int pop()从队列的开头移除并返回元素
3.int peek()返回队列开头的元素
4.boolean empty()如果队列为空，返回true;否则，返回false

这个题的思路是，将一个栈当作输入栈，用于压入push传入的数据；另一个栈当作输出栈，用于pop和peek操作。

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)。
实现MyStack类：
1.void push(intx)将元素x压入栈顶。
2.int pop()移除并返回栈顶元素。
3.int top()返回栈顶元素。
4.boolean empty()如果栈是空的，返回true;否则，返回false。

思路：这个问题首先想到的是使用两个队列来实现。为了满足栈的特性，即最后入栈的元素最先出栈，在使用队列实现栈时，应满足队列前端的元素是最后入栈的元素。可以使用两个队列实现栈的操作，其中queue1用于存储栈内的元素，queue.2作为入栈操作的辅助队列。
入栈操作时，首先将元素入队到queue2,然后将queue1的全部元素依次出队并入队到queue.2,此时
queue:2的前端的元素即为新入栈的元素，再将queue1和queue2互换，则queue1的元素即为栈内的元素，queue1的前端和后端分别对应栈顶和栈底。
由于每次入栈操作都确保quue1的前端元素为栈顶元素，因此出栈操作和获得栈顶元素操作都可以简单实现。出栈操作只需要移除queue1的前端元素并返回即可，获得栈顶元素操作只需要获得queue1的前端元素并返回即可（不移除元素）。
由于queue1用于存储栈内的元素，判断栈是否为空时，只需要判断queue1是否为空即可。

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

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

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

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

    public int top() {
        return queue1.peek();
    }

    public boolean empty() {
        return queue1.isEmpty();
    }
}

3.n数和相加

3.1两数之和

我们创建一个哈希表，对于每一个，我们首先查询哈希表中是否存在target-X,然后将×插入到哈希表中，即可保证不会让×和自己匹配。

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

3.2三数之和

这个公认最好的方式是”排序+双指针“。我们可以先将数组排序来处理重复结果，然后还是固定一位元素，由于数组是排好序的，所以我们用双指针来不断寻找即可求解。

public class ThreeSum {

    public static List<List<Integer>> threeSum(int[] nums) {
        int n = nums.length;
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        // 枚举 a
        for (int first = 0; first < n; ++first) {
            // 需要和上一次枚举的数不相同
            if (first > 0 && nums[first] == nums[first - 1]) {
                continue;
            }
            // c 对应的指针初始指向数组的最右端
            int third = n - 1;
            int target = -nums[first];
            // 枚举 b
            for (int second = first + 1; second < n; ++second) {
                // 需要和上一次枚举的数不相同
                 if (second > first + 1 && nums[second] == nums[second - 1]) {
                     continue;
                 }
                // 需要保证 b 的指针在 c 的指针的左侧
                while (second < third && nums[second] + nums[third] > target) {
                    --third;
                }
                // 如果指针重合，随着 b 后续的增加
                // 就不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环
                if (second == third) {
                    break;
                }
                if (nums[second] + nums[third] == target) {
                    List<Integer> list = new ArrayList<Integer>();
                    list.add(nums[first]);
                    list.add(nums[second]);
                    list.add(nums[third]);
                    ans.add(list);
                }
            }
        }
        return ans;
    }

}