C# Sort 和 OrderBy 比较

Posted 2023-02-16

【中文标题】C# Sort 和 OrderBy 比较

【英文标题】：C# Sort and OrderBy comparison

【发布时间】：2010-12-22 09:44:56

【问题描述】：

我可以使用 Sort 或 OrderBy 对列表进行排序。哪个更快？都在做同样的事情 算法？

List<Person> persons = new List<Person>();
persons.Add(new Person("P005", "Janson"));
persons.Add(new Person("P002", "Aravind"));
persons.Add(new Person("P007", "Kazhal"));

1.

persons.Sort((p1,p2)=>string.Compare(p1.Name,p2.Name,true));

2.

var query = persons.OrderBy(n => n.Name, new NameComparer());

class NameComparer : IComparer<string>

    public int Compare(string x,string y)
    
      return  string.Compare(x, y, true);
    

【问题讨论】：

我不敢相信没有一个答案提到这一点，但最大的区别在于：OrderBy 是对 Array 或 List 进行排序的副本，而 Sort 实际上是对其进行排序。

正如标题所说的比较，我想补充一点，OrderBy 是稳定的，并且排序是稳定的，最多 16 个元素，因为如果元素多于 16 个元素，则使用插入排序，然后它会切换到其他不稳定的算法编辑：稳定意味着保持具有相同键的元素的相对顺序。

@PRMan 不，OrderBy 创建了一个惰性可枚举。只有在返回的枚举上调用诸如 ToList 之类的方法时，才会得到排序后的副本。

@Stewart，您不认为 System.Core/System/Linq/Enumerable.cs 中缓冲区中的 Array.Copy 或 Collection.Copy 到 TElement[] 是副本吗？而且，如果您在 IEnumerable 上调用 ToList，您可能会立即在内存中同时拥有 3 个副本。这对于非常大的数组来说是一个问题，这是我的观点的一部分。此外，如果您多次需要相同的排序顺序，则调用就地排序一次比重复排序列表更有效，因为它是永久性的。

@PRMan 哦，你的意思是内部构建了一个排序的副本。这仍然是不准确的，因为 OrderBy 不会创建副本 - 据我所知，这是由 GetEnumerator 方法在您实际开始遍历集合时完成的。我刚刚尝试单步执行我的代码，发现从 LINQ 表达式填充变量的代码几乎可以立即运行，但是当您进入 foreach 循环时，它会花时间对其进行排序。我想当我有更多时间时，我应该花一些时间来弄清楚它是如何在幕后工作的。

【参考方案1】：

我只想补充一点，orderby 更有用。

为什么？因为我可以这样做：

Dim thisAccountBalances = account.DictOfBalances.Values.ToList
thisAccountBalances.ForEach(Sub(x) x.computeBalanceOtherFactors())
thisAccountBalances=thisAccountBalances.OrderBy(Function(x) x.TotalBalance).tolist
listOfBalances.AddRange(thisAccountBalances)

为什么要复杂的比较器？只需根据字段进行排序。这里我是根据 TotalBalance 进行排序的。

很简单。

我不能用排序来做到这一点。我想知道为什么。使用 orderBy 就可以了。

至于速度，它总是 O(n)。

【讨论】：

问题：您的答案中的 O(n) 时间（我假设）是指 OrderBy 还是 Comparer？我不认为快速排序可以达到 O(N) 时间。

【参考方案2】：

简而言之：

列表/数组排序（）：

不稳定的排序。 就地完成。 使用 Introsort/Quicksort。 自定义比较是通过提供一个比较器来完成的。如果比较代价高昂，它可能会比 OrderBy() 慢（允许使用键，见下文）。

OrderBy/ThenBy()：

稳定排序。 不在原位。 使用快速排序。快速排序不是一种稳定的排序。诀窍是：排序时，如果两个元素具有相同的键，它会比较它们的初始顺序（在排序之前已存储）。 允许使用键（使用 lambda）根据元素的值对元素进行排序（例如：x => x.Id）。在排序之前首先提取所有键。与使用 Sort() 和自定义比较器相比，这可能会产生更好的性能。

