B树(C语言描述)

最新推荐文章于 2024-07-13 11:45:43 发布
最新推荐文章于 2024-07-13 11:45:43 发布
阅读量640 收藏 1
点赞数 1
文章标签： b树 数据结构 c语言 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43369883/article/details/130989256
版权
文章介绍了B树的基本概念，包括其作为多路平衡查找树的特性，以及在磁盘寻址中的应用。详细阐述了B树的插入和删除操作，包括插入时的节点分裂处理，以及删除时可能涉及的节点调整。同时，给出了C语言实现B树节点结构体定义、初始化、查找合适节点、插入数据等关键函数的示例代码。
摘要由CSDN通过智能技术生成

一.概念

B树是一种多路平衡查找树，不同于二叉平衡树，他不只是有两个分支，而是有多个分支，一棵m阶B树(balanced tree of order m)是一棵平衡的m路搜索树，B树用于磁盘寻址，它是一种高效的查找算法。

二.性质

  • 根节点至少有2个子女
  • 每个非根节点所包含的关键字个数x满足以下关系：⌈m/2⌉−1⩽x⩽m−1\lceil m/2 \rceil - 1 \leqslant x \leqslant m - 1⌈m/2⌉−1⩽x⩽m−1
  • 所有叶子结点都在同一层
  • 除根结点以外的所有结点（不包括叶子结点）的度数正好是关键字总数加1，故内部子树个数 k 满足：⌈m/2⌉⩽k⩽m\lceil m/2 \rceil \leqslant k \leqslant m⌈m/2⌉⩽k⩽m

三.B树的各种操作 

1.B树的插入 

B树的插入操作只能在叶子结点上进行操作，而且叶子结点上关键字的个数要严格满足B树的性质：⌈m/2⌉−1⩽x⩽m−1\lceil m/2 \rceil - 1 \leqslant x \leqslant m - 1⌈m/2⌉−1⩽x⩽m−1

插入步骤如下：

  1. 寻找合适的叶子结点
  2. 在叶子结点上找到合适的插入位置
  3. 插入后判断关键字个数是否超过m-1，如果超过则结点需要分裂，分裂从中间劈开，并将中间的元素插入到当前结点的父亲结点中，判断父亲结点关键字个数是否超过m-1，如果超过继续分裂，重复第3步

 2.B树的删除

 

 

 

 四.代码各函数分解实例

1.结点的结构体定义 

typedef struct Node
{
	int level;//阶数 
	int keyNum;//关键数的数量
	int childNum;//孩子的数量
	int *keys;//关键字指针数组
	struct Node **children;//孩子数组
	struct Node *parent;//父亲指针 
}Node;

 2.初始化结点

Node *initNode(int level)
{/*参数:树的阶数*/
	Node *node = (Node*)malloc(sizeof(Node));//申请结点的空间 
	node->level = level;//将阶数写入 
	node->keyNum = 0;//关键字个数初始为0 
	node->childNum = 0;//孩子个数初始为0 
	/*level+1是为了后面的插入和删除,方便索引*/
	node->keys = (int*)malloc(sizeof(int)*(level+1));//结点内关键字指针申请空间 
	node->children = (Node**)malloc(sizeof(Node*)*level);//孩子指针申请空间 
	node->parent = NULL;//父结点初始为空 
	int i;
	for(i=0;i<level;i++)
	{/*关键字和孩子指针循环遍历都初始化*/
		node->keys[i] = 0;
		node->children[i] = NULL;
	}
	node->keys[i] = 0;//关键字指针多一个,因此额外初始化 
	return node;//指针函数,返回值为指针 
}

 3.找合适的索引方便插入和删除

int findSuiteIndex(Node *node,int data)
{/*参数一:结点指针
参数二:要查找的元素*/
	int index;//下标 
	for(index=1;index<=node->keyNum;index++)
	{/*从1开始,向后遍历寻找第一个比该元素大的key,返回该key的下标,就是要插入的位置*/
		if(data<node->keys[index])
			break;
	}
	return index;
}

 4.找合适的叶子结点

