数据结构-利用二叉树求解表达式的值

参照严蔚敏<<数据结构>>第2版算法5.12和5.13
当输入 ‘#’ 时代表表示式结束

算法实现:

#include <iostream>
using namespace std;
//定义表达式树
typedef int TreeElemType;
typedef struct TreeNode {
	TreeElemType data;
	struct TreeNode* lchild, *rchild;
}TreeNode,*ExpTree;
//定义树栈
typedef struct ETStackNode {
	ExpTree ETStackdata;
	struct ETStackNode* next;
}ETStackNode,*ETLinkStack;
//定义算符栈
typedef char ElemType;
typedef struct ChStack {
	ElemType ChStackdata;
	struct ChStack* next;
}ChStackNode, *ChLinkStack;
//算符优先级比较表
char CList[7][7] =
{
	{ '>','>','<','<','<','>','>' },
	{ '>','>','<','<','<','>','>' },
	{ '>','>','>','>','<','>','>' },
	{ '>','>','>','>','<','>','>' },
	{ '<','<','<','<','<','=',' ' },
	{ '>','>','>','>',' ','>','>' },
	{ '<','<','<','<','<',' ','=' },
};
//定义七种算符
char *Op = "+-*/()#";
//树栈初始化
void EXTInitStack(ETLinkStack &LS)
{
	LS = NULL;
}
// 树栈添加元素
void EXTPush(ETLinkStack &LS, ExpTree ET)
{
	ETStackNode* p = new ETStackNode;
	p->ETStackdata = ET;
	p->next = LS;
	LS = p;
}
//树栈弹出栈顶元素
void EXTPop(ETLinkStack &LS, ExpTree &ET)
{
	if (LS == NULL) return;
	ET = LS->ETStackdata;
	ETStackNode* p = LS;
	LS = LS->next;
	delete p;
}
//树栈获取栈顶元素
ExpTree EXTGetTop(ETLinkStack &LS)
{
	if (LS) return LS->ETStackdata;
}
//算符栈初始化
void ChInitStack(ChLinkStack &CS)
{
	CS = NULL;
}
//算符栈添加元素
void ChPush(ChLinkStack& CS, ElemType e)
{
	ChStackNode* p = new ChStackNode;
	p->ChStackdata = e;
	p->next = CS;
	CS = p;
}
//算符栈弹出栈顶元素
void ChPop(ChLinkStack& CS, ElemType &e)
{
	if (CS == NULL) return;
	e = CS->ChStackdata;
	ChStackNode* p = CS;
	CS = CS->next;
	delete p;
}
//算符栈获取栈顶元素值
ElemType ChGetTop(ChLinkStack &CS)
{
	if (CS != NULL) return CS->ChStackdata;
}
//判断ch是否为算符
bool In(char ch)
{
	int i = 0;
	while (Op && Op[i] != ch)
		i++;
	return i < 7;
}
//创建表达式树结点
//以T为根节点，*lchild,*rchild分别为左右孩子
void CreateExpTree(ExpTree &T, TreeNode* lchild, TreeNode* rchild, TreeElemType data)
{
	T = new TreeNode;
	T->data = data;
	T->lchild = lchild;
	T->rchild = rchild;
}
//将数值型字符串转换成int型数字
int Atoi(char *str)
{
	int res = 0;
	while (*str)
		res = res * 10 + (*str++ - '0');
	return res;
}
//判断算符优先级
char Precede(char c1, char c2)
{
	int i = 0, j = 0;
	while (Op[i] && Op[i] != c1)
		i++;
	while (Op[j] && Op[j] != c2)
		j++;
	return CList[i][j];
}
//表达式树的创建算法
ExpTree InitExpTree()
{
	ETLinkStack EXPT; 
	ChLinkStack OPTR;
	EXTInitStack(EXPT);
	ChInitStack(OPTR);
	ChPush(OPTR, '#');
	char ch;
	cin >> ch;
	while (ch != '#' || ChGetTop(OPTR) != '#')
	{
		if (!In(ch))
		{
			char data[20] = { '\0' };
			int i = 0;
			data[i++] = ch;
			cin >> ch;
			while (!In(ch))
			{
				data[i++] = ch;
				cin >> ch;
			}

			ExpTree T;
			CreateExpTree(T, NULL, NULL, Atoi(data));
			EXTPush(EXPT, T);
		}
		else
		{
			switch (Precede(ChGetTop(OPTR),ch))
			{
			case '<':
				ChPush(OPTR, ch);
				cin >> ch;
				break;
			case '>':
				char theta;
				ChPop(OPTR, theta);
				TreeNode* t1, *t2;
				EXTPop(EXPT, t2); EXTPop(EXPT, t1);
				ExpTree T;
				CreateExpTree(T, t1, t2, theta);
				EXTPush(EXPT, T);
				break;
			case '=':
				ChPop(OPTR, theta);
				cin >> ch;
				break;
			}
		}
	}
	return EXTGetTop(EXPT);
}
// 中序遍历表达式树
/*
void InOrderTree(ExpTree T)
{
	if (T)
	{
		InOrderTree(T->lchild);
		if (T->lchild)
		{
			char ch = T->data;
			cout << ch;
		}
		else
			cout << T->data;
		InOrderTree(T->rchild);
	}
}
*/
//求值
int GetValue(char ch, int a, int b)
{
	switch (ch)
	{
	case '+':
		return a + b;
	case '-':
		return a - b;
	case '*':
		return a*b;
	case '/':
		return a / b;
	}
}
//遍历表达树进行表达式求值
int EvaluateExpTree(ExpTree T)
{
	int lvalue = 0, rvalue = 0;
	if (T->lchild == NULL&&T->rchild == NULL)
		return T->data;
	else
	{
		lvalue = EvaluateExpTree(T->lchild);
		rvalue = EvaluateExpTree(T->rchild);
		return GetValue(T->data, lvalue, rvalue);
	}
}
//主函数
int main()
{
	ExpTree T = InitExpTree();
	cout << EvaluateExpTree(T) << endl;
	return 0;
}

输入: 3*(7-2)#
输出:15

输入: 4*7-21#
输出:7

输出:3*(4-2)*6/9#
输出:4

数据结构-用栈实现表达式求值