C++实现B-Tree（B-树）

最新推荐文章于 2026-04-21 04:36:52 发布
原创 最新推荐文章于 2026-04-21 04:36:52 发布 · 555 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#c++ #b树 #算法 #数据结构
本文介绍了B-树的基本概念，展示了如何使用C++模板类实现B-树，包括节点结构、关键码处理、插入和删除操作，以及解决插入和删除操作导致的节点大小溢出问题。

参考：邓俊辉老师《数据结构C++语言实现》

B-树节点由多个关键码组成，在数据结构中用向量表示，同理，关键码的孩子也存在向量中，结构如下：

key:                             key0     key1     key2     key3     key4                                                (存数值)

child:                   child0     child1    child2   child3    child4  child5                                        (存指针)

BNode以及BTree定义：

//
// Created by Jayson on 2023/8/5.
//
#include <iostream>
#include "vector"
using namespace std;

template<typename T>
class BTNode{
public:
    BTNode<T>* parent;
    vector<T> key;
    vector<BTNode<T>*> child;

    BTNode(){//构造含有0个关键码的节点
        parent = NULL;
        child.push_back(NULL);
    }
    BTNode(T e,BTNode<T>* lc = NULL, BTNode<T>*rc = NULL){//构造含有一个关键码的节点
        parent = NULL;
        key.push_back(e);
        child.push_back(lc);
        child.push_back(rc);
        if(lc) lc->parent = this;
        if(rc) rc->parent = this;
    }
};

template<typename T>
class BTree{
public:
    BTNode<T>* _root;
    BTNode<T>* _hot;//搜索到节点的父亲，若搜索失败，则为"空节点"的父亲
    int _order;//B-树的阶，也就是child向量能包含元素的最大个数
    int _size;//关键码总数
    void solveOverFlow(BTNode<T>* v);//解决因为插入操作而产生的上溢
    void solveUnderFlow(BTNode<T>* v);//解决因为删除操作而产生的下溢

    BTree(int ord){
        _order = ord;
        _size = 0;
        _root = new BTNode<T>();
    }
    bool empty(){return !_root;}

    //查、插、删
    BTNode<T>* search(T e);
    bool insert(T e);
    bool remove(T e);
};

实现：

//辅助函数，在向量中查找，返回不大于该元素最大的秩，使用二分查找
template<typename T>
int binSearchInBTNode(vector<T> A,T e){
    if(A.size() == 0){
        return 0;
    }

    int lo = 0;
    int hi = A.size();
    while(lo<hi){
        int mid = (lo + hi) / 2;
        if(e < A[mid]){
            hi = mid;
        }else{
            lo = mid + 1;
        }
    }
    lo = lo - 1;
    return lo;
}

template<typename T>
BTNode<T>* BTree<T>::search(T e) {
    BTNode<T>* v = _root;
    _hot = NULL;
    while(v){
        int r = binSearchInBTNode(v->key,e);
        if( (r >= 0) && v->key[r] == e ) return v;
        _hot = v;
        v = v->child[r+1];
    }
    return NULL;
}

template<typename T>
bool BTree<T>::insert(T e) {
    BTNode<T>* v = search(e);
    if(v) return false;

    //查找失败，必失败于外部节点，_hot此时指向叶节点
    int r = binSearchInBTNode(_hot->key,e);
    _hot->key.insert(_hot->key.begin()+r+1,e);
    _hot->child.insert(_hot->child.begin()+r+2,NULL);
    _size++;
    solveOverFlow(_hot);
    return true;
}
template<typename T>
void BTree<T>::solveOverFlow(BTNode<T> *v) {
    if(v->child.size() <= _order) return;

    int rank = v->key.size() / 2;
    BTNode<T>* newNode = new BTNode<T>();
    for(int i = rank+1; i < v->key.size(); i++){
        newNode->key.push_back(v->key[i]);
    }
    newNode->child.clear();
    for(int i =rank+1; i < v->child.size(); i++){
        newNode->child.push_back(v->child[i]);
    }

    for(int i = 0; i < newNode->child.size(); i++){
        if(newNode->child[i])
            newNode->child[i]->parent = newNode;
    }

    T value = v->key[rank];//保存上溢节点值
    v->key.resize(rank);

    BTNode<T>* p = v->parent;
    if(!p){//当前节点已经是根，溢出称为新根
        _root = new BTNode<T>();
        p = _root;
        p->child[0] = v;
        p->child[1] = newNode;
        v->parent = p;
        newNode->parent = p;
        p->key.push_back(value);
    }else{
        int r = binSearchInBTNode(p->key,v->key[0]);//注意这里search的元素是key[0]
        p->key.insert(p->key.begin()+r+1,value);
        p->child.insert(p->child.begin()+r+2,newNode);
        newNode->parent = p;
    }
    solveOverFlow(p);
}

