B-树浅实现

最新推荐文章于 2022-05-18 17:18:35 发布
最新推荐文章于 2022-05-18 17:18:35 发布
阅读量649 收藏 1
点赞数
分类专栏： 数据结构基础 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CJMINGMING/article/details/121447337
版权

B-树查找特定元素e

1.假设当前在树t当中查找元素e

2.同二叉搜索树类似，先在根结点的key数组中找到e<=key[i]的位置i

3.当t不为空

​ （1）如果e==key[i]，则找到元素，返回查找结果

​ （2）如果e<key，则在key[i]的左子树也就是ptr[i]当中继续查找，将当前根节点记为t0，将根节点置为ptr[i]，回到1。

4.当t为空，则未找到元素，插入位置为t0节点、第i个位置

B-树插入元素e

1.利用查找算法找到插入的节点p和位置i，ap初始为NULL，指向比e大的节点

2.将元素e和ap插入相应节点p，然后判断p的key数量是否超过允许的最大结点数M

（1）如果未超过，则完成插入

（2）如果超过，则进行分裂，也就是将p当中的key拆分成一棵树：

​ a.令s= ⌈ M ⌉ \lceil M\rceil ⌈M⌉-1

​ b.key[s]作为根节点，然后新建一个新节点ap，将p当中key|s+1:M|的所有key和ptr|s+1:M|的所有ptr都移动到ap当中

​ c.将ap的父亲指针置为p的父指针

​ d.令p=p->parent，e=p->key[s]，

（3）如果此时p不为空也就是根节点并没有分裂，则回到2，将新分裂的key[s]和其右指针ap插入到原本p所在的节点当中；反之，进入4

4.生成新的根节点，元素e作为唯一一个元素，左指针为原来树根t，右子树为新分裂的ap

B-树删除元素e

1.首先查找删除元素e的节点位置p和位置i

2.然后判断是否为叶子节点、

（1）如果是叶子节点，直接删除，然后判断删除后该节点元素的个数是否小于规定最小值m

​ a.如果没有，结束删除

​ b.如果小于规定最小值m，则进行调整

（2）如果非叶子节点，则从从左子树取出左子树最大值lm，将需要删除的e所在key[i]置为lm，递归调用本删除算法从左子树删除lm

B-树删除调整

1.如果需要调整的节点p不为根节点

（1）通过父指针q找到p在q->ptr数组的位置j

（2）判断p的位置

​ a.p为q的最左侧子节点

​ 判断p的右兄弟rp的key的个数是否大于m，

​ 如果大于，则将右兄弟最小的key替换为其父亲key，父亲key指的是q->key数组当中满足key>p当中所有节点的最小的key值，然后将父亲key插入到p当中

​ 如果小于，则将父亲key和右兄弟合并到p当中，然后删除q当中的父亲key和其右指针（也就是右兄弟）

​ b.p为q中间子节点

​ 判断p的右兄弟rp的key的个数是否大于m

​ 如果大于，则将右兄弟最小的key替换为其父亲key，然后将父亲key插入到p当中

​ 如果小于，判断左兄弟lp的key个数是否大于m，同样右兄弟类似的操作

​ 如果lp和rp的key个数都不够，则将父亲key和右兄弟合并到p当中，然后删除q当中的父亲key和其右指针（也就是右兄弟）

​ c.p为q最右侧子节点

​ 判断p的左兄弟rp的key的个数是否大于m

​ 如果大于，左兄弟的最大值替换父亲key，然后将父亲key插入到p当中

​ 如果小于，则将父亲key和右兄弟合并到p当中，然后删除q当中的父亲key和其右指针（也就是右兄弟）

#include <iostream>
#include <queue>
#include <vector>

using namespace std;
#define MAXM 10

const int m=4;  //阶数
const int Max_key=m-1; //最大关键字个数
const int Min_key=(m-1)/2;//最小关键字个数
typedef int KeyType;//关键字类型
const int unknown=99999;

typedef struct Node
{
    int keynum;//结点个数
    struct Node *parent;//父节点
    KeyType key[MAXM];//关键字向量,0号多元未使用
    struct Node *ptr[MAXM];//子树指针向量
    //记录指针向量
    Node()
    {
        keynum=0;
        parent=NULL;
        for(int i=0;i<MAXM;i++)
        {
            key[i]=unknown;
            ptr[i]=NULL;
        }
    }
}BTNode,*BTree;