Node *findSuiteLeafNode(Node *T,int data)
{/*参数一:根节点指针
参数二:要插入的元素*/
	int index;//元素下标 
	if(T->childNum==0)//结点无孩子说明找到了叶子结点 
		return T;
	else
	{
		index = findSuiteIndex(T,data);//寻找合适的插入位置 
		return findSuiteLeafNode(T->children[index-1],data);//递归,往左子树走 
	}
}

 5.往结点中插入数据

void addData(Node *node,int data,Node **T)
{/*参数一:结点指针
参数二:要插入的数据
参数三:父结点,由于要改变,因此使用二级指针*/
	int index = findSuiteIndex(node,data);
	int i,mid;
	for(i=node->keyNum;i>=index;i--)
		node->keys[i+1] = node->keys[i];
	node->keys[index] = data;
	node->keyNum += 1;
	//判断是否进行分裂 
	if(node->keyNum==node->level)
	{//找到分裂的位置 
		mid = node->level/2+node->level%2;
		//分裂 
		Node *lchild = initNode(node->level);//初始化左孩子结点 
		Node *rchild = initNode(node->level);//初始化右孩子结点
		//将mid左边的值赋值给左孩子 
		for(i=1;i<mid;i++)
			addData(lchild,node->keys[i],T);
		//将mid右边的值赋值给右孩子 
		for(i=mid+1;i<=node->keyNum;i++)
			addData(rchild,node->keys[i],T);
		//将原先结点mid左边的孩子赋值给分裂出来的左孩子 
		for(i=0;i<mid;i++)
		{
			lchild->children[i] = node->children[i];
			if(node->children[i]!=NULL)
			{
				node->children[i]->parent = lchild;
				lchild->childNum++;
			}
		}
		//将原先结点mid右边的孩子赋值给分裂出来的右孩子 
		int index = 0;
		for(i=mid;i<node->childNum;i++)
		{
			rchild->children[index++] = node->children[i];
			if(node->children[i]!=NULL)
			{
				node->children[i]->parent = rchild;
				rchild->childNum++;
			}
		}
		//判断当前结点是不是根结点 
		if(node->parent==NULL)
		{//是根结点 
			Node *newParent = initNode(node->level);
			addData(newParent,node->keys[mid],T);
			newParent->children[0] = lchild;
			newParent->children[1] = rchild;
			newParent->childNum = 2;
			lchild->parent = newParent;
			rchild->parent = newParent;
			*T = newParent;
		}
		else
		{//不是根结点 
			index = findSuiteIndex(node->parent,node->keys[mid]);
			lchild->parent = node->parent;
			rchild->parent = node->parent;
			node->parent->children[index-1] = lchild;
			if(node->parent->children[index]!=NULL)
			{
				for(i=node->parent->childNum-1;i>=index;i--)
					node->parent->children[i+1] = node->parent->children[i];
			}
			node->parent->children[index] = rchild;
			node->parent->childNum++;
			addData(node->parent,node->keys[mid],T);
		}
	}
}

 6.插入结点

void insert(Node** T, int data) 
{/*参数一:父结点
参数二:要插入的数据*/
    Node* node = findSuiteLeafNode(*T, data);//先找到适合插入的叶子结点 
    addData(node, data, T);//执行插入数据函数 
}

 7.遍历输出

void printTree(Node* T) 
{/*参数:根结点*/
	int i;
    if (T != NULL) {
        for (i  = 1; i <= T -> keyNum; i++)//按序遍历结点内的关键字 
            printf("%d ", T -> keys[i]);
        printf("\n");

        for (i = 0; i < T -> childNum; i++)//按序遍历孩子结点 
            printTree(T -> children[i]);//递归遍历 
    }
}

 8.主函数

int main()
{
	int i;
	Node *T = initNode(5);//初始化 
	for(i=1;i<=10;i++)
		insert(&T,i);//插入 
	printTree(T);//遍历打印 
	return 0;
}

 完整代码:

#include <stdio.h>
#include <stdlib.h>
typedef struct Node
{
	int level;//阶数 
	int keyNum;//关键数的数量
	int childNum;//孩子的数量
	int *keys;//关键字指针数组
	struct Node **children;//孩子数组
	struct Node *parent;//父亲指针 
}Node;
/*初始化结点*/
Node *initNode(int level)
{/*参数:树的阶数*/
	Node *node = (Node*)malloc(sizeof(Node));//申请结点的空间 
	node->level = level;//将阶数写入 
	node->keyNum = 0;//关键字个数初始为0 
	node->childNum = 0;//孩子个数初始为0 
	/*level+1是为了后面的插入和删除,方便索引*/
	node->keys = (int*)malloc(sizeof(int)*(level+1));//结点内关键字指针申请空间 
	node->children = (Node**)malloc(sizeof(Node*)*level);//孩子指针申请空间 
	node->parent = NULL;//父结点初始为空 
	int i;
	for(i=0;i<level;i++)
	{/*关键字和孩子指针循环遍历都初始化*/
		node->keys[i] = 0;
		node->children[i] = NULL;
	}
	node->keys[i] = 0;//关键字指针多一个,因此额外初始化 
	return node;//指针函数,返回值为指针 
}
/*找合适的索引方便插入和删除*/
int findSuiteIndex(Node *node,int data)
{/*参数一:结点指针
参数二:要查找的元素*/
	int index;//下标 
	for(index=1;index<=node->keyNum;index++)
	{/*从1开始,向后遍历寻找第一个比该元素大的key,返回该key的下标,就是要插入的位置*/
		if(data<node->keys[index])
			break;
	}
	return index;
}
/*找合适的叶子结点*/
Node *findSuiteLeafNode(Node *T,int data)
{/*参数一:根节点指针
参数二:要插入的元素*/
	int index;//元素下标 
	if(T->childNum==0)//结点无孩子说明找到了叶子结点 
		return T;
	else
	{
		index = findSuiteIndex(T,data);//寻找合适的插入位置 
		return findSuiteLeafNode(T->children[index-1],data);//递归,往左子树走 
	}
}
/*往结点中插入数据*/
void addData(Node *node,int data,Node **T)
{/*参数一:结点指针
参数二:要插入的数据
参数三:父结点,由于要改变,因此使用二级指针*/
	int index = findSuiteIndex(node,data);
	int i,mid;
	for(i=node->keyNum;i>=index;i--)
		node->keys[i+1] = node->keys[i];
	node->keys[index] = data;
	node->keyNum += 1;
	//判断是否进行分裂 
	if(node->keyNum==node->level)
	{//找到分裂的位置 
		mid = node->level/2+node->level%2;
		//分裂 
		Node *lchild = initNode(node->level);//初始化左孩子结点 
		Node *rchild = initNode(node->level);//初始化右孩子结点
		//将mid左边的值赋值给左孩子 
		for(i=1;i<mid;i++)
			addData(lchild,node->keys[i],T);
		//将mid右边的值赋值给右孩子 
		for(i=mid+1;i<=node->keyNum;i++)
			addData(rchild,node->keys[i],T);
		//将原先结点mid左边的孩子赋值给分裂出来的左孩子 
		for(i=0;i<mid;i++)
		{
			lchild->children[i] = node->children[i];
			if(node->children[i]!=NULL)
			{
				node->children[i]->parent = lchild;
				lchild->childNum++;
			}
		}
		//将原先结点mid右边的孩子赋值给分裂出来的右孩子 
		int index = 0;
		for(i=mid;i<node->childNum;i++)
		{
			rchild->children[index++] = node->children[i];
			if(node->children[i]!=NULL)
			{
				node->children[i]->parent = rchild;
				rchild->childNum++;
			}
		}
		//判断当前结点是不是根结点 
		if(node->parent==NULL)
		{//是根结点 
			Node *newParent = initNode(node->level);
			addData(newParent,node->keys[mid],T);
			newParent->children[0] = lchild;
			newParent->children[1] = rchild;
			newParent->childNum = 2;
			lchild->parent = newParent;
			rchild->parent = newParent;
			*T = newParent;
		}
		else
		{//不是根结点 
			index = findSuiteIndex(node->parent,node->keys[mid]);
			lchild->parent = node->parent;
			rchild->parent = node->parent;
			node->parent->children[index-1] = lchild;
			if(node->parent->children[index]!=NULL)
			{
				for(i=node->parent->childNum-1;i>=index;i--)
					node->parent->children[i+1] = node->parent->children[i];
			}
			node->parent->children[index] = rchild;
			node->parent->childNum++;
			addData(node->parent,node->keys[mid],T);
		}
	}
}
/*插入结点*/
void insert(Node** T, int data) 
{/*参数一:父结点
参数二:要插入的数据*/
    Node* node = findSuiteLeafNode(*T, data);//先找到适合插入的叶子结点 
    addData(node, data, T);//执行插入数据函数 
}
/*遍历输出*/
void printTree(Node* T) 
{/*参数:根结点*/
	int i;
    if (T != NULL) {
        for (i  = 1; i <= T -> keyNum; i++)//按序遍历结点内的关键字 
            printf("%d ", T -> keys[i]);
        printf("\n");

        for (i = 0; i < T -> childNum; i++)//按序遍历孩子结点 
            printTree(T -> children[i]);//递归遍历 
    }
} 
int main()
{
	int i;
	Node *T = initNode(5);//初始化 
	for(i=1;i<=10;i++)
		insert(&T,i);//插入 
	printTree(T);//遍历打印 
	return 0;
}

 运行结果:

 

 

