04B树_BTree

最新推荐文章于 2023-06-06 10:59:30 发布
最新推荐文章于 2023-06-06 10:59:30 发布
阅读量165 收藏 1
点赞数
分类专栏： 大话数据结构（语言为C语言）（作者程杰写的） 文章标签： B树 查找算法 插入算法 数据结构 C语言
原文链接：https://www.cnblogs.com/cj723/archive/2011/02/06/1949498.html
版权 
#include<stdio.h> 
#include<stdlib.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存储空间初始分配量 */

#define m 3 /*  B树的阶，暂设为3 */ 
#define N 17 /*  数据元素个数 */ 
#define MAX 5 /*  字符串最大长度+1  */

typedef int Status;	/* Status是函数的类型,其值是函数结果状态代码，如OK等 */ 

typedef struct BTNode
{
	int keynum; /*  结点中关键字个数，即结点的大小 */ 
	struct BTNode *parent; /*  指向双亲结点 */ 
	struct Node /*  结点向量类型 */ 
	{
		 int key; /*  关键字向量 */ 
		 struct BTNode *ptr; /*  子树指针向量 */ 
		 int recptr; /*  记录指针向量 */ 
	}node[m+1]; /*  key,recptr的0号单元未用 */ 
}BTNode,*BTree; /*  B树结点和B树的类型 */ 

typedef struct
{
	BTNode *pt; /*  指向找到的结点 */ 
	int i; /*  1..m，在结点中的关键字序号 */ 
	int tag; /*  1:查找成功，O:查找失败 */ 
}Result; /*  B树的查找结果类型 */ 

/*  在p->node[1..keynum].key中查找i,使得p->node[i].key≤K＜p->node[i+1].key */ 
int Search(BTree p, int K)
{ 
	int i=0,j;
	for(j=1;j<=p->keynum;j++)
	 if(p->node[j].key<=K)
	   i=j;
	return i;
}

/*  在m阶B树T上查找关键字K，返回结果(pt,i,tag)。若查找成功，则特征值 */ 
/*  tag=1，指针pt所指结点中第i个关键字等于K；否则特征值tag=0，等于K的  */
/*  关键字应插入在指针Pt所指结点中第i和第i+1个关键字之间。 */
Result SearchBTree(BTree T, int K)
{ 
	BTree p=T,q=NULL; /*  初始化，p指向待查结点，q指向p的双亲  */
	Status found=FALSE;
	int i=0;
	Result r;
	while(p&&!found)
	{
	 i=Search(p,K); /*  p->node[i].key≤K<p->node[i+1].key  */
	 if(i>0&&p->node[i].key==K) /*  找到待查关键字 */ 
	   found=TRUE;
	 else
	 {
	   q=p;
	   p=p->node[i].ptr;
	 }
	}
	r.i=i;
	if(found) /*  查找成功  */
	{
	 r.pt=p;
	 r.tag=1;
	}
	else /*   查找不成功，返回K的插入位置信息 */ 
	{
	 r.pt=q;
	 r.tag=0;
	}
	return r;
}

/* 将r->key、r和ap分别插入到q->key[i+1]、q->recptr[i+1]和q->ptr[i+1]中 */ 
void Insert(BTree *q,int i,int key,BTree ap)
{ 
	int j;
	for(j=(*q)->keynum;j>i;j--) /*  空出(*q)->node[i+1]  */
		(*q)->node[j+1]=(*q)->node[j];
	(*q)->node[i+1].key=key;
	(*q)->node[i+1].ptr=ap;
	(*q)->node[i+1].recptr=key;
	(*q)->keynum++;
}

/* 将结点q分裂成两个结点，前一半保留，后一半移入新生结点ap */ 
void split(BTree *q,BTree *ap)
{ 
	int i,s=(m+1)/2;
	*ap=(BTree)malloc(sizeof(BTNode)); /*  生成新结点ap */ 
	(*ap)->node[0].ptr=(*q)->node[s].ptr; /*  后一半移入ap */ 
	for(i=s+1;i<=m;i++)
	{
		 (*ap)->node[i-s]=(*q)->node[i];
		 if((*ap)->node[i-s].ptr)
			(*ap)->node[i-s].ptr->parent=*ap;
	}
	(*ap)->keynum=m-s;
	(*ap)->parent=(*q)->parent;
	(*q)->keynum=s-1; /*  q的前一半保留，修改keynum */ 
}

