插入排序算法：該算法的復雜度為O(N^2),需要比對N-1趟，最壞情況下，每一趟比對的元素個數(shù)會隨著i的增加而增加。比如進行到了第k+1趟，實際上就是假設了前k個元素是有序的，這時候只需要將a[k+1]與a[k]比較，如果a[k+1]大于a[k]則說明a[k+1]是目前最大的數(shù)，如果a[k+1] < a[k].這時說明a[k]的位置不對，需要往后移動，也就是a[k+1]中保存a[k]的值，可以將a[k+1]的值與a[k]交換。然后比較a[k]與a[k-1]，直到找到該元素的合適位置。

void insertSort(int *a, int size)
{
int i = 0, j = 0, tmp = 0;
for(i = 1; i < size; ++ i)
{
tmp = a[i];
for(j = i; j > 0 && tmp < a[j-1]; --j)
a[j] = a[j - 1];
a[j] = tmp;
}
}

增量排序(shell 排序)：該算法的復雜度要略小于插入排序算法，但是也基本上認為是亞O(N^2)。實現(xiàn)的基本過程如下，選擇一個較大的增量gap，一般選擇為數(shù)組長度的一般作為起始的增量。然后從當前增量作為起始下標開始訪問，比較a[i]和a[i-gap],如果a[i] a[0]，這是已經處理過的。如果a[i] > a[i-gap]則不處理。減小gap,一般去gap = gap/2。重新進行上面的操作，直到gap = 1，因為這時候已經滿足a[i]

voidshellSort(int *a, int size)
{
int i = 0, j = 0, gap = 0.
int tmp = 0;

/*選擇合適的增量*/
for(gap = size / 2; gap > 0; gap /= 2 )
{
/*以增量為下標進行比較*/
for( i = gap ; i < size ; ++ i)
{
/*找到比較數(shù)的位置*/
tmp = a[i];
for(j = i; j >= gap && tmp < a[j - gap]; j -= gap)
a[j] = a[j - gap];/*更新a[j-gap]的位置*/
a[j] = tmp; /*找到比較數(shù)的位置*/
}
}
}

堆排序：堆排序的實現(xiàn)主要是采用了最小堆或者最大堆的特性，堆中的根元素肯定是最小元素或者最大元素，刪除其中的根元素實質上就找到了最大/最小值。這樣通過N次刪除就找到了一個有序序列。我們知道在二叉堆中刪除和插入操作采用了上慮和下慮的方式，每次刪除和插入操作的時間復雜度為O(logN)。但是堆排序存在一個堆的創(chuàng)建問題，這個創(chuàng)建是非常的浪費時間的，時間復雜度為O(N)，這樣一個堆排序的操作事件大約為O(NlogN)。相比前面的兩種方式要快速。實現(xiàn)的過程如下，分配一個新的內存空間，遍歷元素N，創(chuàng)建一個二叉堆數(shù)組，然后執(zhí)行N次刪除操作，刪除的元素添加到原來的內存空間中，實現(xiàn)了數(shù)組的排序操作，這種方式時間復雜度上有所減小，但是空間復雜度上卻有了很大的增加，存儲容量增加了近一倍。

聰明的解決方式根據(jù)堆的性質，刪除一個元素就會釋放最后的一個存儲單元，這時候將刪除的元素保存到釋放存儲單元中，然后刪除一個元素就保存到釋放的內存中去，就能避免存儲量增加的問題。但是這時候出現(xiàn)的序列就是一個反序，但總歸是有序序列。當然也可以通過創(chuàng)建(Max)堆來得到min序列，創(chuàng)建(Min)堆來得到max序列。因此堆排序的基本模型就是創(chuàng)建一個堆，刪除堆元素的操作過程。

堆排序是非常穩(wěn)定的算法，他平均使用的比較只比最壞情形下指出的略少，堆排序總是使用至少NlogN-O(N)次排序，而且存在能夠到達這個界的輸入數(shù)據(jù)。

void max_heapify(int *a,int index, int size)
{
int child = LEFTSON(index);

int tmp = a[index];

for(; LEFTSON(index) < size ; index = child)
{
child = LEFTSON(index);
if(child != size - 1 && a[child] < a[child + 1])
child ++;

/***************************
* 提升兒子到父結點，
* 兒子結點的位置上存在空穴，
* 需要繼續(xù)比較
**************************/
if(a[child] > tmp)
a[index] = a[child];
else/*不需要提升*/
break;
}
/*保存結點的位置找到*/
a[index] = tmp;
}

void Build_Maxheap(int *a, int size)
{
int step = 0;

/***************************************
* (size-1)/2實質是找到a[size-1]的父結點，
* 也就是倒數(shù)第二層，堆的創(chuàng)建過程是一個
* 由低層到高層逐漸創(chuàng)建的過程
**************************************/
for(step = (size - 1) / 2 ; step >= 0; -- step)
max_heapify(a, step, size);
}

void heapSort(int *a, int size)
{
int i = 0;
/*創(chuàng)建堆*/
Build_Maxheap(a,size);

for(i = size - 1; i > 0; --i)
{
/*swap(a[i],a[0])*/
a[i] = a[i] + a[0];
a[0] = a[i] - a[0];
a[i] = a[i] - a[0];
/*更新堆的結構*/
max_heapify(a,0,i);
}
}

歸并排序：該算法的時間復雜度為O(NlogN)，使用的比較次數(shù)幾乎是最優(yōu)的，是遞歸算法的經典例子。

