用C语言总结一下常用排序算法，虽然大多数语言里已经提供了排序算法，比如C函数库中提供了qsort排序函数（内部为快速排序实现），但理解排序算法的思想的意义远远超过了实用的价值。这里我总结了常用的排序算法，并用C语言实现。这些算法的书写顺序也有一定的关联，比如希尔排序是对插入算法的改进，快速排序是对冒泡排序的改进，快速排序和归并排序都用递归实现。
注：每种方法的实现尽量提供了相同的形参列表。这里并没用涉及堆排序，箱排序等算法的实现。
 
插入排序
算法概要：插入排序依据遍历到第N个元素的时候前面的N-1个元素已经是排序好的，那么就查找前面的N-1个元素把这第N个元素放在合适的位置，如此下去直到遍历完序列的元素为止。
Code:
void insertSort(int array[], int length)  
{  
    int key;  
    for(int i=1; i<length; i++)  
    {  
        key = array[i];   
        for(int j=i-1; j>=0 && array[j] > key; j--)  
        {  
                array[j+1] = array[j];  
        }  
        array[j+1] = key;  
    }  
}  
希尔排序
 
算法概要：shell排序是对插入排序的一个改装，它每次排序排序根据一个增量获取一个序列，对这这个子序列进行插入排序，然后不断的缩小增量扩大子序列的元素数量，直到增量为1的时候子序列就和原先的待排列序列一样了，此时只需要做少量的比较和移动就可以完成对序列的排序了。
Code:
void shellSort(int array[], int length)  
{  
    int key;  
    int increment;  
    for(increment = length/2; increment>0; increment /= 2)  
    {  
        for(int i=increment; i<length; i++)  
        {  
            key = array[i];  
            for(int j = i-increment; j>=0 && array[j] > key; j -= increment)  
            {  
                array[j+increment] = array[j];  
            }  
            array[j+increment]=key;  
        }  
    }  
  
}  
 
冒泡排序
算法概要：冒泡排序是经过n-1趟子排序完成的，第i趟子排序从第1个数至第n-i个数，若第i个数比后一个数大（则升序，小则降序）则交换两数。
Code:
void bubbleSort(int  array[], int length)  
{  
    int flag = 0;  
    for(int i=0; i<length-1; i++)  
    {  
        for(int j=0; j<length-1-i; j++)  
        {  
            if(array[j]>array[j+1])  
            {  
                flag = 1;  
                array[j] = array[j] + array[j+1];  
                array[j+1] = array[j] - array[j+1];  
                array[j] = array[j] - array[j+1];  
            }  
        }  
        if(flag == 0) break;  
    }  
}  
 
快速排序
快速排序（Quicksort）是对冒泡排序的一种改进。通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
Code:
int Sort(int array[], int first, int last)  
{  
    int pivot = array[first];  
    int temp;  
    if(last-first <=0) return -1;  
  
    while(first != last)  
    {  
        while(array[last] >= pivot && last != first) last--;  
        temp = array[first];  
        array[first] = array[last];  
        array[last] = temp;  
        while(array[first] <= pivot && last != first) first++;  
        temp = array[first];  
        array[first] = array[last];  
        array[last] = temp;  
    }  
    return last;  
}  
  
void quickSort(int array[], int length)  
{  
    int temp = Sort(array, 0, length-1);  
    if(temp == -1 ) return;  
    quickSort(array,temp+1);  
    quickSort(&array[temp+1],length-temp-1);  
}  
 
归并排序
算法概要：归并排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
Code:
void Merge(int A[],int low,int mid,int high)      
 {      
     int i,j,k;    
     int *P = new int[mid-low+1],*Q = new int[high-mid];      
     
     for (i =0;i  < mid - low +1;++i)   P[i] = A[i+low];
          
     for (i = 0; i  < high - mid;++i)   Q[i] = A[mid+1+i];      
      
     i = j = 0,k = low;      
     while ((i  <= mid-low) && (j  <= high-mid-1))      
     {      
      
         if (P[i]  <= Q[j])   A[k++] = P[i++];      
         else  A[k++]= Q[j++];      
     }      
      
     if (i > mid - low)   { for (;j  <= high-mid-1;++j)   A[k++] = Q[j]; }      
     else     
     {   for (; i <= mid - low;++i)   A[k++] = P[i];  }      
      
     delete [] P;      
     delete [] Q;      
 }      
      
 void mergeSort(int A[],int left,int right)      
 {      
     if (left  < right)      
     {      
         int i = (left + right) / 2;      
         MergeSort(A,left,i);      
         MergeSort(A,i+1,right);      
         Merge(A,left,i,right);      
     }      
 }