文章目录

1.栈的基本介绍

1.栈的英文为(stack)
2.栈是一个先入后出(FILO-First In Last Out)的有序列表。
3.栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
4.根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

入栈(push)和出栈(pop)的图解

第三章-数据结构之栈_数据结构

第三章-数据结构之栈_数组_02

2.栈的应用场景

1.子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。  
2.处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
3.表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
4.二叉树的遍历。
5.图形的深度优先(depth一first)搜索法。

3.数组模拟栈

第三章-数据结构之栈_堆栈_03

3.1 代码实现

//定义一个Arraystack表示栈
class ArrayStack {
    int maxSize; //栈的大小
    int[] stack; //数组模拟栈，数据就放在该数组
    int top = -1; // top表示栈顶，初始化为-1

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[maxSize];
    }

    // 栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    // 栈空
    public boolean isEmpty() {
        return top == -1;
    }

    // 入栈-push
    public void push(int value) {
        // 先判断 栈是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    // 出栈-pop, 将栈顶的数据返回
    public int pop() {
        // 先判断栈是否空
        if (isEmpty()) {
            // 抛出异常
            throw new RuntimeException("栈空，没有数据");
        }
        int value = stack[top];
        top--;
        return value;
    }

    // 显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据");
            return;
        }
        // 需要从栈顶开始显示数据
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

}
public static void main(String[] args) {
        //测试一下ArrayStack 是否正确
        // 先创建一个ArrayStack对象->表示栈
        ArrayStack stack = new ArrayStack(4);
        String key = "";
        boolean loop = true; // 控制是否退出菜单
        Scanner scanner = new Scanner(System.in);

        while (loop) {
            System.out.println("show: 表示显示栈");
            System.out.println("exit: 退出程序");
            System.out.println("push: 表示添加数据到栈(入栈)");
            System.out.println("pop: 表示从栈取出数据(出栈)");
            System.out.println();
            System.out.println("请输入你的选择");
            key = scanner.next();
            switch (key) {
                case "show":
                    stack.list();
                    break;
                case "push":
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try {
                        int res = stack.pop();
                        System.out.printf("出栈的数据是 %d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }

        System.out.println("程序退出");
    }

程序运行结果

show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

请输入你的选择
show
栈空，没有数据
show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

请输入你的选择
push
请输入一个数
10
show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

请输入你的选择
push
请输入一个数
20
show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

请输入你的选择
push
请输入一个数
30
show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

请输入你的选择
push
请输入一个数
40
show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

请输入你的选择
push
请输入一个数
50
栈满
show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

请输入你的选择
show
stack[3]=40
stack[2]=30
stack[1]=20
stack[0]=10
show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

请输入你的选择
pop
出栈的数据是 40
show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

请输入你的选择
pop
出栈的数据是 30
show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

请输入你的选择
pop
出栈的数据是 20
show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

请输入你的选择
pop
出栈的数据是 10
show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

请输入你的选择
pop
栈空，没有数据
show: 表示显示栈
exit: 退出程序
push: 表示添加数据到栈(入栈)
pop: 表示从栈取出数据(出栈)

3.2 数组模拟栈全部代码

public class ArrayStackDemo {

    public static void main(String[] args) {
        //测试一下ArrayStack 是否正确
        // 先创建一个ArrayStack对象->表示栈
        ArrayStack stack = new ArrayStack(4);
        String key = "";
        boolean loop = true; // 控制是否退出菜单
        Scanner scanner = new Scanner(System.in);

        while (loop) {
            System.out.println("show: 表示显示栈");
            System.out.println("exit: 退出程序");
            System.out.println("push: 表示添加数据到栈(入栈)");
            System.out.println("pop: 表示从栈取出数据(出栈)");
            System.out.println();
            System.out.println("请输入你的选择");
            key = scanner.next();
            switch (key) {
                case "show":
                    stack.list();
                    break;
                case "push":
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try {
                        int res = stack.pop();
                        System.out.printf("出栈的数据是 %d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }

        System.out.println("程序退出");
    }

}

//定义一个Arraystack表示栈
class ArrayStack {
    int maxSize; //栈的大小
    int[] stack; //数组模拟栈，数据就放在该数组
    int top = -1; // top表示栈顶，初始化为-1

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[maxSize];
    }

    // 栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    // 栈空
    public boolean isEmpty() {
        return top == -1;
    }

    // 入栈-push
    public void push(int value) {
        // 先判断 栈是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    // 出栈-pop, 将栈顶的数据返回
    public int pop() {
        // 先判断栈是否空
        if (isEmpty()) {
            // 抛出异常
            throw new RuntimeException("栈空，没有数据");
        }
        int value = stack[top];
        top--;
        return value;
    }

    // 显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据");
            return;
        }
        // 需要从栈顶开始显示数据
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }
  
}

4.链表模拟栈

public class LinkedStackDemo {

    public static void main(String[] args) {
        LinkedStack linkedStack = new LinkedStack();
        linkedStack.push(1);
        linkedStack.push(2);
        linkedStack.push(3);
        linkedStack.push(4);

        linkedStack.pop();
        linkedStack.pop();
        linkedStack.pop();
        System.out.println("-----");
        linkedStack.show();
    }
}

class LinkedStack {

    Node head = new Node(0); //头结点，不能移动

    Node temp = head; //辅助指针

    // 栈空
    public boolean isEmpty() {
        return head.next == null;
    }

    //入栈
    public void push(int value) {
        Node node = new Node(value);
        if (head.next == null) { //第一次进栈
            head.next = node; //尾插法

        }else { //头插法
            node.next = head.next;
            head.next = node;
        }
    }

    //出栈
    public void pop() {
        //先判断栈空
        if (isEmpty() || temp.next == null) {
            // 抛出异常
            throw new RuntimeException("栈空，没有数据");
        }else {
            System.out.println(temp.next);
            temp = temp.next;
        }
    }

    //遍历栈
    public void show() {
        Node temp = head.next;
        while (true) {
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

}

//节点
class Node {

    int no; //编号
    Node next; //指向下一个节点

    public Node(int no) {
        this.no = no;
    }

    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                '}';
    }
}

程序运行结果

Node{no=4}
Node{no=3}
Node{no=2}
-----
Node{no=4}
Node{no=3}
Node{no=2}
Node{no=1}

5.栈实现综合计算器(中缀表达式)

第三章-数据结构之栈_数组_04

5.1 代码实现

//先创建一个栈，直接使用前面创建好的
//定义一个Arraystack2表示栈
class ArrayStack2 {
    int maxSize; //栈的大小
    int[] stack; //数组模拟栈，数据就放在该数组
    int top = -1; // top表示栈顶，初始化为-1

    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[maxSize];
    }

    //增加一个方法，可以返回当前栈顶的值，但不是真正的pop
    public int peek(){
        return stack[top];
    }

    // 栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    // 栈空
    public boolean isEmpty() {
        return top == -1;
    }

    // 入栈-push
    public void push(int value) {
        // 先判断 栈是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    // 出栈-pop, 将栈顶的数据返回
    public int pop() {
        // 先判断栈是否空
        if (isEmpty()) {
            // 抛出异常
            throw new RuntimeException("栈空，没有数据");
        }
        int value = stack[top];
        top--;
        return value;
    }

    // 显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据");
            return;
        }
        // 需要从栈顶开始显示数据
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

    //返回运算符的优先级，优先级是程序员来确定的
    //优先级使用数字表示，数字越大，则优先级就越高
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        }else if (oper == '+' || oper == '-') {
            return 0;
        }else {
            return -1; //假定目前的表达式只有"+ , - , * , /"
        }
    }

    //判断是不是一个运算符
    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    //计算方法
    public int cal(int num1,int num2,int oper) {
        int res = 0; //res 用于存放计算的结果
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res; //返回结果
    }

}
public static void main(String[] args) {
        //根据前面老师的思路，完成表达式的运算
        String expression = "7+2*6-4";
        //创建两个栈，一个数栈，一个符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        //定义需要的相关变量
        int index = 0; //用于扫描
        int num1 = 0; //
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' '; //将每次扫描得到的字符保存到ch
        //开始while循环，扫描expression
        while (true) {
            //依次得到expression 的每一个字符
            ch = expression.substring(index,index+1).charAt(0);
            //判断ch是数字还是运算符，然后做相应的处理
            if(operStack.isOper(ch)) { //如果ch是运算符
                //判断当前的符号栈是否为空
                if ( !operStack.isEmpty()) { //如果当前的符号栈里面不为空
                    // 如果符号栈有操作符，就进行比较,
                    // 如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,
                    // 在从符号栈中pop出一个符号，进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1,num2,oper);
                        //把运算结果存到数栈里面
                        numStack.push(res);
                        //然后将当前的操作符存入符号栈
                        operStack.push(ch);
                    }else {
                        //如果当前的操作符的优先级大于栈中的操作符，就直接存入符号栈
                        operStack.push(ch);
                    }
                }else {
                    //如果为空则直接存入符号栈
                    operStack.push(ch);
                }
            }else { //如果是数字，则直接存入数栈
                numStack.push(ch - 48); //'1'对应的ASCII码是49，所以需要减掉48
            }
            //让index+1，并判断是否扫描到expression的最后了
            index++;
            if (index >= expression.length()) {
                break;
            }
        }

        // 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行
        while (true) {
            //如果符号栈为空，则计算到最后的结果，数栈中只有一个数字[结果]
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1,num2,oper);
            numStack.push(res);
        }
        // 将数栈的最后数，pop出，就是结果
        res = numStack.pop();
        System.out.printf("表达式 %s = %d",expression, res);

    }

程序运行结果

表达式 7+2*6-4 = 15

5.2 对多位数进行了判断，使得程序可处理多位数的运算

public static void main(String[] args) {
        //根据前面老师的思路，完成表达式的运算
        String expression = "70*2*20-5+1-50+36-4";
        //创建两个栈，一个数栈，一个符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        //定义需要的相关变量
        int index = 0; //用于扫描
        int num1 = 0; //
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' '; //将每次扫描得到的字符保存到ch
        String keepNum = ""; //用于拼接多位数
        //开始while循环，扫描expression
        while (true) {
            //依次得到expression 的每一个字符
            ch = expression.substring(index,index+1).charAt(0);
            //判断ch是数字还是运算符，然后做相应的处理
            if(operStack.isOper(ch)) { //如果ch是运算符
                //判断当前的符号栈是否为空
                if ( !operStack.isEmpty()) { //如果当前的符号栈里面不为空
                    // 如果符号栈有操作符，就进行比较,
                    // 如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,
                    // 在从符号栈中pop出一个符号，进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1,num2,oper);
                        //把运算结果存到数栈里面
                        numStack.push(res);
                        //然后将当前的操作符存入符号栈
                        operStack.push(ch);
                    }else {
                        //如果当前的操作符的优先级大于栈中的操作符，就直接存入符号栈
                        operStack.push(ch);
                    }
                }else {
                    //如果为空则直接存入符号栈
                    operStack.push(ch);
                }
            }else { //如果是数字，则直接存入数栈
                //numStack.push(ch - 48); //'1'对应的ASCII码是49，所以需要减掉48
                //分析思路
                //1.当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
                //2.在处理数字时，需要向expression的表达式的index 后再看一位,如果是数字就进行扫描，如果是符号才入栈
                //3.因此我们需要定义一个字符串变量，用于拼接

                //处理多位数
                keepNum += ch;

                //如果ch已经是expression的最后一位，就直接入栈
                if (index == expression.length()-1) {
                    numStack.push(Integer.parseInt(keepNum));
                }else {

                    //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
                    //注意是看后一位，不是index++
                    if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        // 如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
                        numStack.push(Integer.parseInt(keepNum));
                        //重要的!!!!!!，keepNum一定要清空
                        keepNum = "";
                    }

                }
            }
            //让index+1，并判断是否扫描到expression的最后了
            index++;
            if (index >= expression.length()) {
                break;
            }
        }

        // 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行
        while (true) {
            //如果符号栈为空，则计算到最后的结果，数栈中只有一个数字[结果]
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1,num2,oper);
            numStack.push(res);
        }
        // 将数栈的最后数，pop出，就是结果
        res = numStack.pop();
        System.out.printf("表达式 %s = %d",expression, res);

    }

