前缀表达式与后缀表达式求法（栈的应用）

最新推荐文章于 2024-06-10 21:38:37 发布
最新推荐文章于 2024-06-10 21:38:37 发布
阅读量1.7w 收藏 106
点赞数 9
分类专栏： 19年复习知识点 文章标签： C++ （逆）波兰表达式 前后缀表达式 栈 正则表达式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42416780/article/details/89812250
版权

1.前缀、中缀、后缀表达式
中缀表达式即为人们熟悉的数学运算式子写法。而前缀、后缀表达式是为了计算机计算方便的写法。
前缀表达式是一种没有括号的算术表达式，与中缀表达式不同的是，其将运算符写在前面，操作数写在后面。后缀表达式则是将操作数写在前面，运算符写在后面。
前缀表达式又称波兰表达式，后缀表达式又称逆波兰表达式。通过利用栈的特性，我们可以从中缀表达式得到前后缀表达式，轻松的计算出其结果。
我们先写一组表达式，后面就用这组表达式：

中缀：9*8+(14-8/2)*3
前缀：+ * 9 8 * - 14 / 8 2 3   //这里把每一个操作数或运算符用空格分开
后缀：9 8 * 14 8 2 / - 3 * +

如何存储前缀和后缀表达式呢？如果直接用字符串，那么数字之前就会混乱，所以我用了结构体存储：

struct A
{
	int a;
	char type;  //数字为0，符号为1
};
struct Poland    //前缀/后缀表达式的存储方式   不用string的原因是，无法从字符串中分开操作数
{
	char type;  //p前缀  s后缀
	int lenth;
	A *content;
};

2.中缀表达式转前缀表达式
①初始化两个栈S1,S2，从右往左扫描中缀式。

②遇到操作数：将其压入S2栈。

③遇到括号时：
若是右括号‘）’，将其压入S1栈；
若是左括号‘（’，则依次弹出S1栈的元素，并将其压入S2栈，直至S1栈栈顶元素为右括号‘）’，弹出这个右括号。

④遇到运算符时：
若S1栈为空或者其栈顶元素为右括号‘）’，将其压入S1。
否则，比较运算符和S1栈顶运算符（一定是运算符）的优先级：
若其优先级≥S1栈顶运算符，则将其压入S1；
若小于，则将S1栈顶运算符弹出并压入S2，重新进行步骤④。

⑤重复②③④直到到达中缀式最左边，将S1剩余元素压入S2。最后依次取出S2元素即为前缀表达式。

代码：

