C# 列表List＜T＞排序整理

最新推荐文章于 2025-07-09 20:21:52 发布
原创 最新推荐文章于 2025-07-09 20:21:52 发布 · 2.5k 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c# #列表 #排序

Sort

Sort 是 List<T> 自带的排序方法，其排序特性如下：

1、默认升序；

2、会改变原列表；

3、不稳定排序：相等元素的相对次序可能会改变。

基本数据类型

方法一

List<int> intList = new List<int> {4, 5, 1, 3, 2};
// 升序
intList.Sort();  // 1 2 3 4 5
/*
// 降序（先升序，再反转）
intList.Sort();
intList.Reverse();  // 5 4 3 2 1
*/

方法二

List<int> intList = new List<int> {4, 5, 1, 3, 2};
// 升序
/*intList.Sort((x, y) => x.CompareTo(y));  // 1 2 3 4 5
/*
// 降序
intList.Sort((x, y) => y.CompareTo(x));  // 5 4 3 2 1
*/

自定义数据类型

自定义 Student 类

public class Student
{
    public string name {get; set;}
    public int age {get; set;}
    public int score {get; set;}
}

单属性排序

void dumpList(List<Student> stuList, string desc)
{
    Console.WriteLine(desc);
    foreach(var student in stuList)
    {
        Console.Write("name = {0}, age = {1}, score = {2}", student.name, student.age, student.score);
        Console.WriteLine();
    }
}

List<Student> stuList = new List<Student> {
    new Student() {name = "张三", age = 20, score = 95},
    new Student() {name = "李四", age = 19, score = 99},
    new Student() {name = "王五", age = 21, score = 95},
    new Student() {name = "赵六", age = 20, score = 90},
    new Student() {name = "陈七", age = 22, score = 95},
    new Student() {name = "刘八", age = 21, score = 92}
};
dumpList(stuList, "-----原始列表-----");
// -----原始列表-----
// name = 张三, age = 20, score = 95
// name = 李四, age = 19, score = 99
// name = 王五, age = 21, score = 95
// name = 赵六, age = 20, score = 90
// name = 陈七, age = 22, score = 95
// name = 刘八, age = 21, score = 92

stuList.Sort((x, y) => x.score.CompareTo(y.score));
dumpList(stuList, "-----按 score 属性升序-----");
// -----按 score 属性升序-----
// name = 赵六, age = 20, score = 90
// name = 刘八, age = 21, score = 92
// name = 张三, age = 20, score = 95
// name = 陈七, age = 22, score = 95
// name = 王五, age = 21, score = 95
// name = 李四, age = 19, score = 99

stuList.Sort((x, y) => y.age.CompareTo(x.age));
dumpList(stuList, "-----按 age 属性降序-----");
// -----按 age 属性降序-----
// name = 陈七, age = 22, score = 95
// name = 王五, age = 21, score = 95
// name = 刘八, age = 21, score = 92
// name = 赵六, age = 20, score = 90
// name = 张三, age = 20, score = 95
// name = 李四, age = 19, score = 99

嵌套排序

List<Student> stuList = new List<Student> {
    new Student() {name = "张三", age = 20, score = 95},
    new Student() {name = "李四", age = 19, score = 99},
    new Student() {name = "王五", age = 21, score = 95},
    new Student() {name = "赵六", age = 20, score = 90},
    new Student() {name = "陈七", age = 22, score = 95},
    new Student() {name = "刘八", age = 21, score = 92}
};
dumpList(stuList, "-----原始列表-----");
// -----原始列表-----
// name = 张三, age = 20, score = 95
// name = 李四, age = 19, score = 99
// name = 王五, age = 21, score = 95
// name = 赵六, age = 20, score = 90
// name = 陈七, age = 22, score = 95
// name = 刘八, age = 21, score = 92

