2. 程式人生 > 其它 >紅黑樹 插入 C語言實現

紅黑樹 插入 C語言實現

阿新 • • 發佈：2021-10-21

紅黑樹 C語言實現

推薦一個紅黑樹視覺化網站: https://www.cs.usfca.edu/~galles/visualization/RedBlack.html

1. 什麼是紅黑樹

https://baike.baidu.com/item/紅黑樹/2413209?fr=aladdin

紅黑樹是一種自平衡二叉查詢樹，巴拉巴拉--- ， 請注意前提，是一顆二叉查詢樹。

關於二叉查詢樹: https://baike.baidu.com/item/二叉排序樹/10905079?fromtitle=二叉查詢樹&fromid=7077965&fr=aladdin

2. 紅黑樹概念

  • 每個節點要麼是紅色，要麼是黑色
  • 根節點和葉節點是黑色的(紅黑樹的葉節點是NULL LEAF
    ,預設NULL節點為黑色)
  • 如果一個節點是紅色，那麼它的孩子是黑色的(不允許連續2個紅節點，但是允許2個連續的黑節點)
  • 任意節點到葉節點的樹鏈中包含相同數量的黑節點

紅黑樹圖示

3. 紅黑樹插入

3.0 插入節點名稱規定

G: 爺爺節點

P: 父親節點

U: 叔叔節點

N: 新插入節點

3.1 插入規則

  • 1 . 對於新插入的節點，顏色初始化為紅節點。
  • 2 . 根節點為黑色。
  • 3 . 如果在黑節點後插入，則無需進行修復。
  • 4 . 如果在紅節點後插入，需要進行修復。

3.2 針對上面插入規則第三點 修復規則

  • 1 . 當前節點為根節點，且為紅色，需要染成黑色。

  • 2 . 若插入節點父節點為紅色，叔叔節點為紅色，則需要進行染色操作。

  • 3 . 若插入節點父節點為紅色，叔叔節點為黑色，則需要進行旋轉。

如何判斷需要染色修復

插入節點的父節點為紅色，叔叔節點為紅色，則需要進行染色操作。

染色修復

  1. 將父親節點 和 叔叔節點 染成黑色。
  2. 將爺爺節點染成紅色。
  3. 將爺爺節點賦值給當前節點 ，再次獲取父親/叔叔/爺爺節點進行判斷。

如何判斷需要旋轉修復

插入節點的父節點為紅色，叔叔節點為黑色，則需要進行旋轉修復

旋轉修復

左左修復/左右修復/右左修復/右右修復

3.3 插入圖示

3.3.1 在黑節點後插入，則無需進行修復。

對於如下資料，我們插入一個節點 130

插入節點後如下，因為 130 的父節點為 黑節點，所以 無需進行修復

3.3.2 在紅節點後插入，需要進行修復

對於如下資料，我們插入一個150

插入之後資料如下

此時，P節點和N節點 都為紅節點，則需要進行修復

3.3.3 染色修復

父親節點 和 叔叔節點 都為紅節點 需要進行染色修復

如上圖，染色修復流程為:

  1. 將父親節點 和 叔叔節點 染成黑色。
  2. 將爺爺節點染成紅色。
  3. 將爺爺節點賦值給當前節點 ，再次獲取父親/叔叔/爺爺節點進行判斷。

應該修復為:

且因N為根節點，應該染成黑色，故

3.3.4 旋轉修復

1. 左左修復

如下要插入90節點

插入後如下

NULL: 空節點

修復過程:

G樹向右旋轉

然後染色，N 和 G 染為紅色，P 染為黑色

2. 左右修復

如下樹，要插入85節點

插入後如下

修復過程

P樹先向右選擇

旋轉後如下，就和【左左型別】一致了

3. 右右修復

樹如如下

要插入一個260的節點

修復過程:

G樹向左旋轉

旋轉之後

將G染成紅色，N染成紅色，P染成黑色

4. 右左修復

如下一棵樹

需要插入 248 節點，插入後如下

