C#中List.Sort()--集合排序方法分析

最新推荐文章于 2024-02-29 21:03:01 发布
最新推荐文章于 2024-02-29 21:03:01 发布
阅读量7.4k 收藏 25
点赞数 2
分类专栏： C# C#教学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xieyunc/article/details/105624406
版权
C# 同时被 2 个专栏收录
40 篇文章 5 订阅
订阅专栏
C#教学
28 篇文章 1 订阅
订阅专栏

在C#中，List.Sort() 不仅为我们提供了默认的排序方法，还为我们提供了4种自定义排序的方法，通过默认排序方法，我们无需重写任何Sort()方法的实现代码，就能对单参数类型的List数据进行单一规则的排序，如果通过对这些方法进行改进我们可以轻松做到对多参数、多规则的复杂排序。

下面是C#自定义排序的4种方法：

  1. List<T>.Sort();         
  2. List<T>.Sort(IComparer<T> Comparer);
  3. List<T>.Sort(int index, int count, IComparer<T> Comparer);
  4. List<T>.Sort(Comparison<T> comparison);

实现目标

假设存在一个People类，包含Name、Age属性，在客户端中创建List保存多个实例，希望对List中的内容根据Name和Age参数进行排序，排序规则为，先按姓名升序排序，如果姓名相同再按年龄的升序排序：

class People
{
    public People(string name, int age) { Name = name; Age = age; }
    public string Name { get; set; } //姓名
    public int Age { get; set; }  //年龄
}

// 客户端
class Client
{
    static void Main(string[] args)
    {
        List<People> peopleList = new List<People>();
        peopleList.Add(new People("张三", 22));
        peopleList.Add(new People("张三", 24));
        peopleList.Add(new People("李四", 18));
        peopleList.Add(new People("王五", 16));
        peopleList.Add(new People("王五", 30));
    }
}

方法一、对People类继承IComparable接口，实现CompareTo()方法

该方法为系统默认的方法，单一参数时会默认进行升序排序。但遇到多参数（Name、Age）排序时，我们需要对该默认方法进行修改。

  • 方法一：People类继承IComparable接口，实现CompareTo()方法
  • IComparable<T>：定义由值类型或类实现的通用比较方法，旨在创建特定于类型的比较方法以对实例进行排序。
  • 原理：自行实现的CompareTo()方法会在list.Sort()内部进行元素两两比较，最终实现排序
class People : IComparable<People>
{
    public People(string name, int age) { Name = name;Age = age; }
    public string Name { get; set; }
    public int Age { get; set; }

    // list.Sort()时会根据该CompareTo()进行自定义比较
    public int CompareTo(People other)
    {
        if (this.Name != other.Name)
        {
            return this.Name.CompareTo(other.Name);
        }
        else if (this.Age != other.Age)
        {
            return this.Age.CompareTo(other.Age);
        }
        else return 0;
    }
}

// 客户端
peopleList.Sort();

// OUTPUT:
//      李四 18
//      王五 16
//      王五 30
//      张三 22
//      张三 24

方法二：增加People类的外部比较类，继承IComparer接口、实现Compare()方法

区别于上述继承IComparable的方法，该方法不可在People内继承实现IComparer接口，而是需要新建比较方法类进行接口实现

  • 方法二：新建PeopleComparer类、继承IComparer接口、实现Compare()方法
  • 原理：list.Sort()将PeopleComparer类的实例作为参数，在内部使用Compare()方法进行两两比较，最终实现排序（注：上述方法为CompareTo()，此处为Compare()方法）
// 自定义比较方法类
class PeopleComparer : IComparer<People>
{
    // 区别于CompareTo()单参数，此处为双参数
    public int Compare(People x, People y)
    {
        if (x.Name != y.Name)
        {
            return x.Name.CompareTo(y.Name);
        }
        else if (x.Age != y.Age)
        {
            return x.Age.CompareTo(y.Age);
        }
        else return 0;
    }
}

// 客户端
// 传入参数为自定义比较类的实例            
peopleList.Sort(new PeopleComparer());

// OUTPUT:
//      李四 18
//      王五 16
//      王五 30
//      张三 22
//      张三 24

同理，List<T>.Sort(int index, int count, IComparer<T> Comparer) 方法的参数：待排元素起始索引、待排元素个数、排序方法

