【数据结构】堆

最新推荐文章于 2024-09-01 12:10:25 发布
最新推荐文章于 2024-09-01 12:10:25 发布
阅读量96 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/StandDev/article/details/132395070
版权

文章目录

一、堆的概念及结构

有一个集合 K = {k0 ， k1 ， k2 ， … ， kn-1} ，把它的所有元素按完全二叉树的顺序存储方式存储在一 个一维数组中 ，并满足： Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >=K2i+2) i = 0 ， 1 ， 2… ，（即双亲比孩子的数值小(大)）则称为小堆 ( 或大堆) 。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆的性质：堆中某个节点的值总是不大于或不小于其父节点的值；堆的逻辑结构是一棵完全二叉树。

在这里插入图片描述

二、堆的实现

1. 结构的定义

堆的元素按完全二叉树的顺序存储方式存储在一维数组中，所以堆的结构和顺序表的结构一样。

typedef int HeapDataType;

typedef struct heap
{
	HeapDataType* data;
	int size;
	int capacity;
}heap;

2. 堆的初始化

和顺序表一样，先在Init函数外创建一个堆变量，再把堆的地址传进初始化函数，创建一个空堆。

void InitHeap(heap* ph)
{
	assert(ph);
	ph->data = NULL;
	ph->capacity = 0;
	ph->size = 0;
}

3. 堆的插入

堆只能在尾部进行插入，由于堆要求在插入元素后仍保持堆的性质，所以我们需要对堆进行向上调整，把新插入的元素调整到正确的位置，向上调整的过程其实也是建堆的过程。

