堆排序（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)，不稳定排序。