关于快速排序与归并排序

最新推荐文章于 2024-01-03 22:56:09 发布
最新推荐文章于 2024-01-03 22:56:09 发布
阅读量564 收藏
点赞数
分类专栏： 心得感想
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyx2000/article/details/71086910
版权

鉴于快速排序难以分析的复杂度和对stl的极度不信任做了一下尝试。
数据生成器

#include<iostream>
#include<cstdio>
#include<time.h>
#include<stdlib.h>
using namespace std;
FILE *ans = fopen("ans.out","w");
int cnt=0;
void solve(){
    FILE *fp = fopen("1.in","w");
    int n = rand()%1000000+1000000;
    fprintf(fp,"%d\n",n);
    for(int i=1;i<=n;i++){
        fprintf(fp,"%d\n",rand()%10000);
    }
    fclose(fp);
    system("fast");
    system("merge");
    system("fast_hand");
    FILE *fp1 = fopen("1.out","r");
    FILE *fp2 = fopen("2.out","r");
    FILE *fp3 = fopen("3.out","r");
    int cnt_1,cnt_2,cnt_3,t_1,t_2,t_3;
    fscanf(fp1,"%d %d",&cnt_1,&t_1);fscanf(fp2,"%d %d",&cnt_2,&t_2);
    fscanf(fp3,"%d %d",&cnt_3,&t_3);
//  printf("%d %d %d %d %d %d\n",t_1,t_2,t_3,cnt_1,cnt_2,cnt_3);
    fprintf(ans,"size %d,time %d %d %d,cnt %d %d %d\n",n,t_1,t_2,t_3,cnt_1,cnt_2,cnt_3);
}
int main(){
    srand(time(0));
    for(int i=1;i<=1000;i++){
        cnt=i;
        solve();
    }
    return 0;
}

stl sort

#include<time.h>
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
int read(){
    int rt=0,fl=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')fl=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){rt=rt*10+ch-'0';ch=getchar();}
    return rt*fl;
}
int cnt=0;
struct str{
    int ca;
    str(){

    }   
    str(int _bu){
        this->ca=_bu;
    }
    bool operator < (str b)const{
        cnt++;
        return this->ca < b.ca;
    }
};
str s[10000000];
int n;
int main(){
    freopen("1.in","r",stdin);
    freopen("1.out","w",stdout);
    n  = read();
    for(int i=1;i<=n;i++){
        int a = read();
        s[i] = str(a);
    }
    sort(s + 1,s + n);
    cout<<cnt<<endl<<clock();
    return 0;
}

mergesort

#include<bits/stdc++.h>
using namespace std;
int read(){
    int rt=0,fl=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')fl=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){rt=rt*10+ch-'0';ch=getchar();}
    return rt*fl;
}
int cnt=0,n;
struct str{
    int ca;
    str(){

    }   
    str(int _bu){
        this->ca=_bu;
    }
    bool operator < (str b)const{
        cnt++;
        return this->ca < b.ca;
    }
};
str s[10000000],buf[10000000];
void init(){
    n = read();
    for(int i = 1;i < n;i++){
        int a = read();
        s[i] = str(a);
    }
}
void sort(int l,int r){ 
    if(l==r)return;
    int mid = l + r >> 1 ,L = l,R = mid+1;
    sort(l,mid);sort(mid+1,r);
    for(int i = l;i <= r;i++){
        if(L<=mid&&R<=r){
            if(s[L]<s[R]){
                buf[i]=s[L++];
            }else{
                buf[i]=s[R++];
            }
        }else if(L<=mid){
            buf[i]=s[L++];
        }else{
            buf[i]=s[R++];
        }
    }
//  for(int i=l;i<=r;i++)s[i]=buf[i];
    memcpy(s+l,buf+l,(r-l+1)*sizeof(str));
}
int main(){
    freopen("1.in","r",stdin);
    freopen("2.out","w",stdout);
    init();
    sort(1,n);
    cout<<cnt<<endl<<clock();
    return 0;
}

手写快拍

