栈

最新推荐文章于 2024-07-13 16:00:03 发布
最新推荐文章于 2024-07-13 16:00:03 发布
阅读量136 收藏
点赞数
分类专栏： Java数据结构与算法 文章标签： 数据结构 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44776943/article/details/104565689
版权

栈

栈的一个实际需求

请输入一个表达式

计算式:[722-5+1-5+3-3] 点击计算【如下图】

在这里插入图片描述
请问: 计算机底层是如何运算得到结果的? 注意不是简单的把算式列出运算,因为我们看这个算式 7 * 2 * 2 - 5, 但是计算机怎么理解这个算式的(对计算机而言，它接收到的就是一个字符串)，我们讨论的是这个问题。-> 栈

栈的介绍

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

在这里插入图片描述

栈的应用场景

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

栈的快速入门

  1. 用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来储存栈的数据内容， 下面我们就数组模拟栈的出栈，入栈等操作。
  2. 实现思路分析,并画出示意图

在这里插入图片描述

实现栈的思路分析

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

代码实现：

package com.atguigu.stack; 
import java.util.Scanner; 
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 "push":
        	System.out.println("请输入一个数"); 
          int value = scanner.nextInt(); 
          stack.push(value);
        	break;
        case "pop": 
          try {
        		int res = stack.pop();
        		System.out.printf("出栈的数据是 %d\n", res); 
          } catch (Exception e) {
          	// TODO: handle exception
        		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; 
  }
  
  //入栈-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]); 
      }
    } 
    }

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

使用栈来实现综合计算器-

在这里插入图片描述
思路分析(图解)

在这里插入图片描述

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

  1. 通过一个 index 值 (索引) ，来遍历我们的表达式

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

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

    3.1 如果发现当前符号栈为空 ，就直接入栈

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

  4. 当表达式扫描完毕，就顺序从数栈和符号栈中pop出相应的数字和符号，并运行

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

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

代价实现[1. 先实现一位数的运算， 2. 扩展到多位数的运算]

package com.atguigu.stack; 

