《算法导论》中BTree的代码实现~

最新推荐文章于 2026-04-17 11:23:31 发布
原创 最新推荐文章于 2026-04-17 11:23:31 发布 · 7.2k 阅读 · 8 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#算法 #tree #delete #insert #disk
#search
本文介绍了《算法导论》中的BTree数据结构，并提供了BTree的C++实现，包括插入、删除和搜索操作。配合运行截图，帮助读者深入理解BTree在磁盘存储中的应用。


BTree.h

#ifndef _BTREE_H 
#define _BTREE_H

#define MINDEGREE 3 // 定义BTree的最小度
#define MAXDEGREE (MINDEGREE*2)

// 定义BTree的数据结构
typedef void* NodeData;

typedef struct _targBTreeNode
{
	NodeData	data; // 
	_targBTreeNode*	cs[MAXDEGREE]; //孩子指针数组
	int	keys[MAXDEGREE-1]; //关键字数组
	int count; // 关键字个数
	int is_leaf; // 是否为叶子结点
} BTreeNode, *BTree;

#define BTREE_SIZE sizeof(BTreeNode)

void alloc_tree(BTree &tree); //分配内存 
void insert_keys_to_tree(BTree &tree, int keys[], int n); //将keys插入至tree中
void insert_key_to_tree(BTree &tree, int key); // 将key插入至根树tree中
void insert_key_to_unfull_tree(BTree &tree, int key); // 将key关键字插入至未满子树tree中 
void break_tree_child(BTree &tree, BTree &child, int i); // 将tree的第i个子孩子分裂
void disk_read(const BTree tree); // 代表读磁盘，未实现
void disk_write(const BTree tree); // 代表写磁盘，未实现
void display_tree(const BTree tree); // 显示BTree
int search_tree(const BTree tree, int key); // 搜索BTree中是否存在关键字
void delete_tree(BTree &tree, int key); // 删除BTree中的某一关键字，主要处理BTree为空的两种情况~
void delete_unless_tree(BTree &tree, int key); // 删除BTree中的某一子树~
int pre_succor_tree(const BTree tree, int i); // 找tree中第i位关键字的前驱~
int after_succor_tree(const BTree tree, int i); // 找Btree中第i位关键字的后继~

#endif


BTree.cpp

#include "BTree.h"
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <assert.h>

void alloc_tree(BTree &tree)
{
	if(0 == (tree = (BTree) malloc (BTREE_SIZE)))
	{
		exit(-1);
	}
	memset(tree, 0, BTREE_SIZE);
	tree->is_leaf = 1;
}

void insert_keys_to_tree(BTree &tree, int keys[], int n)
{
	for(int i = 0; i < n; i++)
	{
		insert_key_to_tree(tree, keys[i]);
	}
}

void insert_key_to_tree(BTree &tree, int key)
{
	if(tree == NULL)
	{
		alloc_tree(tree);
	}
	// 如果根关键字已满，则进行分裂
	if(tree->count == (MAXDEGREE-1))
	{
		BTree new_root = NULL;
		alloc_tree(new_root);
		new_root->is_leaf = 0;
		new_root->cs[0] = tree;
		break_tree_child(new_root, tree, 0); // 分裂
		tree = new_root;
		insert_key_to_unfull_tree(tree, key);
	}
	else
	{
		insert_key_to_unfull_tree(tree, key);
	}
}

void break_tree_child(BTree &tree, BTree &child, int i)
{
	int j = 0;
	BTree rchild = NULL;

	alloc_tree(rchild);
	rchild->is_leaf = child->is_leaf; // 和原child一致
	// 将原child分成两个孩子
	// 将原child的右侧r-1个关键字移至rchild的keys中
	for(j = 0; j < (MINDEGREE-1); j++)
	{
		rchild->keys[j] = child->keys[MINDEGREE+j];
	}
	rchild->count = MINDEGREE - 1;
	// 将原child的右侧的r+1个孩子移至rchild的cs中
	for(j = 0; j < MINDEGREE; j++)
	{
		rchild->cs[j] = child->cs[MINDEGREE+j];
	}
	child->count = MINDEGREE - 1;
	
	//将child的第r个结点关键字插入tree的第i个位置
	// 将tree从第i+1至第(tree->count)位置的cs后移一位
	for(j=tree->count;j > i; j--)
	{
		tree->cs[j+1] = tree->cs[j];
	}
	tree->cs[i+1] = rchild;
	// 将从第i至(tree->count-1)位置的关键字全部向后挪1
	for(j=tree->count-1; j > i; j--)
	{
		tree->keys[j+1] = tree->keys[j];
	}
	tree->keys[i] = child->keys[MINDEGREE-1];
	tree->count++;	
	disk_write(tree);
	disk_write(child);
	disk_write(rchild);
}

