B-树原理以及代码实现 C/C++

最新推荐文章于 2024-05-13 21:18:28 发布
最新推荐文章于 2024-05-13 21:18:28 发布
阅读量1k 收藏 11
点赞数 1
分类专栏： 数据结构 文章标签： 算法 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34764432/article/details/107476622
版权

B树的用途

B树在用途是很普遍的，常见的数据库mysql，sqlite都用到了B树。总的来讲，B树主要是用于大规模的搜索，其层高固定的性质，提高了搜索的效率，降低了复杂度。B树是一种外存数据结构，也就是用到外部磁盘的时候，会用到B树。因此磁盘的每一次寻址都是一次时间消耗，常规的二叉查找树如果数据量很大的话，树的层高就很高，从而增加了磁盘寻址的时间消耗，B树使层高固定在横向添加关键字索引方便查找，并且也降低了查找树时磁盘寻址的次数。

B树的性质

一个m阶的B树需要满足以下性质：

  1. 每个结点最多包含m个孩子（m>=2）
  2. 叶子结点的层高都一致
  3. 除了根结点和子结点外，每个结点的元素必须大于等于m/2个
  4. 如果根结点不是叶子结点，则至少有两个孩子
  5. 每个非终端结点中包含n个关键字：
    （1）ki为关键字，从头到尾按照升序排序
    （2）pi为关键字之间的接点，指向子树根，pi指向的子树上的元素大小在k(i-1)到k(i)之间
    （3）结点上的n个关键字，n必须满足m/2-1 <= n <= m-1
    还有一种是以度(一个结点能包含的最少的关键字数)表示的B-树。那么每个结点最多就可以包含2m-1个关键字，最多包含2m个孩子结点。

B树的定义

我在代码中经常这样定义B树的结点：

#define KEY_VALUE int
typedef struct btree_node {
    KEY_VALUE* keys;  // 结点的关键字的集合
    struct btree_node* childrens[];  // 结点的子结点的指针数组
    int num;   // 结点的关键字的个数
    int leaf;    // 是否是叶子结点  1:叶子结点 0:非叶子结点
} btree_node;
typedef struct btree {
    btree_node* root;
    int degree;  // B树的度
} btree;

结点的定义相对来说比较简单，主要包含关键字的集合，指向孩子的指针数组，关键字的个数以及是否是叶子结点。其中是否是叶子结点这个参数比较重要，因为需要带入来判断我们是否是叶子结点，叶子结点和非叶子结点的操作是不一样的。

B树结点的创建

创建一个结点是比较简单的，有了上面的数据结构，我们只要对每一个值进行初始化就可以。

btree_node* btree_create_node(int t, int leaf)
{
    btree_node* node = (btree_nbode*)calloc(1, sizeof(btree_node));
    if (node == NULL) {
		return;
    }
    node->keys = (KEY_VALUE*)calloc(1, (2 * t -1) * sizeof(KEY_VALUE));
    if (node->keys == NULL) {
    	free(node);
    	return;
    }
    node->childrens = (btree_node**)calloc(1, 2 * t * sizeof(btree_node*));
    if (node->keys == NULL) {
    	free(node->keys);
    	free(node);
    	return;
    }
    node->num = 0;
    node->leaf = leaf;
    return node;
}

B树的删除

有创建的话就会有删除。

void btree_delete_node(btree_node* node)
{
    if (node == NULL) {
		return;
	}
    if (node->keys) {
		free(node->keys);
	}
	if (node->childrens != NULL) {
		free(node->childrens);
    }
    free(node);
    return;
}

B树结点的插入

