当前位置： 首页 > news >正文

【算法】LeetCode：栈与队列篇

news 来源：原创 2025/5/1 11:35:43

一、理论基础

1.1 栈

  • 先进后出

  • 适合做对称匹配类的题目

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DrpyUL1a-1668170886039)(F:\算法学习\图片\2022-11-04_17-26-49.png)]

1.2 队列

  • 先近先出

二、LeetCode题序

总结

  • 栈
    • 20 (简单)有效的括号
    • 1047 (简单)删除字符串中的所有相邻重复项
    • 150 (中等)逆波兰表达式求值
  • 对垒
    • 239 (困难)滑动窗口最大值
    • 347 (中等)前 K 个高频元素

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（双端队列）来模拟一个栈，只要是标准的栈操作即可。

思路

在这里插入图片描述

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() {
        dumpInStack();
        return stackOut.pop();
    }
    //返回队头元素：如果出栈没有元素，则将入栈全部添加到出栈中，然后获取栈尾元素
    public int peek() {
        dumpInStack();
        return stackOut.peek();
    }
    //判空
    public boolean empty() {
        return stackOut.isEmpty() && stackIn.isEmpty();
    }
    private void dumpInStack(){
        if(stackOut.isEmpty()){
            while(!stackIn.isEmpty()) stackOut.push(stackIn.pop());
        }
    }
}
/**
 * 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（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

思路

在这里插入图片描述

class MyStack {
    Queue<Integer> que;
    Queue<Integer> queBuf;
    public MyStack() {
        que=new LinkedList<>();
        queBuf=new LinkedList<>();
    }
    //入栈
    public void push(int x) {
        //1.添加到 buf，作为队列的第一个出队元素
        queBuf.offer(x);
        //2.将前面栈顺序的元素添加到buf队后
        while(!que.isEmpty()) queBuf.offer(que.poll());
        //3.角色反转
        Queue<Integer> buf=queBuf;
        queBuf=que;
        que=buf;
    }
    //出栈
    public int pop() {
        return que.poll();
    }
    //返回栈顶元素
    public int top() {
        return que.peek();
    }
    //判空
    public boolean empty() {
        return que.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. 左右括号不匹配
  3. 右括号多余

在这里插入图片描述

class Solution {
    //方式一
    public boolean isValid(String s) {
        Deque<Character> deque=new LinkedList<>();
        for(int i=0;i<s.length();i++){
            char c=s.charAt(i);
            //1.遍历到每个左括号，给栈中添加对应的右括号
            if(c == '('){
                deque.push(')');
            }else if(c =='{'){
                deque.push('}');
            }else if(c =='['){
                deque.push(']');
            }
            //第一种情况：右括号多余
            //第二种情况：左右括号不匹配
            else if(deque.isEmpty() || deque.pop()!=c) return false;
        }
        //第三种情况：左括号多余
        return deque.isEmpty();
    }
    //方式二
    public boolean isValid2(String s) {
        Stack<Character> stack=new Stack<>();
        for(int i=0;i<s.length();i++){
            char c=s.charAt(i);
            if(c == ')'){
                //第二种情况：右括号多余
                if(stack.isEmpty()) return false;
                //弹出左括号
                char v=stack.pop();
                //第一种情况：左右括号不匹配
                if(v!='(') return false;
            }else if(c =='}'){
                if(stack.isEmpty()) return false;
                char v=stack.pop();
                if(v!='{') return false;
            }else if(c ==']'){
                if(stack.isEmpty()) return false;
                char v=stack.pop();
                if(v!='[') return false;
            }else{
                //添加左括号
                stack.push(c);
            }
        }
        //第三种情况：左括号多余
        return stack.isEmpty();
    }
}

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

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

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

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

在这里插入图片描述

/**
 * 方式三效率更高
 */