/*已知中缀表达式，求前缀表达式*/
Poland infix_to_prefix(string infix)
{
	stack<A> s1, s2;
	regex p("(\\d+)");   //用于查找数字的正则式
	string s = infix;
	reverse(s.begin(), s.end());   //求前缀式需要从右往左扫描，为了方便，直接颠倒字符串
	string::const_iterator iter = s.begin();
	string::const_iterator iter_end = s.end();
	while (iter < iter_end)
	{
		smatch result;
		if (iter >= iter_end)   //防止迭代器位置超出字符串
			break;
		if (*iter >= '0'&&*iter <= '9') //遇操作数   这里不能直接用regex_search，必须要确定后面的字符串第一个字符是数字
		{
			regex_search(iter, iter_end, result, p);
			string temp = result[0];
			int num = atoi(temp.c_str());  //string转int     c_str函数返回当前字符串的首字符地址
			A sym1;
			sym1.a = num;
			sym1.type = 0;
			s2.push(sym1);
			iter = result[0].second;  //别忘了更新迭代器位置，这里second表示查找到的数字在源串中后面部分串的首地址
		}
		else  //遇符号
		{
			char ope = *iter;
			A sym2;
			sym2.a = (int)ope;
			sym2.type = 1;
		label:
			if (ope == ')')   //遇右括号，直接入栈
			{
				s1.push(sym2);
			}
			else if (ope == '(')  //遇左括号，将栈内直到右括号之前的元素依次弹出压入S2
			{
				while (s1.top().a != (int)')')
				{
					A t = s1.top();
					s1.pop();
					s2.push(t);
				}
				//这里让)也出栈
				s1.pop();
			}
			else  //其他运算符，如 %/* >= +-
			{
				if (s1.empty() || (s1.top().a == (int)')'&&s1.top().type == 1))  //若s1为空或其栈顶为)，符号入栈s1   或者符号优先级>=栈顶符号
					s1.push(sym2);
				else
				{
					int pri = compare_priority(ope, (char)s1.top().a);  //这里判断符号优先级 1大于 0相等 -1小于
					if (pri >= 0)
					{
						s1.push(sym2);
					}
					else if (pri == -1)  //若优先级小于栈顶符号，则将栈顶符号弹出压入S2，继续比较
					{
						s2.push(s1.top());
						s1.pop();
						goto label;   //直接goto前面判断符号的开始位置
					}
				}
			}
			iter++;  //别忘了更新迭代器位置

		}
	}
	while (!s1.empty())
	{
		s2.push(s1.top());
		s1.pop();
	}

	/*以下部分为存储前缀表达式*/
	Poland prefix;
	prefix.type = 'p';
	prefix.lenth = s2.size();
	prefix.content = new A[prefix.lenth];  //结构体中定义的是存储首地址，需要在这里开辟合适大小的数组空间，存储length个操作数或符号数据
	int k = 0;
	while (!s2.empty())
	{
		A res = s2.top();
		A nres;
		s2.pop();
		if (res.type == 0)
		{
			string numm = to_string(res.a);
			reverse(numm.begin(), numm.end());  //因为之前将中缀式颠倒时，数字也颠倒了。这里要改回来
			nres.type = 0;
			nres.a = atoi(numm.c_str());
		}
		else
		{
			nres.type = 1;
			nres.a = res.a;
		}
		*(prefix.content + k) = nres;
		k++;
	}
	return prefix;

}

3.求前缀表达式的值
①初始化一个栈S，从右往左扫描前缀式。

②遇到操作数时，则将其压入栈S。

③遇到运算符时，取出栈S的栈顶元素和次顶元素，运行运算。栈顶元素 运算符 次顶元素 = 结果。将结果压入栈S。

④重复②③直到到达前缀式最左边，此时栈S栈顶元素即为计算结果。

代码：

/*求前缀表达式的值*/
int cal_prefix(Poland prefix)
{
	stack<A> s;
	int i = prefix.lenth - 1;
	while (i >= 0)
	{
		A temp = *(prefix.content + i);
		if (temp.type == 0)
		{
			s.push(temp);
		}
		else
		{
			A num1 = s.top();
			s.pop();
			A num2 = s.top();
			s.pop();
			A res;
			res.type = 0;
			if (temp.a == (int)'+')
			{
				res.a = num1.a + num2.a;
			}
			else if (temp.a == (int)'-')
			{
				res.a = num1.a - num2.a;
			}
			else if (temp.a == (int)'*')
			{
				res.a = num1.a * num2.a;
			}
			else if (temp.a == (int)'/')
			{
				res.a = num1.a / num2.a;
			}
			else if (temp.a == (int)'%')
			{
				res.a = num1.a % num2.a;
			}
			s.push(res);
		}
		i--;
	}
	return s.top().a;
}

4.中缀表达式转后缀表达式
与2类似，最主要的区别是，这里采用正序扫描。且左右括号的情况反过来了，且优先级比较处有微小区别，且最后结果要倒过来。

①初始化两个栈S1,S2，从右往左扫描中缀式。

②遇到操作数：将其压入S2栈。

③遇到括号时：
若是左括号‘（’，将其压入S1栈；
若是右括号‘）’，则依次弹出S1栈的元素，并将其压入S2栈，直至S1栈栈顶元素为左括号‘（’，弹出这个左括号。

