算法通过村第五关-队列和Hash白银笔记|队列和Hash

---

前言

---

提示：昔日玫瑰一其名流芳 今日所持唯玫瑰之名 -- 翁贝利·埃柯

队列和Hash是基础的使用工具，在算法的应用非常广泛，比如广度优先等等，这些问题呢都是比较常见的，往后再说，这里我们看一些比较典型的队列或者Hash问题。

1. 使用栈实现队列

栈的特点是【先进后出】，队列的特点是【先进先出】。两个栈将底部拼接到一起就可以实现队列的所有功能，通过队列也能实现栈的功能。在很多地方能看到通过两个栈实现队列的问题，当然也有很多地方是两个队列实现栈的题目，我们这里就一次吧这个问题搞明白😁。

题目介绍参考：232. 用栈实现队列 - 力扣（LeetCode）


这个题目来说，思路很简答，就是一个栈当作输入，用于压入push传入的数据；另一个栈当作输出栈，用来pop和peek操作。

每次pop或者peek的时候，如果输出栈为空则将输入栈的全部元素一次弹出并压入输出栈，这样输出栈从栈顶到栈低的顺序就是队列首部到尾部的顺序。

那么就代码展示：

import java.util.Stack;

class MyQueue {
    private Stack<Integer> inStack;
    private Stack<Integer> outStack;

    public MyQueue() {
        inStack = new Stack<Integer>();
        outStack = new Stack<Integer>();
    }

    public void push(int x) {
        inStack.push(x);
    }

    public int pop() {
        if (outStack.isEmpty()) {
            inOutStack();
        }
        return outStack.pop();
    }

    public int peek() {
        if (outStack.isEmpty()) {
            inOutStack();
        }
        return outStack.peek();
    }

    public boolean empty() {
        return inStack.isEmpty() && outStack.isEmpty();
    }

    private void inOutStack() {
        while (!inStack.isEmpty()) {
            outStack.push(inStack.pop());
        }
    }
}

2. 使用队列实现栈

参考题目介绍：225. 用队列实现栈 - 力扣（LeetCode）


思路：这个问题首先我们想到的是使用两个队列来时先栈，为了班组栈的特性，即最后入栈的元素最先出栈，在使用队列·实现栈的时候，应该满足队列的前端的元素是最后入栈的元素。可以使用两个队列实现栈的操作，其中queue1，用于存储栈内的元素，queue2作为入栈操作作为辅助队列。

入栈操作时，首先将元素入队到queue2，然后将queue1的全部元素一次出队并入队到queue2，此时queue2的前端元素就是新入栈的元素，再将queue1和queue2互换，则queue1的元素即为栈内的元素，queue1的前端和后端分别对应栈顶和栈底。

由于每次入栈操作都要确保queue1的前端元素为栈顶元素，因此出栈操作和获得栈顶元素的操作都很简单实现。出栈操作只要移除queue1的前端元素并返回即可，获取栈顶元素操作只需要获取queue1的前端元素并返回即可（不需要移除元素）

最后，queue1用于存储栈内元素，判断是否为空时，只需要判断queue1是否为空即可。

说了这么多，写代码展示💕：

import java.util.LinkedList;
import java.util.Queue;

class MyStack {

    private Queue<Integer> queue1;
    private Queue<Integer> queue2;

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

    public void push(int x) {
        queue2.offer(x);
        if (!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数之和问题

很多人刷算法的第一道题目就是：求两数之和的问题，事实上除了这个问题意外还有几个类似的问题，什么三数之和，四数相加I和四数相加II等等，这里我们就看看下面这些问题；

3.1 两数之和

参考题目介绍：1. 两数之和 - 力扣（LeetCode）


提供两种常见的解法：

1. 两次for循环
2. hash表解决

两次for循环：

这个题目使用for就是暴力解决，我们一次确定一个数，只要满足条件就可以返回，代码展示如下：

 	 public static 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];
    }

Hash表解决

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

代码写起来也很简单：

	public static int[] twoSum(int[] nums, int target) {
        int n = nums.length;
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < n; 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];
    }

当然使用Hash还是比较简单的，时间复杂度降低了，但是空间复杂度提高了，那么试想一下有没有其他的方法呢？这个还真不多，不过我们可以对原始数组（有序）进一步做优化，然后采用两层循环的方法，外层让然是一个个的遍历，内层可以换成二分，这样的话复杂度可以从O(n^2)降低到O(nlogn)。有兴趣的话可以尝试一下哟🤣。

3.2 三数之和

参考题目简介：15. 三数之和 - 力扣（LeetCode）


我们来看这个题， 突然增加了一个数，看似简单实则增加了很大难度，我们当然可以算则三次循环嵌套直接找，这样的话时间复杂度太高了O(n^3)，直接放弃。

我们尝试采用双层循环 + Hash来实现，首先结合上面的思路，固定一个target，再利用Hash去查找或取出(-1)*target - num[j]，但是这样的话没办法消除重复结果，比如[-1,0,1,2,-1,-4]，返回结果时[[-1,1,0],[-1,-1,2],[0,-1,1],[1,-1,0],[2,-1,-1]]，如果再加一个去重的话，那就要超时了。

这个时候，我们就要想其他办法，公认的最好方式“排序 + 双指针”。我们可以先将数组排序处理重复结果，然后固定以为元素，由于数组是排好序的，所以我们可以使用双指针不断的寻找即可求解，代码实现如下：

	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];
            // 第二层循环
            for (int second = first + 1;second < n; second++){
                // 与上次不同
                if(second > first + 1 && nums[second] == nums[second -1]){
                    continue;
                }
                // 内层双指针  确保 c 在b 的右边
                while(second < third && nums[second] + nums[third] > target){
                    --third;
                }
                // 当然如果 指针重合了  b++
                // 就不会有满足 a + b + c = 0,并且 b < 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;
    }

拓展：

如果你感兴趣，可以进一步的探索，如果再加一个数呢？

推荐例题：18. 四数之和 - 力扣（LeetCode）、454. 四数相加 II - 力扣（LeetCode）

---

总结

`提示：重点掌握栈和队列的转换，Hash的使用。