B树实现代码

最新推荐文章于 2023-07-04 19:26:18 发布
最新推荐文章于 2023-07-04 19:26:18 发布
阅读量523 收藏 5
点赞数 2
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43430381/article/details/109003516
版权

B树代码实现

阶数 ：3； 输入：1 2 3 4 5；
代码只验证过10以下数据。有兴趣，最好跟着下面流程看
在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>

typedef struct Value{  //相当于树节点数组下的一个值
    int data;
    struct Node *lchild,*rchild;
    struct Node *parent;
}Value;

typedef struct Node{    //这个相当于树节点，将树节点设置为数组
    int size;
    struct Value *value;
    struct Value *parent;
}Node;

Value *MallocValue(Value *p){
    p=(Value *)malloc(sizeof(Value));
    p->lchild=NULL;
    p->rchild=NULL;
    p->parent=NULL;
    return p;
}

Node *Malloc(Node *p,int n){
        p=(Node *)malloc(sizeof(Node));
        p->value=(Value *)malloc(sizeof(Value)*n);
        p->size=0;
        p->parent=NULL;
        return p;
}

void ComParent(Node *p,Value *e,int n){
    int flag=0;
    if(p->size>=n-1){
        for(int i=0;i<p->size;i++){
            if(e->data<p->value[i].data){
                flag=1;
                Node *s;
                Value *v;
                v=MallocValue(v);
                s=Malloc(s,n);
                for(int j=n-2;j>=i;j--){        //先将值插入
                    p->value[j+1]=p->value[j];
                    }
                e->parent=p;
                p->value[i]=*e;
                p->size++;
                *v=p->value[(n-1)/2];
                p->size--;
                for(int j=0;j<(n-1)/2;j++){
                    s->value[j]=p->value[j];
                    s->value[j].parent=s;
                    s->size++;
                    p->size--;
                }
                s->parent=v;
                v->lchild=s;
                v->rchild=NULL;
                for(int j=(n-1)/2+1;j<=n-1;j++){
                    p->value[j-(n-1)/2-1]=p->value[j];
                }
                if(p->parent!=NULL){
                    ComParent(p->parent->parent,v,n);
                }else{
                    Node *pa;
                    pa=Malloc(pa,n);
                    p->parent=v;
                    v->rchild=p;
                    v->parent=pa;
                    pa->value[0]=*v;
                    pa->size++;
                }
                break;
            }
        }
        if(flag==0){
            Node *s;
            Value *v;
            v=MallocValue(v);
            s=Malloc(s,n);
            e->parent=p;
            p->value[n-1]=*e;
            p->size++;
            *v=p->value[(n-1)/2];
            p->size--;
            for(int j=0;j<(n-1)/2;j++){
                    s->value[j]=p->value[j];
                    s->value[j].parent=s;
                    s->size++;
                    p->size--;
            }
            s->parent=v;
            v->lchild=s;
            v->rchild=NULL;
            for(int j=(n-1)/2+1;j<=n-1;j++){
                p->value[j-(n-1)/2-1]=p->value[j];
            }

            if(p->parent!=NULL){
                ComParent(p->parent->parent,v,n);
            }else{
                Node *pa;
                pa=Malloc(pa,n);
                p->parent=v;
                v->rchild=p;
                v->parent=pa;
                pa->value[0]=*v;
                pa->size++;
            }
        }
    }else{
        for(int i=0;i<p->size;i++){
            if(e->data<p->value[i].data){
                flag=1;
                for(int j=p->size-1;j>=i;j--){
                    p->value[j+1]=p->value[j];
                }
                e->parent=p;
                p->value[i]=*e;
                p->size++;
                break;
            }
        }

        if(flag==0){
                e->parent=p;
                p->value[p->size]=*e;
                p->size++;
        }
    }
}

