C # Sắp xếp và Thứ tự bằng cách so sánh

Tôi có thể sắp xếp một danh sách bằng cách sử dụng Sort hoặc OrderBy. Cái nào nhanh hơn? Cả hai đều hoạt động trên cùng một thuật toán?

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

Tại sao không đo lường nó:

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

Trên máy tính của tôi khi được biên dịch ở chế độ Phát hành, chương trình này sẽ in:

Sort: 1162ms
OrderBy: 1269ms

CẬP NHẬT:

Theo đề xuất của @Stefan, đây là kết quả của việc sắp xếp một danh sách lớn ít lần hơn:

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

Bản in:

Sort: 8965ms
OrderBy: 8460ms

Trong trường hợp này, có vẻ như OrderBy hoạt động tốt hơn.

CẬP NHẬT2:

Và sử dụng các tên ngẫu nhiên:

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

Ở đâu:

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

Sản lượng:

Sort: 8968ms
OrderBy: 8728ms

Still OrderBy nhanh hơn

Không, chúng không giống một thuật toán. Đối với người mới bắt đầu, LINQ OrderByđược ghi nhận là ổn định (nghĩa là nếu hai mục có cùng một mục Name, chúng sẽ xuất hiện theo thứ tự ban đầu).

Nó cũng phụ thuộc vào việc bạn đệm truy vấn hay lặp lại nhiều lần (LINQ-to-Objects, trừ khi bạn đệm kết quả, sẽ sắp xếp lại mỗi lần foreach).

Đối với OrderBytruy vấn, tôi cũng muốn sử dụng:

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

(đối với {yourchoice}một trong CurrentCulture, Ordinalhoặc InvariantCulture).

List<T>.Sort

Phương pháp này sử dụng Array.Sort, sử dụng thuật toán QuickSort. Việc triển khai này thực hiện một loại không ổn định; nghĩa là, nếu hai phần tử bằng nhau, thứ tự của chúng có thể không được giữ nguyên. Ngược lại, một sắp xếp ổn định bảo toàn thứ tự của các phần tử bằng nhau.

Enumerable.OrderBy

Phương pháp này thực hiện một sắp xếp ổn định; nghĩa là, nếu khóa của hai phần tử bằng nhau, thứ tự của các phần tử được giữ nguyên. Ngược lại, một sắp xếp không ổn định không bảo toàn thứ tự của các phần tử có cùng một khóa. sắp xếp; nghĩa là, nếu hai phần tử bằng nhau, thứ tự của chúng có thể không được giữ nguyên. Ngược lại, một sắp xếp ổn định bảo toàn thứ tự của các phần tử bằng nhau.

Câu trả lời của Darin Dimitrov cho thấy nó OrderBynhanh hơn một chút so với List.Sortkhi đối mặt với đầu vào đã được sắp xếp. Tôi đã sửa đổi mã của anh ấy để nó liên tục sắp xếp dữ liệu chưa được sắp xếp và OrderBytrong hầu hết các trường hợp, nó hơi chậm hơn.

Hơn nữa, OrderBykiểm tra sử dụng ToArrayđể buộc liệt kê Linq, nhưng điều đó rõ ràng trả về một kiểu ( Person[]) khác với kiểu đầu vào ( List<Person>). Do đó, tôi đã chạy lại thử nghiệm bằng cách sử dụng ToListchứ không phải ToArrayvà nhận được sự khác biệt lớn hơn:

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

Mật mã:

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

Tôi nghĩ điều quan trọng cần lưu ý là sự khác biệt khác giữa Sortvà OrderBy:

Giả sử tồn tại một Person.CalculateSalary()phương pháp, phương pháp này mất rất nhiều thời gian; có thể nhiều hơn cả thao tác sắp xếp một danh sách lớn.

Đối chiếu

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

Tùy chọn 2 có thể có hiệu suất cao hơn, vì nó chỉ gọi CalculateSalaryphương thức n lần, trong khi Sorttùy chọn có thể gọi CalculateSalarytối đa 2 n log ( n ) lần, tùy thuộc vào thành công của thuật toán sắp xếp.

Tóm lại:

Danh sách / Sắp xếp Mảng ():

• Sắp xếp không ổn định.
• Thực hiện tại chỗ.
• Sử dụng Introsort / Quicksort.
• So sánh tùy chỉnh được thực hiện bằng cách cung cấp một trình so sánh. Nếu so sánh là đắt, nó có thể chậm hơn OrderBy () (cho phép sử dụng các khóa, xem bên dưới).

OrderBy / ThenBy ():

• Sắp xếp ổn định.
• Không đúng chỗ.
• Sử dụng Quicksort. Quicksort không phải là một loại ổn định. Đây là mẹo: khi sắp xếp, nếu hai phần tử có khóa bằng nhau, nó sẽ so sánh thứ tự ban đầu của chúng (đã được lưu trữ trước khi sắp xếp).
• Cho phép sử dụng các khóa (sử dụng lambdas) để sắp xếp các phần tử theo giá trị của chúng (ví dụ x => x.Id:). Tất cả các khóa được trích xuất trước khi sắp xếp. Điều này có thể dẫn đến hiệu suất tốt hơn so với việc sử dụng Sort () và một trình so sánh tùy chỉnh.

Nguồn: MDSN , nguồn tham khảo và kho lưu trữ dotnet / coreclr (GitHub).

Một số câu lệnh được liệt kê ở trên dựa trên việc triển khai .NET framework hiện tại (4.7.2). Nó có thể thay đổi trong tương lai.

bạn nên tính độ phức tạp của các thuật toán được sử dụng bằng các phương pháp OrderBy và Sort. QuickSort có độ phức tạp n (log n) theo tôi nhớ, trong đó n là độ dài của mảng.

Tôi cũng đã tìm kiếm orderby's, nhưng tôi không thể tìm thấy bất kỳ thông tin nào ngay cả trong thư viện msdn. nếu bạn không có bất kỳ giá trị nào giống nhau và việc sắp xếp chỉ liên quan đến một thuộc tính, tôi thích sử dụng phương thức Sort () hơn; nếu không, hãy sử dụng OrderBy.

Tôi chỉ muốn thêm rằng orderby là cách hữu ích hơn.

Tại sao? Bởi vì tôi có thể làm điều này:

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

Tại sao so sánh phức tạp? Chỉ cần sắp xếp dựa trên một trường. Ở đây tôi sắp xếp dựa trên TotalBalance.

Rất dễ.

Tôi không thể làm điều đó với sự sắp xếp. Tôi tự hỏi tại sao. Làm tốt với trật tựBy.

Đối với tốc độ, nó luôn luôn là O (n).