文章目录
| 想要一步步稳扎稳打，学习编程的小伙伴可以关注我或者订阅专栏，文章都是免费的，不要错过这一个提升自己的机会！ |
本系列相关文章：
＜数据结构＞倒拔二叉树
已完结系列文章总结：
c语言自学教程——博文总结
1. 二叉树的顺序结构
2. 堆的概念及结构
3. 堆的实现（以小堆为例）
3.1 Heap.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
size_t size;
size_t capacity;
}HP;
void HeapInit(HP* php); // 堆的构建
void HeapDestroy(HP* php); // 堆的销毁
void Swap(HPDataType* pa, HPDataType* pb);//交换
void HeapPrint(HP* php);//打印堆中数据
void AdjustUp(HPDataType* a, size_t child);//向上调整
void HeapPush(HP* php, HPDataType x); //堆的插入
void AdjustDown(HPDataType* a, size_t size, size_t root);//向下调整
void HeapPop(HP* php);// 堆的删除
bool HeapEmpty(HP* php); // 堆的判空
size_t HeapSize(HP* php); // 堆的数据个数
HPDataType HeapTop(HP* php);// 取堆顶的数据
3.2 堆的构建
void HeapInit(HP* php)
{
assert(php);
php->a = NULL;
php->capacity = php->size = 0;
}
3.3 堆的销毁
void HeapDestroy(HP* php)
{
assert(php);
free(php->a);
php->a = NULL;
php->capacity = php->size = 0;
}
3.4 辅助函数
void Swap(HPDataType* pa, HPDataType* pb)
{
HPDataType tmp = *pa;
*pa = *pb;
*pb = tmp;
}
void HeapPrint(HP* php)
{
assert(php);
for (size_t i = 0; i < php->size; i++)
{
printf("%d ", php->a[i]);
}
printf("\n");
}
3.5 向上调整、堆的插入
//向上调整
void AdjustUp(HPDataType* a, size_t child)
{
size_t 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;
}
}
}
void HeapPush(HP* php, HPDataType x)
{
assert(php);
//扩容
if (php->size == php->capacity)
{
size_t newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newCapacity);
assert(tmp);
php->a = tmp;
php->capacity = newCapacity;
}
//插入
php->a[php->size] = x;
++php->size;
//保持堆，移位
AdjustUp(php->a, php->size-1);
}
3.6 向下调整、堆的删除
//向下调整
void AdjustDown(HPDataType* a, size_t size, size_t root)
{
size_t parent = root;
size_t child = root * 2 + 1;
while (child < size)
{
//选左右孩子中小的孩子
if (child + 1 < size && a[child] > a[child + 1])//如果想改成大堆就改第二个大于号
{
child++;
}
//如果孩子小于父亲，则交换，并继续向下调整
if (a[parent] > a[child])//如果想改成大堆就改成小于号
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
//删除堆顶的数据
void HeapPop(HP* php)
{
assert(php);
assert(php->size > 0);
Swap(&php->a[0], &php->a[php->size - 1]);
php->size--;
//向下调整
AdjustDown(php->a, php->size, 0);
}
3.7 堆的判空
bool HeapEmpty(HP* php)
{
assert(php);
return php->size == 0;
}
3.8 堆的数据个数
size_t HeapSize(HP* php)
{
assert(php);
return php->size;
}
3.9 取堆顶的数据
HPDataType HeapTop(HP* php)
{
assert(php);
assert(php->size > 0);
return php->a[0];
}
4. 堆排序
下面的动图是用这个思路来排序的，但它是从后往前放到数组里的，这个跟我们下面的参考代码有些不同。
参考代码
void HeapSort(int* a, int size)
{
HP hp;
HeapInit(&hp);
for (int i = 0; i < size; i++)
{
HeapPush(&hp, a[i]);
}
int j = 0;
while (!HeapEmpty(&hp))
{
a[j] = HeapTop(&hp);
HeapPop(&hp);
j++;
}
HeapDestroy(&hp);
}
int main()
{
int a[] = { 5,10,6,1,-1,2,7,0 };
HeapSort(a, sizeof(a) / sizeof(a[0]));
for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
4.1堆排序的优点和不足
4.2 优化：直接在数组上建堆
4.2.1 向上调整建堆
//在原数组中向上调整，建堆
for (int i = 1; i < size; i++)//i没必要从0开始，第一次没必要向上调整
{
AdjustUp(a, i);
}
4.2.2 向下调整建堆
//向下调整，建堆（从倒数第一个非叶子节点开始,也就是最后一个节点的父亲）
for (int i = (size - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(a, size, i);
}
4.2.3 时间复杂度对比
4.3 堆排序整体逻辑
void HeapSort(int* a, int size)
{
在原数组中向上调整，建堆
//for (int i = 1; i < size; i++)
//{
// AdjustUp(a, i);
//}
//向下调整，建堆（从倒数第一个非叶子节点开始,也就是最后一个节点的父亲）
for (int i = (size - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(a, size, i);
}
size_t end = size - 1;
while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);//将排完了的数，不看做堆里的数
end--;
}
}
int main()
{
int a[] = { 5,10,6,1,8,2,7,0 };
HeapSort(a, sizeof(a) / sizeof(a[0]));
for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
5. TOP-K问题
void PrintTopK(int* a, int n, int k)
{
// 1. 建堆--用a中前k个元素建堆
// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
}
void TestTopk()
{
int n = 10000;
int* a = (int*)malloc(sizeof(int)*n);
srand(time(0));
for (size_t i = 0; i < n; ++i)
{
a[i] = rand() % 1000000;
}
a[5] = 1000000 + 1;
a[1231] = 1000000 + 2;
a[531] = 1000000 + 3;
a[5121] = 1000000 + 4;
a[115] = 1000000 + 5;
a[2335] = 1000000 + 6;
a[9999] = 1000000 + 7;
a[76] = 1000000 + 8;
a[423] = 1000000 + 9;
a[3144] = 1000000 + 10;
PrintTopK(int* a, n, 10);
}
