c# - 为什么这个Linq表达式比另一个表达式慢很多？

Question

执行时间：foo（1）>>> foo（2）>> foo（3）

大约：1427349 >>> 14757 >> 1362

foo（3）是这三种算法中最优化的算法，所以我并不惊讶它是最快的。
让我惊讶的是，foo（2）比foo（1）快得多。我的印象是foo（2）进行排序，而foo（1）的操作与foo（3）相似。我可以知道foo（1）变慢的原因是什么？告诉我幕后情况。谢谢！

void Main()
{   
    Random r = new Random();
    for(int i = 0; i < array.Length; i++)
    {
        array[i] = new A(r.Next(int.MaxValue));
    }   

    foo(1); 
    foo(2);
    foo(3); 
}

A[] array = new A[10000];
static Stopwatch sw = new Stopwatch();

public void foo(int s)
{
    sw.Reset();
    sw.Start();

    switch(s)
    {
        case 1:
            array.First(x => (x.value == array.Max(y => y.value))).Dump();
            break;
        case 2:
            array.OrderBy(x => x.value)
            .Last()
            .Dump();    
            break;
        case 3:
            {           
                int max = array[0].value;
                int index = 0;
                int i = 0;
                for(; i < array.Length; i++)
                {
                    if(array[i].value >= max)
                    {
                        max = array[i].value;
                        index = i;
                    }
                }
                array[index].Dump();
            }
            break;
    }

    sw.Stop();
    sw.Dump();
}
class A
{
    public int value;
    public A(int value)
    {
        this.value = value;
    }
}

代码测试是在linqpad中进行的，因此您可以忽略.Dump()方法。

Answer 1

第一个是O（N²），因为您需要为每个外部迭代对数组进行一次迭代。第二个是O（N log N），因为您先排序。最后一个是O（N），因为您可以在一次遍历中遍历数组，并且每次迭代都没有循环。

尝试这个：

        case 1:
            var max = array.Max(x => x.value);
            array.First(x => x.value == max).Dump();
            break;

现在，它应该可以与第三种情况相提并论，尽管不尽相同，因为平均而言，您必须遍历数组1.5次（假设只有一个元素具有最大值）。