现在的位置: 首页 > 综合 > 正文

《算法导论》笔记--红黑树(二)

2013年12月09日 ⁄ 综合 ⁄ 共 13872字 ⁄ 字号 评论关闭

 

 

红黑树的节点删除

 

从红黑树上删除一个节点,可以先用普通二叉搜索树的方法,将节点从红黑树上删除掉,然后再将被破坏的红黑性质进行恢复。

我们回忆一下普通二叉树的节点删除方法:Z指向需要删除的节点,Y指向实质结构上被删除的结点,如果Z节点只有一个子节点或没有子节点,那么Y就是指向Z指向的节点。如果Z节点有两个子节点,那么Y指向Z节点的后继节点(其实前趋也是一样的),而Z的后继节点绝对不可能有左子树。因此,仅从结构来看,二叉树上实质被删除的节点最多只可能有一个子树。

现在我们来看红黑性质的恢复过程:

如果Y指向的节点是个红色节点,那么直接删除掉Y以后,红黑性质不会被破坏。操作结束。

如果Y指向的节点是个黑色节点,那么就有几条红黑性质可能受到破坏了。首先是包含Y节点的所有路径,黑高度都减少了一(第5条被破坏)。其次,如果Y的有红色子节点,Y又有红色的父节点,那么Y被删除后,就出现了两个相邻的红色节点(第4条被破坏)。最后,如果Y指向的是根节点,而Y的子节点又是红色的,那么Y被删除后,根节点就变成红色的了(第2条被破坏)。

其中,第5条被破坏是让我们比较难受的。因为这影响到了全局。这样动作就太大太复杂了。而且在这个条件下,进行其它红黑性质的恢复也很困难。所以我们首先解决这个问题:如果不改变含Y路径的黑高度,那么树的其它部分的黑高度就必须做出相应的变化来适应它。所以,我们想办法恢复原来含Y节点的路径的黑高度。做法就是把Y节点的黑色,推到它的子节点X上去。(X可能是NIL节点)。这样,X就可能具有双重黑色,或是同时具有红黑两色,也就是第1条性质被破坏了。

但第1条性质是比较容易恢复的:一、如果X是同时具有红黑两色,那么好办,直接把X涂成黑色,就行了。而且这样把所有问题都解决了。因为将X变为黑色,2、4两条如果有问题的话也会得到恢复。二、如果X是双黑色,那么我们希望把这种情况向上推一直推到根节点(调整树结构和颜色,X的指向新的双黑色节点,X不断向上移动),让根节点具双黑色,这时,直接把X的一层黑色去掉就行了(因为根节点被包含在所有的路径上,所以这样做所有路径同时黑高减少一,不会破坏红黑特征)。

下面就具体地分析如何恢复1、2、4三个可能被破坏的红黑特性:我们知道,如果X指向的节点是有红黑两色,或是X是根节点时,只需要简单的对X进行一些改变就行了。要对除X节点外的其它节点进行操作时,必定是这样的情况:X节点是双层黑色,且X有父节点P。由知可知,X必然有兄弟节点W,而且这个W节点必定有两个子节点。(因为这是原树满足红黑条件要求而自然具备的。X为双黑色,那么P的另一个子节点以下一定要有至少两层的节点,否则高黑度不可能和X路径一致)。所以我们就分析这些节点之间如何变形,把问题限制在比较小的范围内解决。另一个前提是:X在一开始,肯定是树底的叶节点或是NIL节点,所以在递归向上的过程中,每一步都保证下一步进行时,至少 X的子树是满足红黑特性的。因此子树的情况就可以认为是已经正确的了,这样,分析就只限制在X节点,X的父节点P,X的兄弟节点W,以及W的两个子节点。这些个节点中。

W以及W的两个子节点C1和C1的一共有五种组合,便有两种情况的处理是一致的,因此调整的过程可以分以下四个情况:

第一种情况:W是红色节点

红黑树的删除1

 