接下来的就是比较重点的部分了。B树的插入和删除。
在现有的B树中插入一个元素到子结点，其实此操作和二叉树的插入类似，从树的根开始遍历到适合当前元素插入的位置（比较元素和结点的key的大小）。但是B树的性质仍然需要满足，因此插入之前需要现在满足B树的性质，保证插入元素之后能够也能满足B树的性质。
那么我们怎样保证插入元素之前，B树的性质不被破坏呢？
这时候就需要采用我们传说中的拆分操作，将即将满的结点拆成两部分，前半部分保留在该结点中，后半部分放入创建的新结点中，中间的结点上移到父结点指针的后一个元素之前。如下图：
在这里插入图片描述
那么具体的步骤如下：
1. 初始化node作为根结点
2. 如果node不是叶子结点，找到node的下一个孩子y；如果y没满的话，将它作为新的结点x，找下一个孩子；如果满了就进行分裂操作，结点node指向结点y的两部分，如果key的值大于y结点的中间元素的值就插在右半边，key小于中间值则插在左半边。
3. 如果插入到叶子结点的话，由于之前从根结点一路走来肯定是满足B树的性质的，所以直接插入可以。

void btree_insert_notfull(btree* T, btree_node* node, KEY_VALUE key)
{
    if (node == NULL || T == NULL) {
		return;
	}
	int i = node->num - 1;
	if (node->leaf) {  // 插入到叶子结点上
		while (i >= 0 && node->keys[i] > key) {
			node->keys[i] = node->keys[i - 1];
			i--;
		}  // 找到第一个比key小的值，插到他的它一个位置
		node->keys[i++] = key;
		node->num++;  // 数量加1，由于加的树叶子结点，所以不用管子结点的指针数组，因为就是NULL；
	} else {
		while (i >= 0 && node->keys[i] > key) i--;  // 找到当前的结点
		if (node->childrens[i + 1]->num == 2 * T->degree - 1) {
			btree_splite_node(T, node, i);  // 如果当前的结点已经满了，则分裂
			if (key > node->keys[i + 1]) i++;  // 分裂完之后，如果子结点上移的结点小于key，那么就插到下一个子结点；如果大于key就插到当前的子结点
		}
		btree_insert_notfull(T, node->childrens[i + 1], key);
	}
}

void btree_insert(btree* T, int key)
{
    if (node == NULL || T == NULL) {
		return;
	}
	btree_node* node = T->root;
	if (node->num != 2 * T->degree - 1) {
		btree_insert_notfull(T, node, key);
	} else {
		// 如果根结点满的话，我们创建一个新的结点，将新的结点作为根结点
		btree_node* x = btree_create_node(T->degree, 0);
		T->root = x;
		x->childrens[0] = node;
		btree_splite_node(T, x, 0);
		// 分裂之后如果key小于上移的值，则到当前的子结点下面找，如果大于的话就到下一个子结点去找key的值。
		int j = 0;
		if (key > x->keys[0]) j++;
		btree_insert_notfull(T, x->childrens[j], key);
    }
}

void btree_splite_node(btree* T, btree_node* x, int key)
{
    int t = T->degree;
    btree_node* y = x->childrens[i];
    btree_node* z = btree_create_node(t, y->leaf);
    z->num = t - 1;
    int j = 0;
    // 创建z结点，将原结点的右半部分给z
    for (j = 0; j < t - 1; j++) {
	    z->keys[j] = y->keys[j + t];
	}
	if (!z->leaf) {
	    for (j = 0; j < t; j++) {
	        z->childrens[j] = y->childrens[j + t];
	    }
    }
    y->num = t - 1;
    // 将x结点的子结点指针以及关键字从后往前移，给上移的结点让出空间
    for (j = x->num; j >= i + 1; j--) {
		x->childrens[j + 1] = x->childrens[j];
    }
    x->chiledrens[i + 1] = z;
    for (j = x->num - 1; j >= i; j--) {
		x->keys[j + 1] = x->keys[j];
	}
	x->keys[j] = y->keys[t - 1];
    x->num++;
}

B树的删除

