严蔚敏 - 数据结构

1. 三.B- 树
1 ．定义
2 ．查找过程
3 ．插入操作
4 ．删除操作
5 ．查找性能的分析

2. 1 ． B- 树的定义
B- 树是一种 平衡 的 多路查找 树 , 多用在文件
系统中 . 一棵 m 阶的 B- 树 , 或为空树 , 或为满足
下列特征的 m 叉树 .
• 树中每个结点至多有 m 棵子树 ;
• 若根结点不是叶子结点 , 则至少有两棵子树
• 除根之外的所有非终端结点至少有 ┌ m/2 ┐ 棵
子树
• 所有的非终端结点中包含下列信息数据
(n,A0,K1,A1,K2,A2,...,Kn,An)

3. 在 m 阶的 B- 树上，每个非终端结
点可能含有：
n 个 关键字 Ki （ 1≤ i≤n ） n<m
n 个 指向记录的指针 Di （ 1≤i≤n ）
n+1 个 指向子树的指针
多叉树的特性
Ai （ 0≤i≤n ）

4. • 非叶结点中的多个关键字均自小至大
有序排列，即： K1< K2 < … < Kn ；
• Ai-1 所指子树上所有关键字均小于 Ki
；
查找树的特性
• Ai 所指子树上所有关键字均大于 Ki
；

5. • 树中所有叶子结点均不带信息，且在
树中的同一层次上；
平衡树的特性

6. n Key
root 1 A0 50 A1
A0 50 A1 Key1 Key2
1 A0 15 A1 2 A0 71 A1 84 A2
15 71 84
A0 A1 A0 A2
A1
3 8 20 26 43 56 62 78 89 96
注 : 该结构示意图中省略了结点指向每个关键
字的记录的指针 Di( 1≤ i ≤ n ).

7. B- 树结构的 C 语言描述如下 :
typedef struct BTNode {
int keynum; // 结点中关键字个数，结点大小
struct BTNode *parent;
// 指向双亲结点的指针
KeyType key[m+1]; // 关键字（ 0 号单元不用）
Record *recptr[m+1]; // 记录指针向量
struct BTNode *ptr[m+1]; // 子树指针向量
} BTNode, *BTree; // B 树结点和 B 树的类型

8. 2. 查找过程： n Key
root 1 A0 50 A1
A0 50 A1 Key1 Key2
1 A0 15 A1 2 A0 71 A1 84 A2
15 71 84
A0 A1 A0 A2
A1
3 8 20 26 43 56 62 78 89 96
查找 :43 查找成功
查找 :60 查找不成功

9. 从根结点出发，沿指针搜索结点和在
结点内进行顺序（或折半）查找 两个过程
交叉进行。
若查找成功，则返回指向被查关键字所
在结点的指针和关键字在结点中的位置
；
若查找不成功，则返回插入位置。

10. 假设返回的是如下所述结构的记录：
typedef struct {
BTNode *pt; // 指向找到的结点的指针
int i; // 1..m ，在结点中的关键字序号
int tag; // 标志查找成功 (=1) 或失败 (=0)
} Result; // 在 B 树的查找结果类型

11. Result SearchBTree(BTree T, KeyType K) {
// 在 m 阶的 B- 树 T 中查找关键字 K, 返回
// 查找结果 (pt, i, tag) 。若查找成功，则
// 特征值 tag=1, 指针 pt 所指结点中第 i 个
// 关键字等于 K ； 否则特征值 tag=0, 等于
// K 的关键字应插入在指针 pt 所指结点
// 中第 i 个关键字和第 i+1 个关键字之间
… …
} // SearchBTree

12. // 初始化 ,p 指向待查结点 ,q 指向 p 的双亲
p=T; q=NULL; found=FALSE; i=0;
while (p && !found) {
n=p->keynum;
// 在 p->key[1..n] 中查找 i, p-key[i]<=K<p->key[i+1]
i=Search(p, K);
if (i>0 && p->key[i]= =K) found=TRUE;
else { q=p; p=p->ptr[i]; } // q 指示 p 的双亲
}
if (found) return (p,i,1); // 查找成功
else return (q,i,0); // 查找不成功

