C++实现中缀表达式求值代码

给出中缀表达式字符串，求出值。

主要思路：

1.对字符串进行词法分析，分析结果存储到二元数组，用该二元数组存储中缀表达式。

2.将中缀表达式转化成后缀表达式。

3.利用栈对后缀表达式求值。

特点：

能去掉字符串的空格。

能识别两位以上的整型数据计算，操作符主要是（＋，－，×，／）．

代码运行结果：

中缀表达式例子是：12+3*(   8/2)；

#include<iostream>
#include<cstring>
using namespace std;
#define maxSize 120
char buffer[maxSize];//表达式的最长长度
char strToken[maxSize];
typedef struct line{
	unsigned short id;
	short indexOfTable;
};
struct line data[maxSize];
int intTable[maxSize];
short flagOfIntTable = 0;
short flagOfStruct = 0;

struct line stackOfEP[maxSize];//存储后缀表达式
short stackOfID[maxSize];//存放符号
short countOfEP = 0;
short countOfID = 0;

const  short INTEGER = 1;
const short LEFT_B = 3;
const short RIGHT_B = 4;
const short PLUS =  6;
const short MINUX = 7;

const short MULTIPLY = 9;
const short DIVIDE = 10;

void deleBlank(const char* str){//将字符串空格清除
	char *temp = buffer;
	if(0 == *str){
		*temp = '\0';
	}
	while(*str){
		if(*str ==' '){
				str++;
				continue;
			}
		*temp++ = *str++; 
	}
	*temp = '\0';
}
void init(char *str){
	for(short i = 0;i <=strlen(str);i++){
		*str = 0;
	}
}
void wordAnalyse(const char* str){
	const char *start = str;//字符开始指针
	const char *search;//搜索指针
	char *temp;
	while(*start){
		search = start;
		temp = strToken;//循环一次，temp指针重新纠正为指向strToken首地址。
		if(isdigit(*search) != 0){//是数字的时候返回值是4
			while(isdigit(*search) != 0){
			*temp++ = *search++;	
			}
			*temp = '\0';
			intTable[flagOfIntTable] = atoi(strToken);
			//转换字符串成int型，atof();itoa(int value,char*s1,int radix)
			data[flagOfStruct].id = INTEGER;
			data[flagOfStruct].indexOfTable = flagOfIntTable;
			init(strToken);//重新初始化
			flagOfStruct++;
			flagOfIntTable++;
			start = search;
		}
		else if(*start == '+'){
			data[flagOfStruct].id = PLUS;
			data[flagOfStruct].indexOfTable = -1;
			flagOfStruct++;
			start++;
			}
		else if(*start == '-'){
			data[flagOfStruct].id = MINUX;
			data[flagOfStruct].indexOfTable = -1;
			flagOfStruct++;
			start++;
		}
		else if(*start == '*'){
			data[flagOfStruct].id = MULTIPLY;
			data[flagOfStruct].indexOfTable = -1;
			flagOfStruct++;
			start++;
			}
		else if(*start == '/'){
			data[flagOfStruct].id = DIVIDE;
			data[flagOfStruct].indexOfTable = -1;
			flagOfStruct++;
			start++;
		}
		else if(*start == '('){
			data[flagOfStruct].id = LEFT_B;
			data[flagOfStruct].indexOfTable = -1;
			flagOfStruct++;
			start++;
		}
		else if(*start == ')'){
			data[flagOfStruct].id = RIGHT_B;
			data[flagOfStruct].indexOfTable = -1;
			flagOfStruct++;
			start++;
		}
		else{start++;}
}
}



