二叉树遍历（递归与非递归）算法

二叉树定义

#include<stdio.h>
#include<malloc.h>
#define STACK_INIT_SIZE 30
#define STACKINCREMENT  10
#define OK 1
#define ERROR -1
typedef char TElemType;
typedef struct BiTNode{
    TElemType data;
    struct BiTNode *lchild, *rchild;
    int flag;
}BiTNode,*BiTree;
typedef BiTree SElemType;
typedef int Status;
typedef struct{
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStack;
void Print(char e){
 printf(" %c",e);
}

构造一个空栈

Status InitStack(SqStack &s){
 s.base = (SElemType * ) malloc(STACK_INIT_SIZE * sizeof(SElemType));
    if(!s.base) return(-1);
    s.top=s.base;
    s.stacksize=STACK_INIT_SIZE;
    return OK;
}

若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR

Status GetTop(SqStack s, SElemType &e ){
    if( s.top == s.base) return ERROR;
    e = *(s.top-1);
    return OK;
}

插入元素e为新的栈顶元素

Status Push(SqStack &s, SElemType e){
    if(s.top-s.base >= s.stacksize){    //栈满，追加存储空间
        s.base = (SElemType *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(SElemType));
        if(!s.base) return(-1); //存储分配失败
        s.top = s.base + s.stacksize;
        s.stacksize += STACKINCREMENT;
    }
    *s.top++ = e;
    return OK;
}

若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR

Status Pop(SqStack &s, SElemType &e){
    if(s.top==s.base)return ERROR;
    e = * --s.top;
    return OK;
}

判断栈空

int StackEmpty(SqStack s) {
    return s.base == s.top;
}

利用先序序列建立二叉树

void RecursionCreateBiTree(BiTree &T){
 char ch;
 ch = getchar();
 if(ch ==‘#‘)
  T=NULL;
 else{
  T = (BiTree)malloc(sizeof(BiTNode));
  T->data = ch;
  RecursionCreateBiTree(T->lchild);
  RecursionCreateBiTree(T->rchild);
 }
}

先序递归遍历二叉树

void RecursionPreOrder(BiTree t){
 if(t!=NULL){
  printf(" %c",t->data);
  RecursionPreOrder(t->lchild);
  RecursionPreOrder(t->rchild);
 }
}

中序递归遍历二叉树

void RecursionInOrder(BiTree t){
 if(t!=NULL){
  RecursionInOrder(t->lchild);
  printf(" %c",t->data);
  RecursionInOrder(t->rchild);
 }
}

后序递归遍历二叉树

void RecursionPostOrder(BiTree t){
 if(t!=NULL){
  RecursionPostOrder(t->lchild);
  RecursionPostOrder(t->rchild);
  printf(" %c",t->data);
 }
}

非递归先序遍历二叉树

void NoRecursionPreOrderTraverse(BiTree T){
 SqStack S;
 BiTree P = T;
 InitStack(S);
 while(P!=NULL ||  !StackEmpty(S)){
  if(P){
   Print(P->data);
   Push(S,P);
   P=P->lchild;
  }
  else{
   Pop(S,P);
   P=P->rchild;
  }
 }
}

非递归中序遍历二叉树

void NoRecursionInOrderTraverse(BiTree T){
 SqStack S;
 InitStack(S);
 BiTree p;
 Push(S,T);
 while(!StackEmpty(S)){
  while(GetTop(S,p)&&p)
   Push(S,p->lchild);
  Pop(S,p);
  if(!StackEmpty(S)){
   Pop(S,p);
   printf(" %c",p->data);
   Push(S,p->rchild);
  }
 }
}

非递归后序遍历

void NoRecursionPostOrderTraverse(BiTree T){
 SqStack S;
 InitStack(S);
 BiTree p = T;
 while(p || !StackEmpty(S)){
  if(p){
   if(p->flag==1 ){
    p->flag = 2;         //此时将flag设置成2可让下一次调用此函数访问此二叉树不受影响
    printf(" %c",p->data);
    if(StackEmpty(S))
     break;
    Pop(S,p);
   }
   else
   {
    p->flag = 1;
    Push(S,p);
    Push(S,p->rchild);
    p = p->lchild;
   }
  }
  else
   Pop(S,p);
 }
}

打印

void main(){
 BiTree T;
 printf("请输入先序序列，用 # 表示空：\n");
 RecursionCreateBiTree(T);
 printf("\n");
 printf("先序递归：");
 RecursionPreOrder(T);
 printf("\n");
 printf("中序递归：");
 RecursionInOrder(T);
 printf("\n");
 printf("后序递归：");
 RecursionPostOrder(T);
 printf("\n");
 printf("先序非递归：");
 NoRecursionPreOrderTraverse(T);
 printf("\n");
 printf("中序非递归：");
 NoRecursionInOrderTraverse(T);
 printf("\n");
 printf("后序非递归：");
 NoRecursionPostOrderTraverse(T);
 printf("\n");
}

二叉树