基数排序(桶排序) 不同方法

详细解释：算法导论/数据结构书

1.链式基数排序


//n个数，每个数有g个关键字
//排序：从最后的关键字开始到最前的关键字
//分配+收集
//每个关键字分配+收集需要n+n时间，而共有g个关键字，时间复杂度为O(2ng)，效率很高。
//如果用数组，数据集中在一个区间，则区间的长度很长，另外的区间的内存浪费了。
//用链表可以解决这个问题，且数据不需要先后顺序，所以无必要非要用数组

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 //个数
  4 #define maxn 1000
  5 //数的范围 x~y
  6 #define x 0
  7 #define y 9
  8 //关键字个数
  9 #define g 3
 10 
 11 //n个数，每个数有g个关键字
 12 //排序：从最后的关键字开始到最前的关键字
 13 //分配+收集
 14 //每个关键字分配+收集需要n+n时间，而共有g个关键字，时间复杂度为O(2ng)，效率很高。
 15 //如果用数组，数据集中在一个区间，则区间的长度很长，另外的区间的内存浪费了。
 16 //用链表可以解决这个问题，且数据不需要先后顺序，所以无必要非要用数组
 17 
 18 struct node
 19 {
 20     //关键字的值
 21     long key[g+1];
 22 }data[maxn+1];
 23 //next:下一个数的编号
 24 //front,rear:一个链表的首,尾数据的编号
 25 long next[maxn+1],front[y-x+1],rear[y-x+1];
 26 
 27 int main()
 28 {
 29     long n,i,j,head,pos,value,t;
 30     scanf("%ld",&n);
 31     for (i=1;i<=n;i++)
 32         for (j=1;j<=g;j++)
 33             scanf("%ld",&data[i].key[j]);
 34     for (i=1;i<n;i++)
 35         next[i]=i+1;
 36     next[n]=0;
 37     head=1;
 38     //key i
 39     for (i=g;i>=1;i--)
 40     {
 41         //值为j的链表的首地址，0代表j链表没有元素
 42         for (j=x;j<=y;j++)
 43             front[j]=0;
 44         pos=head;
 45         ///分配
 46         while (pos)
 47         {
 48             //把一个数添加到value链表的末尾
 49             value=data[pos].key[i];
 50             //如果原来value链表有元素，则原来value链表的末尾元素的后继为第pos个数
 51             //如果原来value链表没有元素，则value链表的起始元素为第pos个数
 52             if (front[value]!=0)
 53                 next[rear[value]]=pos;
 54             else
 55                 front[value]=pos;
 56             //当前value链表的末尾元素为第pos个数
 57             rear[value]=pos;
 58             pos=next[pos];
 59         }
 60         ///收集
 61         //把x链表,x+1链表,……,y链表 连接起来，而k链表的最后一个元素的后继为k+1链表的第一个元素
 62         value=x;
 63         while (front[value]==0)
 64             value++;
 65         head=front[value];
 66         while (value<=y)
 67         {
 68             t=value+1;
 69             while (front[t]==0 && t<=y)
 70                 t++;
 71             if (t==y+1)
 72                 break;
 73             next[rear[value]]=front[t];
 74             value=t;
 75         }
 76         next[rear[value]]=0;
 77     }
 78     printf("\n");
 79     pos=head;
 80     while (pos)
 81     {
 82         for (i=1;i<=g;i++)
 83             printf("%ld ",data[pos].key[i]);
 84         printf("\n");
 85         pos=next[pos];
 86     }
 87     return 0;
 88 }
 89 /*
 90 input:
 91 10
 92 1 1 2
 93 9 7 9
 94 3 8 5
 95 1 3 3
 96 5 4 3
 97 6 8 5
 98 2 1 3
 99 1 4 5
100 9 1 1
101 5 1 3
102 output:
103 1 1 2
104 1 3 3
105 1 4 5
106 2 1 3
107 3 8 5
108 5 1 3
109 5 4 3
110 6 8 5
111 9 1 1
112 9 7 9
113 */

 

