排序和顺序统计量（算法导论）

人一生别太狂，指不定谁辉煌

总结排序算法的运行时间

算法	最坏运行时间	平均期望运行时间	是否是原址排序
插入排序	O(n2)	O(n2)	是
归并排序	O(nlgn)	O(nlgn)	否
堆排序	O(nlgn)	……	是
快速排序	O(n2)	O(nlgn)期望	是
计数排序	O(k+n)	O(k+n)	否
基数排序	O(d(k+n))	O(d(k+n))
桶排序	O(n2)	O(n)

---

选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法

---

堆排序

堆排序算法的设计

HeapSort(A){
    BuildMaxHeap(A);
    for(i=A.length downto 1){
        exchange(A[1],A[i]);
        A.heapSize = A.heapSize-1;
        MaxHeapIfy(A,1);
    }

}
//构建大根堆
BuildMaxHeap(A){
    A.heapSize = A.length;
    for(i=A.length/2 downto 1){
        MaxHeapIfy(A,i)
    }
}

//维护堆的性质
MaxHeapIfy(A,i){
    l = left(i);
    r = right(i);
    if(l<A.heapSize&&A[i]<A[l]){
        laragest=l;
    }else{
        laragest=i;
    }
    if(r<A.heapSize&&A[laragest]<A[r]){
        laragest=r;
    }
    if(laragest!=i){
        exchange(A[i],A[laragest]);
        MaxHeapIfy(A,laragest)
    }





}

优先队列

优先队列十分类似于堆排序，只是在使用方法的命名和在结构上略有差异。
优先队列是一种用来维护一组元素构成的集合S的数据结构，其中的每一个元素都有一个相关的值，称为关键字。

快速排序

普通快速排序的算法设计

QuickSort(A,p,r){
    if(p<r){
        q=Partition(A,p,r);
        QuickSort(A,p,q-1);
        QuickSort(A,q+1,r){
    }
}

Partition(A,p,r){
    x=A[r];
    i=p-1;
    for(j=p to r-1){
        if(A[j]<x){
            i=i+1;
            exchange(A[i],A[j]);
        }
    }
    exchange(A[i+1],A[r]);
    return i+1;
}

快速排序随机化版本的算法

RandomPartition(A,p,r){
    i=Random(p,r);
    exchange(A[i],A[r]);
    return Partition(A,p,r);
}

计数排序

CountSort(A,B,k){
    C[k] = new array;
    for(i=0 to k){
        C[i]=0;
    }
    for(j=1 to A.length){
        C[A[j]] = C[A[j]]+1;
    }
    for(i=1 to k){
        C[i]=C[i]+C[i-1];
    }
    for(j=A.length downto 1){
        B[C[A[j]]]=A[j];
        C[A[j]]=C[A[j]]-1;
    }

}