数据结构基础(23) --红黑树的设计与实现(中)

Insert完善

    根据规则4, 新增节点必须为红; 根据规则3, 新增节点之父节点必须为黑.

 

示例:

    (1)插入16(红色)/55(红色), 则既不用旋转, 也不用重新染色

    (2)插入82(红色), 则违反了红黑规则, 需要进行动态的调整;

 

红黑树所需的处理

1.单旋转

     新插入的X与其父P都是红色的, 而且X还是G的外部孙子;

 

2.双旋转

    新插入的X与其父P都是红色的, 而且X还是G的内部孙子;

 

3.还需要处理有两个红色孩子的节点, 将右儿子变成黑色的, 我们只允许左儿子是红色的;方法: 旋转+重新染色

 

insert完整实现代码:

[cpp] view plain copy

1. /**注意带有 ++ 注释的为新添加的代码**/  
2. template <typename Comparable>  
3. void RedBlackTree<Comparable>::insert(const Comparable &x)  
4. {  
5.     current = parent = grand = great = header;  
6.     nullNode->element = x;  
7.   
8.     while (current->element != x)  
9.     {  
10.         //让祖父成为曾祖父, 父亲成为祖父, 自己成为父亲  
11.         //每个人都长了一辈  
12.         great = grand;  
13.         grand = parent;  
14.         parent = current;  
15.   
16.         current = (x < current->element) ? current->left  
17.                   : current->right;  
18.   
19.         // ++  
20.         //+ 处理1. 如果current节点有两个红孩子  
21.         if ((current->left->color == RED) && (current->right->color == RED))  
22.             handleReorient( x );  
23.     }  
24.   
25.     //如果树中包含相同的元素  
26.     if (current != nullNode)  
27.         throw DuplicateItemException();  
28.   
29.     current = new Node(x, nullNode, nullNode);  
30.     if (x < parent->element)  
31.         parent->left = current;  
32.     else  
33.         parent->right = current;  
34.   
35.     // ++  
36.     //+ 处理2. 如果新插入的节点破坏了红黑规则, 则还需做一次处理  
37.     handleReorient( x );  
38. }  

[cpp] view plain copy

1. /**自动平衡函数: 
2.     [1]重新染色 
3.     [2]自动旋转 
4. */  
5. template <typename Comparable>  
6. void RedBlackTree<Comparable>::handleReorient(const Comparable & item)  
7. {  
8.     // 将current节点染成红色  
9.     current->color = RED;  
10.     // 将current的left和right节点染成黑色  
11.     current->left->color = current->right->color = BLACK;  
12.   
13.     // 如果current节点的父节点也是红的 -> 单旋转 or 双旋转  
14.     if( parent->color == RED )  
15.     {  
16.         //则将其祖父(爷爷)的颜色染成红色  
17.         grand->color = RED;  
18.   
19.         //然后判断新插入的节点是否是内部孙子?  
20.         //如果是, 则增加一次旋转->构成双旋转  
21.   
22.         //if注释: 如果该节点小于爷爷, 小于爸爸, 这两种情况不同时满足  
23.         //则说明其是爷爷的内孙子  
24.         if( (item < grand->element) != (item < parent->element) )  
25.         {  
26.             // 则依grand(祖父)节点进行旋转  
27.             parent = rotate( item, grand );  // Start double rotate  
28.         }  
29.         // 则依great(曾祖父)节点进行旋转  
30.         current = rotate( item, great );  
31.   
32.         //令当前节点为黑色  
33.         current->color = BLACK;  
34.     }  
35.   
36.     //根节点必须是黑色的  
37.     header->right->color = BLACK; // Make root black  
38. }  

[cpp] view plain copy

1. // 自动判断并进行旋转函数  
2. template <typename Comparable>  
3. typename RedBlackTree<Comparable>::Node *  
4. RedBlackTree<Comparable>::rotate(const Comparable &item,  
5.                                  Node *theParent )  
6. {  
7.     //位于theParent的左子树  
8.     if( item < theParent->element )  
9.     {  
10.         //如果为真, 则说明theParent->left有左孩子,  
11.         //否则, 有右孩子  
12.         item < theParent->left->element ?  
13.         //如果theParent左边有一棵子树, 则以theParent->left  
14.         //为轴, 向右转  
15.         rotateWithLeftChild( theParent->left )  :  // LL  
16.         //如果theParent右边有一棵子树, 则以theParent->left  
17.         //为轴, 向左转  
18.         rotateWithRightChild( theParent->left ) ;  // LR  
19.   
20.         return theParent->left;     //返回左子树  
21.     }  
22.     else    //位于右子树  
23.     {  
24.         //如果为真, 则说明theParent->right有左孩子,往右转  
25.         //否则, 有右孩子, 往左转  
26.         item < theParent->right->element ?  
27.         rotateWithLeftChild( theParent->right ) :  // RL  
28.         rotateWithRightChild( theParent->right );  // RR  
29.   
30.         return theParent->right;    //返回右子树  
31.     }  
32. }  

测试代码:

[cpp] view plain copy

1. int main()  
2. {  
3.     //用NEG_INF来代表负无穷大  
4.     const int NEG_INF = -999999;  
5.     RedBlackTree<int> tree(NEG_INF);  
6.   
7.     tree.insert(50);  
8.     cout << tree.header->right->element << " " << tree.header->right->nodeColor() << endl;  
9.     cout << endl;  
10.     tree.insert(40);  
11.     cout << tree.header->right->left->element << " " << tree.header->right->left->nodeColor() << endl << endl;  
12.   
13.     //此时需要进行旋转和重新染色  
14.     tree.insert(30);  
15.     cout << tree.header->right->element << " " << tree.header->right->nodeColor() << endl ;  
16.     cout << tree.header->right->left->element << " " << tree.header->right->left->nodeColor() << endl;  
17.     cout << tree.header->right->right->element << " " << tree.header->right->right->nodeColor() << endl;  
18.   
19.     return 0;  
20. }  