/* 生成含信息(T,r,ap)的新的根结点&T，原T和ap为子树指针 */ 
void NewRoot(BTree *T,int key,BTree ap)
{ 
	BTree p;
	p=(BTree)malloc(sizeof(BTNode));
	p->node[0].ptr=*T;
	*T=p;
	if((*T)->node[0].ptr)
		(*T)->node[0].ptr->parent=*T;
	(*T)->parent=NULL;
	(*T)->keynum=1;
	(*T)->node[1].key=key;
	(*T)->node[1].recptr=key;
	(*T)->node[1].ptr=ap;
	if((*T)->node[1].ptr)
		(*T)->node[1].ptr->parent=*T;
}

/*  在m阶B树T上结点*q的key[i]与key[i+1]之间插入关键字K的指针r。若引起 */ 
/*  结点过大,则沿双亲链进行必要的结点分裂调整,使T仍是m阶B树。 */
void InsertBTree(BTree *T,int key,BTree q,int i)
{ 
	BTree ap=NULL;
	Status finished=FALSE;
	int s;
	int rx;
	rx=key;
	while(q&&!finished)
	{
		Insert(&q,i,rx,ap); /*  将r->key、r和ap分别插入到q->key[i+1]、q->recptr[i+1]和q->ptr[i+1]中  */
		if(q->keynum<m)
			finished=TRUE; /*  插入完成 */ 
		else
		{ /*  分裂结点*q */ 
			s=(m+1)/2;
			rx=q->node[s].recptr;
			split(&q,&ap); /*  将q->key[s+1..m],q->ptr[s..m]和q->recptr[s+1..m]移入新结点*ap  */
			q=q->parent;
			if(q)
				i=Search(q,key); /*  在双亲结点*q中查找rx->key的插入位置  */
		}
	}
	if(!finished) /*  T是空树(参数q初值为NULL)或根结点已分裂为结点*q和*ap */ 
		NewRoot(T,rx,ap); /*  生成含信息(T,rx,ap)的新的根结点*T，原T和ap为子树指针 */ 
}


void print(BTNode c,int i) /*  TraverseDSTable()调用的函数  */
{
	printf("(%d)",c.node[i].key);
}

int main()
{
	int r[N]={22,16,41,58,8,11,12,16,17,22,23,31,41,52,58,59,61};
	BTree T=NULL;
	Result s;
	int i;
	for(i=0;i<N;i++)
	{
		s=SearchBTree(T,r[i]);
		if(!s.tag)
			InsertBTree(&T,r[i],s.pt,s.i);
	}
	printf("\n请输入待查找记录的关键字: ");
	scanf("%d",&i);
	s=SearchBTree(T,i);
	if(s.tag)
		print(*(s.pt),s.i);
	else
		printf("没找到");
	printf("\n");

	return 0;
}

在VS2019下，需将源文件的scanf改为scanf_s：

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存储空间初始分配量 */

#define m 3 /*  B树的阶，暂设为3 */ 
#define N 17 /*  数据元素个数 */ 
#define MAX 5 /*  字符串最大长度+1  */

typedef int Status;	/* Status是函数的类型,其值是函数结果状态代码，如OK等 */

typedef struct BTNode
{
	int keynum; /*  结点中关键字个数，即结点的大小 */
	struct BTNode* parent; /*  指向双亲结点 */
	struct Node /*  结点向量类型 */
	{
		int key; /*  关键字向量 */
		struct BTNode* ptr; /*  子树指针向量 */
		int recptr; /*  记录指针向量 */
	}node[m + 1]; /*  key,recptr的0号单元未用 */
}BTNode, * BTree; /*  B树结点和B树的类型 */

typedef struct
{
	BTNode* pt; /*  指向找到的结点 */
	int i; /*  1..m，在结点中的关键字序号 */
	int tag; /*  1:查找成功，O:查找失败 */
}Result; /*  B树的查找结果类型 */

/*  在p->node[1..keynum].key中查找i,使得p->node[i].key≤K＜p->node[i+1].key */
int Search(BTree p, int K)
{
	int i = 0, j;
	for (j = 1; j <= p->keynum; j++)
		if (p->node[j].key <= K)
			i = j;
	return i;
}