来源： MDSN、reference source 和 dotnet/coreclr 存储库 (GitHub)。

上面列出的一些语句基于当前的 .NET 框架实现 (4.7.2)。将来可能会改变。

【参考方案3】：

我认为注意Sort 和OrderBy 之间的另一个区别很重要：

假设存在Person.CalculateSalary() 方法，需要花费大量时间；甚至可能超过对大列表进行排序的操作。

比较

// Option 1
persons.Sort((p1, p2) => Compare(p1.CalculateSalary(), p2.CalculateSalary()));
// Option 2
var query = persons.OrderBy(p => p.CalculateSalary()); 

选项 2 可能具有更优越的性能，因为它只调用 CalculateSalary 方法 n 次，而 Sort 选项可能调用 CalculateSalary 最多 @ 987654321@ 次，取决于排序算法的成功与否。

【讨论】：

这是真的，尽管有解决该问题的方法，即将数据保存在数组中并使用 Array.Sort 重载，该重载采用两个数组，一个是键，另一个是值.在填充键数组时，您将调用CalculateSalary n 次。这显然不如使用 OrderBy 方便。

【参考方案4】：

Darin Dimitrov 的回答表明，OrderBy 在面对已经排序的输入时比List.Sort 稍快。我修改了他的代码，让它反复对未排序的数据进行排序，OrderBy 在大多数情况下会稍微慢一些。

此外，OrderBy 测试使用ToArray 来强制枚举 Linq 枚举器，但这显然返回了与输入类型 (List<Person>) 不同的类型 (Person[])。因此，我使用ToList 而不是ToArray 重新运行了测试，并得到了更大的差异：

Sort: 25175ms
OrderBy: 30259ms
OrderByWithToList: 31458ms

代码：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;

class Program

    class NameComparer : IComparer<string>
    
        public int Compare(string x, string y)
        
            return string.Compare(x, y, true);
        
    

    class Person
    
        public Person(string id, string name)
        
            Id = id;
            Name = name;
        
        public string Id  get; set; 
        public string Name  get; set; 
        public override string ToString()
        
            return Id + ": " + Name;
        
    

    private static Random randomSeed = new Random();
    public static string RandomString(int size, bool lowerCase)
    
        var sb = new StringBuilder(size);
        int start = (lowerCase) ? 97 : 65;
        for (int i = 0; i < size; i++)
        
            sb.Append((char)(26 * randomSeed.NextDouble() + start));
        
        return sb.ToString();
    

    private class PersonList : List<Person>
    
        public PersonList(IEnumerable<Person> persons)
           : base(persons)
        
        

        public PersonList()
        
        

        public override string ToString()
        
            var names = Math.Min(Count, 5);
            var builder = new StringBuilder();
            for (var i = 0; i < names; i++)
                builder.Append(this[i]).Append(", ");
            return builder.ToString();
        
    

    static void Main()
    
        var persons = new PersonList();
        for (int i = 0; i < 100000; i++)
        
            persons.Add(new Person("P" + i.ToString(), RandomString(5, true)));
         

        var unsortedPersons = new PersonList(persons);

        const int COUNT = 30;
        Stopwatch watch = new Stopwatch();
        for (int i = 0; i < COUNT; i++)
        
            watch.Start();
            Sort(persons);
            watch.Stop();
            persons.Clear();
            persons.AddRange(unsortedPersons);
        
        Console.WriteLine("Sort: 0ms", watch.ElapsedMilliseconds);

        watch = new Stopwatch();
        for (int i = 0; i < COUNT; i++)
        
            watch.Start();
            OrderBy(persons);
            watch.Stop();
            persons.Clear();
            persons.AddRange(unsortedPersons);
        
        Console.WriteLine("OrderBy: 0ms", watch.ElapsedMilliseconds);

        watch = new Stopwatch();
        for (int i = 0; i < COUNT; i++)
        
            watch.Start();
            OrderByWithToList(persons);
            watch.Stop();
            persons.Clear();
            persons.AddRange(unsortedPersons);
        
        Console.WriteLine("OrderByWithToList: 0ms", watch.ElapsedMilliseconds);
    

    static void Sort(List<Person> list)
    
        list.Sort((p1, p2) => string.Compare(p1.Name, p2.Name, true));
    

    static void OrderBy(List<Person> list)
    
        var result = list.OrderBy(n => n.Name, new NameComparer()).ToArray();
    

    static void OrderByWithToList(List<Person> list)
    
        var result = list.OrderBy(n => n.Name, new NameComparer()).ToList();
    

