C++实现B树

已于 2022-08-22 10:54:17 修改
阅读量1.2k 收藏 12
点赞数 1
分类专栏： 数据结构 文章标签： b树 数据结构 算法
于 2022-08-22 10:48:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44628585/article/details/126461216
版权

B-tree

一、B树的性质

一颗M阶B树T，满足以下条件
1. 每个结点至多拥有M课子树；
2. 根结点至少拥有两颗子树；
3. 除了根结点以外，其余每个分支结点至少拥有M/2课子树；
4. 所有的叶结点都在同一层上；
5. 有k课子树的分支结点则存在k-1个关键字，关键字按照递增顺序进行排序；
6. 关键字数量满足ceil(M/2)-1 <= n <= M-1。

例子：关键字为26英文字母，阶数M为6，按顺序插入得到的B-tree如下所示。
请添加图片描述

二、B树的创建

2.1 节点的定义

/**
 * B-tree
 * create by marco
 **/
#include <iostream>
#include<vector>
using namespace std;

typedef int KEY_VALUE;

/* 节点数据结构 */
struct btree_node 
{
    KEY_VALUE *keys;    // 节点中的关键字数组
    struct btree_node **children;   // 指向子节点的数组
    int num;    // 节点中关键字个数
    int leaf;   // 是否是叶子节点
};

/* 创建B树节点 */
btree_node* btree_node_create(int dgree, int leaf) 
{
    btree_node *node = (btree_node*)calloc(1, sizeof(btree_node));
    if (node == nullptr) {
        printf("btree_node_create failed!\n");
        return nullptr;
    }

    node->leaf = leaf;
    node->keys = (KEY_VALUE*)calloc(1, (dgree * 2 - 1) * sizeof(KEY_VALUE));
    node->children = (btree_node**)calloc(1, (dgree * 2) * sizeof   (btree_node));
    node->num = 0;
    return node;
}

/* 释放B树节点 */
void btree_node_destory(btree_node *node)
{
    if (node == nullptr)
        return;
    free(node->children);
    free(node->keys);
    free(node);
}

2.2 B树的定义

struct btree 
{
    struct btree_node *root;    // 指向B树的根节点
    int dgree;  // B树的阶数的一半， 如此设置方便之后判断节点是否需要操作
};

/* 创建B树 */
btree* btree_create(int dgree)
{
    btree *T = new btree;

    T->dgree = dgree;
    btree_node *node = btree_node_create(dgree, 1);
    T->root = node;

    return T;
}

三、B树的插入操作

3.1 B树插入关键字的主要思想

  1. 首先二叉遍历找到待插入的叶子节点。注意，B树关键字的插入，必然是插入到叶子节点，可以这么理解，不遍历到叶子节点是无法判断关键字是否已存在的。

  2. 判断叶子节点的关键字个数是否小于阶数M-1，若小于即可直接判断插入的具体位置。插入关键字B、C、D如下图所示。
    请添加图片描述

  3. 如果关键字个数等于阶数M-1，则表示该节点已满，需要分裂节点。分裂叶子节点的具体规则为：将中间关键字（索引为阶数M/2 - 1）放入父节点，新建节点存入被分裂叶子节点的后一半数据，并将新建节点插入到父节点中，排在被分裂叶子节点的分支之后。记得更新被分裂的叶子节点，已经被瓜分啦。插入关键字F如下图所示。
    请添加图片描述

  4. 注意此时需要递归判断父节点的关键字个数，如果等于阶数M-1，则需继续分裂。

  5. 分裂结束即可插入关键字。

3.2 具体实现代码如下

/* 分裂B树节点 */
/**
 * 参数列表：
 *      btree *T : B树指针
 *      btree_node *x : 待分裂节点的父节点指针
 *      int index : 待分裂节点在父节点中的孩子指针索引
 * */
