二叉树的遍历

前序遍历

递归算法：

void RECUR_PREORDER(BTREE T)
{
    if(T){
        VISIT(T);                                    
        PREORDER(T->lchild);
        PREORDER(T->rchild);
    }
}

非递归算法：

核心思想：设置一活动指针p，当p不为空时，先访问p节点，然后将p压入栈中，最后p指向其左孩子。当p为空时，则从栈中退出栈顶元素送p，然后再将p指向节点的右孩子。重复上述过程，直到p为空且栈也为空。

void PREORDER(BTREE T)
{
    BTREE stack[MAXSIZE],p = T;
    int top= -1;
    if(T){
        do{
            while(p!= NULL){
                printf("%d",p->data);
                stack[++top] == p;                     
                p = p->lchild;
            }
            p = stack[top--];
            p = p->rchild;
        }while(!(p && top == -1));
    }
}

中序遍历

递归算法：

void RECUR_INORDER(BTREE T)
{
    if(T){
        recur_INORDER(T->lchild);
        printf("%d",T->data);
        recur_INORDER(T->rchild);
    }
}

非递归算法：

核心思想：当p所指节点不为空时，则将节点所在链节点地址进栈，然后p指向该节点的左孩子节点；当p为空时，则从栈中取出栈顶元素送给p，并访问该节点，然后p指向该节点的右孩子节点。重复上述过程，直到p为空且栈也为空。
具体代码：

void INORDER(BTREE T)
{
    BTREE stack[MAXSIZE],p = T;
    int top = -1;
    if(T!= NULL){
        do{
            while(p!=NULL){
                stack[++top]=p;
                p=p->lchild;
            }
        }
        p = stakc[top--];
        printf("%d",p->data);
        p = p->rchild;
        
    }while(!(p == NULL && top == -1));
}

后序遍历

递归算法：

void SEUR_POSTORDER(BTREE T)
{
    if(T){
       SECUR_POSTORDER(T->lchild);
      SECUR_POSTORDER(T->rchild);
       printf("%d",T->data); 
    }
}

非递归算法：

核心思想：当p指向某一节点时，不能马上对它进行访问，而是要先遍历其左子树，因而要讲此结点进栈，当其左子树遍历完之后，也不能对它进行访问，而是要遍历其右子树，所以需再次将节点进栈，当遍历完右子树之后回到该节点，才能访问该节点，为了标明某节点是否可以访问，引入一个flag变量，并有

0	节点不可以访问
1	节点可以访问

代码实现：

void POSTORDER(BTREE T)
{
    BTREE stack1[MAXSIZE],p = T;
    int stack2[MAXSIZE],top = -1, flag;
    if(T != NULL){
        do{
            while(p != NULL){
                stack1[++top] = p;
                stack[top] = 0;
                p = p->lchild;
            }
            p = stack[top--];
            flag = stack2[top];
            if(flag){
                printf("%d",p->data);
                p = NULL;
            }
            else{
                stack1[++top]=p;
                stack2[top] = 1;
                p = p->rchild;
            }
        }while(!(!T&&top == -1));
    }
}

层序遍历（广度优先遍历）

void LAYERORDER(BTREE T)
{
    BTREE QUEUE[MAXSIZE],P;
    int front,rear;
    if(T!=NULL){
        QUEUE[0] = T;
        front =-1;
        rear = 0;
        while(rear != front){                    
            p =  QUEUE[++front];              
            visit(p);
            if(p->lchild)
                QUEUE[++rear] = p->lchild;     
            if(p->rchild)
                QUEUE[++rear] = p->rchild;       
        }
    }
}