红黑树讲解和代码

最新推荐文章于 2024-08-19 23:33:53 发布
最新推荐文章于 2024-08-19 23:33:53 发布
阅读量2.1k 收藏 1
点赞数
分类专栏： 技术文章

红黑树（附标准代码）（阅读本文之前请先了解二叉搜索树）

红黑树（Red-Black Tree）是二叉搜索树（Binary Search Tree）的一种改进。我们知道二叉搜索树在最坏的情况下可能会变成一个链表（当所有节点按从小到大的顺序依次插入后）。而红黑树在每一次插入或删除节点 之后都会花O（log N）的时间来对树的结构作修改，以保持树的平衡。也就是说，红黑树的查找方法与二叉搜索树完全一样；插入和删除节点的的方法前半部分节与二叉搜索树完全一 样，而后半部分添加了一些修改树的结构的操作。

红黑树的每个节点上的属性除了有一个key、3个指针：parent、lchild、rchild以外，还多了一个属性：color。它只能是两种颜色：红或黑。而红黑树除了具有二叉搜索树的所有性质之外，还具有以下4点性质：

1. 根节点是黑色的。
2. 空节点是黑色的（红黑树中，根节点的parent以及所有叶节点lchild、rchild都不指向NULL，而是指向一个定义好的空节点）。
3. 红色节点的父、左子、右子节点都是黑色。
4. 在任何一棵子树中，每一条从根节点向下走到空节点的路径上包含的黑色节点数量都相同。

 

如下图就是一棵红黑树：

红黑树

有了这几条规则，就可以保证整棵树的平衡，也就等于保证了搜索的时间为O（log N）。 但是在插入、删除节点后，就有可能破坏了红黑树的性质。所以我们要做一些操作来把整棵树修补好。下面我就来介绍一下。

首先有一个预备知识，那就是节点的Left-Rotate和Right-Rotate操作。所谓Left-Rotate(x)就是把节点x 向左下方 向移动一格，然后让x原来的右子节点代替它的位置。而Right-Rotate当然就是把Left-Rotate左、右互反一下。如下图：

红黑树 旋转

注意，Left-Rotate(x)后，x的右子树变成了原来y的左子树，Right-Rotate反之。思考一下，这样一次变换后，仍然满足二叉搜索树的性质。在红黑树的插入、删除中，要用到很多Left-Rotate和Right-Rotate操作。

一、 插入

插入首先是按部就班二叉搜索树的插入步骤，把新节点z插入到某一个叶节点的位置上。 接下来把z的颜色设成红色。为什么？还记得红黑树的性质吗，从根节点向下到空节点的每一条路径上的黑色节点数要相同。如果新插入的是黑色节点，那么它所在 的路径上就多出了一个黑色的节点了。所以新插入的节点一定要设成红色。但是这样可能又有一个矛盾，如果z的父节点也是红色，怎么办，前面说过红色节点的子 节点必须是黑色。因此我们要执行下面一个迭代的过程，称为Insert-Fixup，来修补这棵红黑树。

在Insert-Fixup中，每一次迭代的开始，指针z一定都指向一个红色的节点。如果z->parent是黑色，那我们就大功 告成了；如果z->parent是红色，显然这就违返了红黑的树性质，那么我们要想办法把z或者z->parent变成黑色，但这要建立在不 破坏红黑树的其他性质的基础上。

这里再引入两个指针：grandfather，指向z->parent->parent，也就是z的爷爷(显然由于 z->parent为红色，grandfather一定是黑色)；uncle，指向grandfather除了z->parent之外的另一 个子节点，也就是z的父亲的兄弟，所以叫uncle。

（为了说话方便，我们这里都假设z->parent是grandfather的左子节点，而uncle是grandfather的右子节点。如果遇到的实际情况不是这样，那也只要把所有操作中的左、右互反就可以了。）

在每一次迭代中，我们可能遇到以下三种情况。

