数据结构和算法（10）：B-树

B-树：大数据

现代电子计算机发展速度空前，就存储能力而言，情况似乎也是如此：如今容量以TB计的硬盘也不过数百元，内存的常规容量也已达到GB量级。
然而从实际应用的需求来看，问题规模的膨胀却远远快于存储能力的增长。
在同等成本下，存储器的容量越大（小）则访问速度越慢（快）。

实践证明，分级存储是行之有效的方法。在由内存与外存（磁盘）组成的二级存储系统中，数据全集往往存放于外存中，计算过程中则可将内存作为外存的高速缓存，存放最常用数据项的复本。借助高效的调度算法，如此便可将内存的“高速度”与外存的“大容量”结合起来。

两个相邻存储级别之间的数据传输，统称I/O操作。（各级存储器的访问速度相差悬殊，故应尽可能地减少I/O操作）
以内存与磁盘为例，其单次访问延迟大致分别在纳秒（ns）和毫秒（ms）级别，相差5至6个数量级。对内存而言的一秒/一天，相当于磁盘的一星期/两千年。

多路搜索树(二叉搜索树与四路搜索树)：将通常的二叉搜索树，改造为多路搜索树——在中序遍历的意义下，这也是一种等价变换。
以两层为间隔，将各节点与其左、右孩子合并为“大节点”：原节点及其孩子的共三个关键码予以保留；孩子节点原有的四个分支也予以保留并按中序遍历次序排列；节点到左、右孩子的分支转化为“大节点”内部的搜索，在图中表示为水平分支。如此改造之后，每个“大节点”拥有四个分支，故称作四路搜索树。

B-树：结构

所谓 $m$ 阶 B-树，即 $m$ 路平衡搜索树（$m\ge 2$）

所有外部节点的深度统一相等。同时，每个内部节点都存有不超过m - 1个关键码，以及用以指示对应分支的不超过 m 个引用。
具体地，存有 $n\le m-1$ 个关键码：$K_1<K_2<K_3<K_4<...<K_n$ 的内部节点，同时还配有 $n+1\le m$ 个引用：$A_0<A_1<A_2<A_3<A_4<...<A_n$。
反过来，各内部节点的分支数也不能太少。具体地，除根以外的所有内部节点，都应满足：$n+1\ge [m/2]$，而在非空的 B-树中，根节点应满足：$n+1\ge 2$。
由于各节点的分支数介于$[m/2]$ 至 $m$ 之间，故 $m$ 阶B-树也称作 ($m/2$, m)-树。

所有叶节点的深度统一相等。
计算B-树高度时，还需要计入其最底层的外部节点：树高 h = 外部节点的深度

实现

B-树节点

#include "../vector/vector.h"
#define BTNodePosi(T) BTNode<T>* //B-树节点位置

template <typename T> struct BTNode { //B-树节点模板类
// 成员（为简化描述起见统一开放，读者可根据需要迕一步封装）
	BTNodePosi(T) parent; //父节点
	Vector<T> key; //关键码向量
	Vector<BTNodePosi(T)> child; //孩子向量（其长度总比key多一）
// 构造函数（注意：BTNode叧能作为根节点创建，而且初始时有0个关键码和1个空孩子指针）
	BTNode() { parent = NULL; child.insert ( 0, NULL ); }
	BTNode ( T e, BTNodePosi(T) lc = NULL, BTNodePosi(T) rc = NULL ) {
		parent = NULL; //作为根节点，而且初始时
		key.insert ( 0, e ); //叧有一个关键码，以及
		child.insert ( 0, lc ); child.insert ( 1, rc ); //两个孩子
	if ( lc ) lc->parent = this; if ( rc ) rc->parent = this;
	}
};

B-树

#include“BTNode.h” //引入B-树节点类

template <typename T> class BTree [ //B-树模板类
protected:
	int _size;//存放的关键码总数
	int _order; //B-树的阶次，至少为3--创建时指定，一般不能修改
	BTNodePosi(T)_root; //根节点
	BTNodePosi(T)_hot; //BTree::search()最后访问的非空( 除非树空)的节点位置
	void solveOverflow ( BTNodePosi(T) ); //因插入而上溢之后的分裂处理
	void solveUnderflow ( BTNodePosi(T) ); //因删除而下溢之后的合并处理
public:
	BTree ( int order = 3 ): _order ( order )，_size (  ) //构造函数:默认为最低的3阶
	{_root = new BTNode<T>();}
	~BTree(){ if ( _root ) release ( _root );} //析构函数:释放所有节点
	int const order(){ return _order; } //阶次
	int const size(){ return _size; } //规模
	BTNodePosi(T) & root() { return_root;} //树根
	bool empty() const { return !_root;} //判空
	BTNodePosi(T) search ( const T& e ); //查找
	bool insert ( const T& e ); //插入
	bool remove ( const T& e ); //删除
}; //BTree

B-树：查找

只载入必需的节点，尽可能减少 I/O 操作。

可以将大数据集组织为 B-树并存放于外存。对于活跃的B-树，其根节点会常驻于内存；此外，任何时刻通常只有另一节点（称作当前节点）留驻于内存。

