基于栈的中缀算式表达式求值（Java实现）

最新推荐文章于 2024-04-21 17:33:55 发布
最新推荐文章于 2024-04-21 17:33:55 发布
阅读量1.6k 收藏 12
点赞数 2
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52972784/article/details/122154894
版权

目录

一、问题分析

首先，项目是要实现基于栈的中缀算式表达式求值，要求循环输入一个以“=”结尾的中缀算术表达式，输出所求的表达式的值。
要解决此问题，我们可以按照以下步骤来实现：

  1. 建立栈，写出其基本操作
  2. 创建运算符栈和操作数栈
  3. 实现依次读取表达式中的字符，操作数入操作数栈，运算符入栈前要比较其优先级。当栈顶元素优先级小于新读取运算符的优先级，该运算符入栈；若优先级相等，则栈顶元素出栈，即去括号；当栈顶元素优先级大于新读取运算符的优先级，栈顶元素出栈，操作数依次出栈两个，与出栈的运算符进行计算之后将结果入操作数栈
  4. 最后操作数栈里的仅存的一个数就是表达式的结果

二、数据结构

1.逻辑结构

逻辑结构采用的是顺序栈

2.物理结构

static class SequenceStack<T>{
	T[] stackArray;
	int top;
	static int defaultSize=20;
	//栈的初始化 
	public SequenceStack(int n) {
		stackArray=(T[])new Object[n];
		top=-1;
	}	
	public SequenceStack() {
		this(defaultSize);
	}
	//入栈
	public void push(T x) {
		if(top==stackArray.length-1) {
		T[]p=(T[])new Object[stackArray.length*2];
		for(int i=0;i<=top;i++) {
			p[i]=stackArray[i];
		}
		stackArray=p;
		}
		stackArray[++top]=x;
	}
//出栈
public T pop() {
	if(top==-1) {
		System.out.print("栈为空，删除失败");
		return null;
	}
	T x=stackArray[top--];
	return x;
}
//获取栈顶元素
public T getTop() {
	if(top==-1) {
		System.out.print("栈为空，无法获取栈顶元素");
		return null;
	}
	return stackArray[top];
}
//判断栈是否为空
public boolean isEmpty() {
	return top==-1;
	}
}

三、算法

1.栈类SequenceStack中的算法

（1）栈的初始化

public SequenceStack(int n) {
	//强制转化初始化栈
	stackArray=(T[])new Object[n];
	top=-1; 
}
public SequenceStack() {
	//设置栈的空间的默认值
	this(defaultSize);
}

（2）入栈

public void push(T x) {
	//若栈满，增加空间令元素入栈；若栈不满，top值加一，指向最新的栈顶元素
	if(top==stackArray.length-1) {
	T[]p=(T[])new Object[stackArray.length*2];
	for(int i=0;i<=top;i++) {
		p[i]=stackArray[i];
	}
	stackArray=p;
	}
	stackArray[++top]=x;
}

（3）出栈

public T pop() {
	//若栈为空，则无法使元素出栈；若栈不为空，栈顶元素出栈，随后top值减一指向新的栈顶元素
	if(top==-1) {
	System.out.print("栈为空，删除失败");
	return null;
	}
	T x=stackArray[top--];
	return x;
}

（4）获取栈顶元素

public T getTop() {
	//若栈为空，则无法获取栈顶元素；若非空则返回top所指的元素即为栈顶元素
	if(top==-1) {
	System.out.print("栈为空，无法获取栈顶元素");
	return null;
	}
	return stackArray[top];
}

（5）判栈空操作

public boolean isEmpty() {
//若栈空，top值等于-1
	return top==-1;
}

2.主类text中的算法

（1）判定运算符优先级

public static boolean IsOperator(char c) {
//判定是否为规定的运算符
	switch(c) {
	case '=':
	case '+':
	case '-':
	case '*':
	case '/':
	case '(':
	case ')':return true;
	default:return false;
	}	
}

