二叉树的遍历

---

二叉树的遍历

通用类型定义

#define MaxSize 255

typedef char ElemType;

typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild,*rchild;
    //可定义父节点指针  struct BiTNode *parent;
}BiTNode,*BiTree;

访问结点时所做的操作

void visit(BiTNode *T){
    printf("%c-->",T->data);
}

---

递归算法遍历

先序遍历

void PreOrder(BiTree T){
    if(T!=NULL){
        visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

中序遍历

void PreOrder(BiTree T){
    if(T!=NULL){
        visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

后序遍历

void PreOrder(BiTree T){
    if(T!=NULL){
        visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

---

非递归算法遍历

栈的类型定义及操作

typedef struct{                 //顺序栈类型定义
    BiTNode *data[MaxSize];
    int top;
}SqStack;

void InitStack(SqStack *S){		//栈的初始化
    S->top=-1;
}

int StackEmpty(SqStack S){		//判断栈是否为空
    if(S.top==-1)
        return 1;
    else
        return 0;
}

int Push(SqStack *S,BiTNode *x){		//入栈
    if((*S).top==MaxSize-1)
        return 0;
    (*S).data[++(*S).top]=x;
    return 1;
}

int Pop(SqStack *S,BiTNode **x){		//出栈
    if((*S).top==-1)
        return 0;
    *x=S->data[S->top--];
    return 1;
}

int GetTop(SqStack *S,BiTNode **x){		//读栈顶元素
    if(S->top==-1)
        return 0;
    *x=S->data[S->top];
    return 1;
}

先序遍历

void PreOrder2(BiTree T){
    SqStack S;
    InitStack(&S);
    BiTNode *p=T;
    while(p || !StackEmpty(S)){
        if(p){
            visit(p);		//先对根节点进行操作
            Push(&S,p);		//入栈
            p=p->lchild;		//访问左子树
        }
        else{
            Pop(&S,&p);		//出栈
            p=p->rchild;	//访问右子树
        }
    }
}

中序遍历

void InOrder2(BiTree T){
    SqStack S;
    InitStack(&S);
    BiTNode *p=T;
    while(p || !StackEmpty(S)){
        if(p){
            Push(&S,p);
            p=p->lchild;
        }
        else{
            Pop(&S,&p);
            visit(p);
            p=p->rchild;
        }
    }
}

后序遍历

void PostOrder2(BiTree T){
    SqStack S;
    InitStack(&S);
    BiTNode *p=T;
    BiTNode *r=NULL;
    while(p || !StackEmpty(S)){		//p或者栈其中一个不为空，循环继续
        if(p){			//当p结点不为空时
            Push(&S,p);		//入栈
            p=p->lchild;	//继续访问左子树
        }
        else{
            GetTop(&S,&p);		//读取栈顶元素
            if(p->rchild && p->rchild!=r){
            //当p结点存在右子树且右子树不为上一次访问的结点时		
                p=p->rchild;	//继续对右子树进行遍历
            }
            else{
                Pop(&S,&p);
                visit(p);
                r=p;		//r用来记录上一次访问的结点
                p=NULL;
            }
        }
    }
}

层次遍历

队列的定义及基本操作

typedef struct{			//顺序队列的类型定义
    BiTNode *data[MaxSize];
    int front,rear;
}SqQueue;

void InitQueue(SqQueue *Q){		  //初始化队列
    Q->front=Q->front=0;
}

int QueueEmpty(SqQueue Q){		 //判断队列是否为空
    if(Q.rear==Q.front)
        return 1;
    else
        return 0;
}

int EnQueue(SqQueue *Q,BiTNode *x){		 //入队
    if((Q->rear+1)%MaxSize==Q->front)
        return 0;
    Q->data[Q->rear++]=x;
    return 1;
}

int DeQueue(SqQueue *Q,BiTNode **x){   		//出队
    if(Q->rear==Q->front)
        return 0;
    *x=Q->data[Q->front];
    Q->front=(Q->front+1)%MaxSize;
    return 1;
}

int GetHead(SqQueue Q,BiTNode **x){			//读取队头元素
    if(Q.rear==Q.front)
        return 0;
    *x=Q.data[Q.front];
    return 1;
}

void LevelOrder(BiTree T){
    BiTNode *p;
    SqQueue Q;
    InitQueue(&Q);
    EnQueue(&Q,T);		//先使根节点入队
    while(!QueueEmpty(Q)){		//栈不为空则循环继续
        DeQueue(&Q,&p);			//弹出栈顶元素
        visit(p);			//对栈顶元素进行操作
        if(p->lchild!=NULL){		//左孩子不为空时
            EnQueue(&Q,p->lchild);		//左孩子入队
        }
        if(p->rchild!=NULL){		//右孩子不为空时
            EnQueue(&Q,p->rchild);		//右孩子入队
        }
    }
}