以P向左旋轉

旋轉後如下

和【右右型別】型別

程式碼示例

結構體定義

# define RED 1
# define BLACK 0

typedef struct {
        int data; // 資料節點
        struct TreeNode *left; // 左子樹
        struct TreeNode *right; // 右字樹
        int color;  // 二叉樹顏色，1: 紅色 0:黑色

} TreeNode , *PTreeNode;

平衡二叉樹插入程式碼

PTreeNode Insert(PTreeNode *root,int data) {

        printf("插入資料: %d\n",data);
        TreeNode *newNode = (TreeNode *)malloc(sizeof(TreeNode));
        newNode->data = data;
        newNode->color = RED; // 新增節點染成紅色

        TreeNode *parent = NULL;
        TreeNode *grandParent = NULL;

        if (NULL == (*root)) {
                //printf("插入根節點\n");
                newNode->color = BLACK; // 將頭結點染成黑色
                return newNode;
        } else {
                TreeNode *tmp = (*root);
                while (tmp != NULL) {
                        //printf("插入查詢值: %d\n",tmp->data);
                        grandParent = parent;
                        parent = tmp;

                        if (data > tmp->data){
                                tmp = tmp->right;
                        } else if (data < tmp->data){
                                tmp = tmp->left;
                        } else {
                                printf("%d 該值已經存在\n",data);
                        }
                }
                if (data > parent->data) {
                        parent->right = newNode;
                        //printf("parent data:%d newNode data:%d\n",parent->data,newNode->data);
                } else {
                        parent->left = newNode;
                }
        }
        // 如果插入父節點是黑色，則保持不變
        if (parent->color == BLACK) return (*root);

        // 進行插入修復
        return InsertFixup(root,newNode); 
}

插入修復程式碼

