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

最新推荐文章于 2023-11-13 19:45:52 发布
最新推荐文章于 2023-11-13 19:45:52 发布
阅读量633 收藏 1
点赞数
分类专栏： 算法与数据结构 文章标签： 红黑树 RBtree 二叉查找树 数据结构 设计

红黑树是一种自平衡的二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组(C++ STL 中的map/set)。它是在1972年由Rudolf Bayer发明的，他称之为"对称二叉B树"，它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的。红黑树虽然很复杂，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目(来源:百度百科)。

 

算法导论对R-B Tree的介绍：

红黑树，一种二叉查找树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的。

 

由于红黑树也是一颗二叉查找树, 因此红黑树也满足二叉查找树的一般性质(关于二叉查找树的一般性质请参考博客:http://blog.csdn.net/zjf280441589/article/details/42611161)

但由于普通的二叉查找树不具备自动平衡的功能, 因此普通的二叉查找树树很有可能会退化成为一条链表, 若二叉树退化成了一棵具有n个结点的线性链后，则插入/删除/查找操作最坏情况运行时间就变为了O（n）。

因此就有了红黑树, 他的最终查找、插入、删除的时间复杂度最坏情况下依然为O（logn）, 而红黑树之所以这么牛的原因就是它在二叉查找树的基础上增加了着色和相关的性质, 这就是红黑规则:


红黑规则

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

   2.根总是黑色的;

   3.如果节点是红色的, 则它的子节点必须是黑色的;

   4.从根到叶节点的每条路径, 必须包含相同数目的黑色节点(黑高度相同);

   5.每个叶结点（叶结点即指树尾端NIL指针或NULL结点）是黑的;


  根据规则4, 新增节点必须为红; 

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

  当新节点根据二叉树的规则到达插入点, 却未能符合上述红黑规则时, 就必须调整颜色并旋转树形;

 

红黑结点

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. template <typename Type>  
  2. class RedBlackNode  
  3. {  
  4.     friend RedBlackTree<Type>;  
  5. private:  
  6.     RedBlackNode(const Type &_element = Type(),  
  7.                  RedBlackNode *_left = NULL,  
  8.                  RedBlackNode *_right = NULL,  
  9.                  int _color = RedBlackTree<Type>::BLACK)  
  10.         : element(_element), left(_left), right(_right), color(_color) {}  
  11.   
  12. private:  
  13. //为了在红黑树尚未完成的时候进行测试  
  14. //故将之作为public, 待红黑树完成之时,  
  15. //就是将其改为private之时;  
  16. public:  
  17.     Type            element;   //节点值  
  18.     RedBlackNode    *left;  
  19.     RedBlackNode    *right;  
  20.     //红黑树的颜色  
  21.     int             color;  
  22. };  

红黑树

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. template <typename Type>  
  2. class RedBlackTree  
  3. {  
  4. public:  
  5.     //为结点定义别名  
  6.     typedef RedBlackNode<Type> Node;  
  7.   
  8.     enum {RED, BLACK};  
  9.   
  10. public:  
  11.     //此时红黑树所支持的操作尚不完善,  
  12.     //而且函数功能(如析构函数, insert操作)  
  13.     //实现的也并不理想,  
  14.     //但随着红黑树代码的不断演进,  
  15.     //这些代码会不断的完善  
  16.     RedBlackTree(const Type &negInf);  
  17.     ~RedBlackTree();  
  18.   
  19.     void insert(const Type &data);  
  20.   
  21. private:  
  22. //为了在红黑树尚未完成的时候进行测试  
  23. //故将之作为public, 待红黑树完成之时,  
  24. //就是将其改为private之时;  
  25. public:  
  26.     //指向红黑树的头(伪根节点)  
  27.     //RedBlackNode<Type> *header;  
  28.     Node *header;  
  29.     //空节点  
  30.     Node *nullNode;  
  31.   
  32.     //在插入过程中需要的指针  
  33.     Node *current;  //当前节点  
  34.     Node *parent;   //父节点  
  35.     Node *grand;    //祖父节点(爷爷)  
  36.     Node *great;    //曾祖父节点(爷爷的爸爸)  
  37.   
  38.     /* 单旋转 */  
  39.     //带着左孩子旋转: 向右旋转  
  40.     void rotateWithLeftChild(Node *& k2) const;  
  41.     //带着有孩子旋转: 向左旋转  
  42.     void rotateWithRightChild(Node *& k1) const;  
  43.   
  44.     /* 双旋转 */  
  45.     //向右转  
  46.     void doubleRotateWithLeftChild(Node *& k3) const;  
  47.     //向左转  
  48.     void doubleRotateWithRightChild(Node *& k1) const;  
  49. };  

构造与析构

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. //构造函数  
  2. template <typename Type>  
  3. RedBlackTree<Type>::RedBlackTree(const Type &negInf)  
  4. {  
  5.     nullNode = new Node();  
  6.     header = new Node(negInf, nullNode, nullNode);  
  7. }  
  8. //这一版的析构函数实现并不完善,在后续的版本我们会继续完善该析构函数  
  9. template <typename Type>  
  10. RedBlackTree<Type>::~RedBlackTree()  
  11. {  
  12.     delete nullNode;  
  13.     delete header;  
  14. }  

一个二叉查找树的insert

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. //这时的insert其实就是一个普通的  
  2. //二叉查找树的insert, 完全没要照顾到  
  3. //二叉树的平衡, 以及红黑规则的实现  
  4. template <typename Type>  
  5. void RedBlackTree<Type>::insert(const Type &data)  
  6. {  
  7.     great = grand = parent = current = header;  
  8.     //在此处令nullNode成为data, 以作哨兵  
  9.     nullNode->element = data;  
  10.   
  11.     while (current->element != data)  
  12.     {  
  13.         //让祖父成为曾祖父, 父亲成为祖父, 自己成为父亲  
  14.         //每个人都长了一辈  
  15.         great = grand;  
  16.         grand = parent;  
  17.         parent = current;  
  18.   
  19.         current = (data < current->element) ? current->left  
  20.                   : current->right;  
  21.     }  
  22.   
  23.     //如果树中包含相同的元素  
  24.     if (current != nullNode)  
  25.         throw DuplicateItemException();  
  26.   
  27.     current = new Node(data, nullNode, nullNode);  
  28.     if (data < parent->element)  
  29.         parent->left = current;  
  30.     else  
  31.         parent->right = current;  
  32.     //在后续的版本上,需要加上自动平衡(即实现红黑规则) -> 红黑树  
  33. }  

单旋转

注意:内侧孙子节点横向移动(注意下图结点37);

 

左(单)旋:

 

当在某个结点k1上，做左旋操作时，我们假设它的右孩子k2不是NIL[T](k1可以是任何不是NIL[T]的左孩子结点); 左旋以k1到k2之间的链为“支轴”进行，它使k2成为该子树新的根，而k2的左孩子B则成为k1的右孩子。 

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. //实现  
  2. //向左转  
  3. template <typename Type>  
  4. void RedBlackTree<Type>::rotateWithRightChild(Node *& k1) const  
  5. {  
  6.     Node *k2 = k1->right;  
  7.     //结点B横向移动  
  8.     k1->right = k2->left;  
  9.   
  10.     //令k2提领k1  
  11.     k2->left = k1;  
  12.     //令k2为根(使k2替代k1的位置)  
  13.     k1 = k2;  
  14. }  

右(单)旋:

 

    过程与左旋类似;

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. //实现  
  2. //向右转  
  3. template <typename Type>  
  4. void RedBlackTree<Type>::rotateWithLeftChild(Node *& k2) const  
  5. {  
  6.     //首先将B横向移动  
  7.     Node *k1 = k2->left;  
  8.     k2->left = k1->right;  
  9.   
  10.     //令k1提领k2  
  11.     k1->right = k2;  
  12.     //令k1为根(使k1替代k2的位置)  
  13.     k2 = k1;  
  14. }  

测试(在完成单旋转之后):

 

    (构造一颗二叉查找树树如图所示, 左边为尚未旋转之前, 右为旋转之后)

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. //测试代码如下:  
  2. int main()  
  3. {  
  4.     //用NEG_INF来代表负无穷大  
  5.     const int NEG_INF = -999999;  
  6.     RedBlackTree<int> tree(NEG_INF);  
  7.   
  8.     //单旋转时候的测试数据  
  9.     tree.insert(30);  
  10.     tree.insert(15);  
  11.     tree.insert(70);  
  12.     tree.insert(20);  
  13.   
  14.     cout << tree.header->right->element << endl;  
  15.     cout << tree.header->right->left->element << endl;  
  16.     cout << tree.header->right->right->element << endl;  
  17.     cout << tree.header->right->left->right->element << endl;   //20  
  18.   
  19.     //向右旋转  
  20.     cout << "向右旋转" << endl;  
  21.     tree.rotateWithLeftChild(tree.header->right);  
  22.     cout << tree.header->right->element << endl;    //15  
  23.     cout << tree.header->right->right->element << endl; //30  
  24.     cout << tree.header->right->right->left->element << endl;   //20  
  25.     cout << tree.header->right->right->right->element << endl;   //70  
  26.   
  27.     //然后再向左转(又转了回来)  
  28.     cout << "向左旋转" << endl;  
  29.     tree.rotateWithRightChild(tree.header->right);  
  30.     cout << tree.header->right->element << endl;  
  31.     cout << tree.header->right->left->element << endl;  
  32.     cout << tree.header->right->right->element << endl;  
  33.     cout << tree.header->right->left->right->element << endl;   //20  
  34. }  

双旋转

单旋转有时会出现一个问题(如下图所示):


    (如果内侧子孙节点[k1]过深, 则将其单向移动是不会解决问题的)

 

于是就有了双旋转

向右双旋转:

   1.首先以k1为轴, k1与k2向左旋转;

   2.然后以k3为轴, k3与旋转之后的k1向右旋转;

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. //实现  
  2. //向右双旋转  
  3. template <typename Type>  
  4. void RedBlackTree<Type>::doubleRotateWithLeftChild(Node *& k3) const  
  5. {  
  6.     //首先将其左儿子(k1)向左单旋转  
  7.     rotateWithRightChild(k3->left);  
  8.   
  9.     //然后将自己(k3)向右单旋转  
  10.     rotateWithLeftChild(k3);  
  11. }  

向左双旋转:

   1.首先以k3为轴, k2与k3向右旋转;

   2.然后以k1为轴, k1与旋转之后的k2向左旋转;

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. //实现  
  2. //向左双旋转  
  3. template <typename Type>  
  4. void RedBlackTree<Type>::doubleRotateWithRightChild(Node *& k1) const  
  5. {  
  6.     //首先将其右儿子(k2)向右单旋转  
  7.     rotateWithLeftChild(k1->right);  
  8.   
  9.     //然后将自己(k1)向左单旋转  
  10.     rotateWithRightChild(k1);  
  11. }  
  12. //注:其实红黑树中并没有用到双旋转, 而是自己实现了一个rotate操作,   
  13. //在此只为了学习双旋转的理论;  


测试(在完成双旋转之后):


(构造一颗二叉查找树树如图所示, 左边为尚未旋转之前, 右为旋转之后, 以8为轴进行双旋转)


[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. int main()  
  2. {  
  3.     //用NEG_INF来代表负无穷大  
  4.     const int NEG_INF = -999999;  
  5.     RedBlackTree<int> tree(NEG_INF);  
  6.   
  7. //双旋转时的测试数据  
  8.     tree.insert(12);  
  9.     tree.insert(16);  
  10.     tree.insert(8);  
  11.     tree.insert(10);  
  12.     tree.insert(4);  
  13.     tree.insert(14);  
  14.     tree.insert(2);  
  15.     tree.insert(6);  
  16.     tree.insert(5);  
  17.     cout << tree.header->right->element << endl;    //12  
  18.     cout << tree.header->right->left->element << endl;  //8  
  19.     cout << tree.header->right->right->element << endl; //16  
  20.   
  21.     cout << tree.header->right->left->left->element << endl;    //4  
  22.     cout << tree.header->right->left->right->element << endl;   //10  
  23.     cout << tree.header->right->right->left->element << endl;   //14  
  24. //  cout << tree.header->right->left->right->left->element << endl;   //5曾经做过哨兵  
  25. //  cout << tree.header->right->left->right->right->element << endl;  //5  
  26.   
  27.     cout << tree.header->right->left->left->left->element << endl;  //2  
  28.     cout << tree.header->right->left->left->right->element << endl; //6  
  29.   
  30.     cout << tree.header->right->left->left->right->left->element << endl;   //5  
  31.   
  32.   
  33.     cout << "\n向右双旋转" << endl;  
  34.     //以8为基准向右双旋转  
  35.     tree.doubleRotateWithLeftChild(tree.header->right->left);  
  36.     cout << tree.header->right->element << endl;    //12  
  37.     cout << tree.header->right->left->element << endl;  //6  
  38.     cout << tree.header->right->right->element << endl; //16  
  39.   
  40.     cout << tree.header->right->left->left->element << endl;    //4  
  41.     cout << tree.header->right->left->right->element << endl;   //8  
  42.     cout << tree.header->right->right->left->element << endl; //14  
  43.   
  44.     cout << tree.header->right->left->left->left->element << endl;  //2  
  45.     cout << tree.header->right->left->left->right->element << endl;  //5  
  46.     cout << tree.header->right->left->right->right->element << endl;    //10  
  47. }  

实现红黑树用到的异常

[cpp] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. class DSException  
  2. {  
  3. public:  
  4.     DSException(const string &_message = string())  
  5.         : message(_message) {}  
  6.     ~DSException() {}  
  7.   
  8.     virtual string what() const  
  9.     {  
  10.         return message;  
  11.     }  
  12.     virtual string toString() const  
  13.     {  
  14.         return "Exception: " + what();  
  15.     }  
  16.   
  17. private:  
  18.     std::string message;  
  19. };  
  20.   
  21. class DuplicateItemException : public DSException  
  22. {  
  23. public:  
  24.     DuplicateItemException(const string &_msg = string())  
  25.         : DSException(_msg) {}  
  26. };  



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

SpringWar
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构课程设计-基于Qt实现的个人通讯录系统及红黑树的实现.zip
09-29
3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可直接用于毕设、课设、作业等。 适用工作项目、毕业设计，课程设计，项目源码均经过助教老师测试，运行无误，轻松复刻，欢迎下载 -------- 下载后...
红黑数实现
wchoclate的专栏
02-11 775
红黑树的实现，目前只有代码部分，后续会对代码进行完善，并对红黑的原理记性详解。
红黑树代码实现过程详解
weixin_43354959的博客
10-19 650
1.1 颜色使用Boolen定义 1.2 每一个节点有值、父节点、左右节点、颜色等属性 1.3 构造方法和toSting方法 tostring方法用于显示树结构显示的字符串 二.树打印类，用于验证树结构是否正确 目标效果： 打印树结构，我们使用二维数组来组成全空格的画板，将树结构写入二维数组的相应位置中显示出来 2.1 获取树高度 获取树高度用于确定二维数组的高度 2.2 写二维数组 这个方法是递归方法，将每个节点写入二维数组，从树的根节点开始执行，递归执行到每一个节点。 rowIndex是节点要写入的
数据结构拾遗(1) --红黑树的设计与实现(上)
weixin_30835649的博客
02-17 115
红黑树是一种自平衡的二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组(C++STL中的map/set)。它是在1972年由RudolfBayer发明的，他称之为"对称二叉B树"，它现代的名字是在LeoJ.Guibas和RobertSedgewick于1978年写的一篇论文中获得的。红黑树虽然很复杂，但它的操作有着良好的最坏情况运行时间，并且在实践中...
数据结构——红黑树
stromSLR的博客
03-06 4494
数据结构——红黑树 前言 红黑树是map，set，mutilmap，mutilset容器的底层数据结构，也是一种非常重要的数据结构，它在效率上对AVL又做了进一步的优化，因为AVL结构在插入，或删除时，无法避免大量的旋转操作，导致效率有所损耗，但是红黑树，就在这一点有了更好的优化，但是牺牲了平衡性，所以是不是一个完全平衡的二叉搜索树。 一、红黑树的概念和性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色
基于Qt实现的个人通讯录系统及红黑树的实现源码（数据结构课程设计）.zip
最新发布
01-09
1、该资源内项目代码经过严格调试，下载即用确保可以运行！ 2、该资源适合计算机相关专业(如计科、人工智能、大数据、数学、电子信息等)正在...基于Qt实现的个人通讯录系统及红黑树的实现源码（数据结构课程设计）.zip
Linux操作系统大作业，通过数据结构实现B+树，红黑树，堆排序等操作+源代码+文档说明+实验报告
01-08
Linux操作系统大作业，通过数据结构实现B+树，红黑树，堆排序等操作+源代码+文档说明+实验报告 - 小白不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的课程设计，代码都测试ok，都是运行成功后才...
数据结构课程设计：基于Qt实现的个人通讯录系统及红黑树的实现.zip
10-30
1、该资源内项目代码都经过测试...3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 -------- 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。
linux程序实验报告，数据结构（红黑树、堆、栈、二叉搜索树、队列、链表、图）的c代码实现+源代码+文档说明+实验报告
01-08
linux程序实验报告，数据结构（红黑树、堆、栈、二叉搜索树、队列、链表、图）的c代码实现+源代码+文档说明+实验报告 - 小白不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的课程设计，代码都测试...
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 17万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
数据结构（高阶）—— 红黑树
M的博客
11-26 2825
红黑树，是一种二叉搜索树，但在每个结点上增加了一个存储位表示结点的颜色，可以使Red或Black。通过对任何一条从根到叶子的路劲上各个结点着色的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而近似平衡的。对于每个结点，从该结点到其所有后代叶子结点的简单路径上，均包含相同数目的黑色结点。如果一个结点是红色的，则它的两个孩子结点是黑色的。每条路径上的黑色结点数量相同。每个结点不是红色就是黑色。此处的叶子结点指定是空结点。
算法基础: 什么是红黑树?
微不足道的博客
02-19 969
介绍红黑树
数据结构之红黑树（RBTree）
Tlzns的博客
11-13 156
数据结构之红黑树（RBTree）
数据结构：红黑树
让我思考一下
06-02 803
红黑树 红黑树是一种自平衡二叉查找树，可以在O(log(n))O(log(n))O(log(n))时间内完成查找、插入和删除。相对于AVL树来说，牺牲了部分平衡性以换取插入/删除操作时少量的旋转操作，整体来说性能要优于AVL树。红黑树较AVL树等二叉树的不同在于其有个标识位（红色或者黑色），这个标识位的作用在于减少因不平衡造成的旋转操作，虽然此时树不是完全平衡二叉树，但依然有O(log(n)O(log(n)O(log(n)的时间效率。 红黑树的性质 红黑树要满足如下性质： Each node is eit
数据结构 - 红黑树
xd6905的博客
05-15 491
目录 一、红黑树概念 二、代码实现 1 节点定义 2 树的定义 3 插入 3.1 情况一：u节点存在且为红 3.2 情况二：u节点不存在或存在且为黑。 3.3 代码实现部分 4 验证 一、红黑树概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。红黑树就能保证其最长路径中节点个数不会超过最短路径节点个数的两倍。 满足性质： 1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个节点是红色的，则它的两...
[数据结构]红黑树图解及其代码实现
Protein_zmm的博客
08-16 544
红黑树插入、旋转、调整等分析图解及其代码实现
北邮数据结构与算法实践
09-01
4. 高级数据结构：介绍一些高级的数据结构，如堆、红黑树、哈希表等，以及它们的应用场景。 5. 实践项目：通过一些编程实践项目来巩固学生的数据结构和算法知识，并提高其编程能力。 通过北邮数据结构与算法实践...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值