如上图,如果W是红色的,那么B和D节点进行一次左旋,并把D(也就是原来的W)着为黑色,B节点(X的父节点)着为红色。然后让W指向X的新兄弟。这样,就把这种情况转化为了W为黑色的情况来解决。在这个变形中,这五个节点之间保持了红黑性质不变,而X指向的双黑色节点的位置和颜色特性都没有变化。变形后的情况如何解决呢?下面的都是W为黑色的问题,因此下面三种中总有一种会合适。

PS:有没有其它变形呢?有,比如C和D进行右旋,B节点变为红色,变形后五个节点红黑正确的,但是这五个节点与树的其它部分相接处可能会产生问题,这样要考虑的因素就太多了。

 

第二种情况:W以及W的两个子节点都是黑色的

 

红黑树的删除2

 

如上图,注意,B即可以是红色也可以是黑色。

这种情况下,把D节点着成红色。然后把X的一个黑色推到父节点B中去,这时X就指向B节点了。变形前后,这五个节点间的黑高是没有变化的。

唯一可能产生问题的就是如果B原来是红色,那么B和D两个红色相邻就破坏了第4个性质,这样新X的子树就有问题了。这本来不符合我们向上递归的假设。但正好在这种情况下递归就可以结束了。因为B节点原来是红色,现在双加一层黑色,那么X现在指向的这个节点就是红黑两色的,直接把X(也就是B)着为黑色。问题就已经完整解决了。

如果B节点现在是双层黑色,那就以B为新的X进行向上的下一次的递归。

 

第三种情况:W的左子节点是红色的且右子节点是黑色。

 

红黑树的删除3

 

  如上图,B即可以是黑色也可以是红色。

  把C和D进行一次旋转,改变C和D的颜色变形成新的结构。把问题转化成W的右子节点为红色的情况来解决。注意,原来C是红色的,所以C的子节点一定是黑色的,所以旋转中C节点的一个子树挂到之后着为红色的D节点上不会破坏红黑性质。变形后黑高度不变。

 

  第四种情况:W的右子节点是红色(左子节点可以是红色或黑色)

 

红黑树的删除4

 

  如上图,B节点可以是红色或是黑色。

  将B和D进行一次左旋,并交换两者的颜色。再将E着为黑色。这时,只要将X的一层黑色脱去,整个问题也得到了解决。递归结束。(在代码上,为了标识递归结束,我们把X指向根节点)

 

  因此,只要按上面四种情况一直递归处理下去,X最终总会指向根结点或一个红色结点,这时我们就可以结束递归并把问题解决了。

  以上就是红黑色的节点删除过程。

 

 

  以下的简单的代码实现:

