什么是栈？Java如何通过栈实现综合计算器？

转x33g5p2x  于2022-04-18 转载在 Java  
字(10.9k)|赞(0)|评价(0)|浏览(441)

栈的介绍

栈（stack） 是一个先入后出的有序列表。栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，成为栈顶（Top），另一端为固定的一端，成为栈底（Botton）。根据栈的定义可知，先放入栈中的元素在栈底。最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。

栈的应用场景

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

栈的快速入门

用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来存储栈的数据内容，下面我们就用数据模拟栈的出栈，入栈等操作。

实现栈的思路分析

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

代码实现

  1. 创建ArrayStackDomo练习类

  1. 定义一个ArrayStack表示栈
  1. class ArrayStack{
  2.         private int maxSize;  //栈的大小
  3.         private int[] stack;  //数组，数组模拟栈，数据就放在该数组
  4.         private int top = -1; //top表示栈顶，初始化为-1表示没有数据
  5. 	}
  1. 编写构造器
  1. public ArrayStack(int maxSize){
  2.         this.maxSize =maxSize;
  3.         stack = new int[this.maxSize];
  4. 	}
  1. 判断栈满
  1. public boolean isFull(){
  2.        return top == maxSize - 1; //栈顶等于栈的大小的时候表示栈满
  3.     }
  1. 判断栈空
  1. public boolean isEmpty(){
  2.       return top == -1;
  3.   }
  1. 编写入栈方法 push
  1. public void push(int value){
  2.             //判断栈是否满
  3.             if (isFull()){
  4.                 System.out.println("栈满");
  5.                 return;
  6.             }
  7.             top++;
  8.             stack[top] = value;
  9.         }
  1. 编写出栈方法pop，将栈顶数据返回
  1. public int pop(){
  2.             //先判断栈是否空
  3.             if (isEmpty()){
  4.                 //抛出异常
  5.                 throw new RuntimeException("栈空,没有数据~");
  6.             }
  7.             int value = stack[top];
  8.             top--;
  9.             return value;
  10.         }
  1. 编写显示栈的情况[遍历栈]，便利时，需要从栈顶开始显示数据。
  1. public void list(){
  2.             if (isEmpty()){
  3.                 System.out.println("栈空，没有数据~~");
  4.                 return;
  5.             }
  7.             for(int i = top; i >= 0; i--){
  8.                 System.out.printf("stack[%d]=%d\n",i,stack[i]);
  9.             }
  10.         }

测试

  1. public static void main(String[] args) {
  2.         //测试一下ArrayStack是否正确
  3.         //先创建一个ArrayStack对象->表示栈
  4.         ArrayStack stack = new ArrayStack(4);
  5.         String key ="";
  6.         boolean loop =true;//控制是否退出菜单
  7.         Scanner scanner =new Scanner(System.in);
  9.         while (loop){
  10.             System.out.println("show：表示显示栈");
  11.             System.out.println("exit：退出程序");
  12.             System.out.println("push：表示添加数据到栈(入栈)");
  13.             System.out.println("pop：表示从栈取出数据(出栈)");
  14.             System.out.print("请输入你的选择：");
  15.             key=scanner.next();
  16.             switch (key){
  17.                 case "show":
  18.                     stack.list();
  19.                     break;
  20.                 case "exit":
  21.                     scanner.close();
  22.                     loop=false;
  23.                     break;
  24.                 case "push":
  25.                     System.out.print("请输入一个数：");
  26.                     int value = scanner.nextInt();
  27.                     stack.push(value);
  28.                     break;
  29.                 case "pop":
  30.                     try {
  31.                         int res = stack.pop();
  32.                         System.out.printf("出栈的数据是%d\n",res);
  33.                     }catch (Exception e){
  34.                         System.out.println(e.getMessage());
  35.                     }
  36.                     break;
  37.                 default:
  38.                     break;
  39.             }
  40.             System.out.println("---------------------------------");
  41.         }
  42.         System.out.println("程序已退出");
  43.     }
  1. 测试入栈

  1. 测试显示栈

  1. 测试出栈

