栈部分刷题记录

最新推荐文章于 2024-03-12 21:08:10 发布
最新推荐文章于 2024-03-12 21:08:10 发布
阅读量111 收藏
点赞数
分类专栏： 编程学习 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013607605/article/details/124603319
版权
本文探讨了栈在处理各种计算和解析问题中的应用，包括棒球操作、简化路径、最长绝对路径、逆波兰表达式求值、基本计算器、括号匹配、函数的独占时间和标签验证。通过示例代码展示了如何利用栈解决这些问题，涉及括号匹配、运算符优先级和递归等概念。
摘要由CSDN通过智能技术生成

一、用栈访问最后若干元素

question 682(棒球)、

在这里插入图片描述
answer

class Solution {
    public int calPoints(String[] ops) {
        int res=0;
        int[] arr=new int[ops.length];
        int i=0;
        for(String s:ops){
            switch(s){
                case "+" : arr[i]=arr[i-1]+arr[i-2];i++; break;
                case "D" : arr[i]=2*arr[i-1];i++;break;
                case "C" : arr[i-1]=0;i--;break;
                default : arr[i]=Integer.valueOf(s);i++;
            }
        }
        for(int num:arr){
            res+=num;
        }
        return res;
    }
}

question71(简化路径)、

在这里插入图片描述
answer

class Solution {
    public String simplifyPath(String path) {
        String[] names=path.split("/");
        //java官方推荐栈用双端队列
        Deque<String> stack=new ArrayDeque<String>();
        for(String name:names){
            if("..".equals(name)){
                if(!stack.isEmpty()){
                    stack.pollLast();
                }
            }else if(name.length()>0&&!".".equals(name)){
                stack.offerLast(name);
            }
        }
        StringBuffer ans=new StringBuffer();
        if(stack.isEmpty()){
            ans.append("/");
        }else{
            while(!stack.isEmpty()){
                ans.append("/");
                ans.append(stack.pollFirst());
            }
        }
        return ans.toString();
    }
}

question 388（文件的最长绝对路径）

在这里插入图片描述
在这里插入图片描述
answer

class Solution {
    public int lengthLongestPath(String input) {
        int n = input.length();
        //下标
        int pos = 0;
        //ans记录当前最长的路径
        int ans = 0;
        Deque<Integer> stack = new ArrayDeque<Integer>();
        while (pos < n) {
            /* 检测当前文件(一个文件夹)的深度 */
            int depth = 1;
            //第几级目录就有几个'\t'
            while (pos < n && input.charAt(pos) == '\t') {
                pos++;
                depth++;
            }
            /* 统计当前文件名的长度 */
            boolean isFile = false;  
            int len = 0;   
            while (pos < n && input.charAt(pos) != '\n') {
                if (input.charAt(pos) == '.') {
                    isFile = true;
                }
                len++;
                pos++;
            }
            /* 跳过当前的换行符 */
            pos++;
            //stack.size()应该小于depth，才属于同一级目录，此刻还未插入当前文件长度
            while (stack.size() >= depth) {
                stack.pop();
            }
            //加一是   ’/‘
            if (!stack.isEmpty()) {
                len += stack.peek() + 1;
            }
            if (isFile) {
                ans = Math.max(ans, len);
            } else {
                //文件长度递增的入栈（l1,l2+l1+1,l1+l2+l3+2）
                stack.push(len);
            }
        }
        return ans;
    }
}

二、栈与计算器

question 150（逆波兰表达式求值）、

在这里插入图片描述
answer

class Solution {
    public int evalRPN(String[] tokens) {
        int len=tokens.length;
        Deque<Integer> stack=new ArrayDeque<>();
        String operaters="+-*/";
        for(int i=0;i<len;i++){
            String token=tokens[i];
            if(!operaters.contains(token)){
                //push 添加栈顶
                stack.push(Integer.parseInt(token));
            }else{
                //pop移除栈顶
                int num1=stack.pop();
                int num2=stack.pop();
                switch(token){
                    case "+" : stack.push(num1+num2);break;
                    case "-" : stack.push(num2-num1);break;
                    case "*" : stack.push(num1*num2);break;
                    case "/" : stack.push(num2/num1);break;
                }
            }
        }
        return stack.pop();
    }
}

