【算法导论】学习笔记——第13章 红黑树

红黑树（red-black tree）是许多平衡搜索树中的一种，因此基本操作（查询、删除、搜索）等在最坏情况下的时间复杂度均为O(lgn)。
13. 1 红黑树的性质
红黑树时一棵二叉搜索树，并且在每个结点上增加了一个属性表示颜色：红色或黑色。通过对任何一条从根到叶子的简单路径上各个结点的颜色进行约束，
红黑树确保没有一条路径会比其它路径长出2倍。因而是近似于平衡的。
一棵红黑树是满足下面红黑性质的二叉搜索树：
1. 每个结点是红色或黑色；
2. 根结点是黑色的；
3. 每个叶结点（NIL）是黑色的；
4. 如果一个结点是红色的，则它的两个子结点都是黑色的；
5. 对每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点。（黑高相等）
从某个结点x出发到达一个叶结点的任意一条简单路径上的黑色结点个数称为该结点的黑高（black-height）。

13.1-1
均不是，若结点为红色不满足性质4；若结点为黑色不满足性质5.

13.1-2
仍旧是红黑树，满足性质1-5

13.1-3
这个题目描述的不清楚，其实就是把红色结点和黑结点归并到一起组成一个新的结点。因此，
当黑色父结点的子结点均为黑色时，度为2；
当黑色父结点仅含一个黑色子结点时，度为3；
当黑色父结点的两个子结点均为红色时，度为4.
由于红色结点全部被吸收，即仅余下黑结点。由红黑树性质5可知叶结点深度均相同。

13.1-4
这个题目描述的不清楚，其实就是把红色结点和黑结点归并到一起组成一个新的结点。因此，
当黑色父结点的子结点均为黑色时，度为2；
当黑色父结点仅含一个黑色子结点时，度为3；
当黑色父结点的两个子结点均为红色时，度为4.
由于红色结点全部被吸收，即仅余下黑结点。由红黑树性质5可知叶结点深度均相同。

13.1-5
可以先形式化验证, 考虑结点x的黑高为BH(x), 红高为RH(x), 而RH(x)<=BH(x). 结点x到后代叶结
点的最长路径为BH(x)+RH(x), 最短路径为BH(x). 因此，至多为2倍。再形象地考虑一下路径会是什么样的。
设x的黑高为h，当x的颜色为黑色，则最长路径的着色为黑-红-黑-
...-红-黑-红-黑, 长度为(2h-2)，最短路径的着色为黑-黑-...-黑-黑，长度为(h-1), 比值为2 。
当x的颜色为红色，则最长路径的着色为红-黑-红-黑-
...-红-黑-红-黑, 长度为(2h-1)，最短路径的着色为红-黑-黑-
...-黑-黑，长度为h, 比值趋近于2 。
因此，综上可知比值最多为2.

13.1-6
内部结点最多为2^(2k)-1, 显然为一棵完全数，每层结点颜色为黑-红交替。
内部结点最少为2^k-1，显然为一棵全黑树。

13.1-7
比值最大为2:1, 比值最小为0（全黑树）。

13.2 旋转
旋转操作室平衡树中重要的操作之一，红黑树中仅有两种旋转：左旋与右旋。时间复杂度均为O(lgn)。通过左旋与右旋维护红黑树的性质。

void Left_Rotate(Tree_t *t, Node_t *x) {
    Node_t *y = x->right;
    x->right = y->left;
    if (y->left != t->NIL)
        y->left->p = x;
    y->p = x->p;
    if (x->p == t->NIL) {
        // x is root
        t->root = y;    
    } else if (x == x->p->left) {
        x->p->left = y;
    } else {
        x->p->right = y;
    }
    y->left = x;
    x->p = y;
}

void Right_Rotate(Tree_t *t, Node_t *y) {
    Node_t *x = y->left;
    y->left = x->right;
    if (x->right != t->NIL)
        x->right->p = y;
    x->p = y->p;
    if (y->p == t->NIL) {
        // y is root
        t->root = x;
    } else if (y == y->p->left) {
        y->p->left = x;
    } else {
        y->p->right = x;
    }
    x->right = y;
    y->p = x;
}

13.2-2


13.2-3
a加1，b不变，c减1

13.2-4


13.3 插入
插入操作主要包括RB-INSERT（在适合位置插入元素）与RB-INSERT-FIXUP（维护红黑树性质）。

void RBTree_Insert_Fixup(Tree_t *t, Node_t *z) {
    Node_t *y;
    
    while (z->p->color == RED) {
        // means z->p->p->color == BLACK
        if (z->p == z->p->p->left) {
            y = z->p->p->right;
            if (y->color == RED) {
                z->p->color = BLACK;
                y->color = BLACK;
                z->p->p->color = RED;
                z = z->p->p;
            } else {
                // y->color is BLACK
                if (z == z->p->right) {
                    z = z->p;
                    Left_Rotate(t, z);
                }
                z->p->color = BLACK;    // break later
                z->p->p->color = RED;
                Right_Rotate(t, z->p->p);
            }
        } else {
            y = z->p->p->left;
            if (y->color == RED) {
                z->p->color = BLACK;
                y->color = BLACK;
                z->p->p->color = RED;
                z = z->p->p;
            } else {
                // y->color is BLACK
                if (z == z->p->left) {
                    z = z->p;
                    Right_Rotate(t, z);
                }
                z->p->color = BLACK;    // break later
                z->p->p->color = RED;
                Left_Rotate(t, z->p->p);
            }
        }
    }
    t->root->color = BLACK;
}

