重庆邮电大学数据结构实验五

实验五 基于二叉树的表达式求值算法

一、实验目的

1. 掌握二叉树的二叉链表存储表示和二叉树的遍历等基本算法。

2. 掌握根据中缀表达式创建表达式树的算法。

3. 掌握基于表达式树的表达式求值算法。

二、实验内容

问题描述

输入一个表达式 ( 表达式中的数均为小于 10 的正整数 ) ，利用二叉树来表示该

表达式，创建表达式树，然后利用二叉树的遍历操作求表达式的值。

输入要求

多组数据。每组数据 1 行，为一个表达式，表达式以 “=” 结尾。当输入只有

一个 “=” 时，输入结束。

输出要求

每组数据输出 1 行，为表达式的值。

输入样例

2*(2+5)=

1+2=

输出样例

14

3

#include<iostream>
#include <cstdio>
using namespace std;

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

#define STACK_INIT_SIZE 100   
#define STACKINCREMENT 10   
typedef int Status;
typedef char TElemType;
typedef int ElemType;
typedef struct BiNode
{
	TElemType data;
	struct BiNode* lchild;
	struct BiNode* rchild;
}BiNode, * BiTree;
typedef BiTree SBElemType;

int  preorderTraverse(BiTree T)
{
	if (T == NULL)
		return 0;
	else
	{
		cout << T->data;
		preorderTraverse(T->lchild);
		preorderTraverse(T->rchild);
	}
}

int InorderTraverse(BiTree T)
{
	if (T == NULL)
		return 0;
	else
	{
		InorderTraverse(T->lchild);
		cout << T->data;
		InorderTraverse(T->rchild);
	}
}


int  PostorderTraverse(BiTree T)
{
	if (T == NULL)
		return 0;
	else
	{
		PostorderTraverse(T->lchild);
		PostorderTraverse(T->rchild);
		cout << T->data;
	}
}



typedef struct
{
	TElemType* base;
	TElemType* top;
	int stacksize;
}SqStack;


Status InitStack(SqStack* S)
{
	S->base = (TElemType*)malloc(STACK_INIT_SIZE * sizeof(TElemType));
	if (!S->base)
	{
		cout << "内存分配失败!\n";
		exit(0);
	}

	S->top = S->base;
	S->stacksize = STACK_INIT_SIZE;
	return OK;
}

Status GetTop(SqStack* S, TElemType* e)
{
	if (S->top == S->base)
		return ERROR;

	*e = *(S->top - 1);
	return OK;
}

Status Push(SqStack* S, TElemType e)
{
	if (S->top - S->base >= STACK_INIT_SIZE)
	{
		S->base = (TElemType*)realloc(S->base, (S->stacksize + STACKINCREMENT) * sizeof(TElemType));
		if (!S->base)
		{
			cout << "内存分配失败!\n";
			exit(OVERFLOW);
		}

		S->top = S->base + S->stacksize;
		S->stacksize += STACKINCREMENT;
	}

	*S->top++ = e;

	return OK;
}

Status Pop(SqStack* S, TElemType* e)
{
	if (S->top == S->base)
		return ERROR;

	*e = *--S->top;

	return OK;
}






typedef struct {
	SBElemType* base;
	SBElemType* top;
	int stacksize;
} SqStack_BiTree;


void SqStack_BiTree_InitStack(SqStack_BiTree& S)
{
	if (!(S.base = (SBElemType*)malloc(STACK_INIT_SIZE
		* sizeof(SBElemType))))
		exit(0);
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;
}

void SqStack_BiTree_DestroyStack(SqStack_BiTree& S)
{
	free(S.base);
	S.base = NULL;
	S.top = NULL;
	S.stacksize = 0;
}

void SqStack_BiTree_Push(SqStack_BiTree& S, SBElemType e)
{
	if (S.top - S.base >= S.stacksize)
	{
		S.base = (SBElemType*)realloc(S.base, (S.stacksize
			+ STACKINCREMENT) * sizeof(SBElemType));
		if (!S.base)
			exit(OVERFLOW);
		S.top = S.base + S.stacksize;
		S.stacksize += STACKINCREMENT;
	}
	*(S.top)++ = e;
}

Status SqStack_BiTree_Pop(SqStack_BiTree& S, SBElemType& e)
{

	if (S.top == S.base)
	{
		return ERROR;
	}
	e = *--S.top;;

	return OK;
}

