您的位置: 首页  >  文章  >  红黑树详解

红黑树详解

分类: 文章 • 2024-09-05 08:44:16

1.定义

红黑树是特殊的二叉查找树，又名R-B树(RED-BLACK-TREE)，由于红黑树是特殊的二叉查找树，即红黑树具有了二叉查找树的特性，而且红黑树还具有以下特性：

  • 1.每个节点要么是黑色要么是红色

  • 2.根节点是黑色

  • 3.每个叶子节点是黑色，并且为空节点(还有另外一种说法就是，每个叶子结点都带有两个空的黑色结点（被称为黑哨兵），如果一个结点n的只有一个左孩子，那么n的右孩子是一个黑哨兵；如果结点n只有一个右孩子，那么n的左孩子是一个黑哨兵。)

  • 4.如果一个节点是红色，则它的子节点必须是黑色

  • 5.从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

有几点需要注意的是：

  • 1.特性3中指定红黑树的每个叶子节点都是空节点，但是在Java实现中红黑树将使用null代表空节点，因此遍历红黑树时看不到黑色的叶子节点，反而见到的叶子节点是红色的

  • 2.特性4保证了从根节点到叶子节点的最长路径的长度不会超过任何其他路径的两倍，例如黑色高度为3的红黑树，其最短路径(路径指的是根节点到叶子节点)是2(黑节点-黑节点-黑节点)，其最长路径为4(黑节点-红节点-黑节点-红节点-黑节点)。

2.实践

2.1 红黑树操作

2.1.1 插入操作

首先红黑树在插入节点的时，我们设定插入节点的颜色为红色,如果插入的是黑色节点，必然会违背特性5，即改变了红黑树的黑高度，如下插入红色结点又存在着几种情况：

1.黑父

如图所示，这种情况不会破坏红黑树的特性，即不需要任何处理红黑树详解

2.红父

当其父亲为红色时又会存在以下的情况

红叔

红叔的情况，其实相对来说比较简单的，如下图所示，只需要通过修改父、叔的颜色为黑色，祖的颜色为红色，而且回去递归的检查祖节点即可红黑树详解黑叔 黑叔的情况有如下几种，这几种情况下是不能够通过修改颜色达到平衡的效果，因此会通过旋转的操作，红黑树种有两种旋转操作，左旋和右旋(现在存在的疑问，什么时候使用到左旋，什么时候使用到右旋)

Case 1:[先右旋，在改变颜色(根节点必须为黑色，其两个子节点为红色，叔节点不用改变)],如下图所示，注意省略黑哨兵节点

红黑树详解

Case 2:[先左旋变成Case1中的情况，再右旋，最后改变颜色(根节点必须为黑色，其两个子节点为红色，叔节点不用改变)],如下图所示，注意省略黑哨兵节点

红黑树详解

Case 3:[先左旋，最后改变颜色(根节点必须为黑色，其两个子节点为红色，叔节点不用改变)],如下图所示，注意省略黑哨兵节点

红黑树详解

Case 4:[先右旋变成Case 3的情况，再左旋，最后改变颜色(根节点必须为黑色，其两个子节点为红色，叔节点不用改变)],如下图所示，注意省略黑哨兵节点

红黑树详解

以上就是红黑树新增节点所有可能的操作，下面会介绍红黑树中的删除操作

2.1.2 删除操作 删除操作相比于插入操作情况更加复杂，删除一个节点可以大致分为三种情况：

1.删除的节点没有孩子节点，即当前节点为叶子节点，这种可以直接删除

2.删除的节点有一个孩子节点，这种需要删除当前节点，并使用其孩子节点顶替上来

3.删除的节点有两个孩子节点，这种需要先找到其后继节点(树中大于节点的最小的元素);然后将其后继节点的内容复制到该节点上，其后继节点就相当于该节点的替身， 需要注意的是其后继节点一定不会有两个孩子节点(这点应该很好理解，如果后继节点有左孩子节点，那么当前的后继节点肯定不是最小的，说明后继节点只能存在没有孩子节点或者只有一个右孩子节点)，即这样就将问题转换成为1,2中的方式。

在讲述修复操作之前，首先需要明白几点，

1.对于红黑树而言，单支节点的情况只有如下图所示的一种情况，即为当前节点为黑色，其孩子节点为红色,(1.假设当前节点为红色，其两个孩子节点必须为黑色，2.若有孙子节点，则必为黑色，导致黑子数量不等，而红黑树不平衡)

红黑树详解

2.由于红黑树是特殊的二叉查找树，它的删除和二叉查找树类型，真正的删除点即为删除点A的中序遍历的后继(前继也可以)，通过红黑树的特性可知这个后继必然最多只能有一个孩子，其这个孩子节点必然是右孩子节点，从而为单支情况(即这个后继节点只能有一个红色孩子或没有孩子)

下面将详细介绍，在执行删除节点操作之后，将通过修复操作使得红黑树达到平衡的情况。

