码迷,mamicode.com
首页 > 其他好文 > 详细

看数据结构写代码(58) B-树

时间:2015-04-24 14:25:00      阅读:168      评论:0      收藏:0      [点我收藏+]

标签:b-树   b-树的插入   

B-树 一种 自平衡的 多路 查找树。它在文件系统里很有用。

一个m阶的B-树,要么是空树,要么是满足这些特性的树。、

1.树 最多 有 m个分支。

2.树的根 最少 两个子树。

3. 树的非终端叶子节点 最少  m/2 向上 取整   个 子树。

4.所有叶子节点 都在 一层。


它的节点 结构:  (N,P0,K1,P1,K2,p2......Kn,Pn)

其中 N 是 节点的 关键字个数,p0~pn 是 指向子树的指针,K1~Kn是关键字


#define M		3 //B树的阶数..

typedef int keyType;

typedef struct BTreeNode{
	int keyNum;//关键字的个数.
	BTreeNode * ptr[M+1];//指针数组,(总比 关键字 多一个).
	keyType key[M+1];//关键字数组,第0个没用,从 第1个开始,
	BTreeNode * parentNode;//节点的父亲..
}*BTree;

根据上面的特性,总结:

1.节点中 分支树,最大为 阶数,最小 为 m/2 向上 取整(根节点最小为2,只有一个根节点 的树 可以没有子树)

2.所有结构中,关键字个数  =  指向子树的指针树 -1,所以关键字 最大 为 M-1,最少 为  上面 所说的 最小值 -1.

3.K1~Kn,顺序排放。

4.假设 k 是 节点的 第 x个 关键字,那么 P(x-1)指向的 子树中的 的 关键字 都比 k小,P(x)指向的子树指向的关键字 都比 k大。


B-树的 查找,分为 两部分,一部分 是顺指针查找节点 ,一部分 是 子 节点里 查找。下面的 search函数 就是 在 子节点里查找 关键字。

struct Result{//查找的结果
	int tag;//0查找失败,1查找成功
	int index;//位置
	BTreeNode * p;//指向查找成功的指针或者插入位置的 指针
};
//查找到:返回k的位置; 没查找到:返回 k值的 搜索指针位置。
int search(BTree t,keyType k){
	if (t != NULL){
		for (int i = 1; i <= t->keyNum; i++){
			if (t->key[i] == k){//找到了返回当前索引
				return i;
			}
			else if(t->key[i] > k){//没找到,返回 前一个位置
				return i-1;
			}
		}
		return t->keyNum;//所有节点 都比 k 小
	}
	return 0;
}
//查找
Result searchBTree(BTree t,keyType k){
	BTree p = t,q = NULL;
	bool isFind = false;
	int index = 0;
	while (p != NULL){
		index = search(p,k);
		if (index >= 1 && p->key[index] == k ){
			isFind = true;
			break;
		}
		else{
			q = p;
			p = p->ptr[index];
		}
	}
	if (isFind){//查找到了
		Result r ={1,index,p};
		return r;
	}
	else{
		Result r ={0,index,q};
		return r;
	}
}

下面 主要 说 B-树的 插入 算法。

1.如果节点 存在,不插入

2.节点不存在,插入 节点

3.如果 插入后, 节点  的 关键字个数 大于 M-1个,则 需要 分裂 ,具体分裂如下:

技术分享

如果 造成 父节点 关键字个数 超过 M-1,则 需要 分裂。


完整代码如下:

// BTree.cpp : 定义控制台应用程序的入口点。
//B-树:多路自平衡查找树

#include "stdafx.h"
#include <cstdlib>
#include <cmath>
#include "queue.h"
#define M		3 //B树的阶数..

typedef int keyType;

typedef struct BTreeNode{
	int keyNum;//关键字的个数.
	BTreeNode * ptr[M+1];//指针数组,(总比 关键字 多一个).
	keyType key[M+1];//关键字数组,第0个没用,从 第1个开始,
	BTreeNode * parentNode;//节点的父亲..
}*BTree;

//获取一个节点,这样 的 初始化是个 好习惯.
BTreeNode * makeNode(){
	BTreeNode * node = (BTreeNode*)malloc(sizeof(BTreeNode));
	node->parentNode = NULL;
	for (int i = 0; i <= M; i++){
		node->ptr[i] = NULL;
	}
	node->keyNum = 0;
	return node;
}