过程：
先以根节点作为当前节点，然后再逐层深入。若在当前节点（所包含的一组关键码）中能够找到目标关键码，则成功返回。否则（在当前节点中查找“失败”），则必可在当前节点中确定某一个引用（“失败”位置），并通过它转至逻辑上处于下一层的另一节点。若该节点不是外部节点，则将其载入内存，并更新为当前节点，然后继续重复上述过程。

实现

template<typename T> BTNodePosi(T) BTree<T>::search ( const T& e ) //在B-树中查找关键码e
	BTNodePosi(T) v =_root; _hot = NULL; //从根节点出发
	while ( v ){ //逐层查找
		Rank r = v->key.search ( e ); //在当前节点中，找到不大于e的最大关键码
		if ( ( 0 <= r ) && ( e == v->key[r] ) ) return v; //成功:在当前节点中命中目标关键码
		_hot = v; v = v->hild[r + 1]; //否则，转入对应子树(_hot指向其父)--需做I/0，最费时间
	}//这里在向量内是二分查找，但对通常的_order可直接顺序查找
	return NULL; //失败:最终抵达外部节点
}

成功时返回目标关键码所在的节点，上层调用过程可在该节点内进一步查找以确定准确的命中位置；失败时返回对应外部节点，其父节点则由变量_hot指代。

性能分析

B-树查找操作所需的时间消耗于两个方面：1.将某一节点载入内存；2.在内存中对当前节点进行查找。
对于高度为h的B-树，外存访问不超过O(h - 1)次.

若存有N个关键码的m阶B-树高度为h，则必有：${\log }_m(N+1)\le h\le lo{g}_{[m/2]}[(N+1)/2]+1$
也就是说，存有N个关键码的m阶B-树的高度 $h=\Theta ({\log }_{m}N)$。

每次查找过程共需访问 $O({\log }_{m}N)$ 个节点，相应地需要做 $O({\log }_{m}N)$ 次外存读取操作。由此可知，对存有 $N$ 个关键码的 $m$ 阶B-树的每次查找操作，耗时不超过 $O(lo{g}_{m}N)$。

尽管没有渐进意义上的改进，但相对而言极其耗时的I/O操作的次数，却已大致缩减为原先的1/log2 m。

B-树：插入

关键码插入

template <typename T> boo BTree<T>::insert ( const T& e ){ //将关键码e插入B树中
	BTNodePosi(T) v = search ( e ); if ( v )return false; //确认目标节点不存在
	Rank r = _hot->key.search ( e ); //在节点_hot的有序关键码向量中查找合适的插入位置
	_hot->key.insert ( r + 1，e ); //将新关键码插至对应的位置
	_hot->child.insert ( r + 2，NULL ); //创建一个空子树指针
	_size++;//更新全树规模
	solveOverflow (_hot); //如有必要，需做分裂
	return true; //插入成功
}

为在B-树中插入一个新的关键码 e，首先调用search(e)在树中查找该关键码。若查找成功，则按照“禁止重复关键码”的约定不予插入，操作即告完成并返回false。

查找过程必然终止于某一外部节点v，且其父节点由变量_hot指示。当然，此时的_hot必然指向某一叶节点（可能同时也是根节点）。接下来，在该节点中再次查找目标关键码e。尽管这次查找注定失败，却可以确定e在其中的正确插入位置r。最后，只需将e插至这一位置。

至此，_hot所指的节点中增加了一个关键码。若该节点内关键码的总数依然合法（即不超过m - 1个），则插入操作随即完成。否则，称该节点发生了一次上溢（overflow），此时需要通过适当的处理，使该节点以及整树重新满足B-树的条件。

上溢与分裂

一般地，刚发生上溢的节点，应恰好含有 $m$ 个关键码。若取 $s=[m/2]$，则它们依次为：$\{k_0,...,k_{s-1};k_s;k_{s+1},...,k_{m-1}\}$。可见，以 $k_s$ 为界，可将该节点分前、后两个子节点，且二者大致等长。于是，可令关键码 $k_s$上升一层，归入其父节点（若存在）中的适当位置，并分别以这两个子节点作为其左、右孩子。这一过程，称作节点的分裂。

实现

template<typename T> //关键码插入后若节点上溢，则做节点分裂处理
void BTree<T>::solveOverflow ( BTNodePosi(T) v ) {
	if (_order >= v->child.size() ) return; //递归基:当前节点并未上溢
	Rank s = _order / 2; //轴点(此时应有_order = key.size() = child.size() - 1)
	BTNodePosi(T) u = new BTNode<T>();//注意:新节点已有一个空孩子
	for ( Rank j= 0;j< _order - s - 1; j++ ) {//v右侧_order-s-1个孩子及关键码分裂为右侧节点u
		u->child.insert ( j，v->child.remove ( s +1));//逐个移动效率低
		u->key.insert ( j，v->key.remove ( s +1));//此策略可改进
	}
	u->child[_order -  - 1] = V->child.remove ( s +  );//移动v最靠右的孩子
	if ( u->child[e] ) //若u的孩子们非空，则
		for ( Rank j= ;j< _order - s; j++ ) //令它们的父节点统一
			u->child[j]->parent = u; //指向u
	BTNodePosi(T) p = v->parent; //v当前的父节点p
	if ( !p )[_root = p = new BTNode<T>(); p->child[0] = v; v->parent = p;} //若p空则创建之
	Rank r = 1 + p->key.search ( v->key[0] ); //p中指向u的指针的秩
	p->key.insert ( r，v->key.remove ( s ) ); //轴点关键码上升
	p->child.insert (r + 1，u );
	u->parent = p;//新节点u与父节点p互联
	solveOverflow ( p ); //上升一层，如有必要则继续分裂——至多递归O(logn)层
}

