C # Sort and OrderBy confronto

Posso ordinare un elenco utilizzando Sort o OrderBy. Quale è più veloce? Entrambi lavorano sullo stesso algoritmo?

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

Perché non misurarlo:

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

Sul mio computer, quando viene compilato in modalità di rilascio, questo programma stampa:

Sort: 1162ms
OrderBy: 1269ms

AGGIORNARE:

Come suggerito da @Stefan, ecco i risultati dell'ordinamento di un grande elenco meno volte:

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

stampe:

Sort: 8965ms
OrderBy: 8460ms

In questo scenario sembra che OrderBy funzioni meglio.

UPDATE2:

E usando nomi casuali:

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

Dove:

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

I rendimenti:

Sort: 8968ms
OrderBy: 8728ms

Still OrderBy è più veloce

No, non sono lo stesso algoritmo. Per i principianti, LINQ OrderByè documentato come stabile (cioè se due elementi hanno lo stesso Name, appariranno nell'ordine originale).

Dipende anche dal fatto che si bufferizzi la query o la si iteri più volte (LINQ-to-Objects, a meno che non si memorizzi nel buffer il risultato, riordinerà per foreach).

Per la OrderByquery, sarei anche tentato di utilizzare:

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

(per {yourchoice}uno di CurrentCulture, Ordinalo InvariantCulture).

List<T>.Sort

Questo metodo utilizza Array.Sort, che utilizza l'algoritmo QuickSort. Questa implementazione esegue un ordinamento instabile; cioè, se due elementi sono uguali, il loro ordine potrebbe non essere mantenuto. Al contrario, un ordinamento stabile conserva l'ordine degli elementi che sono uguali.

Enumerable.OrderBy

Questo metodo esegue un ordinamento stabile; ovvero, se le chiavi di due elementi sono uguali, l'ordine degli elementi viene mantenuto. Al contrario, un ordinamento instabile non conserva l'ordine degli elementi che hanno la stessa chiave. ordinare; cioè, se due elementi sono uguali, il loro ordine potrebbe non essere mantenuto. Al contrario, un ordinamento stabile conserva l'ordine degli elementi che sono uguali.

La risposta di Darin Dimitrov mostra che OrderByè leggermente più veloce di List.Sortquando si trova di fronte a input già ordinati. Ho modificato il suo codice in modo da ordinare ripetutamente i dati non ordinati e OrderBynella maggior parte dei casi è leggermente più lento.

Inoltre, il OrderBytest utilizza ToArrayper forzare l'enumerazione dell'enumeratore Linq, ma questo ovviamente restituisce un type ( Person[]) che è diverso dall'input type ( List<Person>). Ho quindi rieseguito il test utilizzando ToListinvece di ToArraye ho ottenuto una differenza ancora maggiore:

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

Il codice:

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

Penso che sia importante notare un'altra differenza tra Sorte OrderBy:

Supponiamo che esista un Person.CalculateSalary()metodo, che richiede molto tempo; forse più dell'operazione di smistamento di un elenco di grandi dimensioni.

Confrontare

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

L'opzione 2 può avere prestazioni superiori, perché chiama il CalculateSalarymetodo solo n volte, mentre l' Sortopzione potrebbe chiamare CalculateSalaryfino a 2 n log ( n ) volte, a seconda del successo dell'algoritmo di ordinamento.

In poche parole:

Ordinamento elenco / array ():

• Ordinamento instabile.
• Fatto sul posto.
• Usa Introsort / Quicksort.
• Il confronto personalizzato viene eseguito fornendo un comparatore. Se il confronto è costoso, potrebbe essere più lento di OrderBy () (che consente di utilizzare le chiavi, vedi sotto).

OrderBy / ThenBy ():

• Ordinamento stabile.
• Non sul posto.
• Usa Quicksort. Quicksort non è un tipo stabile. Ecco il trucco: durante l'ordinamento, se due elementi hanno la stessa chiave, confronta il loro ordine iniziale (che è stato memorizzato prima dell'ordinamento).
• Permette di usare le chiavi (usando lambda) per ordinare gli elementi sui loro valori (es:) x => x.Id. Tutte le chiavi vengono estratte prima dell'ordinamento. Ciò potrebbe comportare prestazioni migliori rispetto all'utilizzo di Sort () e di un comparatore personalizzato.

Fonti: MDSN , sorgente di riferimento e repository dotnet / coreclr (GitHub).

Alcune delle affermazioni sopra elencate si basano sull'attuale implementazione del framework .NET (4.7.2). Potrebbe cambiare in futuro.

dovresti calcolare la complessità degli algoritmi usati dai metodi OrderBy e Sort. QuickSort ha una complessità di n (log n) come ricordo, dove n è la lunghezza dell'array.

Ho cercato anche orderby, ma non sono riuscito a trovare alcuna informazione nemmeno nella libreria msdn. se non si hanno gli stessi valori e l'ordinamento relativo a una sola proprietà, preferisco utilizzare il metodo Sort (); in caso contrario, utilizzare OrderBy.

Voglio solo aggiungere che orderby è molto più utile.

Perché? Perché posso farlo:

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

Perché comparatore complicato? Basta ordinare in base a un campo. Qui sto ordinando in base a TotalBalance.

Molto facile.

Non posso farlo con l'ordinamento. Mi chiedo perché. Va bene con orderBy.

Per quanto riguarda la velocità è sempre O (n).