answer2

class Solution {
    public int evalRPN(String[] tokens) {
        int len=tokens.length;
        Deque<Integer> stack=new ArrayDeque<>();
        
        for(int i=0;i<len;i++){
            String token=tokens[i];
            if(isNumber(token)){
                //push 添加栈顶
                stack.push(Integer.parseInt(token));
            }else{
                //pop移除栈顶
                int num1=stack.pop();
                int num2=stack.pop();
                switch(token){
                    case "+" : stack.push(num1+num2);break;
                    case "-" : stack.push(num2-num1);break;
                    case "*" : stack.push(num1*num2);break;
                    case "/" : stack.push(num2/num1);break;
                }
            }
        }
        return stack.pop();
    }
     public boolean isNumber(String token) {
        return !("+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token));
    }
}

question 227(基本计算器)、

在这里插入图片描述
answer

class Solution {
    //一般需要两个栈，一个数据栈，一个符号栈
    //符号栈用sign代替，只存储上一个符号，乘除直接计算，减变加负数
    public int calculate(String s) {
        //-2  = +(-2)
        //保存上一个符号，初始为+
        char sign='+';
        //当前数
        int num=0;
        Deque<Integer> stack=new LinkedList<>();
        int len=s.length();

        for(int i=0;i<len;i++){
            if(Character.isDigit(s.charAt(i))){
                //可能存在进位的情况
                num=num*10+s.charAt(i)-'0';
            }
            if(!Character.isDigit(s.charAt(i))&&s.charAt(i)!=' '||i==len-1){
                switch(sign){
                    //push从头插入
                    case '+' : stack.push(num);break;
                    case '-' : stack.push(-num);break;
                    case '*' : stack.push(stack.pop()*num); break;
                    case '/' : stack.push(stack.pop()/num); break;
                }
                sign=s.charAt(i);
                num=0;
            }
        }
        //处理stack里面相加的数字
        int ans=0;
        while(!stack.isEmpty()){
            ans+=stack.pop();
        }
        return ans;
    }
}

question224(基本计算器)

在这里插入图片描述
answer

class Solution {
    public int calculate(String s) {
        Deque<Integer> stack=new LinkedList<>();
        //sign 代表正负
        int sign=1;
        int res=0;
        int length=s.length();
        for(int i=0;i<length;i++){
            char ch=s.charAt(i);
            if(Character.isDigit(ch)){
                int cur=ch-'0';
                //可能不是个位数
                while(i+1<length&&Character.isDigit(s.charAt(i+1))){
                    cur=cur*10+s.charAt(++i)-'0';
                }
                //没遇到括号，直接累加
                res=res+cur*sign;
            }else if(ch=='+'){
                sign=1;
            }else if(ch=='-'){
                sign=-1;
            }else if(ch=='('){
                //括号外面已经累加的数，入栈
                stack.push(res);
                res=0;
                stack.push(sign);
                sign=1;
            }else if(ch==')'){
                //res*stack.pop(),弹出的是符号位
                res=res*stack.pop()+stack.pop();
            }
        }
        return res;
    }
}

三、栈与括号匹配

question20(有效的括号)、

在这里插入图片描述
answer

class Solution {
    public boolean isValid(String s) {
        int len=s.length();
        if(len%2!=0){
            return false;
        }

        Map<Character,Character> pairs=new HashMap<>();
        pairs.put(')','(');
        pairs.put(']','[');
        pairs.put('}','{');

        //遇到左括号，入栈，遇到右括号，看栈中是否有对应的左括号
        Deque<Character> stack=new LinkedList<>();

        for(int i=0;i<len;i++){
            char cur=s.charAt(i);
            //如果是右括号
            if(pairs.containsKey(cur)){
                if(stack.isEmpty()||stack.peek()!=pairs.get(cur)){
                    return false;
                }
                stack.pop();
            }else{
                stack.push(cur);
            }
        }
        return stack.isEmpty();
    }
}

answer 2
时间复杂度高，replace o(n)

class Solution {
    public boolean isValid(String s) {
        if(s.length()%2!=0){
            return false;
        }
        int len=s.length()/2;
        for(int i=0;i<len;i++){
            s=s.replace("()","");
            s=s.replace("[]","");
            s=s.replace("{}","");
            if(s.length()==0){
                return true;
            }
        }
        return false;
    }
}

question636（函数的独占时间)、

