中序遍历二叉树(栈,递归,非递归)已调试,C语言

#include

#include

#define OK 1

#define ERROR 0

#define OVERFLOW -2

#define TRUE 1

#define FALSE 0

typedef int Status;

typedef char TElemType;

typedef struct BiTNode{

TElemType data;

struct BiTNode *lchild,*rchild;

}BiTNode,*BiTree;

typedef BiTree SElemType;

typedef struct SNode{

SElemType data;

struct SNode *next;

}SNode,*LinkStack;

Status CreateBiTree(BiTree *T)

{

char ch;

scanf("%c",&ch);

if(ch=='#') *T=NULL;

else{

if(!(*T=(BiTNode*)malloc(sizeof(BiTNode)))) exit(OVERFLOW);

(*T)->data=ch;

CreateBiTree(&((*T)->lchild));

CreateBiTree(&((*T)->rchild));

}

return OK;

}

Status InitStack(LinkStack *S)

{

*S=(SNode *)malloc(sizeof(SNode));

if(!(*S)) exit(OVERFLOW);

(*S)->next=NULL;

return OK;

}

Status Push(LinkStack S, SElemType e)

{

SNode *newbase;

newbase=(SNode *)malloc(sizeof(SNode));

if(!newbase) return(ERROR);

newbase->data=e;

newbase->next=S->next;

S->next=newbase;

return OK;

}

Status Pop(LinkStack S, SElemType *e)

{

SNode *p;

if(!(S->next)) return ERROR;

p=S->next;

*e=p->data;

S->next=p->next;

free(p);

return OK;

}

Status GetTop(LinkStack S, SElemType *e) {

if(!(S->next)) return ERROR;

*e=S->next->data;

return OK;

}

Status StackEmpty(LinkStack S)

{

if(S->next) return FALSE;

return TRUE;

}

//算法.2，二叉树中序遍历的非递归算法

Status InOrderTraverse(BiTree T)

{

LinkStack S;

BiTree p;

p=T;

InitStack(&S);

Push(S,p);

while(!StackEmpty(S))

{

while(GetTop(S,&p)&&p) Push(S,p->lchild);

Pop(S,&p);

if(!StackEmpty(S)){

Pop(S,&p);

if(!p->data) return ERROR;

else printf("%c",p->data);

Push(S,p->rchild);

}

}

return OK;

}

/*

//算法.3，二叉树中序遍历的非递归算法

Status InOrderTraverse(BiTree T)

{

LinkStack S;

BiTree p;

InitStack(&S);

p=T;

while(p||!StackEmpty(S))

{

if(p){Push(S,p); p=p->lchild;}

else

{

Pop(S,&p);

printf("%c",p->data);

if(!(p->data)) return ERROR;

p=p->rchild;

}

}

printf("\n");

return OK;

}

*/

/*二叉树中序遍历的递归算法

void InOrderTraverse(BiTree T)

{

if(T==NULL)return;

InOrderTraverse(T->lchild);

printf("%c",T->data);

InOrderTraverse(T->rchild);

}

*/

void main()

{

BiTree T1;

CreateBiTree(&T1);

InOrderTraverse(T1);

}