當前位置：首頁 > 编程语言 > C# >内容正文

C#

【C# 技术】C# 常用排序方式

發布時間：2024/1/2 C# 41 coder

生活随笔收集整理的這篇文章主要介紹了【C# 技术】C# 常用排序方式小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

?前言
?在最近的項目中經常會對C#中的數據進行排序，對于基本數據類型，其排序方式比較簡單，只需要調用內置算法即可實現，但對于自定義數據類型以及自定義排序規則的情況實現起來就比較麻煩，所以在本文章中將詳細介紹一下在中C#中如何對數據進行排序。
?應用技術： LINQ; Array.Sort();

1. 常規數據排序

1.1 使用Sort排序

? 對于系統內置數據，我們可以使用Sort方法直接進行排序，默認是采用正序進行排序，此處提供了三種方式：

方式一：使用默認的Sort()方法直接就可以進行排序。
方式二：使用Sort()方法并添加回調函數，回調函數調用數據類型CompareTo()方法。
方式三：使用Sort()方法并添加回調函數，回調函數進行自定義，此處采用三目運算符寫了個簡單的方法。

static void test_general_sort()
{
    int[] data = { 89, 63, 48, 62, 75, 663, 45, 359, 42 };
    // 1. 方式一
    Array.Sort(data);
    // 2. 方式二
    Array.Sort(data, (x, y) => x.CompareTo(y));
    // 3. 方式三
    Array.Sort(data, (x, y) => x > y ? 1 : -1);
    print_array(data);
}

? 如果是想進行逆序排序，最簡單的方式就是將正序排列的數組進行一次反轉即可，不然的話就是改變方法二以及方法三的回調函數輸出，如下面代碼所示。

static void test_general_sort_()
{
    int[] data = { 89, 63, 48, 62, 75, 663, 45, 359, 42 };
    // 1. 方式一
    Array.Sort(data);
    Array.Reverse(data);
    // 2. 方式二
    Array.Sort(data, (x, y) => y.CompareTo(x));
    // 3. 方式三
    Array.Sort(data, (x, y) => x > y ? -1 : 1);
    print_array(data);
}

1.2 使用LINQ語句進行排序

? 然后我們介紹一下使用LINQ語句進行排序，LINQ是一組用于C#和Visual Basic語言的擴展。它允許編寫C#或者Visual Basic代碼以查詢數據庫相同的方式操作內存數據。在此處我們可以使用兩種方式實現：

方式一：使用原生的LINQ語句進行查詢，此處主要通過自己寫LINQ語句；
方式二：使用封裝好的方法OrderBy()，該方法使用比較簡單，可以直接調用對應大方法即可。

static void test_general_linq()
{
    int[] data = { 89, 63, 48, 62, 75, 663, 45, 359, 42 };
    // 1. 方式一
    IEnumerable<int> query = from d in data
                             orderby d
                             select d;
    // 2. 方式二
    query = data.OrderBy(x => x);
    print_array(query);
}

? 如果要項進行逆序排序，此處可以添加descending關鍵字進行設定，或者直接使用OrderByDescending() 方法。

static void test_general_linq_()
{
    int[] data = { 89, 63, 48, 62, 75, 663, 45, 359, 42 };
    // 1. 方式一
    IEnumerable<int> query = from d in data
                             orderby d descending
                             select d;
    // 2. 方式二
    query = data.OrderByDescending(x => x);
    print_array(query);
}

1.3 多條件排序

? 在實際使用時，我們可能會遇到多條件排序，即第一個條件相等時時，在采用第二個條件排序，如果遇到這種情況，我們處理起來可能就比較麻煩。如下面代碼所示，對于一個字符串數組，我想首先按照字符串長度進行排序，如果字符串長度相等，就按照首字母進行排序。實現方式如下所示：

static void test_general_sort_more()
{
    string[] words = { "the", "quick", "brown", "fox", "jumps", "and" };
    Array.Sort<string>(words, (x, y) =>
    {
        if (x.Length > y.Length) { return 1; }
        else if (x.Length == y.Length)
        {
            if (x.Substring(0, 1)[0] > y.Substring(0, 1)[0]) { return 1; }
            else { return -1; }
        }
        else { return -1; }
    });
    print_array(words);
}

