关于“主键-次键”排序的三种方法比较。

自己给自己放了七天假，回家休息一下。在家懒，七天就写了300多行代码，还质量不高...

在《计算机编程艺术——vlo3》中（以下简称Art3），在排序内容前言的习题中谈到关于带主键和次键的排序问题，其实就类似与字符串的排序方式，即比完主键看次键1，再次键2...。三种方法：

　　A：先按主键排序，再在排完序的序列里将主键相同的划分为一个个区域，再比较次键1，递归的进行下去，直到次键全部比较完或区域中只剩下一个元素。

　　B：先以最小的次键n排序，再以次键n-1排序，...一直到主键。

　　C：排序时比较是以字典排序法比较，一次搞定。

以下是我的实现和测试代码：

 

/*对于具有主键（唯一）和次键（>=0）的排序，有三种方式：
  1.先对主键进行排序进行分组，在每个分组内再依次对各个次键进行排序分组
  2.先对优先级最低的键进行排序，然后再逐步上升
  3.对于排序的元素比较方式是字典排序法

  注意：要使三种排序的结果一致，前提条件是排序是稳定的。

    实验表明三种方案中，C（字典排序法）是最稳定的，效率最高的。
 */
 //for timeval and gettimeofday
 #include<sys/time.h>

#include<stdio.h>
#include<stdlib.h>

 #define A 1
 #define B 2
#define C 3

typedef
struct 
{
    int keys[100];
}elem;

//记录三种策略的总时间（单位usec）
unsigned int total_A_u=0;
unsigned int total_B_u=0;
unsigned int total_C_u=0;




typedef int (*msort_func)(void* a,void* b,int at);

//merge sort 保证排序的稳定性 
//参数：
//    array为代排序的序列
//    n序列元素的个数
//    size序列元素的大小
//    f为比较函数
//
void msort(elem** array,size_t n,int key_num,msort_func f);

//模拟情形1：已经排好序的序列，但序列中的元素数值是随机的
void sorted_random(elem** pe,unsigned int n,int key_num);
//模拟情景2：完全反序
void res_sorted_random(elem** pe,unsigned int n,int key_num);
//模拟情景3：完全随机
void unsorted(elem** pe,unsigned int n,int key_num);

//分析函数：统计分析每一种情形下的三种排序方法的复杂度：
//    1.比较次数
//    2.总时间
void analysis(elem** pe,unsigned int n,int key_num,int type);


void print_keys(elem** pe,int n,int key_num)
{
    int i,j;
    for(i=0;i<n;i++)
    {
        printf("The %dth element is:",i+1);
        for(j=0;j<key_num;j++)
        {
            printf("%d ",pe[i]->keys[j]);
        }
        printf("\n");
    }
}

int sort_func(void* a ,void * b,int at)
{
    elem *x = (elem*)a;
    elem *y = (elem*)b;
    return (x->keys[at]-y->keys[at]);
}

int main()
{
    unsigned int elem_num;
    scanf("%u",&elem_num);
    elem **pelems =  (elem**)malloc(sizeof(elem*)*elem_num);
    int i;
    for(i=0;i<elem_num;i++)
        pelems[i]=(elem*)malloc(sizeof(elem));
    int key_num;
    for(key_num=10;key_num<=30;key_num++)
    {
        sorted_random(pelems,elem_num,key_num);
        printf("SORTED:\n");
        print_keys(pelems,elem_num,key_num);
        analysis(pelems,elem_num,key_num,A);
        analysis(pelems,elem_num,key_num,B);
        analysis(pelems,elem_num,key_num,C);
        
        res_sorted_random(pelems,elem_num,key_num);
        printf("RES SORTED\n");
        print_keys(pelems,elem_num,key_num);
        analysis(pelems,elem_num,key_num,A);
        analysis(pelems,elem_num,key_num,B);
        analysis(pelems,elem_num,key_num,C);

        unsorted(pelems,elem_num,key_num);
        printf("RANDOM\n");
        print_keys(pelems,elem_num,key_num);
        analysis(pelems,elem_num,key_num,A);
        analysis(pelems,elem_num,key_num,B);
        analysis(pelems,elem_num,key_num,C);
        
        printf("Total time of A:%ld B:%ld C:%ld\n",total_A_u,total_B_u,total_C_u);
    }
    for(i=0;i<elem_num;i++)
        free(pelems[i]);
    free(pelems);
    return 0;
}

void msort(elem** array,size_t n,int key_num,msort_func f)
{
    if(n<=1)
        return;
    int mid = n/2;
    msort(array,mid,key_num,f);
    msort(array+mid,n-mid,key_num,f);

    elem** tmp = (elem**)malloc(n*sizeof(elem*));
    int i,j,k;
    k=i=0;j=mid;
    while(i<mid && j<n)
    {
        //[i] > [j]
        if(f(array[i],array[j],key_num)>0)
        {
            tmp[k]=array[j];
            j++;
        }
        //[i] <= [j]
        else
        {
            tmp[k]=array[i];
            i++;
        }
        k++;
    }
    if(k!=n)
    {
        if(i<mid)
        {
            while(i<mid)
                tmp[k++]=array[i++];
        }
        else
        {
            while(j<n)
                tmp[k++]=array[j++];
        }
    }
    for(i=0;i<n;i++)
        array[i]=tmp[i];
}

inline unsigned int gen_rand(unsigned int last)
{
    static unsigned int add=0;
    add+=last;
    srand(time(NULL)+(add));
    return rand();
}

void sorted_random(elem** pe,unsigned int n,int key_num)
{
    int at =0;
    for(;at<key_num;at++)
    {
        int highest = 10000;
        unsigned int remain = n;
        int now =0;
        unsigned int last =0;
        while(remain)
        {
            last=gen_rand(last);
            if((last%highest)<remain)
            {
                pe[n-remain]->keys[at]=now;
                remain--;
            }
            else
            {
                now++;
                highest--;
            }
        }
    }
}




