C語言實現二叉樹的基本操做

時間  2019-11-13
標籤 c語言 實現 二叉樹 基本 欄目 應用數學 简体版
原文   原文鏈接

二叉樹是一種很是重要的數據結構。本文總結了二叉樹的常見操做：二叉樹的構建，查找，刪除，二叉樹的遍歷(包括前序遍歷、中序遍歷、後序遍歷、層次遍歷)，二叉搜索樹的構造等。

1. 二叉樹的構建

  二叉樹的基本構建方式爲:添加一個節點，若是這是一棵空樹，則將該節點做爲根節點；不然按照從左到右、先左子樹後右子樹的順序逐個添加節點。好比依次添加節點:1,6,10,2,7,11，則獲得的二叉樹爲:

在這裏，咱們須要藉助一個鏈表來保存節點，以實現二叉樹的順序插入，具體作法以下：
1.0 初始化一個用來保存二叉樹節點的空鏈表；
1.1 插入一個節點，
①若是該樹是一棵空樹，則將該節點做爲根節點，而且將該節點添加到鏈表中；
②若是該樹不爲空，取得鏈表第一個節點的值(注意不是鏈表的頭節點)。若是該節點左子樹爲空，則將待插入節點添加到左子樹，而且將左子樹添加到鏈表；不然將待插入節點添加到右子樹，將右子樹添加到鏈表。此時，父節點的左右子樹都不爲空，將該父節點(即鏈表第一個節點)
彈出。
按照這樣的順序，咱們就能夠完成二叉樹節點的順序插入。node

2. 二叉搜索樹的構建

   二叉搜索樹是這樣一棵樹：對於任意一個節點，其左子樹的值均小於父節點的值；右子樹的值均大於父節點的值。從二叉樹的根節點開始，對於其左右子樹均按照這樣的方式遞歸插入，便可以獲得一棵二叉搜索樹。二叉搜索樹具備很好的性質，由於它的有序性，若是在二叉搜索樹中查找一個元素能夠按照相似二分查找的方式進行；對於二叉搜索樹，若是採用中序遍歷則能夠獲得按照值遞增排列的節點。二叉搜索樹的具體構建方式以下：
插入一個節點：
2.1若是當前節點自己值爲空，則將插入節點直接做爲當前節點；
2.2若是當前節點自己值不爲空，
①比較插入節點的值與當前節點的值，若是插入節點值小於當前節點值，則將該節點遞歸插入左子樹；
②比較插入節點的值與當前節點的值，若是插入節點值大於當前節點值，則將該節點遞歸插入右子樹；
③ 若是插入節點的值等於當前節點的值，則直接返回(即二叉搜索樹每一個節點的值都是不一樣的)。數據結構

3.二叉搜索樹的查找

  二叉搜索樹的查找相似於二分查找。具體步驟以下：
3.1 從根節點開始，比較查找值與當前節點值的大小：
① 若是當前節點值爲空，則說明沒法查找到該值，直接返回；
②若是當前節點值等於查找值，則查找成功；
③若是查找值小於當前節點的值，則遞歸查找左子樹；
④若是查找值大於當前節點的值，則遞歸查找右子樹。app

4. 二叉搜索樹的刪除

   二叉搜索樹的刪除與查找基本相似，不一樣之處在於若是查找到了待刪除的節點，則將該節點直接刪除以後，還要進行以下操做保證刪除節點以後的二叉樹還是一棵二叉搜索樹：
①若是該刪除節點沒有左右子樹，則直接刪除該節點；
②若是該刪除節點只有左子樹(右子樹)，則將刪除節點的父節點直接指向其左子樹(右子樹);
③若是該刪除節點既有左子樹又有右子樹，則有下面的三種處理方法：
4.3.1：找到按照中序遍歷該刪除節點的直接前驅節點，將該節點轉移到刪除節點，而後刪除這個前驅節點；
4.3.2：找到按照中序遍歷該刪除節點的直接後續節點，將該節點轉移到刪除節點，而後刪除這個後序節點；
4.3.3：找到按照中序遍歷該刪除節點的直接前驅節點，將刪除節點的左子樹接到父節點上，將刪除節點的右子樹接到該前序節點的右子樹上，而後刪除節點。3d

5. 二叉樹的前序遍歷

  因爲二叉樹是遞歸定義的，因此二叉樹的遍歷通常也是採用遞歸的形式。前序遍歷即採用先訪問根節點，再訪問左子樹，最後訪問右子樹的順序。前序遍歷也是按照相似的方式遞歸遍歷，具體操做以下：
