二叉树的遍历(前中后，层次)——legend



二叉树的遍历：traverse

 （1）深度优先遍历 ：（递归与非递归）

  （1.1）先序 （先根）：preOrder(WithRecusion/WithoutRecusion)
  （1.2）中序 （中根）：inOrder(WithRecusion/WithoutRecusion)
  （1.3）后序 （后根）：postOrder(WithRecusion/WithoutRecusion)

（注意：非递归的深度优先遍历中：栈中的字段有top,以及节点指针数组BTNode* array[Maxsize]   ）

----

 （2）广度优先遍历 ：
  （2.1）层次遍历 ：leverOrder

(注意：层次遍历中队列中的字段有 front ,rear  以及 节点指针数组 BTNode* array[Maxsize]  )

1.如果在队列中加入一个字段 int levelArray[Maxsize]可以记录下每个节点的层次。

2.如果在队列中的的数组的每个元素为typedef struct Element { BTNode * pnode ,int parentIndex};（parentIndex表示当前节点pnode的父节点所在的下标）

然后队列为{ front ,rear,  Element array[Maxsize]  }，则可以根据由某个节点快速的查找到父节点，对于查找路径方便。

-----

（3）祖先节点与 到根节点的路径：
 ---------------------------------
 （一）先序：先访根节点，再访问左子树，再访问右子树。
 （1）递归：
 void PreOrder(BTNode* b){

  if(b!=NULL){

   visit(b->data);
   PreOrder(b->lchild);
   PreOrder(b->rchild);
  }
 }

 （2）非递归：
 思想：先根，然后左子树，然后右子树。
 所以：先将根节点进栈，在栈非空时循环：出栈p，访问p，将其右孩子节点进栈，再左孩子节点接栈。

 void preOrder(BTNode *b){
  BTNode*  stack[Maxsize];
  BTNode * p;
  int top=-1;
  if(b!=NULL){
   top++;
   stack[top]=b;//根节点进栈

   while(top>-1){
   //栈非空

   p=stack[top];
   top--;//出栈

   visit(p->data);//访问

    if(p->rchild!=NULL){
    //右孩子非空，则进栈
    top++;
    stack[top]=p->rchild;
    }

//必须先判断右子树，然后再判断左子树，右孩子先进栈。

    if(p->lchild!=NULL){
    //左孩子非空，则进栈
    top++;
    stack[top]=p->lchild;
    }

   }

  }
 }

注意：非递归的先序遍历中，必须是先是右孩子进栈，然后孩子进栈，顺序不可以颠倒，否则就是根右左。
-----------

（二）中序：先左子树，然后跟节点，然后右子树。
（1）递归：
void inOrder(BTNode * b){
 if(b!=NULL){
 inOrder(b->lchild);
 visit(b->data);
 inOrder(b->rchild);
 }
}

（2）非递归：
思想：
1）先扫描根节点的所有左节点并将它们一一压栈，
2）然后出栈一个节点p，当前新出栈的节点p必然没有左孩子或者左孩子以及被访问过，然后访问节点p，
3）然后扫描节点p的右孩子，然后将p的右孩子的所有左孩子一一压栈，与1）重复，直至栈空。

   void inOrder(BTNode * b){
    BTNode* stack[Maxsize];
    BTNode* p;
    int top=-1;

    if(b!=NULL){
     p=b;
      while(p!=NULL || top>-1){
        while(p){
        //根节点p的左孩子不断进栈
        top++;
        stack[top]=p;
        p=p->lchild;
        }

        if(top>-1){
        //栈非空时
        p=stack[top];
        top--;//出栈

        visit(p->data);//访问
        p=p->rchild;//p的右子树作为新的p，让p的右子树的左孩子逐个进栈

        }

      }

    }
   }

   -----------

   （三）后续：先左子树，然后右子树，然后根节点。
   （1）递归：
    void postOrder(BTNode *b){
     if(b){
     postOrder(b->lchild);
     postOrder(b->rchild);
     visit(b->data);
     }
    }

   （2）非递归：

   思想：
   1）先扫描一个根节点的所有的左孩子并一一进栈
   2）出栈一个节点p，然后扫描节点p的右孩子并进栈，在扫描p的右孩子的所有左孩子并一一进栈。即将p的右孩子作为1）中的跟节点，重复1）
   3）当一个节点的左右孩子均访问过，才访问该节点。直至栈空。
难点：如何判断节点p的右孩子已经访问过了，用q保存右子树中刚刚访问过的节点（初值为null），若p->rchild=q，说明p节点的左右子树都已经访问过了，然后就可以访问p了。如果不成立，说明p的右子树没有访问完。

void postOrder(BTNode *b){
 BTNode* stack[Maxsize];
 BTNode* p=b,*pre;
 int flag,top=-1;

 if(b){

  do{

   while(p){//节点p的所有左孩子进栈
   top++;
   stack[top]=p;
   p=p->lchild;
   }

   pre=NULL;//pre指向栈顶节点前一个已经访问过的节点。
   flag=1;
   while(top!=-1 && flag==1){
    p=stack[top];//取栈顶，但不出栈

    if(p->rchild==pre){
    top--;//出栈
    visit(p->data);//访问
    pre=p;//更新已经访问过的 节点。
    }

    else{
    //否则将p节点的右孩子的所有左孩子进栈。
    p=p->rchild;
    flag=0;//跳出当前循环
    }
   }

  }while(top!=-1);

 }

}

---------------
（四）层次遍历:levelOrder
#include "queue.h"
void levelOrder(BTNode * T){
 BTNode * p;
 Queue Q;
 initQueue(Q);
 enQueue(Q,T);
 while(!isEmpty(Q)){
 deQueue(Q,p);
 visit(p->data);
 if(p->lchild) enQueue(Q,p->lchild);
 if(p->rchild)  enQueue(Q,p->rchild);
 }
}

或者：
void levelOrder(BTNode* b){
 BTNode* queue[Maxsize];
 int front=rear=-1;
 BTNode* pnode;

 rear++;
 queue[rear]=b;//进队

 while(rear!=front){//队列非空

 front=(front+1)%Maxsize;
 pnode=queue[front];//出队
 visit(pnode->data);//访问

 if(pnode->lchild) {
 rear++;
 queue[rear]=pnode->lchild;//左孩子进队
 }

 if(pnode->rchild) {
 rear++;
 queue[rear]=pnode->rchild;//右孩子进队
 }

 }

}

---------

（5）补充：路径与祖先节点。

1.某个节点的祖先节点 即 从该节点到根节点的路径；

2. 非递归的后序遍历中，栈中栈顶节点的下面的节点为栈顶节点的祖先节点，，即  将栈 中各个元素出栈可以得到栈顶节点到根结点的路径。