算法通关村第五关——队栈哈希白银挑战笔记

本篇内容主要强化队列、栈和哈希表的使用，能够灵活的根据各类数据结构的特性完成算法题目。将从分析数据结构特性出发，理解为什么这么选择数据结构，以及题目解决思路。

1.用栈实现队列

队列：先进先出；栈：先进后出。那么如何使用栈来实现队列呢？比如元素AB依次入栈，出栈顺序变为BA，再将元素BA依次入栈，出栈顺序就是AB，实现了元素AB进，元素AB出这一队列的特性。

OK，两个元素的情况已经搞定了，那么三个元素的情况呢？答：依旧如此！元素ABC入栈，出栈CBA，元素CBA入栈，出栈ABC。

OK，三个元素的情况都已经搞定了，后面n个元素的情况也是如此！再看比如AB元素进入队列，A出队，C进入队列，BC出队，这一问题该怎么用栈来表示呢？①AB元素入栈，A出栈，A入栈，A出栈②C元素入栈，CB元素出栈，CB元素入栈，BC元素出栈。根据步骤①②即可获得序列ABC。在描述中，我们不难发现有两个栈存在！令人振奋的是，用栈实现队列的思想可以当作模板！

输入栈，输出栈：①元素入队的时候，元素压入输入栈中；②元素出队，输入栈的元素出栈压入输出栈，弹出输出栈栈顶元素；③队列为空，输入栈和输出栈的元素都是空。厘清思路，直接上代码！

class MyQueue {

    Stack<Integer> inStack;
    Stack<Integer> outStack;

    public MyQueue() {
        inStack = new Stack<>();
        outStack = new Stack<>();
    }
    public void push(int x) {
        inStack.push(x);
    }
    //输出栈非空则直接出栈，输出栈为空则将输入栈的元素加入输出栈再出栈
    public int pop() {
        if(outStack.empty()){
            in2Out();
        }
        return outStack.pop();
    }
    public int peek() {
        if(outStack.empty()){
            in2Out();
        }
        return outStack.peek();
    }
    public boolean empty() {
        return inStack.empty() && outStack.empty();
    }

    private void in2Out(){
        while(!inStack.empty()){
            outStack.push(inStack.pop());
        }
    }

}

2.用队列实现栈

还是先从两个元素情况的元素说起，AB元素入栈这一过程，可以先将元素A入队，此时这个数据结构就是栈，第二个元素B到来时，必须要使队列中呈现BA的排列顺序，只能将队列先清空，将B入队，再将A入队，可是原队列清空将导致元素A丢失，因此必须采用一种数据结构将A保存，采用什么数据结构？答：队列。因此应该设置两个队列，队列1和队列2，队列1中保存A，队列2为空，队列2中先入队元素B，再入队元素A，此时队列2中元素为BA符合栈的规则！

如果元素C此时入栈该怎么办？我们要保证最后队列中顺序为CBA，可以将现在队列1清空，并入队元素C，然后将队列2中元素加入队列1中，使得队列1中元素为CBA，满足栈规则！

用队列实现栈的思想依然可以当作模板来特殊记忆！

队列1，队列2：每次元素入栈时，首先入队队列2，然后将队列1中的元素全部加入队列2中（队列1此时为空），队列2就完成了栈这一数据结构。下一次入栈，需要将元素先入队队列1，然后将队列2中元素全部加入队列1中（队列2为空），队列1就完成了栈这一数据结构。两个过程交替进行！如果每次逻辑执行完，队列1和队列2互换，那么队列1始终是符合栈的顺序，队列2始终是空队列。

厘清思路，直接上代码！

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

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

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

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

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

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

3.n个数之和

两个数之和

题目见LeetCode1，描述为给定一个整数数组和一个目标值，返回数组中和为目标值的两个数字的下标。

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

输出：[0,1]

解题思路很简单，暴力点！两边循环，第一个循环确定第一个数字，第二个循环确定第二个数字，题目解决！可是这种时间复杂度往往时间超限，我们该如何优化？

很简单嘛，我可以在寻找第二个数字的时候使用哈希表，以空间换时间，将算法整体的时间复杂度下降到，快快快，具体该怎么做呢？别急听我分析！

哈希表用于查找第二个数字，当找到第二个数字，则查找成功返回对应数字下标；当没找到第二个数字，我们就将当前遍历的第一个数字加入和哈希表中，希望后续遍历到第二个数字的时候，能在哈希表中查找到第一个数字。

厘清思路，直接上代码！

    public static int[] twoSum2(int[] nums, int target) {
        HashMap<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};
            }else{
                map.put(nums[i],i);
            }
        }
        return new int[0];
    }

三个数之和

题目见LeetCode15，很显然第三个题目是第二个题目的进一步考察，显然第数字A需要进行遍历枚举，那么再找数字BC的时候，就将问题转化为找两个数字之和（和为-A），为了确保查找结果不重复，每次枚举A的值应该不同，BC可以任意查找，那么问题进一步转化，如何确保数组中元素不重复？先排序，后使用数组元素去重的思想即可！排序后，数组中ABC中，C一定是最大的数字，如果B+C==-A则找到这三个数字，进行存储，如果B+C<-A那么证明不存在这样的ABC三个数字（题目用例设置，我们无需考虑这种情况），如果B+C>-A那么证明可能存在这样的ABC三个数字使得A+B+C==0，那么继续将C调小，再枚举就可以。这种方法就是“排序+双指针”，可以作为模板重点记忆！

厘清思路，直接上代码!

    public static List<List<Integer>> threeSum(int[] nums) {
        int len = nums.length;
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<>();
        for (int first = 0; first < len; first++) {
            if(first > 0 && nums[first] == nums[first - 1]){
                continue;
            }
            int target = -nums[first];
            int third = len-1;
            for (int second = first + 1; second < len; second++) {
                while(third > second && nums[second] + nums[third] > target){
                    third--;
                }
                if(second == third){
                    break;
                }
                if(nums[second] + nums[third] == target){
                    List<Integer> list = new ArrayList<>();
                    list.add(nums[first]);
                    list.add(nums[second]);
                    list.add(nums[third]);
                    ans.add(list);
                }
            }
        }
        return ans;
    }

OK，《算法通关村第五关——队栈哈希白银挑战笔记》结束，喜欢的朋友三联加关注！关注鱼市带给你不一样的算法小感悟！（幻听）

再次，感谢鱼骨头教官的学习路线！鱼皮的宣传！小y的陪伴！ok，拜拜，第五关第三幕见！

很难坚持下来，可坚持下来了，也就不觉得难！加油！