void traverse(){//将中缀表达式转化成后缀表达式
	
	
	for(int i = 0;i <flagOfStruct;i++){
		if(data[i].id == INTEGER){
			stackOfEP[countOfEP++] = data[i];//如果是数字，直接压入后缀表达式。
		}
		else if(data[i].id >=PLUS&&data[i].id <= DIVIDE){//如果是运算符号
			
			while(true){
				if(countOfID == 0){
					stackOfID[countOfID++] = data[i].id;
					break;
				}
				else if(data[i].id - stackOfID[countOfID] >= 2){
					stackOfID[countOfID++] = data[i].id;//入栈
					break;
				}
				else{
					stackOfEP[countOfEP].id = stackOfID[--countOfID];//出栈
					stackOfEP[countOfEP].indexOfTable = -1;
					countOfEP++;
				}
			}
			
		}
		else if(data[i].id == LEFT_B){//
			stackOfID[countOfID++] = data[i].id;
		}
		else if(data[i].id == RIGHT_B){
			while(true){
			//直到有左括号，则弹出循环
				if(stackOfID[countOfID-1] == LEFT_B){//必须减一，不然逻辑错误。
					countOfID--;//出栈
					break;
				}
				if(countOfID == 0){
					break;
				}
				stackOfEP[countOfEP].id = stackOfID[--countOfID];
				stackOfEP[countOfEP].indexOfTable = -1;
				countOfEP++;
			}
		}
	}
	//数据输入结束时，释放所有符号栈的内容，并添加到后缀式
			while(countOfID){
				stackOfEP[countOfEP].id = stackOfID[--countOfID];
				stackOfEP[countOfEP].indexOfTable = -1;
				countOfEP++;
			}
		
}

//计算后缀表达式
int compute(){
	short tempPtr = 0;
	int number[120];
	for(int i = 0;i <countOfEP;i++){
		if(stackOfEP[i].id == INTEGER){
			number[tempPtr++] = intTable[stackOfEP[i].indexOfTable];
		}
		else if(stackOfEP[i].id == PLUS){
			int a = number[--tempPtr];
			int b = number[--tempPtr];
			number[tempPtr++] = b + a;
		}
		else if(stackOfEP[i].id == MINUX){
			int a = number[--tempPtr];
			int b = number[--tempPtr];
			number[tempPtr++] = b - a;
		}
		else if(stackOfEP[i].id == MULTIPLY){
			int a = number[--tempPtr];
			int b = number[--tempPtr];
			number[tempPtr++] = b * a;
		}
		else if(stackOfEP[i].id == DIVIDE){
			int a = number[--tempPtr];
			int b = number[--tempPtr];
			number[tempPtr++] = b/a;
		}
	}
	return *number;
}
void display(){
	for(int i = 0;i <flagOfStruct;i++){
		if(data[i].id == INTEGER){printf("%d",intTable[data[i].indexOfTable]);}
		else if(data[i].id == PLUS){printf("+");}
		else if(data[i].id == MINUX){printf("-");}
		else if(data[i].id == MULTIPLY){printf("*");}
		else if(data[i].id == DIVIDE){printf("/");}
		else if(data[i].id == LEFT_B){printf("(");}
		else if(data[i].id == RIGHT_B){printf(")");}
		else{printf("\n");}
	}
}
void displayEP(){
	for(int i = 0;i <countOfEP;i++){
		if(stackOfEP[i].id == INTEGER){printf("%d",intTable[stackOfEP[i].indexOfTable]);}
		else if(stackOfEP[i].id == PLUS){printf("+");}
		else if(stackOfEP[i].id == MINUX){printf("-");}
		else if(stackOfEP[i].id == MULTIPLY){printf("*");}
		else if(stackOfEP[i].id == DIVIDE){printf("/");}
		else if(stackOfEP[i].id == LEFT_B){printf("(");}
		else if(data[i].id == RIGHT_B){printf(")");}
		else{printf("\n");}
	}
}
int main(){
	//test wordAnalytse()
	char str[20] = "12+3*  (8/2)";
	deleBlank(str);
	//printf(buffer);
	wordAnalyse(buffer);
	traverse();
	displayEP();
	printf("\n");
	printf("%d\n",compute());
	return 0;
}