void initTree(BTree *tree){
	*tree = NULL;
}

struct Result{//查找的结果
	int tag;//0查找失败,1查找成功
	int index;//位置
	BTreeNode * p;//指向查找成功的指针或者插入位置的 指针
};
//查找到:返回k的位置; 没查找到:返回 k值的 搜索指针位置。
int search(BTree t,keyType k){
	if (t != NULL){
		for (int i = 1; i <= t->keyNum; i++){
			if (t->key[i] == k){//找到了返回当前索引
				return i;
			}
			else if(t->key[i] > k){//没找到,返回 前一个位置
				return i-1;
			}
		}
		return t->keyNum;//所有节点 都比 k 小
	}
	return 0;
}
//查找
Result searchBTree(BTree t,keyType k){
	BTree p = t,q = NULL;
	bool isFind = false;
	int index = 0;
	while (p != NULL){
		index = search(p,k);
		if (index >= 1 && p->key[index] == k ){
			isFind = true;
			break;
		}
		else{
			q = p;
			p = p->ptr[index];
		}
	}
	if (isFind){//查找到了
		Result r ={1,index,p};
		return r;
	}
	else{
		Result r ={0,index,q};
		return r;
	}
}
//将 p 插入 到  t->ptr[index+1]
//将 k 插入到 t->key[index+1];
void insert(BTree t,int index,keyType k,BTree p){
	//index 后面的移开
	for (int i = t->keyNum; i > index; i--){
		t->key[i+1] = t->key[i];
		t->ptr[i+1] = t->ptr[i];
	}
	t->key[index+1] = k;
	t->ptr[index +1] = p;
	t->keyNum ++;
}

//将 index 后部分分裂出 一个 新的节点
//指针 复制 :index 到 keyNum
//关键字复制: index +1 到 keyNum
void split(BTree t,int index,BTree * newNode){
	*newNode = makeNode();
	int count = 0;
	for (int i = index; i <= t->keyNum; i++){
		if (i > index){////关键字复制: index +1 到 keyNum
			count++;
			(*newNode)->key[count] = t->key[i];//从1 开始.
		}
		BTree child = (*newNode)->ptr[count] = t->ptr[i];
		//忘记写了,需要 把 带走的节点 设置 新的 父节点
		if (child != NULL){
			child->parentNode = *newNode;
		}
		t->ptr[i] = NULL;//设置原有指针为NULL
	}
	//下面两句漏写..
	(*newNode)->parentNode = t->parentNode;
	t->keyNum = index -1;//原节点 数量 减少.
	(*newNode)->keyNum = count;
}
//新的根节点(之前为 空树,或者 分裂出了 一个 头节点)
void newRoot(BTree * t,keyType k,BTree left,BTree right){
	BTree p = *t = makeNode();
	p->key[1] = k;
	p->ptr[0] = left;
	p->ptr[1] = right;
	p->keyNum = 1;
	if (left != NULL){
		left->parentNode = p;
	}
	if (right != NULL)
	{
		right->parentNode = p;
	}
}
//插入
void insertBTree(BTree * t,keyType k){
	Result r = searchBTree(*t,k);
	if (r.tag ==  0){//不存在 ,插入.
		int index = r.index;//插入位置
		BTree p = r.p;//插入节点
		BTree q = NULL;//插入关键字的 右孩子.
		BTree r = NULL;
		bool finished = false;
		while (p != NULL){
			insert(p,index,k,q);
			if (p->keyNum < M){//M阶 的 树,最多 有 M-1个 关键字{
				finished = true;
				break;
			}
			else{//关键字个数 超过M-1个,需要 分裂.
				int mid = (int)ceil(M/2.0);
				split(p,mid,&q);
				k = p->key[mid];//分裂需要插入 到父节点的关键字
				r = p;
				p = p->parentNode;//父节点
				index = search(p,k);//插入到父节点的位置.
			}
		}
		if (finished == false){//空树,或者 根节点的 关键字 大于 M-1
			newRoot(t,k,r,q);
		}
	}
}

