在排序過程中依據不同原則對內部排序方法進行分類，可大致分為插入排序、交換排序、選擇排序、歸併排序和基數排序等五類

插入排序

直接插入排序

直接插入排序市一中最簡單的排序方法，它的基本操作是將一個記錄插入到已排好序的有序表中，從而得到一個新的有序表

void InsertSort(SqList &L)
{
for(int i=2;i<L.length;i++)
    if(LT(L.r[i].key,L.r[i-1].key))
                            //若L.r[i].key<L.r[i-1].key則需將L.r
 
[i]插入有序表中
    {
        L.r[0]=L.r[i];      //複製哨兵
        for(int j=i-1;LT(L.r[0].key,L.r[j].key);--j)
        L.r[j+1]=L.r[j];    //記錄後移
        L.r[j+1]=L.r[0];    //插入至正確位置
    }
}//InsertSort

折半插入排序

——穩定的排序方法

 void BInsertSort( SqList &L) {
     for ( i = 2; i< L.length; ++i) {
       L.r[0] = L.r[i];                  // 將L.r[i]暫存在L.r[0] 
 

       low=1; high= i-1;
       while ( low<=high) {              // 在r[low.. High]中折半查詢有序插入的位置
           m = (low +high)/2;            // 折半
          if  LT( L.r[0].key, L.r[m].key)  high= m-1;   
                                         // 插入點在低半區
           else  low=m+1;                //插入點在高半區
       }//while
 

       for(j=i-1; j>=high+1; --j)   
           L.r[j+1]=L.r[j];              // 記錄後移
       L.r[high+1]=L.r[0];               // 插入
   } //for
}// BInsertSort

希爾排序

——不穩定的排序方法

希爾排序又稱“縮小增量排序”，先將整個待排記錄序列分割成若干自序列分別進行直接插入排序，待整個序列中的記錄“基本有序”時，再對整體進行一次直接插入排序

快速排序

氣泡排序

——穩定的排序方法

首先將第一個記錄的關鍵字和第二個記錄的關鍵字進行
比較，若為逆序（即L.r[1].key>L.r[2].key），則將兩個記錄交換之，
然後比較第二個記錄和第三個記錄的關鍵字。依次類推，直至第n-1
個記錄和第n個記錄的關鍵字進行過比較為止。上述過程稱作第一
趟起泡排序，其結果使得關鍵字最大的記錄被安置到最後一個記錄
的位置上。然後進行第二趟排序，對前n-1個記錄進行同樣操作，其
結果是使關鍵字次大的記錄被安置到第n-1個記錄的位置上

void  bubblesort (SqList &L){
                    //對順序表 L 做起泡排序
    for ( i = n-1, change = TRUE; i >= 1&& change; --i){
                    //在 0..i 的範圍內將第 n-i 大的元素起泡至位置 i
        change = FALSE;
        for ( j = 0; j < i; ++j)
            if ( L.r[j].key > L.r[j+1].key)
            {L.r[j] <-> L.r[j+1]; change = TRUE;}
    }//for-i
}//bubblesort

快速排序

——不穩定的排序方法

通過一趟快速劃分經待排記錄分割成兩個獨立的部分，其中一部分的關鍵字均比另一部分的關鍵字小，重複以上步驟，以達到整個序列有序

int Partition( SqList  &L, int low, int high ) {
    // 交換順序表L中子表L.r[low.. high]的記錄，使樞軸記錄到位，並返回其所在位置，此時，在它之前（後）的記錄均不大（小）於它。
    L.r[0] = L.r[low];   // 用子表的第一個記錄作樞軸記錄
     pivotkey = L.r[low].key; 
    while ( low<high) {
        while ( low<high && L.r[high].key >=pivotkey) --high;
       if (low<high)    L.r[low] = L.r[high];
        while ( low<high && L.r[low].key<=pivotkey)  ++low;
        if (low<high)   L.r[high] = L.r[low];
    }
    L.r[low] = L.r[0];      // 樞軸記錄到位
    reutrn low;              // 返回樞軸所在位置
 } // Partiton

選擇排序

簡單選擇排序

——穩定排序