class Solution {
    //方式一：用 StirngBuilder 作为栈，实现逻辑参考上图
    public String removeDuplicates1(String s) {
        StringBuilder sb=new StringBuilder();
        //记录栈顶指针
        int top=-1;
        //1.遍历字符串中每一个字符
        for(int i=0;i<s.length();i++){
            char c=s.charAt(i);
            //2.如果当前字符与栈顶字符相等：删除栈顶字符，指针后移
            if(top>=0 && sb.charAt(top)==c) sb.deleteCharAt(top--);
            //3.当前字符与栈顶字符不相等：入栈，移动前移
            else{
                sb.append(c);
                top++;
            }
        }
        return sb.toString();
    }
    //方式二：用 ArrayDeque 作为栈，实现逻辑参考上图
    public String removeDuplicates2(String s) {
        //ArrayDeque在添加、删除两端元素时比链表好得多
        ArrayDeque<Character> deque=new ArrayDeque<>();
        //1.遍历字符串中每一个字符
        for(int i=0;i<s.length();i++){
            char c=s.charAt(i);
            //2.与栈定元素进行比较：栈空、不相等则入栈
            if(deque.isEmpty() || deque.peek()!=c) deque.push(c);
            //3.相等则移除栈定的相等元素
            else{
                deque.pop();
            }
        }
        String result="";
        while(!deque.isEmpty()){
            result=deque.pop()+result;
        }
        return result;
    }
    //方式三：双指针法，使用slow确定最终的字符串
    public String removeDuplicates(String s) {
        char[] arr=s.toCharArray();
        int slow=1;
        for(int fast=1;fast<s.length();fast++){
            //2.删除重复元素：将fast元素前移
            arr[slow]=arr[fast];
            //1.找到slow-1、slow相同：slow指针指向slow-1，在下一论将slow+1的值赋给slow-1
            if(slow>0 && arr[slow]==arr[slow-1]) slow--;
            else slow++;
        }
        return new String(arr,0,slow);
    }
}

150 (中等)逆波兰表达式求值

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

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

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

  • 示例

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

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

在这里插入图片描述

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack=new LinkedList<>();
        //1.遍历字符
        for(int i=0;i<tokens.length;i++){
            String s=tokens[i];
            //2.是运算符：取出栈顶两个元素进行运算，将结果推入栈顶
            if("+".equals(s) || "-".equals(s) || "*".equals(s) || "/".equals(s)){
                int b=stack.pop();
                int a=stack.pop();
                if("+".equals(s)) stack.push(a+b);
                else if("-".equals(s)) stack.push(a-b);
                else if("*".equals(s)) stack.push(a*b);
                else if("/".equals(s)) stack.push(a/b);
            }
            //3.是数字：推入栈顶
            else stack.push(Integer.valueOf(s));
        }
        return stack.pop();
    }
}

239 (困难)滑动窗口最大值

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

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

class Solution {
    //解法一：利用双端队列直接实现单调队列（队列元素为数组下标），效果最好
    public int[] maxSlidingWindow(int[] nums, int k) {
        ArrayDeque<Integer> deque=new ArrayDeque<>();
        int len=nums.length;
        int[] result=new int[len-k+1];
        int num=0;
        for(int i=0;i<len;i++){
            //1.移除窗口过界元素:从第k+1个元素开始
            while(!deque.isEmpty() && deque.peek()<i-k+1) deque.poll();
            //2.添加窗口元素：添加到队尾，并保证队尾小于前面元素
            while(!deque.isEmpty() && nums[deque.peekLast()]<nums[i]) deque.removeLast();
            deque.add(i);
            //3.在窗口中获取最大值
            if(i>=k-1) result[num++]=nums[deque.peek()];
        }
        return result;
    }
    //解法二：自定义单调队列
    public int[] maxSlidingWindow2(int[] nums, int k) {
        int len=nums.length;
        int[] result=new int[len-k+1];
        MyQueue myQue=new MyQueue();
        int num=0;
        //生成窗口
        for(int i=0;i<k;i++){
            //1.在队尾依次添加窗口元素：遍历队尾元素，如果比队尾元素大，则删除队尾元素
            myQue.add(nums[i]);
        }
        result[num++]=myQue.peek();
        //移动窗口
        for(int i=k;i<len;i++){
            //1.在队尾依次添加窗口元素：遍历队尾元素，如果比队尾元素大，则删除队尾元素
            myQue.poll(nums[i-k]);
            //2.在队头删除窗口过界元素：如果队头最大值元素与此元素相等，则移除队头元素
            myQue.add(nums[i]);
            //3.获取队头元素：此时队头元素为窗口中最大值
            result[num++]=myQue.peek();
        }
        return result;
    }
}
class MyQueue {
    Deque<Integer> deque=new LinkedList<>();
    public void add(int value){
        while(!deque.isEmpty() && value>deque.getLast()) deque.removeLast();
        deque.add(value);
    }
    public void poll(int value){
        if(value==deque.peek()) deque.pop();
    }
    public int peek(){
        return deque.peek();
    }
}

