几种排序算法

来源：互联网发布：vb label 编辑：程序博客网时间：2024/05/01 16:45

原来在做数据结构课程设计的时候，分别对几种排序算法的“关键字的比较次数”、“记录的移动次数”做了具体的比较，结果显示在一般情况下快速排序最好、堆排序次之。

表几种常用排序算法性能比较

时间复杂度

空间复杂度

稳定

插入排序

O(n2)

√

希尔排序

O(n2)

冒泡排序

O(n2)

√

选择排序

O(n2)

快速排序

O(Nlogn)

O(logn)

堆排序

O(Nlogn)

归并排序

O(Nlogn)

O(n)

√

在一些排序算法中要求较快的速度，因而要选择好的排序算法。

归并排序

快速排序

堆排序

插入排序

冒泡排序

希尔排序

选择排序

下面给出几种排序算法的实现及调用，数组采用0下标开始，size为n：

堆排序：

void swap(int x[],int i,int j)

{
   int t = x[i];
   x[i] = x[j];
   x[j] = t;
}
void restore(int a[],int root,int n)
{
   int m,j = root;
   while(j <= n/2 - 1)
   {
       if((j*2+2 < n)&&(a[j*2+1] < a[j*2+2]))
           m = j*2+2;
       else
           m = j*2+1;
       if(a[j] < a[m])
       {
           swap(a,j,m);
           j = m;
       }
       else
           return;
   }
}
//堆排序，即使不断的重建
void heapsort(int a[],int n)
{
   int i;
   for(i = n/2 - 1;i >= 0;i --)
       restore(a,i,n);
   for(i = n-1;i > 0;i --)
   {
       swap(a,0,i);
       restore(a,0,i);
   }

}

//调用方式：heapsort(start,n);

快速排序：

递归算法(摘自编程之美，精简清晰)：

void quicksort(int x[],int l,int u)
{
   int i,m;
   if(l >= u)return;
   m = l;
   for(i = l+1; i <= u;i ++)
       if(x[i] < x[l])
           swap(x,++m,i);
   swap(x,l,m);
   quicksort(x,l,m-1);
   quicksort(x,m+1,u);
}

调用方式：quicksort(start,0,n-1);

---------------------------------------------------------------------------------------------

以下内容来自本科的课程设计代码，数组下标从1-n，代码不是很清晰，仅供参考。
//**************************直接插入排序*************************

void InsertSort(int a[],int n)
{
int t,j;
for(int i=2;i<=n;i++)
{
   t=a[i];
   j=i-1;
   while(t<a[j])
   {
    a[j+1]=a[j];
    j--;
   }
   a[j+1]=t;
}
}
//*****************************************************************

//**************************快速排序算法******************//
int Part(int a[],int m,int n)
{
int i,j,k;
Interchange(a,(int)(m+n)/2,m+1);
if(a[m+1]>a[n])
   Interchange(a,m+1,n);
if(a[m]>a[n])
   Interchange(a,m,n);
if(a[m+1]>a[m])
   Interchange(a,m,m+1);
i=m;
j=n+1;
k=a[m];
while(i<j)
{
   i++;
   while(a[i]<k)
    i++;
   j--;
   while(a[j]>k)
    j--;
   if(i<j)
    Interchange(a,i,j);
}
Interchange(a,m,j);
return j;
}

class stacktype
{
public:
int x,y;
stacktype(int m=0,int n=0):x(m),y(n){}
};

void HSort(int a[],int n,int M)
{

stack<stacktype> stackptr;
stacktype temp(0,0);
int f,t,j;
stackptr.push(temp);
f=1;
t=n;
while(f<t)
{
   j=Part(a,f,t);
   if((j-f<M)&&(t-j<M))
   {
    if(!stackptr.stackEmpty()){
     temp=stackptr.pop();
    f=temp.x;
    t=temp.y;
    continue;
    }
    else
     break;
   }
   if((j-f<M)&&(t-j>=M))
   {
    f=j+1;
    continue;
   }
   if((j-f>=M)&&(t-j<M))
   {
    t=j-1;
    continue;
   }

   if((j-f>=M)&&(t-j>=M))
   {
    if(j-f>t-j)
    {
     stackptr.push(stacktype(f,j-1));
     f=j+1;
    }
    else
    {
     stackptr.push(stacktype(j+1,t));
     t=j-1;
    }
   }
}
InsertSort(a,n);
}
//******************************over***************************//

void main()
{
int a[11]={-1,1,2,5,7,3,9,4,8,6,0};
for(int i=1;i<=10;i++)
cout<<a[i]<<" ";
cout<<endl;
HSort(a,10,4);
for(i=1;i<=10;i++)
cout<<a[i]<<" ";
cout<<endl;
}

直接选择排序：

//排序调试程序之直接选择排序

#include "iostream.h"

//交换数组中下标为m/n的数
void Interchange(int a[],int m,int n)
{
int t;
t=a[m];
a[m]=a[n];
a[n]=t;
}

//直接选择排序算法
void SSort(int a[],int n)
{
int t;
for(int j=n;j>=2;j--)
{
   t=1;
   for(int i=2;i<=j;i++)
    if(a[t]<a[i])
     t=i;
   Interchange(a,j,t);
}
}

void main()
{
int a[11]={-1,1,2,5,7,3,9,4,8,6,0};
for(int i=1;i<=10;i++)
cout<<a[i]<<" ";
cout<<endl;
SSort(a,10);
for(i=1;i<=10;i++)
cout<<a[i]<<" ";
cout<<endl;
}

冒泡排序和直接插入排序略