B树的删除
删除的操作比插入的操作要更加复杂，当然如果只是在叶子结点上进行删除，那就比较简单了。但如果在飞叶子结点上进行删除呢？我们需要考虑以下几种情况：

  1. 如果删除的关键字在叶子结点，那么直接删除k关键字

  2. 如果删除的关键字在当前的结点中，这是有需要分为3种情况：
    （1）如果位于要删除的关键字之前的孩子结点上至少有num个关键字，那么就将前一个子结点的最后一个关键字上移，然后删掉该关键字所占的内存。
    在这里插入图片描述

    （2）如果位于要删除的关键字之后的孩子结点至少有num个关键字，那么就将后一个子结点的第一个关键字上移，覆盖要删除的关键字，然后将子结点的该关键字删除。
    在这里插入图片描述
    （3）如果位于要删除关键字的前后两边的子结点的关键字个数没有t个，那么就需要合并两个子结点和父结点要删除的这个结点到左边的子结点，删除右边的子结点，然后在左边的子结点中删除关键字结点。
    在这里插入图片描述

  3. 如果删除的关键字在不在当前的结点中，则确定包含关键字的子树的根结点。
    （1）如果当前结点的兄弟结点都只包含t-1个关键字，将x的一个关键字移动至新的结点，使之合并为一个新的结点。图中描述的是和右兄弟结点合并，也可以和左兄弟结点合并
    在这里插入图片描述
    （2）如果当前结点仅包含t-1个关键字，但是兄弟结点至少有t个关键字，那么久先将父结点的某个关键字下移到当前的结点，然后将兄弟结点的一个关键字上移到父结点。图中表示的是右兄弟结点借，也可以向左兄弟结点借。
    在这里插入图片描述

void btree_merge_key(btree* T, btree_node* node, int idx)
{
    if (T->root == NULL || node == NULL) {
        return;
    }

    btree_node* left = node->childrens[idx];
    btree_node* right = node->childrens[idx + 1];

    left->keys[T->degree - 1] = node->keys[idx];
    for (int i = 0; i < T->degree - 1; i++) {
        left->keys[i + T->degree] = right->keys[i];
    }
    if (!left->leaf) {
        for (int i = 0; i < T->degree; i++) {
            left->childrens[i + T->degree] = right->keys[i];
        }
    }
    left->num += T->degree;

    btree_destory_node(right);

    for (int j = idx + 1; j < node->num; j++) {
        node->keys[j - 1] = node->keys[j];
        node->childrens[i] = node->childrens[i + 1];
    }
    node->keys[node->num - 1] = 0;
    node->childrens[node->num] = NULL;
    node->num--;

    if (!node->num) {
        T->root = left;
        btree_destory_node(node);
    }

}

