算数表达式逻辑表达式求值

最新推荐文章于 2024-05-24 21:52:31 发布
最新推荐文章于 2024-05-24 21:52:31 发布
阅读量2.3k 收藏 2
点赞数
分类专栏： Java 文章标签： 算数表达式求值 四则运算 Dijkstra
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qin9r3y/article/details/8897513
版权

    项目中要实现校验公式，一开始使用BeanShell插件求值，后来改用Dijkstra(迪杰斯特拉)算法自己实现表达式求值。该算法使用一个符号栈和一个数值栈，遍历表达式字符串当遇到数值时入数值栈。当遇到符号时若比符号栈顶的符号优先级高则入符号栈，若比符号栈顶的符号优先级低，则先把两栈中能计算的统统计算掉（直到符号栈顶的符号优先级小于遇到的符号）。遍历完再计算掉两栈中剩余的项。对于括号的处理也是类似，遇到左括号则入符号栈，遇到右括号则统统计算掉，直到遇到左括号。

    计算是指：符号栈退栈得符号，数值栈连退两栈（若是二元运算符的话）得两个数值，将得到的数值用符号运算符计算，得到的结果再压回数值栈。实现的源码如下：

package com.huateng.report.pboccbrcdemo.util;

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

/**
 * 
 * 计算算术表达式或逻辑表达式的值
 * 
 * @author zhou_yiqing
 * @since 2013-5-7
 * @version 1.0
 * 
 */

public class ExpressionEvaluator {
	private static Map<String, Integer> opLvl;
	
	static {
		init();
	}
	
	private static void init() {
		opLvl = new HashMap<String, Integer>();
		opLvl.put("||", 0);
		opLvl.put("&&", 1);
		opLvl.put(">", 2);
		opLvl.put("<", 2);
		opLvl.put(">=", 2);
		opLvl.put("<=", 2);
		opLvl.put("==", 2);
		opLvl.put("!=", 2);
		opLvl.put("+", 3);
		opLvl.put("-", 3);
		opLvl.put("*", 4);
		opLvl.put("/", 4);
		opLvl.put("sqr", 5);
		opLvl.put("(", -1);
		opLvl.put(")", -2);
	}
	
	/**
	 * 计算中缀表达式
	 * @param nifix 以算术或逻辑中缀表达式
	 * @return 若为算术值则是Integer或Double实例，若为逻辑值则是Boolean实例
	 * @throws Exception
	 */
	public static Object calcNifix(String nifix) throws Exception {
		Object ret = null;
		Stack<String> opStack = new Stack<String>();
		Stack<Object> oaStack = new Stack<Object>();
		int length = nifix.length();
		int begin = 0;
		boolean numStat = true;
		
		for (int i=0; i<length; i++) {
			char c = nifix.charAt(i);
			if (Character.isDigit(c) || c=='.') { // 遇到数值
				if (!numStat) {
					throw new Exception("无法识别的运算符\""+nifix.substring(begin, i)+ "\"");
				} else {
					numStat = true;
				}
			} else if (Character.isSpaceChar(c)) { // 遇到空白
				continue;
			} else { // 遇到运算符
				if  (numStat) {
					if (begin != i) {
						String oa = nifix.substring(begin, i).trim();
						if (!"".equals(oa)) {
							try {
								if (oa.indexOf(".") != -1) {
									oaStack.push(Double.parseDouble(oa));
								} else {
									oaStack.push(Integer.parseInt(oa));
								}
							} catch (Exception e) {
								throw new Exception("无法识别的数值：" + oa);
							}
						}
					}
					begin = i;
					numStat = false;
				}
				String op = nifix.substring(begin, i+1).trim();
				if (opLvl.containsKey(op)) {
					if (">".equals(op) || "<".equals(op)) {
						if (i+1 < length && nifix.charAt(i+1) == '=') {
							continue;
						}
					}
					int lvl = opLvl.get(op);
					switch (lvl) {
					case 5:
						opStack.push(op);
						break;
					case -1:
						opStack.push(op);
						break;
					case -2:
						try {
							calcStack(opStack, oaStack, true, -1);
						} catch (Exception e) {
							throw new Exception("第" + i + "列附近出现错误："+ e.getMessage());
						}
						if (!opStack.isEmpty()) {
							String topOp = opStack.peek();
							if (opLvl.get(topOp) >= 5) {
								opStack.pop();
								Double result = null;
								try {
									result =  calcSingleOperator(oaStack.pop(), topOp);
								} catch (Exception e) {
									throw new Exception("第" + i + "列附近出现错误："+ e.getMessage());
								}
								oaStack.push(result);
							}
						}
						break;
					default:
						if (!opStack.isEmpty()) {
							try {
								calcStack(opStack, oaStack, false, lvl);
							} catch (Exception e) {
								throw new Exception("第" + i + "列附近出现错误："+ e.getMessage());
							}
							opStack.push(op);
						} else {
							opStack.push(op);
						}
						break;
					}
					begin = i+1;
					numStat = true;
				}
			}
		}
		if (!oaStack.isEmpty()) {
			if (!opStack.isEmpty()) {
				if (begin < length) {
					String oa = nifix.substring(begin, length).trim();
					if (!"".equals(oa)) {
						try {
							if (oa.indexOf(".") != -1) {
								oaStack.push(Double.parseDouble(oa));
							} else {
								oaStack.push(Integer.parseInt(oa));
							}
						} catch (Exception e) {
							throw new Exception("无法识别的数值：" + oa);
						}
					}
				}
				ret = calcStack(opStack, oaStack, false, Integer.MIN_VALUE);
			} else {
				return oaStack.pop();
			}
		} else {
			String str = nifix.trim();
			try {
				if (str.indexOf(".") != -1) {
					ret = Double.parseDouble(nifix.trim());
				} else {
					ret = Integer.parseInt(nifix.trim());
				}
			} catch (Exception e) {
				throw new Exception("无法识别的数值：" +str);
			}
		}
		
		return ret;
	}
	
