【考研|数据结构】栈的应用

package com.lichun.algorithm;

import java.util.Stack;


public class StackApplication {
    
    public boolean bracketCkeck(String str) {
        Stack stack = new Stack<>();
        char[] chars = str.toCharArray();
        // 依次扫描所有字符
        for (int i = 0; i < chars.length; i++) {
            char ch = chars[i];
            // 遇到左括号入栈
            if (ch == '(' || ch == '[' || ch == '{') {
                stack.push(ch);
            // 遇到右括号则弹出栈顶元素检查是否匹配    
            } else {
                // 匹配失败情况：右括号单身
                if (stack.empty()) {
                    return false;
                }
                char topElem = stack.pop();
                // 匹配失败情况：左右括号不匹配
                if (ch == ')' && topElem != '(') {
                    return false;
                } else if (ch == ']' && topElem != '[') {
                    return false;
                } else if (ch == '}' && topElem != '{') {
                    return false;
                }
            }
        }
        
        return stack.empty();
    }

    public static void main(String[] args) {
        StackApplication stackApplication = new StackApplication();
        boolean bracketCkeck = stackApplication.bracketCkeck("(({[][()()]}))");
        if (bracketCkeck) {
            System.out.println("yes");
        } else {
            System.out.println("no");
        }
    }
}

Reverse Polish notation（逆波兰表达式=后缀表达式）
Polish notation（波兰表达式=前缀表达式）

① 确定中缀表达式中各个运算符的运算顺序
② 选择下一个运算符，按照「左操作数 右操作数 运算符」的方式组合成一个新的操作数
③ 如果还有运算符没被处理，就继续 ②

运算顺序不唯一，因此对应的后缀表达式也不唯一
“左优先”原则：只要左边的运算符能先计算，就优先计算左边的（可保证运算顺序唯一）

初始化一个栈，用于保存暂时还不能确定运算顺序的运算符。
从左到右处理各个元素，直到末尾。可能遇到三种情况：
① 遇到操作数。直接加入后缀表达式。
② 遇到界限符。遇到“(”直接入栈；遇到“)”则依次弹出栈内运算符并加入后缀表达式，直到弹出“(”为止。注意：“(”不加入后缀表达式。
③ 遇到运算符。依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，若碰到“(” 或栈空则停止。之后再把当前运算符入栈。
按上述方法处理完所有字符后，将栈中剩余运算符依次弹出，并加入后缀表达式。

从左往右扫描，每遇到一个运算符，就让运算符前面最近的两个操作数执行对应运算， 合体为一个操作数

注意：两个操作数的左右顺序

①从左往右扫描下一个元素，直到处理完所有元素
②若扫描到操作数则压入栈，并回到①；否则执行③
③若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到①

注意：先出栈的“右操作数”
若表达式合法，则最后栈中只会留下一个元素，就是最终结果

① 确定中缀表达式中各个运算符的运算顺序
② 选择下一个运算符，按照「运算符 左操作数 右操作数」的方式组合成一个新的操作数
③ 如果还有运算符没被处理，就继续 ②

“右优先”原则：只要右边的运算符能先计算，就优先算右边的

①从右往左扫描下一个元素，直到处理完所有元素
②若扫描到操作数则压入栈，并回到①；否则执行③
③若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到①

注意：先出栈的是“左操作数”

中缀转后缀 + 后缀表达式求值

初始化两个栈，操作数栈和运算符栈
若扫描到操作数，压入操作数栈
若扫描到运算符或界限符，则按照“中缀转后缀”相同的逻辑压入运算符栈（期间也会弹出运算符，每当弹出一个运算符时，就需要再弹出两个操作数栈的栈顶元素并执行相应运算，运算结果再压回操作数栈）