B树完整实现（附详细注释）

最新推荐文章于 2024-08-14 12:26:14 发布
最新推荐文章于 2024-08-14 12:26:14 发布
阅读量425 收藏 2
点赞数
分类专栏： 算法导论（C语言实现） 文章标签： B树 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alike_meng/article/details/83020299
版权

一定要结合图形和书来看，注释是根据算法导论写的，有些太绕了，直接上书看好得多。
可以结合具体例子看，根据例子来理解代码要轻松一些
代码是抄的这个博主的（B树我自己写不出来…），有少许改动，原博文除了没有注释之外，分析写的还是很好的，主要是代码结构很简洁，大概也是按照导论来的。
https://blog.csdn.net/geek_jerome/article/details/78895289

看以下代码中要注意的地方：
1.输出的形式很奇怪，但是用递归输出的，也不好改。输出形式就是从根开始向下递归，然后 把当前指针所在的位置的结点的孩子从左到右全部输出。再到下一层。如果是内部结点就是0，叶子结点就是1。虽然不好看，但是逻辑还是在那里能看懂。
2.delete那部分函数写注释的时候很绕，直接看变量名搞清楚父子关系，兄弟关系可能还要清楚一些。
3.我这边编译通过了，结果目前看来没问题，and，搞不定的话就体会一下思想就好，加油！


#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#define MinDegree 2      //最小度c

typedef int ElementType;             //定义数据类型
typedef int* PtrElementType;         //定义指针类型


typedef struct TreeNode *PtrBTNode;     //定义一个结点和一个指向结点的指针
typedef struct TreeNode BTNode;

typedef struct TreeNode {                        //结点的结构体，包含位置，判断是否为叶子结点，关键字，孩子结点的指针
	int Num;                                      //Num是当前结点的关键字的个数
	bool IsLeaf;
	PtrElementType Key;
	PtrBTNode *Child;
};          


typedef struct Tree *PtrBT;     //定义指向树根的指针
typedef struct Tree {
	PtrBTNode Root;
};              

//函数列表
PtrBTNode BTAllocateNode();
PtrBTNode BTSearch(PtrBTNode Root, ElementType Val, int* Index);
void BTChildSplit(PtrBTNode SplitNodeP, int ChildIndex);
void BTInsertNonFull(PtrBTNode Root, ElementType Val);
void BTInsert(PtrBT T, ElementType Val);
void BTDelete(PtrBT T, PtrBTNode Root, ElementType Val);
void Merge(PtrBT T, PtrBTNode ParentNode, int LeftIndex, int RightIndex);
void ShiftKey(PtrElementType Key, bool Direction, int Begin, int End);
void ShiftChild(PtrBTNode *Child, bool Direction, int Begin, int End);
int GetIndex(PtrElementType Key, int Size, ElementType Val);
void BTPrintTree(PtrBTNode Root);
void BTCreateTree(PtrBT T);

//A test program
int main() {
	PtrBT T = (PtrBT)malloc(sizeof(struct Tree));

	T->Root = BTAllocateNode();
	BTCreateTree(T);

	printf("B_Tree after delete 8:\n");
	BTDelete(T, T->Root, 8);
	BTPrintTree(T->Root);
	printf("B_Tree after delete 16:\n");
	BTDelete(T, T->Root, 16);
	BTPrintTree(T->Root);
	printf("B_Tree after delete 15:\n");
	BTDelete(T, T->Root, 15);
	BTPrintTree(T->Root);
	printf("B_Tree after delete 4:\n");
	BTDelete(T, T->Root, 4);
	BTPrintTree(T->Root);
	return 0;
}

PtrBTNode BTAllocateNode() {                     
	int i;
	PtrBTNode NewNode = (PtrBTNode)malloc(sizeof(BTNode));         //新建一个结点，分配空间

	NewNode->Num = 0;                                              //初始化新建结点
	NewNode->IsLeaf = true;                          //如果是叶子结点
	NewNode->Key = (PtrElementType)malloc(sizeof(ElementType) * (MinDegree * 2 - 1));                      //分配叶子结点关键字的最大空间（内结点至多有2*最小度-1的关键字个数）
	NewNode->Child = (PtrBTNode*)malloc(sizeof(PtrBTNode) * (MinDegree * 2));                              //分配孩子结点指针的空间（内结点至多有2*最小度的空间）
	for (i = 0; i < MinDegree * 2; i++) {
		NewNode->Child[i] = NULL;                  //初始化指针
	}

	return NewNode;
}

