几种常用排序小结

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

一：选择排序

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

特性：不稳定， 内部

复杂度：最好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），构造堆需要线性时间

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

代码：

<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
);
fizdown(pq, 1, --N);
}
}</span>