浅谈C#容器类型数据排序

已于 2023-12-12 10:49:43 修改
阅读量109 收藏
点赞数 1
文章标签： c# 开发语言
于 2023-11-28 00:26:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44293426/article/details/134656676
版权

0. 完整代码链接

链接：https://pan.baidu.com/s/1NibsPHraeUFSq1uxuioMdQ?pwd=hyw3 
提取码：hyw3

1. 基本值类型数据排序(引言)

我们先来看int型数组排序

    int[] nums = { 1, 5, 3, 9, 7 };
    
    Console.WriteLine("--- 排序前: ---" + "\n");
    foreach (int i in nums) 
    {
        Console.Write(i + " ");
    }
    
    Array.Sort(nums);
    
    Console.WriteLine("\n");
    Console.WriteLine("--- 排序后: ---" + "\n");
    
    foreach (int i in nums)
    {
        Console.Write(i + " ");
    }

输出：

没有问题

2. 那么问题来了，自定义数据类型可以这么排序吗？？?

先来看代码 

1. Student.cs

public class Student
{
    public int Id { get; set; }
    public float Score { get; set; }

    public override string ToString()
    {
        return $"Id: {Id}, Score: {Score}";
    }
}

2. Main.cs

Student[] stus =
{
    new Student(){ Id = 1, Score = 80},
    new Student(){ Id = 3, Score = 60},
    new Student(){ Id = 5, Score = 90},
    new Student(){ Id = 2, Score = 100},
    new Student(){ Id = 4, Score = 50},
};
Array.Sort(stus);

运行主函数，报异常

这个异常叫做无效操作异常，或者叫错误操作异常
原因是
在数组中失败的比较了两个元素，
内部异常 —— 参数异常：至少一个对象必须实现可比较接口(IComparable)

3. 那么问题又来了，为什么基本数据类型就可以直接排序，自定义类型就不可以呢？？？

通过查看 int 源码可以发现

原来int实现了接口IComparable，所以可以排序

这个接口有一个方法

//
// Summary:
//    Defines a generalized comparison method that a value type or class implements
//    to create a type-specific comparison method for ordering or sorting its instances.
//    
//    定义值类型或类实现的通用比较方法，以创建特定于类型的比较方法用于排序，或排序它的实例。
//
// Type parameters:
//    T:
//    The type of object to compare.
//    需要比较的对象类型
public interface IComparable<in T>
{
    //
    // Summary:
    //    Compares the current instance with another object of the same type and returns
    //    an integer that indicates whether the current instance precedes, follows, or
    //    occurs in the same position in the sort order as the other object.
    //    将当前实例与另一个相同类型的对象进行比较，并返回一个整数，该整数指示当前实例在排序顺序        
    //    上是在另一个对象之前、之后还是出现在相同的位置。
    //
    // Parameters:
    //    other:
    //    An object to compare with this instance.
    //    和这个实例比较的一个对象
    // Returns:
    //    A value that indicates the relative order of the objects being compared. The
    //    return value has these meanings:
    //    指示被比较对象的相对顺序的值。
    //    返回值有以下含义:

    //    Value – Meaning(值含义)
    //    Less than zero – This instance precedes other in the sort order.
    //    小于零 - 此实例在排序顺序上位于其他实例之前。
    
    //    Zero – This instance occurs in the same position in the sort order as other.              
    //    0 - 此实例在排序顺序中出现在与其他实例相同的位置。

    //    Greater than zero – This instance follows other in the sort order.
    //    大于零 - 这个实例按照排序顺序跟在其他实例后面。
    int CompareTo(T? other);
}

而 int 重写了这个方法

public int CompareTo(object? value)
{
    if (value == null)
    {
        return 1;
    }
    if (value is int i)
    {
        if (m_value < i) return -1;
        if (m_value > i) return 1;
        return 0;
    }
    throw new ArgumentException(SR.Arg_MustBeInt32);
}

所以可以排序，既然如此自定义类型 Student 也实现这个接口(IComparable)不就可以了吗

代码如下：

public class Student : IComparable<Student>
{
    public int Id { get; set; }
    public float Score { get; set; }

    public override string ToString()
    {
        return $"Id: {Id}, Score: {Score}";
    }