PtrBTNode BTSearch(PtrBTNode Root, ElementType Val, int* Index) {       //传入的指向某子树的根节点的指针和要在该子树查找的关键字
	int i=0;
	while (i <= Root->Num && Val > Root->Key[i])              //找出使Val<Key[i]的最小下标i，如果找不到就把i的位置设为Num+1                 
		i++;
	if (i <= Root->Num && Root->Key[i] == Val) {               //检查是否找到，找到则返回
		*Index = i;
		return Root;
	}
	else if (true == Root->IsLeaf) {                      //如果根是叶子结点，子树就是空的
		return NULL;
	}
	else {
		return BTSearch(Root->Child[i], Val, Index);
	}
}

//分裂前x为父节点，Child[i]为子节点，Child[i]中有2*MinDgree-1个关键字，有2*MinDegree个子女
//在分裂后Child[i]有MinDegree-1个关键字，MinDegree个子女
void BTChildSplit(PtrBTNode x, int i) {
	int j;
	PtrBTNode z = BTAllocateNode();        //新建一个结点储存被分裂出来的元素
	PtrBTNode FullNode = x -> Child[i];            //父节点x的孩子中下标为i（也就是第i个孩子）赋值给结点FullNode

	for (j = 0; j<= MinDegree - 1; j++) {                   //把FullNode中的后一半元素的关键字赋给z
		z->Key[j] = FullNode->Key[MinDegree + j];
	}
	if (false == FullNode->IsLeaf) {         //如果FullNode不是叶子结点
		z->IsLeaf = false;             //那z也不是叶子结点
		for (j = 0; j < MinDegree; j++) {    //z的子女就等于FullNode的后一半的子女
			z->Child[j] = FullNode->Child[MinDegree + j];
		}
	}
	z->Num = FullNode->Num = MinDegree-1;               //Child[i]分裂后，FullNode和z都有MinDegree-1个关键字

	ShiftKey(x->Key,1,i, x->Num - 1);             //把正中间的那个元素移到父节点上面去，ShiftKey会找到它的位置，并把它的位置空出来

	x->Key[i] = FullNode->Key[MinDegree - 1];                 //将需要上移的关键字移到空出来的位置

	ShiftChild(x->Child, 1, i + 1, x->Num);       //现在多了一个元素，x的指针域都需要往后移动一位

	x->Child[i + 1] = z;            //将新分裂出来的结点插入其父节点。

	(x->Num)++;                                  //因为Child中有一个移到了x，所以多了一个元素
}


void BTInsertNonFull(PtrBTNode CurrentNode, ElementType Val) {                 //插入一个非满的结点     
	int Index = GetIndex(CurrentNode->Key, CurrentNode->Num, Val);           //用GetIndex找到插入的下标i

	if (true == CurrentNode->IsLeaf) {                    //如果当前结点是一个叶子结点

		ShiftKey(CurrentNode->Key, 1, Index, CurrentNode->Num - 1);           //使用shiftkey函数空位置出来
		CurrentNode->Key[Index] = Val;          //插进空位
		(CurrentNode->Num)++;       //个数++

	}
	else {                                              //如果不是叶子结点，应该将结点插到CurrentNode为根的适当叶节点中去，需要确定递归朝哪个子节点下降

		if (MinDegree * 2 - 1 == CurrentNode->Child[Index]->Num) {                 //检查递归是否降至一个满结点上
			BTChildSplit(CurrentNode, Index);                              //如果到了一个满结点就分裂
			if (CurrentNode->Key[Index] < Val) {                   //确定从哪个孩子结点下降
				Index++;
			}
		}
		BTInsertNonFull(CurrentNode->Child[Index], Val);             //递归的将Val插入到合适的子树上去
	}
}
void BTInsert(PtrBT T, ElementType Val) {              
	PtrBTNode NewNode;

	if (MinDegree * 2 - 1 == T->Root->Num) {       //如果B树T的根节点关键字的个数满了的话
		NewNode = BTAllocateNode();                //分配一个新的结点
		NewNode->IsLeaf = false;                   //如果新建的结点不是叶子结点
		NewNode->Child[0] = T->Root;               //新建结点的第一个孩子是原来的B树的根
		T->Root = NewNode;                         //新的B树的根是新建的结点

		BTChildSplit(NewNode, 0);   //newnode的child[0]分裂
	}

	BTInsertNonFull(T->Root, Val);        //沿树向下递归
}

