数据结构源码笔记(C语言):B树的相关运算算法

//B树的相关运算算法

#include<stdio.h>
#include<malloc.h>


#define MAXM  10//定义B树最大的阶数
typedef int KeyType;//关键码类型


typedef struct node//B树结点类型定义
{
	KeyType keynum;//关键字的个数
	KeyType key[MAXM];//存放关键字
	struct node *parent;//双亲结点指针
	struct node *ptr[MAXM];//孩子结点指针数组
}BTNode;

typedef struct //B树查找结果类型
{
	BTNode *pt;//指向找到的结点
	int i;//结点中关键字序号
	int tag;//1:查找成功;0:查找失败
}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)
{//zai p->key[1...keynum]中查找i,使得p->key[i]<=k<p->key[i+1]
	for(int i=0;i<p->keynum && p->key[i+1]<=k;i++);
	return i;
}


Result SearchBTree(BTNode *t,KeyType k)
{// 在m阶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;
}

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->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和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
			{
				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)//查找关键字
		{
			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("\n");
	printf("创建一棵%d阶B-树:\n",m);
	for(j=0;j<n;j++)//创建一个3阶B树
	{
		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("删除操作:\n");
	k=8;
	DeleteBTree(k,t);
	printf("删除%d:",k);
	DispBTree(t);
	
	printf("\n");
	k=1;
	DeleteBTree(k,t);
	printf("删除%d:",k);
	DispBTree(t);
	printf("\n\n");
	return 0;
}

数据结构源码笔记(C语言描述)汇总:

数据结构源码笔记(C语言):英文单词按字典序排序的基数排序

数据结构源码笔记(C语言):直接插入排序

数据结构源码笔记(C语言):直接选择排序

数据结构源码笔记(C语言):置换-选择算法

数据结构源码笔记(C语言):Huffman树字符编码

数据结构源码笔记(C语言):Josephus问题之顺序表

数据结构源码笔记(C语言):Josephus问题之循环链接表

数据结构源码笔记(C语言):多项式合并

数据结构源码笔记(C语言):二叉树之叶子结点旋转销毁

数据结构源码笔记(C语言):哈夫曼树

数据结构源码笔记(C语言):集合的位向量表示

数据结构源码笔记(C语言):链接队列

数据结构源码笔记(C语言):链接栈

数据结构源码笔记(C语言):线性表的单链表示

数据结构源码笔记(C语言):线性表的顺序表示

数据结构源码笔记(C语言):栈的基本操作

数据结构源码笔记(C语言):中缀表达式

数据结构源码笔记(C语言):希尔插入排序

数据结构源码笔记(C语言):索引文件建立和查找

数据结构源码笔记(C语言):冒泡排序

数据结构源码笔记(C语言):快速排序

数据结构源码笔记(C语言):可变长度字符串的快速排序

数据结构源码笔记(C语言):基数排序

数据结构源码笔记(C语言):二路归并排序

数据结构源码笔记(C语言):堆排序

数据结构源码笔记(C语言):二叉树搜索树Kruskal

数据结构源码笔记(C语言):二叉搜索树Prim

数据结构源码笔记(C语言):最短路径弗洛伊德算法

数据结构源码笔记(C语言):深度、广度优先生成树

数据结构源码笔记(C语言):邻接矩阵转化邻接表

数据结构源码笔记(C语言):统计字符串中出现的字符及其次数

数据结构源码笔记(C语言):顺序查找

数据结构源码笔记(C语言):哈希表的相关运算算法

数据结构源码笔记(C语言):分块法查找

数据结构源码笔记(C语言):二分查找

数据结构源码笔记(C语言):二叉树遍历

数据结构源码笔记(C语言):二叉平衡树的相关操作算法

数据结构源码笔记(C语言):二叉排序树的基本操作算法

数据结构源码笔记(C语言):B树的相关运算算法

©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页