④遇到运算符时：
若S1栈为空或者其栈顶元素为左括号‘（’，将其压入S1。
否则，比较运算符和S1栈顶运算符（一定是运算符）的优先级：
若其优先级>S1栈顶运算符，则将其压入S1；
若其优先级≤S1栈顶运算符，则将S1栈顶运算符弹出并压入S2，重新进行步骤④。

⑤重复②③④直到到达中缀式最右边。将S1剩余元素压入S2。最后依次取出S2元素进行倒序即为后缀表达式。

代码：

Poland infix_to_suffix(string infix)
{
	stack<A> s1, s2;
	regex p("(\\d+)");   //用于查找数字的正则式
	string s = infix;
	string::const_iterator iter = s.begin();
	string::const_iterator iter_end = s.end();

	while (iter < iter_end)
	{
		smatch result;
		if (iter >= iter_end)   //防止迭代器位置超出字符串
			break;
		if (*iter >= '0'&&*iter <= '9') //遇操作数   这里不能直接用regex_search，必须要确定后面的字符串第一个字符是数字
		{
			regex_search(iter, iter_end, result, p);
			string temp = result[0];
			int num = atoi(temp.c_str());  //string转int     c_str函数返回当前字符串的首字符地址
			A sym1;
			sym1.a = num;
			sym1.type = 0;
			s2.push(sym1);
			iter = result[0].second;  //别忘了更新迭代器位置，这里second表示查找到的数字在源串中后面部分串的首地址
		}
		else  //遇符号
		{
			char ope = *iter;
			A sym2;
			sym2.a = (int)ope;
			sym2.type = 1;
		label:
			if (ope == '(')   //遇左括号，直接入栈
			{
				s1.push(sym2);
			}
			else if (ope == ')')  //遇右括号，将栈内直到左括号之前的元素依次弹出压入S2
			{
				while (s1.top().a != (int)'(')
				{
					A t = s1.top();
					s1.pop();
					s2.push(t);
				}
				//这里让(也出栈
				s1.pop();
			}
			else  //其他运算符，如 %/* >= +-
			{
				if (s1.empty() || (s1.top().a == (int)'('&&s1.top().type == 1))  //若s1为空或其栈顶为(，符号入栈s1   或者符号优先级>栈顶符号
					s1.push(sym2);
				else
				{
					int pri = compare_priority(ope, (char)s1.top().a);  //这里判断符号优先级 1大于 0相等 -1小于
					if (pri > 0)
					{
						s1.push(sym2);
					}
					else if (pri == -1||pri==0)  //若优先级小于等于栈顶符号，则将栈顶符号弹出压入S2，继续比较
					{
						s2.push(s1.top());
						s1.pop();
						goto label;   //直接goto前面判断符号的开始位置
					}
				}
			}
			iter++;  //别忘了更新迭代器位置

		}
	}
	while (!s1.empty())
	{
		s2.push(s1.top());
		s1.pop();
	}
	/*以下部分为存储后表达式*/
	Poland suffix;
	suffix.type = 's';
	suffix.lenth = s2.size();
	suffix.content = new A[suffix.lenth];  //结构体中定义的是存储首地址，需要在这里开辟合适大小的数组空间，存储length个操作数或符号数据
	int k = suffix.lenth-1;  //这里要倒过来
	while (!s2.empty())
	{
		A res = s2.top();
		A nres;
		s2.pop();
		if (res.type == 0)
		{
			string numm = to_string(res.a);
			nres.type = 0;
			nres.a = atoi(numm.c_str());
		}
		else
		{
			nres.type = 1;
			nres.a = res.a;
		}
		*(suffix.content + k) = nres;
		k--;
	}
	return suffix;
}

5.求后缀表达式的值
与3类似，同样这里要正序扫描，且次顶元素在运算符前。
①初始化一个栈S，从右往左扫描后缀式。

②遇到操作数时，则将其压入栈S。

③遇到运算符时，取出栈S的栈顶元素和次顶元素，运行运算。次顶元素 运算符 栈顶元素 = 结果。将结果压入栈S。

