第15周项目3 B-树的基本操作

最新推荐文章于 2023-12-04 21:41:07 发布
最新推荐文章于 2023-12-04 21:41:07 发布
阅读量380 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyj854275509/article/details/50296535
版权

问题：

/*
* Copyright (c)2015,烟台大学计算机与控制工程学院
* All rights reserved.
* 文件名称：项目3.cbp
* 作    者：张芸嘉
* 完成日期：2015年12月14日
* 版 本 号：v1.0

* 问题描述：
        实现B-树的基本操作。基于序列{4, 9, 0, 1, 8, 6, 3, 5, 2, 7}完成测试。 
        
        （1）创建对应的3阶B-树b，用括号法输出b树。 
        （2）从b中分别删除关键字为8和1的节点，用括号法输出删除节点后的b树。

* 输入描述：无
* 程序输出：测试数据
*/


代码：

#include <stdio.h>
#include <malloc.h>
#define MAXM 10                     //定义B-树的最大的阶数
typedef int KeyType;                //KeyType为关键字类型
typedef struct node                 //B-树结点类型定义
{
    int keynum;                     //结点当前拥有的关键字的个数
    KeyType key[MAXM];              //key[1..keynum]存放关键字,key[0]不用
    struct node *parent;            //双亲结点指针
    struct node *ptr[MAXM];         //孩子结点指针数组ptr[0..keynum]
} BTNode;
typedef struct                      //B-树的查找结果类型
{
    BTNode *pt;                     //指向找到的结点
    int i;                          //1..m,在结点中的关键字序号
    int tag;                        //1:查找成功,O:查找失败
}  Result;
int m;                              //m阶B-树,为全局变量
int Max;                            //m阶B-树中每个结点的至多关键字个数,Max=m-1
int Min;                            //m阶B-树中非叶子结点的至少关键字个数,Min=(m-1)/2
int Search(BTNode *p,KeyType k)
{
    //在p->key[1..keynum]中查找i,使得p->key[i]<=k<p->key[i+1]
    int i=0;
    for(i=0; i<p->keynum && p->key[i+1]<=k; i++);
    return i;
}
Result SearchBTree(BTNode *t,KeyType k)
{
    /*在m阶t树t上查找关键字k,返回结果(pt,i,tag)。若查找成功,则特征值
     tag=1,指针pt所指结点中第i个关键字等于k；否则特征值tag=0,等于k的
     关键字应插入在指针Pt所指结点中第i和第i+1个关键字之间*/
    BTNode *p=t,*q=NULL; //初始化,p指向待查结点,q指向p的双亲
    int found=0,i=0;
    Result r;
    while (p!=NULL && found==0)
    {
        i=Search(p,k);              //在p->key[1..keynum]中查找i,使得p->key[i]<=k<p->key[i+1]
        if (i>0 && p->key[i]==k)    //找到待查关键字
            found=1;
        else
        {
            q=p;
            p=p->ptr[i];
        }
    }
    r.i=i;
    if (found==1)                   //查找成功
    {
        r.pt=p;
        r.tag=1;
    }
    else                            //查找不成功,返回K的插入位置信息
    {
        r.pt=q;
        r.tag=0;
    }
    return r;                       //返回k的位置(或插入位置)
}
void Insert(BTNode *&q,int i,KeyType x,BTNode *ap)
{
    //将x和ap分别插入到q->key[i+1]和q->ptr[i+1]中
    int j;
    for(j=q->keynum; j>i; j--)  //空出一个位置
    {
        q->key[j+1]=q->key[j];
        q->ptr[j+1]=q->ptr[j];
    }
    q->key[i+1]=x;
    q->ptr[i+1]=ap;
    if (ap!=NULL) ap->parent=q;
    q->keynum++;
}
void Split(BTNode *&q,BTNode *&ap)
{
    //将结点q分裂成两个结点,前一半保留,后一半移入新生结点ap
    int i,s=(m+1)/2;
    ap=(BTNode *)malloc(sizeof(BTNode));    //生成新结点*ap
    ap->ptr[0]=q->ptr[s];                   //后一半移入ap
    for (i=s+1; i<=m; i++)
    {
        ap->key[i-s]=q->key[i];
        ap->ptr[i-s]=q->ptr[i];
        if (ap->ptr[i-s]!=NULL)
            ap->ptr[i-s]->parent=ap;
    }
    ap->keynum=q->keynum-s;
    ap->parent=q->parent;
    for (i=0; i<=q->keynum-s; i++) //修改指向双亲结点的指针
        if (ap->ptr[i]!=NULL) ap->ptr[i]->parent = ap;
    q->keynum=s-1;                      //q的前一半保留,修改keynum
}
void NewRoot(BTNode *&t,BTNode *p,KeyType x,BTNode *ap)
{
    //生成含信息(T,x,ap)的新的根结点*t,原t和ap为子树指针
    t=(BTNode *)malloc(sizeof(BTNode));
    t->keynum=1;
    t->ptr[0]=p;
    t->ptr[1]=ap;
    t->key[1]=x;
    if (p!=NULL) p->parent=t;
    if (ap!=NULL) ap->parent=t;
    t->parent=NULL;
}
void InsertBTree(BTNode *&t, KeyType k, BTNode *q, int i)
{
    /*在m阶t树t上结点*q的key[i]与key[i+1]之间插入关键字k。若引起
     结点过大,则沿双亲链进行必要的结点分裂调整,使t仍是m阶t树。*/
    BTNode *ap;
    int finished,needNewRoot,s;
    KeyType x;
    if (q==NULL)                        //t是空树(参数q初值为NULL)
        NewRoot(t,NULL,k,NULL);         //生成仅含关键字k的根结点*t
    else
    {
        x=k;
        ap=NULL;
        finished=needNewRoot=0;
        while (needNewRoot==0 && finished==0)
        {
            Insert(q,i,x,ap);               //将x和ap分别插入到q->key[i+1]和q->ptr[i+1]
            if (q->keynum<=Max) finished=1; //插入完成
            else
            {
                //分裂结点*q,将q->key[s+1..m],q->ptr[s..m]和q->recptr[s+1..m]移入新结点*ap
                s=(m+1)/2;
                Split(q,ap);
                x=q->key[s];
                if (q->parent)              //在双亲结点*q中查找x的插入位置
                {
                    q=q->parent;
                    i=Search(q, x);
                }
                else needNewRoot=1;
            }
        }
        if (needNewRoot==1)                 //根结点已分裂为结点*q和*ap
            NewRoot(t,q,x,ap);              //生成新根结点*t,q和ap为子树指针
    }
}
void DispBTree(BTNode *t)   //以括号表示法输出B-树
{
    int i;
    if (t!=NULL)
    {
        printf("[");            //输出当前结点关键字
        for (i=1; i<t->keynum; i++)
            printf("%d ",t->key[i]);
        printf("%d",t->key[i]);
        printf("]");
        if (t->keynum>0)
        {
            if (t->ptr[0]!=0) printf("(");  //至少有一个子树时输出"("号
            for (i=0; i<t->keynum; i++)     //对每个子树进行递归调用
            {
                DispBTree(t->ptr[i]);
                if (t->ptr[i+1]!=NULL) printf(",");
            }
            DispBTree(t->ptr[t->keynum]);
            if (t->ptr[0]!=0) printf(")");  //至少有一个子树时输出")"号
        }
    }
}
void Remove(BTNode *p,int i)
//从*p结点删除key[i]和它的孩子指针ptr[i]
{
    int j;
    for (j=i+1; j<=p->keynum; j++)      //前移删除key[i]和ptr[i]
    {
        p->key[j-1]=p->key[j];
        p->ptr[j-1]=p->ptr[j];
    }
    p->keynum--;
}
void Successor(BTNode *p,int i)
//查找被删关键字p->key[i](在非叶子结点中)的替代叶子结点
{
    BTNode *q;
    for (q=p->ptr[i]; q->ptr[0]!=NULL; q=q->ptr[0]);
    p->key[i]=q->key[1];    //复制关键字值
}
void MoveRight(BTNode *p,int i)
//把一个关键字移动到右兄弟中
{
    int c;
    BTNode *t=p->ptr[i];
    for (c=t->keynum; c>0; c--) //将右兄弟中所有关键字移动一位
    {
        t->key[c+1]=t->key[c];
        t->ptr[c+1]=t->ptr[c];
    }
    t->ptr[1]=t->ptr[0];        //从双亲结点移动关键字到右兄弟中
    t->keynum++;
    t->key[1]=p->key[i];
    t=p->ptr[i-1];              //将左兄弟中最后一个关键字移动到双亲结点中
    p->key[i]=t->key[t->keynum];
    p->ptr[i]->ptr[0]=t->ptr[t->keynum];
    t->keynum--;
}
void MoveLeft(BTNode *p,int i)
//把一个关键字移动到左兄弟中
{
    int c;
    BTNode *t;
    t=p->ptr[i-1];              //把双亲结点中的关键字移动到左兄弟中
    t->keynum++;
    t->key[t->keynum]=p->key[i];
    t->ptr[t->keynum]=p->ptr[i]->ptr[0];

    t=p->ptr[i];                //把右兄弟中的关键字移动到双亲兄弟中
    p->key[i]=t->key[1];
    p->ptr[0]=t->ptr[1];
    t->keynum--;
    for (c=1; c<=t->keynum; c++)    //将右兄弟中所有关键字移动一位
    {
        t->key[c]=t->key[c+1];
        t->ptr[c]=t->ptr[c+1];
    }
}
void Combine(BTNode *p,int i)
//将三个结点合并到一个结点中
{
    int c;
    BTNode *q=p->ptr[i];            //指向右结点,它将被置空和删除
    BTNode *l=p->ptr[i-1];
    l->keynum++;                    //l指向左结点
    l->key[l->keynum]=p->key[i];
    l->ptr[l->keynum]=q->ptr[0];
    for (c=1; c<=q->keynum; c++)        //插入右结点中的所有关键字
    {
        l->keynum++;
        l->key[l->keynum]=q->key[c];
        l->ptr[l->keynum]=q->ptr[c];
    }
    for (c=i; c<p->keynum; c++)     //删除父结点所有的关键字
    {
        p->key[c]=p->key[c+1];
        p->ptr[c]=p->ptr[c+1];
    }
    p->keynum--;
    free(q);                        //释放空右结点的空间
}
void Restore(BTNode *p,int i)
//关键字删除后,调整B-树,找到一个关键字将其插入到p->ptr[i]中
{
    if (i==0)                           //为最左边关键字的情况
        if (p->ptr[1]->keynum>Min)
            MoveLeft(p,1);
        else
            Combine(p,1);
    else if (i==p->keynum)              //为最右边关键字的情况
        if (p->ptr[i-1]->keynum>Min)
            MoveRight(p,i);
        else
            Combine(p,i);
    else if (p->ptr[i-1]->keynum>Min)   //为其他情况
        MoveRight(p,i);
    else if (p->ptr[i+1]->keynum>Min)
        MoveLeft(p,i+1);
    else
        Combine(p,i);
}
int SearchNode(KeyType k,BTNode *p,int &i)
//在结点p中找关键字为k的位置i,成功时返回1,否则返回0
{
    if (k<p->key[1])    //k小于*p结点的最小关键字时返回0
    {
        i=0;
        return 0;
    }
    else                //在*p结点中查找
    {
        i=p->keynum;
        while (k<p->key[i] && i>1)
            i--;
        return(k==p->key[i]);
    }
}
int RecDelete(KeyType k,BTNode *p)
//查找并删除关键字k
{
    int i;
    int found;
    if (p==NULL)
        return 0;
    else
    {
        if ((found=SearchNode(k,p,i))==1)       //查找关键字k
        {
            if (p->ptr[i-1]!=NULL)              //若为非叶子结点
            {
                Successor(p,i);                 //由其后继代替它
                RecDelete(p->key[i],p->ptr[i]); //p->key[i]在叶子结点中
            }
            else
                Remove(p,i);                    //从*p结点中位置i处删除关键字
        }
        else
            found=RecDelete(k,p->ptr[i]);       //沿孩子结点递归查找并删除关键字k
        if (p->ptr[i]!=NULL)
            if (p->ptr[i]->keynum<Min)          //删除后关键字个数小于MIN
                Restore(p,i);
        return found;
    }
}
void DeleteBTree(KeyType k,BTNode *&root)
//从B-树root中删除关键字k,若在一个结点中删除指定的关键字,不再有其他关键字,则删除该结点
{
    BTNode *p;              //用于释放一个空的root
    if (RecDelete(k,root)==0)
        printf("   关键字%d不在B-树中\n",k);
    else if (root->keynum==0)
    {
        p=root;
        root=root->ptr[0];
        free(p);
    }
}
int main()
{
    BTNode *t=NULL;
    Result s;
    int j,n=10;
    KeyType a[]= {4,9,0,1,8,6,3,5,2,7},k;
    m=3;                                //3阶B-树
    Max=m-1;
    Min=(m-1)/2;
    printf("创建一棵%d阶B-树:\n",m);
    for (j=0; j<n; j++)                 //创建一棵3阶B-树t
    {
        s=SearchBTree(t,a[j]);
        if (s.tag==0)
            InsertBTree(t,a[j],s.pt,s.i);
        printf("   第%d步,插入%d: ",j+1,a[j]);
        DispBTree(t);
        printf("\n");
    }
    printf("  结果B-树: ");
    DispBTree(t);
    printf("\n");
    printf("删除操作:\n");
    k=8;
    DeleteBTree(k,t);
    printf("  删除%d: ",k);
    printf("B-树: ");
    DispBTree(t);
    printf("\n");
    k=1;
    DeleteBTree(k,t);
    printf("  删除%d: ",k);
    printf("B-树: ");
    DispBTree(t);
    printf("\n");
    return 0;
}


