Stack经典编程题

逆波兰表达式求值（后缀表达式）、括号匹配、出栈入栈次序匹配 

目录

逆波兰表达式求值

20. 有效的括号

JZ31 栈的压入、弹出序列

---

逆波兰表达式求值

示例 1：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/evaluate-reverse-polish-notation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

我来简单解释一下：从0下标开始向后遍历，遇到数字字符串就压入栈，遇到符号字符串就弹出两个数字字符串，并进行计算，将结果压栈，我来画个图解释一下

java模拟实现

//利用栈实现
//注意点1：要注意第一个弹出的应该是是符号右侧的值,因为3 - 5和 5 - 3的答案是两个值
//注意点2：字符串比较相等需要使用equals（）;
import java.util.Stack;
class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        String str = "";//存放字符串符号+ - * /
        int num2 = 0;
        int num1 = 0;
        for(int i = 0; i < tokens.length; ++i){
            if(tokens[i].equals("+") || tokens[i].equals("-") || tokens[i].equals("*") || 
               tokens[i].equals("/") ){//字符串匹配得用equals
                str = tokens[i];
                num2 = stack.pop();//一定要将首个出栈元素放入到符号右侧  1-2  和2-1 结果不一样
                num1 = stack.pop();
                switch(str){
                    case "+" : stack.push(num1+num2);
                        break;
                    case "-" : stack.push(num1-num2);
                        break;
                    case "*" : stack.push(num1*num2);
                        break;
                    case "/" : stack.push(num1/num2);//只保留整数部分
                        break;
                }
            }
            else
            {
                stack.push(Integer.parseInt(tokens[i]));
            }
        }
        return stack.pop();//将最后一个元素出栈
    }
}

20. 有效的括号

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

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

java模拟实现，此时是初步实现，思路：遇到左侧符号就入栈，遇到右侧符号就匹配，匹配成功就出栈，匹配失败说明该括号不匹配return false；

import java.util.Stack;
class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        char temp;
        for(int i = 0; i < s.length(); ++i){
            temp = s.charAt(i);
            if(temp == '(' || temp == '{' || temp == '['){//遇到左侧符号就入栈
                stack.push(temp);
            }
            else//题目说：只有这三类，所以不是左侧符号，那就是右侧符号了
            {
                
                //匹配成功
                if(stack.peek() == '(' && temp == ')' || stack.peek() == '{' && temp == '}'||
                stack.peek() == '[' && temp == ']'){
                    stack.pop();//出栈
                }
                else{//匹配失败
                    return false;
                }
            }
        }
        
    return true;
    }
}

但是没有判断两种情况
1.栈中还有多余左侧符号，但已无右侧符号匹配
2.栈中可能已经没有左侧符号了，但右侧符号还有多余的

因此改善后的代码

import java.util.Stack;
class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        char temp;
        for(int i = 0; i < s.length(); ++i){
            temp = s.charAt(i);
            if(temp == '(' || temp == '{' || temp == '['){//遇到左侧符号就入栈
                stack.push(temp);
            }
            else//题目说：只有这三类，所以不是左侧符号，那就是右侧符号了
            {
                //2.栈中可能已经没有左侧符号了，但右侧符号还有多余的
                if(stack.empty()){
                    return false;
                }
                //匹配成功
                if(stack.peek() == '(' && temp == ')' || stack.peek() == '{' && temp == '}'||
                stack.peek() == '[' && temp == ']'){
                    stack.pop();//出栈
                }
                else{//匹配失败
                    return false;
                }
            }
        }
        if(!stack.empty()){//1.栈中还有多余左侧符号，但已无右侧符号匹配
            return false;
        }
    return true;
    }
}

JZ31 栈的压入、弹出序列

描述

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

输入：

[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      

注意：在压栈的时候也可以出栈，比如[1,2,3,4,5] 压栈的时候，可以先压入三个，然后接着出栈，并不一定要一次性完全压入栈！！！

import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        int i = 0;//pushA的指针
        int j = 0;//popA的指针
        Stack<Integer> stack = new Stack<>();
        for(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();
    }
}