2.基数排序+排序

 

//n个数，每个数有g个关键字
//可以在一次基数排序(桶排序)后，结合其它排序
//适用于：2~3个关键字，第一个关键字的范围较大，且分布较为分散，
    //通过第一个关键字把数分成若干个区间后，区间的大小较小，从而每个区间的排序时间也较小

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 //个数
  4 #define maxn 1000
  5 //数的范围 x~y
  6 #define x 0
  7 #define y 9
  8 //关键字个数
  9 #define g 3
 10 
 11 //n个数，每个数有g个关键字
 12 //可以在一次基数排序(桶排序)后，结合其它排序
 13 //适用于：2~3个关键字，第一个关键字的范围较大，且分布较为分散，
 14     //通过第一个关键字把数分成若干个区间后，区间的大小较小，从而每个区间的排序时间也较小
 15 
 16 struct node
 17 {
 18     //关键字的值
 19     long key[g+1];
 20 }data[maxn+1],f[maxn+1];
 21 //next:下一个数的编号
 22 //front,rear:一个链表的首,尾数据的编号
 23 long next[maxn+1],front[y-x+1],rear[y-x+1];
 24 
 25 void qsort_(long l,long r)
 26 {
 27     long i,j,p,q;
 28     struct node t;
 29     i=l; j=r; p=f[(l+r)>>1].key[2]; q=f[(l+r)>>1].key[3];
 30     while (i<=j)
 31     {
 32         while (f[i].key[2]<p || (f[i].key[2]==p && f[i].key[3]<q)) i++;
 33         while (f[j].key[2]>p || (f[j].key[2]==p && f[j].key[3]>q)) j--;
 34         if (i<=j)
 35         {
 36             t=f[i];
 37             f[i]=f[j];
 38             f[j]=t;
 39             i++;
 40             j--;
 41         }
 42     }
 43     if (i<r) qsort_(i,r);
 44     if (j>l) qsort_(l,j);
 45 }
 46 
 47 int main()
 48 {
 49     long n,i,j,head,pos,value,b;
 50     scanf("%ld",&n);
 51     for (i=1;i<=n;i++)
 52         for (j=1;j<=g;j++)
 53             scanf("%ld",&data[i].key[j]);
 54     for (i=1;i<n;i++)
 55         next[i]=i+1;
 56     next[n]=0;
 57     head=1;
 58     ///key 1
 59 
 60     //值为j的链表的首地址，0代表j链表没有元素
 61     for (j=x;j<=y;j++)
 62         front[j]=0;
 63     pos=head;
 64     ///分配
 65     while (pos)
 66     {
 67         //把一个数添加到value链表的末尾
 68         value=data[pos].key[1];
 69         //如果原来value链表有元素，则原来value链表的末尾元素的后继为第pos个数
 70         //如果原来value链表没有元素，则value链表的起始元素为第pos个数
 71         if (front[value]!=0)
 72             next[rear[value]]=pos;
 73         else
 74             front[value]=pos;
 75         //当前value链表的末尾元素为第pos个数
 76         rear[value]=pos;
 77         pos=next[pos];
 78     }
 79     ///收集
 80     printf("\n");
 81     j=0;
 82     for (i=x;i<=y;i++)
 83         if (front[i]!=0)
 84         {
 85             b=j+1;
 86             pos=front[i];
 87             while (pos!=rear[i])
 88             {
 89                 j++;
 90                 f[j]=data[pos];
 91                 pos=next[pos];
 92             }
 93             j++;
 94             f[j]=data[pos];
 95             qsort_(b,j);
 96         }
 97     for (i=1;i<=n;i++)
 98     {
 99         for (j=1;j<=g;j++)
100             printf("%ld ",f[i].key[j]);
101         printf("\n");
102     }
103     return 0;
104 }
105 /*
106 input:
107 10
108 1 1 2
109 9 7 9
110 3 8 5
111 1 3 3
112 5 4 3
113 6 8 5
114 2 1 3
115 1 4 5
116 9 1 1
117 5 1 3
118 output:
119 1 1 2
120 1 3 3
121 1 4 5
122 2 1 3
123 3 8 5
124 5 1 3
125 5 4 3
126 6 8 5
127 9 1 1
128 9 7 9
129 */

 

