【算法与数据结构】—— 基数排序（后缀数组基础）

基数排序

---

定义：
基数排序(Radix Sort)是桶排序的扩展，它的基本思想是：将整数按位切割成不同的数字，然后按每个位数分别比较（位操作）。
具体做法是：将待排序序列中的所有数字统一为同一数位长度，数位较短的数前面补零（比如对于序列{1,23,456}而言，需要将这序列格式化为{001,023,456}）。然后从最低位开始，依次排序，直到最高位排序完成以后, 数列就变成一个有序序列。

---

下面通过一个实际的例子来进行阐述。
假设现在需要对数组{42, 6, 184, 671, 24, 819, 352, 74}进行排序，采用基数排序的流程如下：

在上图中，首先是将所有待排序数值的长度统一（比如在上面的数字集合中，最大的数是个三位数，因此需要将上面的数字集合中的42改写为042、6改写为006、24改写为024、74改写为074），然后再从最低位开始，依次进行排序，排序流程如下：

1. 按照个位数进行排序。
2. 按照十位数进行排序。
3. 按照百位数进行排序。

最终，数列就变成了一个有序序列。
实际上，每个位上的排序其主要思路都是一致的。也就是说如果我们能够实现对其中某个位置上的排序，那么剩下的那些都将迎刃而解。下面我们就以“个位”为例，对数组{42, 6, 184, 671, 24, 819, 352, 74}进行基数排序，其过程如下：
① 首先，我们需要定义一个用于统计数字[0,9]的出现次数的桶数组buckets[ ]，并将其中的所有元素初始化为0。显然，其长度应设为10；
② 接下来我们对原数组中个位上的各个值进行统计，如下：

此时我们得到的桶数组的值为：buckets[10]={0,1,2,0,3,0,1,0,0,1}。
紧接着，我们对桶数组中的每项都进行一个前缀累加操作，此时桶数组中的值更新为：
buckets[10]={0,1,3,3,6,6,7,7,7,8}。
③ 对于原数组ary[8]={42, 6, 184, 671, 24, 819, 352, 74}，如果仅按个位上的值进行排序的话，我们容易得到答案为ans[8]={671, 42, 352, 184, 24, 74, 6, 819}（数值相同时，就依照其本身的前后位置进行排列）。此时我们来分析桶数组buckets[ ]、排序后的数组ans[ ]以及原数组ary[ ]之间的关系，看能否从中找到联系：

如上图所示：如果我们从最后一项往前看，首先是ary[7]=74，其个位上的数为4；
对应看buckets[4]=6，而在最终的结果数组ans中，ans[6-1]=ans[5]正好等于74。

继续往上推，接下来是ary[6]=352，其个位上的数为2；
对应看buckets[2]=3，而在最终的结果数组ans中，ans[3-1]=ans[2]正好等于352。

再往上推是ary[5]=819，其个位上的数为9；
对应看buckets[9]=8，而在最终的结果数组ans中ans[8-1]=ans[7]正好等于819。

不难发现，对于初始数组ary而言，如果我们仅看待排序的数在某个位置上的值（比如上面仅看个位），那么若将这个值取出作为buckets数组的索引，其对应的取值再减1就是最终该数按某个位置进行排序后在ans数组中的位置。
这个规律是否真的成立呢？我们再继续往上走试试，此时是ary[4]=24，其个位上的数为4。问题来了，我们最开始从ary数组中取ary[7]时，其个位上的值也是4啊。如果我们在取ary[4]=24时还和上面执行一样的过程，那必然会导致最终ans[5]的值由之前的74更新为24，但是这样显然是不正确的。
如果耐心一点，我们可以做一个大胆的猜想：每次在buckets数组中的某个值被取用后，我们就将这个值减1。比如在第一次遇到ary[7]=74时，其个位上的值为4，对应在buckets[ ]数组中，buckets[4]=6，此时，我们将buckets[4]自减1，然后得到buckets[4]=5，并将5作为74在ans数组中的索引；接下来，当到了ary[4]=24时，其个位上的值也为4，对应在buckets[ ]数组中，buckets[4]=5，此时，我们将buckets[4]自减1，然后得到buckets[4]=4，并将4作为24在ans数组中的索引……根据这样的规律，我们可以不断地往上推，最终你会发现，得出的ans数组和上图中给出的完全一致。
你可以将上面的ary数组内容替换成任意非负整数序列，会发现上述规律对其都将适用。
如此一来，我们就得到了桶数组buckets[ ]、排序后的数组ans[ ]与原数组ary[ ]在某个位上的关系。有了这个关系，我们就可以设计相关的算法来完成对“个位”进行基数排序的算法。拓展一下也就能完成对其他“十位”、“百位”……等位置的排序。如果把某个位（如“个位”、“十位”等）作为一个参数，就能得到一个通用的基数排序函数。