347 (中等)前 K 个高频元素

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

/**
 * 1.计算频数
 * 2.根据频数排序
 * 3.获取前k的元素
 */
class Solution {
    //方式一：基于小根堆
    public int[] topKFrequent(int[] nums, int k) {
        //1.计算频数
        Map<Integer,Integer> map=new HashMap<>();
        for(int num:nums){
            map.put(num,map.getOrDefault(num,0)+1);
        }
        //2.根据频数排序
        //小堆队列：int[0]=entry.key,int[1]=entry.value。按int[1]排序
        PriorityQueue<int[]> pq=new PriorityQueue<>((a,b)->a[1]-b[1]);
        Set<Map.Entry<Integer,Integer>> entries=map.entrySet();
        for(Map.Entry<Integer,Integer> entry:entries){
            Integer key=entry.getKey();
            Integer value=entry.getValue();
            if(pq.size()<k) pq.add(new int[]{key,value});
            else{
                if(pq.peek()[1]<value){
                    pq.poll();
                    pq.add(new int[]{key,value});
                }
            }
        }
        //3.获取前k的元素
        int result[]=new int[k];
        for(int i=k-1;i>=0;i--){
            result[i]=pq.poll()[0];
        }
        return result;
    }
    //方式二：基于大根堆
    //省略...
}

相关文章：

  • 【Linux】进程通信 | 管道
  • python 办公自动化（Excel）
  • 前端面试题记录（大环境不太友好的2022篇）
  • 为什么python量化书籍都不讲金融只讲编程？
  • Cadence Allegro DXF结构图的导入详细教程
  • 【Leetcode】拿捏链表（一）——206.反转链表、203.移除链表元素
  • C语言实现三子棋小游戏（源码+教程）
  • 爱心html制作并部署github
  • 【蓝桥杯真题练习】STEMA科技素养练习题库 答案版013 持续更新中~
  • Mysql 当前月每天累计统计，Mysql 本月第一天
  • 第一个发布成功的UI组件库
  • 【python】点燃我，温暖你 ，快来Get同款~
  • Flutter：webview_flutter插件使用
  • 学习python第6天
  • [附源码]计算机毕业设计JAVAjsp求职招聘平台开发
  • C++ opencv 图像像素的逻辑操作
  • 【Revit二次开发】模型中存储数据——参数和外部存储(Parameter, Schema and Entity)
  • 基于粒子群优化和模拟退火算法增强传统聚类研究（Matlab代码实现）
  • 前端经典面试题 | 性能优化之图片优化
  • 这些包括我在内都有的Python编程陋习，趁早改掉
  • 国际油价重挫！美股道指连跌三月，啥情况？
  • 新能源车盈利拐点：8家上市车企去年合计净利854亿元，多家扭亏
  • 体坛联播｜欧冠巴萨3比3战平国米，柯洁未进入国家集训队
  • 上海市十六届人大常委会第二十一次会议表决通过有关人事任免事项
  • 五一假期上海地铁部分线路将延时运营，这些调整请查收
  • 中国农业国际交流协会会长王守聪失联已逾半年，协会启动罢免