删除

这次，让我们直接看例子，请回顾之前看到的【树一】

1．  最简单的情况就是，删除一个leaf结点的值后，改结点仍然不会空。比如删除【树一】的39，43，69，73（是说一次删除一个，不是指依次删除）。提到的值都是位于leaf上，而且这些结点都是已经有两个值；不过要记得移除了large值的话，不需要多做什么；但移除small值，需要将large值设置为-1，然后把原来的large移动到small上。

2．  在【树一】上移除12

如果移走了12，树会变成如下：

<53>

         /         \

        /           \

<27>        <65, 78>

/  \        /     |     \

   <>  <39,43> <60> <69,74>  <93>

            树八 (not valid yet)

    <27> 的左子树空了，这不合法。这时候，我们需要向<12>的“亲戚”(sibling)借一个值，也就是<27>的右子树，它刚好有两个值。将小值39推上去，再将27拉下来，最后如下

<53>

         /         \

        /           \

<39>        <65, 78>

/  \        /     |     \

   <27> <43> <60> <69,74>  <93>

            树九

    这里使用的策略是，当删除一个结点的值会识得该结点变空，就尝试向它的亲戚结点借一个值，如果可能的话。

3．  删除非leaf结点的值

这次让我们删除【树九】的65，这是一个在非leaf结点上的值。

因为当一个结点非leaf，它一定有子树，因此也必定存在有“inorder successor”（这个东西真的不知道怎么翻译，这个跟BST的删除一样，找到一个最小的比65大的元素）

所以，我们可以找到69，然后跟65替换，最后的树变成

<53>

         /         \

        /           \

<39>        <69, 78>

/  \        /     |     \

   <27> <43>   <60>   <74>  <93>

     树十

4．  删除一个元素，其亲戚结点无值可借

比如【树十】我们要删除74，它右边的亲戚结点只有一个值，无法借过来。还记得我之前曾经提过吗，对，我们把父结点的值拉下来，就刚好如同我们新增时候所做的反过来。我们可以将69拖下来，并与60合并。最后树变成

<53>

         /         \

        /           \

<39>         <78>

/  \        /        \

   <27> <43>   <60,69>    <93>

     树十一

请自己尝试在【树十一】上增加74，看看是否和【树十】一样

5．  删除一个元素，其亲戚结点无值可借，而且父结点只有一个元素，无法下推

比如，我们要从【树十】中删除43，如果我们像刚才所说的那样做，把父结点拖下来合并，树就会变成这样：

<53>

         /         \

        /           \

<>         <69, 78>

/  \        /     |     \

 <27,39> <>   <60>   <74>  <93>

     树十二 (not valid yet)

这明显不合法。我们需要做的时候重复一次，再把父结点（39的父结点是53）拖下来合并，原来39的位置变成53了，53的位置又变空了。可是这次原来39的位置有亲戚子树<69,78>可以借。请参照情况2，把小值69推上去，因为53去了左子树那边，需要找它的inorder successor（找到60)，把它移到53的右子树去。最终，完整的树变成

<69>

         /         \

        /           \

<53>          <78>

/   \        /     \

 <27,39> <60>   <74>   <93>

     树十三

现在是一棵合法的2-3树了，但是这次你不能用将43重新插入来检验是否正确，因为如果重新插入43会变成

<69>

         /         \

        /           \

<39,53>        <78>

/  |  \        /   \

 <27> <43> <60>   <74>   <93>

     树十四

6．  删除一个元素，其亲戚结点无法借值，其父结点只有一个元素，其父结点的亲戚结点也无法借值……

这是最复杂的情况，其实也就是需要不断的重复步骤，直到出现以下情况

1）  当一个结点有两个元素

2）  当一个结点的亲戚结点可以借值

3）  当已经到达root

当最后一种情况发生的时候，root的两个子树就合并，原来的root就被删除，新的root出现，树的高度减1

总结

删除元素i的方法

1）  找到包含元素i的结点n

2）  如果n是一个leaf，先删除i