下面给出实现基数排序的完整代码（附详细解释）：

/*
 * 获取数组a中最大值
 *
 * 参数说明：
 *     a -- 数组
 *     n -- 数组长度
 */
int get_max(int a[], int n)
{
    int i, max;

    max = a[0];
    for (i = 1; i < n; i++)
        if (a[i] > max)
            max = a[i];
    return max;
}

/*
 * 对数组按照"某个位数"进行排序(桶排序)
 *
 * 参数说明：
 *     a -- 数组
 *     n -- 数组长度
 *     exp -- 指数。对数组a按照该指数进行排序。
 *
 * 例如，对于数组a={42, 6, 352, 671, 24, 819, 184, 76}；
 *    (01) 当exp=1表示按照"个位"对数组a进行排序
 *    (02) 当exp=10表示按照"十位"对数组a进行排序
 *    (03) 当exp=100表示按照"百位"对数组a进行排序
 *    ...
 */
void count_sort(int a[], int n, int exp)
{
    int output[n];             	//存放排序后的数组
    int i, buckets[10] = {0};

    //将数据出现的次数存储在buckets[]中
    for (i = 0; i < n; i++)
        buckets[ (a[i]/exp)%10 ]++;

    //更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在output[]中的位置
    for (i = 1; i < 10; i++)
        buckets[i] += buckets[i - 1];

    //将数据存储到临时数组output[]中
    for (i = n - 1; i >= 0; i--)
    {
        output[buckets[ (a[i]/exp)%10 ] - 1] = a[i];
        buckets[ (a[i]/exp)%10 ]--;
    }

    //将排序好的数据赋值给a[]
    for (i = 0; i < n; i++)
        a[i] = output[i];
}

/*
 * 基数排序
 *
 * 参数说明：
 *     a -- 数组
 *     n -- 数组长度
 */
void radix_sort(int a[], int n)
{
    int exp;    //指数。当对数组按各位进行排序时，exp=1；按十位进行排序时，exp=10；...
    int max = get_max(a, n);    //数组a中的最大值

    //从个位开始，对数组a按"指数"进行排序
    for (exp = 1; max/exp > 0; exp *= 10)
        count_sort(a, n, exp);
}

radix_sort(a, n)的作用是对数组a进行基数排序。

1. 首先通过get_max(a)获取数组a中的最大值。获取最大值的目的是计算出数组a的最大指数。
2. 获取到数组a中的最大指数后，再从指数1开始，根据位数对数组a中的元素进行排序。
3. count_sort(a, n, exp)的作用是对数组a按照指数exp进行排序。

---

上面给出的算法仅仅是针对非负整数序列，有同学肯定要问了，那有没有更强大的，对所有整数序列都适用的呢？当然是有的。
仔细想，在加入负数之后，对于整个序列而言，相当于新添了9种新状态：-1、-2、……、-8、-9。那么我们要想办法将这些新的状态和之前的0、1、……、8、9加以区别。
有一种很简单的办法是：将a[i]%10+10（a[i]是存放初始序列的数组），这样一来就可以将所有的负数控制在[1,9]之间，同时将所有的非负数控制在[10,19]之间。说白了就是将上面的buckets[ ]数组容量扩大即可。并且在执行a[i]%10+10后，对于其中的每个a[i]而言，相对大小都未发生改变（毕竟大家都增加了10）。因此这样处理a[i]，对于sort函数而言并不会使其失去正确性。
基于这样的一种思路，下面给出适用于所有整数序列的基数排序算法（仅需要修改sort函数即可）：

void sort(int a[], int n, int exp)
{
	int[] output = new int[n]; 				//存储"被排序数据"的临时数组
	int i, buckets[] = new int[20];			//负数只需要把buckets容量扩大为20个即可
	
	//将数据出现的次数存储在buckets[]中
	for (i = 0; i < n; i++)
	    buckets[ (a[i]/exp)%10 + 10 ]++;
	
	//更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在output[]中的位置。
	for (i = 1; i < 20; i++)
	    buckets[i] += buckets[i - 1];
	
	//将数据存储到临时数组output[]中
	for (i = n - 1; i >= 0; i--){
	    output[buckets[ (a[i]/exp)%10 + 10 ] - 1] = a[i];
	    buckets[ (a[i]/exp)%10 + 10 ]--;
	}
	
	//将排序好的数据赋值给a[]
	for (i = 0; i < n; i++)
	   a[i] = output[i];
}

---