【LC】最小栈，栈的压入、弹出序列， 逆波兰表达式， 有效的括号

1.最小栈(lc155)

题目描述:

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

• MinStack() 初始化堆栈对象。

• void push(int val) 将元素val推入堆栈。

• void pop() 删除堆栈顶部的元素。

• int top() 获取堆栈顶部的元素。

• int getMin() 获取堆栈中的最小元素。

示例 1:

输入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

输出：
[null,null,null,null,-3,null,0,-2]

解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.

提示：

• -231 <= val <= 231 - 1

• pop、top 和 getMin 操作总是在 非空栈 上调用

• push, pop, top, and getMin最多被调用 3 * 104 次

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/min-stack

解题思路：

1. 利用两个栈，一个为正常栈(保存所有的进出栈数据)，一个为最小栈(只有当数据为最小时，才会入栈)

2. 核心在于：入栈时，若数据最小，需要两个栈都要入栈，出栈时，如果出的数据为最小，需要更新最小栈

代码实现：

class MinStack {

    private Stack<Integer> stack;
    private Stack<Integer> minStack;

    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }
    
    public void push(int val) {
        stack.push(val);
        if(minStack.empty() || val<=minStack.peek()){
            minStack.push(val);
        }
    }
    
    public void pop() {
        int s = stack.pop();
        if(s == minStack.peek()){
            minStack.pop();
        }
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(val);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

提交结果：

2. 栈的压入、弹出序列(牛客JZ31)

题目描述:

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。

1. 0<=pushV.length == popV.length <=1000

2. -1000<=pushV[i]<=1000

3. pushV 的所有数字均不相同

示例1

输入：[1,2,3,4,5],[4,5,3,2,1]
返回值：true
说明：可以通过push(1)=>push(2)=>push(3)=>push(4)=>pop()=>push(5)=>pop()=>pop()=>pop()=>pop()这样的顺序得到[4,5,3,2,1]这个序列，返回true

示例2

输入：[1,2,3,4,5],[4,3,5,1,2]
返回值：false
说明：由于是[1,2,3,4,5]的压入顺序，[4,3,5,1,2]的弹出顺序，要求4，3，5必须在1，2前压入，且1，2不能弹出，但是这样压入的顺序，1又不能在2之前弹出，所以无法形成的，返回false

链接：栈的压入、弹出序列_牛客题霸_牛客网 (nowcoder.com)

来源：牛客网

解题思路：

此题是对栈特性非常好的检测，直接使用栈来模拟入栈和出现的过程即可，因此该题的核心工作就是要弄清楚什么时候入栈以及出栈入栈：当栈为空，或者栈顶元素和待出栈元素不相等时

注意：入栈时要保证有元素，如果没有元素则一定不相等.出栈：当栈顶元素待出栈元素相同时出栈

循环进行上述过程即可，直到所有的元素全部出栈

举例：

入栈1,2,3,4,5

出栈4,5,3,2,1

首先1入辅助栈，此时栈顶1≠4，继续入栈2

此时栈顶2≠4，继续入栈3

此时栈顶3≠4，继续入栈4

此时栈顶4＝4，出栈4，出栈序列向后一位，此时为5，,辅助栈里面是1,2,3

此时栈顶3≠5，继续入栈5

此时栈顶5=5，出栈5,出栈序列向后一位，此时为3，,辅助栈里面是1,2,3

此时栈顶3=3, 出栈3,出栈序列向后一位，此时为2，,辅助栈里面是1,2

此时栈顶2=2, 出栈2,出栈序列向后一位，此时为1，,辅助栈里面是1

此时栈顶1=1, 出栈1,出栈序列向后一位, 此时出栈序列遍历结束, 辅助栈为空栈

代码实现：

import java.util.*;

public class Solution {
    public boolean IsPopOrder(int [] pushA, int [] popA) {
        Stack<Integer> stack = new Stack<>();
        int j = 0;
        for(int i = 0; i < pushA.length; i++) {
            stack.push(pushA[i]);
            while(j < popA.length && !stack.empty() && stack.peek() == popA[j]) {
                stack.pop();
                j++;
            }
        }
        return stack.empty();
    }
}

提交结果：

3. 逆波兰表达式(lc150)

题目描述:

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

• 有效的算符为 '+'、'-'、'*' 和 '/' 。

• 每个操作数（运算对象）都可以是一个整数或者另一个表达式。

• 两个整数之间的除法总是 向零截断 。

• 表达式中不含除零运算。

• 输入是一个根据逆波兰表示法表示的算术表达式。

• 答案及所有中间计算结果可以用 32 位 整数表示。

示例 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 + * 也可以依据次序计算出正确结果。

• 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中。

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/evaluate-reverse-polish-notation

解题思路：

对tokens数组进行遍历，依次获取到每个元素，如果：

1. 该元素是数字(注意：不是运算符肯定是数字)，将该数字入栈

2. 该元素是运算符，从栈顶获取该运算符对应的右左操作数，进行相应的操作，最后将结果入栈

循环结束后，栈顶的元素就是最终表达式的结果.

代码实现：

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        //遍历数组
        for (String x:
             tokens) {
            if(! isOperation(x)){ //是数子的情况
                //将字符转为数字
                stack.push(Integer.parseInt(x));
            } else { //是操作符号的情况
                int right = stack.pop();
                int left = stack.pop();
                switch (x) {
                    case "+":
                        stack.push(left + right);
                        break;
                    case "-":
                        stack.push(left - right);
                        break;
                    case "*":
                        stack.push(left * right);
                        break;
                    case "/":
                        stack.push(left / right);
                        break;
                }
            }
        }
        return stack.pop();
    }
    private boolean isOperation(String s){
        //字符串相等用equals
        return s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/");
    }
}

提交结果：

4. 有效的括号(lc20)

题目描述:

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

有效字符串需满足：

• 左括号必须用相同类型的右括号闭合。

• 左括号必须以正确的顺序闭合。

• 每个右括号都有一个对应的相同类型的左括号。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 1 <= s.length <= 104

• s 仅由括号 '()[]{}' 组成

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/valid-parentheses

解题思路：

循环遍历String中的字符，逐个取到每个括号，如果该括号是：

1. 左括号，直接入栈

2. 右括号，与栈顶的左括号进行匹配，如果不匹配直接返回false否则继续循环

循环结束后，如果栈空则匹配，否则左括号比右括号多肯定不匹配

代码实现：

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for(int i = 0; i < s.length() ; i++) {
            char ch1 = s.charAt(i);
            if(ch1 == '(' || ch1 == '{' || ch1 == '['){ // 是左的情况入栈
                stack.push(ch1);
            } else {             //不是左 
                if(stack.empty()){  //空的话 
                    return false;
                } else {  //不空的话
                    char ch2 = stack.peek();  //看栈顶元素接下来匹配 成功的话弹出
                    if(ch2 == '(' && ch1 == ')' || ch2 == '{' && ch1 == '}' || ch2 == '[' && ch1 == ']'){
                        stack.pop();
                    }else{  //不成功直接false
                        return false;
                    }
                }
            }
        }
        return stack.empty();  //一直是左的情况  遍历到最后 不为空 即false
    }
}

提交结果：