前缀表达式和后缀表达式 - C++代码

已于 2022-07-05 11:49:47 修改
阅读量3.3k 收藏 24
点赞数 6
分类专栏： 数据结构和算法 文章标签： c++ 开发语言
于 2022-07-05 11:48:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55464171/article/details/125616296
版权

目录


刷题向文章，不介绍原理，只介绍规则

速览

算术表达式分为：

  • 前缀表达式(波兰式)
  • 后缀表达式(逆波兰式)
  • 中缀表达式

中缀表达式是我们最熟悉的表达式，是常见的运算式，如下所示：

(2 + 3) * 4 - 5

这就是一个中缀表达式
相对于中缀表达式，前缀表达式的运算符在操作数之前，把上面的中缀表达式改写成前缀表达式为：

- * + 2 3 4 5

注意，并不是所有运算符在所有数字之前，如：

+ - 1 2 * 3 5

也可以是前缀表达式

前缀表达式

前缀表达式的运算规则

从右向左依次扫描表达式，如果扫描到数字，则把数字压入栈
如果扫描到运算符，则依次弹出栈顶的两个数字进行计算，并把计算结果压入栈

例：计算前缀表达式 - * +2345 的值

扫描值堆栈计算值
55
45 4
35 4 3
25 4 3 2
+5 4 52+3=5
*5 205*4=20
-1520-5=15

前缀表达式的值为 15

中缀表达式转换为前缀表达式

创建2个空栈 S1 和 S2，S1 为符号栈，S2 为临时栈，从右向左扫描中缀表达式

  1. 如果遇到数字，压入 S2 栈中
  2. 如果遇到符号：
    如果 S1 为空栈，或者 S1 栈顶为右括号，直接压入 S1 中
    如果扫描到的符号优先级大于等于 S1 栈顶的符号，直接压入 S1 中
    如果扫描到的符号优先级小于 S1 栈顶的符号，则把 S1 栈顶的符号弹出并压入 S2，重复这一步骤，直到可以把扫描到的符号压入 S1
  3. 如果遇到括号：
    如果遇到左括号，直接压入 S1
    如果遇到右括号，依次弹出 S1 栈顶的符号并压入 S2，直到遇到左括号时，丢弃这一对括号
    最后，依次把 S1 栈顶元素弹出压入 S2 中，依次弹出 S2 栈顶元素，得到前缀表达式

例：把中缀表达式 1+((2+3) * 4)-5 转换为前缀表达式