//小根堆
void HeapPush(heap* ph, HeapDataType x)
{
	assert(ph);
	if (ph->capacity == ph->size) //扩容
	{
		int newcapacity = ph->data == NULL ? 4 : ph->capacity * 2;
		HeapDataType* temp = (HeapDataType*)realloc(ph->data, sizeof(HeapDataType) * newcapacity);
		if (temp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		ph->data = temp;
		ph->capacity = newcapacity;
	}
	ph->data[ph->size] = x;
    //向上调整，保持堆结构
	AdjustUp(ph->data, ph->size);
	ph->size++;
}

4. 向上调整

这里以小根堆为例，如图：假设现在我们已经有了一个小根堆，现在我们往堆尾插入一个元素，那么可能会出现两种情况：

在这里插入图片描述

1、插入的元素大于父节点，此时我们的堆仍保持小根堆结构，所以不需要改动；比如我们往堆中插入30；

在这里插入图片描述

2、插入的元素小于父节点；这种情况下我们就需要把该节点不断往上调整，直到把堆调整为小根堆，最坏的情况是该节点被调整为根节点，比如我们插入10；

在这里插入图片描述

void Swap(HeapDataType* a, HeapDataType* b)
{
	assert(a && b);
	HeapDataType temp = *a;
	*a = *b;
	*b = temp;
}

//向上调整 - 小堆
void AdjustUp(HeapDataType* nums, int child)
{
	assert(nums);
	while (child > 0)//最坏调整到根节点停止
	{
		int parents = (child - 1) / 2;//父节点下标
		if (nums[child] < nums[parents]) //交换条件
		{
			Swap(&nums[child], &nums[parents]);
			child = parents;          //子节点取代父节点下标
		}
		else //否则直接退出，此时已经满足堆结构
		{
			break; 
		}
	}
}

如果我们需要调整大根堆，只需要把交换的条件修改一下即可。

if(nums[child] > nums[parents])

5. 堆的删除

对于堆的删除有明确的规定：我们只能删除堆顶的元素；但是头删之后存在两个问题：

1、顺序表头删需要挪动数据，效率低下；

2、挪动数据之后堆中各节点的父子关系完全破坏，很明显不满足堆的结构了；

对于上面的这些问题，我们有如下解决办法：

1、我们在删除之前先将堆顶和堆尾的元素交换，然后让size减一，这样相当于删除了堆顶的元素，且效率达到了O(1)；

2、由于我们把堆尾元素交换到了堆顶，堆的结构遭到了局部破坏，所以需要设计一个向下调整算法来保持堆的结构；

//小根堆
void HeapPop(heap* ph)
{
	assert(ph && ph->size > 0);
	Swap(ph->data, ph->data + ph->size - 1);
	ph->size--;
	AdjustDown(ph->data, ph->size, 0);
}

6. 向下调整

堆向下调整的思路和向上调整刚好相反 (还是以小根堆为例)：

1、找出子节点中较小的节点；2、比较父节点与较小子节点，如果父节点大于较小子节点则交换两个节点；3、交换之后，原来的子节点成为新的父节点，然后继续 1 2 步骤，直到调整为堆的结构。

注意：

  1. 向下调整算法比向上调整多一个参数size，因为向下调整需要判断子节点不能超过堆的范围

  2. 向下调整算法有一个前提：左右子树必须都是堆，才能调整。

在这里插入图片描述

void Swap(HeapDataType* a, HeapDataType* b)
{
	assert(a && b);
	HeapDataType temp = *a;
	*a = *b;
	*b = temp;
}

//向下调整 - 小堆
void AdjustDown(HeapDataType* nums, int size, int sub)
{
	assert(nums);
	int parents = sub;
	int minchild = parents * 2 + 1;//先默认最小孩子为左孩子
	//当子结点超过堆的范围就结束
	while (minchild < size)
	{
        //选出真正的较小子节点
		if (minchild + 1 < size && nums[minchild + 1] < nums[minchild])
		{
			minchild++;
		}
		//如果父节点大于最小的子结点，就交换双方位置
		if (nums[parents] > nums[minchild])
		{
			Swap(nums + parents, nums + minchild);
			//迭代
			parents = minchild;
			minchild = parents * 2 + 1;
		}
		//否则不用向下调整，直接跳出循环
		else
		{
			break;
		}
	}
}

和向上调整类似，如果我们想要向下调整为大堆，也只需要改变交换条件：

//选出真正的较大子节点
if (minchild + 1 < size && nums[minchild + 1] > nums[minchild])
//如果父节点小于最大的子结点，就交换双方位置
if (nums[parents] < nums[minchild])

7、取出堆顶的元素

HeapDataType HeapTop(heap* ph)
{
	assert(ph && ph->size > 0);
	return ph->data[0];
}

8、返回堆的元素个数

int HeapSize(heap* ph)
{
	assert(ph);
	return ph->size;
}

9、判断堆是否为空

bool IsHeapEmpty(heap* ph)
{
	assert(ph);
	return ph->size == 0;
}

10、打印堆中的数据

void PrintHeap(heap* ph)
{
	assert(ph);
	for (int i = 0; i < ph->size; i++)
	{
		printf("%d ", ph->data[i]);
	}
	printf("\n");
}

11、堆的销毁

void DestroyHeap(heap* ph)
{
	assert(ph);
	free(ph->data);
	ph->capacity = 0;
	ph->size = 0;
}

三、堆的应用

1. 堆排序

堆排序是选择排序的一种，它的时间复杂度为 O(N*logN)，空间复杂度为 O(1)，是一种十分优秀的排序算法，主要步骤就是建堆和选择数。

建堆

建堆有两种方法：向上调整建堆和向下调整建堆。

向上调整建堆： 把数组的第一个元素作为堆的根节点，然后把其余元素看作插入结点在堆末尾插入，每插入一个元素就向上调整一次，从而始终保证堆的结构；

在这里插入图片描述

向上调整建堆的时间复杂度： 由于堆是完全二叉树，而满二叉树是完全二叉树的一种，所以此处为了简化计算，使用满二叉树来求时间复杂度

在这里插入图片描述

如上图，我们把每一层的节点个数乘以每一个节点需要调整的次数，最后再求和，就可以得到一共需要调整的次数；然后再根据满二叉树节点总数与树的高度的关系将表达式中的h替换掉，最终可以得到向上调整建堆的时间复杂度为：O(N*logN)；

向下调整建堆： 从倒数第一个非叶子节点 (即最后一个叶子节点的父节点) 开始向下调整，直到调整到根。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dois3qci-1692531353764)(C:\Users\86185\AppData\Roaming\Typora\typora-user-images\image-20230818180009394.png)]

向下调整建堆的时间复杂度： 使用满二叉树来求时间复杂度

在这里插入图片描述

如上图，向下调整建堆的时间复杂度为：O(N)，比向上调整的效率更高，这似乎有点反直觉，因为两者看起来并没有什么本质的不同，无非就是方向相反，但是简单分析就能发现原因，因为向下调整随着调整次数的增大，需要调整的结点越来越少，两者相乘就不会特别大，另外最后一层（接近一半的结点）是不需要调整的。