PTreeNode InsertFixup(PTreeNode *root,PTreeNode newNode) {

        TreeNode *parent = NULL; // 父親節點
        TreeNode *grandParent = NULL; // 爺爺節點 
        TreeNode *greatGrandParent = NULL; // 祖爺爺節點
        TreeNode *uncle = NULL; // 叔叔節點
        int uncleColor = 0; // 叔叔節點顏色，預設為黑色

        while (true) {
                //
                // 尋找節點 父親/爺爺祖爺爺節點
                TreeNode *tmp = (*root);
                while (tmp != NULL) {
                        if (newNode->data == tmp->data) {
                                break;
                        }
                        greatGrandParent = grandParent;
                        grandParent = parent;
                        parent = tmp;

                        (newNode->data > tmp->data) ? (tmp = tmp->right) : (tmp = tmp->left);
                }

                // 當前節點是根節點，染成黑色
                if (newNode == (*root)) newNode->color = BLACK;

                if (grandParent == NULL) break;

                // 獲取叔叔節點
                (parent == grandParent->left) ? (uncle = grandParent->right) : (uncle = grandParent->left);

                // 獲取叔叔節點顏色
                if (uncle != NULL) uncleColor = uncle->color;

                // 染色操作
                if ((parent->color == RED) && (uncleColor == RED)) {
                        parent->color = BLACK;
                        uncle->color = BLACK;
                        grandParent->color = RED;

                        newNode = grandParent;
                        continue;
                }

                // 父節點為紅色，叔叔節點為黑色，則需要進行旋轉
                if ((parent->color == RED) && uncleColor == BLACK) {
                        // 左左
                        if ((parent == grandParent->left) && (newNode == parent->left)) {
                                grandParent->left = NULL;

                                TreeNode *oldParentRight = parent->right;

                                parent->right = grandParent;
                                grandParent->left = oldParentRight;

                                if ((*root) == grandParent) {
                                        (*root) = parent;
                                } else {
                                        (greatGrandParent->left == grandParent) ? (greatGrandParent->left = parent) : (greatGrandParent->right = parent);
                                }

                                // 染色
                                newNode->color = RED;
                                grandParent->color = RED;
                                parent->color = BLACK;
                                //continue;
                                break;
                        // 左右
                        } else if ((parent == grandParent->left) && (newNode == parent->right)) {
                                grandParent->left = newNode;

                                TreeNode *newNodeLeft = newNode->left;


                                newNode->left = parent;
                                parent->right = newNodeLeft;

                                TreeNode *newNodeRight = newNode->right;
                                newNode->right = grandParent;
                                grandParent->left = newNodeRight;
                                //newNode->left = parent;

                                // 若要旋轉的樹是根節點
                                if ((*root) == grandParent) {
                                        (*root) = newNode;
                                } else {
                                        // 要旋轉的樹非根節點
                                        (greatGrandParent->left == grandParent) ? (greatGrandParent->left = newNode) : (greatGrandParent->right = newNode);
                                }

                                parent->color = RED;
                                grandParent->color = RED;
                                newNode->color = BLACK;
                                //continue;
                                break;

                        // 右左
                        } else if ((parent == grandParent->right) && (newNode == parent->left)) {
                                parent->left = NULL;

                                TreeNode *newNodeRight = newNode->right;
                                newNode->right = parent;
                                parent->left = newNodeRight;

                                grandParent->right = newNode;

                                TreeNode *newNodeLeft = newNode->left;
                                newNode->left = grandParent;
                                grandParent->right = newNodeLeft;


                                // 要旋轉的樹是根節點
                                if ((*root) == grandParent) {
                                        (*root) = newNode;

                                } else {
                                        // 要旋轉的樹是非根節點
                                        (greatGrandParent->left == grandParent) ? (greatGrandParent->left = newNode) : (greatGrandParent->right = newNode);
                                }

                                // 染色
                                newNode->color = BLACK;
                                grandParent->color = RED;
                                parent->color = RED;
                                //continue;
                                break;

                        // 右右
                        } else if ((parent == grandParent->right) && (newNode == parent->right)) {
                                grandParent->right = NULL;

                                TreeNode *oldParentLeft = parent->left;
                                parent->left = grandParent;
                                grandParent->right = oldParentLeft;

                                // 要旋轉的樹是根節點
                                if ((*root) == grandParent) {
                                        (*root) = parent;

                                } else {
                                        // 要旋轉的樹是非根節點
                                        (greatGrandParent->left == grandParent) ? (greatGrandParent->left = parent) : (greatGrandParent->right = parent);
                                }

                                // 染色
                                grandParent->color = RED;
                                newNode->color = RED;
                                parent->color = BLACK;
                                //continue;
                                break;
                        }
                }
                break;
        }
        return (*root);
}

插入完整程式碼

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

# define RED 1
# define BLACK 0

typedef struct {
        int data; // 資料節點
        struct TreeNode *left; // 左子樹
        struct TreeNode *right; // 右字樹
        int color;  // 二叉樹顏色，1: 紅色 0:黑色

} TreeNode , *PTreeNode;

