C # Ordenar y ordenar por comparación

Puedo ordenar una lista usando Sort u OrderBy. Cual es mas rapido? ¿Ambos trabajan en el mismo 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);
    }
}

Por qué no medirlo:

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

En mi computadora, cuando se compila en modo de lanzamiento, este programa imprime:

Sort: 1162ms
OrderBy: 1269ms

ACTUALIZAR:

Como sugirió @Stefan, aquí están los resultados de ordenar una lista grande menos veces:

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

Huellas dactilares:

Sort: 8965ms
OrderBy: 8460ms

En este escenario, parece que OrderBy funciona mejor.

ACTUALIZACIÓN2:

Y usando nombres aleatorios:

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

Dónde:

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

Rendimientos:

Sort: 8968ms
OrderBy: 8728ms

Aún así, OrderBy es más rápido

No, no son el mismo algoritmo. Para empezar, el LINQ OrderByestá documentado como estable (es decir, si dos elementos tienen el mismo Name, aparecerán en su orden original).

También depende de si almacena la consulta en búfer o la itera varias veces (LINQ-to-Objects, a menos que almacene el resultado, reordenará por foreach).

Para la OrderByconsulta, también estaría tentado a usar:

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

(para {yourchoice}uno de CurrentCulture, Ordinalo InvariantCulture).

List<T>.Sort

Este método usa Array.Sort, que usa el algoritmo QuickSort. Esta implementación realiza un tipo inestable; es decir, si dos elementos son iguales, es posible que no se conserve su orden. Por el contrario, una clasificación estable conserva el orden de los elementos que son iguales.

Enumerable.OrderBy

Este método realiza una clasificación estable; es decir, si las claves de dos elementos son iguales, se conserva el orden de los elementos. Por el contrario, una ordenación inestable no conserva el orden de los elementos que tienen la misma clave. ordenar; es decir, si dos elementos son iguales, es posible que no se conserve su orden. Por el contrario, una clasificación estable conserva el orden de los elementos que son iguales.

La respuesta de Darin Dimitrov muestra que OrderByes un poco más rápido que List.Sortcuando se enfrenta a una entrada ya ordenada. Modifiqué su código para que ordene repetidamente los datos sin clasificar y, OrderByen la mayoría de los casos, sea un poco más lento.

Además, la OrderByprueba utiliza ToArraypara forzar la enumeración del enumerador Linq, pero eso obviamente devuelve un tipo ( Person[]) que es diferente del tipo de entrada ( List<Person>). Por lo tanto, volví a ejecutar la prueba usando en ToListlugar de ToArrayy obtuve una diferencia aún mayor:

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

El código:

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

Creo que es importante notar otra diferencia entre Sorty OrderBy:

Supongamos que existe un Person.CalculateSalary()método que requiere mucho tiempo; posiblemente más que incluso la operación de ordenar una lista grande.

Comparar

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

La opción 2 puede tener un rendimiento superior, porque solo llama al CalculateSalarymétodo n veces, mientras que la Sortopción puede llamar CalculateSalaryhasta 2 n log ( n ) veces, dependiendo del éxito del algoritmo de ordenación.

En pocas palabras:

Ordenar lista / matriz ():

• Tipo inestable.
• Hecho en el lugar.
• Utilice Introsort / Quicksort.
• La comparación personalizada se realiza proporcionando un comparador. Si la comparación es cara, puede ser más lenta que OrderBy () (que permite usar claves, ver más abajo).

OrderBy / ThenBy ():

• Tipo estable.
• Fuera de lugar.
• Utilice Quicksort. Quicksort no es un tipo estable. Aquí está el truco: al ordenar, si dos elementos tienen la misma clave, compara su orden inicial (que se ha almacenado antes de ordenar).
• Permite usar claves (usando lambdas) para ordenar elementos por sus valores (ej x => x.Id.:). Todas las claves se extraen primero antes de ordenar. Esto podría resultar en un mejor rendimiento que usar Sort () y un comparador personalizado.

Fuentes: MDSN , fuente de referencia y repositorio dotnet / coreclr (GitHub).

Algunas de las declaraciones enumeradas anteriormente se basan en la implementación actual del marco .NET (4.7.2). Podría cambiar en el futuro.

debe calcular la complejidad de los algoritmos utilizados por los métodos OrderBy y Sort. QuickSort tiene una complejidad de n (log n) como recuerdo, donde n es la longitud de la matriz.

También he buscado orderby's, pero no pude encontrar ninguna información ni siquiera en la biblioteca msdn. si no tiene los mismos valores y clasificación relacionados con una sola propiedad, prefiero usar el método Sort (); si no, use OrderBy.

Solo quiero agregar que orderby es mucho más útil.

¿Por qué? Porque puedo hacer esto:

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

¿Por qué comparador complicado? Simplemente ordene según un campo. Aquí estoy ordenando según TotalBalance.

Muy fácil.

No puedo hacer eso con el género. Me pregunto porque. Hazlo bien con orderBy.

En cuanto a la velocidad, siempre es O (n).