//index之后的关键字 和指针左移
void leftMove(BTree p,int index){
	if(index < p->keyNum){
		for (int i = index; i < p->keyNum; i++){
			if (i>= 1){
				p->key[i] = p->key[i+1];
			}
			p->ptr[i] = p->ptr[i+1];
		}
	}
	else{//在最后一个位置,不需要移动
		p->ptr[p->keyNum] = NULL;
	}
	p->keyNum--;
}

//*t 树根,start:搜索开始的节点
bool deleteBTree(BTree * t,BTree start,keyType key){
	Result r = searchBTree(start,key);
	if (r.tag == 1){//找到了
		BTree p = r.p;
		int index = r.index;
		//不是 最底下一层非终端节点,寻找右子树最小节点,替换k值,并删除最小节点
		if (p->ptr[0] != NULL){
			BTree q = p->ptr[index];
			while (q->ptr[0] != NULL){
				q = q->ptr[0];
			}
			p->key[index] = q->key[1];
			return deleteBTree(t,p->ptr[index],q->key[1]);//删除最小节点退出函数
		}
		else// 是 最底下一层 非终端节点.
		{
			//节点最小阶数为 M/2 向上取整,关键字 比 最小阶数 小1
			int min = (int)ceil(M/2.0)-1;
			BTree parent = p->parentNode;
			//是根节点 或者 节点数 大于 min
			if (p->keyNum > min || parent == NULL ){
				leftMove(p,index);//index后面的关键字左移
				if (p->keyNum == 0){//根节点关键字最少为1,空树.
					free(*t);
					*t = NULL;
				}
				return true;
			}
			else if(p->keyNum == min){
				leftMove(p,index);//将删除关键字后面的 左移
				BTree leftBrother = NULL;
				BTree rightBrother = NULL;
				int pIndex = search(parent,key);//寻找节点在 父节点的 位置(查找位置
				if (pIndex>=1){
					leftBrother = parent->ptr[pIndex-1];//左相邻兄弟
				}
				if (pIndex < parent->keyNum){
					rightBrother = parent->ptr[pIndex+1];//右兄弟
				}
				//寻找 是否 有相邻 兄弟 keyNum大于 min的.
				if(leftBrother != NULL && leftBrother->keyNum > min){//左兄弟有空间
					//整个空间 的关键字 右移一个位置
					for (int i = p->keyNum; i >= 1; i--){
						p->key[i+1] = p->key[i];
					}
					p->key[1] = parent->key[pIndex];//父节点关键字下移
					p->keyNum++;
					parent->key[pIndex] = leftBrother->key[leftBrother->keyNum];//将最大值上移到父节点。
					leftBrother->keyNum--;//最终 左兄弟节点的 关键字少了一个,其余没变.
					return true;
				}
				else if (rightBrother != NULL && rightBrother->keyNum > min){//右兄弟有空间
					p->key[p->keyNum+1] = parent->key[pIndex+1];//父节点关键字下移
					p->keyNum++;
					parent->key[pIndex+1] = rightBrother->key[1];//将最小值上移
					leftMove(rightBrother,1);//将 最小值 之后的 左移.
					return true;
				}
				BTree merger = NULL;//合并后的节点
				while (parent != NULL){
					//左右相邻空间都等于 min,需要 删除节点后合并(书中第三种情况)
					if (leftBrother != NULL){
						merger = leftBrother;
						//将节点中其他关键字 和 父节点的第pindex个 复制到左兄弟中
						int lIndex = leftBrother->keyNum+1;//左兄弟下标
						leftBrother->key[lIndex] = parent->key[pIndex];//先复制父节点关键字
						leftMove(parent,pIndex);//父节点关键字后面的左移
						for (int i = 0; i <= p->keyNum; i++){
							if  (i >=1){
								leftBrother->key[lIndex] = p->key[i];
							}
							leftBrother->ptr[lIndex++] = p->ptr[i];
							if (p->ptr[i] != NULL){//设置新的父节点
								p->ptr[i]->parentNode = leftBrother;
							}
						}
						leftBrother->keyNum += p->keyNum + 1;
						free(p);//合并完成删除节点
					}
					else if (rightBrother != NULL){
						merger = rightBrother;
						//加入到右兄弟节点的关键字个数,减去一个关键字,再加上一个父节点关键字
						int addNum = p->keyNum + 1;
						rightBrother->keyNum += addNum;
						//为插入关键字移位
						for (int i = rightBrother->keyNum; i >= 0; i--){
							if (i >= 1){
								rightBrother->key[i+addNum] = rightBrother->key[i];
							}
							rightBrother->ptr[i+addNum] = rightBrother->ptr[i];
						}
						int i = 0;
						for (; i <= p->keyNum; i++){
							if (i >= 1){
								rightBrother->key[i] = p->key[i];
							}
							rightBrother->ptr[i] = p->ptr[i];
							if (p->ptr[i] != NULL){//设置新的父节点
								p->ptr[i]->parentNode = rightBrother;
							}
						}
						rightBrother->key[i] = parent->key[pIndex+1];
						leftMove(parent,pIndex+1);//左移
						free(p);//合并完成,删除节点
					}
					//父节点关键字不足,继续删除父节点,然后合并.
					if (parent->keyNum < min){
						p = parent;
						parent = parent->parentNode;
						pIndex = search(parent,key);//寻找节点在 父节点的 位置(查找位置
						leftBrother = rightBrother = NULL;
						if (pIndex>=1){
							leftBrother = parent->ptr[pIndex-1];//左相邻兄弟
						}
						if (pIndex < parent->keyNum){
							rightBrother = parent->ptr[pIndex+1];//右兄弟
						}
					}
					else if (parent->keyNum > M-1){//合并后的关键字超过 M-1,需要分裂
						BTree newNode = NULL,r = NULL;
						bool finished = false;
						p = parent;
						keyType k = 0;
						while (p != NULL){
							int mid = (int)ceil(M/2.0);
							split(p,mid,&newNode);
							k = p->key[mid];//分裂需要插入 到父节点的关键字
							r = p;
							p = p->parentNode;
							if (p != NULL){
								index = search(p,k);//插入到父节点的位置.
								insert(p,index,k,newNode);
								if (p->keyNum < M){//M阶 的 树,最多 有 M-1个 关键字{
									finished = true;
									break;
								}
							}
						}
						if (finished == false){//空树,或者 根节点的 关键字 大于 M-1
							newRoot(t,k,r,newNode);
						}
						return true;
					}
				}
				//根节点最少一个,当为0时,将合并的节点设置为新的 根节点。
				if (p->keyNum == 0){
					free(p);
					*t = merger;
					return true;
				}
			}
			else{//error
				printf("------------ERROR--------------\n");
			}
		}
	}
	return false;//没找到
}

