Linq Orderby 与自身进行比较。为什么？

Question

总结：在将 Linq OrderBy 与比较器一起使用时，我看到 OrderBy 将项目与自身进行比较 Compare (x, x)，并且我看到它多次比较相同的项目 Comparer (x, y)。

• 为什么 OrderBy Compare (x, x)？
• 为什么 OrderBy 会多次比较同一商品？

---

问题描述

如果你有一个（可能是空的）项目序列，并且你想要最大的一个，你可以使用OrderBy(...).FirstOrDefault()。

我想，如果您只使用最大的一件，订购数千件商品会浪费处理能力。您可以尝试通过创建某种Max 方法在一个枚举中找到这个最大的元素。

同样，如果您搜索最大的几个元素：为什么要对所有项目进行排序？

我听到有人说，如果你使用 OrderBy 并且只取第一个元素，那么就不是完整的序列。

所以我想创建一个测试程序，在其中使用客户比较器订购客户。要查看哪些客户是比较者，客户比较者会将客户的 Id 写入控制台。

class Customer
{
    public int Id {get; set;}
    ...
}

class CustomerComparer : Comparer<Customer>
{
    public override int Compare(Customer x, Customer y)
    {
        int result = Comparer<int>.Default(x.Id, y.Id);
        Console.WriteLine("Compare {0} - {1} => {2}", x.Id, y.Id, result);
        return result;
    }
}

控制台程序

static void Main(string[] args)
{
    var customers = new[]
    {
        new Customer {Id = 2},
        new Customer {Id = 9},
        new Customer {Id = 6},
        new Customer {Id = 1},
        new Customer {Id = 4},
        new Customer {Id = 7},
        new Customer {Id = 3},
        new Customer {Id = 8},
        new Customer {Id = 5},
    };

    IComparer<Customer> comparer = new CustomerComparer;
    var result = customers.OrderBy(customer => customer, customerComparer).FirstOrDefault();

如果我运行程序，我会得到以下输出：

Compare 4 - 2 => 1
Compare 4 - 9 => -1
Compare 4 - 5 => -1
Compare 4 - 8 => -1
Compare 4 - 3 => 1
Compare 4 - 6 => -1
Compare 4 - 7 => -1
Compare 4 - 4 => 0
Compare 4 - 1 => 1
Compare 4 - 6 => -1
Compare 4 - 1 => 1
Compare 3 - 2 => 1
Compare 3 - 3 => 0
Compare 3 - 1 => 1
Compare 3 - 4 => -1
Compare 3 - 4 => -1
Compare 3 - 1 => 1
Compare 2 - 2 => 0
Compare 2 - 1 => 1
Compare 4 - 4 => 0
Compare 4 - 3 => 1
Compare 9 - 6 => 1
Compare 9 - 7 => 1
Compare 9 - 9 => 0
Compare 9 - 5 => 1
Compare 9 - 8 => 1
Compare 9 - 9 => 0
Compare 9 - 8 => 1
Compare 7 - 6 => 1
Compare 7 - 7 => 0
Compare 7 - 8 => -1
Compare 7 - 5 => 1
Compare 6 - 6 => 0
Compare 6 - 5 => 1
Compare 7 - 7 => 0
Compare 7 - 8 => -1
Compare 7 - 7 => 0

我看到了一些奇怪的东西：

• 客户 [4] 与其自身进行了多次比较。这也适用于客户 [7] 和 [6]，但不适用于客户 [8] 和 [1]
• 将客户 [4] 与客户 [6] 进行比较，经过几次比较后，再次将客户 [4] 与客户 [6] 进行比较。
• 客户 [3] 和 [4] 被比较两次，中间没有任何其他比较。
• 双重比较也适用于客户 [4] 和 [1]，稍后适用于 [4] 和 [3]，但不适用于其他客户

为什么这是一种高效的排序算法？

Answer 1

正如 Jeroen Mostert 所提到的，它可能将元素与自身进行比较以使算法更简单，并且在某些情况下，简单性可以提高性能。我希望排序算法得到相当好的优化，所以我不会担心一些额外的比较。另请注意，Orderby 保证是稳定的，这可能会对算法施加额外的限制。

为了解决返回最大值的问题，我建议创建您自己的实现来迭代集合并返回最小/最大。这是相当微不足道的。或者使用类似MoreLinq MaxBy / MinBy

我听说有人说，如果你使用 OrderBy 并且只取第一个元素，那么就不是完整的序列。

OrderBy 的内部运作没有记录。理论上，运行时可以检查整个 linq 调用序列并生成最佳代码。 编辑：

• 在 .Net core 3.x 及更高版本中似乎确实将其优化为 O(n)（感谢 Matthew Watson 指出这一点）。
• 在 .Net 框架中，它看起来会创建一个 EnumerableSorter，最终对整个事情进行快速排序，大概是一个稳定的变体。即O(n log n)
• 在实体框架中，查询应转换为 SQL 并通过查询优化器运行，可能会导致 O(n)（或更好的）运行时。