Question

任何人都可以告诉我在Linq.Sort中使用了哪种类型的排序技术（气泡，插入，选择）。

编辑：是否还有一个简单的方法是使用这个函数并自己查看源代码 - 我曾经能够用Java做到这一点

Answer 1

没有LINQ Enumerable.SortBy方法。

但是，有一个Enumerable.OrderBy函数可以实例化使用OrderedEnumerable类的新EnumerableSorter。这些类的源代码如下。欢迎您随意给他们打电话。

internal abstract class EnumerableSorter<TElement>
{
    // Methods
    protected EnumerableSorter()
    {
    }

    internal abstract int CompareKeys(int index1, int index2);
    internal abstract void ComputeKeys(TElement[] elements, int count);
    private void QuickSort(int[] map, int left, int right)
    {
        do
        {
            int index = left;
            int num2 = right;
            int num3 = map[index + ((num2 - index) >> 1)];
            do
            {
                while ((index < map.Length) && (this.CompareKeys(num3, map[index]) > 0))
                {
                    index++;
                }
                while ((num2 >= 0) && (this.CompareKeys(num3, map[num2]) < 0))
                {
                    num2--;
                }
                if (index > num2)
                {
                    break;
                }
                if (index < num2)
                {
                    int num4 = map[index];
                    map[index] = map[num2];
                    map[num2] = num4;
                }
                index++;
                num2--;
            }
            while (index <= num2);
            if ((num2 - left) <= (right - index))
            {
                if (left < num2)
                {
                    this.QuickSort(map, left, num2);
                }
                left = index;
            }
            else
            {
                if (index < right)
                {
                    this.QuickSort(map, index, right);
                }
                right = num2;
            }
        }
        while (left < right);
    }

    internal int[] Sort(TElement[] elements, int count)
    {
        this.ComputeKeys(elements, count);
        int[] map = new int[count];
        for (int i = 0; i < count; i++)
        {
            map[i] = i;
        }
        this.QuickSort(map, 0, count - 1);
        return map;
    }
}

internal class EnumerableSorter<TElement, TKey> : EnumerableSorter<TElement>
{
    // Fields
    internal IComparer<TKey> comparer;
    internal bool descending;
    internal TKey[] keys;
    internal Func<TElement, TKey> keySelector;
    internal EnumerableSorter<TElement> next;

    // Methods
    internal EnumerableSorter(Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending, EnumerableSorter<TElement> next)
    {
        this.keySelector = keySelector;
        this.comparer = comparer;
        this.descending = descending;
        this.next = next;
    }

    internal override int CompareKeys(int index1, int index2)
    {
        int num = this.comparer.Compare(this.keys[index1], this.keys[index2]);
        if (num == 0)
        {
            if (this.next == null)
            {
                return (index1 - index2);
            }
            return this.next.CompareKeys(index1, index2);
        }
        if (!this.descending)
        {
            return num;
        }
        return -num;
    }

    internal override void ComputeKeys(TElement[] elements, int count)
    {
        this.keys = new TKey[count];
        for (int i = 0; i < count; i++)
        {
            this.keys[i] = this.keySelector(elements[i]);
        }
        if (this.next != null)
        {
            this.next.ComputeKeys(elements, count);
        }
    }
}

您可以使用.NET Reflector来读取已编译的.NET程序集的源代码。

Answer 2

在反射器中查找后，OrderBy LINQ运算符使用快速排序。

internal abstract class EnumerableSorter<TElement>
{
    // Methods
    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
    protected EnumerableSorter();
    internal abstract int CompareKeys(int index1, int index2);
    internal abstract void ComputeKeys(TElement[] elements, int count);
    private void QuickSort(int[] map, int left, int right);
    internal int[] Sort(TElement[] elements, int count);
}

方法名QuickSort使得它非常明显，算法证实了它。

要检查一个程序集，请使用像ILSpy这样的工具（抛出的通常名称是反射器，然而，在下一个版本中不再是免费的，并且所有免费版本都包含一个禁用开关，基于时间，最后一个免费版本将在2011年3月的某个时候被禁用。）

Answer 3

Enumrable.OrderBy的文档只是陈述

此方法执行稳定排序;也就是说，如果两个元素的键相等，则保留元素的顺序。

这意味着不同版本的.NET Framework之间的实现可能会有所不同，但假设它为O（n log n）。

修改
需要注意的是，Array.Sort的文档明确提到了使用快速排序（并指出它不稳定）。

Enumerable.SortBy - 使用哪种排序功能？

3 个答案:

您可以使用.NET Reflector来读取已编译的.NET程序集的源代码。