typedef struct
{
    BTNode *pt;//找到的结点
    int i;//查找结果在节点中关键字的位置
    int tag;//查找是否成功
}Result;

typedef enum status
{
    FALSE,
    TRUE,
    OK,
    ERROR,
    OVERFLOW,
    EMPTY
}Status;

Status InitBTree(BTree &t);//初始化B树
Status InsertNode(BTree t,KeyType key,BTree ap,int i);//插入特定结点
Status InsertBtree(BTree &t,BTree q,int i,KeyType key);//插入关键字
Result SearchBtree(BTree t,KeyType key);//查找关键字
int Search(BTree t,int key);//返回关键字在结点当中的位置
Status DeleteNode(BTree p,int i);//从结点当中删除关键字
Status DeleteBtree(BTree t,KeyType key);//删除关键字

Status InitBTree(BTree &t)
{
    t=NULL;
    return OK;
}

int Search(BTree t,int key)
{
    int i;
    for(i=1;i<=t->keynum;i++)
    {
        if(t->key[i]>=key)
            break;
    }
    return i;
}
Status InsertNode(BTree t,KeyType key,BTree ap,int i)
{
    int j=t->keynum;
    while(j>=i)
    {
        t->ptr[j+1]=t->ptr[j];
        t->key[j+1]=t->key[j];
        j--;
    }
    t->ptr[i]=ap;
    t->key[i]=key;
    t->keynum++;
    return OK;
}//插入key[i]和ptr[i]

void SplitNode(BTree p,int s,BTree &ap)
{
    ap=new BTNode;
    int j=0;
    ap->ptr[j++]=p->ptr[s];
    if(ap->ptr[0])
        ap->ptr[0]->parent=ap;
    p->ptr[s]=NULL;
    p->key[s]=unknown;
    for(int i=s+1;i<=p->keynum;i++)
    {
        ap->key[j]=p->key[i];
        ap->ptr[j]=p->ptr[i];
        if(ap->ptr[j])
            ap->ptr[j]->parent=ap;
        p->ptr[i]=NULL;
        p->key[i]=unknown;
        j++;
    }
    ap->keynum=p->keynum-s;
}


Status InsertBtree(BTree &t,BTree q,int i,KeyType key)
{
    KeyType x=key;
    BTree ap=NULL;
    bool finished=FALSE;
    while(q&&!finished)
    {
        InsertNode(q,x,ap,i);
        if(q->keynum<=Max_key)
        {
            finished=TRUE;
        }
        else
        {
            int mid=(Max_key+1)/2;
            x=q->key[mid];
            SplitNode(q,mid,ap);//将key[mid,m]和ptr[mid+1,m]转移到ap
            ap->parent=q->parent;
            q->keynum=mid-1;
            q=q->parent;
            if(q)
            {
                i=Search(q,x);
            }
        }
    }
    if(!finished)
    {
        //cout<<"insert root"<<endl;
        BTree nt=new BTNode;
        nt->keynum=1;
        nt->key[1]=x;
        nt->ptr[0]=t;
        nt->ptr[1]=ap;
        if(t)
            t->parent=nt;
        if(ap)
            ap->parent=nt;
        t=nt;
    }
    return OK;
}

Result SearchBtree(BTree t,KeyType key)
{
    BTree q,p;
    int flag=0;
    q=t;
    p=q;
    int i=1;
    while(q&&!flag)
    {
        i=Search(q,key);
        if(q->key[i]==key)
            flag=1;
        else
        {
            p=q;
            q=q->ptr[i-1];
        }
    }
    Result r;
    if(flag)
    {
        r.i=i;
        r.tag=1;
        r.pt=q;
    }
    else
    {
        r.i=i;
        r.pt=p;
        r.tag=0;
    }
    return r;
}

Status DeleteNode(BTree p,int i)
{
    for(;i<p->keynum;i++)
    {
        p->key[i]=p->key[i+1];
        p->ptr[i]=p->ptr[i+1];
    }
    p->key[i]=unknown;
    delete (p->ptr[i]);
    p->ptr[i]=NULL;
    p->keynum--;
    return OK;
}

