最全各类排序算法原理及其C语言实现

声明：为简便描述算法，以下排序对象arr[ ]为整型数组，len为其长度，且按不降序排序。

一、插入排序

1.直接插入排序

1）原理：将数组分为有序和无序两部分，有序部分一开始只有数组的第一个元素。对于无序部分的每个元素，要插入到有序数列中，方法是与有序部分的末尾元素作比较，若前者大于后者则前者位置不变；否则，往前检索，同时将这个元素往后移动(检索一次，移动一次)，直到找到这个待插入元素小于第n个元素且大于或等于第n-1个元素的位置，然后将其插入到这个位置。以此类推，直到无序数列元素个数为0。

2）C代码实现

void insert_sort(int arr[],int len){    int i,j,k;    for(i=0;i<=len;i++){        j=i-1;        k=arr[i];        while(j>-1&&k<arr[j]){            arr[j+1]=arr[j];            j--;        }        arr[j+1]=k;    }}

直接插入排序是稳定的，时间复杂度为O(n^2)。

2.二分插入排序

1）原理：思想简单，利用二分查找的方法，对已排序的序列折半地找到要插入的位置。

2）C代码实现

void bin_sort(int arr[],int len){    if(len==2){        arr[0]+=arr[1];arr[1]=arr[0]-arr[1];arr[0]-=arr[1];return;    }    int i,j;    for(i=1;i<len;i++){        int t=arr[i],left=0,right=i-1;        while(left<=right){            int mid=(left+right)/2;            if(t<arr[mid])  right=mid-1;            else    left=mid+1;        }        for(j=i-1;j>=left;j--)  arr[j+1]=arr[j];        if(left!=i) arr[left]=t;    }}

二分插入排序是稳定的，时间复杂度为O(n^2)。

3.表插入排序

1）原理：表插入排序的目的是在直接插入排序的基础上减少移动元素的次数，所以其排序对象为单链表。跟直接插入排序一样，在已排序序列中，找到待插入元素要插入的位置，进行单链表的插入操作。

2）C代码实现

plist list_sort(plist head)//head指向空头结点{    plist pre,now,p,q;//pre为now的前一个指针    pre=head->next;    if(pre==NULL)   return head;    now=pre->next;    if(now==NULL)   return head;//空链表或只有一个节点    while(now){        q=head;p=head->next;        while(p!=now&&p->info<=now->info){            q=p;p=p->next;//查找位置        }        if(p==now){//now位置不变            pre=pre->next;            now=pre->next;            continue;        }        pre->next=now->next;//使now脱链        q->next=now;        now->next=p;        now=pre->next;    }    return head;}

表插入排序是稳定的，时间复杂度为O(n^2)。

4.shell排序

1）原理：希尔排序是对直接插入排序的改进。先取一个整数d1<n，把arr分为d1组，所有距离为d1倍数的元素看成一组，先在各组内进行直接插入排序（或其它排序法），然后取d2<d1重复同样的分组和排序，直到di=1，即对arr全部元素进行排序。shell排序一趟排序就可以消去多个逆序对，效率上优于直接插入排序。 d 的选取方法不一，至今也不能确定哪一最好，这里姑且取d为每次增量为前一次的一半。

2）C代码实现

