算法导论-第18章-B树

最新推荐文章于 2022-09-18 16:52:57 发布
最新推荐文章于 2022-09-18 16:52:57 发布
阅读量661 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 算法导论

一、定义

1、B树

B树是为磁盘或其它直接存取辅助存储设备而设计的一种平衡查找树，主要特点是降低磁盘I/O操作次数。
B树以自然的方式推广二叉查找树。
B树的分支因子由磁盘特性所决定。 

2、B数的数据结构

int n：当前存储在结点x中的关键字个数
key[N]：每个结点有n个关键字，以非降序存放
bool leaf;//TRUE:x是叶子；FALSE:x是内结点
node *child[N+1]：只有内部结点才有，叶结点没有。（孩子结点个数为当前结点关键字的个数+1）。指向其n+1个孩子的指针。child[1].key <= key[1] <= child[2].key……，即当前结点的第i个关键字不小于它的第i个孩子结点的所有关键字，不大于它的第i+1个孩子结点的所有关键字。

3.B树的特征

（1）只有内结点才有指向子女的指针，且child[1].key <= key[1] <= child[2].key……
（2）每个叶结点具有相同的深度，即树的高度h。
（3）分支因子（最小度数）t>=2
（4）每个 非根 结点至少有t-1个关键字，如果是内结点，至少有t个子女（根结点可以有一个关键字，也可以有多个，孩子结点个数=关键字个数+1）
（5）每个结点至多有2t-1个关键字，如果是内结点，至多有2t个子女。如果有2t个孩子，称该结点是满的。

4.B树上的操作

B-Tree-Search(x, k)；查找关键字K，时间：O(t*logt n)。
B-Tree-Create(T)；创建一棵空的B树
B-Tree-Split-Child(x,i,y)；分裂B树中的满结点，把一个结点分成两个，主要用于后面的插入结点。O(t)。
B-Tree-Insert-Nonfull(x,k)；在非满结点x中插入关键字k。
B-Tree-Insert(T,k)；向以T为根结点的B树中插入关键字k。当T为满结点时，先调用 B-Tree-Split-Child(x,i,y)进行分裂，然后再调用上面的 B-Tree-Insert-Nonfull(x,k)进行插入。 O(t*logt n)。
B-Tree-Delete(T,k)；删除关键字k， O(t*logt n)。

二、代码

B_Tree.h

#include <iostream>
using namespace std;

#define N 10
int t = 2;
//B树结点结构
struct node
{
	int n;//当前存储在结点x中的关键字数
	char key[N];//n个关键字，以非降序存放
	bool leaf;//TRUE:x是叶子；FALSE:x是内结点
	node *child[N+1];//指向其n+1个孩子的指针
	//构造函数
	node(int num, bool IsLeaf):n(num),leaf(IsLeaf){}
	//磁盘读写操作
	void Disk_Read(){}
	void Disk_Write(){}
};
//B树结构
class B_Tree
{
public:
	//指向根结点
	node *root;
	B_Tree():root(NULL){}

	//从以x为根结点的树中寻找关键字为k的结点，若找到，将结果存入y中，返回其是第几个关键字
	int B_Tree_Search(node *x, char k, node&y);
	//构造一棵带树结点的空树
	void B_Tree_Create();
	//分裂，把y分裂为两个结点，选择其中一个关键字插入到x中的第i个位置
	void B_Tree_Split_Child(node *x, int i, node *y);
	//将关键字k插入到一个未满的结点x中
	void B_Tree_Insert_Nonfull(node *x, char k);
	//向T中插入关键字k
	void B_Tree_Insert(char k);
	//删除T树中关键字为k的结点，由于是递归方法，当前处理的是x结点
	void B_Tree_Delete(node *x, char k);
	//按关键字从小到大输出结点
	void Print(node *n);
};