#include<ctime>
#include<cstdio>
#include<iostream>
using namespace std;
int read(){
    int rt=0,fl=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')fl=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){rt=rt*10+ch-'0';ch=getchar();}
    return rt*fl;
}
int cnt=0,n;
struct str{
    int ca;
    str(){

    }   
    str(int _bu){
        this->ca=_bu;
    }
    bool operator < (str b)const{
        cnt++;
        return this->ca < b.ca;
    }
    bool operator > (str b)const{
        cnt++;
        return this->ca > b.ca;
    }   
};
str a[10000000],buf[10000000];
void init(){
    n = read();
    for(int i = 0;i < n;i++){
        int aa = read();
        a[i] = str(aa);
    }
}
void quicksort(int left,int right)
{
    int i,j;str base;
    i=left; j=right;
    base=a[(i+j)/2];
    while (i<=j){
        while (a[i]<base) i++;
        while (a[j]>base) j--;
        if (i<=j){
            str t=a[i]; a[i]=a[j];a[j]=t;
            i++;
            j--;
        }
    }
    if (left<j) quicksort(left,j);
    if (i<right) quicksort(i,right);
}
int main()
{
    freopen("1.in","r",stdin);
    freopen("3.out","w",stdout);
    init();
    quicksort(0,n-1);
    cout<<cnt<<endl<<clock();
     return 0;
}

结果
可以看出，在不开O2优化且数据保证随机的条件下，手写快拍是最快的，但比较次数也是最多的，归并排序虽然耗时最长，但比较次数是最少的，而且少的非常明显。
当然在开启O2优化的情况下，stl的sort是完虐它们的。
为了加大比较次数对时间影响，我把排序的对象换成了字符串。
数据生成器

#include<iostream>
#include<cstdio>
#include<time.h>
#include<stdlib.h>
using namespace std;
FILE *ans = fopen("ans.out","w");
int cnt=0;
void solve(){
    FILE *fp = fopen("1.in","w");
    int n = rand()%1000000+100000;
    fprintf(fp,"%d\n",n);
    for(int i=1;i<=n;i++){
        int len = rand()%15+2;
        for(int j=1;j<=len;j++){
            fprintf(fp,"%c",rand()%17+'a');
        }
        fprintf(fp,"\n");
    }
    fclose(fp);

    system("fast");
    system("merge");
    system("fast_hand");
    FILE *fp1 = fopen("1.out","r");
    FILE *fp2 = fopen("2.out","r");
    FILE *fp3 = fopen("3.out","r");
    int cnt_1,cnt_2,cnt_3,t_1,t_2,t_3;
    fscanf(fp1,"%d %d",&cnt_1,&t_1);fscanf(fp2,"%d %d",&cnt_2,&t_2);
    fscanf(fp3,"%d %d",&cnt_3,&t_3);
    printf("%d %d %d %d %d %d\n",t_1,t_2,t_3,cnt_1,cnt_2,cnt_3);
    fprintf(ans,"size %d,time %d %d %d,cnt %d %d %d\n",n,t_1,t_2,t_3,cnt_1,cnt_2,cnt_3);

}
int main(){
    srand(time(0));
    for(int i=1;i<=10000;i++){
        cnt=i;
        solve();
    }
    return 0;
}

stl

#include<time.h>
#include<string>
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
int read(){
    int rt=0,fl=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')fl=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){rt=rt*10+ch-'0';ch=getchar();}
    return rt*fl;
}
int cnt=0;
struct str{
    string ca;
    str(){

    }   
    str(string _bu){
        this->ca=_bu;
    }
    bool operator < (str b)const{
        cnt++;
        return this->ca < b.ca;
    }
};
str s[10000000];
int n;
int main(){
    freopen("1.in","r",stdin);
    freopen("1.out","w",stdout);
    n  = read();
    for(int i=1;i<=n;i++){
    //  int a = read();
        string a;
        cin>>a;
        s[i] = str(a);
    }
    sort(s + 1,s + n);
    cout<<cnt<<endl<<clock();
    return 0;
}

merge

#include<bits/stdc++.h>
using namespace std;
int read(){
    int rt=0,fl=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')fl=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){rt=rt*10+ch-'0';ch=getchar();}
    return rt*fl;
}
int cnt=0,n;
struct str{
    string ca;
    str(){

    }   
    str(string _bu){
        this->ca=_bu;
    }
    bool operator < (str b)const{
        cnt++;
        return this->ca < b.ca;
    }
};
str s[10000000],buf[10000000];
void init(){
    n = read();
    for(int i = 1;i <= n;i++){
    //  int a = read();
        string a;
        cin>>a;
        s[i] = str(a);
    }
}
void sort(int l,int r){ 
    if(l==r)return;
    int mid = l + r >> 1 ,L = l,R = mid+1;
    sort(l,mid);sort(mid+1,r);
    for(int i = l;i <= r;i++){
        if(L<=mid&&R<=r){
            if(s[L]<s[R]){
                buf[i]=s[L++];
            }else{
                buf[i]=s[R++];
            }
        }else if(L<=mid){
            buf[i]=s[L++];
        }else{
            buf[i]=s[R++];
        }
    }
    memcpy(s+l,buf+l,(r-l+1)*sizeof(str));
}
int main(){
    freopen("1.in","r",stdin);
    freopen("2.out","w",stdout);
    init();
    sort(1,n);
    cout<<cnt<<endl<<clock();
    return 0;
}

