【尚硅谷数据结构】第 5 章栈

1、栈的基本介绍

参考：https://blog.csdn.net/oneby1314/category_10231585.html

1.1 栈的实际需求

请计算表达式：[7**2*2-5+1-5+3-3] 的值
请问: 计算机底层是如何运算得到结果的？注意不是简单的把算式列出运算，因为我们看这个算式 7 * 2 * 2 - 5，但是计算机怎么理解这个算式的
对计算机而言，它接收到的就是一个字符串，我们讨论的是这个问题：栈

在这里插入图片描述

1.2 栈的基本性质

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

在这里插入图片描述

1.3 栈的应用场景

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

2、数组模拟栈

2.1 代码思路

在这里插入图片描述

2.2、代码实现

栈的定义

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

	// 构造器
	public ArrayStack(int maxSize) {
      
      
		this.maxSize = maxSize;
		stack = new int[this.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]);
		}
	}
}

2.3 数组模拟栈全部代码

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("请输入你的选择：");

            key = scanner.next();
            switch (key) {
    
    
                case "show" :
                    stack.list();
                    break;
                case "exit" :
                    scanner.close(); // 关闭流，防止资源浪费
                    loop = false;
                    break;
                case "push" :
                    System.out.println("请输入一个数字：");
                    stack.push(scanner.nextInt());
                    break;
                case "pop" :
                    try {
    
    
                        int res = stack.pop();
                        System.out.printf("出栈的数据是 %d \n",res);
                    } catch (Exception e) {
    
    
                        System.out.println(e.getMessage());
                    }
            }
        }
        System.out.println("程序结束！");
    }
}

// 定义一个ArrayStack表示栈
class ArrayStack {
    
    
    private int maxSize;
    private int[] stack;
    private int 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;
    }

    // 入栈
    public void push(int num) {
    
    
        // 入栈之前先判断是否满
        if (isFull()) {
    
    
            System.out.println("栈满，无法添加！");
            return;
        } else {
    
    
            top ++;
            stack[top] = num;
        }
    }

    // 出栈
    public int pop() {
    
    
        // 出栈之前先判断是否栈空
        if (isEmpty()) {
    
    
            throw new RuntimeException("栈空，无法出栈！");
        } else {
    
    
            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]);
        }
    }
}

2.4 链表模拟栈

代码

我用的尾插法，需要遍历，时间复杂度高。

可以考虑使用头插法;

public class LinkStackDemo {
    
    
    public static void main(String[] args) {
    
    
        LinkStack linkStack = new LinkStack();
        linkStack.push(new Node(1));
        linkStack.push(new Node(2));
        linkStack.push(new Node(3));
        linkStack.push(new Node(4));

        System.out.println("--原来----");
        linkStack.show();

        System.out.println("---弹出---");
        System.out.println(linkStack.pop());
        System.out.println(linkStack.pop());
        System.out.println(linkStack.pop());
        System.out.println(linkStack.pop());


        System.out.println("---剩余---");
        System.out.println();

        linkStack.show();

    }
}

// 链表节点
class Node {
    
    
    private int no;
    private Node next;

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

    public int getNo() {
    
    
        return no;
    }

    public void setNo(int no) {
    
    
        this.no = no;
    }

    public Node getNext() {
    
    
        return next;
    }

    public void setNext(Node next) {
    
    
        this.next = next;
    }

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

// 链表栈
class LinkStack {
    
    
    private Node head; // 头指针
    private Node top; // 栈顶

    public LinkStack() {
    
    
        head = new Node(-1);
        top = head;
    }

    // 判断栈是否为空
    public boolean isEmpty() {
    
    
        return head.getNext() == null;
    }


    // 遍历
    public void show() {
    
    
        if (isEmpty()) {
    
    
            System.out.println("栈空，无法打印！");
            return;
        }
        Node temp = head;
        while (temp.getNext() != null) {
    
    
            System.out.println(temp.getNext());
            temp = temp.getNext();
        }
    }

    // 入栈
    public void push(Node node) {
    
    
        top.setNext(node);
        top = node;
    }

