Question

 public static int[] Sort(int[] ints)
        {
            var dictionary = new IndexedDictionary<int, int>();

            foreach (var i in ints)
            {
                dictionary.Add(i, i);
            }

            for (int i = 0; i <= ints.Length - 1; i++)
            {
                var indexValue = dictionary[i].Key;

                dictionary[indexValue - 1].Value = indexValue;
            }

            return dictionary.Values();
        }

这是一个桶排序吗？我看过几种水桶，它们看起来比这更复杂。另外请忽略IndexedDictionary类 - 它是一个允许按索引获取值的自定义类。

编辑：CompuChip - 如果你想看IndexedDictionary：

 public class IndexedDictionary<T, TY>
    {
       public class DicObject<T, Y>
        {
            public T Key { get; set; }
            public Y Value { get; set; }
        }

       private HashSet<DicObject<T, TY>> list = new HashSet<DicObject<T, TY>>();

        public void Add(T o, TY u)
        {
            list.Add(new DicObject<T, TY>{Key = o, Value = u});
        }

        public DicObject<T, TY> this[int i] {
             get{return list.ElementAt(i);}
        }

        public T[] Keys()
        {
            return list.Select(x => x.Key).ToArray();
        }

        public TY[] Values()
        {
            return list.Select(x => x.Value).ToArray();
        }
    }

它根本不是关键。

Answer 1

我不确定我们如何忽略IndexedDictionary，因为它似乎是你的算法的关键，但假设它像标准字典一样工作，我认为这基本上是一个插入排序 - 你把所有将您的值放入字典中，将其插入正确的位置以保持其键的排序，最后您只需提取所有正确顺序的值。但是，所有的努力都是不可见的，因为它在Dictionary类中。

标准类的类似解决方案类似于

public static IEnumerable<int> Sort(int[] ints)
{
    var dictionary = new Dictionary<int, bool>();

    foreach (var i in ints)
    {
        dictionary.Add(i, false);
    }

    return dictionary.Keys;
}

（虽然这不涉及多次出现的数字）。

Answer 2

这是pigeon hole sorting的一种形式，但它仅限于能够对具有1和更高的唯一值的集合进行排序而没有间隙。（例如，如果您尝试对数组{4,3,2}进行排序，它将崩溃。）

因此，对于它适用的任何集合，它的作用与：

相同

public static int[] Sort(int[] ints) {
  return Enumerable.Range(1, ints.Length).ToArray();
}

IndexedDictionary只是一种复杂而缓慢的方式，以任意顺序迭代项目，并根据相同的任意顺序将每个值放置到位，以便它们最终被排序。使用常规数组可以更简单，更快速地执行相同的操作：

public static int[] Sort(int[] ints) {
  int[] result = new int[ints.Length];
  foreach (int value in ints) {
    result[value - 1] = value;
  }
  return result;
}

对于使用不必具有最低值1并且是连续的集合的实现，您将创建一个从最低值到最高值的数组并将值放入其中，然后收集它们按顺序：

public static int[] Sort(int[] ints) {
  int min = ints.Min();
  int max = ints.Max();
  int?[] pigeonHoles = new int?[max - min + 1];
  foreach (int value in ints) {
    pigeonHoles[value - min] = value;
  }
  int[] result = new int[ints.Length];
  int index = 0;
  foreach (int? value in pigeonHoles) {
    if (value.HasValue) {
      result[index++] = value.Value;
    }
  }
  return result;
}

c＃中这个排序算法的名称是什么

2 个答案: