不简单的选择排序—堆排序算法

堆排序算法

堆排序(Heap Sort)就是利用堆(假设利用大堆顶)进行排序的方法。它的基本思想是，将待排序的序列构造成一个大堆顶。此时，整个序列的最大值就是堆顶的根节点。将它移走(其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值)，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次大值。如此反复执行，便能得到一个有序序列了。

/* 对顺序表L作堆排序*/
#include <stdio.h>
#define MAXSIZE 10

typedef struct
{
    int r[MAXSIZE];
    int length;
}SqList;
void swap(SqList *L, int i, int j)
{
    int temp = L->r[i];
    L->r[i] = L->r[j];
    L->r[j] = temp;
}

/*已知L->r[s..m]中记录的关键字除L->r[s]之外均满足堆的定义*/
/*本函数调整L->r[s]的关键字，使L->r[s..m]成为一个大堆顶*/
void HeapAdjust(SqList *L, int s, int m)
{
    int temp, j;
    temp = L->r[s];
    for(j = 2*s; j <= m; j*=2)  //沿关键字较大的孩子节点向下筛选
    {
        if(j < m && L->r[j] < L->r[j+1])  
        {
            ++j;                    //j为关键字中较大的记录的下标
        }
        if(temp >= L->r[j])
        {   
            break;                      //rc应该插入在位置s上
        }
        L->r[s] = L->r[j];
        s = j;
    }
    L->r[s] = temp;             //插入
}
void HeapSort(SqList *L)  
{
    int i;
    for(i = L->length/2; i > 0; i--)  //把L中的r构建成一个大堆顶
    {
        HeapAdjust(L, i, L->length);
    }
    for(i = L->length; i > 1; i--)  //将每个最大值的根结点与末尾元素交换，再次调整其成为大堆顶
    {
        swap(L, 1, i);  //将堆顶记录和当前未经排序子序列的最后一个记录交换
        HeapAdjust(L, 1, i-1); //将L->r[1..i-1]重新调整成为大堆顶
    }
}   
int main()
{
    SqList H;
    int n;
    
    scanf("%d",&n);
    H.length = n-1;
    for(int i = 0; i < n; i++)
    {
        scanf("%d",&H.r[i]);
    }
    HeapSort(&H);
     for(int i = 1; i < n; i++)
    {
        printf("%d ",H.r[i]);
    }
}

/*
程序运行示例：
10
0 50 10 90 30 70 40 80 60 20
10 20 30 40 50 60 70 80 90 %    
*/

堆排序复杂度分析

堆排序的效率到底有多高呢？它的运行时间主要是消耗在初始构建堆和在重建时的反复筛选上。在构建堆的过程中，因为我们是完全二叉树从最下层最右边的非终端节点开始构建，将它与其孩子进行比较和若有必要的交换，对于每个非终端节点来说，其实最多进行两次比较和互换操作。因此真个构建堆的时间复杂度为O(n).

总体来说，堆的时间复杂度为O( $nlogn$)。由于堆排序对原始记录的排序状态并不敏感，因此，它无论最好、最坏和平均时间复杂度均为O( $nlogn$)。这在性能上显然要远远好于冒泡、简单选择、直接插入的O( $n^2$)的时间复杂度了。

空间复杂度上，它只有一个用来交换的暂存单元，也非常的不错。不过由于记录的比较与交换是跳跃式进行，因此堆排序也是一种不稳定的排序方法。

最后，由于初始构建堆所需的比较次数比较多，因此，它并不适合待排序列个数较少的情况。