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

文章目录

  • 前言
  • 1. 使用栈实现队列
  • 2. 使用队列实现栈
  • 3. n数之和问题
    • 3.1 两数之和
      • 两次for循环:
      • Hash表解决
    • 3.2 三数之和
  • 拓展:
  • 总结


前言


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

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

1. 使用栈实现队列

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

题目介绍参考:232. 用栈实现队列 - 力扣(LeetCode)
算法通过村第五关-队列和Hash白银笔记|队列和Hash_第1张图片
算法通过村第五关-队列和Hash白银笔记|队列和Hash_第2张图片
这个题目来说,思路很简答,就是一个栈当作输入,用于压入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)
算法通过村第五关-队列和Hash白银笔记|队列和Hash_第3张图片
算法通过村第五关-队列和Hash白银笔记|队列和Hash_第4张图片
思路:这个问题首先我们想到的是使用两个队列来时先栈,为了班组栈的特性,即最后入栈的元素最先出栈,在使用队列·实现栈的时候,应该满足队列的前端的元素是最后入栈的元素。可以使用两个队列实现栈的操作,其中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)
算法通过村第五关-队列和Hash白银笔记|队列和Hash_第5张图片
算法通过村第五关-队列和Hash白银笔记|队列和Hash_第6张图片
提供两种常见的解法:

  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)
算法通过村第五关-队列和Hash白银笔记|队列和Hash_第7张图片
算法通过村第五关-队列和Hash白银笔记|队列和Hash_第8张图片
我们来看这个题, 突然增加了一个数,看似简单实则增加了很大难度,我们当然可以算则三次循环嵌套直接找,这样的话时间复杂度太高了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的使用。

你可能感兴趣的:(算法集训营,算法,哈希算法,笔记,数组,双指针,java,栈)