7种排序

/*---------------------------

    程序功能：比较七种排序算法的时间消耗

    七种算法：1.冒泡排序、2.直接插入排序、3.简单选择排序、4.希尔排序、5.堆排序、6.归并排序、7.快速排序。

    统一规约：1，排序为从小到大 升序排序
              2，Max  表示排序数组的大小
              3，rt   记录前一次运行算法的时间，求差的结果为当前排序时间
              4，a[] 为排序数组， a2[] 为恢复数组，每次一个排序结束后由a2[]进行恢复
              5，char_len 字符串长度
              6，save[] 用在归并事的保存数据
              7，Distance 设置快排的比较间隔，小于这个值就会进行插入排序。
    

 --------------------------- */
#include<iostream>
//#include<stdio.h>
#include<ctime>
#include<cstdlib>
#include<cmath>
#include<algorithm>

#define Max 1000000
#define char_len 100
#define Distance 10


int a[Max]={0};
int a2[Max]={0};
int save[Max];

double rt=0.0;

//计算排序时间函数 用到了 函数指针， 可以调用到 随意函数 来计算排序时间
void printTime( void (*sort )(int a[Max] ) , char name[char_len] ){
    clock_t   tick; 
    double t;

    //实际排序
    sort(a);
    tick=clock(); 
    //算排序总时间
    t=(double)tick/CLK_TCK; 
    
    printf( "Total time used of  %s  is:  %lf   second\n\n ", name , t-rt); 
    rt=t;
}    

//初始化数组 +  随机函数
void init_array(){
    int i=0;
    srand((unsigned)time(NULL)); /*随机种子*/ 

    for(i = 1 ; i<Max; i++){
        a2[i]=a[i]=rand()*i; 

    // if( i%100==0)
    //        printf("\n");
    //    printf("%d ",a[i]);
    }
}

//初始化数组 + 将用a2[] 来恢复 a [] 的值 ，恢复到 开始状态
void init_array2(){
    int i=0;
    for(i = 1 ; i<Max; i++){
        a[i]=a2[i]; 
    }
}
//打印数组
void print_array(){
    int i;
    for( i=0; i<Max; i++){
        if( i%10==0)
            printf("\n");
        printf("%d ",a[i]);
    }
}




/*
    第一个算法 ： 冒泡排序---------------------------------------------------------------------------

  */
//冒泡 a[]
void bubble_sort( int a[]){
    int i,j,k;
    
    for(i=Max ; i>0 ; i--){
        for( j=1; j<i-1;j++){
            if( a[j]>a[j+1] ){
                k=a[j];
                a[j]=a[j+1];
                a[j+1]=k;
            }
        }
    }
//    print_array();
}



/*
    第二个算法 ： 直接插入排序---------------------------------------------------------------------------

  */


//插入排序对 a 中 从 left ---> right 的数据排序， 如此设计可提供快排和归并调用
void insertionsort(int a[], int left, int  right){
    int i , j , k ;

    for( i=left+1; i<=right; i++){
        k= a[i];
        for( j = i-1; j>0 ; j--){
            if( a[j]> k ){
                a[j+1]=a[j];
            }else{
            //    a[j+1]=k;
                break;
            }
        }
        a[j+1]=k;
    }
}

//插入排序接口
void insert_sort( int a[]){

    insertionsort(a , 1, Max-1 );

//    print_array();

}





/*
    第三个算法 ： 简单选择排序---------------------------------------------------------------------------

  */


