一.、直接插入排序演算法(陣列儲存) 1.n個待排元素，分成兩部分，有序部分和無序部分 2.初始：有序段：a[0] 無序段：a[1]--a[n] 3.演算法實現思想 從無序中取出一個元素a[i]和有序區間元素進行比較，並且將其插入合適的位置，插入位置之後的元素要後移。 例： {3，2，5，8，4，7，6，9} {3}{2，5，8，4，7，6，9} {2，3}{5，8，4，7，6，9} {2，3，5}{8，4，7，6，9} {2，3，5，8}{4，7，6，9} {2，3，4，5，8}{7，6，9} {2，3，4，5，7，8}{6，9} {2，3，4，5，6，7，8}{9} {2，3，4，5，6，7，8，9} 4.演算法實現 void IninsertSort(inr a[],int n) { int i,j,x; for(i=1;i<n;i++) { x=a[i]; for(j=i-1;j>-1&&a[j]>x;j--) a[j+1]=a[j]; a[j+1]=x; } } 5.演算法效能及其優化 空間複雜度：O(1) 時間複雜度：O(n2) 穩定性：穩定 優化：插入時對有序段從後向前查詢； 找要插入的元素的位置時對有序段進行二分查詢 二、氣泡排序（陣列儲存） 1.n個元素排完序最多經過n-1趟 2.演算法實現思想 假如一組數按從小到大排序，對該組數進行兩兩比較，看是否需要交換，如果需要交換就交換，不需要交換就不用交換繼續繼續想下執行，直到這些元素都被比較過一遍之後，有一個元素放在了他最終的位置上（即：第一個或者最後一個） 例： {3，5，6，4，2，7} {2，3，5，6，4，7} {2，3，4，5，6，7} 3.演算法實現 void BubbleSort(int a[],int n) { int i,j,t; for(i=0;i><n-1;i++) { for(j=n-1;j>i;j--) { if(a[j]>a[j-1]) { t=a[j]; a[j]=a[j-1]; a[j-1]=t; } } } } 注：該過程需要把所有的過程跑完才結束 4.演算法效能及其優化 空間複雜度：O(1) 時間複雜度：O(n2) 穩定性：穩定 優化：對外層迴圈設定標記符flag,只要所以元素都按順序排完了就輸出，不需要所有的都跑完； 對內層迴圈，從後邊向前邊往出冒元素 實現程式碼如下： void BubbleSort(int a[],int n) { int i,j,t,tag; for(i=0;i<n-1;i++) { tag=0; for(j=n-1;j>i;j--) { t=a[j]; a[j]=a[j-1]; a[j-1]=t; tag=1; } if(!tag) break; } } 三、快速排序 1.基本思想 （1）選擇一個基準元素，，通常選擇第一個或者最後一個元素 （2）通過一次排序，將待排序記錄分割成兩部分，其中一部分記錄不基準元素小的元素，一部分記錄比基準元素大的元素 （3）此時基準元素正好在排好序的正確位置上 （4）然後分別對這兩部分記錄用同樣的方法繼續進行排序，直到整個序列有序 例： 2演算法實現： 遞迴實現： void QuickSort(int a[],int low,int high) { int i, j, x; if (low <high) { i = low; j = high; x = a[i]; while (i < j) { while(i < j && a[j] > x) j--; /* 從右向左找第一個小於x的數 */ if(i < j) a[i] = a[j]; while(i < j && a[i] < x) i++; /* 從左向右找第一個大於x的數 */ if(i < j) a[j] = a[i]; } a[i] = x; QuickSort(a, low, i-1); /* 遞迴呼叫 */ QuickSort(a, i+1, high); } } 非遞迴排序： #include<stdio.h> #define N 7 void QuickSort(int a[],int n) { for(int i=0;i<n;i++) { for(int j=0;j<n-i-1;j++) { if(a[j]>a[j+1]) { int t=a[j]; a[j]=a[j+1]; a[j+1]=t; } } } } //void QuickSort(int a[],int n) //{ // for(int i=0;i<n;i++) // { // for(int j=i;j<n;j++) // { // if(a[i]>a[j]) // { // int t=a[i]; // a[i]=a[j]; // a[j]=t; // } // } // } //} 3.演算法效能及其優化 空間複雜度：O(1) 時間複雜度：O(n2) 最好情況 O(nlogn) 穩定性：不穩定 優化： 在本改進演算法中 , 只對長度大於 k 的子序列遞迴呼叫快速排序 , 讓原序列基本有序，然後再對整個基本有序序列用插入排序演算法排序。實踐證明，改進後的演算法時間複雜度有所降低，且當 k 取值為  8  左右時 , 改進演算法的效能最佳。演算法思想如下:(連連結中有優化後的程式碼) 四、希爾排序 1.演算法思想 先將整個待排序的記錄序列分割成若干子序列分別進行插入排序，待整個序列中的記錄基本有序時在對整體進行一次直接插入排序 操作如下： 選擇一個增量序列個數k,對序列進行k趟排序，每趟排序，根據對應的增量d，將待排序列分成長度為m的子序列，分別對各自的表進行直接插入排序，盡因增量為1時，整個序列作為一個表來處理，表長度為整個序列的長度 例： 3.演算法實現 增量序列d = {n/2 ,n/4, n/8 .....1}  n 為要排序數的個數即：先將要排序的一組記錄按某個增量 d （ n/2,n 為要排序數的個數）分成若干組子序列，每組中記錄 的下 標相差 d. 對每組中全部元素進行直接插入排序，然後再用一個較小的增量（ d/2 ）對它進行分組，在每組中再進行直接插入排序。繼續不斷縮小增量直至為 1 ，最後使用直接插入排序完成排序。 void ShellSort(int a[],int n) { int i,j,x; int d=n/2; while(d>=1) { for(i=d;i<n;i++) { x=a[i]; for(j=i-d;j>=0;j-=d) { if(a[j]>x) a[j+d]=a[j]; else break; } a[j+d]=x; } d=d/2; } } 4.演算法效能及其優化 空間複雜度：O(1) 時間複雜度：O(n2) 最好情況 O(nlogn) 穩定性：不穩定 五、簡單選擇排序 1.演算法思想 設所有元素的第一個元素為最大的元素（或者最小的元素），然後用第一個元素與其他元素比較，找到其中最大的（或最小的）和第一個元素交換，一次排序完，陣列中第一個位置上放的是該序列完成排序後元素縮放的位置。（即一次排序完之後肯定有一個元素放到正確的位置上，後邊在比較時就不用再考慮這些元素） 2.演算法實現 void SelectSort(int a[],int n) { int i,j,kmin,t; for(i=0;i<n;i++) { kmin=i; for(j=i+1;j<n;j++) { if(a[kmin]>a[j]) kmin=j; } if(i!=kmin) { t=a[i]; a[i]=a[kmin]; a[kmin]=t; } } } 3.演算法效能及其優化 空間複雜度：O(1) 時間複雜度：O(n2) 穩定性：不穩定 優化： 簡單選擇排序，每趟迴圈只能確定一個元素排序後的定位。我們可以考慮改進為每趟迴圈確定兩個元素（當前趟最大和最小記錄）的位置 , 從而減少排序所需的迴圈次數。改進後對 n 個數據進行排序，最多隻需進行 [n/2] 趟迴圈即可。具體實現如下： void  SelectSort( int  r[], int  n) {       · int  i ,j , min ,max, tmp;        for  (i=1 ;i <= n/2;i++) {              // 做不超過n/2趟選擇排序             min = i; max = i ;  //分別記錄最大和最小關鍵字記錄位置             for  (j= i+1; j<= n-i; j++) {                if  (r[j] > r[max]) {                    max = j ;  continue  ;                }                  if  (r[j]< r[min]) {                    min = j ;                }             }            //該交換操作還可分情況討論以提高效率           tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;         tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;            }    }   六、歸併排序 1.演算法思想 是將兩個或者是兩個以上的有序表合成一個新的有序表，即把待排序列分成若干個子序列，每個子序列是有序的，然後把有序子序列合併成整體有序序列 例如： 歸併排序示例： 2.演算法實現 （1）遞迴實現 //實現歸併，並把資料都放在list1裡面 void merging(int *list1,int list1_size,int *list2,int list2_size) { int i,j,k,m; i = j = k = 0; int temp[MAXSIZE]； while(i<list1_size&&j<list2_size) { if(list1[i] < list2[j]) { temp[k++] = list1[i++]; } else { temp[k++] = list2[j++]; } } //如果有剩下的，那麼說明就是它是比前面的陣列都大的，直接加入就可以了 while(i<list1_size) { temp[k++] = list1[i++]; } while(j<list2_size) { temp[k++] = list2[j++]; } for(m=0; m<(list1_size + list2_size);m++) { list1[m] = temp[m]; } } void MergeSort(int k[],int n) { if(n>1) { int *list1 = k; //定義一個指標變數，指向陣列k的地址 int list1_size = n/2; //陣列的長度分為本來陣列長度的一半 int *list2 = k +n/2; //定義另外一個指標變數，指向陣列k+n/2的地址 int list2_size = n - list1_size;//長度為剛才總的減去剛才分去那一半 MergeSort(list1,list1_size); //呼叫陣列本身，相當與遞迴， MergeSort(list2,list2_size); //呼叫陣列本身，相當與遞迴 merging(list1,list1_size,list2,list2_size); } } （2）迭代實現 void MergeSort(int k[],int n) { int i,next,left_min,left_max,right_min,right_max; //開闢一個與原來陣列一樣大小的空間用來儲存用 int *temp = (int *)malloc(n * sizeof(int)); //逐級上升，第一次比較2個，第二次比較4個，第三次比較8個。。。 for(i=1; i<n; i*=2) { //每次都從0開始，陣列的頭元素開始 for(left_min=0; left_min<n-i; left_min = right_max) { right_min = left_max = left_min + i; right_max = left_max + i; //右邊的下標最大值只能為n if(right_max>n) { right_max = n; } //next是用來標誌temp陣列下標的，由於每次資料都有返回到K， //故每次開始得重新置零 next = 0; //如果左邊的資料還沒達到分割線且右邊的陣列沒到達分割線，開始迴圈 while(left_min<left_max&&right_min<right_max) { if(k[left_min] < k[right_min]) { temp[next++] = k[left_min++]; } else { temp[next++] = k[right_min++]; } } //上面迴圈結束的條件有兩個，如果是左邊的遊標尚未到達，那麼需要把 //陣列接回去，可能會有疑問，那如果右邊的沒到達呢，其實模擬一下就可以 //知道，如果右邊沒到達，那麼說明右邊的資料比較大，這時也就不用移動位置了 while(left_min < left_max) { //如果left_min小於left_max，說明現在左邊的資料比較大 //直接把它們接到陣列的min之前就行 k[--right_min] = k[--left_max]; } while(next>0) { //把排好序的那部分陣列返回該k k[--right_min] = temp[--next]; } } } } 3.演算法效能及其優化 空間複雜度：O(n+logN) 時間複雜度：O(nlog(n)) 穩定性：不穩定 優化：兩路歸併的遞演算法： void  MSort(ElemType *r, ElemType *rf, int  s,  int  t)   {        ElemType *rf2;       if (s==t) r[s] = rf[s];        else       {             int  m=(s+t)/2;           /*平分*p 表*/            MSort(r, rf2, s, m);         /*遞迴地將p[s…m]歸併為有序的p2[s…m]*/            MSort(r, rf2, m+1, t);       /*遞迴地將p[m+1…t]歸併為有序的p2[m+1…t]*/            Merge(rf2, rf, s, m+1,t);    /*將p2[s…m]和p2[m+1…t]歸併到p1[s…t]*/        }   }   void  MergeSort_recursive(ElemType *r, ElemType *rf,  int  n)   {    /*對順序表*p 作歸併排序*/        MSort(r, rf,0, n-1);   }   七、堆排序 1.演算法思想 堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。（形成的樹一定為完全二叉樹） 堆的定義如下：具有n 個元素的序列（k1,k2,...,kn),當且僅當滿足 時稱之為堆。由堆的定義可以看出， 堆頂元素 （即第一個元素）必為最小項（小頂堆）。若以一維陣列存 儲一個堆，則堆對應一棵完全二叉樹，且所有非葉結點的值均不大於(或不小於)其子女的值，根結點（堆頂元素）的值是最小(或最大)的。如： （a）大頂堆序列：（96, 83,27,38,11,09)   (b)  小頂堆序列：（12，36，24，85，47，30，53，91）