void insert_key_to_unfull_tree(BTree &tree, int key)
{
	int i = 0;
	
	// 如果是叶子结点，则直接插入即可，由于tree未全满，则符合BTree定义
	if(tree->is_leaf == 1)
	{
		// 找到需要沿下插入的位置
		i=tree->count-1;
		while(i>=0 && key < tree->keys[i])
		{
			tree->keys[i+1] = tree->keys[i];
			i--;
		}
		tree->keys[i+1] = key;
		tree->count++;
		disk_write(tree);
	}
	else
	{ // 如果是内结点，则需找到继续寻找位置后，判断其子结点是否已经全满，如全满则分裂，并继续沿下寻找
		i=tree->count-1;
		while(i>=0 && key < tree->keys[i])
		{
			i--;
		}
		i++; // 找到继续寻找位置
		
		disk_read(tree->cs[i]);
		// 如果子树已满，则将其分裂
		if(tree->cs[i]->count == (MAXDEGREE-1))
		{
			break_tree_child(tree, tree->cs[i], i);
			if(key > tree->keys[i])
			i++;
		}
		insert_key_to_unfull_tree(tree->cs[i], key);
	}
}

void disk_read(const BTree tree)
{

}

void disk_write(const BTree tree)
{

}

void display_tree(const BTree tree)
{
	if(tree==NULL || tree->count == 0)
	{
		return;
	}

	printf("(%d", tree->keys[0]);
	int i = 0;
	for(i = 1; i < tree->count; i++)
	{
		printf(",%d", tree->keys[i]);
	}
	printf(")");
	if(0 == tree->is_leaf)
	{
		printf("(");
		for(i = 0; i < tree->count+1; i++)
		{
			display_tree(tree->cs[i]);
		}
		printf(")");
	}
}

int search_tree(const BTree tree, int key)
{
	if(tree==NULL)
		return 0;
	for(int i = tree->count-1; (i >= 0) && (key < tree->keys[i]); i--);
	// 在遍历结束之前找到匹配关键字
	if((i != -1) && (key == tree->keys[i]))
	{
		return 1;
	}
	i++;

	if(1 == tree->is_leaf)
	{
		return 0;
	}
	else
	{
		return search_tree(tree->cs[i], key);
	}
}

void delete_tree(BTree &tree, int key)
{
	if(0 == search_tree(tree, key))
	{
		return;
	}
	
	// 查找关键字位置，或子树
	if( (tree->count==1) && (1 == tree->is_leaf))
	{
		free(tree);
		tree = NULL;
		return;
	}
	else if((tree->count==1) && (tree->keys[0] == key) && (tree->cs[0]->count == MINDEGREE-1) && (tree->cs[1]->count == MINDEGREE-1))
	{
		int j = 0;
		BTree l_child = tree->cs[0], r_child = tree->cs[1];
		
		l_child->keys[MINDEGREE-1] = tree->keys[0];
		for(j = 0; j < r_child->count; j++)
		{
			l_child->keys[j+MINDEGREE] = r_child->keys[j];
		}
		for(j = 0; j < MINDEGREE; j++)
		{
			l_child->cs[MINDEGREE+j] = r_child->cs[j];
		}
		l_child->count = MAXDEGREE - 1;
		free(r_child);
				
		free(tree);
		tree = l_child;
		delete_unless_tree(tree, key);
	}
	else
	{
		delete_unless_tree(tree, key);
	}
}

