数据结构与算法·四 —— 栈

最新推荐文章于 2022-06-08 22:08:47 发布
最新推荐文章于 2022-06-08 22:08:47 发布
阅读量1.1k 收藏
点赞数
分类专栏： 数据结构与算法 学习笔记 文章标签： 栈 数据结构 java 计算表达式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/un357951/article/details/115095647
版权

栈

栈是一个 先入后出 (FILO-First In Last Out)的 有序 列表

栈(stack)是限制线性表中元素的插入和删除，只能在线性表的同一端进行的一种特殊线性表。

允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。

根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

入栈演示图
出栈演示图

栈的应用场景

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

数组模拟栈

实现栈的思路分析：

  1. 使用数组来模拟栈
  2. 定义一个 top 来表示栈顶，初始化为 − 1 -1 −1
  3. 入栈的操作，当有数据加入到栈时， top++; 、 stack[top] = data;
  4. 出栈的操作， int value = stack[top];、top--;、return value;

数组模拟栈

代码实现
package data.structure.stack;
import java.util.Scanner;

public class ArrayStackDemo {
    public static void main(String[] args) {
        ArrayStack arrayStack = 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":
                    arrayStack.show();
                    break;
                case "push":
                    System.out.println("请输入数据： ");
                    int value = scanner.nextInt();
                    arrayStack.push(value);
                    break;
                case "pop":
                    try {
                        int res = arrayStack.pop();
                        System.out.println("栈顶元素为 ： " + 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 {
    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;
    }
    // 入栈
    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top += 1;
        stack[top] = value;
    }
    // 出栈
    public int pop() {
        if (isEmpty()) {
            // 抛出异常带有返回，不需要 return
            throw new RuntimeException("栈空");
        }
        int value = stack[top];
        top -= 1;
        return value;
    }
    // 遍历栈
    public void show() {
        // 从栈顶开始显示数据
        if (isEmpty()) {
            System.out.println("栈空");
            return;
        }
        for (int i = top; i >= 0 ; i--) {
            System.out.println("stack[" + i + "] = " + stack[i]);
        }
    }
}

栈实现综合计算器

对于一位数的运算

使用栈完成表达式的计算思路：

  1. 通过一个 index 值（索引），来遍历表达式

  2. 如果发现是一个数字, 就直接入数栈

  3. 如果发现扫描到是一个符号, 就分如下情况

    • 如果发现 当前的符号栈为空，就直接入栈
    • 如果 符号栈有操作符，就进行比较
    • 如果当前的操作符的优先级 小于或者等于 栈中的操作符， 就需要从数栈中 pop 出两个数，在从符号栈中 pop 出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈；
    • 如果当前的操作符的优先级 大于 栈中的操作符， 就直接入符号栈

  4. 当表达式扫描完毕，就顺序的从数栈和符号栈中 pop 出相应的数和符号，并运行
    （对于 - ，用后面弹出的数减去先弹出的数；/ 同理）

  5. 最后在数栈只有一个数字，就是表达式的结果

验证： 3+2*6-2 = 13

从左向右扫描表达式，遇到数字 3 、 2 、 6 3、2、6 3、2、6 和符号 + 、 ∗ +、* +、∗ 都直接入栈即可

示例1

遇到符号 − - −，需要 pop 6 、 2 、 ∗ 6、2、* 6、2、∗ 进行运算，其结果再次压入数栈，然后将符号 − - − 也压入符号栈

示例2

因为表达式扫描结束，开始逐渐 pop 数字和符号进行运算，其结果再次压入数栈，直到符号栈中没有符号

示例3
示例4

代码示例

package data.structure.stack;
public class Calculator {
    public static void main(String[] args) {
        // 使用栈计算表达式  3 + 6 * 2 - 2 =
        String expression = "9+6*2-2";
        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
        while (true) {
            ch = expression.substring(index, index + 1).charAt(0);
            if (operStack.isOper(ch)) {  // 如果是运算符
                if (!operStack.isEmpty()) {  // 如果符号栈不为空
                    if (operStack.priority(ch) <= operStack.priority(operStack.head())) {
                        // 且当前操作符优先级 ≤ 栈顶操作符
                        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 {  // 如果是数字   ASCII 码表，0=48
                numStack.push(ch - 48);
            }
            index += 1;
            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);
        }
        System.out.println("结果是 " + expression + " = " + numStack.pop());
    }
}

// 定义一个 ArrayStack2 表示栈
class ArrayStack2 {
    private int maxSize; // 栈的大小
    private int[] stack; // 数组模拟栈，数据放到数组中
    private int top = -1; // top 表示栈顶，初始化为 -1
    // 构造器
    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }
    // 栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }
    // 栈空
    public boolean isEmpty() {
        return top == -1;
    }
    // 入栈
    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top += 1;
        stack[top] = value;
    }
    // 出栈
    public int pop() {
        if (isEmpty()) {
            // 抛出异常带有返回，不需要 return
            throw new RuntimeException("栈空");
        }
        int value = stack[top];
        top -= 1;
        return value;
    }
    // 遍历栈
    public void show() {
        // 从栈顶开始显示数据
        if (isEmpty()) {
            System.out.println("栈空");
            return;
        }
        for (int i = top; i >= 0 ; i--) {
            System.out.println("stack[" + i + "] = " + stack[i]);
        }
    }
    // 获取栈顶的值，但是不出栈
    public int head() {
        return stack[top];
    }
    // 返回运算符的优先级（自己定义，使用数字表示，数字越大，优先级越高）
    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;
        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;
    }
}

对于多位数的运算

当处理多位数时，不可以发现是数就入栈
需要向后继续查看，是否是数字
需要定义一个字符串变量，用于拼接多位数

代码示例

package data.structure.stack;
public class Calculator {
    public static void main(String[] args) {
        // 使用栈计算表达式  3 + 6 * 2 - 2 =
        String expression = "90000+6000*2-200";
        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 (true) {
            ch = expression.substring(index, index + 1).charAt(0);
            if (operStack.isOper(ch)) {  // 如果是运算符
                if (!operStack.isEmpty()) {  // 如果符号栈不为空
                    if (operStack.priority(ch) <= operStack.priority(operStack.head())) {
                        // 且当前操作符优先级 ≤ 栈顶操作符
                        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);
                // 当处理多位数时，不可以发现是数就入栈
                // 需要向后继续查看，是否是数字
                // 需要定义一个字符串变量，用于拼接多位数
                keepNum += ch;
                // 判断 ch 是否是最后一位
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                } else {
                    // 判断下一位是否是数字
                    if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        numStack.push(Integer.parseInt(keepNum));
                        // 清空 keepNum
                        keepNum = "";
                    }
                }
            }
            index += 1;
            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);
        }
        System.out.println("结果是 " + expression + " = " + numStack.pop());
    }
}