综合上面两种建堆方法，最好选择向下调整建堆，建堆的时间复杂度为：O(N)；

选数

建堆完成后，接下来就是选数，假设现在我们要排降序，那么方法一共有两种：

1、建大堆：开辟一个和原数组同等大小的新数组，然后对原数组建大堆，每次取出堆顶的元素 (最大的元素) 按顺序放在新数组中，最后再将新数组中的数据覆盖至原数组；

缺点：需要开辟额外的空间，删除堆顶元素后向下调整的时间复杂度是O(logN)，所以嵌套后时间复杂度：O(N*logN)，空间复杂度：O(N)；

2、建小堆：先对原数组建小堆，然后将堆顶和堆尾的数据进行交换，使得数组中最小的元素处于数组末尾，然后向下调整前n - 1个元素，使得次小的数据位于堆顶，最后重复前面的步骤，把次小的数据存放到最小的数据之前，直到数组有序；

优点：没有额外的空间消耗，且时间复杂度达到了 O(N*logN)；

综合上面两种选数的方法，选数的时间复杂度为：O(N*logN)，空间复杂度为：O(1)；

void Swap(HeapDataType* a, HeapDataType* b)
{
	assert(a && b);
	HeapDataType temp = *a;
	*a = *b;
	*b = temp;
}

//向下调整 - 小堆
void AdjustDown(HeapDataType* nums, int size, int sub)
{
	assert(nums);
	int parents = sub;
	int minchild = parents * 2 + 1;//先默认最小孩子为左孩子
	//当子结点超过堆的范围就结束
	while (minchild < size)
	{
        //选出真正的较小子节点
		if (minchild + 1 < size && nums[minchild + 1] < nums[minchild])
		{
			minchild++;
		}
		//如果父节点大于最小的子结点，就交换双方位置
		if (nums[parents] > nums[minchild])
		{
			Swap(nums + parents, nums + minchild);
			//迭代
			parents = minchild;
			minchild = parents * 2 + 1;
		}
		//否则不用向下调整，直接跳出循环
		else
		{
			break;
		}
	}
}

//升序 -> 建大根堆
//降序 -> 建小根堆
void HeapSort(int* nums, int numsSize)
{
	//建堆method1：插入法 向上调整 O(N * logN)
	/*for (int i = 1; i < numsSize; i++)
	{
		AdjustUp(nums, i);
	}*/
	
	//建堆method2：向下调整 O(N)
	for (int i = (numsSize - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(nums, numsSize, i);
	}
    
    //选数
	//降序 -> 小根堆 -> 向下调整 O(N * logN) 
	while (numsSize > 1)
	{
		Swap(nums, nums + numsSize - 1);
		AdjustDown(nums, --numsSize, 0);
	}
}

int main()
{
	int nums[] = { 10, 26, 85, 4, 23, 14, 12, 36, 16 };
	HeapSort(nums, sizeof(nums) / sizeof(int));
	for (int i = 0; i < sizeof(nums) / sizeof(int); i++)
	{
		printf("%d ", nums[i]);
	}
	printf("\n");
    return 0;
}

在这里插入图片描述

2. Topk问题

TOP-K问题：即求数据集合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大，无法排序；比如：世界500强、富豪榜、王者荣耀巅峰前十等。

对于Top-K问题，能想到的最简单直接的方式就是排序，但是，如果数据量非常大，排序就不太可取了 (数据都不能一下子全部加载到内存中)，最佳的方式就是用堆来解决，基本思路如下：

  1. 用数据集合的前K个元素来建堆， 求前k个最大的元素，则建小堆，反之则建大堆；

  2. 用剩余的N-K个元素依次与堆顶元素来比较，满足条件则替换堆顶元素，并向下调整保持堆的结构；

void Swap(HeapDataType* a, HeapDataType* b)
{
	assert(a && b);
	HeapDataType temp = *a;
	*a = *b;
	*b = temp;
}

//向下调整 - 小堆
void AdjustDown(HeapDataType* nums, int size, int sub)
{
	assert(nums);
	int parents = sub;
	int minchild = parents * 2 + 1;//先默认最小孩子为左孩子
	//当子结点超过堆的范围就结束
	while (minchild < size)
	{
        //选出真正的较小子节点
		if (minchild + 1 < size && nums[minchild + 1] < nums[minchild])
		{
			minchild++;
		}
		//如果父节点大于最小的子结点，就交换双方位置
		if (nums[parents] > nums[minchild])
		{
			Swap(nums + parents, nums + minchild);
			//迭代
			parents = minchild;
			minchild = parents * 2 + 1;
		}
		//否则不用向下调整，直接跳出循环
		else
		{
			break;
		}
	}
}

int* Topk(int* nums, int numsSize, int k)
{
	int* ans = (int*)malloc(sizeof(int) * k);
	if (ans == NULL)
	{
		perror("Topk");
		exit(-1);
	}
	for (int i = 0; i < k; i++)
	{
		ans[i] = nums[i];
	}
    //向下建堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(ans, k, i);
	}
	for (int i = k; i < numsSize; i++)
	{
		if (nums[i] > ans[0]) //如果数组中其他元素大于堆顶元素
		{
			ans[0] = nums[i]; //替换堆顶元素
			AdjustDown(ans, k, 0); //向下调整保持堆的结构
		}
	}
	return ans;
}

