（原创）各种排序算法性能分析

[beef9999]

// Beef @ USTC. All rights reserved.
// [e-mail]
// 2011.12.22
// 五种排序算法的性能分析
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <iterator>
#include <time.h>
#include "CalTime.h"
using namespace std;

typedef vector<double> VoD;

int _tmain(int argc, _TCHAR* argv[])
{
	Time *p;
	p=new InsertionTime;
	cout<<MAXIMUM<<"个随机数的插入排序消耗时间为"<<p->cal_time()<<"秒"<<endl;
	p=new MergeTime;
	cout<<MAXIMUM<<"个随机数的合并排序消耗时间为"<<p->cal_time()<<"秒"<<endl;
	p=new QuickTime;
	cout<<MAXIMUM<<"个随机数的快速排序消耗时间为"<<p->cal_time()<<"秒"<<endl;
	p=new BubbleTime;
	cout<<MAXIMUM<<"个随机数的冒泡排序消耗时间为"<<p->cal_time()<<"秒"<<endl;
	p=new BucketTime;
	cout<<MAXIMUM<<"个随机数的桶排序（"<<BUCKET_NUM<<"个桶）消耗时间为"<<p->cal_time()<<"秒"<<endl;
	return 0;
}

// Beef @ USTC. All rights reserved.
// [e-mail]
// 2011.12.22
#ifndef CALTIME_H
#define CALTIME_H
//////////////////////////////////////////////////////////////////////////
#include <vector>
#include <time.h>
#define MAXIMUM 1000
#define BUCKET_NUM	100
using std::vector;
typedef vector<double> VoD;
/*
	时间 基类
*/
class Time
{
public:
	Time();
	double cal_time();		//每个派生类都调用该函数计算时间
	virtual void each_sort(){}	//针对每个算法的虚函数
	void initArray();
protected:
	VoD m_A;
	clock_t start,finish;
};
/*
	插入排序
*/
class InsertionTime: public Time
{
public:
	virtual void each_sort();
protected:
	void insertion_sort(VoD &A);
};
/*
	合并排序
*/
class MergeTime:public Time
{
public:
	virtual void each_sort();
private:
	void merge_sort(VoD &A,int p,int r);
	void merge(VoD &A,int p,int q,int r);
};
/*
	快速排序
*/
class QuickTime:public Time
{
public:
	virtual void each_sort();
private:
	void quick_sort(VoD &A,int p,int r);
	int partition(VoD &A,int p,int r);
};
/*
	冒泡排序
*/
class BubbleTime:public Time
{
public:
	virtual void each_sort();
private:
	void bubble_sort(VoD &A);
};
/*
	桶排序
*/
class BucketTime:public InsertionTime
{
public:
	virtual void each_sort();
private:
	void bucket_sort(VoD &A);
};
//////////////////////////////////////////////////////////////////////////
#endif

[beef9999]