① 若是當前節點值爲空，返回；
②若是當前節點值不爲空，打印當前節點值；遞歸遍歷左子樹；遞歸遍歷右子樹。code

6. 二叉樹的中序遍歷

①若是當前節點值爲空，返回；
②遞歸遍歷左子樹；打印當前節點的值；遞歸遍歷右子樹。blog

7. 二叉樹的後序遍歷

①若是當前節點值爲空，返回；
②遞歸遍歷左子樹；遞歸遍歷右子樹；打印當前節點的值。遞歸

8. 二叉樹的層次遍歷

  二叉樹的層次遍歷，即從根節點開始，逐層按照從左到右的順序遍歷。層次遍歷比前中後序遍歷要麻煩一點，它須要藉助一個額外的鏈表來保存節點進行遍歷。具體作法以下：
①初始化一個用來保存二叉樹節點的空鏈表；
②若是這是一棵空二叉樹，直接返回；不然將根節點添加到鏈表；
③while(當鏈表不爲空時)
  彈出鏈表第一個二叉樹節點，打印該二叉樹節點的值；
  若是該二叉樹節點的左子樹不爲空，則將該左子樹添加到鏈表；
  若是該二叉樹節點的右子樹不爲空，則將該右子樹添加到鏈表；get

  以上就是關於二叉樹的基本操做，下面是C語言具體實現的代碼，供你們參考：it

/*
二叉樹的基本操做:插入，刪除,查找,前序遍歷,中序遍歷,後序遍歷,層次遍歷
*/
#include<stdio.h>
#include<stdlib.h>
#define BLANK -1 
#define LEFT -2
#define RIGHT -3
typedef struct BINARY_TREE
{
    // 左子樹
    struct BINARY_TREE *left;
    // 右子樹
    struct BINARY_TREE *right;
    int value;
} Binary_tree;
typedef struct NODE
{
    struct NODE *link;
    Binary_tree *value;
} Node;

// 二叉樹插入
int insert(Binary_tree *root,int value,Node *node_root);
// 二叉搜索樹插入
int search_insert(Binary_tree *root,int value);
// 二叉樹刪除 
int erase(Binary_tree *roote,int value);
// 二叉搜索樹查找
int search_find(Binary_tree *root,int value);
// 二叉樹前序遍歷
void pre_print(Binary_tree *root);
// 二叉樹中序遍歷
void mid_print(Binary_tree *root);
// 二叉樹後序遍歷
void back_print(Binary_tree *root);
// 層次遍歷
void level_print(Binary_tree *root);
// 彈出鏈表第一個元素
Binary_tree* top(Node *root);
// 將元素添加到鏈表末尾
int append(Node *current,Binary_tree* value);


int main(void)
{
    Binary_tree *root = (Binary_tree*)malloc(sizeof(Binary_tree));
    if(root == NULL)
    {
        printf("Malloc memory failed!\n");
        exit(-1);
    }
    root->left = NULL;
    root->right = NULL;
    root->value = BLANK;
    Node *node_root = (Node*)malloc(sizeof(Node));
    if(node_root == NULL)
    {
        printf("Malloc memory failed!\n");
        exit(-1);
    }
    node_root->link = NULL;
    search_insert(root,10);
    search_insert(root,2);
    search_insert(root,2);
    search_insert(root,3);
    search_insert(root,4);
    search_insert(root,15);
    search_insert(root,6);
    search_find(root,15);
        /*
    insert(root,10,node_root);
    insert(root,2,node_root);
    insert(root,2,node_root);
    insert(root,3,node_root);
    insert(root,4,node_root);
    insert(root,15,node_root);
    insert(root,6,node_root);
    */
    printf("前序遍歷: ");
    pre_print(root);
    puts("");
    printf("中序遍歷: ");
    mid_print(root);
    puts("");
    printf("後序遍歷: ");
    back_print(root);
    puts("");
    printf("層次遍歷: ");
    level_print(root);
    puts("");
    free(root);
    return 0;
}
// 二叉樹插入
int insert(Binary_tree *root,int value,Node *node_root)
{
    // 若是是空樹
    if(root->left == NULL && root->right == NULL && root->value == BLANK)
    {
        root->value = value;
        append(node_root,root);
        printf("Insert %d into an empty link list!\n",value);
    }
    else
    {
        // 構造一個新節點
        Binary_tree *new_tree_node = (Binary_tree*)malloc(sizeof(Binary_tree));
        new_tree_node->value = value;
        new_tree_node->left = new_tree_node->right = NULL;
        // 獲得鏈表第一個節點的值
        Binary_tree *current = node_root->link->value;
        // 若是左子樹爲空
        if(current->left == NULL)
        {
            current->left = new_tree_node;
            append(node_root,current->left);
            printf("Insert %d in parent's left node!\n",value);
        }   
        // 左子樹不爲空
        else
        {
            current->right = new_tree_node;
            append(node_root,current->right);
            printf("Insert %d in parent's right node!\n",value);
            top(node_root);
        }
    }
    return 0;
}
// 二叉搜索樹插入
int search_insert(Binary_tree *root,int value)
{
    // 若是左右子樹都爲空且根節點值爲小於0(BLANK 或者 LEFT 或者 RIGHT)
    if(root->left == NULL && root->right == NULL && root->value < 0)
    {
        if(root->value == BLANK)
            printf("Insert %d into an empty binary tree succeed!\n",value);
        else if(root->value == LEFT)
            printf("Insert %d into parent's left node succeed!\n",value);
        else
            printf("Insert %d into parent's right node succeed!\n",value);
        root->value = value;
        return value;
    }
    if(value < root->value)
    {
        if(root->left == NULL)
        {
            root->left = (Binary_tree*)malloc(sizeof(Binary_tree));
            if(root->left == NULL)
            {
                printf("Malloc memory failed!\n");
                exit(-1);
            }
            root->left->value = LEFT;
            root->left->left = root->left->right = NULL;
        }
        search_insert(root->left,value);
    }
    else if(value > root->value)
    {
        if(root->right == NULL)
        {
            root->right = (Binary_tree*)malloc(sizeof(Binary_tree));
            if(root->right == NULL)
            {
                printf("Malloc memory failed!\n");
                exit(-1);
            }
            root->right->value = RIGHT;
            root->right->left = root->right->right = NULL;
        }
        search_insert(root->right,value);
    }
    else
    {
        printf("%d already exits in binary tree!\n");
        return value;
    }
}