//查找最值的 递归函数，  对 begin --- > end 中选择最小值的 下表
int SelectMin( int begin, int end){
    int c, b ;
    int center= (begin+end)/2;

    if( begin<end){
        c=SelectMin(begin,center);
        b= SelectMin(center+1, end);
        return a[c] < a[b] ? c : b ;
    }else{
        return begin;
    }


}
//选择排序主函数， 对 a[] 排序。 
void select_sort( int a[]){
    int i, j, k,min;
    for( i =1; i<Max; i++){
    /**/min=0xfffffff;
        for(j=i;j<Max; j++){
            if(a[j]<min ){
                min=a[j];
                k=j;
            }
        }
    //    k = SelectMin( i,Max-1);

        //将每次选择的最小值和前面的数进行对调，数组前半部分有序
        if( i!=k ){
            j=a[i];
            a[i]=a[k];
            a[k]=j;
        }
    }
//    print_array();
}


/*
    第四个算法 ： 希尔排序---------------------------------------------------------------------------

  */


//希尔排序 a, 对 公差为 dk 的 元素排序。
void  shell_insert(int a[], int dk){
    int i, j , k ;
    for(i=dk+1 ; i< Max ; i++){
        k=a[i];
        for( j= i-dk; j>0 ; j-=dk){
            if( a[j]> k ){
                a[j+dk]=a[j];
            }else{
            //    a[j+dk]=k;
                break;
            }
        }
        a[j+dk]=k;
    }
}
//希尔主函数，排序 a[];
void  shell_sort( int a[] ){
    int k=0;

    //确定公差数量
    int kp= (int)(log(Max-1)/log(2));
    
    //printf("%d\n",kp);
    for( k=0; k<=kp; k++){
        //有人统计 希尔的公差为  2^(kp-k)+1 时，效率最高
        shell_insert( a,(int)pow(2,kp-k)-1);
    }
//    print_array();
}



/*
    第五个算法 ： 堆排序 ---------------------------------------------------------------------------

  */


// 堆的调整函数， s 表示 当前调整的位置， length 表示 调整范围： a [] 的 1--->length 位置，
void heap_adjust( int a[] ,  int s , int length ){
    int i  ,k; 

    k = a[s];

    //确定a[s]是最大元素；s以后的节点都满足这样的定义；
    for( i = 2*s ; i<length ; i*=2){
        

        //这里用到 i+1 <length ， 不是 i<length , 错了很久，终于搞定了
        if( (i+1)<length &&  a[i]<a[i+1] ) i++;

        if( a[i] <= k ) break;

        a[s] = a [ i] ;

        s = i; 
    }
    a[ s] = k; 
}

//堆排主函数， 对 a[] 排序。
void heap_sort( int a[] ){
    
    int i, k;

    //对每个非叶节点进行调整（即有孩子的节点）
    for( i = (Max-1)/2  ; i>0; i--){

        heap_adjust( a, i, Max);
    }
    //将弹出的最大值放在最后，结果就是从小到大
    for( i = Max-1 ; i > 1; i--){
        k=a[1];
        a[1]=a[i];
        a[i]=k;

        heap_adjust(a, 1, i);
    }
  //  print_array();
}


/*    

    第六个算法 ： 归并排序 ---------------------------------------------------------------------------

  */



//合并函数， a 中的 left1 —> right1 , a中的 left2 --> right2 ,进行归并
void merge ( int a[],int left1,int right1,int left2 ,int right2){
 

    int k=0, i , j , m ;
    
    for( i = left1 , j = left2 ; i<= right1 && j <= right2 ; ){

        //我这里放了一个错误：a[l1]<a[l2] ==== 费了半小时调试
        if(a[i]<a[j])
            save[k++]=a[i++];
        else
            save[k++]=a[j++];
    }
    while(i<=right1)
        save[k++]=a[i++];

    while(j<=right2)
        save[k++]=a[j++];
    for( m= 0 ; m<k; m++){
        a[left1++]= save[m];
    }
}

// 归并递归函数 ， left 和 right ,表示 a[]中的问题规模
void  MergeSort(int a[],int left, int right ){
    
    int center=(left + right ) /2;
    if(left < right){

        MergeSort(a,left,center);
        MergeSort(a,center+1,right);
        merge(a,left,center,center+1,right);
    
    } 
}