#include "StdAfx.h"
#include "CalTime.h"
#include <iostream>
using namespace std;
//////////////////////////////////////////////////////////////////////////
Time::Time()
{
	initArray();
}
void Time::initArray()
{
	m_A.reserve(MAXIMUM);
	for (int i=0;i!=MAXIMUM;++i)
		m_A.push_back(rand()/double(RAND_MAX));
}
double Time::cal_time()
{
	start=clock();
	each_sort();
	finish=clock();
	double total=(finish-start)/double(CLOCKS_PER_SEC);
	return total;
}
//////////////////////////////////////////////////////////////////////////
void InsertionTime::insertion_sort(VoD &A)
{
	for (int j=1;j!=A.size();++j)
	{
		double key=A[j];
		int i=j-1;
		while (i>=0&&A[i]>key)
		{
			A[i+1]=A[i];
			--i;
		}
		A[i+1]=key;
	}
}
void InsertionTime::each_sort()
{
	insertion_sort(m_A);
}
//////////////////////////////////////////////////////////////////////////
void MergeTime::merge_sort(VoD &A,int p,int r)
{
	if (p<r)
	{
		int q=(p+r)/2;	//默认取整
		merge_sort(A,p,q);
		merge_sort(A,q+1,r);
		merge(A,p,q,r);
	}
}
void MergeTime::merge(VoD &A,int p,int q,int r)
{
	int n1=q-p+1;
	int n2=r-q;
	int i,j;
	VoD leftArray,rightArray;
	for(i=0;i!=n1;++i)
		leftArray.push_back(A[p+i]);
	for(j=0;j!=n2;++j)
		rightArray.push_back(A[q+j+1]);
	leftArray.push_back(MAXIMUM+1);
	rightArray.push_back(MAXIMUM+1);
	i=j=0;
	for(int k=p;k!=r+1;++k)
	{
		if(leftArray[i]<=rightArray[j])
		{
			A[k] = leftArray[i]; 
			++i;
		}
		else
		{
			A[k] = rightArray[j];
			++j;
		}
	}	
}
void MergeTime::each_sort()
{
	merge_sort(m_A,0,m_A.size()-1);
}
//////////////////////////////////////////////////////////////////////////
void QuickTime::quick_sort(VoD &A,int p,int r)
{
	int q=0;
	if(p<r)
	{
		q=partition(A,p,r);
		quick_sort(A,p,q-1);
		quick_sort(A,q+1,r);
	}
}
int QuickTime::partition(VoD &A,int p,int r)
{
	double x=A[r];
	double temp=0;
	int	i=p-1;
	for(int j=p;j!=r;++j)
	{  
		if(A[j]<=x)
		{    
			++i;
			temp=A[i];
			A[i]=A[j];
			A[j]=temp;
		}
	}
	temp=A[i+1];
	A[i+1]=A[r];
	A[r]=temp;
	return i+1;
}
void QuickTime::each_sort()
{
	quick_sort(m_A,0,m_A.size()-1);
}
//////////////////////////////////////////////////////////////////////////
void BubbleTime::bubble_sort(VoD &A)
{
	double temp=0;
	int i,j;
	for(i=0;i!=A.size()-1;++i)
	{
		for(j=0;j!=A.size()-i-1;++j)
		{
			if(A[j]>A[j+1])
			{
				temp=A[j];
				A[j]=A[j+1];
				A[j+1]=temp;
			}
		}	
	}
}
void BubbleTime::each_sort()
{
	bubble_sort(m_A);
}
//////////////////////////////////////////////////////////////////////////
void BucketTime::bucket_sort(VoD &A)
{
	vector<VoD> B(BUCKET_NUM,0); 
	for (int i=0;i!=A.size();++i)		//放入桶中
	{
		int var=static_cast<int>(BUCKET_NUM*A[i]/1);
		B[var].push_back(A[i]);
	}
	A.clear();
	for (int i=0;i!=B.size();++i)
	{
		if (B[i].empty())
			continue;
		insertion_sort(B[i]);			//对每个桶调用快速排序
		for (VoD::const_iterator iter=B[i].begin();iter!=B[i].end();++iter)
			A.push_back(*iter);			//将排序好的桶里的链表重新加入A
	}
}
void BucketTime::each_sort()
{
	bucket_sort(m_A);
}

[oxwuag]

1.C++少用define,多用const
2.不推荐用vector实现排序，vector的operator[]等函数调用入栈出栈的需要时间，影响性能
3.桶排序用的是插入排序，注释错了 :)
4.作为一个完整的程序来讲，new的对象，要对其释放
5.构造函数，最佳写法是member initialization list形式

[beef9999]

插入、合并、快速、冒泡、桶排序性能分析
每一句都是最标准的C++代码，充分运用面向对象的设计理念，整体结构紧凑富有逻辑性。
具体算法严格参照《算法导论》第四版
vs2010下可以正常运行
其他环境下，请自行建立工程，并拷贝sorts目录下sorts.cpp CalTime.h CalTime.cpp的内容

[oxwuag]

空杯理论。。。

[iamnobody]

[Quote=引用 4 楼 oxwuag 的回复:]
空杯理论。。。
[/Quote]

楼主写了这么多代码是精神可嘉的.
而且背理论也是必须的.是前提.

但是算法导论上应该有说明这些排序算法的复杂度,没有必要进行所谓的测试,就像之前老是写一些JAVA和C++的代码来说明JAVA比C++快的行为那样...

楼主说的每个算法都有他们擅长的数据环境,这种测试是没有意义的..

你比较一下在大数据量的情况下,你写的算法的速度和std::sort的速度就知道一种单纯的排序算法是多么的有限了..