C # Sort e comparação OrderBy

Posso classificar uma lista usando Sort ou OrderBy. Qual é mais rápido? Ambos estão trabalhando no mesmo 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 que não medir:

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

No meu computador, quando compilado no modo Release, este programa imprime:

Sort: 1162ms
OrderBy: 1269ms

ATUALIZAR:

Conforme sugerido por @Stefan, aqui estão os resultados de classificar uma lista grande menos vezes:

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

Impressões:

Sort: 8965ms
OrderBy: 8460ms

Nesse cenário, parece que o desempenho de OrderBy é melhor.

ATUALIZAÇÃO2:

E usando nomes aleatórios:

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

Onde:

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

Rendimentos:

Sort: 8968ms
OrderBy: 8728ms

Ainda assim, OrderBy é mais rápido

Não, eles não são o mesmo algoritmo. Para começar, o LINQ OrderByé documentado como estável (ou seja, se dois itens tiverem o mesmo Name, eles aparecerão em sua ordem original).

Também depende de você armazenar em buffer a consulta em vez de iterá-la várias vezes (LINQ-to-Objects, a menos que você armazene o resultado em buffer, será reordenado por foreach).

Para a OrderByconsulta, também ficaria tentado a usar:

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

(para {yourchoice}um de CurrentCulture, Ordinalou InvariantCulture).

List<T>.Sort

Este método usa Array.Sort, que usa o algoritmo QuickSort. Essa implementação executa uma classificação instável; ou seja, se dois elementos forem iguais, sua ordem pode não ser preservada. Em contraste, uma classificação estável preserva a ordem dos elementos que são iguais.

Enumerable.OrderBy

Este método executa uma classificação estável; ou seja, se as chaves de dois elementos são iguais, a ordem dos elementos é preservada. Em contraste, uma classificação instável não preserva a ordem dos elementos que possuem a mesma chave. ordenar; ou seja, se dois elementos forem iguais, sua ordem pode não ser preservada. Em contraste, uma classificação estável preserva a ordem dos elementos que são iguais.

A resposta de Darin Dimitrov mostra que isso OrderByé um pouco mais rápido do que List.Sortquando confrontado com uma entrada já classificada. Modifiquei seu código para que classifique repetidamente os dados não classificados e, OrderByna maioria dos casos, é um pouco mais lento.

Além disso, o OrderByteste usa ToArraypara forçar a enumeração do enumerador Linq, mas isso obviamente retorna um tipo ( Person[]) que é diferente do tipo de entrada ( List<Person>). Portanto, executei novamente o teste usando em ToListvez de ToArraye obtive uma diferença ainda maior:

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

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

Acho importante notar outra diferença entre Sorte OrderBy:

Suponha que exista um Person.CalculateSalary()método que leve muito tempo; possivelmente mais do que a operação de classificação de uma grande lista.

Comparar

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

A opção 2 pode ter desempenho superior, pois chama o CalculateSalarymétodo apenas n vezes, enquanto a Sortopção pode chamar CalculateSalaryaté 2 n log ( n ) vezes, dependendo do sucesso do algoritmo de ordenação.

Resumindo:

Classificar por lista / matriz ():

• Tipo instável.
• Feito no local.
• Use o Introsort / Quicksort.
• A comparação personalizada é feita fornecendo um comparador. Se a comparação for cara, pode ser mais lenta do que OrderBy () (que permite o uso de chaves, veja abaixo).

OrderBy / ThenBy ():

• Tipo estável.
• Não está no lugar.
• Use Quicksort. Quicksort não é um tipo estável. Aqui está o truque: ao classificar, se dois elementos tiverem chaves iguais, ele compara sua ordem inicial (que foi armazenada antes da classificação).
• Permite usar chaves (usando lambdas) para classificar os elementos em seus valores (por exemplo x => x.Id:). Todas as chaves são extraídas antes da classificação. Isso pode resultar em melhor desempenho do que usar Sort () e um comparador personalizado.

Fontes: MDSN , fonte de referência e repositório dotnet / coreclr (GitHub).

Algumas das declarações listadas acima são baseadas na implementação atual do .NET framework (4.7.2). Isso pode mudar no futuro.

você deve calcular a complexidade dos algoritmos usados ​​pelos métodos OrderBy e Sort. QuickSort tem uma complexidade de n (log n), como me lembro, onde n é o comprimento da matriz.

Também procurei o Orderby's, mas não consegui encontrar nenhuma informação, mesmo na biblioteca do msdn. se você não tiver os mesmos valores e classificação relacionada a apenas uma propriedade, prefiro usar o método Sort (); se não, use OrderBy.

Só quero acrescentar que o pedido por é muito mais útil.

Por quê? Porque eu posso fazer isso:

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

Por que comparador complicado? Basta classificar com base em um campo. Aqui estou classificando com base no TotalBalance.

Muito fácil.

Eu não posso fazer isso com sorte. Eu quero saber porque. Faça bem com orderBy.

Quanto à velocidade, é sempre O (n).