Case 1. uncle也是红色。这时只要把z->parent和uncle都设成黑色，并把grandfather设成红色。这样仍然确保了每一条路径上的黑色节点数不变。然后把z指向grandfather，并开始新一轮的迭代。如下图：

红黑树 插入 情况1

Case 2. uncle是黑色，并且z是z->parent的右子节点。这时我们只要把z指向z->parent，然后做一次Left-Rotate(z)。就可以把情况转化成Case 3。

Case 3. uncle是黑色，并且z是z->parent的左子节点。到了这一步，我们就剩最后一步了。只要把z->parent设成黑色，把 grandfather设成红色，再做一次Right-Rotate(grandfather)，整棵树就修补完毕了。可以思考一下，这样一次操作之后， 确实满足了所有红黑树的性质。Case 2和Case 3如下图：

红黑树 插入 情况2 情况3

反复进行迭代，直到某一次迭代开始时z->parent为黑色而告终，也就是当遇到Case 3后，做完它而告终。

二、删除

让我们来回顾一下二叉搜索树的删除节点z的过程：如果z没有子节点，那么直接删除即可；如果z只有一个子节点，那么让这个子节点来代替z的 位置，然 后把z删除即可；如果z有两个子节点，那么找到z在中序遍历中的后继节点s（也就是从z->rchild开始向左下方一直走到底的那一个节点），把 s的key赋值给z的key，然后删除s。

红黑树中删除一个节点z的方法也是首先按部就班以上的过程。 如果删除的节点是黑色的，那么显然它所在的路径上就少一个黑色节点，那么红黑树的性质就被破坏了。这时我们就要执行一个称为Delete-Fixup的过程，来修补这棵树。下面我就来讲解一下。

一个节点被删除之后，一定有一个它的子节点代替了它的位置（即使是叶节点被删除后，也会有一个空节点来代替它的位置。前面说过，在红黑树中，空节点是一个实际存在的节点。）。我们就设指针x指向这个代替位置的节点。

显然，如果x是红色的，那么我们只要把它设成黑色，它所在的路径上就重新多出了一个黑色节点，那么红黑树的性质就满足了。

然而，如果x是黑色的，那我们就要假想x上背负了2个单位的黑色。那么红黑树的性质也同样不破坏，但是我们要找到某一个红色的节点，把x上“超载”的这1个单位的黑色丢给它，这样才算完成。Delete-Fixup做的就是这个工作。

Delete-Fixup同样是一个循环迭代的过程。每一次迭代开始时，如果指针x指向一个红色节点，那么大功告成，把它设成黑色即告终。相反如果x黑色，那么我们就会面对以下4种情况。

这里引入另一个指针w，指向x的兄弟。这里我们都默认x是x->parent的左子节点，则w是x->parent的右子节点。（如果实际遇到相反的情况，只要把所有操作中的左、右互反一下就可以了。）

Case 1. w是红色。这时我们根据红黑树的性质可以肯定x->parent是黑色、w->lchild是黑色。我们把x->parent与w的颜 色互换，然后做一次Left-Rotate(x->parent)。做完之后x就有了一个新的兄弟：原w->lchild，前面说过它一定是 黑色的。那么我们就在不破坏红黑树性质的前提下，把Case 1转换成了Case2、3、4中的一个，也就是w是黑色的情况。如下图：

红黑树 删除 情况1

Case 2. w是黑色，并且w的两个子节点都是黑色。这时我们只要把w设成红色。然后把x移到x->parent，开始下一轮迭代（注意，那“超载”的1单位的 黑色始终是跟着指针x走的，直到x走到了一个红色节点上才能把它“卸下”）。思考一下，这一次操作不会破坏红黑树的性质。这如下图（图中节点B不一定是红 色，也可能是黑色）：

红黑树 删除 情况2

Case 3. w是黑色，并且w的右子节点也是黑色。这时我们把w与w->lchild的颜色互换，然后做Right-Rotate(w)。思考一下，这样做之后 不会破坏红黑树的性质。这时x的新的兄弟就是原w->lchild。而Case 3被转化成了Case 4。