运行结果：

知识点总结：

        B-树的基本操作。

zyj854275509
关注
《英雄编程体验课》第 15 课 | C语言中的数学库
英雄哪里出来
07-05 5万+
C语言中的数学库
2013级C++第15周项目——二维数组
hgdfguj的博客
11-18 459
分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 课程主页在：http:
B树的基本操作
05-13
B树的实现与基本操作，包括添加和删除有关节点等
第15周实践项目-B-树的基本操作
lalala_wm的博客
12-05 499
问题 /* *Copyright (c) 2015,烟台大学计算机学院 *All rights reserved. *文件名称：test.cpp *作者：王敏 *完成日期：2015年12月5日 *版本号：v1.0 * *问题描述：实现B-树的基本操作 *输入描述： *程序输出： */ 代码 #include #include #define MAXM 10
B-树基本操作的实现 利用C++模板类封装
龙卡的博客
12-21 1442
程序还未经过严格的测试，不能保证完全正确，仅作为学习参考。 注释感觉还比较详细，我就不多bb了，直接上代码 /* 项目名：B-树 作者：龙卡 完成时间：2020/12/21 0:04 个人感受：手撕B-树真的太难了，要想写好还得在每一步把所有可能的情况全部考虑完，调试过程中遇到的最严重的bug就是par指针 的维护不到位，有很多情况没有维护好，导致出了bug。本来以为会让做平衡二叉树的实验，结果直接上B-树，只能说 “老赵，可真有你的” */ #include<iostream> #includ
数据结构实验报告-查找-B-树基本操作的实现-实验内容与要求
03-17
定义B-树存储结构（要求m3；为方便操作，结点中增加双亲结点指针域，最底层的Fail结点用NULL指针表示并且所有结点均存储于内存）。定义B-树插入关键字函数、删除关键字函数、查找关键字函数以及按层次遍历输出B-树所有结点的函数。主函数定义菜单(1.插入关键字 2.删除关键字 3. 查找关键字 4.层次遍历输出B-树所有结点 5.结束程序)。
数据结构实验报告10-查找-B-树基本操作的实现-实验内容与要求.docx
07-06
定义B-树存储结构（要求m3；为方便操作，结点中增加双亲结点指针域，最底层的Fail结点用NULL指针表示并且所有结点均存储于内存）。定义B-树插入关键字函数、删除关键字函数、查找关键字函数以及按层次遍历输出B-树所有结点的函数。主函数定义菜单(1.插入关键字 2.删除关键字 3. 查找关键字 4.层次遍历输出B-树所有结点 5.结束程序)。 1. 插入关键字功能的输入为一个关键字，输出为新插入关键字所在结点的信息。 要求结点信息输出格式如下所示: (R102, n, K1, K2, …, Kn) R102表示结点位置，R表示根结点指针；第一个数字1表示根结点的A[1]指针，第二个数字0表求R->A[1]所指结点的A[0]指针，第三个数字2表示R->A[1]->A[0]所指结点的A[2]指针，即该结点指针为: R->A[1]->A[0]->A[2](该结点在第4层上)。n为该结点的关键字数目，K1, K2, …, Kn为该结点中n个非递减有序的关键字。 2. 删除关键字功能的输入为一个关键字，输出为删除成功与失败的信息。 3. 查找关键字功能的输入为一个关键字，输出为查找成功与失败的信息，查找成功时，应输出关键字所在结点信息（结点信息输出方法同1.）。 4. 按层次遍历输出B-树所有结点功能的输入为一个字符文件名，输出为该字符文件，字符文件中，一个结点的信息输出一行（结点信息输出方法同1.），结点输出次序为按层次号由小到大并且同层结点从左向右。
第十五周 项目3 B-树的基本操作
wly16885885的博客
12-15 462
问题描述及代码： #ifndef BTREE_H_INCLUDED #define BTREE_H_INCLUDED /* *烟台大学计控学院 *作 者：王力源 *完成日期：2016年12月15日 *问题描述: 实现B-树的基本操作。基于序列{4, 9, 0, 1, 8, 6, 3, 5, 2, 7}完成测试。 　　 （1）创建对应的3阶B-树b，用括号法输出
第15周项目3 - B-树的基本操作
wangjingsnowzero的博客
12-08 451
Copyright (c)2016,烟台大学计算机与控制工程学院  * All rights reserved.  * 文件名称：项目3.cbp  * 作    者：王婧  * 完成日期：2016年12月8日  * 版 本 号：v1.0    * 问题描述：          实现B-树的基本操作。基于序列{4, 9, 0, 1, 8, 6, 3, 5, 2, 7}完成测试。
软件项目管理第4版课后习题-期末复习题型分册版-带答案
热门推荐
Serendipity
12-30 2万+
一、填空题 1、敏捷模型包括（4）个核心价值，对应（12）个敏捷原则。 2、项目管理包括（启动过程组）、（计划过程组）、（执行过程组）、（控制过程组）、（收尾过程组）5个过程组。 3、项目立项之后，项目负责人会进行（自造-购买）决策，确定待开发产品的哪些部分应该采购、外包开发、自主研发等。 4、PMI人才三角重点关注（技术项目管理）、（领导力）、（战略和商务管理）3个关键技能。 5、在（立项）阶段，应该明确项目的目标、时间表、使用的资源和经费，而且得到项目发起人的认可。 6、（瀑布模型）生存期模型中，要求项
数据结构-动态查找表（B树的基本操作代码实现）
weixin_52144018的博客
02-14 995
#include <iostream> using namespace std; const int m = 3;//设定B树的阶数 //关键字的个数n必须满足：[m/2]-1≤n≤m-1 const int MaxKeyNum = m - 1;//最大关键字数量 const int MinKeyNum = m / 2 - 1;//最小关键字数量 typedef int ElemType;//关键字类型定义 typedef struct BTNode { int keynum; /.
数据结构-（2-3树，2-3-4树，B-树，B+树）
理科男同学
11-16 2229
目录 1，二叉树存在问题分析 2，多叉树B树的介绍 2.1，2-3树和2-3-4树的介绍 2.2，B树的查找 2.3，B树的创建和插入 2.4，B树的删除 3，B+树 3.1，m 阶的B+树与m阶的B树的主要差异 1，二叉树存在问题分析 虽然我们说二叉排序树，平衡二叉树的查找操作效率较高，但是也存在问题, 请看下面的二叉树。 二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如1亿)， 就存在如下问题: 问题1：在构建二叉树时，需要多次进行i/
实现B-树的相关运算算法
xiezhi123456的博客
02-22 1898
B-tree即B树，B即Balance，平衡的意思。B-树是一种多路搜索树(并不一定是二叉的)。 当查找的文件较大，且存放在磁盘等直接存取设备中时，为了减少查找过程中对磁盘的读写次数，提高查找效率，基于直接存取设备的读写操作以"页"为单位的特征。 1970年，R.Bayer和E.M.McCreight提出了一种称之为B-树的多路平衡查找树，在文件系统中有所应用，主要用作文件的索引。它是一种平衡...
C++实现B-Tree（B-树）
weixin_43462583的博客
08-05 302
key: key0 key1 key2 key3 key4 (存数值)child: child0 child1 child2 child3 child4 child5 (存指针)
C++数据结构：B树
最新发布
weixin_43908419的博客
12-04 1930
索引，就是通过某些关键信息，让用户可以快速找到某些事物，例如通过目录，我们就可以快速检索到一本书中特定的内容所在的页码。B/B+最普遍的用途，就是做索引。索引（index）是帮助MySQL高效获取数据的数据结构。当数据量很大的时候，为了方便数据的管理、提高检索效率，通常会将数据保存至数据库。数据库不仅仅要存储数据，还要维护特定的数据结构和一些高效的搜索算法，以帮助用户快速引用到某些数据。这种实现快速查找的数据结构，就是索引。
C++(数据结构与算法):53---平衡搜索树之B-树
董哥的黑板报
02-23 1140
一、索引顺序访问方法 当字典足够小时，可以整个驻留在内存中时，AVL树和红黑树都能够保证良好的时间性能。对于那些必须存储在磁盘上的大型字典（外部字典或文件），需要度数更高的搜索树来改善字典操作的性能。在研究这样的搜索树之前，先看一下外部字典的索引顺序访问方法（ISAM）。这种方法对顺序和随机访问都具有良好的时间性能 块的概念 在ISAM方法中，可用的磁盘空间被划分为很多块 块是在磁盘空间中...
B树插入删除操作
linyanqing21的博客
07-07 2366
插入 想想2-3树的插入。2-3树结点的最大容量是2个元素，故当插入操作造成超出容量之后，就得分裂。同样m-阶B树规定的结点的最大容量是m-1个元素，故当插入操作造成超出容量之后也得分裂，其分裂成两个结点每个结点分m/2个元素。（副作用是在其父结点中要插入一个中间元素，用于分隔这两结点。和2-3树一样，再向父结点插入一个元素也可能会造成父结点的分裂，逐级向上操作，直到不再造成分裂
c++学习笔记十四
retacn_yue的专栏
09-20 112
继承 1 类和面向对象编程 2 类的继承 继承和聚合 从基类中派生新类 头文件 Box.h示例代码如下: #ifndef BOX_H #define BOX_H class Box{ //构造器 public:Box(double lv=1.0,double wv=1.0,double hv=1.0); private...
C++之 类
walkingMa的专栏
09-03 982
封装： 给定类型的每个对象含有两组成员:一组数据值，作为数据成员；一组操作，作为函数成员。 一个对象里的数据成员一般是隐蔽的，即外界不能直接访问该数据，但对象里的函数成员可以访问数据成员，函数成员是对象与外界的接口。 继承：        继承是根据一个类型定义另一个类型的能力。假设有两个类型：BankAccount、LoanAccount。LoanAccount类型继承了BankAcco
2015级刘鹏《数据结构与算法实验》：B-树设计与Python实现
在云南大学数学与统计学院的2015级20151910042学生刘鹏的上机实践报告中，他参与了名为"数据结构与算法实验"的课程，具体实验项目是B-树实验（选做）。实验的主要目标是通过实践加深对存储管理与B-树这类关键数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值