对一些简单排序算法的效率比较

最新推荐文章于 2024-01-01 00:15:00 发布
最新推荐文章于 2024-01-01 00:15:00 发布
阅读量603 收藏
点赞数 1
分类专栏： 算法 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzp0753/article/details/47397319
版权

空闲时整理了一下关于排序算法的内容，写写也当作是复习吧。
在这里我列了六种排序算法，分别是冒泡，选择，插入，Shell，快排和堆排。因为只是强调算法和效率，所以都用一维数组的形式来验证了。
首先我们整理一下这几种算法的时间复杂度（第一个是平均情况，第二个是最坏情况）：
/*
冒泡排序 O(n^2) O(n^2)
选择排序 O(n^2) O(n^2)
插入排序 O(n^2) O(n^2)
希尔排序 O(n^1.5) O(n^2)
快速排序 O(nlogn) O(n^2)
堆排序 O(nlogn) O(nlogn)
*/
还有就是关于排序稳定性的比较。我们知道，若排序前有两个关键字相等的数据，在排序之后位置并没有相对变动，那么我们就称该种排序方式是稳定的。
据此我们可以把冒泡排序，插入排序归为稳定排序，而相应的，选择排序，Shell排序，快排和堆排都是不稳定排序。
对于如何合理地选择排序方法，我写了一段程序，针对一个大小为10000的随机数组进行排序，比较所需的时间。
代码如下：

#include<iostream>
#include<ctime>
#include<cstdlib>
#include<time.h>
using namespace std;

int a[10001]; 
void Infos(int size)//show the oeders
{
    cout<<"--------------------------------------------"<<endl;
    cout<<"intput order"<<endl;
    cout<<"1 for Bubble sort_1"<<endl;
    cout<<"2 for Bubble sort_2"<<endl;
    cout<<"3 for Selection sort"<<endl;
    cout<<"4 for Insertion sort"<<endl;
    cout<<"5 for Shell sort"<<endl;
    cout<<"6 for Quick sort"<<endl;
    cout<<"7 for Heap sort"<<endl;
    cout<<"--------------------------------------------"<<endl;
    for(int i=0;i<size;i++)
    {
        cout<<a[i]<<" ";
    }
    cout<<endl;
    cout<<"--------------------------------------------"<<endl;
}

void restore(int array[],int size)//restore the array
{
    for(int i=0;i<size;i++)
    {
        array[i]=a[i];
    }
}

void s_print(int array[],int size)//output function
{
    for(int i=0;i<size;i++)
    {
        cout<<array[i]<<endl;
    }
    cout<<endl;
} 