template<typename T>
bool BTree<T>::remove(T e) {
    BTNode<T>* v = search(e);
    if(!v) return false;

    int rank = binSearchInBTNode(v->key,e);
    if(v->child[0]){
        //v不是叶子节点
        BTNode<T>* u = v->child[rank+1];
        while(u->child[0]){
            u = u->child[0];
        }
        v->key[rank] = u->key[0];
        v = u;
        rank = 0;
    }
    v->key.erase(v->key.begin()+rank);
    v->child.erase(v->key.begin()+rank+1);
    _size--;
    solveUnderFlow(v);
}

template<typename T>
void BTree<T>::solveUnderFlow(BTNode<T> *v) {
    if( v->child.size() >= ((_order+1)/2) )return;//递归基：阶数满足条件

    BTNode<T>* p = v->parent;
    if(!p){//递归基：根节点size为0
        if(v->key.size()==0 && v->child[0]){
            _root = v->child[0];
            v->child[0]->parent = NULL;
            v->child[0] = NULL;
        }
        return;
    }

    int r = 0;
    while(p->child[r] != v){
        r++;
    }//确定v是r的第几个孩子

    //case1
    if(r>0){//左兄弟必然存在   此时p->child[r] == v;p->child[r-1] == 左兄弟
        BTNode<T>* ls = p->child[r-1];
        if(ls->child.size() >= ((_order+1)/2)+1){//左兄弟能借
            v->key.insert(v->key.begin(),p->key[r-1]);
            T value = ls->key[ls->key.size()-1];
            p->key[r-1] = value;
            v->child.insert(v->child.begin(),ls->child[ls->child.size()-1]);
            if(ls->child[ls->child.size()-1]) v->child[0]->parent = v;
            ls->key.resize(ls->key.size()-1);
            ls->child.resize(ls->child.size()-1);
            return;//修复完成
        }
    }
    //case2
    if(r<p->child.size()-1){//右兄弟必然存在
        BTNode<T>* rs = p->child[r+1];
        if(rs->child.size() >= ((_order+1)/2)+1)){//右兄弟能借
            v->key.push_back(p->key[r-1]);
            T value = rs->key[0];
            p->key[r-1] = value;
            v->child.push_back(rs->child[0]);
            if(rs->child[0]) rs->child[0]->parent = v;
            rs->key.erase(rs->key.begin());
            rs->child.erase(rs->child.begin());
            return;//修复完成
        }
    }

    //case3左右兄弟都无法借关键码，因此需要合并
    if(r>0){//与左兄弟合并
        BTNode<T>* ls = p->child[r-1];
        ls->key.push_back(p->key[r-1]);
        p->key.erase(p->key.begin()+r-1);
        p->child.erase(p->child.begin()+r);
        for(int i = 0; i<v->key.size(); i++){
            ls->key.push_back(v->key[i]);
        }
        for(int i = 0; i<v->child.size(); i++){
            ls->child.push_back(v->child[i]);
            if(v->child[i]) v->child[i]->parent = ls;
        }
        delete v;
    }else{//与右兄弟合并
        BTNode<T>* rs = p->child[r+1];
        rs->key.insert(rs->key.begin(),p->key[r]);
        p->child.erase(p->child.begin()+r);
        p->key.erase(p->key.begin()+r);
        for(int i = v->key.size()-1;i>=0;i--){
            rs->key.insert(rs->key.begin(),v->key[i]);
        }
        for(int i = v->child.size()-1; i>=0;i--){
            rs->child.insert(rs->child.begin(),v->child[i]);
            if(v->child[i]) v->child[i]->parent = rs;
        }
        delete v;
    }

    solveUnderFlow(p);
    return;
}