【讨论】：

我现在在 LinqPad 5 (.net 5) 中运行测试代码，OrderByWithToList 与 OrderBy 花费的时间相同。

【参考方案5】：

您应该计算 OrderBy 和 Sort 方法使用的算法的复杂度。 我记得 QuickSort 的复杂度为 n (log n)，其中 n 是数组的长度。

我也搜索过 orderby，但即使在 msdn 库中也找不到任何信息。 如果您没有任何相同的值和仅与一个属性相关的排序，我更喜欢使用 排序（）方法；如果不是，请使用 OrderBy。

【讨论】：

根据当前的 MSDN 文档，Sort 根据输入使用 3 种不同的排序算法。其中包括快速排序。关于 OrderBy() 算法的问题在这里（快速排序）：***.com/questions/2792074/…

【参考方案6】：

为什么不测量它：

class Program

    class NameComparer : IComparer<string>
    
        public int Compare(string x, string y)
        
            return string.Compare(x, y, true);
        
    

    class Person
    
        public Person(string id, string name)
        
            Id = id;
            Name = name;
        
        public string Id  get; set; 
        public string Name  get; set; 
    

    static void Main()
    
        List<Person> persons = new List<Person>();
        persons.Add(new Person("P005", "Janson"));
        persons.Add(new Person("P002", "Aravind"));
        persons.Add(new Person("P007", "Kazhal"));

        Sort(persons);
        OrderBy(persons);

        const int COUNT = 1000000;
        Stopwatch watch = Stopwatch.StartNew();
        for (int i = 0; i < COUNT; i++)
        
            Sort(persons);
        
        watch.Stop();
        Console.WriteLine("Sort: 0ms", watch.ElapsedMilliseconds);

        watch = Stopwatch.StartNew();
        for (int i = 0; i < COUNT; i++)
        
            OrderBy(persons);
        
        watch.Stop();
        Console.WriteLine("OrderBy: 0ms", watch.ElapsedMilliseconds);
    

    static void Sort(List<Person> list)
    
        list.Sort((p1, p2) => string.Compare(p1.Name, p2.Name, true));
    

    static void OrderBy(List<Person> list)
    
        var result = list.OrderBy(n => n.Name, new NameComparer()).ToArray();
    

在我的计算机上，当以发布模式编译时，此程序会打印：

Sort: 1162ms
OrderBy: 1269ms

---

更新：

正如@Stefan 所建议的，这里是对大列表进行较少次数排序的结果：

List<Person> persons = new List<Person>();
for (int i = 0; i < 100000; i++)

    persons.Add(new Person("P" + i.ToString(), "Janson" + i.ToString()));


Sort(persons);
OrderBy(persons);

const int COUNT = 30;
Stopwatch watch = Stopwatch.StartNew();
for (int i = 0; i < COUNT; i++)

    Sort(persons);

watch.Stop();
Console.WriteLine("Sort: 0ms", watch.ElapsedMilliseconds);

watch = Stopwatch.StartNew();
for (int i = 0; i < COUNT; i++)

    OrderBy(persons);

watch.Stop();
Console.WriteLine("OrderBy: 0ms", watch.ElapsedMilliseconds);

打印：

Sort: 8965ms
OrderBy: 8460ms

在这种情况下，OrderBy 的表现似乎更好。

---

更新2：

并使用随机名称：

List<Person> persons = new List<Person>();
for (int i = 0; i < 100000; i++)

    persons.Add(new Person("P" + i.ToString(), RandomString(5, true)));

地点：

