C＃の並べ替えとOrderByの比較

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);
    }
}

なぜそれを測定しないのですか？

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: {0}ms", watch.ElapsedMilliseconds);

        watch = Stopwatch.StartNew();
        for (int i = 0; i < COUNT; i++)
        {
            OrderBy(persons);
        }
        watch.Stop();
        Console.WriteLine("OrderBy: {0}ms", 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: {0}ms", watch.ElapsedMilliseconds);

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

プリント：

Sort: 8965ms
OrderBy: 8460ms

このシナリオでは、OrderByのパフォーマンスが向上しているように見えます。

UPDATE2：

そしてランダムな名前を使用する：

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の方が速い

いいえ、同じアルゴリズムではありません。手始めに、LINQ OrderByは安定版として文書化されNameています（つまり、2つの項目が同じである場合、それらは元の順序で表示されます）。

また、クエリをバッファリングするか、数回反復するかによっても異なります（LINQ-to-Objectsは、結果をバッファリングしない限り、ごとに並べ替えられますforeach）。

OrderBy問合せ、私はまた、使用するために誘惑されるだろう。

OrderBy(n => n.Name, StringComparer.{yourchoice}IgnoreCase);

（のため{yourchoice}の一つCurrentCulture、OrdinalまたはInvariantCulture）。

List<T>.Sort

このメソッドは、QuickSortアルゴリズムを使用するArray.Sortを使用します。この実装は不安定なソートを実行します。つまり、2つの要素が等しい場合、それらの順序は保持されない可能性があります。対照的に、安定したソートでは、等しい要素の順序が保持されます。

Enumerable.OrderBy

このメソッドは安定したソートを実行します。つまり、2つの要素のキーが等しい場合、要素の順序は保持されます。対照的に、不安定なソートでは、同じキーを持つ要素の順序は保持されません。ソート; つまり、2つの要素が等しい場合、それらの順序は保持されない可能性があります。対照的に、安定したソートでは、等しい要素の順序が保持されます。

ダリン・ディミトロフの答えは、すでにソートされた入力に直面したときOrderByよりもわずかに速いことを示してList.Sortいます。私は彼のコードを変更して、ソートされていないデータを繰り返しソートし、OrderByほとんどの場合少し遅くなるようにしました。

さらに、OrderByテストはToArrayLinq列挙子の列挙を強制するために使用しますが、これは明らかにPerson[]入力タイプ（List<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: {0}ms", 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: {0}ms", 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: {0}ms", 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();
    }
}

私はそれが間に別の違いに注意することが重要だと思う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最大2 n log（n）回呼び出す可能性があります。

一言で言えば ：

リスト/配列Sort（）：

• 不安定なソート。
• インプレースで行われます。
• Introsort / Quicksortを使用します。
• カスタム比較は、比較子を提供することによって行われます。比較にコストがかかる場合は、OrderBy（）（キーを使用できるようにする、以下を参照）よりも遅くなる可能性があります。

OrderBy / ThenBy（）：

• 安定したソート。
• インプレースではありません。
• Quicksortを使用します。クイックソートは安定したソートではありません。トリックは次のとおりです。並べ替えるときに、2つの要素のキーが等しい場合、最初の順序（並べ替えの前に格納されている）を比較します。
• キーを使用して（ラムダを使用）、値に基づいて要素を並べ替えることができます（例：:) x => x.Id。ソートする前に、すべてのキーが最初に抽出されます。これにより、Sort（）およびカスタム比較子を使用するよりもパフォーマンスが向上する可能性があります。

ソース： MDSN、参照ソース、dotnet / coreclrリポジトリ（GitHub）。

上記のステートメントの一部は、現在の.NETフレームワーク実装（4.7.2）に基づいています。将来変更される可能性があります。

OrderByおよびSortメソッドで使用されるアルゴリズムの複雑さを計算する必要があります。私が覚えているように、QuickSortの複雑さはn（log n）です。ここで、nは配列の長さです。

私もorderbyを検索しましたが、msdnライブラリでも情報を見つけることができませんでした。同じ値がなく、1つのプロパティのみに関連する並べ替えがない場合は、Sort（）メソッドを使用することをお勧めします。そうでない場合は、OrderByを使用します。

私はその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）です。