Leetcode刷题笔记—stack (13)

已于 2024-02-01 06:41:04 修改
阅读量50 收藏
点赞数
文章标签： leetcode 笔记 算法
于 2023-06-22 11:52:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77651729/article/details/131337866
版权

 402. Remove K Digits

class Solution {
    public String removeKdigits(String num, int k) {
        if(k >= num.length()) {
            return "0";
        }
        Stack<Character> stack = new Stack();
        // 单调栈 保持整个num是升序
        for(char digit : num.toCharArray()) {
            while(k > 0 && !stack.isEmpty() &&  stack.peek() > digit) {
                stack.pop();
                k --;
            }
            stack.push(digit);
        }
            // 如果整个升序完成，升序的过程是删除了一些digit的，k还没有减完变成0，
            // 那么移除掉末尾的digit，因为这个时候num是升序的，越末尾数字越大
        while(k > 0) {
            stack.pop();
            k --;
        }
        StringBuilder str = new StringBuilder();
        while(!stack.isEmpty()) {
            str.insert(0, stack.pop());
            // str.append(stack.pop());
        }
        // 去掉leading zero，
        int index = 0;
        while( index < str.length() && str.charAt(index) == '0') {
            index++;
        }
        str.delete(0, index); // delete method do not include index
        return str.length() == 0 ? "0" : str.toString();
        // str.reverse().toString();
    }
}

682. Baseball Game

class Solution {
    public int calPoints(String[] op) {
        List<Integer> li = new ArrayList();
        int res = 0;
        for(int i = 0; i < op.length; i++) {
            if(op[i].equals("+")) {
                int sum = li.get(li.size()-1) + li.get(li.size()-2);
                li.add(sum);
            } else if(op[i].equals("D")) {
                li.add(2 * li.get(li.size() - 1));
            } else if(op[i].equals("C")) {
               li.remove(li.size() - 1);
            } else {
                li.add(Integer.parseInt(op[i]));
            }
        }
        for(int i = 0; i < li.size(); i++) {
            res += li.get(i);
        }
        return res;
    }
}



class Solution {
    public int calPoints(String[] operations) {
        Stack<Integer> stack = new Stack<>();
        for (String s : operations) {
            if (s.equals("+")) {
                int a = stack.pop();
                int newScore = a + stack.peek();
                stack.push(a);
                stack.push(newScore);
            }
            else if (s.equals("D")) {
                stack.push(2 * stack.peek());
            }
            else if (s.equals("C")) {
                stack.pop();
            }
            else stack.push(Integer.parseInt(s));
        }
        int totalScore = 0;
        while (!stack.isEmpty()) totalScore += stack.pop();
        return totalScore;
    }
}

20. Valid Parentheses

class Solution {
    public boolean isValid(String s) {
       Stack<Character> mat = new Stack<>();
       char[] ss = s.toCharArray();
       for(int i = 0; i < ss.length; i++) {
           char a = ss[i];
           if(a == '(' || a == '[' || a == '{') {
               mat.push(a);
           } else if(mat.empty()) {
           // no matched brackets
               return false;
           } else if(a == ')' && mat.pop() != '(') {
               return false;
           } else if(a == ']' && mat.pop() != '[') {
               return false;
           } else if(a == '}' && mat.pop() != '{') {
               return false;
           }
       }
        return mat.empty();
    }
}

2048. Next Greater Numerically Balanced Number

class Solution {
    private boolean isBN(int num) {
        int[] occurence = new int[10];
        while(num > 0) {
            int digit = num % 10;
            occurence[digit]++;
            num /= 10;
        }
        for(int i = 0; i < 10; i++) {
            if(occurence[i] != 0 && occurence[i] != i) {
                return false;
            }
        }
        return true;
    }
    public int nextBeautifulNumber(int n) {
        // ➕1操作，加1后check是否符合，符合返回 不符合再加1
        // 使用数组或者map来存储出现次数，方便和digit的值是否相等
        int num = n + 1;
        while(! isBN(num)) {
            num++;
        }
        return num;
    }
}

2454. Next Greater Element IV

class Solution {
    public int[] secondGreaterElement(int[] nums) {
        int len = nums.length, res[] = new int[len];
        Arrays.fill(res, -1);
        Stack<Integer> s1 = new Stack(), s2 = new Stack(), temp = new Stack();
        for(int i = 0; i < len; i++) {
            while(!s2.isEmpty() && nums[s2.peek()] < nums[i]) {
                res[s2.pop()] = nums[i];
            }
            while(!s1.isEmpty() && nums[s1.peek()] < nums[i]) {
                temp.push(s1.pop()); // 使用缓存栈平移到声s2中，不然直接移动顺序会有问题
            }
            while(!temp.isEmpty()) {
                s2.push(temp.pop());
            }
            s1.push(i);
        }
        return res;
    }
}

556. Next Greater Element III

