【算法通关村第五关——队列和Hash经典算法题】

队列和Hash经典算法题

---

前言

在算法通关村第五关上一篇中我们介绍了队列和Hash的基本概念和用法。在这篇文章，我们先简单看几道队列和Hash的算法题。

一、用栈实现队列

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

代码实现如下

class MyQueue {
	//定义两个栈，一个用来实现队列的pop，一个用来实现队列的push
    Deque<Integer> inStack;
    Deque<Integer> outStack;
    public MyQueue() {
        inStack = new LinkedList<Integer>();
        outStack = new LinkedList<Integer>();
    }
    public void push(int x) {
        inStack.push(x);
    }
    //pop操作要从outStack出栈，如果该栈为空，调用方法补充该栈的数据
    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());
        }
    }
}

二、用队列实现栈

leetcode225 先看题意:
请你仅使用两个队列实现一个后入先出 (LIFO) 的栈，并支持普通栈的全部四种操作 (push、top、pop 和 empty) 。
其实这道题和第一道题类似，只不过是用的数据结构转换了一下而已，我就不做太多的赘述，大家看代码理解一下就可以。

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();
    }
}

二、N个数之和

2.1两个数之和

LeetCode1.给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值target 的那两个整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。
本题有两种解法，第一种就是双层for循环，前后遍历整个数组，遇到和target相等的就返回。
由于我们这里着重介绍的是Hash，所以用第二种办法：遍历一次nums数组，然后用target-当前遍历的数组的值，去Hash中找，没找到的话就放进Hash中，找到之后就返回下标。
代码如下

public int[] twoSum2(int[] nums, int target) { 
// 定义一个名为twoSum2的方法，接收一个整数数组nums和一个整数目标值target作为参数，返回一个整数数组
    Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>(); 
    // 创建一个哈希表，用于存储数组中的数及其下标
    for (int i = 0; i < nums.length; ++i) { 
    // 遍历数组nums
        if (hashtable.containsKey(target - nums[i])) { 
        // 如果哈希表中存在一个数，使得这个数与当前遍历到的数的和等于目标值
            return new int[]{hashtable.get(target - nums[i]), i}; 
            // 返回这两个数的下标
        }
        hashtable.put(nums[i], i); 
        // 如果哈希表中不存在这样的数，将当前遍历到的数及其下标存入哈希表
    }
    return new int[0]; 
    // 如果遍历完数组仍未找到满足条件的两个数，返回一个空数组
}

2.2三个数之和

如果将两个数换成三个会怎样呢? LeetCode15.给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c，使得 a + b + c = ? 请你找出所有和为 0 且不重复的三元组，注意:答案中不可以包含重复的三元组。
解题思路（结合代码阅读）：
1.首先，对输入的整数数组进行排序。
2.初始化一个空的结果列表 ans，用于存储满足条件的三元组。
3.使用两层循环遍历数组中的每个元素，分别用 first 和 second 表示。
第一层循环：从数组的第一个元素开始，每次向后移动一位。
第二层循环：从当前元素 first 的下一个元素开始，每次向后移动一位。
4.在内层循环中，使用一个指针 third 指向数组的最右端，初始值为 n - 1。
5.初始化一个变量 target，其值为 -nums[first]，表示需要找到的第三个数。
6.在内层循环中，使用一个指针 second 从 first + 1 开始向后移动，每次向后移动一位。
在移动 second 的过程中，通过判断 nums[second] + nums[third] 与 target 的大小关系来调整 third 指针的位置，确保可以找到满足条件的 c 值。
如果 second 和 third 指针重合，说明已经找到了满足条件的三元组，可以跳出循环。
7.如果 nums[second] + nums[third] 等于 target，说明找到了一个满足条件的三元组。
将这三个数添加到结果列表 ans 中。
8.完成内层循环后，继续外层循环，直到遍历完整个数组。
9.返回结果列表 ans，即为所有满足条件的三元组。

 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) {
                // 需要保证 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;
    }

---

总结

在今天的文章，我们讨论了两种使用栈和队列实现队列和栈的操作。首先，我们介绍了如何使用两个栈（一个用于入队操作，另一个用于出队操作）来实现一个先入先出队列。接着，我们讨论了如何使用两个队列（一个用于入队操作，另一个用于出队操作）来实现一个后入先出栈。这些方法都利用了栈和队列的特性，即后进先出（LIFO）和先进先出（FIFO）。
接下来，我们详细介绍了LeetCode 232和225两道题的解法。对于232题，我们使用了两个栈来实现一个先入先出队列，同时支持队列的基本操作。对于225题，我们使用了两个队列来实现一个后入先出栈，并支持栈的基本操作。这两道题的思路都是通过转换数据结构来实现栈和队列的功能。
最后，我们进一步探讨了如何在一个包含n个整数的数组中找到所有和为0且不重复的三元组。我们首先对数组进行排序，然后使用两层循环遍历数组中的每个元素，分别用first和second表示。在内层循环中，我们使用一个指针third指向数组的最右端，初始值为n-1。通过调整third指针的位置，我们可以确保找到满足条件的三元组。