标签: radix-sort

正如标题所说,基数排序是唯一的非比较排序算法吗？我的猜测是肯定的.

下面是一个用Java编写的LSD Radix排序实现,用于对字符串数组进行排序,其中每个字符串都包含完全W字符.

我想计算运行时期间的数组访问次数.我已经读过LSD排序应该要求n * c数组访问,其中n字符串c的数量和每个字符串中的字符数量.但是,下面的算法会多次访问多个数组.如果我在这些中增加一个计数器,我最终会得到一个重要的因素nc.

那么究竟什么构成了算法上下文中的"数组访问"？是否只有一个数组访问实例被认为更重要,我应该在这里计算,或者这个示例实际上是一个低效的实现,它使用了多于必要的数组访问？

 public int lsdSort(String[] array, int W) {
  int access = 0;
  // Sort a[] on leading W characters.
  int N = array.length;
  String[] aux = new String[N];
  for (int d = W-1; d >= 0; d--)
  { // Sort by key-indexed counting on dth char.
    int[] count = new int[R+1]; // Compute frequency counts.
    for (int i = 0; i < N; i++) { …

order()如果我使用indata.frame和，我会得到不同的结果data.table。例如：

A <- data.frame(one = c("k"), two = c("3_28","31_60","48_68"))
B <- as.data.table(A)

A[order(A$one,A$two), ]
#   one   two
# 1   k  3_28
# 2   k 31_60
# 3   k 48_68


B[order(B$one, B$two), ]
#    one   two
# 1:   k 31_60
# 2:   k  3_28
# 3:   k 48_68

我必须承认这有点令人震惊，因为多年来我一直假设order()结果data.frame相同data.table。我想我需要检查很多代码！

有什么方法可以确保和order()给出相同的结果吗？data.framedata.table

如果这种行为差异已经众所周知，并且这只是我无知的一个例子，我深表歉意。

优先使用任何非病毒开源许可证

我想出了以下内容,但可以预见它不起作用.

var t = new Array(a.length);
var r = 4;
var b = 64;

var count = new Array(1<<r);
var pref = new Array(1<<r);

var groups = Math.ceil(b / r);

var mask = (1 << r) - 1;

var shift = 0;
for(var c = 0; c < groups; c++)
{
    shift += r;

    for(var j = 0; j < count.length; j++)
    {
        count[j] = 0;
    }

    for(var i = 0; i < a.length; i++)
    {
        count[ (a[i] >> shift) …

以下基数排序执行四次计数排序（256 个桶，32 位整数，从最低有效数字开始），取自Sedgewick 的算法教科书。

public class LSD {
    private final static int BITS_PER_BYTE = 8;

    // LSD sort an array of integers, treating each int as 4 bytes
    // assumes integers are nonnegative
    // [ 2-3x faster than Arrays.sort() ]
    public static void sort(int[] a) {
    int BITS = 32;                 // each int is 32 bits 
    int W = BITS / BITS_PER_BYTE;  // each int is 4 bytes
    int R = 1 << BITS_PER_BYTE;    // each bytes is …

我只是在阅读以下问题： 基数排序最高有效还是最低有效，哪个更快？

接受答案的作者暗示，MSD基数排序确实更快。我不明白为什么。

我已经实现了LSD和MSD（通过执行移位操作来实现二进制），LSD是迭代的，只需要一个存储桶数组，而MSD是递归的，并且每个递归调用都需要一个单独的存储桶数组。

如果您创建一个由1000万个整数组成的随机数组，那么我将看不到MSD会比LSD快多少，因为每次您重新输入函数时都会分配额外的存储桶数组，并且您还必须面对递归调用的开销他们自己。

我可以看到MSD和LSD的组合如何带来整体提升（对前几位运行MSD，对其余位运行LSD以减少高速缓存未命中），但是单独的MSD有望比LSD更有效考虑到它的递归特性以及每个递归调用都需要一个新的存储桶数组这一事实，与LSD不同，LSD既是迭代的，又只需要一个存储桶数组来完成整个排序过程？

如果我只需要对由ASCII字符组成的字符串进行排序,那么想知道使用最重要和最不重要的基数排序之间有什么区别？我认为他们应该有相同的结果,但是被以下链接中的以下声明搞糊涂了,如果有人可以帮助澄清,那就太棒了.

https://en.wikipedia.org/wiki/Radix_sort

最高位数(MSD)基数排序可用于按字典顺序对键进行排序.与最低有效位(LSD)基数排序不同,最重要的数字基数排序不一定保留重复键的原始顺序.

林先生,提前谢谢

我一直在研究,虽然我已经想出了使用Radix Sort来按字母顺序排列字符串数组的一般想法,但我知道我的方向是错误的.

这是我到目前为止:

void radixSort(string* sortMe, int l)
{
    queue<string>* sections = new queue<string>[27];    //Have a-z, and also one for strings that are null terminated.
    for(int i = 0; i < numElements; i++)
    {
        if(!(sortMe[i][l] == 32))
            sections[sortMe[i][l]-96].push(sortMe[i]);      //-96 because the ascii code for a is 97. If, for example a is the character, it will be placed at 1. 0 is left for null characters
    }

    for(int i =0; i < 26; i++)
    {
        while(!sections[i].empty())
        {
            temp.push_back(sections[i].front());
            sections[i].pop();
        } …

给定N个8位数字的数组(值0-255)？

如何找到中位数？

我尝试了基数排序和中位数算法的中位数.

如果数字的值在0到255之间,有没有更好的方法？