《算法导论》练习18.3-2： 请写出B-TREE-DELETE的伪代码。

与插入情况相对称，除了根结点外（根结点个数不能少于1），B树的关键字数不能少于t-1个。对于简单删除情况，如果我们定位到关键字处在某个结点中，如果这个结点中关键字个数恰好是t-1个，如果直接删除这个关键字，就会违反B树规则。

此时，需要考虑两种处理方案：

1)把这个结点与其相邻结点合并，合并时需要把父结点的一个关键字加进来，除非相邻的那个结点的关键字数也是t-1个，否则，合并后会超出2t-1的限制，同样违反B树规则。而且，因为从父结点拉下一个关键字，导致父结点的关键字数少1，如果原来父结点关键字数是t-1，那么父结点违反B树规则，这种情况下，必须进行回溯处理。（对于下图（a）初始树，删除结点Z就会出现这种情况）

2）从相邻结点借一个关键字过来，这种情况要求，相邻结点必须有多于t-1个关键字，借的过程中，需要转经父结点，否则违反B树规则。

为了避免回溯，要求我们在从树根向下搜索关键字的过程中，凡是遇到途经的结点，如果该结点的关键字数是t-1，则我们需要想办法从其他地方搞个关键字过来，使得该结点的关键字数至少为t。

搞，也是从相邻结点搞，如果相邻结点有的话，当然，也要经过父结点进行周转。如果没有，就说明相邻结点的关键字个数也是t-1，这种情况，直接对该结点与其相邻结点进行合并，以满足要求。

B树的结点的合并基于如下情况调用：内结点x的第i个子结点y和第i+1个子结点z的关键字数都是t-1，此时需要把内结点x的第i个关键字下移与y和z的合并，形成一个结点y。

B树中结点的合并：

B-TREE-MERGE-CHILD(x, i, y,z)

1 n[y] ← 2t -1

2 for j ← t +1 to 2t -1

3   do key_j[y] ← key_j–t[z]

4 key_t[y] ← key_i[x]

5 if not leaf[y]

6  then for j ← t +1 to 2t -1

7        do c_j[y] ← c_j–t[z]

8 for j ← i +1 to n[x]

9  do c_j[x] ← c_j+1[x]

10 n[x] ← n[x] -1

11 FREE-NODE(z)

12 DISK-WRITE(y)

13 DISK-WRITE(z)

14 DISK-WRITE(x)

B树的删除：

B-TREE-DELETE(T,k)

1  r ← root[T]

 2  if n[r] = 1

 3    then DISK_READ(c1[r])

 4       DISK_READ(c2[r])

 5       y ←c1[r]

 6       z ←c2[r]

 7       if n[y] = n[z] = t-1                   ▹ Cases 2c or 3b

 8         then  B-TREE-MERGE-CHILD(r, 1, y, z) 

 9            root[T] ← y

 10           FREE-NODE(r)

 11           B-TREE-DELETE-NONONE(y, k)

12      else B-TREE-DELETE-NONONE (r, k)

13 else B-TREE-DELETE-NONONE (r, k)

考虑到根结点的特殊性，对根结点为1，并且两个子结点都是t-1的情况进行了特殊的处理：

先对两个子结点进行合并，然后把原来的根删除，把树根指向合并后的子结点y。

这样B树的高度就减少了1。这也是B树高度唯一会减少的情况。 

除了这种情况以外，就直接调用子过程B-TREE-DELETE-NONONE (x, k)。

B-TREE-DELETE-NONONE (x, k)

1  i ← 1

 2  if leaf[x]                                       ▹ Cases 1

 3     then while i <= n[x] and k > keyi[x]

 4            do i ← i + 1

 5               if k = keyi[x]

 6                 then for j ← i+1 to n[x]

 7                        do keyj-1[x] ←keyj[x]

 8                      n[x] ← n[x] - 1

 9                      DISK-WRITE(x)

 10              else error:”the key does not exist”

 11    else while i <= n[x] and k > keyi[x]