Status MoveLeft(BTree lp,BTree rp)
{
    int i=lp->keynum+1;
    int j=1;
    while(j<=rp->keynum)
    {
        lp->key[i]=rp->key[j];
        lp->ptr[i]=rp->ptr[j];
        rp->key[j]=unknown;
        rp->ptr[j]=NULL;
        i++;
        j++;
        lp->keynum++;
    }
}
Status AdjustBtree(BTree &t,BTree p)
{
    //不为根节点
    if(p->parent)
    {
        BTree q=p->parent;
        BTree lp=NULL;
        BTree rp=NULL;
        int j=0;
        for(;j<=q->keynum;j++)
        {
            if(q->ptr[j]==p)
                break;
        }
        if(j==0)
        {
            rp=q->ptr[j+1];
            if(rp->keynum>Min_key)
            {
                InsertNode(p,q->key[j+1],rp->ptr[0],p->keynum+1);
                q->key[j+1]=rp->key[1];
                DeleteNode(rp,1);
            }
            else
            {
                InsertNode(p,q->key[j+1],rp->ptr[0],p->keynum+1);
                MoveLeft(p,rp);
                DeleteNode(q,j+1);
                rp=NULL;
            }
        }//p为最左边指针
        else if(j>0&&j<q->keynum)
        {
            lp=q->ptr[j-1];
            rp=q->ptr[j+1];
            if(rp->keynum>Min_key)
            {
                InsertNode(p,q->key[j+1],rp->ptr[0],p->keynum+1);
                q->key[j+1]=rp->key[1];
                DeleteNode(rp,1);
            }
            else if(lp->keynum>Min_key)
            {
                InsertNode(p,q->key[j],lp->ptr[lp->keynum],1);
                q->key[j]=lp->key[lp->keynum];
                DeleteNode(lp,lp->keynum);
            }
            else
            {
                InsertNode(p,q->key[j+1],rp->ptr[0],p->keynum+1);
                MoveLeft(p,rp);
                DeleteNode(q,j+1);
                rp=NULL;
            }
        }//中间指针
        else
        {
            lp=q->ptr[j-1];
            if(lp->keynum>Min_key)
            {
                InsertNode(p,q->key[j],lp->ptr[lp->keynum],1);
                q->key[j]=lp->key[lp->keynum];
                DeleteNode(lp,lp->keynum);
            }
            else
            {
                InsertNode(lp,q->key[j],p->ptr[0],lp->keynum+1);
                MoveLeft(lp,p);
                DeleteNode(q,j);
                p=NULL;
            }
        }//最右边指针
        if(q->keynum<Min_key)
        {
            AdjustBtree(t,q);
        }
    }
    else
    {
        t=t->ptr[0];
        /*
        if(t->ptr[0])
            cout<<t->ptr[0]->key[1]<<endl;*/
    }
}
Status DeleteBtree(BTree t,KeyType key)
{
    Result r=SearchBtree(t,key);
    if(!r.pt)
        return ERROR;
    BTree p=r.pt;
    BTree temp;
    temp=p->ptr[0];
    if(temp==NULL)
    {
            DeleteNode(p,r.i);
            if(p->keynum<Min_key)
                AdjustBtree(t,p);
    }//叶子结点
    else
    {
        BTree lc=p->ptr[r.i-1];//如果还有左孩子，则从左孩子当中找个最大值替代要删除的key
        p->key[r.i]=lc->key[lc->keynum];
        DeleteBtree(lc,lc->key[lc->keynum]);
    }

    if(t->keynum==0)
    {
        BTree t1=t->ptr[0];
        t=t->ptr[0];
        t->ptr[0]=NULL;
    }
}

void DisplayBTree(BTree t)
{
    queue<BTNode*> q;
    q.push(t);
    vector<vector<vector<int>>> res;
    q.push(NULL);
    BTree p;
    vector<vector<int>> t2;
    while(!q.empty())
    {
        p=q.front();
        q.pop();
        if(!p)
        {
            res.push_back(t2);
            if(!q.empty())
            {
                q.push(NULL);
            }
            t2.clear();
        }
        else
        {
            vector<int> t1;
            for(int i=0;i<=p->keynum;i++)
            {
                if(p->ptr[i])
                    q.push(p->ptr[i]);
            }
            for(int i=1;i<=p->keynum;i++)
            {
                t1.push_back(p->key[i]);
            }
            t2.push_back(t1);
        }
    }
    for(int i=0;i<res.size();i++)
    {
        for(int j=0;j<res[i].size();j++)
        {
            for(int k=0;k<res[i][j].size();k++)
            {
                cout<<res[i][j][k]<<' ';
            }
            cout<<"---";
        }
        cout<<endl;
    }
}
int main()
{
    BTree t;
    InitBTree(t);
    vector<int> testData={56,3,37,24,53,90,61,100,70,45,77,33,1000,1500,2600,26};
    for(int i=0;i<testData.size();i++)
    {
        Result r=SearchBtree(t,testData[i]);
        if(r.tag==0)
            InsertBtree(t,r.pt,r.i,testData[i]);
         //DisplayBTree(t);
    }
    DisplayBTree(t);
    DeleteBtree(t,100);
    DisplayBTree(t);
    DeleteBtree(t,1000);
    DisplayBTree(t);
    DeleteBtree(t,1500);
    DisplayBTree(t);
    DeleteBtree(t,24);
    DisplayBTree(t);
    DeleteBtree(t,2600);
    DisplayBTree(t);
    DeleteBtree(t,90);
    DisplayBTree(t);
    DeleteBtree(t,56);
    DisplayBTree(t);
    DeleteBtree(t,77);
    DisplayBTree(t);
    return 0;
}

