C#教程

关注公众号 jb51net

关闭
首页 > 软件编程 > C#教程 > C#排序方式

C#常用排序方式总结

作者:椒颜皮皮虾

在最近的项目中经常会对C#中的数据进行排序,对于基本数据类型,其排序方式比较简单,只需要调用内置算法即可实现,但对于自定义数据类型以及自定义排序规则的情况实现起来就比较麻烦,所以在本文章中将详细介绍一下在中C#中如何对数据进行排序,需要的朋友可以参考下

1. 常规数据排序

1.1 使用Sort排序

  对于系统内置数据,我们可以使用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代码以查询数据库相同的方式操作内存数据。在此处我们可以使用两种方式实现:

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方法直接进行排序,默认是采用正序进行排序,此处提供了三种方式:

代码如下所示:

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代码以查询数据库相同的方式操作内存数据。在此处我们可以使用两种方式实现:

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#排序方式的资料请关注脚本之家其它相关文章!

您可能感兴趣的文章:
阅读全文