	/**
	 * 计算一元运算符
	 */
	private static Double calcSingleOperator(Object oa, Object op) throws Exception {
		if ("sqr".equals(op)) {
			if (oa instanceof Integer) {
				return Math.sqrt((Integer)oa);
			} else if (oa instanceof Double) {
				return Math.sqrt((Double)oa);
			} else {
				throw new Exception("一元运算类型不匹配");
			}
		} else {
			throw new Exception("未知的一元运算符："+ op);
		}
	}
	
	/**
	 * 二元运算符计算
	 */
	private static Number calcCalculateOperator(Object oa1, Object oa2, String op) throws Exception {
		if ("+".equals(op)) {
			if (oa2 instanceof Integer && oa1 instanceof Integer) {
				return (Integer)oa2 + (Integer)oa1;
			} else if (oa2 instanceof Integer && oa1 instanceof Double) {
				return (Integer)oa2 + (Double)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Integer) {
				return (Double)oa2 + (Integer)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Double) {
				return (Double)oa2 + (Double)oa1;
			} else {
				throw new Exception("二元运算类型不匹配");
			}
		} else if ("-".equals(op)) {
			if (oa2 instanceof Integer && oa1 instanceof Integer) {
				return (Integer)oa2 - (Integer)oa1;
			} else if (oa2 instanceof Integer && oa1 instanceof Double) {
				return (Integer)oa2 - (Double)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Integer) {
				return (Double)oa2 - (Integer)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Double) {
				return (Double)oa2 - (Double)oa1;
			} else {
				throw new Exception("二元运算类型不匹配");
			}
		} else if ("*".equals(op)) {
			if (oa2 instanceof Integer && oa1 instanceof Integer) {
				return (Integer)oa2 * (Integer)oa1;
			} else if (oa2 instanceof Integer && oa1 instanceof Double) {
				return (Integer)oa2 * (Double)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Integer) {
				return (Double)oa2 * (Integer)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Double) {
				return (Double)oa2 * (Double)oa1;
			} else {
				throw new Exception("二元运算类型不匹配");
			}
		} else if ("/".equals(op)) {
			if (oa2 instanceof Integer && oa1 instanceof Integer) {
				return (Integer)oa2 / (Integer)oa1;
			} else if (oa2 instanceof Integer && oa1 instanceof Double) {
				return (Integer)oa2 / (Double)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Integer) {
				return (Double)oa2 / (Integer)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Double) {
				return (Double)oa2 / (Double)oa1;
			} else {
				throw new Exception("二元运算类型不匹配");
			}
		} else {
			throw new Exception("未知的二元运算符：" + op);
		}
	}
	