//从以x为根结点的树中寻找关键字为k的结点，若找到，将结果存入y中，返回其是第几个关键字
int B_Tree::B_Tree_Search(node *x, char k, node&y)
{
	int i = 1;
	//找到第一个关键字不大于k的i
	while(i < x->n && k > x->key[i])
		i++;
	//若key[i] = k，则找到了
	if(i <= x->n && k == x->key[i])
	{
		//将结果存入y中
		y = *x;
		//返回其是第几个关键字
		return i;
	}
	//若没找到，则返回空
	if(x->leaf)
	{
		//	&y = NULL;
		return 0;
	}
	//若还有子树可以找，则递归查找第i个子树
	x->child[i]->Disk_Read();
	return B_Tree_Search(x->child[i], k, y);
}
//构造一棵带树结点的空树
void B_Tree::B_Tree_Create()
{
	//生成一个根结点
	//初始时，根结点为叶子结点，根结点中没有关键字
	root = new node(0, true);
	root->Disk_Write();
}
//分裂，把满结点y分裂为两个结点，选择其中一个关键字插入到x中的第i个位置
void B_Tree::B_Tree_Split_Child(node *x, int i, node *y)
{
	int j;
	//生成一个新结点z
	//要把y分裂为y和z，前面的y除了n其他都不变，要为后面的z赋关键字，孩子结点
	//分裂前y有2t-1个关键字，分裂后前t-1个属于y，后t-1个属于z，中间第t个属于x
	node *z = new node(t-1, y->leaf);
	y->n = t - 1;
	//后t-1个关键字依次复制给z
	for(j = 1; j < t; j++)
		z->key[j] = y->key[j+t];
	//如果有孩子，孩子也要复制过去，原来有2t个子树，前t个属于y，后t个属于z
	if(y->leaf == false)
	{
		for(j = 1; j <= t; j++)
			z->child[j] = y->child[j+t];
	}
	//使z作为x的第i+1个孩子(y已经是x的第i个孩子)
	for(j = x->n+1; j > i; j--)
		x->child[j+1] = x->child[j];
	x->child[i+1] = z;
	//把y中第t个关键字插入到x的第i个位置
	for(j = x->n; j >= i; j--)
		x->key[j+1] = x->key[j];
	x->key[i] = y->key[t];
	//x的关键字+1
	x->n++;
	y->Disk_Write();
	z->Disk_Write();
	x->Disk_Write();
}
//将关键字k插入到以未满结点k为根结点的子树中，实际上是把k插入到叶结点，通过递归，直到遇到叶结点，再插入
void B_Tree::B_Tree_Insert_Nonfull(node *x, char k)
{
	int i = x->n;//从后向前遍历，再插入
	//实际上是把k插入到叶结点，else的操作只是往下降，遇到满结点进行分裂，最终都是要插入到叶结点中
	//若x是叶子结点，递归结束条件
	if(x->leaf)
	{
		//找到该插入的位置
		while(i >= 1 && k < x->key[i])
		{
			x->key[i+1] = x->key[i];
			i--;
		}
		//插入关键字k
		x->key[i+1] = k;
		x->n++;
		x->Disk_Write();
	}
	//若不是叶子结点
	else
	{
		//找到该插入的位置
		while(i >= 1 && k < x->key[i])
			i--;
		i++;
		//读取其孩子，将关键字插入到它的孩子中，分两种情况
		x->child[i]->Disk_Read();
		//孩子已满
		if(x->child[i]->n == 2 * t - 1)
		{
			//对孩子执行分裂操作，分裂后，孩子变为不满
			B_Tree_Split_Child(x, i, x->child[i]);
			//x->key[i]为刚从x的子结点升上来的关键字，如果k比它大，则k要插入到第i个结点后面的结点的孩子中去
			if(k > x->key[i])
				i++;
		}
		//孩子不满，直接对孩子进行插入操作
		B_Tree_Insert_Nonfull(x->child[i], k);
	}
}
//向T中插入关键字k
void B_Tree::B_Tree_Insert(char k)
{
	node *r = root, *s;
	//若根结点已满
	if(r->n == 2*t-1)
	{
		//申请一个新的结点,将新的结点作为根结点
		root = new node(0, false);
		root->child[1] = r;
		//将原根结点分裂为两个结点，分别作为s的第0个孩子和第1个孩子
		B_Tree_Split_Child(root, 1, r);
		//把关键字k插入到根结点中，此时根结点一定不满
		B_Tree_Insert_Nonfull(root, k);
	}
	//若根结点不满
	else
		//直接把关键字插入到根结点中
		B_Tree_Insert_Nonfull(r, k);
}
//删除T树中关键字为k的结点，由于是递归方法，当前处理的是x结点
void B_Tree::B_Tree_Delete(node *x, char k)
{
	int i, j;
	//找到x中第一个不小于k的关键字，即待处理的位置
	for(i = 1; i <= x->n; i++)
		if(x->key[i] >= k)
			break;
	//y是关键字k之前的结点,即小于k的最大孩子
	//z是关键字k之后的结点,即大于k的最小孩子
	node *y = x->child[i], *z = x->child[i+1], *d;
	//若关键字k在结点x中的第i个位置
	if(x->key[i] == k && i <= x->n)
	{
		//1)y是叶子结点，则直接从x中删除k
		if(x->leaf == true)
		{
			//关键字依次前移
			for(j = i; j < x->n; j++)
				x->key[j] = x->key[j+1];
			//关键字数-1
			x->n--;
			return;
		}
		//2)x是内结点
		//2-a：x中前于k的子结点y包含至少t个关键字
		if(y->n >= t)
		{
			//找出k在以y为根的子树中的前驱d
			d = y;
			while(d->leaf == false)
				d = d->child[d->n+1];
			//用d取代k
			x->key[i] = d->key[d->n];
			//递归地删除d
			B_Tree_Delete(y, d->key[d->n]);
		}
		//2-b：x是位于k之后的子结点z包含至少t个关键字
		else if(z->n >= t)
		{
			//找出k在以z为根的子树中的后继d
			d = z;
			while(d->leaf == false)
				d = d->child[1];
			//用d取代k
			x->key[i] = d->key[1];
			//递归地删除d
			B_Tree_Delete(z, d->key[1]);
		}
		//2-c：y和z都只有t-1个关键字，将k和z中所有关键字合并进y，使得x失去k和指向z的指针
		else
		{
			//将k关键字合并进y
			y->key[y->n+1] = k;
			//将z中所有关键字合并进y
			for(j = 1; j <= z->n; j++)
				y->key[y->n+j+1] = z->key[j];
			//如果有孩子，孩子也要合并
			if(y->leaf == false)
			{
				//使得x指向z的指针
				for(j = 1; j <= z->n+1; j++)
					y->child[y->n+j+1] = z->child[j];
			}
			//y包含2t-1个关键字
			y->n = y->n + 1 + z->n;
			//使得x失去k
			for(j = i; j < x->n; j++)
				x->key[j] = x->key[j+1];
			//使x失去指向z的指针
			for(j = i+1; j <= x->n; j++)
				x->child[j] = x->child[j+1];
			x->n--;
			//如果x是根结点，x
			if(x->n == 0 && root == x)
				root = y;
			//释放z
			delete z;
			//将k从y中递归删除
			B_Tree_Delete(y, k);
		}
	}
	//3)关键字不在结点x中，则必定包含k的正确的子树的根x->child[i]
	else
	{
		//x是叶子结点,找到根结点都没有找到k，则k不在树中
		if(x->leaf == true)
		{
			cout<<"error:not exist"<<endl;
			return;
		}
		//x是内结点
		//3-a:child[i]中只有t-1个关键字
		if(y->n == t-1)
		{
			//它的相邻兄弟x->child[i+1](用z表示)包含至少t个关键字
			if(i <= x->n && i <= x->n && z->n >= t)
			{
				//将x中的关键字下降至y
				y->n++;
				y->key[y->n] = x->key[i];
				//将z的某一关键字上升至x
				x->key[i] = z->key[1];
				for(j = 1; j < z->n; j++)
					z->key[j] = z->key[j+1];
				//将z适合的子女指针移到y
				if(y->leaf == false)
				{
					y->child[y->n+1] = z->child[1];
					for(j = 1; j <= z->n; j++)
						z->child[j] = z->child[j+1];
				}
				//z的关键字数-1
				z->n--;
			}
			//它的相邻兄弟x->child[i-1]包含至少t个关键字
			else if(i > 1 && x->child[i-1]->n >= t )
			{
				//将x中的关键字下降至y
				for(j = y->n; j >= 1; j--)
					y->key[j+1] = y->key[j];
				y->key[1] = x->key[i-1];
				y->n++;
				//将y的相邻兄弟x->child[i-1]的某一关键字上升至x
				x->key[i-1] = x->child[i-1]->key[x->child[i-1]->n];
				//将该兄弟适合的子女指针移到y
				if(y->leaf == false)
				{
					for(j = y->n; j >= 1; j--)
						y->child[j+1] = y->child[j];
					y->child[1] = x->child[i-1]->child[x->child[i-1]->n+1];
				}
				//x->child[i-1]的关键字数-1
				x->child[i-1]->n--;
			}
			//y和其所有相邻兄弟都只有t-1个关键字，则与其中一个兄弟合并
			else
			{
				//与后面一个结点(用z表示)合并
				if(i <= x->n)
				{
					//将x->key[i]并入y中
					y->key[y->n+1] = x->key[i];
					//将z中所有关键字并入y中
					for(j = 1; j <= z->n; j++)
						y->key[j+y->n+1] = z->key[j];
					//如果有孩子，所有孩子也要并入
					if(y->leaf == false)
					{
						for(j = 1; j <= z->n+1; j++)
							y->child[j+y->n+1] = z->child[j]; 
					}
					//修改y的关键字数
					y->n = y->n + 1 + z->n;
					//将x->key[i]从x中移出
					for(j = i; j < x->n; j++)
						x->key[j] = x->key[j+1];
					//把指向z的指针从x->child中移出
					for(j = i+1; j <= x->n; j++)
						x->child[j] = x->child[j+1];
					//x的关键字数-1
					x->n--;
					//若根结点被删除，更新根结点
					if(x->n==0 && root == x)
						root = y;
				}
				//与前面一个结点合并
				else
				{
					//令z=x->child[i-1],y=x->child[i]，把z并入y中
					z = y;i--;
					y = x->child[i];
					//将x->key[i]并入y中
					y->key[y->n+1] = x->key[i];
					//将z中所有关键字并入y中
					for(j = 1; j <= z->n; j++)
						y->key[j+y->n+1] = z->key[j];
					//如果有孩子，所有孩子也要并入
					if(y->leaf == false)
					{
						for(j = 1; j <= z->n+1; j++)
							y->child[j+y->n+1] = z->child[j]; 
					}
					//修改y的关键字数
					y->n = y->n + 1 + z->n;
					//将x->key[i]从x中移出
					for(j = i; j < x->n; j++)
						x->key[j] = x->key[j+1];
					//把指向z的指针从x->child中移出
					for(j = i+1; j <= x->n; j++)
						x->child[j] = x->child[j+1];
					//x的关键字数-1
					x->n--;
					//若根结点被删除，更新根结点
					if(x->n==0 && root == x)
						root = y;
				}
			}
		}
		//递归执行删除操作
		B_Tree_Delete(y, k);
	}
}
//按关键字从小到大输出结点
void B_Tree::Print(node *n)
{
	int i;
	for(i = 1; i <= n->n; i++)
	{
		if(n->leaf == false)
			Print(n->child[i]);
		cout<<n->key[i]<<' ';
	}
	if(n->leaf == false)
		Print(n->child[n->n+1]);
}