class Solution {
    public int nextGreaterElement(int n) {
        // find last position [k - 1] < [k]
        // find first element > [k - 1] and exchange their position (from len - 1 to k)
        // reverse the elements from k to len - 1
        //将int转换成 string 在转换成char数组
        char[] ch = String.valueOf(n).toCharArray();
        int len = ch.length;
        int i = len - 2;
        // 找到第一个最后一个转折点开始降序19这里 3265195431
        while(i >= 0 && ch[i + 1] <= ch[i]) { // 等于必须有 
            i--;
        }
        // 54321这样的特列没有nge
        if(i < 0) {
            return -1;
        }
        // 从3265195431后面开始找到第一个大于1的数
        int j = len - 1;
        while(j >= 0 && ch[j] <= ch[i]) {
            j--;
        }
        swap(ch, i, j);
        reverse(ch, i + 1);
        // 将最终ch数组转化成int 但有可能超出整数最大范围，所以改成long类型
        long res = Long.parseLong(new String(ch));
        return (res <= Integer.MAX_VALUE ? (int)res : -1);

    }
    private void reverse(char[] ch, int i) {
        int start = i;
        int end = ch.length - 1;
        while(start < end) {
            swap(ch, start++, end--);
        }
    }
    private void swap(char[] ch, int i, int j) {
        char temp = ch[i];
        ch[i] = ch[j];
        ch[j] = temp;
    }
}

503. Next Greater Element II

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        // 是一个circle 1 2 1 相当于在后面加了一遍 1 2 1 1 2 1
        int len = nums.length;
        int res[] = new int[len];
        Arrays.fill(res, -1);
        Stack<Integer> stack = new Stack();
        for(int i = 0; i < 2 * len; i++) {
            int num = nums[i % len]; // 技巧: 计算后面的值
            while(!stack.isEmpty() && nums[stack.peek()] < num) { //注意写num不是 nums[i]
                res[stack.pop()] = num; // 这里也注意是stack.pop()，不是stack.peep(),不然会timeout，还有num，不然会下标越界
            }
            if(i < len) {
                stack.push(i);
            }
        }
        return res;
    }
}

496. Next Greater Element I

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Deque<Integer> stack = new ArrayDeque();
        Map<Integer, Integer> map = new HashMap();
        int[] res = new int[nums1.length];
        for(int num : nums2) {
            while(!stack.isEmpty() && stack.peek() < num) {
                map.put(stack.pop(), num);
            }
            stack.push(num);
        }
        for(int i = 0; i < nums1.length; i++) {
            res[i] = map.getOrDefault(nums1[i], -1);
        }
        return res;
    }
}

345. Reverse Vowels of a String

class Solution {
    public String reverseVowels(String s) {
        Deque<Character> stack = new ArrayDeque();
        for(char c : s.toCharArray()) {
            if(c == 'a' || c == 'e' || c == 'i'|| c == 'o' || c == 'u'|| c == 'A' || c == 'E'|| c == 'I' || c == 'O'|| c == 'U') {
                stack.addLast(c);
            }
        }
        StringBuilder str = new StringBuilder();
        for(char c : s.toCharArray()) {
            if(c == 'a' || c == 'e' || c == 'i'|| c == 'o' || c == 'u'|| c == 'A' || c == 'E'|| c == 'I' || c == 'O'|| c == 'U') {
                str.append(stack.pollLast());
            } else {
                str.append(c);
            }
        }
        return str.toString();
    }
}

32. Longest Valid Parentheses

class Solution {
    public int longestValidParentheses(String s) {
        Stack<Integer> st = new Stack();
        st.push(-1);
        int n = 0;
        for(int i = 0; i < s.length(); i++) {
            if(s.charAt(i) == '(') {
                st.push(i);
            } else if(s.charAt(i) == ')') {
                st.pop();
                if(st.empty()) {
                    st.push(i);
                } else {
                    n = Math.max(n, i - st.peek());
                }
            }
        }
        return n;
    }
}

150. Evaluate Reverse Polish Notation

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

636. Exclusive Time of Functions

class Solution {
    public int[] exclusiveTime(int n, List<String> logs) {
        int[] res = new int[n];
        if(n == 0 || logs == null || logs.size() == 0) {
            return res;
        }
        Deque<Integer> stack = new ArrayDeque();
        int preT = 0;
        for(String log : logs) {
            String[] logP = log.split(":");
            int curT = Integer.parseInt(logP[2]);
            if("start".equals(logP[1])) {
                if(!stack.isEmpty()) {
                    res[stack.peek()] += curT - preT;
                }
                stack.push(Integer.parseInt(logP[0]));
                preT = curT;
            } else {
                res[stack.pop()] += curT - preT + 1;
                preT = curT + 1;
            }
        }
        return res;
    }
}

844. Backspace String Compare 