// 定义一个 ArrayStack2 表示栈
class ArrayStack2 {
    private int maxSize; // 栈的大小
    private int[] stack; // 数组模拟栈，数据放到数组中
    private int top = -1; // top 表示栈顶，初始化为 -1
    // 构造器
    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }
    // 栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }
    // 栈空
    public boolean isEmpty() {
        return top == -1;
    }
    // 入栈
    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top += 1;
        stack[top] = value;
    }
    // 出栈
    public int pop() {
        if (isEmpty()) {
            // 抛出异常带有返回，不需要 return
            throw new RuntimeException("栈空");
        }
        int value = stack[top];
        top -= 1;
        return value;
    }
    // 遍历栈
    public void show() {
        // 从栈顶开始显示数据
        if (isEmpty()) {
            System.out.println("栈空");
            return;
        }
        for (int i = top; i >= 0 ; i--) {
            System.out.println("stack[" + i + "] = " + stack[i]);
        }
    }
    // 获取栈顶的值，但是不出栈
    public int head() {
        return stack[top];
    }
    // 返回运算符的优先级（自己定义，使用数字表示，数字越大，优先级越高）
    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;
        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 + 4 ) × 5 − 6 (3+4)×5-6 (3+4)×5−6 对应的前缀表达式就是 - × + 3 4 5 6