如果n不是一个leaf，找到i的inorder successor，与i交换，然后删除i

3）  如果这个时候n不是空，那么删除完成

如果n变空了，恶梦开始(^^)，我们需要修复树

a)       检查n的亲戚结点，如果有两个元素，借一个过来（要注意借过来的元素和父结点元素的安排）比如你从左子树借一个过来，那当然是借一个左子树的large，然后原来的父结点元素拖下来；如果是从右子树借一个，那当然是借small，还要同时把small变成large，再把small变成新父结点，原来的父结点放到空结点去。（如果觉得比较混乱请自己画个图就清楚了）

b)       如果没有亲戚结点有两个元素，那就直接把父结点拖下来合并，让父结点变成空。

c)       递归的往上重复，直到遇到在情况6中所述的三种情形。

代码

首先我要给大家看的是 tree23里面的delete方法

public void delete(int data)     {         tree23Node ptr, found;         int tmp;                 found = locate(data); // 首先我找到该元素所在的结点                 if (found==null)         {             return;         }         else         {             if (!found.isLeaf()) // if it is not a leaf             {                 if (found.small==data && found.itemCount>1)                 {                     ptr = found.middle;                 }                 else                 {                     ptr = found.right;                 }                             // 这里我是找 inorder successor                 while(ptr.left!=null) ptr = ptr.left;                                 // 然后交换需要删除的那个值                 if (found.small==data)                 {                     tmp = found.large;                     found.small = ptr.small;                     ptr.large = tmp;                 }                 else                 {                     tmp = found.large;                     found.large = ptr.smll;                     ptr.large = tmp;                 }             }             else  // found is a leaf             {                 ptr = found;             }                         // 交换完毕了就删除元素             if (ptr.large == data) {     ptr.large = -1;  ptr.itemCount–;             }             else if (ptr.small==data)             {                 ptr.small = ptr.large;                 ptr.large = -1;                 ptr.itemCount–;             }                         // if it is empty, fix the root             // 这里我用了跟新增一样的技巧，调用fix方法修复，然后返回整棵树             if (ptr.itemCount == 0)                 root = ptr.fix();                         } // end if found==null     } // end delete

剩下的工作，就是在 tree23Node里增加一个方法fix，不需要任何参数，该方法调用的时候this一定是一个空结点，然后就往上找就是。具体实现的步骤已经说得很清楚了，而方法也类似split那样。

如果感兴趣的朋友不妨自己试试，倒的确是一个锻炼的好机会。

后记

这篇东西纯粹是介绍性质的文章，因为2-3树在国外是很受重视的，可惜似乎国内倒不太关注。我在google上找到有人问，却没有什么比较详细的中文资料。于是才决定写这篇东西。写得比较潦草，也没有非常专业的口吻，不妥的地方还请指教。非常欢迎转载，但是请不要自己修改后发表到盈利的报刊杂志上，只限网上转载，转载的时候也请声明出处，谢谢。

]]> http://blog.donews.com/sowen/archive/2004/12/16/204210.aspx/feed 1 http://blog.donews.com/sowen/archive/2004/12/15/203627.aspx http://blog.donews.com/sowen/archive/2004/12/15/203627.aspx#comments Wed, 15 Dec 2004 06:35:00 +0000 angGoGo http://blog.donews.com/sowen/archive/2004/12/15/203627.aspx

对于 class tree23，我提供了一个public的insert方法，如下：

