B树 详解及C语言简单实现

已于 2022-10-03 22:10:58 修改
阅读量1.3k 收藏 14
点赞数
分类专栏： 数据结构与算法 文章标签： b树 数据结构 算法
于 2022-10-03 19:40:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52668274/article/details/127150957
版权

简介

  B树是一棵多路平衡搜索树，也称为B-树、B_树。其是一种自平衡树状数据结构，对存储的数据进行查找、插入和删除时间复杂度为O(log n)。B树一般较多用在存储系统上，比如数据库或文件系统。

B树（m 阶）特点：
1 每个节点最多有m个孩子
2 每个非叶子节点至少有ceil(m/2)个孩子，除了根节点
3 对于根节点，子树个数范围为[2,m]，节点内值的个数范围为[1,m-1]
4 对于非根节点，节点内的值个数范围为[ceil(m/2)-1,m-1]
5 根节点(非叶子节点)至少有两个孩子
6 所有叶子节点在同一层
7 节点内的值按照从小到大排列
8父节点的若干值作为分离值分成多个子树，左子树小于对应分离值，对应分离值小于右子树

B树的层次结构：
在这里插入图片描述

B树查找

B树的搜索和二叉搜索树类似，从根节点开始，从上往下递归的遍历树。在每一层节点上，使用二分查找法匹配目标键，或者通过键的范围来确定子树。
如下图（以4阶B树为例）

查找关键字8，则流程如下：
在这里插入图片描述

B树插入

对于新元素的插入，都是发生在叶子节点上的。所有的插入操作都是从根节点开始，搜索这棵树，并找到该元素应该被插入的节点。将新元素插入到该节点需要如下步骤：
1） 如果该节点上的元素数未满，则将新元素插入到该节点，并保持节点中元素的顺序。
如图：
在这里插入图片描述

2）如果该节点上的元素已满，则需要将该节点平均地分裂成两个节点：
从该节点中的元素和新元素先出一个中位数小于中位数的元素放到左边节点，大于中位数的元素放到右边节点，中位数做为分隔值。
分隔值被插入到父节点中（增加了树的高度），这可能会导致父节点的分裂，分裂父节点时又可能会使它的父节点分裂，以此类推。如果分裂一直上升到根节点，那么就创建一个新的根节点，它有一个分隔值和两个子节点。（这就是根节点并不像内部节点一样有最少子节点数量限制的原因）
如先插入key为44，首先找到目标节点，发现该节点元素已满，
在这里插入图片描述
此时我们发现该节点元素已满，按照规则此节点会进行分裂：
在这里插入图片描述

B树删除

B树的删除就复杂了许多，可分为下面几种情况：

删除叶子节点中的元素
1）搜索要删除的元素 --> 如果它在叶子节点上，直接将其删除
删除元素 11
在这里插入图片描述
2）如果删除后产生了下溢出（键数小于最小值），则向其兄弟节点借元素。即将其父节点元素下移至当前节点，将兄弟节点中元素上移至父节点（若是左节点，上移最大元素；若是右节点，上移最小元素）
在这里插入图片描述

4）若兄弟节点也达到下限，则合并兄弟节点与分割键。
删除内部节点中的元素 （1）内部节点中元素为其左右子节点的分割值，需要从左子节点最大元素或右子节点最小元素中选出一个新的分割符。被选中的分割符从原子节点中移除，作为新的分隔值替换掉被删除的元素。 （2）上一步中，若左右子节点元素数均达到下限，则合并左右子节点。 （3）若删除元素后，其中节点元素数小于下限，则继续合并。
在这里插入图片描述
删除非叶子节点中的元素
1）如果左子节点的键数超过最小值，则删除的内部节点将替换为中序前置节点。
如果右子节点的键数超过最小值，则删除的内部节点将替换为中序后置节点。
在这里插入图片描述
2) 如果任一子级的键数正好是最小的，则合并左子级和右子级。
在这里插入图片描述

  1. 在这种情况下，树的高度会缩小。如果目标键位于内部节点中，并且删除该键会导致节点中的键数量减少（即，少于所需的最小值），则查找中序前置和中序后置。如果两个子项都包含最少数量的键，则不能进行借用。这导致了第二种情况（2），即合并孩子。
    再说一遍，找兄弟同级借键。但是，如果同级也只有最少数量的键，则将节点与同级以及父级合并。把孩子们按顺序排列好。
    在这里插入图片描述
