各排序算法的实现及性能比较

#include <cstdio>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <iostream>
using namespace std;
const int maxn=100+5;

void Display(int a[]){
	cout << "排序过后的数组为:" << endl;
	for(int i=0;i<maxn;i++)
    	cout << a[i] << " ";
    printf("\n\n");
}

//冒泡排序未优化版
//对于已经有一定顺序的序列排序效果好，但是比较次数仍不变
void MaoPao_sort(int a[]){
	int cnt_judge=0,cnt_move=0;
    for(int i=0;i<maxn;i++){
        for(int j=maxn-1;j>i;j--){
        	cnt_judge++;
            if(a[j]<a[j-1]){//a[j-1]最小就可以变成a[i]
                int t=a[j];
                a[j]=a[j-1];
                a[j-1]=t;
                cnt_move+=3;
            }
        }
    }
    printf("冒泡排序未优化版:\n判断次数:%6d    移动次数:%6d    合计:%6d\n",cnt_judge,cnt_move,cnt_judge+cnt_move);
    Display(a);
}

//冒泡排序优化版
//对于已经有一定顺序的序列排序效果好，但是比较次数仍不变
void MaoPao_optimize_sort(int a[]){
	int cnt_judge=0,cnt_move=0;
    bool flag=1;
    for(int i=0;i<maxn && flag;i++){
        flag=0;//若是在i后相邻的两个元素的不断比较中都没有交换过一次位置，那么说明此时后面是完全排好序的
        for(int j=maxn-1;j>i;j--){
        	cnt_judge++;
            if(a[j]<a[j-1]){//a[j-1]最小就可以变成a[i]
                int t=a[j];
                a[j]=a[j-1];
                a[j-1]=t;
                flag=1;//说明后面还是没有排好
                cnt_move+=3;
            }
        }
    }
    printf("冒泡排序优化版:\n判断次数:%6d    移动次数:%6d    合计:%6d\n",cnt_judge,cnt_move,cnt_judge+cnt_move);
    Display(a);
}

//选择排序
//交换次数少，判断次数并未减少
void Select_sort(int a[]){
    int Min,cnt_judge=0,cnt_move=0;
    for(int i=0;i<maxn;i++){
        Min=i;//和冒泡排序不太一样，这里Min只是保存最小的那个值的下标，然后最后再交换具有最小下标值的那个元素与当前元素进行交换
        for(int j=i+1;j<maxn;j++){
        	cnt_judge++;
            if(a[j]<a[Min]){
            	Min=j;
            }
        }
        cnt_judge++;
        if(Min!=i){
            int t=a[Min];
            a[Min]=a[i];
            a[i]=t;
            cnt_move+=3;
        }
    }
    printf("选择排序:\n判断次数:%6d    移动次数:%6d    合计:%6d\n",cnt_judge,cnt_move,cnt_judge+cnt_move);
    Display(a);
}

//直接插入排序
//简单排序中性能最好，尤其是在7和7个以下长度的数组中最管用
void Insert_sort(int a[]){
    int temp,j,cnt_judge=0,cnt_move=0;
    for(int i=1;i<maxn;i++){
    	cnt_judge++;
        if(a[i]<a[i-1]){
            temp=a[i];
            for(j=i-1;j>=0&&a[j]>temp;j--){
                a[j+1]=a[j];//整体向后移
                cnt_move++;
            }
            a[j+1]=temp;//插入合适的位置
            cnt_move++;
        }
    }
    printf("直接插入排序:\n判断次数:%6d    移动次数:%6d    合计:%6d\n",cnt_judge,cnt_move,cnt_judge+cnt_move);
    Display(a);
}

//希尔排序
//降低了算法的复杂度
void XiEr_sort(int a[]){
    int temp,j,gap=maxn,cnt_judge=0,cnt_move=0;
    do{
        gap=gap/3 + 1;//希尔排序中的这个间隔的变量默认就是这样选取的
        for(int i=gap;i<maxn;i++){//比较就是从gap开始
        	cnt_judge++;
            if(a[i]<a[i-gap]){
                //间隔不断地被缩小，每次总是把平均分布的数调出来进行插入排序，所有的数都会轮上，直到最后间隔变为1
                temp=a[i];
                for(j=i-gap;j>=0&&a[j]>temp;j-=gap){
                    a[j+gap]=a[j];
                    cnt_move++;
                }
                cnt_move++;
                a[j+gap]=temp;
            }
        }
    }while(gap>1);
	printf("希尔排序:\n判断次数:%6d    移动次数:%6d    合计:%6d\n",cnt_judge,cnt_move,cnt_judge+cnt_move);
	Display(a);
}

