紅黑樹

時間  2019-11-15
原文   原文鏈接

原理請參考《算法導論》算法

定義一個紅黑樹類函數

template <typename T>
class rb_tree {
public:
    typedef struct _rb_type {
        _rb_type(_rb_type *_left, _rb_type *_right, _rb_type *_p, bool cl, T k) :
            left(_left), right(_right), p(_p), color(cl), key(k) {}
        bool color;//true for red, false for black
        T key;
        _rb_type *left, *right, *p;
    }rb_type, *prb_type;
    rb_tree(T *A, int n) :root(NULL) {
        for (int i = 0; i < n; i++)
            this->rb_insert(A[i]);
    }
    ~rb_tree() {
        rb_empty(root);
    }
    void left_rotate(prb_type x);//左旋
    void right_rotate(prb_type x);//右旋
    void rb_insert(T key);//插入
    prb_type rb_max(prb_type x);
    prb_type rb_min(prb_type x);
    prb_type rb_search(T key);//查找
    prb_type rb_successor(T key);//後繼
    prb_type rb_predecussor(T key);//前趨
    void rb_delete(T key);//刪除
    void rb_delete(prb_type z);
    void rb_empty(prb_type x);//後續所有刪除
    prb_type Root();
    void rb_show(prb_type x);//顯示，僅測試使用
private:
    void rb_insert_fixup(prb_type z);//插入後修復
    void rb_delete_fixup(prb_type x);//刪除後修復
    prb_type root;
};

相關成員函數的實現學習

left_rotate成員函數，實現某節點的左旋轉測試

template <typename T>
void rb_tree<T>::left_rotate(typename rb_tree<T>::prb_type x) {
    prb_type y = x->right;//y非空
    x->right = y->left;
    if (y->left) y->left->p = x;//交換子節點
    y->p = x->p;//更新父節點
    if (x->p == NULL)//將y鏈接到x的父節點
        root = y;
    else {
        if (x == x->p->left)
            x->p->left = y;
        else
            x->p->right = y;
    }
    y->left = x;
    x->p = y;
}

right_rotate成員函數，實現某節點的右旋轉this

template <typename T>
void rb_tree<T>::right_rotate(typename rb_tree<T>::prb_type x) {
    prb_type y = x->left;
    x->left = y->right;
    if (y->right) y->right->p = x;
    y->p = x->p;
    if (x->p == NULL)
        root = y;
    else {
        if (x == x->p->left)
            x->p->left = y;
        else
            x->p->right = y;
    }
    y->right = x;
    x->p = y;
}

rb_insert成員函數，將某個key值插入到紅黑樹中，並修正讓其知足紅黑樹的性質spa

template <typename T>
void rb_tree<T>::rb_insert(T key) {
    prb_type y = NULL, x = root, z = new rb_type(NULL, NULL, NULL, true, key);
    while (x != NULL) {
        y = x;
        if (key < x->key)
            x = x->left;
        else
            x = x->right;
    }
    z->p = y;
    if (y == NULL)
        root = z;
    else {
        if (key < y->key)
            y->left = z;
        else
            y->right = z;
    }
    rb_insert_fixup(z);
}

rb_insert_fixup成員函數，接上面，根據二叉樹插入方法插入後，修正紅黑樹3d

template <typename T>
void rb_tree<T>::rb_insert_fixup(typename rb_tree<T>::prb_type x) {
    prb_type y;
    while (x->p && x->p->color) {//紅色
        if (x->p == x->p->p->left) {//父節點存在，必定存在祖父節點
            y = x->p->p->right;
            //沒法知足性質4
            if (!y || y->color) {//若y爲NULL，默認不存在的節點是黑色
                x->p->color = false;
                if (y) y->color = false;
                x->p->p->color = true;
                x = x->p->p;//從新設置z節點
            }
            else if (x == x->p->right) { //沒法知足性質5
                x = x->p;
                left_rotate(x);
            }
            if (x->p && x->p->p) {//保證存在
                x->p->color = false;
                x->p->p->color = true;
                right_rotate(x->p->p);
            }
        }
        else {//和上面左節點相反
            y = x->p->p->left;
            if (!y || y->color) {
                x->p->color = false;
                if (y) y->color = false;
                x->p->p->color = true;
                x = x->p->p;//從新設置z節點
            }
            else if (x == x->p->left) {
                x = x->p;
                right_rotate(x);
            }
            if (x->p && x->p->p) {
                x->p->color = false;
                x->p->p->color = true;
                left_rotate(x->p->p);
            }
        }
    }
    root->color = false;
}

rb_search成員函數，根據相關key值，找到對應的節點code

template <typename T>
typename rb_tree<T>::prb_type rb_tree<T>::rb_search(T key) {
    prb_type x = root;
    while (x != NULL && key != x->key) {
        if (key < x->key)
            x = x->left;
        else
            x = x->right;
    }
    return x;
}

如下幾個成員函數，是爲了rb_delete函數做準備，分別是rb_max, rb_min, rb_successor, rb_predecessorblog

rb_max成員函數io

template <typename T>
typename rb_tree<T>::prb_type rb_tree<T>::rb_max(typename rb_tree<T>::prb_type x) {
    if (x == NULL) return NULL;
    while (x->right) x = x->right;
    return x;
}

rb_min成員函數

template <typename T>
typename rb_tree<T>::prb_type rb_tree<T>::rb_min(typename rb_tree<T>::prb_type x) {
    if (x == NULL) return NULL;
    while (x->left) x = x->left;
    return x;
}

rb_successor成員函數

template <typename T>
typename rb_tree<T>::prb_type rb_tree<T>::rb_successor(T key) {
    prb_type x = rb_search(key), y;
    if (x == NULL) return NULL;
    if (x->right)
        return rb_min(x->right);
    y = x->p;
    while (y != NULL && y->right == x) {//沒有則返回NULL
        x = y;
        y = y->p;
    }
    return y;
}

rb_predecessor成員函數

template <typename T>
typename rb_tree<T>::prb_type rb_tree<T>::rb_predecussor(T key) {
    prb_type x = rb_search(key), y;
    if (x == NULL) return NULL;
    if (x->left)
        return rb_max(x->left);
    y = x->p;
    while (y != NULL && y->left == x) {
        x = y;
        y = y->p;
    }
    return y;
}

最後，比較關鍵的刪除函數rb_delete成員函數，實現了重載函數，是爲了最後測試使用

rb_delete成員函數，重載一

template <typename T>
void rb_tree<T>::rb_delete(T key) {
    prb_type z = rb_search(key), y, x;
    if (z == NULL) return;
    if (z->left == NULL || z->right == NULL)//y是待刪除的節點
        y = z;//z有一個子節點
    else
        y = rb_successor(key);//z有兩個子節點，後繼和前趨保證了y有一個或沒有子節點
    if (y->left != NULL)
        x = y->left;
    else
        x = y->right;
    if (x != NULL) //存在一個子節點，先更正父子關係
        x->p = y->p;
    if (y->p == NULL)//再決定是在左或者右節點
        root = x;
    else {
        if (y->p->left == y)
            y->p->left = x;
        else
            y->p->right = x;
    }
    if (y != z)//處理兩個子節點的交換
        z->key = y->key;
    if (!y->color)//黑色
        rb_delete_fixup(x);
    delete y;
}

重載二

template <typename T>
void rb_tree<T>::rb_delete(typename rb_tree<T>::prb_type z) {
    prb_type y, x;
    if (z == NULL) return;
    if (z->left == NULL || z->right == NULL)//y是待刪除的節點
        y = z;//z有一個子節點
    else
        y = rb_successor(z->key);//z有兩個子節點，後繼和前趨保證了y有一個或沒有子節點
    if (y->left != NULL)
        x = y->left;
    else
        x = y->right;
    if (x != NULL) //存在一個子節點，先更正父子關係
        x->p = y->p;
    if (y->p == NULL)//再決定是在左或者右節點
        root = x;
    else {
        if (y->p->left == y)
            y->p->left = x;
        else
            y->p->right = x;
    }
    if (y != z)//處理兩個子節點的交換
        z->key = y->key;
    if (!y->color)//黑色
        rb_delete_fixup(x);
    delete y;
}

