二叉樹的遍歷及經常使用算法

時間 2020-05-23

標籤二叉樹遍歷經常使用算法欄目應用數學简体版

原文原文鏈接

二叉樹的遍歷及經常使用算法

遍歷的定義:

按照某種次序訪問二叉樹上的全部結點,且每一個節點僅被訪問一次;node

遍歷的重要性:算法

當咱們須要對一顆二叉樹進行,插入,刪除,查找等操做時,一般都須要先遍歷二叉樹,全部說:遍歷是二叉樹的基本操做;數據結構

遍歷思路:

二叉樹的數據結構是遞歸定義(每一個節點均可能包含相同結構的子節點),因此遍歷也可使用遞歸,即結點不爲空則繼續遞歸調用測試
每一個節點都有三個域,數據與,左孩子指針和右孩子之指針,每次遍歷只須要讀取數據,遞歸左子樹,遞歸右子樹,這三個操做spa

三種遍歷次序:

根據訪問三個域的不一樣順序,能夠有多種不一樣的遍歷次序,而一般對於子樹的訪問都按照從左往右的順序;指針

設:L爲遍歷左子樹,D爲訪問根結點,R爲遍歷右子樹,且L必須位於R的前面code

能夠得出如下三種不一樣的遍歷次序:blog

先序遍歷

操做次序爲DLR,首先訪問根結點，其次遍歷根的左子樹，最後遍歷根右子樹，對每棵子樹一樣按這三步(先根、後左、再右)進行遞歸

中序遍歷

操做次序爲LDR,首先遍歷根的左子樹，其次訪問根結點，最後遍歷根右子樹，對每棵子樹一樣按這三步(先左、後根、再右)進行隊列

後序遍歷

操做次序爲LRD,首先遍歷根的左子樹，其次遍歷根的右子樹，最後訪問根結點，對每棵子樹一樣按這三步(先左、後右、最後根)進行

層次遍歷

層次遍歷即按照從上到下從左到右的順序依次遍歷全部節點,實現層次遍歷一般須要藉助一個隊列,將接下來要遍歷的結點依次加入隊列中;

遍歷的應用

「遍歷」是二叉樹各類操做的基礎，能夠在遍歷過程當中對結點進行各類操做，如:對於一棵已知二叉樹

求二叉樹中結點的個數
求二叉樹中葉子結點的個數;
求二叉樹中度爲1的結點個數
求二叉樹中度爲2的結點個數
5求二叉樹中非終端結點個數
交換結點左右孩子
斷定結點所在層次

等等...

C語言實現:

#include <stdio.h>

//二叉鏈表數據結構定義
typedef struct TNode {
    char data;
    struct TNode *lchild;
    struct TNode *rchild;
} *BinTree, BinNode;


//初始化
//傳入一個指針 令指針指向NULL
void initiate(BinTree *tree) {
    *tree = NULL;
}

//建立樹
void create(BinTree *BT) {
    printf("輸入當前結點值: (0則建立空節點)\n");
    char data;
    scanf(" %c", &data);//連續輸入整形和字符時.字符變量會接受到換行,因此加空格
    if (data == 48) {
        *BT = NULL;
        return;
    } else {
        //建立根結點
        //注意開闢的空間大小是結構體的大小 而不是結構體指針大小,寫錯了不會立馬產生問題,可是後續在其中存儲數據時極有可能出現內存訪問異常(飆淚....)
        *BT = malloc(sizeof(struct TNode));
        //數據域賦值
        (*BT)->data = data;
        printf("輸入節點 %c 的左孩子 \n", data);
        create(&((*BT)->lchild));//遞歸建立左子樹
        printf("輸入節點 %c 的右孩子 \n", data);
        create(&((*BT)->rchild));//遞歸建立右子樹
    }
}

//求雙親結點(父結點)
BinNode *Parent(BinTree tree, char x) {
    if (tree == NULL)
        return NULL;
    else if ((tree->lchild != NULL && tree->lchild->data == x) ||
            (tree->rchild != NULL && tree->rchild->data == x))
        return tree;
    else{
        BinNode *node1 = Parent(tree->lchild, x);
        BinNode *node2 = Parent(tree->rchild, x);
        return node1 != NULL ? node1 : node2;
    }

}
//先序遍歷
void PreOrder(BinTree tree) {
    if (tree) {
        //輸出數據
        printf("%c ", tree->data);
        //不爲空則按順序繼續遞歸判斷該節點的兩個子節點
        PreOrder(tree->lchild);
        PreOrder(tree->rchild);
    }
}

//中序
void InOrder(BinTree tree) {
    if (tree) {
        InOrder(tree->lchild);
        printf("%c ", tree->data);
        InOrder(tree->rchild);
    }
}

//後序
void PostOrder(BinTree tree) {
    if (tree) {
        PostOrder(tree->lchild);
        PostOrder(tree->rchild);
        printf("%c ", tree->data);
    }
}


//銷燬結點 遞歸free全部節點
void DestroyTree(BinTree *tree) {
    if (*tree != NULL) {
        printf("free %c \n", (*tree)->data);
        if ((*tree)->lchild) {
            DestroyTree(&((*tree)->lchild));
        }
        if ((*tree)->rchild) {
            DestroyTree(&((*tree)->rchild));
        }
        free(*tree);
        *tree = NULL;
    }
}