PTreeNode InsertFixup(PTreeNode *root,PTreeNode newNode) {

        TreeNode *parent = NULL; // 父親節點
        TreeNode *grandParent = NULL; // 爺爺節點 
        TreeNode *greatGrandParent = NULL; // 祖爺爺節點
        TreeNode *uncle = NULL; // 叔叔節點
        int uncleColor = 0; // 叔叔節點顏色，預設為黑色

        while (true) {
                //
                // 尋找節點 父親/爺爺祖爺爺節點
                TreeNode *tmp = (*root);
                while (tmp != NULL) {
                        if (newNode->data == tmp->data) {
                                break;
                        }
                        greatGrandParent = grandParent;
                        grandParent = parent;
                        parent = tmp;

                        (newNode->data > tmp->data) ? (tmp = tmp->right) : (tmp = tmp->left);
                }

                // 當前節點是根節點，染成黑色
                if (newNode == (*root)) newNode->color = BLACK;

                if (grandParent == NULL) break;

                // 獲取叔叔節點
                (parent == grandParent->left) ? (uncle = grandParent->right) : (uncle = grandParent->left);

                // 獲取叔叔節點顏色
                if (uncle != NULL) uncleColor = uncle->color;

                // 染色操作
                if ((parent->color == RED) && (uncleColor == RED)) {
                        parent->color = BLACK;
                        uncle->color = BLACK;
                        grandParent->color = RED;

                        newNode = grandParent;
                        continue;
                }

                // 父節點為紅色，叔叔節點為黑色，則需要進行旋轉
                if ((parent->color == RED) && uncleColor == BLACK) {
                        // 左左
                        if ((parent == grandParent->left) && (newNode == parent->left)) {
                                grandParent->left = NULL;

                                TreeNode *oldParentRight = parent->right;

                                parent->right = grandParent;
                                grandParent->left = oldParentRight;

                                if ((*root) == grandParent) {
                                        (*root) = parent;
                                } else {
                                        (greatGrandParent->left == grandParent) ? (greatGrandParent->left = parent) : (greatGrandParent->right = parent);
                                }

                                // 染色
                                newNode->color = RED;
                                grandParent->color = RED;
                                parent->color = BLACK;
                                //continue;
                                break;
                        // 左右
                        } else if ((parent == grandParent->left) && (newNode == parent->right)) {
                                grandParent->left = newNode;

                                TreeNode *newNodeLeft = newNode->left;


                                newNode->left = parent;
                                parent->right = newNodeLeft;

                                TreeNode *newNodeRight = newNode->right;
                                newNode->right = grandParent;
                                grandParent->left = newNodeRight;
                                //newNode->left = parent;

                                // 若要旋轉的樹是根節點
                                if ((*root) == grandParent) {
                                        (*root) = newNode;
                                } else {
                                        // 要旋轉的樹非根節點
                                        (greatGrandParent->left == grandParent) ? (greatGrandParent->left = newNode) : (greatGrandParent->right = newNode);
                                }

                                parent->color = RED;
                                grandParent->color = RED;
                                newNode->color = BLACK;
                                //continue;
                                break;

                        // 右左
                        } else if ((parent == grandParent->right) && (newNode == parent->left)) {
                                parent->left = NULL;

                                TreeNode *newNodeRight = newNode->right;
                                newNode->right = parent;
                                parent->left = newNodeRight;

                                grandParent->right = newNode;

                                TreeNode *newNodeLeft = newNode->left;
                                newNode->left = grandParent;
                                grandParent->right = newNodeLeft;


                                // 要旋轉的樹是根節點
                                if ((*root) == grandParent) {
                                        (*root) = newNode;

                                } else {
                                        // 要旋轉的樹是非根節點
                                        (greatGrandParent->left == grandParent) ? (greatGrandParent->left = newNode) : (greatGrandParent->right = newNode);
                                }

                                // 染色
                                newNode->color = BLACK;
                                grandParent->color = RED;
                                parent->color = RED;
                                //continue;
                                break;

                        // 右右
                        } else if ((parent == grandParent->right) && (newNode == parent->right)) {
                                grandParent->right = NULL;

                                TreeNode *oldParentLeft = parent->left;
                                parent->left = grandParent;
                                grandParent->right = oldParentLeft;

                                // 要旋轉的樹是根節點
                                if ((*root) == grandParent) {
                                        (*root) = parent;

                                } else {
                                        // 要旋轉的樹是非根節點
                                        (greatGrandParent->left == grandParent) ? (greatGrandParent->left = parent) : (greatGrandParent->right = parent);
                                }

                                // 染色
                                grandParent->color = RED;
                                newNode->color = RED;
                                parent->color = BLACK;
                                //continue;
                                break;
                        }
                }
                break;
        }
        return (*root);
}

