如何将一系列的记录排成有序的？答案通常很简单：使用库函数排序。
本节介绍几个排序方法，以及部分方法的改进措施，并作出相应的实验来验证。
1.插入排序
为了将数组x[n]按升序排列，我们首先将第一个元素视为有序子数组x[0..0]，然后插入x[1],...,x[n-1]，如下面的伪代码所示：
for i=[1,n)
/* invariant: x[0..i-1] is sorted */
/* goal: sift x[i] down to its proper
place in x[0..i] */代码中isort1()为基本的插入排序代码，isort2()在1的基础上进行改进--将isort1()中的swap()函数展开内联写入内循环。isort3()将赋值语句移出内循环以达到最后只需一次赋值的效果。
2.快速排序
快速排序用到了第八章中的分治法：排序数组时，将数组分成两个小部分，然后对它们递归排序。
下面分别用下标l和u表示数组待排序不分的下界和上界，递归结束的条件是待排序部分的元素个数小于2。代码如下：
void qsort(l, u)
if l>=u then
/* at most one element, do nothing */
return
/* goal: partition array around a particular value,
which is eventually placed in its correct position p */
qsort(l, p-1)
qsort(p+1, u)
代码中qsort1()为简单的快速排序算法，
当输入数组是不同元素的随机排列时，该快速排序平均需要O(nlogn)的时间和O(logn)的栈空间。任何基于比较的排序至少需要O(nlogn)次比较，因此快速排序接近最优算法。伪代码如下：
void qsort1(l, u)
if(l>=u)
return
m=l
for i=[l+1, u]
/* invariant: x[l+1..m] < x[l] && x[m+1..i-1] >= x[l] */
if(x[i]<x[l])
swap(++m, i)
swap(l, m)
qsort1(l, m-1)
qsort1(m+1, u)
但是在非随机输入上它的性能存在问题。考虑一种极端的情况：n个相同元素组成的数组。对于这种输入，插入排序的性能很好：每个元素需要移动的距离都为0，总的运行时间为O(n)；但qsort1()函数性能却很低。
n-1次划分中每次划分都需要O(n)时间来去掉一个元素，所以总的运行时间为O(n^2)。因为每次划分结束后m值都在未排序序列的最左端，导致在接下来的两小部分递归中左半部分长度为0，所以m是遍历地像序列右方推进，导致不能达到对数logn的划分效果，所以最后n个元素的n-1次划分花费了O(n^2)的时间复杂度。qsort2()对这种情况进行了改进，采用双向划分的策略，循环不变式为：
当所有元素都相同时，做法为当遇到相同的元素时停止扫描，并交换i和j的值。这样做虽然使交换的次数增加了，但却将所有元素都相同的最坏情况变成了差不多需要nlogn次比较的最好情况。因为在这种情况下，划分的m会在数组的中间部分出现，故可以达到logn的效果。伪代码如下：
void qsort3(l, u)
if l>=u
return
t=x[l]; i=l; j=u+1
loop
do i++ while i<=u && x[i]<t
do j-- while x[j]>t
if i>j
break;
swap(i, j)
swap(l, j)
qsort3(l, j-1)
qsort3(j+1, u)
以下为一些算法上的说明：
1.对于随机数产生，rand()是让每次产生的数都不一样，但是重复执行程序若输入参数与上次相同则产生的数一样，所以为伪随机数。若加上函数srand()为rand()设置种子则rand()每次产生的数不同且重复执行(参数相同情况下)产生的数也不一样。
2.希尔排序就是更广义的插入排序，只不过比较的步长不是1而是一个gap值。
3.selectsort()为选择排序即冒泡排序。
4.注意快速排序的边界条件。
5.注意，堆使用的是下标从1开始的数组，C语言中最简单的方法就是声明x[n+1]并浪费元素x[0]。在程序中设定新的指针int *x=realx，以使x可以移动来适应堆排序。因为要设立升序序列所以建立大顶堆。在编写siftdown()函数时注意设立边界参数以适应对函数的调用。
6.在timedriver()中灵活地编写计时程序和错误检测程序。
下面为代码部分：
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAXN 10000000
//#include <algorithm>
//using namespace std;
int realx[MAXN];
int n;
int *x=realx; // allow x to shift for heaps
// generate random number between l and u
int randint(int l, int u)
{
//return (RAND_MAX()%(u-l)+l);
return l+(RAND_MAX*rand()+rand())%(u-l+1);
}
/*
int swap(int i, int j)
{
int temp;
temp=i; i=j; j=temp;
return 0;
}
*/
int swap(int i, int j)
{
int t;
t=x[i];
x[i]=x[j];
x[j]=t;
return 0;
}
// INSERTION SORT
// simplest insertion sort
int isort1()
{
int i, j;
for(i=1;i<n;i++)
{
for(j=i;j>0&&x[j-1]>x[j];j--)
//swap(x[j], x[j-1]);
swap(j,j-1);
}
return 0;
}
// write swap function inline
int isort2()
{
int i, j, temp;
for(i=1;i<n;i++)
{
for(j=i;j>0&&x[j-1]>x[j];j--)
{
temp=x[j];
x[j]=x[j-1];
x[j-1]=temp;
}
}
return 0;
}
// do swap at last
int isort3()
{
int i, j, t;
for(i=1;i<n;i++)
{
t=x[i];
for(j=i;j>0&&x[j-1]>t;j--)
x[j]=x[j-1];
x[j]=t;
}
return 0;
}
// SHELL SORT
// The basic
int shellsort()
{
int i, j, gap, temp;
for(gap=n/2;gap>0;gap/=2)
{
for(i=gap;i<n;i++) //
{
//for(j=i;j>0&&x[j-gap]>x[j];j-=gap) j must be bigger or equal to gap
for(j=i;j>=gap&&x[j-gap]>x[j];j-=gap)
{
temp=x[j];
x[j]=x[j-gap];
x[j-gap]=temp;
}
}
}
return 0;
}
// SELECTION SORT
int selectsort()
{
int i, j;
for(i=1;i<n;i++)
{
//for(j=n-1;j>=0;j--) the numbers in front are already in order
for(j=n-1;j>=i;j--)
{
if(x[j]<x[j-1])
swap(j,j-1);
}
}
return 0;
}
// QUICK SORT
// simplest version l=0 u=n-1
int qsort1(int l, int u)
{
int i, m;
if(l>=u)
return 0;
m=l;
//for(i=l;i<u;i++) // the ending condition
//for(i=l;i<=u;i++)
for(i=l+1;i<=u;i++) // x[l]作为哨兵(sentinel)，从x[l+1]开始比较
{
if(x[i]<x[l])
swap(++m, i);
}
swap(l,m);
qsort1(l,m-1);
qsort1(m+1,u);
return 0;
}
// Two-way partitioning
int qsort2(int l, int u)
{
/*
int i, j, t, m;
if(l>=u)
return 0;
m=l;
i=l;
j=u;
while(i<j)
{
//while(x[i]<x[l]) i++;
while(x[j]>x[l]) j--;
swap(x[i], x[j]);
i++;
j--;
}
if(i==j)
{
if(x[i]>x[l])
m=i-1;
else
m=i;
}
else
m=i-1;
swap(x[l],x[m]);
qsort2(l,m-1);
qsort2(m+1,u);
*/
int i, j, t;
if(l>=u)
return 0;
t=x[l];
i=l;
j=u+1;
for(;;)
{
do i++; while(i<=u&&x[i]<t); // i<=u
do j--; while(x[j]>t);
if(i>j) // stop condition
break;
swap(i,j);
}
swap(l,j);
qsort2(l,j-1);
qsort2(j+1,u);
return 0;
}
// qsort2 + randomization + isort small subarrays + swap inline
int cutoff=50;
int qsort3(int l, int u)
{
int i, j, t, temp;
if(l>=u)
return 0;
if(u-l<cutoff)
return 0;
//int cutoff=50; // set
/*
int random;
random=randint(l, u);
swap(x[l],x[random]);
*/
swap(l,randint(l,u));
t=x[l];
i=l;
j=u+1;
for(;;)
{
do i++; while(i<=u&&x[i]<t);
do j--; while(x[j]>t);
if(i>j) // stop condition
break;
temp=x[i];
x[i]=x[j];
x[j]=temp;
}
swap(l,j);
qsort2(l,j-1);
qsort2(j+1,u);
return 0;
}
// 编写程序，在O(n)时间内从数组x[0..n-1]中找出第k个最小的元素。算法可以对x中的元素进行排序。
int select(int l, int u, int k)
{
swap(l,randint(l,u));
int i, j, t, temp;
t=x[l];
i=l;
j=u+1;
for(;;)
{
do i++; while(i<=u&&x[i]<t);
do j--; while(x[j]>t);
if(i>j) // stop condition
break;
temp=x[i];
x[i]=x[j];
x[j]=temp;
}
swap(l,j);
if(j>k)
select(l, j-1, k);
else if(j<k)
select(j+1, u, k);
return 0;
}
// HEAP SORT
/*
int heapsort()
{
int i;
for(i=1;i<n;i++)
siftup(i);
for(i=0;i<n;i++)
{
swap(x[i],x[n-1-i]);
siftdown()
}
return 0;
}
*/
// 由小到大的顺序
int heapsort1()
{
int i;
x--;
for(i=2;i<=n;i++)
siftup1(i);
for(i=n;i>=2;i--)
{
swap(1,i);
siftdown1(1,i-1);
}
x++;
return 0;
}
int heapsort2()
{
int i, m=n;
x--;
for(i=2;i<=n;i++)
siftup2(i);
/*
for(i=n;i>=2;i--)
{
swap(1,i);
siftdown1(1,i-1);
}
*/
for(i=1;i<n;i++)
{
swap(1,m);
m=n-i;
siftdown2(1,m);
}
x++;
return 0;
}
int siftup2(int a)
{
//if(a<1)
if(a==1)
return 0;
//int t=x[a];
int b=a/2;
if(x[a]>=x[b])
{
swap(a,b);
siftup2(b);
}
else
return 0;
}
// 调整成大顶堆
int siftup1(int u)
{
int i;
for(;;)
{
/*
i=u/2;
if(i==1)
break;
*/
if(u==1)
break;
i=u/2;
//if(x[i]<x[u])
//if(x[i]<=x[u])
if(x[i]>=x[u])
break;
swap(i,u);
u=i;
}
return 0;
}
int siftdown2(int a, int m)
{
if(a>m/2)
return 0;
int c=a*2;
if(c+1<=m&&x[c]<=x[c+1])// c+1<=m
c++;
if(x[a]<=x[c])
{
swap(a,c);
siftdown2(c,m);
}
else
return 0;
}
// 调整成大顶堆
int siftdown1(int l, int u)
{
int i, c;
i=l;
for(;;)
{
c=2*i;
if(c>u)
break;
//if()
if(c+1<=u&&x[c+1]>x[c])
c++;
if(x[i]>x[c])
break;
swap(i,c);
i=c;
}
return 0;
}
int intcomp(const void *x, const void *y)
{
return *(int *)x-*(int *)y;
}
int timedriver()
{
int algnum, maxv, i, starttime, k, clicks;
//srand((unsigned)time(NULL));
while(scanf("%d %d %d",&algnum, &n, &maxv)!=EOF)
{
for(i=0;i<n;i++)
x[i]=randint(0, maxv-1);
k=n/2;
starttime=clock();
switch(algnum) // switch-case
{
case 11: qsort(x, n, sizeof(int), intcomp); break;
//case 12: sort(x, x+n); break;
case 21: isort1(); break;
case 22: isort2(); break;
case 23: isort3(); break;
case 31: qsort1(0, n-1); break;
case 32: qsort2(0, n-1); break;
case 33: qsort3(0, n-1); isort3();break;
case 41: select(0, n-1, k); break;
case 51: heapsort1(); break;
case 52: heapsort2(); break;
case 61: shellsort(); break;
case 62: selectsort(); break;
}
clicks=clock()-starttime;
if(algnum==41) // test selection
{
for(i=0;i<k;i++)
if(x[i]>x[k])
printf(" SELECT BUG i=%d\n", i);
for(i=k+1;i<n;i++)
if(x[i]< x[k])
printf(" SELECT BUG i=%d\n", i);
}
else // test sort
{
for(i=0;i<n-1;i++)
if(x[i]>x[i+1])
printf(" SORT BUG i=%d\n", i);
}
printf("%d\t%d\t%d\t%d\t%g\n",algnum, n, maxv, clicks, 1e9*clicks/(CLOCKS_PER_SEC*n));
}
return 0;
}
// main
int main()
{
timedriver();
return 0;
}
其中堆排序的两种方法时间上有一些波动：
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