[cpp] view plain copy

1. //由于需要用到nodeColor成员函数, 因此我们将RedBlackNode类改造如下:  
2. template <typename Comparable>  
3. class RedBlackNode  
4. {  
5.     friend class RedBlackTree<Comparable>;  
6. public:  
7.     RedBlackNode(const Comparable &theElement = Comparable(),  
8.                  RedBlackNode *theLeft = NULL,  
9.                  RedBlackNode *theRight = NULL,  
10.                  int theColor = RedBlackTree<Comparable>::BLACK)  
11.         : element(theElement), left(theLeft), right(theRight), color(theColor) {}  
12.   
13. public:  
14.     //返回当前节点的颜色, 以作测试  
15.     std::string nodeColor() const  
16.     {  
17.         return (color == RedBlackTree<Comparable>::BLACK) ? "black" : "red";  
18.     }  
19.   
20. public:  
21.     Comparable element;  
22.     RedBlackNode *left;  
23.     RedBlackNode *right;  
24.     int color;  
25. };  

红黑树其他操作

[cpp] view plain copy

1. template <typename Comparable>  
2. class RedBlackTree  
3. {  
4.     ...  
5.     bool isEmpty() const;  
6.     void makeEmpty();  
7.   
8.     Gref<Comparable> find(const Comparable & x) const;  
9.     Gref<Comparable> findMin() const;  
10.     Gref<Comparable> findMax() const;  
11.   
12.     //递归删除所有节点  
13.     void reclainMemory(Node *t) const;  
14.     ...  
15. };  

[cpp] view plain copy

1. //析构函数完善版本  
2. template <typename Comparable>  
3. RedBlackTree<Comparable>::~RedBlackTree()  
4. {  
5.     if (!isEmpty())  
6.         makeEmpty();  
7.   
8.     delete nullNode;  
9.     delete header;  
10. }  

[cpp] view plain copy

1. //红黑树查找:与二叉查找树类似  
2. template <typename Comparable>  
3. Gref<Comparable> RedBlackTree<Comparable>::find(const Comparable &x) const  
4. {  
5.     if (isEmpty())  
6.         return Gref<Comparable>();  
7.   
8.     nullNode->element = x;  
9.     Node *iter = header->right;  
10.   
11.     while (true)  
12.     {  
13.         if (x < iter->element)  
14.             iter = iter->left;  
15.         else if (x > iter->element)  
16.             iter = iter->right;  
17.   
18.         //如果 x == iter->element  
19.         else if (iter != nullNode)  
20.             return Gref<Comparable>(iter->element) ;  
21.         else  
22.             return Gref<Comparable>();  
23.     }  
24. }  

[cpp] view plain copy

1. //查找最大值: 一路向右  
2. template <typename Comparable>  
3. Gref<Comparable> RedBlackTree<Comparable>::findMax() const  
4. {  
5.     if (isEmpty())  
6.         return Gref<Comparable>();  
7.   
8.     Node *iter = header->right;  
9.     while (iter->right != nullNode)  
10.     {  
11.         // 一直向右走  
12.         iter = iter->right;  
13.     }  
14.   
15.     return Gref<Comparable>(iter->element);  
16. }  

[cpp] view plain copy

1. //查找最小值: 一路向左  
2. template <typename Comparable>  
3. Gref<Comparable> RedBlackTree<Comparable>::findMin() const  
4. {  
5.     if (isEmpty())  
6.         return Gref<Comparable>();  
7.   
8.     Node *iter = header->right;  
9.     while (iter->left != nullNode)  
10.     {  
11.         // 一直向左走  
12.         iter = iter->left;  
13.     }  
14.   
15.     return Gref<Comparable>(iter->element);  
16. }  

[cpp] view plain copy

1. template <typename Comparable>  
2. bool RedBlackTree<Comparable>::isEmpty() const  
3. {  
4.     if (header->right == nullNode)  
5.         return true;  
6.     return false;  
7. }  
8.   
9. template <typename Comparable>  
10. void RedBlackTree<Comparable>::makeEmpty()  
11. {  
12.     reclainMemory(header->right);  
13.     header->right = nullNode;  
14. }  
15.   
16. template <typename Comparable>  
17. void RedBlackTree<Comparable>::reclainMemory(Node *t) const  
18. {  
19.     //t == t->left的时候, 是当t==nullNode时  
20.     if (t != t->left)  
21.     {  
22.         reclainMemory(t->left);  
23.         reclainMemory(t->right);  
24.         delete t;  
25.     }  
26. }  

Gref设计与实现

[cpp] view plain copy

1. //一个包装器: 将指针封装成为引用  
2. template <typename Object>  
3. class Gref  
4. {  
5. public:  
6.     Gref(): obj(NULL) {}  
7.     explicit Gref(const Object &x)  
8.         : obj(& x) {}  
9.   
10.     const Object &get() const  
11.     {  
12.         if (isNull())  
13.             throw NullPointerException();  
14.         else  
15.             return * obj;  
16.     }  
17.   
18.     bool isNull() const  
19.     {  
20.         if (obj == NULL)  
21.             return true;  
22.         return false;  
23.     }  
24.   
25. private:  
26.     const Object * obj;  
27. }; 
    

原文地址：http://blog.csdn.net/zjf280441589/article/details/43865449