void RChildCope(Node *p,Value *e,int n){  //对于右孩子需要分离右边数据
        if(e->data>=p->value[p->size-1].data){  //插入值大于最大一个
            if(p->size>=n-1){
                if(p->value[p->size-1].rchild!=NULL){
                    RChildCope(p->value[p->size-1].rchild,e,n);
                }else{
                    //首先将中间值向父节点传，并将小于中间值的独立成一个子节点，成为中间值的左孩子
                    //大于中间值的向左移动，再将值插入
                    //中间传入父节点后再进行类似比较
                    Node *s;
                    Value *v;
                    v=MallocValue(v);
                    s=Malloc(s,n);
                    e->parent=p;
                    p->value[n-1]=*e;
                    p->size++;
                    *v=p->value[(n-1)/2];
                    p->size--;
                    for(int j=(n-1)/2+1;j<n;j++){
                            s->value[j-(n-1)/2-1]=p->value[j];
                            s->value[j].parent=s;
                            s->size++;
                            p->size--;
                    }
                    s->parent=v;
                    v->rchild=s;
                    v->lchild=p;
                    if(p->parent!=NULL){
                        ComParent(p->parent->parent,v,n);
                    }else{
                        Node *pa;
                        pa=Malloc(pa,n);
                        p->parent=v;
                        v->parent=pa;
                        pa->value[0]=*v;
                        pa->size++;
                    }

                }

            }else{
                if(p->value[p->size-1].rchild!=NULL){
                    RChildCope(p->value[p->size-1].rchild,e,n);
                }else{
                    e->parent=p;
                    p->value[p->size]=*e;
                    p->size++;
                }
            }
        }else{
            for(int i=0;i<=p->size-1;i++){
                if(e->data<p->value[i].data){
                    if(p->size>=n-1){
                        if(p->value[p->size-1].lchild!=NULL){
                            Compare(p->value[p->size-1].lchild,e,n);
                            break;
                        }else{
                            Node *s;
                            Value *v;
                            v=MallocValue(v);
                            s=Malloc(s,n);
                            for(int j=n-2;j>=i;j--){        //先将值插入
                                p->value[j+1]=p->value[j];
                                }
                            e->parent=p;
                            p->value[i]=*e;
                            p->size++;
                            *v=p->value[(n-1)/2];
                            p->size--;
                            for(int j=(n-1)/2+1;j<p->size;j++){
                                s->value[j-(n-1)/2-1]=p->value[j];
                                s->value[j-(n-1)/2-1].parent=s;
                                s->size++;
                                p->size--;
                            }
                            s->parent=v;
                            v->rchild=s;
                            v->lchild=p;
                            if(p->parent!=NULL){
                                ComParent(p->parent->parent,v,n);
                                break;
                            }else{
                                Node *pa;
                                pa=Malloc(pa,n);
                                p->parent=v;
                                v->parent=pa;
                                pa->value[0]=*v;
                                pa->size++;
                                break;
                            }



                        }

                    }else{
                        if(p->value[i].lchild!=NULL){
                            Compare(p->value[i].lchild,e,n);
                            break;
                        }else{
                            for(int j=p->size-1;j>=i;j--){
                                p->value[j+1]=p->value[j];
                            }
                            e->parent=p;
                            p->value[i]=*e;
                            p->size++;
                            break;
                        }
                    }
                }
            }

        }

}

