设计一个算法，将一般算术表达式转化为逆波兰表达式，并求逆波兰表达式的值

栈的设计与使用

实验内容

设计一个算法，将一般算术表达式转化为逆波兰表达式，并求逆波兰表达的值

解题思路

(1)一般算术表达(中缀表达)，如#3×(4+2)/2-5#，#为表达式界定符，逆波兰表达式(后缀表达式)，如前述表达的后缀表达式为:3 4 2 + × 2 / 5 - 设中缀表达式的运算符有+、-、×、/、#五种，运算符的优先级别从高到低为()、×、/、+、-、#;有括号先算括号内，再算括号外的，多层括号由内向外进行。中缀表达式转换为后缀表达式需要用到一个临时栈optr暂存运算符。（由于*会引起格式问题，所以以上叙述用×代替）

具体代码如下

#define _CRT_SECURE_NO_WARNINGS
#include
#include
using namespace std;

const int StackSize = 100;
template<typename DataType>
class SeqStack {
public:
	SeqStack() {
		top = -1;
	}
	~SeqStack() {
		top = -1;
	}
	void Push(DataType x);
	DataType Pop();
	DataType GetTop();
	DataType GetTopfront();
	int GetCount();
	bool Empty();
	void Display();
	DataType* returnArr();
private:
	DataType data[StackSize];
	int top;
};

template<typename DataType>
DataType SeqStack<DataType>::GetTopfront()
{
	return DataType();
}
template<typename DataType>
void SeqStack<DataType>::Push(DataType x) {
	if (top == StackSize - 1) throw "上溢";
	data[++top] = x;
}
template<typename DataType>
DataType SeqStack<DataType>::Pop() {
	DataType x;
	if (top == -1) throw "下溢";
	x = data[top--];
	return x;
}
template<typename DataType>
DataType SeqStack<DataType>::GetTop() {
	return data[top];
}

template<typename DataType>
int SeqStack<DataType>::GetCount() {
	return top+1;
}
template<typename DataType>
bool SeqStack<DataType>::Empty() {
	if (top == -1)
		return true;
	else
		return false;
}
template<typename DataType>
void SeqStack<DataType>::Display() {
	for (int i = 0; i <= top; i++) {
		cout << data[i]<<' ';
	}
	cout << endl;
}
template<typename DataType>
DataType* SeqStack<DataType>::returnArr() {
	return data;
}

SeqStack<char> optr;
SeqStack<char> outstack;
int Priority(char op) {
	if (op == '*' || op == '/')
		return 2;
	else if (op == '+' || op == '-')
		return 1;
	else if (op == '#')
		return 0;
	else
		return -1;
}

// 判断输入串中的字符是不是操作符，如果是返回true
bool isOperator(char op) {
	if (op == '+' || op == '-' || op == '*' || op == '/'|| op == '#')
		return true;
	else
		return false;
}
// 对两个数进行运算
double Operate(double x, double y, char op) {
	if (op == '+')
		return x + y;
	else if (op == '-')
		return x - y;
	else if (op == '*')
		return x * y;
	else if (op == '/')
		return x / y;
	else
		return -1;
}

//将中缀表达式转换为逆波兰表达式
void change(char* s, int len) {
	for (int i = 0; i < len; i++) {
		//1）求输入串的逆序。
		if (isdigit(s[i])) {
			outstack.Push(s[i]);		// 判断是否是数字，假如是操作数，把它添加到输出串中。
			while (i + 1 < len && isdigit(s[i + 1])) {
				outstack.Push(s[i + 1]);
				i++;
			}
		}
		if (s[i] == '(') {               // 假如是"("，将它入栈
			optr.Push(s[i]);
		}
		while (isOperator(s[i])) {       // 如果是运算符，执行算法对应操作；
			if (optr.Empty() || optr.GetTop() == '(' || Priority(s[i]) > Priority(optr.GetTop())) {  // 如果是空栈或者栈顶为"）"或者新来的元素优先级更高
				optr.Push(s[i]);
				break;
			}
			else if (s[i] == '#' && optr.GetTop() == '#') {	
				//当栈顶元素与当前字符都是'#'时则将栈顶的'#'弹出，break结束内部循环，i++结束外部循环
				optr.Pop();
				i++;
				break;
			}
			else {                       // 否则就把字符栈顶元素放到输出串中
				outstack.Push(optr.Pop());
			}
		}
		if (s[i] == ')') {                               //假如是")"，栈中运算符逐个出栈并输出，直到遇到"(",同时将"("出栈并丢弃。
			while (optr.GetTop() != '(') {
				outstack.Push(optr.Pop());
			}
			optr.Pop();
		}
	}
}

// 计算后缀表达式返回结果
double calculate(SeqStack<char> out) {
	
	//栈中的元素个数
	int len = out.GetCount();
	//返回数组
	char* s = out.returnArr();
	//设定临时堆栈opnd暂存计算过程的中间结果
	SeqStack<double> opnd;
	for (int i = 0; i < len; i++) {
		if (isdigit(s[i])) {
			//字符数字的’0’ASCII码值为48，所以任意0~9字符数字的ASCII值减去“0”的ASCII值即是他的整型数字
			int x = s[i] - '0';
			//字符数字转为整型数字后压入栈中
			opnd.Push(x);
		}
		else
		{
			double X1 = opnd.Pop();
			double X2 = opnd.Pop();
			opnd.Push(Operate(X2, X1, s[i]));
		}
	}
	return opnd.Pop();
}

int main() {
	char A[] = "#3*(4+2)/2-5#";
	int len = sizeof(A)/sizeof(char)-1;
	cout << "中缀表达式为:" << A << endl;
	change(A, len);
	cout << "后缀表达式为:";
	outstack.Display();
	cout << "后缀表达式的计算值为：" << calculate(outstack) << endl;
	outstack.~SeqStack();
	system("pause");
	return 0;
}