// 查找元素爲X的結點    使用的是層次遍歷
BinNode *FindNode(BinTree tree, char x) {
    if (tree == NULL) {
        return NULL;
    }
    //隊列
    BinNode *nodes[1000] = {};
    //隊列頭尾位置
    int front = 0, real = 0;
    //將根節點插入到隊列尾
    nodes[real] = tree;
    real += 1;
    //若隊列不爲空則繼續
    while (front != real) {
        //取出隊列頭結點輸出數據
        BinNode *current = nodes[front];
        if (current->data == x) {
            return current;
        }
        front++;
        //若當前節點還有子(左/右)節點則將結點加入隊列
        if (current->lchild != NULL) {
            nodes[real] = current->lchild;
            real++;
        }
        if (current->rchild != NULL) {
            nodes[real] = current->rchild;
            real++;
        }
    }
    return NULL;
}

//層次遍歷
// 查找元素爲X的結點    使用的是層次遍歷
void LevelOrder(BinTree tree) {
    if (tree == NULL) {
        return;
    }
    //隊列
    BinNode *nodes[1000] = {};
    //隊列頭尾位置
    int front = 0, real = 0;
    //將根節點插入到隊列尾
    nodes[real] = tree;
    real += 1;
    //若隊列不爲空則繼續
    while (front != real) {
        //取出隊列頭結點輸出數據
        BinNode *current = nodes[front];
        printf("%2c", current->data);
        front++;
        //若當前節點還有子(左/右)節點則將結點加入隊列
        if (current->lchild != NULL) {
            nodes[real] = current->lchild;
            real++;
        }
        if (current->rchild != NULL) {
            nodes[real] = current->rchild;
            real++;
        }
    }
}


//查找x的左孩子
BinNode *Lchild(BinTree tree, char x) {
    BinTree node = FindNode(tree, x);
    if (node != NULL) {
        return node->lchild;
    }
    return NULL;
}

//查找x的右孩子
BinNode *Rchild(BinTree tree, char x) {
    BinTree node = FindNode(tree, x);
    if (node != NULL) {
        return node->rchild;
    }
    return NULL;
}


//求葉子結點數量
int leafCount(BinTree *tree) {
    if (*tree == NULL)
        return 0;
        //若左右子樹都爲空則該節點爲葉子,且後續不用接續遞歸了
    else if (!(*tree)->lchild && !(*tree)->rchild)
        return 1;
    else
        //若當前結點存在子樹,則遞歸左右子樹, 結果相加
        return leafCount(&((*tree)->lchild)) + leafCount(&((*tree)->rchild));
}


//求非葉子結點數量
int NotLeafCount(BinTree *tree) {
    if (*tree == NULL)
        return 0;
        //若該結點左右子樹均爲空,則是葉子,且不用繼續遞歸
    else if (!(*tree)->lchild && !(*tree)->rchild)
        return 0;
    else
        //若當前結點存在左右子樹,則是非葉子結點(數量+1),在遞歸獲取左右子樹中的非葉子結點,結果相加
        return NotLeafCount(&((*tree)->lchild)) + NotLeafCount(&((*tree)->rchild)) + 1;
}

//求樹的高度(深度)
int DepthCount(BinTree *tree) {
    if (*tree == NULL)
        return 0;
    else{
        //當前節點不爲空則深度+1 在加上子樹的高度,
        int lc = DepthCount(&((*tree)->lchild)) + 1;
        int rc = DepthCount(&((*tree)->rchild)) + 1;
        return lc > rc?lc:rc;// 取兩子樹深度的 最大值
    }
}

//刪除左子樹
void RemoveLeft(BinNode *node){
    if (!node)
        return;
    if (node->lchild)
        DestroyTree(&(node->lchild));
    node->lchild = NULL;
}
//刪除右子樹
void RemoveRight(BinNode *node){
    if (!node)
        return;
    if (node->rchild)
        DestroyTree(&(node->rchild));
    node->rchild = NULL;
}

int main() {
    BinTree tree;
    create(&tree);
    BinNode *node = Parent(tree, 'G');
    printf("G的父結點爲%c\n",node->data);
    BinNode *node2 = Lchild(tree, 'D');
    printf("D的左孩子結點爲%c\n",node2->data);
    BinNode *node3 = Rchild(tree, 'D');
    printf("D的右孩子結點爲%c\n",node3->data);
    printf("先序遍歷爲:");
    PreOrder(tree);
    printf("\n");
    printf("中序遍歷爲:");
    InOrder(tree);
    printf("\n");
    printf("後序遍歷爲:");
    PostOrder(tree);
    printf("\n");
    printf("層次遍歷爲:");
    LevelOrder(tree);
    printf("\n");

    int a = leafCount(&tree);
    printf("葉子結點數爲%d\n",a);
    int b = NotLeafCount(&tree);
    printf("非葉子結點數爲%d\n",b);
    int c = DepthCount(&tree);
    printf("深度爲%d\n",c);

    //查找F節點
    BinNode *node4 = FindNode(tree,'C');

    RemoveLeft(node4);
    printf("刪除C的左孩子後遍歷:");
    LevelOrder(tree);
    printf("\n");
    
    RemoveRight(node4);
    printf("刪除C的右孩子後遍歷:");
    LevelOrder(tree);
    printf("\n");
    
    //銷燬樹
    printf("銷燬樹 \n");
    DestroyTree(&tree);
    printf("銷燬後後遍歷:");
    LevelOrder(tree);
    printf("\n");
    printf("Hello, World!\n");
    return 0;
}

測試:

測試數據爲下列二叉樹:

運行程序複製粘貼下列內容:

A
B
D
G
0
0
H
0
0
E
0
0
C
K
0
0
F
I
0
J
0
0
0

特別感謝:iammomo

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。