void Compare(Node *p,Value *e,int n){
        if(e->data>=p->value[p->size-1].data){  //插入值大于最大一个,最大右子树需要分离右边
            if(p->size>=n-1){
                if(p->value[p->size-1].rchild!=NULL){
                    RChildCope(p->value[p->size-1].rchild,e,n);
                }else{
                    //首先将中间值向父节点传，并将小于中间值的独立成一个子节点，成为中间值的左孩子
                    //大于中间值的向左移动，再将值插入
                    //中间传入父节点后再进行类似比较
                    Node *s;
                    Value *v;
                    v=MallocValue(v);
                    s=Malloc(s,n);
                    e->parent=p;
                    p->value[n-1]=*e;
                    p->size++;
                    *v=p->value[(n-1)/2];
                    p->size--;
                    for(int j=0;j<(n-1)/2;j++){
                            s->value[j]=p->value[j];
                            s->value[j].parent=s;
                            s->size++;
                            p->size--;
                    }
                    s->parent=v;
                    v->lchild=s;
                    v->rchild=p;
                    for(int j=(n-1)/2+1;j<=n-1;j++){
                        p->value[j-(n-1)/2-1]=p->value[j];
                    }

                    if(p->parent!=NULL){
                        ComParent(p->parent->parent,v,n);
                    }else{
                        Node *pa;
                        pa=Malloc(pa,n);
                        p->parent=v;
                        v->parent=pa;
                        pa->value[0]=*v;
                        pa->size++;
                    }

                }

            }else{
                if(p->value[p->size-1].rchild!=NULL){
                    RChildCope(p->value[p->size-1].rchild,e,n);
                }else{
                    e->parent=p;
                    p->value[p->size]=*e;
                    p->size++;
                }
            }
        }else{
            for(int i=0;i<=p->size-1;i++){
                if(e->data<p->value[i].data){
                    if(p->size>=n-1){
                        if(p->value[p->size-1].lchild!=NULL){
                            Compare(p->value[p->size-1].lchild,e,n);
                            break;
                        }else{
                            Node *s;
                            Value *v;
                            v=MallocValue(v);
                            s=Malloc(s,n);
                            for(int j=n-2;j>=i;j--){        //先将值插入
                                p->value[j+1]=p->value[j];
                                }
                            e->parent=p;
                            p->value[i]=*e;
                            p->size++;
                            *v=p->value[(n-1)/2];
                            p->size--;
                            for(int j=0;j<(n-1)/2;j++){
                                s->value[j]=p->value[j];
                                s->value[j].parent=s;
                                s->size++;
                                p->size--;
                            }
                            s->parent=v;
                            v->lchild=s;
                            v->rchild=p;
                            for(int j=(n-1)/2+1;j<=n-1;j++){
                                p->value[j-(n-1)/2-1]=p->value[j];
                            }
                            if(p->parent!=NULL){
                                ComParent(p->parent->parent,v,n);
                                break;
                            }else{
                                Node *pa;
                                pa=Malloc(pa,n);
                                p->parent=v;
                                v->parent=pa;
                                pa->value[0]=*v;
                                pa->size++;
                                break;
                            }



                        }

                    }else{
                        if(p->value[i].lchild!=NULL){
                            Compare(p->value[i].lchild,e,n);
                            break;
                        }else{
                            for(int j=p->size-1;j>=i;j--){
                                p->value[j+1]=p->value[j];
                            }
                            e->parent=p;
                            p->value[i]=*e;
                            p->size++;
                            break;
                        }
                    }
                }
            }

        }

    }

Node *insert(Node *tree,int e,int n){
    Value *v;
    if(tree==NULL){
        tree=Malloc(tree,n);
        tree->size++;
        tree->value[0].data=e;
        tree->value[0].lchild=NULL;
        tree->value[0].rchild=NULL;
        tree->value[0].parent=tree;
        return tree;
    }
    v=MallocValue(v);
    v->data=e;
    Compare(tree,v,n);
    while(tree->parent!=NULL){
        tree=tree->parent->parent;
    }
    return tree;

}

