B - 树原理复习及实现 C++

最新推荐文章于 2023-12-04 21:41:07 发布
最新推荐文章于 2023-12-04 21:41:07 发布
阅读量270 收藏
点赞数 1
分类专栏： 【数据结构】 【算法】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/paradox_1_0/article/details/103437546
版权

B 树又叫平衡多路查找树。一棵m阶的B树的特性如下：

  1. 树中每个结点最多含有m个孩子（m\geq 2）
  2. 除根结点和叶子结点外，其它每个结点至少有[ceil(m/2))]个孩子
  3. 若根结点不是叶子结点(不是空树)，则至少有2个孩子
  4. 所有叶子结点都出现在同一层，叶子结点不包含任何关键字信息(可以看做是外部接点或查询失败的接点，实际上这些结点不存在，指向这些结点的指针都为NULL)
  5. 每个非终端结点(最底层的非叶子节点)中包含有n个关键字信息：(n, P0, K1, P1, K2,......,Kn, Pn)。其中：

           

            a)  Ki (i=1...n)为关键字，且关键字按顺序升序排序K(i-1)< Ki

            b) Pi为指向子树根的接点，且指针Pi-1指向子树种所有结点的关键字均小于Ki，但都大于K(i-1)

            c) 关键字的个数n必须满足： [ceil(m/2) - 1)] \leqslant n\leqslant m -1

注：平衡m叉查找树是指每个关键字的左侧子树与右侧子树的高度差的绝对值不超过1的查找树，其结点结构与上面提到的B-树结点结构相同，由此可见，B-树是平衡m叉查找树，但限制更强，要求所有叶结点都在同一层。

下图演示的是一棵三阶B树：

                            

B树的查找： 

搜索B树与搜索二叉树很相似，只是在每个结点所做的不是二叉或者“两路”分支决定，二是根据该结点的子女数所做的多路分支决定。更准确的说，在每个内结点x处，要做n(x) + 1路的分支决定。

B树的插入：

插入操作是指插入一条记录，即（key, value）的键值对。如果B树中已存在需要插入的键值对，则用需要插入的value替换旧的value。若B树不存在这个key,则一定是在叶子结点中进行插入操作。

1）根据要插入的key的值，找到叶子结点并插入。

2）判断当前结点key的个数是否小于等于m-1，若满足则结束，否则进行第3步。

3）以结点中间的key为中心分裂成左右两部分，然后将这个中间的key插入到父结点中，这个key的左子树指向分裂后的左半部分，这个key的右子支指向分裂后的右半部分，然后将当前结点指向父结点，继续进行第3步。

向B树中插入关键字，同二叉查找树中插入一个关键字类似，要查找插入新关键字的叶子结点位置。因为不能把关键字插入到一个已满的终端结点中，故需要将一个已满的结点按其中间关键字分裂成两个结点，中间关键字被提升到该结点的父结点中。但是这种满结点的分裂动作会沿着树向上传播。为了解决这个问题，可以采取这样一种策略：当沿着树根往下查找新关键字所属位置时，就沿途分裂遇到的每个满结点。因此，每当要分裂一个满结点时，就能确保它的父结点不是满的。

B树的删除：

删除操作是指，根据key删除记录，如果B树中的记录中不存对应key的记录，则删除失败。

1）如果当前需要删除的key位于非叶子结点上，则用后继key（这里的后继key均指后继记录的意思）覆盖要删除的key，然后在后继key所在的子支中删除该后继key。此时后继key一定位于叶子结点上，这个过程和二叉搜索树删除结点的方式类似。删除这个记录后执行第2步

2）该结点key个数大于等于ceil(m/2))-1，结束删除操作，否则执行第3步。

3）如果兄弟结点key个数大于ceil(m/2))-1，则父结点中的key下移到该结点，兄弟结点中的一个key上移，删除操作结束。

否则，将父结点中的key下移与当前结点及它的兄弟结点中的key合并，形成一个新的结点。原父结点中的key的两个孩子指针就变成了一个孩子指针，指向这个新结点。然后当前结点的指针指向父结点，重复上第2步。

有些结点它可能即有左兄弟，又有右兄弟，那么我们任意选择一个兄弟结点进行操作即可。

C++实现 

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<iostream>

using namespace std;