static char OP[][]= {
//用数组定义运算符的优先级表
{'>','>','<','<','<','>','>'},
{'>','>','<','<','<','>','>'},
{'>','>','>','>','<','>','>'},
{'>','>','>','>','<','>','>'},
{'<','<','<','<','<','#','E'},
{'>','>','>','>','E','>','>'},
{'<','<','<','<','<','E','#'}
};
public static int GetOperatorID(char Operator) {
//定义运算符下标，在数组中即可比较出彼此的优先级
	switch(Operator) {
	case '+':retCode=0;break;
	case '-':retCode=1;break;
	case '*':retCode=2;break;
	case '/':retCode=3;break;
	case '(':retCode=4;break;
	case ')':retCode=5;break;
	case '=':retCode=6;break;
	}
	return(retCode);
}
public static char Precede(char Operator1,char Operator2) {
//获取下标比较优先级
	int OperatorID1,OperatorID2;
	OperatorID1=GetOperatorID(Operator1);
	OperatorID2=GetOperatorID(Operator2);
	if(OperatorID1<0||OperatorID1>6||OperatorID2<0||OperatorID2>6) {
	return('E');
	}
	return(OP[OperatorID1][OperatorID2]);
}

（2）运算法则

public static double Operate(double op1,char cal,double op2) {
//运算法则	
	switch(cal) {
	case '+': return op1+op2;
	case '-': return op1-op2;
	case '*': return op1*op2;
	case '/': return op1/op2;
	default:return 0;
	}
}

（3）读取操作数和运算符分别进栈

public static double ExpEvaluation(char []exp) {
//建立操作数栈和运算符栈，依次读取表达式中的字符，操作数入操作数栈，运算符入栈前要比较其优先级。当栈顶元素优先级小于新读取运算符的优先级，该运算符入栈；若优先级相等，则栈顶元素出栈，即去括号；当栈顶元素优先级大于新读取运算符的优先级，栈顶元素出栈，操作数依次出栈两个，与出栈的运算符进行计算之后将结果入操作数栈
	SequenceStack<Character>OPTR=new SequenceStack<Character>();
	SequenceStack<Double>OPND=new SequenceStack<Double>();
	OPTR.push('=');
	while(exp[i]!='='||OPTR.getTop()!='=') {
		if(!IsOperator(exp[i])) {
			String temp="";
			while(!IsOperator(exp[i])&&i<exp.length) {
				temp+=exp[i];
				i++;
			}
			double result=Double.parseDouble(temp);
			OPND.push(result);
		}
		else {
			switch(Precede(OPTR.getTop(),exp[i])) {
			case '<':
			OPTR.push(exp[i]);
			i++;
			break;
			case '#':
			OPTR.pop();
			i++;
			break;
			case '>':
			thera=OPTR.pop();
			b=OPND.pop();
			a=OPND.pop();
			OPND.push(Operate(a,thera,b));
			break;
			}
		}
	}
	val=OPND.getTop();
	return(val);
}

全部代码