​

我的代码不是我的代码
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高级数据结构之B树（B-tree）
白马负金羁
05-09 4886
一、B树（B-tree）的定义 B树是二叉树的一种推广，它在以硬盘为主的多级存储结构中常常被用来执行高效搜索。下图是一棵B树的简单示例，其中存储的是英语中的辅音字母。如果B树的一个内部结点x包含有x.n个关键字，那么它就会有x.n+1个孩子。结点x中的关键字是有序排列的，而且这些有序的关键字也把以x为根的子树中所包含关键字分隔成x.n+1个子域，每个子域对应一棵子树。当在一棵B树中查找一个关键字...
单列集合Collection---TreeSet----HashSet--树结构浅谈
Yesterday Once More的博客
10-19 213
Set接口 继承Collection 实现类：HashSet类 TreeSet类 特点： 可以去除重复（可以存储重复的元素，但会自动去除重复的元素） 存取顺序不一致（存入的顺序和取出的打印时的顺序不一致） 没有带索引的方法，所以不能通过普通for循环遍历，也不能通过索引来获取，删除Set集合里面的元素 TreeSet 集合类 特点： 不包含重复元素的集合 没有带索引的方法 可以将元素按照规则进行排序 使用时必须制定排序规则 自然排序(Comparable接口)的使用： 使用空参构造创建TreeSet集
B树的实现
gaoyi的专栏
05-15 1294
B树是什么，不用说了，相信大家都懂，我今天只想详细地说一下B树的插入和删除的详细算法，为了以后自己看起来方便，并且附上自己的代码，希望对各位也能够有所帮助。B树的插入算法：1）用查找的方法为x找到所在的位置，查找路径终于某个空树，然后把x插入到其父结点的有序位置上，注意B树所有的插入都是在叶结点上进行。2）如果插入x后，结点不超长，则插入完毕；否则，进入下一步，进行超长处理。3）将超长结点一分为二...
B+树的实现
热门推荐
施工中请绕行
12-10 1万+
B+树是B树的变形，它在B树的节点里删除了关键字的指针域，只保留了链接节点的指针域，在叶节点上，这个链接节点的指针域用来保存关键字信息。B+树中的关键字在树中可能不止出现一次（最多出现两次），但一定在叶节点出现一次。相邻的叶节点用单链表形式连接起来，也就是说，找到了最左的叶节点后，所有关键字信息就可以按照遍历单链表的形式遍历出来。                虽然在B+树中关键字可能会冗余存
B-树 实现
水人的专栏
02-29 657
B-树主要用在文件系统中，关键字为文件名，值为文件在磁盘中的地址。分支因子很大，一般为50到2000，一个节点就用一个磁盘块存储。 按照《算法导论》的描述，节点有如下性质： 1、至少有t-1个关键字，至多2*t-1个关键字，关键字以升序排列； 2、至少有t个子女节点指针，至多2*t个； 3、n[x]个关键字对应n[x]+1个子女节点指针； 4、根节点至少包含一个关键字； 以下是
B-树实现
haodynasty的专栏
08-10 205
1.什么是B-树？ 这个在我的前一篇博客中已经详细的阐释过： http://hao3100590.iteye.com/blog/1576846 具体的了解，好好看看这篇文章就可以了！   2.实现关键问题分析 a.B-树删除原则 见下图：  当然总结起来，大的方面就3点，具体的细节就没有做多大的说明，在下面具体实现的时候会说明   b.B-树的递归和非递归遍历 对于非递归遍历...
B树实现
weixin_41053675的博客
11-07 341
B-树是一种平衡的多路查找树，它在文件系统中很有用。[1] B-树主要用作文件的索引，因此它的查找涉及外存的存取。[1] B-树适用于：当文件很大时，索引表（树表）本身也在外存，则查找索引时需多次访问外存，并且，访问外存的次数恰为查找路径上的结点数。为减少访问外存的次数，应尽量缩减索引表的深度。此时宜采用m叉的B-树作索引表。m的选择取决于索引项的多少和缓冲区的大小。[1] 实现语言...
课程设计(旅游管理系统-和B-树的实现).doc
06-19
总的来说，这份课程设计报告深入浅出地阐述了旅游信息管理系统的设计和B-树的实现，涵盖了数据结构中的重要概念，如二叉排序树、单链表和B-树，以及如何在实际问题中应用这些数据结构。这些知识在互联网开发中尤其...
b树C#语言实现
11-28
代码参考了《算法导论》一书，这本书是算法领域的经典教材，对B树的介绍深入浅出，提供了详细的理论和实例。在实现过程中，可能会涉及到递归方法来处理子树的插入和删除操作，以及利用C#的泛型特性来支持不同数据...
b-树的代码实现
01-21
关于b-树的插入，删除等操作的实现，花费了我不少的时间，希望对大家有所帮助
B-树的源代码实现
07-02
数据结构课程设计是做了玩儿的。 C风格的B-树，支持宏定义N阶
B-+树的实现细节
12-26
B-+树的实现细节，赞赞赞赞赞赞赞赞赞赞赞赞赞赞赞赞赞赞赞赞赞
b+/-树的实现源代码
05-18
“b+ 树”和“b- 树”的具体实现，有意搜索引擎或数据库的可以参考一下。
算法-理论基础- 树（包含源程序）.rar
09-16
树的主要类型包括二叉树、完全二叉树、满二叉树、平衡二叉树（如AVL树、红黑树）、B树、B+树等。每种类型的树都有其特定的性质和应用场景。例如，二叉搜索树允许快速查找、插入和删除操作；AVL树通过保持平衡，确保...
B-树的实现（一）
c_living的博客
07-18 321
B-树(多路平衡搜索树)的定义虽然比较简单，寥寥几条： 1.m阶B-树，最多只能有m个分支。 2.m阶B-树的关键字个数要介于[m/2](向上取整)-1和m-1之间（根节点除外） 3.关键字内部按升序排列 4.所有叶子节点一定在同一层 根据定义来实现B-树的难点在第二条，这就会导致分裂和合并的情况。 图文讲解可以看下面这个博客，非常的详细：  http://www.cnblogs.c...
二叉树（B-Tree）实现
qq_41195778的博客
05-18 756
二叉树实现 简单的二叉树实现，涉及添加左子节点，右子节点，删除子节点，删除只考虑整树删除，暂时不考虑升树，后面会出升树的实现 定义Node结点 @Data public class Node<T> { private T no; private Node left; private Node right; public Node(T no) { this.no = no; } @Override public Strin
B-树的实现（二）C语言实现
c_living的博客
07-18 555
虽然前面把伪代码进行了阐述，但是想要真正的编写出来还是非常的不容易，鉴于能力有限，本人的实现版本如下（和伪代码差距有点大，码力差距还是和别人有很大） #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define m 4 //B_树的数据结构 typedef struct node{ int Numbers; int val[m+1...
B-树概念和插入实现
qq_43780350的博客
10-03 981
B-树 1. 基本搜索结构 顺序查找—O(N) 二分查找—序列必须有序—>logN 二叉搜索树—O(N) AVL—红黑树—O(logN) 哈希—高效查找—>O(1) 位图—>O(1) 布隆过滤器—O(k) 以上结构适合用于数据量不是很大的情况，如果数据量非常大，一次性无法加载到内存中，使用上述结构就不是很方便。比如：使用平衡树搜索一个大文件 上面方法其实只在内存中保存了每一项...
B-树插入节点：查找分类与算法详解
总结来说，这部分内容深入浅出地介绍了查找算法的基础理论和实践应用，特别是B-树的插入操作和查找性能优化，对于理解数据结构和数据库管理有着重要的作用。掌握这些概念和技术，有助于提高程序设计和数据分析的效率...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值