為什么這個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次（假設只有一個元素具有最大值）。