红黑树 删除 情况3

Case 4. w是黑色，并且w的右子节点是红色。一但遇到Case 4，就胜利在望了。我看下面一张图。先把w与x->parent的颜色互换，再做Left-Rotate(x->parent)。这时图中节 点E（也就是原w->rchild）所在的路径就肯定少了一个黑色，而x所在的路径则多了一个黑色。那么我们就把x上多余的1个单位的黑色丢给E就 可以了。至此，Delete-Fixup就顺利完成了。

红黑树 删除 情况4

以下是我的红黑树代码，其中的所有函数都不包含递归（当然，由于树的层数不会很大，要写成递归也可以）... 

struct Key {
    int value;
};
struct RBTNode {
    Key key;
    int lcount;
    int rcount;
    RBTNode* lchild;
    RBTNode* rchild;
    RBTNode* parent;
    bool color;
};
class RBT {
private:
    const static bool RED = true;
    const static bool BLACK = false;
    RBTNode* m_null;
    RBTNode* m_root;
    void clear() {//
        RBTNode* p = m_root;
        while (p != m_null) {
            if (p->lchild != m_null) {
                p = p->lchild;
            }else if (p->rchild != m_null) {
                p = p->rchild;
            }else {
                RBTNode* temp = p;
                p = p->parent;
                if (temp == p->lchild) {
                    p->lchild = m_null;
                }else {
                    p->rchild = m_null;
                }
                delete temp;
            }
        }
        m_root = m_null;
    }
    void delFixup(RBTNode* delNode) {
        RBTNode* p = delNode;
        while (p != m_root && p->color == BLACK) {
            if (p == p->parent->lchild) {
                RBTNode* sibling = p->parent->rchild;
                if (sibling->color == RED) {
                    sibling->color = BLACK;
                    p->parent->color = RED;
                    leftRotate(p->parent);
                    sibling = p->parent->rchild;
                }
                if (sibling->lchild->color == BLACK
                    && sibling->rchild->color == BLACK
                    ) {
                        sibling->color = RED;
                        p = p->parent;
                }else {
                    if (sibling->rchild->color == BLACK) {
                        sibling->lchild->color = BLACK;
                        sibling->color = RED;
                        rightRotate(sibling);
                        sibling = sibling->parent;
                    }
                    sibling->color = sibling->parent->color;
                    sibling->parent->color = BLACK;
                    sibling->rchild->color = BLACK;
                    leftRotate(sibling->parent);
                    p = m_root;
                }
            }else {
                RBTNode* sibling = p->parent->lchild;
                if (sibling->color == RED) {
                    sibling->color = BLACK;
                    p->parent->color = RED;
                    rightRotate(p->parent);
                    sibling = p->parent->lchild;
                }
                if (sibling->lchild->color == BLACK
                    && sibling->rchild->color == BLACK
                    ) {
                        sibling->color = RED;
                        p = p->parent;
                }else {
                    if (sibling->lchild->color == BLACK) {
                        sibling->rchild->color = BLACK;
                        sibling->color = RED;
                        leftRotate(sibling);
                        sibling = sibling->parent;
                    }
                    sibling->color = sibling->parent->color;
                    sibling->parent->color = BLACK;
                    sibling->lchild->color = BLACK;



                    rightRotate(sibling->parent);
                    p = m_root;
                }
            }
        }
        p->color = BLACK;
    }
    void insertFixup(RBTNode* insertNode) {
        RBTNode* p = insertNode;
        while (p->parent->color == RED) {
            if (p->parent == p->parent->parent->lchild) {
                RBTNode* parentRight = p->parent->parent->rchild;
                if (parentRight->color == RED) {
                    p->parent->color = BLACK;
                    parentRight->color = BLACK;
                    p->parent->parent->color = RED;
                    p = p->parent->parent;
                }else {
                    if (p == p->parent->rchild) {
                        p = p->parent;
                        leftRotate(p);
                    }
                    p->parent->color = BLACK;
                    p->parent->parent->color = RED;
                    rightRotate(p->parent->parent);
                }
            }else {
                RBTNode* parentLeft = p->parent->parent->lchild;
                if (parentLeft->color == RED) {
                    p->parent->color = BLACK;
                    parentLeft->color = BLACK;
                    p->parent->parent->color = RED;
                    p = p->parent->parent;
                }else {
                    if (p == p->parent->lchild) {
                        p = p->parent;
                        rightRotate(p);
                    }
                    p->parent->color = BLACK;
                    p->parent->parent->color = RED;
                    leftRotate(p->parent->parent);
                }
            }
        }
        m_root->color = BLACK;
    }

