基数排序

 

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，为桶排法的改进，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序。

基本解法

第一步

以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 10void 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;}

他人：

1. /******************************************************** 
2. *函数名称：GetNumInPos 
3. *参数说明：num 一个整形数据 
4. *          pos 表示要获得的整形的第pos位数据 
5. *说明：    找到num的从低到高的第pos位的数据 
6. *********************************************************/  
7. int GetNumInPos(int num,int pos)  
8. {  
9.     int temp = 1;  
10.     for (int i = 0; i < pos - 1; i++)  
11.         temp *= 10;  
12.   
13.     return (num / temp) % 10;  
14. }  
15.   
16. /******************************************************** 
17. *函数名称：RadixSort 
18. *参数说明：pDataArray 无序数组； 
19. *          iDataNum为无序数据个数 
20. *说明：    基数排序 
21. *********************************************************/  
22. #define RADIX_10 10    //整形排序  
23. #define KEYNUM_31 10     //关键字个数，这里为整形位数  
24. void RadixSort(int* pDataArray, int iDataNum)  
25. {  
26.     int *radixArrays[RADIX_10];    //分别为0~9的序列空间  
27.     for (int i = 0; i < 10; i++)  
28.     {  
29.         radixArrays[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));  
30.         radixArrays[i][0] = 0;    //index为0处记录这组数据的个数  
31.     }  
32.       
33.     for (int pos = 1; pos <= KEYNUM_31; pos++)    //从个位开始到31位  
34.     {  
35.         for (int i = 0; i < iDataNum; i++)    //分配过程  
36.         {  
37.             int num = GetNumInPos(pDataArray[i], pos);  
38.             int index = ++radixArrays[num][0];  
39.             radixArrays[num][index] = pDataArray[i];  
40.         }  
41.   
42.         for (int i = 0, j =0; i < RADIX_10; i++)    //收集  
43.         {  
44.             for (int k = 1; k <= radixArrays[i][0]; k++)  
45.                 pDataArray[j++] = radixArrays[i][k];  
46.             radixArrays[i][0] = 0;    //复位  
47.         }  
48.     }  
49. }  

法四：（可以排序负数）

 a）计算在某一分位上的数据

[cpp] view plain copy

1. int pre_process_data(int array[], int length, int weight)  
2. {  
3.     int index ;  
4.     int value = 1;  
5.   
6.     for(index = 0; index < weight; index++)  
7.         value *= 10;  
8.   
9.     for(index = 0; index < length; index ++)  
10.         array[index] = array[index] % value /(value /10);  
11.   
12.     for(index = 0; index < length; index ++)  
13.         if(0 != array[index])  
14.             return 1;  
15.   
16.     return 0;  
17. }  

    b）对某一分位上的数据按照0~10排序

[cpp] view plain copy

1. void sort_for_basic_number(int array[], int length, int swap[])  
2. {  
3.     int index;  
4.     int basic;  
5.     int total = 0;  
6.   
7.     for(basic = -9; basic < 10; basic++){  
8.         for(index = 0; index < length; index++){  
9.             if(-10 != array[index] && basic == array[index] ){  
10.                 swap[total ++] = array[index];  
11.                 array[index] = -10;  
12.             }  
13.         }  
14.     }  
15.   
16.     memmove(array, swap, sizeof(int) * length);  
17. }  

    c）根据b中的排序结果，对实际的数据进行排序

[cpp] view plain copy

1. void sort_data_by_basic_number(int array[], int data[], int swap[], int length, int weight)  
2. {  
3.     int index ;  
4.     int outer;  
5.     int inner;  
6.     int value = 1;  
7.   
8.     for(index = 0; index < weight; index++)  
9.         value *= 10;  
10.   
11.     for(outer = 0; outer < length; outer++){  
12.         for(inner = 0; inner < length; inner++){  
13.             if(-10 != array[inner] && data[outer]==(array[inner] % value /(value/10))){  
14.                 swap[outer] = array[inner];  
15.                 array[inner] = -10;  
16.                 break;  
17.             }  
18.         }  
19.     }  
20.   
21.     memmove(array, swap, sizeof(int) * length);  
22.     return;  
23. }  

    d）把a、b、c组合起来构成基数排序，直到某一分位上的数据为0

[cpp] view plain copy

1. void radix_sort(int array[], int length)  
2. {  
3.     int* pData;  
4.     int weight = 1;  
5.     int count;  
6.     int* swap;  
7.     if(NULL == array || 0 == length)  
8.         return;  
9.   
10.     pData = (int*)malloc(sizeof(int) * length);  
11.     assert(NULL != pData);  
12.     memmove(pData, array, length * sizeof(int));  
13.   
14.     swap = (int*)malloc(sizeof(int) * length);  
15.     assert(NULL != swap);  
16.   
17.     while(1){  
18.         count = pre_process_data(pData, length, weight);  
19.         if(!count)  
20.             break;  
21.   
22.         sort_for_basic_number(pData, length, swap);  
23.         sort_data_by_basic_number(array, pData, swap, length, weight);  
24.         memmove(pData, array, length * sizeof(int));  
25.         weight ++;  
26.     }  
27.   
28.     free(pData);  
29.     free(swap);  
30.     return;  
31. }  

总结：

    （1）测试的时候注意负数的情形

    （2）如果在某一位数据相同，那么需要考虑上一轮数据排序的情况

    （3）代码中多次分配小空间，此处代码待优化

补充：

    （1） 1修改了余数取值范围，这样负数也可以参加排序

    （2）增加了一个swap内存分配，避免了内存的重复分配和释放

    （3）删除了count计数，一旦发现有不等于0的数据直接返回为1，不需要全部遍历数据