通過 n-i 次關鍵字間的比較，從n-i+1個記錄中選出關鍵字最小的記錄，並和第i (1<=i<=n) 交換之

void  SelectSort( SqList  &L) {
       // 對順序表Ｌ作簡單選擇排序
　　for( i = 1;  i<L.length; ++i ) {
          j = SelectMinKey( L, i);   //選擇key值最小的記錄
　　 if ( i!=j)  L. r[i]  < — > L.r[j];
       }//for
  } //SelectSort

堆排序

——不穩定的排序方法

只需要一個記錄大小的輔助空間，每個待排序的記錄僅佔用一個儲存空間
堆的定義：完全二叉樹中所有非葉子節點的值均不大於（或均不小於）其左右孩子節點的值

 typedef  SqList   HeapType;      // 堆採用順序表儲存表示
 void  HeapAdjust( HeapType   &H, int s,  int  m) {
   //已知H.r[s..m]中記錄的關鍵字除H.r[s].key之外均滿足堆的定義，本函式調整H.r[s]的關鍵字，使H.r[s..m]成為一個大頂堆（對其中記錄的關鍵字而言）。
   rc = H.r[s];
   for ( j = 2*s; j<=m; j*=2) {      // 沿key較大的孩子結點向下篩選
      if ( j<m  && LT( H.r[j].key, H.r[j+1].key) ) ++j; 
                                     // j 為左右子 key 較大的記錄的下標
      if ( !LT( rc.key, H.r[j].key) )  break;   // rc應插入在位置s上
      H.r[s] = H.r[j]; s = j;
   }
   H.r[s] = rc;             // 插入
} // HeapAdjust

void  HeapSort( HeapType   &H) {
     // 對順序表H進行堆排序。
    for ( i= H.length/2; i>0; --i)     // 把H.r[1.. H.length]建成大頂堆
        HeapAdjust ( H, i, H.length );
    for ( i = H.length; i>1; --i){
        H.r[1]<->H.r[i];              // 將堆頂記錄和當前未經排序子序列
                                      // H.r[1.. i] 中最後一個記錄相互交換
        HeapAdjust( H, 1, i-1);   // 將 H.r[1.. i-1]
    }
 } // HeapSort

歸併排序

“歸併”的含義 是將兩個或兩個以上的有序表組合成一個新的有序表

2-路歸併排序

——穩定的排序方法

2-路歸併排序：假設初始序列含有n個記錄，則可看成是n個有序
的子序列，每個子序列的長度為1，然後兩兩歸併，得到 個
長度為2或1的有序子序列；再兩兩歸併，… …,如此重複，直至得
到一個長度為n的有序序列為止

鏈式基數排序

基數排序是一種藉助 “分配” 和 “收集” 兩種操作對單邏輯關鍵字
進行排序的一種內排方法。
其思想方法是：假設按 LSD 進行排序，
1、從最低位關鍵字起，按關鍵字的不同值（ RADIX 個）將序列中記錄 “分配” 到 RADIX 個鏈佇列中；
2、再 “收集” 之：按該位關鍵字從小到大順序將 RADIX 個鏈隊
列首尾連線；
3、重複1，2步 d 次。
按這種方法實現排序稱之為基數排序，其中 “基” 指的是 RADIX
的取值範圍

幾種排序方法的討論

排序方法 | 平均時間
——————————
簡單排序 | O( n2 )
——————————
快速排序 |O( n log n )
——————————
堆排序 | O( n log n )
——————————
歸併排序 | O( n log n )
——————————
基數排序 | O ( d( n + rd ) )

平均時間效能

快排最佳，所需時間最省，但在最壞情況下的時間效能不如堆排序和歸併排序。而後兩者相比較結果是，在N較大時，歸併排序所需時間較省，但所需輔助儲存量大

簡單性

包括除希爾排序之外的所有插入排序，氣泡排序和簡單選擇排序，其中以直接插入排序最為簡單

時間複雜度

技術排序的時間複雜度可以寫成O（d*n），因此，它適合用於n值很大而關鍵字較小的序列

穩定性

所有時間複雜度為O(n^2)的簡單排序法都是穩定的，而快排、堆排序和希爾排序等時間效能較好的排序方法都是不穩定的