B+树C++代码实现
01-01
一个外国人写的B+树算法，由于注释比较少，故个人在参照时加上了自己的注释。该代码还用带了LRR和折半查找技术，很值得参考学习！！
C++语言实现B+树
10-20
C++实现B+树源代码，自己亲自写的哦，有问题可以联系
别再傻傻分不清了！5分钟搞懂IDS和IPS到底怎么选（附部署场景图）
最新发布
weixin_33730836的博客
04-21 464
本文详细解析了IDS（入侵检测系统）和IPS（入侵防御系统）的核心差异及适用场景，帮助读者快速掌握如何根据实际需求选择合适的网络安全设备。通过部署场景图和成本效益分析，为小型企业和开发测试环境提供实用建议，助力构建高效的第一道防线。
【数据结构】树（四）：B树（C++实现）
快去创造奇迹
04-22 1644
B树
关于B+树的介绍、用途和c++代码实现
猫哥 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS，AIOT)
05-12 4117
数据结构和算法的重要性不言而喻，一些优秀的开源项目的核心和灵魂就是数据结构、算法。在实际的编程中我们经常可以在各种框架、算法中看见B树、B+树的身影。特别是在数据库的数据库引擎中，它们更是占据着重要的地位。 下面我将通过简单的二叉树，到树的进化，多叉树(B树、B+树)的由来、作用、操作以及它们在实际中的应用依次进行详细说明。
B+树C++的实现
southekaer的博客
01-12 1883
1 找到节点中中间位置以及关键字，这个中间位置的关键字后面是需要插入到父节点中，如分裂的节点是根节点则需要创新一个新的根节点存放这个中间位置的关键字。1 从最右侧开始比较，如果插入值小于当前关键词的值，则将当前关键词右移一位，并继续比较，直到对比完第一个关键词或对比到不小于的关键词，将插入值保存。遍历节点内关键词，跟3进行对比，小于3，继续跟2对比，比2小，继续跟1对比，比1小，结束遍历，插入在1的左边。1 将中间值4插入父节点中，查询到此节点的父节点，并插入，如果父节点也需要分裂，则先递归分裂父节点。
Java 的 B-Tree 相关内容
darkstone
11-10 181
B-Tree(Binary Tree) 的 C++ 实现说明: http://cis.stvincent.edu/html/tutorials/swd/btree/btree.html   另一种 BTree(Balance Tree) 的实现例子: http://www.jbixbe.com/doc/tutorial/BTree.html   基于B-Tree 的开源 数据库: http://p...
B-树(B-Tree)的C++演示代码
Vaan的专栏
03-08 2508
 B-树(B-Tree)的C++演示代码    按照算法导论中伪代码转化，其中删除过程算法导论没有给出伪代码，所以对删除相关函数做了说明。另外B-Tree本来是用于硬盘的，但为了简便只阐明B-Tree的基本流程，没有加入硬盘扇区的直接读写操作，全部在内存中进行。1.头文件（B-Tree.h）#ifndef BTREE__JOHN__DMRC#define BTREE__JOHN__DM
