几种算法的比较

 

#include<iostream>
#include<ctime>
#include<cstdlib>
#include<sys/time.h>
#define SIZE 1024*100

enum SortType
{
BUBBLESORT,
INSERTSORT,
MERGESORT,
FASTSORT
};

class SortAlgorithm
{
private:
	SortType sortType;
	int* data;//向堆空间申请内存，存放待排序数据，这里不能是栈数据，由于待排数据量大于8Mb//
	struct timeval startTime;
	struct timeval endTime;
public:
	SortAlgorithm(){
	  srand(time(NULL));
	  this->data=new int[SIZE];
	  for(int i=0;i<SIZE;i++){  //随机化待排数据
		data[i]=rand()%SIZE;
	  }
	}
	~SortAlgorithm(){
	  delete [] data;//释放内存
	}
public:
	void disData();
	void sortData(SortType);
public:
	void bubbleSort();//冒泡排序
	void insertSort(int);//插入排序
	void mergeSort(int,int); //归并排序
	void fastSort(int,int);  //快速排序
public:
	void runSort();   //开始排序 
private:
	void swap(int&,int&); //交换两个数
	void merge(int,int,int);//归并数组，供归并排序调用
};

void SortAlgorithm::swap(int& a,int& b)
{
	int tmp=a;
	a=b;
	b=tmp;
}

void SortAlgorithm::merge(int start,int mid,int end)
{
	int i=start;
	int j=mid+1;
	int k=start;
	int* tmp=new int[SIZE];
	while(i!=mid+1&&j!=end+1){
		if(data[i]<=data[j]){
			tmp[k++]=data[i++];
		}
		else{
			tmp[k++]=data[j++];
		}
	}

	while(i!=mid+1){
		tmp[k++]=data[i++];
	}

	while(j!=end+1){
		tmp[k++]=data[j++];
	}

	for(int n=start;n!=end+1;n++){
		data[n]=tmp[n];
	}

	delete [] tmp;
}
void SortAlgorithm::sortData(SortType st)
{
	this->sortType=st;
}

/*
冒泡排序属于原址排序，时间复杂度为O(N^2)，空间复杂度为O(1)，是一种稳定的排序算法
基本原理是进行N趟比较，分别比较相邻两个数值的大小，知足条件则交换两个数(视排序顺序
而定)，每执行一趟比较一定使得相对最大数(最小数)被转移至相对最顶端，所以N趟以后排序
完成
*/
void SortAlgorithm::bubbleSort()
{
	for(int i=0;i<SIZE;i++){// 一共须要执行SIZE趟才能所有排序彻底
		for(int j=0;j<SIZE-i-1;j++){
			if(data[j]>=data[j+1]){  // 从小到大排序
				swap(data[j],data[j+1]);
			}
		}
	}
}

/*
插入排序是一种稳定排序，时间复杂度为O(N^2)，空间复杂度为O(1)，分红直接插入排序和二分
插入排序两种。直接插入排序和冒泡排序在本质上是相同的，只是出发点和想法不同罢了。首先
假定数组第一个数已是排序完成，从第二个数开始依次进行比较，直到找到小于(大于)某个数的
位置则插入，不然依次日后移。
*/
void SortAlgorithm::insertSort(int size)
{
	int	tmp;
	int i;
	int j;
	for(i=1;i<size;i++){
		tmp=data[i];
		for(j=i;j>0&&(tmp<data[j-1]);j--){
			data[j]=data[j-1];
		}
		data[j]=tmp;
	}
}

/*
归并排序是一种稳定排序，时间复杂度为O(NlgN)，空间复杂度为O(N)，由冯诺依曼提出
其实是采用分治思想而提出的一种高效率排序方法。其原理是先将待排序数组分解，而后
进行合并。即三个步骤：1、分解(devide)，2、处理(conquer)，3、合并(combine)
*/
void SortAlgorithm::mergeSort(int low,int high)
{
	int midNum=(low+high)/2;
	if(low<high){
		mergeSort(low,midNum);
		mergeSort(midNum+1,high);
		merge(low,midNum,high);
	}
}
/*
快速排序是一种不稳定排序方法，最差的状况是时间复杂度为O(N^2)，指望时间复杂度为O(NlgN)
属于原址排序，即空间复杂度为O(1)。经过一趟排序将要排序的数据分割成独立的两部分，其中
一部分的全部数据都比另一部分的全部数据都要小，而后再按此方法对这两部分数据分别进行
快速排序，整个排序过程能够递归进行，以此达到整个数据变成有序序列。
*/
void SortAlgorithm::fastSort(int low,int high)
{
	if(low>=high)	//若是搜索完成则返回
		return;
	
	int right=high;
	int left =low;
	int keyVal=this->data[high];  // 设置标志位，凡是大于标志位的放右边，不然放左边，视顺序而定

	while(left<right){ //保证在子数组内
		while(left<right&&this->data[left]<=keyVal){
			left++;
		}
		this->data[right]=this->data[left];

		while(left<right&&this->data[right]>=keyVal){
			right--;
		}
		this->data[left]=this->data[right];
	}
		this->data[right]=keyVal;
		fastSort(low,left-1);
		fastSort(left+1,high);
}

void SortAlgorithm::runSort()
{
	switch(sortType){
		case BUBBLESORT: bubbleSort();			break;
		case INSERTSORT: insertSort(SIZE);		break;
		case MERGESORT : mergeSort(0,SIZE-1) ;	break;
		case FASTSORT  : fastSort(0,SIZE-1);	break;
		default: throw "not select the sort type yet";
	}
return;
}

void SortAlgorithm::disData()
{
	int cnt=0;
	for(int i=0;i<SIZE;i++){
		std::cout<<data[i]<<' ';
		cnt++;
		if(cnt%20==0)std::endl(std::cout);
	}
}
int main()
{
	SortAlgorithm sortTest;
	sortTest.sortData(MERGESORT);
	sortTest.runSort();
	sortTest.disData();
	getchar();
return 0;
}