在这里插入图片描述
在这里插入图片描述

answer

class Solution {
    public int[] exclusiveTime(int n, List<String> logs) {
        //这道题关键是单线程非抢占cpu，就是说父函数调用子函数
        //子函数结束之后、父函数才有可能结束。不会出现父函数结束了，子函数继续运行的情况。
        //即只有最内层的进程出战后，外层进程才可能出栈
        //遇到start入栈，end出栈
        //最内层函数出栈后要判断栈顶是否还有函数，有的话，下一个出栈的就是，要把当前函数的占用时间减掉
        Deque<int[]> stack=new LinkedList<>();
        //n个程序
        int[] res =new int[n];
        for(String log:logs){
            //把每一项用 ： 分割开
            String[] s=log.split(":");
            int id=Integer.parseInt(s[0]);
            int time=Integer.parseInt(s[2]);
            //如果是开始时间就入栈
            if("start".equals(s[1])){
                stack.push(new int[]{id,time});
                //如果是结束时间就统计当前id运行的时间
            }else if("end".equals(s[1])){
                //0:id, 1:time
                int[] pop=stack.pop();
                //运行时间=end-start+1;
                int interval=time-pop[1]+1;
                //把当前id的运行时间存储起来
                res[pop[0]]+=interval;
                //下一个进程减去当前运行的时间
                if(!stack.isEmpty()){
                     res[stack.peek()[0]]-=interval;
                }
               
            }
        }
        return res;
    }
}

question591(标签验证器)*、

在这里插入图片描述
answer
在这里插入图片描述
answer

class Solution {
    public boolean isValid(String code) {
        int n = code.length();
        Deque<String> tags = new ArrayDeque<String>();

        int i = 0;
        while (i < n) {
            if (code.charAt(i) == '<') {
                if (i == n - 1) {
                    return false;
                }
                //如果遇到结束符
                if (code.charAt(i + 1) == '/') {
                    //结束符的位置
                    int j = code.indexOf('>', i);
                    if (j < 0) {
                        return false;
                    }
                    //截取结束符的名字
                    String tagname = code.substring(i + 2, j);
                    //与开始符名字比较 是否相等
                    if (tags.isEmpty() || !tags.peek().equals(tagname)) {
                        return false;
                    }
                    tags.pop();
                    i = j + 1;
                    if (tags.isEmpty() && i != n) {
                        return false;
                    }
                } else if (code.charAt(i + 1) == '!') {
                    //如果是[CDATA[
                    if (tags.isEmpty()) {
                        return false;
                    }
                    //  i+9是cdate里面的内容
                    if (i + 9 > n-1) {
                        return false;
                    }
                    String cdata = code.substring(i + 2, i + 9);
                    if (!"[CDATA[".equals(cdata)) {
                        return false;
                    }
                    int j = code.indexOf("]]>", i);
                    if (j < 0) {
                        return false;
                    }
                    //跳过]]>
                    i = j + 3;
                } else {
                    int j = code.indexOf('>', i);
                    if (j < 0) {
                        return false;
                    }
                    String tagname = code.substring(i + 1, j);
                    if (tagname.length() < 1 || tagname.length() > 9) {
                        return false;
                    }
                    for (int k = 0; k < tagname.length(); ++k) {
                        if (!Character.isUpperCase(tagname.charAt(k))) {
                            return false;
                        }
                    }
                    tags.push(tagname);
                    i = j + 1;
                }
            } else {
                if (tags.isEmpty()) {
                    return false;
                }
                ++i;
            }
        }

        return tags.isEmpty();
    }
}