main.cpp


#include <iostream>
using namespace std;
#include "B_Tree.h"
int main()
{
	//测试数据
	char ch[] = {'F','S','Q','K','C','L','H','T','V','W','M','R','N','P','A','B','X','Y','D','Z','E'};
	//生成一棵B树
	B_Tree *T = new B_Tree;
	T->B_Tree_Create();
	//依次插入关键字
	cout<<"插入测试"<<endl;
	int i;
	for(i = 0; i < 21; i++)
	{
		T->B_Tree_Insert(ch[i]);
		T->Print(T->root);
		cout<<endl;
	}
	//输出这棵树
	T->Print(T->root);
	cout<<endl;
	//B树删除操作测试
	cout<<"查找与删除测试"<<endl;
	char c;
	for(i = 0; i < 100; i++)
	{
		cin>>c;
		T->B_Tree_Delete(T->root, c);
		T->Print(T->root);
		cout<<endl;
	}
	return 0;
}

转自：http://blog.csdn.net/mishifangxiangdefeng/article/details/7798672
思翊
关注
专栏目录
算法导论-第三版(中文).rar
09-18
第十八章 B-树（B-Trees） 第十九章 二项式堆（Binomial Heaps） 第二十章 斐波纳契堆（Fibonacci Heaps） 第二十一章 不相交集的数据结构（Data Structures for Disjoint Sets） 第六部分（Part VI） 图算法...
《算法导论》第十八章——B树
T的博客
11-05 388
  虽然写这个博客主要目的是为了给我自己做一个思路记忆录，但是如果你恰好点了进来，那么先对你说一声欢迎。我并不是什么大触，只是一个菜菜的学生，如果您发现了什么错误或者您对于某些地方有更好的意见，非常欢迎您的斧正！ B树是为磁盘或其他直接存取的辅助存储设备而设计的一种平衡搜索树。 B数与红黑树的不同之处在于B树的结点可以有很多个孩子。 18.1B树的定义 一棵B树T具有以下性质（根为T.r...