template<class T>
class CBTree
{
private:
	static const int M = 3;					  //B树的最小度数
	static const int KEY_MAX = 2 * M - 1;     //节点包含关键字的最大个数
	static const int KEY_MIN = M - 1;         //非根节点包含关键字的最小个数
	static const int CHILD_MAX = KEY_MAX + 1; //孩子节点的最大个数
	static const int CHILD_MIN = KEY_MIN + 1; //孩子节点的最小个数

	struct Node
	{
		bool isLeaf;             //是否是叶子节点
		int keyNum;              //节点包含的关键字数量
		T keyValue[KEY_MAX];     //关键字的值数组
		Node* pChild[CHILD_MAX]; //子树指针数组

		Node(bool b = true, int n = 0)
			:isLeaf(b), keyNum(n) {}
	};

public:
	/* 创建一棵空的B树 */
	CBTree() {
		m_pRoot = NULL;
	}

	~CBTree() {
		clear();
	}

	/* 向B数中插入新结点key */
	bool insert(const T& key)
	{
		if (contain(key)) {  // 检查该关键字是否已经存在
			return false;
		}
		else {

			if (m_pRoot == NULL) {	// 检查是否为空树
				m_pRoot = new Node();
			}

			if (m_pRoot->keyNum == KEY_MAX) { // 检查根节点是否已满

				Node* pNode = new Node();  // 创建新的根节点
				pNode->isLeaf = false;
				pNode->pChild[0] = m_pRoot;

				splitChild(pNode, 0, m_pRoot);
				m_pRoot = pNode;  //更新根节点指针
			}

			insertNonFull(m_pRoot, key);
			return true;
		}
	}

	bool remove(const T& key)    //从B中删除结点key
	{
		if (!search(m_pRoot, key))  //不存在
		{
			return false;
		}
		if (m_pRoot->keyNum == 1)//特殊情况处理
		{
			if (m_pRoot->isLeaf)
			{
				clear();
				return true;
			}
			else
			{
				Node* pChild1 = m_pRoot->pChild[0];
				Node* pChild2 = m_pRoot->pChild[1];
				if (pChild1->keyNum == KEY_MIN && pChild2->keyNum == KEY_MIN)
				{
					mergeChild(m_pRoot, 0);
					deleteNode(m_pRoot);
					m_pRoot = pChild1;
				}
			}
		}
		recursive_remove(m_pRoot, key);
		return true;
	}
	void display()const //打印树的关键字
	{
		displayInConcavo(m_pRoot, KEY_MAX * 10);
	}
	bool contain(const T& key)const   //检查该key是否存在于B树中
	{
		return search(m_pRoot, key);
	}
	void clear()                      //清空B树
	{
		recursive_clear(m_pRoot);
		m_pRoot = NULL;
	}
private:
	//删除树
	void recursive_clear(Node* pNode)
	{
		if (pNode != NULL)
		{
			if (!pNode->isLeaf)
			{
				for (int i = 0; i <= pNode->keyNum; ++i)
					recursive_clear(pNode->pChild[i]);
			}
			deleteNode(pNode);
		}
	}

	//删除节点
	void deleteNode(Node*& pNode)
	{
		if (pNode != NULL)
		{
			delete pNode;
			pNode = NULL;
		}
	}

	//查找关键字
	bool search(Node* pNode, const T& key)const
	{
		if (pNode == NULL)  //检测节点指针是否为空，或该节点是否为叶子节点
		{
			return false;
		}
		else
		{
			int i;
			for (i = 0; i<pNode->keyNum && key>* (pNode->keyValue + i); ++i)//找到使key<=pNode->keyValue[i]成立的最小下标i
			{
			}
			if (i < pNode->keyNum && key == pNode->keyValue[i])
			{
				return true;
			}
			else
			{
				if (pNode->isLeaf)   //检查该节点是否为叶子节点
				{
					return false;
				}
				else
				{
					return search(pNode->pChild[i], key);
				}
			}
		}
	}