前缀表达式的计算机求值

从 右至左扫描表达式，

遇到数字时，将数字压入堆栈；

遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和 次顶元素），并将结果入栈；

重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果

例如: ( 3 + 4 ) × 5 − 6 (3+4)×5-6 (3+4)×5−6 对应的前缀表达式就是 - × + 3 4 5 6 , 针对前缀表达式求值步骤如下:

  1. 从右至左扫描，将 6 、 5 、 4 、 3 6、5、4、3 6、5、4、3 压入堆栈
  2. 遇到 + 运算符，因此弹出 3 3 3 和 4 4 4（ 3 3 3 为栈顶元素， 4 4 4 为次顶元素），计算出 3 + 4 3+4 3+4 的值，得 7 7 7 ，再将 7 7 7 入栈
  3. 接下来是 × × × 运算符，因此弹出 7 7 7 和 5 5 5，计算出 7 × 5 = 35 7×5=35 7×5=35，将 35 35 35 入栈
  4. 最后是 − - − 运算符，计算出 35 − 6 35-6 35−6 的值，即 29 29 29，由此得出最终结果

中缀表达式

中缀表达式就是常见的运算表达式，如 ( 3 + 4 ) × 5 − 6 (3+4)×5-6 (3+4)×5−6

中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作

因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式.)

后缀表达式

后缀表达式又称逆波兰表达式，与前缀表达式相似，只是运算符位于操作数之后

中举例说明： ( 3 + 4 ) × 5 − 6 (3+4)×5-6 (3+4)×5−6 对应的后缀表达式就是 3 4 + 5 × 6 –

再比如:

逆波兰表达式

后缀表达式的计算机求值

从 左至右扫描表达式，

遇到数字时，将数字压入堆栈，

遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 和 栈顶元素），并将结果入栈；

重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果

例如: ( 3 + 4 ) × 5 − 6 (3+4)×5-6 (3+4)×5−6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:

  1. 从左至右扫描，将 3 3 3 和 4 4 4 压入堆栈；
  2. 遇到 + + + 运算符，因此弹出 4 4 4 和 3 3 3（ 4 4 4 为栈顶元素， 3 3 3 为次顶元素），计算出 3 + 4 3+4 3+4 的值，得 7 7 7，再将 7 7 7 入栈；
  3. 将 5 5 5 入栈；
  4. 接下来是 × × × 运算符，因此弹出 5 5 5 和 7 7 7，计算出 7 × 5 = 35 7×5=35 7×5=35，将 35 35 35 入栈；
  5. 将 6 6 6 入栈；
  6. 最后是 − - − 运算符，计算出 35 − 6 35-6 35−6 的值，即 29 29 29，由此得出最终结果

逆波兰计算器

输入一个逆波兰表达式（后缀表达式），使用栈（stack），计算其结果；要求支持小括号和多位数整数

代码示例
package data.structure.stack;
import java.util.*;
public class PolandNotation {
    public static void main(String[] args) {
        // 定义逆波兰表达式 (30+4)*5-6 => 30 4 + 5 * 6 -
        // 使用空格把数字和符号隔开（可以不分割）
        String suffixExpression = "30 4 + 5 * 6 -";
        // 将 “3 4 + 5 * 6 -" 放到 ArrayList 中
        // 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈，完成计算
        List<String> rpnList = getListString(suffixExpression);
        int res = calculate(rpnList);
        System.out.println("计算结果是 = " + res);
    }

    public static List<String> getListString(String suffixExpression) {
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<String>();
        for (String ele: split) {
            list.add(ele);
        }
        return list;
    }

    public static int calculate(List<String> ls) {
        // 创建栈
        Deque<String> stack = new ArrayDeque<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 (item.equals("+")) {
                    res = num1 + num2;
                } else if (item.equals("-")) {
                    res = num2 - num1;
                } else if (item.equals("*")) {
                    res = num1 * num2;
                } else if (item.equals("/")) {
                    res = num1 / num2;
                } else {
                    throw new RuntimeException("运算符有误");
                }
                stack.push(res + "");
            }
        }
        // stack 中最后的数据就是运算结果
        return Integer.parseInt(stack.pop());
    }
}

