RBTree（红黑树）

                                                                                 红黑树

红黑树（Red Black Tree）和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡。

红黑树是一颗二叉搜索树，它的每一个节点增加了一个存储位用来表示颜色，可以是Red也可以是Black，通过对任意一条根到叶子节点的颜色来约束，红黑树保证最长路径是最短路径的两倍，因此近似平衡；

红黑树的性质：

1：每个节点不是红色就是黑色

2：根节点是黑色

3：如果一个节点时红，则它两个子节点是黑色的（没有连续的红色）

4：对每个节点，从该节点到其后代的所有叶子节点的简单路径，均有相同数目的黑节点（每条路径的黑色节点色数目相同）

两者的差别：AVL树是完全平衡树，更接近满二叉树，因此它的时间复杂度是O(lgN),在二叉树插入删除时旋转多，维护起来比较麻烦，但相比更直观。而RBT树是近似平衡树，时间复杂度是2O(log n)，旋转较少，相对维护起来比较简单，但是相比更抽象。相对来说运用最多的还是RBTree。

红黑树的应用： 在C++ STL中，很多部分都运用了红黑树包括：Linux内核，java  c#  还有(包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)等等。

下面就是节点的颜色转换以及旋转的情况：

在此只展示了parent为孩子的情况，parent为右孩子情况类似。

具体实现源码如下：

#include <math.h>#include <iostream>using namespace std;enum colour{     BLACK,     RED,};template<class K, class V>struct RBTreeNode{    K _key;    V _val;    colour _col;    RBTreeNode<K, V>* _left;    RBTreeNode<K, V>*  _right;    RBTreeNode<K, V>*  _parent;    int _bf;    RBTreeNode(const K& key, const V& value)         :_left(NULL)         , _right(NULL)         , _parent(NULL)         , _key(key)         , _val(value)         , _bf(0)         , _col(RED)    {}};template<class K, class V>class RBTree{    typedef RBTreeNode<K, V>   Node;public:    RBTree()         :_root(NULL)    {}    ~RBTree()    {}    bool Insert(const K& key, const V& value)    {         if (_root == NULL)         {             _root = new Node(key, value);             _root->_col = BLACK;             return true;         }         Node* parent = NULL;         Node* cur = _root;         while (cur)         {             if (cur->_key < key)//右边              {                 parent = cur;                 cur = cur->_right;             }             else if (cur->_key>key)//左边              {                 parent = cur;                 cur = cur->_left;             }             else             {                 return false;//不存在              }         }         cur = new Node(key, value);         if (key > parent->_key)         {             parent->_right = cur;             cur->_parent = parent;         }         else         {             parent->_left = cur;             cur->_parent = parent;         }         while (parent && parent->_col==RED)         {             Node* grandparent = parent->_parent;             if (grandparent->_left==parent)  //父亲在左边             {                 Node* uncle = grandparent->_right;                 if (uncle&&uncle->_col==RED)                 {                      parent->_col = BLACK;                      uncle->_col = BLACK;                      grandparent->_col = RED;                      cur = grandparent;         //向上调整                      parent = cur->_parent;       //                 }                 else   //叔叔不存在或者叔叔为黑，需要旋转                 {                if (cur==parent->_right)                    {                      RotateL(parent);                      swap(parent,cur);                    }                      RotateR(grandparent);                      parent->_col = BLACK;                      grandparent->_col = RED;                      break;                 }             }             else    //parent = grandparent->_right;             {                 Node* uncle = grandparent->_left;                 if (uncle&&uncle->_col == RED)                 {                      parent->_col = BLACK;                      uncle->_col = BLACK;                      grandparent->_col = RED;                      cur = grandparent;         //向上调整                      parent = cur->_parent;         //                 }                 else   //叔叔不存在或者叔叔为黑，需要旋转                 {                      if (cur == parent->_left)                          {                          RotateR(parent);                          swap(parent, cur);   // 若cur在parent的左，cur->_key < parent->_key,旋转后必须交换才符合_key值得排布规则。                      }                      RotateL(grandparent);                      parent->_col = BLACK;                      grandparent->_col = RED;                 }             }         }     _root->_col = BLACK;         return true;    }    bool  Isbalance()    {         if (_root==NULL)         {             return true;         }         if (_root->_col==RED)         {             return false;         }         int Blacknum = 0;         Node* left = _root;         while (left)     //遍历任意一边，计算出黑色节点的个数，作为一个基准，将此数与其他路上的书做较，只要不相等就可以说明此树不是平衡红黑树         {             if (left->_col==BLACK)             {                 Blacknum++;             }             left = left->_left;          }         int num = 0;         return _IsBalance(_root, Blacknum, num);    }    bool _IsBalance(Node* root, const int Blacknum, int num)    {         if (root == NULL)         {             if (num != Blacknum)             {             cout << "黑节点个数不等" << endl;                 return false;             }             else             {                 return true;             }         }         if (root->_col == BLACK)         {             num++;         }         if ((root->_col == RED) && (root->_parent->_col == RED))         {             cout << root->_key << "  " << root->_parent->_key << "  " << endl;             return false;         }         return _IsBalance(root->_left, Blacknum, num) && _IsBalance(root->_right, Blacknum, num);    }    void RotateL(Node* parent)// 左单旋    {         Node* subR = parent->_right;         Node* subRL = subR->_left;         parent->_right = subRL;         if (subRL)     //开始旋转             {             subRL->_parent = parent;         }   //         subR->_left = parent;         subR->_parent = parent->_parent;         Node* ppnode = parent->_parent;         parent->_parent = subR;/////////////////         if (ppnode == NULL)         {             _root = subR;             subR->_parent = NULL;         }         else if (parent == ppnode->_left)         {             ppnode->_left = subR;         }         else         {             ppnode->_right = subR;         }         subR->_parent = ppnode;    }    void RotateR(Node* parent)    {    Node* subL = parent->_left;    Node* subLR = subL->_right;    parent->_left = subLR;    if (subLR)    {    subLR->_parent = parent;    }    subL->_right = parent;    subL->_parent = parent->_parent;    Node* ppnode = parent->_parent;    parent->_parent = subL;    if (ppnode == NULL)    {    _root = subL;    subL->_parent = NULL;    }    else if (ppnode->_left == parent)    {    ppnode->_left = subL;    }    else    {    ppnode->_right = subL;    }    subL->_parent = ppnode;    }    void InOrder()    {         _InOrder(_root);         cout << endl;    }protected:    void _InOrder(Node* root)    {         if (root == NULL)         {             return;         }         _InOrder(root->_left);         cout << root->_key << " ";         _InOrder(root->_right);    }private:    Node* _root;};void Test(){    int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };    //int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };    //int a[] = {2,3,1,4,5};    //int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };    RBTree<int, int> t;    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); i++)    {         //t.Insert(a[i], i);         t.Insert(a[i],i);    cout << t.Isbalance()<< endl;    }    t.InOrder();}