代码随想录-Day10、11、13栈与队列相关题目(Java)

栈与队列知识点

栈的知识点

Java的Stack类

1.Stack类在java.util包中；

2.继承关系

Stack继承了Vector，而Vector类底层使用数组存储数据，那么Stack对象中存储的数据也是存储在数组中的。

3.构造函数

Stack只有一个无参数的构造函数。

4.常用方法介绍

（1）void push(item):把数据压入栈
     addElement（）是父类Vector中的方法，会将压入栈的元素存放在数组末尾。
（2）Object peek():查看栈顶的数据，返回值为栈顶元素，底层数组中最后一个元素，但是不会删除该元素
（3）Obeject pop():查看栈顶的数据，返回值为栈顶元素，底层数组中最后一个元素，同时把栈中的该元素删除。
（4）isEmpty（）：判断栈是否为空栈

队列的知识点

队列是一种特殊的线性表，遵循先入先出、后入后出的基本原则，一般来说，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。
但是java的某些队列运行在任何地方插入删除；比如我们常用的 LinkedList 集合，它实现了Queue 接口，因此，我们可以理解为 LinkedList 就是一个队列；
Queue接口中定义了如下方法：

(1) void add(Object e)：将指定元素加入此队列的尾部
(2) boolean offer(Object e)：将指定元素加入该队列的尾部，当使用有容量限制的队列时，此方法通常比void add(Object e)方法更好，使用此方法时，如果发现队列已满无法添加时，会直接返回false
(3) Object peek()：获取队列头部的元素，但是不删除该元素，如果此队列为空，则返回null
(4) Object poll()：获取队列头部的元素，并删除该元素，如果此队列为空，则返回null
(5) Object remove()：获取队列头部的元素，并删除该元素，队列为空时抛出异常NoSuchElementException

一、用栈实现队列

链接: 232.用栈实现队列

思路

设置两个栈来模拟队列，一个进栈，一个出栈

class MyQueue {
    Stack<Integer>  stackIn;
    Stack<Integer>  stackOut;

    public MyQueue() {
        stackIn = new Stack<>();
        stackOut = new Stack<>();
    }
    
    public void push(int x) {
        stackIn.push(x);
    }
    
    public int pop() {
        dumpStack();
        return stackOut.pop();
    }
    
    public int peek() {
        dumpStack();
        return stackOut.peek();
    }
    
    public boolean empty() {
        return stackIn.isEmpty() && stackOut.isEmpty();
    }
    public void dumpStack(){
        if (!stackOut.isEmpty())  return;
        while (!stackIn.isEmpty()){
            stackOut.push(stackIn.pop());
        }
    }
}

二、用队列实现栈

链接: 225. 用队列实现栈

class MyStack {
    Queue<Integer> que;
    public MyStack() {
        que = new LinkedList<>();
    }
    
    public void push(int x) {
        que.offer(x);
        int size = que.size();
        size--;
        while (size-- > 0){
            que.offer(que.poll());
        }
    }
    
    public int pop() {
        return que.poll();
    }
    
    public int top() {
        return que.peek();
    }
    
    public boolean empty() {
        return que.isEmpty();
    }
}

三、有效的括号

链接: 20.有效的括号

思路

由于栈结构的特殊性，非常适合做对称匹配类的题目。

首先要弄清楚，字符串里的括号不匹配有几种情况。
【要在纸上写一写，弄清楚】三种情况
【图片来源：代码随想录】
1.字符串里的左方向的括号多余了

遇到左方向括号，压入右方向括号，匹配结束发现栈中还要剩余的括号
对应代码中的 return st.isEmpty()

2.括号没有多余，但是括号的类型没有匹配上

对应代码中的 s.charAt(i) != st.peek()

3.字符串里右方向的括号多余了

在匹配过程中发现栈中没有元素了
对应代码中的 st.isEmpty()
小技巧，在压栈时，对于各种左括号，压入右括号，这样在匹配时，只用匹配是否相同即可。

代码

class Solution {
    public boolean isValid(String s) {
        Stack<Character> st = new Stack<>();
        if (s.length() % 2 != 0)
            return false;
        for (int i = 0;i < s.length();i++){
            if (s.charAt(i) == '(')  st.push(')');
            else if(s.charAt(i) == '[') st.push(']');
            else if(s.charAt(i) == '{') st.push('}');
            else if(st.isEmpty() || s.charAt(i) != st.peek()) return false;
            else st.pop();  
        }
        return st.isEmpty();
    }
}

错误

很简单的问题，自己出了一个错
在定义栈st的时候 Stack< Character> st 自己把尖括号里面的数据类型写成了char，不可以必须是对象类型
之间一直写的是Set< Interger> set

四、删除字符串中的所有相邻重复项

链接: 1047. 删除字符串中的所有相邻重复项

思路

