C# 这个排序算法在c语言中的名称是什么# 公共静态int[]排序（int[]int） { var dictionary=newindexeddictionary（）； foreach（内部变量i） { 添加（i，i）； } 对于（int i=0；i

我不确定如何忽略

索引字典，因为它似乎是算法的关键，但假设它像一个标准字典一样工作，我认为这基本上是一个插入排序-您将所有值放入一个字典，该字典将其插入正确的位置以保持其键排序，最后您将我们必须提取所有按正确顺序排列的值。但是，所有的辛苦工作都是不可见的，因为它在
字典
类中

就标准类而言，类似的解决方案类似于

 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();
        }
    }

公共静态IEnumerable排序（int[]int）
{
var dictionary=newdictionary（）；
foreach（内部变量i）
{
添加（i，false）；
}
返回字典。键；
}

（虽然这不处理多次出现的数字）。
这是的一种形式，但它仅限于能够对具有从1到更高的唯一值且没有间隙的集合进行排序。（例如，如果尝试对数组
{4,3,2}
进行排序，它将崩溃。）

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

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;
}

IndexedDictionary
只是一种复杂而缓慢的方法，它可以以任意顺序遍历项，并根据相同的任意顺序将每个值放置到位，以便对它们进行排序。使用常规数组，您可以更简单、更快地完成同样的任务：

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

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

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

这是根据什么属性排序的？我不确定我们怎么能忽略
索引字典
，因为它似乎是您算法的关键，但假设它像标准字典一样工作，我认为这基本上是一种插入排序-您将所有值放入一个字典，然后将其插入正确的位置以保持其键的排序。这似乎向字典中添加了新值，您确定这只是一个排序实现吗？您将该类称为IndexedDictionary？然后我们可以调用每个
列表字典和每个
IEnumerable
索引。您的意思是
IndexedDictionary
实际上只是一个
列表
？
public static int[] Sort(int[] ints) {
  int[] result = new int[ints.Length];
  foreach (int value in ints) {
    result[value - 1] = value;
  }
  return result;
}

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;
}