    inline int keyCmp(const Key& key1, const Key& key2) {
        //比较两个Key的大小。这里可能有更复杂的比较，如字符串比较等。
        return key1.value - key2.value;
    }

    inline void leftRotate(RBTNode* node) {
        //把一个节点向左下方移一格，并让他原来的右子节点代替它的位置。
        RBTNode* right = node->rchild;
        node->rchild = right->lchild;
        node->rcount = right->lcount;
        node->rchild->parent = node;
        right->parent = node->parent;
        if (right->parent == m_null) {
            m_root = right;
        }else if (node == node->parent->lchild) {
            node->parent->lchild = right;
        }else {
            node->parent->rchild = right;
        }
        right->lchild = node;
        right->lcount += node->lcount + 1;
        node->parent = right;
    }

    inline void rightRotate(RBTNode* node) {
        //把一个节点向右下方移一格，并让他原来的左子节点代替它的位置。
        RBTNode* left = node->lchild;
        node->lchild = left->rchild;
        node->lcount = left->rcount;
        node->lchild->parent = node;
        left->parent = node->parent;
        if (left->parent == m_null) {
            m_root = left;
        }else if (node == node->parent->lchild) {
            node->parent->lchild = left;
        }else {
            node->parent->rchild = left;
        }
        left->rchild = node;
        left->rcount += node->rcount + 1;
        node->parent = left;
    }

    RBTNode* treeMax(RBTNode* root) {//找到子树中最大的一个节点
        RBTNode* result = root;
        while (result->rchild != m_null) {
            result = result->rchild;
        }
        return result;
    }

    RBTNode* treeMin(RBTNode* root) {//找到子树中最小的一个节点
        RBTNode* result = root;
        while (result->lchild != m_null) {
            result = result->lchild;
        }
        return result;
    }
public:
    RBT() {
        m_null = new RBTNode;
        m_null->color = BLACK;
        m_null->lchild = m_null->rchild = m_null;
        m_root = m_null;
    }
    ~RBT() {
        clear();
        delete m_null;
    }

    RBTNode* atIndex(int i) {//找到从小到大排序后下标为i的节点。i从0开始。
        RBTNode* result = m_root;
        if (i > result->lcount + result->rcount) {
            result = NULL;
        }else {
            while (i != result->lcount) {
                if (i < result->lcount) {
                    result = result->lchild;
                }else {
                    i -= result->lcount + 1;
                    result = result->rchild;
                }
            }
        }
        return result;
    }

    void del(RBTNode* node) {//删除一个节点
        RBTNode* toDel = node;
        if (node->lchild != m_null && node->rchild != m_null) {
            toDel = treeNext(node);//找到中序后继：即右子树最左节点
        }
        RBTNode* temp = toDel;
        while (temp->parent != m_null) {
            if (temp == temp->parent->lchild) {
                temp->parent->lcount--;
            }else {
                temp->parent->rcount--;
            }
            temp = temp->parent;
        }
        RBTNode* replace = toDel->lchild != m_null? toDel->lchild: toDel->rchild;
        replace->parent = toDel->parent;
        if (replace->parent == m_null) {
            m_root = replace;
        }else if (toDel == toDel->parent->lchild) {
            replace->parent->lchild = replace;
        }else {
            replace->parent->rchild = replace;
        }
        if (toDel != node) {
            node->key = toDel->key;
        }
        if (toDel->color == BLACK) {
            //修改树，以保持平衡。
            delFixup(replace);
        }
        delete toDel;
    }