//变量关系：currentnode是父节点。Child[index]、Child[index-1]、Child[index+1]都是它的子节点。
//当要删除的结点不在当前结点的子树下面的时候定义一个subnode是currentnode的子节点，并且是删除结点的父节点
void BTDelete(PtrBT T, PtrBTNode CurrentNode, ElementType Val) {            
	int Index;
	PtrBTNode Precursor=NULL, Successor=NULL, SubNode;

	Index = GetIndex(CurrentNode->Key, CurrentNode->Num, Val);       //找到value的下标
	SubNode = CurrentNode->Child[Index];            //初始化subnode是包含关键字Val的子树的根的指针

	if (Index < CurrentNode->Num && CurrentNode->Key[Index] == Val) {           //如果关键字在当前结点中

		if (true == CurrentNode->IsLeaf) {             //是叶节点
			ShiftKey(CurrentNode->Key, 0, Index + 1, CurrentNode->Num - 1);           //shiftkey在false的时候能实现把它删了
			(CurrentNode->Num)--;          //减一
			return;
		}

		else {                 //不是叶节点

			Precursor = CurrentNode->Child[Index];             //初始化两个指针指向指向关键字val之前的某左子节点Child[index]、和之后的右子节点Child[index+1]
			Successor = CurrentNode->Child[Index + 1];

			if (Precursor->Num > MinDegree - 1) {              //如果左子节点至少有MinDegree个关键字
				CurrentNode->Key[Index] = Precursor->Key[Precursor->Num - 1];              //原来的位置被前驱取代
				BTDelete(T, Precursor, Precursor->Key[Precursor->Num - 1]);               //原来的关键字被删除
			}
			else if (Successor->Num > MinDegree - 1) {            //如果右子结点至少有MinDegree个关键字
				CurrentNode->Key[Index] = Successor->Key[0];         //后继
				BTDelete(T, Successor, Successor->Key[0]);            //删除
			}
			else {                                //如果左右子结点都只含有MinDegree-1个关键字
				Merge(T, CurrentNode, Index, Index + 1);           //把左右子结点合并，把关键字从父节点拖到子节点
				BTDelete(T, CurrentNode->Child[Index], Val);       //递归删掉关键字
			}
		}
	}
	else {                       //关键字不在当前结点，要确定包含关键字的子树的根                          
		if (true == CurrentNode->IsLeaf) {                 //当前结点是叶子结点
			return;          
		}
		else {

			if (SubNode->Num > MinDegree - 1) {            //这个当前子树的根至少有MinDegree个关键字
				BTDelete(T, SubNode, Val);                 //删除
			}

			else {                    //当前子树的根少于MinDegree个关键字，也就是包含MinDegree-1个关键字

				if (Index > 0) {                                
					Precursor = CurrentNode->Child[Index - 1];
				}
				if (Index < CurrentNode->Num) {
					Successor = CurrentNode->Child[Index + 1];
				}

				if (Index > 0 && Precursor->Num > MinDegree - 1) {             //相邻的左兄弟结点至少有MinDegree个关键字

					ShiftKey(SubNode->Key, 1, 0, SubNode->Num - 1);             //往后移动

					ShiftChild(SubNode->Child, 1, 0, SubNode->Num);             //指针也往后移动

					SubNode->Key[0] = CurrentNode->Key[Index - 1];              //从父结点中移动一个关键字到自己这里

					SubNode->Child[0] = Precursor->Child[Precursor->Num];        //把指针也移动过来
					(SubNode->Num)++;

					CurrentNode->Key[Index - 1] = Precursor->Key[Precursor->Num - 1];          //左兄弟结点的一个关键字移到父节点也就是CurrentNode
					(Precursor->Num)--;

					BTDelete(T, SubNode, Val);           //递归

				}

				else if (Index < CurrentNode->Num && Successor->Num > MinDegree - 1) {           //右子树至少有MinDegree个关键字

					SubNode->Key[SubNode->Num] = CurrentNode->Key[Index];

					SubNode->Child[SubNode->Num + 1] = Successor->Child[0];

					(SubNode->Num)++;

					CurrentNode->Key[Index] = Successor->Key[0];

					ShiftKey(Successor->Key, 0, 1, Successor->Num - 1);

					ShiftChild(Successor->Child, 0, 1, Successor->Num);

					(Successor->Num)--;

					BTDelete(T, CurrentNode->Child[Index], Val);

				}

				else {            //当前子树的根和他的左右兄弟结点都只有MinDgree-1个关键字
					if (Index > 0) {            
						Merge(T, CurrentNode, Index - 1, Index);         //合并递归
						BTDelete(T, Precursor, Val);
					}
					else {               //要删的关键字是他那个结点的第一个元素
						Merge(T, CurrentNode, Index, Index + 1);
						BTDelete(T, SubNode, Val);
					}
				}
			}
		}
	}
}

