【Java】数据结构篇——Stack：经典栈OJ题 |超详题解代码

• 博主简介：努力学习的22级计算机科学与技术本科生一枚🌸
• 博主主页： @是瑶瑶子啦
• 所属专栏: Java岛冒险记【从小白到大佬之路】
• 每日一言🌼: “且视他人之疑目如盏盏鬼火，大胆地去走你的夜路”。——史铁生

1、括号匹配问题⭐

🔗20. 有效的括号

class Solution {
    public boolean isValid(String s) {
        //创建栈
        Stack<Character> stack = new Stack<>();
        //key,遍历整个字符串的字符，进行入栈和出栈操作
        for(int i = 0; i < s.length(); i++){
            //如果是左括号就入栈
            char c = s.charAt(i);
            if(c =='('|| c =='{'|| c =='['){
                stack.push(c);
            }else{
                //如果是右括号
                //1.先看看栈是否为空
                if(stack.empty()){
                    return false;//字符串还没遍历完栈为空，false
                }
                //2.取出栈顶元素，与当前右括号c比较，看看是否匹配
                //
                char top = stack.peek();
                switch (c){
                    case ')':
                        if (top == '('){
                            stack.pop();
                            break;
                        }else{
                            return false;//不匹配直接false
                        }
                    case '}':
                        if (top == '{'){
                            stack.pop();
                            break;
                        }else{
                            return false;//不匹配直接false
                        }
                    case ']':
                        if (top == '['){
                            stack.pop();
                            break;
                        }else{
                            return false;
                        }
                }
            }
        }
        //字符串遍历完了
        //1.栈不为空，直接false
        if(!stack.empty()){
            return false;
        }
        //栈空+字符串空，true
        return true;
    }
}

2、逆波兰表达式求值⭐

🔗150. 逆波兰表达式求值

class Solution {
    public int evalRPN(String[] tokens) {
        //创建一个栈
        Stack<Integer> stack = new Stack<>();
        //扫描字符串数组
        for(int i = 0;i < tokens.length; i++){
            
            String s = tokens[i];
            //1、遇到操作符：取出栈顶（右操作数），第二栈顶（左操作数
            if (s.equals("+")||s.equals("-")||s.equals("*")||s.equals("/")){
                int r = stack.pop();
                int l = stack.pop();
                int result = 0;
                switch (s){
                    case "+":
                        result = l+r;
                        break;
                    case "-":
                        result = l-r;
                        break;
                    case "*":
                        result = l*r;
                        break;
                    case "/":
                        result = l/r;
                        break;
                }
                //将结果压入栈中
                stack.push(result);
            }else{
                //2、遇到运算数，直接压入栈中
                stack.push(Integer.parseInt(s));
            }
        }
        //3、最后栈中的结果就是运算的结果
        return stack.pop();
    }
}

3、最小栈⭐

🔗155. 最小栈

class MinStack {


    Stack<Integer> stack;
    Stack<Integer> minStack;//辅助栈：栈顶元素为对应stack中最小元素！


    public MinStack() {
        this.stack = new Stack<>();
        this.minStack = new Stack<>();
    }
    
    public void push(int val) {
        stack.push(val);
        if(minStack.empty()){
            minStack.push(val);
        }else{
            //取出栈顶元素和当前新增元素比较，若栈顶元素>=新增元素，则入最小栈
            if(minStack.peek()>= val){
                minStack.push(val);
            }
        }
    }
    
    public void pop() {
        if(stack.peek()>minStack.peek()){
            stack.pop();
        }else{
            stack.pop();
            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();
 */

4、栈的压入、弹出序列⭐

🔗栈的压入、弹出序列

注意，在peek和pop的时候要判空！！

import java.util.*;



public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pushV int整型一维数组 
     * @param popV int整型一维数组 
     * @return bool布尔型
     */
    public boolean IsPopOrder (int[] pushV, int[] popV) {
        // write code here
        //定义两个指针i、j分别扫描两个数组
        //1):p1扫描一个元素就入栈
        Stack<Integer> stack = new Stack<>();
        int j = 0;//代表指向popV数组的第一个元素
        for (int i = 0; i < pushV.length && j < popV.length; i++){
            stack.push(pushV[i]);
            //2)入栈完，拿出来和popV此时所指元素比较
            while((!stack.empty())&&stack.peek()==popV[j]){
                //相同(就代表这个元素要出栈了)，则出栈，且j++
                stack.pop();
                j++;
            }
            //直到不同，说明当前i所指元素不用出栈，i才向后走
        }
        //若最终栈为空
        if(stack.empty()){
            return true;
        }
        return false;
    
    }
}

---

💐若有不懂的地方，欢迎随时在评论区or私信找瑶瑶子交流讨论🌺

• Java岛冒险记【从小白到大佬之路】
  

• LeetCode每日一题–进击大厂

• Go语言核心编程
  

• 算法