本题思路很简单，通过题目可以看出使用栈或者类似栈的数据结构解决比较简单。
如果栈为空或者栈顶元素不等于字符串的字符，就push进去
相等就弹出。
在输出删除后的字符串时，注意顺序。

代码

用栈Stack来实现

class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> st = new Stack<>();
        for (int i = 0;i < s.length();i++){
            if (st.isEmpty() || st.peek() != s.charAt(i))
                st.push(s.charAt(i));
            else
                st.pop();
        }
        String str = "";
        while (!st.isEmpty()){
            str = st.pop() + str;
        }
        return str;
    }
}

用字符串来实现

class Solution {
    public String removeDuplicates(String s) {
        // 将 res 当做栈
        // 也可以用 StringBuilder 来修改字符串，速度更快
        StringBuffer res = new StringBuffer();
        // top为 res 的长度
        int top = -1;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            // 当字符串为空，或者有字符串，但字符串的末端不匹配，则将不匹配元素加入到字符串的末尾
            if (top < 0 || res.charAt(top) != c) {
                res.append(c);
                top++;
            } else {
                // 相当于从res字符串的末尾删除
                res.deleteCharAt(top);
                top--;           
            }
        }
        return res.toString();
    }
}

五、逆波兰表达式求值

链接: 150. 逆波兰表达式求值

思路

本题思路非常简单

从开始考虑，如果遇到运算符，则弹出两个数字，进行对应的运算符计算。

对于数字的情况，用else，将其压进去。

本题最困难的是对于各种数据类型的处理。

还有一个因为进栈出栈的特殊性，“-” 和“/”要进行特殊处理。

如下代码是自己完全不考虑字符串处理的情况

代码

自己写的代码

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<String> st = new Stack<>();
        for (int i = 0;i < tokens.length;i++){
            if (tokens[i] == "+"){
                st.push(st.pop() + st.pop());
            }
            else if (tokens[i] == "-"){
                st.push(-st.pop() + st.pop());
            }
            else if (tokens[i] == "*"){
                st.push(st.pop() * st.pop());
            }
            else if (tokens[i] == "/"){
                String temp1 = st.pop();
                String temp2 = st.pop();
                st.push(temp2 / temp1);
            }
            else{
                st.push(tokens[i]);
            }
        }
        return st.pop();
    }
}

报错

压进st的都是String类型，无法进行运算

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> st = new Stack<>();
        for (int i = 0;i < tokens.length;i++){
            if (tokens[i] == "+"){
                st.push(st.pop() + st.pop());
            }
            else if (tokens[i] == "-"){
                st.push(-st.pop() + st.pop());
            }
            else if (tokens[i] == "*"){
                st.push(st.pop() * st.pop());
            }
            else if (tokens[i] == "/"){
                int temp1 = st.pop();
                int temp2 = st.pop();
                st.push(temp2 / temp1);
            }
            else{
                // st.push(Integer.valueOf(tokens[i]));
                st.push(Integer.valueOf(tokens[i]));
            }
        }
        return st.pop();
    }
}

报错

正确解法

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> st = new Stack<>();
        for (String s : tokens){
            if ("+".equals(s)){
                st.push(st.pop() + st.pop());
            }
            else if ("-".equals(s)){
                st.push(-st.pop() + st.pop());
            }
            else if ("*".equals(s)){
                st.push(st.pop() * st.pop());
            }
            else if ("/".equals(s)){
                int temp1 = st.pop();
                int temp2 = st.pop();
                st.push(temp2 / temp1);
            }
            else{
                // st.push(Integer.valueOf(s));
                st.push(Integer.valueOf(s));
            }
        }
        return st.pop();
    }
}

重要：leetcode 内置jdk的问题，不能使用==判断字符串是否相等！

六、滑动窗口最大值

链接: 239. 滑动窗口最大值

思路

采用单调队列。

创建一个单调队列，里面的值从大到小依次递减。

大体思路：将前k个元素加入到单调队列中，队首元素即为最大值

【原因和定义的单调队列方法push(int val) 有关】

然后滑动，每遍历到一个新元素，会执行三步操作：

poll(int val)

【传入参数的原因是，单调队列里面可能在之前就把该元素删掉，确认一下，是否需要继续在单调队列里面删除】

push(int val)操作

【其实是push到单调队列里面，为了保持单调队列的性质，不会将全部元素都加入，而是进行一定的处理】

在单调队列里面比较大小，如果该新元素比单调队列里面的所有元素都大，则单调队列里面的元素都删除，加入新的元素。否则，找到该元素在单调队列里面合适的位置（单调队列中比它小的全都删掉）

peek()

直接取最大值即可。

代码

//自定义数组
class MyQueue {
    Deque<Integer> deque = new LinkedList<>();

