几种常见的排序算法 及代码实现

假设需要排序的数一共有n个

简单选择排序

每次从n个数中选择最小的一个放在还未排序的数的最前面，共n-1次。

- 算法复杂度O(n²)

直接插入排序

每次将待排序的数插入在已排序的数中，共n-1次。

- 算法复杂度：O(n) - O(n²)

冒泡排序

每次比较相邻两个元素的值，如果前者大于后者，则交换。一趟之后，最大的元素沉底。共n-1趟。如果每趟没有发生交换，则说明已经排好。

- 算法复杂度：O(n) - O(n²)

快速排序

假设选择第一个数字为基准数，指针i从前向后移动，指针j从后向前移动。i在移动时指向一个大于基准数的值，j指向一个小于基准数的值，此时，若i<=j时，交换两个指针的值，之后继续移动指针、判断、交换。当i>j时，将j指向的值和基准数交换。

- 算法复杂度：O(nlogn) - O(n²)

#include<iostream>
#include<fstream>
#include<ctime>
#include<stdlib.h>
using namespace std;
#define SIZE  50 //200,000个数据
/*
int time()
{
time_t t0;
time(&t0);
cout<<t0;
return t1-t0;
}*/

void Swap(int &a,int &b)
{
int temp;
temp=a;
a=b;
b=temp;
}

template <class T>
void SelectSort(int A[], int n)
{
int small;
for (int	i=0; i<n-1; i++)
{      							//执行n-1趟
small=i;                        //先假定待排序序列中第一个元素为最小
for (int j=i+1;j<n;j++)         //每趟扫描待排序序列n-i-1次
if (A[j]<A[small]) small=j; //如果扫描到一个比最小值元素还小的，则记下其下标
Swap(A[i],A[small]);            //最小元素与待排序序列中第一个元素交换
}
}

template <class T>
void InsertSort(T A[], int n)
{
for(int i=1; i<n; i++){                //执行n-1趟
int j=i;
T temp=A[i];                      //待插入元素存入临时变量
while(j>0&&temp<A[j-1])
{       //从后往前查找插入位置
A[j]=A[j-1];
j--;             //A[j-1]元素后移，j指针前移
}
A[j]=temp;                         //待插入元素存入找到的插入位置
}
}

template <class T>
void BubbleSort(T A[], int n)
{
int i,j,last;
i=n-1;
while (i>0){                    //最多进行n-1趟
last=0;                     //进入循环就将last置成0
for (j=0; j<i; j++)          //从上往下进行相邻元素的两两比较
if (A[j+1]<A[j]){
Swap(A[j],A[j+1]);  //由于后者小，故交换
last=j;              //有交换就将last置成j
}
i=last;                        //如果一趟排序中没有交换元素，则last为0
}
}

template <class T>
void QuickSort(T A[], int n)
{
QSort(A,0,n-1);                   //以初始序列为待排序序列开始快速排序
}
template <class T>
void QSort(T A[], int left, int right)    //left和right为待排序序列的下界和上界
{
int i,j;
if (left<right){                     //若待排序序列多于一个元素，则继续快速排序
i=left; j=right+1;               //确定待排序序列的游动指针i,j
do{                              //开始一趟快速排序,A[left]作为分割元素
do i++;while (A[i]<A[left]);  //i指针从左往右找第一个分割元素的元素
do j--; while (A[j]>A[left]);//j指针从右往左找第一个分割元素的元素
if (i<j) Swap(A[i],A[j]);    //若i<j，则交换两个元素
}while (i<j);                    //若i<j，则继续本趟排序
Swap(A[left],A[j]);             //交换分割元素A[left]和A[j]的位置
QSort(A,left,j-1);               //对低端序列快速排序
QSort(A,j+1,right);             //对高端序列快速排序
}
}