void btree_node_split(btree *T, btree_node *x, int index)
{
    int dgree = T->dgree;
    btree_node * y = x->children[index];

    /* 新建节点z,将待分裂节点的后一半关键字放入新节点z */
    btree_node *z = btree_node_create(dgree, y->leaf); // 创建节点，传入参  数为：节点的阶数+是否叶子节点
    z->num = dgree - 1; // 设置新节点z的关键字个数
    for (int k = dgree; k < 2 * dgree - 1; ++k)
    {
        z->keys[k - dgree] = y->keys[k];
    }
    if (y->leaf == 0)   // 若待分裂节点为非叶子节点，则拥有的子树也需要复制到   新节点z
    {
        for (int k = dgree; k < 2 * dgree; ++k )
        {
            z->children[k - dgree] = y->children[k];
        }
    }

    /* 将分裂出的关键字放入父节点x */
    for (int k = x->num - 1; k >= index; k--)   // 将后半关键字往后移动位   置，腾出空间，以便存放分裂节点的中间关键字
    {
        x->keys[k + 1] = x->keys[k];
    }
    x->keys[index] = y->keys[dgree - 1]; 
    x->num += 1;
    y->num = dgree - 1;

    /* 将新建节点z作为子树插入到x节点 */
    for (int k = x->num; k > index; --k)    // 将父节点中部分子树往后移动一 个单位，以便插入新建节点z
    {
        x->children[k + 1] = x->children[k];
    }  
    x->children[index + 1] = z;
}

/* 插入关键字---根节点非满 */
void btree_insert_key_nodeNonFull(btree *T, btree_node *x, KEY_VALUE key)
{
    int index = x->num - 1;

    if (x->leaf == 1) 
    {
        while (index >= 0 && x->keys[index] > key )
        {
            x->keys[index + 1] = x->keys[index];
            index--;
        }
        x->keys[index + 1] = key;
        x->num += 1;
    }
    else    // 非叶子节点，则该节点必然不会是待插入节点，继续往下探索，探索过程中判断即将探索的下层节点关键字是否满，满了需要分裂
    {
        while (index >= 0 && x->keys[index] > key)
            index--;

        if (x->children[index + 1]->num == (2 * T->dgree - 1))
        {
            btree_node_split(T, x, index + 1);
            if (x->keys[index + 1] < key)   // 更新待探索的子节点索引，因为 分裂节点会向x节点插入新的关键字，所以要重新判断该关键字是否小于key
                index++;
        }

        btree_insert_key_nodeNonFull(T, x->children[index + 1], key);
    }
}

/* 插入关键字 */
void btree_insert_key(btree *T, KEY_VALUE key)
{
    btree_node *r = T->root;

    if (r->num == 2 * T->dgree - 1) // 特殊情况，根节点关键字满，需要分裂并且   重新设置根节点
    {
        btree_node *node = btree_node_create(T->dgree, 0);
        T->root = node;
        node->children[0] = r;
        btree_node_split(T, node, 0);

        int i = 0;
        if (node->keys[0] < key)    // 判断节点插入的位置
            ++i;
        btree_insert_key_nodeNonFull(T, node->children[i], key);
    }
    else
    {
        btree_insert_key_nodeNonFull(T, r, key);
    }
}

四、B树的删除操作

4.1 B树删除关键字的主要思想

  1. 首先二叉遍历找到关键字所在的节点。

  2. 判断节点的关键字个数删除之后是否满足：ceil(M/2)-1 <= n <= M-1。满足即可直接删除啦。删除关键字A如下如所示。
    请添加图片描述

  3. 不满足的话，首先判断是否可以向左右兄弟节点借关键字。判断规则：a.左右兄弟节点关键字被借走一个之后个数n仍然满足ceil(M/2)-1 <= n <= M-1；b.当左右兄弟都满足时，选关键字个数多的兄弟节点。

  4. 具体借的规则：首先向父节点借一个左/右关键字（与借的节点方位保持一致）放入待删除关键字的节点中，然后将左/右兄弟节点中的最大/最小关键字复制到父节点中。相应的孩子指针也要相应的移动。删除关键字S如下图所示。
    请添加图片描述

  5. 如果左右子节点都无法借出关键字时，需要进行合并操作，即将左/右兄弟节点和当前待删除关键字的节点，以及最后一个小于该关键字的父节点中的关键字合并。删除关键字M如下图所示。
    请添加图片描述

  6. 每个节点中相应的孩子指针的实际操作和关键字类似。