深雨燕纷飞
关注
数据结构_B树(C语言)
小黯
08-16 936
B树：属于多叉树，存在多个孩子结点，并遵循左小右大的规则，常用于数据库索引
B树的C语言实现
wyx911111的博客
12-24 1814
前言 今天我们再来学习另外一种高级数据结构B树，我们知道树的查询时间复杂度和其树的高度有直接关系，当我们向红黑树里面插入大量的数据时，有两个问题： （1）首先，内存是有限的不可能无止境的一直插入数据，而基于BST的平衡树如AVL树和红黑树，本质上都是基于内存的数据结构。 （2）如果将AVL树，红黑树或者跳跃表直接存储到磁盘上，然后用来检索可以吗？ 答案是可以的，但问题是基于磁盘寻道查询比基于内存慢太多了，举个例子，假设现在有100万数据分布在红黑树里面，按照红黑树的平均查找性能O（logN）来..
B树 C语言实现
12-13
B树，C语言实现，添加到vc6.0中，可以执行的程序。
C语言实现数据结构B树
最新发布
点灯师的博客
07-13 377
这里我们不会完整地实现一个B树，但会展示一些关键部分，如节点结构定义、插入和分裂的简化逻辑。4// 假设每个节点的最大关键字数量为4// 存储关键字// 当前节点中关键字的数量// 子节点指针数组，比关键字数多一个// 父节点指针int isLeaf;// 标记是否为叶子节点// 初始化节点i++) {
用C语言实现的完整B树
11-28
用C语言实现的完整B树,提供了大量的接口
B树的代码实现（C语言版本）
02-21
btree.c
B树算法与实现(C语言描述).doc
05-05
B树算法与实现（C语言描述） B树是一种自平衡的搜索树，广泛应用于数据库的索引中。它的优点是能够保持较高的搜索效率，即使在大量数据的情况下。B树的实现通常使用C语言，以下是B树算法的详细描述： B树的定义 B...
详细图解高阶搜索树B树及C语言实现
ZER00000001的博客
07-26 2073
前言 对于大量的数据而言，链表的线性访问时间太慢，不宜使用。本章节将会介绍一种简单的数据结构：树（tree），其大部分操作的运行时间平均为O（logN）。在数据结构中树是非常有用的抽象概念，在本篇中我们将讨论一棵高阶搜索树——b树。前排提示：高阶搜索树的代码难度高出一个量级，建议先把逻辑理顺后再去看代码哦。...
B+树的c语言代码实现
05-29
### B+树C语言代码实现解析 #### 一、引言 本文将深入解析一份C语言实现的B+树代码，这份代码不仅演示了如何在操作系统文件系统之上构建B+树，而且还展示了如何通过文件操作来模拟B+树的建立过程。通过分析这段代码...
C语言数据结构基于B树为索引的图书管理系统源码+课程设计报告
02-06
《C语言数据结构：B树在图书管理系统中的应用与实现》 C语言是计算机科学的基础，也是编程领域中不可或缺的一部分。在数据结构的学习中，B树作为一种高效的数据组织方式，常用于数据库和文件系统的索引。本篇我们将...
Ｂ树的Ｃ语言实现，代码比较条理
09-21
Ｂ树的Ｃ语言实现，可以运行的，代码比较条理
图书管理系统C语言B树实现
01-02
B树为基本数据结构实现图书的借阅、归还、查询及搜索功能
c语言b树的实现
weixin_33711641的博客
12-14 192
关于b树的实现，有一篇博文讲的很清楚 http://blog.csdn.net/v_JULY_v/article/details/6530142 我自己也实现了一个， 头文件btree.h 1 #ifndef _BTREE_H_ 2 #define _BTREE_H_ 3 4 #define T 100 5 #define BTREE_OK 0 6 #defin...
b树c语言,B树——思路、及C语言代码的实现
weixin_34502439的博客
05-19 307
合并:在此先声明，因为一开始只考虑B树的阶为4的情况，后来改为使用宏定义阶M的数值，所以这段代码存在BUG，只支持阶为3或4的B树= =。思路还是挺清晰的，首先先向兄弟结点借元素，如果兄弟能够借给你元素的话(即借了你之后并不会小于最少的分支)，那么直接从兄弟那里取元素，否则，和兄弟合并。合并其实是分裂反过来的情况，从父亲结点那里取出一个key值介于要合并的两个结点之间的元素，插入左部分最末尾处，同...
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-树（c语言）
Mr_tianyanxiaobai的博客
05-15 581
/* B树的提出目的是减少读入，写入磁盘的次数 个人觉得有点像是二叉树的升级并且运用到了底层的一个实例 一个2结点要么没有孩子，要有就有两个不能只有一个 */ #include #include #define m 3//代表节点数，也就是介数 ，m叉树 #define OK 1 #define FALSE 0 typedef struct BiTr { int keynum;/
B树总结（概念、操作及C语言实现）
qq_41699954的博客
09-25 840
一、B树定义 B树，又称多路平衡查找树，B树中所有结点孩子个数的最大值为B树的阶。m阶B树定义如下：空树或者满足如下特征的m叉树：   1）树中每个结点至多有m棵子树，即至多有m-1个关键字；   2）若根结点不是终端结点，则至少有2棵子树，即至少一个关键字；   3）除根节点外所有非叶结点至少有⌈m/2⌉\lceil m/2 \rceil⌈m/2⌉棵子树，即至少有⌈m/2⌉\lceil m/2 \rceil⌈m/2⌉-1个关键字；   4）所有非叶结点结构如下：    其中，Ki（i=0，1，2，…，n
C语言实现高级数据结构之B树
微小冷的学习笔记
12-23 2428
通过C语言实现B树的添加、查询、删除等操作。
B树与B+树算法详解及C语言实现
"本文档详细介绍了B树的算法与实现，使用C语言描述，适合对数据结构和数据库索引有兴趣的读者。文档中提到了B树和B+树的区别，并提供了B树的C语言实现代码片段。" 在计算机科学中，B树（B-Tree）是一种自平衡的树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值