// 二叉搜索樹查找
int search_find(Binary_tree *root,int value)
{
    if(root->left == NULL && root->right == NULL && root->value < 0)
    {
        printf("Can't find %d in binary tree!\n",value);
        return -1;
    }
    if(root->value == value)
    {
        printf("Find %d in binary tree!\n",value);
        return 0;
    }
    else if(value < root->value)
    {
        if(root->left == NULL)
        {
            printf("Can't find %d in binary tree!\n",value);
            return -1;
        }
        search_find(root->left,value);
    }
        
    else
    {
        if(root->right == NULL)
        {
            printf("Can't find %d in binary tree!\n",value);
            return -1;
        }
        search_find(root->right,value);
    }   
}
// 二叉樹前序遍歷
void pre_print(Binary_tree *root)
{
    if(root->left == NULL && root->right == NULL && root->value < 0)
        return;
    printf("%d ",root->value);
    if(root->left != NULL)
        pre_print(root->left);
    if(root->right != NULL)
        pre_print(root->right);
}

// 二叉樹中序遍歷
void mid_print(Binary_tree *root)
{
    if(root->left == NULL && root->right == NULL && root->value < 0)
        return;
    if(root->left != NULL)
        pre_print(root->left);
    printf("%d ",root->value);
    if(root->right != NULL)
        pre_print(root->right);
}

// 二叉樹後序遍歷
void back_print(Binary_tree *root)
{
    if(root->left == NULL && root->right == NULL && root->value < 0)
        return;
    if(root->left != NULL)
        pre_print(root->left);
    if(root->right != NULL)
        pre_print(root->right);
    printf("%d ",root->value);
}

// 彈出鏈表第一個元素
Binary_tree* top(Node *root)
{
    if(root->link == NULL)
    {
        printf("Can't get top value from empty link list!\n");
        exit(-1);
    }
    Node *current = root->link;
    root->link = current->link;
    return current->value;
}
// 將元素添加到鏈表末尾
int append(Node *current,Binary_tree* value)
{
    Node *new_node = (Node*)malloc(sizeof(Node));
    new_node->value = value;
    while(current->link != NULL)
    {
        current = current->link;
    }
    current->link = new_node;
    new_node->link = NULL;
    return 0;
}

// 二叉樹層次遍歷
void level_print(Binary_tree* root)
{
    if(root->left == NULL && root->right == NULL && root->value < 0)
        return;
    Node *node_root = (Node*)(malloc(sizeof(Node)));
    node_root->link = NULL;
    append(node_root,root);
    Binary_tree* current;
    while(node_root->link != NULL)
    {
        current = top(node_root);
        printf("%d ",current->value);
        if(current->left != NULL)
            append(node_root,current->left);
        if(current->right != NULL)
            append(node_root,current->right);
    }
}

運行結果以下：
io

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程