简述容器之rb_tree及其应用--（boolan）

• 概述：
    Red-Black tree(红黑树)是平衡二分搜寻树（balanced binary search tree)中常被使用的一种平衡二分搜寻树的特征：排列规则有利于search和insert，并保持适度平衡————无任何结点太深。
     红黑树只要求局部平衡，C++ STL中的map、set、multimap、multiset都应用了红黑树。
    红黑树的每个节点或者上都有存储位表示节点的颜色，颜色是红或者黑，红黑树的特征有：1.每个节点或者是黑色或者是红色 2.根节点是黑色 3.每个叶子节点是黑色[这里叶子节点，是指为空的叶子节点] 4.如果一个节点是黑色的，那么它的子节点必须是黑色的 5.从一个节点到该节点的子节点的所有路径上包含相同数目的黑节点[注意：这里需要确保没有一条路径会比其他路径长出两倍]

  rb_tree提供“遍历”操作及iterators。按正常规则（++ite）遍历，便能获得排序状态（sorted）。
  我们不应使用rb_tree的iterators改变元素值（因为元素有其严谨的排列规则）。编程里面（programming leve）并未阻绝此事。如此设计是正确的，因为rb_tree即将为set和map服务（作为其底部支持），而map允许元素的data被改变，只有元素的key才是不可被改变的。
  rb_tree提供两种insertion操作：insert_unique()和insert_equal前者表示节点的key 一定在整个tree中独一无二，否则安插失败，后者表示节点的key可以重复。

•   红黑树的基本操作是添加、删除和旋转。在对红黑树进行添加或者删除后，会用到旋转方法。因为添加或删除红黑树中的节点之后，红黑树就发生了变化，可能不满足红黑树的五条特性，也就不再是一颗红黑树了，而是一颗普通的树。而通过旋转，可以使这颗树重新成为红黑树。简单的说旋转的目的是为了让树保持红黑树的特性。
  以下为参考代码：

