文章详细介绍了堆的定义、孩子和双亲节点之间的编号关系，以及堆的实现方式，包括向上调整建堆和向下调整建堆。堆排序算法的实现过程被分为两步：先建立堆，然后通过交换堆顶元素进行排序。时间复杂度方面，向上调整为O(N*logN)，向下调整为O(N)，堆排序为O(N*logN)。最后，文章讨论了如何使用堆解决Top-K问题，提供了一种高效处理大数据集的方法。
堆
1.堆的定义
堆是完全二叉树的一种，子树的根结点比孩子都大称为大根堆，比孩子都小称为小根堆；
2.孩子和双亲结点之间的编号关系
对于从零开始，顺序从从左到右，从上到下的顺序进行编号的时，、
lchild=parent2+1；rchild=parent2+2；parent=(child-1)/2
3.堆的实现
关键是插入和删除根结点的操作。
（1）插入操作
顺序结构，在数组尾插方便，然后再将数据向上调整，使其变成堆。对于大根堆来说，当孩子结点的值大于父亲结点的值时，交换两个结点的值，再将此时的父亲看成孩子，找此时父亲，再次进行比较交换。当孩子结点标号为0的时候，结束循环。建立小根堆就是将比较符号相反就好。
【算法实现】
// 左右子树都是大堆/小堆
void AdjustDown(HPDataType* a, int n, int parent)
{
assert(a);
int child = parent * 2 + 1;
while (child < n)
{
//判断左右孩子的大小
if (child + 1 < n && a[child + 1] > a[child])
{
child++;
}
//对孩子和父子结点比较
if (a[parent] < a[child])
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
（2）删除根结点
对于删除操作来说，删除根结点比较有意义，这样可以找到最大或最小值。但是对于堆来说，删除根结点，不能直接移动数据，这样会导致效率低下和父子兄弟的关系乱套了。
所以，删除根结点时，先将根结点和最后一个数据进行交换，在进行尾删。接着开始向下调整。向下调整的算法的关键条件是：左右子树都是堆的结构。
对于大根堆来说，将父亲结点和孩子结点中最大值进行比较，小的话进行交换，大的话比较结束，当此时父亲结点的孩子结点没有的时候结束循环。
【算法实现】
//向上调整的算法
void AdjustUp(HPDataType* a, int child)
{
// 除了child这个位置，前面数据构成堆
assert(a);
int parent = (child - 1) / 2;
while (child != 0)
{
if (a[parent] < a[child])
{
Swap(&a[parent], &a[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
堆相关操作函数的实现
Heap.h
#pragma once
#include<stdlib.h>
#include<stdio.h>
#include<stdbool.h>
#include<assert.h>
typedef int HPDataType;
typedef struct Heap
{
HPDataType* _a;
int _size;
int _capacity;
}Heap;
// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HPDataType x);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HPDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
int HeapEmpty(Heap* hp);
//交换函数
void Swap(HPDataType* p1, HPDataType* p2);
// 左右子树都是大堆/小堆
void AdjustDown(HPDataType* a, int n, int parent);
// 检查空间，如果满了，进行增容
void CheckCapacity(Heap* psl);
//向上调整的算法
void AdjustUp(HPDataType* a, int child);
Heap.c
#include"Heap.h"
//交换函数
void Swap(HPDataType* p1, HPDataType* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
// 左右子树都是大堆/小堆
void AdjustDown(HPDataType* a, int n, int parent)
{
assert(a);
int child = parent * 2 + 1;
while (child < n)
{
//判断左右孩子的大小
if (child + 1 < n && a[child + 1] > a[child])
{
child++;
}
//对孩子和父子结点比较
if (a[parent] < a[child])
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
// 检查空间，如果满了，进行增容
void CheckCapacity(Heap* psl)
{
assert(psl);
if (psl->_size == psl->_capacity)
{
HPDataType* tmp = (HPDataType*)realloc(psl->_a, psl->_capacity * 2 * sizeof(HPDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
psl->_a = tmp;
psl->_capacity *= 2;
}
}
//向上调整的算法
void AdjustUp(HPDataType* a, int child)
{
// 除了child这个位置，前面数据构成堆
assert(a);
int parent = (child - 1) / 2;
while (child != 0)
{
if (a[parent] < a[child])
{
Swap(&a[parent], &a[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n)
{
assert(hp);
hp->_a = (HPDataType*)malloc(sizeof(HPDataType) * n*2);
if (hp->_a == NULL)
{
perror("malloc fail");
return;
}
hp->_capacity = n*2;
hp->_size = 1;
hp->_a[0] = a[0];
for (int i = 1; i < n; i++)
{
hp->_a[i] = a[i];
AdjustUp(hp->_a, i);
hp->_size++;
}
}
// 堆的销毁
void HeapDestory(Heap* hp)
{
assert(hp);
free(hp->_a);
hp->_a = NULL;
hp->_capacity = hp->_size=0;
}
// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
assert(hp);
CheckCapacity(hp);
hp->_a[hp->_size++] = x;
AdjustUp(hp->_a, hp->_size - 1);
}
// 堆的删除
void HeapPop(Heap* hp)
{
assert(hp);
int tmp = hp->_a[0];
hp->_a[0] = hp->_a[hp->_size - 1];
hp->_a[hp->_size - 1] = tmp;
hp->_size--;
AdjustDown(hp->_a, hp->_size, 0);
}
// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
assert(hp);
return hp->_a[0];
}
// 堆的数据个数
int HeapSize(Heap* hp)
{
assert(hp);
return hp->_size;
}
// 堆的判空
int HeapEmpty(Heap* hp)
{
assert(hp);
return !(hp->_size);
}
4.堆排序算法
升序建大堆，让后将堆顶的元素和最后一个元素交换，这样就可保持左右子树任然是堆，这样在向下调整，可以将次大的数据变到堆顶。重复n次就可了。降序建立小堆即可。
4.1. 向上调整建堆
就是将堆顶设一个初值，再将剩下的元素插入堆即可。
【算法实现】
//升序建立大根堆,向上调整
for (int i = 1; i < n; i++)
{
AdjustUp(a, i);
}
4.2. 向下调整建堆
向下调整的前提条件是：左右子树都要是堆。
通过最后一个元素找到倒数第一个双亲结点，对这个双亲结点向下调整，在自减1就可以找到倒数下一个结点，此时对于每个双亲结点来说，左右子树都是堆了。
【算法实现】
//升序建立大根堆，向下调整
for (int i = (n-1-1)/2; i >= 0; i--)
{
AdjustDown(a, n,i);
}
4.3. 堆排序算法实现
void HeapSort(HPDataType a[], int n)
{
升序建立大根堆,向上调整
//for (int i = 1; i < n; i++)
//{
// AdjustUp(a, i);
//}
//升序建立大根堆，向下调整
for (int i = (n-1-1)/2; i >= 0; i--)
{
AdjustDown(a, n,i);
}
//大根堆排升序
int size = n;
while (size)
{
Swap(&a[0], &a[size - 1]);
size--;
AdjustDown(a, size, 0);
}
}
5.堆相关的时间复杂度的计算
5.1. 向上调整建堆的时间复杂度是O(N*logN)
数学推导：
5.2 向下调整建堆的时间复杂度是O(N)
数学证明：
5.3. 堆排序算法的时间复杂度是O(N*logN)
数学证明：
6.Top-K问题
TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：
- 用数据集合中前K个元素来建立堆
a.前K个最大的元素，建立小堆
b.前K个最小的元素，建立大堆 - 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。
【代码实现】
//Top-K问题
void PrintTopK(const char* file, int k)
{
FILE* fin = fopen(file, "r");
if (fin == NULL)
{
perror("fopen error");
return;
}
int* TopK = (int*)malloc(sizeof(int) * k);
assert(TopK);
//接受K个数据
for (int i = 0; i < k; i++)
{
fscanf(fin, "%d", &TopK[i]);
}
//建立小堆
for (int i = (k - 2) / 2; i >= 0; i--)
{
AdjustDown(TopK, k, i);
}
//数据的替换
int val = 0;
int ret = fscanf(fin, "%d", &val);
while (ret != EOF)
{
if (TopK[0] < val)
{
TopK[0] = val;
AdjustDown(TopK, k, 0);
}
ret = fscanf(fin, "%d", &val);
}
//数据的打印
for (int i = 0; i < k; i++)
{
printf("%d ", TopK[i]);
}
printf("\n");
}
void CreateNDate()//造数据
{
const char* p = "data.txt";
int n = 10000;
srand(time(0));
FILE* fin=fopen(p, "w");
if (fin == NULL)
{
perror("fopen error");
return;
}
for (size_t i = 0; i < n; i++)
{
int x = rand() % n;
fprintf(fin, "%d\n", x);
}
fclose(fin);
}
int main()
{
// CreateNDate();//造数据
PrintTopK("data.txt", 10);
return 0;
}
131
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