中缀表达式转后缀表达式

后缀表达式适合计算式进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，需要将 中缀表达式转成后缀表达式。

具体步骤如下：

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

示例：
中缀表达式： 1 + ( ( 2 + 3 ) × 4 ) − 5 1 + ( ( 2 + 3 )× 4) - 5 1+((2+3)×4)−5
后缀表达式：1 2 3 + 4 * + 5 -

中缀转后缀

中缀转后缀表

代码示例
package data.structure.stack;
import org.w3c.dom.ls.LSInput;
import java.util.*;
import java.util.spi.AbstractResourceBundleProvider;
public class PolandNotation {
    public static void main(String[] args) {
        // 完成将一个中缀表达式转成后缀表达式的功能
        // 1+((2+3)*4)-5 => 1 2 3 + 4 * + 5 -
        String expression = "1+((2+3)*4)-5";
        List<String> ListString = toInfixExpressionList(expression);
        System.out.println(ListString);
        List<String> ListString2 = parseSuffixExpressionList(ListString);
        System.out.println(ListString2);
        int result = calculate(ListString2);
        System.out.println(result);

        // 定义逆波兰表达式 (30+4)*5-6 => 30 4 + 5 * 6 -
        // 使用空格把数字和符号隔开（可以不分割）
        String suffixExpression = "30 4 + 5 * 6 -";
        // 将 “3 4 + 5 * 6 -" 放到 ArrayList 中
        // 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈，完成计算
        List<String> rpnList = getListString(suffixExpression);
        int res = calculate(rpnList);
        System.out.println("计算结果是 = " + res);
    }

