严蔚敏数据结构B树与B+树

最新推荐文章于 2024-11-05 00:21:35 发布
最新推荐文章于 2024-11-05 00:21:35 发布
阅读量242 收藏
点赞数
文章标签： 数据结构 b树 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laohuchishizi/article/details/124674062
版权 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <math.h>
#define OK 1
#define ERROR 0
#define FALSE 0
#define TRUE 1
#define OVERFLOW -2
#define LH 1
#define RH -1
#define EH 0
#define GRADE 4
typedef int Status;
typedef int KeyType;
typedef struct
{
	KeyType key;
}ElemType;
typedef struct
{
	ElemType* elem;
	int length;
}SSTable;
typedef ElemType TElemType;
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;
typedef struct BSTNode
{
	TElemType data;
	int bf;
	struct BSTNode* lchild, * rchild;
}BSTNode, * BSTree;
typedef struct BTNode
{
	int keynum;
	struct BTNode* parent;
	KeyType key[GRADE + 1];
	struct BTNode* ptr[GRADE + 2];
	ElemType* recptr[GRADE + 1];
}BTNode, * BTree;
typedef struct
{
	BTNode* ptr;
	int i;
	int tag;
}Result;


//查找表元素输入,关键字赋值以及比较
void InputTableElem(ElemType* e)
{
	printf("请输入关键字信息\n");
	scanf("%d", &(e->key));
}
void KeyWordAssign(KeyType* destination, KeyType source)
{
	(*destination) = source;
}
void KeyWordPrint(KeyType key)
{
	printf("%d\n", key);
}
void TableElemAssign(ElemType* destination, ElemType source)
{
	(*destination).key = source.key;
}
void TableElemPrint(ElemType e)
{
	printf("%d\n", e.key);
}
Status EQ(KeyType key1, KeyType key2)
{
	if (key1 == key2)
		return TRUE;
	else
		return FALSE;
}
Status LT(KeyType key1, KeyType key2)
{
	if (key1 < key2)
		return TRUE;
	else
		return FALSE;
}
Status LE(KeyType key1, KeyType key2)
{
	if (key1 <= key2)
		return TRUE;
	else
		return FALSE;
}
Status MT(KeyType key1, KeyType key2)
{
	if (key1 > key2)
		return TRUE;
	else
		return FALSE;
}
Status ME(KeyType key1, KeyType key2)
{
	if (key1 >= key2)
		return TRUE;
	else
		return FALSE;
}


//静态查找表
Status CreatSSTable(SSTable* T, int n)
{
	T->length = n;
	T->elem = (ElemType*)malloc(sizeof(ElemType) * (n + 1));
	if (!T->elem) exit(OVERFLOW);
	for (int i = 1; i <= T->length; i++)
	{
		printf("请输入第%d个表项信息：\n", i);
		InputTableElem(&(T->elem[i]));
	}
	return OK;
}
int Search_Seq(SSTable ST, KeyType key)                   //Sequence Search
{
	KeyWordAssign(&(ST.elem[0].key), key);
	int i = ST.length;
	while (!EQ(ST.elem[i].key, key))
		i--;
	return i;
}
int Search_Bin(SSTable ST, KeyType key)                    //Binary Search
{
	int low = 1, high = ST.length;
	int mid = (low + high) / 2;
	while (low <= high)
	{
		if (EQ(ST.elem[mid].key, key))
			return mid;
		if (MT(ST.elem[mid].key, key))
			high = mid - 1;
		else
			low = mid + 1;
	}
	return 0;
}
void SecondOptimal(BiTree* T, SSTable S, int* sw, int low, int high)
{
	int i = low;
	int w = sw[high] + sw[low - 1];
	int min = abs(sw[high] - sw[low]);
	for (int j = low + 1; j <= high; j++)
	{
		if (abs(w - sw[j - 1] - sw[j]) < min)
		{
			i = j;
			min = abs(w - sw[i] - sw[i - 1]);
		}
	}
	(*T) = (BiTree)malloc(sizeof(BiTNode));
	if (!(*T)) exit(OVERFLOW);
	KeyWordAssign(&((*T)->data.key), S.elem[i].key);
	if (i == low)
		(*T)->lchild = NULL;
	else
		SecondOptimal(&((*T)->lchild), S, sw, low, i - 1);
	if (i == high)
		(*T)->rchild = NULL;
	else
		SecondOptimal(&((*T)->rchild), S, sw, i + 1, high);
}


