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

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

     }      

 }