PTreeNode Insert(PTreeNode *root,int data) {

        printf("插入資料: %d\n",data);
        TreeNode *newNode = (TreeNode *)malloc(sizeof(TreeNode));
        newNode->data = data;
        newNode->color = RED; // 新增節點染成紅色

        TreeNode *parent = NULL;
        TreeNode *grandParent = NULL;

        if (NULL == (*root)) {
                //printf("插入根節點\n");
                newNode->color = BLACK; // 將頭結點染成黑色
                return newNode;
        } else {
                TreeNode *tmp = (*root);
                while (tmp != NULL) {
                        //printf("插入查詢值: %d\n",tmp->data);
                        grandParent = parent;
                        parent = tmp;

                        if (data > tmp->data){
                                tmp = tmp->right;
                        } else if (data < tmp->data){
                                tmp = tmp->left;
                        } else {
                                printf("%d 該值已經存在\n",data);
                        }
                }
                if (data > parent->data) {
                        parent->right = newNode;
                        //printf("parent data:%d newNode data:%d\n",parent->data,newNode->data);
                } else {
                        parent->left = newNode;
                }
        }
        // 如果插入父節點是黑色，則保持不變
        if (parent->color == BLACK) return (*root);

        // 進行插入修復
        return InsertFixup(root,newNode); 
}

// 前序遍歷
void Print1(TreeNode *root) {
        if (NULL == root) return;
        printf("[顏色:%s  資料:%d]\t",(root->color == RED) ? ("紅"):("黑") ,root->data);
        Print1(root->left);
        Print1(root->right);
}

// 中序遍歷
void Print2(TreeNode *root) {
        if (NULL == root) return;
        Print2(root->left);
        printf("[顏色:%s  資料:%d]\t",(root->color == RED) ? ("紅"):("黑") ,root->data);
        Print2(root->right);
}

int main() {
        TreeNode *root = NULL;

        int num[] = {160,130,210,150,110,90,80,85,240,260,248};

        int i;
        for (i=0;i<sizeof(num)/sizeof(int);i++) {
                root = Insert(&root,num[i]);
        }

        printf("\n");
        printf("前序遍歷:\n");
        Print1(root);
        printf("\n");
        printf("\n");
        printf("後續遍歷:\n");
        Print2(root);
        printf("\n");

        return 0;
}

程式執行

# gcc RedBlackTreeInsert.c -w -g
# ./a.out 
插入資料: 160
插入資料: 130
插入資料: 210
插入資料: 150
插入資料: 110
插入資料: 90
插入資料: 80
插入資料: 85
插入資料: 240
插入資料: 260
插入資料: 248

前序遍歷:
[顏色:黑  資料:130]     [顏色:黑  資料:90]      [顏色:黑  資料:80]      [顏色:紅  資料:85]      [顏色:黑  資料:110]     [顏色:黑  資料:160] [顏色:黑  資料:150]     [顏色:紅  資料:240]     [顏色:黑  資料:210]     [顏色:黑  資料:260]     [顏色:紅  資料:248]

後續遍歷:
[顏色:黑  資料:80]      [顏色:紅  資料:85]      [顏色:黑  資料:90]      [顏色:黑  資料:110]     [顏色:黑  資料:130]     [顏色:黑  資料:150] [顏色:黑  資料:160]     [顏色:黑  資料:210]     [顏色:紅  資料:240]     [顏色:紅  資料:248]     [顏色:黑  資料:260]
#

uploading-image-456399.png

歡迎轉發！ 請保留源地址: https://www.cnblogs.com/NoneID

相關推薦

紅黑樹 插入 C語言實現

紅黑樹 C語言實現 推薦一個紅黑樹視覺化網站: https://www.cs.usfca.edu/~galles/visualization/RedBlack.html

紅黑樹 插入操作 C語言實現

紅黑樹 插入操作 C語言實現 推薦一個紅黑樹視覺化網站: https://www.cs.usfca.edu/~galles/visualization/RedBlack.html

紅黑樹增刪查python實現

\'\'\' 一、紅黑樹性質 結點必須是紅色或者黑色。 根節點必須是黑色。 葉節點(NIL)必須是黑色(NIL節點無資料，是空節點)。

連結串列和二叉查詢樹的c語言實現

