Stack

栈，只有栈顶可以操作，先进后出，后进先出。

 java中的Stack 继承了Vector类，是线程安全的。

参考：https://blog.csdn.net/f2006116/article/details/51375225

 

栈的使用：

中缀表达式转后缀，然后计算表达式的值。

中缀（1+3*(9-2)+9）转后缀（1 3 9 2 - * + 9 +）：

　　从头遍历中缀表达式：

　　　　　　　　　　　　 1。如果是数字，那么直接输出到结果集

                                            2。如果是操作符(右括号除外)，则直接将其放到栈中。

                                            3。如果是右括号，则开始pop栈，输出结果集，直到pop出左括号，左括号不输出

                                            4。如果是操作符，且操作符的优先级比此时栈顶的操作符优先级低或者相等，那么需要pop栈，直到 栈空 或者 栈顶操作符的优先级小于此操作符。再将该操作符push至栈中。 比如遇到了+号， 此时栈是 + - *   这时候需要将+-*三个元素全部pop输出，将+ push至栈中 

                                             5。表达式遍历完毕后，如果此时栈不为空，需要将栈pop输出直至为空。

 

　　　

代码示例：结果集也使用的是栈，可以换数组来实现。操作符仅考虑了  + - * /  括号，+-一个优先级，*/ 一个优先级 

 

package com.dh.learn.collection;

import java.util.Stack;

public class LearnStack {
    public static void main(String[] args) {
        Stack<String> data = new Stack<>();
        Stack<Character> oper = new Stack<>();

        String expec = "1+2*3+(4*5+6)*7";
        boolean preIsNum = false;
        //中缀表达式转后缀
        for (Character character : expec.toCharArray()) {
            // 如果character是数字，直接入data栈
            if (isNum(character)) {
                //如果上一个也是数字，则表示是两个连续的数字
                if (preIsNum) {
                    data.push(data.pop() + character.toString());
                } else {
                    data.push(String.valueOf(character));
                }
                preIsNum = true;
            } else {
                preIsNum = false;
                //如果操作符栈为空，直接push
                if (oper.isEmpty() || character == '(' || character == '*' || character == '/') {
                    oper.push(character);
                } else if (character == ')') {
                    //操作符是右括号,取操作符栈的数据放到data中，直到遇到左括号
                    Character p = oper.pop();
                    while (p != '(') {
                        data.push(p.toString());
                        if (oper.isEmpty()) {
                            break;
                        }
                        p = oper.pop();
                    }
                } else {
                    //比较优先级 此时character是 +  -
                    Character top = oper.peek();
                    if (top == '*' || top == '/') {
                        while (oper.peek() != '(') {
                            top = oper.pop();
                            data.push(top.toString());
                            if (oper.isEmpty()) {
                                break;
                            }
                        }
                    }
                    oper.push(character);
                }
            }
        }

        while (!oper.isEmpty()) {
            data.push(oper.pop().toString());
        }
        System.out.println(data);
        Stack<Integer> value = new Stack<>();
        for (String s : data) {
            switch (s) {
                case "+":
                    value.push(value.pop() + value.pop());
                    break;
                case "-":
                    value.push(-(value.pop() - value.pop()));
                    break;
                case "*":
                    value.push(value.pop() * value.pop());
                    break;
                case "/":
                    int vx = value.pop();
                    int vy = value.pop();
                    value.push(vy / vx);
                    break;
                default:
                    value.push(Integer.valueOf(s));
            }
        }

        System.out.println(value.pop());
    }

    private static boolean isNum(Character character) {
        return character >= '1' && character <= '9';
    }
}

 

输出结果：

[1, 2, 3, *, +, 4, 5, *, 6, +, 7, *, +]
189