RBTree红黑树

对平衡的要求低

二叉搜索树

性质：

1.每个节点不是红的就是黑的

2.根节点是黑的

3.若一个节点是红的，则它的两个子节点是黑的（即不能出现两个连续的红的）

4.每条路径的黑节点的数量相等

5.每个叶子节点都是黑的（叶子节点：NIL节点，空节点）

最长路径不超过最短路径的两倍

调整情况

cur是刚插入的节点

1.叔叔存在，且为红

根是红色的，可能会不满足RBTree树的规则（eg：出现连续的两个红色），所以还需要继续向上调整

2.叔叔不存在或者叔叔存在且为黑

然后接着第三种情况

3.

根是黑色的，不用再继续向上调整了

左旋

右旋

代码：

#include <iostream>
using namespace std;

enum color
{
                 RED,
                 BLACK
};

template<class K,class V>
struct RBTreeNode
{
                 K _key;
                 V _value;
                 RBTreeNode<K ,V>* _parent;
                 RBTreeNode<K ,V>* _left;
                 RBTreeNode<K ,V>* _right;
                 color _col;

                RBTreeNode( const K & key,const V& value)  //构造函数
                                :_key( key)
                                ,_value( value)
                                ,_parent( NULL)
                                ,_left( NULL)
                                ,_right( NULL)
                                ,_col( RED)  //节点默认颜色：红，因为不会影响插入
                {}
};