    public int CompareTo(Student? other)
    {
        if (other == null) return -1;
        return this.Score > other.Score ? 1 : -1;
    }
}

运行如下代码：

Student[] stus =
{
    new Student(){ Id = 1, Score = 80},
    new Student(){ Id = 3, Score = 60},
    new Student(){ Id = 5, Score = 90},
    new Student(){ Id = 2, Score = 100},
    new Student(){ Id = 4, Score = 50},
};

Console.WriteLine("排序前: ");
foreach (Student stu in stus) 
{
    Console.WriteLine(stu);
}

Array.Sort(stus);

Console.WriteLine("排序后: ");
foreach (Student stu in stus)
{
    Console.WriteLine(stu);
}

结果图

这里按照学生成绩升序排序！！！

完美解决！

4. 问题又来了，C#功能这么强大，Sort方法难道没有重载？

翻看源码得知，原来Sort有这么多重载方法

 其中有一个方法Sort(Array array, IComparer? comparer)，这是什么？

5. IComparer比较器

翻看IComparer源码发现这是一个接口，里面有一个方法

public interface IComparer<in T>
{
    int Compare(T? x, T? y);
}

能否如法炮制，自定义一个类传入这个接口对象，实现自定义类型排序呢

答案肯定可以！

public class StudentComparer : IComparer<Student>
{
    public int Compare(Student? x, Student? y)
    {
        if (x == null || y == null) return 0;
        return x.Score.CompareTo(y.Score);
    }
}

6. CompareTo方法源码

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int CompareTo(float value)
{
    if (m_value < value) return -1;
    if (m_value > value) return 1;
    if (m_value == value) return 0;
    // At least one of the values is NaN.
    if (IsNaN(m_value))
        return IsNaN(value) ? 0 : -1;
    else // f is NaN.
        return 1;
}

Student.cs

public class Student
{
    public int Id { get; set; }
    public float Score { get; set; }

    public override string ToString()
    {
        return $"Id: {Id}, Score: {Score}";
    }
}

Main.cs

Student[] stus =
{
    new Student(){ Id = 1, Score = 80},
    new Student(){ Id = 3, Score = 60},
    new Student(){ Id = 5, Score = 90},
    new Student(){ Id = 2, Score = 100},
    new Student(){ Id = 4, Score = 50},
};

Console.WriteLine("排序前: ");
foreach (Student stu in stus)
{
    Console.WriteLine(stu);
}

Array.Sort(stus, new StudentComparer());

Console.WriteLine("排序后: ");
foreach (Student stu in stus)
{
    Console.WriteLine(stu);
}

输出结果与 标题3结果图一致！

7. 面向接口编程

前面两种方法从概念来说都属于面向接口编程

一个是类实现IComparable

一个是类实现IComparer

8. 用委托实现

 其实还提供了一个 Sort 方法

public static void Sort<T>(T[] array, Comparison<T> comparison)

这里 Comparison 是一个委托

public delegate int Comparison<in T>(T x, T y);

所以代码可以这么改写：

public static void Main(string[] args)
{
    Student[] stus =
    {
        new Student(){ Id = 1, Score = 80},
        new Student(){ Id = 3, Score = 60},
        new Student(){ Id = 5, Score = 90},
        new Student(){ Id = 2, Score = 100},
        new Student(){ Id = 4, Score = 50},
    };

    Console.WriteLine("排序前: ");
    foreach (Student stu in stus)
    {
        Console.WriteLine(stu);
    }

    Array.Sort(stus, CompareByScore);

    Console.WriteLine("排序后: ");
    foreach (Student stu in stus)
    {
        Console.WriteLine(stu);
    }
}
static int CompareByScore(Student a, Student b)
{
    return a.Score > b.Score ? 1 : -1;
}

这里CompareByScore不一定要被static修饰，因为Main被static修饰了，所以CompareByScore也要被static修饰，否则会报错，因为静态方法里不能调用实例方法

输出结果：

9. 用Lambda表达式实现

委托都用了，Lambda表达式更可以用！

改写代码如下