? 在上面這段代碼中，我們主要是使用了Lambda表達式創建了一個委托函數，在這個委托函數里，我們按照排序要求，對其進行了定義，主要是對返回值的條件進行了定義，最后排序結果輸出為:

Array = {the, quick, brown, fox, jumps, and}
Array = {and, fox, the, brown, jumps, quick}

? 不過該方式看起來實現是比較復雜的，對于大多是人來說，可能很難看懂，所以此處我們向大家展示一個比較簡單的方式，就是使用LINQ語句進行多條件排序，如下面代碼所示：

static void test_general_linq_more()
{
    string[] words = { "the", "quick", "brown", "fox", "jumps", "and" };
    // 1. 方式一
    IEnumerable<string> query = from word in words
                                orderby word.Length, word.Substring(0, 1)
                                select word;
    // 2. 方式二
    query = words.OrderBy(x => x.Length).ThenBy(x => x.Substring(0, 1));
    print_array(query);
}

? 使用LINQ語句進行排序看起來就比較簡單了，上面依舊是展示了兩種方式，對于多條件排序，如果使用自定義LINQ語句排序就只需要在上一個條件后增加次要條件即可；如果使用封裝后的LINQ語句，就可以在OrderBy()增加ThenBy()方法添加第二個條件。如果想實現反向排序，實現方式與上文相同。

2. 自定義數據排序

? 下面我們進行自定義數據進行排序，如下面代碼所示，我們在此處定義了一個 Person類，并且繼承了IComparable<Person>接口，該接口主要是用于后面調用Sort方法所必需的接口。

class Person : IComparable<Person>
{
    public string name { get; set; }
    public int age { get; set; }
    public int id { get; set; }

    public int CompareTo(Person? other)
    {
        if (this.age > other.age) { return 1; }
        else { return -1; }
    }
    public override string ToString()
    {
        return "(id: " + id + ", name: " + name + ", age: " + age + ")";
    }
};

2.1 使用Sort排序

? 對于自定義數據，我們可以使用Sort方法直接進行排序，默認是采用正序進行排序，此處提供了三種方式：

方式一：使用默認的Sort()方法直接就可以進行排序，但是需要自定義數據繼承IComparable<T>接口
方式二：使用Sort()方法并添加回調函數，回調函數調用數據類型CompareTo()方法，該方法可以進行自定義。
方式三：使用Sort()方法并添加回調函數，回調函數進行自定義，此處采用三目運算符寫了個簡單的方法，該方式無需繼承繼承IComparable<T>接口以及在自定義數據中添加比較函數。

? 代碼如下所示：

static void test_person_sort()
{
    List<Person> list = new List<Person>()
    {
                new Person(){name="a",age=15,id=1 },
                new Person(){name="b",age=12,id=2 },
                new Person(){name="c",age=14,id=3 },
                new Person(){name="d",age=12,id=4 },
                new Person(){name="e",age=14,id=5 },
                new Person(){name="f",age=12,id=6 },
                new Person(){name="g",age=15,id=7 },
            };
    print_array(list);

    // 1. 方式一
    list.Sort();
    // 2. 方式二
    list.Sort((x, y) => x.CompareTo(y));
    // 3. 方式三
    list.Sort((x, y) => x.age > y.age ? 1 : -1);

    print_array(list);

}

? 排序后結果輸出為：

? 如果想進行逆序排序，需要修改一下比較規則

static void test_person_sort_()
{
    List<Person> list = new List<Person>()
    {
                new Person(){name="a",age=15,id=1 },
                new Person(){name="b",age=12,id=2 },
                new Person(){name="c",age=14,id=3 },
                new Person(){name="d",age=12,id=4 },
                new Person(){name="e",age=14,id=5 },
                new Person(){name="f",age=12,id=6 },
                new Person(){name="g",age=15,id=7 },
            };
    print_array(list);

    // 1. 方式一
    list.Sort((x, y) => y.CompareTo(x));
    // 2. 方式二
    list.Sort((x, y) => x.age > y.age ? -1 : 1);

    print_array(list);

}

