二叉樹的建立

對於二叉樹的建立，可能很多人不知道如何去初始化一個二叉樹，其實初始化二叉樹非常簡單，需要引入一個擴充套件二叉樹的概念

擴充套件二叉樹

擴充套件二叉樹：讓二叉樹的所有節點都具有左右孩子，沒有孩子的，我們手動將其填滿，例如#，即如下所示

擴充套件二叉樹主要的目的是為了確定一顆二叉樹，我們都知道，只有前序加中序或者後序加中序才能確定一棵樹，但是我們同樣可以通過擴充套件二叉樹的前序確定一棵樹，即：
ABC###DE##F##

建立二叉樹程式碼

BiTree CreateTreeNode(void)
{
    char c;
    BiTree T;
    scanf("%c"
 
, &c);
    if (c == '#') {
        T = NULL;
    } else {
        T = (BiTree) calloc(sizeof(BiTNode), 1);
        T->data = c;
        T->lchild = CreateTreeNode();
        T->rchild = CreateTreeNode();
    }
    return T;
}

二叉樹的前中後序遍歷

二叉樹的建立採用的是遞迴的方式，那麼同樣二叉樹的遍歷同樣可以採取遞迴的方式，而且簡單明瞭

前序遍歷

：若二叉樹為空，則空操作返回，否則先訪問根節點，然後前序遍歷左子樹，再前序遍歷右子樹。按照上面建立的二叉樹，則遍歷順序為：ABCDEF

中序遍歷：若二叉樹為空，則空操作返回，否則從根節點開始(不是先訪問根節點)，中序遍歷根節點的左子樹，然後是訪問根節點，最後中序遍歷右子樹。按照上面建立的二叉樹，則遍歷順序為：CBAEDF

後序遍歷：若二叉樹為空，則空操作返回，否則從左到右先葉子後節點的方式先後遍歷左右子樹，最後遍歷根節點。按照上面建立的二叉樹，則遍歷順序為：CBEFDA

前中後序遍歷程式碼

void PreOrderTraverse(BiTree T)
{
    if (T == NULL
 
) {
        return;
    }
    printf("%c", T->data);
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
}

void InOrderTraverse(BiTree T)
{
    if (T == NULL) {
        return;
    }
    InOrderTraverse(T->lchild);
    printf("%c", T->data);
    InOrderTraverse(T->rchild);
}

void PostOrderTraverse(BiTree T)
{
    if (T == NULL) {
        return;
    }
    PostOrderTraverse(T->lchild);
    PostOrderTraverse(T->rchild);
    printf("%c", T->data);
}

二叉樹層次遍歷(佇列方式實現)

二叉樹層次遍歷，即按從上至下從左至右按層次遍歷，這個遍歷就和上面有所不同，不過採用佇列也是非常容易理解和實現的
若根節點為空，直接返回；若根節點非空，則將根節點入隊，然後，判斷佇列是否為空，若不為空，則將隊首節點出隊，訪問，並判斷其左右子節點是否為空，若不為空，則壓入佇列，然後迴圈上面操作直到佇列為空

二叉樹層次遍歷程式碼

void LevelOrderTraverse(BiTree T)
{
    QNode Tmp, tmp;
    LinkQueue Q;
    tmp.next = NULL;
    Tmp.next = NULL;
    Q.front = NULL;
    Q.rear = NULL;

    InitQueue(&Q);
    tmp.Tree = T;
    EnQueue(&Q, &tmp);  // 根節點入隊
    while (DeQueue(&Q, &Tmp)) { // 依次出隊，直到佇列為空
        printf("%c", Tmp.Tree->data);
        if (Tmp.Tree->lchild != NULL) { // 若出隊節點有左孩子，則左孩子入隊
            tmp.Tree = Tmp.Tree->lchild;
            EnQueue(&Q, &tmp);
        }
        if (Tmp.Tree->rchild != NULL) { // 若出隊節點有右孩子，則右孩子入隊
            tmp.Tree = Tmp.Tree->rchild;
            EnQueue(&Q, &tmp);
        }
    }
    FreeQueue(&Q);
}

完整程式碼

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

  > Author: xiaojunyu/LunaW
  > Mail  : [email protected]
  > Gmail : [email protected]
  > Blog  : http://blog.csdn.net/lunaw
  > Web   : http://lunaw.cn

 *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/

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

#define True 1
#define False 0