	/**
	 * 计算逻辑运算符 
	 */
	private static Boolean calcLogicOperator(Object oa1, Object oa2, String op) throws Exception {
		if (oa1 instanceof Boolean && oa2 instanceof Boolean) {
			if ("||".equals(op)) {
				return (Boolean)oa2 || (Boolean)oa1;
			} else if ("&&".equals(op)){
				return (Boolean)oa2 && (Boolean)oa1;
			} else {
				throw new Exception("未知的逻辑运算符：" + op);
			}
		} else {
			throw new Exception("逻辑判断类型不匹配");
		}
		
	}
	
	/**
	 * 计算关系运算符
	 */
	private static Boolean calcRelationOperator(Object oa1, Object oa2, String op) throws Exception {
		if (oa2 instanceof Integer && oa1 instanceof Integer) {
			if (">".equals(op)) {
				return (Integer)oa2 > (Integer)oa1;
			} else if ("<".equals(op)) {
				return (Integer)oa2 < (Integer)oa1;
			} else if (">=".equals(op)) {
				return ((Integer)oa2).intValue() >=  ((Integer)oa1).intValue();
			} else if ("<=".equals(op)) {
				return ((Integer)oa2).intValue() <=  ((Integer)oa1).intValue();
			} else if ("==".equals(op)) {
				return ((Integer)oa2).intValue() ==  ((Integer)oa1).intValue();
			} else if ("!=".equals(op)) {
				return ((Integer)oa2).intValue() !=  ((Integer)oa1).intValue();
			} else {
				throw new Exception("未知的关系运算符：" + op);
			}
		} else if (oa2 instanceof Integer && oa1 instanceof Double) {
			if (">".equals(op)) {
				return (Integer)oa2 > (Double)oa1;
			} else if ("<".equals(op)) {
				return (Integer)oa2 < (Double)oa1;
			} else if (">=".equals(op)) {
				return ((Integer)oa2).intValue() >=  ((Double)oa1).doubleValue();
			} else if ("<=".equals(op)) {
				return ((Integer)oa2).intValue() <=  ((Double)oa1).doubleValue();
			} else if ("==".equals(op)) {
				return ((Integer)oa2).intValue() ==  ((Double)oa1).doubleValue();
			} else if ("!=".equals(op)) {
				return ((Integer)oa2).intValue() !=  ((Double)oa1).doubleValue();
			} else {
				throw new Exception("未知的关系运算符：" + op);
			}
		} else if (oa2 instanceof Double && oa1 instanceof Integer) {
			if (">".equals(op)) {
				return (Double)oa2 > (Integer)oa1;
			} else if ("<".equals(op)) {
				return (Double)oa2 < (Integer)oa1;
			} else if (">=".equals(op)) {
				return ((Double)oa2).doubleValue() >=  ((Integer)oa1).intValue();
			} else if ("<=".equals(op)) {
				return ((Double)oa2).doubleValue() <=  ((Integer)oa1).intValue();
			} else if ("==".equals(op)) {
				return ((Double)oa2).doubleValue() ==  ((Integer)oa1).intValue();
			} else if ("!=".equals(op)) {
				return ((Double)oa2).doubleValue() !=  ((Integer)oa1).intValue();
			} else {
				throw new Exception("未知的关系运算符：" + op);
			}
		} else if (oa2 instanceof Double && oa1 instanceof Double) {
			if (">".equals(op)) {
				return (Double)oa2 > (Double)oa1;
			} else if ("<".equals(op)) {
				return (Double)oa2 < (Double)oa1;
			} else if (">=".equals(op)) {
				return ((Double)oa2).doubleValue() >=  ((Double)oa1).doubleValue();
			} else if ("<=".equals(op)) {
				return ((Double)oa2).doubleValue() <=  ((Double)oa1).doubleValue();
			} else if ("==".equals(op)) {
				return ((Double)oa2).doubleValue() ==  ((Double)oa1).doubleValue();
			} else if ("!=".equals(op)) {
				return ((Double)oa2).doubleValue() !=  ((Double)oa1).doubleValue();
			} else {
				throw new Exception("未知的关系运算符：" + op);
			}
		} else {
			throw new Exception("关系运算类型不匹配");
		}
	}
	
