栈应用：后缀表达式求值

最新推荐文章于 2024-08-10 16:43:58 发布
最新推荐文章于 2024-08-10 16:43:58 发布
阅读量5.3k 收藏 60
点赞数 4
分类专栏： 【C/C++编程】 【数据结构】 文章标签： 栈应用 数据结构和算法 后缀表达式求值 逆波兰表示法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29542611/article/details/79142525
版权

在上一篇博客 栈应用：中缀表达式转后缀表达式 中我们知道如何通过栈将中缀表达式转为后缀表达式，这次我们继续用栈 来实现后缀表达式求值，结合上一篇博客。

上一篇博客中是用c语言实现的，由于c语言中不支持模板函数模板类，当我们遇到不同数据类型那么我们用结构体定义栈结构需要同时定义多个，那么对应的栈操作也需要定义多个，为了方便，我们将栈的实现用c++ 来实现，因为c++中有模板呀，可以很方便的构造不同数据类型的栈。

后缀表达式计算规则

摘自 大话数据结构中的定义。后缀表达式计算规则：从左到右遍历表达式的每个数字和符号，遇到数字就进栈，遇到是符号，就将处于栈顶2个数字出栈，进行运算，运算结果进栈，一直到最终获取结果。

后缀表达式规则分析

比较中缀表达式转后缀表达式的规则，后缀表达式的计算规则简单的多，就是后缀表达式中数值的入栈出栈问题。

遇到数字就进栈，遇到符号，就将栈顶2个元素进行弹栈，然后进行相应的符号计算，将计算结果入栈。

当整个表达式计算完毕，此时值栈中的只有1个数值，它就是整个表达式的值。

后缀表达式值计算局部代码

/*
通过栈对后缀表达式进行求值
*/
double GetResultAfterExp(const char* afterExp)
{
	if (NULL == afterExp)
	{
		return 0;
	}
	// a b 是表达式中的2个操作数
	double a = 0;
	double b = 0;
	int k = 0;// afterExp 下标
	char ch = 0;//后缀表达式中的字符

	char numBuf[10] = { 0 };//连续的数字不能超过10位，也就是后缀表达式中数字不能超过10位
	int numIndex = 0;//numBuf 下标


	SeqStack<double> stack;
	InitStack(&stack);
	while (afterExp[k])
	{
		ch = afterExp[k++];
		//是数值
		if (ch >= '0'&&ch <= '9')
		{
			while (((ch >= '0'&&ch <= '9') || ch == '.') && numIndex < 10)
			{
				numBuf[numIndex++] = ch;
				ch = afterExp[k++];
			}
			numBuf[numIndex] = 0;
			double num = atoi(numBuf);
			push(&stack, num);

		}

		//是符号或者空格
		if (ch< '0' || ch > '9')
		{
			numIndex = 0;//进入这个if 数字肯定不连续了，下标重置为0
			// 是空格
			if (' ' == ch)
			{
				continue;
			}
			else
			{
				double c = 0;
				switch (ch)
				{
				case '+':
					pop(&stack, &a);
					pop(&stack, &b);
					c = b + a;
					push(&stack,c);
					break;
				case '-':
					pop(&stack, &a);
					pop(&stack, &b);
					c = b - a;
					push(&stack, c);
					break;
				case '*':
					pop(&stack, &a);
					pop(&stack, &b);
					c = b * a;
					push(&stack, c);
					break;
				case '/':
					pop(&stack, &a);
					pop(&stack, &b);
					c = b / a;
					push(&stack, c);
					break;
				default:
					//throw "后缀表达式错误";
					//printf("后缀表达式错误\n");
					return 0;
					break;
				}
			}
		}
		afterExp++;

	}
	//计算完毕 将计算结果从栈中弹出
	if (IsEmptyStack(&stack))
	{
		//throw "后缀表达式错误";
		printf("后缀表达式错误\n");
		return 0;
	}
	pop(&stack, &a);
		
	return a;
}


后缀表达式值计算完整代码

代码结构和 栈应用：中缀表达式转后缀表达式 中的代码结构一致，将中缀表达式转后缀表达式整合进来了，将c代码改成c++代码了。

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <cstdlib>
#include <math.h>
#include <memory.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define STACK_INIT_SIZE 20	 // 栈初始容量
#define STACK_INCREMENT 10   //栈满后，每次扩充的容量
#define EXPRESS_MAX 1024 //后缀表达式 长度不能超过1024
typedef int Status;

