数据结构——b树b+树

最新推荐文章于 2025-04-14 22:26:17 发布

越来越无动于衷

最新推荐文章于 2025-04-14 22:26:17 发布

阅读量1.6k

点赞数 21

文章标签：数据结构 b树

本文链接：https://blog.youkuaiyun.com/m0_61261153/article/details/146453556

版权

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)