源代码


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

#include <assert.h>

#define DEGREE		3
typedef int KEY_VALUE;

typedef struct _btree_node {
	KEY_VALUE *keys;
	struct _btree_node **childrens;
	int num;
	int leaf;
} btree_node;

typedef struct _btree {
	btree_node *root;
	int t;
} btree;

btree_node *btree_create_node(int t, int leaf) {

	btree_node *node = (btree_node*)calloc(1, sizeof(btree_node));
	if (node == NULL) assert(0);

	node->leaf = leaf;
	node->keys = (KEY_VALUE*)calloc(1, (2*t-1)*sizeof(KEY_VALUE));
	node->childrens = (btree_node**)calloc(1, (2*t) * sizeof(btree_node));
	node->num = 0;

	return node;
}

void btree_destroy_node(btree_node *node) {

	assert(node);

	free(node->childrens);
	free(node->keys);
	free(node);
	
}


void btree_create(btree *T, int t) {
	T->t = t;
	
	btree_node *x = btree_create_node(t, 1);
	T->root = x;
	
}


void btree_split_child(btree *T, btree_node *x, int i) {
	int t = T->t;

	btree_node *y = x->childrens[i];
	btree_node *z = btree_create_node(t, y->leaf);

	z->num = t - 1;

	int j = 0;
	for (j = 0;j < t-1;j ++) {
		z->keys[j] = y->keys[j+t];
	}
	if (y->leaf == 0) {
		for (j = 0;j < t;j ++) {
			z->childrens[j] = y->childrens[j+t];
		}
	}

	y->num = t - 1;
	for (j = x->num;j >= i+1;j --) {
		x->childrens[j+1] = x->childrens[j];
	}

	x->childrens[i+1] = z;

	for (j = x->num-1;j >= i;j --) {
		x->keys[j+1] = x->keys[j];
	}
	x->keys[i] = y->keys[t-1];
	x->num += 1;
	
}

void btree_insert_nonfull(btree *T, btree_node *x, KEY_VALUE k) {

	int i = x->num - 1;

	if (x->leaf == 1) {
		
		while (i >= 0 && x->keys[i] > k) {
			x->keys[i+1] = x->keys[i];
			i --;
		}
		x->keys[i+1] = k;
		x->num += 1;
		
	} else {
		while (i >= 0 && x->keys[i] > k) i --;

		if (x->childrens[i+1]->num == (2*(T->t))-1) {
			btree_split_child(T, x, i+1);
			if (k > x->keys[i+1]) i++;
		}

		btree_insert_nonfull(T, x->childrens[i+1], k);
	}
}

void btree_insert(btree *T, KEY_VALUE key) {
	//int t = T->t;

	btree_node *r = T->root;
	if (r->num == 2 * T->t - 1) {
		
		btree_node *node = btree_create_node(T->t, 0);
		T->root = node;

		node->childrens[0] = r;

		btree_split_child(T, node, 0);

		int i = 0;
		if (node->keys[0] < key) i++;
		btree_insert_nonfull(T, node->childrens[i], key);
		
	} else {
		btree_insert_nonfull(T, r, key);
	}
}

void btree_traverse(btree_node *x) {
	int i = 0;

	for (i = 0;i < x->num;i ++) {
		if (x->leaf == 0) 
			btree_traverse(x->childrens[i]);
		printf("%C ", x->keys[i]);
	}

	if (x->leaf == 0) btree_traverse(x->childrens[i]);
}