public class Calculator {
  public static void main(String[] args) {
    //根据前面老师思路，完成表达式的运算
    String expression = "3+2*6-2"; //13
    //如何处理多位数的问题? 
    //创建两个栈，数栈，一个符号栈
    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.substring(index, index+1).charAt(0); //判断 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); // 1 + 3
		}
		} else { //如果是数，则直接入数栈
      //numStack.push(ch - 48); //? "1+3" '1' => 1
      //分析思路
      //1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
      //2. 在处理数，需要向 expression 的表达式的 index 后再看一位,如果是数就进行扫描，如果是符号
      //3. 因此我们需要定义一个变量 字符串，用于拼接 
      //处理多位数
			keepNum += ch;
    //如果 ch 已经是 expression 的最后一位，就直接入栈 
     if (index == expression.length() - 1) {
        numStack.push(Integer.parseInt(keepNum)); 
     }else{
       //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈 
       //注意是看后一位，不是 index++
       
      if (operStack.isOper(expression.substring(index+1,index+2).charAt(0))) { 
        //如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
        numStack.push(Integer.parseInt(keepNum));
      
        //重要的!!!!!!, keepNum 清空
         keepNum = "";
      }
     }
      }
      //让 index + 1, 并判断是否扫描到 expression 最后. 
      index++;
      if (index >= expression.length()) {
      break;
      }
    }
      //当表达式扫描完毕，就顺序的从 数栈和符号栈中 pop 出相应的数和符号，并运行. 
    while(true) {
      //如果符号栈为空，则计算到最后的结果, 数栈中只有一个数字【结果】 
      if(operStack.isEmpty()) {
      break; 
      }
      num1 = numStack.pop();
      num2 = numStack.pop();
      oper = operStack.pop();
      res = numStack.cal(num1, num2, oper);
      numStack.push(res);//入栈 
    }
      //将数栈的最后数，pop 出，就是结果
      int res2 = numStack.pop();
      System.out.printf("表达式 %s = %d", expression, res2);
      } 
}
      //先创建一个栈,直接使用前面创建好 //定义一个 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]; 
      }
      //增加一个方法，可以返回当前栈顶的值, 但是不是真正的 
    pop public int peek() {
      return stack[top];
    }
    
    //栈满
    public boolean isFull() {
    	return top == maxSize - 1;
    }
    
    //栈空
    public boolean isEmpty() {
    	return top == -1; 
    }
    
    //入栈-push
    public void push(int value) {
    //先判断栈是否满 
      if(isFull()) {
    		System.out.println("栈满");
    		return; 
      }
    		top++;
    		stack[top] = value; 
    }
    
    //出栈-pop, 将栈顶的数据返回 
    public int pop() {
    //先判断栈是否空 
      if(isEmpty()) {
    //抛出异常
    		throw new RuntimeException("栈空，没有数据~"); 
      }
      
      int value = stack[top]; top--;
      return value;
      }
      //显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据 
    public void list() {
      if(isEmpty()) { 
        System.out.println("栈空，没有数据~~"); 
        return;
      } 
      //需要从栈顶开始显示数据 
      for(int i = top; i >= 0 ; i--) {
      	System.out.printf("stack[%d]=%d\n", i, stack[i]); 
      }
    }
      //返回运算符的优先级，优先级是程序员来确定, 优先级使用数字表示 
      //数字越大，则优先级就越高.
    public int priority(int oper) {
      if(oper == '*' || oper == '/'){ 
        return 1;
      } else if (oper == '+' || oper == '-') { 
        return 0;
      } else {
      	return -1; // 假定目前的表达式只有 +, - , * , /
      }
    }
    //判断是不是一个运算符 
    public boolean isOper(char val) {
    	return val == '+' || val == '-' || val == '*' || val == '/'; 
    }
    //计算方法
    public int cal(int num1, int num2, int oper) {
    int res = 0; // res 用于存放计算的结果 
      switch (oper) {
        case '+':
       	  res = num1 + num2;
          break; 
        case '-':
        	res = num2 - num1;// 注意顺序
          break; 
        case '*':
          res = num1 * num2;
          break; 
        case '/':
        	res = num2 / num1;
          break; 
        default:
          break; 
      }
        return res; 
    }
  }

逆波兰计算器

我们完成一个逆波兰计算器，要求完成如下任务:

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

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

  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，由此得出最终结果
  1. 代码完成