//队列函数
typedef BTNode* QElemType;
typedef struct QNode
{
	QElemType data;
	struct QNode* next;
}QNode, * QueuePtr;
typedef struct
{
	QueuePtr head, tail;
}LinkQueue;
Status InitQueue(LinkQueue* Q)
{
	Q->head = (QueuePtr)malloc(sizeof(QNode));
	if (!Q->head) exit(OVERFLOW);
	Q->tail = Q->head;
	Q->head->next = NULL;
	return OK;
}
Status EnQueue(LinkQueue* Q, QElemType e)
{
	QNode* p;
	p = (QNode*)malloc(sizeof(QNode));
	if (!p) exit(OVERFLOW);
	p->data = e;
	Q->tail->next = p;
	Q->tail = p;
	Q->tail->next = NULL;
	return OK;
}
Status DeQueue(LinkQueue* Q, QElemType* e)
{
	if (Q->head == Q->tail)
		return ERROR;
	QNode* p = Q->head->next;
	(*e) = p->data;
	Q->head->next = p->next;
	if (p == Q->tail)
		Q->tail = Q->head;
	free(p);
	return OK;
}
Status QueueEmpty(LinkQueue Q)
{
	if (Q.head == Q.tail)
		return TRUE;
	else
		return FALSE;
}

