中缀表达式求值​--湖南大学 “数据结构与算法”实验一 线性结构 ​

湖南大学 “数据结构与算法”实验一 线性结构 

背景知识：

前缀表达式、后缀表达式和中缀表达式是对算术表达式的不同记法，
它们的主要区别在于运算符相对于操作数的位置不同。

中缀表达式是最为人们所熟悉的表达方式，也是我们日常书写和阅读数学表达式时常用的形式。
在中缀表达式中，运算符位于操作数之间，例如“3 + 4 * 5”。这种表达方式直观易懂，但对计算机来说解析却相对复杂，因为需要处理运算符的优先级和括号。

前缀表达式，也称为波兰式，是一种没有括号的算术表达式，其中运算符写在前面，操作数写在后面。
例如，“+ 3 4”表示3加4。前缀表达式的优点在于其计算顺序完全由运算符和操作数的位置决定，无需额外的括号来指示优先级。这对计算机来说非常便于解析和计算。

后缀表达式，又称为逆波兰表示法，与前缀表达式相反，它将运算符写在操作数之后。
例如，“3 4 +”同样表示3加4。后缀表达式的计算过程通常使用栈数据结构来实现，
从左到右遍历表达式，遇到操作数就压入栈中，遇到运算符就从栈中弹出相应数量的操作数进行计算，然后将结果再压入栈中。
这种方式同样避免了中缀表达式中需要处理的优先级和括号问题。

总的来说，前缀表达式、后缀表达式和中缀表达式各有其特点和应用场景。
前缀和后缀表达式更适合计算机解析和计算，而中缀表达式则更符合人们的书写和阅读习惯。
在编译过程中，中缀表达式通常需要转换为前缀或后缀表达式以便计算机进行计算。
 

补充知识：

字符类型判断函数: (非string函数)

isdigit(c):   判断字符c是否为数字字符
isalpha(c):  判断字符c是否为字母
islower(c):  判断字符c是否为小写
isupper(c): 判断字符c是否为大写
说明:返回非0表示真，返回0表示假
 

测试样例：

3+4*(5-3)# 
11 

3+;4*(5-3)#
NO

1+2*(1+2*8-9)-9#
8

题目描述：

代码实现：

#include<iostream>
#include<vector>
#include<stack>
using namespace std;
struct node {
	int num;
	char c;
};

int JudgeChar(char&ch) {
	if (ch == '-' || ch == '+')
		return 1;
	else if (ch == '*' || ch == '/')
		return 2;
	else if (ch == '(')
		return 3;
	else if (ch == ')')
		return 4;
	else if (ch == '#')
		return 5;
	else if (isdigit(ch))
		return 6;
	else
		return 0;
}

bool InToPost(vector<node>& vc, string& s) {
	stack<char>sk;
	int x = 0;
	int cnt = 0;
	for (int i = 0; i < (int)s.size()-1; i++) {
		cnt = JudgeChar(s[i]);

		/*如果是运算符, 跟栈首元素比较，
		 如果栈首元素的优先级 >= s[i]
		 栈首元素出栈，进入vector数组，s[i] 入栈
		*/
		switch (cnt){
		case 1:
			while (sk.size() && (sk.top() == '-' || sk.top() == '+' || sk.top() == '/' || sk.top() == '*')) {
				vc.push_back(node{ -1,sk.top() });
				sk.pop();
			}
			sk.push(s[i]);
			break;
		case 2:
			while (sk.size() && (sk.top() == '*' || sk.top() == '/')) {
				vc.push_back(node{ -1,sk.top() });
				sk.pop();
			}
			sk.push(s[i]);
			break;
		case 3:
			sk.push(s[i]);
			break;
		case 4:
			while (sk.size() && sk.top() != '(') {
				vc.push_back(node{ -1,sk.top() });
				sk.pop();
			}
			sk.pop();
			break;
		case 5:
			break;
		case 6:
			//如果是数字，找到完整的数字，再存入vector数组
			x = x * 10 +s[i] - '0';
			if (!isdigit(s[i + 1])) {
				vc.push_back(node{ x,0 });
				x = 0;
			}
			break;
		default:
			return 0;
		}
	}
	while (sk.size()) {
		vc.push_back(node{ -1,sk.top() });
		sk.pop();
	}
	return 1;
}

