本篇博客梳理一个重要的数据结构——堆
注意:若无特殊说明,默认是小堆进行分析
一、堆的概念与分类
1.堆是完全二叉树
2.大堆:父亲≥孩子;小堆:父亲≤孩子
注意:兄弟之间无法确定大小关系
typedef int HPDataType;
typedef struct Heap//堆
{
HPDataType* a;
int size;//有效数据个数
int capacity;//空间容量大小
}Heap;
二、堆的向上/向下调整算法(以小堆为例,大堆反之)
1.向上调整算法
目标节点与所有祖先比较,若父亲≥孩子,则交换
void adjustUp(HPDataType* a,int child)
{
int parent = (child-1)/2;
while (child > 0)
{
if (a[child] < a[parent])//为满足小堆条件,要进行交换
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
2.向下调整算法
目标节点与左右子结点中较小者比较,若父亲≥孩子,则交换
注意:前提是目标节点的左右子树都要满足堆
void Swap(HPDataType* x, HPDataType* y)
{
HPDataType tmp = *x;
*x = *y;
*y = tmp;
}
void adjustDown(HPDataType* a, int size,int parent)
{
int child = 2 * parent + 1;
while (child < size)
{
//找出小的那个孩子
if (child + 1 < size && a[child] > a[child + 1])
{
child++;
}
//此时child下标对应的是较小的那个孩子
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = 2 * parent + 1;
}
else
{
break;
}
}
}
三、堆的实现
1.创建堆(向上调整or向下调整)
先说结论:向下调整建堆时间复杂度更优
(1)向上调整建堆
从第二个结点开始往后依次遍历,有需要就调整
特点:节点数量多的层调整次数也多,节点数量少的层调整次数少
时间复杂度:o(N·logN)
时间复杂度证明:假设树的高度为h,h从1开始
void adjustUp(HPDataType* a,int child)
{
int parent = (child-1)/2;
while (child > 0)
{
if (a[child] < a[parent])//为满足小堆条件,要进行交换
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
(2)向下调整建堆(更优)
从最后一个结点的父结点开始,往前依次遍历,有需要就调整
思想:先把小的树调成堆,再逐层往上,不断扩大“堆的势力范围”
特点:节点数量多的层调整次数少,节点数量少的层调整次数多
时间复杂度:o(N)
时间复杂度证明:假设树的高度为h,h从1开始
void adjustDown(HPDataType* a, int size,int parent)
{
int child = 2 * parent + 1;
while (child < size)
{
//找出小的那个孩子
if (child + 1 < size && a[child] > a[child + 1])
{
child++;
}
//此时child下标对应的是较小的那个孩子
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = 2 * parent + 1;
}
else
{
break;
}
}
}
2.堆的插入
先尾插,再进行向上调整算法
void HeapPush(Heap* hp, HPDataType x)//堆的插入(向上调整算法)
{
assert(hp);
if (hp->size == hp->capacity)//数组已满,需要扩容
{
int newcapacity = (hp->capacity == 0) ? 4 : 2 * (hp->capacity);
HPDataType* arr = (HPDataType*)realloc(hp->a,sizeof(HPDataType) * newcapacity);
if (arr == NULL)
{
perror("malloc failed");
return;
}
hp->a = arr;
hp->capacity = newcapacity;
}
hp->a[hp->size] = x;
hp->size++;
adjustUp(hp->a,hp->size-1);
}
3.堆的删除:删除堆顶的数据
将堆顶的数据和最后一个数据交换,再删除数组最后一个数据,最后进行向下调整算法
(1)交换再删除的目的:保证其余父子关系不乱。如果直接删除堆顶数据,再将其余元素往前挪动一个位置,会导致父子关系乱掉
(2)如果是小堆,即可保证每次删掉的数据都是最小的数据,并且每删一次,次小的数据会到达堆顶(保证了删除的有序性),从小到大删(大堆反之)
(3)时间复杂度分析
假设树节点个数为N,则树高为h=log(N+1),由于一个节点换到堆顶最多往下调(h-1)次,因此时间复杂度为o(logN)
void HeapPop(Heap* hp)//堆的删除
{
assert(hp);
assert(hp->size > 0);
Swap(&hp->a[0], &hp->a[hp->size - 1]);//交换堆顶和最后一个数据
hp->size--;//删除最后一个数据
adjustDown(hp->a, hp->size , 0);//向下调整
}
四、堆排序与TopK问题
1.堆排序
(1)第一步:建堆,如果要排成降序则建小堆,排成升序则建大堆
(2)第二步:利用堆删除思想进行排序
在这里读者可能会有疑问,为什么排成降序要建小堆,建大堆的话最大的不是直接在堆顶了么?原因分析放在后面
具体的操作步骤如下
①交换最后一个元素和堆顶元素
②堆顶元素向下调整
③换到最后的数据不看做堆内数据(“伪删除”)
例如:想把9 7 8 5 2 4 6 1排成降序,则需要先建成小堆
void Swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
//向下调整算法
void adjustDown(int* arr, int size, int parent)
{
int child = 2 * parent + 1;
while (child < size)
{
//找出较小的孩子
if (child + 1 < size && arr[child] > arr[child + 1])
{
child++;
}
//开始调整,交换元素
if (arr[parent] > arr[child])
{
Swap(&arr[parent], &arr[child]);
parent = child;
child = 2 * parent + 1;
}
else
{
break;
}
}
}
void HeapSort(int* a, int size, int parent)//堆排序
{
int end = size - 1;
while (end >= 0)
{
Swap(&a[0], &a[end]);//交换堆顶元素和最后一个数据
adjustDown(a, end, 0);//堆顶元素进行向下调整算法
end--;//最后一个数据不看做堆内元素,“伪删除”
}
}
int main()
{
int arr[] = { 9,7,8,5,2,4,6,1 };
int size = sizeof(arr) / sizeof(arr[0]);
//建堆,用向下调整算法,逐个子树调,最后到整棵树
for (int i = ((size - 1) - 1) / 2; i >= 0; i--)//((size - 1) - 1) / 2是最后一个结点的父结点
{
adjustDown(arr, size, i);//向下调整建堆
}
//堆排序
HeapSort(arr, size, 0);
for (int i = 0; i < size; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
现在来分析一下,为什么排成降序不建大堆?
以9 7 8 5 2 4 6 1为例,如果建立大堆,那么建堆之后9在堆顶不能动了,剩下的元素要排序只能重新建堆,导致父子关系全乱,比较麻烦,所以排成降序推荐建小堆
2.TopK问题
求数据集合中前K个最大的或者最小的元素,一般情况下数据量比较大
例:在N个数中找出最大的前k个
(1)方法一
①建一个N个数的大堆(向下调整算法建堆),时间复杂度o(N)
②pop(删除)操作k次,记录下每次删除的数据,时间复杂度o(k*logN),即o(logN)
合计的时间复杂度:o(N)
缺陷:当N很大时内存存不下
(2)方法二(空间上提升很多)
①用数据集合中前k个元素来建堆——建小堆
②用剩余的N-K个元素依次与堆顶元素比较,如果比堆顶的数据大,就替换堆顶,然后向下调整
- 优势分析:大的数据来了则必进堆(比如k=10,则排名第1到第9的数据都不会挡在堆顶)
- 时间复杂度分析
建堆:o(k),也就是o(1)
向下调整过程:最坏就是每次进堆都要调整到最后一层,o((N-K)*log(k+1)),【结点数为k,则树高log(k+1)】
合计时间复杂度:o(N)
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void CreateNDate()
{
// 造数据
int n = 20;
srand(time(0));
const char* file = "data.txt";
FILE* fin = fopen(file, "w");
if (fin == NULL)
{
perror("fopen error");
return;
}
for (size_t i = 0; i < n; ++i)
{
int x = rand() % 20;
fprintf(fin, "%d\n", x);
}
fclose(fin);
}
void Swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
//向下调整算法
void adjustDown(int* arr, int size, int parent)
{
int child = 2 * parent + 1;
while (child < size)
{
//找出较小的孩子
if (child + 1 < size && arr[child] > arr[child + 1])
{
child++;
}
//开始调整,交换元素
if (arr[parent] > arr[child])
{
Swap(&arr[parent], &arr[child]);
parent = child;
child = 2 * parent + 1;
}
else
{
break;
}
}
}
void PrintTopK(int k,int n)
{
FILE* pf = fopen("data.txt", "r");
if (pf == NULL)
{
perror("fopen error");
return;
}
int* arr = (int*)malloc(sizeof(int) * k);
for (int i = 0; i < k; i++)
{
fscanf(pf, "%d", &arr[i]);
}
//建堆,用向下调整算法,逐个子树调,最后到整棵树
for (int i = ((k - 1) - 1) / 2; i >= 0; i--)//((size - 1) - 1) / 2是最后一个结点的父结点
{
adjustDown(arr, k, i);
}
int ret = 0;
while (fscanf(pf, "%d", &ret) > 0)
{
if (arr[0] <= ret)
{
arr[0] = ret;
adjustDown(arr, k, 0);
}
}
for (int i = 0; i < k; i++)
{
printf("%d ", arr[i]);
}
}
int main()
{
CreateNDate();
PrintTopK(3,20);//找出前十个最大的数
return 0;
}