void res_sorted_random(elem** pe,unsigned int n,int key_num)
{
    int at =0;
    for(;at<key_num;at++)
    {
        int highest = 10000;
        unsigned int remain = n;
        int now =0;
        unsigned int last=0;
        while(remain)
        {
            last=gen_rand(last);
            if((last%highest)<remain)
            {
                pe[remain-1]->keys[at]=now;
                remain--;
            }
            else
            {
                now++;
                highest--;
            }
        }
    }
}
void unsorted(elem** pe,unsigned int n,int key_num)
{    
    int at =0;
    for(;at<key_num;at++)
    {
        int highest = 10000;
        int i;
        unsigned int last=0;
        for(i=0;i<n;i++)
        {
            last=gen_rand(last);
            pe[i]->keys[at]=(last%highest);
        }
    }
}

void plan_A(elem** pelems,unsigned int n,int key_num,int now)
{
    if(now==key_num || n==1)
        return;
    msort(pelems,n,now,sort_func);
    int group_val = (*pelems)->keys[now];
    int i=1;
    elem** group=pelems;
    elem** end = pelems+n;
    while(group+i!=end)
    {
        if(pelems[i]->keys[now]==group_val)
        {
            i++;
        }
        else
        {
            plan_A(group,i,key_num,now+1);
            group+=i;
            i=1;
            if(group!=end)
                group_val = (*group)->keys[now];
        }
    }
}
void plan_B(elem** pelems,unsigned int n,int key_num)
{
    elem ** tpelems = (elem**)malloc(sizeof(elem*)*n);
    int i;
    for(i=0;i<n;i++)
        tpelems[i]=pelems[i];
    int now = key_num-1;
    while(now>=0)
    {
        msort(tpelems,n,now,sort_func);
        now--;
    }

    print_keys(tpelems,n,key_num);
    free(tpelems);
}
int sort_func_C(void* a,void* b,int key_num)
{
    elem* x = (elem*)a;
    elem* y = (elem*)b;
    int i;
    for(i=0;i<key_num;i++)
    {
        if(x->keys[i]!=y->keys[i])
            return (x->keys[i]-y->keys[i]);
    }
    return 0;
}
void plan_C(elem** pelems,unsigned int n,int key_num)
{    
    elem ** tpelems = (elem**)malloc(sizeof(elem*)*n);
    int i;
    for(i=0;i<n;i++)
        tpelems[i]=pelems[i];

    msort(tpelems,n,key_num,sort_func_C);
    print_keys(tpelems,n,key_num);
    free(tpelems);
}

    


void analysis(elem** pelems,unsigned int n,int key_num,int type)
{
    struct timeval tv1;
    struct timeval tv2;
    unsigned long micro_time_passed;
    switch(type)
    {
        case A:
            {
                gettimeofday(&tv1,NULL);
                
                elem ** tpelems = (elem**)malloc(sizeof(elem*)*n);
                int i;
                for(i=0;i<n;i++)
                    tpelems[i]=pelems[i];

                plan_A(tpelems,n,key_num,0);
                
                print_keys(tpelems,n,key_num);
                free(tpelems);

                gettimeofday(&tv2,NULL);
                
                micro_time_passed=(tv2.tv_sec-tv1.tv_sec)*1000+(tv2.tv_usec-tv1.tv_usec)/1000;
                total_A_u+=(tv2.tv_usec-tv1.tv_usec + (tv2.tv_sec-tv1.tv_sec)*1000000);
                printf("plan A cost %ld micro seconds sec:%ld usec %ld\n",micro_time_passed,(tv2.tv_sec-tv1.tv_sec),(tv2.tv_usec-tv1.tv_usec));
                break;

            }
        case B:
            {
                gettimeofday(&tv1,NULL);
                
                plan_B(pelems,n,key_num);
                
                gettimeofday(&tv2,NULL);
                
                micro_time_passed=(tv2.tv_sec-tv1.tv_sec)*1000+(tv2.tv_usec-tv1.tv_usec)/1000;

                total_B_u+=(tv2.tv_usec-tv1.tv_usec + (tv2.tv_sec-tv1.tv_sec)*1000000);
                printf("plan B cost %ld micro seconds sec:%ld usec %ld\n",micro_time_passed,(tv2.tv_sec-tv1.tv_sec),(tv2.tv_usec-tv1.tv_usec));
                break;
            }
        case C:
            {
                gettimeofday(&tv1,NULL);
                
                plan_C(pelems,n,key_num);
                
                gettimeofday(&tv2,NULL);    
                
                micro_time_passed=(tv2.tv_sec-tv1.tv_sec)*1000+(tv2.tv_usec-tv1.tv_usec)/1000;

                total_C_u+=(tv2.tv_usec-tv1.tv_usec + (tv2.tv_sec-tv1.tv_sec)*1000000);
                printf("plan C cost %ld micro seconds sec:%ld usec %ld\n",micro_time_passed,(tv2.tv_sec-tv1.tv_sec),(tv2.tv_usec-tv1.tv_usec));
                break;
            }
    }
}

 

 

 

 

　　从测试结果来看，毫无疑问：肯定是第三种方法平均效率最高，但我一直以为方法B凭借着方法的简单性，要比方法A要快，可是实际上必不是如此...究其原因应该是B方法太呆板，无论源数据是什么情况全都是一股脑的从n键排到主键。看来再做事和做人的时候有时候也不能太呆板，凡事都有其解决之道，而不能一种方法走天下啊。呵呵，卖弄了卖弄了。