//层序遍历
void levelOrderTraverse(BTree tree){
	if (tree != NULL){
		LinkQueue queue;
		queueInit(&queue);
		enqueue(&queue,tree);
		int count = 1;
		int nextCount = 0;
		int level = 1;
		printf("-----------层序遍历--------------\n");
		while (!queueEmpty(queue)){
			printf("第%d层数据:",level);
			for (int i = 0; i < count; i++){
				BTree front;
				dequeue(&queue,&front);
				for (int j= 0; j <= front->keyNum; j++){
					if (j >=1){
						printf("%d\t",front->key[j]);
					}
					if (front->ptr[j] != NULL){
						enqueue(&queue,front->ptr[j]);
					}
					nextCount++;
				}
				printf("------");
			}
			printf("\n");
			count = nextCount;
			nextCount = 0;
			level ++;
		}
		queueDestory(&queue);
		printf("\n");
	}
}


int _tmain(int argc, _TCHAR* argv[])
{
	BTree tree;
	initTree(&tree);
	int array [11] = {22,11,55,66,77,33,44,99,88,22,33};
	for (int i = 0; i < 11; i++){
		insertBTree(&tree,array[i]);
		//printf("-----插入%d后------------\n",array[i]);
		//levelOrderTraverse(tree);
	}
	levelOrderTraverse(tree);
	return 0;
}

其中包含了部分不正确的 B-树 删除代码,在处理 下面 这个问题时,不正确。书中 也没提到 这种情况。希望 以后 完善。

技术分享



看数据结构写代码(58) B-树

标签:b-树   b-树的插入   

原文地址:http://blog.csdn.net/fuming0210sc/article/details/45244835

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!