void Merge(PtrBT T, PtrBTNode ParentNode, int LeftIndex, int RightIndex) {
	PtrBTNode LeftNode = ParentNode->Child[LeftIndex], RightNode = ParentNode->Child[RightIndex];
	int i;

	for (i = 0; i < MinDegree - 1; i++) {                          //把右边结点的元素和指针拿过来合并
		LeftNode->Key[MinDegree + i] = RightNode->Key[i];          
	}
	if (false == LeftNode->IsLeaf) {
		for (i = 0; i < MinDegree; i++) {
			LeftNode->Child[MinDegree + i] = RightNode->Child[i];
		}
	}
	LeftNode->Key[MinDegree - 1] = ParentNode->Key[LeftIndex];           //父节点的一个元素移动下来
	LeftNode->Num = MinDegree * 2 - 1;                    //个数+1

	ShiftKey(ParentNode->Key, 0, LeftIndex + 1, ParentNode->Num - 1);        //parentnode 下移的那个元素在父节点里面删了      

	ShiftChild(ParentNode->Child, 0, RightIndex + 1, ParentNode->Num);        //指针也删了
	
	(ParentNode->Num)--;

	if (ParentNode == T->Root && 0 == ParentNode->Num) {             //如果刚刚那个父节点是根节点的话且移动过后已经没有元素了
		T->Root = LeftNode;           //他的子节点就是新的根
	}
}

void ShiftKey(PtrElementType Key, bool Direction, int Begin, int End) {
	int i;

	if (true == Direction) {                     //true关键字就往后移动
		for (i = End; i >= Begin; i--) {
			Key[i + 1] = Key[i];
		}
	}
	else {                                       //否则关键字往前移动
		for (i = Begin; i <= End; i++) {
			Key[i - 1] = Key[i];
		}
	}
}

void ShiftChild(PtrBTNode *Child, bool Direction, int Begin, int End) {
	int i;

	if (true == Direction) {                //child往后
		for (i = End; i >= Begin; i--) {
			Child[i + 1] = Child[i];
		}
	}
	else {
		for (i = Begin; i <= End; i++) {         //child往前
			Child[i - 1] = Child[i];
		}
	}
}

int GetIndex(PtrElementType Key, int Size, ElementType Val) {
	int i;

	for (i = 0; i < Size; i++) {
		if (Key[i] >= Val) {
			break;
		}
	}

	return i;      //获取下标
}

void BTPrintTree(PtrBTNode Root) {
	int i;

	if (NULL == Root) {
		return;
	}

	putchar('[');
	for (i = 0; i < Root->Num; i++) {
		printf("%d", Root->Key[i]);
		if (i != Root->Num - 1) {
			putchar(' ');
		}
	}
	putchar(']');

	printf("%d", Root->IsLeaf);         //显示1的是叶子，显示0的不是叶子
	putchar('\n');

	for (i = 0; i <= Root->Num; i++) {
		BTPrintTree(Root->Child[i]);
	}
}

void BTCreateTree(PtrBT T) {
	int i;
	int a[] = { 6,7,11,4,8,13,17,9,16,20,3,12,14,15 };

	for (i = 0; i < 14; i++) {
		BTInsert(T, a[i]);
		BTPrintTree(T->Root);     
		printf("The End\n");
	}
}

在写各种树的时候最重要的还是要学会写结构体和指针。