3.从前到后依次对关键字排序(不推荐)

 

//n个数，每个数有g个关键字
//如果从最前的关键字开始到最后的关键字排序，则需要sort(p,q,w) data[x]~data[y]排第w个关键字，
    //然后延伸出sort(s,t,w+1) [p<=s<=t<=q]
//该方法耗费大量时间和内存，不推荐

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 //个数
  4 #define maxn 1000
  5 //数的范围 x~y
  6 #define x 0
  7 #define y 9
  8 //关键字个数
  9 #define g 3
 10 
 11 //n个数，每个数有g个关键字
 12 //如果从最前的关键字开始到最后的关键字排序，则需要sort(p,q,w) data[x]~data[y]排第w个关键字，
 13     //然后延伸出sort(s,t,w+1) [p<=s<=t<=q]
 14 //该方法耗费大量时间和内存，不推荐
 15 
 16 struct node
 17 {
 18     //关键字的值
 19     long key[g+1];
 20 }data[maxn+1],f[maxn+1];
 21 //next:下一个数的编号
 22 //front,rear:一个链表的首,尾数据的编号
 23 
 24 void sort(long p,long q,long w)
 25 {
 26     long i,j,head,pos,value,next[maxn+1],front[y-x+1],rear[y-x+1],b[y+1],e[y+1];
 27     for (i=p;i<q;i++)
 28         next[i]=i+1;
 29     next[q]=0;
 30     head=p;
 31     //值为j的链表的首地址，0代表j链表没有元素
 32     for (j=x;j<=y;j++)
 33         front[j]=0;
 34     pos=head;
 35     ///分配
 36     while (pos)
 37     {
 38         //把一个数添加到value链表的末尾
 39         value=data[pos].key[w];
 40         //如果原来value链表有元素，则原来value链表的末尾元素的后继为第pos个数
 41         //如果原来value链表没有元素，则value链表的起始元素为第pos个数
 42         if (front[value]!=0)
 43             next[rear[value]]=pos;
 44         else
 45             front[value]=pos;
 46         //当前value链表的末尾元素为第pos个数
 47         rear[value]=pos;
 48         pos=next[pos];
 49     }
 50     ///收集
 51     for (i=p;i<=q;i++)
 52         f[i]=data[i];
 53     j=p-1;
 54     for (i=x;i<=y;i++)
 55         if (front[i]!=0)
 56         {
 57             b[i]=j+1;
 58             pos=front[i];
 59             while (pos!=rear[i])
 60             {
 61                 j++;
 62                 data[j]=f[pos];
 63                 pos=next[pos];
 64             }
 65             j++;
 66             data[j]=f[pos];
 67             e[i]=j;
 68         }
 69     if (w!=g)
 70     {
 71         for (i=x;i<=y;i++)
 72             //没有数或者只有1个数就不用排了
 73             if (front[i]!=0 && b[i]!=e[i])
 74                 sort(b[i],e[i],w+1);
 75     }
 76 }
 77 
 78 int main()
 79 {
 80     long i,j,n;
 81     scanf("%ld",&n);
 82     for (i=1;i<=n;i++)
 83         for (j=1;j<=g;j++)
 84             scanf("%ld",&data[i].key[j]);
 85     sort(1,n,1);
 86     printf("\n");
 87     for (i=1;i<=n;i++)
 88     {
 89         for (j=1;j<=g;j++)
 90             printf("%ld ",data[i].key[j]);
 91         printf("\n");
 92     }
 93     return 0;
 94 }
 95 /*
 96 input:
 97 10
 98 1 1 2
 99 9 7 9
100 3 8 5
101 1 3 3
102 5 4 3
103 6 8 5
104 2 1 3
105 1 4 5
106 9 1 1
107 5 1 3
108 output:
109 1 1 2
110 1 3 3
111 1 4 5
112 2 1 3
113 3 8 5
114 5 1 3
115 5 4 3
116 6 8 5
117 9 1 1
118 9 7 9
119 */

 

