你会想看一看博士们的大规模基因组序列处理。笠原和森下。

由四个核苷酸字母A、C、G和T组成的字符串可以特别编码为整数，以便更快地处理。基数排序是书中讨论的许多算法之一;您应该能够适应这个问题的公认答案，并看到一个很大的性能改进。

看起来您已经解决了这个问题，但是为了记录，似乎有一种可行的就地基数排序是“美国国旗排序”。这里描述了:工程基数排序。一般的想法是对每个字符进行2次传递——首先计算每个字符有多少个，这样就可以将输入数组细分为箱子。然后再执行一遍，将每个元素交换到正确的bin中。现在递归地对每个箱子的下一个字符位置排序。

我将对字符串的打包位表示进行burst排序。突发排序被认为比基数排序有更好的局部性，用突发尝试代替经典尝试减少了额外的空间使用。原始论文有测量。

虽然公认的答案完美地回答了问题的描述，但我已经到达了这个地方，徒劳地寻找一种算法将一个数组内联划分为N部分。我自己也写过一个，就是这个。

警告:这不是一个稳定的分区算法，因此对于多层分区，必须对每个结果分区重新分区，而不是对整个数组重新分区。优点是它是内联的。

它有助于解决所提出的问题的方法是，您可以根据字符串中的一个字母重复进行内联分区，然后在分区足够小时使用您选择的算法对分区进行排序。

  function partitionInPlace(input, partitionFunction, numPartitions, startIndex=0, endIndex=-1) {
    if (endIndex===-1) endIndex=input.length;
    const starts = Array.from({ length: numPartitions + 1 }, () => 0);
    for (let i = startIndex; i < endIndex; i++) {
      const val = input[i];
      const partByte = partitionFunction(val);
      starts[partByte]++;
    }
    let prev = startIndex;
    for (let i = 0; i < numPartitions; i++) {
      const p = prev;
      prev += starts[i];
      starts[i] = p;
    }
    const indexes = [...starts];
    starts[numPartitions] = prev;
  
    let bucket = 0;
    while (bucket < numPartitions) {
      const start = starts[bucket];
      const end = starts[bucket + 1];
      if (end - start < 1) {
        bucket++;
        continue;
      }
      let index = indexes[bucket];
      if (index === end) {
        bucket++;
        continue;
      }
  
      let val = input[index];
      let destBucket = partitionFunction(val);
      if (destBucket === bucket) {
        indexes[bucket] = index + 1;
        continue;
      }
  
      let dest;
      do {
        dest = indexes[destBucket] - 1;
        let destVal;
        let destValBucket = destBucket;
        while (destValBucket === destBucket) {
          dest++;
          destVal = input[dest];
          destValBucket = partitionFunction(destVal);
        }
  
        input[dest] = val;
        indexes[destBucket] = dest + 1;
  
        val = destVal;
        destBucket = destValBucket;
      } while (dest !== index)
    }
    return starts;
  }

我从未见过就地基数排序，从基数排序的性质来看，只要临时数组适合内存，我怀疑它比就地排序快得多。

原因:

排序对输入数组进行线性读取，但所有写入几乎都是随机的。从特定的N开始，这可以归结为每次写入的缓存丢失。这种缓存缺失会减慢你的算法。它是否到位并不会改变这种效果。

我知道这不能直接回答您的问题，但是如果排序是一个瓶颈，那么您可能想要看看作为预处理步骤的近似排序算法(软堆上的wiki-page可以让您开始)。

这可以很好地提高缓存的局部性。课本上的错位基数排序会表现得更好。写入仍然几乎是随机的，但至少它们会聚集在相同的内存块周围，这样就增加了缓存命中率。

但我不知道这在实践中是否可行。

顺便说一句:如果你只处理DNA字符串:你可以将一个字符压缩成两个比特，并打包大量数据。这将把内存需求减少到原始表示的四倍。寻址变得更加复杂，但无论如何，CPU的ALU在所有缓存丢失期间都有大量的时间。

你会想看一看博士们的大规模基因组序列处理。笠原和森下。

由四个核苷酸字母A、C、G和T组成的字符串可以特别编码为整数，以便更快地处理。基数排序是书中讨论的许多算法之一;您应该能够适应这个问题的公认答案，并看到一个很大的性能改进。