enum RBTColor{RED, BLACK};template <class T>class RBTNode{    public:        RBTColor color;    // 颜色        T key;            // 关键字(键值)        RBTNode *left;    // 左孩子        RBTNode *right;    // 右孩子        RBTNode *parent; // 父结点        RBTNode(T value, RBTColor c, RBTNode *p, RBTNode *l, RBTNode *r):            key(value),color(c),parent(),left(l),right(r) {}};template <class T>class RBTree {    private:        RBTNode<T> *mRoot;    // 根结点    public:        RBTree();        ~RBTree();        // 前序遍历"红黑树"        void preOrder();        // 中序遍历"红黑树"        void inOrder();        // 后序遍历"红黑树"        void postOrder();        // (递归实现)查找"红黑树"中键值为key的节点        RBTNode<T>* search(T key);        // (非递归实现)查找"红黑树"中键值为key的节点        RBTNode<T>* iterativeSearch(T key);        // 查找最小结点：返回最小结点的键值。        T minimum();        // 查找最大结点：返回最大结点的键值。        T maximum();        // 找结点(x)的后继结点。即，查找"红黑树中数据值大于该结点"的"最小结点"。        RBTNode<T>* successor(RBTNode<T> *x);        // 找结点(x)的前驱结点。即，查找"红黑树中数据值小于该结点"的"最大结点"。        RBTNode<T>* predecessor(RBTNode<T> *x);        // 将结点(key为节点键值)插入到红黑树中        void insert(T key);        // 删除结点(key为节点键值)        void remove(T key);        // 销毁红黑树        void destroy();        // 打印红黑树        void print();    private:        // 前序遍历"红黑树"        void preOrder(RBTNode<T>* tree) const;        // 中序遍历"红黑树"        void inOrder(RBTNode<T>* tree) const;        // 后序遍历"红黑树"        void postOrder(RBTNode<T>* tree) const;        // (递归实现)查找"红黑树x"中键值为key的节点        RBTNode<T>* search(RBTNode<T>* x, T key) const;        // (非递归实现)查找"红黑树x"中键值为key的节点        RBTNode<T>* iterativeSearch(RBTNode<T>* x, T key) const;        // 查找最小结点：返回tree为根结点的红黑树的最小结点。        RBTNode<T>* minimum(RBTNode<T>* tree);        // 查找最大结点：返回tree为根结点的红黑树的最大结点。        RBTNode<T>* maximum(RBTNode<T>* tree);        // 左旋        void leftRotate(RBTNode<T>* &root, RBTNode<T>* x);        // 右旋        void rightRotate(RBTNode<T>* &root, RBTNode<T>* y);        // 插入函数        void insert(RBTNode<T>* &root, RBTNode<T>* node);        // 插入修正函数        void insertFixUp(RBTNode<T>* &root, RBTNode<T>* node);        // 删除函数        void remove(RBTNode<T>* &root, RBTNode<T> *node);        // 删除修正函数        void removeFixUp(RBTNode<T>* &root, RBTNode<T> *node, RBTNode<T> *parent);        // 销毁红黑树        void destroy(RBTNode<T>* &tree);        // 打印红黑树        void print(RBTNode<T>* tree, T key, int direction);#define rb_parent(r)   ((r)->parent)#define rb_color(r) ((r)->color)#define rb_is_red(r)   ((r)->color==RED)#define rb_is_black(r)  ((r)->color==BLACK)#define rb_set_black(r)  do { (r)->color = BLACK; } while (0)#define rb_set_red(r)  do { (r)->color = RED; } while (0)#define rb_set_parent(r,p)  do { (r)->parent = (p); } while (0)#define rb_set_color(r,c)  do { (r)->color = (c); } while (0)};/*  * 对红黑树的节点(x)进行左旋转 * * 左旋示意图(对节点x进行左旋)： *      px                              px *     /                               / *    x                               y                 *   /  \      --(左旋)-->           / \                # *  lx   y                          x  ry      *     /   \                       /  \ *    ly   ry                     lx  ly   * * */template <class T>void RBTree<T>::leftRotate(RBTNode<T>* &root, RBTNode<T>* x){    // 设置x的右孩子为y    RBTNode<T> *y = x->right;    // 将 “y的左孩子” 设为 “x的右孩子”；    // 如果y的左孩子非空，将 “x” 设为 “y的左孩子的父亲”    x->right = y->left;    if (y->left != NULL)        y->left->parent = x;    // 将 “x的父亲” 设为 “y的父亲”    y->parent = x->parent;    if (x->parent == NULL)    {        root = y;            // 如果 “x的父亲” 是空节点，则将y设为根节点    }    else    {        if (x->parent->left == x)            x->parent->left = y;    // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”        else            x->parent->right = y;    // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”    }    // 将 “x” 设为 “y的左孩子”    y->left = x;    // 将 “x的父节点” 设为 “y”    x->parent = y;}/*  * 对红黑树的节点(y)进行右旋转 * * 右旋示意图(对节点y进行左旋)： *            py                               py *           /                                / *          y                                x                   *         /  \      --(右旋)-->            /  \                     # *        x   ry                           lx   y   *       / \                                   / \                   # *      lx  rx                                rx  ry *  */template <class T>void RBTree<T>::rightRotate(RBTNode<T>* &root, RBTNode<T>* y){    // 设置x是当前节点的左孩子。    RBTNode<T> *x = y->left;    // 将 “x的右孩子” 设为 “y的左孩子”；    // 如果"x的右孩子"不为空的话，将 “y” 设为 “x的右孩子的父亲”    y->left = x->right;    if (x->right != NULL)        x->right->parent = y;    // 将 “y的父亲” 设为 “x的父亲”    x->parent = y->parent;    if (y->parent == NULL)     {        root = x;            // 如果 “y的父亲” 是空节点，则将x设为根节点    }    else    {        if (y == y->parent->right)            y->parent->right = x;    // 如果 y是它父节点的右孩子，则将x设为“y的父节点的右孩子”        else            y->parent->left = x;    // (y是它父节点的左孩子) 将x设为“x的父节点的左孩子”    }    // 将 “y” 设为 “x的右孩子”    x->right = y;    // 将 “y的父节点” 设为 “x”    y->parent = x;}/*  * 将结点插入到红黑树中 * * 参数说明： *     root 红黑树的根结点 *     node 插入的结点        // 对应《算法导论》中的node */template <class T>void RBTree<T>::insert(RBTNode<T>* &root, RBTNode<T>* node){    RBTNode<T> *y = NULL;    RBTNode<T> *x = root;    // 1. 将红黑树当作一颗二叉查找树，将节点添加到二叉查找树中。    while (x != NULL)    {        y = x;        if (node->key < x->key)            x = x->left;        else            x = x->right;    }    node->parent = y;    if (y!=NULL)    {        if (node->key < y->key)            y->left = node;        else            y->right = node;    }    else        root = node;    // 2. 设置节点的颜色为红色    node->color = RED;    // 3. 将它重新修正为一颗二叉查找树    insertFixUp(root, node);}/*  * 将结点(key为节点键值)插入到红黑树中 * * 参数说明： *     tree 红黑树的根结点 *     key 插入结点的键值 */template <class T>void RBTree<T>::insert(T key){    RBTNode<T> *z=NULL;    // 如果新建结点失败，则返回。    if ((z=new RBTNode<T>(key,BLACK,NULL,NULL,NULL)) == NULL)        return ;    insert(mRoot, z);}/* * 红黑树插入修正函数 * * 在向红黑树中插入节点之后(失去平衡)，再调用该函数； * 目的是将它重新塑造成一颗红黑树。 * * 参数说明： *     root 红黑树的根 *     node 插入的结点        // 对应《算法导论》中的z */template <class T>void RBTree<T>::insertFixUp(RBTNode<T>* &root, RBTNode<T>* node){    RBTNode<T> *parent, *gparent;    // 若“父节点存在，并且父节点的颜色是红色”    while ((parent = rb_parent(node)) && rb_is_red(parent))    {        gparent = rb_parent(parent);        //若“父节点”是“祖父节点的左孩子”        if (parent == gparent->left)        {            // Case 1条件：叔叔节点是红色            {                RBTNode<T> *uncle = gparent->right;                if (uncle && rb_is_red(uncle))                {                    rb_set_black(uncle);                    rb_set_black(parent);                    rb_set_red(gparent);                    node = gparent;                    continue;                }            }            // Case 2条件：叔叔是黑色，且当前节点是右孩子            if (parent->right == node)            {                RBTNode<T> *tmp;                leftRotate(root, parent);                tmp = parent;                parent = node;                node = tmp;            }            // Case 3条件：叔叔是黑色，且当前节点是左孩子。            rb_set_black(parent);            rb_set_red(gparent);            rightRotate(root, gparent);        }         else//若“z的父节点”是“z的祖父节点的右孩子”        {            // Case 1条件：叔叔节点是红色            {                RBTNode<T> *uncle = gparent->left;                if (uncle && rb_is_red(uncle))                {                    rb_set_black(uncle);                    rb_set_black(parent);                    rb_set_red(gparent);                    node = gparent;                    continue;                }            }            // Case 2条件：叔叔是黑色，且当前节点是左孩子            if (parent->left == node)            {                RBTNode<T> *tmp;                rightRotate(root, parent);                tmp = parent;                parent = node;                node = tmp;            }            // Case 3条件：叔叔是黑色，且当前节点是右孩子。            rb_set_black(parent);            rb_set_red(gparent);            leftRotate(root, gparent);        }    }    // 将根节点设为黑色    rb_set_black(root);}/*  * 删除结点(node)，并返回被删除的结点 * * 参数说明： *     root 红黑树的根结点 *     node 删除的结点 */template <class T>void RBTree<T>::remove(RBTNode<T>* &root, RBTNode<T> *node){    RBTNode<T> *child, *parent;    RBTColor color;    // 被删除节点的"左右孩子都不为空"的情况。    if ( (node->left!=NULL) && (node->right!=NULL) )     {        // 被删节点的后继节点。(称为"取代节点")        // 用它来取代"被删节点"的位置，然后再将"被删节点"去掉。        RBTNode<T> *replace = node;        // 获取后继节点        replace = replace->right;        while (replace->left != NULL)            replace = replace->left;        // "node节点"不是根节点(只有根节点不存在父节点)        if (rb_parent(node))        {            if (rb_parent(node)->left == node)                rb_parent(node)->left = replace;            else                rb_parent(node)->right = replace;        }         else             // "node节点"是根节点，更新根节点。            root = replace;        // child是"取代节点"的右孩子，也是需要"调整的节点"。        // "取代节点"肯定不存在左孩子！因为它是一个后继节点。        child = replace->right;        parent = rb_parent(replace);        // 保存"取代节点"的颜色        color = rb_color(replace);        // "被删除节点"是"它的后继节点的父节点"        if (parent == node)        {            parent = replace;        }         else        {            // child不为空            if (child)                rb_set_parent(child, parent);            parent->left = child;            replace->right = node->right;            rb_set_parent(node->right, replace);        }        replace->parent = node->parent;        replace->color = node->color;        replace->left = node->left;        node->left->parent = replace;        if (color == BLACK)            removeFixUp(root, child, parent);        delete node;        return ;    }    if (node->left !=NULL)        child = node->left;    else         child = node->right;    parent = node->parent;    // 保存"取代节点"的颜色    color = node->color;    if (child)        child->parent = parent;    // "node节点"不是根节点    if (parent)    {        if (parent->left == node)            parent->left = child;        else            parent->right = child;    }    else        root = child;    if (color == BLACK)        removeFixUp(root, child, parent);    delete node;}/*  * 删除红黑树中键值为key的节点 * * 参数说明： *     tree 红黑树的根结点 */template <class T>void RBTree<T>::remove(T key){    RBTNode<T> *node;     // 查找key对应的节点(node)，找到的话就删除该节点    if ((node = search(mRoot, key)) != NULL)        remove(mRoot, node);}/* * 红黑树删除修正函数 * * 在从红黑树中删除插入节点之后(红黑树失去平衡)，再调用该函数； * 目的是将它重新塑造成一颗红黑树。 * * 参数说明： *     root 红黑树的根 *     node 待修正的节点 */template <class T>void RBTree<T>::removeFixUp(RBTNode<T>* &root, RBTNode<T> *node, RBTNode<T> *parent){    RBTNode<T> *other;    while ((!node || rb_is_black(node)) && node != root)    {        if (parent->left == node)        {            other = parent->right;            if (rb_is_red(other))            {                // Case 1: x的兄弟w是红色的                  rb_set_black(other);                rb_set_red(parent);                leftRotate(root, parent);                other = parent->right;            }            if ((!other->left || rb_is_black(other->left)) &&                (!other->right || rb_is_black(other->right)))            {                // Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的                  rb_set_red(other);                node = parent;                parent = rb_parent(node);            }            else            {                if (!other->right || rb_is_black(other->right))                {                    // Case 3: x的兄弟w是黑色的，并且w的左孩子是红色，右孩子为黑色。                      rb_set_black(other->left);                    rb_set_red(other);                    rightRotate(root, other);                    other = parent->right;                }                // Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。                rb_set_color(other, rb_color(parent));                rb_set_black(parent);                rb_set_black(other->right);                leftRotate(root, parent);                node = root;                break;            }        }        else        {            other = parent->left;            if (rb_is_red(other))            {                // Case 1: x的兄弟w是红色的                  rb_set_black(other);                rb_set_red(parent);                rightRotate(root, parent);                other = parent->left;            }            if ((!other->left || rb_is_black(other->left)) &&                (!other->right || rb_is_black(other->right)))            {                // Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的                  rb_set_red(other);                node = parent;                parent = rb_parent(node);            }            else            {                if (!other->left || rb_is_black(other->left))                {                    // Case 3: x的兄弟w是黑色的，并且w的左孩子是红色，右孩子为黑色。                      rb_set_black(other->right);                    rb_set_red(other);                    leftRotate(root, other);                    other = parent->left;                }                // Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。                rb_set_color(other, rb_color(parent));                rb_set_black(parent);                rb_set_black(other->left);                rightRotate(root, parent);                node = root;                break;            }        }    }    if (node)        rb_set_black(node);}

•   容器set，multiset
    set/multiset以rb_tree为底层结构，因此有‘元素自动排序’特性。排序的依据是key，而set/multiset元素的key和value合一：key就是value。
    set/multiset提供“遍历”操作及iterators按正常规则（++ite）遍历，便能获得排序状态（sorted）。
    我们无法使用set/multiset的iterators改变元素值（因为key有其严谨的排列规则）。set/multiset的iterator是其底部的RB tree的const-iterator，就是为了禁止user对元素赋值。
    set元素的key必须独一无二，因此其insert（）用的是re_tree的insert_unique().multiset元素的key可以重复，因此其insert（）用的是rb_tree的insert_equal()。
    set的所有操作都是通过调用底层的红黑树进行操作。

---

•   容器map,multimap
    map/multimap以rb_tree为底层结构，因此有‘元素自动排序’特性。排序的依据是key。
    map/multimap提供“遍历”操作及iterators按正常规则（++ite）遍历，便能获得排序状态（sorted）。
    我们无法使用map/multimap的iterators改变元素的key（因为key有其严谨的排列规则），但可以用它来改变元素的data。因此map/multimap内部自动将user指定的key type设为const，如此便能禁止user对元素的key赋值。
    map的key必须是独一无二的，因此insert（）用的是rb_tree的insert_unique()。multimap元素的key可以重复，因此其insert（）用的是rb_tree的insert_equal().
    注意：容器map，独有的operator[]，但是multimap不可以使用[]进行insert操作。

---

• 容器hashtable
    我们可以使用hashtable iterators 改变元素的data，但不能改变元素的key（因为hashtable根据key实现严谨的元素排列）。到了C++11之后所有的hash开头的都变成了unordered。导致上层的set和map都换了名字，换成了容器unordered_set,unordered_multiset;和容器unordered_map,unordered_multimap,但是使用方法上与之前的都是一样的，只是换了一个名字而已。