扫描值操作S1S2
5压入S25
-压入S1-5
)压入S1-)5
4压入S2-)5 4
*压入S1-)*5 4
)压入S1-)*)5 4
3压入S2-)*)5 4 3
+压入S1-)*)+5 4 3
2压入S2-)*)+5 4 3 2
(弹出+，压入S2-)*5 4 3 2+
(弹出*，压入S2-5 4 3 2+*
+压入S1-+5 4 3 2+*
1压入S2-+5 4 3 2+*1
NULL依次弹出S1栈顶压入S25 4 3 2+*1+ -

所求前缀表达式为：-+1*+2345

代码实现：

// 前缀表达式练习 - 只能输入 0-9 的数
#include<iostream>
using std::cin;
using std::cout;
using std::endl;
#include<string>
using std::string;
#include<stack>
using std::stack;

bool isoperator(int _C);
bool isbrackets(int _C);

int main(int argc, char*argv[]) {
	// 输入中缀表达式
	string infix;
	cin >> infix;
	// 中缀表达式 => 前缀表达式
	stack<char>S1, S2;
	for (auto it = infix.crbegin(); it != infix.crend(); it++) {
		if (isdigit(*it))S2.push(*it);
		else if (isoperator(*it)) {
		CASE_ISOPERATOR:
			if (S1.empty() || ')' == S1.top())S1.push(*it);
			else if ('+' == S1.top() || '-' == S1.top())S1.push(*it);
			else if ('*' == *it || '/' == *it)S1.push(*it);
			else {
				S2.push(S1.top());
				S1.pop();
				goto CASE_ISOPERATOR;
			}
		}
		else if (isbrackets(*it)) {
			if (')' == *it)S1.push(*it);
			else {
				while (!isbrackets(S1.top())) {
					S2.push(S1.top());
					S1.pop();
				}
				S1.pop();
			}
		}
	}
	while (!S1.empty()) {
		S2.push(S1.top());
		S1.pop();
	}
	string prefix;
	while (!S2.empty()) {
		prefix.push_back(S2.top());
		S2.pop();
	}
	// 计算前缀表达式的值
	stack<int>value;
	for (auto it = prefix.crbegin(); it != prefix.crend(); it++) {
		if (isdigit(*it))value.push(*it - '0');
		else {
			int top, second_top;
			top = value.top();
			value.pop();
			second_top = value.top();
			value.pop();
			switch (*it) {
			case'+':value.push(top + second_top); break;
			case'-':value.push(top - second_top); break;
			case'*':value.push(top*second_top); break;
			case'/':value.push(top / second_top); break;
			}
		}
	}
	// 输出前缀表达式及其值
	cout << prefix << '=' << value.top() << endl;
	return 0;
}

bool isoperator(int _C) {
	return '+' == _C || '-' == _C || '*' == _C || '/' == _C ? true : false;
}

bool isbrackets(int _C) {
	return '(' == _C || ')' == _C ? true : false;
}

后缀表达式

后缀表达式的运算

从左向右依次扫描表达式，如果扫描到数字，则把数字压入栈
如果扫描到运算符，则弹出栈顶的两个数字进行计算，并把计算结果压入栈
（和前缀表达式不同，结果 = 次顶数字 operator 顶部数字）

例：计算后缀表达式 23+4 * 5- 的值

扫描值堆栈计算值
22
32 3
+52+3=5
45 4
*205*4=20
5205
-1520-5=15

后缀表达式的值为 15

中缀表达式转换为后缀表达式

创建2个空栈 S1 和 S2，S1 为符号栈，S2 为临时栈，从左向右扫描中缀表达式

  1. 如果遇到数字，压入 S2 栈中
  2. 如果遇到符号：
    如果 S1 为空栈，或者 S1 栈顶为左括号，直接压入 S1 中
    如果扫描到的符号优先级大于 S1 栈顶的符号，直接压入 S1 中
    (注意前缀表达式是大于等于，而后缀表达式只有大于才可以直接压入)
    如果扫描到的符号优先级小于 S1 栈顶的符号，则把 S1 栈顶的符号弹出并压入 S2，重复这一步骤，直到可以把扫描到的符号压入 S1
  3. 如果遇到括号：
    如果遇到右括号，直接压入 S1
    如果遇到左括号，依次弹出S1栈顶的符号并压入 S2，直到遇到左括号时，丢弃这一对括号
    最后，依次把 S1 栈顶元素弹出压入 S2 中，依次弹出 S2 栈顶元素，“反向输出”，得到前缀表达式

例：把中缀表达式 1+((2+3) * 4)-5 转换为前缀表达式

扫描值操作S1S2
1压入S2NULL1
+压入S1+1
(压入S1+(1
(压入S1+((1
2压入S2+((1 2
+压入S1+((+1 2
3压入S2+((+1 2 3
)弹出+，压入S2+(1 2 3+
*压入S1+(*1 2 3+
4压入S2+(*1 2 3+4
)弹出*，压入S2+1 2 3+4*
-弹出+压入S1，压入S1-1 2 3+4*+
5压入S2-1 2 3+4*+5
NULL依次弹出S1顶部元素，压入S21 2 3+4*+5-

所求后缀表达式为：1 2 3+4*+5-

代码实现：

// 后缀表达式练习 - 只能输入 0-9 的数
#include<iostream>
using std::cin;
using std::cout;
using std::endl;
#include<string>
using std::string;
#include<stack>
using std::stack;

bool isoperator(int _C);
bool isbrackets(int _C);

int main(int argc, char*argv[]) {
	// 输入中缀表达式
	string infix;
	cin >> infix;
	// 中缀表达式 => 后缀表达式
	stack<char>S1, S2;
	for (auto it = infix.cbegin(); it != infix.cend(); it++) {
		if (isdigit(*it))S2.push(*it);
		else if (isoperator(*it)) {
		CASE_ISOPERATOR:
			if (S1.empty() || '(' == S1.top())S1.push(*it);
			else if (('+' == S1.top() || '-' == S1.top()) && ('*' == *it || '/' == *it))S1.push(*it);
			else {
				S2.push(S1.top());
				S1.pop();
				goto CASE_ISOPERATOR;
			}
		}
		else if (isbrackets(*it)) {
			if ('(' == *it)S1.push(*it);
			else {
				while (!isbrackets(S1.top())) {
					S2.push(S1.top());
					S1.pop();
				}
				S1.pop();
			}
		}
	}
	while (!S1.empty()) {
		S2.push(S1.top());
		S1.pop();
	}
	string prefix;
	while (!S2.empty()) {
		prefix.insert(prefix.begin(), S2.top());
		S2.pop();
	}
	// 计算后缀表达式的值
	stack<int>value;
	for (auto it = prefix.cbegin(); it != prefix.cend(); it++) {
		if (isdigit(*it))value.push(*it - '0');
		else {
			int top, second_top;
			top = value.top();
			value.pop();
			second_top = value.top();
			value.pop();
			switch (*it) {
			case'+':value.push(second_top + top); break;
			case'-':value.push(second_top - top); break;
			case'*':value.push(second_top*top); break;
			case'/':value.push(second_top / top); break;
			}
		}
	}
	// 输出后缀表达式及其值
	cout << prefix << '=' << value.top() << endl;
	return 0;
}

bool isoperator(int _C) {
	return '+' == _C || '-' == _C || '*' == _C || '/' == _C ? true : false;
}

bool isbrackets(int _C) {
	return '(' == _C || ')' == _C ? true : false;
}

优化代码：
// 后缀表达式求值
#include<iostream>
using std::cin;
using std::cout;
using std::endl;
#include<string>
using std::string;
#include<stack>
using std::stack;

bool isop(char _C);
void orgnize(string&str);

int main() {
	string input, buffer;
	while (!cin.eof()) {
		cin >> buffer;
		input.append(buffer);
		input.push_back(32);
		buffer.clear();
	}
	orgnize(input);
	stack<int>value;
	for (auto it = input.begin(); it != input.end();) {
		if (isdigit(*it)) {
			while (isdigit(*it))
				buffer.push_back(*it++);
			value.push(atoi(buffer.c_str()));
			buffer.clear();
		}
		else if (isop(*it)) {
			int top, second_top;
			top = value.top();
			value.pop();
			second_top = value.top();
			value.pop();
			switch (*it++) {
			case'+':value.push(second_top + top); break;
			case'-':value.push(second_top - top); break;
			case'*':value.push(second_top * top); break;
			case'/':value.push(second_top / top); break;
			}
		}
		else it++;
	}
	cout << "postfix(" << input << ")=" << value.top() << endl;
	return 0;
}

bool isop(char _C) {
	return '+' == _C || '-' == _C || '*' == _C || '/' == _C ? true : false;
}

void orgnize(string&str) {
	while (!str.empty())
		if (isspace(*str.rbegin()))str.pop_back();
		else break;
	while (!str.empty())
		if (isspace(*str.begin()))str.erase(str.begin());
		else break;
	for (auto it = str.begin(); it != str.end();)
		if (isspace(*it++))
			while (isspace(*it))it = str.erase(it);
	for (auto it = str.begin(); it != str.end() - 1; it++) {
		if (isdigit(*it) && isop(it[1]))
			it = str.insert(it + 1, 32);
		else if (isop(*it) && (isdigit(it[1]) || isop(it[1])))
			it = str.insert(it + 1, 32);
	}
}

// 中缀 - 后缀转换
// infix to postfix
#include<iostream>
using std::cin;
using std::cout;
using std::ostream;
using std::endl;
#include<string>
using std::string;
#include<stack>
using std::stack;
#include<vector>
using std::vector;

struct CharInt {
	bool ischar;
	int charint;
	CharInt(bool isch, int chint) :ischar(isch), charint(chint) {}
};
ostream&operator<<(ostream&output, CharInt x) {
	if (x.ischar)output << static_cast<char>(x.charint);
	else output << x.charint;
	return output;
}

bool isop(char _C) {
	return '+' == _C || '-' == _C || '*' == _C || '/' == _C ? true : false;
}

int main() {
	char buffer[128];
	cin.getline(buffer, sizeof(buffer));
	stack<char>S1;
	stack<CharInt>S2;
	for (auto it = buffer; *it;) {
		if (isdigit(*it)) {
			string temp;
			while (isdigit(*it))
				temp.push_back(*it++);
			S2.push(CharInt(false, atoi(temp.c_str())));
		}
		else if (isop(*it)) {
		CASE_ISOP:
			if (S1.empty() || '(' == S1.top())S1.push(*it);
			else if (('+' == S1.top() || '-' == S1.top()) && ('*' == *it || '/' == *it))
				S1.push(*it);
			else {
				S2.push(CharInt(true, S1.top()));
				S1.pop();
				goto CASE_ISOP;
			}
			it++;
		}
		else if ('(' == *it)S1.push(*it++);
		else if (')' == *it++) {
			while (S1.top() != '(') {
				S2.push(CharInt(true, S1.top()));
				S1.pop();
			}
			S1.pop();
		}
	}
	while (!S1.empty()) {
		S2.push(CharInt(true, S1.top()));
		S1.pop();
	}
	vector<CharInt>output;
	while (!S2.empty()) {
		output.insert(output.begin(), S2.top());
		S2.pop();
	}
	for (auto it : output)
		cout << it << ' ';
	cout.put(10);
	return 0;
}
透小犹
关注
  • 6
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简易计算器 C++实现 基于栈 中缀转后缀
07-30
C++基于栈的建议计算器，支持+、-、*、/ 的基本运算。输入中缀表达式，转化成后缀表达式后再输出计算结果。自动检查括号不匹配、除数为0等异常。
C++后缀表达式转前缀表达式
06-29
C++程序，将后缀表达式用栈转换为前缀表达式
数据结构-实验3-后缀表达式求值.doc
07-11
1. 实验目的 1) 掌握栈"后进先出"的特点； 2) 掌握栈的典型应用——后缀表达式求值。 2. 实验内容 1) 用键盘输入一个整数后缀表达式（操作数的范围是0～9，运算符只含(、(、*、/，而 且中间不可以有空格），使用循环程序从左向右读入表达式； 2) 如果读入的是操作数，直接进入操作数栈； 3) 如果读入的是运算符，立即从操作数栈取出所需的操作数，计算操作数运算的值，并 将计算结果存回操作数栈； 4) 检验程序运行结果。 3. 实验要求 1) 分析后缀表达式求值的算法思想，用C（C++）语言完成程序设计。 2) 上机调试通过实验程序。 3) 给出具体的算法分析，包括时间复杂度和空间复杂度等。 4) 撰写实验报告（把输入实验数据及运行结果用抓图的形式粘贴到实验报告上）。 5) 本程序调试通过以后，添加到原教材验证性实验3的菜单中去。 4. 实验步骤与源程序 实验步骤 我先从具体的问题中抽象出适当的数学模型，然后设计出相应的算法，其中，需要设 计一个函数来求后缀表达式，设计另外一个函数来求后缀表达式的值，最后，编写主函 数，串接程序，并调试程序，得出实验结果。 源代码 #inclu
数据结构课设——表达式求值（c++）
01-08
表达式是数据运算的基本形式。人们的书写习惯是中缀式，如：11+22*（7-4）/3.中缀式的计算按运算符的优先级及括号优先的原则，相同级别从左到右进行计算。表达式还有后缀表达式（如：11 22 7 4 - * 3 / +）和前缀表达式（+ 11 / * 22 - 7 4 3）。后缀表达式和前缀表达式中没有括号，给计算带来方便。如后缀表达式计算时按运算符出现的先后进行计算。本设计的主要任务是进行表达式形式的转换及不同形式的表达式计算。
C++前中后缀表达式转表达式二叉树
05-17
选择输入前中后缀表达式，建立表达式二叉树，再前序中序后序遍历二叉树，输出三种形式的表达式
算法：什么是前缀表达式
OceanStar的博客
05-24 1万+
算术表达式是最常用的表达式，又称为数值表达式。它是通过算术运算符来进行运算的数学公式。 表达式计算 (expression evaluation) 是程序设计语言编译中的一个最基本问题，也是早期计算机语言研究的一项重要成果，它使得高级语言程序员可以使用与数学形式相一致的方式书写表达式。 一般我们接触比较熟悉的是 中缀表达式 。 中缀表达式是常见的运算表达式，如 ( 3 + 4 ) × 5 - 6 。中缀表达式在我们日常生活中应用最为广泛，也最符合人的计算思维。 今天来科普一下比较不常用的前缀表达式。 前缀
前缀表达式、中缀表达式、后缀表达式
逐梦苍穹的博客
05-30 4280
本文介绍三种表达式（前缀表达式、中缀表达式和后缀表达式）
数据结构与算法——前缀、中缀、后缀表达式
qq_50233116的博客
10-12 4438
前缀、中缀、后缀表达式
前缀中缀后缀表达式介绍
实践求真知
03-06 1万+
一前缀表达式 1 前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前。 2 举例 (3+4)×5-6 对应的前缀表达式是： - × + 3 4 5 6 3前缀表达式的计算机求值过程 从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。 例如: (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 , 针对前缀表达...
前缀表达式，中缀表达式和后缀表达式的定义与联系（超详细）
weixin_62268437的博客
04-03 3942
目录 前缀、中缀、后缀表达式 前缀表达式 前缀表达式的计算机求值 中缀表达式 后缀表达式 后缀表达式的计算机求值 中缀表达式转化为前缀和后缀表达式 小结 前缀、中缀、后缀表达式 前缀、中缀、后缀表达式是对表达式的不同记法，其区别在于运算符相对于操作数的位置不同，前缀表达式的运算符位于操作数之前，中缀和后缀同理 举例： 中缀表达式：1 + (2 + 3) × 4 - 5 前缀表达式：- + 1 × + 2 3 4 5 后缀表达式：1 2 3 + 4 × + 5 - 前缀表达式 前
数据结构与算法学习01之前缀表达式（波兰表达式）、中缀表达式、后缀表达式（逆波兰表达式）
lzh_jk1b_xyxy的博客
04-15 1319
前缀表达式（波兰表达式） 概念：前缀表达式的运算符位于操作符之前 举例：(3+4)*5-6,对应的前缀表达式就是 - * + 3 4 5 6 前缀表达式的计算机求值： 从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算付对它们做相应的计算（栈顶元素和次顶元素），并将结果入栈：重复上述过程知道表达式最左端，最后运算得出的值即为表达式的结果。 例如：(3+4)*5...
【c++】后缀表达式求值（详解）
m0_74044018的博客
09-12 2997
后缀表达式的介绍和详细代码实现，计算逆波兰表达式的结果，用C++实现
数据结构与算法(8):前缀表达式(波兰表达式),中缀表达式,后缀表达式(逆波兰表达式:实例逆波兰计算器)
qq_42400763的博客
09-14 896
一:前缀表达式的计算机求值   从右到左扫描表达式,遇到了数字,就将数字压入堆栈,遇到运算符就将运算符压入堆栈,弹出栈顶的两个数,用运算符对他们做相应的计算.(栈顶元素,和次顶元素).并将结果入栈,接着重复上述的过程指导表达式的最左端,最后运算得出的值即为表达式的结果 举个例子:(3+4)*5-6对应的前缀表达式就是-*+3456,针对前缀表达式求值步骤如下: 从右到左进行扫描,将6543依次压入栈中 遇到+运算符后弹出3和4(3为栈顶一个元素,4为次顶元素),计算出3+4的值后,得到的7压入栈中. 接下
前缀表达式（波兰表达式）介绍及其代码实现（Java）
代码之美
10-10 5732
1 前缀表达式介绍 前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前举例说明： (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 1.1 前缀表达式的计算机求值过程 从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素和次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。 1.2 前缀表达式的计算过程举例说明 例如: (3+4)×5-6 对应的前缀表达式就是 - × +
数据结构——前缀、中缀、后缀表达式实现和转换（Java）
m0_52861211的博客
03-30 2839
前缀表达式，中缀表达式，后缀表达式，前缀表达式计算器，后缀表达式计算器，中缀表达式转化后缀表达式。
前缀/中缀/后缀----表达式之间的相互转换
qq_40877281的博客
04-18 1万+
前缀/中缀/后缀----表达式 三种表达式 三者之间互相转换 中缀->前缀 and 中缀->后缀 后缀->中缀 and 前缀->中缀 后缀->前缀 and 前缀->后缀 代码实现 中缀转后缀 中缀转前缀 三种表达式 前缀表达式: +ab, 这种也叫做波兰式 中缀表达式: a+b, 这种正常表达式需要带括号, 而波兰式不用带括号 后缀表达式: ab+, 这种也叫做逆波兰式 三者之间互相转换 中缀->前缀 and 中缀->后缀 a+b..
【数据结构与算法】【12】前缀表达式、中缀表达式、后缀表达式
热门推荐
命运之手
06-06 1万+
什么是前缀表达式、中缀表达式、后缀表达式前缀表达式、中缀表达式、后缀表达式，是通过树来存储和计算表达式的三种不同方式以如下公式为例(a+(b−c))∗d( a+(b-c) )*d(a+(b−c))∗d通过树来存储该公式，可以表示为 那么问题就来了，树只是一种抽象的数据结构，它必须要通过某个形式的文本来才能存储和输入此时，就有了三种表示方法：前缀表达式、中缀表达式、后缀表达式它们分别相当于树的前序遍历、中序遍历、后序遍历，前中后指的是遍历时符号的遍历顺序前序遍历：符号 - 左操作数 - 右操作数中序遍历：左操
前缀、中缀、后缀表达式及简易运算实现总结
凡的博客
07-17 2465
前缀、中缀、后缀表达式及简易运算实现总结
第 5 章 栈
Oneby的博客
08-06 5648
第 5 章 栈 1、栈的基本介绍 1.1、栈的实际需求 请计算表达式：[722-5+1-5+3-3] 的值 请问: 计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算，因为我们看这个算式 7 * 2 * 2 - 5，但是计算机怎么理解这个算式的 对计算机而言， 它接收到的就是一个字符串， 我们讨论的是这个问题：栈 1.2、栈的基本性质 栈的英文为(stack) 栈是一个**先入后出(FILO-First In Last Out)**的有序列表。 栈(stack)是限制线性表中元素的插入和
c++中缀表达式转前缀后缀表达式
最新发布
10-05
而前缀表达式和后缀表达式是中缀表达式的另外两种等价的写法。 将中缀表达式转换为前缀表达式的方法如下： 1. 从右到左遍历中缀表达式的每个字符。 2. 如果字符是操作数，直接输出到前缀表达式。 3. 如果字符是操作...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值