    // 将中缀表达式转成对应的 list
    public static List<String> toInfixExpressionList(String s) {
        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 += 1;
            } else {  // 如果是一个数，则需要考虑是否是一个多位数
                str = "";
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                    str += c;
                    i += 1;
                }
                ls.add(str);
            }
        } while (i < s.length());
        return ls;
    }

    // 将中缀表达式的 list 转成 后缀表达式的 list
    public static List<String> parseSuffixExpressionList(List<String> ls) {
        // 定义一个符号栈
        Deque<String> s1 = new ArrayDeque<String>();
        // s2 在实际中，并不需要pop数据，并且需要逆序输出，所以可以用 list 代替
        List<String> s2 = new ArrayList<String>();
        // 遍历 ls
        for (String item: ls) {
            // 如果是一个数，加入 s2
            if (item.matches("\\d+")) { // 匹配多位数
                s2.add(item);
            } else if (item.equals("(")) {
                // 如果是 左括号（ ，直接压入 s1
                s1.push(item);
            } else if (item.equals(")")) {
                // 如果是 右括号 ），依次弹出 s1 栈顶的运算符，并压入 s2，
                // 直到遇到 左括号（，将这一对 （）丢弃
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();  // 将 左括号（ 弹出，消除小括号
            } else {  // 对于 item 是运算符的情况
                // 当 item 优先级 ≤ s1 栈顶运算符，弹出 s1 栈顶运算符，并加入到 s2
                // 再次与 s1 中新的栈顶运算符比较
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                // item 入栈
                s1.push(item);
            }
        }
        // 将 s1 中剩余的运算符加入 s2
        while (s1.size() != 0) {
            s2.add(s1.pop());
        }
        // 因为 s2 是 list，所以不需要逆序输出就是后缀表达式
        return s2;
    }

    // 分割后缀表达式，从 String 到 List<String>
    public static List<String> getListString(String suffixExpression) {
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<String>();
        for (String ele: split) {
            list.add(ele);
        }
        return list;
    }

    // 计算后缀表达式
    public static int calculate(List<String> ls) {
        // 创建栈
        Deque<String> stack = new ArrayDeque<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 (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 {
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;
    public static int getValue(String operation) {
        int result = 0;
        switch (operation) {
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("不存在该运算符");
                break;
        }
        return result;
    }
}

其他代码

中缀转后缀代码2

package com.atguigu.reversepolishcal;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class ReversePolishCalCase {
public static void main(String[] args) {
//举例1: 2 + (3-4) => 2 3 4 - +
 //举例2: 4 * 5 - 8 + 60 + 8 / 2 = 4 5 * 8 - 60 + 8 2 / + 
 //举例3: (3+4)×5-6 => 3 4 + 5 * 6 -
//String suffixExperss = "4 5 * 8 - 60 + 8 2 / +";
//String suffixExperss = "2 3 4 - +";
//String suffixExperss = "3 4 + 5 * 6 -";
//
ReversePolishCal reversePolishCal = new ReversePolishCal();
//
//List <String> suffixExpressionList = reversePolishCal.getListBySuffixExpression(suffixExperss);
//
//        System.out.println("计算结果:"+ reversePolishCal.calculate(suffixExpressionList));
        
        //测试输入中缀表达式是否能计算成功
        String infixExpression = "4*5-8+60+8/2";
        List<String> infixExpressionList = reversePolishCal.toInfixExpression(infixExpression);
        List<String> suffixExpressionList2 = reversePolishCal.parseSuffixExpression(infixExpressionList);
        //输出后缀表达式
        for(String ele : suffixExpressionList2) {
        System.out.print(ele + " ");
        }
        System.out.println();
        //输出结果
        System.out.println("计算结果:"+ reversePolishCal.calculate(suffixExpressionList2));  
}
}
class ReversePolishCal {

/**
     * 把字符串转换成中序表达式 : 比如 2+(3-4), 并放入到 List 中
     * @param s
     * @return
     */
    public List<String> toInfixExpression(String infixExpression) {
        List<String> ls = new ArrayList<String>();//存储中序表达式
        int i = 0;
        String str;
        char c;
        do {
        //如果c 在 < 48 或者 > 57 说明是符号, 这里没有判断是 + , - , * , / 等等
            if ((c = infixExpression.charAt(i)) < 48 || (c = infixExpression.charAt(i)) > 57) {
                ls.add("" + c);
                i++;
            } else { // 说明是数字，要进行拼接处理
                str = "";
                while (i < infixExpression.length() && (c = infixExpression.charAt(i)) >= 48
                        && (c = infixExpression.charAt(i)) <= 57) {
                    str += c;
                    i++;
                }
                ls.add(str);
            }

        } while (i < infixExpression.length());
        return ls;
    }
    
    /**
     * 将一个中缀表达式对应的 List 转成 转换成逆波兰表达式, 放入到 List 中
     * @param ls
     * @return
     */
    public  List<String> parseSuffixExpression(List<String> ls) {
        Stack<String> s1=new Stack<String>();
        Stack<String> s2=new Stack<String>();
        List<String> lss = new ArrayList<String>();
        for (String ss : ls) {
            if (ss.matches("\\d+")) {
                lss.add(ss);
            } else if (ss.equals("(")) {
                s1.push(ss);
            } else if (ss.equals(")")) {

                while (!s1.peek().equals("(")) {
                    lss.add(s1.pop());
                }
                s1.pop();
            } else {
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(ss)) {
                    lss.add(s1.pop());
                }
                s1.push(ss);
            }
        }
        while (s1.size() != 0) {
            lss.add(s1.pop());
        }
        return lss;
    }

//将一个后缀表达式，依次放入到 List<String> 中
public List<String> getListBySuffixExpression(String suffixExpression) {
String[] split = suffixExpression.split(" ");
List<String> list = new ArrayList<String>();
for (String element : split) {
list.add(element);
}
return list;
}

/**
 * @param ls 是一个按照逆波兰表达式得到 List 
 * @return
 */
    public int calculate(List<String> ls) {
    Stack<String> s=new Stack<String>();
        for (String str : ls) {
            if (str.matches("\\d+")) {
                s.push(str);
            } else {
                int b = Integer.parseInt(s.pop());
                int a = Integer.parseInt(s.pop());
                int result=0;
                if (str.equals("+")) {
                    result = a + b;
                } else if (str.equals("-")) {
                    result = a - b;
                } else if (str.equals("*")) {
                    result = a * b;
                } else if (str.equals("/")) {
                    result = a / b;
                } else {
                throw new RuntimeException("符号错误");
                }
                s.push("" + result);
            }
        }
        //System.out.println(s.peek()); 
        return Integer.parseInt(s.pop());
    }
}

class Operation {
    private static int ADDITION=1;
    private static int SUBTRACTION=1;
    private static int MULTIPLICATION=2;
    private static int DIVISION=2;

    public static int getValue(String operation){
        int result;
        switch (operation){
            case "+":
                result=ADDITION;
                break;
            case "-":
                result=SUBTRACTION;
                break;
            case "*":
                result=MULTIPLICATION;
                break;
            case "/":
                result=DIVISION;
                break;
            default:
//                System.out.println("不存在该运算符");
                result=0;
        }
        return result;
    }
}

逆波兰计算器增强版

完整版的逆波兰计算器，功能包括
支持 + - * / ( )
多位数，支持小数,
兼容处理, 过滤任何空白字符，包括空格、制表符、换页符

package com.atguigu.reversepolishcal;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;
import java.util.regex.Pattern;

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();
        }
    }
}
timedecdec
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
选修课程复习（ICPC）
m0_46182401的博客
06-17 264
选修课重难点 (个人观点) 1.快排（递归思想） void quickSort(int *array, int left, int right) { if(left < right) { int pivot = array[left]; int low = left, high = right; while(low < high) { while(array[high] >= pivot && low < high) high--;
Day12刷题笔记之数组最后一个元素加一
Niracity的博客
01-19 143
数组最后一个元素加一
顺序栈的操作1
weixin_52634719的博客
09-23 686
定义一个结构类型，叫做顺序栈SqStack; 这里需要两个指向元素的指针，栈底指针base,栈顶指针top,还需要一个stacksize，表示数组的大小 这里top指向最后一个元素之后， 这里top和base我们可以把他们定义为整型，用来存放数组的下标 （这种方式就是用下标来引用数组中的元素） 两个指针也可以这样相减，他的结果是两个指针差几个元素，所以得到的是元素个数，但必须是指向同一数组的，比如有一个数组，有一个指针p指向下标为0的元素，p+1就是将p移动一个元素，这个元素占...
栈——栈的定义及基本操作（初始化、判空、进栈、出栈、遍历栈、销毁栈等）
热门推荐
薛定谔的猫的博客
04-19 7万+
文章目录栈的定义栈的存储栈上的基本操作初始化判空操作进栈操作出栈操作读栈顶元素遍历栈销毁栈完整代码及实例共享栈 栈的定义 栈（Stack）是只允许在一端进行插入或删除操作的线性表。 栈的示意图： 栈顶Top：线性表允许插入和删除的那一端。 栈底Bottom：固定的，不允许进行插入和删除的另一端。  假设某个栈S={a1,a2, … ,an}，如上图所示，则a1为栈底元素，an为栈顶元素。由于只能在栈顶进行插入和删除操作，故进栈顺序为a1,a2, … ,an，出栈顺序为an, … ,a2,a1。故栈的操
【三】栈
weixin_41449756的博客
06-20 344
一、栈的介绍 1、介绍 栈的英文为(stack) 栈是一个先入后出(FILO-First In Last Out)的有序列表 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端,为变化的一端,称为栈顶(Top),另一端为固定的一端,称为栈底(Bottom) 根据栈的定义可知,最先放入栈中元素在栈底,最后放入的元素在栈顶,而删除元素刚好相反,最后放入的元素最先删除,最先放入的元素最后删除 图解方式说明出栈(pop)和入栈(push)的概念
数据结构与算法上机试验——栈实现十进制转换二进制（C语言）
11-23
适用于计算机类专业学生，试验报告
《数据结构与算法分析——C语言描述》随书练习.zip
最新发布
12-27
常见的数据结构有数组、链表、栈、队列、树、图等。 算法则是解决特定问题的步骤，是对数据运算和操作的详细描述。算法的设计和选择会直接影响到程序的效率，因此，在设计和选择算法时，需要考虑到时间复杂度、空间...
算法和数据结构——栈.pdf
08-07
#资源达人分享计划#
数据结构与算法 Python语言描述 ——裘宗燕版
07-05
数据结构与算法 Python语言描述-裘宗燕 高清带目录 详细讲述线性表 、字符串、栈和队列、二叉树和树、图、字典和集合、排序等
数据结构与算法分析Java3rd英文_数据结构与算法分析_
10-03
数据分析与算法分析，书的内容包括表、栈、队列、树、散列表、优先队列、排序、不相交集算法、图论算法、算法分析、算法设计、摊还分析、查找树算法、k-d树和配对堆等。
ReversePolishMultiCalc.java
05-30
分享一个java简单实现的逆波兰式计算器，满足小数情况（逆波兰式（Reverse Polish notation，RPN，或逆波兰记法），也叫后缀表达式（将运算符写在操作数之后））
数据结构遍历顺序栈_数据结构与算法（五）--- 栈
weixin_29279153的博客
02-12 896
栈栈(stack)又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。遵循先进后出原则栈.png顺序存储栈物理结构是顺序存储，先开辟一块内存空间，每...
【数据结构--栈的应用--计算多项式】
qq_61719813的博客
05-11 799
文章目录表达式求值总体思路代码实现 表达式求值 总体思路 自左至右扫描表达式，若遇到操作数则压入操作数栈；遇到运算符，则需要比较其与运算符栈栈顶元素的优先级，若其优先级高于栈顶元素优先级则进栈，反之则取出栈顶运算符和操作数栈栈顶的连续两个操作数进行运算，并将结果存入操作数栈，然后继续比较该运算符与栈顶运算符的优先级。左括号压入运算符栈，右括号不压入运算符栈，取出运算符栈栈顶运算符和操作数栈栈顶的两个操作数进行运算，并将结果压入操作数栈，直到弹出左括号为止。 代码实现 初始化 此处需创建两个栈，一个栈用于存放
[04数据结构]栈和队列的基本理解、操作和笔试题
再吃一个橘子
11-14 769
栈使用顺序结构（数组栈）；而队列使用链式结构（链式队列）
顺序栈的基本操作（超详细）
m0_53679998的博客
06-08 3万+
本文是在b站上学完王卓老师之后写的，各种操作我都觉得都十分的详细。如果代码或者描述有不对的地方，欢迎大家指正。
【数据结构】C语言最基础练习：栈的初始化，压栈，出栈，遍历，清空
baidu_39334407的博客
10-27 5192
随手练习一下，详细代码解释都在代码片里请仔细看看 如果有什么不对的地方，请在下方留言 先建立头文件： #define _CRT_SECURE_NO_WARNINGS 1 #ifndef _TEST_H #define _TEST_H //栈的链式存储结构； typedef struct Node //创建一种类型的节点； { int data; struct Node * pnext; }N...
数据结构遍历顺序栈_数据结构和算法-栈结构
weixin_35660371的博客
02-12 2429
栈的定义栈是一种后进先出的数据结构。栈是限制插入和删除只能在一个位置上的线性表。允许删除和插入的一端位于表的末端，叫做栈顶。不允许删除和插入的另一端叫做栈底。对栈的基本操作有push(压栈)和pop(出栈)。图示：栈的实现栈的实现主要包括两种方式：顺序栈和链表栈。顺序栈使用数组来实现。缺点：需要提前声明一个数组大小。如果数组不够大，就有可能发生越界问题。如果数组过大，则可能浪费一定的空间。栈的定义...
栈的出栈、入栈、遍历、清空操作
九月鹰飞
08-08 1555
#include #include typedef struct node { int data; struct node *next; }Node ,*PNode; typedef struct stack { PNode pTop; PNode pBot; }Stack, *PStack; void init(PStack pS) { pS->pTop = pS->pBot
《数据结构与算法——c++版》
08-11
《数据结构与算法——c 版》是一本介绍数据结构和算法的学习教材。这本书以C语言为主要编程语言，全面讲解了数据结构和算法的基本概念及其常见的应用。通过学习本书，读者可以掌握C语言中常用的数据结构和算法，提高...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值