程序运行结果

表达式 70*2*20-5+1-50+36-4 = 2778

5.3 综合计算器全部代码

/**
 * 栈实现综合计算器
 */
public class Calculator {

    public static void main(String[] args) {
        //根据前面老师的思路，完成表达式的运算
        String expression = "70*2*20-5+1-50+36-4";
        //创建两个栈，一个数栈，一个符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        //定义需要的相关变量
        int index = 0; //用于扫描
        int num1 = 0; //
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' '; //将每次扫描得到的字符保存到ch
        String keepNum = ""; //用于拼接多位数
        //开始while循环，扫描expression
        while (true) {
            //依次得到expression 的每一个字符
            ch = expression.substring(index,index+1).charAt(0);
            //判断ch是数字还是运算符，然后做相应的处理
            if(operStack.isOper(ch)) { //如果ch是运算符
                //判断当前的符号栈是否为空
                if ( !operStack.isEmpty()) { //如果当前的符号栈里面不为空
                    // 如果符号栈有操作符，就进行比较,
                    // 如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,
                    // 在从符号栈中pop出一个符号，进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1,num2,oper);
                        //把运算结果存到数栈里面
                        numStack.push(res);
                        //然后将当前的操作符存入符号栈
                        operStack.push(ch);
                    }else {
                        //如果当前的操作符的优先级大于栈中的操作符，就直接存入符号栈
                        operStack.push(ch);
                    }
                }else {
                    //如果为空则直接存入符号栈
                    operStack.push(ch);
                }
            }else { //如果是数字，则直接存入数栈
                //numStack.push(ch - 48); //'1'对应的ASCII码是49，所以需要减掉48
                //分析思路
                //1.当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
                //2.在处理数字时，需要向expression的表达式的index 后再看一位,如果是数字就进行扫描，如果是符号才入栈
                //3.因此我们需要定义一个字符串变量，用于拼接

                //处理多位数
                keepNum += ch;

                //如果ch已经是expression的最后一位，就直接入栈
                if (index == expression.length()-1) {
                    numStack.push(Integer.parseInt(keepNum));
                }else {

                    //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
                    //注意是看后一位，不是index++
                    if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        // 如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
                        numStack.push(Integer.parseInt(keepNum));
                        //重要的!!!!!!，keepNum一定要清空
                        keepNum = "";
                    }

                }
            }
            //让index+1，并判断是否扫描到expression的最后了
            index++;
            if (index >= expression.length()) {
                break;
            }
        }

        // 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行
        while (true) {
            //如果符号栈为空，则计算到最后的结果，数栈中只有一个数字[结果]
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1,num2,oper);
            numStack.push(res);
        }
        // 将数栈的最后数，pop出，就是结果
        res = numStack.pop();
        System.out.printf("表达式 %s = %d",expression, res);

    }
}

