数据结构07:查找[C++][B树Btree]

图源:文心一言

考研对于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树入门简介

🐋B树基本结构

⌨️代码实现

🧵分段代码

🔯P0:调用库文件

🔯P1:定义结点的类与树的类

🔯P2:B树结点

🔯P3:插入操作

🔯P4:删除操作

🔯P5:遍历B树

🔯P6:main函数

🧵完整代码

🔯P1:完整代码

🔯P2:执行结果

🔚结语


🦮思维导图


🐳基本概念

🐋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为边界进行分裂,左侧为左兄弟、右侧为右兄弟,中间挂到父结点上。

图源:Insertion into a B-tree

  • 在 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树的诗歌,内容大概如下,我觉得还挺优美的,顺便可以用来复习本节的内容~😶‍🌫️

博文到此结束,写得模糊或者有误之处,欢迎小伙伴留言讨论与批评,督促博主优化内容{例如有错误、难理解、不简洁、缺功能}等~😶‍🌫️😶‍🌫️

博文若有帮助,欢迎小伙伴动动可爱的小手默默给个赞支持一下,收到点赞的话,博主肝文的动力++~🌟🌟

相关推荐
JSU_曾是此间年少15 分钟前
数据结构——线性表与链表
数据结构·c++·算法
sjsjs1122 分钟前
【数据结构-合法括号字符串】【hard】【拼多多面试题】力扣32. 最长有效括号
数据结构·leetcode
此生只爱蛋1 小时前
【手撕排序2】快速排序
c语言·c++·算法·排序算法
blammmp1 小时前
Java:数据结构-枚举
java·开发语言·数据结构
何曾参静谧1 小时前
「C/C++」C/C++ 指针篇 之 指针运算
c语言·开发语言·c++
昂子的博客2 小时前
基础数据结构——队列(链表实现)
数据结构
lulu_gh_yu2 小时前
数据结构之排序补充
c语言·开发语言·数据结构·c++·学习·算法·排序算法
ULTRA??3 小时前
C加加中的结构化绑定(解包,折叠展开)
开发语言·c++
凌云行者3 小时前
OpenGL入门005——使用Shader类管理着色器
c++·cmake·opengl
凌云行者3 小时前
OpenGL入门006——着色器在纹理混合中的应用
c++·cmake·opengl