/*  在m阶B树T上查找关键字K，返回结果(pt,i,tag)。若查找成功，则特征值 */
/*  tag=1，指针pt所指结点中第i个关键字等于K；否则特征值tag=0，等于K的  */
/*  关键字应插入在指针Pt所指结点中第i和第i+1个关键字之间。 */
Result SearchBTree(BTree T, int K)
{
	BTree p = T, q = NULL; /*  初始化，p指向待查结点，q指向p的双亲  */
	Status found = FALSE;
	int i = 0;
	Result r;
	while (p && !found)
	{
		i = Search(p, K); /*  p->node[i].key≤K<p->node[i+1].key  */
		if (i > 0 && p->node[i].key == K) /*  找到待查关键字 */
			found = TRUE;
		else
		{
			q = p;
			p = p->node[i].ptr;
		}
	}
	r.i = i;
	if (found) /*  查找成功  */
	{
		r.pt = p;
		r.tag = 1;
	}
	else /*   查找不成功，返回K的插入位置信息 */
	{
		r.pt = q;
		r.tag = 0;
	}
	return r;
}

/* 将r->key、r和ap分别插入到q->key[i+1]、q->recptr[i+1]和q->ptr[i+1]中 */
void Insert(BTree* q, int i, int key, BTree ap)
{
	int j;
	for (j = (*q)->keynum; j > i; j--) /*  空出(*q)->node[i+1]  */
		(*q)->node[j + 1] = (*q)->node[j];
	(*q)->node[i + 1].key = key;
	(*q)->node[i + 1].ptr = ap;
	(*q)->node[i + 1].recptr = key;
	(*q)->keynum++;
}

/* 将结点q分裂成两个结点，前一半保留，后一半移入新生结点ap */
void split(BTree* q, BTree* ap)
{
	int i, s = (m + 1) / 2;
	*ap = (BTree)malloc(sizeof(BTNode)); /*  生成新结点ap */
	(*ap)->node[0].ptr = (*q)->node[s].ptr; /*  后一半移入ap */
	for (i = s + 1; i <= m; i++)
	{
		(*ap)->node[i - s] = (*q)->node[i];
		if ((*ap)->node[i - s].ptr)
			(*ap)->node[i - s].ptr->parent = *ap;
	}
	(*ap)->keynum = m - s;
	(*ap)->parent = (*q)->parent;
	(*q)->keynum = s - 1; /*  q的前一半保留，修改keynum */
}

/* 生成含信息(T,r,ap)的新的根结点&T，原T和ap为子树指针 */
void NewRoot(BTree* T, int key, BTree ap)
{
	BTree p;
	p = (BTree)malloc(sizeof(BTNode));
	p->node[0].ptr = *T;
	*T = p;
	if ((*T)->node[0].ptr)
		(*T)->node[0].ptr->parent = *T;
	(*T)->parent = NULL;
	(*T)->keynum = 1;
	(*T)->node[1].key = key;
	(*T)->node[1].recptr = key;
	(*T)->node[1].ptr = ap;
	if ((*T)->node[1].ptr)
		(*T)->node[1].ptr->parent = *T;
}

/*  在m阶B树T上结点*q的key[i]与key[i+1]之间插入关键字K的指针r。若引起 */
/*  结点过大,则沿双亲链进行必要的结点分裂调整,使T仍是m阶B树。 */
void InsertBTree(BTree* T, int key, BTree q, int i)
{
	BTree ap = NULL;
	Status finished = FALSE;
	int s;
	int rx;
	rx = key;
	while (q && !finished)
	{
		Insert(&q, i, rx, ap); /*  将r->key、r和ap分别插入到q->key[i+1]、q->recptr[i+1]和q->ptr[i+1]中  */
		if (q->keynum < m)
			finished = TRUE; /*  插入完成 */
		else
		{ /*  分裂结点*q */
			s = (m + 1) / 2;
			rx = q->node[s].recptr;
			split(&q, &ap); /*  将q->key[s+1..m],q->ptr[s..m]和q->recptr[s+1..m]移入新结点*ap  */
			q = q->parent;
			if (q)
				i = Search(q, key); /*  在双亲结点*q中查找rx->key的插入位置  */
		}
	}
	if (!finished) /*  T是空树(参数q初值为NULL)或根结点已分裂为结点*q和*ap */
		NewRoot(T, rx, ap); /*  生成含信息(T,rx,ap)的新的根结点*T，原T和ap为子树指针 */
}