這個算法的基本操作是合并兩個已經排序的表，因為這兩個表是已經排序的，所以若將輸出放到第三個表中則該算法可以通過對輸入數(shù)據(jù)一趟排序來完成。基本的合并算法是取兩個輸入數(shù)組A和B，一個輸出數(shù)組C以及3個計數(shù)器(Actr、Bctr、Cctr)，他們開始于對應數(shù)組的開始端，A[Actr]和B[Bctr]的較小者復制到C[ctr]中的一下一個位置，相關的計數(shù)器向前推進一步，當兩個輸入表有一個用完，則將另一個表中剩余的部分拷貝到C中。

由于該算法的前提是兩個已經排序的表，但實際上的輸入肯定不能滿足條件，因此需要采用分治策略，所謂“分”就是將輸入表分成兩個表進行處理，對兩個表分別采用分治進行排序。所謂“治”就是按照上述的算法合并兩個排序表得到一個完整的排序表。由上面的分析可以知道，每一次分治都存在分開和合并操作，是經典的遞歸問題。需要注意的是在歸并算法中臨時數(shù)組的處理問題，采用動態(tài)存儲的方式可能要簡單好一些，但是需要注意內存的釋放，避免內存泄露。

void mergeSort(int * a, int left, int right)
{
int i = 0;
int *atmp = NULL;
int *Actr = NULL, *Bctr = NULL, *Cctr = NULL;

/*遞歸退出條件*/
if(left >= right)
return;

atmp = (int *)calloc((right - left + 1) / 2,sizeof(int));
if(NULL == atmp)
return;

for(i = 0; i < (right - left + 1) / 2 ; ++ i)
atmp[i] = a[left + i];

mergeSort(atmp,0,i - 1);
mergeSort(a, left + i, right);

Actr = atmp;
Bctr = a + left + i;
Cctr = a + left;

while(Actr != atmp + i && Bctr != a + right + 1)
{
if(*Actr <= *Bctr)
*Cctr++ = *Actr++;
else
*Cctr++ = *Bctr++;
}
while(Actr != atmp + i)
*Cctr ++ = *Actr++;
while(Bctr != a + right + 1)
*Cctr ++ = *Bctr ++;

free(atmp);
atmp = NULL;
}

歸并算法的時間復雜度的推導過程：

其中時間復雜度公式滿足如下的等式T(N)=2T(N/2)+N，其中的N為合并操作的時間，推導過程如下:

歸并排序存在的問題是，它很難應用于主存排序，主要問題在于合并兩個排列的表需要線性附加內存，在整個算法中還需要花費將數(shù)據(jù)復制到臨時數(shù)組在復制回來這樣的一些附加操作，其結果是嚴重減慢了排序的速度。

快速排序：是實踐中最快的已知排序算法，它的平均運行時間是O(NlogN)，算法之所以快是因為非常精煉和高度優(yōu)化的內部循環(huán)，但是最壞的性能是O(N^2),將堆排序與快速排序結合，可以在堆排序的O(NlogN)最壞運行時間下，得到幾乎所有輸入的最快運行時間。

快速排序也是一種分治的遞歸算法，通常包括4個步驟：

1、如果數(shù)組S中元素個數(shù)為0或者1個，則直接返回

2、取數(shù)組S中的一個數(shù)v作為樞紐元。

3、將數(shù)組S-v劃分成兩個不相交的集合，其中S1:x <= v, S2: x > v.這一步需要注意不要寫成是S1:x<=v,S2:x>=v，能減少很多的麻煩。

4、返回{quickSort(S1) , v, quickSort(S2)}。

上面的四步就完成了數(shù)組的快速排序，可見快速排序也是一個遞歸的過程，需要將多個子集進行。

快速排序的實現(xiàn)主要是第三步的實現(xiàn)，如何實現(xiàn)將數(shù)據(jù)分成兩個集合的操作。實現(xiàn)的方式如下：

假設選擇的樞紐元pivot是數(shù)組的開始值a[0]，那么將兩個下標i,j分別表示數(shù)組的第1個數(shù)a[1](i = 1)和最后一個數(shù)a[N](j = N)，如果i < j，也就是數(shù)組長度大于2個時，將指向第一個數(shù)a[1]和樞紐元pivot進行比較，如果小于等于樞紐元則說明當前值是S1集合的，因此不需要移動，增加i指向下一個數(shù)a[2]，直到找到大于樞紐元的數(shù)a[i]，則i暫停增加，這時操作另一個下標j，比較j表征的數(shù)a[j]是否大于樞紐元pivot，如果大于則說明當前的數(shù)屬于S2，不需要移動，減小j，直到找到小于等于樞紐元的數(shù)a[j]，如果i < j，則說明這兩個數(shù)是需要改變位置的，因此調整兩個數(shù)的位置swap(a[p],a[q])，然后接著上面的方法移動兩個下標，并完成相應的交換操作，當兩個下標表征相同的位置(j == i，這種情況是pivot = a[i])或者j < i(這種情況是不存在相同元素pivot != a[i])以后，說明集合分類操作已經完成，后一個j指向的位置就是當前樞紐元的位置，這時候小于j的下標的數(shù)據(jù)就是S1,而大于j的下標的數(shù)據(jù)就是S2。因此還需要將樞紐元a[0]與a[j]交換，得到樞紐元的位置。對于這種數(shù)組元素較大的情況，此時的j一般認為都是滿足a[j] <= pivot。（等于的情況也是可能存在的）。