question32（最长有效括号）

在这里插入图片描述
answer

class Solution {
    public int longestValidParentheses(String s) {
        int res=0;
        Deque<Integer> stack=new LinkedList<Integer>();
        //表示最后一个没有被匹配的右括号的下标
        stack.push(-1);
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)=='('){
                stack.push(i);
            }else{
                stack.pop();
                if(stack.isEmpty()){
                    //没有左括号匹配，更新最后一个没有被匹配的右括号下标
                    stack.push(i);
                }else{
                    //匹配
                    res=Math.max(res,i-stack.peek());
                }
            }
        }
        return res;
    }
}

四、递归

question 385(迷你语法分析器)、

在这里插入图片描述
answer

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * public interface NestedInteger {
 *     // Constructor initializes an empty nested list.
 *     public NestedInteger();
 *
 *     // Constructor initializes a single integer.
 *     public NestedInteger(int value);
 *
 *     // @return true if this NestedInteger holds a single integer, rather than a nested list.
 *     public boolean isInteger();
 *
 *     // @return the single integer that this NestedInteger holds, if it holds a single integer
 *     // Return null if this NestedInteger holds a nested list
 *     public Integer getInteger();
 *
 *     // Set this NestedInteger to hold a single integer.
 *     public void setInteger(int value);
 *
 *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
 *     public void add(NestedInteger ni);
 *
 *     // @return the nested list that this NestedInteger holds, if it holds a nested list
 *     // Return empty list if this NestedInteger holds a single integer
 *     public List<NestedInteger> getList();
 * }
 */
class Solution {
    //用栈做
    public NestedInteger deserialize(String s) {
        if(s.charAt(0)!='['){
            return new NestedInteger(Integer.parseInt(s));
        }
        Deque<NestedInteger> stack=new ArrayDeque<>();
        int num=0;
        int flage=1;
        for(int i=0;i<s.length();i++){
            char c=s.charAt(i);
            if(c=='-'){
                flage=-1;
            }else if(Character.isDigit(c)){
                num=num*10+c-'0';
            }else if(c=='['){
                stack.push(new NestedInteger());
            }else if(c==','||c==']'){
                if(Character.isDigit(s.charAt(i-1))){
                    num*=flage;
                    stack.peek().add(new NestedInteger(num));
                }
               num=0;
               flage=1;
               if(c==']'&&stack.size()>1){
                   NestedInteger ni=stack.pop();
                   stack.peek().add(ni);
               }
            }
        }
        return stack.pop();
    }
}

question341 *、

question 394(字符串解码)

在这里插入图片描述
answer

