排序算法对比

 

 

排序算法对比

1.     算法设计思想：

（1）       冒泡排序：将数组a[0,1,···,n-1]看做是垂直排列的，每个元素值看做该气泡的重量，因为轻重量的气泡不能在重重量之下，所以从最后一个气泡开始和其前面一个比较，若下面的轻则交换，如此反复直到所有轻气泡都在上面，重的都在下面为止。

（2）       选择排序：第一次循环从0的位置开始找所有元素中最小，与0位置元素交换···第i次循环从i-1的位置开始往后找此时最小元素与i-1元素交换，直到所有的都循环完。

（3）       插入排序：像揭牌一样，设第一个元素是排好序的，第二个元素和第一个元素比较找到它的位置····第i个元素和之前排好的i-1个元素比较找到自己的位置，直到所有的元素都排序完毕。

（4）       归并排序：本次实验中采取自顶向下的分治方法，先将一个大的数组分成近似相等的两部分，分别对两边进行排序，两边各自排好序后将两边的两个小数组在按非递减的顺序归并到一个数组中。具体归并思路是：先设一个大数组，取两个小数组中较小的元素放入这个大数组中直到其中一个小数组的元素插入完毕，然后将另一个数组剩余的值复制入大数组中。

（5）       快速排序：取第一个元素做基准，将所有元素分成左右两部分，用分治法分别对两边排序，然后将两边分别排序好的两组元素再按大小顺序合并成一个数组。

2.       算法程序代码：

 #include<iostream>

#include<ctime>

#include<cstdlib>

#include<ctime>

using std::cout;

using std::endl;

#define N 100

///产生随机数///

void array(int A[])

{

    int i;

    srand(time(0));

    for (i=0;i<N;i++)

        A[i]=rand()%N;

 

    /*cout<<"原始数组："<<endl;

    for (i=0;i<N;i++)

        cout<<A[i]<<' ';

    cout<<endl;*/

 

}

///冒泡排序/

void bubble(int x[])

{

    int i,j,num;

    int A[N];

    for (i=0;i<N;i++)

        A[i]=x[i];                     //A【】为待排序数组

    for (i=0;i<N;i++)

    {

        for (j=N-1;j>i;j--)

        {

            if (A[j]<A[j-1])

            {

                num=A[j-1];

                A[j-1]=A[j];

                A[j]=num;

            }

        }

 

    }

   /* cout<<"*******************冒泡排序*****************"<<endl;

    for (i=0;i<N;i++)

        cout<<A[i]<<' ';

    cout<<endl;*/

}

/选择排序/

void select(int x[])

{

    int i,j,min,num;

    int A[N];

    for (i=0;i<N;i++)

        A[i]=x[i];                     //A【】为待排序数组

    for (i=0;i<N;i++)

    {

        min=i;

        for (j=i+1;j<N;j++)

        {

            if (A[j]<A[min])

                min=j;

        }

        if (min!=i)

        {

            num=A[i];

            A[i]=A[min];

            A[min]=num;

        }

    }

    /*cout<<"*******************选择排序*****************"<<endl;

    for (i=0;i<N;i++)

        cout<<A[i]<<' ';

    cout<<endl;*/

}

插入排序

void insert(int x[])

{

    int i,j,num;

    int A[N];

    for (i=0;i<N;i++)

        A[i]=x[i];                     //A【】为待排序数组

    for (i=1;i<N;i++)

    {

        if (A[i]<A[i-1])

        {

            num=A[i];

            j=i-1;

            while (j>=0&&num<A[j])

            {

                A[j+1]=A[j];

                j--;

            }

            A[j+1]=num;

        }

    }

 

    /*cout<<"*******************插入排序*****************"<<endl;

    for (i=0;i<N;i++)

        cout<<A[i]<<' ';

    cout<<endl;*/

}

//归并排序//

void merge(int A[],int left,int right,int k)

{

    int i,j,m;

    m=left;

    int B[N];

    i=left;

    j=k+1;

    while ((i<=k)&&(j<=right))

    {

        if (A[i]<=A[j])

        {

            B[m]=A[i];

            i++;

        }

        else

        {

            B[m]=A[j];

            j++;

        }

        m++;

    }

        while (j<=right)

            B[m++]=A[j++];

        while (i<=k)

            B[m++]=A[i++];

    i=left;

    while (i<=right)

    {

        A[i]=B[i];i++;

    }

 

}

void mergesort(int A[],int left,int right)

{

    int mid;

    if(left<right)

    {

        mid=(right+left)/2;

        mergesort(A,left,mid);

        mergesort(A,mid+1,right);

        merge(A,left,right,mid);

    }

}

//快速排序

int sort(int A[],int a,int b)

{

    int n=A[a];

    ?????如何合并a<b一项？

    while (a<b)

    {

        while (A[b]>=n&&a<b)  //不需要b>0???

            b--;

        if (a<b)

        {

            A[a]=A[b];

            a++;

        }

        while (A[a]<=n&&a<b)  //不需要a<N???

            a++;

        if (a<b)

        {

            A[b]=A[a];

            b--;

        }

    }

    A[a]=n;

    return a;

}

 

void quicksort(int A[],int left,int right)

{

    int a;

    if (right>left)

    {

        a=sort(A,left,right);

        quicksort(A,left,a-1);

        quicksort(A,a+1,right);

    }

}

//main 函数 ///

 

int  main()

{

    int A[N];

    int t1,t2;

    array(A);

    //冒泡/

    t1=clock();

    bubble(A);

    t2=clock();

    cout<<"冒泡排序需要时间为:"<<(double)(t2-t1)/10000<<endl;

    //选择//

    t1=clock();

    select(A);

    t2=clock();

    cout<<"选择排序需要时间为:"<<(double)(t2-t1)/10000<<endl;

    ///插入///

    t1=clock();

    insert(A);

    t2=clock();

    cout<<"插入排序需要时间为:"<<(double)(t2-t1)/10000<<endl;

    ///归并/

    int x[N];

    for (int i=0;i<N;i++)

    x[i]=A[i];                     //x【】为待排序数组

    t1=clock();

    mergesort(x,0,N-1);

    t2=clock();

    cout<<"归并排序需要时间为:"<<(double)(t2-t1)/10000<<endl;

    /*cout<<"排序后数组："<<endl;

    for (int i=0;i<N;i++)

        cout<<x[i]<<' ';*/

    /快速//

    int y[N];

    for (int i=0;i<N;i++)

    y[i]=A[i];                     //y【】为待排序数组

    t1=clock();

    quicksort(y,0,N-1);

    t2=clock();

    cout<<"快速排序需要时间为:"<<(double)(t2-t1)/10000<<endl;

    /*cout<<"排序后数组："<<endl;

    for (int i=0;i<N;i++)

        cout<<y[i]<<' ';*/

    return 0;

}

 

 

 

 

3.       实验数据及实验结果：

（1）N=1000即有一千个待排序数时得到的结果是：

冒泡排序所需时间为：0ms

选择排序所需时间为：0ms

插入排序所需时间为：0ms

归并排序所需时间为：0ms

快速排序所需时间为：0ms

（2）N=10000即有一万个待排序数时得到的结果是：

冒泡排序所需时间为：421ms

选择排序所需时间为：203ms

插入排序所需时间为：141ms

归并排序所需时间为：0ms

快速排序所需时间为：0ms

（3）N=100000即有十万个待排序数时得到的结果是：

冒泡排序所需时间为：49938ms

选择排序所需时间为：22266ms

插入排序所需时间为：16125ms

归并排序所需时间为：125ms

快速排序所需时间为：16ms