Student[] stus =
{
    new Student(){ Id = 1, Score = 80},
    new Student(){ Id = 3, Score = 60},
    new Student(){ Id = 5, Score = 90},
    new Student(){ Id = 2, Score = 100},
    new Student(){ Id = 4, Score = 50},
};

Console.WriteLine("排序前: ");
foreach (Student stu in stus)
{
    Console.WriteLine(stu);
}

Array.Sort(stus, (Student stu1, Student stu2) =>
{
    return stu1.Score > stu2.Score ? 1 : -1;
});

Console.WriteLine("排序后: ");
foreach (Student stu in stus)
{
    Console.WriteLine(stu);
}

输出结果不变：

10. (扩展)冒泡排序

10.1 普通版

void BubbleSort(int[] nums)
{
    int len = nums.Length;
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 0; j < len - i - 1; j++)
        {
            if (nums[j] > nums[j + 1])
            {
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
            }
        }
    }
}

看了这篇帖子，以后就不要这么写了，不通用！

10.2 通用版

/// <summary>
/// 这里condition作为条件委托参数传入, 您可以自定义专属于自己的冒泡排序条件！！！
/// </summary>
/// <typeparam name="T"> 参数类型 </typeparam>
/// <param name="array"> 数组变量名 </param>
/// <param name="contion"> 条件 </param>
static void BubbleSort<T>(T[] array, Func<T, T, bool> condition)
{
    int len = array.Length;
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 0; j < len - i - 1; j++)
        {
            if (condition(array[j], array[j + 1]))
            {
                T temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

10.3 测试代码

int[] nums = { 1, 5, 7, 3, 9 };

Console.WriteLine("排序前: ");
foreach (var item in nums)
{
    Console.Write(item + " ");
}

BubbleSort<int>(nums, (a, b) =>
{
    return a > b;
});

Console.WriteLine("\n\n排序后: ");
foreach (var item in nums)
{
    Console.Write(item + " ");
}

输出结果：

百里.登风
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#：实现Numerical string sort数字字符串排序算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-03 278
C#：实现Numerical string sort数字字符串排序算法(附完整源码)
c#输入三个数升序排列_如何用C#设计数字排序器
weixin_39685674的博客
12-21 531
双击【排序】按钮，生成Click事件，在事件中输入如下代码：double a = double.Parse(textBox1.Text);double b = double.Parse(textBox2.Text);double c = double.Parse(textBox3.Text);if (a > b){if (b > c){ label5.Text = a + ">"...
【C# 技术】 C# 常用排序方式——自定义数据排序
最新发布
grape_yan的博客
01-01 1769
在最近的项目中经常会对C#中的数据进行排序，对于基本数据类型，其排序方式比较简单，只需要调用内置算法即可实现，但对于自定义数据类型以及自定义排序规则的情况实现起来就比较麻烦，所以在本文章中将详细介绍一下在中C#中如何对数据进行排序。
C# 数据容器详解：Array、List、Dictionary、LinkedList、Queue、Stack
xinzhilinger的博客
04-20 1989
ArrayList 关于ArrayList的原理： 核心是数组： 可以动态扩容：通过创建一个更大的新数组，来将原来的数组转移到新数组 插入删除方便 存储的是对象： 需要装箱、拆箱操作 是不安全类型 List 核心是数组： 可以动态扩容：同样是创建新的更大数组来迁移数据 使用泛型来实现对装箱拆箱操作的避免 内存优化 对于List可以规定长度，来避免 动态扩容操作，这样就可以避免新的内存空间的消耗 HashTable 键值对形式： ton ...
浅谈C#中的值类型和引用类型
01-01
C#只有两种数据类型：值类型和引用类型 值类型在线程栈分配空间，引用类型在托管堆分配空间 值类型转为引用类型称成为装箱，引用类型转为值类型称为拆箱 以下是值类型和引用类型对照表 从上图可以简单看出：string...
浅谈C#中对引用类型的误解
08-25
主要介绍了浅谈C#中对引用类型的误解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
浅谈C# 中的可空值类型 null
01-01
C# 不允许把 null 赋给一个值类型的数据。在 C# 中，以下语句是非法的： 代码如下:int a = null; // 非法  但是，利用 C# 定义的一个修饰符，可将一个变量声明为一个可空（nullable）值类型。可空值类型在行为上...
浅谈c#表达式树Expression简单类型比较demo
12-26
实例如下： using System; using System.Linq.Expressions; class DynamicPredicate { public static Expression<Func>> Generate(string op) { ParameterExpression x = Expression.Parameter(typeof(T), "x");...
（九）顺序容器
qq_40212968的博客
07-24 484
顺序容器
C#完成的排序演示器【附源码】
04-18
C#完成的排序演示器，可用于教学~~ 内附源码，简单易懂，有利于对怕徐算法的理解O(∩_∩)O~
c#输入三个整数，按从小到大顺序输出。
热门推荐
Roninzhz的博客
11-21 1万+
1.编程实现：输入三个整数，按从小到大顺序输出。 //实现三个数从小到大的排序 public static void Sort() { Console.WriteLine("请输入三个整数回车分开：\n"); /*此处的 x y z 分别从控制台获取三个键盘输入的数据 并且此处的 int.Parse作用：将往控制台输入的数据转成int整型数据 */
C# 数字排序
wpyok168的博客
09-06 2452
使用list.sort()、list.orderby()、string[].orderby()排序例子 using System; using System.Collections.Generic; using System.Linq; using System.Text.RegularExpressions; namespace 数字排序 { class Program { stat...
c#三个数从小到大排序_怎么实现数字从小到大的排列
weixin_29009081的博客
12-28 1492
该楼层疑似违规已被系统折叠隐藏此楼查看此楼/*冒泡排序：让数组中的元素两两比较(第i号与第i+1号比较)，如要把数组num元素按从小到大排序：* 先拿第0号元素和第1号比较，若nums[0]>nums[1]，则把二者互换位置int[]nums={9,8,7,6,5,4,3,2,1};* 第一趟：* nums[0]为9，nums[1]为8，9>8,将nums[0]和nums[1]互换位...
c# 数字字母混合排序比较器
zhanhuajie1991的博客
08-20 1192
项目上涉及到一些编码的排序，网上找了一下没有合适的比较器，于是自己动手编写了一个。供大家学习参考。 class StringComparer : IComparer<string> { public bool MatchCase { get; } public StringComparer(bool match...
C# 容器上控件排序
勿忘初心
06-17 6930
public static class Sort { #region 设置PanelControl上按钮显示位置 /// /// 设置按钮显示位置 /// /// 需要调整按钮顺序的Panel /// 按钮间隔 public static void SetButtonCen
C# 伪随机数 随机数顺序排列 附带双色球机选程序
SpriteNet的专栏
10-25 2931
伪随机数是一个老生常谈的问题 因为貌似能一夜暴富的最稳定的办法就是买彩票了，当然我也抱有这个幻想。。。。。。我觉得彩票和魔方以及像数独其他什么的都可以看作是数组或者矩阵，特别是玩魔方的高手肯定都是一些数学比较优秀的人 彩票貌似看起来就是随机事件，开奖的时候也貌似很正规，抓哪个球就是哪个球，只不过是机器抓的，但是反过来想想，天朝都能把女航天员送上天、原子弹都能造出来，难道还不能控制彩票的结果？开
C#计数排序
计算机的世界
07-27 294
计数排序是一种适合于最大值和最小值的差值不是不是很大的排序。例如 temp[i] = m, 表示元素 i 一共出现了 m 次 /// <summary> /// 计数排序 /// </summary> static void CountSort(int[] arr) { //1.得到数列的最大值 int Max = arr[0]; for
如何用C#设计一个简单的Windows程序，输入5个数字，然后排序并输出
攻城狮小关的博客
10-26 2412
1.题目要求如下： C#设计一个简单的Windows程序，输入5个数字，然后排序并输出，如图所示 2.来吧，展示： using System; using System.Windows.Forms; namespace sort { public partial class Form1 : Form { public Form1() { InitializeComponent(); } ..
c#按数据类型arraylist排序
09-09
其次，C语言非常灵活，允许程序员自定义数据类型和操作符。这使得程序更易读、易维护和易扩展。此外，C语言的语法简洁而清晰，易于学习和理解。它也具有高效性，生成的代码运行速度快，占用的内存较少。 C语言广泛...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值