    void insert(const Key& key) {//插入一个节点
        RBTNode* node = new RBTNode;

        node->key = key;
        node->lcount = 0;
        node->rcount = 0;
        node->lchild = m_null;
        node->rchild = m_null;
        node->color = RED;

        RBTNode* p = m_root;
        RBTNode* leaf = m_null;
        while (p != m_null) {
            leaf = p;
            if (keyCmp(node->key, p->key) < 0) {
                p->lcount++;
                p = p->lchild;
            }else {
                p->rcount++;
                p = p->rchild;
            }
        }
        node->parent = leaf;
        if (leaf == m_null) {//如果是空树。
            m_root = node;
        }else if (keyCmp(node->key, leaf->key) < 0) {
            leaf->lchild = node;
        }else {
            leaf->rchild = node;
        }
        //修改树，以保持平衡。
        insertFixup(node);
    }
    int nodeCount() {
        return m_root != m_null? m_root->lcount + m_root->rcount + 1: 0;
    }

    RBTNode* search(const Key& key) {//按照key查找一个节点。
        RBTNode* result = m_root;
        while (result != m_null && keyCmp(key, result->key) != 0) {
            result = keyCmp(key, result->key) < 0 ? result->lchild : result->rchild;
        }
        return result == m_null? NULL: result;
    }

    void toArray(int* array) {//把树中节点的值放进一个数组。
        RBTNode* p = treeMin(m_root);
        int i = 0;
        while (p != m_null) {
            array[i] = p->key.value;
            i++;
            p = treeNext(p);
        }
    }

    RBTNode* treeNext(RBTNode* node) {//一个节点在中序遍列中的下一个节点。后继
        RBTNode* result;
        if (node->rchild != m_null) {
            result = treeMin(node->rchild);
        }else {
            result = node->parent;
            RBTNode* temp = node;
            while (result != m_null && temp == result->rchild) {
                temp = result;
                result = result->parent;
            }
        }
        return result;
    }

    RBTNode* treePre(RBTNode* node) {//一个节点在中序遍列中的前一个节点。前驱
        RBTNode* result;
        if (node->lchild != m_null) {
            result = treeMax(node->lchild);
        }else {
            result = node->parent;
            RBTNode* temp = node;
            while (result != m_null && temp == result->lchild) {
                temp = result;
                result = result->parent;
            }
        }
        return result;
    }
};

 