    // 出栈
    public Node pop() {
    
    
        if (isEmpty()) {
    
    
            throw new RuntimeException("栈为空，无法打印！");
        }
        Node value = top;
        // 找到top的前一个节点
        Node temp = head;
        while (true) {
    
    
            if (temp.getNext() == top) {
    
    
                break;
            }
            temp = temp.getNext();
        }
        // 栈顶前移
        top = temp;
        // 释放最后一个节点
        top.setNext(null);
        return value;
    }
}

3、栈实现综合计算器(中缀表达式)

3.1 代码思路

栈分为两个栈：
- 数栈（numStack）: 存储表达式中的数字
- 符号栈（operStack）: 存储表达式中的符号
扫描表达式（这里并没有考虑括号）：
- 对于数：扫描到数，则直接压入数栈
- 对于运算符：扫描到运算符，分为如下几种情况：
  - 如果符号栈为空，则直接入栈
  - 如果符号栈不为空：
    - 如果当前扫描到的运算符的优先级 <= 符号栈栈顶的运算符的优先级，说明上次的运算符优先级较高，先执行优先级高的运算：
      - 从数栈中弹出两个数，根据符号栈栈顶的运算符进行运算（优先级高，就先算出来）
      - 然后将计算的结果压入栈中
      - 再将当前运算符压入符号栈
    - 如果当前扫描到的运算符的优先级 > 符号栈栈顶的运算符的优先级
      - 说明上次的运算符优先级较低，直接压入符号栈
何时停止循环？
- 处理完表达式，退出循环
- 即表达式下标（index）的值大于表达式（expression）的长度
- 代码：index >= expression.length()
表达式扫描完成：
- 此时符号栈中的运算符优先级都相同
- 从数栈中弹出两个数，再从符号栈中弹出一个运算符，进行运算，计算结果放回数栈中
- 何时停止循环？符号栈为空则停止：operStack.isEmpty()
- 表达式的值？符号栈为空时，数栈栈顶还有一个元素，这个元素的值就是表达式的值
举例：3+2*6-2
- 首先
  - 将 3 压入数栈
  - 将 + 压入符号栈
  - 将 2 压入数栈
```
2
3	  +
数栈	符号栈
123
```
- 由于 * 优先级大于 + ，所以将 * 压入符号栈，然后将 6 压入数栈
```
6
2	  *
3	  +
数栈	符号栈
1234
```
- 由于 - 优先级低于 * ，所以从数栈中弹出两个数（6 和 2），从符号栈中弹出一个运算符（*），进行运算，运算结果再压入数栈，然后将 - 压入符号栈
```
12	  -
3	  +
数栈	符号栈
123
```
- 将 2 压入数栈，表达式处理完毕
```
2
12	  -
3	  +
数栈	符号栈
1234
```
- 重复此过程，直至符号栈为空：从数栈中弹出两个数，再从符号栈中弹出一个运算符，进行运算，计算结果放回数栈中
```
10
3	  +
数栈	符号栈
123
```
```
13
数栈	符号栈
12
```

在这里插入图片描述

3.2 代码实现

栈的定义：专为计算器而生的栈
对于乘除法特别说明：由于栈先进后出的特点，num1 是运算符后面的数（减数、除数），num2 是运算符前的数（被减数、被除数），特别需要注意减法与除法的顺序 ( 先弹出来的是num2, 中缀特点 ) ;
- res = num2 - num1;
- res = num2 / num1;

// 先创建一个栈
// 定义一个ArrayStack2表示栈，需要扩展功能
class ArrayStack2 {
    
    
    private int maxSize;
    private int[] stack;
    private int top = -1;

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

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

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

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

    // 入栈
    public void push(int num) {
    
    
        // 入栈之前先判断是否满
        if (isFull()) {
    
    
            System.out.println("栈满，无法添加！");
            return;
        } else {
    
    
            top ++;
            stack[top] = num;
        }
    }