④重复②③直到到达前缀式最右边，此时栈S栈顶元素即为计算结果。

代码：

/*求后缀表达式的值*/
int cal_suffix(Poland suffix)
{
	stack<A> s;
	int i = 0;
	while (i < suffix.lenth)
	{
		A temp = *(suffix.content + i);
		if (temp.type == 0)
		{
			s.push(temp);
		}
		else
		{
			A num2 = s.top();
			s.pop();
			A num1 = s.top();
			s.pop();
			A res;
			res.type = 0;
			if (temp.a == (int)'+')
			{
				res.a = num1.a + num2.a;
			}
			else if (temp.a == (int)'-')
			{
				res.a = num1.a - num2.a;
			}
			else if (temp.a == (int)'*')
			{
				res.a = num1.a * num2.a;
			}
			else if (temp.a == (int)'/')
			{
				res.a = num1.a / num2.a;
			}
			else if (temp.a == (int)'%')
			{
				res.a = num1.a % num2.a;
			}
			s.push(res);
		}
		i++;
	}
	return s.top().a;
}

6.测试

int main()   //     9*8+(14-8/2)*3  =102         14-31%(19-8*2)+(56-33/(12-4))  =65
{
	string infix;
	cin >> infix;
	Poland prefix = infix_to_prefix(infix);
	Poland suffix = infix_to_suffix(infix);
	cout << endl;

	cout << "前缀表达式的长度为：" << prefix.lenth << endl;
	for (auto i = 0; i < prefix.lenth; i++)
	{
		A temp = *(prefix.content + i);
		string ts = "";
		if (temp.type == 0)
			ts += to_string(temp.a);
		else
			ts += (char)temp.a;
		cout << ts << " ";
	}
	cout << endl;
	cout <<"前缀表达式的计算值为："<< cal_prefix(prefix) << endl;	

	cout << endl;

	cout << "后缀表达式的长度为：" << suffix.lenth << endl;
	for (auto i = 0; i < suffix.lenth; i++)
	{
		A temp = *(suffix.content + i);
		string ts = "";
		if (temp.type == 0)
			ts += to_string(temp.a);
		else
			ts += (char)temp.a;
		cout << ts << " ";
	}
	cout << endl;
	cout << "后缀表达式的计算值为：" << cal_suffix(suffix) << endl;
	return 0;
}

分别尝试了三组中缀表达式，结果如下：
9*8+(14-8/2)*3 =102
在这里插入图片描述
14-31%(19-8*2)+(56-33/(12-4)) =65
在这里插入图片描述
3+(7245/167+54*(6522-681%13+192))*7 =2536306
在这里插入图片描述

