算法分析与设计---排序
2010年冬天上课，老师留的作业要求课后上机实现排序的算法，现在一年半已经过去了。
#include <iostream>
using namespace std;
#include <stdlib.h>
#include <time.h>
#define random(x)(rand()%(x))
#define N 10000
class timer//单位ms
{
public:
void start()
{
start_t=clock();
}
clock_t time()
{
return (clock()-start_t);
}
private:
clock_t start_t;
};
timer TIMER;
/*--------------------------直接插入排序----------------------*/
void InsertSort(int a[])
{
TIMER.start();
for(int i=1; i<N; i++)
{
int temp=a[i];
int j;
for(j=i; j>0&&temp<a[j-1]; j--)
a[j]=a[j-1];
a[j]=temp;
}
cout<<"\tTimeSpared:"<<TIMER.time()<<"ms"<<endl;
}
/*--------------------------直接插入排序-----------------------*/
/*--------------------------希尔排序---------------------------*/
void ShellSort(int a[])
{
TIMER.start();
for(int gap=N/2; gap; gap=gap/2)
for(int i=gap; i<N; i++)
{
int temp=a[i];
int j;
for(j=i; j>=gap&&temp<a[j-gap]; j-=gap)
a[j]=a[j-gap];
a[j]=temp;
}
cout<<"\tTimeSpared:"<<TIMER.time()<<"ms"<<endl;
}
/*--------------------------希尔排序--------------------------*/
/*--------------------------冒泡排序--------------------------*/
void BubbleSort(int a[])
{
TIMER.start();
//bool exchange=true;
for(int i=1; i<N; i++)
for(int j=N-1; j>=i; j--)
{
//exchange=false;
if(a[j-1]>a[j])
{
swap(a[j-1],a[j]);
//exchange=true;
}
}
cout<<"\tTimeSpared:"<<TIMER.time()<<"ms"<<endl;
}
/*--------------------------冒泡排序--------------------------*/
/*--------------------------快速排序--------------------------*/
int Partition(int a[], int low, int high)
{
//a[0]=a[low];
int pivotkey=a[low];
while(low<high)
{
while(low<high&&a[high]>=pivotkey)
--high;
a[low]=a[high];
while(low<high&&a[low]<=pivotkey)
++low;
a[high]=a[low];
}
//a[low]=a[0];
a[low]=pivotkey;
return low;
}
void QSort(int a[], int low, int high)
{
if(low<high)
{
int pivotloc=Partition(a, low, high);
QSort(a, low, pivotloc-1);
QSort(a, pivotloc+1, high);
}
}
void QuickSort(int a[])
{
TIMER.start();
QSort(a, 0, N-1);
cout<<"\tTimeSpared:"<<TIMER.time()<<"ms"<<endl;
}
/*--------------------------快速排序--------------------------*/
/*------------------------直接选择排序------------------------*/
void SelectSort(int a[])
{
TIMER.start();
for(int i=0; i<N; i++)
{
int j, k;
for(j=i+1, k=i; j<N; j++)
if(a[j]<a[k])
k=j;
if(k!=i)
swap(a[k],a[i]);
}
cout<<"\tTimeSpared:"<<TIMER.time()<<"ms"<<endl;
}
/*------------------------直接选择排序------------------------*/
/*---------------------------堆排序---------------------------*/
void HeapAdjust(int a[], int i, int n)
{
int child=2*i+1;
int temp=a[i];
while(child<n)
{
if(child<n-1&&a[child]<a[child+1])
child++;
if(temp>=a[child])
break;
a[i]=a[child];
i=child;
child=2*i+1;
}
a[i]=temp;
}
void HeapSort(int a[])
{
TIMER.start();
int i;
for(i=(N-2)/2; i>=0; i--)
HeapAdjust(a, i, N);
for(i=N-1; i>0; i--)
{
swap(a[0],a[i]);
HeapAdjust(a, 0, i);
}
cout<<"\tTimeSpared:"<<TIMER.time()<<"ms"<<endl;
}
/*---------------------------堆排序---------------------------*/
/*--------------------------归并排序--------------------------*/
void Merge(int a[], int p, int q, int r)
{
int* temp=(int*)malloc((r-p+1)*sizeof(int));
int begin1, begin2, end1, end2, k;
begin1=p;
end1=q;
begin2=q+1;
end2=r;
k=0;
while((begin1<=end1)&&(begin2<=end2))
{
if(a[begin1]<a[begin2])
{
temp[k]=a[begin1];
begin1++;
}
else
{
temp[k]=a[begin2];
begin2++;
}
k++;
}
while(begin1<=end1)
{
temp[k++]=a[begin1++];
//k++;
//begin1++;
}
while(begin2<=end2)
{
temp[k++]=a[begin2++];
//k++;
//begin2++;
}
for(k=0; k<(r-p+1); k++)
a[p+k]=temp[k];
free(temp);
}
void MSort(int a[], int first, int last)
{
//TIMER.start();
int mid=0;
if(first<last)
{
mid=(first+last)/2;
MSort(a, first, mid);
MSort(a, mid+1, last);
Merge(a, first, mid, last);
}
//cout<<"\tTimeSpared:"<<TIMER.time()<<"ms"<<endl;
}
void MergeSort(int a[])
{
TIMER.start();
MSort(a, 0, N-1);
cout<<"\tTimeSpared:"<<TIMER.time()<<"ms"<<endl;
}
/*--------------------------归并排序--------------------------*/
/*--------------------------基数排序--------------------------*/
/*
void RadixSort(int a[])
{
TIMER.start();
int i, j, k, n, lsd;
int temp[N][N]={0};
int order[N]={0};
n=1;
k=0;
while(n<=10000)//对于随机数怎样确定n的范围取值
{
for(i=0; i<N; i++)
{
lsd=((a[i]/n)%10);
temp[lsd][order[lsd]]=a[i];
order[lsd]++;
}
for(i=0; i<N; i++)
{
if(order[i]!=0)
for(j=0; j<order[i]; j++)
{
a[k]=temp[i][j];
k++;
}
order[i]=0;
}
n*=10;
k=0;
}
cout<<"\tTimeSpared:"<<TIMER.time()<<"ms"<<endl;
}
*/
/*--------------------------基数排序--------------------------*/
int main()
{
int i;
int* ascending=new int[N];//升序序列
int* descending=new int[N];//降序序列
int* randomness=new int[N];//随机序列
for(i=0; i<N; i++)
{
ascending[i]=i;
randomness[i]=i;
descending[i]=N-i-1;
}
for(i=0; i<N; i++)
swap(randomness[i],randomness[random(N)]);
cout<<"-------------直接插入排序-------------"<<endl;
cout<<"Sort ascending N="<<N;InsertSort(ascending);
cout<<"Sort randomness N="<<N;InsertSort(randomness);
cout<<"Sort descending N="<<N;InsertSort(descending);
cout<<"-------------希尔排序-------------"<<endl;
cout<<"Sort ascending N="<<N;ShellSort(ascending);
cout<<"Sort randomness N="<<N;ShellSort(randomness);
cout<<"Sort descending N="<<N;ShellSort(descending);
cout<<"-------------起泡排序-------------"<<endl;
cout<<"Sort ascending N="<<N;BubbleSort(ascending);
cout<<"Sort randomness N="<<N;BubbleSort(randomness);
cout<<"Sort descending N="<<N;BubbleSort(descending);
cout<<"-------------快速排序-------------"<<endl;
cout<<"Sort ascending N="<<N;QuickSort(ascending);
cout<<"Sort randomness N="<<N;QuickSort(randomness);
cout<<"Sort descending N="<<N;QuickSort(descending);
cout<<"-------------直接选择排序-------------"<<endl;
cout<<"Sort ascending N="<<N;SelectSort(ascending);
cout<<"Sort randomness N="<<N;SelectSort(randomness);
cout<<"Sort descending N="<<N;SelectSort(descending);
cout<<"-------------堆排序-------------"<<endl;
cout<<"Sort ascending N="<<N;HeapSort(ascending);
cout<<"Sort randomness N="<<N;HeapSort(randomness);
cout<<"Sort descending N="<<N;HeapSort(descending);
cout<<"-------------归并排序-------------"<<endl;
cout<<"Sort ascending N="<<N;MergeSort(ascending);
cout<<"Sort randomness N="<<N;MergeSort(randomness);
cout<<"Sort descending N="<<N;MergeSort(descending);
/*
cout<<"-------------基数排序-------------"<<endl;
cout<<"Sort ascending N="<<N;RadixSort(ascending);
cout<<"Sort randomness N="<<N;RadixSort(randomness);
cout<<"Sort descending N="<<N;RadixSort(descending);
*/
}