stuList.Sort((x, y) => {
    int ret = y.score.CompareTo(x.score);
    if (ret == 0)
    {
        return x.age.CompareTo(y.age);
    }
    else
    {
        return ret;
    }
});
dumpList(stuList, "-----嵌套排序：按 score 降序，score 相同则按 age 升序-----");
// -----嵌套排序：按 score 降序，score 相同则按 age 升序-----
// name = 李四, age = 19, score = 99
// name = 张三, age = 20, score = 95
// name = 王五, age = 21, score = 95
// name = 陈七, age = 22, score = 95
// name = 刘八, age = 21, score = 92
// name = 赵六, age = 20, score = 90

ps

obj1.CompareTo(obj2) 返回值（int）：

  • 大于0（1）：obj1 在 obj2 后面；
  • 等于0（0）：obj1 和 obj2 在同一位置；
  • 小于0（-1）：obj1 在 obj2 前面；

OrderBy/OrderByDescending

OrderBy/OrderByDescending （OrderBy升序，OrderByDescending降序）是通用的序列排序方法，其排序特性如下：

1、使用前必须先引入命名空间：System.Linq；

2、不会改变原列表；

3、稳定排序：相等元素的相对次序不会改变。

基本数据类型

List<int> intList = new List<int> {4, 5, 1, 3, 2};
// 升序
intList = intList.OrderBy(x => x).ToList();  // 1 2 3 4 5
// 降序
intList = intList.OrderByDescending(x => x).ToList();  // 5 4 3 2 1

自定义数据类型

单属性排序

List<Student> stuList = new List<Student> {
    new Student() {name = "张三", age = 20, score = 95},
    new Student() {name = "李四", age = 19, score = 99},
    new Student() {name = "王五", age = 21, score = 95},
    new Student() {name = "赵六", age = 20, score = 90},
    new Student() {name = "陈七", age = 22, score = 95},
    new Student() {name = "刘八", age = 21, score = 92}
};
dumpList(stuList, "-----原始列表-----");
// -----原始列表-----
// name = 张三, age = 20, score = 95
// name = 李四, age = 19, score = 99
// name = 王五, age = 21, score = 95
// name = 赵六, age = 20, score = 90
// name = 陈七, age = 22, score = 95
// name = 刘八, age = 21, score = 92

stuList = stuList.OrderBy(obj => obj.score).ToList();
dumpList(stuList, "-----按 score 属性升序-----");
// -----按 score 属性升序-----
// name = 赵六, age = 20, score = 90
// name = 刘八, age = 21, score = 92
// name = 张三, age = 20, score = 95
// name = 王五, age = 21, score = 95
// name = 陈七, age = 22, score = 95
// name = 李四, age = 19, score = 99

stuList = stuList.OrderByDescending(obj => obj.age).ToList();
dumpList(stuList, "-----按 age 属性降序-----");
// -----按 age 属性降序-----
// name = 陈七, age = 22, score = 95
// name = 刘八, age = 21, score = 92
// name = 王五, age = 21, score = 95
// name = 赵六, age = 20, score = 90
// name = 张三, age = 20, score = 95
// name = 李四, age = 19, score = 99

嵌套排序

List<Student> stuList = new List<Student> {
    new Student() {name = "张三", age = 20, score = 95},
    new Student() {name = "李四", age = 19, score = 99},
    new Student() {name = "王五", age = 21, score = 95},
    new Student() {name = "赵六", age = 20, score = 90},
    new Student() {name = "陈七", age = 22, score = 95},
    new Student() {name = "刘八", age = 21, score = 92}
};
dumpList(stuList, "-----原始列表-----");
// -----原始列表-----
// name = 张三, age = 20, score = 95
// name = 李四, age = 19, score = 99
// name = 王五, age = 21, score = 95
// name = 赵六, age = 20, score = 90
// name = 陈七, age = 22, score = 95
// name = 刘八, age = 21, score = 92

stuList = stuList.OrderByDescending(obj => obj.score).ThenBy(obj => obj.age).ToList();
dumpList(stuList, "-----嵌套排序：按 score 降序，score 相同则按 age 升序-----");
// -----嵌套排序：按 score 降序，score 相同则按 age 升序-----
// name = 李四, age = 19, score = 99
// name = 张三, age = 20, score = 95
// name = 王五, age = 21, score = 95
// name = 陈七, age = 22, score = 95
// name = 刘八, age = 21, score = 92
// name = 赵六, age = 20, score = 90