//快速排序1
//最有效的排序算法之一，对于处理大的数组排序时比较好，可以考虑和直接插入排序分情况使用
//将该区间以a[low]为中心，分为两部分
int Partition(int a[],int low,int high,int &cnt_judge,int &cnt_move){
    int pivotkey=a[low];//这里说明分界其实就是a[low]
    while(low<high){//双向扫描
        while(low<high && a[high]>=pivotkey) high--;//在右边的大的就留下，小的就扔给左边的a[low]
        a[low]=a[high];cnt_move++;//这里a[low]的值就丢失了，但是没关系，最后会补上的
        while(low<high && a[low]<=pivotkey) low++;//在左边的小的就留下，大的的就扔给右边的a[high]
        a[high]=a[low];cnt_move++;
    }
    a[low]=pivotkey;cnt_move++;
    return low;
}
//递归，对区间进行不断的划分
void Qsort(int a[],int low,int high,int &cnt_judge,int &cnt_move){
	cnt_judge++;
    if(low<high){
        int pivotloc=Partition(a,low,high,cnt_judge,cnt_move);//将该区间以a[low]为中心，分为两部分
        Qsort(a,low,pivotloc-1,cnt_judge,cnt_move);//对两边继续进行细分的分割
        Qsort(a,pivotloc+1,high,cnt_judge,cnt_move);
    }
}
void Qsort_sort1(int a[]){
	int cnt_judge=0,cnt_move=0;
    Qsort(a,0,maxn-1,cnt_judge,cnt_move);
    printf("快速排序1:\n判断次数:%6d    移动次数:%6d    合计:%6d\n",cnt_judge,cnt_move,cnt_judge+cnt_move);
    Display(a);
}

//快速排序2
void quick_sort(int a[],int l,int r,int &cnt_judge,int &cnt_move) {
    int i=l,j=r,mid=a[r];这里是以最后一位为基准点的，最后基准点自动跑到中间，不需要再空降赋值
    do {
        while(a[i]<mid) ++i;
        while(a[j]>mid) --j;//这是每次找到两个矛盾然后交换的方法，当只有一方有矛盾时，另一方就会不断搜索直到这一方，这样自己与自己交换也不会有什么问题
        if (i<=j) {
            swap(a[i],a[j]);
            ++i;--j;
            cnt_move+=3;
        }
    }while(i<j);
    cnt_judge++;
    if (l < j) quick_sort(a,l,j,cnt_judge,cnt_move);
    cnt_judge++;
    if (i < r) quick_sort(a,i,r,cnt_judge,cnt_move);//其实i=j
}
void Qsort_sort2(int a[]) {
	int cnt_judge=0,cnt_move=0;
    quick_sort(a,0,maxn,cnt_judge,cnt_move);
    printf("快速排序2:\n判断次数:%6d    移动次数:%6d    合计:%6d\n",cnt_judge,cnt_move,cnt_judge+cnt_move);
    Display(a);
}

//堆排序
//算法的时间复杂度小，适合于处理较大的数据，但是不适合于较小的数据
//对以s为根结点的树进行范围在m内的堆排序
void HeapAdjust(int a[],int s,int m,int &cnt_judge,int &cnt_move){
    int temp=a[s];//保存开始双亲
    for(int j=2*s;j<=m;j*=2){//s永远是双亲
    	cnt_judge++;
        if(j<m && a[j+1]>a[j]) j++;//获得较大的儿子
        cnt_judge++;
        if(temp>=a[j]) break;//保证双亲的正确位置，儿子不会比双亲大
        a[s]=a[j];
        s=j;
    }
    a[s]=temp;//双亲空降
}
//对数组进行完整的堆排序
void Heapsort(int a[],int &cnt_judge,int &cnt_move){//想要获得一个增序的数列，自然是大顶堆，这样大的数都到数组后面去了
    int len = maxn;//这里长度看具体数组的长度而定，也算上a[0]
    for(int i = len/2;i>0;i--){
        HeapAdjust(a,i,len,cnt_judge,cnt_move);//对一个无序的堆使其有序化，由于最后一个双亲就是len/2(即k)，因为其儿子为2k+1或2k，若要遍历，只需对所有的双亲均操作即可
    }
    for(int i = len;i>1;i--){
        int t=a[i];
        a[i]=a[1];
        a[1]=t;//把堆顶交换到最后一个未排序的元素处
        cnt_move+=3;
        HeapAdjust(a,1,i-1,cnt_judge,cnt_move);//对新堆进行调整，同时限制范围，已经排好序的部分就不用再排序了
    }
}
void Tree_sort(int a[]){
    //堆排序因为与数组二叉树有关，所以没有a[0]这个说法
    int cnt_judge=0,cnt_move=0;
    Heapsort(a,cnt_judge,cnt_move);
    printf("堆排序:\n判断次数:%6d    移动次数:%6d    合计:%6d\n",cnt_judge,cnt_move,cnt_judge+cnt_move);
    Display(a);
}