算法导论读书笔记（18）B树
liujianli的博客
06-22 629
第五部分 高级数据结构第18章 B树 B树是为磁盘或其他直播存取的辅助存储设备而设计的一种平衡搜索树，它们在降低磁盘I/O操作数方面要更好一些。 B树的结点可以有很多孩子 1. B树的定义一棵B树T是具有以下性质的有根树（根为T.root） 1. 每个结点x有下面属性： a. x.n，当前存储在结点x中的关键字个数。 b. x.n个关键字本身x.key1, x.key2, …, x.keyx.
《算法导论》第18章-B树 引入 && 18.1 B树的定义
Toby的博客
09-18 182
本文为《算法导论》第18章-B树 引入 && 18.1 B树的定义 的笔记，欢迎参考！
算法导论笔记：18B树
weixin_30753873的博客
05-09 74
磁盘作为辅存，它的容量要比内存大得多，但是速度也要慢许多，下面就是磁盘的的结构图： 磁盘驱动器由一个或多个盘片组成，它们以固定的速度绕着主轴旋转，数据存储于盘片的表面，磁盘驱动器通过磁臂末尾的磁头来读写盘片。礠臂可以将磁头向主轴移近或移远。当一个磁头处于静止的时候，它下面经过的磁盘表面称为磁道。 磁盘之所以比主存要慢，是因为它有机械运动...
《算法导论》第18章 B树
漂泊尘埃0x101010的专栏
09-02 651
1. B树的定义B树示意图：// 保存在B树中的关键字，同时也可以保存其他数据 type Key interface { CompareTo(other Key) int String() string }type BTree struct { root *BTreeNode t int // 最小度数，除根节点外的内部节点至少有t个孩子，至多2t个孩子 }ty
算法导论-答案（第二版-扫描版）
04-08
第八章讨论了线性时间排序算法，这类算法可以在O(n)时间内完成排序任务。例如，习题8.1-1至8.1-4介绍了计数排序的基本原理。习题8.2-1至8.2-4则探讨了基数排序的应用场景。习题8.3-1至8.3-5介绍了桶排序的实现方式。...
算法导论-麻省理工（中文）
11-22
　第十八章 B-树（B-Trees） 　第十九章 二项式堆（Binomial Heaps） 　第二十章 斐波纳契堆（Fibonacci Heaps） 　第二十一章 不相交集的数据结构（Data Structures for Disjoint Sets） 　第六部分（Part VI） 图...
算法导论第十八章习题解答
05-06
第十八章通常涉及图算法，包括最短路径、最小生成树、网络流等核心概念。在这个章节的习题解答中，我们将探讨这些关键知识点，并尝试用代码来表示它们。 1. **最短路径算法**： - **Dijkstra算法**：用于寻找图中...
算法导论全部练习和习题的答案
12-05
5. **Ch18.pdf** - 第十八章可能涉及字符串处理，如模式匹配算法（如KMP算法），字符串搜索和字符串的哈希函数。 6. **Ch27.pdf** - 第二十七章可能涉及图的深度优先搜索和广度优先搜索，以及树的遍历方法，还有图...
算法导论 第十八章；B 树
dllTimes
07-18 936
B树是为磁盘或其他直接存取辅助存储设备而设计的一种平衡查找树。B树的”分支因子“可能很大，即每个节点可以有很多子女。这一因子由所用磁盘特性所决定，并且可以降低磁盘I/O操作次数。许多数据库系统都使用B树或B树的变形来存储信息。 B树结构形式如下: 其特点： 1）每个节点x有以下域： a)  x.n:当前存储在节点x中的关键字 b) x.n 个key值，以非降序顺序存放，即 x.key
算法导论之第十八章-B树
孤竹彧的根据地
07-24 234
B树就是个树，和二叉树的区别是，二叉树只能有两个子节点，所以二叉树的劣势在于深度过深了 二叉树有点分治法里的二分，而B树就有点彻底的分治法的意思了 B树的内节点(即非叶节点)上也是有值的，为关键字，关键字的值是要有顺序的(我的代码里默认升序，关键字的值只是一个整数，其实可以保存对象) B树的关键字个数不是随意的 1)我们有一个度数用t来表示，t>=2 2)关键字的个数m，m>=t-1,...
算法导论 第18章 B树
幸福在路上
07-29 7626
一、定义 1、B树 B树是为磁盘或其它直接存取辅助存储设备而设计的一种平衡查找树，主要特点是降低磁盘I/O操作次数。 B树以自然的方式推广二叉查找树。 B树的分支因子由磁盘特性所决定。  2、B数的数据结构 int n：当前存储在结点x中的关键字数 key[N]：n个关键，以非降序存放 bool leaf;//TRUE:x是叶子；FALSE:x是内结点 node *child[N
算法导论18.2-4
MyLinChi的博客
11-16 740
问题描述 假设关键字{1,2,…,n}被插入一棵最小度数为2的空B树中，那么最终的B树有多少个结点？ 问题求解 把关键字{1,2,…,11}一次插入B树中的变化如下所示： 可以发现，由于每次插入的树都比前面的大，因此新关键字永远是放到了最右边的结点中。除了最右边一直往下的路径上的结点（记为R）中的关键字数有可能大于1外，其他所有结点的关键字数量都是1.当所有
《算法导论》笔记 第18章 18.1 B树的定义
Azarath Metrion Zinthos
04-29 1627
【笔记】 【练习】
算法导论第18章 18-1
u010969626的博客
07-18 937
18.1-1      根据B树的定义 每个节点包含的关键字的个数有上界和下界，用一个被称为B树的最小度数的固定整数t来表示这些界。 除了根节点以外的每个节点必须至少有t-1个关键字。除了根节点以外的每个内部节点至少有t个孩子，如果树非空，根节点至少有一个关键字。 每个节点之多可包含2t-1个关键字。每个节点之多有2t个孩子。 由此可见如果树的最小度数为1，根节点以外的每个节点至少有
算法导论—B树
掉下个小石头
09-09 1259
华电北风吹 天津大学认知计算与应用重点实验室 最后修改日期：2015/9/10B树是二叉搜索树的扩展。B树主要是用于操作存储在磁盘或其他直接存取的辅助存储设备上的大量数据。当数据太多的时候，内存不足以支持全部的数据，因此需要分批将磁盘中的数据载入内存。由于对磁盘的读写操作相比于内存来说要慢几个数量级，所以在对磁盘数据进行读写的时候要尽量减少磁盘的读写次数。B树类似于红黑树，但在降低磁盘I/O
算法导论 第18章 B 树
V然成风
04-03 1466
前言    B树和红黑树一样，也是一种平衡树。但是前者主要用在数据库系统或者文件系统中，有助于降低磁盘I/O次数；此外，B树可以有很多的子女，几十或者上千个不等，“分支因子”较大。 B树定义    B树是递归定义的，每个节点，都可以看做是一棵以该节点为根的子B树。 B树高度    B树的操作    本篇博客实现的B树提供以下操作：    1、判空操
计算机导论-第三章：问题求解框架与算法概念
"哈尔滨工业大学的计算机导论课程第三章，主要讲解了问题求解框架，特别是算法类问题。由聂兰顺博士和战德臣博士共同授课，涵盖了算法概念、算法类问题求解概述、数学建模、策略设计、基本数据结构与控制结构、算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值