template <class T>
void Merge(T A[],int i1,int j1,int i2,int j2)
{  // i1,j1是子序列1的下、上界，i1,j2是子序列2的下、上界
T *Temp=new T[j2-i1+1];             //分配能存放两个子序列的临时数组
int i=i1,j=i2,k=0;                   //i,j是两个子序列的游动指针，k是Temp的游动指针
while (i<=j1&&j<=j2)                //若两个子序列都不空，则循环
if (A[i]<=A[j]) Temp[k++]=A[i++];   //将A[i]和A[j]中较小的存入Temp[k]
else Temp[k++]=A[j++];
while (i<=j1) Temp[k++]=A[i++];     //若第一个子序列中还有剩余的就存入Temp
while (j<=j2) Temp[k++]=A[j++];     //若第二个子序列中还有剩余的就存入Temp
for (i=0; i<k; i++) A[i1++]=Temp[i]; //将临时数组中的元素倒回A
delete [] Temp;
}

template <class T>
void MergeSort(T A[], int n)
{
int i1,j1,i2,j2;      //i1,j1是子序列1的下、上界，i2,j2是子序列2的下、上界
int size=1;                      //子序列中元素个数，初始化为1。
while (size<n){
i1=0;
while (i1+size<n){ //若i1+size<n，则说明存在两个子序列，需再两两合并
i2=i1+size;                  //确定子序列2的下界
j1=i2-1;               //确定子序列1的上界
if (i2+size-1>n-1)
j2=n-1;  //若第2个子序列中不足size个元素，则置子序列2的上界j2=n-1
else j2=i2+size-1;        //否则有size个，置j2=i2+size-1
Merge(A,i1,j1,i2,j2);     //合并相邻两个子序列　        i1=j2+1;                  //确定下一次合并第一个子序列的下界
}
size*=2;                     //元素个数扩大一倍
}
}

template <class T>
void AdjustDown(T A[], int r, int j)
{
int child=2*r+1; T temp=A[r];
while(child<=j) {
if((child<j)&&(A[child]<A[child+1])) child++;  //找两个孩子中较大的孩子
if (temp>= A[child]) break;
A[(child-1)/2]=A[child];
child=2*child+1;
}
A[(child-1)/2]=temp;
}

template <class T>
void HeapSort(T A[], int n)
{
for(int i=(n-2)/2; i>-1; i--)
AdjustDown(A,i,n-1);  //构造最大堆
for(int i=n-1; i>0; i--)
{
Swap(A[0],A[i]);                     //堆顶和堆底元素交换位置
AdjustDown(A,0,i-1);                 //将A[0]向下调整为堆
}
}

int main()
{
int a[SIZE];
time_t t0,t1;
/*SelectSort*/
for(int i=0;i<SIZE;i++)
{
a[i]=rand()%SIZE;
}

time(&t0);
SelectSort<int>(a,SIZE);
time(&t1);
cout<<"SelectSort:"<<t1-t0<<endl;

for(int i=0;i<SIZE;i++)
{
cout<<a[i]<<" ";
}
/*InsertSort*/
for(int i=0;i<SIZE;i++)
{
a[i]=rand()%SIZE;
}

time(&t0);
InsertSort<int>(a,SIZE);
time(&t1);
cout<<"InsertSort:"<<t1-t0<<endl;

for(int i=0;i<SIZE;i++)
{
cout<<a[i]<<" ";
}
/*BubbleSort*/
for(int i=0;i<SIZE;i++)
{
a[i]=rand()%SIZE;

}

time(&t0);
BubbleSort<int>(a,SIZE);
time(&t1);
cout<<"BubbleSort:"<<t1-t0<<endl;

for(int i=0;i<SIZE;i++)
{
cout<<a[i]<<" ";
}
/*QuickSort*/
for(int i=0;i<SIZE;i++)
{
a[i]=rand()%SIZE;
}

time(&t0);
QuickSort<int>(a,SIZE);
time(&t1);
cout<<"QuickSort:"<<t1-t0<<endl;

for(int i=0;i<SIZE;i++)
{
cout<<a[i]<<" ";
}

/*HeapSort*/
for(int i=0;i<SIZE;i++)
{
a[i]=rand()%SIZE;
}

time(&t0);
HeapSort<int>(a,SIZE);
time(&t1);
cout<<"HeapSort:"<<t1-t0<<endl;

/*MergeSort*/
for(int i=0;i<SIZE;i++)
{
a[i]=rand()%SIZE;
}
time(&t0);
MergeSort<int>(a,SIZE);
time(&t1);
cout<<"MergeSort:"<<t1-t0<<endl;

for(int i=0;i<SIZE;i++)
{
cout<<a[i]<<" ";
}
return 0;
}