int main()
{
	srand((unsigned int)time(NULL)); //用时间戳产生随机数种子
	int* nums = (int*)malloc(sizeof(int) * 10000);
	if (nums == NULL)
	{
		perror("TestTopk");
		exit(-1);
	}
    //生成10000个小于10000的整数
	for (int i = 0; i < 10000; i++)
	{
		nums[i] = rand() % 10000;
	}
    //生成10个大于10000的整数
	for (int i = 0; i < 10; i++)
	{
		nums[rand() % 10000] = 10000 + i;
	}
	int* ans = Topk(nums, 10000, 10);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ans[i]);
	}
	printf("\n");
	free(ans);
	ans = NULL;
	free(nums);
	nums = NULL;
    return 0;
}

在这里插入图片描述

四、完整代码

Heap.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>

typedef int HeapDataType;

typedef struct heap
{
	HeapDataType* data;
	int size;
	int capacity;
}heap;

//初始堆
void InitHeap(heap* ph);

//打印堆
void PrintHeap(heap* ph);

//往堆里插入数据
void HeapPush(heap* ph, HeapDataType x);

//删除堆的首元素
void HeapPop(heap* ph);

//获取堆的首元素
HeapDataType HeapTop(heap* ph);

//判断堆是否为空
bool IsHeapEmpty(heap* ph);

//求堆的大小
int HeapSize(heap* ph);

//销毁堆
void DestroyHeap(heap* ph);

//堆排序
void HeapSort(int* nums, int numsSize);

//Topk
int* Topk(int* nums, int numsSize, int k);

Heap.c

#include"heap.h"

void InitHeap(heap* ph)
{
	assert(ph);
	ph->data = NULL;
	ph->capacity = 0;
	ph->size = 0;
}

void PrintHeap(heap* ph)
{
	assert(ph);
	for (int i = 0; i < ph->size; i++)
	{
		printf("%d ", ph->data[i]);
	}
	printf("\n");
}

void Swap(HeapDataType* a, HeapDataType* b)
{
	assert(a && b);
	HeapDataType temp = *a;
	*a = *b;
	*b = temp;
}

//向上调整 - 小堆
void AdjustUp(HeapDataType* nums, int child)
{
	assert(nums);
	while (child > 0)
	{
		int parents = (child - 1) / 2;
		if (nums[child] < nums[parents])
		{
			Swap(&nums[child], &nums[parents]);
			child = parents;
		}
		else
		{
			break;
		}
	}
}

//向下调整 - 小堆
void AdjustDown(HeapDataType* nums, int size, int sub)
{
	assert(nums);
	int parents = sub;
	int minchild = parents * 2 + 1;//先默认最小孩子为左孩子
	//当子结点超过堆的范围就结束
	while (minchild < size)
	{
		if (minchild + 1 < size && nums[minchild + 1] < nums[minchild])
		{
			minchild++;
		}
		//如果父节点大于最小的子结点，就交换双方位置
		if (nums[parents] > nums[minchild])
		{
			Swap(nums + parents, nums + minchild);
			//迭代
			parents = minchild;
			minchild = parents * 2 + 1;
		}
		//否则不用向下调整，直接跳出循环
		else
		{
			break;
		}
	}
}

