堆排序（HeapSort）

1.大体思路

将待排序数组按照下标建立成一个二叉树的数据结构（假象的，实际上任然是一个一维数组），并构造一个函数MaxHeapify()，使得二叉树的每个父节点的值都要比其孩子节点的值大（使用递归调用实现），因此树的根部即为最大值，将最大值与数组最后一个元素进行交换，并把数组最后一个元素从堆中剔除，采用将数组可操作性长度减一来实现（–nLen），再将刚交换到堆顶的元素使用MaxHeapify()将其放到满足要求的位置，此时堆顶元素又成立最大值…以此类推，即可完成对数组的升序排序。

2.代码如下

#include <iostream>
#include <ctime>
#include <windows.h>
using namespace std;

void Swape(int *p, int *q) {
int tmp = *p;
*p = *q;
*q = tmp;
}

void RandomSort(int *nArr, int nLen) {
srand(time(NULL));
for(int i = 0; i < nLen; ++i) {
int nIndex = rand() % nLen;
Swape(&nArr[i], &nArr[nIndex]);
//Sleep(2000);                       //等待2s，更新随机种子
}
}

void InitArr(int *nArr, int nLen) {     //初始化数组
srand(time(NULL));
for(int i = 0; i < nLen; ++i) {
//nArr[i] = rand() % 100;
nArr[i] = i;
}
}

void PrintArr(int *nArr, int nLen) {   //打印数组
for(int i = 0; i < nLen; ++i) {
cout << nArr[i] << " ";
}
cout << endl;
}

//返回父节点下标
int Parent(int i) {
return (i - 1) / 2;
}

//返回i左节点下标
int LeftChild(int i) {
return 2 * i + 1;
}

//返回i右节点下标
int RightChild(int i) {
return 2 * i + 2;
}

//最大堆化，保证每个父节点都比子节点大
void MaxHeapify(int *nArr, int nLen, int i) {
int LC = LeftChild(i);
int RC = RightChild(i);
int nMaxPos;
if(LC < nLen && nArr[LC] > nArr[i]) {
nMaxPos = LC;
} else {
nMaxPos = i;
}
if(RC < nLen && nArr[RC] > nArr[nMaxPos]) {
nMaxPos = RC;
}

if(nMaxPos != i) {
Swape(&nArr[nMaxPos], &nArr[i]);
MaxHeapify(nArr, nLen, nMaxPos);
}
}

//将最大值移动到树的根节点，即数组头
void BuildMaxHeap(int *nArr, int nLen) {
for(int i = Parent(nLen - 1); i >= 0; --i) {
MaxHeapify(nArr, nLen, i);
}
}

//最大堆排序
void HeapSort(int *nArr, int nLen) {
BuildMaxHeap(nArr, nLen);                //将最大值移动至堆顶
for(int i = nLen - 1; i > 0; --i) {
Swape(&nArr[i], &nArr[0]);           //将堆顶的最大值放在数组最末尾nArr[nLen - 1]处
--nLen;                              //在堆中去除末尾元素（因为已经排好序，最后一位是最大值）
MaxHeapify(nArr, nLen, 0);           //从堆顶开始，将刚刚交换上来的nArr[i]往下移动，直至满足其父节点大于其本身的值
}
}

int main() {
int nLen = 10;
int nArr[nLen];
InitArr(nArr, nLen);
RandomSort(nArr, nLen);
PrintArr(nArr, nLen);
cout << endl;

HeapSort(nArr, nLen);
PrintArr(nArr, nLen);
cout << endl;

return 0;
}

3.输出结果如下



4.总结

时间复杂度O(NlogN)，空间复杂度O(1)，不稳定排序。