堆排序（Heapsort）

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。
二叉堆的定义
二叉堆是完全二叉树或者是近似完全二叉树。
二叉堆满足二个特性：
1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。
2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。
当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。下图展示一个最小堆，一般将二叉堆就简称为堆。


堆的存储
一般都用数组来表示堆，i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。如第0个结点左右子结点下标分别为1和2。

这里写代码片
//堆的插入
//新加入i结点  其父结点为(i - 1) / 2
void MinHeapFixup(int a[], int i)
{
    int j, temp;

    temp = a[i];
    j = (i - 1) / 2;      //父结点
    while (j >= 0 && i != 0)
    {
        if (a[j] <= temp)
            break;

        a[i] = a[j];     //把较大的子结点往下移动,替换它的子结点
        i = j;
        j = (i - 1) / 2;
    }
    a[i] = temp;
}
/*
//更简短的表达为：
void MinHeapFixup(int a[], int i)
{
    for (int j = (i - 1) / 2; (j >= 0 && i != 0)&& a[i] > a[j]; i = j, j = (i - 1) / 2)
        Swap(a[i], a[j]);
}
*/
// 堆的删除
//在最小堆中加入新的数据nNum
void MinHeapAddNumber(int a[], int n, int nNum)
{
    a[n] = nNum;
    MinHeapFixup(a, n);
}
//  从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2
void MinHeapFixdown(int a[], int i, int n)
{
    int j, temp;

    temp = a[i];
    j = 2 * i + 1;
    while (j < n)
    {
        if (j + 1 < n && a[j + 1] < a[j]) //在左右孩子中找最小的
            j++;

        if (a[j] >= temp)
            break;

        a[i] = a[j];     //把较小的子结点往上移动,替换它的父结点
        i = j;
        j = 2 * i + 1;
    }
    a[i] = temp;
}
//在最小堆中删除数
void MinHeapDeleteNumber(int a[], int n)
{
    Swap(a[0], a[n - 1]);
    MinHeapFixdown(a, 0, n - 1);
}

//堆化数组
//建立最小堆
void MakeMinHeap(int a[], int n)
{
    for (int i = n / 2 - 1; i >= 0; i--)
        MinHeapFixdown(a, i, n);
}
// 堆排序
void MinheapsortTodescendarray(int a[], int n)
{
    for (int i = n - 1; i >= 1; i--)
    {
        Swap(a[i], a[0]);
        MinHeapFixdown(a, 0, i);
    }
}

#include<stdio.h>
#include<stdlib.h>
void array_show(int* arr, int len);
void heapSort(int a[], int n);
void Swap(int &a,int &b)
{
 int temp;
 temp = a;
 a = b;
 b = temp;
}

int main(int argc, char* argv[])
{
    int arr[10] = {4,3,8,5,2,1,6,0,7,9};
    array_show(arr, 10);
    heapSort(arr, 10);
    putchar(10);
    array_show(arr, 10);

    system("pause");

    return 0;
}

void array_show(int* arr, int len)
{
    int i ;
    for(i = 0; i != len; i ++)
    {
        printf("%d ", arr[i]);
    }
}
//2.堆排序
void siftDown(int a[], int i, int n)
{
    int lhs=2*i+1;
    int rhs=2*i+2;
    int maxid=i;
    if(lhs<n && a[i]<a[lhs]) maxid=lhs;
    if(rhs<n && a[maxid]<a[rhs]) maxid=rhs;
    if(maxid!=i)
    {
        Swap(a[i],a[maxid]);
        siftDown(a,maxid,n);
    }
}

void makeHeap(int a[], int n)
{
    for(int i=n/2+1; i>=0; i--)
    {
        siftDown(a,i,n);
    }
}

void heapSort(int a[], int n)
{
    makeHeap(a,n);
    for(int i=n-1; i>=0; i--)
    {
        Swap(a[0],a[i]);
        siftDown(a,0,i);
    }
}

堆排序与快速排序，归并排序一样都是时间复杂度为O(N*logN)的几种常见排序方法。 堆排序的时间，主要由建立初始堆和反复重建堆这两部分的时间开销构成，它们均是通过调用Heapify实现的。
平均性能：O(N*logN)。
其他性能
由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。
堆排序是就地排序，辅助空间为O(1）.
它是不稳定的排序方法（排序的稳定性是指如果在排序的序列中，存在前后相同的两个元素的话，排序前 和排序后他们的相对位置不发生变化）。