方法三、采用泛型委托 Comparison<T>，绑定自定义的比较方法

区别于上述继承接口的方法，此方法的参数为 泛型委托 Comparison<T>

  • 委托原型：public delegate int Comparison<in T>(T x, T y);
  • 方法三：依照委托的使用方法，首先创建委托实例MyComparison，并绑定到自定义的比较方法PeopleComparison()上，最终调用list.Sort()时 将委托实例传入
  • 原理：list.Sort()根据传入的委托方法，进行两两元素比较最终实现排序
// 客户端
class Client
{
    // 方法0 自定义比较方法
    public static int PeopleComparison(People p1, People p2)
    {
        if (p1.Name != p2.Name)
        {
            return p1.Name.CompareTo(p2.Name);
        }
        else if (p1.Age != p2.Age)
        {
            return p1.Age.CompareTo(p2.Age);
        }
        else return 0;
    }

    static void Main(string[] args)
    {
        / 创建list ... /
        
        // 方法0 创建委托实例并绑定
        Comparison<People> MyComparison = PeopleComparison;

        // 传入该实例实现比较方法
        peopleList.Sort(MyComparison);

        // OUTPUT:
        //      李四 18
        //      王五 16
        //      王五 30
        //      张三 22
        //      张三 24
    }
}

此外，既然Comparison<T>是泛型委托，则完全可以用 Lambda表达式 进行描述：

// Lambda表达式实现Comparison委托
peopleList.Sort((p1, p2) =>
{
    if (p1.Name != p2.Name)
    {
        return p2.Name.CompareTo(p1.Name);
    }
    else if (p1.Age != p2.Age)
    {
        return p2.Age.CompareTo(p1.Age);
    }
    else return 0;
});

// OUTPUT:
//      张三 24
//      张三 22
//      王五 30
//      王五 16
//      李四 18

总结

虽然本文仅使用了List<T>一种容器对Sort()方法进行阐述，但是不同容器的使用Sort()的方法大相径庭，因为核心的原理都是应用两种接口及泛型委托：

  • 两种接口：IComparable<T> 、 IComparer<T>
  • 泛型委托：Comparison<T>

参考

 附：一个完整的测试Demo

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
  
namespace ListSort
{
    class Program
    {
        static void DisplayInfo<T>(List<T> list) {
            //输出List元素内容
            foreach(var item in list) {
                System.Console.Write("{0} ",item.ToString());
            }
            System.Console.WriteLine("");
        }

        // 方法3 自定义委托泛型比较方法
        public static int PeopleComparison(People p1, People p2)
        {
            if (p1.Name != p2.Name)
            {
                return p1.Name.CompareTo(p2.Name);
            }
            else if (p1.Age != p2.Age)
            {
                return p1.Age.CompareTo(p2.Age);
            }
            else return 0;
        }
        static void Main(string[] args)
        {
            List<People> peopleList = new List<People>();
            peopleList.Add(new People("张三", 22));
            peopleList.Add(new People("张三", 24));
            peopleList.Add(new People("李四", 18));
            peopleList.Add(new People("王五", 16));
            peopleList.Add(new People("王五", 30));

            System.Console.WriteLine("排序前原始数据：");
            DisplayInfo(peopleList);
            System.Console.WriteLine("------------------------------------");

            System.Console.WriteLine("方法1排序后数据：");
            peopleList.Sort();
            DisplayInfo(peopleList);

            System.Console.WriteLine("方法2排序后数据：");
            DisplayInfo(peopleList);

            // 方法1 使用IComparer<T>接口。
            peopleList.Sort(new PeopleComparer());
  
            // 方法2 除以上两种方法以外还可以使用另一种方法，在People类中实现IComparable<T>
            peopleList.Sort();
            System.Console.WriteLine("方法3排序后数据：");
            DisplayInfo(peopleList);

            // 方法3 创建泛型委托实例并绑定
            Comparison<People> MyComparison = PeopleComparison;

            // 传入该实例实现比较方法
            peopleList.Sort(MyComparison);

            System.Console.WriteLine("方法3排序后数据：");
            DisplayInfo(peopleList);

            // 方法3 使用Comparison<T>委托，Lambda写法
            peopleList.Sort((left, right) =>
            {
                //先按姓名排序，如果姓名相同再按年龄排序
                int x = left.Name.CompareTo(right.Name);
                if(x==0) {
                    if (left.Age > right.Age)
                        x = 1;
                    else if (left.Age == right.Age)
                        x = 0;
                    else
                        x = -1;
                }
                return x;
            });
  
        }
    }

　　//方法一
    public class People : IComparable<People>
    {
        public int Age { get;set;}
        public string Name { get;set;}
        public People(string name,int age) {
            this.Name = name;
            this.Age = age;
        }

