3：逆波兰计算器

最新推荐文章于 2022-08-24 19:13:50 发布
最新推荐文章于 2022-08-24 19:13:50 发布
阅读量146 收藏
点赞数
分类专栏： # java数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51755061/article/details/115822840
版权

逆波兰计算器（整数）

1.中缀表达式=>中缀表达式List

举例：

  • 中缀表达式：1+((2+3)×4)-5
  • 中缀表达式对应的List=[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]

代码实现：

	//  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;//返回
	}

注意点：

  • 从String中提取出字符（ s.charAt(i) )
  • 判断是否为数字（48 <= x <=57）[‘0’ —> ‘9’]
  • 判断字符是否为多位数的判断方法（while）

2.中缀表达式List => 后缀表达式List

举例：
ArrayList [1,+,(,(,2,+,3,),,4,),-,5] =》 ArrayList [1,2,3,+,4,,+,5,–]

具体步骤如下:

  • 1：初始化两个栈：运算符栈 s1 和储存中间结果的栈 s2；

  • 2：从左至右扫描中缀表达式；

  • 3：遇到操作数时，将其压 s2；

  • 4：遇到运算符时，比较其与 s1 栈顶运算符的优先级：

    • 1.如果 s1 为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
    • 优先级比栈顶运算符的高，也将运算符压入 s1
    • 否则，将 s1 栈顶的运算符弹出并压入到 s2 中，再次转到(4-1)与 s1 中新的栈顶运算符相比较

  • 5：遇到括号时：

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

  • 6：重复步骤 2 至 5，直到表达式的最右边

  • 7：将 s1 中剩余的运算符依次弹出并压入 s2

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

代码举例：

//即 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

	}

注意点：

  • 栈的定义（Stack s1 = new Stack()）
    • push（）加入栈
    • peek（）弹出栈
  • 正则表达式：判断是否是一个数字（item.matches("\ \ d+"）

3.对逆波兰表达式的运算

	//完成对逆波兰表达式的运算
	/*
	 * 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());
	}

}

4.其他

编写一个类 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("不存在该运算符" + operation);
			break;
		}
		return result;
	}
	
}

完成将一个中缀表达式转成后缀表达式的功能

//完成将一个中缀表达式转成后缀表达式的功能
		/*说明
		//1. 1+((2+3)×4)-5 => 转成  1 2 3 + 4 × + 5 –
		//2. 因为直接对str 进行操作，不方便，因此 先将  "1+((2+3)×4)-5" =》 中缀的表达式对应的List
		//   即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
		//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)); // ?

完整代码：

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 => 转成  1 2 3 + 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)); // ?


	}



	//即 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

	}


	//  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;//返回
	}


	//完成对逆波兰表达式的运算

	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("不存在该运算符" + operation);
				break;
		}
		return result;
	}

}

结果
在这里插入图片描述

亿钱君
关注
专栏目录
逆波兰计算器
s19862388581的博客
12-07 212
一. 前缀、中缀、后缀表达式的基本介绍 前缀表达式 (1) 前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前。举例说明： (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6。 (2) 前缀表达式求值：从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和 次顶元素），并将结果入栈重复，上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。 中缀表达式 中缀表达式就是常见的运算表达式，如(3+4)×5-6
逆波兰式计算器
06-15
逆波兰式完整代码计算器，带注释可直接运行VS2013，测试数据"1.0+3/2-tan(45)/(1+1)"，
rpn-calculator:逆波兰符号计算器
07-04
RPN计算器 是一种数学表示法，其中每个运算符都遵循其所有操作数，而法则将运算符置于前缀位置。 它也被称为后缀表示法，只要运算符参数是固定的，它就没有括号。 安装 npm install rpn-calculator 用法 var ...
简单的控制台版逆波兰计算器
06-12
这是我在大一下学期结束时做的课程设计，能力有限，是控制台版的 代码看起来有点不伦不类，是因为要求用c++写，我先用c写的，然后改了下头文件和函数，但是完全可以用 当时是用的vs2010编译的，有些代码可能不通用。...
逆波兰算法实现：Python平台 计算器 demo
最新发布
05-20
在这个Python平台上实现的计算器demo中，我们将深入探讨逆波兰算法的工作原理以及如何利用Python来实现它。 首先，逆波兰算法的基本思想是将一个带有常规运算符的中缀表达式转换为后缀表达式，然后按照后缀表达式的...
基于逆波兰式计算器
04-02
逆波兰式计算器是一种基于后缀表达式的计算工具，它在计算机科学中被广泛用于解析和求解数学表达式。在本项目中，我们利用Visual Studio（VS）和Microsoft Foundation Classes (MFC)库来构建一个具有图形用户界面...
逆波兰式计算器 数据结构 C语言编写 源代码
01-08
数据结构源代码 char a[]={'+','-','*','/','(',')','#'}; //优先关系矩阵，规定：=为0,>为1,<为-1,空为NO int PriorityTable[7][7]={{ 1, 1,-1,-1,-1, 1, 1}, { 1, 1,-1,-1,-1, 1, 1}, { 1, 1, 1, 1,-1, 1, 1}, { 1, 1, 1, 1,-1, 1, 1}, {-1,-1,-1,-1,-1, 0, NO}, { 1, 1, 1, 1,NO, 1, 1}, {-1,-1,-1,-1,-1,NO, 0} }; int menu(void); 很精彩
C#逆波兰式计算器
10-12
计算器实现了基本的运算功能，可做表达式计算，以逆波兰式运算
java实现栈+栈的应用( 括号匹配算法常用思路)
lifengfengli的博客
10-22 390
栈实现后缀表达式求值 思路分析 我们完成一个逆波兰计算器，要求完成如下任务: 输入一个逆波兰表达式(后缀表达式)，使用栈(Stack), 计算其结果 支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算。 思路分析 例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下: 1．从左至右扫描，将 3 和 4 压入堆栈； 2．遇到+运算符，因此弹出 4 和 3（4 为栈顶元素，3 为次顶元素），计算出 3+4 的值
逆波兰计算器（Java）
weixin_48544279的博客
08-24 220
逆波兰计算器（后缀表达式）（Java实现）
逆波兰(后缀表达式)计算器
Rong_zhe的博客
08-19 607
后缀表达式对于人来说是比较难理解的，但是对于计算机来说，缺失比较简单易懂的结构，这主要是由于计算机内存是栈式结构。当我们知道一个表达式的后缀表达式的时候，可以通过栈很快的完成计算器功能。如下： 由上面的执行流程可以很快的分析出来后缀表达式的思路。 后缀表达式思路 代码实现 import java.util.ArrayList; import java.util.List; import java.util.Stack; /** * 逆波兰表达式计算器 */ public class PolandN
BISON程序：逆波兰表达式分析与计算器实现
3. `exp`：定义了逆波兰表达式的处理，包括基本的数值（NUM）、加法 (+)、减法 (-)、乘法 (*), 除法 (/)、乘方 (^) 和取负 (n) 操作。这里使用了递归下降的方法，通过组合子表达式来构建更复杂的表达式。 `yylex` ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值