public void insert(int data) {     // if the root is empty, which means the tree is emtpy.     // create the tree. otherwise, call a private method         if (root==null)     {         root = new tree23Node(data);     }     else     {         insert(root, data);     } } // end insert

同时，我也提供了一个private的insert方法，其实也可以放到同一个地方，主要就是免得一个方法太长而已。该方法代码如下：

private void insert(tree23Node curr, int data) {     // stores the node in a temporary variable         tree23Node ptr = curr;   // for 2-3 tree, all new item must be inserted in a leaf.      // find the correct leaf firstly      // 还记得我前面说过的吧，第一步永远都是先找到一个leaf                      while (!ptr.isLeaf())      {          if (data <= ptr.small && ptr.left!=null)          {               ptr = ptr.left;           }           else if (data>=ptr.large && ptr.right!=null)           {                ptr = ptr.right;           }           else if (data<ptr.large && ptr.middle!=null)           {               ptr =  ptr.middle;           }       }                 // 下面首先判断两种情况，如果当前的leaf只有一个元素，直接放进去就是了                       if (ptr.itemCount==1)       {            if (ptr.small <= data)            {                 ptr.large = data;                 ptr.itemCount ++;             }             else             {                 ptr.large = ptr.small;                 ptr.small = data;                 ptr.itemCount ++;             }        } // end outer if                        // 否则的话，这个leaf已经full了，因为它有两个值。那我就split它好了。但是在split之前，我先做一件事，就是先还是照加入新值，并按顺序排列好。就是说，如果新值最小，就放到small，把原来的small放到large，把原来的large放到temp。如果新值最大，就放到temp；如果它是中间值，就放到large，而原来的large就放到temp。                        else        {              if (ptr.large <= data)              {                  ptr.temp = data;               }               else if (ptr.small <= data)               {                   ptr.temp = ptr.large;                   ptr.large = data;               }               else               {                   ptr.temp = ptr.large;                   ptr.large = ptr.small;                   ptr.small = data;               }                                   // increase the item count of this node, which               // should be 3 now                                   ptr.itemCount++;                                   // call split method and overwrite root                 root=ptr.split(); // split 方法返回的是一棵完整的树            } // end else } // end method insert

终于到了最激动人心的时候，就是 class tree23Node 的split方法。

为什么要把这个方法放到tree23Node里面呢？一开始我只是觉得会方便一些，因为比较split的时候，对每个结点的各种属性都需要访问和改变，如果在this里面访问，可以不需要写 “[对象].” 这样。呵呵，很无聊的原因吧。

其实，放到tree23Node还是有原因的，从OO的概念上看，tree23.split() 没有意义，无论它是否private。Split这个操作是属于一个node的。另外，从可读性和操作性上，放在tree23里都相当麻烦，我也看过不少这样做的代码，大家也不妨去google查查看。

在显示代码之前，先做一些说明。

Split方法只有当一个node是full的时候才被调用，而且返回值是一棵完整的2-3tree。

该结点其中small是最小值，large是中间值，temp包含最大值。我们要做的是：

1.     将最小值和最大值分开，变成独立的两个node，让我们叫一个是小结点，一个是大结点

2.     把中间值推到父结点。

1）如果父结点是空的，那么表示我们已经到了root，创建一个新root包含那个中间值，并连接小结点到left，大结点到right，返回新创建的root

2) 看看this是属于父结点的哪一个子树

    a) 属于左子树，推上去的值一定是一个父结点的最小值，需要保存在small里

如果父结点是full的，先把原来的right连接到rtNode里做个备份，原来的large放到temp里，small放到large，推上去的值放在small里。现在轮到父结点需要split了，请在这里记住rtNode不为null。

如果父结点不是full，那大家都知道怎么做了。

b）属于右子树，推上去的一定是父结点的最大值，需要保存在large（也可能在temp里，要看父结点是否full）

   然后如上，分析父结点是否为full

c) 属于中子树，如果父子树有中子树，那么表示它一定已经full了。

   最后，看看父结点的 rtNode是否为空，如果不是，表示需要继续往上split。递归调用。否则就一直循环推上去直到root，返回。

可能我上面解释的不太清楚，还是让我们看代码吧

