#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),由冯诺依曼提出
实际上是采用分治思想而提出的一种高效率排序方法。其原理是先将待排序数组分解,然后
进行合并。即三个步骤:一、分解(devide),二、处理(conquer),三、合并(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;
}