b树的c++实现

最新推荐文章于 2022-08-22 10:48:08 发布
最新推荐文章于 2022-08-22 10:48:08 发布
阅读量1.1k 收藏 5
点赞数
分类专栏： C++语言程序设计 算法 文章标签： b树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012637838/article/details/45463047
版权 
#include <iostream>
#include <vector>
#include <queue>

using namespace std;


class BTree{
	static const int M = 2;
	struct BTNode{
		int keyNum;
		int key[2 * M - 1];  //关键字数组
		struct BTNode* child[2 * M];//孩子结点数组
		bool isLeaf;
	};
	
	BTNode* root;
	//在插入时，保证pNode结点的关键字少于2*M-1个
	void InsertNonFull(BTNode* pNode, int key);
	//当child结点有2M-1个关键字时，分裂此结点
	void SplitChild(BTNode* parent, int i, BTNode* child);
	//两个M-1个元素的结点合并
	void merge(BTNode* parent, BTNode* pNode1, BTNode* pNode2, int index);
	//找到比pNode结点第一个关键字小的最大的关键字，也就是前继结点
	int predecessor(BTNode* pNode);
	//找到后继结点
	int successor(BTNode* pNode);
	//pNode1向parent要一个结点key[index]，parent向pNode0要一个结点，pNode1关键字个数为M-1
	void ExchangeLeftNode(BTNode *parent, BTNode* pNode0, BTNode* pNode1, int index);
	void ExchangeRightNode(BTNode* parent, BTNode* pNode1, BTNode *pNode2, int index);
	//删除，结点关键字个数不少于M
	void RemoveNonLess(BTNode* pNode, int key);
	void DiskWrite(BTNode* pNode);
	void DiskRead(BTNode *pNode);
	BTNode* Search(BTNode* pNode, int key, int &index);
public:
	BTree();
	~BTree();
	BTNode* search(int key, int &index);
	void insert(int key);
	void remove(int key);
	//按层级打印。
	void PrintRow();
};

 
BTree::BTree()
{
	root = new BTNode();
	root->isLeaf = true;
	root->keyNum = 0;
	DiskWrite(root);
}

 
BTree::~BTree()
{
	struct BTNode* pNode;
	queue<struct BTNode*> q;
	q.push(root);
	while (!q.empty()){
		pNode = q.front();
		q.pop();
		
		if (pNode->isLeaf)
			continue;
		for (int i = 0; i <= pNode->keyNum; i++)
			q.push(pNode->child[i]);
		delete pNode;
	}
}

 
void BTree::DiskWrite(BTNode* pNode)
{

}

 
void BTree::DiskRead(BTNode *pNode)
{

}

 
BTree::BTNode* BTree::Search(BTNode* pNode, int key, int &index)
{
	int i = 0;
	while (i<pNode->keyNum&&key>pNode->key[i])//找到第一个大于等于key的下标
		i++;
	if (i < pNode->keyNum&&key == pNode->key[i]){//如果找到关键字，返回
		index = i;
		return pNode;
	}
	if (pNode->isLeaf)//已经搜到叶子结点，不存在
		return NULL;
	else{
		DiskRead(pNode->child[i]);
		return Search(pNode->child[i], key, index);//在第一个大于key值的孩子节点中递归搜索
	}
}

 
void BTree::InsertNonFull(BTNode* pNode, int key)
{
	int i = pNode->keyNum - 1;
	if (pNode->isLeaf){//如果是叶子结点，直接插入
		while (i >= 0 && key < pNode->key[i]){
			pNode->key[i + 1] = pNode->key[i];
			i--;
		}
		pNode->key[i + 1] = key;
		pNode->keyNum++;
		DiskWrite(pNode);
	}
	else {
		while (i >= 0 && key < pNode->key[i])
			i--;//找到第一个小于等于key的下标
		i++;
		DiskRead(pNode->child[i]);
		if (pNode->child[i]->keyNum == 2 * M - 1){//判断孩子结点是否有2*M-1个关键字，有就需要分裂
			SplitChild(pNode, i, pNode->child[i]);
			if (key>pNode->key[i])//如果key比上移到父节点的元素大
				i++;
		}
		InsertNonFull(pNode->child[i], key);//已保证孩子结点关键字个数少于2*M-1个
	}
}

 
void BTree::SplitChild(BTNode* parent, int i, BTNode* child)
{
	int j;
	struct BTNode* pNode = new BTNode();
	pNode->isLeaf = child->isLeaf;
	pNode->keyNum = M - 1;
	for (j = 0; j < M - 1; j++)//将child结点的后M-1个关键字赋给新节点
		pNode->key[j] = child->key[j + M];
	if (!child->isLeaf){//如果child不是叶子结点，将其后M个孩子结点赋给新节点。
		for (j = 0; j < M; j++)
			pNode->child[j] = child->child[j + M];
	}
	child->keyNum = M - 1;

	for (j = parent->keyNum; j > i; j--)
		parent->child[j + 1] = parent->child[j];//将child结点的父节点parent下标i以后的结点指针都向后移动一位，
	parent->child[j + 1] = pNode;//将新生成的结点当成parent的一个孩子
	for (j = parent->keyNum - 1; j >= i; j--)	//将i后面的关键字都向后移动一位
		parent->key[j + 1] = parent->key[j];
	parent->key[j + 1] = child->key[M - 1];//将孩子结点的中间结点移到父节点的指定位置
	parent->keyNum++;
	DiskWrite(parent);
	DiskWrite(pNode);
	DiskWrite(child);
}

 
void BTree::merge(BTNode* parent, BTNode* pNode1, BTNode* pNode2, int index)
{
	pNode1->key[M - 1] = parent->key[index];
	for (int i = 0; i < M - 1; i++)//将pNode2的关键字移到pNode1中
		pNode1->key[i + M] = pNode2->key[i];
	pNode1->keyNum = 2 * M - 1;
	if (!pNode1->isLeaf){//如果不是叶子，将pNode2的孩子指针也移到pNode1中
		for (int i = 0; i < M; i++)
			pNode1->child[i + M] = pNode2->child[i];
	}

	for (int i = index; i < parent->keyNum; i++){//将父节点index以后的关键字以及孩子指针都向前移动一位
		parent->key[i] = parent->key[i + 1];
		parent->child[i + 1] = parent->child[i + 2];
	}
	parent->keyNum--;
	delete pNode2;
}

 
int BTree::predecessor(BTNode* pNode)
{
	while (!pNode->isLeaf)
		pNode = pNode->child[pNode->keyNum];
	return pNode->key[pNode->keyNum - 1];
}

 int BTree::successor(BTNode* pNode)
{
	while (!pNode->isLeaf)
		pNode = pNode->child[0];
	return pNode->key[0];
}

 
void BTree::ExchangeLeftNode(BTNode *parent, BTNode* pNode0, BTNode* pNode1, int index)
{
	for (int i = pNode1->keyNum; i > 0; i--)
		pNode1->key[i] = pNode1->key[i - 1];//pNode1结点所有关键字向后移动一位
	pNode1->key[0] = parent->key[index];//第0个关键字来自父节点
	pNode1->keyNum++;
	parent->key[index] = pNode0->key[pNode0->keyNum - 1];//父节点的index处的关键字来自pNode0的最大关键字

	if (!pNode0->isLeaf){//如果不是叶子结点，
		for (int i = pNode1->keyNum; i > 0; i--)//将pNode1的孩子指针都向后移动一位，并将pNode0的最后一个孩子指针赋给它的第一个
			pNode1->child[i] = pNode1->child[i - 1];
		pNode1->child[0] = pNode0->child[pNode0->keyNum];
	}

	pNode0->keyNum--;
}

 
void BTree::ExchangeRightNode(BTNode* parent, BTNode* pNode1, BTNode *pNode2, int index)
{
	pNode1->key[pNode1->keyNum] = parent->key[index];
	pNode1->keyNum++;
	parent->key[index] = pNode2->key[0];
	for (int i = 0; i < pNode2->keyNum - 1; i++)
		pNode2->key[i] = pNode2->key[i + 1];

	if (!pNode2->isLeaf){
		pNode1->child[pNode1->keyNum] = pNode2->child[0];
		for (int i = 0; i < pNode2->keyNum; i++)
			pNode2->child[i] = pNode2->child[i + 1];
	}
	pNode2->keyNum--;
}

 
void BTree::RemoveNonLess(BTNode* pNode, int key)
{
	if (pNode->isLeaf){//到了叶子结点，直接删除
		int i = 0;
		while (i<pNode->keyNum&&key>pNode->key[i])
			i++;
		if (i < pNode->keyNum&&key == pNode->key[i]){
			while (i < pNode->keyNum - 1){
				pNode->key[i] = pNode->key[i + 1];
				i++;
			}
			pNode->keyNum--;
		}
		else {
			cout << "not found!" << endl;
		}
	}
	else {
		int i = 0;
		while (i < pNode->keyNum&&key > pNode->key[i])//找到第一个大于等于key的关键字
			i++;
		if (i < pNode->keyNum&&key == pNode->key[i]){//在结点中找到要删除的关键字
			struct BTNode* pNode1 = pNode->child[i];
			struct BTNode* pNode2 = pNode->child[i + 1];
			if (pNode1->keyNum >= M){//如果关键字左边的孩子结点的关键字数大于等于M
				int target = predecessor(pNode1);//将其前继结点移到pNode中
				pNode->key[i] = target;
				RemoveNonLess(pNode1, target);//递归删除target
			}
			else if (pNode2->keyNum >= M){//右边，同理
				int target = successor(pNode2);
				pNode->key[i] = target;
				RemoveNonLess(pNode2, target);
			}
			else {
				merge(pNode, pNode1, pNode2, i);//都小于M，合并
				RemoveNonLess(pNode1, key);
			}
		}
		else {//不在此结点中
			struct BTNode *pNode1 = pNode->child[i];
			struct BTNode *pNode0 = NULL;
			struct BTNode *pNode2 = NULL;
			if (i>0)
				pNode0 = pNode->child[i - 1];//左结点
			if (i < pNode->keyNum)
				pNode2 = pNode->child[i + 1];//右结点
			if (pNode1->keyNum == M - 1){//如果要删除的孩子结点关键字个数为M-1
				if (i > 0 && pNode0->keyNum >= M){//如果左邻结点至少有M个关键字，向其借一个
					ExchangeLeftNode(pNode, pNode0, pNode1, i - 1);
				}
				else if (i < pNode->keyNum&&pNode2->keyNum >= M){//同理，
					ExchangeRightNode(pNode, pNode1, pNode2, i);
				}
				else if (i>0){//两个相邻结点都只有M-1个关键字，合并
					merge(pNode, pNode0, pNode1, i - 1);
					pNode1 = pNode0;
				}
				else{
					merge(pNode, pNode1, pNode2, i);
				}
				RemoveNonLess(pNode1, key);

			}
			else{
				RemoveNonLess(pNode1, key);
			}
		}
	}
}

 
BTree::BTNode* BTree::search(int key, int &index)
{
	return Search(root, key, index);
}

 
void BTree::insert(int key)
{
	struct BTNode* r = root;
	if (root->keyNum == 2 * M - 1){//根节点特殊处理，如果根节点关键字个数为2*M-1，
		struct BTNode* pNode = new BTNode();//新建一个结点作为新的根节点，并将现在的根节点作为
		root = pNode;//新根节点的孩子结点
		pNode->isLeaf = false;
		pNode->keyNum = 0;
		pNode->child[0] = r;
		SplitChild(pNode, 0, r);//孩子结点r有2*M-1个关键字
		InsertNonFull(pNode, key);
	}
	else
		InsertNonFull(r, key);
}

 
void BTree::remove(int key)
{
	if (root->keyNum == 1){//如果根节点只有两个孩子
		struct BTNode* pNode1 = root->child[0];
		struct BTNode* pNode2 = root->child[1];
		if (pNode1->keyNum == M - 1 && pNode2->keyNum == M - 1){//且两个孩子都只有M-1个关键字，合并
			merge(root, pNode1, pNode2, 0);
			delete root;
			root = pNode1;
		}
		else {
			RemoveNonLess(root, key);
		}
	}
	else {
		RemoveNonLess(root, key);
	}
}

 
void BTree::PrintRow()
{
	struct BTNode* pNode;
	queue<struct BTNode*> q;
	q.push(root);
	while (!q.empty()){
		pNode = q.front();
		q.pop();
		cout << "[ ";
		for (int i = 0; i < pNode->keyNum; i++)
			cout << pNode->key[i] << " ";
		cout << "]" << endl;
		if (pNode->isLeaf)
			continue;
		for (int i = 0; i <= pNode->keyNum; i++)
			q.push(pNode->child[i]);
	}
}

