几种常用排序小结

国庆期间，都出去玩了，自己在实验室无聊，把几种常用排序总结一下。

一：选择排序

原理：首先，选择数组中最小的元素，将它与数组中第一个元素交换，然后找次小的，与数组第二个元素交换。按照此方法直到数组有序。

特性：不稳定， 内部

复杂度：最好O（n^2）；最差O（n^2） 

特点：对已有序的文件依赖较小；对于元素比较大，关键字比较比较小的文件，应该选择该法，移动次数少（N-1），最后一个不用移动。

代码：

<span style="font-size:18px">void slectionsort(int a[], int l, int r)
{
    int i,j;
    for(i = l; i<=r-1; i++)
    {
        int min = i;
        for(j = i+1; j<=r; j++)
            if(a[j] < a[min])
                min = j;
        exch(a[i],a[min]);       
    }
}</span>

二：插入排序

原理：每次考虑一个元素，插入排好序的数中，为了插入，先将较大的元素一个一个向右移动。

特性：稳定，内部

复杂度：最优O（n）,数组排好序；最差：O（n^2）,数组逆序

特点：少量元素，它和文件原始顺序有着密切关系，如果文件较大，并且已经排好序或几乎排好，插入比选择快。

代码：

<span style="font-size:18px">void insertionsort(int a[], int l, int r)
{
    int i;
    for(i=r; i>l; i--)
        if(a[i] < a[i-1])
            exch(a[i-1],a[i]); //找到最小元素放到第一位，做为哨兵
    for(i = l+2; i <=r; i++)
    {
        int j=i;
        int key = a[i];
        while(key < a[j-1])    // 右移，此处有个哨兵，因为a[0]是最小元素，所以不用判断j>0这个条件，更有效率
        {
            a[j] = a[j-1];
            j--;
        }
        a[j] = key;            //插入
    }
        
}</span>

三：冒泡排序

原理：遍历文件，如果近邻的元素顺序不对就交换，直到有序

特性：稳定，内部

复杂度：最坏O（n^2）,最优O（n^2）

特点：简单，效率较低

代码：

<span style="font-size:18px">void bubble(int a[], int l, int r)
{
    int i,j;
    for(i = l; i<r; i++)
        for(j=r; j>i; j--)
        {
            if(a[j] < a[j-1])
                exch(a[j],a[j-1]);
        }
}</span>

四：希尔排序

原理：插入排序运行效率低是因为它所执行的交换操作涉及近邻元素，每次只能移动一位。希尔是插入排序的扩展，它允许非相邻的元素进行交换来提高效率。

特性：不稳定，内部

复杂度：O（n^l）(1<l<2与歩长有关)

特点：

代码：

<span style="font-size:18px">void shellsort(int a[], int l, int r)
{
    int i,j,h;
    for(h =1; h<= (r-l)/9; h = 3*h+1) ;            //选择歩长，歩长比例为1/3；
    for(; h>0; h /= 3)
        for(i=l+h; i<=r; i++)
            {
                j=i;
                int key = a[i];
                while(j > l+h && key < a[j-h])     //把1换成h,没用哨兵所以要判断j>l+h
                {
                    a[j] = a[j-h];
                    j -= h;
                }
                a[j] = key;
            }
}</span>

五：快速排序

原理：分治排序算法，它将数组划分两个部分，然后分别对两个部分进行排序，对于某个i,

     a[i]在数组最终位置上，

     a[l],...a[i-1]中的元素都比a[i]小

     a[i+1]......a[r]中的元素都比a[i]大

特性：不稳定，内部

复杂度：O（n*lgn）

特点：最坏情况有N^2/2次比较，对于有序文件退化

代码：

<span style="font-size:18px">int partition(int a[], int l, int r);
void quicksort(int a[], int l, int r)
{
    int i;
    if(r <=l)
        return;
    i = partition(a, l, r);
    quicksort(a, l, i-1);
    quicksort(a, i+1, r);
}

int partition(int a[], int l, int r)
{
    int i = l-1, j=r;
    int v = a[r];
    for( ; ; )
    {
        while(a[++i] < v) ;
        while(v < a[--j])
            if(j == l)
                break;
        if(i >= j)
            break;
        exch(a[i],a[j]);
    }
    exch(a[i], a[r]);
    
    return i;
}</span>

六：归并排序

原理：将已排好序的文件，选择其中最小的输出，直到所有文件元素都输出，这样就把所有文件合并成一个有序文件。

特性：稳定，外部

复杂度：O（n*lgn）

特点：使用与N成正比的额外内存空间，如果使用的归并算法是稳定的，那么归并排序也是稳定的，与输入文件初始顺序无关。

代码：自顶向下的归并排序

<span style="font-size:18px">int b[maxN];
merge(int a[], int l, int m, int r)
{
    int i,j,k;
    for(i=m+1; i>l; i--)
        b[i-1] = a[i-1];
    for(j=m; j<r; j++)
        b[r+m-j] = a[j+1];
    for(k=l; k<=r; k++)
    {
        if(b[j] < b[i])
            a[k] = b[j--];
        else
            a[k] = b[i++];
    }
}
void mergesort(int a[], int l, int r)
{
    int m = (r+l) / 2;
    if(r <= l)
        return;
    mergesort(a, l, m);
    mergesort(a, m+1, r);
    merge(a, l, m, r);
}</span>

七：堆排序

原理：如果一棵树中每个节点的关键字都大于或等于所有子节点的关键字，就称树是堆有序的。堆是一个节点的集合，表示为数组，其中关键字是按照堆有序的完全二叉树的形式排列的。数组中位于i的元素的父节点位置为i/2。

特性：不稳定，内部

复杂度：O（n*lgn），构造堆需要线性时间

特点：与输入实例无关，不存在使得堆排序特别慢的输入实例，快排对输入有序时，特别慢。

代码：

<span style="font-size:18px">fixdown(int a[], int k, int N)
{
    int j;
    while(2*k <= N)
    {
        j = 2*k;                                       //k为考察的父亲节点，j为其左子节点
        if( j< N && a[j] < a[j+1]) j++;                //选择较大的字节点
        if(a[k] >= a[j])
            break;
        exch(a[k],a[j]);
        k = j;
    }
}

void heapsort(int a[], int l, int r)
{
    int k, N = r-l +1;
    int *pq = a+l-1;
    for( k = N/2; k >=1; k--)
        fixdown(pq, k, N);
    while( N > 1)
    {
        exch(pq[1], pq[N]);
        fizdown(pq, 1, --N);
    }
}</span>