手写快排

#include<ctime>
#include<cstdio>
#include<iostream>
using namespace std;
int read(){
    int rt=0,fl=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')fl=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){rt=rt*10+ch-'0';ch=getchar();}
    return rt*fl;
}
int cnt=0,n;
struct str{
    string ca;
    str(){

    }   
    str(string _bu){
        this->ca=_bu;
    }
    bool operator < (str b)const{
        cnt++;
        return this->ca < b.ca;
    }
    bool operator > (str b)const{
        cnt++;
        return this->ca > b.ca;
    }   
};
str a[10000000],buf[10000000];
void init(){
    n = read();
    for(int i = 0;i <= n;i++){
    //  int aa = read();
        string aa;
        cin>>aa;
        a[i] = str(aa);
    }
}
void quicksort(int left,int right)
{
    int i,j;str base;
    i=left; j=right;
    base=a[(i+j)/2];
    while (i<=j){
        while (a[i]<base) i++;
        while (a[j]>base) j--;
        if (i<=j){
            str t=a[i]; a[i]=a[j];a[j]=t;
            i++;
            j--;
        }
    }
    if (left<j) quicksort(left,j);
    if (i<right) quicksort(i,right);
}
int main()
{
    freopen("1.in","r",stdin);
    freopen("3.out","w",stdout);
    init();
    quicksort(0,n-1);
    cout<<cnt<<endl<<clock();
     return 0;
}

结果如下，不开O2的情况下，归并速度比stl快了100ms
这里写图片描述
开O2的情况下，还是归并优于快排（两次数据不一样大）
这里写图片描述
纵观以上的结果，我们还是要根据具体情况选择好的排序方法，当然在OI中这显得不是太重要，但在实际工程应用中，还是要把握好每一种排序方式的优点，进而选择最合适的排序方法。

Kvrmnks
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
快速排序和归并排序
weixin_41837346的博客
01-08 156
归并排序 思想：把数组平分成两部分，分别排好序，然后合并。 分治：先分解，再合并 递归递推公式 merge_sort(p,r) = merge(merge_sort(p,q),merge_sort(q+1,r)) 递归终止条件：p>=r //10组测试数据 for (let i = 0; i < 10; i++) { let arr = getTestData() ...
归并排序和快速排序总结
佳佳的博客
11-05 4815
归并排序和快速排序总结1. 算法基本思路：分治分治，字面上的解释是“分而治之”，就是把一个复杂的问题分成多个同等结构的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。归并排序和快速排序都采用了二分法思想。不同之处在于，归并排序在“分”的问题上是简单的一刀切，而将重点放在了如何“归并”上。而快速排序则花了很大的功夫在如何“分”这个问题上，“归并”则
快速排序归并排序简单排序算法比较
07-16
自己写的三个排序算法的比较。快速排序、归并排序、简单排序 对三个排序算法所消耗时间进行统计，比较时间效率 程序是在Linux下用C写的，ｖｃ下并未做测试。
排序算法：归并排序、快速排序
张维鹏的博客
01-29 2482
  相关博客： 排序算法：冒泡排序、插入排序、选择排序、希尔排序 排序算法：归并排序、快速排序 排序算法：桶排序、计数排序、基数排序 排序算法：堆排序 十大排序算法小结 一、归并排序： 1、工作原理： 归并排序的采用分治思想，如果要排序一个数组，我们先把数组从中间分成前后两个部分，然后对前后两个部分分别进行排序，再将排好序的两部分合并在一起，这样整个数组就都有序了。 2、动图演...
