－希爾排序
克服插入排序每次只能交換一對元素的缺點
5-間隔的排序，3-間隔的排序，1-間隔排序（最后必須是1-間隔）
最重要的性質：更小間隔的排序不會破壞較大間隔排序的大小序列
原始希爾排序
void Shell_sort ( ElementType A[ ], int N )
{
for ( D = N/2 ; D > 0 ; D /= 2 ) { // 希爾增量序列（eg：5、3、1）
for ( P = D ; P < N ; P ++ ) { // 插入排序
Tmp = A [ P ] ;
for ( i = p ; i >= D && A[ i - D ] > Tmp ; i -= D )
A[ i ] = A[ i - D ] ;
A[ i ] = Tmp ;
}
}
}
如果增量元素不互質，則小增量可能根本不起作用
＊更大增量序列：
Hibbard增量序列： Dk = 2的k次方－1；相鄰的元素互質
Sedgewick增量序列：｛1，5，19，41，109，…｝；
－堆排序
選擇排序中，從未排序序列中找出最小元素，取出放入最小位置。這一過程也是一個for循環，會提高時間復雜度，堆排序是在選擇排序的基礎上改進這一過程
void Heap_Sort ( ElementType A[ ], int N )
{
for ( i = N/2 ; i >= 0 ; i - - ) // 建立最小堆
PercDown ( A , i , N ) ; // i 對應根結點的位置，N對應當前堆里有多少元素
for ( i = N - 1 ; i > 0 ; i - - ){
Swap ( &A[ 0 ] , & A [ i ] ) ; // i 紀錄當前最后元素的下標
PercDown ( A , 0 , i ) ; // 調整為最大堆
}
}
定理：堆排序處理N個不同元素的隨機排列的平均比較次數是：2N logN - O ( N log logN )
雖然堆排序給出最佳平均時間復雜度，但實際效果不如用Sedgewick增量排序的希爾排序。
－歸并排序
核心：兩個有序子序列的歸并
void Merge { ElementType A[ ] , ElementType TmpA[ ] , int L , int R , int RightEnd }
// A[ ]是原始待排的序列，TmpA[ ]是臨時存放數組
{
LeftEnd = R - 1 ; // 左邊終點位置。假設左右兩列挨著，左邊位置等于右邊位置減1
Tmp = L ; // 存放結果的數組的初始位置
NumElements = RightEnd - L + 1 ; // 歸并結束后元素數量
while ( L <= LeftEnd && R <= RightEnd ){
if ( A[ L ] <= A[ R ] ) TmpA [ Tmp ++ ] = A[ L++ ] ;
else TmpA [ Tmp ++ ] = A[ R++ ] ;
}
while ( L <= LeftEnd ) // 直接復制左邊剩下的
TmpA [ Tmp ++ ] = A [ L++ ] ;
while ( R <= RightEnd ) // 直接復制右邊剩下的
TmpA [ Tmp++ ] = A[ R++ ] ;
for ( i = 0 ; i < NumElements ; i ++ , RightEnd - - ) // 由于 RightEnd一直沒變，從它開始講TmpA倒入A
A[ RightEnd ] = TmpA[ RightEnd ] ;
}
遞歸算法（分而治之）
void MSort { ElementType A[ ] , ElementType TmpA[ ] , int L , int RightEnd }
{
int Center ;
if ( L < RightEnd ){
Center = ( L + RightEnd ) / 2 ;
MSort ( A , TmpA , L , Center ) / 2 ;
MSort ( A , TmpA , Center + 1 , RightEnd ) ;
Merge ( A , TmpA , L , Center + 1 , RightEnd ) ;
}
}
統一函數接口
void Merge_sort ( ElementType A[ ] , int N )
{
ElementType *TmpA ;
TmpA = malloc ( N * sizeof ( ElementType ) ) ; // 申請一塊與原始序列同樣大小的內存作為臨時數組
if ( TmpA != NULL ){
MSort ( A , TmpA , 0 , N - 1 ) ;
free ( TmpA ) ; // 釋放臨時數組 TmpA
}
else Error ( “空間不足” ) ;
}
非遞歸算法
void Merge_pass { ElementType A[ ] , ElementType TmpA[ ] , int N , int length } // 當前有序子列的長度
{
for ( i = 0 ; i <= N - 2length ; i += 2length )
Merge1 ( A , TmpA , i , i + length , i + 2*length - 1 ) ; // 將A中元素歸并到TmpA中
if ( i + length < N ) // 歸并最后2個子列
Merge1 ( A , TmpA , i , i + length , N - 1 ) ;
else // 最后只剩1個子列
for ( j = 1 ; j < N ; j ++ ) TmpA[ j ] = A[ j ] ;
}
統一接口：
void Merge_sort ( ElementType A[ ] , int N )
{
ElementType *TmpA ;
TmpA = malloc ( N * sizeof ( ElementType ) ) ;
if ( TmpA != NULL ) {
while ( length < N ) {
Merge_pass ( A , TmpA , N , length ) ;
length += 2 ;
Merge_pass ( TmpA , A , N , length ) ;
length *= 2 ;
}
free ( TmpA ) ;
}
else Error ( “空間不足" )
}
它是穩定的，一般不做內排序，做外排序時非常有用
