八种排序算法效率比较

最新推荐文章于 2024-01-01 00:15:00 发布
最新推荐文章于 2024-01-01 00:15:00 发布
阅读量1.2w 收藏 10
点赞数 4
分类专栏： 算法

http://terence2008.info/archives/sorting_compare.html

  从刚上大一那会儿学的C语言开始，就已经接触到了不少排序算法，但当时都只是为了完成简单的排序任务而已，而且所给的数据也不够多，所以看不出各个排序算法间的执行效率的优劣。最近有个数据结构课程设计的实验，是有关于排序算法之间的效率比较，我就顺便把它放上来了，并对各个算法执行的效率时间做了柱形统计图表。此次实验主要测试了8种排序算法：插入排序、快速排序、冒泡排序、希尔排序、简单选择排序、堆排序、归并排序、折半插入排序。

      总共建立了三种情况，分别是平均排序、最好情况排序、最坏情况排序。第一种情况就是使用了VC6.0下的随机数生成函数输出100000个随机数进行排序；第二种情况是100000个数本身已经按从小到大的顺序排列了；第三种情况就是100000个数全部是按逆序排列。代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<windows.h>
#define MAX 100000
 
void InsSort(int r[],int length)
{
	int i,j;
	for (i=2;i<=length;i++)
	{
		r[0]=r[i];
		j=i-1;
		while(r[0]<r[j])
		{
			r[j+1]=r[j];
			j=j-1;
		}
		r[j+1]=r[0];
	}
}       //插入排序
 
void swap(int &x,int &y)
{
	int z;
	z=x;
	x=y;
	y=z;
}
int median3(int a[],int left,int right)
{
	int center=(left+right)/2;
	if(a[left]>a[center])
		swap(a[left],a[center]);
	if(a[left]>a[right])
		swap(a[left],a[right]);
	if(a[center]>a[right])
		swap(a[center],a[right]);
	swap(a[center],a[right-1]);
	return a[right-1];
}
void insertionsort(int a[],int n)
{
	int j,p;
	int tmp;
	for(p=1;p<=n;p++)
	{
		tmp=a[p];
		for(j=p;j>0&&a[j-1]>tmp;j--)
			a[j]=a[j-1];
		a[j]=tmp;
	}
}
void qsort(int a[],int left,int right)
{
	int i,j;
	int pivot;
	if(left+2<=right)
	{
		pivot=median3(a,left,right);
		i=left;j=right-1;
		for(;;)
		{
			while(a[++i]<pivot){}
			while(a[--j]>pivot){}
			if(i<j)
				swap(a[i],a[j]);
			else
				break;
		}
		swap(a[i],a[right-1]);
		qsort(a,left,i-1);
		qsort(a,i+1,right);
	}
	else
		insertionsort(a+left,right-left+1);
}
void quicksort(int a[],int n)
{
	qsort(a,0,n-1);
}      //快速排序
 
void BubbleSort(int r[],int length)
{
	int i,j,temp;
	for(j=length;j>0;j--)
		for(i=0;i<j-1;i++)
			if(r[i]>r[i+1])
			{
				temp=r[i];
				r[i]=r[i+1];
				r[i+1]=temp;
			}
}      //冒泡排序
 
void ShellInsert(int r[],int length,int delta)
{
	int i,j;
	for(i=1+delta;i<=length;i++)
		if(r[i]<r[i-delta])
		{
			r[0]=r[i];
			for(j=i-delta;j>0&&r[0]<r[j];j-=delta)
				r[j+delta]=r[j];
			r[j+delta]=r[0];
		}
}
void  ShellSort(int r[], int length, int delt[], int n)
{ 
	int i;
	for(i=0;i<=n-1;++i)
		ShellInsert(r,length,delt[i]);
}       //希尔排序
 
void SelectSort(int r[],int length)
{
	int i,j,k;
	int n;
	int x;
    n=length;
	for (i=1;i<=n-1;++i)
	{
		k=i;
		for(j=i+1;j<=n;++j)
			if(r[j]<r[k])
				k=j;
			if( k!=i)
			{
				x= r[i];
				r[i]=r[k];
				r[k]=x;
			}
	}
 
}        //简单选择排序
 