完整代码

  1. import java.util.Scanner;
  3. /**
  4.  * @author mengzhichao
  5.  * @create 2022-04-15-16:28
  6.  */
  7. public class ArrayStackDemo {
  9.     public static void main(String[] args) {
  10.         //测试一下ArrayStack是否正确
  11.         //先创建一个ArrayStack对象->表示栈
  12.         ArrayStack stack = new ArrayStack(4);
  13.         String key ="";
  14.         boolean loop =true;//控制是否退出菜单
  15.         Scanner scanner =new Scanner(System.in);
  17.         while (loop){
  18.             System.out.println("show：表示显示栈");
  19.             System.out.println("exit：退出程序");
  20.             System.out.println("push：表示添加数据到栈(入栈)");
  21.             System.out.println("pop：表示从栈取出数据(出栈)");
  22.             System.out.print("请输入你的选择：");
  23.             key=scanner.next();
  24.             switch (key){
  25.                 case "show":
  26.                     stack.list();
  27.                     break;
  28.                 case "exit":
  29.                     scanner.close();
  30.                     loop=false;
  31.                     break;
  32.                 case "push":
  33.                     System.out.print("请输入一个数：");
  34.                     int value = scanner.nextInt();
  35.                     stack.push(value);
  36.                     break;
  37.                 case "pop":
  38.                     try {
  39.                         int res = stack.pop();
  40.                         System.out.printf("出栈的数据是%d\n",res);
  41.                     }catch (Exception e){
  42.                         System.out.println(e.getMessage());
  43.                     }
  44.                     break;
  45.                 default:
  46.                     break;
  47.             }
  48.             System.out.println("---------------------------------");
  49.         }
  50.         System.out.println("程序已退出");
  51.     }
  52. }
  54.     //定义一个 ArrayStack 表示栈
  55.     class ArrayStack{
  56.         private int maxSize;  //栈的大小
  57.         private int[] stack;  //数组，数组模拟栈，数据就放在该数组
  58.         private int top = -1; //top表示栈顶，初始化为-1表示没有数据
  60.         //构造器
  61.         public ArrayStack(int maxSize){
  62.             this.maxSize =maxSize;
  63.             stack = new int[this.maxSize];
  64.         }
  66.         //栈满
  67.         public boolean isFull(){
  68.             return top == maxSize - 1; //栈顶等于栈的大小的时候表示栈满
  69.         }
  71.         //栈空
  72.         public boolean isEmpty(){
  73.             return top == -1;
  74.         }
  76.         //入栈-push
  77.         public void push(int value){
  78.             //判断栈是否满
  79.             if (isFull()){
  80.                 System.out.println("栈满");
  81.                 return;
  82.             }
  83.             top++;
  84.             stack[top] = value;
  85.         }
  87.         //出栈-pop，将栈顶的数据返回
  88.         public int pop(){
  89.             //先判断栈是否空
  90.             if (isEmpty()){
  91.                 //抛出异常
  92.                 throw new RuntimeException("栈空,没有数据~");
  93.             }
  94.             int value = stack[top];
  95.             top--;
  96.             return value;
  97.         }
  99.         //显示栈的情况[便利栈]，遍历时，需要从栈顶开始显示数据
  100.         public void list(){
  101.             if (isEmpty()){
  102.                 System.out.println("栈空，没有数据~~");
  103.                 return;
  104.             }
  106.             for(int i = top; i >= 0; i--){
  107.                 System.out.printf("stack[%d]=%d\n",i,stack[i]);
  108.             }
  109.         }
  111.     }

栈的一个实际需求

假如我们输入一串表达式字符串。计算机底层是如何运算得到结果的？如果用栈实现呢？

7 + 2 ∗ 6 − 4 7+2*6-47+2∗6−4

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

  1. 通过一个 index 值（索引），来遍历我们的表达式
  2. 如果我们发现是一个数字，就直接入栈
  3. 如果我们发现扫描到的是一个符号，就分如下情况，如果发现当前的符号栈为空，就直接入栈，如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数，在从符号栈中pop出一个符号，进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈，如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈。
  4. 当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并进行运算。
  5. 最后在数栈只有一个数字，就是表达式的结果。