题目：

题目13基数排序的实现（学时：3）
A为每个关键字不超过3位的十进制整数关键字集合，试编写一个采用静态链表组织模式实现的基数排序程序将A进行由小到大的排序。

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 //个数
  4 #define maxn 1000
  5 //数的范围 x~y
  6 #define x 0
  7 #define y 9
  8 //关键字个数
  9 #define g 3
 10 
 11 //n个数，每个数有g个关键字
 12 //排序：从最后的关键字开始到最前的关键字
 13 //分配+收集
 14 //每个关键字分配+收集需要n+n时间，而共有g个关键字，时间复杂度为O(2ng)。
 15 //如果用数组，数据集中在一个区间，则区间的长度很长，另外的区间的内存浪费了。
 16 //用链表可以解决这个问题，且数据不需要先后顺序，所以无必要非要用数组
 17 
 18 struct node
 19 {
 20     //关键字的值
 21     long key[g+1];
 22 }data[maxn+1];
 23 //next:下一个数的编号
 24 //front,rear:一个链表的首,尾数据的编号
 25 long next[maxn+1],front[y-x+1],rear[y-x+1];
 26 
 27 int main()
 28 {
 29     char c;
 30     long n,i,j,head,pos,value,t;
 31     scanf("%ld",&n);
 32     for (i=1;i<=n;i++)
 33     {
 34         c=getchar();
 35         for (j=1;j<=g;j++)
 36         {
 37             c=getchar();
 38             data[i].key[j]=c-48;
 39         }
 40 
 41     }
 42     for (i=1;i<n;i++)
 43         next[i]=i+1;
 44     next[n]=0;
 45     head=1;
 46     //key i
 47     for (i=g;i>=1;i--)
 48     {
 49         //值为j的链表的首地址，0代表j链表没有元素
 50         for (j=x;j<=y;j++)
 51             front[j]=0;
 52         pos=head;
 53         ///分配
 54         while (pos)
 55         {
 56             //把一个数添加到value链表的末尾
 57             value=data[pos].key[i];
 58             //如果原来value链表有元素，则原来value链表的末尾元素的后继为第pos个数
 59             //如果原来value链表没有元素，则value链表的起始元素为第pos个数
 60             if (front[value]!=0)
 61                 next[rear[value]]=pos;
 62             else
 63                 front[value]=pos;
 64             //当前value链表的末尾元素为第pos个数
 65             rear[value]=pos;
 66             pos=next[pos];
 67         }
 68         ///收集
 69         //把x链表,x+1链表,……,y链表 连接起来，而k链表的最后一个元素的后继为k+1链表的第一个元素
 70         value=x;
 71         while (front[value]==0)
 72             value++;
 73         head=front[value];
 74         while (value<=y)
 75         {
 76             t=value+1;
 77             while (front[t]==0 && t<=y)
 78                 t++;
 79             if (t==y+1)
 80                 break;
 81             next[rear[value]]=front[t];
 82             value=t;
 83         }
 84         next[rear[value]]=0;
 85     }
 86     printf("\n");
 87     pos=head;
 88     while (pos)
 89     {
 90         for (i=1;i<=g;i++)
 91             printf("%ld",data[pos].key[i]);
 92         printf("\n");
 93         pos=next[pos];
 94     }
 95     return 0;
 96 }
 97 /*
 98 input:
 99 10
100 112
101 979
102 385
103 133
104 543
105 685
106 213
107 145
108 911
109 513
110 output:
111 112
112 133
113 145
114 213
115 385
116 513
117 543
118 685
119 911
120 979
121 */

 

posted @ 2017-05-06 21:54  congmingyige  阅读(384)  评论(0)  编辑  收藏  举报