Status SqStack_BiTree_GetTop(SqStack_BiTree S, SBElemType& e)
{

	if (S.top > S.base) {
		e = *(S.top - 1);

		return OK;
	}
	else
	{
		return ERROR;
	}

}

char Precede(char t1, char t2)
{
	int i, j;
	char pre[7][7] = {
			{'>','>','<','<','<','>','>'},
			{'>','>','<','<','<','>','>'},
			{'>','>','>','>','<','>','>'},
			{'>','>','>','>','<','>','>'},
			{'<','<','<','<','<','=','0'},
			{'>','>','>','>','0','>','>'},
			{'<','<','<','<','<','0','='} };
	switch (t1) {
	case '+': i = 0; break;
	case '-': i = 1; break;
	case '*': i = 2; break;
	case '/': i = 3; break;
	case '(': i = 4; break;
	case ')': i = 5; break;
	case '=': i = 6; break;
	}
	switch (t2) {
	case '+': j = 0; break;
	case '-': j = 1; break;
	case '*': j = 2; break;
	case '/': j = 3; break;
	case '(': j = 4; break;
	case ')': j = 5; break;
	case '=': j = 6; break;
	}
	return pre[i][j];
}
Status In(TElemType c)
{
	switch (c)
	{
	case '+':
	case '-':
	case '*':
	case '/':
	case '(':
	case ')':
	case '=':
		return TRUE;
	default:
		return FALSE;
	}

}

ElemType Operate(ElemType a, TElemType theta, ElemType b)
{
	TElemType c;
	switch (theta)
	{
	case '+':
		c = a + b;
		break;
	case '-':
		c = a - b;
		break;
	case '*':
		c = a * b;
		break;
	case '/':
		c = a / b;
		break;
	}
	return c;
}



void EvaluateExpression(BiTree& root, char* str)
{
	SqStack OPTR;
	InitStack(&OPTR);
	SqStack_BiTree EXPT;
	SqStack_BiTree_InitStack(EXPT);

	char ch, x, theta;
	BiTree a, b;
	int i = 0;

	Push(&OPTR, '=');
	ch = str[i++];
	GetTop(&OPTR, &x);
	while (ch != '=' || x != '=')
	{
		if (In(ch))
		{
			switch (Precede(x, ch))
			{
			case '<':
				Push(&OPTR, ch);
				ch = str[i++];
				break;

			case '=':
				Pop(&OPTR, &x);
				ch = str[i++];
				break;
			case '>':
				Pop(&OPTR, &theta);
				BiTree TEMP;
				TEMP = (BiNode*)malloc(sizeof(BiNode));
				if (!TEMP)
					exit(-1);
				TEMP->data = theta;
				SqStack_BiTree_Pop(EXPT, b);
				SqStack_BiTree_Pop(EXPT, a);

				TEMP->lchild = a;
				TEMP->rchild = b;
				SqStack_BiTree_Push(EXPT, TEMP);


				root = TEMP;
				break;
			}
		}

		if (ch >= '0' && ch <= '9')
		{
			BiTree Temp;
			Temp = (BiNode*)malloc(sizeof(BiNode));
			if (!Temp)
				exit(-1);
			Temp->data = ch;
			Temp->lchild = NULL;
			Temp->rchild = NULL;
			SqStack_BiTree_Push(EXPT, Temp);

			ch = ch = str[i++];;
		}



		GetTop(&OPTR, &x);

	}

}

int	calculate_BiTree(BiTree& T)
{
	int lvalue;
	int rvalue;
	char theta;
	if (T == NULL)	return 0;
	if (T != NULL)
	{
		if (T->lchild == NULL && T->lchild == NULL)
			return T->data - '0';
		else
		{
			lvalue = calculate_BiTree(T->lchild);
			rvalue = calculate_BiTree(T->rchild);
			theta = T->data;

			return Operate(lvalue, theta, rvalue);
		}
	}
}


int main()
{
	BiTree T;
	char str[1000];
	int result[100] = { 0 };
	int number = 0;
	do
	{
		cout << "";
		cin.getline(str, 30);

		EvaluateExpression(T, str);
		result[number] = calculate_BiTree(T);
		number++;
	} while (strcmp(str, "=") != 0);


	for (int j = 0; j < number - 1; j++)
	{
		cout << endl;
		cout << "" << result[j] << endl;
	}
}