	//分裂子节点
	void splitChild(Node* pParent, int nChildIndex, Node* pChild)
	{
		/* 将pChild分裂成pLeftNode和pChild两个节点 */
		Node* pRightNode = new Node();
		pRightNode->isLeaf = pChild->isLeaf;
		pRightNode->keyNum = KEY_MIN;

		/* 拷贝关键字的值 */

		int i;
		for (i = 0; i < KEY_MIN; ++i) {
			pRightNode->keyValue[i] = pChild->keyValue[i + CHILD_MIN];
		}

		/* 如果不是叶子节点，拷贝孩子节点指针 */

		if (!pChild->isLeaf) {

			for (i = 0; i < CHILD_MIN; ++i) {
				pRightNode->pChild[i] = pChild->pChild[i + CHILD_MIN];
			}
		}

		/* 更新左子树的关键字个数 */
		pChild->keyNum = KEY_MIN;

		/* 将父节点中的nChildIndex后的所有关键字的值和子树指针向后移一位 */
		for (i = pParent->keyNum; i > nChildIndex; --i) {

			pParent->pChild[i + 1] = pParent->pChild[i];
			pParent->keyValue[i] = pParent->keyValue[i - 1];
		}

		++pParent->keyNum;  //更新父节点的关键字个数
		pParent->pChild[nChildIndex + 1] = pRightNode;  //存储右子树指针
		pParent->keyValue[nChildIndex] = pChild->keyValue[KEY_MIN];//把节点的中间值提到父节点
	}

	/* 在非满节点中插入关键字 */
	void insertNonFull(Node* pNode, const T& key)
	{
		int i = pNode->keyNum;
		if (pNode->isLeaf) {

			while (i > 0 && key < pNode->keyValue[i - 1]) {

				pNode->keyValue[i] = pNode->keyValue[i - 1];
				--i;
			}

			pNode->keyValue[i] = key;
			++pNode->keyNum;
		}
		else {

			while (i > 0 && key < pNode->keyValue[i - 1]) --i;

			Node* pChild = pNode->pChild[i];
			if (pChild->keyNum == KEY_MAX) {

				splitChild(pNode, i, pChild);
				if (key > pNode->keyValue[i])
					pChild = pNode->pChild[i + 1];
			}

			insertNonFull(pChild, key);
		}
	}

	/* 显示B树 */
	void displayInConcavo(Node* pNode, int count)const
	{
		if (pNode != NULL)
		{
			int i, j;
			for (i = 0; i < pNode->keyNum; ++i)
			{
				if (!pNode->isLeaf)
				{
					displayInConcavo(pNode->pChild[i], count - 2);
				}
				for (j = count; j >= 0; --j)
				{
					cout << "-";
				}
				cout << pNode->keyValue[i] << endl;
			}
			if (!pNode->isLeaf)
			{
				displayInConcavo(pNode->pChild[i], count - 2);
			}
		}
	}

	/* 合并两个子节点 */
	void mergeChild(Node* pParent, int index)
	{
		Node* pChild1 = pParent->pChild[index];
		Node* pChild2 = pParent->pChild[index + 1];

		pChild1->keyNum = KEY_MAX;
		pChild1->keyValue[KEY_MIN] = pParent->keyValue[index];//将父节点index的值下移

		int i;
		for (i = 0; i < KEY_MIN; ++i) {
			pChild1->keyValue[i + KEY_MIN + 1] = pChild2->keyValue[i];
		}

		if (!pChild1->isLeaf) {

			for (i = 0; i < CHILD_MIN; ++i) {
				pChild1->pChild[i + CHILD_MIN] = pChild2->pChild[i];
			}
		}

		/* 父节点删除index的key，index后的往前移一位 */
		--pParent->keyNum;
		for (i = index; i < pParent->keyNum; ++i) {

			pParent->keyValue[i] = pParent->keyValue[i + 1];
			pParent->pChild[i + 1] = pParent->pChild[i + 2];
		}

		deleteNode(pChild2);
	}