void shell_sort(int arr[],int len){    int i,j,k,t;    for(k=len/2;k>0;k/=2){//k为当前增量        for(i=k;i<len;i++){            t=arr[i];            for(j=i-k;j>=0&&t<arr[j];j-=k)//各组中大的元素往后移                arr[j+k]=arr[j];            arr[j+k]=t;        }    }}

shell排序是不稳定的，时间复杂度比较复杂，这里不给出。

二、选择排序

1.直接选择排序

1）原理：先在数组中找出最小值，通过交换将其放在数组第一位，然后再从剩余的未排序数组中找到最小值，将其放在已排序数组的末尾。以此类推，直到整个数组排好序。

2）C代码实现

void select_sort(int arr[],int len){    int i,j,t,k;    for(i=0;i<len-1;i++){        k=i;        for(j=i+1;j<len;j++){            if(arr[k]<arr[j])//找最小值                k=j;        }        if(i!=k)            t=arr[i];arr[i]=arr[k];arr[k]=t;    }}

直接选择排序是不稳定的，时间复杂度为O(n^2)。

2.堆排序

1）原理：先把数组元素构造成大根堆，然后从堆中不断选出最大元素，从而达到排序的目的。排序结果需要申请空间来保存，但为节省空间，可以利用原始数组。如何利用原始数组？只需将堆顶元素（数组首元素）与最后一个元素交换，同时另堆得大小减一。这种交换可能破坏堆序性，所以每次交换，都要调用sift函数，从后向前逐步把待排序元素调整为最大堆，直到堆中只剩下一个元素，此时数组元素已排好序。同时这个sift函数也是创建堆时所使用的。

2）C代码实现

void sift(int arr[],int heapSize,int i){    int tmp=arr[i],child=2*i+1;    while(child<heapSize){        if(child<heapSize-1&&arr[child]<arr[child+1])//选择比较大的子节点            child++;        if(arr[child]>tmp){            arr[i]=arr[child];//将大节点上移            i=child;            child=i*2+1;        }        else    break;//调整结束    }    arr[i]=tmp;}void heap_sort(int arr[],int len){    int i;    for(i=len/2-1;i>=0;i--) sift(arr,len,i);//初始创建堆    for(i=len-1;i>0;i--){//len-1趟堆排序        arr[i]+=arr[0];        arr[0]=arr[i]-arr[0];        arr[i]-=arr[0];        sift(arr,i,0);//调整堆，注意i起控制调整范围的作用    }}

堆排序是不稳定的，时间复杂度为O(nlogn)。

三、交换排序

1.冒泡排序

1）原理：首先比较arr[0]和arr[1]，若前者大，则交换位置，否则不交换；然后比较新的arr[1]和arr[2]作同样处理，以此类推，直到处理完第n-1和第n个元素为止，这称为一趟冒泡。经过这次冒泡，arr中的最大元素被交换到第n个位置上。此后，再对前n-1个元素进行同样处理，使得它们中的最大者又被交换到第n-1个位置上。以此类推，最多经过n-1趟冒泡就能完成排序。可以设置一个标志 noswap 表示本次冒泡是否有元素交换，如果没有说明整个arr已排好序，跳出for循环。

2）C代码实现

void bubble_sort(int arr[],int len)//从数组头部开始，各元素与其后面的每个元素作比较{    int i,j,t;    for(i=0;i<len;i++){        int noswap=0;        for(j=i;j<len-1-i;j++)        if(arr[j+1]>arr[j]){            t=arr[i];arr[i]=arr[j];arr[j]=t;            noswap=1;        }        if(noswap)  break;    }}

冒泡排序是稳定的，时间复杂度为O(n^2)。

2.快速排序

1）原理：在待排序的数组中取一个元素作为准基数（取数组头、中、尾元素的中位数，以减少比较和移动次数），把所有比它小的元素移到左边，把所有比它大的元素移到右边，中间放准基数，称为一趟排序。然后，对前后两个子序列进行同样处理，直到整个数组排好序。具体算法步骤可参见http://developer.51cto.com/art/201403/430986.htm

2）C代码实现

void quick_sort(int arr[],int left,int right){    int i=left,j=right,k=arr[left],t;//k储存准基数，假设 arr[i]<=arr[(i+j)/2]<=arr[j],否则可先交换    if(i>j)        return ;    while(i!=j){        while(i<j&&arr[j]>=k)//必须是先从右边比较，否则准基数归位时将出错            j--;        while(i<j&&arr[i]<=k)            i++;        if(i<j){            t=arr[i];arr[i]=arr[j];arr[j]=t;        }    }    arr[left]=arr[i];    arr[i]=k;    quick_sort(arr,left,i-1);    quick_sort(arr,i+1,right);}

快速排序是不稳定的，时间复杂度为O( nlogn )。

四、归并排序

1.原理：归并排序采用递归实现，总体上有两个步骤（分解与归并）：
先将待排序数组R[0...n-1]分解成n个长度为1的有序序列（其实是一个元素），将相邻的两个元素有序归并，得到n/2个长度为2的有序序列；然后将这些有序序列再次归并，得到n/4个长度为4的有序序列；如此反复进行下去，最后得到一个长度为n的有序序列。
归并的具体步骤：比较arr[i]和arr[j],将较小值复制到新的数组new_arr[k],同时让i，j都加上1。如此循环下去，直到其中一个数组被复制完，再让另一个数组所剩余的元素（已排序）直接拼接到的new_arr的后面。

2.C代码实现

void merg(int arr[],int new_arr[],int left,int right,int mid){    int i=left,j=mid+1,k=left;    while(i!=mid+1&&j!=right+1)    {        if(arr[i]>arr[j])            new_arr[k++]=arr[j++];        else            new_arr[k++]=arr[i++];    }    while(i!=mid+1)        new_arr[k++]=arr[i++];    while(j!=right+1)        new_arr[k++]=arr[j++];    for(i=left;i<=right;i++)        arr[i]=new_arr[i];}void merge_sort(int arr[],int new_arr[],int left,int right){    int mid;    if(left<right)    {        mid=(left+right)/2;        merge_sort(arr,new_arr,left,mid);//左分解        merge_sort(arr,new_arr,mid+1,right);//右分解        merg(arr,new_arr,left,right,mid);//调用 merg子函数 归并    }}

归并排序是稳定的，时间复杂度为O( nlogn )。

最后还有基数排序，再写了。