13. 3 ．插入
在查找不成功之后，需进行插入。
显然，关键字插入的位置必定在最下
层的非叶结点，有下列几种情况：
1 ）插入后，该结点的关键字个数
n<m ，不修改指针 ;

14. 2 ）插入后，该结点的关键字个数 n=m ，
则 需进行 “ 结点分裂 ” ，令 s = m/2 ，
在原结点中保留
（ A0 ， K1 ， …… ， Ks-1 ， As-1 ）；
建新结点
（ As ， Ks+1 ， …… ， Kn ， An ）；
将（ Ks ， p ）插入双亲结点；
3 ）若双亲为空，则建新的根结点。

15. 例如 : 下列为 3 阶 B- 树
50
30 50 50 80 80
3050 80
∧ 20 20 40 ∧ ∧ 40 ∧ ∧ 60∧60∧ ∧
∧ ∧ ∧ ∧ ∧
∧60∧80∧90∧
∧ 80 80 ∧90∧
插入关键字 = 60, 90, 30,

16. 在 B- 树上插入关键字的算法
Status InsertBTree ( ETree &T, KeyType K, BTree q, int i){
// 在 m 阶 B- 树 T 上结点 *q 的 key[i] 与 key[i+1] 之间插入
关键字 K. 若引起结点过大 , 则沿双亲链进行必要的结点
分裂调整 , 使 T 仍是 m 阶 B- 树 .
{ x=K; ap=NULL; finished = FALSE;
while (q&&!finished) {
// 将 x 和 ap 分别插入到 q->key[i+1] 和 q->ptr[i+1]
Insert(q,i,x,ap);
if (q->keynum < m) finished = TRUE; // 插入完成
else { // 分裂结点 *q
...

17. 在 B- 树上插入关键字的算法
s=[m/2]; split(q,s,ap); x=q->key[s];
// 将 q->key[s+1..m],q->recptr[s+1..m] 及 q->ptr[s..m] 移入新
结点 *ap
q = q->parent;
if (q) i = Search(q,x); // 在双亲结点 *q 中查找 x 的插入位置
} //end else
} //end while
//T 是空树 ( 参数 q 的初值为 NULL) 或根结点已经分裂为结
点 *q 和 *ap
if (!finished) NewRoot(T,q,x,ap); // 生成含信息 (T,x,ap)
的新的根结点 *T, 原 T 和 ap 为子树指针
return OK;
} //InsertBTree

18. 4 ．删除
和插入的考虑相反，首先必须找到
待删关键字所在结点，并且要求删除之后
，结点中关键字的个数不能小于
于 m/2-1 ，否则，要从其左 ( 或右 ) 兄弟
结点“ 借调 ” 关键字，若其左和右兄弟结点
均无关键字可借 ( 结点中只有最少量的关
键字 ) ，则必须进行结点的“ 合并 ” 。有下
列三种可能 :

19. 1. 被删关键字所在结点中的关键字数目不小于
于 m/2 ，则只需从该结点中删去该关键字 Ki
和相应指针 Ai ，树的其它部分不变。
45
24 53 90
∧ ∧ 3∧
3∧12∧ ∧ 37 ∧ ∧50∧ ∧61∧70 ∧ ∧100∧
删除关键字 = 12

20. 2. 被删关键字所在结点中的关键字数目等于
于 m/2- 1 ，而与该结点相邻的右兄弟（或左兄弟
）结点中的关键字数目大于于 m/2- 1 ，则需将其
兄弟结点中的最小（或最大）关键字上移至双亲结
点中，而将双亲结点中小于（或大于）且紧靠该上
移关键字的关键字下移至被删结点中。
45 删除关键字 = 50
24 53 90
∧ 3∧ ∧ 37 ∧ ∧ 50∧ ∧ 61∧70 ∧ ∧100∧

21. 3. 被删关键字所在结点和其相邻的兄弟结点中的关
键字数目均等于于 m/2- 1 ，假设该结点有兄弟结
点，且其右兄弟结点地址由双亲结点中的 A i 所指，
则在删去关键字之后，它所在结点中剩余的关键字
和指针，加上双亲结点中的关键字 Ki ，合并到 A i 所
指兄弟结点中（若没有右兄弟，则合并至左兄弟结
点中）。
45 删除关键字 = 53
24 61 90
∧ 3∧ ∧ 37 ∧ ∧53∧ ∧70 ∧ ∧100∧

22. 5 ．查找性能的分析
在 B- 树中进行查找时，其查找
时间
主要花费在搜索结点（访问外存）
上，即主要取决于 B- 树的深度。
问：含 N 个关键字的 m 阶 B- 树
可能达到的最大深度 H 为多少？

23. 反过来问： 深度为 H 的 B- 树中，
至少含有多少个结点？
先推导每一层所含最少结点数：
第 1 层 1 个
第 2 层 2 个
第 3 层 2×m/2 个
第 4 层 2×(m/2)2 个
… …
第 H+1 层 2×(m/2) H-1 个

24. 假设 m 阶 B- 树的深度为 H+1 ，由
于
第 H+1 层为叶子 结点，而当前树中含有
N 个关键字，则叶子结点必为 N+1 个，
由此可推得下列结果：
N+1≥2(m/2)H-1
H-1≤logm/2 ((N+1)/2)
H≤logm/2 ((N+1)/2)+1

25. 结论：
在含 N 个关键字的 B- 树
上进行一次查找，需访问的
结点个数不超过
logm/2 ((N+1)/2)+1

26. 四、 B 树
+
是 B- 树的一种变型

27. 1 ． B+ 树的结构特点：
※ 每个叶子结点中含有 n 个关键字
和 n 个指向记录的指针；并且，
所有叶子结点彼此相链接构成一个
有序链表，其头指针指向含最小关
键字的结点；

28. ※ 每个非叶结点中的关键字 Ki 即为
其相应指针 Ai 所指子树中关键字的
最大值；
※ 所有叶子结点都处在同一层次上 ,
每个叶子结点中关键字的个数均介
于 于 m/2 和 m 之间。

29. root
50 96
15 50 62 78 96
sq
3 8 15 20 26 43 56 62 71 78 84 89
50 96

30. B+ 树上的查找 , 插入与删除
1) 查找 : 在 B+ 的查找不中途退出 . 不论成功
与否 , 都是走了一条从根到叶子结点的路径 .
root
查找 :62
50 96
15 50 62 78 96
sq
3 8 15 20 26 43 56 62 71 78 84 89
50 96

31. B+ 树上的查找 , 插入与删除
2) 插入 : 仅在叶子结点上进行 , 当
结点中的关键字个数大于 m 时 ,
要分裂成两个结点 , 它们所含有
的关键字个数分别为 [(m+1)/2]. 且
双亲结点中应同时包含两个结点
中最大关键字 .

32. 插入 :25
root
50 96
15 50 62 78 96
sq
3 8 15 20 26 43 56 62 71 78 84 89
50 96
20 25 26 43 50

33. B+ 树上的查找 , 插入与删除
3) 删除 : 仅在叶子结点上进行 . 当叶子
结点中的最大关键字被删除时 , 其在
非终端结点中的值可以作为一个 “
分界关键字”存在 . 当因删除使结点
中关键字的个数少于 [m/2] 时 , 其和兄
弟结点的合并过程亦和 B- 树类似 .

34. 删除 删除 :50
root
50 96
15 50
sq 分界关键字 62 78 96
3 8 15 20 26 43 56 62 71 78 84 89
50 96