void main(){
    int n,e;
    Node *tree=NULL;
    printf("请输入创建B树的阶数！！");
    scanf("%d",&n);
    printf("请输入数值！！");
    scanf("%d",&e);
    while(e!=999){
        tree=insert(tree,e,n);
        printf("请输入数值！！");
        scanf("%d",&e);
    }
    printf(" %d ",tree->value[0].data);
    printf("%d\n",tree->value[1].data);
 //   printf("%d-->%d-->\n",tree->value[0].rchild->value[0].data);
    printf("%d  ",tree->value[0].lchild->value[0].data);
    printf("%d  ",tree->value[0].rchild->value[0].data);
  //  printf("%d  ",tree->value[0].rchild->value[1].data);
  //  printf("%d  ",tree->value[1].lchild->value[0].data);
  //  printf("%d-->%d\n",tree->value[0].lchild->value[0].data,tree->value[0].lchild->size);
  //  printf("%d-->\n",tree->value[0].lchild->value[1].data);
   // printf("%d-->\n",tree->value[1].lchild->value[0].lchild->value[0].data);
    printf("%d  ",tree->value[1].rchild->value[0].data);
    printf("%d  ",tree->value[1].rchild->value[1].data);
    printf("%d  ",tree->value[1].rchild->value[2].data);
}
沾了点血
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构基础-B树的实现
07-31 786
B树是重要的数据结构。我们用C语言如何实现，是非常关键的。它的规则严格，所以一步一步都要严格按照规则来。
数据结构-B树的特点结构与C++实现
m0_61789994的博客
06-09 1718
B树，全称为B-树（B-tree），是一种自平衡的搜索树，由Rudolf Bayer和Edward McCreight于1972年提出。B树的设计目标是在磁盘等外部存储介质上进行高效的查找、插入和删除操作。B树的关键特点是它可以容纳多个子节点的节点，这使得B树可以充分利用外部存储介质的块读取能力，减少磁盘IO次数，提高访问效率。B树的节点通常会存储一组有序的键值对，用于进行数据的检索和排序。
一个完整的B+树代码及详细注释
jinking01的专栏
03-30 3402
因为这一段在开发自己的文件系统，需要支持时间点和时间段的快速检索，所以考虑使用B+树构建时间索引。github上有不少B+树的源码，但是都比较复杂。这里找到一个非常简单的代码实现，代码设计的非常精妙，但是没有注释。连续看了几天，结合我自己对B+树的原理的理解，给代码增加了注释。后面我会基于此修改成满足项目需求的子模块。在这里先把代码贴出来吧。如果有问题，请在评论区讨论。 /* * To conver to an append-only design, only the 'fwrite' in the
大厂必备技能：数据结构树之B树、B+树
zjjcchina的博客
05-31 672
今天呢，在本篇文章中，咱们结束树这种数据结构，讲解最后几个知识点，也就是大家学习Java过程中肯定听说过的B树以及B+树，我相信大家肯定听过这两种树，大部分是在MySQL高级篇讲解索引的底层原理的时候，大家肯定知道索引的底层是B+树，在咱们B+树key保存着每条数据的唯一索引，而data域则保存着当前数据在咱们硬盘中的内存地址。今天呢，咱们好好讲解一下B树以及B+树，最后咱们手写一下B+树，让大家更好的掌握这棵特别重要且效率非常之高的树，让咱们的技术更上一层楼，离优秀的自己更近一步。
B树插入代码C++实现
12-22
在实际编程中，文件`20201109 BTree`可能包含了具体的B树插入操作的源代码，你可以通过阅读和理解这个文件来进一步学习和实践B树的插入功能。学习B树不仅可以提升你对数据结构的理解，也有助于解决涉及大数据存储和...
完整B树算法Java实现代码
09-01
在计算机科学中，B树（B-tree）是一种自平衡的多路查找树，它的设计目的是为了优化磁盘或网络存储环境下的数据检索效率。...在Java中实现B树需要理解其数据结构特点，并适当地处理插入、查找和删除操作，确保树的平衡。
B+树代码实现
01-12
B+树代码实现
B+树的代码实现.pdf
05-03
B+树的相关技术描述以及基于B+树的代码实现设计注意事项，代码设计注意事项，开源内容
b+树实现原代码
11-27
在提供的“b+树实现原代码.doc”文档中，我们可以预期看到以下关键部分： 1. **节点结构定义**：包括非叶子节点和叶子节点的定义，通常包含键值数组、子节点指针数组以及可能的数据存储区域。 2. **插入函数**：...
B树的实现（C++）
07-16
网上很多程序没有注释，代码运行报错。所以精心重写了一下B树的实现。程序结构严谨，有详细的注释，运行没有问题，基于vs2013平台。对于刚学算法的人应该会有很大帮助。
Ｂ树的Ｃ语言实现，代码比较条理
09-21
Ｂ树的Ｃ语言实现，可以运行的，代码比较条理
B树c++代码
qq_40713201的博客
02-26 205
【代码】B树c++代码。
【C/C++】B+树（C语言实现）
Michael
04-23 1249
C原因实现B+树的基本操作，包括查找、插入和分裂。在范围查找中，首先使用search函数找到第一个大于等于左端点的关键字所在的叶子节点，然后依次访问后续的叶子节点，将符合条件的关键字加入到结果集中。需要注意的是，在插入关键字时，如果节点中关键字个数超过了阶数M，需要进行分裂操作。希望这个修改后的代码能够帮助您解决问题。
B树的实现与源代码一
aytfly的专栏
09-02 1211
B树的定义 假设B树的度为t（t>=2），则B树满足如下要求：（参考算法导论） （1）  每个非根节点至少包含t-1个关键字，t个指向子节点的指针；至多包含2t-1个关键字，2t个指向子女的指针（叶子节点的子女为空）。 （2）  节点的所有key按非降序存放，假设节点的关键字分别为K[1], K[2] … K[n], 指向子女的指针分别为P[1], P[2]…P[n+1]，其中n为节点关键字
关于B+树的介绍、用途和c++代码实现
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
05-12 3206
数据结构和算法的重要性不言而喻，一些优秀的开源项目的核心和灵魂就是数据结构、算法。在实际的编程中我们经常可以在各种框架、算法中看见B树、B+树的身影。特别是在数据库的数据库引擎中，它们更是占据着重要的地位。 下面我将通过简单的二叉树，到树的进化，多叉树(B树、B+树)的由来、作用、操作以及它们在实际中的应用依次进行详细说明。
C语言 B+树
wentzheng的博客
07-04 334
【代码】C语言 B+树。
C语言-B树（B-树）的完整实现
热门推荐
geek_jerome的博客
12-25 2万+
B树的定义 B树是一种平衡的多路查找树。 一颗m阶B树，或为空树，或为满足下列特性的m叉树。 （1）树中每个结点最多含有m棵子树; （2）若根结点不是叶子结点，则至少有两颗子树; （3）除根之外的所有非终端结点至少有[m/2]; （4）每个非终端结点中包含信息：（n,A0,K1,A1,K2,A2,…,Kn,An)。其中 ①Ki（1≤i≤n）为关键字，且关键字按升序排序。 ②指针Ai（
B树的代码实现和解析
jinzhi66的博客
04-18 1135
1.问题描述： (1)实现在B-树上的查找，并分析其时间复杂性。 (2)实现B-树的ADT，包括其上的基本操作：结点的加入和删除。 (3)要求B-树结构中的M=3或5，实现其中的一种即可。 (4)实现基本操作的演示。 2.模块划分 (1)初始化B树。 (2)查找操作。 (3)显示操作。 (4)插入操作 (5)删除操作。 (6)销毁操作。 3.代码部分 #ifndef _BTREE_H #define _BTREE_H #define MAXM 10
B树、B+树代码实现
最新发布
08-29
这是一个简单的B树代码实现，其中根据t的值对节点进行分裂和合并操作，以保证B树的平衡性。在插入数据时，将键和值插入到合适的位置，并根据需要分裂节点。这个示例只是B树的基本实现，你可以根据具体的需求进行扩展...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值