用C语言实现常用排序算法

用C语言总结一下常用排序算法，虽然大多数语言里已经提供了排序算法，比如C函数库中提供了qsort排序函数（内部为快速排序实现），但理解排序算法的思想的意义远远超过了实用的价值。这里我总结了常用的排序算法，并用C语言实现。这些算法的书写顺序也有一定的关联，比如希尔排序是对插入算法的改进，快速排序是对冒泡排序的改进，快速排序和归并排序都用递归实现。

注：每种方法的实现尽量提供了相同的形参列表。这里并没用涉及堆排序，箱排序等算法的实现。

 

插入排序

算法概要：插入排序依据遍历到第N个元素的时候前面的N-1个元素已经是排序好的，那么就查找前面的N-1个元素把这第N个元素放在合适的位置，如此下去直到遍历完序列的元素为止。

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的时候子序列就和原先的待排列序列一样了，此时只需要做少量的比较和移动就可以完成对序列的排序了。

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个数比后一个数大（则升序，小则降序）则交换两数。

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）是对冒泡排序的一种改进。通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

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);
}

 

归并排序

算法概要：归并排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

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);
     }
 }