? 逆序排序后的輸出為

2.2 使用LINQ語句進行排序

? 接下來介紹一下使用LINQ語句進行排序，LINQ是一組用于C#和Visual Basic語言的擴展。它允許編寫C#或者Visual Basic代碼以查詢數據庫相同的方式操作內存數據。在此處我們可以使用兩種方式實現：

方式一：使用原生的LINQ語句進行查詢，此處主要通過自己寫LINQ語句；在使用時要注意一點，如果自定義數據繼承IComparable<T>接口，那么該數據在比較時會自動調用該數據類的比較方法進行比較，如果未繼承該接口，就需要在輸入時指定該數據類型使用哪種數據進行比較，如下文代碼中，我們使用了d.age屬性進行數據比較。
方式二：使用封裝好的方法OrderBy()，該方法使用比較簡單，可以直接調用對應的方法即可，注意事項跟使用原生的LINQ語句一致。

static void test_person_linq()
{
    List<Person> list = new List<Person>()
            {
                new Person(){name="a",age=15,id=1 },
                new Person(){name="b",age=12,id=2 },
                new Person(){name="c",age=14,id=3 },
                new Person(){name="d",age=12,id=4 },
                new Person(){name="e",age=14,id=5 },
                new Person(){name="f",age=12,id=6 },
                new Person(){name="g",age=15,id=7 },
            };
    print_array(list);
    // 1. 方式一
    IEnumerable<Person> query = from d in list
                                orderby d.age
                                select d;
    // 2. 方式二
    query = list.OrderBy(x => x.age);
    print_array(query);
}

如果想進行逆序排序，只需要添加descending關鍵字進行設定，或者直接使用OrderByDescending() 方法。

static void test_person_linq_()
{
    List<Person> list = new List<Person>()
            {
                new Person(){name="a",age=15,id=1 },
                new Person(){name="b",age=12,id=2 },
                new Person(){name="c",age=14,id=3 },
                new Person(){name="d",age=12,id=4 },
                new Person(){name="e",age=14,id=5 },
                new Person(){name="f",age=12,id=6 },
                new Person(){name="g",age=15,id=7 },
            };
    print_array(list);
    // 1. 方式一
    IEnumerable<Person> query = from d in list
                                orderby d.age descending
                                select d;
    // 2. 方式二
    query = list.OrderByDescending(x => x.age);
    print_array(query);
}

2.3 多條件排序

? 在實際使用時，我們可能會遇到多條件排序，即第一個條件相等時時，在采用第二個條件排序，如果遇到這種情況，我們處理起來可能就比較麻煩，對于自定義數據，如果我們在定義數據時繼承IComparable<T>接口，并在接口方法中自定義排序要求即可。在下面中我們提供了一種使用Sort()接口并利用委托函數定義比較規則來實現數據排序，代碼如下所示：

static void test_person_sort_more()
{
    List<Person> list = new List<Person>()
            {
                new Person(){name="a",age=15,id=1 },
                new Person(){name="b",age=12,id=2 },
                new Person(){name="c",age=14,id=3 },
                new Person(){name="d",age=12,id=4 },
                new Person(){name="e",age=14,id=5 },
                new Person(){name="f",age=12,id=6 },
                new Person(){name="g",age=15,id=7 },
            };
    print_array(list);
    list.Sort((x, y) => {
        if (x.age > y.age) { return 1; }
        else if (x.age == y.age)
        {
            if (x.id > y.id) { return 1; }
            else { return -1; }
        }
        else { return -1; }
    });

    print_array(list);

}

? 如果想進行逆序排序，只需要修改一下相關的比較條件即可，逆序排序代碼如下所示：

static void test_person_sort_more_()
{
    List<Person> list = new List<Person>()
            {
                new Person(){name="a",age=15,id=1 },
                new Person(){name="b",age=12,id=2 },
                new Person(){name="c",age=14,id=3 },
                new Person(){name="d",age=12,id=4 },
                new Person(){name="e",age=14,id=5 },
                new Person(){name="f",age=12,id=6 },
                new Person(){name="g",age=15,id=7 },
            };
    print_array(list);
    list.Sort((x, y) => {
        if (y.age > x.age) { return 1; }
        else if (y.age == x.age)
        {
            if (y.id > x.id) { return 1; }
            else { return -1; }
        }
        else { return -1; }
    });

    print_array(list);
}