private static Random randomSeed = new Random();
public static string RandomString(int size, bool lowerCase)

    var sb = new StringBuilder(size);
    int start = (lowerCase) ? 97 : 65;
    for (int i = 0; i < size; i++)
    
        sb.Append((char)(26 * randomSeed.NextDouble() + start));
    
    return sb.ToString();

产量：

Sort: 8968ms
OrderBy: 8728ms

OrderBy 还是更快

【讨论】：

我认为，对一个非常小的列表（3 个项目）进行 1000000 次排序，或者对一个非常大的列表（1000000 个项目）进行几次排序是有很大不同的。两者都非常相关。在实践中，中等大小的列表（什么是中等？......现在假设 1000 个项目）是最有趣的。恕我直言，用 3 个项目对列表进行排序不是很有意义。

请注意，“更快”和“明显更快”之间存在差异。在您的上一个示例中，差异约为四分之一秒。用户会注意到吗？用户等待将近 9 秒才能得到结果是不能接受的吗？如果这两个问题的答案都是“否”，那么从性能的角度来看，您选择哪一个并不重要。

还要注意，这里的测试在开始秒表之前对列表进行排序，所以我们比较两种算法在面对排序输入时的比较。这可能与它们在未排序输入下的相对性能完全不同。

这些结果非常令人惊讶，恕我直言，考虑到LINQ 与就地List<T>.Sort 实现相比必须花费额外的内存。我不确定他们是否在较新的 .NET 版本中改进了这一点，但在我的机器上（i7 第三代 64 位 .NET 4.5 版本）Sort 在所有情况下都优于OrderBy。此外，通过查看OrderedEnumerable<T> 源代码，它似乎在最终调用 Quicksort 之前创建了 三个 额外的数组（首先是 Buffer<T>，然后是投影键数组，然后是索引数组）对索引数组进行排序。

...在这一切之后，有 ToArray 调用创建了结果数组。内存操作和数组索引是非常快的操作，但我仍然找不到这些结果背后的逻辑。

【参考方案7】：

不，它们不是同一个算法。对于初学者，LINQ OrderBy 被记录为stable（即，如果两个项目具有相同的Name，它们将按其原始顺序出现）。

这还取决于您是缓冲查询还是对其进行多次迭代（LINQ-to-Objects，除非您缓冲结果，否则将按照 foreach 重新排序）。

对于OrderBy 查询，我也很想使用：

OrderBy(n => n.Name, StringComparer.yourchoiceIgnoreCase);

（对于yourchoiceCurrentCulture、Ordinal 或InvariantCulture 之一）。

List<T>.Sort

此方法使用 Array.Sort，它 使用快速排序算法。这 实现执行不稳定 种类;也就是说，如果两个元素是 相等，他们的顺序可能不是 保存。相反，稳定的排序 保留元素的顺序 是平等的。

Enumerable.OrderBy

此方法执行稳定排序；也就是说，如果两个元素的键相等，则保留元素的顺序。相反，不稳定的排序不会保留具有相同键的元素的顺序。 种类;也就是说，如果两个元素是 相等，他们的顺序可能不是 保存。相反，稳定的排序 保留元素的顺序 是平等的。

【讨论】：

如果您使用 .NET Reflector 或 ILSpy 破解 Enumerable.OrderBy 并深入了解其内部实现，您可以看到 OrderBy 排序算法是 QuickSort 的一种变体，可以进行稳定排序。 （参见System.Linq.EnumerableSorter<TElement>。）因此，Array.Sort 和 Enumerable.OrderBy 都可以预期有 O(N log N) 执行时间，其中 N 是数字集合中的元素。

@Marc 我不太明白如果两个元素相等并且不保留它们的顺序会有什么区别。对于原始数据类型来说，这当然不是问题。但是，即使对于引用类型，如果我要排序，名字 Marc Gravell 的人出现在另一个名字为 Marc Gravell 的人之前（例如 :)）又有什么关系呢？我不是在质疑你的答案/知识，而是在寻找这种场景的应用。

@Mukus 假设您按名称（或实际上按出生日期）对公司通讯录进行排序 - 不可避免地会有重复。最终的问题是：他们会发生什么？子订单定义了吗？