複習資料結構時，手撕的連結串列和二叉查詢樹。 我覺得需要解釋一下的地方，我都在程式碼處寫了註釋。

【PTA資料結構與演算法題目集筆記】7-4 是否同一棵二叉搜尋樹（C語言實現）

技術標籤：演算法資料結構c語言 7-4 是否同一棵二叉搜尋樹 題目要求 給定一個插入序列就可以唯一確定一棵二叉搜尋樹。然而，一棵給定的二叉搜尋樹卻可以由多種不同的插入序列得到。例如分別按照序列{2, 1, 3}和{

有趣的演算法（八） ——紅黑樹插入演算法

有趣的演算法（八）——紅黑樹插入演算法 （原創內容，轉載請註明來源，謝謝）

紅黑樹-結點的刪除（C語言實現）

紅黑樹結點的刪除 首先來回顧一下二叉樹結點的刪除，總共分為了三種情況：

J.U.C 之 ConcurrentHashMap 紅黑樹轉換

ConcurrentHashMap的實現過程，其中有提到在put操作時，如果發現連結串列結構中的元素超過了TREEIFY_THRESHOLD（預設為8），則會把連結串列轉換為紅黑樹，已便於提高查詢效率。程式碼如下：

C語言實現哈夫曼樹的構建

哈夫曼樹（霍夫曼樹）又稱為最優樹. 1、路徑和路徑長度 在一棵樹中，從一個結點往下可以達到的孩子或孫子結點之間的通路，稱為路徑。通路中分支的數目稱為路徑長度。若規定根結點的層數為1，則從根結點到第L層結點的

C語言實現哈夫曼樹

本文例項為大家分享了C語言實現哈夫曼樹的具體程式碼，供大家參考，具體內容如下

java實現紅黑樹

一、紅黑樹的介紹 紅黑樹(Red-Black Tree，簡稱R-B Tree)，它一種特殊的二叉查詢樹。紅黑樹是特殊的二叉查詢樹，意味著它滿足二叉查詢樹的特徵：任意一個節點所包含的鍵值，大於等於左孩子的鍵值，小於等於右孩子的鍵

資料結構C語言實現----向連結串列中插入結點

1.明確在第幾個結點後插入 2.找到插入位置的前一個結點 3.交換指標：設插入位置的前一個結點為結點A , 插入的結點為結點B ， 插入結點後面的一個節點為結點C

紅黑樹原理與實現

紅黑樹 紅黑樹的性質 根節點必須是黑色 每個結點必須是黑色或者紅色 葉子節點 (nil) 是黑色

資料結構C語言實現----樹

樹的基本知識點 　　樹的定義 　　樹的ADT（抽象資料型別） 　　樹的儲存結構

二杈樹（c語言連結串列實現）

用例中的樹的結構圖 #include <stdio.h> #include <stdlib.h> typedef int ElemType; struct TreeNode

七夕表白! C語言實現愛情紅玫瑰

本文例項為大家分享了C語言實現愛情紅玫瑰的具體程式碼，供大家參考，具體內容如下

紅黑樹原理（插入+刪除過程分析）

引言 紅黑樹的原理經常在面試中被問到，因此根據瀏覽的一些部落格進行了歸納總結。 參考如下：新增連結描述新增連結描述新增連結描述 紅黑樹原理

B樹，B+樹，紅黑樹應用場景及B+實現

B樹，B+樹，紅黑樹應用場景筆記 一、B樹的應用 1、B樹大量應用在資料庫和檔案系統當中。

紅黑樹-結點的插入

紅黑樹介紹 紅黑樹本質上是一種二叉查詢樹，但它在二叉查詢樹的基礎上額外添加了一個標記（顏色），同時具有一定的規則。這些規則使紅黑樹保證了一種平衡，插入、刪除、查詢的最壞時間複雜度都為 O(logn)。它的統計效

使用C語言實現用陣列構建二叉樹並遍歷

#include <stdio.h> typedef struct Node { int data; struct Node* lchild; struct Node* rchild; }Node;