	//递归的删除关键字
	void recursive_remove(Node* pNode, const T& key)
	{
		int i = 0;
		while (i<pNode->keyNum && key>pNode->keyValue[i])
			++i;

		/* 关键字key在节点pNode中 */
		if (i < pNode->keyNum && key == pNode->keyValue[i])
		{
			/* pNode是个叶节点 */
			if (pNode->isLeaf) {

				/* 从pNode中删除k */
				--pNode->keyNum;
				for (; i < pNode->keyNum; ++i) {
					pNode->keyValue[i] = pNode->keyValue[i + 1];
				}

				return;
			}
			else {	//pNode是个内节点

				/* 节点pNode中前于key的子节点 */
				Node* pChildPrev = pNode->pChild[i];
				/* 节点pNode中后于key的子节点 */
				Node* pChildNext = pNode->pChild[i + 1];

				/* 节点pChildPrev中至少包含CHILD_MIN个关键字 */
				if (pChildPrev->keyNum >= CHILD_MIN) {

					/* 获取key的前驱关键字 */
					T prevKey = getPredecessor(pChildPrev);
					recursive_remove(pChildPrev, prevKey);
					/* 替换成key的前驱关键字 */
					pNode->keyValue[i] = prevKey;
					return;
				}
				else if (pChildNext->keyNum >= CHILD_MIN) {	//节点pChildNext中至少包含CHILD_MIN个关键字

					/* 获取key的后继关键字 */
					T nextKey = getSuccessor(pChildNext);
					recursive_remove(pChildNext, nextKey);
					/* 替换成key的后继关键字 */
					pNode->keyValue[i] = nextKey;
					return;
				}
				else {

					/* 节点pChildPrev和pChildNext中都只包含CHILD_MIN-1个关键字 */

					mergeChild(pNode, i);
					recursive_remove(pChildPrev, key);
				}
			}
		}
		else {	//关键字key不在节点pNode中

			/* 包含key的子树根节点 */
			Node* pChildNode = pNode->pChild[i];

			/* 只有t-1个关键字 */
			if (pChildNode->keyNum == KEY_MIN) {

				/* 左兄弟节点 */
				Node* pLeft = i > 0 ? pNode->pChild[i - 1] : NULL;
				/* 右兄弟节点 */
				Node* pRight = i < pNode->keyNum ? pNode->pChild[i + 1] : NULL;


				/* 左兄弟节点至少有CHILD_MIN个关键字 */
				int j;
				if (pLeft && pLeft->keyNum >= CHILD_MIN) {

					/* 父节点中i-1的关键字下移至pChildNode中 */
					for (j = pChildNode->keyNum; j > 0; --j) {
						pChildNode->keyValue[j] = pChildNode->keyValue[j - 1];
					}

					pChildNode->keyValue[0] = pNode->keyValue[i - 1];

					if (!pLeft->isLeaf) {

						/* pLeft节点中合适的子女指针移植到pChildNode中 */
						for (j = pChildNode->keyNum + 1; j > 0; --j) {
							pChildNode->pChild[j] = pChildNode->pChild[j - 1];
						}

						pChildNode->pChild[0] = pLeft->pChild[pLeft->keyNum];
					}

					++pChildNode->keyNum;
					/* pLeft节点中的最大关键字上升到pNode中 */
					pNode->keyValue[i] = pLeft->keyValue[pLeft->keyNum - 1];
					--pLeft->keyNum;
				}
				else if (pRight && pRight->keyNum >= CHILD_MIN) {	//右兄弟节点至少有CHILD_MIN个关键字

					/* 父节点中i的关键字下移至pChildNode中 */
					pChildNode->keyValue[pChildNode->keyNum] = pNode->keyValue[i];
					++pChildNode->keyNum;
					/* pRight节点中的最小关键字上升到pNode中 */
					pNode->keyValue[i] = pRight->keyValue[0];

					--pRight->keyNum;
					for (j = 0; j < pRight->keyNum; ++j) {
						pRight->keyValue[j] = pRight->keyValue[j + 1];
					}

					if (!pRight->isLeaf) {

						/* pRight节点中合适的子女指针移植到pChildNode中 */
						pChildNode->pChild[pChildNode->keyNum] = pRight->pChild[0];
						for (j = 0; j <= pRight->keyNum; ++j) {
							pRight->pChild[j] = pRight->pChild[j + 1];
						}
					}
				}
				else if (pLeft) {	//与左兄弟合并

					mergeChild(pNode, i - 1);
					pChildNode = pLeft;
				}
				else if (pRight) {	//与右兄弟合并
					mergeChild(pNode, i);
				}
			}
			recursive_remove(pChildNode, key);
		}
	}

	/* 找到前驱关键字 */
	T getPredecessor(Node* pNode)
	{
		while (!pNode->isLeaf) {
			pNode = pNode->pChild[pNode->keyNum];
		}

		return pNode->keyValue[pNode->keyNum - 1];
	}

	/* 找到后继关键字 */
	T getSuccessor(Node* pNode)
	{
		while (!pNode->isLeaf) {
			pNode = pNode->pChild[0];
		}

		return pNode->keyValue[0];
	}

private:
	Node* m_pRoot;  //B树的根节点
};


int main(int argc, char* argv[])
{
	CBTree<int> m_btree;
	m_btree.insert(10);
	m_btree.insert(14);
	m_btree.insert(19);
	m_btree.insert(33);
	m_btree.insert(22);
	m_btree.insert(2);
	m_btree.insert(56);
	m_btree.insert(78);
	m_btree.insert(45);
	m_btree.insert(16);
	m_btree.insert(37);
	m_btree.insert(65);
	m_btree.insert(61);

	m_btree.display();
	return 0;
}

