B-树，B+树，B*树

---

B-树

为什么需要B-树

种类	数据格式	时间复杂度
顺序查找	无要求	O(N)
二分查找	有序	O( log2N)
二叉搜索树	无要求	O(N)
二叉平衡树(AVL树和红黑树)	无要求	O( log2N)
哈希	无要求	O(1)
位图	无要求	O(1)
布隆过滤器	无要求	O(K)(K为哈希函数个数，一般比较小)

以上结构适合用于数据量不是很大的情况，如果数据量非常大，一次性无法加载到内存中，使用上述结构就不是很方便。比如：使用平衡树搜索一个大文件。

从上面可以看出在外查找中，红黑树或AVL树的缺陷：

1. 每一层都需要通过地址从磁盘中获取key进行比较，树的高度比较高，查找时最差情况下要比较树的高度次。
2. 数据量如果特别大时，树中的节点可能无法一次性加载到内存中，需要多次IO。

那如何加速对数据的访问呢？

1. 提高IO的速度。
2. 降低树的高度，使其成为多叉树平衡树。

B-树的性质

一棵M阶(M>2)的B树，是一棵平衡的M路平衡搜索树，可以是空树或者满足以下性质：

1. 根节点关键字的数量[1,M-1],孩子的数量[2,2M]
2. 每个非根节点至少有(M/2-1)个关键字，至多有M-1个关键字，并且以升序排列(满了就会分裂)
3. 每个非根,非叶子节点至少有M/2个孩子，至多有M个孩子(关键字+1)
4. 一个节点中的关键字按照升序排列，孩子的数量比关键字的个数多1
5. 所有叶子节点都在同一层(横/上 增长)
6. key[i] 和 key[i+1] 之间的孩子节点的值介于key[i]、key[i+1] 之间(二叉树搜索树性质)

通过这种方式，B树压缩了树的高度。

为了保证key的数量，比孩子的数量少一个，新插入的值都是插入到叶子节点之中，当某个节点满了，进行分裂，新创建一个兄弟节点，拷贝右半区间到兄弟节点，中位数提取到放到父亲处（因为分裂新增了一个兄弟节点，对于父亲而言多了一个孩子，还得多一个关键字，这样才能保持孩子的数量永远比关键字数量多一个的特性），如果没有父亲则创建新的根，分裂出来的两个节点分别做这个中位数的左右孩子。

分裂规则中，只有根节点分裂，才会增加高度，新增一层。所以新节点永远是横向和向上增长，因此叶子节点永远在同一层。

B-树的性能分析

对于度为M的B-树，每一个节点的子节点个数为(M/2-1)到(M-1)之间，因此树的高度应该在要log_(m-1)N 和log_(m/2)N 之间，在定位到该节点后，再采用二分查找的方式可以很快的定位到该元素，所以查找和插入需要log_(m-1)N ~l og_(m/2)N 次比较。

• 我们的外存，比如硬盘，是将所有的信息分割成相等大小的页面，每次硬盘读写的都是一个或多个完整的页面，对于一个硬盘来说，一页的长度可能是211到214个字节。
• 在一个典型的B树应用中，要处理的硬盘数据量很大，因此无法一次全部装入内存。因此我们会对B树进行调整，使得B树的阶数（或结点的元素）与硬盘存储的页面大小相匹配。
• 比如说一棵B树的阶为1001（即1个结点包含1000个关键字），高度为2，它可以储存超过10亿个关键字，我们只要让根结点(数据的地址)持久地保留在内存中，那么在这棵树上，寻找某一个关键字至多需要两次硬盘的读取即可。
• 这就好比我们普通人数钱都是一张一张的数，而银行职员数钱则是五张、十张，甚至几十张一数，速度当然是比常人快了不少。通过这种方式，在有限内存的情况下，每一次磁盘的访问我们都可以获得最大数量的数据(放在同一层)。由于B树每结点可以具有比二叉树多得多的元素，所以与二叉树的操作不同，它们减少了必须访问结点和数据块的数量，从而提高了性能。可以说，B树的数据结构就是为内外存的数据交互准备的。
• B-树的搜索，从根结点开始，对结点内的关键字（有序）序列进行二分查找，如果命中则结束，否则进入查询关键字所属范围的儿子结点；重复，直到所对应的儿子指针为空，或已经是叶子结点；