template<class EleType>
struct SeqStack
{
	EleType* top;//栈顶指针
	EleType* base;//栈底指针
	int stackSize;//栈容量
};

//初始化栈
template<class EleType>
Status InitStack(SeqStack<EleType>* stack)
{
	//开辟空间
	stack->base = stack->top = (EleType*)malloc(STACK_INIT_SIZE * sizeof(EleType));
	if (!stack->base)
	{
		exit(0);
	}
	stack->stackSize = STACK_INIT_SIZE;
	return OK;
}
//压栈
template<class EleType>
Status push(SeqStack<EleType>* stack, EleType e)
{
	if (stack == NULL)
	{
		return ERROR;
	}
	//压栈之前检测容量是否足够
	if (stack->top - stack->base == stack->stackSize)
	{
		//超出容量 进行扩容，使用realloc函数，会拷贝原内存内容
		stack->base = (EleType*)realloc(stack->base, stack->stackSize + STACK_INCREMENT);
		if (!stack->base)
		{
			exit(0);
		}
		stack->top = stack->base + stack->stackSize;
		stack->stackSize += STACK_INCREMENT;
	}
	*stack->top = e;
	stack->top++;
	return OK;
}
//弹栈
template<class EleType>
Status pop(SeqStack<EleType>* stack, EleType *e)
{
	if (stack == NULL || e == NULL)
	{
		return ERROR;
	}
	//空栈
	if (stack->top == stack->base)
	{
		return ERROR;
	}
	*stack->top--;
	*e = *stack->top;
	return OK;
}
/*
获取栈顶元素
*/
template<class EleType>
Status GetTop(SeqStack<EleType>* stack, EleType *e) {
	if (NULL == stack) {
		return ERROR;
	}
	*e = *(stack->top - 1);
	return OK;
}
/*
判断栈是否为空
*/
template<class EleType>
int IsEmptyStack(SeqStack<EleType>* stack) {
	if (NULL == stack) {
		return ERROR;
	}
	if (stack->top == stack->base) {
		return TRUE;
	}
	return FALSE;
}
/*
销毁栈
*/
template<class EleType>
Status DestroyStack(SeqStack<EleType>* stack)
{
	if (NULL == stack) {
		return ERROR;
	}
	//销毁栈 是释放栈在内存中占用的空间资源
	if (!stack->base)
	{
		free(stack->base);
	}
	stack->top = stack->base = NULL;
	stack->stackSize = 0;
	return OK;
}

