我的红黑树学习笔记

红黑树

---

红黑树的规则：

1. 每个节点非黑即红。
2. 根结点是黑色。
3. 叶结点 (NIL) 是黑色。
4. 如果一个结点是红色, 则它的两个子节点都是黑色的。
5. 从根结点出发到所有叶结点的路径上, 均包含相同。

调整策略：

1. 插入调整站到 祖父节点 观察。
2. 删除调整站在 父节点 观察。
3. 插入和删除的情况一共五种。

优势：最短路径 与 最长路径 长度至多差一倍。

---

插入操作：

首先我们明确插入节点 x 必将预先设置为红色，这样保证了 规则 5 的成立。

当插入的新结点 x 的父结点是红色时,需要从新结点出发向上进行调整。

1）x 的叔父节点为红色

此时 x 的祖父节点一定是黑色，我们直接将祖父节点改为红色，父节点和叔父节点均改为黑色即可。

调整前：

调整后：

2）x 的叔父节点为黑色，而且 x 是一个右孩子。

观察 x 对于其祖父节点在其左子树还是右子树上，如若在其左子树，则当前属于LR型。

对于 x 的父节点进行左小旋，这样保证了$ x $ 的左子树上每条路径黑色节点不变。

变换结束后，x 的叔父节点仍为黑色，父节点仍为红色，不过此时 x 已经成为了一个左孩子，按第三种情况 进行调整。

调整前：

调整后：

3）x 的叔父节点为黑色，而且 x 是一个左孩子。

观察 x 对于其祖父节点在其左子树还是右子树上，如若在其左子树，则当前属于LL型。

将 x 的父节点改为黑色，x 的祖父节点改为红色，然后对于 x 的父节点进行一次右大旋。

这时 x 的父结点为黑色，不需要再向上迭代调整了。

调整前：

调整后：

这里我们只讨论了LL型与LR型的调整策略，对于RR型与RL型调整策略是对称的。

---

删除操作：

在讨论二叉排序树删除节点，在删除度数为2的节点时，我们将其转化为度为1的节点删除，我们在对于红黑树删除操作时也该是如此。

如果要删除的节点为红色，其父节点与子节点应该均为黑色，直接将子节点连到其父节点即可。因为他的颜色是红色，所以直接删除他不会破坏规则5。

如果要删除的节点为黑色，其子节点为红色，直接将子节点替换上来，然后改为黑色即可。

当待删除节点 x 与子节点均为黑色时：

首先我们将待删除节点 x 的子节点替换上来，将其添加一层黑色 (双重黑色)。

具有 “双重黑色” 的节点，在计算路径上黑色节点数量时，经过 x 要计算两次。

1）具有 “双重黑色”的节点 x 兄弟节点为红色。

将 x 的兄弟节点改为黑色，父节点改为红色。如若 x 是一个右孩子，那么对于 x 的父节点进行一个右旋操作。

此时，对于 x 兄弟节点变为了黑色，可以按照接下来几种情况情形处理。

调整前：

调整后：

2）待删除节点 x 的兄弟节点为黑色，兄弟节点的两个孩子也均为黑色。

此时我们将 $x$ 的兄弟节点改为红色，然后 $x$ 褪去一层黑色，为 $x$ 的父节点加一层黑色。

接下来我们将 x 的父节点作为 x 继续向上调整。

调整前：

调整后：

3）待删除节点 x 的兄弟节点为黑色，兄弟节点的左孩子为红色，右孩子为黑色。

此时我们交换其兄弟节点与其左孩子的颜色，然后对于其兄弟节点进行右旋操作。属于RL型。

现在兄弟节点的右孩子为红色了（RR型），我们继续按照第四种情况进行调整。

调整前：

调整后：

4）待删除节点 x 的兄弟节点为黑色，兄弟节点的左孩子为黑色，右孩子为红色。

将兄弟节点的父节点与右孩子从红色改为黑色，然后对于 x 的父节点进行一次左旋操作。使得 x 去掉一层黑色，此时以 x 的父节点 作为 x 继续向上调整。

调整前：

调整后：

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

typedef struct RBNode {
    int key, color; // 0 red, 1 black, 2 double black
    struct RBNode *lchild, *rchild;
} RBNode;

RBNode *NIL;

RBNode *getNewNode(int key) {
    RBNode *p = (RBNode *)malloc(sizeof(RBNode));
    p->key = key;
    p->color = 0;
    p->lchild = p->rchild = NIL;
    return p;
}

__attribute__((constructor)) void init_NIL() {
    NIL = getNewNode(0);
    NIL->color = 1;
    NIL->lchild = NIL->rchild = NIL;
    return ;
}

int hasRedChild(RBNode *node) {
    return node->lchild->color == 0 || node->rchild->color == 0;
}

RBNode *left_rotate(RBNode *node) {
    RBNode *temp = node->rchild;
    node->rchild = temp->lchild;
    temp->lchild = node;
    return temp;
}

