C # เรียงลำดับและเรียงลำดับโดยเปรียบเทียบ

ฉันสามารถจัดเรียงรายการโดยใช้ Sort หรือ OrderBy อันไหนเร็วกว่ากัน? ทั้งสองทำงานบนอัลกอริทึมเดียวกันหรือไม่

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 จะทำงานได้ดีกว่า

UPDATE2:

และใช้ชื่อสุ่ม:

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-to-Objects เว้นแต่คุณจะบัฟเฟอร์ผลลัพธ์จะเรียงลำดับใหม่ต่อforeach)

สำหรับOrderByคำถามนี้ฉันอยากจะใช้:

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

(สำหรับ{yourchoice}หนึ่งCurrentCulture, OrdinalหรือInvariantCulture)

List<T>.Sort

วิธีนี้ใช้ Array.Sort ซึ่งใช้อัลกอริทึม QuickSort การใช้งานนี้ดำเนินการจัดเรียงที่ไม่เสถียร นั่นคือถ้าสององค์ประกอบเท่ากันลำดับของมันอาจไม่ได้รับการรักษาไว้ ในทางตรงกันข้ามการจัดเรียงแบบคงที่จะรักษาลำดับขององค์ประกอบที่เท่ากัน

Enumerable.OrderBy

วิธีนี้ดำเนินการจัดเรียงที่มั่นคง นั่นคือถ้าคีย์ของสององค์ประกอบเท่ากันลำดับขององค์ประกอบจะถูกรักษาไว้ ในทางตรงกันข้ามการจัดเรียงที่ไม่เสถียรจะไม่รักษาลำดับขององค์ประกอบที่มีคีย์เดียวกัน เรียง; นั่นคือถ้าสององค์ประกอบเท่ากันลำดับของมันอาจไม่ได้รับการรักษาไว้ ในทางตรงกันข้ามการจัดเรียงแบบคงที่จะรักษาลำดับขององค์ประกอบที่เท่ากัน

คำตอบของ Darin Dimitrov แสดงให้เห็นว่าOrderByเร็วกว่าเล็กน้อยList.Sortเมื่อต้องเผชิญกับข้อมูลที่จัดเรียงไว้แล้ว ฉันแก้ไขโค้ดของเขาเพื่อให้มันเรียงลำดับข้อมูลที่ไม่ได้เรียงลำดับซ้ำ ๆ และOrderByในกรณีส่วนใหญ่ช้ากว่าเล็กน้อย

นอกจากนี้การOrderByทดสอบToArrayยังใช้เพื่อบังคับให้มีการแจงนับของ Linq enumerator แต่จะส่งกลับ type ( 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 ไม่ใช่การจัดเรียงที่มั่นคง นี่คือเคล็ดลับ: เมื่อจัดเรียงหากองค์ประกอบสองรายการมีคีย์เท่ากันจะเปรียบเทียบลำดับเริ่มต้น (ซึ่งเก็บไว้ก่อนการเรียงลำดับ)
• จะช่วยให้การใช้ปุ่ม (ใช้ lambdas) องค์ประกอบเรียงลำดับค่าของพวกเขา (เช่นx => x.Id) คีย์ทั้งหมดจะถูกแยกออกก่อนการเรียงลำดับ ซึ่งอาจส่งผลให้ประสิทธิภาพดีกว่าการใช้ Sort () และตัวเปรียบเทียบแบบกำหนดเอง

แหล่งที่มา: MDSN , แหล่งอ้างอิงและdotnet / coreclrพื้นที่เก็บข้อมูล (GitHub)

ข้อความบางส่วนที่ระบุไว้ข้างต้นเป็นไปตามการใช้งาน. NET framework ปัจจุบัน (4.7.2) อาจมีการเปลี่ยนแปลงในอนาคต

คุณควรคำนวณความซับซ้อนของอัลกอริทึมที่ใช้โดยวิธีการ OrderBy และ Sort QuickSort มีความซับซ้อนของ n (log n) เท่าที่ฉันจำได้โดยที่ n คือความยาวของอาร์เรย์

ฉันค้นหา orderby ด้วย แต่ฉันไม่พบข้อมูลใด ๆ แม้แต่ในไลบรารี msdn หากคุณไม่มีค่าเดียวกันและการเรียงลำดับที่เกี่ยวข้องกับคุณสมบัติเพียงรายการเดียวฉันต้องการใช้เมธอด Sort () ถ้าไม่ใช้ 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

ง่ายมาก.

ฉันทำแบบนั้นไม่ได้ ฉันสงสัยว่าทำไม. ทำได้ดีกับ orderBy

สำหรับความเร็วก็คือ O (n) เสมอ