//先创建一个栈，直接使用前面创建好的
//定义一个Arraystack2表示栈
class ArrayStack2 {
    int maxSize; //栈的大小
    int[] stack; //数组模拟栈，数据就放在该数组
    int top = -1; // top表示栈顶，初始化为-1

    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[maxSize];
    }

    //增加一个方法，可以返回当前栈顶的值，但不是真正的pop
    public int peek(){
        return stack[top];
    }

    // 栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    // 栈空
    public boolean isEmpty() {
        return top == -1;
    }

    // 入栈-push
    public void push(int value) {
        // 先判断 栈是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    // 出栈-pop, 将栈顶的数据返回
    public int pop() {
        // 先判断栈是否空
        if (isEmpty()) {
            // 抛出异常
            throw new RuntimeException("栈空，没有数据");
        }
        int value = stack[top];
        top--;
        return value;
    }

    // 显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据");
            return;
        }
        // 需要从栈顶开始显示数据
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

    //返回运算符的优先级，优先级是程序员来确定的
    //优先级使用数字表示，数字越大，则优先级就越高
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        }else if (oper == '+' || oper == '-') {
            return 0;
        }else {
            return -1; //假定目前的表达式只有"+ , - , * , /"
        }
    }

    //判断是不是一个运算符
    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    //计算方法
    public int cal(int num1,int num2,int oper) {
        int res = 0; //res 用于存放计算的结果
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res; //返回结果
    }

}