void print(BTNode c, int i) /*  TraverseDSTable()调用的函数  */
{
	printf("(%d)", c.node[i].key);
}

int main()
{
	int r[N] = { 22,16,41,58,8,11,12,16,17,22,23,31,41,52,58,59,61 };
	BTree T = NULL;
	Result s;
	int i;
	for (i = 0; i < N; i++)
	{
		s = SearchBTree(T, r[i]);
		if (!s.tag)
			InsertBTree(&T, r[i], s.pt, s.i);
	}
	printf("\n请输入待查找记录的关键字: ");
	scanf_s("%d", &i);
	s = SearchBTree(T, i);
	if (s.tag)
		print(*(s.pt), s.i);
	else
		printf("没找到");
	printf("\n");

	return 0;
}
AKK188888881
关注
专栏目录
数据结构与算法之多路查找树
weixin_47225948的博客
09-19 235
数据结构与算法之多路查找树
多路查找
Blackoutdragon的博客
02-08 464
多路查找 二叉树的问题分析 二叉树需要加载到内存中去，当结点较少时，检索效率较高，但是当二叉树的结点过多时会出现如下问题 在构建二叉树的过程中，需要多次进行i/o操作（海量数据存储在数据库或者是文件中），构建二叉树时的速度严重下降 在检索二叉树时，二叉树高度过高，会带来检索上的困难 多叉树 在多叉树中，每个节点都有数据项，最多两个子节点。如果允许每个接待你可以有更多的数据项和更多的子节点...
12. 数据结构之多路查找树
weixin_45267102的博客
09-05 380
文章目录1. 二叉树与B树1.1 多叉树1.2 B 树的基本介绍1.3 2-3树是最简单的B树结构插入规则234树2. `B 树`、`B+`树和 `B*`树2.1 B 树2.2 B+树对上图的说明2.3 B*树☆ 1. 二叉树与B树 二叉树的操作效率较高，但是也存在问题, 请看下面的二叉树 二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如 1 亿)， 就存在如下问题 问题 1：在构建二叉树时，需要多次进行 i/o 操作(海量数据存在数据库或文件中)，节点海
什么面试官问的B树、B+树、B*树，你还不懂？
JeremyIverson的博客
03-24 570
多路查找树 1.1 二叉树与B 树 1.1.1 二叉树的问题分析 二叉树的操作效率较高，但是也存在问题, 请看下面的二叉树 二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如 1 亿)， 就存在如下问题: 问题 1：在构建二叉树时，需要多次进行 i/o 操作(海量数据存在数据库或文件中)，节点海量，构建二叉树时， 速度有影响 问题 2：节点海量，也会造成二...
查找——多路查找树（B树）
Revendell的博客
02-24 352
多路查找树(multi-way search tree)，其每一个节点的孩子数可以多于两个，且每一个节点处可以存储多个元素，所有元素之间存在某种特定的排序关系。主要有四种特殊形式：2-3树、2-3-4树、B树、B+树。 1、2-3树 ...
btree_Vc.zip_ btree_Vc_B树_btree_btree_Vc
09-21
6. **源代码分析**："BTree2.C"是实现B树功能的源代码文件，可能包含了B树节点的定义、插入和删除的实现逻辑。"www.pudn.com.txt"可能是项目的相关文档或者说明文件，可能包含对代码的解释和使用指南。 通过这个...
用线性表实现的Btree.rar_B 树索引_btree_建立索引
09-22
在数据库和文件系统中，B树（B-Tree）是一种重要的数据结构，它被广泛用于构建索引，以便高效地存储和检索大量数据。本文将深入解析如何利用线性表来实现一个m阶B树，并探讨如何进行数据的插入、删除以及范围查询。 ...
BTREE 树形文件处理系统.zip_R tree_b tree_btree
09-22
BTREE树形文件处理系统是一种基于B树（B-Tree）数据结构的高效存储和检索系统，常用于数据库和文件系统中。B树是多路平衡查找树，它能够保持数据有序，允许快速访问和更新大量数据。R树和B树是两种不同的空间索引...
btree_vb.zip_b tree_btree_tree_visual basic
09-22
总结起来，"btree_vb.zip_b tree_btree_tree_visual basic" 是一个使用Visual Basic语言实现的B树算法，通过理解和学习这个实现，你可以了解到如何在实际编程中构建和操作B树，这对于数据库和文件系统开发尤其有用。...
btree-vv.rar_btree_b树系统_图书馆管理系统_数据结构 管理系统_用数据结构设计图书管理
09-19
在"btree.cpp"文件中，我们可以预期找到B树的C++实现代码。这个文件可能会包括B树节点的定义，如包含键值和子节点指针的结构，以及B树的基本操作函数，如插入、删除和查找。这些函数会遵循B树的性质，确保每次操作后...
多路查找树
qq_19520877的博客
10-01 711
多路查找树(muitl-way search tree)，其每一个节点的孩子数可以多于两个，且每一个节点处可以存。B树（BalanceTree）是对二叉查找树的改进。它的设计思想是，将相关数据尽量集中在一起，以便一。非叶子结点的子树指针P[i]，指向关键字值属于[K[i], K[i+1])的子树。非叶子结点的子树指针与关键字个数相同。次读取多个数据，减少硬盘操作次数。为所有叶子结点增加一个链指针。所有关键字都在叶子结点出现。MySQL索引B+Tree。
查找-之多路查找树
heda3的博客
02-04 341
二叉排序树或平衡二叉树（AVL树、红黑树） 查找-之二叉排序树（查找、插入、删除） 查找-之平衡二叉树AVL和红黑树 结点只有两个孩子，且结点只能存储一个元素 问题： 一个结点只存储1个元素，在元素很多时，使得树的深度或高度很大 出现的问题是：内存存取外存的次数非常多-使得时间效率降低 解决方法： 2-3树 结构： 1970年 约翰·霍普克洛夫发明的多路查找...
(十二):多路查找树
qq_41984117的博客
05-08 103
1.二叉树与B树 1.1二叉树问题 二叉树操作效率较高，但是也存在问题。 二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如1亿)， 就存在如下问题: 问题1：在构建二叉树时，需要多次进行i/o操作(海量数据存在数据库或文件中)，节点海量，构建二叉树时，速度有影响 问题2：节点海量，也会造成二叉树的高度很大，会降低操作速度. 1.2多叉树 在二叉树中，每个节点有数据项，最多有两个子节点。如果允许每个节点可以有更多的数据项和更多的子节点，就是多叉树（multiway
学习笔记：数据结构与算法（二十）：多路查找树
lelelewei的博客
04-19 155
学习笔记：数据结构与算法（二十）：多路查找树定义2-3树2-3树的插入原理2-3树的删除原理2-3-4树B树 定义 多路查找树的特点是其每一个结点的孩子数可以多于两个，且每个结点处可以存储多个元素。所有元素之间存在某种特定的关系。 2-3树 多路查找树中每一个结点都具有两个孩子或者三个孩子称为2-3树。 2-3树的插入原理 插入1，正常。 插入5，需要拆分6.7 插入11，需要拆分9.10 … 如果所有的树都是三个节点，那么就需要再深一层 现在插入2，需要增加深度 2-3树的删除原理 情况1：如果删除
14.数据结构之多路查找树与堆
最新发布
wlyang666的博客
06-06 369
之前介绍的都是二叉查找树，二叉树一个节点最多有两个子节点，那么多于两个节点是什么情况呢，这就是我们本节要介绍的多路查找树。多路查找树，也是我们数据库mysql底层索引维护方式。下面，我们来详细介绍。
多路查找树开篇
dazhong159的专栏
09-11 4570
1、引言         以前我们所讨论的数据结构，处理数据都是在内存中。假如我们所要操作的数据集非常大，大到内存无法处理了怎么办？如数据库上千万记录的数据表、硬盘中上万个文件等。在这种情况下，对数据的处理需要不断的从硬盘等存储设备中调入或者调出内存页面。而过多的进行IO读写，显然会降低系统的效率。为了降低对外存的访问次数，我们就需要新的数据结构来处理这样的问题。 2、2-3树
Linux v2.13.6中确定扩展状态的xfs_bmap_btree分析
文件xfs_bmap_btree.c包含了核心的数据结构和函数，这些函数用于操作和维护B+树结构中的extent状态。而头文件xfs_bmap_btree.h则可能包含与这些数据结构和函数相关的定义、宏以及类型声明，它是对xfs_bmap_btree.c的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值