队栈和Hash的经典算法题

关卡名	队栈和Hash的经典算法题	我会了✔️
内容	1.如何用栈实现队列	✔️
	2.如何用队列实现栈	✔️
	3.三数之和如何做	✔️

1 用栈实现队列 

栈的特点是后进先出，队的特点是先进先出。两个栈将底部拼接到一起就能实现队列的效果， 通过队列也能实现栈的功能。在很多地方能看到让你通过两个栈实现队列的题目，也有很多地方是两个队列实现栈的题目，我们就干脆一次看一下如何做。这正好对应LeetCode232和225两道题。
LeetCode232 先看题意：
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

要实现的 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾

int pop() 从队列的开头移除并返回元素

int peek() 返回队列开头的元素

boolean empty() 如果队列为空，返回 true ；否则，返回 false

这个题的思路是，将一个栈当作输入栈，用于压入 push 传入的数据；另一个栈当作输出栈，用于pop 和 peek 操作。
每次pop 或 peek 时，若输出栈为空则将输入栈的全部数据依次弹出并压入输出栈，这样输出栈从栈顶往栈底的顺序就是队列从队首往队尾的顺序。
代码难度不算大：

    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 用队列实现栈

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

void push(int x) 将元素 x 压入栈顶。

int pop() 移除并返回栈顶元素。

int top() 返回栈顶元素。

boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

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

很多人开始LeetCode的第一题就是求两数之和的问题，事实上除此之外，还有几个类似的问题，例如LeetCode15 三数之和，LeetCode18.四数相加和 LeetCode454.四数相加II等等。我们就集中看一下。

3.1 两数之和

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

示例1：

输入：nums = [2,7,11,15], target = 9

输出：[0,1]

解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例2：

输入：nums = [3,2,4], target = 6

输出：[1,2]

本题可以使用两层循环解决，第一层确定一个数，2，7，一直到11，然后内层循环继续遍历后序元素，判断是否存在target - x的数即可，代码如下： 

public int[] twoSum(int[] nums,int target){
    int n = nums.length;
    for(int i=0;i<n;++i){
        for(int j=i+1;j<n;++j){
            if(nums[i] + nums[j] == target){
                return new int[]{i, j};
            }
        }
    }
    return new int[0];
}

这种方式的不足在于寻找 target - x 的时间复杂度过高，我们可以使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N)降低到 O(1)。这样我们创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。

public int[] twoSum(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];
}

 如果使用Hash还是比较容易的，时间复杂度低了，但是空间复杂度高了，那是否还有其他方法呢？这个真不多，不过假如告诉你原始数组是有序的那可以进一步优化，仍然采用两层循环的方式，外层仍然是一个个遍历，而内层循环可以换成二分，这样复杂度就从O(n^2)降低到O(nlogn)。感兴趣的同学可以尝试写一下看看。

3.2 三数之和

如果将两个数换成三个会怎样呢？LeetCode15.给你一个包含 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]]

本题看似就是两数增加了一个数，但是难度增加了很多，我们可以使用三层循环直接找，时间复杂度为O(n^3)，太高了，放弃。也可以使用双层循环+Hash来实现，首先按照第一题两数之和的思路，我们可以固定一个数target，再利用两数之和的思想去map中存取或查找(-1)*target - num[j]，但是这样的问题是无法消除重复结果，例如如果输入[-1,0,1,2,-1,-4]，返回的结果是[[-1,1,0],[-1,-1,2],[0,1,-1],[0,-1,1],[1,-1,0],[2,-1,-1]]，如果我们再增加一个去重方法，将直接导致执行超时。
那这时候，我们就要想其他方法了，这个公认最好的方式是”排序+双指针“。我们可以先将数组排序来处理重复结果，然后还是固定一位元素，由于数组是排好序的，所以我们用双指针来不断寻找即可求解，代码如下：

 

class Solution {
    public 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;
    }
}