#include
#include
#define?LIST_INIT_SIZE	100
#define?LISTINCREMENT	100
#define?STACK_INIT_SIZE?????100??
#define?STACKINCREMENT??????100??
typedef?char?Elemtype;
typedef?struct
{
	Elemtype	*elem;
	int?		length;
	int			listsize;
}SqList;
typedef?char?TElemtype;

typedef?struct?BiTNode
{
	TElemtype?data;
	struct?BiTNode?*lchild*rchild;
}BiTNode*BiTree;

typedef?char?SElemtype;
typedef?struct
{
	SElemtype?*base;
	SElemtype?*top;
	int?stacksize;
}SqStack;

void?InitBiTree（BiTree?&T）?//初始化二叉樹T?
{
	T=（BiTree）malloc（sizeof（BiTNode））;
	if（!T）exit（-2）;	
}?

BiTNode*?predicate（SqList?&Lint?fristint?last）?//還要考慮小括號在最外層的情況
{
	BiTree?T1;
	if（last-frist==1）
	{
		BiTree?Ty;
	?	InitBiTree（Ty）;
		Ty->data=L.elem[frist];
		Ty->lchild=NULL;
		Ty->rchild=NULL;
		return?Ty;
	}	
	int?flag=0jt=0ct=0t=0;
	for（int?i=frist;i	{
		if（L.elem[i]==‘（‘）flag++;
		else?if（L.elem[i]==‘）‘）flag--;
		
		if（flag==0）{
????????????if（L.elem[i]==‘+‘||L.elem[i]==‘-‘）
				jt=i;
			else?if（L.elem[i]==‘*‘||L.elem[i]==‘/‘）
				ct=i;
		}
	}
	if（（ct==0）&&（jt==0））
		T1=predicate（Lfrist+1last-1）;?
	else{
		if（jt>0）t=jt;
		else?if（ct>0）t=ct;
	InitBiTree（T1）;
	T1->data=L.elem[t];
	T1->lchild=predicate（Lfristt）;
	T1->rchild=predicate（Lt+1last）;
	}
	return?T1;
}

void?InitList（SqList?&L）??
{?
????L.elem?=?（Elemtype?*）malloc（LIST_INIT_SIZE*sizeof（Elemtype））;??
????if（!L.elem）exit（-2）;??
????L.length=0;??
????L.listsize=LIST_INIT_SIZE;????
}?

void?PreOrderTraverse?（BiTree?T）?//先序遍歷二叉樹T????
{
	if（T==NULL）
	{
		return;
	}
	else
	{	printf（“%c?“T->data）;
		PreOrderTraverse?（T->lchild）;
		PreOrderTraverse?（T->rchild）;
	}
}

void?InOrderTraverse?（BiTree?T）?//中序遍歷二叉樹T
{
	if（T==NULL）
	{
		return;
	}
	else
	{	
		InOrderTraverse?（T->lchild）;
		printf（“%c?“T->data）;
		InOrderTraverse?（T->rchild）;
	}	
}??

void?PostOrderTraverse?（BiTree?T）?//后序遍歷二叉樹T
{
	if（T==NULL）
	{
		return;
	}
	else
	{	
		PostOrderTraverse?（T->lchild）;
		PostOrderTraverse?（