void exchange(int a,int b)
{
    int temp;
    temp=a;
    a=b;
    b=temp;
}
/**********************************************************/
//case 1:
void Bsort1(int array[],int size)//Bubble sort 1(fast)
{
    int temp;
    for(int i=0;i<size-1;i++)
    {
        for(int j=size-1;j>i;j--)
        {
            if(array[j]<array[j-1])
            {
                temp=array[j];
                array[j]=array[j-1];
                array[j-1]=temp;
            }
        }
    }
    //s_print(array,size);
}
/**********************************************************/
//case 2:
void Bsort2(int array[],int size)//Bubble sort 2(slow)
{
    int temp;
    for(int i=0;i<size-1;i++)
    {
        for(int j=0;j<size-1;j++)
        {
            if(array[j+1]<array[j])
            {
                temp=array[j+1];
                array[j+1]=array[j];
                array[j]=temp;
            }
        }
    }
    //s_print(array,size);
}
/**********************************************************/
//case 3:
void Ssort(int array[],int size)//Selection sort
{
    int temp=array[0],m=0;
    for(int i=0;i<size;i++)
    {
        for(int j=i;j<size;j++)
        {
            if(temp>array[j])
            {
                temp=array[j];
                m=j;
            }
        }
        array[m]=array[i];
        array[i]=temp;
        temp=array[i+1];
        m=i;
        m++;
    }
    //s_print(array,size);
}
/**********************************************************/
//case 4:
void Isort(int array[],int size)//Insertion sort
{
    int temp,j;
    for(int i=1;i<size;i++)
    {
        temp=array[i];
        j=i-1;
        while(j>=0&&temp<array[j])
        {
            array[j+1]=array[j];
            j--;
        }
        array[j+1]=temp;
    }
    //s_print(array,size);
}
/**********************************************************/
//case 5:
void Sh_sort(int array[],int size)//Shell sort
{
    int t,j,temp;
    for(int t=size/2;t>=1;t/=2)
    {
        for(int i=t;i<size;i++)
        {
            temp=array[i];
            j=i-t;
            while(array[j]>temp&&j>=0)
            {
                array[j+t]=array[j];
                j=j-t;
            }
            array[j+t]=temp;
        }
    }
    //s_print(array,size);
}
/**********************************************************/
//case 6:
void Qsort(int array[],int left,int right)//Quick sort
{
    int l,r,temp;
    l=left;
    r=right;
    int p=(left+right)/2;             //确定比较的基准数 
    while(l<r)
    {
        while(array[l]<array[p])
        {
            l=l+1;
        }
        while(array[r]>array[p])
        {
            r=r-1;
        }
        if(l<r||l==r)
        {
            temp=array[l];
            array[l]=array[r];
            array[r]=temp;
            r=r-1;
            l=l+1;
        }
    }
    if(l==r)
    {
        l=l+1;
    }
    if(left<r)                //递归 
    {
        Qsort(array,left,r);
    }
    if(right>l)
    {
        Qsort(array,l,right);
    }
    //s_print(array,left+right+1);
}
/**********************************************************/
//case 7:
void Build_Heap(int array[],int i,int n)//按节点规律构造堆 
{
    int j,temp;
    while(2*i+1<n)
    {
        j=2*i+1;
        if(j+1<n)
        {
            if(array[j]<array[j+1])
            {
                j=j+1;
            }
        }
        if(array[i]<array[j])
        {
            temp=array[i];
            array[i]=array[j];
            array[j]=temp;
            i=j;
        }
        else
        {
            break;
        }
    }
} 
void Hsort(int array[],int size)//Heap sort
{
    int i,j,temp,m;
    for(i=size/2-1;i>=0;i--)
    {
        Build_Heap(array,i,size);
    }
    //cout<<"初始堆"<<endl;
    //s_print(array,size);
    for(i=size-1;i>0;i--)
    {
        temp=array[0];
        array[0]=array[i];
        array[i]=temp;
        m=0;
        Build_Heap(array,m,i);
    }
    //s_print(array,size);
}

