Danh sách C # <> Sắp xếp theo x rồi đến y

Tương tự như List <> OrderBy theo thứ tự bảng chữ cái , chúng ta muốn sắp xếp theo một phần tử, rồi đến phần tử khác. chúng tôi muốn đạt được chức năng tương đương với

SELECT * from Table ORDER BY x, y  

Chúng tôi có một lớp chứa một số hàm sắp xếp và chúng tôi không gặp vấn đề gì khi sắp xếp theo một phần tử.
Ví dụ:

public class MyClass {
    public int x;
    public int y;
}  

List<MyClass> MyList;

public void SortList() {
    MyList.Sort( MySortingFunction );
}

Và chúng tôi có những thứ sau trong danh sách:

Unsorted     Sorted(x)     Desired
---------    ---------    ---------
ID   x  y    ID   x  y    ID   x  y
[0]  0  1    [2]  0  2    [0]  0  1
[1]  1  1    [0]  0  1    [2]  0  2
[2]  0  2    [1]  1  1    [1]  1  1
[3]  1  2    [3]  1  2    [3]  1  2

Sắp xếp ổn định sẽ được ưu tiên hơn, nhưng không bắt buộc. Giải pháp hoạt động cho .Net 2.0 được hoan nghênh.

Hãy nhớ rằng bạn không cần một sự sắp xếp ổn định nếu bạn so sánh tất cả các thành viên. Giải pháp 2.0, theo yêu cầu, có thể trông như thế này:

 public void SortList() {
     MyList.Sort(delegate(MyClass a, MyClass b)
     {
         int xdiff = a.x.CompareTo(b.x);
         if (xdiff != 0) return xdiff;
         else return a.y.CompareTo(b.y);
     });
 }

Xin lưu ý rằng giải pháp 2.0 này vẫn được ưa chuộng hơn giải pháp Linq 3.5 phổ biến, nó thực hiện sắp xếp tại chỗ và không có yêu cầu lưu trữ O (n) của phương pháp Linq. Tất nhiên, trừ khi bạn muốn đối tượng Danh sách ban đầu được giữ nguyên.

Đối với các phiên bản .Net nơi bạn có thể sử dụng LINQ OrderByvà ThenBy(hoặc ThenByDescendingnếu cần):

using System.Linq;
....
List<SomeClass>() a;
List<SomeClass> b = a.OrderBy(x => x.x).ThenBy(x => x.y).ToList();

Lưu ý: đối với .Net 2.0 (hoặc nếu bạn không thể sử dụng LINQ), hãy xem câu trả lời của Hans Passant cho câu hỏi này.

Bạn cần triển khai giao diện IComparer . Đây là một bài viết tốt với mã ví dụ.

Bí quyết là thực hiện một loại ổn định. Tôi đã tạo một lớp Widget có thể chứa dữ liệu thử nghiệm của bạn:

public class Widget : IComparable
{
    int x;
    int y;
    public int X
    {
        get { return x; }
        set { x = value; }
    }

    public int Y
    {
        get { return y; }
        set { y = value; }
    }

    public Widget(int argx, int argy)
    {
        x = argx;
        y = argy;
    }

    public int CompareTo(object obj)
    {
        int result = 1;
        if (obj != null && obj is Widget)
        {
            Widget w = obj as Widget;
            result = this.X.CompareTo(w.X);
        }
        return result;
    }

    static public int Compare(Widget x, Widget y)
    {
        int result = 1;
        if (x != null && y != null)                
        {                
            result = x.CompareTo(y);
        }
        return result;
    }
}

Tôi đã triển khai IComp so sánh được, vì vậy nó có thể được sắp xếp không ổn định theo List.Sort ().

Tuy nhiên, tôi cũng đã triển khai phương thức tĩnh Compare, phương thức này có thể được chuyển như một đại biểu cho một phương thức tìm kiếm.

Tôi đã mượn phương pháp sắp xếp chèn này từ C # 411 :

 public static void InsertionSort<T>(IList<T> list, Comparison<T> comparison)
        {           
            int count = list.Count;
            for (int j = 1; j < count; j++)
            {
                T key = list[j];

                int i = j - 1;
                for (; i >= 0 && comparison(list[i], key) > 0; i--)
                {
                    list[i + 1] = list[i];
                }
                list[i + 1] = key;
            }
    }

Bạn sẽ đặt điều này vào lớp trợ giúp sắp xếp mà bạn đã đề cập trong câu hỏi của mình.

Bây giờ, để sử dụng nó:

    static void Main(string[] args)
    {
        List<Widget> widgets = new List<Widget>();

        widgets.Add(new Widget(0, 1));
        widgets.Add(new Widget(1, 1));
        widgets.Add(new Widget(0, 2));
        widgets.Add(new Widget(1, 2));

        InsertionSort<Widget>(widgets, Widget.Compare);

        foreach (Widget w in widgets)
        {
            Console.WriteLine(w.X + ":" + w.Y);
        }
    }

Và nó xuất ra:

0:1
0:2
1:1
1:2
Press any key to continue . . .

Điều này có thể được làm sạch với một số đại biểu ẩn danh, nhưng tôi sẽ để điều đó cho bạn.

CHỈNH SỬA : Và NoBugz thể hiện sức mạnh của các phương pháp ẩn danh ... vì vậy, hãy coi tôi là trường cũ hơn: P

Điều này có thể giúp bạn, Cách sắp xếp Danh sách Chung C #

Tôi đã gặp sự cố trong đó OrderBy và ThenBy không cho tôi kết quả mong muốn (hoặc tôi không biết cách sử dụng chúng một cách chính xác).

Tôi đã đi với một danh sách. Giải pháp sắp xếp như thế này.

    var data = (from o in database.Orders Where o.ClientId.Equals(clientId) select new {
    OrderId = o.id,
    OrderDate = o.orderDate,
    OrderBoolean = (SomeClass.SomeFunction(o.orderBoolean) ? 1 : 0)
    });

    data.Sort((o1, o2) => (o2.OrderBoolean.CompareTo(o1.OrderBoolean) != 0
    o2.OrderBoolean.CompareTo(o1.OrderBoolean) : o1.OrderDate.Value.CompareTo(o2.OrderDate.Value)));