【力扣-刷题——栈与队列】附力扣链接、题目描述、解题方法及代码（232 、225、20、1047、150、239、347）

😀如果对你有帮助的话😊
🌺为博主点个赞吧 👍
👍点赞是对博主最大的鼓励😋
💓爱心发射~💓

附：栈与队列中常用的java函数方法整理

基础知识

使用栈实现队列的下列操作：

• push(x) – 将一个元素放入队列的尾部。
• pop() – 从队列首部移除元素。
• peek() – 返回队列首部的元素。
• empty() – 返回队列是否为空。

MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);
queue.peek();  // 返回 1
queue.pop();   // 返回 1
queue.empty(); // 返回 false

232. 用栈实现队列——简单

力扣

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

• void push(int x) 将元素 x 推到队列的末尾
• int pop() 从队列的开头移除并返回元素
• int peek() 返回队列开头的元素
• boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

• 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
• 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false
 

提示：

• 1 <= x <= 9
• 最多调用 100 次 push、pop、peek 和 empty
• 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

方法一:使用双端队列

class MyQueue {
    /*
        1、先存到s1中，入栈
        2、出栈从s2出
            - 若s2为空，将s1存入s2
            - 不为空直接弹出
    */
    Stack<Integer> s1;
    Stack<Integer> s2;
    int front;

    public MyQueue() {
        s1 = new Stack<>();
        s2 = new Stack<>();
    }
    
    public void push(int x) {
        // 判断元素是否为首位
        if(s1.empty()){
            front = x;
        }
        s1.push(x);
    }
    
    public int pop() {
        // 从s2中弹出
        if(s2.isEmpty()){
            // s2为空，从s1中弹到s2
            while(!s1.isEmpty()){
                s2.push(s1.pop());
            }
        }
        return s2.pop();
    }
    
    public int peek() {
        if(!s2.isEmpty()){
            return s2.peek();
        }
        return front;
    }
    