void Get_time_Bsort1(int a[],int size)
{
    cout<<"Bubble sort(fast): "<<endl;
    clock_t start,end;
    double cpu_time;
    srand(time(NULL));
    for(int i=0;i<size;i++)
    {
        a[i]=rand();
    }
    start=clock();
    Bsort1(a,size);
    end=clock();
    cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
    cout<<"Run Time = "<<cpu_time<<endl;
    cout<<"——————————————————"<<endl;
}
void Get_time_Bsort2(int a[],int size)
{
    cout<<"Bubble sort(slow): "<<endl;
    clock_t start,end;
    double cpu_time;
    srand(time(NULL));
    for(int i=0;i<size;i++)
    {
        a[i]=rand();
    }
    start=clock();
    Bsort2(a,size);
    end=clock();
    cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
    cout<<"Run Time = "<<cpu_time<<endl;
    cout<<"——————————————————"<<endl;
}
void Get_time_Ssort(int a[],int size)
{
    cout<<"Selection sort: "<<endl;
    clock_t start,end;
    double cpu_time;
    srand(time(NULL));
    for(int i=0;i<size;i++)
    {
        a[i]=rand();
    }
    start=clock();
    Ssort(a,size);
    end=clock();
    cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
    cout<<"Run Time = "<<cpu_time<<endl;
    cout<<"——————————————————"<<endl;
}
void Get_time_Isort(int a[],int size)
{
    cout<<"Insertion sort: "<<endl;
    clock_t start,end;
    double cpu_time;
    srand(time(NULL));
    for(int i=0;i<size;i++)
    {
        a[i]=rand();
    }
    start=clock();
    Isort(a,size);
    end=clock();
    cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
    cout<<"Run Time = "<<cpu_time<<endl;
    cout<<"——————————————————"<<endl;
}
void Get_time_Sh_sort(int a[],int size)
{
    cout<<"Shell sort: "<<endl;
    clock_t start,end;
    double cpu_time;
    srand(time(NULL));
    for(int i=0;i<size;i++)
    {
        a[i]=rand();
    }
    start=clock();
    Sh_sort(a,size);
    end=clock();
    cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
    cout<<"Run Time = "<<cpu_time<<endl;
    cout<<"——————————————————"<<endl;
}
void Get_time_Qsort(int a[],int size)
{
    cout<<"Quick sort: "<<endl;
    clock_t start,end;
    double cpu_time;
    srand(time(NULL));
    for(int i=0;i<size;i++)
    {
        a[i]=rand();
    }
    start=clock();
    Qsort(a,0,size-1);
    end=clock();
    cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
    cout<<"Run Time = "<<cpu_time<<endl;
    cout<<"——————————————————"<<endl;
}
void Get_time_Hsort(int a[],int size)
{
    cout<<"Heap sort: "<<endl;
    clock_t start,end;
    double cpu_time;
    srand(time(NULL));
    for(int i=0;i<size;i++)
    {
        a[i]=rand();
    }
    start=clock();
    Hsort(a,size);
    end=clock();
    cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
    cout<<"Run Time = "<<cpu_time<<endl;
    cout<<"——————————————————"<<endl;
}
const int N=10000;
int main()
{
    Get_time_Bsort1(a,N);
    Get_time_Bsort2(a,N);
    Get_time_Ssort(a,N);
    Get_time_Isort(a,N);
    Get_time_Sh_sort(a,N);
    Get_time_Qsort(a,N);
    Get_time_Hsort(a,N);
}

运行之后，结果如下：

这里写图片描述

所以在面对数据大的随机数列时，应采用堆排，快排这种时间复杂度为O(nlogn)的算法，而数据量小时，可采用插入排序或选择排序法。

P.S:没有FP坑啊······