//小根堆
void HeapPush(heap* ph, HeapDataType x)
{
	assert(ph);
	if (ph->capacity == ph->size) //扩容
	{
		int newcapacity = ph->data == NULL ? 4 : ph->capacity * 2;
		HeapDataType* temp = (HeapDataType*)realloc(ph->data, sizeof(HeapDataType) * newcapacity);
		if (temp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		ph->data = temp;
		ph->capacity = newcapacity;
	}
	ph->data[ph->size] = x;
	AdjustUp(ph->data, ph->size);
	ph->size++;
}

//小根堆
void HeapPop(heap* ph)
{
	assert(ph && ph->size > 0);
	Swap(ph->data, ph->data + ph->size - 1);
	ph->size--;
	AdjustDown(ph->data, ph->size, 0);
}

HeapDataType HeapTop(heap* ph)
{
	assert(ph && ph->size > 0);
	return ph->data[0];
}

bool IsHeapEmpty(heap* ph)
{
	assert(ph);
	return ph->size == 0;
}

int HeapSize(heap* ph)
{
	assert(ph);
	return ph->size;
}

void DestroyHeap(heap* ph)
{
	assert(ph);
	free(ph->data);
	ph->capacity = 0;
	ph->size = 0;
}


//升序 -> 大根堆
//降序 -> 小根堆
void HeapSort(int* nums, int numsSize)
{
	//建堆method1：插入法 向上调整 O(N * logN)
	/*for (int i = 1; i < numsSize; i++)
	{
		AdjustUp(nums, i);
	}*/
	
	//建堆method2：向下调整 O(N)
	for (int i = (numsSize - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(nums, numsSize, i);
	}
	//降序 - 小根堆 - 向下调整 O(N * logN) 
	while (numsSize > 1)
	{
		Swap(nums, nums + numsSize - 1);
		AdjustDown(nums, --numsSize, 0);
	}
}

int* Topk(int* nums, int numsSize, int k)
{
	int* ans = (int*)malloc(sizeof(int) * k);
	if (ans == NULL)
	{
		perror("Topk");
		exit(-1);
	}
	for (int i = 0; i < k; i++)
	{
		ans[i] = nums[i];
	}
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(ans, k, i);
	}
	for (int i = k; i < numsSize; i++)
	{
		if (nums[i] > ans[0])
		{
			ans[0] = nums[i];
			AdjustDown(ans, k, 0);
		}
	}
	return ans;
}

test.c

#include"heap.h"
#include<time.h>

void TestHeap()
{
	heap H;//创建堆变量
	InitHeap(&H);
	int nums[] = { 10, 26, 85, 4, 23, 14, 12, 36, 16 };
	for (int i = 0; i < sizeof(nums) / sizeof(int); i++)
	{
		HeapPush(&H, nums[i]);
	}
	PrintHeap(&H);
	int n = sizeof(nums) / sizeof(int);
	while (n--)
	{
		printf("%d ", HeapTop(&H));
		HeapPop(&H);
	}
}

void TestHeapSort()
{
	int nums[] = { 10, 26, 85, 4, 23, 14, 12, 36, 16 };
	HeapSort(nums, sizeof(nums) / sizeof(int));
	for (int i = 0; i < sizeof(nums) / sizeof(int); i++)
	{
		printf("%d ", nums[i]);
	}
	printf("\n");
}

void TestTopk()
{
	srand((unsigned int)time(NULL));
	int* nums = (int*)malloc(sizeof(int) * 10000);
	if (nums == NULL)
	{
		perror("TestTopk");
		exit(-1);
	}
	for (int i = 0; i < 10000; i++)
	{
		nums[i] = rand() % 10000;
	}
	for (int i = 0; i < 10; i++)
	{
		nums[rand() % 10000] = 10000 + i;
	}
	int* ans = Topk(nums, 10000, 10);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ans[i]);
	}
	printf("\n");
	free(ans);
	ans = NULL;
	free(nums);
	nums = NULL;
}

int main()
{
	//TestHeap();
	//TestHeapSort();
	TestTopk();
	return 0;
}
}

void TestHeapSort()
{
	int nums[] = { 10, 26, 85, 4, 23, 14, 12, 36, 16 };
	HeapSort(nums, sizeof(nums) / sizeof(int));
	for (int i = 0; i < sizeof(nums) / sizeof(int); i++)
	{
		printf("%d ", nums[i]);
	}
	printf("\n");
}