? 通過上面代碼我們可以看出使用除了可以使用Sort()接口是比較復雜的，其中的比較過程需要我們自己定義。下面我們將介紹使用LINQ語言進行多條件排序，當我們使用原生的LINQ語句時，在進行自定義數據比較時，需要聲明所選擇的對象的屬性，并且按照先后順序進行排序即可；如果使用封裝后的LINQ語句，可以使用OrderBy()以及ThenBy()分別指定條件，在添加條件時，要生命比較的對象屬性。代碼如下所示：

static void test_person_linq_more()
{
    List<Person> list = new List<Person>()
            {
                new Person(){name="a",age=15,id=1 },
                new Person(){name="b",age=12,id=2 },
                new Person(){name="c",age=14,id=3 },
                new Person(){name="d",age=12,id=4 },
                new Person(){name="e",age=14,id=5 },
                new Person(){name="f",age=12,id=6 },
                new Person(){name="g",age=15,id=7 },
            };
    print_array(list);
    // 1. 方式一
    IEnumerable<Person> query = from d in list
                                orderby d.age, d.id
                                select d;
    // 2. 方式二
    query = list.OrderBy(x => x.age).ThenBy(x => x.id);
    print_array(query);
}

? 如果想進行逆序排序，對于原生LINQ語句，在條件后添加descending即可，對于封裝后的LINQ語句，

static void test_person_linq_more_()
{
    List<Person> list = new List<Person>()
            {
                new Person(){name="a",age=15,id=1 },
                new Person(){name="b",age=12,id=2 },
                new Person(){name="c",age=14,id=3 },
                new Person(){name="d",age=12,id=4 },
                new Person(){name="e",age=14,id=5 },
                new Person(){name="f",age=12,id=6 },
                new Person(){name="g",age=15,id=7 },
            };
    print_array(list);

    // 1. 方式一
    IEnumerable<Person> query = from d in list
                                orderby d.age descending, d.id descending
                                select d;
    // 2. 方式二
    query = list.OrderByDescending(x => x.age).ThenByDescending(x => x.id);
    print_array(query);
}

? 自定義數據排序后，程序運行最后輸出為：

? 自定義數據逆序排序后，程序運行最后輸出為：

3. 多維數據排序

? 在實際應用中，我們可能還會使用到多維數據，例如對于二維數據，我們在排序時可能會按照第二維數據的第一個數據作為主要排序關鍵字，第二數據作為第二個關鍵字進行排序，當遇到這種情況時，我們可以直接使用LINQ語句進行排序，如下面代碼所示，我們定義了一個二維數組，類似于將一系列點數據存放到數組中，然后我們可以參考上文中自定義數據排序方法，書寫排序代碼：

static void test_array_sort()
{
    List<List<int>> list = new List<List<int>>() {
                new List<int>{ 1, 9 } ,
                new List<int>{ 6, 6 } ,
                new List<int>{ 1, 4 } ,
                new List<int>{ 6, 2 } ,
                new List<int>{ 1, 6 } ,
                new List<int>{ 7, 2 } ,
                new List<int>{ 1, 2 } ,
                new List<int>{ 3, 5 }
            };
    print_array(list);
    // 1. 方式一
    IEnumerable<List<int>> query = from d in list
                                   orderby d[0], d[1]
                                   select d;
    // 2. 方式二
    query = list.OrderBy(x => x[0]).ThenBy(x => x[1]);
    print_array(query);
}

排序后結果輸出為：

4. 總結

以上就是給大家帶來的C#常用排序方式一些實現方式，希望大家在日常使用中能夠用到。

總結

以上是生活随笔為你收集整理的【C# 技术】C# 常用排序方式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：文心一言 VS 讯飞星火 VS chat
下一篇：全球各类卫星遥感图像的下载方法汇总