int main(void)
{
	BTree tree;
	tree.insert('c');
	tree.insert('n');
	tree.insert('g');
	tree.insert('a');
	tree.insert('h');
	tree.insert('e');
	tree.insert('k');
	tree.insert('q');
	tree.insert('m');
	tree.insert('f');

	tree.insert('w');
	tree.insert('l');
	tree.insert('t');
	tree.insert('z');
	tree.insert('d');
	tree.insert('p');
	tree.insert('r');
	tree.insert('x');
	tree.insert('y');
	tree.insert('s');
	tree.remove('n');
	tree.remove('b');
	tree.PrintRow();

}


好吧，其实我只是把前面的c代码封装了一下，依旧是参考了《算法导论》以及http://blog.chinaunix.net/uid-20196318-id-3030529.html

uniquever
关注
专栏目录
B+树C++的实现
southekaer的博客
01-12 1359
1 找到节点中中间位置以及关键字，这个中间位置的关键字后面是需要插入到父节点中，如分裂的节点是根节点则需要创新一个新的根节点存放这个中间位置的关键字。1 从最右侧开始比较，如果插入值小于当前关键词的值，则将当前关键词右移一位，并继续比较，直到对比完第一个关键词或对比到不小于的关键词，将插入值保存。遍历节点内关键词，跟3进行对比，小于3，继续跟2对比，比2小，继续跟1对比，比1小，结束遍历，插入在1的左边。1 将中间值4插入父节点中，查询到此节点的父节点，并插入，如果父节点也需要分裂，则先递归分裂父节点。
B树的实现（C++）
07-16
网上很多程序没有注释，代码运行报错。所以精心重写了一下B树的实现。程序结构严谨，有详细的注释，运行没有问题，基于vs2013平台。对于刚学算法的人应该会有很大帮助。
b树的实现
u012637838的专栏
05-03 657
#include #include #include #include #include #define M 2 using namespace std; struct BTNode{ int keyNum; int key[2*M-1]; //关键字数组 struct BTNode* child[2*M];//孩子结点数组 bool isLeaf; }; void D
B树的原理与实现(C++)
weixin_30273175的博客
04-20 512
B树的定义 一棵B树T是具有如下性质的有根树(根为root[T])： 1）每个结点x有如下域： a）n[x]，当前存储在结点x中的关键字个数； b）n[x]个关键字本身，以非降序存放，因此key1[x]≤key2[x]≤…≤keyn[x][x]； c）leaf[x]，是一个布尔值，如果x是叶子结点的话，则它为TRUE，如果x为一个内结点，则它为FA...
B树的C++实现
MBuger的博客
03-11 1100
简介和AVL树、RB树一样，B树也是一种搜索树结构，能够存储数据也可以对其进行排序。它的特点是结点可以有多余两个的子结点。但是他的优势在于处理大块数据的读写操作，因为在计算机中的存储体系当中，有一种叫做局部性的东西。他分为时间局部性和空间局部性。时间局部性：最近被访问的内存内容会很快再被访问； 空间局部性：靠近当前被访问内存的内存内容很快也会被访问。当在处理大块数据操作的时候B树的特性就可以减少定
B树算法的C++实现
10-24
B树算法的C++实现，B树算法的C++实现，B树算法的C++实现，B树算法的C++实现
B.rar_B+树_B+树 C++实现_B树_visual c
09-20
综上所述，这个压缩包提供了B+树的C++实现，包括核心的B+树操作以及示例代码，以及Visual C++项目文件，便于在Windows环境下编译和运行。通过学习这些代码，你可以深入了解B+树的内部工作机制及其在C++中的实现细节...
b树的C++实现
11-04
总的来说，B树的C++实现是一个涉及到数据结构和算法的重要练习，它能够帮助我们理解B树的工作原理，并提升我们的编程能力。通过理解和实现B树，我们可以更好地处理大数据量的场景，提高数据操作的效率。
B+树C++简单实现
02-20
本文将深入探讨B+树的概念、结构及其C++实现，包括插入、删除和查找操作。 首先，B+树（B Plus Tree）是一种自平衡的多路搜索树，它能够保持数据有序，特别适合于大型数据存储，如数据库索引。其特点在于所有的...
B树插入代码C++实现
12-22
C++实现B树时，通常会定义一个BTreeNode类，包括键数组、子节点指针数组以及节点是否为叶子节点等属性。同时，还需要提供插入、查找、删除等操作的成员函数。为了便于理解和调试，可以使用递归方式实现这些操作，但...
B树、B+树的C++实现
07-05
B树、B+树的C++实现
B+树C++实现
06-08
B+树的C++实现版本 用法举例: /* * @param bkSize 区块大小,及每个数据块的大小,建议与硬盘的区块大小相同(一般为512或4096),此值不能过小否则会导致初始化失败. * @param filePath b+树关联的文件位置. * @...
B树算法与实现
IT民工之路
06-26 686
B树的定义 假设B树的度为t（t>=2），则B树满足如下要求：（参考算法导论） （1）  每个非根节点至少包含t-1个关键字，t个指向子节点的指针；至多包含2t-1个关键字，2t个指向子女的指针（叶子节点的子女为空）。 （2）  节点的所有key按非降序存放，假设节点的关键字分别为K[1], K[2] … K[n], 指向子女的指针分别为P[1], P[2]…P[n+1]，其中n为节点关键字
[C++] B树的简单实现
giturtle's blog
08-22 336
template<class K,size_t M = 1024> struct BTreeNode{ K _key[M]; BTreeNode<K,M>* _sub[M+1]; //多给一个方便分裂 BTreeNode<K,M>* _parent = nullptr; size_t _keysize; }; template<cl...
B树实现
u012954468的专栏
04-07 442
#include #include #define M 3 //2-3b树的实现 3阶b树 typedef struct btree{ int count;//结点中元素个数 即关键字个数 int element[M-1]; struct btree* next[M]; bool isLeaf;//增加一个是否是叶子结点判断 }*Btree; //打印 void print(Bt
B树的实现
qq_43390943的博客
04-17 1118
文章目录 #include <iostream> #include <time.h> using namespace std; //定义b树的阶数 const int m = 4; template<typename T> struct BTNode { BTNode<T>():keyNum(0),key(new T[m+1]),parent(...
C++实现B树
weixin_44628585的博客
08-22 1376
C++实现B树数据结构，包括创建，添加和删除的操作。
C++实现红黑树模板类
"这是一个C++实现的红黑树模板类，包含插入、删除和查找操作，以及旋转函数。" 红黑树是一种自平衡的二叉查找树（BST），它在进行插入和删除操作后能保持相对较好的平衡性，从而提供高效的查找、插入和删除性能。在...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值