tree23Node split() { tree23Node retval, node1, node2;      int s, m, l;                                              s = small;      m = large;      l = temp;                          // firstly, prepare two new nodes that are splited      // in this node. That means, I have two new nodes that      // one has the smallest item, another has the largest item.      // Then, I will pass the middle item up.           node1 = new tree23Node(s)                    ;      node2 = new tree23Node(l);                          // there are two cases      // 1. this is the root, I just need to create a new root      //    that contains the middle item and connect two new      //    nodes to it      // 2. this is not the root, I need to do the following things      //      1) consider this node is parent’s left, middle, or      //         right, to do different connections      //      2) if parent is still full, recursively split                      if (parent==null)      {            // create a new node contains the middle value                       retval = new tree23Node(m);            retval.left = node1;            retval.right = node2;       }       else       {          // get the parent node                             retval = parent;                        // if this node is parent’s left child                            if (retval.left==this)          {               // if parent is full already, now parent should               // have four children(1 is in rtNode), three items                         if (retval.itemCount>1)               {                     retval.rtNode = retval.right;                     retval.right = retval.middle;                    retval.temp = retval.large;                }                  retval.left = node1;                retval.middle = node2;                retval.large = retval.small;                retval.small = m;          }          else if (retval.right==this)          {                 // if parent of this is not full, now parent                 // should have 3 children, otherwise 4, 1 is in                 // rtNode                                             if (retval.itemCount==1)                 {                      retval.middle = node1;                      retval.right = node2;                      retval.large = m;                  }                  else                  {                       retval.right = node1;                       retval.rtNode = node2;                       retval.temp = m;                   }          }          else if (retval.middle == this)          {                   // if this is the parent’s middle child                   // it means parent must have 2 items, it                   // has been full, I need to store one in rtNode                                           retval.middle = node1;               retval.rtNode = retval.right;               retval.right = node2;               retval.temp = retval.large;               retval.large = m;          }          else          {               //should never happen                                    System.out.println(“pointer error!”);               System.exit(0);          }                                  // 我已经把新元素加到父结点去了，它是否合法我暂时不管，总之我先增父结点的总数，减掉当前结点的总数                                   retval.itemCount++;           itemCount–;                         } // end else parent != null                           // fix the new nodes                       node1.parent = node2.parent = retval;                        // if this node is not a leaf, I also need to fix       // new nodes’ children and those parents                       if (!isLeaf())       {             node1.left = left;             node1.right = middle;             node2.left = right;             node2.right = rtNode;                      if (node1.left!=null)             {                 node1.left.parent = node1;              }                                     if (node1.right!=null)             {                 node1.right.parent = node1;              }                                      if (node2.left!=null)              {                  node2.left.parent = node2;              }                                    if (node2.right!=null)              {                  node2.right.parent = node2;               }       } // end if                           // now I can clean the resources                           left = middle = right = rtNode = parent = null;                           // if parent still has an rtNode, it means parent is full       // now, it needs to be splited too.                           if (retval.rtNode!=null)       {             return retval.split();       }                           // if I am here, that means I have splited everything       // now I move to the top, return the root                           while (retval.parent!=null)       {             retval = retval.parent;       }                           return retval;                 } // end method split

到这里，新增就全部讲完了。真是累得可以，明天继续。

有的人明明有辆几乎崭新的跑车，还是要再买一部新车换；有的人有了一台很大的显示器，还是要再买一个液晶的；再看看一些人的家具，质量好得真是没话说。这些人有了解钱来的有多辛苦吗？当他们爹妈提款机啊？

可能是因为我是工作了几年才出国，所以很明白一个月几千元工薪阶层的积累有多难。想想大多数人的父母，我相信不是个个都是银行行长，省长之类人的子女吧，还是应该有很多双亲都是在为子女撑着省钱的吧。

出国留学本来花费就高，家里的两老头发都半白也不能退休，还要再撑几年。平时我和我女朋友两个人每个月都记帐，省吃俭用的，家里除了床和书桌什么都没有了；我每个月还抓紧时间赚点小钱帮补一下，也都只是想帮帮家里，让两老放心。可是别的人就是可以开跑车，家里什么电器都齐全，过着奢华而豪放的日子。

我并不是想引起什么纠纷，也无意贬低什么人，更不是妒忌他们；我只是想在这里说说，如果你家里真的有实力，你可以花那些豪钱，但也不要忘了留学真正的目的。

等胜利完成了学业后，花自己挣的钱才是最开心和满足的事啊……