数据结构源码笔记（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树的相关运算算法