void delete_unless_tree(BTree &tree, int key)
{	
	// 查找关键字位置，或子树
	int i = 0, j = 0;
	for(i = tree->count-1; (i>=0) && (key < tree->keys[i]); i--);
	
	// 由于已经确保关键字在此树中，且无子树，故直接删除
	if(1 == tree->is_leaf)
	{
		// 即将从第i+1位置至(tree->count-1)位置关键字都往前挪1位，并tree->count--
		for(j = i + 1; j < (tree->count); j++)
		{
			tree->keys[j-1] = tree->keys[j];
		}
		tree->count--;	
	}
	else if((i != -1) && (tree->keys[i] == key))
	{// 如果关键字在此树当中，但为内结点，~
		// case2a 若其左孩子有大于等于r个结点，则将其前继代替tree->key[i]，并移至左孩子，将其递归删除~
		if(tree->cs[i]->count >= MINDEGREE)
		{
			int new_key = pre_succor_tree(tree, i);
			tree->keys[i] = new_key;
			delete_unless_tree(tree->cs[i], new_key);
		}
		else if(tree->cs[i+1]->count >= MINDEGREE)
		{//case2b 若右孩子大于等于r个结点，则将其后继代替tree->key[i], 并移至右孩子，递归删除~
			int new_key = after_succor_tree(tree, i+1);
			delete_unless_tree(tree->cs[i+1], new_key);
		}
		else
		{//case2c 若左右孩子均为r-1个关键字，则需将删除结点下沉并左右孩子合并，再删除~
			BTree l_child = tree->cs[i], r_child = tree->cs[i+1];
			
			l_child->keys[MINDEGREE-1] = tree->keys[i];
			for(j = 0; j < r_child->count; j++)
			{
				l_child->keys[j+MINDEGREE] = r_child->keys[j];
			}
			for(j = 0; j < MINDEGREE; j++)
			{
				l_child->cs[MINDEGREE+j] = r_child->cs[j];
			}
			l_child->count = MAXDEGREE - 1;
			free(r_child);
			
			// 将keys域中(i+1)位至(tree->count-1)位向前移1位
			for(j = i+1; j < (tree->count -1); j++)
			{
				tree->keys[j-1] = tree->keys[j];
			}
			// 将cs域中从(i+2)位至(tree->count）位向前移1位
			for(j = i+2; j < tree->count; j++)
			{
				tree->cs[j-1] = tree->cs[j];
			}
			tree->count--;
			
			delete_unless_tree(tree->cs[i], key);
		}
	}
	else
	{ // 如果不在tree的keys中，且为内结点~
		i++; // 找至子孩子的正确位置
		if(tree->cs[i]->count >= MINDEGREE)
		{// 如果关键字个数>=最小度
			delete_unless_tree(tree->cs[i], key);
		}
		else
		{// 如果子树根只有MINDEGREE-1个关键字，则需要考虑从兄弟借，或与兄弟合并情况
			// case 3a 如果可以从其左孩子借一关键字
			if((i != 0) &&(tree->cs[i-1]->count >= MINDEGREE))
			{
				BTree ichild = tree->cs[i], lchild = tree->cs[i-1];
				// 将i孩子的所有子孩子右移1，以便为lchild的最后一个子孩子移至第0位置
				for(j = tree->count; j >= 0; j--)
				{
					ichild->cs[j+1] = ichild->cs[j]; 
				}
				ichild->cs[0] = lchild->cs[lchild->count];
				// 将i孩子的所有关键字右移1，以便为tree中第(i-1)位置的key移至第1个位置
				for(j = tree->count-1; j >= 0; j--)
				{
					ichild->keys[j+1] = ichild->keys[j];
				}
				ichild->keys[0] = tree->keys[i-1];
				ichild->count++;
				
				// 将tree中第(i-1)位关键字替换成lchild中最右关键字
				tree->keys[i-1] = lchild->keys[lchild->count-1];
				
				// 将lchild中左孩子左移1
				for(j = 0; j < lchild->count; j++)
				{
					lchild->cs[j] = lchild->cs[j+1];
				}
				// 将lchild中左孩子关键字左移1
				for(j = 0; j < (lchild->count-1); j++)
				{
					lchild->keys[j] = lchild->keys[j+1];
				}
				lchild->count--;
				delete_unless_tree(ichild, key);
			}// if case 3a
			else if((i != tree->count) && tree->cs[i+1]->count >= MINDEGREE)
			{// case3a' 如果child i的右兄弟关键字够“借”(即>=MINDEGREE)
				BTree ichild = tree->cs[i], rchild = tree->cs[i+1];
				// 将rchild的第0个子孩子移至ichild中子孩子最未位置中
				ichild->cs[ichild->count+1] = rchild->cs[0];
				// 将tree的第i个关键字加至ichild的关键字中
				ichild->keys[ichild->count] = tree->keys[i];
				ichild->count++;				
				
				// 将rchild的第0个关键字覆盖至tree中
				tree->keys[i] = rchild->keys[0];

				// 将rchild的所有子孩子左移1
				for(j = 0; j < rchild->count; j++)
				{
					rchild->cs[j] = rchild->cs[j+1];
				}
				for(j = 0; j < (rchild->count-1); j++)
				{
					rchild->keys[j] = rchild->keys[j+1];
				}
				rchild->count--;
				delete_unless_tree(ichild, key);
			}// else if
			else
			{// case3b 左右兄弟都为MINDEGREE-1的情况
				// 如没有左兄弟，则将i+1,转至有左兄弟的情况进行处理
				if(i == 0)
				{
					i++; 
				}

				BTree ichild = tree->cs[i];
				BTree lchild = tree->cs[i-1];
				// 将i的子孩子移至左兄弟
				for(j = 0; j < MINDEGREE; j++)
				{
					lchild->cs[j+MINDEGREE] = ichild->cs[j];
				}
				// 将tree的关键字i-1移至左兄弟中
				lchild->keys[MINDEGREE-1] = tree->keys[i-1];
				// 将i的关键字都移至左兄弟中
				for(j = 0; j < MINDEGREE-1; j++)
				{
					 lchild->keys[MINDEGREE+j] = ichild->keys[j];
				}
				lchild->count = MAXDEGREE-1;
				free(ichild);
				
				// 调整tree中的子孩子位置
				for(j=i; j < tree->count; j++)
				{
					tree->cs[j] = tree->cs[j+1];
				}
				// 调整tree中关键字位置
				for(j=i-1; j < (tree->count-1); j++)
				{
					tree->keys[j] = tree->keys[j+1];
				}
				tree->count--;
				delete_unless_tree(lchild, key);
			}
		}// else
	}// else
}