4.2 具体实现代码如下

/* 合并节点 */
/**
 * 参数列表：
 *      btree *T : B树指针
 *      btree_node *node : 待合并节点的上一次父节点指针
 *      int index : 合并需要三个部分---父节点关键字，父节点关键字前后的子节点。 index为父节点关键字索引
 * */
void btree_node_merge(btree *T, btree_node *node, int index)
{
    btree_node *left = node->children[index];   // 合并的左子节点
    btree_node *right = node->children[index + 1];  // 合并的右子节点

    /* 将父节点关键字以及右子节点都存入左子节点中 */
    left->keys[T->dgree - 1] = node->keys[index];
    for (int i = 0; i < right->num; ++i)    // 移动right中的关键字
    {
        left->keys[T->dgree + i] = right->keys[i];
    }
    if (left->leaf == 0)    // 移动right中的子节点指针
    {
        for (int i = 0; i <= right->num; ++i)
        {
            left->children[T->dgree + i] = right->children[i];
        }
    }
    left->num += right->num + 1;

    btree_node_destory(right);  // 释放右子节点

    for (int i = index + 1; i < node->num; ++i) // 更新父节点关键字和指向子 节点的指针位置
    {
        node->keys[i - 1] = node->keys[i];
        node->children[i] = node->children[i + 1];
    }
    node->children[node->num + 1] = nullptr;
    node->num -= 1;

    if (node->num == 0) // 如果父节点个数为0,这种情况只可能是父节点为根节点
    {
        T->root = left;
        btree_node_destory(node);
    }
}

/* 删除节点中关键字 */
void btree_node_delete_key(btree *T, btree_node *node, KEY_VALUE key)
{
    if (node == nullptr)
        return;

    int index = 0;
    // 找到节点中第一个大于等于key的关键字
    while (index < node->num && key > node->keys[index])    
        index++;

    if (index < node->num && node->keys[index] == key) {    // 在该节点中找 到等于key的关键字, 考虑具体的删除操作

        if (node->leaf == 1)    // 该节点为叶子节点
        {
            for (int i = index; i < node->num - 1; ++i)
            {
                node->keys[i] = node->keys[i + 1];
            }
            node->keys[node->num - 1] = 0;
            node->num -= 1;

            if (node->num == 0)
            {
                free(node);
                T->root = nullptr;
            }
        } else if (node->children[index]->num >= T->dgree) {    // 借用左   子节点的关键字进行覆盖
            btree_node * left = node->children[index];
            node->keys[index] = left->keys[left->num - 1];

            btree_node_delete_key(T, left, left->keys[left->num - 1]);  /   / 递归删除子节点中用来覆盖上层节点的关键字
        } else if (node->children[index + 1]->num >= T->dgree) {    // 借   用左子节点的关键字进行覆盖
            btree_node *right = node->children[index + 1];
            node->keys[index] = right->keys[0];

            btree_node_delete_key(T, right, right->keys[0]);    // 递归删   除子节点中用来覆盖上层节点的关键字
        } else {
            btree_node_merge(T, node, index);
            btree_node_delete_key(T, node->children[index], key);
        }

    } else {    // 继续往children[index]子节点找

        btree_node *child = node->children[index];
        if (child == nullptr) {
            printf("Cannot find key : %d\n", key);
            return;
        }

        /* 找关键字所在的节点过程中，遇到关键字个数==dgree-1的节点，进行丰满处  理 */
        if (child->num == T->dgree - 1) {
            btree_node *left = nullptr, *right = nullptr;
            if (index > 0)
                left = node->children[index - 1];
            if (index < node->num)
                right = node->children[index + 1];

            if ((left && left->num >= T->dgree) || (right && right->num     >= T->dgree)) {
                int select = 0;
                if (left && right)
                    select = (right->num > left->num) ? 1 : 0;

                if (select) {   // 选右子树
                    /* 将父节点node的第一个大于key的关键字移给child */
                    child->keys[child->num] = node->keys[index];
                    child->num += 1;
                    child->children[child->num] = right->children[0];

                    /* 将child右兄弟节点的第一个关键字移给父节点node */
                    node->keys[index] = right->keys[0];

                    /* 更新child右兄弟节点中关键字和子节点指针的位置 */
                    for (int i = 0; i < right->num - 1; ++i) {
                        right->keys[i] = right->keys[i + 1];
                        right->children[i] = right->children[i + 1];
                    }
                    right->keys[right->num - 1] = 0;
                    right->children[right->num - 1] = right->children   [right->num];
                    right->children[right->num] = nullptr;
                    right->num -= 1;

                } else {    // 选左子树

                    child->num++;
                    child->children[child->num] = child->children   [child->num - 1];
                    for (int i = child->num - 2; i >= 0; --i) {
                        child->keys[i + 1] = child->keys[i];
                        child->children[i + 1] = child->children[i];
                    }
                    child->keys[0] = node->keys[index - 1];
                    child->children[0] = left->children[left->num];

                    node->keys[index - 1] = left->keys[left->num - 1];

                    left->keys[left->num - 1] = 0;
                    left->children[left->num] = nullptr;
                    left->num -= 1;
                }
            } else {
                if (left && left->num == T->dgree - 1) {
                    btree_node_merge(T, node, index - 1);
                    child = left;
                } else if (right && right->num == T->dgree - 1) {
                    btree_node_merge(T, node, index);
                }
            }
        }
        btree_node_delete_key(T, child, key);
    }
}


