冒泡排序和快速排序耗时比较(时间复杂度的理想与现实)

本文通过两组实验对比了冒泡排序与快速排序的效率。第一组实验进行了10000次操作,每次生成长度为100的随机数组;第二组实验进行了100次操作,每次生成长度为10000的随机数组。同时讨论了实际运行时间和理论时间复杂度之间的差异。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一个简单的题:

测试一:做10000次操作,每次随机产生一个100的数组。比较冒泡和快排的时间效率。

测试二:做100次操作,每次随机产生一个10000的数组。比较冒泡和快排的时间效率。

代码:

#include <iostream>
#include<cstdio>
#include<algorithm>//swap()函数需要
#include<ctime>//time()需要
#include<cstdlib>//rand()和srand()需要
//#include<bits/stdc++.h>//这个头文件或者上面所有头文件。不过这个不是跨平台的
using namespace std;
const int maxn=10000+10,maxa=10000,maxb=100,maxx=0xffffff;
int a[maxn];
double random()
{
    return (double)rand()/RAND_MAX;//生成[0,1]之间的均匀随机数
}
int random(int m)
{
    return (int)((m-1)*random()+0.5);//生成[0,m-1]之间的均匀随机数
}
//冒泡排序
void BubbleSort(int a[],int n)
{
       int i,j;
       for(i=0;i<n;i++)
              for(j=1;j<n-i;j++)
                     if(a[j-1]>a[j])
                            swap(a[j-1],a[j]);
}
//快速排序
void quick_sort(int a[],int l,int r)
{
    if (l<r)
    {
//swap(a[l],a[(l+r)/2]); //将中间的这个数和第一个数交换 
        int i=l,j=r,x=a[l];
        while(i<j)
        {
            while(i<j&&a[j]>=x) // 从右向左找第一个小于x的数
j--;
            if(i<j)
a[i++]=a[j];
            while(i<j&&a[i]<x) // 从左向右找第一个大于等于x的数
i++;
            if(i<j)
a[j--]=a[i];
        }
        a[i]=x;
        quick_sort(a,l,i-1); // 递归调用
        quick_sort(a,i+1,r);
    }
}


int main()
{
    int t,i,j;
    double t1,t2,t3,t4;
    char c;
    srand(time(NULL));//初始化随机数种子
//    printf("是否继续:y/n\n");
//    scanf("%c",&c);
//    while(c=='y'||c=='Y')
//    {
        printf("choose test (1  2)\n");
        scanf("%d",&t);
    if(t==1)
    {
        printf("下面进行冒泡排序:\n");
        t1=time(0);//time(a)函数的用法:百度之。将当前时间存储在地址a中。取0或者null就是放弃地址。
        for(i=0;i<maxa;i++)
        {
            for(j=0;j<maxb;j++)
            a[j]=random(maxx);
            BubbleSort(a,maxb);
            for(j=0;j<maxb;j++)
            printf("%d\n",a[j]);
        }
        t2=time(0);
//        printf("冒泡排序耗时t=%lf\n",t2-t1);
       // getchar();
        t3=time(0);
         for(i=0;i<maxa;i++)
        {
            for(j=0;j<maxb;j++)
            a[j]=random(maxx);
            quick_sort(a,0,maxb);
            for(j=0;j<maxb;j++)
            printf("%d\n",a[j]);
        }
        t4=time(0);
        printf("冒泡排序耗时t=%lf\n",t2-t1);
        printf("快速排序耗时t=%lf\n",t4-t3);
    }
    if(t==2)
    {
        printf("下面进行冒泡排序:\n");
        t1=time(0);
        for(i=0;i<maxb;i++)
        {
            for(j=0;j<maxa;j++)
            a[j]=random(maxx);
            BubbleSort(a,maxa);
            for(j=0;j<maxa;j++)
            printf("%d\n",a[j]);
        }
        t2=time(0);
//        printf("冒泡排序耗时t=%lf\n",t2-t1);
        t3=time(0);
         for(i=0;i<maxb;i++)
        {
            for(j=0;j<maxa;j++)
            a[j]=random(maxx);
            quick_sort(a,0,maxa);
            for(j=0;j<maxa;j++)
            printf("%d\n",a[j]);
        }
        t4=time(0);
        printf("冒泡排序耗时t=%lf\n",t2-t1);
        printf("快速排序耗时t=%lf\n",t4-t3);
    }
//    printf("是否继续:y/n\n");
//    scanf("%c",&c);
//    }
    return 0;
}





