二叉树的非递归遍历（先序、中序、后序和层序遍历）

[前文]

二叉树的非递归遍历有 先序遍历、中序遍历 、后续遍历 和 层序遍历。

非递归算法实现的基本思路：使用堆栈。而层序遍历的实现：使用队列。

如下图所示的二叉树：

　　　　

前序遍历顺序为：ABCDE　　（先访问根节点，然后先序遍历其左子树，最后先序遍历其右子树）

中序遍历顺序为：CBDAE　　（先中序遍历其左子树，然后访问很节点，最后中序遍历其右子树）

后续遍历顺序为：CDBEA　　（先后序遍历其左子树，然后后续其右子树，最后访问根节点）

层序遍历顺序为：ABECD　　 （由上至下、从左到右遍历二叉树）

[准备]

　　1. 堆栈的存储结构和相关操作（具体见： 堆栈的定义与操作——顺序存储和链式存储）

　　2. 队列的存储结构和相关操作（具体见：队列的定义与操作——顺序存储和链式存储）

　　3. 建立二叉树。

typedef struct TreeNode *BinTree;
struct TreeNode {
    char Data;
    BinTree Left;
    BinTree Right;
};

BinTree CreateBinTree(BinTree T)
{
    char c;
    scanf("%c", &c);
    if ( c != '#' ) {
        T = (BinTree)malloc(sizeof(struct TreeNode));
        T->Data = c;
        T->Left = CreateBinTree(T->Left);
        T->Right = CreateBinTree(T->Right);
    }
    else {
        T = NULL;
    }
    return T;
}

[实现]　　

　　1. 先序遍历

void PreOrderTraverse(BinTree BT)
{
    BinTree T = BT;
    Stack S = CreateStack();    /* 创建并初始化堆栈  */
    while ( T || !IsEmpty(S) ) {
        while ( T ) {         /* 一直向左并将沿途节点压入栈底  */
            printf("%c ", T->Data);    /* 打印节点数据 */
            Push(S, T);
            T = T->Left;  
        }
        if ( !IsEmpty(S) ) {
            T = Pop(S);            /* 节点弹出堆栈 */ 
            T = T->Right;        /* 转向右子树 */ 
        }
    }
}

　　2.中序遍历

void InOrderTraverse(BinTree BT)
{
    BinTree T = BT;
    Stack S = CreateStack();    /* 创建并初始化堆栈  */
    while ( T || !IsEmpty(S) ) {
        while ( T ) {         /* 一直向左并将沿途节点压入栈底  */
            Push(S, T);
            T = T->Left;  
        }
        if ( !IsEmpty(S) ) {
            T = Pop(S);            /* 节点弹出堆栈 */ 
            printf("%c ", T->Data);    /* 打印节点数据 */
            T = T->Right;        /* 转向右子树 */ 
        }
    }
}

　　3. 后序遍历

struct Node {
    BinTree BT;
    char Tag;
};
typedef struct Node *PtrToNode;

void PostOrderTraverse(BinTree T)
{
    BinTree P = T;
    struct Node *PNode;
    Stack S = CreateStack();
    
    while ( P || !IsEmpty(S) ) {
        // 遍历左子树 
        while ( P ) {
            PNode = (struct Node*)malloc(sizeof(struct Node));
            PNode->BT = P;
            PNode->Tag = 'L';    //  第一次被标记 
            Push(S, PNode);
            P = P->Left;
        }
        // 栈不空 并且  栈顶元素 是第二次被标记 
        while ( !IsEmpty(S) && GetTop(S)->Tag == 'R' ) {
            PNode = Pop(S);
            printf("%c ", PNode->BT->Data);
        }
        
        if ( !IsEmpty(S) ) {
            PNode = GetTop(S);
            PNode->Tag = 'R';    // 第二次被标记 
            P = PNode->BT;
            P = P->Right;         // 转向右子树 
        }
    }
}

　　4. 层序遍历

void LevelOrderTraverse(BinTree BT)
{
    Queue Q;
    ElementType T;
    
    if ( !BT )    return;    // 若是空树则返回 
    
    Q = CreateQueue();    // 创建空队列  
    AddQ(Q, BT);
    while ( !IsEmpty(Q) ) {
        T = DeleteQ(Q);
        printf("%c ", T->Data);
        if ( T->Left )    AddQ(Q, T->Left);
        if ( T->Right ) AddQ(Q, T->Right);
    }
}