//B-树与B+树
void PrintBTree(BTree T)
{
	if (!T)
		printf("B-树为空\n");
	else
	{
		printf("B树层序输出为：\n");
		LinkQueue Q;
		InitQueue(&Q);
		EnQueue(&Q, T);
		QElemType p;
		while (!QueueEmpty(Q))
		{
			DeQueue(&Q, &p);
			int i = 0;
			while (i < p->keynum)
			{
				//KeyWordPrint(p->key[i]);
				TableElemPrint(*(p->recptr[i]));
				if (p->ptr[i])
					EnQueue(&Q, p->ptr[i]);
				i++;
			}
			if (p->ptr[i])
				EnQueue(&Q, p->ptr[i]);
		}
	}
}
int Search(BTree T, KeyType key)                                       //找B-树的一个节点中找记录，若找到，为找到记录的位置，未找到则为插入位置
{                                                                      //若树不存在，则位置为0
	int i = 0;
	while (T && i < T->keynum && LT(T->key[i], key))
		i++;
	return i;
}
Status SearchBTree(BTree T, KeyType key, Result* res)
{
	BTNode* p = T, * q = NULL;
	int found = FALSE;
	int i = 0;
	while (p && (found == FALSE))
	{
		i = Search(p, key);
		if (i < p->keynum && EQ(p->key[i], key))
			found = TRUE;
		else
		{
			q = p;
			p = p->ptr[i];
		}
	}
	if (found)
	{
		res->tag = TRUE;
		res->i = i;
		res->ptr = p;
	}
	else
	{
		res->tag = FALSE;
		res->i = i;
		res->ptr = q;
	}
	return OK;
}
Status CreatBTNode(BTree* T, ElemType e)
{
	(*T) = (BTree)malloc(sizeof(BTNode));
	if (!(*T)) exit(OVERFLOW);
	(*T)->keynum = 1;
	KeyWordAssign(&((*T)->key[0]), e.key);
	(*T)->recptr[0] = (ElemType*)malloc(sizeof(ElemType));
	if (!(*T)->recptr[0]) exit(OVERFLOW);
	TableElemAssign((*T)->recptr[0], e);
	return OK;
}
int Split(BTree T1, BTree T2)
{
	int split = ceil(GRADE / 2);
	T1->keynum = split - 1;
	T2->keynum = GRADE - split;
	split--;
	for (int i = split + 1; i < GRADE; i++)
	{
		KeyWordAssign(&(T2->key[i - split - 1]), T1->key[i]);
		T2->ptr[i - split - 1] = T1->ptr[i];
		T2->recptr[i - split - 1] = T1->recptr[i];
	}
	T2->ptr[GRADE - split - 1] = T1->ptr[GRADE];
	return split;
}
Status InsertBTree(BTree* ROOT, BTree* T, int pos, ElemType e, BTree T1, BTree T2)
{
	if (!(*T))
	{
		CreatBTNode(ROOT, e);
		(*ROOT)->parent = NULL;
		(*ROOT)->ptr[pos] = T1;
		(*ROOT)->ptr[pos + 1] = T2;
		(*T) = (*ROOT);
	}
	else
	{
		if ((*T)->keynum < GRADE)
		{
			int i = (*T)->keynum - 1;
			while (i >= pos)
			{
				(*T)->ptr[i + 2] = (*T)->ptr[i + 1];
				KeyWordAssign(&((*T)->key[i + 1]), (*T)->key[i]);
				(*T)->recptr[i + 1] = (*T)->recptr[i];
				i--;
			}
			KeyWordAssign(&((*T)->key[pos]), e.key);
			(*T)->recptr[pos] = (ElemType*)malloc(sizeof(ElemType));
			if (!(*T)->recptr[pos]) exit(OVERFLOW);
			TableElemAssign((*T)->recptr[pos], e);
			(*T)->ptr[pos] = T1;
			(*T)->ptr[pos + 1] = T2;
			(*T)->keynum++;
		}
		if ((*T)->keynum == GRADE)
		{
			BTNode* new;
			new = (BTNode*)malloc(sizeof(BTNode));
			if (!new) exit(OVERFLOW);
			int splitpos = Split((*T), new);
			int i = Search((*T)->parent, (*T)->key[splitpos]);
			InsertBTree(ROOT, &((*T)->parent), i, *((*T)->recptr[splitpos]), (*T), new);
			new->parent = (*T)->parent;
			(*T) = (*T)->parent;
		}
	}
	return OK;
}
Status Delete_BT(BTree* ROOT, BTree* T, int pos)
{
	int min = ceil(GRADE / 2) - 1;
	for (int i = pos; i <= (*T)->keynum - 2; i++)
	{
		KeyWordAssign(&((*T)->key[i]), (*T)->key[i + 1]);
		(*T)->recptr[i] = (*T)->recptr[i + 1];
	}
	(*T)->keynum--;
	if ((*T) == (*ROOT))
	{
		if ((*T)->keynum == 0)
			(*ROOT) = (*T)->ptr[0];
	}
	else
	{
		if ((*T)->keynum < min)
		{
			BTNode* parent = (*T)->parent;
			BTNode* lsibling = NULL, * rsibling = NULL, * helpsibling = NULL;
			int childpos = Search(parent, (*T)->key[pos]);
			if (childpos - 1 > 0)
				lsibling = parent->ptr[childpos - 1];
			if (childpos + 1 <= parent->keynum)
				rsibling = parent->ptr[childpos + 1];
			int tag = 0;
			if (lsibling)
			{
				tag = 1;
				helpsibling = lsibling;
			}
			if (rsibling)
			{
				tag = 2;
				helpsibling = rsibling;
			}
			if (lsibling && lsibling->keynum > min)
			{
				tag = 3;
				helpsibling = lsibling;
			}
			if (rsibling && rsibling->keynum > min)
			{
				tag = 4;
				helpsibling = rsibling;
			}
			int last;
			switch (tag)
			{
			case 1:
				last = helpsibling->keynum;
				KeyWordAssign(&(helpsibling->key[last]), parent->key[childpos - 1]);
				helpsibling->recptr[last] = (ElemType*)malloc(sizeof(ElemType));
				if (!helpsibling->recptr[last]) exit(OVERFLOW);
				helpsibling->recptr[last] = parent->recptr[childpos - 1];
				helpsibling->keynum++;
				last++;
				for (int i = 0; i < (*T)->keynum; i++)
				{
					KeyWordAssign(&(helpsibling->key[last + i]), (*T)->key[i]);
					helpsibling->recptr[last + i] = (ElemType*)malloc(sizeof(ElemType));
					if (!helpsibling->recptr[last + i]) exit(OVERFLOW);
					helpsibling->recptr[last + i] = (*T)->recptr[i];
					helpsibling->keynum++;
					helpsibling->ptr[last + i] = (*T)->ptr[i];
				}
				helpsibling->ptr[helpsibling->keynum] = (*T)->ptr[(*T)->keynum];
				for (int i = parent->keynum - 1; i >= childpos; i--)
					parent->ptr[i] = parent->ptr[i + 1];
				Delete_BT(ROOT, &parent, childpos - 1);
				break;
			case 2:
				last = (*T)->keynum;
				KeyWordAssign(&((*T)->key[last]), parent->key[childpos]);
				(*T)->recptr[last] = (ElemType*)malloc(sizeof(ElemType));
				if (!(*T)->recptr[last]) exit(OVERFLOW);
				(*T)->recptr[last] = parent->recptr[childpos];
				(*T)->keynum++;
				last++;
				for (int i = 0; i < helpsibling->keynum; i++)
				{
					KeyWordAssign(&((*T)->key[last + i]), helpsibling->key[i]);
					(*T)->recptr[last + i] = (ElemType*)malloc(sizeof(ElemType));
					if (!(*T)->recptr[last + i]) exit(OVERFLOW);
					(*T)->recptr[last + i] = helpsibling->recptr[i];
					(*T)->keynum++;
					(*T)->ptr[last + i] = helpsibling->ptr[i];
				}
				(*T)->ptr[(*T)->keynum] = helpsibling->ptr[helpsibling->keynum];
				for (int i = parent->keynum - 1; i >= childpos + 1; i--)
					parent->ptr[i] = parent->ptr[i + 1];
				Delete_BT(ROOT, &parent, childpos);
				break;
			case 3:
				(*T)->ptr[(*T)->keynum + 1] = (*T)->ptr[(*T)->keynum];
				for (int i = (*T)->keynum - 1; i > 0; i--)
				{
					KeyWordAssign(&((*T)->key[i + 1]), (*T)->key[i]);
					(*T)->recptr[i + 1] = (*T)->recptr[i];
					(*T)->ptr[i + 1] = (*T)->ptr[i];
				}
				KeyWordAssign(&((*T)->key[0]), parent->key[childpos - 1]);
				(*T)->recptr[0] = parent->recptr[childpos - 1];
				(*T)->keynum++;
				last = helpsibling->keynum;
				KeyWordAssign(&(parent->key[childpos - 1]), helpsibling->key[last - 1]);
				parent->recptr[childpos - 1] = helpsibling->recptr[last - 1];
				(*T)->ptr[0] = helpsibling->ptr[last];
				Delete_BT(ROOT, &helpsibling, last - 1);
				break;
			case 4:
				last = (*T)->keynum;
				KeyWordAssign(&((*T)->key[last]), parent->key[childpos]);
				(*T)->recptr[last] = parent->recptr[childpos];
				(*T)->keynum++;
				KeyWordAssign(&(parent->key[childpos]), helpsibling->key[0]);
				parent->recptr[childpos] = helpsibling->recptr[0];
				(*T)->ptr[(*T)->keynum] = helpsibling->ptr[0];
				for (int i = 0; i < helpsibling->keynum; i++)
					helpsibling->ptr[i] = helpsibling->ptr[i + 1];
				Delete_BT(ROOT, &helpsibling, 0);
				break;
			default:
				return ERROR;
			}
		}
	}
}
Status DeleteBTree(BTree* ROOT, BTree* T, int pos)
{
	if ((*T)->ptr[pos] != NULL)
	{
		Result res;
		SearchBTree((*T)->ptr[pos], (*T)->key[pos], &res);
		KeyWordAssign(&((*T)->key[pos]), res.ptr->key[res.i - 1]);
		(*T)->recptr[pos] = res.ptr->recptr[res.i - 1];
		Delete_BT(ROOT, &(res.ptr), res.i - 1);
	}
	else
		Delete_BT(ROOT, T, pos);
	return OK;
}

