• C#泛型-使用委托的Sort排序方法 泛型的排序有3种方法,分别是: 1、List.Sort(),只能在集合元素实现了IComparable泛型接口时使用 2、List.Sort(Comparison),Comparison是一个方法委托,它带有2个参数T,返回...
    

    C#泛型-使用委托的Sort排序方法

    泛型的排序有3种方法,分别是:
    1、List<T>.Sort(),只能在集合元素实现了IComparable泛型接口时使用
    2、List<T>.Sort(Comparison<T>),Comparison<T>是一个方法委托,它带有2个参数T,返回int类型,可以灵活指定如何排序,但是需要编码时手动指定如何排序;
    3、List<T>.Sort(IComparer<T>),使用实现了IComparer<T>接口的类给集合排序,可以灵活指定如何排序,但是需预先定义好类的排序方法

    这里介绍第二种方法:
    首先定义一个类,用作集合的元素
    using System;
    using System.Collections.Generic;


    /// <summary>
    /// 学生类
    /// </summary>
    public class Student
    {
        private string name;
        // 姓名
        public string Name
        {
            get { return name; }
            set { }
        }
        private int age;
        // 年龄
        public int Age
        {
            get { return age; }
            set { age = value; }
        }

        private string grade;
        // 年级
        public string Grade
        {
            get { return grade; }
            set { grade = value; }
        }


        //构造函数
        public Student(string name, int age, string grade)
        {
            this.name = name;
            this.age = age;
            this.grade = grade;
        }
        public override string ToString()
        {
            return this.name + "," + this.age.ToString() + "," + this.grade;
        }
    }

    下面就开始排序了:
    using System;
    using System.Collections.Generic;
    public class test
    {
        public static void Main()
        {
            List<Student> arr = new List<Student>();
            arr.Add(new Student("张三", 7, "一年级"));
            arr.Add(new Student("李四", 11, "二年级"));
            arr.Add(new Student("王五", 21, "一年级"));
            arr.Add(new Student("陈六", 8, "三年级"));
            arr.Add(new Student("刘七", 15, "二年级"));
           
            // 调用Sort方法,传入一个匿名方法,实现按年级排序
            arr.Sort(delegate(Student x, Student y) { return x.Grade.CompareTo(y.Grade ); }); 

     
            // 循环显示集合里的元素
            foreach( Student item in arr)
                Console.WriteLine(item.ToString());

            // 调用Sort方法,传入一个匿名方法,实现按姓名排序
            arr.Sort(delegate(Student x, Student y) { return x.Name.CompareTo(y.Name); });   
     

            // 循环显示集合里的元素
            foreach( Student item in arr)
                Console.WriteLine(item.ToString());
        }
    }

    展开全文
  • 泛型列表进行排序 泛型方法 非泛型方法 区别 int IComparable&lt;T&gt;.CompareTo(T otherObj) int IComparable.CompareTo(object otherObj) 在泛型版本中是强类型化的 bool IComparable...
    对泛型列表进行排序
    泛型方法 非泛型方法 区别
    int IComparable<T>.CompareTo(T otherObj) int IComparable.CompareTo(object otherObj) 在泛型版本中是强类型化的
    bool IComparable<T>.Equals(T otherObj) N/A 在非泛型接口中不存在,可以改用继承的object.Equals()
    int IComparer<T>.Compare(T objectA,T objectB) int IComparer.Compare(object objectA,object objectB) 在泛型版本中是强类型化的
    bool IComparer<T>.Equals(T otherA,T objectB) N/A 在非泛型接口中不存在,可以改用继承的object.Equals()
    int IComparer<T>.GetHashCode(T objectA) N/A 在非泛型接口中不存在,可以改用继承的object.GetHashCode()

    对要排序的类型提供IComparable<T>接口,或者提供IComparer<T>接口,就可以对List<T>进行排序。还可以提供泛型委托作为排序方法。例:

    Comparison<T>:这个委托类型用于排序方法,其返回类型和参数如下:

    int method(T objectA,T objectB)

    Predicate<T>:这个委托类型用于搜索方法,其返回类型和参数如下:

    bool method(T targetObject)

    展开全文
  • c#泛型排序·委托

    2020-03-10 15:15:46
    c#泛型排序 泛型排序用于多类对象结构体分别排序的情况,也算是进一步了解委托。 class Program { static void Main(string[] args) { Student[] stu = { new Student("stu1", 40), new Studen...

    c#泛型排序

    泛型排序用于多类对象结构体分别排序的情况,也算是进一步了解委托。

    class Program
        {
            static void Main(string[] args)
            {
                Student[] stu = {
                new Student("stu1", 40),
                 new Student("stu2", 50),
                 new Student("stu3", 46),
                new Student("stu4", 83),
                 new Student("stu5", 93),
                new Student("stu6", 29)};
                TSort<Student>(stu, Student.Compare);
                foreach (var item in stu)
                {
                    Console.WriteLine(item.ToString());
                }
            }
            static private void TSort<T>(T[] tt,Func<T,T,int> compare)//委托的使用
            {//泛型冒泡排序
                for (int i = 0; i < tt.Length-1; i++)
                {
                    for (int j = 0; j < tt.Length-i-1; j++)
                    {
                        if (compare(tt[j],tt[j+1])>0)
                        {
                            T temp = tt[j + 1];
                            tt[j + 1] = tt[j];
                            tt[j] = temp;
                        }
                    }
                }
            } 
       }
        class Student
        {//prop
            public string name { get; private set; }
            public int score { get;private set; }
    
            public Student(string name,int score)
            {//ctor
                this.name = name;
                this.score = score;
            }
            public override string ToString()
            {
                return name+":"+score;
            }
            static public int Compare(Student stu1,Student stu2)
            {//静态方法和非静态方法的区别,非静态方法只能通过实例化对象.调用,
                //非静态方法可通过类.调用,因而二者生命周期也不一样
                if (stu1.score<stu2.score)
                {
                    return -1;
                }
                else if(stu1.score>stu2.score)
                {
                    return 1;
                }
                else
                {
                    return 0;
                }
            }
        }
    
    展开全文
  • 在前面的文章中我们讲述了C#如何实现冒泡排序!那么有没有想过如何实现对任意的数据类型进行冒泡排序呢?这里我们将就此问题进行解答!首先我们了解到冒泡排序的本质就是升序或者降序排列一个数组的元素!我们首先去...

    在前面的文章中我们讲述了C#如何实现冒泡排序!那么有没有想过如何实现对任意的数据类型进行冒泡排序呢?这里我们将就此问题进行解答!首先我们了解到冒泡排序的本质就是升序或者降序排列一个数组的元素!我们首先去举个例子来感受一下冒泡排序,像整型数组就是这样排序:

     

           /// <summary>  
           /// 整型数组的冒泡排序  
           /// </summary>  
           /// <param name="arr"></param>  
           public static void BobbleSort(int[] arr)  
           {  
               for (int i = 0; i < arr.Length-1; i++)  
               {  
                   for (int j = 0; j < arr.Length-1-i; j++)  
                   {  
                       if (arr[j] < arr[j + 1])  
                       {  
                           int temp = arr[j];  
                           arr[j] = arr[j + 1];  
                           arr[j + 1] = temp;  
                       }  
                   }  
               }  
           }  

     

    字符串数组的冒泡排序就是:

     

            /// <summary>
            /// 字符串数组的冒泡排序
            /// </summary>
            /// <param name="arr"></param>
            public static void BobbleSortStr(string[] arr)
            {
                for (int i = 0; i < arr.Length - 1; i++)
                {
                    for (int j = 0; j < arr.Length - 1 - i; j++)
                    {
                        if (arr[j].Length < arr[j + 1].Length)
                        {
                            string temp = arr[j];
                            arr[j] = arr[j + 1];
                            arr[j + 1] = temp;
                        }
                    }
                }
            }

     

    通过这两个冒泡排序的观察我们不难发现,这两个排序的不同之处只有在数据交换的条件判断时不同,其他的地方一模一样.我们不妨考虑把这个地方提取出来根据数据不同传递不同的条件!此时我们可以考虑把这个条件写成一个方法来进行传递,给他一个返回值的结果就可以了,那么就需要考虑需要什么类型的返回值?我们观察条件得知需要比较来交换变量的用途,既然考量的是比较的结果,很容易想到连个数比较大小无外乎三种情况,大于0,小于0,等于0。这里我们把可以把等于0并入其中的一种情况! 此时确定了返回值类型,我们还需要比较的方法,聪明的你是否想到了委托就可以满足这里的需求呢!

    	public delegate int DelCompare<T>(T t1,T t2);//传入两个参数来作比较 


    然后修改刚才的代码:

     

     

            /// <summary>  
            /// 冒泡排序  
            /// </summary>  
            /// <param name="arr"></param>  
            public static void BobbleSort<T>(T[] arr,DelCompare<T> del)  
            {  
                for (int i = 0; i < arr.Length-1; i++)  
                {  
                    for (int j = 0; j < arr.Length-1-i; j++)  
                    {  
                        if (del(arr[j], arr[j + 1]) < 0)  
                        {  
                            T temp = arr[j];  
                            arr[j] = arr[j + 1];  
                            arr[j + 1] = temp;  
                        }  
                    }  
                }  
            }  

    不妨也把打印的方法也写一个泛型的打印:

            /// <summary>  
            /// 打印数组的元素  
            /// </summary>  
            /// <typeparam name="T"></typeparam>  
            /// <param name="arr"></param>  
            public static void Print<T>(T[] arr)  
            {  
                for (int i = 0; i < arr.Length; i++)  
                {  
                    Console.Write(arr[i]+" ");  
                }  
                Console.WriteLine();  
            } 


    好了,我们此时测试一下,让我们一起来见证奇迹: 

     

     

     

     

            void Main(string[] args)  
            {  
                int[] nums = { 1, 3, 54, 5, 6, 45, 6, 7, 8, 8, 34, 67, 8, 9 };  
                Print<int>(nums);  
                BobbleSOrt<int>(nums, (int t1, int t2) => {  
                    return t1 - t2;  
                });  
                Print<int>(nums);  
      
                Console.ReadKey();  
            }  
    

     

    结果是我们预期的:

     

    这样示范你觉得还不够那么我们不妨这样测试一下,写一个这样的自定义类:

     

     

        public class Person
        {
            //一些属性
            public string Name { get; set; }
            public int Age { get; set; }
            public int MathScore { get; set; }
            public int ChineseScore { get; set; }
            public int EnglishScore { get; set; }
            public Person()
            {
    
            }
            public Person(string name, int age, int mathScore, int chineseScore, int englishScore)
            {
                this.Name = name;
                this.Age = age;
                this.MathScore = mathScore;
                this.ChineseScore = chineseScore;
                this.EnglishScore = englishScore;
            }
            public override string ToString()
            {
                return string.Format("{0} {1} {2} {3} {4} {5}", this.Name, this.Age, this.ChineseScore, this.MathScore, this.EnglishScore, (this.ChineseScore + this.MathScore + this.EnglishScore));
            }
        }

     

     

     

     

     

    接着初始化一个Person类的数组:

     

                Person[] pArr = new Person[10];
                Random range = new Random();
                for (int i = 0; i < pArr.Length; i++)
                {
                    int rAge = range.Next(10, 15);
                    int rChineseScore = range.Next(0, 101);
                    int rMathScore = range.Next(0, 101);
                    int rEnglishScore = range.Next(0, 101);
                    pArr[i] = new Person("张三_" + i, rAge, rMathScore, rChineseScore, rEnglishScore);
                }

     

    再次测试一下结果(这次按总成绩来排名):

     

                Print<Person>(pArr);
                BobbleSort<Person>(pArr, (Person p1, Person p2) =>
                {
                    return p1.ChineseScore + p1.MathScore + p1.EnglishScore - p2.ChineseScore - p2.MathScore - p2.EnglishScore;
                });
                Print<Person>(pArr);
    
                Console.ReadKey();

     

     

     

    我们惊奇的发现结果依然是我们预期的:

     

    展开全文
  • C#泛型比较大小

    2019-06-30 11:38:24
    using System; using System.Collections.Generic; using System.Linq; using System.Text;...using System.Threading.Tasks;...namespace 泛型比较大小 { class Program { //Compare<T>...

     

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 泛型比较大小
    {
        class Program
        {
            //Compare<T>是泛型类,T为类型参数
            public class Compare<T> where T : IComparable
            {
                //使用泛型实现的比较方法
                public static T compareGeneric(T t1, T t2)
                {
                    if (t1.CompareTo(t2) > 0)
                    {
                        return t1;
                    }
                    else
                    {
                        return t2;
                    }           
                }
            }
            static void Main(string[] args)
            {
                //调用泛型方法
                Console.WriteLine(Compare<int>.compareGeneric(1, 2));
                Console.WriteLine(Compare<string>.compareGeneric("aa", "a"));
                Console.ReadKey();
            }
        }
    }

     

    转载于:https://www.cnblogs.com/xiefengdaxia123/p/5983042.html

    展开全文
  • c#泛型冒泡排序

    2015-09-13 01:18:05
    public delegate bool Contrast(T t1, T t2); public static void Sequence(T[] items, Contrast contrast) { for (int i = 0; i ; i++) { for (int j = i + 1; j ; j+
  • 选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。 目的: 实现数组元素的...
  • List list=new List(); list.OrderBy(t => t.SendTime).ToList() 使用拉姆达表达式。 list.OrderBy(t=>t.SendTime)结果显示是linq的类型。...我用list.OrderBy(t=>t.SendTime) as model和Modle(list.OrderBy(t=>...
  • C#泛型应用及原理

    2019-08-19 14:03:04
    泛型(generic)是C#语言2.0和通用语言运行时(CLR)的一个新特性。泛型为.NET框架引入了类型参数(type parameters)的概念。类型参数使得设计类和方法时,不必指定方法有一个或多个具体参数,而是在调用方法的时候...
  • 首先设计界面:一个Label标签 编写代码:‘ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing;...using System.Wi...
  • 1.Employee类  Employee类中包含姓名和薪水,自定义的比较方法是按照薪水的多少。 class Employee { public string Name { get; private set;... public int Salary { get;... public Employee...
  • C# 泛型冒泡排序

    2019-07-23 03:59:35
    服务代码:   1 internal static class BubbleSort 2 { 3 internal static void Excute<T>(T[] arr, IComparer<T> comparer) 4 { 5 for (int i = 0; i &l...
  • C#泛型快速排序算法

    2008-01-08 23:06:00
    快速排序算法是我经常使用的算法,所以也写成了泛型了,省事,不用为每个类型去写个特定的算法了。排序的对象是实现了IList接口的集合。我已经发了一个查找类,经常都要一起使用的。using System;using System....
  • c#泛型集合排序

    2019-06-17 18:40:25
    c#泛型集合排序总结 今天学习学累了,还有一点时间就总结一下重要的知识点吧!也算复习了! 排序有很多方法其中有很多都是被接受的(即老师上课讲的),当时虽然也会用但是很不理解为什么要这样做,这样做为什么能...
  • 1、
  • //1: //先定义2个属性存书名书编号,这里有2中属性的使用方式=-=  private int id; private string name; public int Id { get{return id ;} set { id = value; } } publi
  • C#泛型 理解为“比较广泛的数据类型”,可表示任何一种数据类型,泛型类的参数实例化发生在程序运行时,而不是编译阶段。 C#泛型集合,与普通集合一一对应。普通集合在对数据进行操作时无法在编译前确定其具体类型...
  • C# 语言和公共语言运行时 (CLR) 在 2.0 版本中添加了泛型泛型将类型参数的概念引入 .NET Framework,这样就可以设计具有相同特征的类和方法:在客户端代码声明并初始化这些类和方法之前,这些类和方法会延迟指定一...
  • 想删除一堆大小相同的文件,于是想到用List泛型自定义类型排序和比较
  • c# 泛型(一)--引入

    2017-02-16 17:50:02
    我们在编写程序时,经常遇到两个模块的功能非常相似,只是一个是处理int数据,另一个是处理string数据,或者其他自定义的数据类型,但我们...如果不久以后需要对一个byte类型的数组进行排序,而上面的排序算法只能接
1 2 3 4 5 ... 20
收藏数 10,162
精华内容 4,064