12           do i ← i + 1

 13              DISK-READ(ci[x])

 14              y ←ci[x]

 15              if i <= n[x]

 16                then DISK-READ(ci+1[x])

 17                     z ←ci+1[x]

 18              if k = keyi[x]                          ▹ Cases 2

19                then if n[y] > t-1                   ▹ Cases 2a

 20                       then k′←B-TREE-SEARCH-PREDECESSOR(y)

 21                            B-TREE-DELETE-NONONE (y, k′)

 22                            keyi[x] ←k′

 23                     else if n[z] > t-1               ▹ Cases 2b

 24                       then k′←B-TREE-SEARCH-SUCCESSOR (z)

 25                            B-TREE-DELETE-NONONE (z, k′)

 26                            keyi[x] ←k′

 27                     else B-TREE-MERGE-CHILD(x, i, y, z)▹ Cases 2c

 28                          B-TREE-DELETE-NONONE (y, k)

 29              else                                   ▹ Cases 3

 30                if i >1

 31                  then DISK-READ(ci-1[x])

 32                       p ←ci-1[x]

 33                if n[y] = t-1 

 34                  then if i>1 and n[p] >t-1               ▹ Cases 3a

 35                         then B-TREE-SHIFT-TO-RIGHT-CHILD(x,i,p,y)

 36                       else if i <= n[x] and n[z] > t-1    ▹ Cases 3a

 37                         then B-TREE-SHIFT-TO-LEFT-CHILD(x,i,y,z)

 38                       else if i>1                       ▹ Cases 3b

 39                         then B-TREE-MERGE-CHILD(x, i, p, y)  

 40                              y ← p

 41                       else B-TREE-MERGE-CHILD(x, i, y, z)▹ Cases 3b

 42                B-TREE-DELETE-NONONE (y, k)

查找前驱

B-TREE-SEARCH-PREDECESSOR(y)

1  x ← y

2  i ← n[x]

3  while not leaf[x]

4    do DISK_READ(ci+1[x])

5       x ←ci+1[x]

6       i ← n[x]

7  return keyi[x]

查找后继

B-TREE-SEARCH-SUCCESSOR (z)

1  x ← z

2  while not leaf[x]

3    do DISK_READ(c1[x])

4       x ←c1[x]

5  return key1[x]

转移到右边的子结点

B-TREE-SHIFT-TO-RIGHT-CHILD(x,i,y,z)

1 n[z] ← n[z] +1

2 j ← n[z]

3 while j > 1

4   do keyj[z] ←keyj-1[z]

5      j ← j -1

6 key1[z] ←keyi[x]

7 keyi[x] ←keyn[y][y]

8 if not leaf[z]

9   then j ← n[z]

10       while j > 0

11         do cj+1[z] ←cj[z]

12            j ← j -1

13       c1[z] ←cn[y]+1[y]

14 n[y] ← n[y] -1

15 DISK-WRITE(y)

16 DISK-WRITE(z)

17 DISK-WRITE(x)

转移到左边的子结点

B-TREE-SHIFT-TO-LEFT-CHILD(x,i,y,z)

1 n[y] ← n[y] +1

2 keyn[y][y] ← keyi[x]

3 keyi[x] ←key1[z]

4 n[z] ← n[z] -1

5 j ← 1

6 while j <= n[z]

7   do keyj[z] ←keyj+1[z]

8      j ← j +1

9 if not leaf[z]

10  then cn[y]+1[y] ←c1[z]

11       j ← 1

12       while j <= n[z]+1

13         do cj[z] ←cj+1[z]

14            j ← j + 1

15 DISK-WRITE(y)

16 DISK-WRITE(z)

17 DISK-WRITE(x)

注意：每次递归调用前，程序都能保证包括关键字的子树根的关键字数至少为t（除了根结点外），

这是B-TREE-DELETE-NONONE子过程能够正确运行的关键，类似的，

可以用循环不变式证明B-TREE-DELETE-NONONE子过程的正确性。