用C語言總結一下常用排序演算法，雖然大多數語言裡已經提供了排序演算法，比如C函式庫中提供了qsort排序函式（內部為快速排序實現），但理解排序演算法的思想的意義遠遠超過了實用的價值。這裡我總結了常用的排序演算法，並用C語言實現。這些演算法的書寫順序也有一定的關聯，比如希爾排序是對插入演算法的改進，快速排序是對氣泡排序的改進，快速排序和歸併排序都用遞迴實現。

注：每種方法的實現儘量提供了相同的形參列表。這裡並沒用涉及堆排序，箱排序等演算法的實現。

插入排序

演算法概要：插入排序依據遍歷到第N個元素的時候前面的N-1個元素已經是排序好的，那麼就查詢前面的N-1個元素把這第N個元素放在合適的位置，如此下去直到遍歷完序列的元素為止。

1. void insertSort(int array[], int length)  
2. {  
3.     int key;  
4.     for(int i=1; i<length; i++)  
5.     {  
6.         key = array[i];   
7.         for(int j=i-1; j>=0 && array[j] > key; j--)  
8.         {  
9.                 array[j+1] = array[j];  
10.         }  
11.         array[j+1] = key;  
12.     }  
13. }  

希爾排序

演算法概要：shell排序是對插入排序的一個改裝，它每次排序排序根據一個增量獲取一個序列，對這這個子序列進行插入排序，然後不斷的縮小增量擴大子序列的元素數量，直到增量為1的時候子序列就和原先的待排列序列一樣了，此時只需要做少量的比較和移動就可以完成對序列的排序了。

1. void shellSort(int array[], int length)  
2. {  
3.     int key;  
4.     int increment;  
5.     for(increment = length/2; increment>0; increment /= 2)  
6.     {  
7.         for(int i=increment; i<length; i++)  
8.         {  
9.             key = array[i];  
10.             for(int j = i-increment; j>=0 && array[j] > key; j -= increment)  
11.             {  
12.                 array[j+increment] = array[j];  
13.             }  
14.             array[j+increment]=key;  
15.         }  
16.     }  
17. }  

氣泡排序

演算法概要：氣泡排序是經過n-1趟子排序完成的，第i趟子排序從第1個數至第n-i個數，若第i個數比後一個數大（則升序，小則降序）則交換兩數。

1. void bubbleSort(int  array[], int length)  
2. {  
3.     int flag = 0;  
4.     for(int i=0; i<length-1; i++)  
5.     {  
6.         for(int j=0; j<length-1-i; j++)  
7.         {  
8.             if(array[j]>array[j+1])  
9.             {  
10.                 flag = 1;  
11.                 array[j] = array[j] + array[j+1];  
12.                 array[j+1] = array[j] - array[j+1];  
13.                 array[j] = array[j] - array[j+1];  
14.             }  
15.         }  
16.         if(flag == 0) break;  
17.     }  
18. }  

快速排序

快速排序（Quicksort）是對氣泡排序的一種改進。通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，以此達到整個資料變成有序序列。

1. int Sort(int array[], int first, int last)  
2. {  
3.     int pivot = array[first];  
4.     int temp;  
5.     if(last-first <=0) return -1;  
6.     while(first != last)  
7.     {  
8.         while(array[last] >= pivot && last != first) last--;  
9.         temp = array[first];  
10.         array[first] = array[last];  
11.         array[last] = temp;  
12.         while(array[first] <= pivot && last != first) first++;  
13.         temp = array[first];  
14.         array[first] = array[last];  
15.         array[last] = temp;  
16.     }  
17.     return last;  
18. }  
19. void quickSort(int array[], int length)  
20. {  
21.     int temp = Sort(array, 0, length-1);  
22.     if(temp == -1 ) return;  
23.     quickSort(array,temp+1);  
24.     quickSort(&array[temp+1],length-temp-1);  
25. }  

歸併排序

演算法概要：歸併排序法是將兩個（或兩個以上）有序表合併成一個新的有序表，即把待排序序列分為若干個子序列，每個子序列是有序的。然後再把有序子序列合併為整體有序序列。

1. void Merge(int A[],int low,int mid,int high)      
2.  {      
3.      int i,j,k;    
4.      int *P = newint[mid-low+1],*Q = newint[high-mid];      
5.      for (i =0;i  < mid - low +1;++i)   P[i] = A[i+low];
6.      for (i = 0; i  < high - mid;++i)   Q[i] = A[mid+1+i];      
7.      i = j = 0,k = low;      
8.      while ((i  <= mid-low) && (j  <= high-mid-1))      
9.      {      
10.          if (P[i]  <= Q[j])   A[k++] = P[i++];      
11.          else  A[k++]= Q[j++];      
12.      }      
13.      if (i > mid - low)   { for (;j  <= high-mid-1;++j)   A[k++] = Q[j]; }      
14.      else
15.      {   for (; i <= mid - low;++i)   A[k++] = P[i];  }      
16.      delete [] P;      
17.      delete [] Q;      
18.  }      
19.  void mergeSort(int A[],int left,int right)      
20.  {      
21.      if (left  < right)      
22.      {      
23.          int i = (left + right) / 2;      
24.          MergeSort(A,left,i);      
25.          MergeSort(A,i+1,right);      
26.          Merge(A,left,i,right);      
27.      }      
28.  }