C # Sortieren und Bestellen durch Vergleich

Ich kann eine Liste mit Sortieren oder Bestellen sortieren. Welches ist schneller? Arbeiten beide an demselben Algorithmus?

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

Warum nicht messen:

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

Auf meinem Computer druckt dieses Programm beim Kompilieren im Release-Modus:

Sort: 1162ms
OrderBy: 1269ms

AKTUALISIEREN:

Wie von @Stefan vorgeschlagen, sind hier die Ergebnisse der weniger häufigen Sortierung einer großen Liste:

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

Drucke:

Sort: 8965ms
OrderBy: 8460ms

In diesem Szenario sieht es so aus, als ob OrderBy eine bessere Leistung erbringt.

UPDATE2:

Und mit zufälligen Namen:

List<Person> persons = new List<Person>();
for (int i = 0; i < 100000; i++)
{
    persons.Add(new Person("P" + i.ToString(), RandomString(5, true)));
}

Wo:

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

Ausbeuten:

Sort: 8968ms
OrderBy: 8728ms

Trotzdem ist OrderBy schneller

Nein, sie sind nicht der gleiche Algorithmus. Für den Anfang wird der LINQ OrderByals stabil dokumentiert (dh wenn zwei Elemente dasselbe haben Name, werden sie in ihrer ursprünglichen Reihenfolge angezeigt).

Es hängt auch davon ab, ob Sie die Abfrage puffern oder mehrmals wiederholen (LINQ-to-Objects wird, sofern Sie das Ergebnis nicht puffern, nachbestellen foreach).

Für die OrderByAbfrage wäre ich auch versucht zu verwenden:

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

(für {yourchoice}einen von CurrentCulture, Ordinaloder InvariantCulture).

List<T>.Sort

Diese Methode verwendet Array.Sort, das den QuickSort-Algorithmus verwendet. Diese Implementierung führt eine instabile Sortierung durch. Das heißt, wenn zwei Elemente gleich sind, wird ihre Reihenfolge möglicherweise nicht beibehalten. Im Gegensatz dazu behält eine stabile Sortierung die Reihenfolge der gleichen Elemente bei.

Enumerable.OrderBy

Diese Methode führt eine stabile Sortierung durch. Das heißt, wenn die Schlüssel zweier Elemente gleich sind, bleibt die Reihenfolge der Elemente erhalten. Im Gegensatz dazu behält eine instabile Sortierung nicht die Reihenfolge der Elemente bei, die denselben Schlüssel haben. Sortieren; Das heißt, wenn zwei Elemente gleich sind, wird ihre Reihenfolge möglicherweise nicht beibehalten. Im Gegensatz dazu behält eine stabile Sortierung die Reihenfolge der gleichen Elemente bei.

Die Antwort von Darin Dimitrov zeigt, dass dies OrderByetwas schneller ist als List.Sortbei bereits sortierten Eingaben. Ich habe seinen Code so geändert, dass er die unsortierten Daten wiederholt sortiert und OrderByin den meisten Fällen etwas langsamer ist.

Darüber hinaus wird beim OrderByTest die ToArrayAufzählung des Linq-Enumerators erzwungen, dies gibt jedoch offensichtlich einen Typ ( Person[]) zurück, der sich vom Eingabetyp ( List<Person>) unterscheidet. Ich habe den Test daher mit ToListund nicht wiederholt ToArrayund einen noch größeren Unterschied festgestellt :

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

Der Code:

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

Ich denke, es ist wichtig, einen weiteren Unterschied zwischen Sortund festzustellen OrderBy:

Angenommen, es gibt eine Person.CalculateSalary()Methode, die viel Zeit in Anspruch nimmt. möglicherweise mehr als nur das Sortieren einer großen Liste.

Vergleichen Sie

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

Option 2 weist möglicherweise eine überlegene Leistung auf, da die CalculateSalaryMethode nur n- mal Sortaufgerufen wird , während die Option je nach Erfolg des Sortieralgorithmus CalculateSalarybis zu 2 n log ( n ) mal aufruft .

In einer Nussschale :

List / Array Sort ():

• Instabile Sortierung.
• Fertig an Ort und Stelle.
• Verwenden Sie Introsort / Quicksort.
• Der benutzerdefinierte Vergleich erfolgt durch Bereitstellung eines Vergleichers. Wenn der Vergleich teuer ist, ist er möglicherweise langsamer als OrderBy () (mit dem Schlüssel verwendet werden können, siehe unten).

OrderBy / ThenBy ():

• Stabile Sorte.
• Nicht an Ort und Stelle.
• Verwenden Sie Quicksort. Quicksort ist keine stabile Sorte. Hier ist der Trick: Wenn zwei Elemente beim Sortieren den gleichen Schlüssel haben, wird ihre ursprüngliche Reihenfolge verglichen (die vor dem Sortieren gespeichert wurde).
• Ermöglicht die Verwendung von Schlüsseln (unter Verwendung von Lambdas), um Elemente nach ihren Werten zu sortieren (z x => x.Id. B. :) . Alle Schlüssel werden vor dem Sortieren zuerst extrahiert. Dies kann zu einer besseren Leistung führen als die Verwendung von Sort () und eines benutzerdefinierten Vergleichers.

Quellen: MDSN , Referenzquelle und Dotnet / Coreclr- Repository (GitHub).

Einige der oben aufgeführten Anweisungen basieren auf der aktuellen .NET Framework-Implementierung (4.7.2). Es könnte sich in Zukunft ändern.

Sie sollten die Komplexität der Algorithmen berechnen, die von den Methoden OrderBy und Sort verwendet werden. Wie ich mich erinnere, hat QuickSort eine Komplexität von n (log n), wobei n die Länge des Arrays ist.

Ich habe auch nach Orderby's gesucht, aber ich konnte selbst in der MSDN-Bibliothek keine Informationen finden. Wenn Sie nicht dieselben Werte und Sortierungen haben, die sich nur auf eine Eigenschaft beziehen, bevorzuge ich die Sort () -Methode. Wenn nicht, verwenden Sie OrderBy.

Ich möchte nur hinzufügen, dass orderby viel nützlicher ist.

Warum? Weil ich das kann:

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

Warum komplizierter Vergleich? Sortieren Sie einfach nach einem Feld. Hier sortiere ich nach TotalBalance.

Sehr leicht.

Ich kann das nicht mit sort machen. Ich wundere mich warum. Machen Sie es gut mit orderBy.

Die Geschwindigkeit ist immer O (n).