算数表达式的二叉树表示

/*中国海洋大信息科学与工程学院计算机甘言海*/
#include
#include

typedef struct node //节点类型
{
char val; //节点符号
struct node *left; //左子树
struct node *right; //右子树
}*pTreeNode,treeNode;

template
class stack //栈类型定义
{
private:
T *top;
T *base;
int length;
int num;
int size;
public:
stack();
T getTop();
bool push(T);
T pop();
};

template
stack::stack() //构造函数，用于初始化
{
size=10;
if((base=top=(T *)malloc(sizeof(T)*size))==NULL)
exit(0);
num=0;
length=size;
}

template
bool stack::push(T param) //进栈函数
{
if(num{
*(++top)=param;
num++;
}
else
{
length+=size;
if((base=(T *)realloc(base,sizeof(T)*length))==NULL)
return false;
top=base+num;
*top=param;
num++;
}
return true;
}

template
T stack::pop() //出栈函数
{
if(num)
{
num--;
return *(top--);
}
else
exit(0);
}

template
T stack::getTop() //返回栈顶元素
{
return *top;
}

typedef struct //运算符优先级定义，分为前后，f前，g后
{
char op;
int f;
int g;
}Prior;


Prior pList[] = //优先级列表
{
'+', 2, 1,
'-', 2, 1,
'*', 4, 3,
'/', 4, 3,
'(', 0, 5,
')', 6, 0,
'\n', 0, 0
};

stack OptrStack; //定义运算符栈
stack ExprStack; //定义表达式栈

char ComparePriority(char opf,char opg) //比较运算符优先级
{
int op1=-1,op2=-1;
for(int i=0;i < 8;i++)
{
if(pList[i].op == opf)
op1 = pList[i].f;
if(pList[i].op == opg)
op2 = pList[i].g;
}
if(op1 == -1 || op2 == -1)
{
printf("operator error!\n");
exit(0);
}
if(op1 > op2)
return '>';
else if(op1 == op2)
return '=';
else
return '<';
}


char getNextToken() //用于获取输入缓存区中的字符
{
int t;
while(1)
{
t = getchar();
if(t == ' '||t == '\t')
;
else
{
return t;
}
}
}

pTreeNode mkleaf(char num) //创建叶子节点
{
pTreeNode pt = new treeNode;
if(pt == NULL)
{
printf("Memory distribute failed!\n");
exit(0);
}
pt->left = NULL;
pt->right = NULL;
pt->val = num;
return pt;
}


pTreeNode mknode(char op,treeNode* left,treeNode* right) //创建中间节点
{
pTreeNode pt = new treeNode;
if(pt == NULL)
{
printf("Memory distribute failed!\n");
exit(0);
}

if(left == NULL||right == NULL)
{
printf("Lossing operand!\n");
exit(0);
}
pt->left = left;
pt->right = right;
pt->val = op;
return pt;
}


pTreeNode CreateTree() //构建算术表达式的二叉树表示，返回根节点的指针
{
char next;
char op;
pTreeNode opnd1,opnd2;
fflush(stdin);
next = getNextToken();
while(next!='\n'||OptrStack.getTop()!='\n')
{
if(next >= 'a'&&next <= 'z')
{
ExprStack.push(mkleaf(next));
next = getNextToken();
}
else
{
switch(ComparePriority(OptrStack.getTop(),next))
{
case '<':
OptrStack.push(next);
next = getNextToken();
break;
case '=':
OptrStack.pop();
next = getNextToken();
break;
case '>':
opnd2 = ExprStack.pop();
opnd1 = ExprStack.pop();
op = OptrStack.pop();
ExprStack.push(mknode(op,opnd1,opnd2));
break;
}
}
}
return ExprStack.getTop();
}

//------------------------------------用递归遍历二叉树的方式输出前、中、后序表达式
void PreOrderTraverse(pTreeNode root)
{
if(root->left)
{
printf("%c ",root->val);
PreOrderTraverse(root->left);
PreOrderTraverse(root->right);
}
else
{
printf("%c ",root->val);
}
}

void MiddleOrderTraverse(pTreeNode root)
{
if(root->left)
{
MiddleOrderTraverse(root->left);
printf("%c ",root->val);
MiddleOrderTraverse(root->right);
}
else
{
printf("%c ",root->val);
}
}
void FollowOrderTraverse(pTreeNode root)
{
if(root->left)
{
FollowOrderTraverse(root->left);
FollowOrderTraverse(root->right);
printf("%c ",root->val);
}
else
{
printf("%c ",root->val);
}
}

void main()
{
OptrStack.push('\n');
system("color 0a");
while(1)
{
system("CLS");
pTreeNode ExprTree;
printf("请输入算术表达式（末尾以$结束）：\n");
ExprTree = CreateTree();
printf("算术表达式的先序表示：\n");
PreOrderTraverse(ExprTree);
printf("\n算术表达式的后序表示：\n");
FollowOrderTraverse(ExprTree);
printf("\n算术表达式的中序表示：\n");
MiddleOrderTraverse(ExprTree);
printf("\n");
system("PAUSE");
}
}