图源:文心一言
考研对于B树的要求重点在推理手算的部分,只参考王道论坛咸鱼老师的视频就可以了;若时间非常充裕的小伙伴,也可以往下滑了解一下代码~🥝🥝
备注:
-
这次的代码是从这里复制的:B-tree (programiz.com)。因为代码比较复杂,我与AI修改的代码没有通过删除根结点的测试,因此直接借用了大佬的代码与配图。博主增加了注释,注释可能有误,小伙伴发现问题请联系博主~
-
另外,之前在博文列表中写的红黑树删除红色结点代码有问题,有需要的小伙伴也可以在这个快乐网站里查看红黑树删除代码:Deletion in a Red-Black Tree (programiz.com),有图有文,支持以下主流编程语言[python、java、c、c++]~
-
第1版:查资料、写注释~🧩🧩
参考用书: 王道考研《2024年 数据结构考研复习指导》
参考用书配套视频: 7.4_1_B树_哔哩哔哩_bilibili
特别感谢: Chat GPT老师、BING AI老师、文心一言老师~
📇目录
🦮思维导图
- 本篇仅涉及到B树:Btree的代码;
- 思维导图为整理王道教材第7章 查找 的所有内容,其余学习笔记在以下博客~
🐳基本概念
🐋B树入门简介
今天我们要聊聊一种特殊的树,它有着一个让人浮想联翩的名字------B树!这棵树的名字听着就像是B站"张三"一样简单、响亮而土气,但实际上是一棵不可貌相、深藏不露的树!
它的一个关键特点是每个****结点 可以存储多个值,而不是像普通的二叉树只能容纳一个数据。
另外,B树也像平衡二叉树、红黑二叉树一样------可以自我调节,但处理方式有有一些区别:
- 平衡树:调整相对简单一些,但是在实际插入结点过程中,由于经常触发不平衡的调整机制,导致需要频繁地调整树形,仿佛是进退两难的托孤大臣;
- 红黑树:经过优化减少了调整次数,但红黑树的成员总是难以避免看向爸爸、叔叔、爷爷甚至是儿子、侄子、孙子的脸色,仿佛是如履薄冰的中年社畜;
- B树:调整相对红黑树简单,而相对平衡树稳定。每个结点存放的数据约为自身容纳量的一半,当一个结点装满了数据,它就会找到平辈伙伴:"嘿,我装不下了,需要找个地方放这些数据!"如果兄弟也容纳不下这些数据,它们就会向父结点请求帮助,寻找一个合适的位置来存放额外的数据~
当然,B树也有一些限制。它需要严格遵守一些规则,比如结点 中的值必须按照一定的顺序排列,让我们更容易找到需要的关键字。
因此,B树可以高效地处理大量的数据,它在数据库、文件系统、操作系统,甚至是人工智能的图像处理、机器学习、自然语言处理等领域也有着广泛的应用。
不过,B树本身的代码也很------毕竟普通二叉树代码100+,平衡二叉树代码150+,红黑树代码250+,B树代码300+;这点代码的增长量,虽然对于电脑来说算是蚍蜉撼树,但是对于考试来说绝对是泰山压顶,可能要把卷子写到溢出来~
🐋B树 基本结构
那么,B树大家族是如何处理海量数据的呢?它是以类似于小组的形式存放结点,保证结点内关键字的数量趋向于持恒或者盈满。萌新结点如果想拜入m阶B树的公会,入会须知:
|----|----|------|-----|------|-----|-----|-----|------|
| 名称 | 数量 | 子树指针 | 关键字 | 子树指针 | 关键字 | ... | 关键字 | 子树指针 |
| 符号 | n | P0 | K1 | P1 | K2 | ... | Kn | Pn |
- 每个小组的组成:
- 关键字K、指针P、数量n;
- 关键字K:结点中存储的数据,这些关键字就像是常驻本层小组的组员,按数值大小顺序排列,默认从小到大排列,即K1 < K2 < ... < Kn;
- 指针P:Ki < Pi < Ki+1,这些指针就像是传令员,如果在本层找不到对应的关键字K,但也能锁定结点的范围,对应该关键字范围的传令员就会揣着任务奔向下一层的小组员;
- 结点的关键字数量n:记录本层有多少个关键字,它是决定数据在插入、删除时是否向兄弟结点甚至是父结点借位置的关键;
- 每个小组最多容纳结点数:
- 树中的每个结点至多有m棵子树,即至多含有m-1个关键字;
- 每个小组最少容纳结点数:
- 根结点:若根结点不是叶结点,则至少有2棵子树;
- 分支结点:除根结点以外的所有非叶结点至少有⌈m/2 ⌉棵子树,即至少含有⌈m/2 ⌉-1个关键字;
- 叶子结点:没有数据的虚拟结点,所有的叶结点都出现在同一层次上,如果指针P找到了叶结点,那就说明查找失败了。
每个结点至少含有⌈m/2 ⌉-1个关键字,这样设计的好处在于,保证了B树的小组人员不会太少,若组员太少会导致在相同容量下B树很空或者深度较大,降低查找效率。
举个栗子,例如以下这棵树的阶数是m=3,则:
- 结点中最少关键字K是⌈m/2 ⌉-1 = ⌈3/2 ⌉-1=1个,此时对应的子树指针P是1+1=2个;
- 结点中最多关键字K是m-1 = 3-1 = 2个,此时对应的子树指针P是2+1=3个。
后面我们以代码+图的形式,说明如何创建一棵B树~
图源:文心一言
⌨️代码实现
🧵分段代码
🔯P0:调用库文件
- 输入输出流文件iostream:实现输出文字的效果;配合using namespace std;,可以将输出std::cout直接简写为cout,代码看着会简洁一些~
cpp
#include <iostream>
using namespace std;
🔯P1:定义结点的类与树的类
- BTreeNode 类表示 B 树的结点结构。每个结点包含键值、孩子结点的指针和其他辅助信息~
cpp
// BTreeNode类:表示B树的结点结构
class BTreeNode {
int *keys; // 指针,用于存储B树结点的关键字
int t; // B树的最小度数
BTreeNode **C; // BTreeNode 类型的指针数组,用于存储B树结点的子结点,其数量为2*t
int n; // 表示当前结点包含的关键字数量
bool leaf; // 布尔类型,用于标识当前结点是否为叶子结点
public: // 公共类:相关操作
BTreeNode(int _t, bool _leaf); // BTreeNode类的构造函数声明,初始化度数t、叶子结点leaf
void traverse(); // 遍历B树中的键值
int findKey(int k); // 寻找键值
void insertNonFull(int k); // 插入未满结点
void splitChild(int i, BTreeNode *y); // 分离已满结点
void deletion(int k); // 删除键值
void removeFromLeaf(int idx); // 从叶子结点删除键值
void removeFromNonLeaf(int idx); // 从非叶子结点删除键值
int getPredecessor(int idx); // 获取前驱结点
int getSuccessor(int idx); // 获取后继结点
void fill(int idx); // 处理删除下溢:从同级结点借用键值
void borrowFromPrev(int idx); // 处理删除下溢:向前驱结点借用键值
void borrowFromNext(int idx); // 处理删除下溢:向后继结点借用键值
void merge(int idx); // 处理删除下溢:合并结点
friend class BTree; // 友元BTree:表示BTree类可以访问BTreeNode类的私有成员
};
- BTree 类表示整个 B 树结构,提供 B 树的基本功能:查找、插入、删除~
cpp
// BTree类:表示整个B树结构,提供B树基本功能:查找、插入、删除
class BTree {
BTreeNode *root; // B树的根结点
int t; // B树的最小度数
public:
BTree(int _t) { // 构造函数,用于初始化B树,接受参数:最小度数_t
root = NULL; // 根结点置空
t = _t; // 接收一个整数参数_t,并将其赋值给类成员变量t,以便在后序使用
}
void traverse() { // 遍历整个B树
if (root != NULL) // 如果根结点不为空
root->traverse(); // 调用遍历traverse()函数
}
void insertion(int k); // 增加结点
void deletion(int k); // 删除结点
};
以上代码需要注意的点:
- 代码中所述的叶子结点,实际上是我们之前图中的终端结点,即最底层存有数据的结点;
- "int *keys ;"B树一般采用指针定义键值,使得调整操作更加灵活,且实现一种动态数组的效果,节省空间;想想如果使用int型数组定义,可能会把数组长度定义死,然后在完成结点上溢分裂操作的时候,由于不能在满数组中插入结点,因此就会多分裂1次~
🔯P2:B树结点
- 定义了结点最小度数t [此数值为用户在main函数中定义]是如何限制结点的指针数量C 与键值数量keys的
- 初始化了叶子结点类型leaf 与键值数量n~
cpp
// B树结点
BTreeNode::BTreeNode(int t1, bool leaf1) {
t = t1; // 接受参数t1,赋值到结点的最小度数t
leaf = leaf1; // 接受参数leaf1,赋值到叶子结点leaf,标识本结点是否为叶子结点
keys = new int[2 * t - 1]; // 分配键值,键值数量最多为2t-1个
C = new BTreeNode *[2 * t]; // 分配孩子指针,指针数量最多为2t个
n = 0; // 成员变量n初始化为0,表示结点初始的键值数量为0
}
🔯P3:插入操作
当我们要向B树中插入一个新的关键字时,我们从根结点开始,根据关键字的大小,沿着指针向下搜索,直到找到一个终端结点[必须在内部结点最底层的终端结点插入,可保证失败结点在同一层]。我以为正常思路是从终端结点往上判断,like this:
- 如果终端结点还有位置,则按照排序,插入终端结点;
- 如果终端结点没有位置,则从中间分裂终端结点,并将结点中间的关键字提到父结点;
- 如果父结点满了,我们就需要继续分裂和上移,直到找到一个不满的父结点或者创建一个新的根结点。
但是代码编写的顺序正好是逆序的,就是先判断根结点,再判断终端结点。注意因为插入结点只能在终端结点进行,所以根结点为满时也就是可以插入的路径结点均为满的时候。首先,调用insert函数:
- 如果根结点为空,则创建1个新的根结点;
- 如果根结点已满,则调用splitChild函数分裂根结点;
- 如果根结点不为空且未满,则在根结点调用InsertNonFull函数将新结点插入到终端结点;
实际上的操作,(1)在插入15时终端结点为满,导致了终端结点的分裂操作;(2)在插入17时终端结点为满,调整过程中导致了终端结点与根结点的连锁分裂操作~
注意分裂的时候都是从中间开始分裂,也就是以每个结点的最小度数t为边界进行分裂,左侧为左兄弟、右侧为右兄弟,中间挂到父结点上。
- 在 BTree 类中,insertion(k) 函数用于插入键值 k~
cpp
// 插入键值
void BTree::insertion(int k) {
if (root == NULL) { // 如果{根结点为空}
root = new BTreeNode(t, true); // 创建包含最小度数为t的叶子结点root
root->keys[0] = k; // 将结点的第0位设置为键值k
root->n = 1; // 将结点的键值数量n设置为1
} else { // 如果{根结点不为空}
if (root->n == 2 * t - 1) { // 如果根结点已满,即{根结点的键值数量n==2*t-1}
BTreeNode *s = new BTreeNode(t, false); // 创建包含最小度数为t的非叶子结点s
s->C[0] = root; // s结点的孩子指针C[0]指向root,即root作为s结点的第1个孩子结点
s->splitChild(0, root); // 调用splitChild,执行分裂操作
int i = 0; // 如果索引参数i=0
if (s->keys[0] < k) // 遍历结点s内的当前键值 keys是否 < k
i++;
s->C[i]->insertNonFull(k); // 在第C[i]个指针调用insertNonFull(k)
root = s; // 将s设置为根结点
} else // 如果{根结点未满}
root->insertNonFull(k); // 在根结点上调用insertNonFull(k),在叶子结点执行插入操作
}
}
- 在 BTreeNode 类中,insertNonFull(k) 函数用于在非满结点中插入键值 k,splitChild(i, y) 函数用于拆分孩子结点 y~
cpp
// 插入键值:根结点未满
void BTreeNode::insertNonFull(int k) {
int i = n - 1; // 设置索引参数i = 结点键值数量n-1,即结点的末端
if (leaf == true) { // 如果{当前结点 是 叶子结点}
while (i >= 0 && keys[i] > k) { // 如果 i>=0,且结点内第i个键值 > 目标键值k
keys[i + 1] = keys[i]; // 将大于i的键值向右移动
i--; // i向左移动
}
keys[i + 1] = k; // 第i+1个键值设置为目标键值k
n = n + 1; // 结点内键值数量n+1
} else { // 如果{当前结点 不是 叶子结点}
while (i >= 0 && keys[i] > k) // 如果 i>=0,且结点内第i个键值 > 目标键值k
i--; // i向左移动
if (C[i + 1]->n == 2 * t - 1) { // 如果{叶子结点的数量 == 2*t-1},表示该指针指向的孩子结点已满
splitChild(i + 1, C[i + 1]); // 调用splitChild拆分子结点
if (keys[i + 1] < k) // 如果第i+1个键值 < 目标键值k,表示左子结点的键值均 < k
i++; // i向右移动,配合下一步操作,会将目标键值k 插入到 右子节点
}
C[i + 1]->insertNonFull(k); // 对于第i+1个孩子指针,递归调用insertNonFull(k),使其继续向下一个结点探索
}
}
// 插入键值:拆分孩子结点
void BTreeNode::splitChild(int i, BTreeNode *y) { // 将索引i、被拆分结点y作为参数传入
BTreeNode *z = new BTreeNode(y->t, y->leaf); // 创建结点z:继承了y结点的最小度数、与是否为叶子结点的特性
z->n = t - 1; // 结点z的键值数n = 最小度数t-1
for (int j = 0; j < t - 1; j++) // 结点z的右侧键值左移
z->keys[j] = y->keys[j + t];
if (y->leaf == false) { // 如果结点y不是终端结点
for (int j = 0; j < t; j++) // 结点z的孩子指针左移
z->C[j] = y->C[j + t];
}
y->n = t - 1; // 结点y的键值数n = 最小度数t-1
for (int j = n; j >= i + 1; j--) // 结点y中大于结点i的键值向右移动
C[j + 1] = C[j];
C[i + 1] = z; // 结点z挂在索引i的右侧,成为结点y的右兄弟
for (int j = n - 1; j >= i; j--) // 大于索引i的结点y的指针右移
keys[j + 1] = keys[j];
keys[i] = y->keys[t - 1]; // 将结点y的第t-1个键值提升为当前结点的第i个键值,即使中间结点上升到父结点
n = n + 1; // 结点y的键值数n = n+1
}
🔯P4:删除操作
我以为删除结点的一般性思路是先查找[二分法向下遍历]、再删除、后调整,就像我在其它二叉树博文里介绍的思路,like this:
- 查询需要被删除的关键字;
- 删除关键字操作:
- 如果这个结点是终端结点,我们直接删除;
- 如果这个结点是非终端结点,我们在子树中找到可以替代的结点,转化为删除终端结点的操作;
- 检查删除后的树是否需要调整:
- 如果这个结点在删除前、后满足最小关键字数量限制,我们就直接调用删除,不需要做任何其他操作。
- 如果这个结点在删除前、后低于最小关键字数量限制,我们就需要借用或者合并相邻的兄弟结点来补充它。
- 如果借用或者合并导致结点低于最小关键字数量限制,我们就需要递归地向下借用、向上借用、或合并结点,直到找到一个不低于最小关键字数量限制的祖先结点或者减少B树的高度。
但是具体到代码,感觉它的思路就很巧妙,人家调换了顺序,根据每一轮的查询结果 决定是否删除结点,再次注意此处代码中的叶子结点应该是我们所指的终端结点:
- 首先,通过调用 findKey(k) 函数,找到与目标键值 k 相等的键值在当前结点的位置索引 idx。
- 然后,根据找到的索引 idx,判断目标键值 k 是否存在于当前结点:
- 如果找到了目标键值 k(idx < n && keys[idx] == k),则根据当前结点的类型(叶子结点或非叶子结点)调用相应的删除函数:
- 如果当前结点是叶子结点,则调用 removeFromLeaf(idx) 函数来从叶子结点中删除该键值。
- 如果当前结点是非叶子结点,则调用 removeFromNonLeaf(idx) 函数来从非叶子结点中删除该键值。
- 如果在当前结点中未找到目标键值 k,则需要进一步处理:
- 首先,判断当前结点是否为叶子结点。如果是叶子结点,则输出提示信息说明目标键值 k 不在 B 树中,并结束函数调用。
- 如果当前结点不是叶子结点,说明目标键值可能存在于当前结点的子结点中。在这种情况下,需要进一步处理:
- 使用标志变量 flag 来判断计数变量 idx 是否等于结点数量 n,即是否遍历到当前结点的尾部。
- 如果当前结点的子结点(C[idx])的键值数量小于最小度数 t(C[idx]->n < t),则调用 fill(idx) 函数来填充子结点。
- 根据前面的 flag 判断,如果目标键值 k 存在于当前结点的右侧子结点中,则递归调用 C[idx - 1]->deletion(k) 来删除该键值。
- 否则,如果目标键值 k 存在于当前结点的左侧子结点中,则递归调用 C[idx]->deletion(k) 来删除该键值。
GPT老师点评:
- 第二种思想的优势在于,它将查找和删除操作结合在一起,通过在查找过程中处理删除,可以避免多次遍历相同的路径,从而提高了删除操作的效率。特别是在B树结点较大且层次较多的情况下,这种优化对性能的改进会更明显。
- 相比之下,第一种思想中,查找和删除是两个独立的步骤,可能需要多次遍历同一路径来完成删除,导致了一些额外的开销。
- 综上所述,第二种思想中的优化让删除操作更加高效。然而,两种思想在根本上并无太大差异,实现的效果是相同的,而选择哪种思想最终取决于具体实现和编程习惯。在实际编写代码时,根据自己的需求和对B树结点的组织方式选择适合的删除思想即可。
删除终端键值 包含3种调节情况,另外删除非终端键值的情况都可以转化为删除终端键值:即找到终端结点数值上的前驱或后继键值,替换本键值,然后转化为删除在终端的替身键值~
图源:https://www.programiz.com/dsa/deletion-from-a-b-tree:
**第一种情况:**删除终端/叶子结点不会破坏最小度数的特性,直接删除~
**第二种情况:**删除终端/叶子结点,破坏了最小度数的特性,此时看向左兄弟、右兄弟,他们够借,直接借1个数过来~
**第三种情况:**删除非终端/叶子结点,破坏了最小度数的特性,此时看向左兄弟、右兄弟,他们不够借,因此调用兄弟结点和父结点的数据凑到本结点,并删除兄弟结点~
- 在 BTree 类中,deletion(k) 函数用于删除键值 k~
cpp
// 删除操作
void BTree::deletion(int k) {
if (!root) { // 如果B树为空
cout << "B树为空\n";
return;
}
root->deletion(k); // 如果B树不为空,从根结点开始调用删除函数deletion
// 以下处理特殊情况:在删除操作后根结点的键值数量为0
if (root->n == 0) { // 如果{ 根结点的键值数量n == 0 },即根结点没有键值
BTreeNode *tmp = root; // 创建tmp指针指向root,以便后续释放内存
if (root->leaf) // 如果{ 根结点root是叶子结点 }
root = NULL; // 清空root
else // 如果{ 根结点root不是叶子结点 }
root = root->C[0]; // 将root指向root的第1个孩子结点,用于替代原根结点
delete tmp; // 释放原根结点的内存空间
}
return;
}
- 在 BTreeNode 类中,deletion(k) 函数用于删除键值 k,其中可能会涉及到一些下溢处理~
cpp
// 删除操作
void BTreeNode::deletion(int k) {
int idx = findKey(k); // 位置索引idx,通过调用 findkey 找到与目标键值k在当前结点中的位置索引
if (idx < n && keys[idx] == k) { // 如果表示找到了目标键值k,即{ 位置索引idx < 结点数量n } 且 { 第[idx]个键值的数值 = 需要目标数值k }
if (leaf) // 如果是叶子结点
removeFromLeaf(idx); // 调用函数 removeFromLeaf(idx);
else // 如果不是叶子结点
removeFromNonLeaf(idx); // 调用函数 removeFromNonLeaf(idx);
} else { // 如果表示未找到目标数值k,即不满足上述条件
if (leaf) { // 如果是叶子结点
cout << "键值 " << k << " 不在B树中\n"; // 输出:键值不在树中
return; // 结束函数调用
}
// 如果不是叶子结点,需要进一步处理
bool flag = ((idx == n) ? true : false); // flag:计数变量idx 是否等于 结点数量n?即判断索引idx遍历是否到结点尾部
if (C[idx]->n < t) // 处理下溢:如果当前结点的子结点(C[idx])的键值数量小于最小度数 t(C[idx]->n < t)
fill(idx); // 调用 fill(idx) 函数来填充子结点
if (flag && idx > n) // 如果目标键值 k 存在于当前结点的右侧子结点中
C[idx - 1]->deletion(k); // 递归调用 C[idx - 1]->deletion(k) 来删除该键值
else // 否则,如果目标键值 k 存在于当前结点的左侧子结点中
C[idx]->deletion(k); // 递归调用 C[idx]->deletion(k) 来删除该键值
}
return;
}
// 删除操作:寻找键值
int BTreeNode::findKey(int k) {
int idx = 0; // 位置索引idx,初始为0
while (idx < n && keys[idx] < k) // 如果 { 位置索引idx < 结点数量n } 且 { 第[idx]个键值的数值 < 需要目标数值k }
++idx; // idx+1,继续比较结点内下一个值
return idx; // 返回idx的值:如果找到了与 k 相等的键值,则返回其在结点中的索引;如果没有找到,就返回它应该插入的位置索引
}
// 删除操作:删除叶子结点关键字
void BTreeNode::removeFromLeaf(int idx) { // 将索引idx作为参数传入
for (int i = idx + 1; i < n; ++i) // 将索引移动到被删除键值之后
keys[i - 1] = keys[i]; // 将大于索引idx的键值全部向前移动一格,覆盖删除键值
n--; // 将"n"的值(结点中键的数量)减1以反映键的删除
return;
}
// 删除操作:删除非叶子结点关键字
void BTreeNode::removeFromNonLeaf(int idx) { // 将索引idx作为参数传入
int k = keys[idx]; // 创建变量k,记录被删除的键值
if (C[idx]->n >= t) { // 如果 当前结点的左子结点的有效键值数C[idx]->n ≥ 结点的最小度数t
int pred = getPredecessor(idx); // 创建变量pred,调用函数getPredecessor,记录被删除键值的前驱键值(前驱键值是左子结点的最大键值)
keys[idx] = pred; // 将前驱键值pred替换到当前结点keys[idx]
C[idx]->deletion(pred); // 删除前驱键值pred,并在左子结点递归地调用删除函数deletion
}
else if (C[idx + 1]->n >= t) { // 如果 当前结点的右子结点的有效键值数C[idx + 1] ≥ 结点的最小度数t
int succ = getSuccessor(idx); // 创建变量succ,调用函数getSuccessor,记录被删除键值的后继键值(后继键值是右子结点的最小键值)
keys[idx] = succ; // 将后继键值succ替换到当前结点keys[idx]
C[idx + 1]->deletion(succ); // 删除后继键值succ,并在右子结点递归地调用删除函数deletion
}
else { // 如果 当前结点的左、右孩子键值都不够
merge(idx); // 调用merge函数,执行结果:将右子结点的键值合并到左子节点,并删除右子结点的指针
C[idx]->deletion(k); // 删除当前键值k,并在左子结点递归地调用删除函数deletion
}
return;
}
// 删除非叶子结点关键字处理:获得前驱结点
int BTreeNode::getPredecessor(int idx) { // 将索引idx作为参数传入
BTreeNode *cur = C[idx]; // 创建指针cur,指向关键字的左孩子指针
while (!cur->leaf) // 如果当前结点不是叶子结点
cur = cur->C[cur->n]; // 指针cur指向左孩子结点的最末端结点,即结点的最大值
return cur->keys[cur->n - 1]; // 返回叶子节点的最大值,实际为将对非叶子结点的操作转化为对叶子结点的操作
}
// 删除非叶子结点关键字处理:获得后继结点
int BTreeNode::getSuccessor(int idx) { // 将索引idx作为参数传入
BTreeNode *cur = C[idx + 1]; // 创建指针cur,指向关键字的右孩子指针
while (!cur->leaf) // 如果当前结点不是叶子结点
cur = cur->C[0]; // 指针cur指向左孩子结点的最起始结点,即结点的最小值
return cur->keys[0]; // 返回叶子节点的最小值,实际为将对非叶子结点的操作转化为对叶子结点的操作
}
// 删除下溢处理:填充
void BTreeNode::fill(int idx) { // 将索引idx作为参数传入
if (idx != 0 && C[idx - 1]->n >= t) // 如果{索引idx≠0}且{当前键值的左兄弟子树 ≥ 结点最小度数t}
borrowFromPrev(idx); // 调用borrowFromPrev,向左兄弟借数据
else if (idx != n && C[idx + 1]->n >= t) // 如果{索引idx≠0}且{当前键值的右兄弟子树 ≥ 结点最小度数t}
borrowFromNext(idx); // 调用borrowFromNext,向右兄弟借数据
else { // 如果不属于以上状况,左、右兄弟都不够借
if (idx != n) // 如果{索引idx≠结点数目n},说明索引idx遍历到结点的最末端
merge(idx); // 调用merge,合并当前结点与右兄弟结点
else // 如果{索引idx=结点数目n},说明索引idx未遍历到结点的最末端
merge(idx - 1); // 调用merge,合并当前结点与左兄弟结点
}
return;
}
// 删除下溢处理:向左兄弟借数据
void BTreeNode::borrowFromPrev(int idx) { // 将索引idx作为参数传入
BTreeNode *child = C[idx]; // 创建指针child,指向当前结点的子结点C[idx]
BTreeNode *sibling = C[idx - 1]; // 创建指针sibling,指向当前结点的子结点的左兄弟结点C[idx-1]
for (int i = child->n - 1; i >= 0; --i) // 将child结点的所有键值右移1位
child->keys[i + 1] = child->keys[i];
if (!child->leaf) { // 如果child不是叶子节点
for (int i = child->n; i >= 0; --i) // 将child结点的所有指针右移1位,空出首位
child->C[i + 1] = child->C[i];
}
child->keys[0] = keys[idx - 1]; // 将当前结点的第idx - 1个键值 赋值到 child的第1个键值
if (!child->leaf) // 如果child结点不是叶子结点
child->C[0] = sibling->C[sibling->n]; // 将孩子的左兄弟结点的最后1个孩子结点指针 指向 child的第1个孩子结点指针
keys[idx - 1] = sibling->keys[sibling->n - 1]; // 将孩子的左兄弟结点的最后1个键值 赋值到 索引idx-1结点的键值
child->n += 1; // child的键值数量n+1
sibling->n -= 1; // sibling的键值数量n-1
return;
}
// 删除下溢处理:向右兄弟借数据
void BTreeNode::borrowFromNext(int idx) { // 将索引idx作为参数传入
BTreeNode *child = C[idx]; // 创建指针child,指向当前结点的子结点C[idx]
BTreeNode *sibling = C[idx + 1]; // 创建指针sibling,指向当前结点的子结点的右兄弟结点C[idx-1]
child->keys[(child->n)] = keys[idx]; // 将当前结点的索引键值 赋值到 孩子结点的最末端键值
if (!(child->leaf)) // 如果 {孩子结点 不是 叶子节点}
child->C[(child->n) + 1] = sibling->C[0]; // 右兄弟结点的首位键值指针 指向 孩子结点的末位结点的右孩子指针
keys[idx] = sibling->keys[0]; // 右兄弟结点的首位键值 赋值到 当前索引的键值
for (int i = 1; i < sibling->n; ++i) // 右兄弟结点的键值 全部左移一位,实际作用为删除右兄弟首结点的值
sibling->keys[i - 1] = sibling->keys[i];
if (!sibling->leaf) { // 如果 {右兄弟结点 不是 叶子结点}
for (int i = 1; i <= sibling->n; ++i) // 右兄弟结点的指针 全部左移一位
sibling->C[i - 1] = sibling->C[i];
}
child->n += 1; // child的键值数量n+1
sibling->n -= 1; // sibling的键值数量n-1
return;
}
// 删除下溢处理:合并当前结点与右兄弟结点
void BTreeNode::merge(int idx) { // 将索引idx作为参数传入
BTreeNode *child = C[idx]; // 创建指针child,指向当前结点的子结点C[idx]
BTreeNode *sibling = C[idx + 1]; // 创建指针sibling,指向当前结点的子结点的右兄弟结点C[idx-1]
child->keys[t - 1] = keys[idx]; // 将索引键值 赋值到 孩子结点的最小度数键值【前提:孩子结点与右兄弟结点都不满足度数】
for (int i = 0; i < sibling->n; ++i) // 将右兄弟结点的所有键值 赋值到 孩子结点的末尾
child->keys[i + t] = sibling->keys[i];
if (!child->leaf) { // 如果 {孩子结点 不是 叶子结点}
for (int i = 0; i <= sibling->n; ++i) // 将右兄弟结点的所有指针 赋值到 孩子结点的指针
child->C[i + t] = sibling->C[i];
}
for (int i = idx + 1; i < n; ++i) // 将当前结点 索引键值右侧的点全部左移,实际作用相当于删除索引值
keys[i - 1] = keys[i];
for (int i = idx + 2; i <= n; ++i) // 将当前结点 索引键值右侧的指针全部左移,除了覆盖本结点外还有最末端键值的右指针也要左移
C[i - 1] = C[i];
child->n += sibling->n + 1; // 孩子结点的数量 = 孩子结点的数量+右兄弟结点的数量+1
n--; // 当前结点的数量 - 1
delete (sibling); // 删除 兄弟结点
return;
}
🔯 P5:遍历B树
核心思想:先序遍历~
注意一下:如果利用索引i遍历,孩子指针会比叶子结点多1个的事情就可以了~
cpp
// 先序遍历B树
void BTreeNode::traverse() {
int i;
for (i = 0; i < n; i++) { // 当{索引i < 结点数量n}时,遍历本结点的所有键值
if (leaf == false) // 如果{当前结点 不是 叶子结点}
C[i]->traverse(); // 递归调用本函数,继续向下遍历指针
cout << " " << keys[i]; // 输出递归栈指针对应结点的值
}
if (leaf == false) // 循环结束后,如果{当前结点 不是 叶子结点}
C[i]->traverse(); // 递归调用本函数,遍历最后1个孩子指针
}
🔯 P6:main函数
作用就是创建了一棵小树,并且执行遍历~
cpp
int main() {
BTree t(3); // 设置B树的最小度数为3
t.insertion(8); // 插入 结点8
t.insertion(9);
t.insertion(10);
t.insertion(11);
t.insertion(15);
t.insertion(16);
t.insertion(17);
t.insertion(18);
t.insertion(20);
t.insertion(23);
cout << "B树包含的结点是: ";
t.traverse(); // 执行先序遍历
t.deletion(11); // 删除结点11
cout << "\nB树包含的结点是: ";
t.traverse(); // 执行先序遍历
}
🧵完整代码
🔯 P1:完整代码
写了好长好长时间的注释,删的时候发现自己都懒得删,手麻------
cpp
#include <iostream>
using namespace std;
// BTreeNode类:表示B树的结点结构
class BTreeNode {
int *keys;
int t;
BTreeNode **C;
int n;
bool leaf;
public:
BTreeNode(int _t, bool _leaf);
void traverse();
int findKey(int k);
void insertNonFull(int k);
void splitChild(int i, BTreeNode *y);
void deletion(int k);
void removeFromLeaf(int idx);
void removeFromNonLeaf(int idx);
int getPredecessor(int idx);
int getSuccessor(int idx);
void fill(int idx);
void borrowFromPrev(int idx);
void borrowFromNext(int idx);
void merge(int idx);
friend class BTree;
};
// BTree类:表示整个B树结构,提供B树基本功能:查找、插入、删除
class BTree {
BTreeNode *root;
int t;
public:
BTree(int _t) {
root = NULL;
t = _t;
}
void traverse() {
if (root != NULL)
root->traverse();
}
void insertion(int k);
void deletion(int k);
};
// B树结点
BTreeNode::BTreeNode(int t1, bool leaf1) {
t = t1;
leaf = leaf1;
keys = new int[2 * t - 1];
C = new BTreeNode *[2 * t];
n = 0;
}
// 删除操作
void BTreeNode::deletion(int k) {
int idx = findKey(k);
if (idx < n && keys[idx] == k) {
if (leaf)
removeFromLeaf(idx);
else
removeFromNonLeaf(idx);
} else {
if (leaf) {
cout << "键值" << k << "不在B树中\n";
return;
}
bool flag = ((idx == n) ? true : false);
if (C[idx]->n < t)
fill(idx);
if (flag && idx > n)
C[idx - 1]->deletion(k);
else
C[idx]->deletion(k);
}
return;
}
// 删除操作:寻找键值
int BTreeNode::findKey(int k) {
int idx = 0;
while (idx < n && keys[idx] < k)
++idx;
return idx;
}
// 删除操作:删除叶子结点关键字
void BTreeNode::removeFromLeaf(int idx) {
for (int i = idx + 1; i < n; ++i)
keys[i - 1] = keys[i];
n--;
return;
}
// 删除操作:删除非叶子结点关键字
void BTreeNode::removeFromNonLeaf(int idx) {
int k = keys[idx];
if (C[idx]->n >= t) {
int pred = getPredecessor(idx);
keys[idx] = pred;
C[idx]->deletion(pred);
}
else if (C[idx + 1]->n >= t) {
int succ = getSuccessor(idx);
keys[idx] = succ;
C[idx + 1]->deletion(succ);
}
else {
merge(idx);
C[idx]->deletion(k);
}
return;
}
// 删除非叶子结点关键字处理:获得前驱结点
int BTreeNode::getPredecessor(int idx) {
BTreeNode *cur = C[idx];
while (!cur->leaf)
cur = cur->C[cur->n];
return cur->keys[cur->n - 1];
}
// 删除非叶子结点关键字处理:获得后继结点
int BTreeNode::getSuccessor(int idx) {
BTreeNode *cur = C[idx + 1];
while (!cur->leaf)
cur = cur->C[0];
return cur->keys[0];
}
// 删除下溢处理:填充
void BTreeNode::fill(int idx) {
if (idx != 0 && C[idx - 1]->n >= t)
borrowFromPrev(idx);
else if (idx != n && C[idx + 1]->n >= t)
borrowFromNext(idx);
else {
if (idx != n)
merge(idx);
else
merge(idx - 1);
}
return;
}
// 删除下溢处理:向左兄弟借数据
void BTreeNode::borrowFromPrev(int idx) {
BTreeNode *child = C[idx];
BTreeNode *sibling = C[idx - 1];
for (int i = child->n - 1; i >= 0; --i)
child->keys[i + 1] = child->keys[i];
if (!child->leaf) {
for (int i = child->n; i >= 0; --i)
child->C[i + 1] = child->C[i];
}
child->keys[0] = keys[idx - 1];
if (!child->leaf)
child->C[0] = sibling->C[sibling->n];
keys[idx - 1] = sibling->keys[sibling->n - 1];
child->n += 1;
sibling->n -= 1;
return;
}
// 删除下溢处理:向右兄弟借数据
void BTreeNode::borrowFromNext(int idx) {
BTreeNode *child = C[idx];
BTreeNode *sibling = C[idx + 1];
child->keys[(child->n)] = keys[idx];
if (!(child->leaf))
child->C[(child->n) + 1] = sibling->C[0];
keys[idx] = sibling->keys[0];
for (int i = 1; i < sibling->n; ++i)
sibling->keys[i - 1] = sibling->keys[i];
if (!sibling->leaf) {
for (int i = 1; i <= sibling->n; ++i)
sibling->C[i - 1] = sibling->C[i];
}
child->n += 1;
sibling->n -= 1;
return;
}
// 删除下溢处理:合并当前结点与右兄弟结点
BTreeNode *child = C[idx];
BTreeNode *sibling = C[idx + 1];
child->keys[t - 1] = keys[idx];
for (int i = 0; i < sibling->n; ++i)
child->keys[i + t] = sibling->keys[i];
if (!child->leaf) {
for (int i = 0; i <= sibling->n; ++i)
child->C[i + t] = sibling->C[i];
}
for (int i = idx + 1; i < n; ++i)
keys[i - 1] = keys[i];
for (int i = idx + 2; i <= n; ++i)
C[i - 1] = C[i];
child->n += sibling->n + 1;
n--;
delete (sibling);
return;
}
// 插入键值
void BTree::insertion(int k) {
if (root == NULL) {
root = new BTreeNode(t, true);
root->keys[0] = k;
root->n = 1;
} else {
if (root->n == 2 * t - 1) {
BTreeNode *s = new BTreeNode(t, false);
s->C[0] = root;
s->splitChild(0, root);
int i = 0;
if (s->keys[0] < k)
i++;
s->C[i]->insertNonFull(k);
root = s;
} else
root->insertNonFull(k);
}
}
// 插入键值:根结点未满
void BTreeNode::insertNonFull(int k) {
int i = n - 1;
if (leaf == true) {
while (i >= 0 && keys[i] > k) {
keys[i + 1] = keys[i];
i--;
}
keys[i + 1] = k;
n = n + 1;
} else {
while (i >= 0 && keys[i] > k)
i--;
if (C[i + 1]->n == 2 * t - 1) {
splitChild(i + 1, C[i + 1]);
if (keys[i + 1] < k)
i++;
}
C[i + 1]->insertNonFull(k);
}
}
// 插入键值:拆分孩子结点
void BTreeNode::splitChild(int i, BTreeNode *y) {
BTreeNode *z = new BTreeNode(y->t, y->leaf);
z->n = t - 1;
for (int j = 0; j < t - 1; j++)
z->keys[j] = y->keys[j + t];
if (y->leaf == false) {
for (int j = 0; j < t; j++)
z->C[j] = y->C[j + t];
}
y->n = t - 1;
for (int j = n; j >= i + 1; j--)
C[j + 1] = C[j];
C[i + 1] = z;
for (int j = n - 1; j >= i; j--)
keys[j + 1] = keys[j];
keys[i] = y->keys[t - 1];
n = n + 1;
}
// 先序遍历B树
void BTreeNode::traverse() {
int i;
for (i = 0; i < n; i++) {
if (leaf == false)
C[i]->traverse();
cout << " " << keys[i];
}
if (leaf == false)
C[i]->traverse();
}
// 删除操作
void BTree::deletion(int k) {
if (!root) {
cout << "B树为空\n";
return;
}
root->deletion(k);
// 以下处理特殊情况:在删除操作后根结点的键值数量为0
if (root->n == 0) {
BTreeNode *tmp = root;
if (root->leaf)
root = NULL;
else
root = root->C[0];
delete tmp;
}
return;
}
int main() {
BTree t(3);
t.insertion(8);
t.insertion(9);
t.insertion(10);
t.insertion(11);
t.insertion(15);
t.insertion(16);
t.insertion(17);
t.insertion(18);
t.insertion(20);
t.insertion(23);
cout << "B树包含的结点是: ";
t.traverse();
t.deletion(11);
cout << "\nB树包含的结点是: ";
t.traverse();
}
🔯 P2:执行结果
运行结果如下图所示~
🔚结语
BING AI在提示词中总是提示创作B树的诗歌,内容大概如下,我觉得还挺优美的,顺便可以用来复习本节的内容~😶🌫️
博文到此结束,写得模糊或者有误之处,欢迎小伙伴留言讨论与批评,督促博主优化内容{例如有错误、难理解、不简洁、缺功能}等~😶🌫️😶🌫️
博文若有帮助,欢迎小伙伴动动可爱的小手默默给个赞支持一下,收到点赞的话,博主肝文的动力++~🌟🌟