//归并排序
//算法的时间复杂度小，比较稳定，但是不常用，因为需要一个等长的辅助数组
//将有序的a[Begin..mid]和a[mid+1..End]归并为有序的T[Begin..End]
void Merge(int a[],int t[],int Begin,int mid,int End,int &cnt_judge,int &cnt_move){
    int t1,t2;//t1用来计数第一次循环赋值的元素数，mid和End后面有用，故不变化，但是Begin就可以变化
    for(t1=Begin,t2=mid+1;Begin<=mid && t2<=End;t1++){//挑出当前两部分中首元素中较小的一个放进去
    	cnt_judge++;cnt_move++;
        if(a[Begin]<a[t2]) t[t1]=a[Begin++];
        else t[t1]=a[t2++];
    }
    if(Begin<=mid){//将剩余的元素补齐
        for(;Begin<=mid;Begin++,t1++){
            t[t1]=a[Begin];cnt_move++;
        }
    }
    if(t2<=End){
        for(;t2<=End;t2++,t1++){
            t[t1]=a[t2];cnt_move++;
        }
    }
}
void Mergesort(int a[],int res[],int Begin,int End,int &cnt_judge,int &cnt_move){
    int t[maxn];//这只是制造的一个临时存储站，其实在递归的过程中还会有很多小t，只是这些小t最终汇总到一起就是最开始的这个t数组
    cnt_judge++;
    if(Begin == End) {res[Begin]=a[Begin];cnt_move++;}
    else{
        int mid=(Begin+End)/2;//将其一分为二
        Mergesort(a,t,Begin,mid,cnt_judge,cnt_move);//递归地将这个区间内的元素合并了
        Mergesort(a,t,mid+1,End,cnt_judge,cnt_move);
        Merge(t,res,Begin,mid,End,cnt_judge,cnt_move);//把这两个区间排序后合并了
    }
}
void GuiBing_sort(int a[]){
    int res[maxn],cnt_judge=0,cnt_move=0;
    Mergesort(a,res,0,maxn-1,cnt_judge,cnt_move);
    printf("归并排序:\n判断次数:%6d    移动次数:%6d    合计:%6d\n",cnt_judge,cnt_move,cnt_judge+cnt_move);
    Display(res);
}

void Init(int a[],int ta[]){
	for(int i=0;i<maxn;i++) ta[i]=a[i];
}

void Function(int a[],int ta[]){
	cout << "生成的序列如下:" << endl;
	for(int i=1;i<maxn;i++)
		cout << a[i] << " ";
	printf("\n\n");
	Init(a,ta);MaoPao_sort(ta);
	Init(a,ta);MaoPao_optimize_sort(ta);
	Init(a,ta);Select_sort(ta);
	Init(a,ta);Insert_sort(ta);
	Init(a,ta);XiEr_sort(ta);
	Init(a,ta);Qsort_sort1(ta);
	Init(a,ta);Qsort_sort2(ta);
	Init(a,ta);Tree_sort(ta);
	Init(a,ta);GuiBing_sort(ta);
}

int main(){
	int a[maxn],ta[maxn];
	//随机生成数据，需要的话可以自己修改数据
	srand((unsigned)time(NULL));
	for(int i=1;i<maxn;i++) a[i]=rand()%maxn;
	Function(a,ta);
	return 0;
}