【Java数据结构 -- 栈相关算法：中缀表达式转后缀、最小栈、括号匹配、和出栈入栈次序匹配】

1.逆波兰表达式求值

思路：

// 中缀 : 1+2*3+(4*5+6)*7
// 后缀 : ( (1 + (2*3) ) + ((4*5)+6)*7) )
//        ( (1 (23)* ) + ((45)*6)+7)* ) +
//          1 23* + 45*6 +7* +
//给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

遍历字符串数组，判别数字和运算符，把数字压栈，遇到运算符再出栈两个数字，出的第一个为运算符右边，第二个为左边。

    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for(int i = 0;i < tokens.length;i++) {
            String str = tokens[i];
            if(!isOperation(str)) {
                // 不是运算符 说明是数字
                int val = Integer.valueOf(str);
                stack.push(val);
            } else {
                // 是运算符
                int num2 = stack.pop();
                int 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;
                }
            }
        }
        return stack.pop();
    }

    private boolean isOperation(String str) {
        if(str.equals("+") || str.equals("-") || str.equals("*") ||
                str.equals("/")) {
            return true;
        }
        return false;
    }

2. 最小栈

需要用到两个栈，分别stack和minStack，
压栈元素：当minStack为空时，也同样压栈； 当minStack不为空时peek最小栈的栈顶元素是否大于等于要压栈的元素，是就进行压入最小栈minStack；
出栈：判断stack是否等于最小栈peek栈顶元素，等于进行minStack出栈。
查看栈顶元素：直接stack.pop()
获取最小栈的元素：minStack.peek()

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

3. 括号匹配

思路：

    // 遍历字符串 将其放入栈中 栈空了 字符串遍历完了 符合要求
    // 只要是左括号就入栈，遇到右括号看是否匹配
    //右括号不匹配，就直接返回false
    //字符串没有遍历完成，但栈为空，此时也是不匹配
    //字符串遍历完成，但是栈还是不为空 此时也是不匹配

    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        // 1.遍历字符串
        for(int i = 0;i < s.length();i++) {
            char ch = s.charAt(i);
            //2. 是不是左括号
            if(ch == '(' || ch == '{' || ch == '[') {
                stack.push(ch);
            }else {
                //3.右括号
                //3.1 栈为空
                if(stack.isEmpty()) {
                    return false;
                }
                //3.2 栈不为空
                char ch2 = stack.peek(); // 左括号
                if(ch2 =='(' && ch == ')' || ch2 == '{' && ch == '}' || ch2 == '[' && ch == ']') {
                    stack.pop();
                }else {
                    return false;
                }
            }
        }
        //字符串遍历完了，栈不为空
        if(!stack.isEmpty()){
            return false;
        }
        return true;
    }

4. 出栈入栈次序匹配

思路：

    // 1.遍历pushV数组 把pushV数组元素放入栈中
    // 2.每次放一个元素就看和popV元素是否一样
    // 3.一样j++ 不一样接着放pushV数组元素入栈
    // 直到遍历完popV

    public boolean IsPopOrder (int[] pushV, int[] popV) {


        Stack<Integer> stack = new Stack<>();
        int j = 0;
        for(int i = 0;i < pushV.length;i++) {
            stack.push(pushV[i]);

            while(!stack.isEmpty() && j < popV.length &&
                    stack.peek() == popV[j]) {
                stack.pop();
                j++;
            }
        }
        return stack.empty(); //栈为空也可以
        //return j >= popV.length;
    }