原文来自于：http://dblab.cs.toronto.edu/courses/443/2013/05.btree-index.html
1. B+树索引概述
在上一篇文章中，我们讨论了关于index的几个中重要的课题：
A) index是保存在磁盘上的一种数据结构，用于提高查询或是扫描record的速度。
B) 排序索引树通过保存page的指针加速record的查找。（ISAM）
C) 维护排序索引树的代价很高，因此，ISAM通过创建overflow page来解决这个问题，但是过多的overflow page会使查询性能从log（指数log）级别降低到线性遍历。
下面我们将介绍一种高度健壮的、比较流行的一种数据结构——B+树，作为ISAM的扩展。
一般说来，B+树是一种高效的基于磁盘保存的数据结构，主要保存(key, value)pair。它支持对key的高效查找，和高效的范围迭代。
B+树提供了这些功能：
A) 快速的record查找
B) 快速的record遍历
C) 不通过overflow page的形式维护排序树结构
B+树背后的关键思想是利用有序平衡树，替代ISAM中的排序树。
2. B+树的定义
B+树是用磁盘上的page作为node节点的树。B+树中的节点可以区分为leaf node（叶子节点）和interior node（内部节点）。
由于每一个node刚好是磁盘中的一个page，在B+树中，我们使用的术语node和page是可以互换的。
2.1 leaf node
leaf node保存数据entry（条目，相当于record），entry的形式是(key, value)。所有的leaf node也被组织成page链表的形式。B+树的leaf node如下图所示：
下面是leaf node抽象的数据结构定义：
struct LeafNode
{
vector<Key> keys;
vector<Value> values;
PagePointer next_page;
};
对任意的leaf node，下面的公式都是成立的：
p.keys.size() == p.values.size()
2.2 interior node
Interior node组织成一个树的形式，从root node（根节点，根节点也是一个interior node）开始，通过保存一系列key，来加速查询leaf node。
Interior node保存着一系列key和page指针，它的结构如图所示：
下面是interior node抽象的数据结构定义：
struct InteriorNode
{
vector<Key> keys;
vector<PagePointer> pointers;
};
对任意的interior node来时，下面的公式都是成立的：
p.keys.size() +1 == p.pointers.size()
有一个定义：Neighbouring pointer（临近指针）
对于一个key ki，我们定义before(ki)是ki前面临近的page指针，after(ki)是ki后面临近的指针。也就是说：
p.before(ki) = p.pointers[i]
p.after(ki) = p.pointers[i+1]
2.3 B+树的属性和约束条件
2.3.1 node中的key都是排好序的。
假设，p是B+树中的node，那么我们必须维持p.keys关于value是有序的。
2.3.2 各个node之间也是按key进行排序的。
B+树是有序树，表现在一下几个方面：
A) leaf node是有序的：
∀p∈LeafNode,∀k∈p.keys,∀k′∈p.next_page.keys,k<k′
多个leaf node组成一个有序链表，在各个leaf node之间使得高效的对(key, value)遍历成为可能。
B) interior node是有序的：
B+树对所有的key k，和其临近的指针after(k) 、after(k)，满足下面的条件：
k>max(keys(before(k)))
k≤min(keys(after(k)))
换句话说，k是介于before(k)、after(k) 的key之间的key。如图：
2.3.3 B+树是平衡树
B+树是平衡树，所有从root node到任何leaf node的路径长度是相等的。
2.3.4 B+树node是充分填充的
B+树允许它的node部分填充。主要是设计了一个填充因子的参数，用来限定每个non-root node（非根节点）的最小填充度。
如果一个non-root node的填充度不够，我们就说该node underflow，在B+树里只有root node可以underflow。
这里有一个不合格的B+数的例子。假设我们定义了下面的参数：
Capacity of each node: 4 keys
Fill factor: 50%
当该树经过平衡和排序后，它的结构如下图所示：
它存在着这样一个问题：没有满足我们上面定义的填充因子（fill factor）50%：
3. B+树的查询search和插入insert
B+树的主要操作有：
/** * finds the leaf node that _should_ contain the entry with the specified key */ LeafNode search(Node root, Key key) /** * Inserts a key/val pair into the tree. * Returns the root of the new tree which _may_ be different * from the old root node. */ InteriorNode insert_into_tree(InteriorNode root, Key newkey, Value val)
B+树的insert算法必须保证执行相应的操作之后使得树依然满足B+的所有属性和约束。
3.1 Searching
B+树的查询算法就是简单直接的树的查找算法：
LeafNode search(Node p, Key key)
{
if(p is LeafNode)
return root;
else
{
if(key < p.keys[0])
return search(before(p.keys[0]), key);
else if(key > p.keys[-1])
return search(after(p.keys[-1]), key);
else {
let i be p.keys[i] <= key < p.keys[i+1]
return search(after(p.keys[i]), key)
}
}
}
3.2 Inserting
B+树的insert操作是非常棘手的。它不像AVL的insert操作那样简单，B+树还需要考虑node的overflow和underflow。
Insert算法从这开始：
1） 寻找insert的正确的目标leaf node
2） 向目标leaf node中尝试insert操作
InteriorNode insert_into_tree(InteriorNode root, Key newkey, Value val)
{
LeafNode leaf = search(root, newkey);
return insert_into_node(leaf, newkey, val);
}
其中，insert_into_node中，要做如下的一些事：
/**
* Tries to inserts the (newkey/val) pair into
* the node.
*
* If `target` is an interior node, then `val` must be a page pointer.
*/
InteriorNode insert_into_node(Node target, newkey, val)
{
if( ... CASE 1 ... )
{
/* handle CASE 1 */
}
else if( ... CASE 2 ... )
{
/* handle CASE 2 */
}
else if( ... CASE 3 ... )
{
/* handle CASE 2 */
}
}
其中三个不同的case包括：
A) 目标leaf node有足够的空间保存key
B) 目标leaf node已满，但是它的parent node（父节点）有足够的空间保存key
C) 目标leaf node和它的parent node已满。
Case 1：
这是最简单的一种情况，将entry(newkey, value) 插入到目标leaf node即可。
A) Root node 不需要改变
B) 磁盘I/O也无需讨论。所有的操作都在一个page中。buffer manager（缓存管理）可以被用到，仿佛所有的node都保存在内存。
如图示：
Case 2：
在这种情况下，target node已满，但是它的parent node有足够的空间保存一个key。
A) 创建一个target node的兄弟node作为new_target node，将new_target node插入带target node之后。
B) 将target node中的所有entry和我们需要增加的entry分配保存到target node和new_target node中。由于分配之前target node是满的，那么就可以断定分配之后，这两个node不会存在underflow。
C) 将new_target的指针(k,p) = (leaf2.keys[0], ADDRESS[leaf2]) insert到target node的parent node中。由于parent node有足够的空间保存一个key，所以parent node不会出现overflow。
如图示：
Case 3：
这种情况是target和parent[target]都满了的情况。我们需要递归的尝试将新的key insert到target的祖先node中。甚至都有这种情况：root node也没有足够的空间保存这个新key ，这种情况下，我们必须对root进行分割，创建一个新的node作为B+树的root node。
具体细节如下：
A) 创建一个new_target node，insert到target之后。
B) 将target中的entry分配保存到target和new_target中。
现在我们需要将new_target node的指针(k,p) = (leaf2.keys[0], ADDRESS[leaf2])插入到它的PARENT[target]，但是PARENT[target]已经满了。
A) 令target_parent = PARENT[target]
B) 令all_keys = sorted(target_parent.keys ∪ {k})
C) 申请一个新的node：new_interior
D) 令i = floor(all_keys.size() / 2)
middle_key = all_keys[i]
E) 将all_keys[0 .. i-1]保存到target_parent中，将all_keys[i+1 .. n]保存new_interior到中。
F) 如果target_parent是root，那么我们就创建一个新的node作为grandparent ，令grandparent = PARENT[target_parent]。
G) 递归地调用：
insert_into_node(grandparent, middle_key, ADDRESS[new_interior])
如图所示：
4. B+树的其它的东西
a) B+树也支持高效的删除delete。删除算法是insert算法的逆过程。在delete的算法中会通过merge（合并）node，去避免underflow。如果发生merge node，那么会在parent node递归的delete这个(Key, PagePointer)。
b) 如果所有的data entry都保存在sequential file中，并且关于key排序，那么就可以非常有效的将sequential file装载到B+树。
c) B+树可以作为基于磁盘有序存储的排序算法。