B 树（B-Tree）和 B + 树（B+ - Tree）是两种常用于数据库和文件系统的数据结构，它们都属于多路平衡搜索树，能高效地实现数据的插入、删除和查找操作。
B 树（B-Tree）
定义
B 树是一种自平衡的多路搜索树，每个节点可以拥有多个子节点。一棵 m 阶的 B 树需要满足以下条件：
- 每个节点最多有 m 个子节点。
- 除根节点和叶子节点外，每个节点至少有⌈m/2⌉个子节点。
- 根节点至少有 2 个子节点（除非它是叶子节点）。
- 所有叶子节点都在同一层上。
- 每个节点中的键按升序排列，且键的数量比子节点数量少 1。
代码示例（Python）
class BTreeNode:
def __init__(self, leaf=False):
self.leaf = leaf
self.keys = []
self.child = []
class BTree:
def __init__(self, t):
self.root = BTreeNode(True)
self.t = t
def insert(self, k):
root = self.root
if len(root.keys) == (2 * self.t) - 1:
temp = BTreeNode()
self.root = temp
temp.child.insert(0, root)
self.split_child(temp, 0)
self.insert_non_full(temp, k)
else:
self.insert_non_full(root, k)
def insert_non_full(self, x, k):
i = len(x.keys) - 1
if x.leaf:
x.keys.append(None)
while i >= 0 and k < x.keys[i]:
x.keys[i + 1] = x.keys[i]
i -= 1
x.keys[i + 1] = k
else:
while i >= 0 and k < x.keys[i]:
i -= 1
i += 1
if len(x.child[i].keys) == (2 * self.t) - 1:
self.split_child(x, i)
if k > x.keys[i]:
i += 1
self.insert_non_full(x.child[i], k)
def split_child(self, x, i):
t = self.t
y = x.child[i]
z = BTreeNode(y.leaf)
x.child.insert(i + 1, z)
x.keys.insert(i, y.keys[t - 1])
z.keys = y.keys[t:]
y.keys = y.keys[:t - 1]
if not y.leaf:
z.child = y.child[t:]
y.child = y.child[:t]
def print_tree(self, x, l=0):
print("Level ", l, " ", len(x.keys), end=":")
for i in x.keys:
print(i, end=" ")
print()
l += 1
if not x.leaf:
for i in x.child:
self.print_tree(i, l)
# 创建一个3阶B树
b_tree = BTree(3)
keys = [10, 20, 30, 40, 50]
for key in keys:
b_tree.insert(key)
b_tree.print_tree(b_tree.root)B 树在磁盘存储中的应用
磁盘存储特性与 B 树设计动机
磁盘的读写操作是以块为单位进行的，且磁盘的寻道时间和旋转延迟相对较长，因此减少磁盘 I/O 次数是提高磁盘数据访问效率的关键。B 树作为一种多路平衡搜索树，其每个节点可以存储多个关键字和子节点指针，使得树的高度相对较低，从而在进行数据查找、插入和删除操作时，能够减少磁盘 I/O 次数。
- 节点大小与磁盘块匹配：B 树的一个节点通常对应磁盘上的一个块。通过合理设置节点的大小，使其与磁盘块的大小相匹配，可以充分利用磁盘的读写特性。例如，一次磁盘读取操作可以将整个节点的数据加载到内存中，避免了多次小数据量的磁盘读写。
- 减少树的高度：由于 B 树的每个节点可以有多个子节点，相比二叉搜索树等其他树结构，B 树的高度要低很多。在进行数据查找时，从根节点到目标节点所经过的节点数量较少，也就意味着磁盘 I/O 次数减少。例如，对于一个包含大量数据的 B 树，可能只需要进行 3 - 4 次磁盘 I/O 操作就能找到目标数据。
B + 树（B+ - Tree）
B + 树是 B 树的一种变体，它和 B 树有很多相似之处，但也有一些关键区别：
- 所有的数据都存储在叶子节点中，非叶子节点只存储索引信息。
- 叶子节点之间通过指针相连，形成一个有序链表，方便进行范围查询。
- 每个非叶子节点至少有⌈m/2⌉个子节点，最多有 m 个子节点。
代码示例（Python）
class BPlusTreeNode:
def __init__(self, leaf=False):
self.leaf = leaf
self.keys = []
self.child = []
self.next = None
class BPlusTree:
def __init__(self, t):
self.root = BPlusTreeNode(True)
self.t = t
def insert(self, k):
root = self.root
if len(root.keys) == (2 * self.t) - 1:
temp = BPlusTreeNode()
self.root = temp
temp.child.insert(0, root)
self.split_child(temp, 0)
self.insert_non_full(temp, k)
else:
self.insert_non_full(root, k)
def insert_non_full(self, x, k):
i = len(x.keys) - 1
if x.leaf:
x.keys.append(None)
while i >= 0 and k < x.keys[i]:
x.keys[i + 1] = x.keys[i]
i -= 1
x.keys[i + 1] = k
else:
while i >= 0 and k < x.keys[i]:
i -= 1
i += 1
if len(x.child[i].keys) == (2 * self.t) - 1:
self.split_child(x, i)
if k > x.keys[i]:
i += 1
self.insert_non_full(x.child[i], k)
def split_child(self, x, i):
t = self.t
y = x.child[i]
z = BPlusTreeNode(y.leaf)
x.child.insert(i + 1, z)
x.keys.insert(i, y.keys[t - 1])
z.keys = y.keys[t:]
y.keys = y.keys[:t - 1]
if not y.leaf:
z.child = y.child[t:]
y.child = y.child[:t]
else:
z.next = y.next
y.next = z
def print_tree(self, x, l=0):
print("Level ", l, " ", len(x.keys), end=":")
for i in x.keys:
print(i, end=" ")
print()
l += 1
if not x.leaf:
for i in x.child:
self.print_tree(i, l)
# 创建一个3阶B+树
b_plus_tree = BPlusTree(3)
keys = [10, 20, 30, 40, 50]
for key in keys:
b_plus_tree.insert(key)
b_plus_tree.print_tree(b_plus_tree.root)B + 树在数据库中的应用
数据库查询需求与 B + 树优势
数据库系统中，经常需要进行等值查询和范围查询。B + 树的结构特点使其非常适合这些查询需求。所有的数据都存储在叶子节点中，且叶子节点之间通过指针相连形成有序链表，这使得范围查询变得非常高效。同时，非叶子节点只存储关键字和指针，进一步提高了树的存储效率和查询性能。
主键索引：在关系型数据库中，主键索引通常采用 B + 树实现。以 MySQL 的 InnoDB 存储引擎为例，主键索引的 B + 树叶子节点存储了完整的行数据。当通过主键进行查询时，数据库系统会根据主键值在 B + 树中进行查找，最终定位到包含目标数据的叶子节点。
辅助索引：除了主键索引，数据库还可以创建辅助索引。辅助索引的 B + 树叶子节点存储的是主键值，而不是完整的行数据。当通过辅助索引进行查询时，首先在辅助索引的 B + 树中找到对应的主键值，然后再通过主键索引的 B + 树找到完整的行数据。