    void push(int val){
        while (!deque.isEmpty() && val > deque.getLast()){
            deque.removeLast();
        }
        // 删除完不要忘记再加上啊。
        deque.add(val);
    }

    void poll(int val){
        if (!deque.isEmpty() && val == deque.peek()){
            deque.poll();
        }
    }
    int peek(){
        return deque.peek();
    }
}

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 1)
            return nums;

        int len = nums.length - k + 1;
        int[] res = new int[len];

        MyQueue myqueue = new MyQueue();
        int num = 0;

    // 将前k个元素加进单调队列
        for (int i = 0;i < k;i++){
            myqueue.push(nums[i]);
        }
        // 前k个元素的最大值
        res[num++] = myqueue.peek();

    // 开始滑动遍历
        for (int i = k;i < nums.length;i++){
            // 移除前面的元素
            myqueue.poll(nums[i - k]);
            // 加入新元素
            myqueue.push(nums[i]);
            // 返回最大值
            res[num++] = myqueue.peek();
        }
        return res;
    }
}

七、前K个高频元素

链接: 347.前 K 个高频元素

思路

思路很清晰：利用哈希表存储每个元素出现的次数，然后对次数进行排序，返回前k个键值对里面的键

数字是key,出现的次数是value

重点是这个排序应该如何进行，且只需要前k个元素的顺序，是否有简化方法

本题采用的思路是优先级队列模拟小顶堆，进行弹出过程的排序。

在优先队列中存储二元组(num,cnt),cnt表示元素值num在数组中的出现次数，出现次数按从队头到队尾的顺序是从小到大排,出现次数最低的在队头(相当于小顶堆)。

大体思路是，一边遍历哈希表，一边往优先级队列里面加，如果优先级队列大于我们所需的大小k，则新元素与优先级队列最开头即最小的元素进行比较，如果大于，则弹出开头最小的元素，将新元素加入优先级队列中。

最后哈希表遍历完成后，优先级队列里面只有k个元素。这k个元素按照小顶堆弹出的顺序，在前面的应该是出现次数最少的，所以我们设置了一个新的数组，采用倒序接收优先级队列中的元素（这个元素是键值对，我们只用接收键值对里面的key即可）

代码

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        // 利用哈希表存储每个元素出现的次数，
        Map<Integer,Integer> map = new HashMap<>();
        for (int i = 0;i < nums.length;i++){
            map.put(nums[i],map.getOrDefault(nums[i],0) + 1);
        }
        // 利用优先级队列（小顶堆）对次数进行排序，返回前k个键值对里面的键
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1,pair2) -> pair1[1] - pair2[1]);
        // 一边遍历哈希表，一边往优先级队列里面加，如果优先级队列大于我们所需的大小k，
        //则新元素与优先级队列最开头即最小的元素进行比较，如果大于，则弹出开头最小的元素，将新元素加入优先级队列中。
        for(Map.Entry<Integer,Integer> entry : map.entrySet()){
            if (pq.size() < k){
                pq.add(new int[]{entry.getKey(),entry.getValue()});
            }else{
                if (entry.getValue() > pq.peek()[1]){
                    pq.poll();
                    pq.add(new int[]{entry.getKey(),entry.getValue()});
                }
            }
        }
        // 设置了一个新的数组，采用倒序接收优先级队列中的元素
        int[] res = new int[k];
        for (int i = k - 1;i >= 0;i--){
            res[i] = pq.poll()[0];
        }
        return res;
    }
}

欠缺的知识点

1.Map.getOrDefault()
格式：
Map.getOrDefault(key，默认值)；

Map中会存储一一对应的key和value。
如果 在Map中存在key，则返回key所对应的的value。
如果 在Map中不存在key，则返回默认值。

【有种Math.max(num,0)的感觉】

2.for(Map.Entry<Integer,Integer> entry:map.entrySet())

Entry是属于Map的静态内部类，在创建Map对象的时候就会同时创建一个Entry对象，用来记录键与值的映射关系。

entrySet()：返回此映射所包含的映射关系的 Set 视图。

3.PriorityQueue<int[]> pq = new PriorityQueue<>((pair1,pair2)->pair1[1]-pair2[1]);

括号里面是Comparator接口的lambda表达式

/*Comparator接口说明:
 * 返回负数，形参中第一个参数排在前面；返回正数，形参中第二个参数排在前面
 * 对于队列：排在前面意味着往队头靠
 * 对于堆（使用PriorityQueue实现）：从队头到队尾按从小到大排就是最小堆（小顶堆），
 *                                从队头到队尾按从大到小排就是最大堆（大顶堆）--->队头元素相当于堆的根节点
 * */

Queue 和 Deque:https://blog.csdn.net/weixin_52767345/article/details/128592123?spm=1001.2014.3001.5502
优先级队列：https://blog.csdn.net/qq_41845823/article/details/124281687