void sift(int r[],int k,int m)
{
	int t;
	int i,j;
	int x;
	int finished;
	t= r[k];
	x=r[k];
	i=k;
	j=2*i;
	finished=FALSE;
	while(j<=m&&!finished)
	{     
		if(j<m&&r[j]< r[j+1])
			j=j+1;
		if(x>=r[j])
			finished=TRUE;
		else 
		{
			r[i]=r[j];
			i=j;
			j=2*i;
		}
	}
	r[i] =t;
}
void crt_heap(int r[], int length)
{
	int i,n;
    n=length;
	for (i=n/2;i>=1;--i) 
		sift(r,i,n);
}
void HeapSort(int r[],int length)
{
	int i,n;
	int b;
	crt_heap(r,length);
	n= length;
	for (i=n;i>=2;--i)
	{
		b=r[1];
		r[1]=r[i];
		r[i]=b;
		sift(r,1,i-1);
	}
}       //堆排序
 
void merge(int a[],int tmparray[],int lpos,int rpos,int rightend)
{
	int i,leftend,numelements,tmppos;
	leftend=rpos-1;
	tmppos=lpos;
	numelements=rightend-lpos+1;
	while(lpos<=leftend && rpos<=rightend)
		if(a[lpos]<=a[rpos])
			tmparray[tmppos++]=a[lpos++];
		else
			tmparray[tmppos++]=a[rpos++];
		while(lpos<=leftend)
			tmparray[tmppos++]=a[lpos++];
		while(rpos<=rightend)
			tmparray[tmppos++]=a[rpos++];
		for(i=0;i<numelements;i++,rightend--)
			a[rightend]=tmparray[rightend];
}
void msort(int a[],int tmparray[],int left,int right)
{
	int center;
	if(left<right)
	{
		center=(left+right)/2;
		msort(a,tmparray,left,center);
		msort(a,tmparray,center+1,right);
		merge(a,tmparray,left,center+1,right);
	}
}
void mergesort(int a[],int n)
{
	int *tmparray;
	tmparray=(int*)malloc(n*sizeof(int));
	if(tmparray!=NULL)
	{
		msort(a,tmparray,0,n-1);
		free(tmparray);
	}
	else
		printf("no space for tmp array!");
}        //归并排序
 
void BInsertSort(int num[],int n)
{
	int length=n;
	int low,high,i,j,m;
	for(i=2;i<=length;i++)
	{
	   num[0]=num[i];
	   low=1;
	   high=i-1;
	   while(low<=high)
	   {
		   m=(low+high)/2;
			if(num[0]<num[m])
				high=m-1;
			else
				low=m+1;
	   }
	   for(j=i-1;j>=high+1;j--)
		   num[j+1]=num[j];
	   num[high+1]=num[0];
	}
}        //折半插入排序
 