rb_delete_fixup成員函數，和插入相似，每一次刪除一個節點，要調整紅黑樹顏色讓其知足紅黑樹的性質（原理和rb_insert_fixup類似，不懂實現的，請認真學習《算法導論》）

template <typename T>
void rb_tree<T>::rb_delete_fixup(typename rb_tree<T>::prb_type x) {
    prb_type w;
    while (x && x!=root && !x->color) {//黑色
        if (x == x->p->left) {
            w = x->p->right;
            if (w->color) {//紅色
                w->color = false;
                x->p->color = true;
                left_rotate(x->p);
                w = x->p->right;
            }
            if ((!w->left && !w->right)|| (!w->left->color && !w->right->color)) {//雙黑
                w->color = true;
                x = x->p;
            }
            else {
                if (!w->right->color) {//單黑
                    w->left->color = false;
                    w->color = true;
                    right_rotate(w);
                    w = x->p->right;
                }
                w->color = x->p->color;
                x->p->color = false;
                w->right->color = false;
                left_rotate(x->p);
                x = root;
            }
        }
        else {//相反的狀況
            w = x->p->left;
            if (w->color) {//紅色
                w->color = false;
                x->p->color = true;
                right_rotate(x->p);
                w = x->p->left;
            }
            if ((!w->left && !w->right) || (!w->left->color && !w->right->color)) {//雙黑
                w->color = true;
                x = x->p;
            }
            else {
                if (!w->left->color) {//單黑
                    w->right->color = false;
                    w->color = true;
                    left_rotate(w);
                    w = x->p->left;
                }
                w->color = x->p->color;
                x->p->color = false;
                w->left->color = false;
                right_rotate(x->p);
                x = root;
            }
        }
    }
    if (x) x->color = false;//巧妙處理，默認黑
}

rb_empty成員函數，按照後續的遍歷刪除全部的節點

template <typename T>
void rb_tree<T>::rb_empty(typename rb_tree<T>::prb_type x) {
    if (x != NULL) {
        rb_empty(x->left);
        rb_empty(x->right);
        rb_delete(x);//後續保證子葉爲空
        rb_show(root);//測試使用
        printf("-------------------------------------\n");
    }
}

爲了測試全部函數是否正確，定義了一些輔助成員函數（可選）

Root成員函數

template <typename T>
typename rb_tree<T>::prb_type rb_tree<T>::Root() {
    return root;
}

rb_show成員函數

template <typename T>
void rb_tree<T>::rb_show(typename rb_tree<T>::prb_type x) {
    if (x != NULL) {
        rb_show(x->left);
        if (x == root)
            printf("root: (%s)%d\n", root->color ? "red" : "black", root->key);
        else
            printf("(%s)%d\n", x->color ? "red" : "black", x->key);
        rb_show(x->right);
    }
}

若是要分離模板實現，請提早實例化！！！！

template class rb_tree<int>;

 

最後的最後，上測試圖吧！

測試一：

數據錄入： 11 2 14 1 7 15 5 8 4

若是結果正確，應該生成《算法導論》中的圖（以下，深色表示黑色，淺色表示紅色）

代碼產生的結果（正確）：

測試二：

錄入數據：13 8 17 1 11 15 25 6 22 27

若是結果正確，應該生成如下圖的樣子

代碼產生的結果以下（正確）：

測試三：

爲了測試全部函數，那麼以測試一中的數據爲主，而後經過後續逐一刪除，而且查看是否刪除後，函數能正確的調整紅黑樹的顏色

未調用刪除函數前，完整的紅黑樹是如下圖

而後調用rb_empty成員函數後，產生一下結果（每次刪除一個節點，都會顯示樹的狀態和數據，你們花點時間，本身手動刪一次，和下面結果同樣）

 

全部代碼均通過測試，結果正確！

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