    // 出栈
    public int pop() {
    
    
        // 出栈之前先判断是否栈空
        if (isEmpty()) {
    
    
            throw new RuntimeException("栈空，无法出栈！");
        } else {
    
    
            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 var) {
    
    
        return var == '+' || var == '-' || var == '*' || var == '/';
    }


    // 计算方法
    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;
    }
}

3.3 综合计算器全部代码

public class Caculator {
    
    
    public static void main(String[] args) {
    
    
        String expression = "30+2*6-20";
        // 创建两个栈，一个数栈，一个符号栈
        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 = ' '; // 将每次扫描得到的char保存到ch
        String keepNum = ""; // 用于拼接多位数
        // 开始while循环的扫描expression的每一个字符
        while (true) {
    
    
            // 依次得到expression的每一个字符
            ch = expression.charAt(index);
            // 判断ch是什么，然后做相应的处理
            if(operStack.isOper(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. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是一个多位数
                // 2. 在处理数时，需要向expression的表达式的index后再看一位，如果是数就进行扫描，如果是符号才入栈
                // 3. 因此，我们需要定义一个字符串变量，用于拼接

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

                // 如果ch已经是expression的最后一位,就直接入栈
                if (index == expression.length()-1) {
    
    
                    numStack.push(Integer.parseInt(keepNum));
                }else {
    
    
                    // 判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则将该数字入栈
                    // 注意是看后一位，不是inedx++

                    if (operStack.isOper(expression.charAt(index+1))) {
    
    
                        // 如果后一位是运算符，则入栈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);
        }
        int res2 = numStack.pop();
        System.out.printf("表达式 %s = %d", expression, res2);
    }
}


// 先创建一个栈
// 定义一个ArrayStack2表示栈，需要扩展功能
class ArrayStack2 {
    
    
    private int maxSize;
    private int[] stack;
    private int top = -1;

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

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

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

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

  
    // 入栈
    public void push(int num) {
    
    
        // 入栈之前先判断是否满
        if (isFull()) {
    
    
            System.out.println("栈满，无法添加！");
            return;
        } else {
    
    
            top ++;
            stack[top] = num;
        }
    }

  
    // 出栈
    public int pop() {
    
    
        // 出栈之前先判断是否栈空
        if (isEmpty()) {
    
    
            throw new RuntimeException("栈空，无法出栈！");
        } else {
    
    
            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 var) {
    
    
        return var == '+' || var == '-' || var == '*' || var == '/';
    }


    // 计算方法
    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;
    }
}

4、前缀中缀后缀表达式

4.1 前缀表达式(波兰表达式)

4.1.1 前缀表达式

前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前
举例说明： (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6

4.1.2 前缀表达式的计算机求值

从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素和次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果
例如：(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，由此得出最终结果（这里有一个顺序问题，先弹出来的在左边！）

4.2 中缀表达式

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

4.3、后缀表达式

4.3.1 后缀表达式

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

再比如:

正常的表达式	逆波兰表达式
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 + =

4.3.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，由此得出最终结果（这里有一个顺序问题，和前面不一样！先弹出来的在右边【减数/除数】）

5、逆波兰计算器

5.1 计算器说明

输入一个逆波兰表达式(后缀表达式)，使用栈(Stack)，计算其结果
支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算

5.2、代码思路

计算后缀表达式无需考虑运算符优先级问题，所以只需要一个数栈即可
分为两种情况：
- 遇到数：压如数栈
- 遇到运算符：从数栈中弹出两个数，进行计算，计算结果压入数栈
何时计算完成？表达式扫描完毕就代表完成

5.3 代码实现

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

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

    //完成对逆波兰表达式的运算
	/*
	 * 1)从左至右扫描，将3和4压入堆栈；
		2)遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
		3)将5入栈；
		4)接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
		5)将6入栈；
		6)最后是-运算符，计算出35-6的值，即29，由此得出最终结果
	 */
    public static int calculate(List<String> ls) {
    
    
        // 创建一个栈即可
        Stack<String> stack = new Stack<String>();
        // 遍历ls
        for (String item : ls) {
    
    
            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 ("+".equals(item)) {
    
    
                    res = num1 + num2;
                } else if ("-".equals(item)) {
    
    
                    res = num2 - num1;
                } else if ("*".equals(item)) {
    
    
                    res = num1 * num2;
                } else if ("/".equals(item)) {
    
    
                    res = num2 / num1;
                } else {
    
    
                    throw new RuntimeException("运算符有误！");
                }
                // 把res入栈
                stack.push(res + "");
            }
        }
        // 最后留在stack中的就是运算结果
        return Integer.parseInt(stack.pop());
    }
}

程序运行结果
```
list=[3, 4, +, 5, *, 6, -]
29
```

6、中缀表达式转后缀表达式

6.1 代码思路

初始化两个栈：运算符栈operStack和储存中间结果的栈tempStack；
从左至右扫描中缀表达式；
遇到操作数时，将其压tempStack；
遇到运算符时，比较其与operStack栈顶运算符的优先级：
1. 如果operStack为空，或栈顶运算符为左括号“(”，则直接将此运算符入tempStack栈（分如下两种情况）；
  - operStack 栈顶为空：之前的优先级别高的运算已经处理完成，已经得到了一个结果，将当前运算符直接压入 operStack 栈即可
  - operStack 栈顶为左括号：我都挨着左括号了，我要和它同生共死！当把我从operStack 出栈，用于运算后，这对括号中的表达式的值也就计算出来了
2. 如果当前运算符优先级比栈顶运算符的高，也将运算符压入tempStack；（当前运算符优先级高，先执行运算）
3. 否则，当前运算符优先级 <= 栈顶运算符优先级，将operStack栈顶的运算符弹出并压入到tempStack中（operStack 栈顶运算符优先级高，先执行运算），再次转到(4.1)与operStack中新的栈顶运算符相比较
  
  （分如下两种情况）；
  - 一直循环，将 tempStack 栈顶元素取出，直到在 operStack 栈中找到比当前运算符优先级高的运算符，让其先执行运算
  - 如果在 tempStack 栈中找不到比当前运算符优先级高的运算符，则会直接将 operStack 栈掏空，然后将当前运算符压入 tempStack 栈中（放在栈底）
遇到括号时：
1. 如果是左括号“(”，则直接压入operStack，等待与其配对的右括号，因为括号中的表达式需要优先运算
2. 如果是右括号“)”，则依次弹出operStack栈顶的运算符，并压入tempStack，直到遇到左括号为止，此时将这一对括号丢弃（此时括号内的运算完成，并将结果压入了tempStack）
重复步骤2至5，直到表达式的最右边
将operStack中剩余的运算符依次弹出并压入tempStack（operStack 栈中剩下的运算都是优先级相同的运算符，按顺序执行即可）
依次弹出tempStack中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

在这里插入图片描述

6.3 代码实现

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

// 方法：将 中缀表达式转成对应的List
// s="1+((2+3)×4)-5";
public static List<String> toInfixExpressionList(String s) {
      
      
    // 定义一个List,存放中缀表达式 对应的内容
    List<String> ls = new ArrayList<String>();
    int i = 0; // 这时是一个指针，用于遍历 中缀表达式字符串
    String str; // 对多位数的拼接
    char c; // 每遍历到一个字符，就放入到c
    do {
      
      
        // 如果c是一个非数字，我需要加入到ls
        if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
      
      
            ls.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++;
            }
            ls.add(str);
        }
    } while (i < s.length());
    return ls;// 返回
}

将中缀表达式（List）转为后缀表达式（List）

如果是一个数，加入tempList
如果是 ( ，则直接入operStack（括号内的表达式优先计算）
如果是 ) ，则依次弹出 operStack 栈顶的运算符，并压入 tempList ，直到遇到左括号为止，此时将这一对括号丢弃（括号内的表达式优先计算）
否则比较当前运算符和栈顶运算符优先级
- 当前运算符优先级 > 栈顶运算符，将当前运算符压入 operStack 栈中（当前运算符优先级较高，先进行运算）
- 当前运算符优先级 <= 栈顶运算符，将 operStack 栈顶运算符取出，压入 tempList 中，再次对新的栈顶元素进行优先级判断（之前的运算符优先级较高，先进行运算）

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

    // 遍历ls
    for (String item : ls) {
      
      
        if (item.matches("\\d+")) {
      
       // 如果是一个数，加入tempList
            tempList.add(item);
        } else if (item.equals("(")) {
      
       // 如果是 ( ，则直接入operStack
            operStack.push(item);
        } else if (item.equals(")")) {
      
       // 如果是 ) ，则将括号内的值算出，并压入 tempList）
            // 如果是右括号“)”，则依次弹出operStack栈顶的运算符，并压入tempList，直到遇到左括号为止，此时将这一对括号丢弃
            while (!operStack.peek().equals("(")) {
      
      
                tempList.add(operStack.pop());
            }
            operStack.pop();// !!! 将 ( 弹出 s1栈， 消除小括号
        } else {
      
       // 否则比较当前运算符和栈顶运算符优先级
            // 当item的优先级小于等于operStack栈顶运算符,
            // 将operStack栈顶的运算符弹出并加入到tempList中，再次转到(4.1)与operStack中新的栈顶运算符相比较
            // 问题：我们缺少一个比较优先级高低的方法
            while (operStack.size() != 0 && Operation.getValue(operStack.peek()) >= Operation.getValue(item)) {
      
      
                tempList.add(operStack.pop());
            }
            // 还需要将item压入栈
            operStack.push(item);
        }
    }

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

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

}

我写的代码：

反思：

代码明显冗余，原因：对算法的理解不到位！
代码结构不整洁，else if 应当先小后大
都对比，多反思！

    // 中缀表达式转为后缀表达式_自己尝试
    public static List<String> infixToSuffix(List<String> list) {
    
    
        Stack<String> operStack = new Stack<>();
        Stack<String> tempStack = new Stack<>();
        // 结果
        List<String> res = new ArrayList<String>();
        // 对中缀表达式元素列表进行遍历
        for (String item : list) {
    
    
            if (item.matches("\\d+")) {
    
    
                // 遇到操作数直接入栈tempStack
                tempStack.push(item);
            } else if ("+".equals(item) || "-".equals(item) || "*".equals(item) || "/".equals(item) ) {
    
    
                // 遇到运算符
                boolean loop = true;
                while (loop) {
    
    
                    if (operStack.isEmpty()) {
    
    
                        // 符号栈为空
                        operStack.push(item);
                        loop = false;
                    } else {
    
    
                        // 符号栈不为空
                        if ("(".equals(operStack.peek())) {
    
    
                            // 如果栈顶为左括号，则直接入符号栈
                            operStack.push(item);
                            loop = false;
                        } else {
    
    
                            //
                            Stack<String> temp1 = new Stack<>(); // 找一个临时的栈
                            temp1 = operStack;
                            while (true) {
    
    
                                // 与不是括号的符号进行比较
                                if (!"(".equals(temp1.peek()) && !")".equals(temp1.peek())) {
    
    
                                    break;
                                }
                                temp1.pop();
                            }
                            if (getPirority(temp1.peek()) < getPirority(item)) {
    
    
                                // 错误原因：没有考虑栈顶为括号的情况
                                // 优先级比栈顶的运算符优先级高，入符号栈
                                operStack.push(item);
                                loop = false;
                            }else {
    
    
                                // 优先级低于符号栈栈顶元素，将s1栈顶弹出，入栈tempStack
                                if ( !operStack.isEmpty()) {
    
    
                                    String temp = operStack.pop();
                                    tempStack.push(temp);
                                } else {
    
    
                                    loop = false;
                                }
                            }
                        }
                    }
                }
            } else if ("(".equals(item)) {
    
    
                // 遇到括号(
                operStack.push(item);
            } else if (")".equals(item)) {
    
    
                // 遇到右括号
                if ( !operStack.isEmpty()) {
    
    
                    while ( !operStack.peek().equals("(")) {
    
    
                        tempStack.push(operStack.pop());
                    }
                    operStack.pop();
                }
            }
        }
        // 将s1中剩余的运算符依次弹出入栈s2
        while ( !operStack.isEmpty() ) {
    
    
            tempStack.push(operStack.pop());
        }
        // 依次弹出s2中的元素并输出
        while ( !tempStack.isEmpty() ) {
    
    
            res.add(tempStack.pop());
        }
        List<String> reverseList = new ArrayList<String>();
        int len = res.size();
        for (int i = 0; i < len; i++) {
    
    
            reverseList.add(res.get(len-i-1));
        }
        return reverseList;
    }

7、完整版逆波兰计算器

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();
        }
    }
}

【尚硅谷数据结构】第 5 章 栈

1、栈的基本介绍

1.1 栈的实际需求

1.2 栈的基本性质

1.3 栈的应用场景

2、数组模拟栈

2.1 代码思路

2.2、代码实现

2.3 数组模拟栈全部代码

2.4 链表模拟栈

3、栈实现综合计算器(中缀表达式)

3.1 代码思路

3.2 代码实现

3.3 综合计算器全部代码

4、前缀 中缀 后缀表达式

4.1 前缀表达式(波兰表达式)

4.1.1 前缀表达式

4.1.2 前缀表达式的计算机求值

4.2 中缀表达式

4.3、后缀表达式

4.3.1 后缀表达式

4.3.2、后缀表达式的计算机求值

5、逆波兰计算器

5.1 计算器说明

5.2、代码思路

5.3 代码实现

6、中缀表达式转后缀表达式

6.1 代码思路

6.3 代码实现

7、完整版逆波兰计算器

猜你喜欢

【尚硅谷数据结构】第 5 章栈

4、前缀中缀后缀表达式