二叉树的建立和遍历

    二叉树的节点结构为：

struct NODE
{
    char ch;

    struct NODE *lChild;
    struct NODE *rChild;
};

    按照前序的顺序递归建立一颗二叉树：

void PreOrderCreatBinary(struct NODE **root)
{
    // 函数入口检验
    if (NULL == root)
    {
        printf ("Invalid Parameter(s)!\n");
        return;
    }

    char ch;

    printf ("Input NODE value, '#' equal NULL:");
    scanf ("%c", &ch);

    // 去掉输入结束按下的回车符
    getchar();

    if ('#' == ch)
    {
        *root = NULL;
        return;
    }

    if (NULL == (*root = (struct NODE *)malloc(sizeof(struct NODE))))
    {
        printf ("Fail to malloc space for *root!\n");
        return;
    }

    (*root)->ch = ch;

    // 建立其左子树
    printf ("Create %c's left child.\n", (*root)->ch);
    PreOrderCreatBinary (&((*root)->lChild));

    // 建立其右子树
    printf ("Create %c's right child.\n", (*root)->ch);
    PreOrderCreatBinary (&((*root)->rChild));
}

    前序递归遍历二叉树：

void RecursionPreOrder(struct NODE *root)
{
    if (NULL != root)
    {
        // 访问根节点
        printf ("%c ", root->ch);

        // 访问左子树
        RecursionPreOrder (root->lChild);

        // 访问右子树
        RecursionPreOrder (root->rChild);
    }
}

    第一种非递归前序遍历二叉树的方式：

void NonRecursivePreOrder(struct NODE *root)
{
    if (NULL == root)
    {
        printf ("Empty Binary Tree!\n");
        return;
    }

    struct NODE *Stack[MAX];
    int nTop = -1;
    struct NODE *Temp = NULL;

    // 根节点首先入栈
    Stack[++nTop] = root;
    while (nTop >= 0)
    {
        // 取出栈顶节点并访问
        Temp = Stack[nTop--];
        printf ("%c ", Temp->ch);

        // 左子树要先于右子树被访问，则右子树先入栈
        if (NULL != (Temp->rChild))
        {
            Stack[++nTop] = Temp->rChild;
        }

        // 然后左子树入栈
        if (NULL != (Temp->lChild))
        {
            Stack[++nTop] = Temp->lChild;
        }
    }
}

    第二种非递归前序遍历二叉树的方式：

void NonRecursivePreOrder2(struct NODE *root)
{
    if (NULL == root)
    {
        printf ("Empty Binary Tree!\n");
        return;
    }

    struct NODE *Stack[MAX];
    int nTop = -1;
    struct NODE *Temp = root;

    // 访问当前节点及其全部左子树
    while (NULL != Temp)
    {
        printf ("%c ", Temp->ch);

        Stack[++nTop] = Temp;
        Temp = Temp->lChild;
    }

    while (nTop >= 0)
    {
        // 取得栈顶元素的右子树
        Temp = Stack[nTop]->rChild;
        --nTop;

        // 同样访问当前节点及其全部左子树
        while (NULL != Temp)
        {
            printf ("%c ", Temp->ch);
            
            Stack[++nTop] = Temp;
            Temp = Temp->lChild;
        }
    }
}

    中序递归遍历二叉树：

void RecursionInOrder(struct NODE *root)
{
    if (NULL != root)
    {
        // 访问左子树
        RecursionInOrder (root->lChild);

        // 访问根节点
        printf ("%c ", root->ch);

        // 访问右子树
        RecursionInOrder (root->rChild);
    }
}

    中序非递归遍历二叉树：

void NonRecursionInOrder(struct NODE *root)
{
    if (NULL == root)
    {
        printf ("Empty Binary Tree!\n");
        return;
    }

    struct NODE *Stack[MAX];
    int nTop = -1;
    struct NODE *curr = root->lChild;

    Stack[++nTop] = root;

    while ((NULL != curr) || (nTop >= 0))
    {
        // 根节点及其左子树全部入栈
        while (NULL != curr)
        {
            Stack[++nTop] = curr;
            curr = curr->lChild;
        }

        // 访问栈顶节点
        curr = Stack[nTop--];
        printf ("%c ", curr->ch);

        curr = curr->rChild;
    }
}

    后序递归遍历二叉树：

