计算表达式

中序转后序：

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include<string>
#include<vector>
using namespace std;
#define MAX 50


struct node
{
	double i;
	char c;
	bool t;
};
       
bool isdigit(char c)
{
	if ((c >= '0'&&c <= '9') || c == '.')
		return true;
	else
		return  false;


}
int compare(char stack_o, char infix_o)
{
	//在中序表示法队列和暂存堆栈中，运算符的优先级表，
	//其优先级值为INDEX/2                               
	char infix_priority[9];
	char stack_priority[8];
	int index_s = 0, index_i = 0;
	infix_priority[0] = 'q'; infix_priority[1] = ')';
	infix_priority[2] = '+'; infix_priority[3] = '-';
	infix_priority[4] = '*'; infix_priority[5] = '/';
	infix_priority[6] = '^'; infix_priority[7] = ' ';
	infix_priority[8] = '(';
	stack_priority[0] = 'q'; stack_priority[1] = '(';
	stack_priority[2] = '+'; stack_priority[3] = '-';
	stack_priority[4] = '*'; stack_priority[5] = '/';
	stack_priority[6] = '^'; stack_priority[7] = ' ';
	while (stack_priority[index_s] != stack_o)
		index_s++;
	while (infix_priority[index_i] != infix_o)
		index_i++;
	return ((int)(index_s / 2) >= (int)(index_i / 2) ? 1 : 0);
}
//中序转前序的方法
vector<node> infix_to_postfix(string s)
{
	vector<node>temp;
	node a;
	char infix_q[MAX]; //用来存放中序表示法的队列  
	//运算符优先级的比较，若输入运算符的优先级小于堆栈中运算符的优先级，
	//则返回值为1，否则为0                   
	for (int i = 0; i<MAX; i++)
		infix_q[i] = '\0';
	for (int i = 0; i < s.size(); i++)
		infix_q[i] = s[i];

	int rear = 0, top = 0, flag = 0, i = 0;
	char stack_t[MAX];
	for (i = 0; i<MAX; i++)
		stack_t[i] = '\0';
   i = 0;
	while (infix_q[i] != '\0')
	{
		i++;
		rear++;
	}
	infix_q[rear] = 'q';  //在队列加入q为结束符号
	
	stack_t[top] = 'q';  //在堆栈加入q为结束符号                                               
	for (flag = 0; flag <= rear; flag++)
	{
		switch (infix_q[flag])
		{
			//输入为)时，则输出堆栈内的运算符，直到堆栈内为(
		case ')':
			while (stack_t[top] != '(')
			{
				a.t = false;
				a.c = stack_t[top--];
				temp.push_back(a);
			}
			top--;
			break;
			//输入为q，则将堆栈内还未输出的运算符输出
		case 'q':
			while (stack_t[top] != 'q')
			{
				a.t = false;
				a.c = stack_t[top--];
				temp.push_back(a);
			}
			break;
			//输入为运算符，若其优先级小于TOP在堆栈中所指运算符的优先级，
			//则将堆栈所指运算符输出，若优先级大于等于TOP在堆栈中所指运算符
			//的优先级，则将输入的运算符压入堆栈。 
		case '(':
		case '^':
		case '*':
		case '/':
		case '+':
		case '-':
			while (compare(stack_t[top], infix_q[flag]) == 1)
			{
				a.t = false;
				a.c = stack_t[top--];
				temp.push_back(a);
			}
			stack_t[++top] = infix_q[flag];
			break;
			//输入为操作数，则直接输出
		default:
		{
			a.t = true;
			string s;
			
			for (int i = flag; isdigit(infix_q[flag]); flag++)
			{
				s.push_back(infix_q[flag]);
			}
			
			flag--;
			double te = stod(s, 0);
			a.i = te;
			temp.push_back(a);
		}
	
			break;
		}
	}

	return temp;
	
}


int main()
{
	string s = "25+3*4+5";

	vector<node> a= infix_to_postfix(s);
	
	for (int i = 0; i < a.size(); i++)
	{
		if (a[i].t)
			cout << a[i].i << " ";
		else
			cout << a[i].c << " ";
	}
	system("pause");
	return 0;
}

后序求值：有错误 "3/(10/10/8)"  得到的后序为“3 10 8/10//”结果居然24

错误处在前一步，中序转后序

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include<string>
#include<vector>
#include<stack>
using namespace std;

	const int MAX = 50;


struct node
{
	double i;
	char c;
	bool t;
};
       