void btree_print(btree *T, btree_node *node, int layer)
{
	btree_node* p = node;
	int i;
	if(p){
		printf("\nlayer = %d keynum = %d is_leaf = %d\n", layer, p->num, p->leaf);
		for(i = 0; i < node->num; i++)
			printf("%c ", p->keys[i]);
		printf("\n");
#if 0
		printf("%p\n", p);
		for(i = 0; i <= 2 * T->t; i++)
			printf("%p ", p->childrens[i]);
		printf("\n");
#endif
		layer++;
		for(i = 0; i <= p->num; i++)
			if(p->childrens[i])
				btree_print(T, p->childrens[i], layer);
	}
	else printf("the tree is empty\n");
}


int btree_bin_search(btree_node *node, int low, int high, KEY_VALUE key) {
	int mid;
	if (low > high || low < 0 || high < 0) {
		return -1;
	}

	while (low <= high) {
		mid = (low + high) / 2;
		if (key > node->keys[mid]) {
			low = mid + 1;
		} else {
			high = mid - 1;
		}
	}

	return low;
}


//{child[idx], key[idx], child[idx+1]} 
void btree_merge(btree *T, btree_node *node, int idx) {

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

	int i = 0;

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

	//destroy right
	btree_destroy_node(right);

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

	if (node->num == 0) {
		T->root = left;
		btree_destroy_node(node);
	}
}

void btree_delete_key(btree *T, btree_node *node, KEY_VALUE key) {

	if (node == NULL) return ;

	int idx = 0, i;

	while (idx < node->num && key > node->keys[idx]) {
		idx ++;
	}

	if (idx < node->num && key == node->keys[idx]) {

		if (node->leaf) {
			
			for (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) { //root
				free(node);
				T->root = NULL;
			}

			return ;
		} else if (node->childrens[idx]->num >= T->t) {

			btree_node *left = node->childrens[idx];
			node->keys[idx] = left->keys[left->num - 1];

			btree_delete_key(T, left, left->keys[left->num - 1]);
			
		} else if (node->childrens[idx+1]->num >= T->t) {

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

			btree_delete_key(T, right, right->keys[0]);
			
		} else {

			btree_merge(T, node, idx);
			btree_delete_key(T, node->childrens[idx], key);
			
		}
		
	} else {

		btree_node *child = node->childrens[idx];
		if (child == NULL) {
			printf("Cannot del key = %d\n", key);
			return ;
		}

		if (child->num == T->t - 1) {

			btree_node *left = NULL;
			btree_node *right = NULL;
			if (idx - 1 >= 0)
				left = node->childrens[idx-1];
			if (idx + 1 <= node->num) 
				right = node->childrens[idx+1];

			if ((left && left->num >= T->t) ||
				(right && right->num >= T->t)) {

				int richR = 0;
				if (right) richR = 1;
				if (left && right) richR = (right->num > left->num) ? 1 : 0;

				if (right && right->num >= T->t && richR) { //borrow from next
					child->keys[child->num] = node->keys[idx];
					child->childrens[child->num+1] = right->childrens[0];
					child->num ++;

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

					right->keys[right->num-1] = 0;
					right->childrens[right->num-1] = right->childrens[right->num];
					right->childrens[right->num] = NULL;
					right->num --;
					
				} else { //borrow from prev

					for (i = child->num;i > 0;i --) {
						child->keys[i] = child->keys[i-1];
						child->childrens[i+1] = child->childrens[i];
					}

					child->childrens[1] = child->childrens[0];
					child->childrens[0] = left->childrens[left->num];
					child->keys[0] = node->keys[idx-1];
					
					child->num ++;

					node->keys[idx-1] = left->keys[left->num-1];
					left->keys[left->num-1] = 0;
					left->childrens[left->num] = NULL;
					left->num --;
				}

			} else if ((!left || (left->num == T->t - 1))
				&& (!right || (right->num == T->t - 1))) {

				if (left && left->num == T->t - 1) {
					btree_merge(T, node, idx-1);					
					child = left;
				} else if (right && right->num == T->t - 1) {
					btree_merge(T, node, idx);
				}
			}
		}

		btree_delete_key(T, child, key);
	}
	
}


