C # Сортування та Порядок порівняння

Я можу сортувати список за допомогою Сортування або Упорядкувати. Який швидше? Обидва працюють за одним алгоритмом?

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 працює краще.

ОНОВЛЕННЯ2:

І з використанням випадкових імен:

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, вони з'являться у первинному порядку).

Це також залежить від того, чи буферизуєте ви запит проти ітерації його декілька разів (LINQ до об'єктів, якщо ви не буферуєте результат, буде повторно замовлений foreach).

Для OrderByзапиту я також захотів би використати:

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

(Для {yourchoice}одного з CurrentCulture, Ordinalабо InvariantCulture).

List<T>.Sort

Цей метод використовує Array.Sort, який використовує алгоритм QuickSort. Ця реалізація виконує нестабільний сорт; тобто якщо два елементи рівні, їх порядок може не зберігатися. На противагу цьому, стійкий сорт зберігає порядок елементів, рівних.

Enumerable.OrderBy

Цей метод виконує стабільний сорт; тобто, якщо ключі двох елементів рівні, порядок елементів зберігається. Навпаки, нестабільний сорт не зберігає порядок елементів, які мають однаковий ключ. сортувати; тобто якщо два елементи рівні, їх порядок може не зберігатися. На противагу цьому, стійкий сорт зберігає порядок елементів, рівних.

Відповідь Даріна Димитрова показує, що OrderByце дещо швидше, ніж List.Sortколи ми стикаємося з уже відсортованими введеннями. Я змінив його код, щоб він неодноразово сортував несортовані дані, а OrderByв більшості випадків трохи повільніше.

Крім того, OrderByтест використовує ToArrayдля примусового перерахування нумератора Linq, але це, очевидно, повертає тип ( 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 ) разів, залежно від успіху алгоритму сортування.

Коротко :

Сортувати список / масив ():

• Нестабільний сорт.
• Зроблено на місці.
• Використовуйте Introsort / Quicksort.
• Замовне порівняння проводиться шляхом порівняння. Якщо порівняння дороге, воно може бути повільніше, ніж OrderBy () (які дозволяють використовувати клавіші, див. Нижче).

OrderBy / thenBy ():

• Стабільний сорт.
• Не на місці.
• Використовуйте Quicksort. Quicksort - це не стійкий сорт. Ось хитрість: при сортуванні, якщо два елементи мають рівний ключ, він порівнює їх початковий порядок (який було збережено перед сортуванням).
• Дозволяє використовувати клавіші (за допомогою лямбда) для сортування елементів за їх значеннями (наприклад:) x => x.Id. Усі клавіші витягуються спочатку перед сортуванням. Це може призвести до кращих показників, ніж використання Sort () та спеціального порівняння.

Джерела: MDSN , довідкове джерело та сховище dotnet / coreclr (GitHub).

Деякі з перерахованих вище тверджень засновані на поточній реалізації .NET Framework (4.7.2). Це може змінитися в майбутньому.

слід обчислити складність алгоритмів, що використовуються методами OrderBy та Sort. QuickSort має складність n (log n), як я пам’ятаю, де n - довжина масиву.

Я теж шукав orderby, але я не міг знайти жодної інформації навіть у бібліотеці msdn. якщо у вас немає однакових значень та сортування, пов’язаних лише з одним властивістю, я вважаю за краще використовувати метод 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.

Дуже легко.

Я не можу зробити це з роду. Цікаво, чому. Зробіть добре з замовленням.

Що стосується швидкості, це завжди O (n).