几种常见的排序方法

/*1.插入排序*/
/*算法思路：
  假设待排序的n个元素存放在数组a[n]里面，并且a[0]到a[i-1]是已排好序列的元素，而 a[i]到
  a[n-1]是未排序的元素，把未排序的元素 a[i]插入到a[0]到a[i-1]里面，使得a[0]--a[i]成为有序
  经历i=1到i= n-1次插入后排序完成
  使用在数组和链表都可以，使用在元素较少的情况下
  
  时间复杂度O（n^2),空间复杂度O（1）
*/
void insert_sort(int *a,int n)
{
    int i,j,t;
    for(i=1;i<n;i++)
    {
        t=a[i];
        for(j=i-1;j>=0&&t<a[j];j--)
        {
            a[j+1]=t;
        }
    }
}
/*2.选择排序法
算法思路：假定待排序的n个元素在数组a[n]里面，从序列的后n-i+1（i=0,1,2..n-2)个元素a[i],a[i+1]..a[n]
中 至少 选择一个最小元素a[k]与前面的元素 a[i]交换位置，这个过程从i=0,直到 i=n-2为止的n-1次选择交换后
，a[0],a[1]... a[n-1]就完成了

时间复杂度O（n^2),空间复杂度O（1）

稳定性排序不稳定，在直接选择排序中，存在不相邻的元素之间的互换，可能会改变具有相同的排序码的元素前后位置
简单的排序方法，适用于元素个数较少的情况*/
void select_sort(int *a,int n)
{
    int i,j,k,t;
    for(i=0;i<n-1;i++)
    {
        k=i;
        for(j=i+1;j<n;j++)
        {
            if(a[j]<a[k])
                k=j;
        }
        t=a[i];
        a[i]=a[k];
        a[k]=t;
    }
}
/*3.冒泡排序
    算法思路：设待排序的n个元素放在数组a[n]中，无序区间的范围是（a[0],a[1]..a[n-1])
    要求在当前无序区内，从最上面的元素a[0]开始，对每个相邻的元素a[i+1]和a[i](0,1..n-1)
    进行比较，使值较小的元素换至较大的元素之上，经过一趟冒泡，假设最后下移的元素是a[k],则无序
    区中值较大的几个元素到达下端并从小到达依次在a[k+1],a[k+2],a[n-1]里面，无序区间范围变成
    a[0],a[1]...a[k]然后在当前的无序区间进行下一趟排序
    
    复杂度:空间O(n^2),时间O（1）
    
    稳定性：稳定，值相同的元素不会互换位置
        
*/
void bubble_sort(int *a,int n)
{
    int i,j,k;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n-i-1;j++)
        {
            if(a[j]>a[j+1])
            {
                k=a[j];
                a[j]=a[j+1];
                a[j+1]=k;
            }

        }
    }
}
void bubble_sort2(int *a,int n)
{
    int i,k,t;
    n--;
    while(n>0)
    {
        k=0;
        for(i=0;i<n;i++)
        {
            if(a[i]>a[i+1])
            {
                t=a[i];
                a[i]=a[i+1];
                a[i+1]=t;
                k=i;/*k保存最后交换的位置*/
            }
        }
        n=k;/*n保存无序区的最大下标*/
    }
}
/*4.希尔排序*/
/*算法思路：设待排序的n个元素放在数组a[n]中，首先选择一组增量， d0,d1..dt-1,n>d0>d1>..>dt-1=1
  对于 i=0，1..t-1，依次进行下面的各趟处理根据当前的增量di将n个元素分成di个组，每组元素的下标相隔
  di,即a[k],a[k+di],a[k+2*di],..(k=0,1...di-1);再对各组元素进行插入排序。
    
  复杂度：O（nlog2n)和O（n^2)之间 空间复杂度O（1）
  稳定性：不稳定，值相同的元素在某趟排序可能分在不同的组，组内元素排序元素会移动，位置会互换
  希尔排序比插入排序复杂
*/
void shell_sort(int *a,int *d,int t,int n)//d存放增量，t为增量的个数
{
    int i,j,k,y;
    for(i=0;i<t;i++)
    {
        for(j=d[i];j<n;j++)
        {
            y=a[i];
            for(k=j-d[i];k>=0&&y<a[k];k-=d[i])
                a[k+d[i]]=a[k];
            a[k+d[i]]=y;
        }
    }
}
/*快速排序
  算法思路：在待排序的序列里面，任意选择一个元素，通过某种方法，把该元素放在合适的位置上，使得序列中值小于
  该元素的所有元素都在该元素的左边，值大于该元素的所有元素都在该元素的右边，这样所选择的元素正好处在它应该
  在的排序的最终位置上
    
  复杂度：平均O（nlog2n).最坏O（n^2)
  不稳定
*/
void quick_sort(int *a,int s,int e)//s,e表示排序的开始位置和结束位置
{
    int i,j,t;
    if(s<e)
    {
        i=s;
        j=e;
        t=a[s];
        while(i!=j)
        {
            while(i<j&&a[j]>t)
                i++;
            if(i<j)
                a[j--]=a[i];
        }
        a[i]=t;
        quick_sort(a,s,i-1);
        quick_sort(a,i+1,e);
    }
}