package com.atguigu.stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolandNotation {
	public static void main(String[] args) { //先定义给逆波兰表达式
//(30+4)×5-6 =>304+5 × 6-=>164
// 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / + //测试
//说明为了方便，逆波兰表达式 的数字和符号使用空格隔开 //String suffixExpression = "30 4 + 5 * 6 -";
		String suffixExpression = "4 5 * 8 - 60 + 8 2 / +"; // 76
//思路
//1. 先将 "34+5 × 6-"=> 放到ArrayList中
//2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算
		List<String> list = getListString(suffixExpression);
		System.out.println("rpnList=" + list);
		int res = calculate(list);
		System.out.println("计算的结果是=" + res);
	}
//将一个逆波兰表达式， 依次将数据和运算符 放入到 ArrayList 中
	public static List<String> getListString(String suffixExpression) {
//将 suffixExpression 分割
		String[] split = suffixExpression.split(" ");
		List<String> list = new ArrayList<String>();
		for (String ele : split) {
			list.add(ele);
		}
		return list;
	}
//完成对逆波兰表达式的运算

//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 num2 = Integer.parseInt(stack.pop());
				int num1 = Integer.parseInt(stack.pop());
				int res = 0;
				if (item.equals("+")) {
					res = num1 + num2;
				} else if (item.equals("-")) {
					res = num1 - num2;
				} else if (item.equals("*")) {
					res = num1 * num2;
				} else if (item.equals("/")) {
					res = num1 / num2;
				} else {
					throw new RuntimeException("运算符有误");
				}
//把 res 入栈
				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 中新的栈顶运算符相比较;

  1. 遇到括号时:

(1) 如果是左括号“(”，则直接压入 s1

(2) 如果是右括号“)”，则依次弹出 s1 栈顶的运算符，并压入 s2，直到遇到左括号为止，此时将这一对括号丢弃

  1. 重复步骤 2 至 5，直到表达式的最右边

  2. 将 s1 中剩余的运算符依次弹出并压入 s2

  3. 依次弹出 s2 中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

举例说明:

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

因此结果为 :“123+4 × +5 –”

扫描到的元素s2(栈底—>栈顶)s1(栈底—>栈顶)说明
11空数字，直接入栈
+1+s1为空，运算符直接入栈
（1+（左括号，直接入栈
（1+（（左括号，直接入栈
21 2+（（数字
+1 2+（（ +s1栈顶为左括号，运算符直接入栈
31 2 3+（（ +数字
）1 2 3 ++（右括号，弹出运算符直至遇到左括号
x1 2 3 ++（ xs1栈顶为左括号，运算符直接入栈
41 2 3 + 4+（ x数字
）1 2 3 + 4 x+右括号，弹出运算符直至遇到左括号
-1 2 3 + 4 x +-- 与 +优先级相同，因此弹出 + ，再压入 -
51 2 3 + 4 x + 5-数字
到达最右端1 2 3 + 4 x + 5 -空s1中剩余的运算符

代码实现中缀表达式转为后缀表达式

代码实现：

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

public class PolandNotation {
	public static void main(String[] args) {
//完成将一个中缀表达式转成后缀表达式的功能
//说明
//1.1+((2+3)×4)-5=> 转成 123+4 × +5 –
//2. 因为直接对 str 进行操作，不方便，因此 先将 "1+((2+3)×4)-5" =》 中缀的表达式对应的 List
// 即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
//3. 将得到的中缀表达式对应的 List => 后缀表达式对应的 List
// 即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,–]
		String expression = "1+((2+3)*4)-5";//注意表达式
		List<String> infixExpressionList = toInfixExpressionList(expression);
		System.out.println("中缀表达式对应的 List=" + infixExpressionList); // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
		List<String> suffixExpreesionList = parseSuffixExpreesionList(infixExpressionList);
		System.out.println("后缀表达式对应的 List" + suffixExpreesionList); //ArrayList [1,2,3,+,4,*,+,5,–]
		System.out.printf("expression=%d", calculate(suffixExpreesionList)); // ?

		//先定义给逆波兰表达式
		//(30+4)×5-6 =>304+5 × 6-=>164
		// 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / +
		//测试
		//说明为了方便，逆波兰表达式 的数字和符号使用空格隔开 //String suffixExpression = "30 4 + 5 * 6 -";
		String suffixExpression = "4 5 * 8 - 60 + 8 2 / +"; // 76
		//思路
		//1. 先将 "34+5 × 6-"=> 放到ArrayList中
		//2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算
		List<String> list = getListString(suffixExpression);
		System.out.println("rpnList=" + list);
		int res = calculate(list);
		System.out.println("计算的结果是=" + res);
	}
//即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,–]
//方法:将得到的中缀表达式对应的 List => 后缀表达式对应的
	List public static List<String> parseSuffixExpreesionList(List<String> ls) {
//定义两个栈
		Stack<String> s1 = new Stack<String>(); // 符号栈
//说明:因为 s2 这个栈，在整个转换过程中，没有 pop 操作，而且后面我们还需要逆序输出
//因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> s2
//Stack<String> s2 = new Stack<String>(); // 储存中间结果的栈 s2
		List<String> s2 = new ArrayList<String>(); // 储存中间结果的 Lists2
//遍历 ls
		for (String item : ls) {
//如果是一个数，加入 s2
			if (item.matches("\\d+")) {
				s2.add(item);
			} else if (item.equals("(")) {
				s1.push(item);
			} else if (item.equals(")")) {
//如果是右括号“)”，则依次弹出 s1 栈顶的运算符，并压入 s2，直到遇到左括号为止，此时将这一对括号丢弃
				while (!s1.peek().equals("(")) {
					s2.add(s1.pop());
				}
				s1.pop();//!!! 将 ( 弹出 s1 栈， 消除小括号
			} else {
//当 item 的优先级小于等于 s1 栈顶运算符, 将 s1 栈顶的运算符弹出并加入到 s2 中，再次转到(4.1) 与 s1 中新的栈顶运算符相比较
//问题:我们缺少一个比较优先级高低的方法
				while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item) ) {
					s2.add(s1.pop());
				}
//还需要将 item 压入栈
				s1.push(item);
			}
		}
//将 s1 中剩余的运算符依次弹出并加入 s2
		while (s1.size() != 0) {
			s2.add(s1.pop());
		}
		return s2; //注意因为是存放到 List, 因此按顺序输出就是对应的后缀表达式对应的 List
	}