typedef struct BiTNode {
    int data;
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

BiTree CreateTreeNode(void);    // 先變為擴充套件二叉樹，前序遞迴輸入
void PreOrderTraverse(BiTree T);    // 前序遍歷，遞迴
void InOrderTraverse(BiTree T); // 中序遍歷，遞迴
void PostOrderTraverse(BiTree T);   // 後序遍歷，遞迴
void LevelOrderTraverse(BiTree T);  // 層次遍歷，佇列
void DestroyTree(BiTree T); // 銷燬樹，後序遞迴

/* 佇列 */
typedef struct QNode {
    BiTree Tree;
    struct QNode *next;
} QNode, *QueuePtr;

typedef struct Queue {
    QueuePtr front, rear;
} LinkQueue;

int IsEmpt(LinkQueue * queue);  // 判斷是否為空
int InitQueue(LinkQueue * queue);   //初始化佇列
int FreeQueue(LinkQueue * queue);   // 釋放佇列
int EnQueue(LinkQueue * queue, QueuePtr Q); // 進佇列
int DeQueue(LinkQueue * queue, QueuePtr Q); // 出佇列

int main(void)
{
    BiTree T = NULL;
    printf("請輸入擴充套件二叉樹: ");
    T = CreateTreeNode();
    printf("\n前序遍歷: ");
    PreOrderTraverse(T);
    printf("\n中序遍歷: ");
    InOrderTraverse(T);
    printf("\n後序遍歷: ");
    PostOrderTraverse(T);
    printf("\n層次遍歷: ");
    LevelOrderTraverse(T);
    DestroyTree(T);
    return 0;
}

BiTree CreateTreeNode(void)
{
    char c;
    BiTree T;
    scanf("%c", &c);
    if (c == '#') {
        T = NULL;
    } else {
        T = (BiTree) calloc(sizeof(BiTNode), 1);
        T->data = c;
        T->lchild = CreateTreeNode();
        T->rchild = CreateTreeNode();
    }
    return T;
}

void DestroyTree(BiTree T)
{
    if (T == NULL) {
        return;
    }
    DestroyTree(T->lchild);
    DestroyTree(T->rchild);
    free(T);        // 採用後序遍歷遞迴銷燬
    T = NULL;
}

void PreOrderTraverse(BiTree T)
{
    if (T == NULL) {
        return;
    }
    printf("%c", T->data);
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
}

void InOrderTraverse(BiTree T)
{
    if (T == NULL) {
        return;
    }
    InOrderTraverse(T->lchild);
    printf("%c", T->data);
    InOrderTraverse(T->rchild);
}

void PostOrderTraverse(BiTree T)
{
    if (T == NULL) {
        return;
    }
    PostOrderTraverse(T->lchild);
    PostOrderTraverse(T->rchild);
    printf("%c", T->data);
}

void LevelOrderTraverse(BiTree T)
{
    QNode Tmp, tmp;
    LinkQueue Q;
    tmp.next = NULL;
    Tmp.next = NULL;
    Q.front = NULL;
    Q.rear = NULL;

    InitQueue(&Q);
    tmp.Tree = T;
    EnQueue(&Q, &tmp);  // 根節點入隊
    while (DeQueue(&Q, &Tmp)) { // 依次出隊，直到佇列為空
        printf("%c", Tmp.Tree->data);
        if (Tmp.Tree->lchild != NULL) { // 若出隊節點有左孩子，則左孩子入隊
            tmp.Tree = Tmp.Tree->lchild;
            EnQueue(&Q, &tmp);
        }
        if (Tmp.Tree->rchild != NULL) { // 若出隊節點有右孩子，則右孩子入隊
            tmp.Tree = Tmp.Tree->rchild;
            EnQueue(&Q, &tmp);
        }
    }
    FreeQueue(&Q);
}

int DeQueue(LinkQueue * queue, QueuePtr Q)
{
    QueuePtr P;
    if (IsEmpt(queue)) {
        return False;
    }
    P = queue->front->next;
    memcpy(Q, P, sizeof(QNode));    // 將隊頭資料儲存
    queue->front->next = P->next;   // 隊頭下移一位
    if (queue->rear == P) { // 若隊尾是隊頭，則將隊尾指向頭節點
        queue->rear = queue->front;
    }
    free(P);
    return True;
}

int EnQueue(LinkQueue * queue, QueuePtr Q)
{
    QueuePtr S = (QueuePtr) calloc(sizeof(QNode), 1);
    memcpy(S, Q, sizeof(QNode));
    queue->rear->next = S;
    queue->rear = S;
    return 0;
}

int InitQueue(LinkQueue * queue)
{
    queue->front = (QueuePtr) calloc(sizeof(QNode), 1);
    queue->front->next = NULL;
    queue->rear = queue->front;
    return 0;
}

int IsEmpt(LinkQueue * queue)
{
    if (queue->front == NULL || queue->front == queue->rear) {
        return True;
    } else {
        return False;
    }
}

int FreeQueue(LinkQueue * queue)
{
    QueuePtr A, B;
    for (A = queue->front; A != NULL; B = A->next, free(A), A = B) ;
    return 0;
}