Case 1:被删除的节点为红色，则这节点必定为叶子节点(首先这里的被删除的节点指的是真正删除的节点，通过上文得知的真正删除的节点要么是节点本身，要么是其后继节点，若是节点本身则必须为叶子节点，不为叶子节点的话其会有左右孩子，则真正删除的是其右孩子树上的最小值，若是后继节点，也必须为叶子节点，若不是则其也会有左右孩子，从而和2中相违背)，这种情况下删除红色叶节点就可以了，不用进行其他的操作了。

红黑树详解

Case 2:被删除的节点是黑色，其子节点是红色，将其子节点顶替上来并改变其颜色为黑色，如下图所示

红黑树详解

Case 3:被删除的节点是黑色，其子节点也是黑色，将其子节点顶替上来，变成了双黑的问题，此时有以下情况

红黑树详解

  • Case 1:新节点的兄弟节点为红色，此时若新节点在左边则做左旋操作，否则做右旋操作，之后再将其父节点颜色改变为红色，兄弟节点

红黑树详解

红黑树详解

从图中可以看出，操作之后红黑树并未达到平衡状态，而是变成的黑兄的情况

Case 2:新节点的兄弟节点为黑色,此时可能有如下情况

红父二黑侄：将父节点变成黑色，兄弟节点变成红色，新节点变成黑色即可,如下图所示

红黑树详解

红黑树详解黑父二黑侄：将父节点变成新节点的颜色，新节点变成黑色，兄弟节点染成红色，还需要继续以父节点为判定点继续判断,如下图所示

红黑树详解

红黑树详解

红侄：情况一:新节点在右子树，红侄在兄弟节点左子树，此时的操作为右旋，并将兄弟节点变为父亲的颜色，父亲节点变为黑色，侄节点变为黑色，如下图所示

红黑树详解

情况二:新节点在右子树，红侄在兄弟节点右子树，此时的操作为先左旋，后右旋并将侄节点变为父亲的颜色，父节点变为黑色，如下图所示

红黑树详解

情况三：新节点在左子树，红侄在兄弟节点左子树,此时的操作为先右旋在左旋并将侄节点变为父亲的颜色，父亲节点变为黑色，如下图所示

红黑树详解情况四：新节点在右子树，红侄在兄弟节点右子树,此时的操作为左旋，并将兄弟节点变为父节点的颜色，父亲节点变为黑色，侄节点变为黑色，如下图所示

红黑树详解

2.2 红黑树实现

如下是使用JAVA代码实现红黑树的过程，主要包括了插入、删除、左旋、右旋、遍历等操作

2.2.1 插入

 

  1. private void insert(RBTreeNode<T> node){

  2. int cmp;

  3. RBTreeNode<T> root = this.rootNode;

  4. RBTreeNode<T> parent = null;

  5.  

  6.  

  7. while(null != root){

  8. parent = root;

  9. cmp = node.key.compareTo(root.key);

  10. if (cmp < 0){

  11. root = root.left;

  12. } else {

  13. root = root.right;

  14. }

  15. }

  16.  

  17. node.parent = parent;

  18.  

  19. if (null == parent){

  20. this.rootNode = node;

  21. } else {

  22.  

  23. cmp = node.key.compareTo(parent.key);

  24. if (cmp < 0){

  25. parent.left = node;

  26. } else {

  27. parent.right = node;

  28. }

  29. }

  30.  

  31.  

  32. node.color = COLOR_RED;

  33.  

  34.  

  35. insertFixUp(node);

  36. }

 

  1. private void insertFixUp(RBTreeNode<T> node){

  2. RBTreeNode<T> parent,gparent;

  3.  

  4. while( ((parent = getParent(node)) != null) && isRed(parent)){

  5. gparent = getParent(parent);

  6.  

  7.  

  8.  

  9. if(parent == gparent.left){

  10. RBTreeNode<T> uncle = gparent.right;

  11. if ((null != uncle) && isRed(uncle)){

  12. setColorBlack(uncle);

  13. setColorBlack(parent);

  14. setColorRed(gparent);

  15. node = gparent;

  16. continue;

  17. }

  18.  

  19. if (parent.right == node){

  20. RBTreeNode<T> tmp;

  21. leftRotate(parent);

  22. tmp = parent;

  23. parent = node;

  24. node = tmp;

  25. }

  26.  

  27. setColorBlack(parent);

  28. setColorRed(gparent);

  29. rightRotate(gparent);

  30. } else {

  31. RBTreeNode<T> uncle = gparent.left;

  32. if ((null != uncle) && isRed(uncle)){

  33. setColorBlack(uncle);

  34. setColorBlack(parent);

  35. setColorRed(gparent);

  36. node = gparent;

  37. continue;

  38. }

  39.  

  40. if (parent.left == node){

  41. RBTreeNode<T> tmp;

  42. rightRotate(parent);

  43. tmp = parent;

  44. parent = node;

  45. node = tmp;

  46. }

  47.  

  48. setColorBlack(parent);

  49. setColorRed(gparent);

  50. leftRotate(gparent);

  51. }

  52. }

  53. setColorBlack(this.rootNode);

  54. }