//归并 （ 符合函数入口 ）
void merge_sort ( int a[] ){

    MergeSort( a, 1, Max-1 );
//    print_array();

}




/*
    第七个算法 ： 快速排序---------------------------------------------------------------------------

  */


//交换 a[] 数组下 表 为   h  和 t 的值
void swap( int h, int t){
    int k;
    k=a[h];
    a[h]=a[t];
    a[t]=k;
}

// 在 a[] 中 选择 一个比较适合的比较值
 int  median3(int a[],int left,int right ){

    int center =(left + right)/2;

    if (a[center]<a[left])
        swap(left,center);
    if (a[right]<a[left])
        swap(left,right);
    if (a[right]<a[center])
        swap(center,right);

    swap(center,right);

    return a[right];
 }

//快排函数， 对 a[] 中的 left -->right 进行切割分块，递归完成。
 void quickSort(int a[],int left,int right){

    if (left+Distance <=right)    {

         int pivot=median3(a,left,right);

         int i=left,j=right;

         for(;;){
            while (a[++i]<pivot){}
            while (pivot<a[--j]){}     
            if (i<j)
                swap(i,j);
            else           
                break; 
         }

        swap (i,right);

        quickSort(a,left,i-1);
        quickSort(a,i+1,right); 
    }
    else
           insertionsort(a,left,right);
 }

 //函数接口
 void quick_sort(int a[]  ){
    
     quickSort(a,1,Max-1);

//     print_array();
 }



/*
    主函数---------------------------------------------------------------------------

  */

int main(){

    init_array(); 
/*----------------------------------------------
    
    第一段测试代码，建议将Max 调整 10000--100000
    
      目的为：对每个算法的运行都有一个比较
    ----------------------------------------------*/
    /* 

    printTime(  &bubble_sort ," 冒泡算法");    
    init_array2();
    printTime(  &insert_sort ,"插入算法");
    init_array2();
    printTime(  &select_sort ,"选择算法");    
    init_array2();
    printTime(  &shell_sort  ,"希尔算法");
    
    init_array2();
    printTime(  &heap_sort   ,"堆算法  ");

    init_array2();
    printTime(  &merge_sort  ,"归并算法");

    init_array2();
    printTime(  &quick_sort  ,"快排算法");*/

/*----------------------------------------------
    
    第二段测试代码，建议将Max 调整 100000--10000000（十万 到 一千万， 后三个可以到一亿）
    
      目的为：对快速算法来个更刺激的比较
    ----------------------------------------------*/
    /* 
    init_array2();
    printTime(  &shell_sort  ,"希尔算法");*/
    init_array2();
    printTime(  &heap_sort   ,"堆算法  ");

    init_array2();
    printTime(  &merge_sort  ,"归并算法");

    init_array2();
    printTime(  &quick_sort  ,"快排算法");

    init_array2();
    printTime(  &sort  ,"快排算法");

 
/*----------------------------------------------
    
    第三段测试代码，建议将Max 调整  10--100。并将每个算法后
    
      目的为：表示每个算法都是可以的到真确的排序结果
    ----------------------------------------------*/
/*
    init_array2();printf("冒泡算法");
    bubble_sort (a);printf("\n");
    print_array();

    init_array2();printf("\n插入算法");
    insert_sort(a);printf("\n");
    print_array();

    init_array2();printf("\n选择算法");
    select_sort(a);printf("\n");
    print_array();


    init_array2();printf("\n希尔算法");
    shell_sort(a);printf("\n");
    print_array();

    init_array2();printf("\n堆算法  ");
    heap_sort(a);printf("\n");
    print_array();
    
    init_array2();printf("\n归并算法");
    merge_sort(a);printf("\n");
    print_array();
    
    init_array2();printf("\n快排算法");
    quick_sort(a);printf("\n");
    print_array();*/


    printf("\n");


    return 0;
}