void RecursionPostOrder(struct NODE *root)
{
    if (NULL != root)
    {
        // 访问左子树
        RecursionPostOrder (root->lChild);

        // 访问右子树
        RecursionPostOrder (root->rChild);

        // 访问根节点
        printf ("%c ", root->ch);
    }
}

    第一种后序非递归遍历二叉树的方式：

void NonRecursionPostOrder(struct NODE *root)
{
    if (NULL == root)
    {
        printf ("Empty Binary Tree!\n");
        return;
    }

    struct NODE *Stack[MAX];
    int nTop = -1;
    struct NODE *curr = root;
    struct NODE *Previewed = NULL;

    while ((NULL != curr) || (nTop >= 0))
    {
        while (NULL != curr)
        {
            Stack[++nTop] = curr;
            curr = curr->lChild;
        }
        
        // 获取当前栈顶节点
        curr = Stack[nTop];

        // 判断当前节点的右子树状态然后做出相应的操作
        if ((NULL == (curr->rChild)) || (Previewed == (curr->rChild)))
        {
            printf ("%c ", curr->ch);
            Previewed = curr;
            curr = NULL;
            --nTop;
        } 
        else
        {
            curr = curr->rChild;
        }
    }
}

    第二种后序非递归遍历二叉树的方式：

void NonRecursionPostOrder2(struct NODE *root)
{
    if (NULL == root)
    {
        printf ("Empty Binary Tree!\n");
        return;
    }

    struct NODE *Stack1[MAX];
    int nTop1 = -1;
    struct NODE *Stack2[MAX];
    int nTop2 = -1;
    struct NODE *Temp = NULL;

    // 根节点先入栈1
    Stack1[++nTop1] = root;
    while (nTop1 >= 0)
    {
        Temp = Stack1[nTop1--];
        Stack2[++nTop2] = Temp;

        // 左子树要先在栈2中被访问，则左子树需先入栈1
        if (NULL != (Temp->lChild))
        {
            Stack1[++nTop1] = Temp->lChild;
        }

        if (NULL != (Temp->rChild))
        {
            Stack1[++nTop1] = Temp->rChild;
        }
    }

    // 按2栈出栈顺序打印即是后序顺序
    while (nTop2 >= 0)
    {
        Temp = Stack2[nTop2--];
        printf ("%c ", Temp->ch);
    }
}

    测试主函数：

#include <stdio.h>
#include <malloc.h>
#define MAX 100

int main(void)
{
    struct NODE *root = NULL;

    // 前序建立二叉树
    PreOrderCreatBinary (&root);

    printf ("\n建立的二叉树的前序递归遍历序列为:\n");
    RecursionPreOrder (root);
    printf ("\n");

    printf ("\n建立的二叉树的前序第一种非递归方式遍历序列为:\n");
    NonRecursivePreOrder (root);
    printf ("\n");

    printf ("\n建立的二叉树的前序第二种非递归方式遍历序列为:\n");
    NonRecursivePreOrder2 (root);
    printf ("\n");

    printf ("\n建立的二叉树的中序递归遍历序列为:\n");
    RecursionInOrder (root);
    printf ("\n");

    printf ("\n建立的二叉树的中序非递归遍历序列为:\n");
    NonRecursionInOrder (root);
    printf ("\n");

    printf ("\n建立的二叉树的后序递归遍历序列为:\n");
    RecursionPostOrder (root);
    printf ("\n");

    printf ("\n建立的二叉树的后序第一种非递归方式遍历序列为:\n");
    NonRecursionPostOrder (root);
    printf ("\n");

    printf ("\n建立的二叉树的后序第二种非递归方式遍历序列为:\n");
    NonRecursionPostOrder2 (root);
    printf ("\n");

    return(0);
}

    结果：