插入节点的操作主要分为以下几步：

  • 1.定位：即遍历整理红黑树，确定添加的位置，如上代码中insert方法中就是在找到添加的位置

  • 2.修复：这也就是前面介绍的，添加元素后可能会使得红黑树不在满足其特性，这时候需要通过变色、旋转来调整红黑树，也就是如上代码中insertFixUp方法

2.2.2 删除节点

如下为删除节点的代码

 

  1. private void remove(RBTreeNode<T> node){

  2. RBTreeNode<T> child,parent;

  3. boolean color;

  4.  

  5. if ((null != node.left) && (null != node.right)){

  6.  

  7.  

  8. RBTreeNode<T> replace = node;

  9.  

  10. replace = replace.right;

  11. while(null != replace.left){

  12. replace = replace.left;

  13. }

  14.  

  15.  

  16. if (null != getParent(node)){

  17.  

  18. if (getParent(node).left == node){

  19. getParent(node).left = replace;

  20. } else {

  21. getParent(node).right = replace;

  22. }

  23. } else {

  24. this.rootNode = replace;

  25. }

  26.  

  27. child = replace.right;

  28. parent = getParent(replace);

  29. color = getColor(replace);

  30.  

  31. if (parent == node){

  32. parent = replace;

  33. } else {

  34. if (null != child){

  35. setParent(child,parent);

  36. }

  37. parent.left = child;

  38.  

  39. replace.right = node.right;

  40. setParent(node.right, replace);

  41. }

  42.  

  43. replace.parent = node.parent;

  44. replace.color = node.color;

  45. replace.left = node.left;

  46. node.left.parent = replace;

  47. if (color == COLOR_BLACK){

  48. removeFixUp(child,parent);

  49. }

  50.  

  51. node = null;

  52. return;

  53. }

  54.  

  55. if (null != node.left){

  56. child = node.left;

  57. } else {

  58. child = node.right;

  59. }

  60.  

  61. parent = node.parent;

  62. color = node.color;

  63. if (null != child){

  64. child.parent = parent;

  65. }

  66.  

  67. if (null != parent){

  68. if (parent.left == node){

  69. parent.left = child;

  70. } else {

  71. parent.right = child;

  72. }

  73. } else {

  74. this.rootNode = child;

  75. }

  76.  

  77. if (color == COLOR_BLACK){

  78. removeFixUp(child, parent);

  79. }

  80. node = null;

  81. }

  82.  

  83. private void removeFixUp(RBTreeNode<T> node, RBTreeNode<T> parent){

  84. RBTreeNode<T> other;

  85.  

  86. while ((null == node || isBlack(node)) && (node != this.rootNode) ){

  87.  

  88. if (node == parent.left){

  89.  

  90. other = parent.right;

  91.  

  92. if (isRed(other)){

  93. setColorBlack(other);

  94. setColorRed(parent);

  95. leftRotate(parent);

  96. other = parent.right;

  97. }

  98.  

  99.  

  100. if ((other.left == null || isBlack(other.left)) &&

  101. (other.right == null || isBlack(other.right))){

  102. setColorRed(other);

  103. node = parent;

  104. parent = getParent(node);

  105. } else {

  106.  

  107. if (null == other.right || isBlack(other.right)){

  108. setColorBlack(other.left);

  109. setColorRed(other);

  110. rightRotate(other);

  111. other = parent.right;

  112. }

  113.  

  114. setColor(other, getColor(parent));

  115. setColorBlack(parent);

  116. setColorBlack(other.right);

  117. leftRotate(parent);

  118. node = this.rootNode;

  119. break;

  120. }

  121. } else {

  122. other = parent.left;

  123. if (isRed(other)){

  124. setColorBlack(other);

  125. setColorRed(parent);

  126. rightRotate(parent);

  127. other = parent.left;

  128. }

  129.  

  130. if ((null == other.left || isBlack(other.left)) &&

  131. (null == other.right || isBlack(other.right))){

  132. setColorRed(other);

  133. node = parent;

  134. parent = getParent(node);

  135. } else {

  136. if (null == other.left || isBlack(other.left)){

  137. setColorBlack(other.right);

  138. setColorRed(other);

  139. leftRotate(other);

  140. other = parent.left;

  141. }

  142.  

  143. setColor(other,getColor(parent));

  144. setColorBlack(parent);

  145. setColorBlack(other.left);

  146. rightRotate(parent);

  147. node = this.rootNode;

  148. break;

  149. }

  150. }

  151. }

  152. if (node!=null)

  153. setColorBlack(node);

  154. }

删除节点主要分为几种情况去做对应的处理：

  • 删除节点,按照如下三种情况去删除节点

  • 真正删除的节点没有子节点

  • 真正删除的节点有一个子节点

  • 正在删除的节点有两个子节点

  • 修复红黑树的特性，如代码中调用removeFixUp方法修复红黑树的特性。

3.总结

以上主要介绍了红黑树的一些特性，包括一些操作详细的解析了里面的过程，写的时间比较长，感觉确实比较难理清楚。后面会持续的理解更深入，若有存在问题的地方，请指正！

相关推荐