package shiyan;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class text {
	public static boolean IsOperator(char c) {
		switch(c) {
		case '=':
		case '+':
		case '-':
		case '*':
		case '/':
		case '(':
		case ')':return true;
		default:return false;
		}	
	}
	static char OP[][]= {
			{'>','>','<','<','<','>','>'},
			{'>','>','<','<','<','>','>'},
			{'>','>','>','>','<','>','>'},
			{'>','>','>','>','<','>','>'},
			{'<','<','<','<','<','#','E'},
			{'>','>','>','>','E','>','>'},
			{'<','<','<','<','<','E','#'}
	};
	public static int GetOperatorID(char Operator) {
		int retCode;
		retCode=-1;
		switch(Operator) {
		case '+':retCode=0;break;
		case '-':retCode=1;break;
		case '*':retCode=2;break;
		case '/':retCode=3;break;
		case '(':retCode=4;break;
		case ')':retCode=5;break;
		case '=':retCode=6;break;
		}
		return(retCode);
	}
	public static char Precede(char Operator1,char Operator2) {
		int OperatorID1,OperatorID2;
		OperatorID1=GetOperatorID(Operator1);
		OperatorID2=GetOperatorID(Operator2);
		if(OperatorID1<0||OperatorID1>6||OperatorID2<0||OperatorID2>6) {
			return('E');
		}
		return(OP[OperatorID1][OperatorID2]);
	}
	public static double Operate(double op1,char cal,double op2) {
		switch(cal) {
		case '+': return op1+op2;
		case '-': return op1-op2;
		case '*': return op1*op2;
		case '/': return op1/op2;
		default:return 0;
		}
	}
	static class SequenceStack<T>{
		T[] stackArray;
		int top;
		static int defaultSize=20;
		
		public SequenceStack(int n) {
			stackArray=(T[])new Object[n];
			top=-1;
		}	
		public SequenceStack() {
			this(defaultSize);
		}
		
		public void push(T x) {
			//栈满
			if(top==stackArray.length-1) {
				T[]p=(T[])new Object[stackArray.length*2];
				for(int i=0;i<=top;i++) {
					p[i]=stackArray[i];
				}
				stackArray=p;
			}
			stackArray[++top]=x;
		}
		
		public T pop() {
			if(top==-1) {
				System.out.print("栈为空，删除失败");
				return null;
			}
			T x=stackArray[top--];
			return x;
		}
		
		public T getTop() {
			if(top==-1) {
				System.out.print("栈为空，无法获取栈顶元素");
				return null;
			}
			return stackArray[top];
		}
		
		public boolean isEmpty() {
			return top==-1;
		}
		
	}
	public static double ExpEvaluation(char []exp) {
		char thera;
		int i=0;
		double b,a,val;	
		SequenceStack<Character>OPTR=new SequenceStack<Character>();
		SequenceStack<Double>OPND=new SequenceStack<Double>();
		OPTR.push('=');
		while(exp[i]!='='||OPTR.getTop()!='=') {
			if(!IsOperator(exp[i])) {
				String temp="";
				while(!IsOperator(exp[i])&&i<exp.length) {
					temp+=exp[i];
					i++;
				}
				double result=Double.parseDouble(temp);
				OPND.push(result);
			}
			else {
				switch(Precede(OPTR.getTop(),exp[i])) {
				case '<':
					OPTR.push(exp[i]);
					i++;
					break;
				case '#':
					OPTR.pop();
					i++;
					break;
				case '>':
					thera=OPTR.pop();
					b=OPND.pop();
					a=OPND.pop();
					OPND.push(Operate(a,thera,b));
					break;
				}
			}
		}
		val=OPND.getTop();
		return(val);
	}
    public static void main(String[]args) {
    	for(;;) {
    		try {
    			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    			String s=br.readLine();
        		char[]us=s.toCharArray();
        		System.out.println(String.format("%.2f", ExpEvaluation(us)));
        	}catch(IOException e) {
        		e.printStackTrace();
        	}
    	}  	
    }
}
以沐欢年
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言：中缀算术表达式求值（栈 附答案）.docx
10-26
C语言一道练习如何建立栈和运用栈来进行一些操作的好题。里面涉及加减乘除括号的优先级考虑和入栈出栈的规则来实现计算中缀表达式。作为数据结构中比较重要的一个结构——栈，我们可以通过这道题更加好的理解栈的用途并熟悉栈的运用
基于栈结构的中缀表达式求值实验报告
05-25
基于栈结构的中缀表达式求值 用c语言详细的叙述了如何求栈结构的中缀表达式的值
数据结构 基于栈的中缀算术表达式求值
fzyz2333的博客
01-26 1万+
数据结构 实验2 基于栈的中缀算术表达式求值实验目的实验内容实验提示 实验目的 1.掌握栈的基本操作算法的实现，包括栈初始化、进栈、出栈、取栈顶元素等。 2.掌握利用栈实现中缀表达式求值的算法。 实验内容 问题描述 输入一个中缀算术表达式，求解表达式的值。运算符包括“+”、“-”、 “*”、“/”、 “(”“)”“=”，参加运算的数为double 类型且为正数。(要求:直接使用中缀算术表达式进行计算，不能转换为后缀或前缀表达式再进行计算，只考虑二元运算即可。) 输入要求 多组数据，每组数据一行，对应一个算术
数据结构 实验2：基于栈的中缀算术表达式求值
热门推荐
m0_51371779的博客
06-09 1万+
目录实验目的实验内容设计思路代码及注释运行实例 实验目的 掌握栈的基本操作算法的实现，包括栈初始化、进栈、出栈、取栈顶元素等 掌握利用栈实现中缀表达式求值的算法 实验内容 输入一个中缀算术表达式，求解表达式的值。运算包括“+”，“-”，“*”，“/”,”(”,”)”，“=”参加运算的数为double类型且为正数。（要求：直接使用中缀算术表达式进行计算，不能转换为后缀或前缀表达式再进行计算，只考虑二元运算即可） 输入要求： 多组数据，每组数据一行，对应一个算术表达式，每个表达式均以“=”结尾，当表达式只要一个
表达式求值
2301_80713324的博客
04-21 419
任务描述本关任务：输入一个中缀算术表达式，求解表达式的值。运算符包括+、-、*、/、(、)、=，参加运算的数为double类型且为正数。（要求：直接针对中缀算术表达式进行计算，不能转换为后缀或前缀表达式再进行计算，只考虑二元运算即可。编程要求输入多组数据，每组数据一行，对应一个算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。参加运算的数为double类型。输出对于每组数据输出一行，为表达式的运算结果。输出保留两位小数。测试说明。
基于栈的计算中缀表达式求值（纯c语言篇）
SM_zeng的博客
05-24 720
有字符串转数字及符号。
顺序栈求中缀表达式的值:
m0_57603543的博客
07-04 78
//用顺序栈实现中缀表达式的计算,好处就是没有上限啦 #include<stdio.h> #include <stdlib.h> #define MaxSize 100 //存储空间初始分配量 typedef struct { //存储运算符号*/+-()= char symbolData[MaxSize]; int top; }SqSymbolStack; typedef struct { //存储运算数 char numData[MaxSize
C++ 用栈实现中缀表达式求值
04-01
简易数据结构
严蔚敏《数据结构》实验二：基于栈的中缀算数表达式求值
最新发布
06-29
严蔚敏《数据结构》实验二：基于栈的中缀算数表达式求值
C++ 栈和队列 中缀表达式求值
04-24
采用栈和队列数据结构及C++程序设计语言实现中缀表达式求值#数据结构实验#栈和队列应用#C++程序设计语言
数据结构实验：利用堆栈实现中缀表达式的计算（C++）
m0_64568089的博客
11-06 823
用堆栈计算表达式。
中缀表达式的求值（栈实现）
08-05
模拟计算器的功能，对输入的一串表达式进行求值。算法定义了运算符的优先级，最后利用栈的方法来实现。
[C语言、C++]数据结构作业：用栈实现中缀表达式直接求值
Yhisken的博客
10-25 520
给定中缀表达式，用2个栈直接求值。
数据结构与算法实验4（栈应用）中缀表达式计算
VUno)UKGzseI
04-07 921
数据结构与算法实验4（栈应用）中缀表达式计算 栈ADT应用：中缀表达式求值 表达式求值是进行数据处理的最基本操作。请编写程序完成一个简单算术表达式的求值。要求如下： （1）运算符包括：+、-、*、-、^(乘方)、括号 （2）运算量为数值常量，根...
第1关：栈的应用 - 计算中缀表达式
weixin_51994374的博客
11-13 2528
样例输入： (1+2)*(9-6) 样例输出： result = 9.000000 基本思路： 1、遇到数字进栈； 2、遇到（ 进栈； 3、遇到+或-，判断栈顶元素是不是（，是就进栈，不是就计算，确保在+-入栈前，前面的运算都已完成； 4、遇到*或/，如果栈顶元素是*或/就计算，否则进栈 5、遇到），如果栈顶元素不是（，就进行计算，直到遇到（为止。 6、最后将剩余的运算符进行计算 double ComputeInfix(char* s) //计算中缀表达式 { // 请在此添加代码
栈实现中缀表达式求解
qq_46659042的博客
01-31 922
算术表达式有三种：中缀表达式、前缀表达式、后缀表达式，日常用的算术表达式为中缀表达式，其计算数值虽然一目了然，却不容易被计算机解释，其主要原因是在中缀表达式中，各运算符的优先级不同，不能简单地从表达式的左边直接计算到右边。所以要用两个栈实现，一个用来放操作数,一个用来放运算符。 算法步骤： 1.初始化并简历两个栈，一个用来放操作数OPND,一个用来放运算符OPTR，首先将操作数栈置为空栈，表达式起始符’#’为运算符栈底元素。 2.输入一个后缀表达式（以#结束），依次读入表达式中每个字符，若是操作数进OPND
用栈对算术表达式求值
sanqima的专栏
09-30 5132
假设算术表达式只包含”+”、“-”、“*”、“/”、正整数和括号的合法数学表达式。求算术表达式值的过程是：先将算术表达式转换成后缀表达式(逆波兰式)，然后对该后缀表达式求值。 　　1)将算术表达式exp转换成后缀表达式postexp; 　　2)对后缀表达式postexp求值。 完整代码如下：
使用堆栈完成计算表达式（JAVA实现）
weixin_43589025的博客
05-06 679
题目描述：对"6+3*3-3"进行计算 思路分析： （0）创建两个栈，一个用于存放数字，一个用于存放运算符 （1）通过一个index值（索引），来遍历表达式 （2）如果是一个数字，就直接进入堆栈 （3）如果是一个运算符的话： ①如果当前运算符栈为空，则直接进入堆栈 ②如果当前运算符栈不为空，则与之前的那个运算符进行优先级比较。如果优先级小于或者等于之前的那一个运算符，就需要从数栈中pop出两个数字...
Java用栈实现表达式求值
weixin_46073538的博客
08-16 723
当减号之前和会进行一个比对，当入栈的符号栈小于栈顶的优先级时，符号栈栈顶的运算符会和数字栈顶的两个元素进行运算，将运算结果放入数字栈顶。数字入栈发现入栈的是12字符串，因为12是一个数字，我们不能把他分开所以就必须将连续的数字拼接一起。大家学过数学的都知道*（乘法的优先级大于加法）所以应该先算3*3。...
基于栈的中缀算术表达式求值流程图
11-11
以下是基于栈的中缀算术表达式求值流程图： 1. 初始化两个栈，操作数栈和运算符栈。 2. 从左到右扫描中缀表达式。 3. 若扫描到操作数，将其压入操作数栈。 4. 若扫描到运算符或界限符，则按照“中缀转后缀”相同的逻辑压入运算符栈。 5. 每当弹出一个运算符时，就需要在弹出两个操作数栈的栈顶元素并执行相应运算，运算结果在压回操作数栈。 6. 重复步骤3-5，直到扫描完整个中缀表达式。 7. 最后操作数栈中只剩下一个元素，即为中缀表达式的计算结果。 下面是一个示例中缀表达式求值的流程图： ![基于栈的中缀算术表达式求值流程图](https://i.imgur.com/8JZzvJL.png)

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值