6.前缀表达式(波兰表达式)

/*
1.前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前
2.前缀表达式的计算机求值
从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果
3.例如: (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 , 针对前缀表达式求值步骤如下:
①从右至左扫描，将6、5、4、3压入堆栈
②遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素），计算出3+4的值，得7，再将7入栈
③接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈
④最后是-运算符，计算出35-6的值，即29，由此得出最终结果
*/

7.中缀表达式

/*
1.中缀表达式就是常见的运算表达式，如(3+4)×5-6
2.中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作(前面我们讲的案例就能看的这个问题)，因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式.)
*/

8.后缀表达式(逆波兰表达式)

/*
1.后缀表达式又称逆波兰表达式,与前缀表达式相似，只是运算符位于操作数之后
2.中举例说明： (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –
3.再比如:
*/

正常的表达式

逆波兰表达式

a + b

a b +

a + ( b - c )

a b c - +

a + ( b - c ) * d

a b c – d * +

a + d * ( b - c )

a d b c - * +

a = 1 + 3

a 1 3 + =

/*
后缀表达式的计算机求值
1.从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和 次顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果
2.例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:
①从左至右扫描，将3和4压入堆栈；
②遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
③将5入栈；
④接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
⑤将6入栈；
⑥最后是-运算符，计算出35-6的值，即29，由此得出最终结果
*/

8.1 逆波兰计算器

/**
 * 逆波兰计算器
 */
public class PolandNotation {

    public static void main(String[] args) {
        //先定义一个逆波兰表达式
        //(30+4)×5-6 => 30 4 + 5 × 6 -  => 164
        // 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / + => 76
        //说明：为了方便，逆波兰表达式的数字和符号使用空格隔开
        String suffixExpression = "4 5 * 8 - 60 + 8 2 / +";
        //思路：
        //1.先将 逆波兰表达式 放到ArrayList中
        //2.将 ArrayList 传给一个方法，遍历 ArrayList，配合栈，完成计算
        List<String> list = getListString(suffixExpression);
        System.out.println("rpnList = " + list);

        int res = calculate(list);
        System.out.println("结果是: " + res);
    }

    //将一个 逆波兰表达式，依次将数据和运算符 放入到 ArrayList中
    public static List<String> getListString(String suffixExpression) {
        //将 suffixExpression 分割，按照空格分割
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<String>();
        for (String ele : split) {
            list.add(ele);
        }
        return list;
    }