代码实现

struct BTreeNode
{
	//孩子的数量比关键字数量多一个
	//多给一个空间，方便插入以后再分裂
	pair<K, V> _kvs[M];
	BTreeNode<K, V, M>* _child[M+1];

	BTreeNode<K, V, M>* _parent;//父指针

	size_t _kvSize;//记录存储了多少个关键字

	BTreeNode()
		:_parent(nullptr)
		, _kvSize(0)
	{
		for (int i = 0; i < M + 1; i++)
		{
			_child[i] = nullptr;//创建一个新节点，孩子节点全部置为空
		}
	}
};

template<class K, class V, size_t M>
class BTree
{
	typedef BTreeNode<K, V, M> Node;
public:
	pair<Node*, int> Find(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root; //从根节点开始搜索
		while (cur)
		{
			int i = 0;
			//寻找当前节点当中的关键字
			while (i < cur->_kvSize) //如果M比较大，换成二分查找
			{
				if (cur->_kvs[i].first < key)//key大于当前位置，往右边找
					i++;
				else if (cur->_kvs[i].first > key)//key小于当前位置，往左孩子找
					break;
				else
					return make_pair(cur, i);//找到了，返回即可
			}
			//来到这里，要么当前节点的所有关键字都小于key，要么当前节点中有大于key的关键字
			//即需要继续往孩子节点中进行搜索

			parent = cur;//往下一层走之前，记录父亲
			cur = cur->_child[i];
		}
		//没有找到
		return make_pair(parent, -1);//返父亲指针
	}



	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)//根节点为空
		{
			_root = new Node;
			_root->_kvs[0] = kv;//填入当前关键字
			_root->_kvSize = 1;//关键字数量++
			return true;
		}
		pair<Node*, int> ret = Find(kv.first);
		if (ret.second >= 0)
		{
			//已经有了，不能插入
			return false;
		}

		//往cur节点中插入一个kv
		//1.如果cur没满就结束
		//2.如果满了就分裂，分裂出兄弟以后，往父亲插入一个关键字和孩子，再满就继续分裂。
		//3.最坏的情况就是分裂到根，原来的根分裂产生新的根
		Node* cur = ret.first;
		Node* sub = nullptr;
		pair<K, V> newkv = kv;

		while (1)
		{
			InsertKV(cur, newkv, sub);

			if (cur->_kvSize < M)//没满，直接结束
			{
				return true;
			}
			else//满了，需要分裂
			{
				//分裂出一个兄弟节点
				Node* newnode = new Node;
				//[0,mid-1]位置的关键字留给原来的节点
				//[mid+1,M-1]位置的关键字拷贝给兄弟节点
				int mid = cur->_kvSize / 2;

				//拷贝一半的数据给兄弟节点
				size_t j = 0;
				for (int i = mid + 1; i < cur->_kvSize; i++)
				{
					newnode->_kvs[j++] = cur->_kvs[i];//拷贝关键字
					newnode->_kvSize++;//关键字总数++
				}
				//在向上分裂的过程之中，如果有孩子节点，则需要拷贝孩子节点
				//原来的保留[0,mid]的孩子
				//兄弟节点拷贝[mid+1,size]的孩子
				j = 0;
				for (int i = mid + 1; i <= cur->_kvSize; i++)
				{
					if (cur->_child[i] == nullptr)//没有孩子了
						break;

					newnode->_child[j++] = cur->_child[i];
					cur->_child[i]->_parent = newnode;//更新父节点
					cur->_child[i] = nullptr;
				}
				//原来节点留下的关键字数量=原来的-兄弟中的-交付给根节点的
				cur->_kvSize = cur->_kvSize - newnode->_kvSize - 1;
				newkv = cur->_kvs[mid];
				//将mid处位置的值，放入父节点之中
				//1.如果没有父节点，则需要创建根节点
				//2.如果有父节点，往父节点中插入mid位置的关键字
				if (cur->_parent == nullptr)//没有父节点
				{
					//创建父节点，并且将关键字填入
					_root = new Node;
					_root->_kvs[0] = newkv;
					_root->_kvSize=1;

					//填入孩子节点
					_root->_child[0] = cur;
					_root->_child[1] = newnode;

					//填入父节点指针
					cur->_parent = _root;
					newnode->_parent = _root;

					return true;
				}
				else//有父亲节点，循环调用InsertKV(cur->_parent, newkv, newnode);
				{
					sub = newnode;
					cur = cur->_parent;
				}
			}
		}
		return true;
	}
	//中序遍历，输出的数是升序的
	void Inorder()
	{
		_Inorder(_root);
	}