int pre_succor_tree(const BTree tree, int i)
{
	BTree p = tree->cs[i];
	//前驱为tree的最左子树的最右叶子结点的最后右一个关键字
	while((p->is_leaf == 0))
	{
		p = p->cs[p->count];
	}
	return p->keys[p->count-1];
}

int after_succor_tree(const BTree tree, int i)
{
	BTree p = tree->cs[i+1];	
	//后继为tree的右子树最左叶子结点的第一个关键字
	while(p->is_leaf == 0)
	{
		p = p->cs[0];
	}
	return p->keys[0];
}
////////////////////////////////////
// 定义测试数据
#define TEST_NUM 11
int test_keys[TEST_NUM] = {10, 2, 1, 5, 4, 7, 8, 6, 13, 11, 14};

int main()
{
	BTree tree = NULL;

	insert_keys_to_tree(tree, test_keys, TEST_NUM);
	display_tree(tree);
	
	delete_tree(tree, 1);
	printf("\n\nafter delete 1:\n");
	display_tree(tree);

	delete_tree(tree, 7);
	printf("\n\nafter delete 7:\n");
	display_tree(tree);

	delete_tree(tree, 4);
	printf("\n\nafter delete 4:\n");
	display_tree(tree);

	delete_tree(tree, 2);
	printf("\n\nafter delete 2:\n");
	display_tree(tree);

	printf("\n");
	return 0;
}



运行截图