class Solution {
    /**
     * 双栈解法：
     * 准备两个栈，一个存放数字，一个存放字符串
     * 遍历字符串分4中情况
     * 一、如果是数字 将字符转成整型数字 注意数字不一定是个位 有可能是十位，百位等 
     所以digit = digit*10 + ch - '0';
     * 二、如果是字符 直接将字符放在临时字符串中
     * 三、如果是"[" 将临时数字和临时字符串入栈
     * 四、如果是"]" 将数字和字符串出栈 此时临时字符串res = 出栈字符串 + 出栈数字*res
     */
    public String decodeString(String s) {
      //创建数字栈，创建字符串栈及临时数字和临时字符串
      Deque<Integer> stack_digit=new LinkedList<>();
      Deque<StringBuilder> stack_string=new LinkedList<>();
      int digit=0;
      StringBuilder res=new StringBuilder();
      //遍历字符串分4中情况
      for(int i=0;i<s.length();i++){
          char ch=s.charAt(i);
          if(ch=='['){
            //如果是"["将临时数字和临时字符串入栈
            stack_digit.push(digit);
            stack_string.push(res);
            digit=0;
            res=new StringBuilder();
          }else if(ch==']'){
            //如果是"]"将数字和字符串出栈，此时临时字符串
            //res=出栈字符串+出栈数字*res;
            StringBuilder temp=stack_string.poll();
            int count=stack_digit.poll();
            for(int j=0;j<count;j++){
                temp.append(res.toString());
            }
            res=temp;
          }else if(Character.isDigit(ch)){
              //如果是数字，放入临时数字中
              digit=digit*10+ch-'0';
          }else{
              //如果是字符，直接将字符放在临时字符串中
              res.append(ch);
          }
      }
      return res.toString();
    }
}
【刷题总结】栈系列问题
迈向年薪百万之路
06-07 782
文章目录一、算法介绍二、解题模板1、栈的实现2、栈的API3、深度优先4、单调栈问题三、栈系列问题1、栈的基础特征（1）设计题，用来实现其他结构（2）利用栈的基础特征2、括号&表达式运算&退格问题（1）括号匹配问题（2）表达式运算问题（3）退格问题3、单调栈4、树的遍历-深度优先5、图的遍历-深度优先 一、算法介绍 栈：后入先出 栈系列问题：https://leetcode-cn.com/tag/stack/problemset/ 栈的典型问题 设计题 括号、表达式运算、字符串
栈（刷题）
chichan0818的博客
01-08 169
转载于:https://my.oschina.net/u/3715015/blog/2998652
刷题篇-栈
qq_40438165的博客
01-11 1453
一、设计一个最小栈 题目要求：设计一个支持push，pop，top等操作并且可以在O(1)O(1)O(1)时间内检索出最小元素的堆栈。 push(x)–将元素x插入栈中 pop()–移除栈顶元素 top()–得到栈顶元素 getMin()–得到栈中最小元素 样例： MinStack minStack = new MinStack(); minStack.push(-1); minStack.p...
数据结构 栈 ：一文搞懂栈【附带 lettcode 刷题】1000字
leader_song的博客
03-13 1249
数据结构 栈 ：一文搞懂栈【附带 lettcode 刷题
Leetcode 栈刷题心得单调栈用法
qq_35677589的博客
03-24 176
leetcode刷题过程中取得了部分心得： 在栈的专题下，主要的考察点是栈先进后出的特性，当遍历一个字符串或者一个列表的时候，可能会出现类似于字符串解码，或者是接雨水之类的问题，这时就需要从后往前出栈，只有栈才能满足这样的特性。 因此当出现从后往前输出已经遍历的过的值的时候，就应该考虑使用栈这种数据结构。 首先我们最应该掌握的栈的一种用法就是单调栈 leetcode中的每日温度接雨水等都是典型的单调栈解题、 以接雨水题为例 class Solution { public int t
Leetcode刷题记录——栈
futurepkuswoman的博客
09-24 457
一些努力刷leetcode的记录
攻防世界pwn刷题记录
最新发布
yw__y的博客
03-12 396
。
力扣刷题记录
hadet的博客
01-16 1542
文章目录1.两数之和：2.二分查找：2.1 第一个错误版本： 1.两数之和： 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 暴力破解： 第一个循环为什么-1是因为第一次循环可以不循环最后一个元素 public int[] twoSum(int[] nums, int target)
刷题记录：单调栈问题
40029
04-12 412
文章目录初识单调栈问题引例栈与单调栈完整例题进阶：单调栈解法的共性新的问题归纳与总结再进阶：变形的单调栈问题参考 初识单调栈问题 引例 例题: 给定一个数组，输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数。如果不存在，则输出 -1。 输入: [1,2,1] 输出: [2,-1,-1] 首先我们来看上面这道问题。最容易想到的思路是遍历数...
LeetCode刷题记录
qq_21793443的博客
11-17 187
LeetCode刷题集锦 做记录用给出心得 简单: 1.整数反转 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。 如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。 示例 1： 输入：x = 123 输出：321 思路:1.int/10 保留整数 2.int%10 找出最后一位 3.注意范围 代码(java): class Solution { public int reverse(int x) {
algo:算法刷题记录
03-12
在这个“algo:算法刷题记录”中，我们可以推测这是一个关于算法学习和实践的项目，主要使用JavaScript语言进行实现。JavaScript是一种广泛应用于Web开发的动态编程语言，但同样适用于数据处理和算法实现。 ...
leetcode-python:leetcode刷题记录
04-12
（利用部分信息）二分查找，(利用所有信息)线性查找 路径回溯法 找到所有的divide结果，用回溯法 DP DP 指针+DP DFS 单调栈 单调双端队列 DFS DFS+回溯 - DFS/BFS 395. 至少有 K 个重复字符的最长子串 ...
leetcode:leecode刷题记录
03-28
这个名为 "leetcode:leecode刷题记录" 的压缩包文件很可能包含了作者在 LeetCode 上刷题的全过程记录，可能包括解题思路、代码实现和解题心得。这里我们将深入探讨与 LeetCode 相关的编程知识点，尤其是与 C++ 语言...
LeetCode：LeetCode刷题记录
02-12
这个"LeetCode刷题记录"很可能是某位开发者在学习过程中整理的资料，包含了他的解题思路、代码实现以及可能遇到的问题与解决方案。LeetCode-master这个文件名暗示了这可能是一个GitHub仓库的克隆，其中包含了该...
算法：leetcode刷题记录
02-17
本压缩包文件“Algorithm-master”很可能包含了某位开发者在LeetCode上刷题的过程记录或者是一些解题的代码实现。让我们深入探讨一下这个主题，特别是与Java相关的部分。 在LeetCode上，你可以找到各种难度级别的...
输出魔方矩阵（C语言实现）
u013607605的博客
11-20 4065
题目： 输出魔方阵，所谓魔方阵是指这样的方阵，它的每一行，每一列和对角线的和均相等，要输出1-n^2个自然数构成的魔方阵，例如 8 1 6 3 5 7 4 9 2 解决方案 当n<=2时不存在魔方矩阵 if(n<3){ printf("不存在n=%d的魔方矩阵",n); return; } 当n为奇数时，可用“罗...
数组部分刷题记录
u013607605的博客
04-04 771
以下仅为个人刷题笔记记录，如有错误，敬请指正，勿喷。 数组部分刷题记录 一、数组的遍历 question:485 给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。 示例1： 输入：nums = [1,1,0,1,1,1] 输出：3 解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3. 示例二： 输入：nums = [1,0,1,1,0,1] 输出：2 answer: 设置一个temp变量统计当前连续1的个数。当遇到0时，比较当前1的个数 与之前最大值。 class
Ubuntu：RabbitMq安装与踩雷
u013607605的博客
06-24 393
使用rabbitmq的库安装erlang，脚本如下: #!/bin/sh sudo apt-get install curl gnupg debian-keyring debian-archive-keyring apt-transport-https -y ## Team RabbitMQ's main signing key sudo apt-key adv --keyserver "hkps://keys.openpgp.org" --recv-keys "0x0A9AF2115F4687BD29
字符串部分刷题笔记
u013607605的博客
04-07 215
字符串部分刷题笔记 字符 question 520（检测大写字母） answer: 两种情况 1：都是大写 2：从第二个开始都是小写 lass Solution { public boolean detectCapitalUse(String word) { //分两种情况 //1:所有字符都是大写 //2:从第二个字符开始都是小写 return word.equals(word.toUpperCase())||word.substr
Leetcode题库：技术分享与刷题记录
LeetCode题库中的题目主要分为几个大类，比如数组、字符串、链表、栈、队列、树、图、数学、动态规划、回溯算法等。每道题目的结构包括题目描述、输入输出格式、示例、说明和相关讨论。题目的描述部分详细介绍了问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值