	/**
	 * 计算运算符栈
	 * @param opStack 运算符栈
	 * @param oaStack 运算成员栈
	 * @param popParenth 是否一直计算到左括号
	 * @param lvlDeep 运算符级别深度
	 * @return Integer或Double或Boolean的运算结果
	 * @throws Exception
	 */
	private static Object calcStack(Stack<String> opStack, 
			Stack<Object> oaStack, boolean popParenth, int lvlDeep) throws Exception {
		Object ret = null;
		while (!opStack.isEmpty()) {
			String topOp = opStack.peek();
			if (!popParenth) {
				int lvl = opLvl.get(topOp);
				if (lvl >= lvlDeep) {
					opStack.pop();
					Object oa1 = oaStack.pop();
					Object oa2 = oaStack.pop();
					Object result = null;
					if (lvl < 2) {
						result = calcLogicOperator(oa1, oa2, topOp);
					} else if (lvl < 3) {
						result = calcRelationOperator(oa1, oa2, topOp);
					} else if (lvl < 5) {
						result = calcCalculateOperator(oa1, oa2, topOp);
					}
					oaStack.push(result);
					ret = result;
				} else {
					break;
				}
			} else {
				if (!"(".equals(topOp)) {
					opStack.pop();
					Object oa1 = oaStack.pop();
					Object oa2 = oaStack.pop();
					int lvl = opLvl.get(topOp);
					Object result = null;
					if (lvl < 2) {
						result = calcLogicOperator(oa1, oa2, topOp);
					} else if (lvl < 3) {
						result = calcRelationOperator(oa1, oa2, topOp);
					} else if (lvl < 5) {
						result = calcCalculateOperator(oa1, oa2, topOp);
					}
					oaStack.push(result);
					ret = result;
				} else {
					opStack.pop();
					break;
				}
			}
		}
		return ret;
	}
	
	/*public static void main(String[] args) throws Exception {
	//	System.out.println(calcNifix("9+2*3+10/2"));
		System.out.println(calcNifix("(2<3+3)&&(3>9||4>2)"));
		System.out.println(calcNifix(
				"62202.00>=323.00+545.00+ 453.00+47.00+233.00+468.00+34.00+323.00+32.00+3213.00+3213.00+4342.00+34242.00+543.00+546.00+6757.00+213.00+3243.00+3432.00"));
		System.out.println(calcNifix(" (2)+ (3-6)"));
		System.out.println(calcNifix("sqr(4)"));
		System.out.println(calcNifix(" 1+ 2- ( 3+( sqr( 4 )-5) +1) "));
		System.out.println(calcNifix("9+(3-1)*3+10/2"));
	}*/

}


 