template<class K,class V>
class RBTree
{
                 typedef RBTreeNode <K,V> Node;

private:
                 Node* _root;
public:
                RBTree()  //构造函数
                                :_root( NULL)
                {}
                 bool Insert(const K& key,const V& value)
                {
                                 if(_root==NULL )
                                {
                                                _root= new Node (key,value);
                                }
                                 else
                                {
                                                 Node* cur=_root;
                                                 Node* parent=NULL ;

                                                 while(cur)
                                                {
                                                                parent=cur;
                                                               
                                                                 if(cur->_key>key )  //插左
                                                                {
                                                                                cur=cur->_left;
                                                                }
                                                                 else if (cur->_key<key)  //插右
                                                                {
                                                                                cur=cur->_right;
                                                                }
                                                                 else
                                                                {
                                                                                 return false ;
                                                                }
                                                }
                                                cur= new Node (key,value);
                                                 if(parent->_key>key )  //插左
                                                {
                                                                parent->_left=cur;
                                                }
                                                 else  //插右
                                                {
                                                                parent->_right=cur;
                                                }
                                                cur->_parent=parent;

                                                 //调整
                                                 while(cur!=_root && parent->_col==RED)  //parent为红，则包含着其父为黑
                                                {
                                                                 Node* grandfather=parent->_parent;

                                                                 if(grandfather->_left==parent)
                                                                {
                                                                                 Node* uncle=grandfather->_right;

                                                                                 if(uncle && uncle->_col==RED)  //调整情况1
                                                                                {
                                                                                                parent->_col= BLACK ;
                                                                                                uncle->_col= BLACK ;
                                                                                                grandfather->_col= RED ;

                                                                                                 //因为把根调整成了红色，可能会影响RBTree的规则，所以要继续上调
                                                                                                cur=grandfather;
                                                                                                parent=cur->_parent;
                                                                                }
                                                                                 else
                                                                                {
                                                                                                 //调整情况2，先变化成情况3
                                                                                                 if(cur==parent->_right)
                                                                                                {
                                                                                                                RotateL(parent);  //左旋
                                                                                                                swap(parent,cur);
                                                                                                }
                                                                                                 //调整情况3
                                                                                                parent->_col= BLACK ;
                                                                                                grandfather->_col= RED ;
                                                                                                RotateR(grandfather);  //右旋
                                                                                                 break;  //根是黑色的，不用再继续向上调整了
                                                                                }
                                                                }
                                                                 else  //grandfather->_right==parent，内容大体同上
                                                                {
                                                                                 Node* uncle=grandfather->_left;

                                                                                 if(uncle && uncle->_col==RED)  //调整情况1
                                                                                {
                                                                                                parent->_col= BLACK ;
                                                                                                uncle->_col= BLACK ;
                                                                                                grandfather->_col= RED ;

                                                                                                 //继续上调
                                                                                                cur=grandfather;
                                                                                                parent=cur->_parent;
                                                                                }
                                                                                 else
                                                                                {
                                                                                                 //调整情况2，先变化成情况3
                                                                                                 if(cur==parent->_left)
                                                                                                {
                                                                                                                RotateR(parent);  //右旋
                                                                                                                swap(parent,cur);
                                                                                                }
                                                                                                 //调整情况3
                                                                                                parent->_col= BLACK ;
                                                                                                grandfather->_col= RED ;
                                                                                                RotateL(grandfather);  //左旋
                                                                                                 break;  //根是黑色的，不用再继续向上调整了
                                                                                }
                                                                }
                                                }  //调整结束
                                }

                                _root->_col= BLACK;
                                 return true ;
                }
                 Node* Find(const K& key)
                 {
                              Node* cur=_root;

                              while(cur)
                              {
                                              if(cur->_key>key )
                                                              cur=cur->_left;
                                              else if (cur->_key<key)
                                                              cur=cur->_right;
                                              else  //cur->_key==key,find it!
                                                              return cur;
                              }
                              return NULL ;
                 }
                 bool Isbalance()
                 {
                              if(_root==NULL )
                                              return true ;
                              if(_root->_col==RED )
                                              return false ;

                              int k=0;  //计算黑节点的个数，作为一个基准值
                              Node* cur=_root;
                             
                              while(cur)
                              {
                                              if(cur->_col==BLACK )
                                                              k++;

                                              cur=cur->_left;
                              }

                              int count=0;
                              return _Isbalance(_root,k,count);
                 }
                 void InOrder()  //中序遍历输出
                 {
                              _InOrder(_root);
                                                                                                                  cout<<endl;
                 }
protected:
                 void RotateL(Node * parent)
                {
                                 Node* subR=parent ->_right;
                                 Node* subRL=subR->_left;

                                 parent->_right=subRL;
                                 if(subRL)
                                {
                                                subRL->_parent= parent ;
                                }
                                subR->_left= parent;

                                 Node* ppNode=parent ->_parent;
                                 parent->_parent=subR;
                                 if(ppNode==NULL )
                                {
                                                subR->_parent= NULL ;
                                                _root=subR;
                                }
                                 else
                                {
                                                 if(ppNode->_left==parent )
                                                                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;

                                 Node* ppNode=parent ->_parent;
                                 parent->_parent=subL;
                                 if(ppNode==NULL )
                                {
                                                subL->_parent= NULL ;
                                                _root=subL;
                                }
                                 else
                                {
                                                 if(ppNode->_left==parent )
                                                                ppNode->_left=subL;
                                                 else
                                                                ppNode->_right=subL;

                                                subL->_parent=ppNode;
                                }
                }
                 bool _Isbalance(Node * root,const int k,int count)
                 {
                              if(root ==NULL)
                                              return false ;
                              if(root ->_col==RED && root->_parent->_col==RED )  //连续的红节点
                              {
                                              cout<<"连续输出红节点" <<endl;
                                              return false ;
                              }
                              if(root ->_col==BLACK)
                                              count++;  //记录出现的黑节点的数
                              if(root ->_left==NULL && root->_right==NULL && k!=count)
                              {
                                              cout<<"黑色节点数不等" <<endl;
                                              return false ;
                              }

                              return _Isbalance(root ->_left,k,count)+_Isbalance( root->_right,k ,count);
                 }
                 void _InOrder(Node * root)
                 {
                              if(root ==NULL)
                                              return;

                              _InOrder( root->_left);
                              cout<< root->_key<<" " ;
                              _InOrder( root->_right);
                 }
};

void test()
{
                 RBTree<int ,int> rbt;
                 int a[]={27,20,30,18,25,28,40,23,35,29};

                 for(int i=0;i<sizeof(a)/ sizeof(a[0]);i++)
                {
                                rbt.Insert(a[i],i);
                }
                 rbt.InOrder();
                 rbt.Isbalance();
}

int main()
{
                test();
                system( "pause");
                 return 0;
}

结果：

本文出自 “追寻内心的声音” 博客，请务必保留此出处http://ljy789.blog.51cto.com/10697684/1829933