C#常用排序方式總結(jié)

更新時(shí)間：2024年01月02日 08:35:52 作者：椒顏皮皮蝦

在最近的項(xiàng)目中經(jīng)常會(huì)對(duì)C#中的數(shù)據(jù)進(jìn)行排序,對(duì)于基本數(shù)據(jù)類型,其排序方式比較簡(jiǎn)單,只需要調(diào)用內(nèi)置算法即可實(shí)現(xiàn),但對(duì)于自定義數(shù)據(jù)類型以及自定義排序規(guī)則的情況實(shí)現(xiàn)起來(lái)就比較麻煩,所以在本文章中將詳細(xì)介紹一下在中C#中如何對(duì)數(shù)據(jù)進(jìn)行排序,需要的朋友可以參考下

1. 常規(guī)數(shù)據(jù)排序

1.1 使用Sort排序

對(duì)于系統(tǒng)內(nèi)置數(shù)據(jù)，我們可以使用Sort方法直接進(jìn)行排序，默認(rèn)是采用正序進(jìn)行排序，此處提供了三種方式：

方式一：使用默認(rèn)的Sort()方法直接就可以進(jìn)行排序。
方式二：使用Sort()方法并添加回調(diào)函數(shù)，回調(diào)函數(shù)調(diào)用數(shù)據(jù)類型CompareTo()方法。
方式三：使用Sort()方法并添加回調(diào)函數(shù)，回調(diào)函數(shù)進(jìn)行自定義，此處采用三目運(yùn)算符寫了個(gè)簡(jiǎn)單的方法。

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

如果是想進(jìn)行逆序排序，最簡(jiǎn)單的方式就是將正序排列的數(shù)組進(jìn)行一次反轉(zhuǎn)即可，不然的話就是改變方法二以及方法三的回調(diào)函數(shù)輸出，如下面代碼所示。

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語(yǔ)句進(jìn)行排序

然后我們介紹一下使用LINQ語(yǔ)句進(jìn)行排序，LINQ是一組用于C#和Visual Basic語(yǔ)言的擴(kuò)展。它允許編寫C#或者Visual Basic代碼以查詢數(shù)據(jù)庫(kù)相同的方式操作內(nèi)存數(shù)據(jù)。在此處我們可以使用兩種方式實(shí)現(xiàn)：

方式一：使用原生的LINQ語(yǔ)句進(jìn)行查詢，此處主要通過(guò)自己寫LINQ語(yǔ)句；
方式二：使用封裝好的方法OrderBy()，該方法使用比較簡(jiǎn)單，可以直接調(diào)用對(duì)應(yīng)大方法即可。

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

如果要項(xiàng)進(jìn)行逆序排序，此處可以添加descending關(guān)鍵字進(jìn)行設(shè)定，或者直接使用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 多條件排序

在實(shí)際使用時(shí)，我們可能會(huì)遇到多條件排序，即第一個(gè)條件相等時(shí)時(shí)，在采用第二個(gè)條件排序，如果遇到這種情況，我們處理起來(lái)可能就比較麻煩。如下面代碼所示，對(duì)于一個(gè)字符串?dāng)?shù)組，我想首先按照字符串長(zhǎng)度進(jìn)行排序，如果字符串長(zhǎng)度相等，就按照首字母進(jìn)行排序。實(shí)現(xiàn)方式如下所示：

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表達(dá)式創(chuàng)建了一個(gè)委托函數(shù)，在這個(gè)委托函數(shù)里，我們按照排序要求，對(duì)其進(jìn)行了定義，主要是對(duì)返回值的條件進(jìn)行了定義，最后排序結(jié)果輸出為:

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

不過(guò)該方式看起來(lái)實(shí)現(xiàn)是比較復(fù)雜的，對(duì)于大多是人來(lái)說(shuō)，可能很難看懂，所以此處我們向大家展示一個(gè)比較簡(jiǎn)單的方式，就是使用LINQ語(yǔ)句進(jìn)行多條件排序，如下面代碼所示：

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語(yǔ)句進(jìn)行排序看起來(lái)就比較簡(jiǎn)單了，上面依舊是展示了兩種方式，對(duì)于多條件排序，如果使用自定義LINQ語(yǔ)句排序就只需要在上一個(gè)條件后增加次要條件即可；如果使用封裝后的LINQ語(yǔ)句，就可以在OrderBy()增加ThenBy()方法添加第二個(gè)條件。如果想實(shí)現(xiàn)反向排序，實(shí)現(xiàn)方式與上文相同。

2. 自定義數(shù)據(jù)排序

下面我們進(jìn)行自定義數(shù)據(jù)進(jìn)行排序，如下面代碼所示，我們?cè)诖颂幎x了一個(gè) Person類，并且繼承了IComparable<Person>接口，該接口主要是用于后面調(diào)用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排序

對(duì)于自定義數(shù)據(jù)，我們可以使用Sort方法直接進(jìn)行排序，默認(rèn)是采用正序進(jìn)行排序，此處提供了三種方式：

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

代碼如下所示：

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

}

排序后結(jié)果輸出為：

如果想進(jìn)行逆序排序，需要修改一下比較規(guī)則

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語(yǔ)句進(jìn)行排序

接下來(lái)介紹一下使用LINQ語(yǔ)句進(jìn)行排序，LINQ是一組用于C#和Visual Basic語(yǔ)言的擴(kuò)展。它允許編寫C#或者Visual Basic代碼以查詢數(shù)據(jù)庫(kù)相同的方式操作內(nèi)存數(shù)據(jù)。在此處我們可以使用兩種方式實(shí)現(xiàn)：

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

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

如果想進(jìn)行逆序排序，只需要添加descending關(guān)鍵字進(jìn)行設(shè)定，或者直接使用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 多條件排序

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

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

}

如果想進(jìn)行逆序排序，只需要修改一下相關(guān)的比較條件即可，逆序排序代碼如下所示：

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

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

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

如果想進(jìn)行逆序排序，對(duì)于原生LINQ語(yǔ)句，在條件后添加descending即可，對(duì)于封裝后的LINQ語(yǔ)句，

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

自定義數(shù)據(jù)排序后，程序運(yùn)行最后輸出為：

自定義數(shù)據(jù)逆序排序后，程序運(yùn)行最后輸出為：

3. 多維數(shù)據(jù)排序

在實(shí)際應(yīng)用中，我們可能還會(huì)使用到多維數(shù)據(jù)，例如對(duì)于二維數(shù)據(jù)，我們?cè)谂判驎r(shí)可能會(huì)按照第二維數(shù)據(jù)的第一個(gè)數(shù)據(jù)作為主要排序關(guān)鍵字，第二數(shù)據(jù)作為第二個(gè)關(guān)鍵字進(jìn)行排序，當(dāng)遇到這種情況時(shí)，我們可以直接使用LINQ語(yǔ)句進(jìn)行排序，如下面代碼所示，我們定義了一個(gè)二維數(shù)組，類似于將一系列點(diǎn)數(shù)據(jù)存放到數(shù)組中，然后我們可以參考上文中自定義數(shù)據(jù)排序方法，書(shū)寫排序代碼：

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

排序后結(jié)果輸出為：