堆排序

堆排序是对简单选择排序算法的一种改进。可以构建大顶堆（每个结点的值都大于等于其左右孩子的值）也可以构建小顶堆（每个结点的值都小于等于其左右孩子的值）。堆排自我感觉代码理解起来还是有点难，主要是如何构建一个新堆以及输出堆顶元素后，怎样调整剩余元素成为一个新堆。

 1、堆排代码

void heapsort(SqList *s)
{
    int increment = s->length/2;   //父结点记录，父结点为从increment到s->length的记录
    //构建大顶堆
    for (int i = increment;i>0;i--)
    {
        heapadjust(s,i,s->length);
    }
    //交换大顶堆父结点到末端，将最大元素沉到叶结点处；再调整剩余元素为一个新的大顶堆
    for(int j = s->length;j>1;j--)
    {
        swap(s,1,j);
        heapadjust(s,1,j-1);
    }
}

2、堆调整代码

void heapadjust(SqList *s,int i,int j)
{
    //保存当前结点
    int temp = s->data[i];
    int k;
    //对该节点的左右孩子进行比较，再将左右孩子中较大的与根结点比较，将最大者作为根结点（与选择排序类似，选择最大的值作为根结点）
    for (k = 2*i;k < j;k*=2)
    {
        if ((s->data[k]) < (s->data[k+1]))
        {
            k++;
        }
        if (temp > s->data[k])
        {
            break;
        }
        s->data[i] = s->data[k];
        i = k;
    }
    s->data[i] = temp;
}

堆排测试完整代码：

#include <iostream>
using namespace std;
#define MAXSIZE 100

struct SqList
{
    int data[MAXSIZE];
    int length;
};

void heapadjust(SqList *s,int i,int j)
{
    //保存当前结点
    int temp = s->data[i];
    int k;
    //对该节点的左右孩子进行比较，再将左右孩子中较大的与根结点比较，将最大者作为根结点（与选择排序类似，选择最大的值作为根结点）
    for (k = 2*i;k < j;k*=2)
    {
        if ((s->data[k]) < (s->data[k+1]))
        {
            k++;
        }
        if (temp > s->data[k])
        {
            break;
        }
        s->data[i] = s->data[k];
        i = k;
    }
    s->data[i] = temp;
}

void swap(SqList *s,int i,int j)
{
    int temp;
    if (s->data[i] > s->data[j])
    {
        temp = s->data[i];
        s->data[i] = s->data[j];
        s->data[j] = temp;
    }
}

void heapsort(SqList *s)
{
    int increment = s->length/2;   //父结点记录，父结点为从increment到s->length的记录
    //构建大顶堆
    for (int i = increment;i>0;i--)
    {
        heapadjust(s,i,s->length);
    }
    //交换大顶堆父结点到末端，将最大元素沉到叶结点处；再调整剩余元素为一个新的大顶堆
    for(int j = s->length;j>1;j--)
    {
        swap(s,1,j);
        heapadjust(s,1,j-1);
    }
}

void main()
{
    SqList s;
    s.length = 5;
    int m;
    for (int i = 1; i <= s.length;i++)
    {
        cin >> m;
        s.data[i] = m;
    }
    heapsort(&s);
    for (int i = 1; i <= s.length;i++)
    {
        cout << s.data[i] << " ";        
    }
    system("pause");
}

结果：

复杂度分析：

堆排序的运行时间主要消耗在初始构建堆和重建堆时的反复筛选上。在构建堆的过程中，根结点与其左右孩子结点最多进行两次的比较与交换操作，因此整个构建堆的时间复杂度为O(n)。在正式排序的过程中，第i次取堆顶记录重建堆需要用O(logi)的时间（完全二叉树的性质），并需要取n-1次堆顶记录，因此，重建堆的时间复杂度为O(nlogn)。

空间复杂度上，它只有一个用来交换的暂存单元，空间复杂度为O(1)。

由于记录的比较与交换是跳跃式进行的，因此堆排是一种不稳定的排序算法。