//方法:将 中缀表达式转成对应的 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;//返回 }
//将一个逆波兰表达式， 依次将数据和运算符 放入到 ArrayList 中
		public static List<String> getListString(String suffixExpression) {
//将 suffixExpression 分割
			String[] split = suffixExpression.split(" ");
			List<String> list = new ArrayList<String>();
			for (String ele : split) {
				list.add(ele);
			}
			return list;
		}
//完成对逆波兰表达式的运算

//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 num2 = Integer.parseInt(stack.pop());
					int num1 = Integer.parseInt(stack.pop());
					int res = 0;
					if (item.equals("+")) {
						res = num1 + num2;
					} else if (item.equals("-")) {
						res = num1 - num2;
					} else if (item.equals("*")) {
						res = num1 * num2;
					} else if (item.equals("/")) {
						res = num1 / num2;
					} else {
						throw new RuntimeException("运算符有误");
					}
//把 res 入栈
					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;
		}
	}

逆波兰计算器完整版

完整版的逆波兰计算器，功能包括

  1. 支持 ±*/()
  2. 多位数，支持小数,
  3. 兼容处理, 过滤任何空白字符，包括空格、制表符、换页符

说明:逆波兰计算器完整版考虑的因素较多，下面给出完整版代码供同学们学习，其基本思路和前面一样，也是使用到:中缀表达式转后缀表达式。