完整代码实现

  1. /**
  2.  * @author mengzhichao
  3.  * @create 2022-04-16-11:12
  4.  */
  5. public class Calculator {
  6.     public static void main(String[] args) {
  7.         //定义一个表达式
  8.         String expression = "7+2*6-4";
  9.         //创建两个栈，一个数栈，一个符号栈
  10.         CalculatorArrayStack numStack = new CalculatorArrayStack(100);
  11.         CalculatorArrayStack operStack = new CalculatorArrayStack(100);
  12.         int index = 0; //用于扫描
  13.         int num1 = 0;
  14.         int num2 = 0;
  15.         int oper = 0;
  16.         int res = 0;
  17.         char ch =' '; //将每次扫描得到的char保存在ch中
  18.         //开始while循环的扫描 expression
  19.         while (true){
  20.             //一次得到 experssion 的每一个字符
  21.             ch = expression.substring(index,index+1).charAt(0);
  22.             //判断ch是什么，然后做相应的处理
  23.             if (operStack.isOper(ch)){ //如果是运算符
  24.                 //判断当前的符号栈是否为空
  25.                 if (!operStack.isEmpty()){
  26.                     //如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，
  27.                     //就需要从数栈中pop出两个数，在从符号栈中pop出一个符号，
  28.                     //进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈
  29.                     if (operStack.priority(ch) <= operStack.priority(operStack.peek())){
  30.                         num1 = numStack.pop();
  31.                         num2 = numStack.pop();
  32.                         oper = operStack.pop();
  33.                         res = numStack.cal(num1,num2,oper);
  34.                         //把运算的结果入数栈
  35.                         numStack.push(res);
  36.                         //然后将当前的操作符入符号栈
  37.                         operStack.push(ch);
  38.                     }else {
  39.                         //如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
  40.                         operStack.push(ch);
  41.                     }
  42.                 }else {
  43.                     //如果为空直接入符号栈...
  44.                     operStack.push(ch); // 7 * 2
  45.                 }
  47.             }else {
  48.                 numStack.push(ch - 48);
  49.             }
  50.             //让index + 1，并判断是否扫描到expression最后
  51.             index++;
  52.             if (index >= expression.length()){
  53.                 break;
  54.             }
  55.         }
  56.         //当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并进行运算。
  57.         while (true){
  58.             //如果符号栈为空，则计算到最后的结果，数栈中只有一个数字【结果】
  59.             if (operStack.isEmpty()){
  60.                 break;
  61.             }
  62.             num1 = numStack.pop();
  63.             num2 = numStack.pop();
  64.             oper = operStack.pop();
  65.             res = numStack.cal(num1,num2,oper);
  66.             numStack.push(res);
  67.         }
  68.         //将数栈的最后数，pop出，就是结果
  69.         int res2 = numStack.pop();
  70.         System.out.printf("表达式%s = %d",expression,res2);
  71.     }
  72. }
  74. //先创建一个栈
  75. class CalculatorArrayStack{
  76.     private int maxSize;  //栈的大小
  77.     private int[] stack;  //数组，数组模拟栈，数据就放在该数组
  78.     private int top = -1; //top表示栈顶，初始化为-1表示没有数据
  80.     //构造器
  81.     public CalculatorArrayStack(int maxSize){
  82.         this.maxSize =maxSize;
  83.         stack = new int[this.maxSize];
  84.     }
  86.     //栈满
  87.     public boolean isFull(){
  88.         return top == maxSize - 1; //栈顶等于栈的大小的时候表示栈满
  89.     }
  91.     //栈空
  92.     public boolean isEmpty(){
  93.         return top == -1;
  94.     }
  96.     //入栈-push
  97.     public void push(int value){
  98.         //判断栈是否满
  99.         if (isFull()){
  100.             System.out.println("栈满");
  101.             return;
  102.         }
  103.         top++;
  104.         stack[top] = value;
  105.     }
  107.     //返回栈顶的值，不做任何修改
  108.     public int peek(){
  109.         return stack[top];
  110.     }
  112.     //出栈-pop，将栈顶的数据返回
  113.     public int pop(){
  114.         //先判断栈是否空
  115.         if (isEmpty()){
  116.             //抛出异常
  117.             throw new RuntimeException("栈空,没有数据~");
  118.         }
  119.         int value = stack[top];
  120.         top--;
  121.         return value;
  122.     }
  124.     //显示栈的情况[便利栈]，遍历时，需要从栈顶开始显示数据
  125.     public void list(){
  126.         if (isEmpty()){
  127.             System.out.println("栈空，没有数据~~");
  128.             return;
  129.         }
  131.         for(int i = top; i >= 0; i--){
  132.             System.out.printf("stack[%d]=%d\n",i,stack[i]);
  133.         }
  134.     }
  136.     //返回运算符的优先级，优先级是程序员来确定，优先级使用数字表示
  137.     //数字越大，则优先级越高
  138.     public int priority(int oper){
  140.         if (oper == '*' || oper == '/'){
  141.             return 1;
  142.         }else if (oper == '+' || oper == '-'){
  143.             return 0;
  144.         } else {
  145.             return -1; //假定目前的表达式只有+，-，*，/
  146.         }
  147.     }
  149.     //判断是不是一个运算符
  150.     public boolean isOper(char val){
  151.         return val == '+' || val == '-' || val == '*' || val == '/';
  152.     }
  154.     //计算方法
  155.     public int cal(int num1,int num2,int oper){
  156.         int res = 0; //res 用于存放计算的结果
  157.         switch (oper){
  158.             case '+':
  159.                 res = num1 + num2;
  160.                 break;
  161.             case '-':
  162.                 res = num2 - num1; //注意顺序
  163.                 break;
  164.             case '*':
  165.                 res = num1 * num2;
  166.                 break;
  167.             case '/':
  168.                 res = num2 / num1;
  169.                 break;
  170.             default:
  171.                 break;
  172.         }
  173.         return res; //结果返回
  174.     }
  175. }