int btree_delete(btree *T, KEY_VALUE key) {
	if (!T->root) return -1;

	btree_delete_key(T, T->root, key);
	return 0;
}


int main() {
	btree T = {0};

	btree_create(&T, 3);
	srand(48);

	int i = 0;
	char key[26] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	for (i = 0;i < 26;i ++) {
		//key[i] = rand() % 1000;
		printf("%c ", key[i]);
		btree_insert(&T, key[i]);
	}

	btree_print(&T, T.root, 0);

	for (i = 0;i < 26;i ++) {
		printf("\n---------------------------------\n");
		btree_delete(&T, key[25-i]);
		//btree_traverse(T.root);
		btree_print(&T, T.root, 0);
	}
	
}
Serendipity_Shy
关注
  • 0
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构基础-B树的实现
07-31 786
B树是重要的数据结构。我们用C语言如何实现，是非常关键的。它的规则严格，所以一步一步都要严格按照规则来。
C语言实现高级数据结构之B树
微小冷的学习笔记
12-23 2406
通过C语言实现B树的添加、查询、删除等操作。
C语言-B树（B-树）的完整实现
热门推荐
geek_jerome的博客
12-25 2万+
B树的定义 B树是一种平衡的多路查找树。 一颗m阶B树，或为空树，或为满足下列特性的m叉树。 （1）树中每个结点最多含有m棵子树; （2）若根结点不是叶子结点，则至少有两颗子树; （3）除根之外的所有非终端结点至少有[m/2]; （4）每个非终端结点中包含信息：（n,A0,K1,A1,K2,A2,…,Kn,An)。其中 ①Ki（1≤i≤n）为关键字，且关键字按升序排序。 ②指针Ai（
B树总结（概念、操作及C语言实现）
qq_41699954的博客
09-25 801
一、B树定义 B树，又称多路平衡查找树，B树中所有结点孩子个数的最大值为B树的阶。m阶B树定义如下：空树或者满足如下特征的m叉树：   1）树中每个结点至多有m棵子树，即至多有m-1个关键字；   2）若根结点不是终端结点，则至少有2棵子树，即至少一个关键字；   3）除根节点外所有非叶结点至少有⌈m/2⌉\lceil m/2 \rceil⌈m/2⌉棵子树，即至少有⌈m/2⌉\lceil m/2 \rceil⌈m/2⌉-1个关键字；   4）所有非叶结点结构如下：    其中，Ki（i=0，1，2，…，n
【C语言】B 树全代码实现与超超详细思路解读（五天的呕心沥血，绝对原创每个细节，详解查找、插入与删除）
Ice__Clean的博客
12-05 1983
本文详细解读了 B 树的查找、插入与删除代码，其中代码有大量的注释，同时还附上了个人的编写思路、代码总体思路、应该注意的地方以及需要避开的坑等等。对于某些需要解释的参数，也都做了详细的说明。相信看完本篇博客，即便不参考文中的代码，手撕一份 B 树也是没问题的啦
【C语言】B树查找、插入、删除以及代码实现
weixin_44348253的博客
01-05 1394
B树的查找、插入、删除算法简单介绍，以及使用C语言进行实现。
贪心算法的C语言实现与运用详解
09-03
以下是一个简单的C语言实现示例： ```c #include typedef struct { int start; int end; } Activity; int compare(const void *a, const void *b) { Activity *act1 = (Activity *)a; Activity *act2 = ...
二叉树详解（C语言版）.rar
04-09
这篇博文的压缩包文件"二叉树详解（C语言版）.rar"包含了对二叉树的详细讲解和相关的C语言实现代码。 首先，我们需要了解二叉树的基本概念。二叉树是由节点构成的非线性数据结构，每个节点包含两个子节点，分别称为...
C语言指针应用简单实例
08-30
总结一下，C语言中的指针是实现高级程序设计的关键工具，它们允许我们直接操作内存，实现数据结构如链表、树等，以及进行动态内存管理。在上述例子中，我们展示了如何使用指针来交换两个变量的值，这是理解指针基本...
C语言指针详解(经典,非常详细)
最新发布
10-20
多级指针可以用来实现复杂的数据结构，如链表或树。 五、指针和数组 指针可以与数组紧密配合。数组名其实是一个指向其首元素的指针，所以`int arr[5]`和`int *p = arr`是等价的。通过指针，我们可以遍历整个数组，...
B树 C语言实现
12-13
B树，C语言实现，添加到vc6.0中，可以执行的程序。
B+树的c语言代码实现
05-29
c语言的代码实现B+树。基于文件操作。模拟B+树的建立索引
B树、B+树的C++实现
07-05
B树、B+树的C++实现
Ｂ树的Ｃ语言实现，代码比较条理
09-21
Ｂ树的Ｃ语言实现，可以运行的，代码比较条理
详解C语言中结构体的自引用和相互引用
09-02
总结来说，理解和掌握结构体的自引用和相互引用是C语言编程中的重要技能，它们使得数据结构设计更加灵活，可以构建更复杂的抽象数据类型，如链表、树等。在实际编写代码时，务必遵循正确的声明和定义规则，以确保...
数据结构-B树的特点结构与C++实现
m0_61789994的博客
06-09 1718
B树，全称为B-树（B-tree），是一种自平衡的搜索树，由Rudolf Bayer和Edward McCreight于1972年提出。B树的设计目标是在磁盘等外部存储介质上进行高效的查找、插入和删除操作。B树的关键特点是它可以容纳多个子节点的节点，这使得B树可以充分利用外部存储介质的块读取能力，减少磁盘IO次数，提高访问效率。B树的节点通常会存储一组有序的键值对，用于进行数据的检索和排序。
B树的代码实现
一个小孩
04-16 919
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_38430038的博客
05-14 781
B树的原理及实现 B树的作用 B树是一种存放在磁盘中的数据结构，是为了减少磁盘读写的次数，同时也不影响查找效率而设计的。B+树在B树的基础上可以实现链式遍历。B树每个结点具有key值数组和索引数组，将数组大小定位页的倍数可以使计算机方便读取每一个结点。索引比key值多一个，相当于每一个key值都在两个索引中间，左边的索引小于key值，右边的索引大于key值，每一次都可以查找到需要读取的结点的索引地址，所以可以有效的减少磁盘读取次数。 B树的原理 B树有一个固定的阶数（M），该阶数一般为页的倍数，方便磁盘每次
B树的实现
jhcconan614的博客
06-10 429
二叉搜索树我们已经了解了很多种形式了，有AVLTree、红黑树等，不过，这都是在二叉搜索树的基础上加了些东西（平衡因子、颜色），其本质还是二叉搜索树。现在我们遇到一个问题：要是要查找的数据量很大的时候，还用这个，那么树的深度将会很深，那么要怎么解决呢？要保证数据量不变的情况下，将树的深度降低。这就是B树了，今天我们就来了解一下B树的原理，以及实现过程。B-树的定义（数据结构书上就是这么写的，不要读作
C语言实现矩阵转置算法详解-数据结构
"该资源主要讨论的是在C语言中实现矩阵转置的算法，属于数据结构中的内容，可能参考了严蔚敏的《数据结构(C语言版)》教材。此外，还提到了其他相关书籍作为进一步学习的参考资料，并概述了数据结构在计算机科学中的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值