int Getresult(vector<node>& vec) {
	stack<int>stk;
	// C++ 新用法
	// 定义一个变量，用它去遍历同类型的数组

	for (node n1 : vec) {
		if (n1.c == 0) {
			stk.push(n1.num);
		}
		else {
			int x = stk.top();
			stk.pop();
			int y = stk.top();
			stk.pop();
			if (n1.c == '-')
				stk.push(y - x);
			else if (n1.c == '+')
				stk.push(y + x);
			else if (n1.c == '/')
				stk.push(y / x);
			else if (n1.c == '*')
				stk.push(y * x);
		}
	}
	return stk.top();
}

int main() {
	string s;
	cin >> s;
	vector<node>vc;
	if (InToPost(vc, s)==false) {
		cout << "NO";
	}
	else {
		cout << Getresult(vc);
	}
	return 0;
}

最近发现可以先判断字符的类型再决定下一步操作

这里用switch结构更方便(大家一定要加break语句，不然就会像我一样调试好久去Debug)

代码如下：

#include<iostream>
#include<vector>
#include<stack>
using namespace std;
struct node {
	int num;
	char c;
};

int JudgeChar(char&ch) {
	if (ch == '-' || ch == '+')
		return 1;
	else if (ch == '*' || ch == '/')
		return 2;
	else if (ch == '(')
		return 3;
	else if (ch == ')')
		return 4;
	else if (ch == '#')
		return 5;
	else if (isdigit(ch))
		return 6;
	else
		return 0;
}

bool InToPost(vector<node>& vc, string& s) {
	stack<char>sk;
	int x = 0;
	int cnt = 0;
	for (int i = 0; i < (int)s.size()-1; i++) {
		cnt = JudgeChar(s[i]);

		/*如果是运算符, 跟栈首元素比较，
		 如果栈首元素的优先级 >= s[i]
		 栈首元素出栈，进入vector数组，s[i] 入栈
		*/
		switch (cnt){
		case 1:
			while (sk.size() && (sk.top() == '-' || sk.top() == '+' || sk.top() == '/' || sk.top() == '*')) {
				vc.push_back(node{ -1,sk.top() });
				sk.pop();
			}
			sk.push(s[i]);
			break;
		case 2:
			while (sk.size() && (sk.top() == '*' || sk.top() == '/')) {
				vc.push_back(node{ -1,sk.top() });
				sk.pop();
			}
			sk.push(s[i]);
			break;
		case 3:
			sk.push(s[i]);
			break;
		case 4:
			while (sk.size() && sk.top() != '(') {
				vc.push_back(node{ -1,sk.top() });
				sk.pop();
			}
			sk.pop();
			break;
		case 5:
			break;
		case 6:
			//如果是数字，找到完整的数字，再存入vector数组
			x = x * 10 +s[i] - '0';
			if (!isdigit(s[i + 1])) {
				vc.push_back(node{ x,0 });
				x = 0;
			}
			break;
		default:
			return 0;
		}
	}
	while (sk.size()) {
		vc.push_back(node{ -1,sk.top() });
		sk.pop();
	}
	return 1;
}

int Getresult(vector<node>& vec) {
	stack<int>stk;
	// C++ 新用法
	// 定义一个变量，用它去遍历同类型的数组

	for (node n1 : vec) {
		if (n1.c == 0) {
			stk.push(n1.num);
		}
		else {
			int x = stk.top();
			stk.pop();
			int y = stk.top();
			stk.pop();
			if (n1.c == '-')
				stk.push(y - x);
			else if (n1.c == '+')
				stk.push(y + x);
			else if (n1.c == '/')
				stk.push(y / x);
			else if (n1.c == '*')
				stk.push(y * x);
		}
	}
	return stk.top();
}

int main() {
	string s;
	cin >> s;
	vector<node>vc;
	if (InToPost(vc, s)==false) {
		cout << "NO";
	}
	else {
		cout << Getresult(vc);
	}
	return 0;
}