void main()
{
	long dwStart,dwStop,runtime;
	int num[MAX],a[MAX],i,j;
	dwStart=GetTickCount();
	srand((unsigned)time(NULL));
	for(i=0;i<MAX;i++)
		num[i]=rand();	
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("生成%d个随机数运行了%ldms\n\n",MAX,runtime);
 
	printf("********平均排序时间********\n");
	for(i=0;i<MAX;i++)
		a[i]=num[i];
	dwStart=GetTickCount();
	InsSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用插入排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=num[i];
	dwStart=GetTickCount();
	quicksort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用快速排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=num[i];
	dwStart=GetTickCount();
	BubbleSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用冒泡排序运行了%ldms\n",runtime);
 
	int delt[10]={100,80,60,40,20,10,5,3,2,1};
	for(i=0;i<MAX;i++)
		a[i]=num[i];
	dwStart=GetTickCount();
	ShellSort(a,MAX,delt,10);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用希尔排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=num[i];
	dwStart=GetTickCount();
	SelectSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用简单选择排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=num[i];
	dwStart=GetTickCount();
	HeapSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用堆排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=num[i];
	dwStart=GetTickCount();
	mergesort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用归并排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=num[i];
	dwStart=GetTickCount();
	BInsertSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用折半插入排序运行了%ldms\n",runtime);
	printf("****************************\n\n");
 
	printf("******最好情况排序时间******\n");
	for(i=0;i<MAX;i++)
		a[i]=i;
	dwStart=GetTickCount();
	InsSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用插入排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=i;
	dwStart=GetTickCount();
	quicksort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用快速排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=i;
	dwStart=GetTickCount();
	BubbleSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用冒泡排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=i;
	dwStart=GetTickCount();
	ShellSort(a,MAX,delt,10);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用希尔排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=i;
	dwStart=GetTickCount();
	SelectSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用简单选择排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=i;
	dwStart=GetTickCount();
	HeapSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用堆排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=i;
	dwStart=GetTickCount();
	mergesort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用归并排序运行了%ldms\n",runtime);
 
	for(i=0;i<MAX;i++)
		a[i]=i;
	dwStart=GetTickCount();
	BInsertSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用折半插入排序运行了%ldms\n",runtime);
	printf("****************************\n\n");
 
	printf("******最坏情况排序时间******\n");
	for(i=MAX-1,j=0;i<=0,j<MAX;i--,j++)
		a[j]=i;
	dwStart=GetTickCount();
	InsSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用插入排序运行了%ldms\n",runtime);
 
	for(i=MAX-1,j=0;i<=0,j<MAX;i--,j++)
		a[j]=i;
	dwStart=GetTickCount();
	quicksort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用快速排序运行了%ldms\n",runtime);
 
	for(i=MAX-1,j=0;i<=0,j<MAX;i--,j++)
		a[j]=i;
	dwStart=GetTickCount();
	BubbleSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用冒泡排序运行了%ldms\n",runtime);
 
	for(i=MAX-1,j=0;i<=0,j<MAX;i--,j++)
		a[j]=i;
	dwStart=GetTickCount();
	ShellSort(a,MAX,delt,10);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用希尔排序运行了%ldms\n",runtime);
 
	for(i=MAX-1,j=0;i<=0,j<MAX;i--,j++)
		a[j]=i;
	dwStart=GetTickCount();
	SelectSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用简单选择排序运行了%ldms\n",runtime);
 
	for(i=MAX-1,j=0;i<=0,j<MAX;i--,j++)
		a[j]=i;
	dwStart=GetTickCount();
	HeapSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用堆排序运行了%ldms\n",runtime);
 
	for(i=MAX-1,j=0;i<=0,j<MAX;i--,j++)
		a[j]=i;
	dwStart=GetTickCount();
	mergesort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用归并排序运行了%ldms\n",runtime);
 
	for(i=MAX-1,j=0;i<=0,j<MAX;i--,j++)
		a[j]=i;
	dwStart=GetTickCount();
	BInsertSort(a,MAX);
	dwStop=GetTickCount();
	runtime=dwStop-dwStart;
	printf("使用折半插入排序运行了%ldms\n",runtime);
	printf("****************************\n");
 
	printf("\n排序测试完成！");
	getchar();
}

      执行程序是个很漫长的过程，像对于冒泡排序之类的算法，十万个数的排序再好的机器也得算上半天，不过像快速排序之类的算法如果不给予足够多的数据的话，执行时间永远是0毫秒。所以为了测算精确和公平比较，时间长我就慢慢熬吧。。。以下是我用执行完后的结果做成的统计图表（ps：图表中的数据是我在学院机器上的结果，在自己电脑上时间肯定会少许多，就懒得再算一遍了，反正情况都一样~~）：

      结果很明显，快速排序、堆排序、归并排序这三种执行效率最快，不过话说回来，冒泡排序的代码真的是最好写的！看来算法高效代码复杂与算法低下代码简单是个很辩证的关系啊！