char* MidExpToAfterExp(const char* midExp)
{
	//后缀表达式
	char* afterExp = (char*)malloc(sizeof(char)*EXPRESS_MAX);
	memset(afterExp, 0, EXPRESS_MAX);
	int j = 0;//afterExp下标
	int k = 0;//preExp下标

	SeqStack<char> stack;// + - * / ( ）符号栈
	InitStack(&stack);

	char numBuf[10] = { 0 };//连续的数字不能超过10位，也就是中缀表达式中数字不能超过10位
	char ch = 0;
	int numIndex = 0;//numBuf 下标
	while (midExp[k])
	{
		ch = midExp[k++];
		//忽略中缀表达式中的空格
		if (ch == ' ')
		{
			continue;
		}
		//回车代表中缀输入完毕
		if ('\n' == ch)
		{
			break;
		}
		//1、若是数字就输出
		if (ch >= '0' && ch <= '9')
		{
			//如果输入连续的数字，不是连续的数字 循环完毕 会走 2、非数字
			while (((ch >= '0' && ch <= '9') || '.' == ch) && numIndex < 10)
			{
				numBuf[numIndex++] = ch;
				afterExp[j++] = ch;
				ch = midExp[k++];
			}
			numBuf[numIndex] = 0;
			afterExp[j++] = ' ';
		}
		//回车代表中缀输入完毕
		if ('\n' == ch)
		{
			break;
		}
		//忽略中缀表达式中的空格
		else if (' ' == ch)
		{
			continue;
		}
		//2、非数字
		else if (ch < '0' || ch > '9')
		{
			numIndex = 0;//进入这个if 数字肯定不连续了，下标重置为0
						 //右括号一定弹栈
			if (')' == ch)
			{
				int flag = 1;//判断中缀表达式中括号是否匹配,如果成对出现
				while (!IsEmptyStack(&stack))
				{
					pop(&stack, &ch);
					if ('(' == ch)
					{
						flag = 0;//走到这里说明是()括号成对出现
						break;
					}
					afterExp[j++] = ch;
					afterExp[j++] = ' ';
				}
				if (flag)
				{
					printf("中缀表达式输入错误\n");
					//exit(0);
					return	NULL;
				}

			}
			// + - 符号是优先级最低的，一定是先依次弹栈再压栈。
			else if ('+' == ch || '-' == ch)
			{
				char top;
				GetTop(&stack, &top);
				//栈空或者栈顶为左括号 直接压栈
				if (IsEmptyStack(&stack) || '(' == top)
				{
					push(&stack, ch);
				}
				else
				{
					char cur = ch;
					while (!IsEmptyStack(&stack))
					{
						pop(&stack, &ch);
						if ('(' == ch)
						{
							//不是因为)右括号而弹栈，多弹的(左括号压回去
							push(&stack, ch);
							break;
						}
						afterExp[j++] = ch;
						afterExp[j++] = ' ';
					}

					push(&stack, cur);
				}
			}
			// * / 符号优先级只比 + -高，栈空或栈顶为(+-符号栈才直接压栈，其他情况先依次弹栈再压栈
			else if ('*' == ch || '/' == ch)
			{
				char top;
				GetTop(&stack, &top);
				//栈空或者栈顶为左括号同样直接压栈
				if (IsEmptyStack(&stack) || '(' == top || '-' == top || '+' == top)
				{
					push(&stack, ch);
				}
				else if ('*' == top || '/' == top)
				{
					char cur = ch;
					while (!IsEmptyStack(&stack))
					{
						pop(&stack, &ch);
						if ('(' == ch || '-' == ch || '+' == ch)
						{
							//不是因为)右括号而弹栈 * / 优先级高于栈顶 + - 就不弹栈了，多弹的压回去
							push(&stack, ch);
							break;
						}
						afterExp[j++] = ch;
						afterExp[j++] = ' ';
					}
					push(&stack, cur);
				}
			}
			else if ('(' == ch)
			{
				push(&stack, ch);
			}
			else
			{
				printf("中缀表达式输入错误\n");
				//exit(0);
				return	NULL;
			}
		}

	}
	//符号栈内容不为空 依次出栈并打印
	while (!IsEmptyStack(&stack))
	{
		pop(&stack, &ch);
		afterExp[j++] = ch;
		afterExp[j++] = ' ';
	}

	return afterExp;
}
/*
通过栈对后缀表达式进行求值
*/
double GetResultAfterExp(const char* afterExp)
{
	if (NULL == afterExp)
	{
		return 0;
	}
	// a b 是表达式中的2个操作数
	double a = 0;
	double b = 0;
	int k = 0;// afterExp 下标
	char ch = 0;//后缀表达式中的字符

	char numBuf[10] = { 0 };//连续的数字不能超过10位，也就是后缀表达式中数字不能超过10位
	int numIndex = 0;//numBuf 下标


	SeqStack<double> stack;
	InitStack(&stack);
	while (afterExp[k])
	{
		ch = afterExp[k++];
		//是数值
		if (ch >= '0'&&ch <= '9')
		{
			while (((ch >= '0'&&ch <= '9') || ch == '.') && numIndex < 10)
			{
				numBuf[numIndex++] = ch;
				ch = afterExp[k++];
			}
			numBuf[numIndex] = 0;
			double num = atoi(numBuf);
			push(&stack, num);

		}

		//是符号或者空格
		if (ch< '0' || ch > '9')
		{
			numIndex = 0;//进入这个if 数字肯定不连续了，下标重置为0
			// 是空格
			if (' ' == ch)
			{
				continue;
			}
			else
			{
				double c = 0;
				switch (ch)
				{
				case '+':
					pop(&stack, &a);
					pop(&stack, &b);
					c = b + a;
					push(&stack,c);
					break;
				case '-':
					pop(&stack, &a);
					pop(&stack, &b);
					c = b - a;
					push(&stack, c);
					break;
				case '*':
					pop(&stack, &a);
					pop(&stack, &b);
					c = b * a;
					push(&stack, c);
					break;
				case '/':
					pop(&stack, &a);
					pop(&stack, &b);
					c = b / a;
					push(&stack, c);
					break;
				default:
					//throw "后缀表达式错误";
					//printf("后缀表达式错误\n");
					return 0;
					break;
				}
			}
		}
		afterExp++;

	}
	//计算完毕 将计算结果从栈中弹出
	if (IsEmptyStack(&stack))
	{
		//throw "后缀表达式错误";
		printf("后缀表达式错误\n");
		return 0;
	}
	pop(&stack, &a);
		
	return a;
}

