为什么在Distribution-Counting排序算法中从右到左处理输入数组更好？

Question

这是算法

作者说

  

＆＃34;从右到左处理输入数组更方便。＆＃34;

与从0到n-1读取数组有什么不同？

Answer 1

从左到右，一个简单的选择是使D []一个元素变大。 D [] = u + 2 - l的大小。最后一个条目不用于分发，但它使用检查来保存跳过A [] == u或使用两个局部变量的情况。最终目标是D [0] = 0，D [1] = u的实例，D [2] =＃+ u + 1个实例的实例，...

    for j ← 0 to u+1-l do D[j] = 0                     // reset counts
    for i ← 0 to n-1   do D[A[i]+1-l] = D[A[i]+1-l]+1  // set   counts
    for j ← 2 to u-l   do D[j] ← D[j-1] + D[j]         // convert to indicies
    for i ← 0 to n-1 do                                // distribute
        j ← A[i] - l
        S[D[j]] ← A[i]
        D[j] ← D[j] + 1
    return S

改为使用两个局部变量：

    for j ← 0 to u+l do D[j] = 0                       // reset counts
    for i ← 0 to n-1 do D[A[i]-l] = D[A[i]-l]+1        // set   counts
    k = 0                                              // k == sum
    for j ← 0 to u-l do                                // convert to indicies
        i ← D[j]
        D[j] ← k
        k ← k + i
    for i ← 0 to n-1 do                                // distribute
        j ← A[i] - l
        S[D[j]] ← A[i]
        D[j] ← D[j] + 1
    return S

而不是分发，它可能只是一个计数类型：

    for j ← 0 to u-l do C[j] = 0                       // reset counts
    for i ← 0 to n-1 do C[A[i]-l] = C[A[i]-l]+1        // set   counts
    i = 0                                              // generate sorted array
    for j ← 0 to u-l do
        while(C[j] != 0) do
            S[i] ← j-l
            i ← i+1
            C[j] ← C[j]-1
    return S

Answer 2

在最后一步中处理输入数组的顺序无关紧要。作者错了。

但是，从右到左填充输出数组中的“bins”更方便。也可以从左到右填充它们，增加D中的索引而不是降低它们，但这使得计算累积频率的第三步更加复杂。

Answer 3

我没有看到任何差异。实际上，无论元素A的顺序如何，结果都是一样的。

也许，作者暗示了一些具体的实现。例如。在C ++中，for(size_t i = n; i--; )更短，更方便了某些人。