MOKA
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
面试：聊一聊 Java 数组默认的排序算法，我懵了
wadfdhsajd的博客
07-05 934
之前一直没关注过Java底层排序的算法，才仔细看了下Timsort。Timsort 是一个混合、稳定的排序算法，简单来说就是归并排序和二分插入排序算法的混合体，号称世界上最好的排序算法。它由 Tim Peters 在 2002 年提出并实现，一直是 Python 的标准排序算法。Java 在 1.7 后增加了 Timsort API ，从Java中的 可以看出它是默认的排序算法，主要用于非原始类型数组排序。所以不管是进阶编程还是面试，理解 Timsort 都是比较重要。 前置知识 理解 Timsort
7种排序算法的效率比较
12-07
算法课的一个小项目，语言python。代码实习7种排序算法，TK实现简单GUI，源码可以学习7中排序算法详细实现，和GUI的搭建，基本包含了常用GUI组件。
交换排序算法之快速排序-C语言版（带图详细）
小陈没烦恼
04-03 3474
快速排序算法是在几种排序算法中效率最高的一个排序算法了，故称为快速排序，它的时间复杂度为：O(nlog2n)，相比冒泡排序算法的O(n2)有很大的提升。
各种排序不同数据情况下性能比较（冒泡、插入、选择、希尔、归并、堆排、快排、基数排序）
m0_63494135的博客
06-20 2756
各种排序随打
java 快速排序_JAVA面试题：5分钟了解快速排序
weixin_39958248的博客
12-02 260
前言快速排序是面试中经常会问到的一种排序算法，对比其他一些排序算法，快速排序的平均时间相对较少。快速排序思想介绍快速排序使用了分治的思想，通过一轮的排序，可以将序列分割成独立的两个部分，其中一部分的值均比基准值小，另一部分的值均比基准值大。而后针对两部分序列再分别按照同样的算法进行排序，直到序列整体有序。以如下序列arr为例进行升序排序，说明快速排序的基本算法第一个位置的值23作为基准值base，...
十大排序算法——排序算法效率比较——选择排序、冒泡排序、选择排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序
最新发布
weixin_43981402的博客
01-01 518
一次性解决十大排序算法。
Java 八种排序算法比较实践
05-31
本文将深入探讨Java中的八种常见排序算法，并通过实践分析它们的性能、稳定性和适用场景。这八种排序算法包括：冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序、希尔排序和计数排序。 1. 冒泡排序...
c语言编程的几种排序算法比较
08-15
【C语言编程的几种排序算法比较】 排序算法是计算机科学中的基础内容，广泛应用于各种数据处理和信息组织。由于在实际应用中往往需要处理大量数据，因此，排序算法的效率至关重要。衡量算法效率的主要标准是算法的...
java常见八种排序算法
06-29
计数排序是一种非基于比较的排序算法，适用于整数排序。它统计每个输入元素出现的次数，然后根据这些计数确定输出的顺序。计数排序的时间复杂度为O(n+k)，其中k为整数范围，但其不能处理负数和浮点数。 以上就是...
java排序算法效率比较
04-27
本实验通过生成大量随机数并写入文件，然后使用四种不同的排序算法进行排序，以比较它们的效率。以下是对这四种排序算法的详细解释： 1. **冒泡排序（Bubble Sort）** 冒泡排序是最基础的排序算法之一，它通过重复...
各种排序算法的实现及性能比较
04-27
各种排序算法源代码,各种排序算法性能比较:直接插入排序,希尔排序,冒泡排序,快速排序,简单选择排序,堆排序,二路归并排序,STL排序算法
最快的排序算法是什么
热门推荐
温故而知新
09-26 1万+
最快的排序算法是什么，很多人的第一反应是快排，感觉QuickSort 当然应该最快了，其实并非如此，快排是不稳定的，最坏情况下，快排序并不是最优，Java7 中引入的 TimSort 就是一个结合了插入排序和归并排序的高效算法. Timsort最早是 Tim Peters 于2001年为 Python 写的排序算法。自从发明该算法以来，它已被用作Python，Java，Android平台和GNU ...
快速排序/二分法
m0_46088512的博客
09-16 113
// 快速排序 function qs(array) { // 7. 设置结束条件 if (array.length <= 1) { return array; } // 1. 找下标 var ind = Math.floor(array.length / 2); // 2. 存值 var val = array[ind]; // console.log(val); // 3. 删除中间值 array.s.
数据结构（九）高级排序算法——四种高级排序算法的效率比较
在路上
07-11 2470
上面我们已经学习的4种高级排序算法：归并排序、快速排序、堆排序和桶排序。 归并、快速排序 堆排序、桶排序 下面我们通过一个实验案例来进行上述4种排序算法效率的直观比较。 实验内容：创建4个具有相同初始化长度、初始化元素内容和元素顺序的，长度为100000的正整数数组，数组中填充的全部都是取值范围在[0,100000]之间的随机正整数，并且为了消除数据之间差异导致排序效果上带来的影响，我们选...
几个效率高的排序算法
11-25 4516
<br />实用排序算法（复杂度小于等于O(n^2)）中效率最低但实现并不是最简单的的两个，C、C++教材却总喜欢拿来大讲特讲，非常不利于初学者养成“程序效率”的思维。<br /><br />实际上，各种排序算法里，除了堆排序实现较为复杂外，从代码量的角度，大多数算法都不比冒泡、选择算法复杂多少。<br /><br />举几个高速的排序算法的例子，这些才适合进入教材<br /><br />鸽巢排序，排序字节串、宽字节串最快的排序算法，计数排序的变种（将计数缓冲区大小固定，少一次遍历开销），速度是STL中st
C++ 常见排序-冒泡排序，堆排序，快速排序，选择排序
小鸟在飞想的专栏
08-04 181
#include<iostream> using namespace std; //选择排序，复杂度o（n^2）,不稳定 template<typename T> //定义函数模板，int，double，float都可以 void seletion_sort(vector<T> &arr) { for (int i = 0; i < ar...
算法基础——冒泡排序/快速排序/堆排序
luckyxiev5的博客
05-12 325
1.数据结构 2.排序算法 3.基础算法题
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值