void btree_delete_key(btree* T, btree_node* node, KEY_VALUE key)
{
    if (node == NULL) {
        return;
    }
    int idx = 0;
    while (idx < node->num && key > node->keys[idx]) { // 找到第一个大于key的值
        idx++;
    }
    if (idx < num && key == node->keys[idx]) {    // 如果找到了key
        if (node->leaf) {  // 所在结点为叶子结点
            for (int i = idx; i < node->num - 1; i++) {
                node->keys[i] = node->keys[i + 1];
            }
            node->keys[node->num - 1] = 0;
            node->num--;
            if (node->num == 0) {  // 如果为根结点的话直接删除
                free(node);
                T->root = 0;
            }
            return;
        } else {
            if (node->childrens[idx]->num >= T->degree) { // 如果子树可以借一个的话就问子树借
                node->keys[idx] = node->keys[node->num - 1];
                btree_delete_key(T, node->childrens[idx], node->keys[node->num - 1]);
            } else if (node->childrens[idx + 1]->num >= T->degree) { // 没有的话问下一个子树借
                node->keys[idx] = node->childrens[idx + 1]->keys[0];
                btree_delete_key(T, node->childrens[idx + 1], node->childrens[idx + 1]->keys[0]);
            } else { // 两边子树的关键字个数都没到T->degree的话，只能合并
                // 合并
                btree_merge_key(T, node, idx);
                btree_delete_key(T, node->childrens[idx], key);
            }
        }
    } else {
        btree_node* child = node->childrens[idx];
        if (node == NULL) {
            printf("no result\n");
            return;
        }
        if (child->num == T->degree - 1) { // 如果当前子结点不够借位
            btree_node* left = node->keys[idx - 1];
            btree_node* right = node->keys[idx + 1];
            if ((left && left->num >= T->degree) || // 问兄弟结点借，然后加到子结点的上面，再进行删除
                (right && right->num >= T->degree)) {
                int richR = 0;
                if (right) {
                    richR = 1;
                }
                if (left && right) {
                    richR = (right->num - left->num) ? 1 : 0;
                }

                if (right && right->num >= T->degree && richR) {
                    child->keys[child->num] = node->keys[idx];
                    child->childrens[child->num + 1] = right->childrens[0];
                    child->num += 1;

                    node->keys[idx] = right->keys[0];
                    for (int i = 0; i < right->num - 1; i++) {
                        right->keys[i] = right->keys[i + 1];
                        right->childrens[i] = right->childrens[i + 1];
                    }
                    right->keys[num - 1] = 0;
                    right->childrens[num - 1] = right->childrens[num];
                    right->childrens[num] = NULL;
                    right->num--; 
                } else {
                    for (int j = child->num; j > 0; j--) {
                        child->keys[j] = child->keys[j - 1];
                        child->childrens[j + 1] = child->childrens[j];
                    }
                    child->keys[0] = left->keys[left->num - 1];
                    child->childrens[1] = child->childrens[0];
                    child->childrens[0] = left->childrens[left->num];
                    child->num++;

                    left->childrens[left->num] = NULL;
                    left->keys[left->num - 1] = 0;
                    left->num--;
                }
            } else if ((!left || left->num == T->degree - 1) ||
                       (!right || right->num == T->degree - 1)) {
                if (left && left->num == T->degree - 1) {
                    btree_merge_key(T, node, idx -1);
                    child = left;
                } else if (right && right->num == T->degree - 1) {
                    btree_merge_key(T, node, idx);
                }

            }
        }
        btree_delete_key(T, child, key);
    }
}

int btree_delete(btree_node* T, KEY_VALUE key)
{
    if (!T->root) {
        return -1;
    }
    btree_delete_key(T, T->root, key);
    return 0;
}

B树的查找

B树的查找思路其实和二叉树的查找是一致的，从根结点开始遍历，对每个结点进行遍历，如果找到关键字则直接返回，在当前子结点未找到的话则找到关键字所在的子树继续向下查找，最后如果遍历到空结点还是未找到的话，说明没有该关键字。

int btree_node_search(btree_node* node, int key)
{
    if (T->root == NULL) {
		return -1;
    }
    int i = 0;
    while (i < n && key > node->keys[i]) {
		i++;
	}
    if (node->keys[i] == key) {
		return key;
	}
	if (node->leaf) {
		return -1;
	}
	return btree_node_search(node->childrens[i], key);
}

B树的中序遍历

B树的中序遍历也是和二叉树类似，遵循左->中->右的顺序进行。