附上测试结果:

测试一:冒泡:170s;快排:186s。

测试二:冒泡:272s;快排:203s。



估计结果:(时间复杂度)

测试一:冒泡:10^4*100*100=1s;快排:10^4*100*log100=0.01s-0.1s;

测试二:冒泡:100*10^4*10^4=100s;快排:100*10^4*log10^4=0.1s;




至于ACM,很多时候只是做题和出题经验吧。渐进时间复杂度,是从算法讲的。而实际可能相差几百倍甚至更多。因为对机器的依赖,对具体程序的依赖。等等因素吧。




ps:

百度里有个孩纸这样问:为何我的这个程序输出的时间每次都是一样的?

#include <iostream>
#include<stdlib.h>
#include<time.h>
using namespace std;
int main()
{
    double a;
 a=time(NULL);
 cout<<"a="<<a<<endl;
}


//

time() returns the time since the Epoch (00:00:00 UTC, January 1, 1970), measured in seconds。看来只有做差值才有意义,因为那个时间距现在太远了,也就是每次输出都一样啦。呵呵,我猜的。



ps2:

快排网址:http://blog.youkuaiyun.com/morewindows/article/details/6684558

冒泡网址:http://blog.youkuaiyun.com/morewindows/article/details/6657829

### C++中快速排序冒泡排序插入排序的时间复杂度 #### 快速排序 快速排序是一种基于分治策略的高效排序算法。其平均情况下的时间复杂度为 \(O(n \log n)\),这得益于每次分割操作能够大致均匀地将数组分为两部分[^2]。 然而,在最坏的情况下,当输入数据已经是有序或逆序排列时,快速排序可能会退化至线性平方级别的时间消耗,即 \(O(n^2)\)。为了避免这种情况的发生,通常建议在执行快速排序之前先对序列进行随机打乱处理。 ```cpp void quickSort(int arr[], int low, int high) { if (low < high) { // pi is partitioning index, arr[p] is now at right place int pi = partition(arr, low, high); // Separately sort elements before and after partition quickSort(arr, low, pi - 1); quickSort(arr, pi + 1, high); } } ``` #### 冒泡排序 对于冒泡排序而言,无论是正向还是反向实施,该方法都需要遍历整个列表多次来完成全部元素间的比较交换工作。因此,无论是在最佳情形还是最差状况下,它的总运行时间为 \(O(n^2)\)[^3]。 具体来说,如果待排序列完全无序,则需经历最多可达 \(N\) 趟完整的扫描过程;而在每一趟内部又会涉及大约 \(N-i\) 对相邻项之间的对比动作(其中 i 表示当前轮次编号),从而使得整体计算量呈现出二次方增长的趋势。 ```cpp void bubbleSort(int arr[], int n) { bool swapped; for (int i = 0; i < n - 1; ++i) { swapped = false; for (int j = 0; j < n - i - 1; ++j) { if (arr[j] > arr[j + 1]) { std::swap(arr[j], arr[j + 1]); swapped = true; } } // If no two elements were swapped by inner loop, // then break as the array has been sorted. if (!swapped) break; } } ``` #### 插入排序 插入排序同样属于简单直观的一类内省式排序技术之一。它的工作原理类似于人们整理手中扑克牌的过程:从未排序区域取出一张卡片,并将其放置于已排序区间内的恰当位置之上。尽管这种做法看似效率低下,但在面对几乎已经排好序的数据集时却能展现出较好的性能表现——此时接近线性的渐近行为使其成为某些特定应用场景中的理想选择[^5]。 不过就一般意义上来讲,由于需要频繁地向前查找合适的位置以及随之而来的大量移位操作,故此算法的整体耗时依然维持在一个较高的水平线上,即 \(O(n^2)\)。 ```cpp void insertionSort(int arr[], int n) { for (int i = 1; i < n; ++i) { int key = arr[i]; int j = i - 1; /* Move elements of arr[0..i-1], that are greater than key, to one position ahead of their current position */ while (j >= 0 && arr[j] > key) { arr[j + 1] = arr[j]; j--; } arr[j + 1] = key; } } ```
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值