B-树的应用

为了将大型数据库文件存储在硬盘上，以减少访问硬盘次数为目的，在此提出了一种平衡多路查找树——B-树结构。由其性能分析可知它的检索效率是相当高的 为了提高B-树性能还有很多种B-树的变型，力图对B-树进行改进，比如B+树。 

其它可供参考的博文：

https://www.jianshu.com/p/7dedb7ebe033

https://www.cnblogs.com/nullzx/p/8729425.html

paradox_1_0
关注
专栏目录
C++B树
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-28 526
B 树（B-tree）、B+ 树（B±tree） 特点 •一般化的二叉查找树（binary search tree） •“矮胖”，内部（非叶子）节点可以拥有可变数量的子节点（数量范围预先定义好） 应用 •大部分文件系统、数据库系统都采用B树、B+树作为索引结构 区别 •B+树中只有叶子节点会带有指向记录的指针（ROWID），而B树则所有节点都带有，在内部节点出现的索引项不会再出现在叶子节点中。 •B+树中所有叶子节点都是通过指针连接在一起，而B树不会。 B树的优点 对于在内部节点的数据，可直接得到，不必根据
2024年03月CCF-GESP编程能力等级认证C++编程五级真题解析
人生就是一个不断学习的过程
03-28 959
第 1 题 唯一分解定理描述的内容是（ ）？ A. 任意整数都可以分解为素数的乘积 B. 每个合数都可以唯一分解为一系列素数的乘积 C. 两个不同的整数可以分解为相同的素数乘积 D. 以上都不对
B树算法与实现
IT民工之路
06-26 665
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为节点关键字
b树 c++
iwonako的博客
07-22 96
#include<queue> template<class K,int M = 3> struct BTreeNode {//M阶b树 K _key[M];//从0开始，M-1用于溢出时暂时存放 BTreeNode<K, M>* _sub[M + 1];//子树指针，从0开始，M+1暂时存放 BTreeNode<K, M>* _parent; size_t _keynum;//关键字个数 BTree...
C++ B树
nightwizard2030的博客
08-21 897
写了红黑树之后再写B树，可谓是轻松了不少，毕竟B树的分类情况比红黑树少太多。当然从效率上来说，我这个版本的B树实现效率肯定不是最高的，我是先删除移动后再做平衡，其实可以通过标识的方法在平衡里覆盖掉需要删除的点即可。当然写的时候为了思路更清晰，我并没有这样去写。还有个原因主要是，B树真的就是一种思路，就是通过这种结构算法，建立文件系统，从而大量数据搜索的时候，可以接近二分搜索的时间复杂度，优点就在于
2021-4-5 C++程序设计原理与实践复习
qq_43615422的博客
04-05 265
C++程序设计原理与实践复习 人类读/写：源代码，程序文本 : .cpp .h 计算机可以执行：可执行代码、目标代码、机器代码 : .obj(windows中） .o（Unix中） “” ，其中”用来终止字符串 编译器将源代码转换为目标代码。 #include "std_lib_facilities.h" int main() { //C++从main函数开始执行 cout << "Hello,World!\n"; //输出Hello,World! return 0; } 其中1
大学生C语言学习必备---期末复习利器（不挂科)
08-20
C语言是计算机科学领域的一种基础编程语言，尤其对于初学者来说，它是理解计算机工作原理和程序设计思维的理想入口。在大学阶段，C语言是许多计算机专业必修的课程，也是许多非计算机专业学生提升技术能力的选择。这...
2020傲梦第二届等级测评复习资料（C++三级）
最新发布
04-15
### 2020傲梦第二届等级测评复习资料（C++三级） #### 一、基础知识梳理 ##### 进制与进制转换 - **进制介绍**：在计算机科学中，不同的进制被广泛用于数据表示。主要有四种常见的进制： - **十进制**（Decimal...
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
B树的实现（C++）
07-16
网上很多程序没有注释，代码运行报错。所以精心重写了一下B树的实现。程序结构严谨，有详细的注释，运行没有问题，基于vs2013平台。对于刚学算法的人应该会有很大帮助。
B树算法的C++实现
10-24
B树算法的C++实现，B树算法的C++实现，B树算法的C++实现，B树算法的C++实现
B树、B+树的C++实现
07-05
B树、B+树的C++实现
B树的C++源代码及测试代码
11-05
使用方法： #include <string h> #include <stdio h> #include "DataTypeForBtree h" #include "BTree h" struct tree data { char tid[37]; char tname[63]; unsigned int aid; unsigned int id; }; class CMyDataTypeForBtree : public CDataTypeForBtree { public: virtual void Print void key FILE fp { if NULL key || NULL fp return; struct tree data tr struct tree data key; fprintf fp "%u %u %s %s n" tr >id tr >aid tr >tid tr >tname ; } virtual int Compare void p1 void p2 { if NULL p1 || NULL p2 return int unsigned int 0 >> 1 ; 返回一个大点的数表示失败 struct tree data tr1 tr2; tr1 struct tree data p1; tr2 struct tree data p2; if tr2 >aid tr1 >aid { return tr1 >aid tr2 >aid; } if " 0" tr1 >tid[0] && " 0" tr2 >tid[0] { return strcmp tr1 >tname tr2 >tname ; } return strcmp tr1 >tid tr2 >tid ; } CMyDataTypeForBtree { } virtual CMyDataTypeForBtree { } }; int main int argc char argv[] { CMyDataTypeForBtree dt new CMyDataTypeForBtree; CBTree tree dt 5 ; struct tree data tr[101] {{"asd" "4Hero" 1 1} {"abc" "Underworld" 1 0} {"bac" "Samantha" 1 2} {"cass" "Gelka" 1 3} {"mark" "Clark"
B树的C++实现
wzh_xwjh的专栏
10-30 996
最近写一个程序需要用到 B 树，翻书看了下，参照网上的代码写了一个。对于 B 树的定义和生成有不少的文章讲过，我就不多废话，直接贴代码。 　　这里面主要包含两个类，CBTree 和 CDataTypeForBtree，其余几个是测试用的。B 树的实现类 CBTree 里面，关键字实际保存的是地址，虽然也可以保存无符号整数，但显然这不是我的初衷，我想让这一个 B 树类能够处理不同类型的数据
C++数据结构：B树
weixin_43908419的博客
12-04 1859
索引，就是通过某些关键信息，让用户可以快速找到某些事物，例如通过目录，我们就可以快速检索到一本书中特定的内容所在的页码。B/B+最普遍的用途，就是做索引。索引（index）是帮助MySQL高效获取数据的数据结构。当数据量很大的时候，为了方便数据的管理、提高检索效率，通常会将数据保存至数据库。数据库不仅仅要存储数据，还要维护特定的数据结构和一些高效的搜索算法，以帮助用户快速引用到某些数据。这种实现快速查找的数据结构，就是索引。
C++ 数据结构B 树
cat_fish_rain的博客
07-04 971
当数据量很大时，为了能够方便管理数据，提高数据查询的效率，一般都会选择将数据保存到数据库，因此数据库不仅仅是帮助用户管理数据，而且数据库系统还维护着满足特定查找算法的数据结构，这些数据结构以某种方式引用数据，这样就可以在这些数据结构上实现高级查找算法，该数据结构就是索引。树的性质，需要对该节点进行分裂：申请新节点找到该节点的中间位置将该节点中间位置右侧的元素以及其孩子搬移到新节点中,将中间位置元素以及新节点往该节点的双亲节点中插入，即继续4。所有关键字都出现在叶子节点的链表中，且链表中的节点都是有序的。
B树算法实现(c++)
sinat_38230425的博客
02-16 493
这里推荐一篇图文并茂的好文章, B树、B+树、B*树 这里我实现代码过于粗糙，应该有很多地方可以改进， 另外我并没有实现b+树以及b*树，但其实应该也不复杂，无非是在struct增加指向兄弟结点的指针，应该也容易实现: /* * B 树 * */ #include "iostream" #include "vector" #include <cstring> #include &l...
B树的C++代码实现
yantingtao_sunny的博客
04-24 5737
//这是我在学数据库时写的C++的B树的实现. B树有四个性质: 1.树中每个节点最多含有2m-1的节点; 2.除了根节点外,其他每个节点至少有m-1个孩子; 3.若根节点不是叶子节点则至少有2个孩子(即整个树只有根节点); 4.所有叶子节点都在同一层 #include using namespace std; static const int m = 3; //定义最小度为3 s
C++静态生存期详解与基本数据类型复习
静态生存期在C++编程中是一种特殊的对象生命周期，它与程序的整个运行期保持一致，直到程序结束才会被销毁。在C++中，这种类型的对象...复习这一章节时，务必注意理解内存分配原理、运算符优先级以及语句间的逻辑关系。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值