stuList = stuList.OrderBy(obj => obj.score).ThenByDescending(obj => obj.age).ToList();
dumpList(stuList, "-----嵌套排序：按 score 升序，score 相同则按 age 降序-----");
// -----嵌套排序：按 score 升序，score 相同则按 age 降序-----
// name = 赵六, age = 20, score = 90
// name = 刘八, age = 21, score = 92
// name = 陈七, age = 22, score = 95
// name = 王五, age = 21, score = 95
// name = 张三, age = 20, score = 95
// name = 李四, age = 19, score = 99

ps

OrderBy/OrderByDescending 返回序列的类型为 IOrderedEnumerable<TSource>，可以用 ToList 将其转为列表！

即：

stuList = stuList.OrderBy(obj => obj.score).ToList();

=>

IOrderedEnumerable<Student> query = stuList.OrderBy(obj => obj.score);
stuList = query.ToList();

参考：

List<T>.Sort 方法

Enumerable.OrderBy 方法

C# List<T>排序总结

List排序
Kenshin Cui's Blog
12-22 1万+
摘要：在面向对象开发过程中我们经常将一组对象放到一个特定集合中，此时我们通常使用泛型集合来存放，常见的如：List 、Dictionary等。在使用这些泛型集合时我们有时需要对其进行排序，下面我们就一块看一下List如何进行排序（像Dictionary也有其相应的排序方式，例如说使用Linq语法方式，今天暂且不说）。 主要内容： 初始工作 默认排序方式 通过自定义比较器进行排序 设定排序范围 初始工作 假设我们有一个Student对象，简单起见这个对象只有三个属性，分别是学好、姓名、年龄。
C# 关于列表List＜T＞排序总结与整理
采菊东篱下，Python满乾坤！
04-28 2000
一、概述 SortedList 类代表了一系列按照键来排序的键/值对，这些键值对可以通过键和索引来访问。 排序列表是数组和哈希表的组合。它包含一个可使用键或索引访问各项的列表。 如果您使用索引访问各项，则它是一个动态数组（ArrayList）. 如果您使用键访问各项，则它是一个哈希表（Hashtable）。集合中的各项总是按键值排序。 二、SortedList 类的方法和属性 常用的属性 属性 描述 Capacity 获取或设置 SortedList 的容量。 Coun
c# List类排序方法
09-14
List类几种排序方法比较灵活 可以根据自己的需要 选用合适的方法
C# List<T>排序总结
热门推荐
寂寞的博客
06-19 6万+
这里有很多种方法对List进行排序，本文总结了三种方法，但多种实现。1.对基础类型排序方法一：调用sort方法，如果需要降序，进行反转：List<int> list = new List<int>(); list.Sort();// 升序排序 list.Reverse();// 反转顺序方法二：使用lambda表达式，在前面加个负号就是降序了List<int> list= new List<int>
C#基础篇（10）集合类之列表
最新发布
m0_55575697的博客
07-09 390
摘要：C#中的List<T>是System.Collections.Generic命名空间下的动态数组实现，提供比传统数组更灵活的功能。它能自动扩容，支持添加、删除、查询和排序等丰富操作，内部通过动态数组实现，当元素超过容量时会自动扩容（通常为2倍）。相比固定数组，List更适合元素数量变化的场景，但性能略低。关键优化点包括预分配容量和使用批量操作。开发者应根据元素是否频繁变化、性能需求等选择数组或List。理解其内部机制有助于编写高效代码。
C#中List<T>排序
aysh2418的博客
07-20 266
在面向对象开发过程中我们经常将一组对象放到一个特定集合中，此时我们通常使用泛型集合来存放，常见的如：List、Dictionary等。在使用这些泛型集合时我们有时需要对其进行排序，下面我们就一起学习下List<T>是如何进行排序的。 1.初始化集合 假如我们有一个Student对象，简单起见这个对象只有三个属性，分别是学号、姓名、年龄。 namespace YD...
C# 中列表List＜T＞排序
kouzhili1792的博客
07-27 532
c#列表排序
C# List ＜T＞排序
liufeng520的专栏
03-28 750
http://wenku.baidu.com/link?url=IDM-8KCMrQ7aOr9B61lFc6TIMD6IKZ-78KtIrtUJlmk78H6XHHPwXAmGcgHJyzXl_uRLUyk_akw1NgWi9aKZoJsODMBgjB1HMs0rGIdIS-m
C# List 排序
勇敢的心
12-20 1477
C# List 排序     摘要：在面向对象开发过程中我们经常将一组对象放到一个特定集合中，此时我们通常使用泛型集合来存放，常见的如：List 、Dictionary等。在使用这些泛型集合时我们有时需要对其进行排序，下面我们就一块看一下List如何进行排序（像Dictionary也有其相应的排序方式，例如说使用Linq语法方式，今天暂且不说）。 主要内容： 1.  初始工作 2...
C# List<T>.Sort排序
eidolon's blog
10-25 7690
定义一个类型 public class tt { public int id; public string name; public string sex; } 测试 List list = new List(); for (int i = 5; i > 0; i--)
C#中List＜T＞的排序相关的使用方法总结
jamenu的博客
06-14 1864
🌮1.Sort和实现Comparable接口此方式需要类去实现IComparable接口。
List<T>的排序
weixin_30292843的博客
08-02 77
　　在工作中，由于用来进行数据访问的ORM工具不提供按照字段的某个部分进行排序，如我需要按照身份证号的后四位来进行排序。这个时候，只能考虑将获得的对象集合List<T>来进行排序了。 　　list本身提供了一个sort方法，该方法需要传递一个类型为Comparison<T> 的参数，Comparison<T>是个委托类型，它定义的契约是 int（T，T）,即要...
List<T> sort
diudiu8888的专栏
07-15 118
 public static class StringFieldNameSortingSupport { #region Private expression tree helpers private static LambdaExpression GenerateSelector<TEntity>(String prop...
C# List<T>.Sort()总结
qq_39185530的博客
03-24 6428
最近做项目用到了排序功能，记录一下免得以后乱翻， List能用如下代码实现顺序反序排序，对于自定义类，重写Equals或实现IComparable接口可以用List模版实现排序 List<int> test = new List<int> { 1,2,3,4,5,6,7,8,9 }; string ...
C# List的Sort方法
Morris-w的专栏
11-04 890
当你调用 List< T >.Sort 方法时，如果类型 T 实现了 IComparable< T > 接口，那么列表中的元素会根据该接口定义的排序规则进行排序。如果没有实现 IComparable< T > 接口，但是实现了 IComparable 接口，那么也会使用 IComparable 接口的排序规则。你可以传入一个比较函数，该函数定义了两个元素之间的排序关系。比较函数应该返回一个整数，小于 0 表示第一个元素小于第二个元素，等于 0 表示两个元素相等，大于 0 表示第一个元素大于第二个元素。
C# list＜T＞中Sort排序用法
ghhong1988的专栏
01-02 2971
方法一：使用Comparison<T>委托 sort():说明： 如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。要实现这一点，首先应把数组的元素都转换成字符串（如有必要），以便进行比较。 如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具...
C# List排序Sort
中辽普坦的专栏
07-20 2万+
List类可以使用Sort()方法对元素排序。 Sort()方法定义了几个重载方法，分别是   public void List.Sort()，不带有任何参数的Sort方法   public void List.Sort(Comparison)，带有比较代理方法参数的Sort方法     public void List.Sort(IComparer)， 带有比较器参数的Sort方法
C#中，如何重写List<T>的sort方法的比较器？
04-02
<think>好的，我现在需要帮助用户了解如何在C#中自定义List<T>的Sort方法的比较器，特别是实现IComparer接口。首先，我得回忆一下C#中排序的相关知识。用户提到了引用中的内容，所以应该结合这些引用信息来组织答案...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

fightsyj

您的鼓励将是我分享的最大动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值