/* 删除B树关键字 */
void btree_delete_key(btree *T, KEY_VALUE key) {
    if (T->root == nullptr)
        return ;

    btree_node_delete_key(T, T->root, key);
}

五、B树的应用案例

案例一、设计一个图片存储索引组件
  1. 图片的数量是巨大的。
  2. 可以添加图片，可以删除图片
  3. 可以通过图片名称进行查找
  4. 添加，删除，查找都是对单一图片进行操作

六、Tips

下面代码为打印函数和主函数，所有代码段可组成完整的B树创建、添加、删除代码。

void btree_print(btree *T, btree_node *node, int layer)
{
    btree_node *p = node;

    if (p) {
        printf("\nlayer = %d keynum = %d is_leaf = %d\n", layer, p->num, p->leaf);
        for(int i = 0; i < node->num; i++)
            printf("%C ", p->keys[i]);
        printf("\n");

        layer++;
        for(int i = 0; i <= p->num; i++)
            if(p->children[i])
                btree_print(T, p->children[i], layer);
    }
    else 
        printf("the tree is empty\n");
}

int main() {
    btree *T = btree_create(3);

    char key[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    for (int i = 0; i < 26; i++) {
        printf("%C ", key[i]);
        btree_insert_key(T, key[i]);
        btree_print(T, T->root, 0);
    }

    btree_print(T, T->root, 0);

    for (int i = 0; i < 26; i++) {
        printf("\n---------------------------------\n");
        btree_delete_key(T, key[25-i]);
        btree_print(T, T->root, 0);
    }

    return 0;
}

七、 源代码下载

https://download.csdn.net/download/weixin_44628585/86406400

心之所向041
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 实现的B树
weixin_45142497的博客
05-13 281
B树的实现思虑以及具体的编码落地
B-Tree以及创建过程演示
a1_HelloWord的博客
02-15 2816
当元素＜4且＞0时，直接按照顺序插入元素即可，插入元素结束，当元素＝4时，将插入的元素按照顺序放入结点中，然后从中选择一个数作为当前结点的父结点（选择结点的规则是 （n+1)/2 取整），本例为(5+1)/2=3即选取第三个元素，放入父结点中，若没有父结点则创建一个父结点，则插入结束；首先定义一个5阶的B树(平衡5路查找树),现在我们要把4、9、32、12、24、30、51、29、69、31、90、70、75、79、、80、85、91、 这些数字构建出一个5阶树出来;8.插入70，75，79。
B-树 c++实现
huhu123444的博客
06-21 934
B-树是一种平衡查找树，主要用于数据库的查找中。 1.结构题定义： typedef struct BTNode {// treeNode int keynum;// the number of elements struct BTNode *parent;//point to keyType key[m+1];//elements,begin with 0 struct BTNode *child[m];//the points pointing to child of the node }
B+树（C++实现）
一个人，在路上
06-12 1642
本文zh 定义： 一棵M（M>2）阶的B+树满足以下定义： 1.B+树中包含两种类型的结点：内结点和叶子结点。内结点存有关键字和孩子结点的指针，叶子结点存有关键字和数据； 2.每一个关键字都会在叶子结点中出现，叶子结点按照关键字的大小排序，叶子结点中会存有指向兄弟结点的指针； 3.一棵B+树一般存有两个指针：一个指向根结点，一个指向存有最小关键字的叶子结点； 4
【数据结构】树（四）：B树（C++实现）
快去创造奇迹
04-22 1456
B树
B+树C语言实现
qq_49764697的博客
12-27 756
B+树C语言实现，已实现插入功能
C++实现B树的创建，节点添加和删除。
08-22
C++实现B树的创建，节点添加和删除。
B树插入代码C++实现
12-22
C++实现B树时，通常会定义一个BTreeNode类，包括键数组、子节点指针数组以及节点是否为叶子节点等属性。同时，还需要提供插入、查找、删除等操作的成员函数。为了便于理解和调试，可以使用递归方式实现这些操作，但...
B树算法的C++实现
10-24
在给定的压缩包中，"B树"可能是实现B树算法的源代码文件，包含了上述功能的C++实现。通过阅读和学习这个源代码，你可以深入了解B树的内部工作机制，掌握如何在实际项目中应用B树算法。这将对理解和优化大数据存储、...
B树的C++实现
10-30
用 C++ 实现的一个 B 树类，有注释，但不知道我写得能不能看明白。使用时先要从类 CDataTypeForBtree 派生一个类出来，在派生类中实现数据比较函数 Compare，数据输出函数 Print。然后在堆上创建一个数据类对象，把...
B树的实现（C++）
07-16
网上很多程序没有注释，代码运行报错。所以精心重写了一下B树的实现。程序结构严谨，有详细的注释，运行没有问题，基于vs2013平台。对于刚学算法的人应该会有很大帮助。
B+树C++简单实现
02-20
数据库索引实验作业，B+树的C++简单实现，包含插入、删除以及查找功能，附带简单程序流程图助于理解代码。
B树 C语言实现
12-13
B树，C语言实现，添加到vc6.0中，可以执行的程序。
数据结构-B树的特点结构与C++实现
最新发布
m0_61789994的博客
06-09 1707
B树，全称为B-树（B-tree），是一种自平衡的搜索树，由Rudolf Bayer和Edward McCreight于1972年提出。B树的设计目标是在磁盘等外部存储介质上进行高效的查找、插入和删除操作。B树的关键特点是它可以容纳多个子节点的节点，这使得B树可以充分利用外部存储介质的块读取能力，减少磁盘IO次数，提高访问效率。B树的节点通常会存储一组有序的键值对，用于进行数据的检索和排序。
B-Tree的C++实现
Lynn
11-03 1481
简要说明下B树的性质。 用M表示B树的阶数，L表示叶子节点的最大元素个  （性质说明来自于《数据结构与问题求解(C++版)》第19章）  1、数据项保存在叶子中  2、非叶子节点具有M-1个键指导查找的进行；键i代表子树i+1中最小的键  3、根要么是叶子，要么就有2～M个孩子  4、所有非叶子节点，(根除外)都具有[M/2]～M个孩子  5、所有叶子都在同一深度，并且对某一叶子，具
图解B树构建过程
桔子
06-24 7630
1.B树结构同时满足以下特性 每个节点最多包含n个孩子，即n叉树； 除了根节点和叶子节点外，每个节点至少有ceil(n/2)个孩子（ceil是向上取整）； 若根节点不是叶子节点，则至少有两个孩子； 所有叶子节点在同一层； ☆☆☆每个非叶子节点由m个key和m+1个指针组成，其中(ceil(n/2)-1)<=m<=n-1； 【B树的非叶子节点示意图】 key是存储的值，保存的是数据表某一列的内容 p是指针，指向当前节点的孩子 一个非叶子节点中包括m个key和m+1个指针 【伪代码示例】
B树代码实现--C++
lzzw的学习之路
07-29 4061
B树，B+树原理及操作请点击这里 B树代码实现： #include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> #define KeyType int #define Record string con...
C++B树
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-28 517
B 树（B-tree）、B+ 树（B±tree） 特点 •一般化的二叉查找树（binary search tree） •“矮胖”，内部（非叶子）节点可以拥有可变数量的子节点（数量范围预先定义好） 应用 •大部分文件系统、数据库系统都采用B树、B+树作为索引结构 区别 •B+树中只有叶子节点会带有指向记录的指针（ROWID），而B树则所有节点都带有，在内部节点出现的索引项不会再出现在叶子节点中。 •B+树中所有叶子节点都是通过指针连接在一起，而B树不会。 B树的优点 对于在内部节点的数据，可直接得到，不必根据
用c++实现B树的插入
05-29
B树的插入操作相对比较复杂，需要考虑节点分裂、父节点的更新等情况。下面是一个简单的C++代码实现： ```c++ #include <iostream> #include <vector> using namespace std; const int MAX_KEY_NUM = 3; // B树的阶数 const int MIN_KEY_NUM = MAX_KEY_NUM / 2; // B树节点的结构体 struct BTreeNode { bool is_leaf; // 是否是叶子节点 vector<int> keys; // 存储节点的所有关键字 vector<BTreeNode*> children; // 存储子节点的指针 BTreeNode(bool is_leaf=false) : is_leaf(is_leaf) {} }; // 在B树的节点中查找关键字 int search_key(const vector<int>& keys, int key) { int left = 0, right = keys.size() - 1; while (left <= right) { int mid = (left + right) / 2; if (keys[mid] == key) return mid; else if (keys[mid] < key) left = mid + 1; else right = mid - 1; } return left; } // 在B树中查找关键字 BTreeNode* search_node(BTreeNode* root, int key) { if (root == nullptr) return nullptr; int i = search_key(root->keys, key); if (i < root->keys.size() && root->keys[i] == key) return root; else if (root->is_leaf) return nullptr; else return search_node(root->children[i], key); } // B树节点的分裂操作 void split(BTreeNode* node, int i) { BTreeNode* right = new BTreeNode(node->is_leaf); right->keys.assign(node->keys.begin() + MIN_KEY_NUM + 1, node->keys.end()); node->keys.resize(MIN_KEY_NUM); if (!node->is_leaf) { right->children.assign(node->children.begin() + MIN_KEY_NUM + 1, node->children.end()); node->children.resize(MIN_KEY_NUM + 1); } node->children.insert(node->children.begin() + i + 1, right); node->keys.insert(node->keys.begin() + i, right->keys[0]); } // B树的插入操作 void insert(BTreeNode*& root, int key) { if (root == nullptr) { root = new BTreeNode(true); root->keys.push_back(key); } else { BTreeNode* node = root; BTreeNode* parent = nullptr; int i; while (node != nullptr) { i = search_key(node->keys, key); if (i < node->keys.size() && node->keys[i] == key) return; parent = node; node = node->children.empty() ? nullptr : node->children[i]; } parent->keys.insert(parent->keys.begin() + i, key); if (parent->keys.size() > MAX_KEY_NUM) { int mid = MAX_KEY_NUM / 2; split(parent, mid); if (parent == root) { root = new BTreeNode(false); root->children.push_back(parent); } parent = parent->keys[mid]; } } } ``` 这段代码实现了B树的插入操作，其中 `MAX_KEY_NUM` 表示B树的阶数， `MIN_KEY_NUM` 表示每个节点的最小关键字数。在插入操作时，需要考虑节点分裂的情况。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值