算法：堆排序

# 堆排序的Python实现
# coding:utf-8

import random
import time

t = time.time()

# 堆排序, 按照从小到大排序，所以建立大根堆
# 列表的第一个元素没有使用

def ShiftDown(a, i):
if not a:
return

j = i
N = len(a)
while 2*j < N:  # 存在左孩子时
ci = 2 * j # 左孩子节点下标
if ci + 1 < N and a[ci] < a[ci + 1]: # ci保存左右孩子节点中大值的下标
ci += 1

if a[j] < a[ci]: # 和孩子互换，否则，该元素位置正确，可以退出
a[j], a[ci] = a[ci], a[j]
else:
break
j = ci

def BuildHeap(a):
if not a:
return

i = len(a)/2
while i >= 1:
#print a[i]
ShiftDown(a, i)
i -= 1

def HeapSort(a):
BuildHeap(a)
b = []
while len(a) > 1: # 列表的第一个元素没有使用
a[1], a[-1] = a[-1], a[1]  # 将最大元素和最后一个元素互换，弹出最大元素，重新建造堆
b.append(a.pop())
BuildHeap(a)
a = b[::-1]
b.sort()
print a == b
#print b[::-1]
#a[N - 1], a[0] = a[0], a[N - 1]

a = [random.randint(1,100) for i in range(1001)]
#a = [60, 39, 80, 25, 66, 3, 93, 92, 11, 11, 38]
print a
BuildHeap(a)
print a
HeapSort(a)
print time.time() - t

// 最大堆实现, 数组下标从1开始，a[0]不使用。

// 交换两数
void swap(int &a, int &b) {
int t = a;
a = b;
b = t;
}

// 把第i个元素向上移动
void ShiftUp(int a[], int i) {
while(i>1 && a[i]>a[i/2]) {
swap(a[i], a[i/2]);
i >>= 1;
}
}

// 把第i个元素向下移动
void ShiftDown(int a[], int n, int i) {
while((i=2*i) <= n) {
if(i+1<=n && a[i+1]>a[i]) ++i;
if(a[i] > a[i/2]) swap(a[i], a[i/2]);
else break;
}
}

// 把数组a变成具备最大堆性质的数组
void MakeHeap(int a[], int n) {
for(int i=n/2; i>0; --i)
ShiftDown(a, n, i);
}

// 向堆中插入元素x
void Insert(int a[], int &n, int x) {
a[++n] = x;
ShiftUp(a, n);
}

// 删除堆中第i个元素
void Del(int a[], int &n, int i) {
a[i] = a[n--];
if(i>1 && a[i]>a[i/2]) ShiftUp(a, i);
else ShiftDown(a, n, i);
}

// 堆排序，时间复杂度O(nlogn)
void HeapSort(int a[], int n) {
MakeHeap(a, n);
for(int i=n; i>1; --i) {
swap(a[i], a[1]);
ShiftDown(a, i-1, 1);
}
}

//删除最大的元素
int deletemax()
{
int t;
t=h[ 1];//用一个临时变量记录堆顶点的值
h[ 1]=h[ n];//将堆得最后一个点赋值到堆顶
n--;//堆的元素减少1
siftdown(1);//向下调整
return t;//返回之前记录的堆得顶点的最大值
}

#include <stdio.h>
int h[ 101];//用来存放堆的数组
int n;//用来存储堆中元素的个数，也就是堆的大小

//交换函数，用来交换堆中的两个元素的值
void swap(int x,int y)
{
int t;
t=h[ x];
h[ x]=h[ y];
h[ y]=t;
}

//向下调整函数
void siftdown(int i) //传入一个需要向下调整的结点编号i，这里传入1，即从堆的顶点开始向下调整
{
int t,flag=0;//flag用来标记是否需要继续向下调整
//当i结点有儿子的时候（其实是至少有左儿子的情况下）并且有需要继续调整的时候循环窒执行
while( i*2<=n && flag==0 )
{
//首先判断他和他左儿子的关系，并用t记录值较小的结点编号
if( h[ i] > h[ i*2] )
t=i*2;
else
t=i;
//如果他有右儿子的情况下，再对右儿子进行讨论
if(i*2+1 <= n)
{
//如果右儿子的值更小，更新较小的结点编号
if(h[ t] > h[ i*2+1])
t=i*2+1;
}
//如果发现最小的结点编号不是自己，说明子结点中有比父结点更小的
if(t!=i)
{
swap(t,i);//交换它们，注意swap函数需要自己来写
i=t;//更新i为刚才与它交换的儿子结点的编号，便于接下来继续向下调整
}
else
flag=1;//则否说明当前的父结点已经比两个子结点都要小了，不需要在进行调整了
}
}

//建立堆的函数
void creat()
{
int i;
//从最后一个非叶结点到第1个结点依次进行向上调整
for(i=n/2;i>=1;i--)
{
siftdown(i);
}
}

//删除最大的元素
int deletemax()
{
int t;
t=h[ 1];//用一个临时变量记录堆顶点的值
h[ 1]=h[ n];//将堆得最后一个点赋值到堆顶
n--;//堆的元素减少1
siftdown(1);//向下调整
return t;//返回之前记录的堆得顶点的最大值
}

int main()
{
int i,num;
//读入数的个数
scanf("%d",&num);

for(i=1;i<=num;i++)
scanf("%d",&h[ i]);
n=num;

//建堆
creat();

//删除顶部元素，连续删除n次，其实夜就是从大到小把数输出来
for(i=1;i<=num;i++)
printf("%d ",deletemax());

getchar();
getchar();
return 0;
}