关于排序算法的小结

虽然我之前写过一篇博客，关于qsort和sort函数，可以快速的进行排序，但是怎么写排序算法还是要懂的。今天我对排序算法进行一次小结，结合我本学期程序设计高级班所学和在oj上刷题经验来叙述。

一、冒泡法排序
这个排序算法真是烂大街了，我同学看见排序立刻就能打出这个算法。虽然效率低下，时间复杂度为n^2，不过确实容易理解。对n个数字组成的数组，进行（n-1）次排序，每次都比较相邻两个数字的大小，如果反向，则交换位置。我们可以对其进行优化，思路是：记录下每次排序过程中最后一次排序的位置，下次只用比较到这个位置就行了，当有一次循环没有进行比较时，即可结束循环。贴出代码：

//普通冒泡排序
void mp(int a[],int n)
{
    int i,j;
    for(i=1;i<n;i++)
        for(j=0;j<n-i;j++)
            if(a[j]>a[j+1])
                swap(a[j],a[j+1]);

//优化后的冒泡排序
void mpg(int a[],int n)
{
    int i,j=0,p=n-1;
    while(p>0)
    {
        for(i=0;i<p;i++)
        {
            if(a[i]>a[i+1])
            {
                swap(a[i],a[i+1]);
                j=i+1;
            }
        }
        p=j;
        j=0;
    }
} 

二、直接插入排序
没有技术含量的排序算法之一，同样n^2的时间复杂度，每次加入一个数，选择适合它的位置，进行n次选择。下面贴出代码：

void zjcr(int a[],int n)
{
    int i,j,k; 
    for(i=1;i<n;i++)
    {
        for(j=0;a[j]<=a[i]&&j<i;j++);
        if(j!=i) for(k=i;k>j;k--)
        {
            swap(a[k],a[k-1]);
        }
    }
}

三、希尔排序
这是一种缩小增量排序，一般情况下为n^2的时间复杂度，如果数组基本有序，则效率可达到线性级别。其本质为把数组分成n/2组、n/4组、n/8组、……2组、1组分别进行排序。下面贴出代码：

void shell(int a[],int n)  //希尔排序
{
    int i,j,k;
    for(i=n/2;i>0;i/=2)
    {
        for(j=0;j<n/2;j++)
        {
            k=j+i;
            while(k<n)
            {
                if(a[k]<a[k-i]) swap(a[k],a[k-i]);
                k+=i;
            }
        }
    }
}

四、归并排序
这是我在刷题时经常打的排序代码，好记又快速，有nlogn的时间复杂度。其本质为把n个数字组成的数组一层层通过递归的方式划分为n个数组，而后将相邻两个数组逐渐合并，合并时同步进行排序，使合并后的数组依然有序。下面贴上代码：

/*****归并排序**********/
int merge(int left,int mid,int right)
{
    int l=left,r=mid+1,t=left;
    while(l!=mid+1&&r!=right+1)
    {
        if(com(l,r)) b[t++]=a[l++];
        else b[t++]=a[r++];
    }
    while(l!=mid+1) b[t++]=a[l++];
    while(r!=right+1) b[t++]=a[r++];
    for(l=left;l<=right;l++) a[l]=b[l];
    return 0;
}
void mergesort(int left,int right)
{
    int mid=(left+right)/2;
    if(left<right)
    {
        mergesort(left,mid);
        mergesort(mid+1,right);
        merge(left,mid,right);
    }
}
/*********************/

五、快速排序
这个排序算法也有nlogn的时间复杂度，虽然我不常用（因为它在我刚起步时难以理解），但确实代码简单，只用一个子函数，而归并排序得写两个子函数（麻烦ing）。其本质思想为：从数组整体开始，以某个数字（数组内已存在的）为基准，小于它的在一边，大于它的在一边，而后对两边再用快速排序，直到数组只有一个数据为止。下面贴上代码：

/****快速排序*********/
void quicksort(int a[],int left,int right)
{
    int l=left,r=right,t=a[left];
    if(left>=right) return;
    while(1)
    {
        while(a[r]<t&&l<r) r--;
        a[l]=a[r];
        while(a[l]>t&&l<r) l++;
        a[r]=a[l];
        if(l==r)
        {
            a[l]=t;
            break;
        }
    }
    quicksort(a,left,l);
    quicksort(a,l+1,right);
    return;
}
/********************/ 

六、堆排序
老实说，虽然我在程序设计高级班上学了这个算法，让我写也能写出来，但总有一些生疏，或者说理解不透彻，但它的算法效率相当高，虽然时间复杂度也为nlogn，但在某种程度上甚至快于快排和归并。本质为：建立一个大顶堆（小顶堆），而后每次都将堆顶和堆尾交换位置，并默认堆尾的数据脱离堆，接着重新建堆重复上述过程，直到只有一个数据为止。贴上代码：

void heapdown(int a[],int i,int n)
{
    int child;
    for(;i<=n/2;i=child)
    {
        child=i*2;
        if(child<n&&a[child]>a[child+1]) child++;
        if(a[child]<a[i]) swap(a[child],a[i]);
    }
}
void heapsort(int a[],int n)
{
    int i;
    for(i=n;i>0;i--) heapdown(a,i,n);
    for(i=n;i>1;)
    {
        swap(a[1],a[i]);
        heapdown(a,1,--i);
    }
}

那么今天这次总结就到此为止了♪(^∇^*)。