运行并测试

经过测试我们发现通过程序计算出来的结果和我们算出来的结果是一致的，但是不知道大家有没有发现一个问题当我们把表达式中的 7 改为 70 后我们的计算结果就会出现一些问题。

那要怎么解决这个问题呢？我们接着往下看！

功能优化思路分析以及代码完善

  1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
  2. 在处理数，需要向expression的表达式的index 后再看一位，如果是数就进行扫描，如果是符号才入栈
  3. 因此我们需要定义一个变量 字符串，用于拼接
  1. /**
  2.  * @author mengzhichao
  3.  * @create 2022-04-16-11:12
  4.  */
  5. public class Calculator {
  6.     public static void main(String[] args) {
  7.         //定义一个表达式
  8.         String expression = "7*2*2-5+1-5+3-4";
  9.         //创建两个栈，一个数栈，一个符号栈
  10.         CalculatorArrayStack numStack = new CalculatorArrayStack(100);
  11.         CalculatorArrayStack operStack = new CalculatorArrayStack(100);
  12.         int index = 0; //用于扫描
  13.         int num1 = 0;
  14.         int num2 = 0;
  15.         int oper = 0;
  16.         int res = 0;
  17.         char ch =' '; //将每次扫描得到的char保存在ch中
  18.         String keepNum = ""; //用于拼接多位数
  19.         //开始while循环的扫描 expression
  20.         while (true){
  21.             //一次得到 experssion 的每一个字符
  22.             ch = expression.substring(index,index+1).charAt(0);
  23.             //判断ch是什么，然后做相应的处理
  24.             if (operStack.isOper(ch)){ //如果是运算符
  25.                 //判断当前的符号栈是否为空
  26.                 if (!operStack.isEmpty()){
  27.                     //如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，
  28.                     //就需要从数栈中pop出两个数，在从符号栈中pop出一个符号，
  29.                     //进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈
  30.                     if (operStack.priority(ch) <= operStack.priority(operStack.peek())){
  31.                         num1 = numStack.pop();
  32.                         num2 = numStack.pop();
  33.                         oper = operStack.pop();
  34.                         res = numStack.cal(num1,num2,oper);
  35.                         //把运算的结果入数栈
  36.                         numStack.push(res);
  37.                         //然后将当前的操作符入符号栈
  38.                         operStack.push(ch);
  39.                     }else {
  40.                         //如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
  41.                         operStack.push(ch);
  42.                     }
  43.                 }else {
  44.                     //如果为空直接入符号栈...
  45.                     operStack.push(ch); // 7 * 2
  46.                 }
  48.             }else {
  49. //                numStack.push(ch - 48);
  50.                 //分析思路
  51.                 //1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
  52.                 //2. 在处理数，需要向expression的表达式的index 后再看一位，如果是数就进行扫描，如果是符号才入栈
  53.                 //3. 因此我们需要定义一个变量 字符串，用于拼接
  55.                 //处理多位数
  56.                 keepNum += ch;
  58.                 //如果ch已经是expression的最后一位，就直接入栈。
  59.                 if (index == expression.length() - 1){
  60.                     numStack.push(Integer.parseInt(keepNum));
  61.                 }else {
  63.                     //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
  64.                     //注意是看后一位，不是index++
  65.                     if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
  66.                         //如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
  67.                         numStack.push(Integer.parseInt(keepNum));
  68.                         //重要的！！！！！！，keepNum清空
  69.                         keepNum = "";
  70.                     }
  71.                 }
  72.             }
  73.             //让index + 1，并判断是否扫描到expression最后
  74.             index++;
  75.             if (index >= expression.length()){
  76.                 break;
  77.             }
  78.         }
  79.         //当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并进行运算。
  80.         while (true){
  81.             //如果符号栈为空，则计算到最后的结果，数栈中只有一个数字【结果】
  82.             if (operStack.isEmpty()){
  83.                 break;
  84.             }
  85.             num1 = numStack.pop();
  86.             num2 = numStack.pop();
  87.             oper = operStack.pop();
  88.             res = numStack.cal(num1,num2,oper);
  89.             numStack.push(res);
  90.         }
  91.         //将数栈的最后数，pop出，就是结果
  92.         int res2 = numStack.pop();
  93.         System.out.printf("表达式%s = %d",expression,res2);
  94.     }
  95. }
  97. //先创建一个栈
  98. class CalculatorArrayStack{
  99.     private int maxSize;  //栈的大小
  100.     private int[] stack;  //数组，数组模拟栈，数据就放在该数组
  101.     private int top = -1; //top表示栈顶，初始化为-1表示没有数据
  103.     //构造器
  104.     public CalculatorArrayStack(int maxSize){
  105.         this.maxSize =maxSize;
  106.         stack = new int[this.maxSize];
  107.     }
  109.     //栈满
  110.     public boolean isFull(){
  111.         return top == maxSize - 1; //栈顶等于栈的大小的时候表示栈满
  112.     }
  114.     //栈空
  115.     public boolean isEmpty(){
  116.         return top == -1;
  117.     }
  119.     //入栈-push
  120.     public void push(int value){
  121.         //判断栈是否满
  122.         if (isFull()){
  123.             System.out.println("栈满");
  124.             return;
  125.         }
  126.         top++;
  127.         stack[top] = value;
  128.     }
  130.     //返回栈顶的值，不做任何修改
  131.     public int peek(){
  132.         return stack[top];
  133.     }
  135.     //出栈-pop，将栈顶的数据返回
  136.     public int pop(){
  137.         //先判断栈是否空
  138.         if (isEmpty()){
  139.             //抛出异常
  140.             throw new RuntimeException("栈空,没有数据~");
  141.         }
  142.         int value = stack[top];
  143.         top--;
  144.         return value;
  145.     }
  147.     //显示栈的情况[便利栈]，遍历时，需要从栈顶开始显示数据
  148.     public void list(){
  149.         if (isEmpty()){
  150.             System.out.println("栈空，没有数据~~");
  151.             return;
  152.         }
  154.         for(int i = top; i >= 0; i--){
  155.             System.out.printf("stack[%d]=%d\n",i,stack[i]);
  156.         }
  157.     }
  159.     //返回运算符的优先级，优先级是程序员来确定，优先级使用数字表示
  160.     //数字越大，则优先级越高
  161.     public int priority(int oper){
  163.         if (oper == '*' || oper == '/'){
  164.             return 1;
  165.         }else if (oper == '+' || oper == '-'){
  166.             return 0;
  167.         } else {
  168.             return -1; //假定目前的表达式只有+，-，*，/
  169.         }
  170.     }
  172.     //判断是不是一个运算符
  173.     public boolean isOper(char val){
  174.         return val == '+' || val == '-' || val == '*' || val == '/';
  175.     }
  177.     //计算方法
  178.     public int cal(int num1,int num2,int oper){
  179.         int res = 0; //res 用于存放计算的结果
  180.         switch (oper){
  181.             case '+':
  182.                 res = num1 + num2;
  183.                 break;
  184.             case '-':
  185.                 res = num2 - num1; //注意顺序
  186.                 break;
  187.             case '*':
  188.                 res = num1 * num2;
  189.                 break;
  190.             case '/':
  191.                 res = num2 / num1;
  192.                 break;
  193.             default:
  194.                 break;
  195.         }
  196.         return res; //结果返回
  197.     }
  198. }

再次测试

该问题成功解决。

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://chonglian.blog.csdn.net/article/details/124196412

内容来源于网络，如有侵权，请联系作者删除！

Java数据结构算法栈

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com