Cpp代码 
  1. // -------------------------------------------------------  
  2. // FileName : BinarySearchTree.cpp  
  3. // Date     : 2009-1-14   
  4. // Summary  : 红黑树的简单实现,节点中除了红黑树结构本身需要的信息之外,只  
  5. //            包含一个int域作为节点的key  
  6. // CopyLeft : 李诒雯  
  7. // -------------------------------------------------------  
  8.   
  9. #include <stdio.h>  
  10.   
  11. // 定义节点颜色  
  12. enum COLOR {  
  13.     BLACK = 0,  
  14.     RED  
  15. };  
  16.   
  17. // 红黑树节点  
  18. typedef struct tagRBTreeNode {  
  19.     int key;  
  20.     struct tagRBTreeNode *left;  
  21.     struct tagRBTreeNode *right;  
  22.     struct tagRBTreeNode *parent;  
  23.     unsigned char color;  
  24. }RBTreeNode, *PRBTreeNode;  
  25.   
  26. // 红黑树,包含一个指向根节点的指针  
  27. typedef struct tagRBTree {  
  28.     PRBTreeNode root;     
  29. }RBTree, *PRBTree;  
  30.   
  31. // 红黑树的NIL节点  
  32. static RBTreeNode NIL = {0, 0, 0, 0, BLACK};  
  33.   
  34. #define PNIL (&NIL)   // NIL节点地址  
  35.   
  36. // 生成一个红黑树节点,缺省的节点颜色是红黑。  
  37. PRBTreeNode CreateRBTreeNode(int keyVal)  
  38. {  
  39.     PRBTreeNode p = (PRBTreeNode)malloc(sizeof(RBTreeNode));  
  40.     p->color = RED;  
  41.     p->left = PNIL;  
  42.     p->right = PNIL;  
  43.     p->parent = PNIL;  
  44.     p->key = keyVal;  
  45.     return p;  
  46. }  
  47.   
  48. // 释放一个节点的内存  
  49. void DeleteRBTreeNode(PRBTreeNode pDel)  
  50. {  
  51.     if (PNIL != pDel) {  
  52.         free(pDel);  
  53.     }     
  54. }  
  55.   
  56. void InitRBTree(PRBTree pTree) // 初始化一棵红黑树  
  57. {  
  58.     pTree->root = PNIL;  
  59. }  
  60.   
  61. // 顺序遍历一棵红黑树,并对每个节点执行指定的操作  
  62. void INORDER_RBTREE_WALK(PRBTreeNode pRoot, void (*Action)(PRBTreeNode ))  
  63. {  
  64.     // 就是一个二叉树的中序遍历  
  65.     if (PNIL != pRoot) {  
  66.         INORDER_RBTREE_WALK(pRoot->left, Action);  
  67.         Action(pRoot);  
  68.         INORDER_RBTREE_WALK(pRoot->right, Action);  
  69.     }  
  70. }  
  71.   
  72. // 查找指定键值的节点  
  73. PRBTreeNode RBTREE_SEARCH(PRBTreeNode pRoot, int val_key)  
  74. {  
  75.     while ((PNIL != pRoot) && (val_key != pRoot->key)) {  
  76.         pRoot = (val_key < pRoot->key ? pRoot->left : pRoot->right);      
  77.     }  
  78.     return pRoot;  
  79. }  
  80.   
  81. // 查找最大键值节点  
  82. PRBTreeNode RBTREE_MAX(PRBTreeNode pRoot)  
  83. {  
  84.     while (PNIL != pRoot->right) {  
  85.         pRoot = pRoot->right;      
  86.     }  
  87.     return pRoot;  
  88. }  
  89.   
  90. // 查找最小键值节点  
  91. PRBTreeNode RBTREE_MIN(PRBTreeNode pRoot)  
  92. {  
  93.     while (PNIL != pRoot->left) {  
  94.         pRoot = pRoot->left;   
  95.     }  
  96.     return pRoot;  
  97. }  
  98.   
  99. // 查找指定节点的后继节点  
  100. PRBTreeNode RBTREE_SUCCESSOR(PRBTreeNode pRoot)  
  101. {  
  102.     if (PNIL != pRoot->right) {  
  103.         return RBTREE_MIN(pRoot->right);  
  104.     }  
  105.     PRBTreeNode pParent = pRoot->parent;  
  106.     while((PNIL != pParent) && (pRoot == pParent->right)) {  
  107.         pRoot = pParent;  
  108.         pParent = pRoot->parent;           
  109.     }   
  110.     return pParent;  
  111. }  
  112.   
  113. // 查找指定节点的前趋节点  
  114. PRBTreeNode RBTREE_PREDECESSOR(PRBTreeNode pRoot)  
  115. {  
  116.     if (PNIL != pRoot->left) {  
  117.         return RBTREE_MAX(pRoot->left);  
  118.     }  
  119.     PRBTreeNode pParent = pRoot->parent;  
  120.     while((PNIL != pParent) && (pRoot == pRoot->left)) {  
  121.         pRoot = pParent;  
  122.         pParent = pRoot->parent;           
  123.     }   
  124.     return pParent;  
  125. }  
  126.   
  127. // 对指定节点进行左旋  
  128. static void LEFT_ROTATION(PRBTree pTree, PRBTreeNode pNode)  
  129. {  
  130.     PRBTreeNode pRight = pNode->right;  
  131.     pRight->parent = pNode->parent;  
  132.     if(pNode->parent->left == pNode){  
  133.         pRight->parent->left = pRight;  
  134.     }  
  135.     else {  
  136.         pRight->parent->right = pRight;  
  137.     }  
  138.   
  139.     if (PNIL == pRight->parent) {  
  140.         pTree->root = pRight;  
  141.     }  
  142.     if (PNIL != pRight->left) {  
  143.         pRight->left->parent = pNode;  
  144.     }  
  145.     pNode->right = pRight->left;  
  146.     pNode->parent = pRight;  
  147.     pRight->left = pNode;  
  148. }  
  149.   
  150. // 对指定节点进行右旋  
  151. static void RIGHT_ROTATION(PRBTree pTree, PRBTreeNode pNode)  
  152. {  
  153.     PRBTreeNode pLeft = pNode->left;  
  154.     pLeft->parent = pNode->parent;  
  155.     if(pNode->parent->left == pNode){  
  156.         pLeft->parent->left = pLeft;  
  157.     }  
  158.     else {  
  159.         pLeft->parent->right = pLeft;  
  160.     }  
  161.   
  162.     if (PNIL == pLeft->parent) {  
  163.         pTree->root = pLeft;  
  164.     }  
  165.     if (PNIL != pLeft->right) {  
  166.         pLeft->right->parent = pNode;  
  167.     }     
  168.     pNode->left = pLeft->right;  
  169.     pNode->parent = pLeft;  
  170.     pLeft->right = pNode;  
  171. }  
  172.   
  173. // 在红黑树插入动作后进行红黑性质恢复  
  174. static void FIX_UP_RB_AFTER_INSERT(PRBTree pTree, PRBTreeNode pNode)  
  175. {  
  176.     while(RED == pNode->parent->color) {  
  177.         if (pNode->parent == pNode->parent->parent->left){  
  178.             PRBTreeNode pUncleNode = pNode->parent->parent->right;  
  179.             if (RED == pUncleNode->color){  
  180.                 pNode->parent->color = BLACK;  
  181.                 pUncleNode->color = BLACK;  
  182.                 pNode = pUncleNode->parent;  
  183.                 pNode->color = RED;  
  184.             }  
  185.             else   
  186.             {  
  187.                 if (pNode == pNode->parent->right) {  
  188.                     pNode = pNode->parent;  
  189.                     LEFT_ROTATION(pTree, pNode);  
  190.                 }  
  191.                 pNode->parent->color = BLACK;  
  192.                 PRBTreeNode TempP = pNode->parent->parent;  
  193.                 TempP->color = RED;  
  194.                 RIGHT_ROTATION(pTree, TempP);  
  195.             }  
  196.         }  
  197.         else{  
  198.             PRBTreeNode pUncleNode = pNode->parent->parent->left;  
  199.             if (RED == pUncleNode->color){  
  200.                 pNode->parent->color = BLACK;  
  201.                 pUncleNode->color = BLACK;  
  202.                 pNode = pUncleNode->parent;  
  203.                 pNode->color = RED;  
  204.             }  
  205.             else   
  206.             {  
  207.                 if (pNode == pNode->parent->left) {  
  208.                     pNode = pNode->parent;  
  209.                     RIGHT_ROTATION(pTree, pNode);  
  210.                 }  
  211.                 pNode->parent->color = BLACK;  
  212.                 PRBTreeNode TempP = pNode->parent->parent;  
  213.                 TempP->color = RED;  
  214.                 LEFT_ROTATION(pTree, TempP);  
  215.             }  
  216.         }  
  217.     }  
  218.     pTree->root->color = BLACK;  
  219. }  
  220.   
  221. // 红黑树的节点插入  
  222. void RBTREE_INSERT(PRBTree pTree, PRBTreeNode pNode)  
  223. {  
  224.     PRBTreeNode pNodePosition = pTree->root;  
  225.     PRBTreeNode pParent = PNIL;  
  226.   
  227.     while (PNIL != pNodePosition) {  
  228.         pParent = pNodePosition;  
  229.         pNodePosition = (pNode->key > pNodePosition->key ?   
  230.             pNodePosition->right : pNodePosition->left);  
  231.     }  
  232.       
  233.     pNode->parent = pParent;  
  234.     if (PNIL == pParent) {  
  235.         pTree->root = pNode;       
  236.     }  
  237.     else {  
  238.         if (pNode->key > pParent->key) {  
  239.             pParent->right = pNode;  
  240.         }  
  241.         else {  
  242.             pParent->left = pNode;  
  243.         }  
  244.     }  
  245.     FIX_UP_RB_AFTER_INSERT(pTree, pNode);  
  246. }  
  247.   
  248. // 在红黑树删除动作后进行红黑性质恢复  
  249. static void FIX_UP_RB_AFTER_DELETE(PRBTree pTree, PRBTreeNode pNode)  
  250. {  
  251.     while ((pNode->color == BLACK) && (pNode != pTree->root)) {  
  252.         if (pNode == pNode->parent->left){  
  253.             PRBTreeNode pBrother = pNode->parent->right;  
  254.             if (RED == pBrother->color) {  
  255.                 pBrother->color = BLACK;  
  256.                 pNode->parent->color = RED;  
  257.                 LEFT_ROTATION(pTree, pNode->parent);  
  258.                 pBrother = pNode->parent->right;  
  259.             }  
  260.             if ((BLACK == pBrother->right->color) && (BLACK == pBrother->left->color)) {  
  261.                 pBrother->color = RED;  
  262.                 pNode = pNode->parent;  
  263.             }  
  264.             else {  
  265.                 if (BLACK == pBrother->right->color) {  
  266.                     pBrother->color = RED;  
  267.                     pBrother->left->color = BLACK;  
  268.                     RIGHT_ROTATION(pTree, pBrother);  
  269.                     pBrother = pNode->parent->right;  
  270.                 }  
  271.                 pBrother->right->color = BLACK;  
  272.                 pBrother->color = pNode->parent->color;                  
  273.                 pNode->parent->color = BLACK;  
  274.                 LEFT_ROTATION(pTree, pNode->parent);  
  275.                 pNode = pTree->root;  
  276.             }  
  277.         }  
  278.         else{  
  279.             PRBTreeNode pBrother = pNode->parent->left;  
  280.             if (RED == pBrother->color) {  
  281.                 pBrother->color = BLACK;  
  282.                 pNode->parent->color = RED;  
  283.                 RIGHT_ROTATION(pTree, pNode->parent);  
  284.                 pBrother = pNode->parent->left;  
  285.             }  
  286.             if ((BLACK == pBrother->left->color) && (BLACK == pBrother->right->color)) {  
  287.                 pBrother->color = RED;  
  288.                 pNode = pNode->parent;  
  289.             }  
  290.             else {  
  291.                 if (BLACK == pBrother->left->color) {  
  292.                     pBrother->color = RED;  
  293.                     pBrother->right->color = BLACK;  
  294.                     LEFT_ROTATION(pTree, pBrother);  
  295.                     pBrother = pNode->parent->left;  
  296.                 }  
  297.                 pBrother->left->color = BLACK;  
  298.                 pBrother->color = pNode->parent->color;                  
  299.                 pNode->parent->color = BLACK;  
  300.                 RIGHT_ROTATION(pTree, pNode->parent);  
  301.                 pNode = pTree->root;  
  302.             }  
  303.         }  
  304.     }  
  305.     pNode->color = BLACK;  
  306. }  
  307.   
  308. // 红黑树的节点删除  
  309. PRBTreeNode RBTREE_DELETE(PRBTree pTree, PRBTreeNode pDel)  
  310. {  
  311.     PRBTreeNode pRelDel;  
  312.     if ((PNIL == pDel->left) || (PNIL == pDel->right)) {  
  313.         pRelDel = pDel;  
  314.     }  
  315.     else { //  
  316.         pRelDel = RBTREE_SUCCESSOR(pDel);  
  317.     }  
  318.   
  319.     PRBTreeNode pChildOfDel;  
  320.     pChildOfDel = (pRelDel->left!= PNIL ? pRelDel->left : pRelDel->right);  
  321.   
  322.     //  
  323.     pChildOfDel->parent = pRelDel->parent;  
  324.       
  325.     if (PNIL == pRelDel->parent) {  
  326.         pTree->root = pChildOfDel;  
  327.     }  
  328.     else {  
  329.         if (pRelDel == pRelDel->parent->left){  
  330.             pRelDel->parent->left = pChildOfDel;  
  331.         }  
  332.         else {  
  333.             pRelDel->parent->right = pChildOfDel;  
  334.         }  
  335.     }  
  336.   
  337.     if (pRelDel != pDel) {  
  338.         pDel->key = pRelDel->key;  
  339.     }  
  340.   
  341.     if (pRelDel->color == BLACK) {  
  342.         FIX_UP_RB_AFTER_DELETE(pTree, pChildOfDel);  
  343.     }  
  344.     return pRelDel;  
  345. }  
  346.   
  347. /*=============================================*/  
  348. // 测试用函数,打印节点键值。可以传给遍历函数作为第二个参数  
  349. void PrintNode(PRBTreeNode p)  
  350. {  
  351.     if (NULL != p) {  
  352.         printf("%2d ", p->key);  
  353.     }  
  354.     else {  
  355.         printf("NULL!");  
  356.     }  
  357. }  
  358.   
  359. // 打印出红黑树每个节点的各项值。  
  360. void RBTREE_STRUCTURE(PRBTreeNode pRoot)  
  361. {  
  362. #define GetKey(p) (p==PNIL?-1:p->key)  
  363.     //  
  364.     if (PNIL != pRoot) {  
  365.         printf("KeyValue = %d, color = %s, Left = %d, Right = %d, Parent = %d\n",  
  366.             pRoot->key, pRoot->color==BLACK?"BLACK":"RED", GetKey(pRoot->left),   
  367.             GetKey(pRoot->right), GetKey(pRoot->parent));  
  368.         RBTREE_STRUCTURE(pRoot->left);  
  369.         RBTREE_STRUCTURE(pRoot->right);  
  370.     }  
  371. }  
  372.   
  373. /*=============================================*/  
  374. int _tmain(int argc, _TCHAR* argv[])  
  375. {  
  376.     RBTree bsTree;  
  377.     InitRBTree(&bsTree);  
  378.   
  379. #define TEST_NUM_COUNT (10)  
  380.     int values[TEST_NUM_COUNT];  
  381.   
  382.     for (int i=0; i<TEST_NUM_COUNT; ++i) {  
  383.         values[i] = rand()%(TEST_NUM_COUNT*10);  
  384.         PRBTreeNode p = CreateRBTreeNode(values[i]);  
  385.         RBTREE_INSERT(&bsTree, p);  
  386.       
  387.           
  388.         printf("After Insert %2d:  ", values[i]);  
  389.         INORDER_RBTREE_WALK(bsTree.root, PrintNode);      
  390.         printf("RB-Tree Nodes Information\n");  
  391.           
  392.         RBTREE_STRUCTURE(bsTree.root);  
  393.         printf("-------------------------------\n");  
  394.     }  
  395.   
  396.     printf("###############################\n");  
  397.     printf("===============================\n");  
  398.   
  399.     for (int i=0; i<TEST_NUM_COUNT; ++i) {  
  400.         PRBTreeNode pDel = RBTREE_DELETE(&bsTree, RBTREE_SEARCH(bsTree.root, values[i]));  
  401.         DeleteRBTreeNode(pDel);  
  402.         printf("After Delete %2d:  ", values[i]);  
  403.         INORDER_RBTREE_WALK(bsTree.root, PrintNode);  
  404.         printf("RB-Tree Nodes Information\n");  
  405.         RBTREE_STRUCTURE(bsTree.root);  
  406.         printf("-------------------------------\n");  
  407.           
  408.     }  
  409.   
  410.     return 0;  
  411. }  

 

本文出自:http://liyiwen.iteye.com/blog/345799

抱歉!评论已关闭.