    //完成对逆波兰表达式的运算
    /**
     * 例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:
     * ①从左至右扫描，将3和4压入堆栈；
     * ②遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
     * ③将5入栈；
     * ④接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
     * ⑤将6入栈；
     * ⑥最后是-运算符，计算出35-6的值，即29，由此得出最终结果
     */
    public static int calculate(List<String> list) {
        //创建一个栈，只需要一个栈就好
        Stack<String> stack = new Stack<>();
        //遍历list
        for (String item : list) {
            //使用正则表达式来取出数
            if (item.matches("\\d+")) { //匹配的是多位数
                //入栈
                stack.push(item);
            }else { //如果是运算符
                //pop出两个数，并进行运算，结果再入栈
                int num1 = Integer.parseInt(stack.pop()); //栈顶
                int num2 = Integer.parseInt(stack.pop()); //次顶
                int res = 0; //运算结果
                if (item.equals("+")) { //如果运算符是"+"号
                    res = num1 + num2;
                }else if(item.equals("-")) { //如果运算符是"-"号
                    res = num2 - num1; //次顶 - 栈顶
                }else if (item.equals("*")) { //如果运算符是"*"号
                    res = num1 * num2;
                }else if (item.equals("/")){ //如果运算符是"/"号
                    res = num2 / num1; //次顶 / 栈顶
                }else { //如果不是上面的几个运算符，就抛出异常
                    throw new RuntimeException("运算符有误");
                }
                //把结果入栈
                stack.push("" + res);
            }
        }

        //最后留在stack中的数据就是最终的结果
        return Integer.parseInt(stack.pop());
    }

}

程序运行结果

list = [4, 5, *, 8, -, 60, +, 8, 2, /, +]
结果是: 76

9.中缀表达式 转 后缀表达式

9.1 思路

/*
具体步骤：
1.初始化两个栈：运算符栈s1和储存中间结果的栈s2；
2.从左至右扫描中缀表达式；
3.遇到操作数时，将其压s2；
4.遇到运算符时，比较其与s1栈顶运算符的优先级：
  ①如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
  ②否则，若优先级比栈顶运算符的高，也将运算符压入s1；
  ③否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
5.遇到括号时：
  ①如果是左括号“(”，则直接压入s1
  ②如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
6.重复步骤2至5，直到表达式的最右边
7.将s1中剩余的运算符依次弹出并压入s2
8.依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
*/

第三章-数据结构之栈_java_05

9.2 举例

举例说明：将中缀表达式 “1+((2+3)×4)-5” 转换为后缀表达式的过程如下

扫描到的元素

s2(栈底->栈顶)

s1 (栈底->栈顶)

说明

1

1

空

数字，直接入栈

+

1

+

s1为空，运算符直接入栈