zzp0753
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常用排序算法哪个效率更高之从理论到实践
MarcoPro的博客
12-23 2616
这里我们来看看这几个算法哪个效率更高一点呢？
java 快速排序_JAVA面试题：5分钟了解快速排序
weixin_39958248的博客
12-02 258
前言快速排序是面试中经常会问到的一种排序算法，对比其他一些排序算法，快速排序的平均时间相对较少。快速排序思想介绍快速排序使用了分治的思想，通过一轮的排序，可以将序列分割成独立的两个部分，其中一部分的值均比基准值小，另一部分的值均比基准值大。而后针对两部分序列再分别按照同样的算法进行排序，直到序列整体有序。以如下序列arr为例进行升序排序，说明快速排序的基本算法第一个位置的值23作为基准值base，...
常见排序算法
nameofcsdn的博客
01-29 2047
目录 一，排序算法 1，分类方法 （1）内部排序、外部排序 （2）原址排序、非原址排序 （3）稳定排序、非稳定排序 （4）基于计算的排序算法、基于比较的排序算法 2，排序算法测试代码 （1）提供模板函数 （2）约定接口 （3）排序测试 3，常见排序算法 （1）插入排序 （2）选择排序 （3）冒泡排序 （4）归并排序 （5）堆排序 （6）快速排序 （7）基数排序 （8）计数排序 （9）桶排序 （10）希尔排序 二，排序算法效率、组合嵌套 三，sort 四，拓展排
十大排序算法——排序算法效率比较——选择排序、冒泡排序、选择排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序
最新发布
weixin_43981402的博客
01-01 492
一次性解决十大排序算法。
排序算法总结
xcjxnyhhh的博客
05-14 279
所有人对排序这个词并不陌生，最常见的从小到大，从大到小排序，按年龄和身高排序，或者是人们日常生活中点外卖时商家的排序。同样在java中，任何Comparable的对象，即任何实现了接口Comparable进而定义了方法compareTo的类的对象，都可以排序。如何具体的比较两个对象，依赖于对象的特性。 时间复杂度简单介绍 假如我要去超市。有如下选择，走路，自己开车，坐朋友车，坐公共汽车。哪种方式最好？首先，最好的概念是什么？是最省钱，最省自己的时间，最省朋友的时间，还是对环境更有利？假定对读者而言，最好
7种排序算法的效率比较
12-07
算法课的一个小项目，语言python。代码实习7种排序算法，TK实现简单GUI，源码可以学习7中排序算法详细实现，和GUI的搭建，基本包含了常用GUI组件。
java排序算法效率比较
04-27
本实验通过生成大量随机数并写入文件，然后使用四种不同的排序算法进行排序，以比较它们的效率。以下是对这四种排序算法的详细解释： 1. **冒泡排序（Bubble Sort）** 冒泡排序是最基础的排序算法之一，它通过重复...
C#排序算法的比较分析
09-04
本文将对几种常见的C#排序算法进行比较分析，包括时间复杂度、稳定性以及C#代码实现。 首先，我们来看直接插入排序。这种排序算法的基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加...
快速排序归并排序简单排序算法比较
07-16
自己写的三个排序算法的比较。快速排序、归并排序、简单排序 对三个排序算法所消耗时间进行统计，比较时间效率 程序是在Linux下用C写的，ｖｃ下并未做测试。
yuandaima.zip_排序算法比较_排序类
09-24
本文将详细探讨"yuandaima.zip_排序算法比较_排序类"中涉及的各种排序算法，包括它们的基本原理、性能分析以及适用场景。 一、冒泡排序（Bubble Sort） 冒泡排序是最基础的排序算法之一，它通过不断地交换相邻的...
排序算法及效率
06-10
在排序中使用到的几种算法及效率对比
设计一个测试程序比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受。
12-28
设计一个测试程序比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受。
排序算法之（9）--八种常用排序算法效率对比
热门推荐
hiudawn
05-20 2万+
排序是数据处理中一种很重要也很常用的运算，一般情况下，排序操作在数据处理过程中要花费许多时间，为了提高计算机的运行效率，我们提出并不断改进各种各样的排序算法，这些算法也从不同角度展示了算法设计的重要原则和技巧。
常见排序算法效率比较
07-03 457
八种排序算法效率比较
fujibayashikyo的专栏
04-03 1718
从刚上大一那会儿学的C语言开始，就已经接触到了不少排序算法，但当时都只是为了完成简单的排序任务而已，而且所给的数据也不够多，所以看不出各个排序算法间的执行效率的优劣。最近有个数据结构课程设计的实验，是有关于排序算法之间的效率比较，我就顺便把它放上来了，并对各个算法执行的效率时间做了柱形统计图表。此次实验主要测试了8种排序算法：插入排序、快速排序、冒泡排序、希尔排序、简单选择排序、堆排序、归并排序、
各种排序算法的效率比较
思緒凌亂
08-30 2580
（1）本文包括冒泡算法、快排算法、插入排序算法等；通过随机数进行比较他们之前的效率； （2）自己手动实现的简单的算法 冒泡和快排与系统自带的算法进行了比较，由于系统自带是面向容器的，所以总体上不如自己简单实现的效率高，但是基本上在一个数量级上； （3）第一次这样纵向的比较自己手动写的代码，还是有点小激动的，不足之处，请各位指正哦。。 （4）我也幼稚我的哦。。。
各种排序查询的算法效率比较
denny的专栏
05-11 9898
一 排序 SN 排序方式 时间复杂度 空间复杂度
数据结构实验(排序算法效率比较平台).docx
01-24
“数据结构实验(排序算法效率比较平台).docx” 这篇文档是关于数据结构实验的报告，主要目标是设计并实现一个内部排序算法效率比较的平台，以直观地对比不同排序算法在处理随机数据时的关键字比较次数和移动次数。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值