zirconsdu
关注
专栏目录
【动态图文详解-史上最易懂的红黑树讲解】手写红黑树（Red Black Tree）
AI天才研究院
12-10 1万+
红黑树：一棵自平衡（AVL）+二叉查找树(BST)什么是红黑树红黑树，Red-Black Tree 「RBT」是一个自平衡(不是绝对的平衡)的二叉查找树(BST)。红黑树是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑...
【干货分享】红黑树硬核讲解
Linuxhus的博客
06-27 299
预防针：红黑树本来就是基本算法中的难点，所以看此文时建议先有点预备心理或知识铺垫，没接触过RBT而直接看此文的话，绝对懵逼。为了数据的查询跟增删方便，系统引入了二叉查找树，它具有左节点 < 根节点 .........
红黑树代码
05-07
红黑树的C语言代码实现，这我参考《算法导论》写的实例代码，仅供参考^_^
红黑树
weixin_34088583的博客
03-28 101
总想有一个简单的RBTree类，又不想自己实现，找来找去找到这篇好文，除了讲解的清楚简明外，代码也不错，无递归的迭代，而且很容易“拿来”做成模板，如果你也不想"再发明一次轮子"的话... 正文如下: 红黑树（附标准代码）（阅读本文之前请先了解二叉搜索树） 红黑树（Red-Black Tree）是二叉搜索树（Binary Search Tree）的一种改进。我们知道二...
详细红黑树操作通俗易懂讲解（插入与删除+图片通俗讲解）
最新发布
weixin_62513677的博客
08-19 762
详细通俗易懂的红黑树操作讲解，快来看看吧
红黑树详解+代码解析（转载）
cjl的博客
07-16 939
红黑树详解预备知识平衡二叉搜索树二叉搜索树平衡改进二叉搜索树AVL 树平衡因子B树B 树 VS 二叉搜索树红黑树定义和性质红黑树与 B 树的等价变换红黑树的基本操作左旋右旋变色变换规则红黑树搜索红黑树插入插入后实现自平衡红黑树删除定位删除的位置删除后实现自平衡 转载自：https://juejin.im/post/5e509b27f265da57455b3f33#heading-19 红黑树（Red Black Tree）是一种自平衡的二叉搜索树（Self-balancing Binary Search T
红黑树详解
weixin_30588729的博客
11-21 112
在介绍红黑树之前，有必要对树的概念以及相关理论作一个概述： 树 1. 树的导览 树由节点（Nodes）和 边（edges）构成。树有根节点（root），边（deges），父节点（parent），子节点（child），叶节点（leaf）。如果最多只允许两个子节点，即所谓的二叉树（binary tree）。不同的节点如果拥有相同的父节点，则彼此互为兄弟节点（siblings）。根节点至任何节点...
红黑树的代码
四夕日 月
09-20 1192
我写的红黑树代码。
红黑树的插入与删除_详细整理资料
02-25
总之，红黑树的插入和删除操作虽然相对复杂，但通过遵循特定的规则和原则，可以有效地维护树的平衡性，从而确保所有基本操作的时间复杂度均保持在O(log n)的水平。这使得红黑树成为高效数据结构的一个典范，广泛应用...
红黑树python实现
zzp1123的博客
07-04 800
红黑树python实现
C++简单实现红黑树的插入
06-06
在C++中实现红黑树，我们需要理解其特性并将其转化为代码。以下是关于红黑树插入操作的详细讲解。 红黑树有以下性质： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空节点）是...
【模板】红黑树
wakawaka
12-22 503
#define BLACK 1 #define RED 0 class bst { private: struct Node { int value; bool color; Node *leftTree, *rightTree, *parent; Node() { color = RED;
每日一省之————红黑树的java实现
lhever_的博客
10-17 1559
今天本打算复习红黑树，可是红黑树的概念都记得有些模糊不清了。所以网搜复习了一下其基本概念。也因此发现了一篇介绍红黑树的好文章。这篇文章配有大量图示，甚至有动态图演示左旋和右旋操作。所以也给大家分享下： 浅谈算法和数据结构: 九 平衡查找树之红黑树至于自己的实现代码，本人还是希望像之前的几篇关于算法的文章一样，尽可能的将相关的API实现全面一些。不过，已经很晚了，改天补上。既然没有代码，还写这堆废话
平衡树和红黑树的书籍
07-27
有几本关于平衡树和红黑树的书籍可以推荐给你： 1. 《算法导论》（Introduction to Algorithms）- Thomas H. Cormen 等人 这本经典教材详细介绍了平衡树和红黑树的原理、性质和实现，并提供了相应的伪代码和示例。 2. 《数据结构与算法分析》（Data Structures and Algorithm Analysis in C++）- Mark Allen Weiss 该书深入讲解了平衡树和红黑树的概念、应用和实现方法，并提供了C++代码示例。 3. 《算法（第4版）》（Algorithms, Part I）- Robert Sedgewick, Kevin Wayne 这本书由知名算法专家撰写，其中包含了对平衡树和红黑树的讲解，配有Java代码示例。 4. 《数据结构与算法分析：C语言描述》（Data Structures and Algorithm Analysis in C）- Clifford A. Shaffer 该书以C语言为基础，详细介绍了平衡树和红黑树的实现原理和应用，适合C语言开发者阅读。 以上是一些被广泛推荐的书籍，它们对于理解平衡树和红黑树的概念和实现方法非常有帮助。你可以根据自己的编程语言和阅读习惯选择适合的一本进行深入学习。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值