int main(int argc, char *argv[])
{
	while (1)
	{
		printf("请输入中缀表达式(#表示退出)：");

		//中缀表达式
		char* midExp = (char*)malloc(sizeof(char)*EXPRESS_MAX);
		
		memset(midExp, 0, EXPRESS_MAX);
		fgets(midExp, 1024, stdin);//midExp 包含换行符
		if ('#' == midExp[0])
		{
			break;
		}
		SeqStack<char> charStack;
		//后缀表达式
		char* afterExp = MidExpToAfterExp(midExp);
		printf("对应的后缀表达式：%s\n", afterExp);

		double result = GetResultAfterExp(afterExp);
		printf("表达式计算结  果：%.2f\n", result);



	}

	return 0;
}


验证结果




重庆李四
关注
专栏目录
栈应用 ： 中缀表达式转后缀表达式求值
m0_46281615的博客
06-18 680
中缀表达式 （或中缀记法）是一个通用的算术或逻辑公式表示方法， 操作符是以中缀形式处于操作数的中间（例：3 + 4），中缀表达式是人们常用的算术表示方法。与前缀表达式（例：+ 3 4）或后缀表达式（例：3 4 +）相比，中缀表达式不容易被计算机解析，但仍被许多程序语言使用，因为它符合人们的普遍用法。 确实，中缀表达式很符合人类的思想，但是让计算机理解起来却不那么容易，这里我们引进了后缀表达式 后缀表达式(也成为逆波兰表达式） 一个表达式E的后缀形式可以如下定义： （1）如果E是一个变量或常量，则E的后缀
后缀表达式求值 栈
03-08
用数据结构栈实现后缀表达式求值的问题 输入一个后缀表达式 可计算出它的值
栈的后缀表达式求值
weixin_34247155的博客
04-10 211
一，什么是后缀表达式？ 1) 对人类而言，中缀表达式符合人们的习惯。比如： 3 4 + 5 × 6 - 2) 对于计算机而言，计算后缀表达式要比计算中缀表达式更容易。比如后缀表达式：6523+8*+3+* 因为，计算机计算中缀表达式需要考虑优先级、括号。而计算后缀表达式只需要一个栈即可。   计算机计算后缀表达式的过程如下----后缀表达式的计算机求值： 从左至右扫描表达式，遇到数字时...
【数据结构与算法】栈的应用——表达式求值
最新发布
qq_74047911的博客
08-10 1398
我想了一下,我主要写博客的目标还是说为了自己,自己容易忘记,相当于自己来过一遍,所以这是写给我自己的,当然如果你也遇到了相同的问题,那么不防我们可以一起探讨一下.
【数据结构与算法】使用栈Stack来实现后缀表达式(逆波兰表达式)求值
Bulut0907
09-22 1040
前缀表达式也叫波兰表达式。前缀表达式的运算符位于数字之前，例如(3+4)*5-6 对应的前缀表达式就是- * + 3 4 5 6。因为前缀表达式使用的不多，这里我们只要了解即可，不用关系中缀表达式如何转换成前缀表达式通过前缀表达式求值的步骤：从右至左遍历表达式，遇到数字时，将数字压入栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算，并将结果入栈；重复上述过程直到遍历完成，最后运算得出的值即为表达式的结果从右至左遍历表达式，将6、5、4、3压入栈。
栈--后缀表达式求值
m0_60333804的博客
10-01 313
后缀表达式求值-力扣 120 题
利用栈结构求取后缀表达式的值
weixin_34318272的博客
01-06 210
后缀表达式的求值准则： 从左到右依次读取表达式，每遇到一个操作符，就读取该操作符之前的最后两个操作数，计算其值并把计算结果作为一个新的操作数，然后继续向后读取直到结束。从过程上可以看出，优先计算的是后出现的操作数，符合栈结构的特点，所以可以用栈结构来实现。 具体来说，用一个栈来存储操作数，每遇到一个操作符，就执行两次出栈操作。然后把计算的结果在推入栈中。当扫描完整个后缀表达式后，栈中就...
[3.7.1]--307）栈的应用：后缀表达式求值.srt
04-03
[3.7.1]--307）栈的应用：后缀表达式求值.srt
[3.7.1]--307）栈的应用：后缀表达式求值.mp4
04-02
[3.7.1]--307）栈的应用：后缀表达式求值.mp4
数据结构-实验3-后缀表达式求值.doc
07-11
在计算机科学中，后缀表达式常用于利用栈实现表达式的求值。在这个实验中，目标是掌握栈的“后进先出”（LIFO）特性以及如何利用栈处理后缀表达式求值问题。 实验的核心在于设计一个算法，该算法能够读取一个不含...
栈应用：中缀表达式求值
热门推荐
我的笔记
12-02 2万+
后缀表达式求值比较简单，基本过程为：遇到数字则进栈，遇到运算符则出栈俩数字然后计算结果，再把结果入栈，过程比较简单，不再复习了，下面着重记录中缀表达式求值 中缀表达式求值可以先将中缀转后缀，再用后缀计算结果，但是，有点太麻烦，而另一种方式是利用两个栈直接求值，思想与上一个笔记中缀转后缀几乎一样，但稍有差别，中缀表达式求值基本过称为： 定义两个栈，stack1存储数字，stack2存储运算符，将字符...
基于栈的后缀算术表达式求值
sadbird1729的博客
05-14 1万+
@[topic] 题目描述：输入一个中缀算术表达式,将其转换为后缀表达式,然后对后缀表达式进行求值。运算符包括+ - * / =,参与运算的为小于10的自然数。 功能要求及说明： （1） 输入要求：可输入多组测试数据,每组数据对应一个算术表达式,当输入’=’ 时表示输入结束。 （2） 输出要求：对每组数据输出2行,第1行为中缀表达式对应的后缀式,第2行为 后缀式求值的结果 （3） 输入样例： 9+...
C++ 使用栈求解中缀、后缀表达式的值
y6123236的专栏
10-13 2657
表达式求值对于有知识积累的你而言，可以通过认知，按运算符的优先级进行先后运算。但对计算机而言，表达式仅是一串普通的信息而已，需要通过编码的方式告诉计算机运算法则，这个过程中栈起到了至关重要的作用。表达式由2操作数。运算符。在一个复杂的表达式中，操作数和运算符可以有多个，运算符之间存在优先级，且不同运算符所需要的操作数的数量也有差异。这时，表达式的计算过程就变得较复杂。为了简化问题，本文只限于讨论基于常量操作数和双目运算符的表达式。在计算机中，表达式的描述可以有以下3。
栈的应用——后缀表达式求值
qq_35424507的博客
08-24 729
// A code block 1. 若当前字符为数字时直接入栈 2. 若当前字符为运算符时，将两个字符出栈（当为 ‘-’或‘/’ 时用栈较用下面的数字减去上面的数字），并把结果压入栈中 3. 当所有的表达式都遍历完成之后，栈顶元素即为表达式运算结果 /* 栈在表达式中的应用--------求值 */ #include<stdio.h> #include<stdlib.h> #define MAXSIZE 60 struct Stack { char data[M
栈的应用之后缀表达式求值
my_superman的博客
04-03 1082
在这里使用的是顺序栈，头文件可参考前文.cpp文件：/*后缀表达式的求法*/ #include &lt;iostream&gt; #include &lt;strstream&gt; using namespace std; typedef float ElemType; const int StackMaxSize = 50; struct Stack { ElemType s...
C语言栈的应用——后缀表达式求值
那么大圆筒的博客
08-10 6546
算法思路 ​ 上次已经完成了由中缀表达式转后缀表达式的算法，而后缀表达式的优点就是可以从左至右直接读取，没有算数优先级的考量，所以直接进行运算即可。 ​ 该算法需要使用一个栈用来保存操作数，在读取到数字的时候，将数字压入栈中；如果读取到操作符，就弹出栈顶的两个元素，分别为op2和op1（先弹出来的元素为op2），将op1和op2与目前读取到的操作符进行计算，并将结果压回栈中。反复运行直到后缀表达式全部读取完成，此时栈中的结果即后缀表达式的结果。 具体过程 例后缀表达式12+3-45*2/+，定义一个栈num
[源码和文档分享]C语言的基于栈实现的表达式求值
qq_38474647的博客
12-11 490
一、目的 理解中缀表达式求值的过程 理解中缀转后缀表达式求值的过程 掌握堆栈的应用 二、问题描述 缀表达式，其中包含括号，加减乘除，乘方等运算，利用中缀表达式，对表达式分析并求值 入的中缀表达式转换为后缀形式，显示后缀形式，并通过后缀形式求值 三、数据结构 //运算符结构体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值