RBNode *right_rotate(RBNode *node) {
    RBNode *temp = node->lchild;
    node->lchild = temp->rchild;
    temp->rchild = node;
    return temp;
}

RBNode *insert_maintain(RBNode *root) {
    if (!hasRedChild(root)) return root;
    if (root->lchild->color == 0 && root->rchild->color == 0) {
        if (hasRedChild(root->lchild) || hasRedChild(root->rchild)) {
            root->color = 0;
            root->rchild->color = root->lchild->color = 1;
        }
        return root;
    }
    if (root->lchild->color == 0) {
        if (!hasRedChild(root->lchild)) return root;
        if (root->lchild->rchild->color == 0) {
            root->lchild = left_rotate(root->lchild);
        }
        root = right_rotate(root);
    } else {
        if (!hasRedChild(root->rchild)) return root;
        if (root->rchild->lchild->color == 0) {
            root->rchild = right_rotate(root->rchild);
        }
        root = left_rotate(root);
    }
    root->color = 0;
    root->lchild->color = root->rchild->color = 1;
    return root;
}

RBNode *__insert(RBNode *root, int key) {
    if (root == NIL || root == NULL) return getNewNode(key);
    if (root->key == key) return root;
    if (root->key < key) root->rchild = __insert(root->rchild, key);
    else root->lchild = __insert(root->lchild, key);
    return insert_maintain(root);
}

RBNode *insert(RBNode *root, int key) {
    root = __insert(root, key);
    root->color = 1;
    return root;
}

RBNode *predecessor(RBNode *node) {
    RBNode *temp = node->lchild;
    while (temp->rchild != NIL) temp = temp->rchild;
    return temp;
}

RBNode *erase_maintain(RBNode *root) {
    if (root->lchild->color != 2 && root->rchild->color != 2) return root;
    if (root->lchild->color == 0 || root->rchild->color == 0) {
        root->color = 0;
        if (root->lchild->color == 0) {
            root->lchild->color = 1;
            root = right_rotate(root);
            root->rchild = erase_maintain(root->rchild);
        } else {
            root->rchild->color = 1;
            root = left_rotate(root);
            root->lchild = erase_maintain(root->lchild);
        }
        return root;
    }
    if (root->lchild->color == 2) {
        if (!hasRedChild(root->rchild)) {
            root->color += 1;
            root->lchild->color = 1;
            root->rchild->color = 0;
            return root;
        } else if (root->rchild->rchild->color == 1) {
            root->rchild = right_rotate(root->rchild);
            root->rchild->color = 1;
            root->rchild->rchild->color = 0;
        }
        root->lchild->color = 1;
        root = left_rotate(root);
        root->color = root->lchild->color;
        root->lchild->color = root->rchild->color = 1;
    } else {
        if (!hasRedChild(root->lchild)) {
            root->color += 1;
            root->rchild->color = 1;
            root->lchild->color = 0;
            return root;
        } else if (root->lchild->lchild->color == 1) {
            root->lchild = left_rotate(root->lchild);
            root->lchild->color = 1;
            root->lchild->lchild->color = 0;
        }
        root->rchild->color = 1;
        root = right_rotate(root);
        root->color = root->rchild->color;
        root->lchild->color = root->rchild->color = 1;
    }
    return root;
}

RBNode *__erase(RBNode *root, int key) {
    if (root == NULL || root == NIL) return NIL;
    if (root->key < key) root->rchild = __erase(root->rchild, key);
    else if (root->key > key) root->lchild = __erase(root->lchild, key);
    else {
        if (root->lchild == NIL && root->rchild == NIL) {
            NIL->color += root->color;
            free(root);
            return NIL;
        } else if (root->lchild == NIL || root->rchild == NIL) {
            RBNode *temp = root->lchild == NIL ? root->rchild : root->lchild;
            temp->color += root->color;
            free(root);
            return temp;
        } else {
            RBNode *temp = predecessor(root);
            root->key = temp->key;
            root->lchild = __erase(root->lchild, temp->key);
        }
    }
    return erase_maintain(root);
}

RBNode *erase(RBNode *root, int key) {
    root = __erase(root, key);
    root->color = 1;
    return root;
}

void clear(RBNode *root) {
    if (root == NIL || root == NULL) return ;
    clear(root->lchild);
    clear(root->rchild);
    free(root);
    return ;
}

void output(RBNode *root) {
    if (root == NIL) return ;
    printf("(%d | %d, %d, %d)\n", root->color, root->key, root->lchild->key, root->rchild->key);
    output(root->lchild);
    output(root->rchild);
    return ;
}

int main() {
    int op, value;
    RBNode *root = NIL;
    while (scanf("%d%d", &op, &value) != EOF) {
        switch (op) {
            case 0: 
                printf("\ninsert %d\n", value);
                root = insert(root, value); break;
            case 1: 
                printf("\ndelete %d\n", value);
                root = erase(root, value); break;
            default: printf("error\n");
        }
        printf("----------\n");
        output(root);
    }
    return 0;
}