btree.c:B树在C中的实现
05-03
btree.c C语言中的B树实现。 特征 通用接口，支持可变大小的项目。 快速顺序批量加载 ANSI C（C99） 支持自定义分配器 相当不错的表现。 :rocket: 例子 # include < stdio> # include < string> # include " btree.h " struct user { char *first; char *last; int age; }; int user_compare ( const void *a, const void *b, void *udata) { const struct user *ua = a; const struct user *ub = b; int cmp = strcmp (ua-> last , ub-> last ); if (cmp
树状显示二叉树（标准C语言实现）
热门推荐
weixin_40568729的博客
02-28 1万+
二叉搜索树的黑框树状显示（标准C语言实现） 最近在用C语言实现平衡二叉搜索树，用了半天时间实现了树的基本功能后，发现我的二叉树打印方法还是停留在简单的逐行打印，此时的效果图如下： 一行的每两个数值分别对应上一行一个数值的左右孩子，用星号表示空。无疑这中表示方法十分鸡肋，利用人工点数的方式确定节点的左右孩子，实在不方便调试和扩展功能，如果节点多了可能还会造成开发者白内障，危害极大。 出于开发效率和...
树的相关操作：树的先序遍历输入【递归写法】先序遍历、中序遍历、后序遍历【递归、非递归写法】，详解，很详细！！！、寻找固定元素、找叶子节点的个数
qq_63794524的博客
10-31 938
树的相关操作以及树的遍历详解
CN-Chrome-DevTools完全指南：从零开始掌握浏览器开发者工具
最新发布
gitblog_00707的博客
04-17 689
Chrome开发者工具（CN-Chrome-DevTools）是一套内置于Google Chrome浏览器的强大开发调试工具，它能帮助开发者深入浏览器内部机制，高效追踪布局问题、设置JavaScript断点并优化代码性能。本指南将带你从零开始，全面掌握这一必备前端开发利器的核心功能与实用技巧。 ## 快速入门：打开与基本布局 ### 多种打开方式 启动Chrome开发者工具的方式简单直观，适
数据结构——二叉树的基本操作（一）
yxl_d的博客
09-26 5757
一、实验目的及要求 1.理解二叉树的基本概念和特点 2.掌握二叉树的链式存储结构 3.掌握二叉树的基本操作 二、实验内容（或实验原理、实验拓扑） 1.实现二叉树的如下操作，二叉树如下图所示。(采用二叉链存储结构实现) (1)输出二叉树b； (2)输出C节点的左、右孩子节点值； (3)输出二叉树的深度； (4)输出二叉树b的节点个数； (5)输出二叉树b的叶子节点个数。 三、实验设计方案（包括实验...
数据结构与算法分析-C++描述 第4章 B树
qq_37172182的博客
03-27 501
B树的性质： 1）树中每个结点最多含有m棵子树； 2）若根结点不是叶子结点，则至少有2个子树； 3）除根结点之外的所有非终端结点至少有棵子树； 4）每个非终端结点中包含信息：，其中： 1）为关键字，且关键字按升序排序； 2）指针指向子树的根结点，指向子树中所有结点的关键字均小于，且大于； 3）关...
btree实现
congchp的博客
02-11 665
为什么会有btree 多叉树的作用，使得节点数量变少。查找节点的数量变少。 多叉树，降层高。为了寻址次数减少。 rbtree如果用在内存，意义不大。 多叉树和btree之间的关系 多叉树没有约束平衡 多叉树没有约束每个节点子树的数量 btree遍历是顺序的。 btree的定义 一颗M阶B树T，满足以下条件 每个结点至多拥有M棵子树 根结点至少拥有两棵子树 除了根结点以外，其余每个分支结点至少拥有M/2棵子树 所有的叶子结点都在同一层上 有k棵子树的分支结点则存在k-1个关键字，关键字按照递增顺序进行排
B tree和B+tree的区别
Dream_6666的博客
08-26 333
相同的地方： B树和B+树其实都是平衡搜索树。这里要脑补一下平衡搜索树的概念：这个词划分一下就是平衡+搜索+树。也就是说，他首先是一棵树，其次能搜索，再次他是平衡的。大家耳熟能详的一个概念：二叉平衡搜索树。（详细的大家可以在百度上搜一下定义，或者拿起那本厚实的「算法导论」看看）。 不同的地方： 但是B树和B+树却有不同的地方。就是这些不同的地方，决定了他们的用处可能不一样。 我画了一个不太漂亮的B树的图。我们可以看到B树里面，每个结点有这样的特点：不论是叶结点还是非叶结点，都含有Key和一个指向数据的指针
B-Tree和B+Tree的异同
climbs的专栏
01-06 311
B树和B+树其实都是平衡搜索树。这里要脑补一下平衡搜索树的概念：这个词划分一下就是平衡+搜索+树。也就是说，他首先是一棵树，其次能搜索，再次他是平衡的。大家耳熟能详的一个概念：二叉平衡搜索树。（详细的大家可以在百度上搜一下定义，或者拿起那本厚实的「算法导论」看看）。 #异# 但是B树和B+树却有不同的地方。就是这些不同的地方，决定了他们的用处可能不一样。 我画了一个不太漂亮的B树的图。我...
进阶数据结构 BTree 的插入与删除操作实现
王清欢的博客
02-26 6204
在数据库系统和文件系统中，高效的数据组织与管理是关键之一。B-Tree（Balanced Tree）作为一种平衡搜索树结构，在这一领域发挥着重要作用。本文详细探讨了 B-Tree 的基本概念以及对其进行插入与删除操作的实现，旨在帮助读者理解 B-Tree 的工作原理以及如何有效地维护这种数据结构。
c语言如何添加btree.h,GitHub - orange1438/BTree-and-BPlusTree-Realize: BTree and BPlusTree Realize:B树和B+树的实...
weixin_35545176的博客
05-25 474
文件说明：1.Tree.h：B树和B+树的通用接口，虚基类。BTree和BPlusTree都继承它，只有BPlusTree才有linear函数2.BTree.h,BTree.cpp：B树的声明、实现代码3.BPlusTree.h,BPlusTree.cpp：B+树的声明、实现代码，注：大多数的函数，B和B+都是一样的，但是我还是分开写了，比如输出函数4.Context.h：策略方法的实现5.mia...
【JDK17】BTree看这一篇就够了！BTree的添加、删除key的实现原理及代码实现
weixin_44429641的博客
04-30 977
如下图，蓝色格子代表预留出来的一个容量，实际存储时，只有前4个格子可以存储key。蓝色线条也是预留出来的一个孩子指针，实际只有前5个孩子指针会指向子节点。注意分裂操作不仅仅会在叶子节点，也有可能发生在非叶子节点。
第九周项目1 - 二叉树算法库
zhangjunjie1558的博客
11-16 296
二叉树的链式存储算法库采用程序的多文件组织形式，包括两个文件：  　　  　　1.头文件：btree.h，包含定义二叉树的链式存储数据结构的代码、宏定义、要实现算法的函数的声明； #ifndef BTREE_H_INCLUDED #define BTREE_H_INCLUDED #define MaxSize 100 typedef char ElemType; typedef struc
从B树谈到R树之B树的c实现
jinghuainfo
08-31 480
从B树谈到R树之B树的c实现 作者：weedge，July。编程艺术室出品。 前言 代码大全的作者Steve McConnell曾称，他所见识的任何一本书都不是某一个人能完全独立即能完成的。吾深以为然。 本blog内的文章十有八九系我个人参考资料原创所作，与此同时十有二三系本人与吾的朋友共同创作完成。所以，诸君在浏览本博客内任何一篇文章时，务必尊重他人劳动成果。当然，有任何问题，欢迎随时不吝指...
c语言如何添加btree.h,从B树谈到R树之B树的c实现
weixin_39882317的博客
05-25 1387
从B树谈到R树之B树的c实现作者：weedge，July。编程艺术室出品。前言代码大全的作者Steve McConnell曾称，他所见识的任何一本书都不是某一个人能完全独立即能完成的。吾深以为然。本blog内的文章十有八九系我个人参考资料原创所作，同时十有二三系本人与吾的朋友共同创作完成。所以，诸君在浏览本博客内任何一篇文章时，务必尊重他人劳动成果。当然，有任何问题，欢迎随时不吝指正。ok，在本b...
btree 实现
ai_xiangjuan的博客
01-07 1112
btree的使用场景 在巨型数据集中，查找是一项非常耗时的操作。我们希望设计一种这样的数据结构，通过简单的4-5指向数据块的引用就能查找到巨型数据集中我们想要的数据。这时，btree就诞生了。我们以前学习的高效查找结构，如红黑树等，适用于能够存放到内存中的数据。btree主要用于对磁盘或者网络上的数据的查找。如mysql 的存储引擎myisam就是btree的实现。 b-树的数据结构
C++实现BTree代码
nothing
04-14 489
C++实现BTree代码
数据结构——树及二叉树-1
TTTSEP9TH2244的博客
01-16 894
实验预备知识： 1. 熟练运用指针进行程序设计，掌握结构体指针。 2. 掌握使用结构体指针访问结构体变量。 3. 掌握指针作为函数的参数使用。 4. 理解树和二叉树的含义、目的和处理方法。 一、实验目的 理解和掌握树及二叉树的类型定义方法。 定义二叉树的基本存储结构，实现基本运算，构建二叉树算法库。 学习利用树及二叉树解决实际问题 二、实验要求 【项目1】----二叉树算法库的建立 定义二叉树的链式存储结构，实现其基本运算，并完成测试。 【要求】： 头文件btree.h中定义数据结构并声明用于完成基本
一文看懂B TREE和B+TREE数据结构实现过程及数据存储结构
xiaoshitou_2015的博客
06-05 826
一文看懂B TREE和B+TREE数据结构实现过程及数据存储结构。
B-tree 简易源代码实现
nl6666的博客
06-26 332
B-tree(B树）简单c源码实现
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值