alike_meng
关注
专栏目录
数据结构基础-B树的实现
07-31 839
B树是重要的数据结构。我们用C语言如何实现，是非常关键的。它的规则严格，所以一步一步都要严格按照规则来。
B树算法与实现
IT民工之路
06-26 681
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为节点关键字
Java 实现 B树（通俗易懂）
最新发布
lllsure的博客
08-14 1440
B树的概念及其模拟实现，B+树和B*树的介绍
B树实现
weixin_41053675的博客
11-07 354
B-树是一种平衡的多路查找树，它在文件系统中很有用。[1] B-树主要用作文件的索引，因此它的查找涉及外存的存取。[1] B-树适用于：当文件很大时，索引表（树表）本身也在外存，则查找索引时需多次访问外存，并且，访问外存的次数恰为查找路径上的结点数。为减少访问外存的次数，应尽量缩减索引表的深度。此时宜采用m叉的B-树作索引表。m的选择取决于索引项的多少和缓冲区的大小。[1] 实现语言...
B树的实现及操作
m0_65931372的博客
01-08 336
B树是一种自平衡的多叉搜索树，主要用在磁盘索引中。 这里主要讲B树的实现和插入删除操作，对于B树的定义、原理和应用等不再提出。 B数的实现 在讲解具体的操作之前，还是先把B树及其节点的定义给出来。 class bnode { public: bnode(int leaf,int m); ~bnode(); int nums; int leaf;//是否是叶子节点 int *keys; bnode **children; }; class btree { pu
B树的实现
gaoyi的专栏
05-15 1309
B树是什么，不用说了，相信大家都懂，我今天只想详细地说一下B树的插入和删除的详细算法，为了以后自己看起来方便，并且附上自己的代码，希望对各位也能够有所帮助。B树的插入算法：1）用查找的方法为x找到所在的位置，查找路径终于某个空树，然后把x插入到其父结点的有序位置上，注意B树所有的插入都是在叶结点上进行。2）如果插入x后，结点不超长，则插入完毕；否则，进入下一步，进行超长处理。3）将超长结点一分为二...
哈夫曼编码 源程序 附详细注释
02-21
### 哈夫曼编码源程序解析与详细注释解读 #### 一、哈夫曼编码简介 哈夫曼编码是一种广泛应用于数据压缩领域的编码算法，由David A. Huffman于1952年提出。其核心思想是通过构建一棵哈夫曼树来实现对数据的有效...
利用B+树实现Allan方差信号方差最小化附matlab代码.zip
01-23
1.版本：matlab2014/2019a/2021a，内含运行结果...3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
哈夫曼编码源程序带详细注释与压缩示例
在这个源程序中，我们看到一个用C语言实现的哈夫曼编码算法，附有详细的注释，便于理解和学习。 首先，程序定义了一个结构体`header`，用于存储字符、其出现的频率（权重）、在哈夫曼树中的父节点和左右子节点信息...
红黑树 (附 STL 源码学习注释)
jelly_9的博客
11-27 840
除了 AVL 树之外，另一个颇具历史并被广泛运用的平衡二叉搜索树是红黑树。同 AVL 树一样，红黑树的高度也近似为 O(logN)，它是通过给节点标记上两种不同的颜色 (红、黑) 来实现此目的的。 模拟实现代码 概述 红黑树是在1972年由 Rudolf Bayer 发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 ...
C语言实现二叉树(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-13 868
#include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW -1 #define SUCCESS 1 #define UNSUCCESS 0 #define dataNum 5 int i = 0; int dep = 0; char data[dataNum] = { 'A', 'B', 'C', 'D', 'E'
B树的实现（C++）
07-16
网上很多程序没有注释，代码运行报错。所以精心重写了一下B树的实现。程序结构严谨，有详细的注释，运行没有问题，基于vs2013平台。对于刚学算法的人应该会有很大帮助。
B树详细介绍
10-24
B树，本文介绍了B树了定义，包括B树的增加删除修改等。
B树的表示及基本操作的实现。
05-28
B树的表示及基本操作的实现。 1．掌握B树的存贮结构。 2．实现B树中关键字值的插入及删除操作。 3．练习屏幕图形化的显示。
数据结构之B树实现
weixin_49561445的博客
04-27 282
上一篇： 赫夫曼树及赫夫曼编码 简介 B-Tree是为磁盘等外存储设备设计的一种平衡查找树，是一种多路树。它维护有序数据并允许以对数时间进行搜索，顺序访问，插入和删除。B树是二叉搜索树的一般化，因为节点可以有两个以上的子节点。 与其他自平衡二进制搜索树不同，B树非常适合读取和写入相对较大的数据块（如光盘）的存储系统。它通常用于数据库和文件系统。 B树是一种多路查找树，其类似的还有2-3树，2-3-4树 都是B树只是结构更加简单 为什么要引入B树？ （1）系统从磁盘读取数据到内存时是以磁盘块（block）
数据结构-b树实现
u013098139的博客
03-01 191
b树的实现 main.cpp #include <iostream> #include <string> #include "main.h" /* #define MYHEAP_TEST */ /* #define HEAP_SORT_TEST */ /* #define INDEX_MIN_PRIORITY_TEST */ /* #define RED_BLACK_TREE_TEST */ #define BTREE_TEST using std::string; int
B树的代码实现
一个小孩
04-16 967
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
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值