-
基数排序
第一步
以LSD为例，假设原来有一串数值如下所示：
73, 22, 93, 43, 55, 14, 28, 65, 39, 81
首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：
0
1 81
2 22
3 73 93 43
4 14
5 55 65
6
7
8 28
9 39
第二步
接下来将这些桶子中的数值重新串接起来，成为以下的数列：
81, 22, 73, 93, 43, 14, 55, 65, 28, 39
接着再进行一次分配，这次是根据十位数来分配：
0
1 14
2 22 28
3 39
4 43
5 55
6 65
7 73
8 81
9 93
第三步
接下来将这些桶子中的数值重新串接起来，成为以下的数列：
14, 22, 28, 39, 43, 55, 65, 73, 81, 93
这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止。
LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好。MSD的方式与LSD相反，是由高位数为基底开始进行分配，但在分配之后并不马上合并回一个
数组中，而是在每个“桶子”中建立“子桶”，将每个桶子中的数值按照下一数位的值分配到“子桶”中。在进行完最低位数的分配后再合并回单一的
数组中。
时间效率
[1]
：设待排序列为n个记录，d个关键码，关键码的取值范围为radix（对于非负整数，就是0到9），则进行链式基数排序的
时间复杂度为O(d(n+radix))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。 空间效率：需要2*radix个指向队列的辅助空间，以及用于
静态链表的n个
指针。
实现方法
最高位优先(Most Significant Digit first)法，简称MSD法（几乎不用）：先按k1排序分组，同一组中记录，关键码k1相等，再对各组按k2排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd对各子组排序后。再将各组连接起来，便得到一个有序序列。
最低位优先(Least Significant Digit first)法，简称LSD法：先从kd开始排序，再对kd-1进行排序，依次重复，直到对k1排序后便得到一个有序序列。
实现方法一：
C语言
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
|
#include<math.h>
testBS()
{
inta[] = {2, 343, 342, 1, 123, 43, 4343, 433, 687, 654, 3};
int
*a_p = a;
//计算数组长度
intsize =
sizeof
(a) /
sizeof
(
int
);
//基数排序
bucketSort3(a_p, size);
//打印排序后结果
inti;
for
(i = 0; i < size; i++)
{
printf
(
"%d\n"
, a[i]);
}
intt;
scanf
(
"%d"
, t);
}
//基数排序
voidbucketSort3(
int
*p, intn)
{
//获取数组中的最大数
intmaxNum = findMaxNum(p, n);
//获取最大数的位数，次数也是再分配的次数。
intloopTimes = getLoopTimes(maxNum);
inti;
//对每一位进行桶分配
for
(i = 1; i <= loopTimes; i++)
{
sort2(p, n, i);
}
}
//获取数字的位数
intgetLoopTimes(intnum)
{
intcount = 1;
inttemp = num / 10;
while
(temp != 0)
{
count++;
temp = temp / 10;
}
returncount;
}
//查询数组中的最大数
intfindMaxNum(
int
*p, intn)
{
inti;
intmax = 0;
for
(i = 0; i < n; i++)
{
if
(*(p + i) > max)
{
max = *(p + i);
}
}
returnmax;
}
//将数字分配到各自的桶中，然后按照桶的顺序输出排序结果
voidsort2(
int
*p, intn, intloop)
{
//建立一组桶此处的20是预设的根据实际数情况修改
intbuckets[10][20] = {};
//求桶的index的除数
//如798个位桶index=(798/1)%10=8
//十位桶index=(798/10)%10=9
//百位桶index=(798/100)%10=7
//tempNum为上式中的1、10、100
inttempNum = (
int
)
pow
(10, loop - 1);
inti, j;
for
(i = 0; i < n; i++)
{
introw_index = (*(p + i) / tempNum) % 10;
for
(j = 0; j < 20; j++)
{
if
(buckets[row_index][j] == NULL)
{
buckets[row_index][j] = *(p + i);
break
;
}
}
}
//将桶中的数，倒回到原有数组中
intk = 0;
for
(i = 0; i < 10; i++)
{
for
(j = 0; j < 20; j++)
{
if
(buckets[i][j] != NULL)
{
*(p + k) = buckets[i][j];
buckets[i][j] = NULL;
k++;
}
}
}
}
|
Java语言
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
public
class
RadixSort
{
public
static
void
sort(
int
[] number,
int
d)
//d表示最大的数有多少位
{
intk =
0
;
intn =
1
;
intm =
1
;
//控制键值排序依据在哪一位
int
[][]temp = newint[
10
][number.length];
//数组的第一维表示可能的余数0-9
int
[]order = newint[
10
];
//数组orderp[i]用来表示该位是i的数的个数
while
(m <= d)
{
for
(inti =
0
; i < number.length; i++)
{
intlsd = ((number[i] / n) %
10
);
temp[lsd][order[lsd]] = number[i];
order[lsd]++;
}
for
(inti =
0
; i <
10
; i++)
{
if
(order[i] !=
0
)
for
(intj =
0
; j < order[i]; j++)
{
number[k] = temp[i][j];
k++;
}
order[i] =
0
;
}
n *=
10
;
k =
0
;
m++;
}
}
public
static
void
main(String[] args)
{
int
[]data =
{
73
,
22
,
93
,
43
,
55
,
14
,
28
,
65
,
39
,
81
,
33
,
100
};
RadixSort.sort(data,
3
);
for
(inti =
0
; i < data.length; i++)
{
System.out.print(data[i] +
""
);
}
}
}
|
c++
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
int
maxbit(
int
data[],
int
n)
//辅助函数，求数据的最大位数
{
int
d = 1;
//保存最大的位数
int
p = 10;
for
(
int
i = 0; i < n; ++i)
{
while
(data[i] >= p)
{
p *= 10;
++d;
}
}
return
d;
}
void
radixsort(
int
data[],
int
n)
//基数排序
{
int
d = maxbit(data, n);
int
*tmp = newint[n];
int
*count = newint[10];
//计数器
int
i, j, k;
int
radix = 1;
for
(i = 1; i <= d; i++)
//进行d次排序
{
for
(j = 0; j < 10; j++)
count[j] = 0;
//每次分配前清空计数器
for
(j = 0; j < n; j++)
{
k = (data[j] / radix) % 10;
//统计每个桶中的记录数
count[k]++;
}
for
(j = 1; j < 10; j++)
count[j] = count[j - 1] + count[j];
//将tmp中的位置依次分配给每个桶
for
(j = n - 1; j >= 0; j--)
//将所有桶中记录依次收集到tmp中
{
k = (data[j] / radix) % 10;
tmp[count[k] - 1] = data[j];
count[k]--;
}
for
(j = 0; j < n; j++)
//将临时数组的内容复制到data中
data[j] = tmp[j];
radix = radix * 10;
}
delete
[]tmp;
delete
[]count;
}
|
法二：（自己）
//只用于非负整数排序
#include <stdio.h>
#define MAXN 10
void radixsort(int data[],int length)//length为元素个数
{
int *dight[10];//0到9
for(int i=0;i<=9;i++){
dight[i]=(int *)malloc(sizeof(int)*length);//分配空间，每个下标的空间均为元素个数
dight[i][0]=0;//存当前此下标带领的元素的个数
}
int maxnumber=-1;//得到最大数
for(int i=0;i<length;i++){
if(data[i]>maxnumber)
maxnumber=data[i];
}
int maxdight=0;//最大数的位数就为遍历次数
while(maxnumber){
maxdight++;
maxnumber/=10;
}
for(int i=1;i<=maxdight;i++){
int pow=1;//取得当前位的媒介，才能获得每个数的当前位
for(int j=1;j<i;j++)
pow*=10;
for(int j=0;j<=9;j++){//每个下标找当前自己的元素
for(int t=0;t<length;t++){
if(data[t]/pow%10==j){
int num=++dight[j][0];
dight[j][num]=data[t];
}
}
}
//复位
int top=-1;
for(int i=0;i<=9;i++){
for(int j=1;j<=dight[i][0];j++)
data[++top]=dight[i][j];
dight[i][0]=0;
}
}
return;
}
int main(){
int data[MAXN];
for(int i=0;i<MAXN;i++)
scanf("%d",&data[i]);
radixsort(data,MAXN);
for(int i=0;i<MAXN;i++)
printf("%d%c",data[i],i==MAXN-1?'\n':' ');
return 0;
}
- /********************************************************
- *函数名称：GetNumInPos
- *参数说明：num 一个整形数据
- * pos 表示要获得的整形的第pos位数据
- *说明： 找到num的从低到高的第pos位的数据
- *********************************************************/
- int GetNumInPos(int num,int pos)
- {
- int temp = 1;
- for (int i = 0; i < pos - 1; i++)
- temp *= 10;
- return (num / temp) % 10;
- }
- /********************************************************
- *函数名称：RadixSort
- *参数说明：pDataArray 无序数组；
- * iDataNum为无序数据个数
- *说明： 基数排序
- *********************************************************/
- #define RADIX_10 10 //整形排序
- #define KEYNUM_31 10 //关键字个数，这里为整形位数
- void RadixSort(int* pDataArray, int iDataNum)
- {
- int *radixArrays[RADIX_10]; //分别为0~9的序列空间
- for (int i = 0; i < 10; i++)
- {
- radixArrays[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));
- radixArrays[i][0] = 0; //index为0处记录这组数据的个数
- }
- for (int pos = 1; pos <= KEYNUM_31; pos++) //从个位开始到31位
- {
- for (int i = 0; i < iDataNum; i++) //分配过程
- {
- int num = GetNumInPos(pDataArray[i], pos);
- int index = ++radixArrays[num][0];
- radixArrays[num][index] = pDataArray[i];
- }
- for (int i = 0, j =0; i < RADIX_10; i++) //收集
- {
- for (int k = 1; k <= radixArrays[i][0]; k++)
- pDataArray[j++] = radixArrays[i][k];
- radixArrays[i][0] = 0; //复位
- }
- }
- }
法四：（可以排序负数）
a）计算在某一分位上的数据
b）对某一分位上的数据按照0~10排序
c）根据b中的排序结果，对实际的数据进行排序
d）把a、b、c组合起来构成基数排序，直到某一分位上的数据为0
总结：
（1）测试的时候注意负数的情形
（2）如果在某一位数据相同，那么需要考虑上一轮数据排序的情况
（3）代码中多次分配小空间，此处代码待优化
补充：
（1） 1修改了余数取值范围，这样负数也可以参加排序
（2）增加了一个swap内存分配，避免了内存的重复分配和释放
（3）删除了count计数，一旦发现有不等于0的数据直接返回为1，不需要全部遍历数据
90
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