class Solution {
    public boolean backspaceCompare(String s, String t) {
        Stack<Character> stacks = new Stack();
        Stack<Character> stackt = new Stack();
        for(int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if(!stacks.isEmpty() && c == '#') {
                stacks.pop();
            } else {
                if(c != '#')
                stacks.push(c);
            }
        }
        for(int i = 0; i < t.length(); i++) {
            char c = t.charAt(i);
            if(!stackt.isEmpty() && c == '#') {
                stackt.pop();
            } else {
                if(c != '#')
                stackt.push(c);
            }
        }
        return stacks.equals(stackt);
    }
}

2301_77651729
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
LeetCode刷题笔记
qq_40088655的博客
10-14 1089
LeetCode刷题笔记！
Leetcode刷题笔记
qq_42920313的博客
08-05 263
163.缺失的区间 def findMissingRanges(nums,lower,upper): low = lower-1 nums.append(upper+1) res = [] for num in nums: diff = num - low if diff == 2: #nums[i]-nums[i]==2时，说明中间只跨了一个数，所以把这个数字单独作为一个区间 res.append(str(nu
Leetcode 刷题笔记 堆栈与队列
爱学习的大叔的博客
08-30 151
栈 栈（stack），有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素，它的特点在于只能允许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（英语：push）和输出数据（英语：pop）的运算。没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。 由于栈数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In First Out）的原理运作。 栈结构实现 栈可以用顺序表实现，也可以用链表实现。 后进先出 栈的操作 S
【Leetcode刷题笔记】栈
12-22
- 在Python中，我们可以自定义一个栈类Stack，包含push、pop、peek、is_empty和size等方法。 - 对于解决方案类Solution，定义isValid方法，接收括号字符串s作为参数。使用栈S存储遇到的开括号，然后根据闭括号依次...
谷歌师兄的leetcode刷题笔记-SimplexNoise:使用C#中的SimplexNoise实现，并带有用于测试的示例应用
06-30
谷歌师兄的leetcode刷题笔记单纯形噪声 这个应用程序是出于为我正在开发的游戏制作随机地图生成器的愿望而诞生的。 在互联网上搜索地图生成算法的可能想法后，我确定了一个使用 Simplex Noise 的版本，Perlin Noise ...
LeetCode:LeetCode刷题记录
04-23
LeetCode刷题记录通常是程序员在挑战这些题目时留下的代码、思路和学习笔记。Kotlin是一种静态类型的编程语言，它以其简洁的语法、类型安全和互操作性在Java虚拟机（JVM）上运行而受到欢迎。下面我们将深入探讨...
javalruleetcode-leetcode-python:leetcode问题的Python解决方案
06-29
刷题笔记 记录一些刷题细节，很惭愧只做了一点微小的工作 4.13 162题. Find Peak Element.Binary search，需要比较nums[mid]和nums[mid+1]. 4.12 212题. Word Search II. 用trie tree存word list,然后dfs. 4.11 788...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 872
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
C++ | Leetcode C++题解之第283题移动零
Ddddddd_158的博客
07-25 351
C++ | Leetcode C++题解之第283题移动零
LeetCode707 设计链表
daishabby2486的博客
07-25 611
LeetCode707 设计链表的解题记录。
Leetcode—769. 最多能完成排序的块【中等】
Atticus的博客
07-25 360
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
力扣202.快乐数
最新发布
gyj215500的博客
07-25 320
主要是用到了鸽巢原理，最后他们一定会重合，我们只需要判断类似，链表的成环相遇的时候是不是1就行了。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 308
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
leetcode 69. x 的平方根
m0_49013185的博客
07-24 272
可以使用二分查找法或牛顿迭代法来实现 LeetCode 问题。下面是使用二分查找法和牛顿迭代法的 C++ 实现。
leetcode4 -- 寻找两个正序数组的中位数
m0_65985318的博客
07-23 259
先将两数组合并，然后利用sort排序算法，对数组进行从小到大的排序，根据总长度是奇数或者偶数来决定中位数的位置。合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5。合并数组 = [1,2,3] ，中位数 2。请你找出并返回这两个正序数组的。的正序（从小到大）数组。算法的时间复杂度应该为。
对链表的头结点和各个指向结点的引用的理解。力扣24题，两两交换链表中的结点。
qq_52983535的博客
07-23 390
其实是知道在链表前面添加一个没有实际存储内容的头结点是有利于程序运行的，但是在实际编程中总是会忘记或者不知道到底起到什么样的作用，或许这就是纸上得来终觉浅，绝知此事要躬行吧。力扣24题要求我们两两交换链表中的结点。在这种情况就很需要有一个头结点，因为考虑到交换两个头结点的时候往往不单单会只用到被交换的两个结点，往往还需要考虑被交换的第一个结点的前一个结点，因为也需要把它的next指针改变。如果设置待被交换的两个结点按顺序分别是cur和next，那么cur前面的结点就是叫pre。
Java版LeetCode刷题笔记：51-100题解析
“LeetCode 刷题笔记 with Java 51-100（暗黑版）.pdf 是一本关于使用Java解决LeetCode算法题目的详细笔记，由沉默王二创作。该笔记涵盖51至100号题目，包含题解预览链接、LeetCode官方题目链接以及GitHub项目地址。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值