算法导论——六、七章

第六章：堆排序

堆数据结构其实就是完全二叉树，可以用线性数组表示，但该数组A需要有两个属性：length[A]  heap-size[A]，分别表示A元素个数，

以及堆中元素个数。

求亲戚节点号：父亲是 └ i/2 ┘ 左儿子：2*i 右儿子 2*i +1

最大堆、最小堆则分别表示父亲是大还是小

堆排序:首先建立最大堆，然后根节点（有最大值）与末尾节点交换，然后将堆的大小减一，调整堆，再循环

HEAP-SORT(A){// O(n lg n)

    BUILD-MAX-HEAP(A);

    for(i = length[A]; i > 1; i --){

        exchange A[1], A[i]

        heap-size[A] --;

        MAX-HEAPIFY(A,1);

    }

}

BUILD-MAX-HEAP(A){//建立堆，└ length[A]/2 ┘后面都是叶子，没有孩子，无需调整        O(n)

     heap-size[A] = length[A];

     for (i = └ length[A]/2 ┘ ; i >0; i--){

         MAX-HEAPIFY(A,i);

     }

}

MAX-HEAPIFY(A,i){//只有i节点不符合性质，与自己的孩纸交换调整          O(lg n)

      m = left(i);

       n = right(i);

       if(m <= heap-size[A] && A[i] < A[m])

               largest = m;

       else  largest = i;

       if(n <= heap-size[A] && A[largest] < A[n]

                largest = n;

       if(largest != i){

                exchange A[i],A[largest];

                MAX-HEAPIFY(A,largest);

       }

}

第七章：快速排序

也是分治法，比较简单，不多说。

QUICK-SORT(A, p , r){

       if( p  <  r){

              q = PARTITION(A, p, r);

              QUICK-SORT(A, p , q);

              QUICK-SORT(A, q + 1 , r);

       }

}

PARTITION(A , p , r){

     x = A [r];

     i = p;

     for( j = p ; j <= r - 1; j ++){

            if(A[j] <= x ){ exchange A[i], A[j] ;      i ++;}

     }

     exchange A[i], A[r]

     return i;

}

最坏情况 O(n²). 平均情况O（n lg n）