    public boolean empty() {
        return s1.isEmpty() && s2.isEmpty();
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

225. 用队列实现栈——简单

力扣

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

• void push(int x) 将元素 x 压入栈顶。
• int pop() 移除并返回栈顶元素。
• int top() 返回栈顶元素。
• boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

• 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
• 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False
 

提示：

• 1 <= x <= 9
• 最多调用100 次 push、pop、top 和 empty
• 每次调用 pop 和 top 都保证栈不为空

方法二：一个队列

class MyStack {

    /*
        队列： 出列 .poll()
              入列 .offer()
              首元素 .peek()
    */
    Queue<Integer> queue;

    // 创建队列
    public MyStack() {
        queue = new LinkedList<Integer>();
    }
    
    /*
        1、先入列
        2、循环将前n个元素出列--再入列
     */
    public void push(int x) {
        int n = queue.size();
        queue.offer(x);
        for(int i=0; i<n; ++i){
            queue.offer(queue.poll());
        }
    }
    
    // 出元素
    public int pop() {
        return queue.poll();
    }
    
    // 取出队列首元素
    public int top() {
        return queue.peek();
    }
    
    public boolean empty() {
        return queue.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

20. 有效的括号

力扣

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

示例 4：

输入：s = "([)]"
输出：false

示例 5：

输入：s = "{[]}"
输出：true

提示：

• 1 <= s.length <= 104
• s 仅由括号 '()[]{}' 组成

方法一：辅助栈法-map

题解

class Solution {
    /*
        创建哈希表--key为左括号({[ ，  value为右括号]})

        注意：
            - 栈为空会报错，先存入 key：'？'value：'？'
            - 最后一个元素为左括号，返回长度为 1
    */

    private static final Map<Character,Character> map = new HashMap<Character,Character>(){
        {
            put('(',')');put('{','}');put('[',']');put('?','?');
        }
    };

    public boolean isValid(String s) {
        // 判断首位
        if(s.length()>0 && !map.containsKey(s.charAt(0))) return false;
        LinkedList<Character> stack = new LinkedList<Character>(){{add('?');}};
        for(Character c : s.toCharArray()){
            if(map.containsKey(c)){
                stack.addLast(c);
            }else if(map.get(stack.removeLast()) != c){
                return false;
            }
        }
        return stack.size()==1;
    }
}

方法一：辅助栈法–不用map方法

class Solution {
    /*
        创建哈希表--key为左括号({[ ，  value为右括号]})

        注意：
            - 栈为空会报错，先存入 key：'？'value：'？'
            - 最后一个元素为左括号，返回长度为 1
    */

    private static final Map<Character,Character> map = new HashMap<Character,Character>(){
        {
            put('(',')');put('{','}');put('[',']');put('?','?');
        }
    };

    public boolean isValid(String s) {
        /* 
            不用map方法
                1、判断是否为空
                2、将与左括号对应的-右括号放入栈中
                3、入栈    push()  出栈pop()
        */ 
        if(s.isEmpty()) return false;
        Stack<Character> stack = new Stack<Character>();
        for(char c : s.toCharArray()){
            if(c == '('){
                stack.push(')');
            }else if(c == '['){
                stack.push(']');
            }else if(c == '{'){
                stack.push('}');
            }else if(stack.isEmpty() || c != stack.pop()){
                return false;
            }
        }
        if(stack.isEmpty()){
            return true;
        }
        return false;

    }
}

1047. 删除字符串中的所有相邻重复项——简单

力扣

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：

输入："abbaca"
输出："ca"
解释：
例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。
 

提示：

• 1 <= S.length <= 20000
• S 仅由小写英文字母组成。

方法一：栈

class Solution {
    /*
        1、首位---将字符串存入栈中
        2、判断--栈中有数&&与栈顶字符是否相同
            - 相同，出栈 pop
            - 不同，入栈 push
    */
    public String removeDuplicates(String s) {
        StringBuffer stack = new StringBuffer();
        int top = -1;
        for(int i=0; i<s.length(); ++i){
            char c = s.charAt(i);
            if(top>=0 && c== stack.charAt(top)){
                stack.deleteCharAt(top);
                --top;
            }else{
                stack.append(c);
                ++top;
            }
        }
        return stack.toString();
    }
}

150. 逆波兰表达式求值——中等

力扣

根据 逆波兰表示法，求表达式的值。

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

注意 两个整数之间的除法只保留整数部分。

可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：

输入：tokens = ["4","13","5","/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

示例 3：

输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22
 

提示：

• 1 <= tokens.length <= 104
  -tokens[i]是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

• 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
• 该算式的逆波兰表达式写法为( ( 1 2 + ) ( 3 4 + ) * )。

逆波兰表达式主要有以下两个优点：

• 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
• 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

方法一：栈

class Solution {
    public int evalRPN(String[] tokens) {
        /*
            1、判断是数字就存入栈
            2、符号，出栈两个数做运算，再入栈
            3、返回--出栈值
        */
        Deque<Integer> stack = new LinkedList<Integer>();
        int n = tokens.length;
        for(int i=0; i<n; ++i){
            // 取出字符串中的数
            String t = tokens[i];
            if(isNumber(t)){
                // 将整型数据Integer转换为基本数据类型int
                stack.push(Integer.parseInt(t));
            }else{
                int num2 = stack.pop();
                int num1 = stack.pop();
                switch(t){
                    case"+":
                        stack.push(num1 + num2);
                        break;
                    case"-":
                        stack.push(num1 - num2);
                        break;
                    case"*":
                        stack.push(num1 * num2);
                        break;
                    case"/":
                        stack.push(num1 / num2);
                        break;
                    default:
                }
            }
        }
        return stack.pop();
    }
    public boolean isNumber(String t){
        return !("+".equals(t)||"-".equals(t)||"*".equals(t)||"/".equals(t));
    }
}

239. 滑动窗口最大值——困难

力扣

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

示例 1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

示例 2：

输入：nums = [1], k = 1
输出：[1]

提示：

• 1 <= nums.length <= 105
• -104 <= nums[i] <= 104
• 1 <= k <= nums.length

双向队列解决滑动窗口最大值

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        /*
            双向队列
            1、队列中数--从大到小排列
            2、队列中保存的是数组中数的--下标
            3、队列中要保证为三个数

            特殊：
                - 数组为空、数组小于2直接返回数组
         */ 
        if(nums == null || nums.length<2) return nums;
        LinkedList<Integer> queue = new LinkedList(); //双向队列，保存窗口最大值数组位置
        int[] res = new int[nums.length + 1 - k];  // 结果数组
        for(int i=0; i<nums.length; ++i){
            // 先判断nums[i]的值是否都比队列中大
            while(!queue.isEmpty() && nums[queue.peekLast()] <=nums[i]){
                queue.pollLast();
                
            }
            queue.addLast(i); // 添加到队列中
            // 判断队列队首
            if(queue.peek() <= i-k){
                queue.poll(); // 队列中只有三个数
            }
            // 保存值
            if(i+1 >= k){
                res[i+1-k] = nums[queue.peek()];
            }
        }
        return res;


    }
    /*
    peekLast() 方法检索此deque队列的最后一个元素(但不删除)。返回null如果此deque队列为空。
    queue.pollLast()此方法用于检索链表的最后一个元素或结尾元素，最后从列表中删除最后一个元素
    */

    /*
    输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
    输出: [3,3,5,5,6,7]

    解释过程中队列中都是具体的值，方便理解，具体见代码。
    初始状态：L=R=0,队列:{}
    i=0,nums[0]=1。队列为空,直接加入。队列：{1}
    i=1,nums[1]=3。队尾值为1，3>1，弹出队尾值，加入3。队列：{3}
    i=2,nums[2]=-1。队尾值为3，-1<3，直接加入。队列：{3,-1}。此时窗口已经形成，L=0,R=2，result=[3]
    i=3,nums[3]=-3。队尾值为-1，-3<-1，直接加入。队列：{3,-1,-3}。队首3对应的下标为1，L=1,R=3，有效。result=[3,3]
    i=4,nums[4]=5。队尾值为-3，5>-3，依次弹出后加入。队列：{5}。此时L=2,R=4，有效。result=[3,3,5]
    i=5,nums[5]=3。队尾值为5，3<5，直接加入。队列：{5,3}。此时L=3,R=5，有效。result=[3,3,5,5]
    i=6,nums[6]=6。队尾值为3，6>3，依次弹出后加入。队列：{6}。此时L=4,R=6，有效。result=[3,3,5,5,6]
    i=7,nums[7]=7。队尾值为6，7>6，弹出队尾值后加入。队列：{7}。此时L=5,R=7，有效。result=[3,3,5,5,6,7]

    */
}

347. 前 K 个高频元素

力扣

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

示例 2:

输入: nums = [1], k = 1
输出: [1]

提示：

• 1 <= nums.length <= 105
• k 的取值范围是 [1, 数组中不相同的元素的个数]
• 题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的

小顶堆

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        /*
        小顶堆:
            - map中存放数字出现次数(key-数 value-次数)
            - 小顶堆遍历

        函数：
            PriorityQueue 一个基于优先级的无界优先级队列。优先级队列的元素按照其自然顺序进行排序
            poll()返回队首元素的同时删除队首元素，队列为空时返回NULL
            队列接口的offer(E e)方法在不违反容量限制的情况下可以立即将指定的元素插入此队列
            
        */

        int[] res = new int[k];
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i : nums){
            map.put(i, map.getOrDefault(i, 0) + 1);
        }
        Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
        // 根据map的value值正序排，相当于一个小顶堆
        PriorityQueue<Map.Entry<Integer,Integer>> queue = new PriorityQueue<>((o1,o2)-> o1.getValue() - o2.getValue());
        for(Map.Entry<Integer,Integer> entry:entries){
            queue.offer(entry);
            if(queue.size() > k){
                queue.poll();
            }
        }
        for(int i=k-1; i>=0; i--){
            res[i] = queue.poll().getKey();
        }
        
        return res;

    }
}

71. 简化路径

力扣