几种常用排序小结

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

一：选择排序

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

特性：不稳定， 内部

复杂度：最好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>