树和二叉树（代码）

【代码】

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;

typedef struct TreeNode {
    ElementType Data;
    struct TreeNode *Left;
    struct TreeNode *Right;
}*BinTree, *Position;

Position createBinNode(ElementType data)
{
    Position T;

    T = (Position)malloc(sizeof(struct TreeNode));
    if(T == NULL)
    {
        return NULL;
    }
    T->Left  = NULL;
    T->Right = NULL;
    T->Data  = data;

    return T;
}

// 二叉树的递归遍历
void PreOrderTraversal(BinTree Bt)
{
    if(Bt)
    {
        printf("%c ", Bt->Data);
        PreOrderTraversal(Bt->Left);
        PreOrderTraversal(Bt->Right);
    }
}

#if 0
void PreOrderTraversal_R2L(BinTree Bt)
{
    if(Bt)
    {
        printf("%c ", Bt->Data);
        PreOrderTraversal_R2L(Bt->Right);
        PreOrderTraversal_R2L(Bt->Left);
    }
}
#endif

void InOrderTraversal(BinTree Bt)
{
    if(Bt)
    {
        InOrderTraversal(Bt->Left);
        printf("%c ", Bt->Data);
        InOrderTraversal(Bt->Right);
    }
}

void PostOrderTraversal(BinTree Bt)
{
    if(Bt)
    {
        PostOrderTraversal(Bt->Left);
        PostOrderTraversal(Bt->Right);
        printf("%c ", Bt->Data);
    }
}

// 二叉树的非递归遍历
void PreOrderTraversal_ext(BinTree Bt)
{
    BinTree pStack[100];
    int top = -1;
    Position pBt = Bt;

    while(pBt != NULL || top > -1) /* Bt || !isEmpty(pStack) */
    {
        while(pBt)
        {
            // 与中序遍历不同点就是在第一次压栈的时候就进行访问了
            printf("%c ", pBt->Data);
            pStack[++top] = pBt;
            pBt = pBt->Left;
        }
        if(top > -1) /* !isEmpty(pStack) */
        {
            pBt = pStack[top--];
            //printf("%c ", pBt->Data);
            pBt = pBt->Right; /* 转向右子树 */
        }
    }
}

void InOrderTraversal_ext(BinTree Bt)
{
    BinTree pStack[100];
    int top = -1;
    Position pBt = Bt;

    // 当前访问的结点没有右子树的时候,就会出现pBt==NULL,但是栈不空的情况
    while(pBt != NULL || top > -1) /* Bt || !isEmpty(pStack) */
    {
        // TODO: 1.遇到一个结点，就把它压栈，并去遍历它的左子树
        while(pBt)
        {
            pStack[++top] = pBt;
            pBt = pBt->Left;
        }
        // TODO: 2.当左子树遍历结束后，从栈顶弹出这个结点并访问它
        if(top > -1) /* !isEmpty(pStack) */
        {
            pBt = pStack[top--];
            printf("%c ", pBt->Data);
            // TODO: 3.然后按其右指针再去中序遍历该结点的右子树
            pBt = pBt->Right; /* 转向右子树 */
        }
    }
}

void PostOrderTraversal_ext(BinTree Bt)
{
    BinTree pStack[100];
    int top = -1;
    Position pBt = Bt;
    Position pPre = NULL;

    // 先把根结点入栈
    pStack[++top] = Bt;
    while(top > -1)
    {
        // 只探测栈顶的结点是否满足被访问的条件
        // 当前结点为叶结点 或者 当前结点的左孩子或右孩子已经被访问过来，则满足访问条件
        // 怎么保证当前弹出栈的结点比其父结点先出的？
        pBt = pStack[top];
        if((pBt->Left == NULL && pBt->Right == NULL)
            || (pPre != NULL && (pPre == pBt->Left || pPre == pBt->Right)))
        {
            printf("%c ", pBt->Data);
            top--;
            pPre = pBt;
        }
        else
        {
            if(pBt->Right != NULL)
            {
                pStack[++top] = pBt->Right;
            }
            if(pBt->Left != NULL)
            {
                pStack[++top] = pBt->Left;
            }
        }
    }
}

void LevelOrderTraversal(BinTree Bt)
{
    BinTree pQueue[100];
    int head = 0;
    int tail = 0;
    BinTree pBt;

    pQueue[tail++] = Bt;
    while(tail != head)
    {
        pBt = pQueue[head++];
        printf("%c ", pBt->Data);
        if(pBt->Left != NULL)
        {
            pQueue[tail++] = pBt->Left;
        }
        if(pBt->Right != NULL)
        {
            pQueue[tail++] = pBt->Right;
        }
    }
}