主函数：

//B-树主函数
int main()
{
	BTree T = NULL, ROOT = NULL;
	Result res;
	int count = 10;
	ElemType e;
	while (count)
	{
		InputTableElem(&e);
		SearchBTree(ROOT, e.key, &res);
		T = res.ptr;
		InsertBTree(&ROOT, &T, res.i, e, NULL, NULL);
		count--;
	}
	PrintBTree(ROOT);
	count = 10;
	printf("--------------------------------\n\n");
	while (count && ROOT)
	{
		printf("需要输入关键字以删除节点\n");
		InputTableElem(&e);
		SearchBTree(ROOT, e.key, &res);
		T = res.ptr;
		DeleteBTree(&ROOT, &T, res.i);
		PrintBTree(ROOT);
		printf("--------------------------------\n\n");
		count--;
	}
	return 0;
}

输入：（P245所示B树构造，然后将B树节点一一删去）

45
24
53
90
3
37
50
61
70
100

输出：

 删除45：

 以此类推以验证程序正确性

哆啦BCD梦
关注
[数据结构 C语言] 严蔚敏版 B-树：愿我心里没有B树
as12cs的博客
08-10 1114
B-树的算法实现最难的还是插入操作和删除操作。就连生成B-树也依赖着插入操作。InsertBTree函数比较好的解决方法还是模块化- 将插入之后结点的数目变化分情况讨论，将复杂的逻辑结构拆分成 1、插入结点操作Insert 2、结点分裂操作Split 3、寻找插入相应的位置的操作Search 4、建立新的根节点的操作NewRoot 四个函数，具体应用到各种情况的讨论中。 删除函数需要注意的是指针...
【数据结构】B树（B-Tree）
shangguan_1234的博客
11-12 1230
B树 1970年，R.Bayer和E.mccreight提出了一种适合外查找的树，它是一种平衡的多叉树，称为B树。（有些地方写的是B-树，注意不要误读 成"B减树"） 一棵M阶(M>2)的B树，是一棵平衡的M路平衡搜索树，可以是空树或者满足一下性质： 1. 根节点至少有两个孩子 2. 每个非根节点有[ ,M]个孩子 3. 每个非根节点有[ -1,M-1]个关键字，并且以升序排列 4.
数据结构之B树
靠脑袋是真滴记不住啊！！！！！！！！
05-08 824
1.0 简介 1970年，R.Bayer和E.mccreight提出了一种适用于外查找的树， 它是一种平衡的多叉树，称为B树（或B-树、B_树）。 一棵m阶B树(balanced tree of order m)是一棵平衡的m路搜索树。它或者是空树，或者是满足下列性质的树： 1、根结点至少有两个子女； 2、每个非根节点所包含的关键字个数 j 满足：┌m/2┐ - 1 &amp;amp;amp;lt;= j &amp;amp;amp;l...
9-9-B+树-查找-第9章-《数据结构》课本源码-严蔚敏吴伟民版
weixin_33894640的博客
06-21 149
课本源码部分 第9章  查找 - B+树 ——《数据结构》-严蔚敏.吴伟民版        源码使用说明  链接☛☛☛ 《数据结构-C语言版》（严蔚敏,吴伟民版）课本源码+习题集解析使用说明        课本源码合辑  链接☛☛☛ 《数据结构》课本源码合辑        习题集全解析  链接☛☛☛ 《数据结构题集》习题解析合辑          本源码引入的文件  链接☛ Base...
直接插入排序、冒泡排序、简单选择排序、快速排序
qq_64413974的博客
07-02 466
【问题描述】对待排序序列使用直接插入排序算法或冒泡排序算法或简单选择排序算法或快速排序算法进行排序，输出每一趟排序后的结果 【输入形式】序列元素个数 序列 【输出形式】 每一趟排序后的结果 【样例输入】618 6 28 93 46 551. 2.冒泡排序算法 3.简单选择排序算法 4.快速排序算法......
B_树定义与数据结构解析-严蔚敏《数据结构》
B树或类似的数据结构如B+树，能够有效地管理和检索这些多层次的数据，确保快速访问文件和子目录。 《数据结构》课程通常会涵盖各种数据结构，包括链表、栈、队列、树、图以及算法，如排序和搜索。学习数据结构对于...
B-树的各种操作 数据结构 严蔚敏
08-25
B-树的各种操作 C++ 数据结构 严蔚敏 完全是课本上的 花了好长时间
数据结构（严蔚敏版）
02-16
数据结构是计算机科学与技术领域中的核心课程之一，它研究如何在计算机中组织和存储数据，以便高效地访问和修改。严蔚敏教授编著的《数据结构》是一本广泛被采用的经典教材，深受广大计算机专业学生和研究人员的青睐...
数据结构 严蔚敏
02-03
《数据结构》是由著名计算机科学家严蔚敏教授编写的经典教材，主要针对C语言环境讲解数据结构这一核心的计算机科学概念。数据结构是计算机科学中处理数据存储和组织方式的一门学科，对于理解和设计高效的算法至关...
xiejunyan的平衡二叉树
sometime here
12-02 143
#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW -1 typedef int Status; typedef int KeyType; typedef struct RcdType { KeyType key; }RcdType; typedef struct BBSTNode { RcdType data; int height; struct BBSTNode* .
经典数据结构 [ B树，B+树 ]
热门推荐
我帅故我在
07-29 1万+
B 树是为了磁盘或其它存储设备而设计的一种多叉（下面你会看到，相对于二叉，B树每个内结点有多个分支，即多叉）平衡查找树。 B 树又叫平衡多路查找树。一棵m阶的B 树 (m叉树)的特性如下： 树中每个结点最多含有m个孩子（m>=2）； 除根结点和叶子结点外，其它每个结点至少有[ce
【数据结构】m阶B树的特点、插入 和 删除
✈ 正在努力 の 寒江（StudiousTiger) ✌ 呐 ✈
09-09 9039
预备知识：你需要知道什么是二叉搜索树。 一、m 阶 B 树的特点 在严蔚敏的《数据结构》一书中，说“一棵m阶的B树，或为空树，或为满足下列特征的m叉数。如下： 1、每个节点至多有m个子树，也就时一个节点至多有m-1个关键字 怎么理解这句话呢，我们并不能根据一个叉树的节点中的关键字的个数来判断该树的阶数。如果你是自学，或者很久之前学过，那么你可能会不理解这就话的含义。 也就是说一棵树的阶数不是由数本身决定的，而是由外部规定的，如下图： 我们并不能判断上树是几阶B书，因为我们并不知道“2”是不是最多，如果
数据结构---B树和B+树
一切为了考研
09-16 1361
今天看数据结构关于B树和B+树的那一块，感觉挺难得，所以将看的总结了下来，加深记忆吧。主要参考了严蔚敏的书和王道考研书P233. B树是一种多路平衡查找树，也叫B-树。主要定义如下       1.定义任意非叶子结点最多只有M个儿子；且M>2；        2.根结点的儿子数为[2, M]；        3.除根结点以外的非叶子结点的儿子数为[M/2, M]；        4.每个
B-树与B+树原理及实现
qq_42936727的博客
02-28 765
1、B-树定义释义 2、B-树的性质及实现 3、B+树的定义与性质
B树 B+树 红黑树
an2866的博客
01-18 503
B-Tree（B树） 具体讲解之前，有一点，再次强调下：B-树，即为B树。因为B树的原英文名称为B-tree，而国内很多人喜欢把B-tree译作B-树，其实，这是个非常不好的直译，很容易让人产生误解。如人们可能会以为B-树是一种树，而B树又是一种树。而事实上是，B-tree就是指的B树。特此说明。 m阶B树的M阶指的是所有结点中的子结点个数的最大值。 一个m阶B树是一棵空树，或者是...
通用型函数——冒泡排序
2401_84654619的博客
10-29 563
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
【进阶】java基础之集合(2)数据结构＜树＞
最新发布
Y0UZI的博客
11-05 275
二叉查找树，又称二叉排序树或者二叉搜索树。:任意节点左右子树高度差不超过1。
【数据结构篇】探索堆的算法的巧妙
braveact的博客
11-02 1037
⽤剩余的N-K个元素依次与堆顶元素来⽐较，不满⾜则替换堆顶元素 ，然后再将交换进去后的元素向下调整（保证这k个元素始终是堆），最后将剩余N-k个元素依次与堆顶元素⽐完之后，堆中剩余的K个元素就是所求的前k个最⼩或者最⼤的元素。对于Top-K问题，能想到的最简单直接的⽅式就是排序，但是：如果数据量⾮常⼤，排序就不太可取了 (可能数据都不能⼀下⼦全部加载到内存中)。依次将堆顶最大的数据与最后一个（不断发生变化）元素交换，每次都是将最大的数据放最后，可以想象一下，就是升序了。前k个最⼩的元素，则建⼤堆。
非线性数据结构之树
m0_61840987的博客
11-03 681
Fenwick 树与归并树都在区间查询中发挥着重要作用，但其适用场景不同。Fenwick 树适用于动态更新场景，而归并树适用于静态数据集的复杂查询。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值