上溢持续传播至根的情况：原树根分裂之后，新创建的树根仅含单关键码。由此也可看出，就B-树节点分支数的下限要求而言，树根节点的确应该作为例外。

复杂度

若将B-树的阶次m视作为常数，则关键码的移动和复制操作所需的时间都可以忽略。至于solveOverflow()算法，其每一递归实例均只需常数时间，递归层数不超过B-树高度。由此可知，对于存有N个关键码的m阶B-树，每次插入操作都可在O(logm N)时间内完成。

B-树：删除

template <typename T> bool BTree<T>::remove ( const T& e ) { //从BTree树中删除关键码e
	BTNodePosi(T) v = search ( e ); if ( !v ) return false;	//确认目标关键码存在
	Rank r = v->key.search ( e );//确定目标关键码在节点v中的秩（由上，肯定合法)
	if ( v->child[0] ) {	//若v非叶子，则e的后继必属于某叶节点
		BTNodePosi(T) u = v->child[r+1];	//在右子树中一直向左，即可
		while ( u->child[0] ) u = u->child[0];	//找出e的后继
		v->key[r] = u->key[e]; v = u; r = 0;	//并与之交换位置
		}	//至此，v必然位于最底层，且其中第r个关键码就是待删除者
	v->key. remove ( r ); v->child.remove ( r + 1 ); _size--;	//删除e，以及其下两个外部节点之一
	solveUnderflow ( v );//	如有必要，需做旋转或合并
return true;

为从 B-树中删除关键码 e，也首先需要调用 search(e) 查找 e 所属的节点。倘若查找失败，则说明关键码 e 尚不存在，删除操作即告完成：否则按照代码的出口约定，目标关键码所在的节点必由返回的位置v指示。此时，通过顺序查找，即可进一步确定e在节点v中的秩r。

不妨假定v是叶节点——否则，e的直接前驱（后继）在其左（右）子树中必然存在，而且可在O(height(v))时间内确定它们的位置，其中height(v)为节点v的高度。此处不妨选用直接后继。于是，e的直接后继关键码所属的节点u必为叶节点，且该关键码就是其中的最小者u[0]。既然如此，只要令e与u[0]互换位置，即可确保待删除的关键码e所属的节点v是叶节点。

接下来可直接将e（及其左侧的外部空节点）从v中删去。如此，节点v中所含的关键码以及（空）分支将分别减少一个。若该节点所含关键码的总数依然合法（即不少于[m/2] - 1），则删除操作随即完成。否则，称该节点发生了下溢，并需要通过适当的处置，使该节点以及整树重新满足 B-树的条件。

下溢与合并

在m阶B-树中，刚发生下溢的节点V必恰好包含[m/2] - 2个关键码和[m/2] - 1个分支。

1.V 的左兄弟 L 存在，且至少包含 [m/2] 个关键码
将y从节点P转移至节点V中（作为最小关键码），再将x从L转移至P中（取代原关键码y）

2.V 的右兄弟 R 存在，且至少包含 [m/2]个

3.V 的左、右兄弟 L 和R 或者不存在，或者其包含的关键码均不足 [m/2] 个

从父节点P中抽出介于L和V之间的关键码y，并通过该关键码将节点L和V“粘接”成一个节点——这一过程称作节点的合并。

在经如此合并而得新节点中，关键码总数应为：([m/2] - 1) + 1 + ([m/2] - 2) = 2*[m/2] - 2 <= m - 1
故原节点V的下溢缺陷得以修复，而且同时也不致于反过来引发上溢。

修复之后仍可能导致祖父节点以及更高层节点的下溢——这种现象称作下溢的传递。特别地，当下溢传递至根节点且其中不再含有任何关键码时，即可将其删除并代之以其唯一的孩子节点，全树高度也随之下降一层。

与上溢传递类似地，每经过一次下溢修复，新下溢节点的高度都必然上升一层。整个下溢修复的过程中至多需做O(log m N)次节点合并操作。

复杂度

与插入操作同理，在存有N个关键码的m阶 B-树中的每次关键码删除操作，都可以在O(logm N)时间内完成。另外同样地，因某一关键码的删除而导致 $\mathcal{O}(logmN)$ 次合并操作的情况也极为罕见，单次删除操作过程中平均只需做常数次节点的合并。