private:
	//往cur里面插入一个kv和sub孩子
	void InsertKV(Node* cur, const pair<K, V>& kv, Node* sub)
	{
		//从后往前寻找
		int i = cur->_kvSize;
		for (; i > 0; i--)
		{
			if (kv.first > cur->_kvs[i - 1].first)//插入的关键字，大于前面的关键字，说明是插在此位置
			{
				break;
			}
			//插入关键字小于前面的位置，则将前面的位置往后挪，同时孩子节点也需要挪动
			cur->_kvs[i] = cur->_kvs[i - 1];
			cur->_child[i + 1] = cur->_child[i];//孩子的下标比关键字大1
		}
		//填入关键字，和孩子节点
		cur->_kvs[i] = kv;
		cur->_child[i + 1] = sub;
		cur->_kvSize++;//关键字数量自增
		if (sub)
		{
			//sub父指针链接到sub
			sub->_parent = cur;
		}
	}
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;

		size_t i = 0;
		while (i < root->_kvSize)
		{
			_Inorder(root->_child[i]);//先输出左边
			cout << root->_kvs[i].first << " ";//再输出当前位置
			i++;
		}
		_Inorder(root->_child[i]);//输出右边
	}


	Node* _root = nullptr;
};

---

B+树

B+树是对B树的优化和变形，也是一种多路搜索树，其定义和B-树基本相同，差别如下：

• 每个节点中关键字的数量和孩子数量相等,相当于取消了B树最左边的左孩子

• 节点的关键字数量为[1,M]

• 非根节点关键字数量为[M/2,M]

• 所有的值(kv)都会出现在叶子节点上，并且所有的叶子节点都会用一个指针链接起来(方便遍历)，因此只需要遍历叶子节点即可。非叶子节点中只保存key，相当于路径索引。父亲中的存的key是由孩子中的最小值组成

• B+树的搜索与B-树基本相同，区别是B+树只有达到叶子节点才能命中(B-树可以在非叶子节点中命中)，其性能也等价于在关键字全集做一次二分查找。

• B+树在分裂时，拷走一半，不需要把中位数插入到父亲，非叶子节点存分裂的最小值。

B+树的特性：

1. 所有关键字都出现在叶子节点的链表中(稠密索引)，且链表中的节点都是有序的。
2. 不可能在非叶子节点中命中。
3. 非叶子节点相当于是叶子节点的索引(稀疏索引)，叶子节点相当于是存储数据的数据层。
4. 更适合文件索引系统。

B+树查找的优点

• B+树的优势主要体现在查询性能上

• B-树的每个节点都有卫星数据(索引元素指向的数据记录)，B+树中间节点没有卫星数据，这就意味着同样大小的磁盘页，B+树可以容纳更多的节点 -> B+树比B-树更加的矮胖，即IO的次数更少

• 性能上B+树也更加稳定，因为B-树只需要找到匹配元素即可，B+树必须查询到叶子节点

• 相对于B树，B+树适合文件索引系统：

1. B+树空间利用率更高，因为B+树的内部节点只是作为索引使用，而不像B-树那样每个节点都需要存储硬盘指针。
2. 增删文件（节点）时，效率更高，因为B+树的叶子节点包含所有关键字，并以有序的链表结构存储，这样可很好提高增删效率。

---

B*树

B*树是B+树的变形，在B+树的非根和非叶子节点再增加指向兄弟节点的指针。

• B树定义了非叶子结点关键字个数至少为(2/3)*M，即块的最低使用率为2/3(代替B+树的1/2);
• B*树的分裂:当一个结点满时，如果它的下一个兄弟结点未满，那么将一部分数据移到兄弟结点中，再在原结点插入关键字，最后修改父结点中兄弟结点的关键字(因为兄弟结点的关键字范围改变了)。
• 如果兄弟也满了，则在原结点与兄弟结点之间增加新结点，并各复制1/3的数据到新结点，最后在父结点增加新结点的指针。 所以，B * 树分配新结点的概率比B＋树要低，空间使用率更高。
• B*树主要就是节省空间。