代码实现:
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 {
	/**

	* 匹配 +-x/() 运算符

	*/


	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();
	}
}
}
Tomcatist
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
profinet协议栈源码
05-16
标题"profinet协议栈源码"指的是这个项目是关于PROFINET通信协议的软件实现，其核心是协议栈的源代码。PROFINET是一种基于以太网技术的工业自动化网络标准，由德国西门子公司发起，广泛应用于制造业自动化领域。 ...
浅析栈区和堆区内存分配的区别
09-05
栈区和堆区是编程语言中内存管理的两个重要概念，它们在内存分配和管理上有显著的区别。首先，栈区，也称为栈，是编译器自动分配和释放的内存区域，主要用于存放函数参数值和局部变量。栈的内存分配是连续的，就像一...
一文读懂堆与栈的区别
热门推荐
Dablelv 的博客专栏。
06-29 38万+
堆（Heap）与栈（Stack）是开发人员必须面对的两个概念，在理解这两个概念时，需要放到具体的场景下，因为不同场景下，堆与栈代表不同的含义。一般情况下，有两层含义： （1）程序内存布局场景下，堆与栈表示的是两种程序内存分区； （2）数据结构场景下，堆与栈表示两种常用的数据结构。 1.程序内存分区——堆与栈 栈由操作系统自动分配释放 ，用于存放函数的参数值、局部变量的值等，其操作方式类......
数据结构：栈和队列(Stack & Queue)【详解】
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构——栈的详解
晴空๓
04-20 7万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
单调栈
hebtu666
09-15 1万+
通过使用栈这个简单的结构，我们可以巧妙地降低一些问题的时间复杂度。 单调栈性质： 1、若是单调递增栈，则从栈顶到栈底的元素是严格递增的。若是单调递减栈，则从栈顶到栈底的元素是严格递减的。 2、越靠近栈顶的元素越后进栈。（显而易见） 本文介绍单调栈用法 通过一道题来说明。 POJ2559 1. 题目大意：链接 给出一个柱形统计图(histogram), 它的每个项目的宽度是1， 高度...
C++数据结构——栈
GeekZW的博客
06-25 16万+
C++数据结构——栈 最近计划再复习一遍数据结构，看到一篇博客：https://www.cnblogs.com/QG-whz/p/5170418.html#_label0。 1、栈(Stack)是一种线性存储结构，它具有如下特点： ...
顺序栈
Lau's Blog
05-07 3568
栈的顺序存储结构定义及其基本运算实现 #include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef char ElemType; typedef struct { ElemType data[MaxSize]; int top; //栈指针 } SqStack; //顺序栈类型...
栈——栈的定义及基本操作（初始化、判空、进栈、出栈、遍历栈、销毁栈等）
薛定谔的猫的博客
04-19 8万+
文章目录栈的定义栈的存储栈上的基本操作初始化判空操作进栈操作出栈操作读栈顶元素遍历栈销毁栈完整代码及实例共享栈 栈的定义 栈（Stack）是只允许在一端进行插入或删除操作的线性表。 栈的示意图： 栈顶Top：线性表允许插入和删除的那一端。 栈底Bottom：固定的，不允许进行插入和删除的另一端。  假设某个栈S={a1,a2, … ,an}，如上图所示，则a1为栈底元素，an为栈顶元素。由于只能在栈顶进行插入和删除操作，故进栈顺序为a1,a2, … ,an，出栈顺序为an, … ,a2,a1。故栈的操
栈文档之共享栈
二木成林
04-22 7089
共享栈是顺序栈的变种。利用栈底位置相对不变的特性，可以让两个顺序栈共享一个一维数组空间，将两个栈的栈底分别设置在共享空间的两端，两个栈顶向共享空间的中间延申。
Stack-栈实例
10-23
栈是一种特殊的线性数据结构，遵循“后进先出”（LIFO）的原则。在计算机科学中，栈常被用于解决各种问题，如表达式求值、递归、内存管理等。下面我们将深入探讨栈的基本概念、静态栈与链表栈的实现方式，以及它们在...
两个栈空间共享，栈满打印
04-16
标题中的“两个栈空间共享，栈满打印”指的是在C++编程中实现一个特殊的栈结构，其中两个栈共享同一个内存空间。这个结构可以用于存储整数序列中的奇数和偶数，当任一栈达到其最大容量（即“栈满”状态）时，程序会...
顺序栈代码
06-06
顺序栈是一种常见的数据结构，它在内存中按照线性顺序存储元素，操作主要集中在栈顶进行，遵循“后进先出”（LIFO）的原则。顺序栈通常使用数组或者链表来实现，这里我们主要讨论使用数组实现的顺序栈。 在计算机...
数据结构之顺序表
m0_73634434的博客
07-10 412
线性表(List)由零个或多个数据组成的有限数列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串。
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 606
递归算法，爬楼梯等解法
设备管理中的数据结构
yuanwu932730169的博客
07-11 434
它包含了通道标识符、通道状态（如忙/闲）、与通道连接的控制器表的指针、通道队列的队首指针和队尾指针等信息。功能：DCT主要用于记录单个设备的详细信息，包括设备类型、设备标识符、设备状态（如忙/闲、等待/不等待）、指向控制器表的指针、重复执行次数或时间、设备队列的队首指针等。功能：SDT是系统级别的数据结构，用于记录系统中所有物理设备的情况。功能：COCT主要用于记录单个控制器的详细信息，包括控制器标识符、控制器状态（如忙/闲）、与控制器连接的通道表指针、控制器队列的队首指针和队尾指针等。
二分查找和斐波那契查找
最新发布
weixin_50960004的博客
07-13 340
表面上看，后一调整存在风险，此时只能确定切分点arr[mid]＞target ，“贸然”地将arr[mi]排除在进一步的查找范围之外，似乎可能因遗漏这些元素，而导致本应成功的查找以失败告终。也就是说，无论朝哪个方向深入，都只需做1次元素的大小比较，其二，统一沿两个方向深入所需要执行的比较次数，比如都统一为一次。在有序向量中的查找，遇到重复的元素时会返回秩最大的那个，上述查找无法实现这个功能，因此加以改进。所以这样的话，想进入左半区间，进行一次比较，想进入右半区间，会进行两次比较，右侧比较会多。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值