qin9r3y
关注
专栏目录
C++ 逻辑表达式求值
wwxy1995的博客
09-28 4778
#include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;stack&gt; #include&lt;queue&gt; #include&lt;cstring&gt; #include&lt;string&gt; #define N 200 using namespace std; int f(char c);...
栈的应用：逻辑表达式求值（C++）
超级无敌小酱油的博客
08-11 1641
1、不需要括号的后缀表达式（逆波兰表达式） 后缀的意思是所有的符号都是在要运算的数字后面出现，这样就没有了括号。 例如：9+（3-1）*3+10/2，其后缀表达式为9 3 1 - 3 * + 10 2 / + 1.1 中缀表达式转后缀表达式 从左到右遍历**中缀表达式**的数字和符号，若是数字就输出，即成为后缀表达式的一部分；若是符号，则判断其与栈顶符号的优先级，是右括号或优先级低于栈顶符号，...
支持算术运算、逻辑运算、位运算的表达式求值
weixin_34080571的博客
03-15 169
在表达式求值时先将表达式转换为逆波兰表达式，然后再继续对分析出来的逆波兰表达式进行求值。我在写这个表达式求值算法时参考了在天空飞翔的两篇文章，在此感谢这位大哥的好文章支持函数，变量的算术表达式计算（一、计算后缀表达式） 支持函数，变量的算术表达式计算（二、中缀转后缀） 详细的理论我就不明说了，我只简单说说我这表达式求值的处理过程，假如有以下表达：“1+3*5&gt;5”当调用表达求值方法Expre...
计算逻辑表达式的值
m0_62859230的博客
03-19 987
习题3.8
表达式求值
star的博客
01-26 591
中缀—&amp;amp;amp;amp;gt;前缀 HDU2127 中缀—&amp;amp;amp;amp;gt;后缀 HDU1237 224 Basic Calculator 待更新
算数表达式2_表达式二叉树_算数表达式求值_
10-03
这里，我们将深入探讨"算数表达式2_表达式二叉树_算数表达式求值_"这一主题，特别是通过二叉树结构来实现算术表达式的求值。 首先，我们需要理解什么是算数表达式。一个算数表达式通常包含数字、运算符（如加号"+...
哈工大数据结构作业-算数表达式求值
11-29
在哈工大的数据结构课程中，学生被分配了一项作业，任务是实现一个算数表达式求值的程序。这个程序不仅需要处理基本的算数运算，如加法、减法、乘法和除法，还要扩展到处理小数计算以及涉及变量的计算。这个项目旨在...
《数据结构》课程设计-算数表达式求值实验报告（附源码）.docx
12-10
数据结构课程设计-算数表达式求值实验报告 数据结构课程设计是计算机科学和技术专业的重要组成部分，旨在培养学生对数据结构和算法的理解和应用能力。在本实验报告中，我们将设计和实现一个算数表达式求值系统，...
17061833 _於文卓_算数表达式求值演示1
08-08
1. **算数表达式求值**：程序的目标是设计一个能够处理不含变量的整数算术表达式的求值系统，例如加、减、乘、除等四则运算。 2. **算符优先法**：这是一种解析和计算表达式的方法，依据操作符的优先级进行计算。在...
算数表达式求值
06-22
总的来说，“算数表达式求值”是一个涉及解析、数据结构、算法和错误处理等多个方面的重要概念，在计算机科学和软件工程中有广泛应用。通过深入理解和实践，可以更好地掌握程序设计和计算思维。
数学表达式求值 表达式求值
11-24
主要实现对输入的表达式进行求值功能 ，用C编写的程序
逻辑表达式，命题公式表达
06-30
在学习离散数学等课程的过程中，上机实习做得一些程序。理论的实践应用
JAVA数据结构复杂表达式求值
01-03
JAVA数据结构复杂表达式求值
表达式也有逻辑值
Mr_en的专栏
08-08 610
当表达式的运算结果非零，其逻辑值为true；否则，其值为false。 如图，当运算结果为非零0时，逻辑值为true。 当运算结果为零时，逻辑值为false。
字符串表达式如何计算逻辑值
最新发布
zhh99044的博客
05-24 191
原文链接：https://blog.csdn.net/my_clear_mind/article/details/79681686。版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。如上面例子就是其中的(EE&&FF)位置对应的( false && true )
C++入门经典-例2.12-求逻辑表达式的值
weixin_30394251的博客
09-11 191
1：代码如下： // 2.12.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include<iostream> using namespace std; void main() { int i=5,j=8,k=12,l=4,x1,x2; x1=i>j&&k>l; ...
利用栈求逻辑运算表达式的真值
晚风中的自由
03-29 3653
今天浙江理工校赛的D题。 比赛结束后在网上看了文章才做出来的。 Problem D: 逻辑运算 Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 248  Solved: 36 Description  还记得大学里学过的模电么，今天就让我们将与或非变成一道题吧。 给你一个与或非的表达式，求出这个表达式的值，表达式
java逻辑表达式计算与判断
iechenyb专栏
11-30 8949
package com.cyb.regex; import java.text.MessageFormat; import java.util.ArrayList; import java.util.List; import java.util.Locale; import javax.script.ScriptEngine; import javax.script.ScriptEngine...
表达式求值，Java实现
Westmoon
11-23 1803
前些日子，我们.net老师让我们做一个网页计算器，熟悉Vs环境，为图方便上网上下载了一个表达式求值C#版， 感觉蛮好用的，作业很做的不错。 后来也发现自己好久没有做数据结构方面的东西了，于是就萌生了写一个表达式求值的Java实现，算是重复性工作吧， 虽然网上的资源很多，但是大都很凌乱，所以今天详细总结一下。 首先说一下设计思路： 转换过程包括用下面的算法读入中缀表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值