常用的排序方法（一）
做過幾次各大IT公司的實習生招聘筆試題，發現數據結構還是很重要的，其中排序問題總是會出現在試題上，所以對幾種常見的排序方法總結下。
其實排序可分爲兩大類：內部排序和外部排序
內部排序：指需排序的記錄存放在計算機隨機存儲器中進行的排序過程，也就是小數量的數據排序，像冒泡排序，選擇排序等就是內部排序；
外部排序：指需排序的記錄數量很大，以致內存一次不能容納全部記錄，在排序過程中需對外存進行訪問的排序過程；這種我暫時沒怎麼接觸過，不多說了；
下面是幾種常見的部內排序方法：
1. 直接插入排序
每次從無序表中抽出一個數插入到有序表中，使得表仍然有序，第一趟比較前兩個數,然後把第二個數按大小插入到有序表中; 第二趟把第三個數據與前兩個數從後向前掃描，把第三個數按大小插入到有序表中；依次進行下去，進行了(n-1)趟掃描以後就完成了整個排序過程，整個過程如下：
假設序列爲49 38 65 97 76 13 27
【初始關鍵字】 ( 49 ) 38 65 97 13 27
i=2 (38) ( 38 49 ) 65 97 13 27
i=3 (65) ( 38 49 65 ) 97 13 27
i=4 (97) ( 38 49 65 97 ) 13 27
i=5 (13) ( 13 38 49 65 97 ) 27
i=5 (27) ( 13 27 38 49 65 97 )
監視哨（保存當前待比較的數值）temp
Java代碼實現：
int[] text(int[] a ){
for (int i = 1; i < a.length; i++) {
int temp = a[i];
for (int j = i; j > 0 && temp < a[j-1]; j--) {
a[j] = a[j - 1];
}
a[j] = temp;
}
return a;
}
2．希爾排序
又稱縮小增量排序，其基本思想是：先將整個待排序的記錄序列分割成若干子序列分別進行直接插入排序，待整個序列中的記錄“基本有序”時，再對全體記錄進行一次直接插入排序；
就是先取一個小於n（整個記錄的長度）的整數t1作爲第一個增量，把文件的全部記錄分成t1個組。所有距離爲t1的倍數的記錄放在同一個組中。先在各組內進行直接插入排序；然後，取第二個增量t2<t1重複上述的分組和排序，直至所取的增量ti=1(ti<ti-l<…<t2<t1)，即所有記錄放在同一組中進行直接插入排序爲止；
如果記錄的量大且一組內的記錄相隔距離遠，那麼就可以省去多次數據交換，這就是對直接插入排序的改進之處。示例如下：
假設序列爲：49 38 65 97 76 13 27 49 55 04
增量可取： 5 ， 3 ， 1
【初始關鍵字】 49 38 65 97 76 13 27 49 55 04
先分成5組：（49 13） （38 27） （65 49） （97 55） （76 04）
每一組進行直接插入排序後：13 27 49 55 04 49 38 65 97 76（第一趟排序結果）
然後分成3組：（13 55 38 76） （27 04 65） （49 49 97）
每一組進行直接插入排序後：13 04 49 38 27 49 55 65 97 76（第二趟排序結果）
再分成1組（對整個序列排序）（13 04 49 38 27 49 55 65 97 76）
進行直接插入排序後：04 13 27 38 49 49 55 65 76 97（第三趟排序結果）
Java代碼實現：
int [] ShellSort(int[] a) {
int Temp; // 暫存變量
int DataLength; // 分割集合的間隔長度
int Pointer; // 進行處理的位置
DataLength = a.length / 2; // 初始集合間隔長度
while (DataLength != 0) // 數列仍可進行分割
{ // 對各個集合進行處理
for (int j = DataLength; j < a.length; j++) {
Temp = a[j]; // 暫存Data[j]的值,待交換值時用
Pointer = j - DataLength; // 計算進行處理的位置
// 進行集合內數值的比較與交換值
while (Temp < a[Pointer] && Pointer >= 0 && Pointer < a.length) {
a[Pointer + DataLength] = a[Pointer];
// 計算下一個欲進行處理的位置
Pointer = Pointer - DataLength;
if (Pointer < 0 || Pointer >= Index)
break;
}
// 與最後的數值交換
a[Pointer + DataLength] = Temp;
DataLength = DataLength / 2; // 計算下次分割的間隔長度
}
return a;
}
3．冒泡排序
冒泡排序的過程很簡單，首先將第一個數和第二個數進行比較，如果是逆序的，就將兩個數交換，然後比較第二個數和第三個數，依次類推，直到第n-1個數和第n個數據進行比較完爲止，然後進行延續二趟排序，對前n-1個數進行同類操作，直到沒有數可比；
假設序列爲： 49 38 65 97 76 13 27 49
第一趟排序：38 49 65 76 13 27 49 97
第二趟排序：38 49 65 13 27 49 76
第三趟排序：38 49 13 27 49 65
第四趟排序：38 13 27 49 49
第五趟排序：13 27 38 49
第六趟排序：13 27 38
從上面的排序過程可以看到：大的數一個個往下沉，小的數的就向上浮，跟這個排序方法的名字很貼切。
Java代碼實現：
int sort (int[] a){
for(int j=1;j<=a.length;j++){
for(int i=0;i<a.length-j;i++){
if(a[i]>a[i+1]){
int temp;
temp = a[i];
a[i] = a[i+1];
a[i+1] = temp;
}
}
return a;
}
爲了提高效率，可以設置一個是否繼續比較下去的標誌，因爲如果數列的排列順序就是所要求的順序，那就沒必要一個個往下比了，比如：當一趟排序中沒有發生數據交換，就可以提前終止。
4．快速排序
快速排序是對冒泡排序的一種改進，通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列；
設要排序的數組是A[0]……A[N-1]，首先任意選取一個數據（通常選用第一個數據）作爲關鍵數據，然後將所有比它小的數都放到它前面，所有比它大的數都放到它後面，這個過程稱爲一趟快速排序。值得注意的是，快速排序不是一種穩定的排序算法，也就是說，多個相同的值的相對位置也許會在算法結束時產生變動。
一趟快速排序的算法是：
1）設置兩個變量I、J，排序開始的時候：I=0，J=N-1；
2）以第一個數組元素作爲關鍵數據，賦值給key，即 key=A[0]；
3）從J開始向前搜索，即由後開始向前搜索（J=J-1），找到第一個小於key的值A[J]，並與A[I]交換；
4）從I開始向後搜索，即由前開始向後搜索（I=I+1），找到第一個大於key的A[I]，與A[J]交換；
5）重複第3、4、5步，直到 I=J； (3,4步是在程序中沒找到時候j=j-1，i=i+1，直至找到爲止。找到並交換的時候i， j指針位置不變。另外當i=j這過程一定正好是i+或j-完成的最後另循環結束)
過程可如下圖表示：
上面是完成一趟排序的過程，整個排序過程可描述如下：
初始狀態 （49 38 65 97 76 13 27 49）
一次劃分之後 ( 27 38 13 ) 49 （76 97 65 49）
分別進行快速排序 （13）27 （38）
結束 結束 ( 49 65 ) 76 ( 97 )
49 ( 65 ) 76 結束
結束
有序序列 ( 13 27 38 49 49 65 76 97 )
Java代碼實現：
int[] sort(int[] data, int low, int high) {
// 樞紐元,一般以第一個元素爲基準進行劃分
int i = low;
int j = high;
if (low < high) {
// 從數組兩端交替地向中間掃描
int pivotKey = data[low];
// 進行掃描的指針i,j;i從左邊開始,j從右邊開始
while (i < j) {
while (i < j && a[j]>=pivotkey) {
j--;
}// end while
if (i < j) {
// 比樞紐元素小的移動到左邊
data[i] = data[j];
i++;
}// end if
while (i < j && a[i]<=pivotkey) {
i++;
}// end while
if (i < j) {
// 比樞紐元素大的移動到右邊
data[j] = data[i];
j--;
}// end if
}// end while
// 樞紐元素移動到正確位置
data[i] = pivotKey;
// 前半個子表遞歸排序
sort(data, low, i - 1);
// 後半個子表遞歸排序
sort(data, i + 1, high);
}// end if
return a;
}// end sort
5．簡單選擇排序
其基本思想是：在每一趟排序中將n-i+1(i=1,2,…,n-1)個記錄中選取最小的記錄和有序序列中第i個記錄交換，個人覺得這種排序方法跟冒泡排序很像，比如從小到大排序，冒泡是將大的數一個一個往下沉，而簡單選擇排序是將小的數一個個往上冒；
Java代碼實現：
int[] sort(int[] data) {
int len = data.length;
for (int i = 0; i < len; i++) {
int position = i;
for (int j = i + 1; j < len; j++) {
if (data[position]>data[j])) {
position = j;
}
}
Int temp = data[i];
data[i] = data[position];
data[position] = temp;
}
}