pissjello
关注
  • 9
    点赞
  • 踩
  • 106
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
前缀表达式、中缀表达式和后缀表达式 - 乘月归 - 博客园.pdf
03-15
转
数据结构和算法（栈的模拟、前中后缀表达式、表达式求值步骤和思路）
ECHO的博客
03-27 1157
1.栈的介绍 栈的英文为(stack) 栈是一个先入后出(FILO-First In Last Out)的有序列表。 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放...
前缀中缀后缀表达式介绍
实践求真知
03-06 1万+
一前缀表达式 1 前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前。 2 举例 (3+4)×5-6 对应的前缀表达式是： - × + 3 4 5 6 3前缀表达式的计算机求值过程 从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。 例如: (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 , 针对前缀表达...
什么是正交矩阵？
最新发布
...
06-10 1140
一个简单的2x2正交矩阵例子是旋转矩阵`，它代表了二维平面上的一个特定角度的旋转操作，且保持向量的长度和方向间的直角关系不变。因此，上述矩阵满足正交矩阵的定义。
【数据结构与算法】【12】前缀表达式、中缀表达式、后缀表达式
热门推荐
天天向上 Up Up Up (*^▽^*)
06-06 1万+
什么是前缀表达式、中缀表达式、后缀表达式前缀表达式、中缀表达式、后缀表达式，是通过树来存储和计算表达式的三种不同方式以如下公式为例(a+(b−c))∗d( a+(b-c) )*d(a+(b−c))∗d通过树来存储该公式，可以表示为 那么问题就来了，树只是一种抽象的数据结构，它必须要通过某个形式的文本来才能存储和输入此时，就有了三种表示方法：前缀表达式、中缀表达式、后缀表达式它们分别相当于树的前序遍历、中序遍历、后序遍历，前中后指的是遍历时符号的遍历顺序前序遍历：符号 - 左操作数 - 右操作数中序遍历：左操
前缀、中缀、后缀表达式及简易运算实现总结
凡的博客
07-17 4422
前缀、中缀、后缀表达式及简易运算实现总结
前缀、中缀和后缀表达式详解，中缀表达式到后缀表达式的转换规则，以及后缀表达式的计算规则，附计算代码
走过路过不要错过
11-06 1万+
大雾 广东人· 大雾穷横孤儿提供2398奋斗过于·1fwojei9fhgbuij李的萨科技发挥·khfbadlq穿梭在大城市的过程流程是肯定会牛逼出门时刻都回家初始模板和吃吗上课的破壁吃吗搜的看吹牛逼吃吗，搜谱大V南京m从吧水电费出生地 ...
前缀表达式和后缀表达式 - C++代码
m0_55464171的博客
07-05 3586
前缀表达式、后缀表达式的计算、转换规则
中缀表达式输入、转换与计算（前缀和后缀）内附流程图
11-17
表达式2*(9+6/3-5)+4，称为中缀表达式，表示成2 9 6 3 / + 5 - * 4 +称为后缀表达式，表示成+ * 2 - + 9 / 6 3 5 4称为前缀表达式。 ·基本要求 将中缀表达式，转换为后缀表达式和前缀表达式，再分别计算转换后的...
【Java数据结构与算法】 前缀中缀后缀表达式及转换
01-20
文章目录前缀表达式（波兰表达式）前缀表达式分析与介绍思路分析中缀表达式中缀表达式分析与介绍后缀表达式（逆波兰表达式）后缀表达式分析与介绍思路分析逆波兰计算器代码实现逆波兰计算器中缀表达式转换为后缀...
C++后缀表达式转前缀表达式
06-29
这个C++程序使用链式栈来实现后缀表达式转换为前缀表达式的操作。这种方法可以高效地处理大规模的表达式，并且可以灵活地处理不同的操作符和操作数。 Knowledge Points： 1.C++程序设计中，后缀表达式转换为前缀...
表达式求值_表达式求值栈_wrotey1q_栈表达式求值_
10-02
首先，表达式求值可以分为前缀表达式、中缀表达式和后缀表达式（也称为逆波兰表示法）三种常见形式。中缀表达式是我们日常使用的标准数学表达式形式，如 2 + 3 * 4。而前缀和后缀表达式则常用于计算过程中，因为它们...
[数据结构]7-21 求前缀表达式的值（25 分）
一杯糖不加咖啡
12-17 4068
7-21 求前缀表达式的值（25 分） *算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。前缀表达式指二元运算符位于两个运算数之前，例如2+3*(7-4)+8/4的前缀表达式是：+ + 2 * 3 - 7 4 / 8 4。请设计程序计算前缀表达式的结果值。 输入格式: 输入在一行内给出不超过30个字符的前缀表达式，只包含+、-、*、\以及运算数，不同对象（运算数、运算符号）之间以空格分...
【数据结构】前缀、中缀、后缀表达式
qq_42270373的博客
10-30 3011
概念 前缀表达式：前缀表达式是一种没有括号的算数表达式，它将运算符写在前面，操作数写在后面 中缀表达式：操作符处于操作数的中间。中缀表达式是人们常用的算术表示方法 后缀表达式：运算符位于操作数之后 举例： 前缀表达式：+-*/123 中缀表达式：(1+2)×3-7 后缀表达式：12+5×6- 计算方法： （1）前缀表达式：      规则：从右向左遍历表达式，遇到...
【尚硅谷】数据结构和算法——前缀、中缀、后缀表达式规则
weixin_54533016的博客
03-02 2441
1）前缀表达式又称波兰式，前缀表达式的运算符位于操作符之前。2）举例说明：(3+4)*5-6 对应的前缀表达式就是 - * + 3 4 5 6前缀表达式的计算机求值：从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得到的值即为表达式的结果。例如：(3+4)*5-6 对应的前端表达式就是 - * + 3 4 5 6，针对前缀表达式求值步骤如下：1）从右到左。
前缀表达式、中缀表达式、后缀表达式
逐梦苍穹的博客
05-30 4521
本文介绍三种表达式（前缀表达式、中缀表达式和后缀表达式）
数据结构与算法——前缀、中缀、后缀表达式
qq_50233116的博客
10-12 5333
前缀、中缀、后缀表达式
数据结构【一】：前缀表达式与后缀表达式的区别
Santiago
04-13 1198
在早期计息机系统中，由于没有括号规定运算顺序，因此，依靠出栈和入栈两种方式，限定元素和符号之间的关系确定了前缀表达式和后缀表达式两种运算方式，中缀表达式即为普通的运算表达式；当遇到运算符，则将栈顶的两个元素弹出栈外进行运算，将栈顶第1个元素记为top1，栈顶的第2的元素记为top2，运算结束后将结果压入栈中，继续遍历字符串，直到前缀表达式的最左端，最后运算得出的值为该前缀表达式的结果。运算结束后将结果压入栈中，继续遍历字符串，直到前缀表达式的最右端，最后运算得出的值为该前缀表达式的结果。
前缀表达式--转换+求值
山可行,海可平
10-06 635
到现在写的比较多的是后缀表达式，然而到前缀表达式还没什么思路 这里整理一下中缀表达式转前缀表达式及前缀表达式的求值 中缀转前缀 转换原则 有个比较简单的看法：（选择题可以用） 将中缀表达式按计算顺序加括号，前缀表达式则将括号中的运算符移到括号前面，后缀则移到后面，再将所有括号去掉即可 eg. 中缀表达式：a+b*c-(d+e) 所有运算单位加括号：((a+(b*c))-(d+e)) 1. 前缀表达式：把运算符号移动到对应的括号前面 变为：-( +(a *(bc)) +(d
Python语言写前缀表达式
07-15
当要处理前缀表达式时，可以使用递归和栈的思路来实现。以下是一个将前缀表达式计算出结果的Python代码示例： ```python def evaluate_prefix(expression): if len(expression) == 0: return None token = expression.pop(0) # 从表达式中获取下一个令牌 if token.isdigit(): # 如果是数字，则直接返回 return float(token) elif token in ['+', '-', '*', '/']: # 如果是运算符，则递归计算操作数 operand1 = evaluate_prefix(expression) operand2 = evaluate_prefix(expression) if operand1 is None or operand2 is None: # 如果操作数为空，则返回None return None if token == '+': return operand1 + operand2 elif token == '-': return operand1 - operand2 elif token == '*': return operand1 * operand2 elif token == '/': if operand2 == 0: # 避免除以零的情况 return None return operand1 / operand2 return None prefix_expression = input("请输入前缀表达式: ").split() result = evaluate_prefix(prefix_expression) if result is None: print("无效的表达式") else: print("结果为:", result) ``` 在这段代码中，我们使用了一个栈来存储操作数。我们从左到右遍历前缀表达式，如果遇到数字，则直接将其作为操作数入栈；如果遇到运算符，则从栈中弹出两个操作数进行运算，并将结果重新入栈。最后栈中剩余的唯一元素即为表达式的结果。 请注意，这段代码假设输入的前缀表达式是合法且正确格式化的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值