bool isdigit(char c)
{
	if ((c >= '0'&&c <= '9') || c == '.')
		return true;
	else
		return  false;


}
int compare(char stack_o, char infix_o)
{
	//在中序表示法队列和暂存堆栈中，运算符的优先级表，
	//其优先级值为INDEX/2                               
	char infix_priority[9];
	char stack_priority[8];
	int index_s = 0, index_i = 0;
	infix_priority[0] = 'q'; infix_priority[1] = ')';
	infix_priority[2] = '+'; infix_priority[3] = '-';
	infix_priority[4] = '*'; infix_priority[5] = '/';
	infix_priority[6] = '^'; infix_priority[7] = ' ';
	infix_priority[8] = '(';
	stack_priority[0] = 'q'; stack_priority[1] = '(';
	stack_priority[2] = '+'; stack_priority[3] = '-';
	stack_priority[4] = '*'; stack_priority[5] = '/';
	stack_priority[6] = '^'; stack_priority[7] = ' ';
	while (stack_priority[index_s] != stack_o)
		index_s++;
	while (infix_priority[index_i] != infix_o)
		index_i++;
	return ((int)(index_s / 2) >= (int)(index_i / 2) ? 1 : 0);
}
//中序转前序的方法
vector<node> infix_to_postfix(string s)
{
	vector<node>temp;
	node a;
	char infix_q[MAX]; //用来存放中序表示法的队列  
	//运算符优先级的比较，若输入运算符的优先级小于堆栈中运算符的优先级，
	//则返回值为1，否则为0                   
	for (int i = 0; i<MAX; i++)
		infix_q[i] = '\0';
	for (int i = 0; i < (int)s.size(); i++)
		infix_q[i] = s[i];

	int rear = 0, top = 0, flag = 0, i = 0;
	char stack_t[MAX];
	for (i = 0; i<MAX; i++)
		stack_t[i] = '\0';
   i = 0;
	while (infix_q[i] != '\0')
	{
		i++;
		rear++;
	}
	infix_q[rear] = 'q';  //在队列加入q为结束符号
	
	stack_t[top] = 'q';  //在堆栈加入q为结束符号                                               
	for (flag = 0; flag <= rear; flag++)
	{
		switch (infix_q[flag])
		{
			//输入为)时，则输出堆栈内的运算符，直到堆栈内为(
		case ')':
			while (stack_t[top] != '(')
			{
				a.t = false;
				a.c = stack_t[top--];
				temp.push_back(a);
			}
			top--;
			break;
			//输入为q，则将堆栈内还未输出的运算符输出
		case 'q':
			while (stack_t[top] != 'q')
			{
				a.t = false;
				a.c = stack_t[top--];
				temp.push_back(a);
			}
			break;
			//输入为运算符，若其优先级小于TOP在堆栈中所指运算符的优先级，
			//则将堆栈所指运算符输出，若优先级大于等于TOP在堆栈中所指运算符
			//的优先级，则将输入的运算符压入堆栈。 
		case '(':
		case '^':
		case '*':
		case '/':
		case '+':
		case '-':
			while (compare(stack_t[top], infix_q[flag]) == 1)
			{
				a.t = false;
				a.c = stack_t[top--];
				temp.push_back(a);
			}
			stack_t[++top] = infix_q[flag];
			break;
			//输入为操作数，则直接输出
		default:
		{
			a.t = true;
			string s;
			
			for (int i = flag; isdigit(infix_q[flag]); flag++)
			{
				s.push_back(infix_q[flag]);
			}
			
			flag--;
			double te = stod(s, 0);
			a.i = te;
			temp.push_back(a);
		}
	
			break;
		}
	}

	return temp;
	
}


double caculate(vector<node>a);

int main()
{
	string s = "2+3*4+5";

	vector<node> a= infix_to_postfix(s);
	
	for (int i = 0; i < (int)a.size(); i++)
	{
		if (a[i].t)
			cout << a[i].i << " ";
		else
			cout << a[i].c << " ";
	}
	cout << endl;
	double t= caculate(a);
	cout << t << endl;
	system("pause");
	return 0;
}


double caculate(vector<node>a)
{
	double t = 0;
	stack<node>b;

	for (int i = 0; i < (int)a.size(); i++)
	{
		if (a[i].t)
			b.push(a[i]);
		else
		{
			double t1, t2;
			node temp1, temp2;
			char c=a[i].c;
			temp2 = b.top();
			b.pop();
			temp1 = b.top();
			b.pop();
			t1 = temp1.i; t2 = temp2.i;
			switch (c)
			{
			case '+':t1 = t1 + t2; break;
			case '-':t1 = t1 - t2; break;
			case '*':t1 = t1 * t2; break;
			case '/':t1 = t1 / t2; break;
			default:
				cout << "wrong" << endl;
				break;
			}
			temp1.i = t1;
			b.push(temp1);
		}
	}

	node ii = b.top();
	t = ii.i;
	return t;
}