void TestTopk()
{
	srand((unsigned int)time(NULL));
	int* nums = (int*)malloc(sizeof(int) * 10000);
	if (nums == NULL)
	{
		perror("TestTopk");
		exit(-1);
	}
	for (int i = 0; i < 10000; i++)
	{
		nums[i] = rand() % 10000;
	}
	for (int i = 0; i < 10; i++)
	{
		nums[rand() % 10000] = 10000 + i;
	}
	int* ans = Topk(nums, 10000, 10);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ans[i]);
	}
	printf("\n");
	free(ans);
	ans = NULL;
	free(nums);
	nums = NULL;
}

int main()
{
	//TestHeap();
	//TestHeapSort();
	TestTopk();
	return 0;
}
岸边露伴'
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构堆
11-08
堆结构是数据结构的重要组成部分，它是一种特殊的完全二叉树，具有结构性和有序性两个主要特性。结构性是指用数组表示的完全二叉树，即对于数组中的任意位置i（从1开始计数），其左子节点的位置是2i，右子节点的位置...
数据结构 堆
08-17
堆的实现，能够进行插入建堆，插入，删除，判空等操作
数据结构——堆
漫漫无期的博客
10-10 5651
一、概念及其介绍 堆(Heap)是计算机科学中一类特殊的数据结构的统称。 堆通常是一个可以被看做一棵完全二叉树的数组对象。 堆满足下列性质： 堆中某个节点的值总是不大于或不小于其父节点的值。 堆总是一棵完全二叉树。 二、适用说明 堆是利用完全二叉树的结构来维护一组数据，然后进行相关操作，一般的操作进行一次的时间复杂度在O(1)~O(logn)之间，堆通常用于动态分配和释放程序所使用的对象。 若为优先队列的使用场景，普通数组或者顺序数组，最差情况为O(n^2)，堆这种数据结构也可以提高入队...
数据结构之堆
qq_34270874的博客
03-05 3万+
目录一、堆1. 概念2. 性质3. 结构二、堆的实现1. 算法实现：（1）向下调整算法（2）向上调整算法(堆的创建)（3）堆的插入（4）堆的删除（5）堆的排序2. 代码实现(小堆)：（1）堆的定义（2）交换（3）检查容量（4）向下调整（5）向上调整（6）堆的初始化（7）堆的创建（8）销毁堆（9）堆的插入（10）堆的删除（11）获取堆顶元素（12）判空（13）堆排序（14）打印堆 一、堆 1. 概念 如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式
Java数据结构之堆
qq_39537400的博客
03-29 4344
堆的概念 堆逻辑上是一棵完全二叉树 堆物理上是保存在数组中 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆 反之，则是小堆，或者小根堆，或者最小堆 堆的基本作用是快速找集合中的最值 二叉树的顺序存储 使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中。 一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。 这种方式的用法就是堆的表示。 顺序存储中的双亲与孩子的下标关系 已知双亲的下标： 左孩子下标 = 2*parent+1; 右孩子下标 = 2*parent
堆(Heap)数据结构
云原生Java Web领域技术博客
04-09 1958
在阅读本文前，需要明确的是，这里的“堆”是一种数据结构，而不是JVM里的垃圾回收里的堆存储结构。堆可看成一种特殊的树，这里以二叉堆为例介绍堆。
数据结构之堆的详解
qq_45726327的博客
06-12 2311
堆是一种特殊的完全二叉树堆分为小根堆和大根堆,大根堆的根节点值最大,小根堆的根节点值最小最小堆大根堆。
数据结构——【堆】详解
Lucky_mzc的博客
03-08 7139
一. 堆🌲 1. 堆的概念 堆（heap）：一种有特殊用途的数据结构——用来在一组变化频繁（发生增删查改的频率较高）的数据集中查找最值。 堆在物理层面上，表现为一组连续的数组区间：long[] array ；将整个数组看作是堆。 堆在逻辑结构上，一般被视为是一颗完全二叉树。 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆；反之，则是小堆，或者小根堆，或者最小堆。当一个堆为大堆时，它的每一棵子树都是大堆。 2. 堆的存储方式 从堆的概念可知，堆是一棵完全二叉树，
数据结构(全)
热门推荐
s6664的博客
06-21 6万+
线性结构, 树形结构, 图结构, 排序, 查找, 数据结构, 算法
学习数据结构堆.rar
07-19
本资料包"学习数据结构堆.rar"显然是为了帮助学习者深入理解堆的概念、特性和应用。 堆通常分为两种类型：最大堆和最小堆。在最大堆中，每个父节点的值都大于或等于其子节点的值，而根节点是整个堆中最大的元素。...
C++ 数据结构 堆排序的实现
01-20
堆排序（heapsort）是一种比较快速的排序方式，它的时间复杂度为O(nlgn)，并且堆排序具有空间原址性，任何时候只需要有限的空间来存储临时数据。我将用c++实现一个堆来简单分析一下。 堆排序的基本思想为： 1、升序...
数据结构-顺序表-详解
2401_86587256的博客
08-29 1223
数据结构初阶部分，顺序表的详解。
集合及数据结构第十三节（下）———— 枚举与Lambda表达式
2301_79418684的博客
08-27 1255
枚举与枚举的使用 1. 什么是C语言 2. 数据类型 3. 变量、常量 4. 字符串+转义字符+注释 5. 选择语句 6. 循环语句 7. 函数 8. 数组 9. 操作符 10. 常见关键字 11. define 定义常量和宏 12. 指针 13. 结构体
【数据结构-二维前缀和】【含空间优化】力扣3070. 元素和小于等于 k 的子矩阵的数目
sjsjs11的博客
08-29 400
col_sum[j]在遍历行的时候，也会依次计算该列的元素和，要计算前缀和s，实际上就是目前该列的元素和逐列累加，当发现s大于k的时候，那么就停止该行接下来的前缀和，继续计算下一行第一列开始的前缀和，继续遍历行的某个位置的前缀和。这种方法就是传统的前缀和做法，在这道题中，如果group[i][j]小于k，则继续遍历，然后count增加，如果group[i][j]大于k，说明不需要继续遍历这一行接下来列的前缀和了，直接开始计算新一行每一列的前缀和。返回包含 grid 左上角元素、元素和小于或等于 k 的。
数据结构（邓俊辉）学习笔记】串 06——KMP算法：构造next[]表
weixin_44399845的博客
08-27 805
KMP算法：构造next[]表
Linux 数据结构 链表
mxyzhy的博客
08-28 416
单向链表操作
【数据结构取经之路】位图全解
最新发布
bit_pan的博客
09-01 658
位图（Bitmap）是一种非常高效的数据结构，主要用于处理大量数据的快速查找、去重等操作。它利用每一位（bit）来表示某个元素是否存在或某种状态，从而极大地节省了存储空间。在内存和存储空间相对受限的环境下，位图尤其有用。下面，我们先瞅一眼C++标准库里的位图，然后再抽出它的核心部分来自己实现。
数据结构 链表
2301_79898193的博客
08-28 382
1.链表可以动态的增加或者减少节点，而顺序表在一开始就定义了大小，扩展或缩小数组会涉及内存的重新分配，效率低下；2.插入和删除效率 链表更容易时间复杂度为O（1），顺序表需要整个移动大量资源时间复杂度为O(n);3.链表的内存可以是碎片化不连续的内存，而顺序表一定是需要连续的内存，会出现浪费行为。数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。4.链表的插入和删除效率很高。
数据结构之内核链表，栈，队列
2301_78503818的博客
08-29 303
栈和队列都是特殊的表状结构，和之前叙述的顺序表链式表一致，但特点在于顺序表链式表表可以在任意位置插入和删除，而栈和队列只允许在固定位置插入和删除。今天主要学习了内核链表，顺序栈，链式栈，顺序队列，链式队列的相关内容。出栈（弹栈）：将数据元素从栈顶位置取出。栈底：不允许入栈和出栈的一端称为栈底。栈顶：允许入栈出栈的一端称为栈顶。入栈（压栈）：将数据元素放入栈顶。1.一种链表结构能够操作多种类型的数据对象。定义的相关函数接口可查看内核链表的开源代码。二. 栈（FILO：先进后出）
scau 数据结构堆排序
06-09
堆排序是一种基于比较的排序算法，利用堆这种数据结构中的性质进行排序。堆是一种完全二叉树，分为大根堆和小根堆，大根堆的每个节点的值都大于其左右子节点的值，小根堆的每个节点的值都小于其左右子节点的值。 堆...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值