void travelse(btree_node* x)
{
    int i = 0;
    for (i = 0; i < x->num; i++) { // 非叶子结点，先遍历左边子树的结点
		if (x->leaf == 0) {
			travelse(x->childrens[i]);
		}
		print("%d ", x->keys[i]);
	}
	if (x->leaf == 0) {    // 打印以最后一个孩子为根的子树
		travelse(x->keys[i]);
    }
}
chauneyWang
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C/C++ 树的基本概念
Black的博客
12-21 1925
1.理解二叉树 1.1基本概念 根节点；左子树指针，右子树指针，孩子结点，父结点，兄弟结点； 2.二叉树的遍历 #include <stdio.h> #include <stdlib.h> typedef struct treeNode { char data;//存放结点数据 struct treeNode* Lchild; struct treeNode* Rchild; }TREE,*LPTREE; //创建结点 LPTREE createNode(char data)
B树的C++代码实现
yantingtao_sunny的博客
04-24 5711
//这是我在学数据库时写的C++的B树的实现. B树有四个性质: 1.树中每个节点最多含有2m-1的节点; 2.除了根节点外,其他每个节点至少有m-1个孩子; 3.若根节点不是叶子节点则至少有2个孩子(即整个树只有根节点); 4.所有叶子节点都在同一层 #include using namespace std; static const int m = 3; //定义最小度为3 s
C++实现B树
weixin_44628585的博客
08-22 1288
C++实现B树数据结构，包括创建，添加和删除的操作。
B+树（C++实现）
weixin_30482181的博客
09-15 1731
定义： 一棵M（M>2）阶的B+树满足以下定义： 1.B+树中包含两种类型的结点：内结点和叶子结点。内结点存有关键字和孩子结点的指针，叶子结点存有关键字和数据； 2.每一个关键字都会在叶子结点中出现，叶子结点按照关键字的大小排序，叶子结点中会存有指向兄弟结点的指针； 3.一棵B+树一般存有两个指针：一个指向根结点，一个指向存有最小关键字的叶子结点； 4.每个...
C++ 实现的B树
最新发布
weixin_45142497的博客
05-13 281
B树的实现思虑以及具体的编码落地
【C++数据结构】B树概念及其实现（详解）
jhao的博客
07-21 2153
1970年，R.Bayer和E.mccreight提出了一种适合外查找的树，它是一种平衡的多叉树，称为B树。外查找即在不在内存当中查找，通常是在磁盘，磁盘数据通常挨着挨着存，所以只能通过建立索引的方式去找到对应的数据地址。由于AVL，红黑树的高度过高，采用这类数据结构会导致IO次数过多，所以我们通常选择层数更低的B树或者B+树。原理即是让每一层更多。并且B树天然平衡，呈现向右向上增长的趋势。B树的规则根节点至少有两个孩子既保持孩子比关键字多一个。.........
B-树 c++实现
huhu123444的博客
06-21 941
B-树是一种平衡查找树，主要用于数据库的查找中。 1.结构题定义： typedef struct BTNode {// treeNode int keynum;// the number of elements struct BTNode *parent;//point to keyType key[m+1];//elements,begin with 0 struct BTNode *child[m];//the points pointing to child of the node }
基于C++的抽象数据类型B树的实现
毕业作品网站
06-06 222
对某组具体的抽象数据类型，运用课程所学的知识和方法，设计合理的数据结构，并在此基础上实现该抽象数据类型的全部基本操作。通过本设计性实验，检验所学知识和能力，发现学习中存在的问题。 进而达到熟练地运用本课程中的基础知识及技术的目的。编程环境：Vs Code编程语言：C利用 C 语言数据类型表示 B 树的抽象数据类型，以及 B 树的抽象数据类型的实现。抽象数据类型树的定义：树的结构定义和树的一组基本操作B 树是一种平衡的多路查找树。一颗 m 阶 B 树，或为空树，或为满足下列特性的 m 叉树。 初始条件：结点
MinGW-w64 C/C++编译器+libsvm安装包.rar
05-09
C/C++编译器是软件开发的基础工具，它们将程序员编写的源代码转换成计算机可以执行的机器码。GCC通过解析源代码，进行语法分析、语义分析，然后生成中间代码，最后优化并生成可执行文件。MinGW-w64在Windows环境下，...
LT-1B-Programs.zip_单片机开发_C/C++_
08-11
标题“LT-1B-Programs.zip_单片机开发_C/C++_”指的是一个包含单片机开发项目，特别是针对MSP430系列单片机的C/C++源代码的压缩文件。这个文件很可能是为了帮助用户理解和学习如何使用C或C++语言进行MSP430单片机的...
SHA-1算法C++实现
03-10
在C++中实现SHA-1算法涉及到一系列步骤，包括初始化、消息填充、分组处理、循环计算以及结果组合。以下是对这些步骤的详细解释： 1. **初始化**： - SHA-1算法使用5个32位的寄存器A、B、C、D和E，初始值分别为：A0...
C/C++实现KNN算法（附说明文档）
01-29
KNN，全称为K-Nearest Neighbors，是一种基于实例的学习方法，属于监督学习的范畴。...通过理解和掌握KNN算法及其C/C++实现，开发者不仅可以深入理解机器学习的基本原理，还能锻炼编程技能，提升解决实际问题的能力。
C/C++ 数据结构
09-12
常见的树类型有二叉树、平衡树（如AVL树和红黑树）和搜索树（如B树和B+树）。树在计算机科学中有广泛的应用，如文件系统、数据库索引和图形算法等。二叉树是最简单的树形结构，每个节点最多有两个子节点。平衡树则...
C++【B树】【B+树】
芊樱烛渊的博客
12-28 953
相比于我们别的数据结构，我们的B树更加适合进行外查找B树也可以进行内查找，但是有一点浪费空间。
数据结构——B-树（c++）
weixin_48560325的博客
05-18 2552
简介 在计算机科学中，B树（英语：B-tree）是一种自平衡的树，能够保持数据有序。这种数据结构能够让查找数据、顺序访问、插入数据及删除的动作，都在对数时间内完成。B树，概括来说是一个一般化的二叉查找树（binary search tree），可以拥有多于2个子节点。与自平衡二叉查找树不同，B树为系统大块数据的读写操作做了优化。B树减少定位记录时所经历的中间过程，从而加快存取速度。B树这种数据结构可以用来描述外部存储。这种数据结构常被应用在数据库和文件系统的实现上。 定义 一颗m阶B-T...
索引的数据结构：B+Tree
qq_38074398的博客
12-12 300
关于MySQL的B+Tree索引的分析，示意图中主要以主键id索引为例。
B树的代码实现
一个小孩
04-16 914
B树的原理在这篇博客https://blog.csdn.net/xiaoan08133192/article/details/115622370中进行了介绍，这里是B树的代码实现。B树的插入和删除函数，在遍历的时候都是使用不回溯的方法，插入操作在对a结点插入数据的时，已经保证了a的关键字个数小于2*M - 1，删除操作在对a结点删除数据的时，已经保证了a的关键字个数大于M - 1。如何保证这一点是代码的精髓 //M为B树的最小度 #define M 2 typedef struct btree_node
B树详解(附代码)
qq_39454212的博客
12-03 1484
B树详解 1. B树的背景 当数据比较大，无法全部存入内存时，需要将部分数据存在外存中，在需要的时候读入内存，修改之后又写回外存。由于外存的速度与内存有几个数量级的差别，所以想要节省在外存上花的时间，必须提高搜索树的性能。 最常见的外存就是磁盘。磁盘是快设备，也就是说磁盘的读写单位是以块为单位，一般地块大小从0.5k到4k。即使你只读取一个字节，磁盘也是将包含该字节的所有数据读取到硬盘中。而在磁盘读取过程中，最占用时间的是磁盘的寻道，也就是磁头在盘片上找到需要读取的块所在位置的时间，而在盘片上顺序读取数据的
【BTree、B-树】B树的C++实现
ArchyLi
11-25 4085
一、B树的概念B树是平衡的多叉树，一个节点有多于两个（不能小于）结点的平衡多叉树。由于B树倒着生长所以平衡。缺点：浪费空间二、B树满足以下性质：1、根结点至少有两个孩子。[2，M]个孩子 2、每个非根结点有【（M/2），M】个孩子。 3、每个非根结点有【（M/2-1），M-1】个关键字，并且以升序排序。 4、每个结点孩 5、key[i]和key[i+1]之间的孩子节点的值介于key[i]、k
编译原理first集合原理以及C++代码如何实现
06-08
下面是一个用C++实现计算First集合的例子代码： ```cpp #include #include #include #include using namespace std; // 定义产生式结构体 struct Production { char left; string right; }; // 定义非终结...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值