堆排序-----大话数据结构

算法导论--伪代码

思路：对待排序的数组先建立最大堆，将根节点（最大值）与最后一个结点交换，递归

HEAPSORT(A)                         /*A是数组A[1...n]*/
    BUILD-MAX-HEAP(A)              /*建最大堆*/
    for i=A.length downto 2
        exchange A[1] with A[i]
        A.heap_size=A.heap_size-1
        MAX-HEAPIFY(A,1)          /*使得以下标为i为根节点的子树重新遵循最大堆的性质*/

/*建堆*/
BUILD-MAX-HEAP(A)
    A.heap_size=A.length
    for i=[A.length/2] downto 1  //对所有非叶节点，与他的孩子相比找到最大的交换，所以从
        MAX-HEAPIFY(A,i)         //   length/2开始遍历到根结点

MAX-HEAPIFY(A,i) 
    l=LEFT(i)   /*i的左孩子的下标*/
    r=RIGHT(i)  /*i的右孩子的下标*/
    if l<=A.heap_size and A[l]>A[i]     //从A[i]，A[LEFT(i)],A[RIGHT(i)]中选出最大的
        largest=l                       //并将下标保存在largest
    else largist=i                      //
    if r<=A.heap_size and A[r]>A[i]     //
        largest=r                       //
    if largest≠i
        exchange A[i] with A [largest]
        MAX-HEAPIFY(A,largest)          //下标为largest的结点的值，交换后，是原来的A[i]，
                                        //以为largest为根节点的子树不一定满足最大堆，递归
    

大话数据结构

思路：第一步：建最大堆；第二步：循环（将最大值（根节点）与末尾元素交换，并调节成最大堆）

void HeapSort(SqList *L)
{
    int i;
    for(i=L->length/2;i>0;i--)  /*从非叶节点开始建堆*/
        HeapAdjust(L,i,L->length);

    for(i=L->length;i>1;i--)
    {
        swap(L,1,i); /*堆顶与最后一个交换*/
        HeapAdjust(L,1,L->length-1); /*将L->r[1..i-1]重新调整为大顶堆*/
    }    
}

/*与算法导论不同，非递归，有点不好理解*/

/*与算法导论不同，非递归，有点不好理解*/
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;                      //
        if(temp>=L->r[j])             //再与该节点比较
            break;                    //
        L->r[s]=L->[j];               //
        s=j;
    }
    L->r[s]=temp;
}