(

1

+ (

左括号，直接入栈

(

1

+ ( (

同上

2

1 2

+ ( (

数字

+

1 2

+ ( ( +

s1栈顶为左括号，运算符直接入栈

3

1 2 3

+ ( ( +

数字

)

1 2 3 +

+ (

右括号，弹出运算符直至遇到左括号

×

1 2 3 +

+ ( ×

s1栈顶为左括号，运算符直接入栈

4

1 2 3 + 4

+ ( ×

数字

)

1 2 3 + 4 ×

+

右括号，弹出运算符直至遇到左括号

-

1 2 3 + 4 × +

-

-与+优先级相同，因此弹出+，再压入-

5

1 2 3 + 4 × + 5

-

数字

到达最右端

1 2 3 + 4 × + 5 -

空

s1中剩余的运算符

最终结果为：“1 2 3 + 4 × + 5

9.3 代码实现

9.3.1 将中缀表达式 转为 对应的List

将中缀表达式转为对应的 List ：将数字和运算符分开，存储在 ​​List<String>​​ 对象中

//2.将 中缀表达式 转成对应的List
    // s="1+((2+3)×4)-5";
    public static List<String> toInfixExpressionList(String s) {
        // 定义一个List,存放中缀表达式 对应的内容
        List<String> list = new ArrayList<>();
        int i = 0; // 相当于指针，用于遍历 中缀表达式字符串
        String str; // 对多位数的拼接
        char c; // 每遍历到一个字符，就放入到c
        while (i < s.length()) {
            //如果c是一个非数字，就需要加入到list中
            if ( (c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57)  {
                list.add("" + c);
                i++; //i需要后移
            }else { //如果是一个数，需要考虑多位数的问题
                str = ""; //先将str置空，'0'[48]->'9'[57]
           while ( i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57 ) {
                    str += c; //拼接
                    i++;
                }
                list.add(str);
            }
        }

        return list;
    }

9.3.2 将中缀表达式(List) 转为 后缀表达式(List)

//ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,–]
    //3.将得到的中缀表达式对应的List => 后缀表达式对应的List
    public static List<String> parseSuffixExpressionList(List<String> ls) {
        //定义两个栈
        Stack<String> s1 = new Stack<>(); //符号栈
        // 说明：因为s2 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
        // 因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> s2
//        Stack<String> s2 = new Stack<>();
        List<String> s2 = new ArrayList<>();

        //遍历ls
        for (String item : ls) {
            //如果是一个数，就加入到s2
            if (item.matches("\\d")) { //如果是一个数，直接加入s2
                s2.add(item);
            } else if (item.equals("(")) { // 如果是 ( ，则直接加入s1
                s1.push(item);
            } else if (item.equals(")")) {
                // 如果是右括号“)”，则依次弹出s1栈顶的运算符，
                // 并放入s2，直到遇到左括号为止，此时将这一对括号丢弃
                while (!s1.peek().equals("(")) { //如果还没遇到s1的左括号
                    s2.add(s1.pop()); //就一直把s1栈的内容，加入到s2
                }
                s1.pop(); //很重要，将"("弹出s1，即消除小括号
            } else {
                //当item的优先级 小于等于 s1栈顶运算符 的优先级
                //将s1栈顶的运算符弹出并加入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                //还需要将item压入s1栈中
                s1.push(item);
            }
        }

        //将s1中剩余的运算符依次弹出并加入到s2
        while (s1.size() != 0) {
            s2.add(s1.pop());
        }

        return s2; // 注意:因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List
    }

9.3.3 测试代码

//完成将一个将 中缀表达式 转 后缀表达式 的功能
        // 说明
        //1. 1+((2+3)×4)-5 => 转成 1 2 3 + 4 × + 5 –

        //2. 因为直接对str 进行操作，不方便，
        // 因此 先将 "1+((2+3)×4)-5" 以中缀的形式放入list中
        // 即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
        String expression = "1+((2+3)*4)-5";
        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println("中缀表达式对应的list：" + infixExpressionList); //[1, +, (, (, 2, +, 3, ), ×, 4, ), -, 5]

        // 3. 将得到的中缀表达式对应的List => 后缀表达式对应的List
        // 即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,–]
        List<String> suffixExpreesionList = parseSuffixExpressionList(infixExpressionList);
        System.out.println("后缀表达式对应的list：" + suffixExpreesionList); //[1, 2, 3, +, 4, *, +, 5, -]

        System.out.printf("expression=%d", calculate(suffixExpreesionList)); // 16

程序运行结果

中缀表达式对应的list：[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
不存在该运算符
不存在该运算符
后缀表达式对应的list：[1, 2, 3, +, 4, *, +, 5, -]
expression=16

9.4 中缀表达式 转 后缀表达式完整代码

/**
 * 逆波兰计算器
 */
public class PolandNotation {

    public static void main(String[] args) {

        //完成将一个将 中缀表达式 转 后缀表达式 的功能
        // 说明
        //1. 1+((2+3)×4)-5 => 转成 1 2 3 + 4 × + 5 –

        //2. 因为直接对str 进行操作，不方便，
        // 因此 先将 "1+((2+3)×4)-5" 以中缀的形式放入list中
        // 即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
        String expression = "1+((2+3)*4)-5";
        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println("中缀表达式对应的list：" + infixExpressionList); //[1, +, (, (, 2, +, 3, ), ×, 4, ), -, 5]

        // 3. 将得到的中缀表达式对应的List => 后缀表达式对应的List
        // 即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,–]
        List<String> suffixExpreesionList = parseSuffixExpressionList(infixExpressionList);
        System.out.println("后缀表达式对应的list：" + suffixExpreesionList); //[1, 2, 3, +, 4, *, +, 5, -]

        System.out.printf("expression=%d", calculate(suffixExpreesionList)); // 16

    }

    //2.将 中缀表达式 转成对应的List
    // s="1+((2+3)×4)-5";
    public static List<String> toInfixExpressionList(String s) {
        // 定义一个List,存放中缀表达式 对应的内容
        List<String> list = new ArrayList<>();
        int i = 0; // 相当于指针，用于遍历 中缀表达式字符串
        String str; // 对多位数的拼接
        char c; // 每遍历到一个字符，就放入到c
        while (i < s.length()) {
            //如果c是一个非数字，就需要加入到list中
            if ( (c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57)  {
                list.add("" + c);
                i++; //i需要后移
            }else { //如果是一个数，需要考虑多位数的问题
                str = ""; //先将str置空，'0'[48]->'9'[57]
                while ( i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57 ) {
                    str += c; //拼接
                    i++;
                }
                list.add(str);
            }
        }

        return list;
    }

    //ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,–]
    //3.将得到的中缀表达式对应的List => 后缀表达式对应的List
    public static List<String> parseSuffixExpressionList(List<String> ls) {
        //定义两个栈
        Stack<String> s1 = new Stack<>(); //符号栈
        // 说明：因为s2 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
        // 因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> s2
//        Stack<String> s2 = new Stack<>();
        List<String> s2 = new ArrayList<>();

        //遍历ls
        for (String item : ls) {
            //如果是一个数，就加入到s2
            if (item.matches("\\d")) { //如果是一个数，直接加入s2
                s2.add(item);
            } else if (item.equals("(")) { // 如果是 ( ，则直接加入s1
                s1.push(item);
            } else if (item.equals(")")) {
                // 如果是右括号“)”，则依次弹出s1栈顶的运算符，
                // 并放入s2，直到遇到左括号为止，此时将这一对括号丢弃
                while (!s1.peek().equals("(")) { //如果还没遇到s1的左括号
                    s2.add(s1.pop()); //就一直把s1栈的内容，加入到s2
                }
                s1.pop(); //很重要，将"("弹出s1，即消除小括号
            } else {
                //当item的优先级 小于等于 s1栈顶运算符 的优先级
                //将s1栈顶的运算符弹出并加入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                //还需要将item压入s1栈中
                s1.push(item);
            }
        }

        //将s1中剩余的运算符依次弹出并加入到s2
        while (s1.size() != 0) {
            s2.add(s1.pop());
        }

        return s2; // 注意:因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List
    }

    //将一个 逆波兰表达式，依次将数据和运算符 放入到 ArrayList中
    public static List<String> getListString(String suffixExpression) {
        //将 suffixExpression 分割，按照空格分割
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<String>();
        for (String ele : split) {
            list.add(ele);
        }
        return list;
    }

    //完成对逆波兰表达式的运算
    /**
     * ①从左至右扫描，将3和4压入堆栈；
     * ②遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
     * ③将5入栈；
     * ④接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
     * ⑤将6入栈；
     * ⑥最后是-运算符，计算出35-6的值，即29，由此得出最终结果
     */
    public static int calculate(List<String> list) {
        //创建一个栈，只需要一个栈就好
        Stack<String> stack = new Stack<>();
        //遍历list
        for (String item : list) {
            //使用正则表达式来取出数
            if (item.matches("\\d+")) { //匹配的是多位数
                //入栈
                stack.push(item);
            }else { //如果是运算符
                //pop出两个数，并进行运算，结果再入栈
                int num1 = Integer.parseInt(stack.pop()); //栈顶
                int num2 = Integer.parseInt(stack.pop()); //次顶
                int res = 0; //运算结果
                if (item.equals("+")) { //如果运算符是"+"号
                    res = num1 + num2;
                }else if(item.equals("-")) { //如果运算符是"-"号
                    res = num2 - num1; //次顶 - 栈顶
                }else if (item.equals("*")) { //如果运算符是"*"号
                    res = num1 * num2;
                }else if (item.equals("/")){ //如果运算符是"/"号
                    res = num2 / num1; //次顶 / 栈顶
                }else { //如果不是上面的几个运算符，就抛出异常
                    throw new RuntimeException("运算符有误");
                }
                //把结果入栈
                stack.push("" + res);
            }
        }

        //最后留在stack中的数据就是最终的结果
        return Integer.parseInt(stack.pop());
    }

}

//编写一个类 Operation，可以返回一个运算符 对应的优先级
class Operation {

    //写一个方法，返回对应的优先级数字
    public static int getValue(String operation) {
        int result = 0;
        switch (operation) {
            case "+":
                result = 1;
                break;
            case "-":
                result = 1;
                break;
            case "*":
                result = 2;
                break;
            case "/":
                result = 2;
                break;
            default:
                System.out.println("不存在该运算符");
                break;
        }
        return result;
    }
}

10.完整版逆波兰计算器(涉及小数计算)

public class ReversePolishMultiCalc {

     /**
     * 匹配 + - * / ( ) 运算符
     */
    static final String SYMBOL = "\\+|-|\\*|/|\\(|\\)";

    static final String LEFT = "(";
    static final String RIGHT = ")";
    static final String ADD = "+";
    static final String MINUS= "-";
    static final String TIMES = "*";
    static final String DIVISION = "/";

    /**
     * 加減 + -
     */
    static final int LEVEL_01 = 1;
    /**
     * 乘除 * /
     */
    static final int LEVEL_02 = 2;

    /**
     * 括号
     */
    static final int LEVEL_HIGH = Integer.MAX_VALUE;


    static Stack<String> stack = new Stack<>();
    static List<String> data = Collections.synchronizedList(new ArrayList<String>());

    /**
     * 去除所有空白符
     * @param s
     * @return
     */
    public static String replaceAllBlank(String s ){
        // \\s+ 匹配任何空白字符，包括空格、制表符、换页符等等, 等价于[ \f\n\r\t\v]
        return s.replaceAll("\\s+","");
    }

    /**
     * 判断是不是数字 int double long float
     * @param s
     * @return
     */
    public static boolean isNumber(String s){
        Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
        return pattern.matcher(s).matches();
    }

    /**
     * 判断是不是运算符
     * @param s
     * @return
     */
    public static boolean isSymbol(String s){
        return s.matches(SYMBOL);
    }

    /**
     * 匹配运算等级
     * @param s
     * @return
     */
    public static int calcLevel(String s){
        if("+".equals(s) || "-".equals(s)){
            return LEVEL_01;
        } else if("*".equals(s) || "/".equals(s)){
            return LEVEL_02;
        }
        return LEVEL_HIGH;
    }

    /**
     * 匹配
     * @param s
     * @throws Exception
     */
    public static List<String> doMatch (String s) throws Exception{
        if(s == null || "".equals(s.trim())) throw new RuntimeException("data is empty");
        if(!isNumber(s.charAt(0)+"")) throw new RuntimeException("data illeagle,start not with a number");

        s = replaceAllBlank(s);

        String each;
        int start = 0;

        for (int i = 0; i < s.length(); i++) {
            if(isSymbol(s.charAt(i)+"")){
                each = s.charAt(i)+"";
                //栈为空，(操作符，或者 操作符优先级大于栈顶优先级 && 操作符优先级不是( )的优先级 及是 ) 不能直接入栈
                if(stack.isEmpty() || LEFT.equals(each)
                        || ((calcLevel(each) > calcLevel(stack.peek())) && calcLevel(each) < LEVEL_HIGH)){
                    stack.push(each);
                }else if( !stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())){
                    //栈非空，操作符优先级小于等于栈顶优先级时出栈入列，直到栈为空，或者遇到了(，最后操作符入栈
                    while (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek()) ){
                        if(calcLevel(stack.peek()) == LEVEL_HIGH){
                            break;
                        }
                        data.add(stack.pop());
                    }
                    stack.push(each);
                }else if(RIGHT.equals(each)){
                    // ) 操作符，依次出栈入列直到空栈或者遇到了第一个)操作符，此时)出栈
                    while (!stack.isEmpty() && LEVEL_HIGH >= calcLevel(stack.peek())){
                        if(LEVEL_HIGH == calcLevel(stack.peek())){
                            stack.pop();
                            break;
                        }
                        data.add(stack.pop());
                    }
                }
                start = i ;    //前一个运算符的位置
            }else if( i == s.length()-1 || isSymbol(s.charAt(i+1)+"") ){
                each = start == 0 ? s.substring(start,i+1) : s.substring(start+1,i+1);
                if(isNumber(each)) {
                    data.add(each);
                    continue;
                }
                throw new RuntimeException("data not match number");
            }
        }
        //如果栈里还有元素，此时元素需要依次出栈入列，可以想象栈里剩下栈顶为/，栈底为+，应该依次出栈入列，可以直接翻转整个stack 添加到队列
        Collections.reverse(stack);
        data.addAll(new ArrayList<>(stack));

        System.out.println(data);
        return data;
    }

    /**
     * 算出结果
     * @param list
     * @return
     */
    public static Double doCalc(List<String> list){
        Double d = 0d;
        if(list == null || list.isEmpty()){
            return null;
        }
        if (list.size() == 1){
            System.out.println(list);
            d = Double.valueOf(list.get(0));
            return d;
        }
        ArrayList<String> list1 = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            list1.add(list.get(i));
            if(isSymbol(list.get(i))){
                Double d1 = doTheMath(list.get(i - 2), list.get(i - 1), list.get(i));
                list1.remove(i);
                list1.remove(i-1);
                list1.set(i-2,d1+"");
                list1.addAll(list.subList(i+1,list.size()));
                break;
            }
        }
        doCalc(list1);
        return d;
    }

    /**
     * 运算
     * @param s1
     * @param s2
     * @param symbol
     * @return
     */
    public static Double doTheMath(String s1,String s2,String symbol){
        Double result ;
        switch (symbol){
            case ADD : result = Double.valueOf(s1) + Double.valueOf(s2); break;
            case MINUS : result = Double.valueOf(s1) - Double.valueOf(s2); break;
            case TIMES : result = Double.valueOf(s1) * Double.valueOf(s2); break;
            case DIVISION : result = Double.valueOf(s1) / Double.valueOf(s2); break;
            default : result = null;
        }
        return result;

    }

    public static void main(String[] args) {
        //String math = "9+(3-1)*3+10/2";
        String math = "12.8 + (2 - 3.55)*4+10/5.0";
        try {
            doCalc(doMatch(math));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}