void RBTree_Insert(Tree_t *t, Node_t *z) {
    Node_t *y = t->NIL;
    Node_t *x = t->root;
    while (x != t->NIL) {
        y = x;
        if (z->key < x->key) {
            x = x->left;
        } else {
            x = x->right;
        }
    }
    z->p = y;
    if (y == t->NIL) {
        // tree is empty
        t->root = z;
    } else if (z->key < y->key) {
        y->left = z;
    } else {
        y->right = z;
    }
    z->left = z->right = t->NIL;
    z->color = RED;
    RBTree_Insert_Fixup(t, z);
}

13.3-1
若将结点z着为黑色，则红黑树的黑高不平衡。破坏性质5，而且难以维护。

13.3-2


13.3-4


13.3-5


14.4 删除
与插入过程类似，删除过程主要包括RB-DELETE（基本的删除操作）与RB-DELETE-FIXUP（维护红黑树性质），另外还包括TRANSPLANT操作。

void RBTree_Transplant(Tree_t *t, Node_t *u, Node_t *v) {
    if (u->p == t->NIL) {
        t->root = v;
    } else if (u == u->p->left) {
        u->p->left = v;
    } else {
        u->p->right = v;
    }
    v->p = u->p;
}

void RBTree_Delete_Fixup(Tree_t *t, Node_t *x) {
    Node_t *w;
    
    while (x!=t->root && x->color==BLACK) {
        if (x == x->p->left) {
            w = x->p->right;
            if (w->color == RED) {
                w->color = BLACK;
                x->p->color = RED;
                Left_Rotate(t, x->p);
                w = x->p->right;
            }
            // means w->color == BLACK
            if (w->left->color==BLACK && w->right->color==BLACK) {
                w->color = RED;
                x = x->p;    // fetch the black in w & x and pass it to x->p
            } else {
                if (w->right->color == BLACK) {
                    // means w->left->color == RED
                    w->left->color = BLACK;
                    w->color = RED;
                    Right_Rotate(t, w);
                    w = x->p->right;
                }
                // means w->right->color == RED && w->left->color == uncertain
                w->color = x->p->color;
                x->p->color = BLACK;
                w->right->color = BLACK;
                Left_Rotate(t, x->p);
                x = t->root;
            }
        } else {
            w = x->p->left;
            if (w->color == RED) {
                w->color = BLACK;
                x->p->color = RED;
                Right_Rotate(t, x->p);
                w = x->p->left;
            }
            // means w->color == BLACK
            if (w->left->color==BLACK && w->right->color==BLACK) {
                w->color = RED;
                x = x->p; // fetch the black in w & x and pass it to x->p
            } else {
                if (w->left->color == BLACK) {
                    // means x->right->color == RED
                    w->right->color = BLACK;
                    w->color = RED;
                    Left_Rotate(t, w);
                    w = x->p->left;
                }
                // means w->left->color == RED && w->right->color = ANY
                w->color = x->p->color;
                x->p->color = BLACK;
                w->left->color = BLACK;
                Right_Rotate(t, x->p);
                x = t->root;
            }
        }
    }
    x->color = BLACK;
}

void RBTree_Delete(Tree_t *t, Node_t *z) {
    Node_t *x, *y = z;
    bool y_original_color = y->color;
    
    if (z->left == t->NIL) {
        x = z->right;
        RBTree_Transplant(t, y, x);
    } else if (z->right == t->NIL) {
        x = z->left;
        RBTree_Transplant(t, y, x);
    } else {
        y = RBTree_Minimum(t, z->right);
        y_original_color = y->color;
        x = y->right;
        if (y->p == z) {
            x->p = y;
        } else {
            RBTree_Transplant(t, y, x);
            y->right = z->right;
            y->right->p = y;
        }
        RBTree_Transplant(t, z, y);
        y->left = z->left;
        y->left->p = y;
        y->color = z->color;
    }
    
    if (y_original_color == BLACK)
        RBTree_Delete_Fixup(t, x);    // use x replace y
}

红黑树的插入和删除操作都需要分类讨论，因此，为了测试自己的红黑树是否正确可以dfs一下测试上述5个性质是否满足。
一定要注意NIL结点也是黑色的。

13.4-1


13.4-2
证明：
x.color为RED，而原来y的父结点为RED 。 直接将x的颜色改为BLACK，但这只是最简单的一种情况。

13.4-3


13.4-6
证明：
情 况1开 始 时， w.color==RED, 因 此w.p.color=BLACK(红 黑 树 性 质)， 而w.p==x.p， 因 此 当 情
况1发生时，x.p.color==BLACK恒成立。

13.4-7
不一定一样，个别结点的颜色可能会不一样。可以写个随机数发生器实际测试一下。