初始時把要排序的n個數的序列看作是一棵 順序儲存的二叉樹（一維陣列儲存二叉樹） ，調整它們的儲存 序，使之成為一個堆，將堆頂元素輸出，得到n 個元素中最小(或最大)的元素，這時堆的根節點的數最小（或者最大）。然後對前面(n-1)個元素重新調整使之成為堆，輸出堆頂元素，得到n 個元素中次小(或次大)的元素。依此類推，直到只有兩個節點的堆，並對它們作交換，最後得到有n個節點的有序序列。稱這個過程為 堆排序 。 因此，實現堆排序需解決兩個問題： （1） 如何將n 個待排序的數建成堆； （2）輸出堆頂元素後，怎樣調整剩餘n-1 個元素，使其成為一個新堆。 2.演算法實現 void Make_Heap(int a[],int end) { int pa,t,tag=1; while(tag) { pa=end/2; tag=0; while(pa>0) { if(a[pa]<a[2*pa]) { t=a[pa]; a[pa]=a[2*pa]; a[2*pa]=t; tag=1; } if(2*pa+1<=end&&a[pa]<a[2*pa+1]) { t=a[pa]; a[pa]=a[2*pa+1]; a[2*pa+1]=t; tag=1; } pa--; } } } void HeapSort(int a[]) { int pa,p; int end=N; while(end>1) { Make_Heap(a,end); //交換頭結點好尾節點 p=a[1]; a[1]=a[end]; a[end]=p; end--; } } 3.演算法效能及其優化 空間複雜度：O(1) 時間複雜度：最壞 O(nlogn ) 穩定性：不穩定 優化：無 八、基數排序（桶排序） 桶排序的基本思想：將陣列分佈到遊戲那數量的桶子裡，每個桶子再個別排序（有可能在使用別的排序演算法或是以遞迴方式繼續使用桶排序進行排序），桶排序是鴿巢排序的一種歸納結果。當要被排序的陣列內的數值是均勻分配的時候，桶排序使用線性時間(O(n)).但桶排序並不是比較排序，他不受到O(nlogn)下限的影響 簡單來說，就是把資料分組，放在一個個的桶中，然後對每個桶裡面的在進行排序。 例如要對大小為[1..1000]範圍內的n個整數A[1..n]排序 ， 首先，可以把桶設為大小為10的範圍，具體而言，設集合B[1]儲存[1..10]的整數，集合B[2]儲存   (10..20]的整數，……集合B[i]儲存(   (i-1)*10,   i*10]的整數，i   =   1,2,..100。總共有  100個桶。     然後，對A[1..n]從頭到尾掃描一遍，把每個A[i]放入對應的桶B[j]中。  再對這100個桶中每個桶裡的數字排序，這時可用冒泡，選擇，乃至快排，一般來說 任  何排序法都可以。   最後，依次輸出每個桶裡面的數字，且每個桶中的數字從小到大輸出，這  樣就得到所有數字排好序的一個序列了。     假設有n個數字，有m個桶，如果數字是平均分佈的，則每個桶裡面平均有n/m個數字。如果     對每個桶中的數字採用快速排序，那麼整個演算法的複雜度是     O(n   +   m   *   n/m*log(n/m))   =   O(n   +   nlogn   -   nlogm)     從上式看出，當m接近n的時候，桶排序複雜度接近O(n)  當然，以上覆雜度的計算是基於輸入的n個數字是平均分佈這個假設的。這個假設是很強的  ，實際應用中效果並沒有這麼好。如果所有的數字都落在同一個桶中，那就退化成一般的排序了。           前面說的幾大排序演算法 ，大部分時間複雜度都是O（n2），也有部分排序演算法時間複雜度是O(nlogn)。而桶式排序卻能實現O（n）的時間複雜度。但桶排序的缺點是：         1）首先是空間複雜度比較高，需要的額外開銷大。排序有兩個陣列的空間開銷，一個存放待排序陣列，一個就是所謂的桶，比如待排序值是從0到m-1，那就需要m個桶，這個桶陣列就要至少m個空間。         2）其次待排序的元素都要在一定的範圍內等等。        桶式排序是一種分配排序。分配排序的特定是不需要進行關鍵碼的比較，但前提是要知道待排序列的一些具體情況。
分配排序的基本思想： 說白了就是進行多次的桶式排序。 基數排序過程無須比較關鍵字，而是通過“分配”和“收集”過程來實現排序。它們的時間複雜度可達到線性階：O(n)。 例項: 撲克牌中52 張牌，可按花色和麵值分成兩個欄位，其大小關係為： 花色：  梅花< 方塊< 紅心< 黑心   面值：  2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A 若對撲克牌按花色、面值進行升序排序，得到如下序列：
即兩張牌，若花色不同，不論面值怎樣，花色低的那張牌小於花色高的，只有在同花色情況下，大小關係才由面值的大小確定。這就是多關鍵碼排序。 為得到排序結果，我們討論兩種排序方法。 方法1 ：先對花色排序，將其分為4 個組，即梅花組、方塊組、紅心組、黑心組。再對每個組分別按面值進行排序，最後，將4 個組連線起來即可。 方法2 ：先按13 個面值給出13 個編號組(2 號，3 號，...，A 號)，將牌按面值依次放入對應的編號組，分成13 堆。再按花色給出4 個編號組(梅花、方塊、紅心、黑心)，將2號組中牌取出分別放入對應花色組，再將3 號組中牌取出分別放入對應花色組，……，這樣，4 個花色組中均按面值有序，然後，將4 個花色組依次連線起來即可。 設n 個元素的待排序列包含d 個關鍵碼{k1，k2，…，kd}，則稱序列對關鍵碼{k1，k2，…，kd}有序是指：對於序列中任兩個記錄r[i]和r[j](1≤i≤j≤n)都滿足下列有序關係：                                                                 其中k1 稱為最主位關鍵碼，kd 稱為最次位關鍵碼     。 兩種多關鍵碼排序方法： 多關鍵碼排序按照從最主位關鍵碼到最次位關鍵碼或從最次位到最主位關鍵碼的順序逐次排序，分兩種方法： 最高位優先(Most Significant Digit first)法，簡稱MSD 法 ： 1）先按k1 排序 分組 ，將序列分成若干子序列，同一組序列的記錄中，關鍵碼k1 相等。 2）再對各組按k2 排序分成子組，之後，對後面的關鍵碼繼續這樣的排序分組，直到按最次位關鍵碼kd 對各子組排序後。 3）再將各組連線起來，便得到一個有序序列。撲克牌按花色、面值排序中介紹的方法一即是MSD 法。 最低位優先(Least Significant Digit first)法，簡稱LSD 法 ： 1) 先從kd 開始排序，再對kd-1進行排序，依次重複，直到按k1排序分組分成最小的子序列後。 2) 最後將各個子序列連線起來，便可得到一個有序的序列, 撲克牌按花色、面值排序中介紹的方法二即是LSD 法。
基於LSD方法的鏈式基數排序的基本思想 　　“多關鍵字排序”的思想實現“單關鍵字排序”。對數字型或字元型的單關鍵字，可以看作由多個數位或多個字元構成的多關鍵字，此時可以採用“分配-收集”的方法進行排序，這一過程稱作基數排序法，其中每個數字或字元可能的取值個數稱為基數。比如，撲克牌的花色基數為4，面值基數為13。在整理撲克牌時，既可以先按花色整理，也可以先按面值整理。按花色整理時，先按紅、黑、方、花的順序分成4摞（分配），再按此順序再疊放在一起（收集），然後按面值的順序分成13摞（分配），再按此順序疊放在一起（收集），如此進行二次分配和收集即可將撲克牌排列有序。    基數排序: 是按照低位先排序，然後收集；再按照高位排序，然後再收集；依次類推，直到最高位。有時候有些屬性是有優先順序順序的，先按低優先順序排序，再按高優先順序排序。最後的次序就是高優先順序高的在前，高優先順序相同的低優先順序高的在前。基數排序基於分別排序，分別收集，所以是穩定的。 演算法實現： Void RadixSort(Node L[],length,maxradix)   {       int  m,n,k,lsp;      k=1;m=1;       int  temp[10][length-1];      Empty(temp);  //清空臨時空間        while (k<maxradix)  //遍歷所有關鍵字       {         for ( int  i=0;i<length;i++)  //分配過程        {           if (L[i]<m)