数据结构（七）—— 树
weixin_42690036的博客
06-26 692
树形结构
如何用C++实现一个简易数据库（零）
weixin_44214242的博客
03-16 4216
如何用C++实现一个简易数据库 基于cstack/db_tutorial C语言版本 KCNyu 2022/2/2 作为笔者写的第一个系列型教程，还是选择基于前人的教程经验以及添加一些自己个人的探索。也许有很多纰漏之处，希望大家指正。 1. 数据库是什么？ 数据库是“按照数据结构来组织、存储和管理数据的仓库”。是一个长期存储在计算机内的、有组织的、可共享的、统一管理的大量数据的集合。使用者可以对其中的资料执行新增、选取、更新、刪除等操作。 2. SQL是什么？ SQL (Structured Query
用C++实现B+树
我是老伯的博客
01-19 4277
用C++实现B+树
B+树（C++实现）
一个人，在路上
06-12 1917
本文zh 定义： 一棵M（M>2）阶的B+树满足以下定义： 1.B+树中包含两种类型的结点：内结点和叶子结点。内结点存有关键字和孩子结点的指针，叶子结点存有关键字和数据； 2.每一个关键字都会在叶子结点中出现，叶子结点按照关键字的大小排序，叶子结点中会存有指向兄弟结点的指针； 3.一棵B+树一般存有两个指针：一个指向根结点，一个指向存有最小关键字的叶子结点； 4
【C/C++】B+树（C语言实现）
Michael
04-23 1910
C原因实现B+树的基本操作，包括查找、插入和分裂。在范围查找中，首先使用search函数找到第一个大于等于左端点的关键字所在的叶子节点，然后依次访问后续的叶子节点，将符合条件的关键字加入到结果集中。需要注意的是，在插入关键字时，如果节点中关键字个数超过了阶数M，需要进行分裂操作。希望这个修改后的代码能够帮助您解决问题。
C++实现B树
weixin_44628585的博客
08-22 1676
C++实现B树数据结构，包括创建，添加和删除的操作。
B树（B-tree）c++语言
m0_61862494的博客
03-07 355
B树可以自平衡，这意味着每次插入和删除操作后，B树都可以通过旋转和重构节点来保持平衡。这种自平衡的特性使得B树可以应对动态的数据存储需求，同时保持高效的查询和修改操作。B树的节点大小通常和磁盘块大小相同，因此可以直接在磁盘上存储B树。B树可以存储大量的数据，因为它可以在节点中存储多个关键字和指向子节点的指针。B树的查询和修改操作的时间复杂度为O(log n)，其中n是B树中存储的关键字数量。因此，B树被广泛应用于文件系统、数据库管理系统、存储系统和其他需要高效存储和管理大量数据的应用中。
【C++数据结构】B树概念及其实现（详解）
jhao的博客
07-21 2722
1970年，R.Bayer和E.mccreight提出了一种适合外查找的树，它是一种平衡的多叉树，称为B树。外查找即在不在内存当中查找，通常是在磁盘，磁盘数据通常挨着挨着存，所以只能通过建立索引的方式去找到对应的数据地址。由于AVL，红黑树的高度过高，采用这类数据结构会导致IO次数过多，所以我们通常选择层数更低的B树或者B+树。原理即是让每一层更多。并且B树天然平衡，呈现向右向上增长的趋势。B树的规则根节点至少有两个孩子既保持孩子比关键字多一个。.........
C++模板实现B+树
程序猿老樊的博客
08-27 3843
B+ 树是一种树数据结构，是一个n叉排序树，每个节点通常有多个孩子，一棵B+树包含根节点、内部节点和叶子节点。根节点可能是一个叶子节点，也可能是一个包含两个或两个以上孩子节点的节点。 B+ 树通常用于数据库和操作系统的文件系统中。NTFS, ReiserFS, NSS, XFS, JFS, ReFS 和BFS等文件系统都在使用B+树作为元数据索引。B+ 树的特点是能够保持数据稳定有序，其插入与修
b树的实现
u012637838的专栏
05-03 734
#include #include #include #include #include #define M 2 using namespace std; struct BTNode{ int keyNum; int key[2*M-1]; //关键字数组 struct BTNode* child[2*M];//孩子结点数组 bool isLeaf; }; void D
B-tree的代码实现 - c / c++ 版本
飞的更高~~
08-29 3386
看到一篇相关的好文章，引用下：http://www.cnblogs.com/leoo2sk/archive/2011/07/10/mysql-index.html 。相当滴不错，备忘下。 在这篇文章中http://blog.csdn.net/weege/article/details/6526512介绍了B-tree/B+tree/B*tree,并且介绍了B-tree的查找，插入，删除操作。现在
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值