第14周 项目3

最新推荐文章于 2023-05-19 15:02:45 发布
最新推荐文章于 2023-05-19 15:02:45 发布
阅读量335 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LfelL/article/details/78735572
版权

问题及描述：

     

/* 
烟台大学计算机学院 
 
文件名称:xiangmu.cpp 
 
作者:范宝磊
 
完成日期:2017年12月3日 
 
问题描述：实现B-树的基本操作。基于序列{4, 9, 0, 1, 8, 6, 3, 5, 2, 7}完成测试。  
　　（1）创建对应的3阶B-树b，用括号法输出b树。  
　　（2）从b中分别删除关键字为8和1的节点，用括号法输出删除节点后的b树 
 
输入描述：无 
 
输出描述：B-的创建过程和删除节点的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-树的创建和删除。

LfelL
关注
T：B数的表示及其基本操作的实现（C++）
Hodge_Z的博客
12-17 352
习题内容： 1．掌握B树的存贮结构。 2．实现B树中关键字值的插入及删除操作。   B树的定义： B树也称B-树，它是一颗多路平衡查找树。我们描述一颗B树时需要指定它的阶数，阶数表示了一个结点最多有多少个孩子结点，一般用字母M表示阶数。当M取2时，就是我们常见的二叉搜索树。 一颗M阶的B树定义如下： 1）每个结点最多有M-1个关键字。 2）根结点最少可以只有1个关键字。 3）非根...
实现B-树的相关运算算法
xiezhi123456的博客
02-22 1912
B-tree即B树，B即Balance，平衡的意思。B-树是一种多路搜索树(并不一定是二叉的)。 当查找的文件较大，且存放在磁盘等直接存取设备中时，为了减少查找过程中对磁盘的读写次数，提高查找效率，基于直接存取设备的读写操作以"页"为单位的特征。 1970年，R.Bayer和E.M.McCreight提出了一种称之为B-树的多路平衡查找树，在文件系统中有所应用，主要用作文件的索引。它是一种平衡...
B+树生成以及节点插入、删除与查询
09-20
程序实现了树的随机生成,插入,删除,单值查找以及范围查找.主程序为三个类，其中界面类包含画图程序，节点类包含了节电的基本属性，B+树类以节点为基础.
数据结构实践——B-树的基本操作
weixin_33834628的博客
11-29 463
本文是针对[数据结构基础系列(8)：查找]的实践。 【项目 - B-树的基本操作】 实现B-树的基本操作。基于序列{4, 9, 0, 1, 8, 6, 3, 5, 2, 7}完成测试。 （1）创建对应的3阶B-树b，用括号法输出b树。 （2）从b中分别删除关键字为8和1的节点，用括号法输出删除节点后的b树。 [参考解答] #...
2、B-树的插入和生成
lane 备忘录
08-01 1860
B-树的生成是从空树起，逐个插入关键字而得到的。（1）插入关键字K的方法    　首先在树中查找K，若找到则直接返回(假设不处理相同关键字的插入)；否则查找操作必失败于某个叶子上，然后将K插入该叶子中。若该叶子结点原来是非满(指keynum调整操作：    　将违反性质(3)的结点以中间位置上的关键字 为划分点，将该结点(不妨设是*current)：         (m，P0，K1，P1，…，
B-树与B+树的实现及应用
至臻求学，胸怀云月
12-22 1441
元博客地址http://blog.sina.com.cn/s/blog_a46817ff0101devp.html 2) 同样，通过查找确定关键字26亦应插入 *d. 由于*d节点关键字数目超过2，此时需要将 *d分裂成两个节点，关键字26及其前、后两个指针仍保留在 *d 节点中，而关键字37 及其前、后两个指针存储到新的产生的节点 *d` 中。同时将关键字30 和指示节点
三 B树与B+树
jyh的博客
06-25 3171
1、多路查找树       性质：       1、每一个结点的孩子数可以多于两个，且每一个结点处可以存储多个元素       2、元素之间存在某种特定的排序关系1、2-3树每一个结点都有两个孩子（2结点）或三个孩子（3结点）定义：1）要么为空，要么：2）对于2节点，该节点保存一个key及对应value，以及两个指向左右节点的节点，左节点也是一个2-3节点，所有的值都比key要小，右节点也是一个2...
艺术博物馆项目：第14周第2天
02-10
在“艺术博物馆项目：第14周第2天”中，我们主要关注的是利用HTML（HyperText Markup Language）来创建一个交互式、信息丰富的在线艺术博物馆网站。HTML是网页开发的基础，它允许开发者通过标记语言定义文档结构和...
CodePathGram:CodePath 第 1 周项目
06-25
CodePath 第 1 周项目 InstagramPhoto(CodePathGram) Android 应用程序自述文件 这是作为 CodePath 的 Android 类的第一周项目构建的应用程序。 花费时间：总共花费 12-14 小时完成的用户故事： • Required: ...
第14周—项目3
ning847273990的专栏
06-04 941
[cpp] view plaincopy /* * 程序的版权和版本声明部分 * Copyright (c)2013, 烟台大学计算机学院学生 * All rightsreserved. * 作者： 杨绍宁 * 完成日期： 2013年 6 月 3日 * 版本号： v1.0 * 输入描述：无 * 问题描述：抽象类CSolid。 * 程序输出：无 */ #include
5.28安卓程序设计第十四周上课
最新发布
05-28
总的来说，“5.28安卓程序设计第十四周上课”所涵盖的内容主要是如何有效地使用Android Studio进行应用程序开发，包括项目的创建、布局设计、编码调试、测试优化等多个环节。通过深入学习和实践，开发者可以掌握这个...
第三周项目-3
羽吉公
04-21 764
Triangle.h: class Triangle { public: void setA(double x) { a = x; } void setB(double y) { b = y; } void setC(double z) { c = z; } double getA() { return a; } double getB() { retu
数据结构-B 树(B-树)
jiu_yue_ya的博客
05-19 524
B 树的阶在学习 B 树之前，我们先了解一下 B 树是为了解决什么问题的吧，在我们之前学习的数据结构中，处理的数据都是在内存中操作，因此考虑的都是内存的时间复杂度，但是如果我们要操作的数据集非常大，大到内存没办法处理了怎么办？
【B树及B树的基本操作】
m0_53171456的博客
04-27 3138
文章目录1.B树的定义和特性2.B树的性质3.B树创建的过程。 1.B树的定义和特性 B树是一种平衡的多路查找树。 一棵m阶的B树（B树中所有结点的孩子个数的最大值为m)，或为空树，或为满足下列特性的m叉树： (1)树中每个结点至多有m棵子树，至多含有m-1个关键字； (2)若根结点不是叶子结点，则至少有两棵子树； (3)非根非叶节点至少有 ⌈m/2⌉ 棵子树,至少含有 ⌈m/2⌉-1课子树； (4)所有的非终端节点中包含下列信息数据 (5)所有的叶子结点都出现在同一层次上，并且不带信息(可以看作是外
B-树和B+树的应用：数据搜索和数据库索引
热门推荐
黄规速博客:学如逆水行舟，不进则退
07-29 8万+
B-树 1 .B-树定义：有序数组+平衡多叉树 B-树是一种平衡的多路查找树，它在文件系统中很有用。 定义：一棵m 阶的B-树，或者为空树，或为满足下列特性的m 叉树： ⑴树中每个结点至多有m 棵子树； ⑵若根结点不是叶子结点，则至少有两棵子树； ⑶除根结点之外的所有非终端结点至少有[m/2] 棵子树； ⑷所有的非终端结点中包含以下信息数据： （n，A0，K1，A...
第14周
02-16
在第14周的学习中，我们将深入探讨JavaScript这一强大的编程语言。JavaScript，通常简称为JS，是Web开发中不可或缺的一部分，特别是在前端开发领域。它是一种轻量级、解释型的编程语言，支持面向对象、函数式和命令...
第三周项目-4
羽吉公
04-27 592
Stu.h #include #include using namespace std; class Stu { private: string name; //学生姓名 float chinese; //语文成绩 float math; //数学成绩 //接下去写 public: void setStudent(string, float, float); v
B树
h1311454244的博客
08-21 321
https://www.bilibili.com/video/av36069871?from=search&seid=11071313654867248772我是根据这个视频来的。 为何要用到b树，原因是当数据量特别巨大时(操作系统的文件系统，数据库的索引),普通的搜索二叉树会导致树的深度非常的深，而b树是多路查找树，一个节点中有多个关键字(就是你需要的有效信息)，这样可以减少树的深度从...
图解：什么是B-树、B+树、B*树
你好戴先生的博客
06-26 1784
文章目录 1.二叉搜索树 在说B树之前，我们需要先了解一下二叉搜索树 二叉搜索树，顾名思义，是用来搜索的有序树 它具有以下特点： 1.所有非叶子结点至多拥有两个儿子（Left和Right）； 2.所有结点存储一个关键字； 3.非叶子结点的左指针指向小于其关键字的子树，右指针指向大于其关键字的子树。 下边这个就是一棵二叉搜索树 1.1 二叉搜索树的查找 二叉搜索树的搜索，从根结点开始，如果查询的关键字与结点的关键字相等，那么就命中 否则，如果查询关键字比结点关键字小，就进入左儿子 如果比结点关键字大，就进
【数据结构】B树的创建
lz201788的博客
03-19 1万+
B树也是一种搜索树，二叉搜索树、红黑树、都是动态查找树，典型的二叉搜索结构，查找的时间复杂度和树的高度相关O(log2N)。这些二叉搜索结构有一个共同的缺陷：数据量大，树的高度太高，增大访问磁盘的次数，从而效率低下。想要加速对数据的访问速度： 1.提高I/O的时间 2.降低树的高度——平衡多叉树B树的定义 一棵M阶（M>2）的B树，是一棵平衡的M路平衡搜索树，可以是空树或者满足以下性质：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值