算法之——归并排序和快速排序
IT荻的博客
02-08 4231
归并排序 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法： 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）； 自下而上的迭代； 和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的...
【数据结构】归并排序、快速排序（递归法和非递归法）
m0_65679465的博客
02-01 1233
排序算法是基础，但是，对于归并排序和快速排序，其思想方法的理解是重中之重，而且不光要掌握递归法，对非递归法也要有所了解。本文详细介绍了归并排序，以及三种实现快速排序的方法。与此同时，对两种排序算法的非递归法也进行了细致的分析，相信看完一定有所收获！
c语言实现排序算法，快速排序，归并排序
02-06
本文将详细探讨两种常见的高效排序算法——快速排序和归并排序，它们都是C语言实现的重点。 首先，快速排序是一种由C.A.R. Hoare在1960年提出的分治算法。其基本思想是选取一个基准元素，然后将数组分为两部分，一...
快速排序+归并排序+c++
10-27
计算机算法课程的作业，用c++实现了归并排序和快速排序，并比较了两种算法的速度。测试数据为随机生成，可设置为10万、100万、1000万大小的数组。在代码中提供了详细的注释，在容易出错的地方进行了解释。下面是得到...
C++归并排序与快速排序实现.zip
08-20
本资料包“C++归并排序与快速排序实现.zip”主要关注两种经典的排序算法：归并排序（Merge Sort）和快速排序（Quick Sort）。下面我们将详细探讨这两种排序算法以及如何用C++实现它们。 **归并排序（Merge Sort）**...
快速排序与归并排序
12-26
快速排序和归并排序是两种在计算机科学中广泛使用的排序算法，它们各有特点，适用于不同的场景。在这篇文章中，我们将深入探讨这两种排序方法，包括它们的工作原理、性能分析以及各自的优缺点。 首先，我们来了解...
JavaScript希尔排序、快速排序、归并排序算法
10-22
主要为大家详细介绍了JavaScript希尔排序、快速排序、归并排序算法，感兴趣的朋友可以参考一下
排序算法之快速排序、归并排序
couchpotatoshy的博客
06-05 600
从三大排序方法来初识排序算法
【排序算法】归并排序与快速排序：深入解析与比较
最新发布
Ricky的博客
01-03 2396
无论是在数据库操作中的数据检索，还是在高效算法的设计中，良好的排序机制都能显著提升性能和效率。合并时，从两个数组的起始位置开始比较，选择两者中较小的元素放入结果数组中，然后移动指针，重复此过程，直到所有元素都被合并。分区策略: 快速排序通过选择一个基准元素，然后重新排列数组，使得所有小于基准的元素都移到基准的左边，所有大于基准的元素都移到基准的右边。基准元素的选择: 基准的选择可以多样化，常见的方法包括选择第一个元素、最后一个元素、中间元素，或者随机选择一个元素作为基准。归并排序是一种稳定的排序算法。
归并排序和快速排序
m0_63222000的博客
04-28 616
一般的基本排序方法有冒泡排序，插入排序，选择排序等等，但是这些方法需要的时间复杂度最低也是O（n^2）级别，在我们需要对大数量级的数据处理时，这样的时间复杂度显然不能满足我们对时间上的需求，这里我们简单介绍两种时间复杂度较低的排序方法：归并排序和快速排序。尽管很多编译器，库函数由快速排序的实现，但是学习并理解这两种排序算法的原理更有助于我们在以后的使用和解决问题，同时还有助于我们增长算法的思维活跃度。
归并排序与快速排序
qq_34132502的博客
03-18 924
快速排序与归并排序快速排序1、原理与实现（1）分治法（2）轴点（3）构造轴点——partition算法（4）实例（5）性能分析（6）改进（7）变种选取（selection）k-selection与中位数选取：通用算法众数减而治之linearSelect() 最开始的几章我们分别介绍了冒泡排序，插入排序，选择排序与归并排序。在介绍散列技术时也介绍了桶排序，基数排序，计数排序。在讨论优先级队列时也介绍了堆排序，以及更为常用的锦标赛排序。 归并排序和快速排序都使用了分治法，但二者又有区别。 归并排序的计算量和难点
关于辛普森积分法的研究
yyx2000的博客
05-06 6884
一部分函数的积分是可以通过Newton-Leibniz formula计算的。 然而另一部分就不行，我们就要通过数值积分的方式计算。 我们首先看一下 拉格朗日插值法，有了函数的值，通过拉格朗日插值法就可以计算出函数式。 我们设每个多项式是pj(x)，我们通过构造，得出pj(x)的式子。我们要保证对于pj(x),任取一个i属于Ij，pj(xi)=0且pj(xj)=1; 最后我们就可以推
算法与数据结构：22-排序3.pdf
06-28
"这篇文档主要介绍了快速排序和归并排序这两种重要的排序算法，它们都是由英国计算机科学家Charles Antony Richard Hoare提出的。快速排序是1962年由Hoare首次提出，并因其高效性能而广受欢迎，至今仍然是最常用的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值