// 输出二叉树的叶子结点,无论前中后序,叶子的输出顺序都是一样的,从树的左到右.
void PreOrderPrintLeaves(BinTree Bt)
{
    if(Bt)
    {
        if(Bt->Left == NULL && Bt->Right == NULL)
            printf("%c ", Bt->Data);
        PreOrderPrintLeaves(Bt->Left);
        PreOrderPrintLeaves(Bt->Right);
    }
}

void InOrderPrintLeaves(BinTree Bt)
{
    if(Bt)
    {
        InOrderPrintLeaves(Bt->Left);
        if(Bt->Left == NULL && Bt->Right == NULL)
            printf("%c ", Bt->Data);
        InOrderPrintLeaves(Bt->Right);
    }
}

void PostOrderPrintLeaves(BinTree Bt)
{
    if(Bt)
    {
        PostOrderPrintLeaves(Bt->Left);
        PostOrderPrintLeaves(Bt->Right);
        if(Bt->Left == NULL && Bt->Right == NULL)
            printf("%c ", Bt->Data);
    }
}

// 求二叉树的叶结点个数
static int giNodeCnt = 0;
void PreOrderGetNodes(BinTree Bt)
{
    if(Bt)
    {
        PreOrderGetNodes(Bt->Left);
        PreOrderGetNodes(Bt->Right);
        if(Bt->Left == NULL && Bt->Right == NULL)
            giNodeCnt++;
    }
}

int BinTreeGetLeaves(BinTree Bt)
{
    if(Bt == NULL)
        return 0;
    if(Bt->Left == NULL && Bt->Right == NULL)
        return 1;
    else
        return BinTreeGetLeaves(Bt->Left) + BinTreeGetLeaves(Bt->Right);
}

// 求二叉树的高度
int PostOrderGetHeight(BinTree Bt)
{
    int HL, HR, MaxH;

    if(Bt)
    {
        HL = PostOrderGetHeight(Bt->Left);
        HR = PostOrderGetHeight(Bt->Right);
        MaxH = (HL > HR) ? HL : HR;
        return (MaxH + 1);
    }
    else
    {
        return 0;
    }
}

int main(void)
{
    int MaxH;
    Position T1;
    Position T21, T22;
    Position T31, T32, T33, T34;
    Position T41, T42, T43, T44, T45, T46, T47, T48;

    T1  = createBinNode('A');
    T21 = createBinNode('B');
    T22 = createBinNode('C');
    T31 = createBinNode('D');
    T32 = createBinNode('F');
    T33 = createBinNode('G');
    T34 = createBinNode('I');
    T43 = createBinNode('E');
    T46 = createBinNode('H');

    
    T1->Left   = T21;
    T1->Right  = T22;

    T21->Left  = T31;
    T21->Right = T32;

    T22->Left  = T33;
    T22->Right = T34;

    T32->Left  = T43;

    T33->Right = T46;
    
    printf("
");
    printf("PreOrderTraversal:
");
    PreOrderTraversal(T1);

    printf("
");
    printf("PreOrderTraversal_ext:
");
    PreOrderTraversal_ext(T1);

    //printf("
");
    //printf("PreOrderTraversal R->L:
");
    //PreOrderTraversal_R2L(T1);

    printf("
");
    printf("InOrderTraversal:
");
    InOrderTraversal(T1);

    printf("
");
    printf("InOrderTraversal_ext:
");
    InOrderTraversal(T1);

    printf("
");
    printf("PostOrderTraversal:
");
    PostOrderTraversal(T1);

    printf("
");
    printf("PostOrderTraversal_ext:
");
    PostOrderTraversal_ext(T1);

    printf("
");
    printf("LevelOrderTraversal:
");
    LevelOrderTraversal(T1);

    printf("
");
    printf("PreOrderPrintLeaves:
");
    PreOrderPrintLeaves(T1);
    printf("
");
    printf("InOrderPrintLeaves:
");
    InOrderPrintLeaves(T1);
    printf("
");
    printf("PostOrderPrintLeaves:
");
    PostOrderPrintLeaves(T1);

    printf("
");
    printf("PostOrderGetHeight::");
    MaxH = PostOrderGetHeight(T1);
    printf("%d
", MaxH);

    printf("
");
    PreOrderGetNodes(T1);
    printf("PreOrderNodes: %d
", giNodeCnt);

    printf("
");
    printf("BinTreeGetLeaves: %d
", BinTreeGetLeaves(T1));

    return 0;
}