當我們進行數據處理的時候，往往需要對數據進行查找操作，一個有序的數據集往往能夠在高效的查找算法下快速得到結果。所以排序的效率就會顯的十分重要，本篇我們將着重的介紹幾個常見的排序算法，涉及如下內容：
- 排序相關的概念
- 插入類排序
- 交換類排序
- 選擇類排序
- 歸並排序算法實現
一、排序相關的基本概念
排序其實是一個相當大的概念，主要分為兩類：內部排序和外部排序。而我們通常所說的各種排序算法其實指的是內部排序算法。內部排序是基於內存的，整個排序過程都是在內存中完成的，而外部排序指的是由於數據量太大，內存不能完全容納，排序的時候需要借助外存才能完成（常常是算計着某一部分已經計算過的數據移出內存讓另一部分未被計算的數據進入內存）。而我們本篇文章將主要介紹內排序中的幾種常用排序算法：
還有一個概念問題，排序的穩定性問題。如果Ai = Aj，排序前Ai在Aj之前，排序后Ai還在Aj之前，則稱這種排序算法是穩定的，否則說明該算法不穩定。
二、插入類排序算法
插入類排序算法的核心思想是，在一個有序的集合中，我們將當前值插入到適合位置上，使得插入結束之后整個集合依然是有序的。那我們接下來就學習下這幾種同一類別的不同實現。
1、直接插入排序
直接插入排序算法的核心思想是，將第 i 個記錄插入到前面 i-1 個已經有序的集合中。下圖是一個完整的直接插入排序過程：
因為一個元素肯定是有序的，i 等於 2 的時候，將第二個元素插入到前 i-1個有序集合中，當 i 等於3的時候，將第三個元素插入到前 i-1（2）集合中，等等。直到我們去插入最后一個元素的時候，前面的 i-1 個元素構成的集合已經是有序的了，於是我們找到第 i 個元素的合適位置插入即可，整個插入排序完成。下面是具體的實現代碼：
public static void InsertSort(int[] array){
int i=0,j=0,key;
for (i=1;i<10;i++){
key = array[i];
j = i-1;
while(j>=0&&key<array[j]){
//需要移動位置,將較大的值array[j]向后移動一個位置
array[j+1] = array[j];
j--;
}
//循環結束說明找到適當的位置了,是時候插入值了
array[j+1] = key;
}
//輸出排序后的數組內容
for (int value : array){
System.out.print(value+",");
}
}
//主函數中對其進行調用
int[] array = {1,13,72,9,22,4,6,781,29,2};
InsertSort(array);
輸出結果如下：
整個程序的邏輯是從數組的第二個元素開始，每個元素都以其前面所有的元素為基本，找到合適的位置進行插入。對於這種按照從小到大的排序原則，程序使用一個臨時變量temp保存當前需要插入的元素的值，從前面的子序列的最后一個元素開始，循環的與temp進行比較，一旦發現有大於temp的元素，讓它順序的往后移動一個位置，直到找到一個元素小於temp，那么就找到合適的插入位置了。
因為我們使用的判斷條件是，key>array[j]。所以來說，插入排序算法也是穩定的算法。對於值相同的元素並不會更改他們原來的位置順序。至於該算法的效率，最好的情況是所有元素都已有序，比較次數為n-1，最壞的情況是所有元素都是逆序的，比較次數為（n+2）（n-1）/2，所以該算法的時間復雜度為O（n*n）。
2、二分折半插入排序
既然我們每次要插入的序列是有序的，我們完全可以使用二分查找到合適位置再進行插入，這顯然要比直接插入的效率要高一些。代碼比較類似，不再做解釋。
public static void halfInsertSort(int[] array){
for(int k=1;k<array.length;k++){
int key = array[k];
//找到合適的位置
int low,high,mid;
low = 0;high = k-1;
while(low <= high){
mid = (low+high)/2;
if(key == array[mid])break;
else if(key > array[mid]){
low = mid+1;
}else{
high = mid-1;
}
}
//low的索引位置就是即將插入的位置
//移動low索引位置后面的所有元素
for(int x=k-1;x>=low;x--){
array[x+1] = array[x];
}
array[low] = key;
}
//遍歷輸出有序隊列內容
for(int key:array){
System.out.print(key + ",");
}
}
雖然，折半插入改善了查找插入位置的比較次數，但是移動的時間耗費並沒有得到改善，所以效率上優秀的量可觀，時間復雜度仍然為O(n*n)。
2、希爾排序
直接插入排序在整個待排序序列基本有序的情況下，效率最佳，但我們往往不能保證每次待排序的序列都是基本有序的。希爾排序就是基於這樣的情形，它將待排序序列拆分成多個子序列，保證每個子序列的組成元素相對較少，然后通過對子序列使用直接排序。對於本就容量不大的子序列來說，直接排序的效率是相當優秀的。
希爾排序算法使用一個距離增量來切分子序列，例如：
如圖，我們初始有一個序列，按照距離增量為4來拆分的話，可以將整個序列拆分成四個子序列，我們對四個子序列內部進行直接插入排序得到結果如下：
修改距離增量重新划分子序列：
很顯然，當距離增量變小的時候，序列的個數也會變少，但是這些子序列的內部都基本有序，當對他們進行直接插入排序的時候會使得效率變高。一旦距離增量減少為1，那么子序列的個數也將減少為1，也就是我們的原序列，而此時的序列內部基本有序，最后執行一次直接插入排序完成整個排序操作。
下面我們看算法是的具體實現：
/*漸減delete的值*/
public static void ShellSort(){
int[] array = {46,55,13,42,94,17,5,70};
int[] delets = {4,2,1};
for (int i=0;i<delets.length;i++){
oneShellSort(array,delets[i]);
}
//遍歷輸出數組內容
for(int value : array){
System.out.print(value + ",");
}
}
/*根據距離增量的值划分子序列並對子序列內部進行直接插入排序*/
public static void oneShellSort(int[] array,int delet){
int temp;
for(int i=delet;i<array.length;i++){
//從第二個子序列開始交替進行直接的插入排序
//將當前元素插入到前面的有序隊列中
if(array[i-delet] > array[i]){
temp = array[i];
int j=i-delet;
while(j>=0 && array[j] > temp){
array[j+delet] = array[j];
j -= delet;
}
array[j + delet] = temp;
}
}
}
方法比較簡單，具體的實現和直接插入排序算法相近，此處不再做解釋。
三、交換類排序
交換類的排序算法一般是利用兩個元素之間的值的大小進行比較運算，然后移動外置實現的，這類排序算法主要有兩種：
1、冒泡排序
冒泡排序通過兩兩比較，每次將最大或者最小的元素移動到整個序列的一端。這種排序相當常見，也比較簡單，直接上代碼：
public static void bubbleSort(int[] array){
int temp = 0;
for(int i=0;i<array.length-1;i++){
for(int j =0;j<array.length-1-i;j++){
if(array[j]>array[j+1]){
//交換兩個數組元素的值
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
//遍歷輸出數組元素
for(int value : array){
System.out.print(value + ",");
}
}
2、快速排序
快速排序的基本思想是，從序列中任選一個元素，但通常會直接選擇序列的第一個元素作為一個標准，所有比該元素值小的元素全部移動到他的左邊，比他大的都移動到他的右邊。我們稱這叫做一趟快速排序，位於該元素兩邊的子表繼續進行快速排序算法直到整個序列都有序。該排序算法是目前為止，內部排序中效率最高的排序算法。具體它是怎么做的呢？
首先他定義了兩個頭尾指針，分別指向序列的頭部和尾部。從high指針位置開始掃描整個序列，如果high指針所指向的元素值大於等於臨界值，指針前移。如果high指針所指向的元素的值小於臨界值的話：
將high指針所指向的較小的值交換給low指針所指向的元素值，然后low指針前移。
然后從low指針開始，逐個與臨界值進行比較，如果low指向的元素的值小於臨界值，那么low指針前移，否則將low指針所指向的當前元素的值交換給high指針所指向的當前元素的值，然后把high指針前移。
按照這樣的算法，
當low和high會和的時候，就代表着本次快速排序結束，臨界值的左邊和右邊都已歸類。這樣的話，我們再使用遞歸去快速排序其兩邊的子表，直到最后，整張表必然是有序的。下面我們看代碼實現：
/*快速排序的遞歸定義*/
public static void FastSort(int[] array,int low,int high){
if(low<high){
int pos = OneFastSort(array,low,high);
FastSort(array,low,pos-1);
FastSort(array,pos+1,high);
}
}
public static int OneFastSort(int[] array,int low,int high){
//實現一次快速排序
int key = array[low];
int flag = 0;
while (low != high) {
if (flag == 0) {
//flag為0表示指針從high的一端開始移動
if (array[high] < key) {
array[low] = array[high];
low++;
flag = 1;
} else {
high--;
}
} else {
//指針從low的一端開始移動
if (array[low] > key) {
array[high] = array[low];
high--;
flag = 0;
} else {
low++;
}
}
}
array[low] = key;
return low;
}
如果上述介紹的快速排序的算法核心思想理解的話，這段代碼的實現也就比較容易理解了。
四、選擇類排序
選擇類排序的基本思想是，每一趟會在n個元素中比較n-1次，選擇出最大或者最小的一個元素放在整個序列的端點處。選擇類排序有基於樹的也有基於線性表的，有關樹結構的各種排序算法，我們將在后續文章中進行描述，此處我們實現簡單的選擇排序算法。
public static void ChooseSort(int[] array){
for (int i=0;i<array.length;i++){
for (int j=i+1;j<array.length;j++){
if(array[i]>array[j]){
//發現比自己小的元素，則交換位置
int temp = array[j];
array[j]=array[i];
array[i] = temp;
}
}
}
//輸出排序后的數組內容
for (int key : array){
System.out.print(key+",");
}
}
代碼堪比冒泡排序的算法實現，比較簡單直接，此處不再贅述。
五、歸並類排序算法
這里的歸並類排序算法指的就是歸並排序。歸並排序的核心思想是，對於一個初始的序列不斷遞歸，直到子序列中的元素足夠少時，對他們進行直接排序。然后遞歸返回繼續對兩個分別有序的序列進行直接排序，最終遞歸結束的時候，整個序列必然是有序的。
對於一個初始序列，我們遞歸拆分的結果如上圖。最小的子序列只有兩個元素，我們可以輕易的對他們進行直接的排序。簡單的排序結果如下：
然后我們遞歸返回：
初看起來和我們的希爾排序的基本思想有點像，希爾排序通過對初始序列的稀疏化，使得每個子序列在內部上都是有序的，最終在對整個序列進行排序的時候，序列的內部基本有序，總體上能提高效率。但是我們的歸並排序的和核心思想是，通過不斷的遞歸，直到子序列元素足夠少，在內部對他們進行直接的排序操作，當遞歸返回的時候，對返回的兩個子表再次進行歸並排序，使得合成的新序列是有序的，一直到遞歸返回調用結束時候，整個序列就是有序的。
/*歸並排序的遞歸調用*/
public static void MergeSort(int[] array,int low,int high){
if(low == high){
//說明子數組長度為1，無需分解，直接返回即可
}else{
int p = (low+high)/2;
MergeSort(array,low,p);
MergeSort(array,p+1,high);
//完成相鄰兩個子集合的歸並
MergeTwoData(array,low,high);
}
}
/*用於排序兩個子序列的歸並排序算法實現*/
public static void MergeTwoData(int[] array,int low,int high){
int[] arrCopy = new int[high-low+1];
int i,j;
i = low;j= (low+high)/2+1;
for (int key=0;key<=high-low;key++){
//如果左邊子數組長度小於右邊數組長度，當左數組全部入庫之后，右側數組不用做比較直接入庫
if(i==(low+high)/2+1){
arrCopy[key] = array[j];
j++;
}
//如果右側數組長度小於左側數組長度，當右側數組全部入庫之后，左側數組不用做比較直接入庫
else if(j==high+1){
arrCopy[key]=array[i];
i++;
}else if(array[i]<array[j]){
arrCopy[key]=array[i];
i++;
}else{
arrCopy[key] = array[j];
j++;
}
}
j = 0;
//按順序寫回原數組
for(int x=low;x<=high;x++) {
array[x] = arrCopy[j];
j++;
}
}
我們的遞歸調用方法還是比較簡單的，首先從一個序列的中間位置開始遞歸分成兩個子序列並傳入該序列的頭尾索引，當頭尾索引相等的時候，說明序列中只有一個元素，於是無需調用歸並排序，直接返回。等待兩邊的子序列都返回的時候，我們調用歸並排序對這兩個子序列進行排序，繼續向上返回直到遞歸結束，最終的序列必然是有序的。我們主要看看用於歸並兩個子序列的排序算法的實現。
假設我們遞歸返回了這樣的兩個子序列，因為這些子序列都是遞歸返回的，所以他們在內部都是有序的，於是我們需要對兩個子序列排序和並成新序列並向上遞歸返回。
排序的算法如下：
分別取出兩個序列的棧頂元素，進行比較，把小的一方的元素出棧並存入新序列中，值較大的元素依然位於棧頂。這樣，當有一方的元素全部出棧之后，另一方的元素順序填入新序列中即可。具體的算法實現已經在上述代碼中給出了。
至此，線性的基本排序算法都已經介紹完成了，有些算法介紹的比較粗糙，待后續深入理解后再回來補充，總結不到之處，望指出！