数据结构-堆排序及其复杂度计算
目录
1.堆排序
1.1 向上调整建堆
1.2 向下调整建堆
2. 两种建堆方式的时间复杂度比较
2.1 向下调整建堆的时间复杂度
2.2 向上调整建堆的时间复杂度
Topk问题
上节内容，我们讲了堆的实现，同时还包含了向上调整法和向下调整法，最后我们用堆实现了对数据的排序：
int main()
{
HP hp;
HeapInit(&hp);
int arr[] = { 65,100,70,32,50,60 };
int i = 0;
for (i = 0; i < sizeof(arr) / sizeof(int); i++)
{
HeapPush(&hp, arr[i]);
}
while (!HeapEmpty(&hp))
{
HeapDatatype top = HeapTop(&hp);
printf("%d ", top);
HeapPop(&hp);
}
return 0;
}那以上代码能实现对数据的排序吗?
答案是可以的，但是以上方式有两个弊端：
1. 要先写一个堆，太麻烦
2. 空间复杂度+拷贝数据。
1.堆排序
上节内容中，用堆对数据进行排序，是将数据一个一个插入堆，然后再调整排序的，那我们能不能直接把数据就建成一个堆？
当然可以，建堆有两种方式：向上调整建堆、向下调整建堆。
1.1 向上调整建堆
我们先来讲向上调整建堆：
向上调整建堆其实还是插入堆的逻辑，要求前面的数据必须是一个堆，下标从1开始是因为一个数据本身就可以被看做一个堆，然后向上调整。
下图就是我们对一个数组数据进行向上调整建堆后的结果，可以看出来，此时我们建的是一个小堆：
现在问题来了，我们要把数据排为升序，建大堆还是建小堆好？
先说结论：升序 -- 建大堆 降序 -- 建小堆。
假设我们要得到升序，此时又建的是小堆，那我们就把选出的最小的数据放在下标为0的位置，要想继续选出次小的数据放在下标为1的位置，就要把剩下的数据看做堆，这样堆的关系就全乱了，只能重新建堆，代价太大。
而如果我们建大堆，向下调整选出最大的数据，首尾交换，把最大的数据放在最后一个下标的位置，然后隔离最后一个数据，把其他数据看做一个堆，再向下调整选出次大的，首尾交换......直到所有的数据被排好序，此时得到的就是数据升序。
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include
typedef int HeapDatatype;
swap(HeapDatatype* p1, HeapDatatype* p2)
{
HeapDatatype tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//向上调整法
void AdjustUp(HeapDatatype* a, int child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (a[parent] < a[child])
{
HeapDatatype p = a[parent];
a[parent] = a[child];
a[child] = p;
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
//向下调整法
void AdjustDown(HeapDatatype* a, int n, int parent)
{
int child = parent * 2 + 1;
while (child < n)
{
if (child + 1 < n && 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 HeapSort(int* a, int n)
{
//建堆 - 向上调整建堆
for (int i = 1; i < n; i++)
{
AdjustUp(a, i);
}
//向下调整得到次大数据
int end = n - 1;
while (end > 0)
{
swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
end--;
}
}
int main()
{
int a[] = { 7,8,3,5,1,9,5,4 };
HeapSort(a, sizeof(a) / sizeof(int));
return 0;
} 我们建的是大堆，最后得到的就是升序：
要得到数据降序，就要建小堆，向下调整选出最小的数据，首尾交换，把最小数据放在最后一个下标的位置，隔离最后一个数据，把其他数据看做一个堆，再向下调整选出次小的数据，首尾交换......直到所有数据都被拍好序，这就得到数据降序。
代码如下：（只需将向下调整和向上调整中的'<'改为'>'即可）
#define _CRT_SECURE_NO_WARNINGS 1
#include
typedef int HeapDatatype;
swap(HeapDatatype* p1, HeapDatatype* p2)
{
HeapDatatype tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//向上调整法
void AdjustUp(HeapDatatype* a, int child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (a[parent] > a[child])
{
HeapDatatype p = a[parent];
a[parent] = a[child];
a[child] = p;
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
//向下调整法
void AdjustDown(HeapDatatype* a, int n, int parent)
{
int child = parent * 2 + 1;
while (child < n)
{
if (child + 1 < n && 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 HeapSort(int* a, int n)
{
//建堆 - 向上调整建堆
for (int i = 1; i < n; i++)
{
AdjustUp(a, i);
}
//向下调整得到次小数据
int end = n - 1;
while (end > 0)
{
swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
end--;
}
}
int main()
{
int a[] = { 7,8,3,5,1,9,5,4 };
HeapSort(a, sizeof(a) / sizeof(int));
return 0;
} 由于我们建的是小堆，所以得到的就是数据降序：
注意：不论是升序还是降序，数据都是从后往前放的，这样就不会使堆的关系混乱。
1.2 向下调整建堆
我们可以看到，堆排序使用向上调整建堆，还要写两个函数：向下调整函数、向上调整函数。
那我们想用一个向下调整函数就解决问题呢？
这就需要向下调整建堆：
向下调整建堆要求根节点的左右子树都是大堆（小堆），如果左右子树不满足大堆，我们只需要确保左右子树的左右子树是大堆（小堆）即可，如果又不是，我们再往下找，所以只要使所有父节点的左右子树都是大堆（小堆）就行，那我们就倒着调整，因为叶子节点本身就是一个堆，所以不需要调整，那就从最后一个节点的父节点开始调整。
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include
typedef int HeapDatatype;
swap(HeapDatatype* p1, HeapDatatype* p2)
{
HeapDatatype tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//向下调整法
void AdjustDown(HeapDatatype* a, int n, int parent)
{
int child = parent * 2 + 1;
while (child < n)
{
if (child + 1 < n && 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 HeapSort(int* a, int n)
{
//建堆 - 向下调整建堆
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(a, n, i);
}
int end = n - 1;
while (end > 0)
{
swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
end--;
}
}
int main()
{
int a[] = { 7,8,3,5,1,9,5,4 };
HeapSort(a, sizeof(a) / sizeof(int));
return 0;
} 代码中int i=(n-1-1)/2是通过孩子找父亲的下标，n是数组大小，先减一得到最后一个下标，再减一除以二得到最后一个孩子的父节点。
这就是向下调整建堆，以后我们用的都是向下调整建堆，不再使用向上调整建堆，这两种方式不仅代码量上有差距，时间复杂度上也有差距，向下调整建堆的时间复杂度更小。
2. 两种建堆方式的时间复杂度比较
2.1 向下调整建堆的时间复杂度
前文中我们知道了，向下调整建堆要保证每个父节点的左右子树都是大堆（小堆），所以我们在调整的时候是从下往上进行的，而最后一层的每个叶节点本身就可以看做一个堆，不用调整，从它们的父节点开始调整（即倒数第二层开始调整），所以时间复杂度如下：
总步数 = ∑（每一层的节点数*该节点需要调整的层数）
2.2 向上调整建堆的时间复杂度
向上调整和向下调整刚好相反，向下调整时，第h-1行的2^(h-2)个节点需向下调整1层，而向上调整时，第h-1行的2^(h-1)个节点需要向上调整h-2，向下调整是大乘小、小乘大，而向上调整时大乘大、小乘小，时间复杂度如下：
以上就是向上调整建堆和向下调整建堆的时间复杂度，那我们整个堆排序的过程的时间复杂度是多少呢？
堆排序过程中，除了建堆还有向下调整选数，当选数时，要首尾交换，交换一次，从头向下调整一次， 所以第h行的2^(h-1)个节点，每次首尾交换时都要调整(h-1)次，一共2^(h-1)*(h-1)，由此可见，选数据过程中的时间复杂度和向上调整建堆的时间复杂度保持一致，即为O(N*logN)
所以堆排序整体的时间复杂度是：建堆+选数 = O(N+N*logN)，即O(N*logN)。
Topk问题
TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：
1. 用数据集合中前K个元素来建堆
前k个最大的元素，则建小堆
前k个最小的元素，则建大堆
2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。
比如：我们要找10000个数中的前K个最小的数，就把先把前K个数建小堆，然后把用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
#include
//Top-K问题
typedef int HeapDatatype;
swap(HeapDatatype* p1, HeapDatatype* p2)
{
HeapDatatype tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//向下调整法
void AdjustDown(HeapDatatype* a, int n, int parent)
{
int child = parent * 2 + 1;
while (child < n)
{
if (child + 1 < n && 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 CreateNDate()
{
// 造数据
int n = 10000;
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() % 1000000;
fprintf(fin, "%d\n", x);
}
fclose(fin);
}
void PrintTopK(int k)
{
const char* file = "data.txt";
FILE* fout = fopen(file, "r");
if (fout == NULL)
{
perror("fopen error");
return;
}
int* kminheap = (int*)malloc(sizeof(int) * k);
if (kminheap == NULL)
{
perror("malloc error");
return;
}
for (int i = 0; i < k; i++)
{
fscanf(fout, "%d", &kminheap[i]);
}
// 建小堆
for (int i = (k - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(kminheap, k, i);
}
int val = 0;
while (!feof(fout))
{
fscanf(fout, "%d", &val);
if (val > kminheap[0])
{
kminheap[0] = val;
AdjustDown(kminheap, k, 0);
}
}
for (int i = 0; i < k; i++)
{
printf("%d ", kminheap[i]);
}
printf("\n");
}
int main()
{
CreateNDate();
PrintTopK(5);
return 0;
}
关于堆排序的所有内容已经学完了，下节我们继续讲二叉树的前序、中序、后序和层序。
未完待续。。。