        public override string ToString() {
            string result = "";
            result = "["+this.Name+","+ this.Age.ToString()+"]";
            return result;

        }

        public int CompareTo(People other)
        {
            int x = this.Name.CompareTo(other.Name);
            if(x==0) {
                if (this.Age > other.Age)
                    x = 1;
                else if (this.Age == other.Age)
                    x = 0;
                else
                    x = -1;
            }
            return x;
        }
    }

   //方法二
   public class PeopleComparer : IComparer<People>
   {
       public int Compare(People left, People right)
       {
            int x = left.Name.CompareTo(right.Name);
            if(x==0) {
                if (left.Age > right.Age)
                    x = 1;
                else if (left.Age == right.Age)
                    x = 0;
                else
                    x = -1;
            }
            return x;
       }
   }

}

 

小宇飞刀
关注
  • 2
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#之Sort排序
qq_3517289697的博客
01-15 1122
c#short排序算法是.NET Framework中提供的排序方法之一，其使用的算法是基于比较的排序算法，即通过比较元素的大小来进行排序。在排序时，c#short会根据元素类型的不同使用不同的比较方法来判断大小关系。
C#中sort排序相关用法介绍
qiaodahua的博客
05-10 5402
本文介绍了C#中sort排序方法的使用几种情况，并且举例证明
C# List.Sort排序
Peter的博客
03-08 1万+
C#中，List.Sort() 不仅为我们提供了默认的排序方法，还为我们提供了4种自定义排序的方法，通过默认排序方法，我们无需重写任何Sort()方法的实现代码，就能对单参数类型的List数据进行单一规则的排序，如果通过对这些方法进行改进我们可以轻松做到对多参数、多规则的复杂排序。 默认排序 排序Sort,倒序Reverse //默认是元素第一个字母按升序 list.Sort(); //将List里面元素顺序反转 list.Reverse(); //从第二个元素开始，反转4个元素 //结果list.
【C#】 List.Sort 方法
最新发布
Wilhelm的博客
02-29 1267
get {//传入的对象相当于0的位置 //other = 传入对象 //小于0： //放在传入对象的前面 //等于0： //保持当前的位置不变 //大于0： //放在传入对象的后面 if(this . Atk > other . Atk) {return 1;
C#中List的排序(Sort)
思月行云
08-13 5155
本文原创版权归 博客园 灵动生活 所有，转载请标明原创作者及出处，以示尊重！ 作者：灵动生活 原文：http://www.cnblogs.com/ywqu/archive/2009/01/21/1379186.html   要对自定义类数组或List进行排序，譬如： List userList; ArrayList arrayList; 最重要的是：继承IComparer接口，实现i
C#通过IComparable实现ListT.sort()排序
09-04
当我们需要对列表中的元素进行排序时，`List<T>.Sort()` 方法是一个非常方便的工具。但默认情况下，`Sort()` 方法根据元素类型T的自然顺序进行排序，例如整型(int)按值大小排序。然而，如果我们需要对自定义对象进行...
C#源代码-List泛型集合.zip
06-04
在本压缩包"C#源代码-List泛型集合.zip"中，重点聚焦于C#中的`List<T>`类，这是一个非常常用的泛型集合，用于存储同类型的元素序列。`List<T>`是`System.Collections.Generic`命名空间下的一个类，它实现了`IList<T>...
C#源代码-List泛型集合的三个练习.zip
06-04
在C#编程中，List是.NET框架中常用的一个泛型集合，它提供了许多方便的方法来处理数组或集合中的对象。本压缩包文件“C#源代码-List泛型集合的三个练习”包含了三个练习，旨在帮助学习者深入理解和应用List类。以下...
C#中Arraylist的sort函数用法实例分析
09-03
总结来说，C#中ArrayList的Sort方法提供了对ArrayList元素进行排序的能力，既可以使用默认的比较规则，也可以通过自定义IComparer实现来满足特定的排序需求。在实际开发中，为了更好的类型安全和性能，建议使用泛型...
C#使用sort方法对数组进行快速排序
07-29
C#使用sort方法对数组进行快速排序
C# Sort 按年龄排序
03-15
2万多名员工按年龄排序算法， 算法思想是归并排序，同时结合年龄取值的实际情况。
C# List排序简介及四种方法介绍-附代码
热门推荐
weixin_45499836的博客
08-23 1万+
有时用户需要按某项排序，但是查询结果以List格式存储，我们当然可以自己编写一个快速排序的方法进行排序，但是还有多个选择，并且可能比你写的短、效率也不差，那不如在恰当的时候选择其他方法对List进行排序。c#的一大特色就是Linq，他遍布c#里里外外，利用他可以减少大量的代码，不过他是从SQL中出来的，所以SQL还是了解之后，这个就好懂了。方法一： List的OrderBy与OrderByDescending方法。方法二：使用Sort方法，方法四：使用Linq。
javascript中的一些常用方法：call() , apply() , slice() , sort()
a909197213的博客
02-18 1133
1、call与apply /* 知乎：https://www.zhihu.com/question/20289071  */ call 和 apply 都是为了改变某个函数运行时的 context 即上下文而存在的，换句话说，就是为了改变函数体内部 this 的指向。因为 JavaScript 的函数存在「定义时上下文」和「运行时上下文」以及「上下文是可以改变的」这样的概念。
列表排序并返回索引_【c#资料】排序列表（SortedList）
weixin_39846186的博客
11-20 696
排序列表（SortedList）1.简介SortedList 类代表了一系列按照键来排序的键/值对，这些键值对可以通过键和索引来访问。排序列表是数组和哈希表的组合。它包含一个可使用键或索引访问各项的列表。如果您使用索引访问各项，则它是一个动态数组（ArrayList），如果您使用键访问各项，则它是一个哈希表（Hashtable）。注意：集合中的各项总是默认按照键（key）来排序。2.特性介绍1） ...
C# List.Sort
kingBook928的博客
02-22 172
List<int> list=new List<int>{2,3,5,1,4}; list.Sort((int a,int b)=>{ return a-b; }); string str=""; for(int i=0;i<list.Count;i++){ str+=list[i].ToString(); } Debug.Log(str);/...
C# .Sort()函数
qq_40610492的博客
04-21 1万+
List提供了.sort()函数进行排序 如果T是基本类型的话，.sort()是可以直接使用的，比如List、List等 如果是我们自己定义的Class的话，我们就必须自己定义，这时我们需要：IComparer接口中的Compare函数 List.sort()有四种形式： 1. .sort() 在List中的元素对象必须继承于IComparer，而且实现了 CompareTo()方法，基...
C#Sort排序
紫晓慕瑞的博客
09-26 5679
本文转载自http://blog.csdn.net/zhulongxi/article/details/51457891 同时也加入了自己制作的一个例子供大家学习参考，以便更好的理解这个排序
C# 泛型集合中的排序
q__y__L的博客
02-13 1186
就算不熟悉Linq，熟悉SQL查询语句的，也能很快上手Linq。List类的Sort方法有4个重载，其中一个是Sort(IComparer comparer)，也就是你可以直接传入一个实现ICompare的对象，Sort方法会调用次对象的固定方法，这里我们将这个特殊的对象叫做。从前面的讨论可以看出最简单的排序方法是利用Linq或者Lambda，另外两种会增加额外的代码量，但是我们应该了解其背后的原理，Linq和Lambda都是C#后面陆续推出的，自然会更能节省开发者时间。
c# list集合按照字母排序
05-24
可以使用List的Sort方法来对字符串类型的元素进行排序，示例代码如下： ```csharp List<string> list = new List<string>{"orange", "apple", "banana", "pear"}; list.Sort(); // 正序排序 // list.Sort((a, b) => b.CompareTo(a)); // 倒序排序 foreach (string s in list) { Console.WriteLine(s); } ``` 输出结果为： ``` apple banana orange pear ``` 如果需要进行倒序排序，可以使用Sort方法的重载，传入一个比较器函数，示例代码中已经注释掉了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值