• C# .Sort()函数

    2019-04-21 19:54:48
    List提供了.sort()函数进行排序 如果T是基本类型的话,.sort()是可以直接使用的,比如List、List等 如果是我们自己定义的Class的话,我们就必须自己定义,这时我们需要:IComparer接口中的Compare函数 List.sort...

    List提供了.sort()函数进行排序

    如果T是基本类型的话,.sort()是可以直接使用的,比如List、List等
    如果是我们自己定义的Class的话,我们就必须自己定义,这时我们需要:IComparer接口中的Compare函数

    List.sort()有四种形式:

    1. .sort()
         在List中的元素对象必须继承于IComparer,而且实现了 CompareTo()方法,基本上所有的值类型都有,也包括string等
    2. .sort(IComparer<T>)
         基于自定义的类实现
    3. .sort(IComparison<T>)
    4. .sort(int32,int32,IComparer<T>)
         是第二种形式的扩展,可以规定排序范围
    
    //定义一个类
        public class product//自定义类,设置属性name和age
        {
            public string name
            {
                get;
            }
    
            public int age
            {
                get;
            }
    
            public product(string Name,int Age)
            {
                this.name = Name;
                this.age = Age;
            }
        }
    
    //定义排序方式
        class myComparer:IComparer<product>/*实现 IComparer<T> 接口中的 Compare 方法,
                                           在使用Sort排序时会根据Compare方法体的规定进行排序*/
        {
            public int Compare(product x, product y)
            {
                return (x.age.CompareTo(y.age));//(-x.age.CompareTo(y.age)降序
            }
        }
    
    //主函数
        class Program
        {
            static void Main(string[] args)
            {
                List<product> products=new List<product>();
                products.Add(new product("小红",16));
                products.Add(new product("小明",11));
                products.Add(new product("小兰",15));
    
                products.Sort(new myComparer());//函数会将list中的每个值进行两两比较,默认是升序,降序可以在方法体前面加上一个负号
    
                foreach (var VARIABLE in products)
                {
                    Console.WriteLine(VARIABLE.name);
                }
    
                Console.ReadKey();
            }
        }
    

    转载自:https://blog.csdn.net/skysword2/article/details/53064714

    展开全文
  • C#里List.Sort的用法

    2018-12-11 15:23:06
    using System; using System.Collections.Generic; using System.Linq; using System.Text;... namespace ListSort {  class Program  {  static void Main(s...

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using System.Text;

      

    namespace ListSort

    {

        class Program

        {

            static void Main(string[] args)

            {

                List<C> L = new List<C>();

                L.Add(new C { n = 1, s = "b" });

                L.Add(new C { n = 3, s = "a" });

                L.Add(new C { n = 2, s = "c" });<br>

                // 方法1 使用Comparison<T>委托。

                L.Sort((left, right) =>

                {

                    if (left.n > right.n)

                        return 1;

                    else if (left.n == right.n)

                        return 0;

                    else

                        return -1;

                });

      

                // 方法2 使用IComparer<T>接口。

                L.Sort(new CComparer());

      

                // 方法3 除以上两种方法以外还可以使用另一种方法,在C类中实现IComparable<T>

                L.Sort();

            }

        }

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    //方法二

       public class CComparer : IComparer<C>

       {

           public int Compare(C left, C right)

           {

               if (left.n > right.n)

                   return 1;

               else if (left.n == right.n)

                   return 0;

               else

                   return -1;

           }

       }

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

      //方法三

        public class C : IComparable<C>

        {

            public int n;

            public string s;

      

            public int CompareTo(C other)

            {

                if (this.n > other.n)

                    return 1;

                else if (this.n == other.n)

                    return 0;

                else

                    return -1;

            }

        }

    }

    展开全文
  • C# Sort排序

    2016-05-19 23:22:05
    List 的Sort方法排序有三种结果 1,0,-1分别表示大于,等于,小于。 1.对于数值类型的List (List),直接使用Sort进行排序。 List scoreList=new List(){89,100,78,23,67}; scoreList.Sort();//默认按升序排列,...

    List 的Sort方法排序有三种结果 1,0,-1分别表示大于,等于,小于。

    1.对于数值类型的List (List<int>),直接使用Sort进行排序。

    List<int> scoreList=new List<int>(){89,100,78,23,67};
    
    scoreList.Sort();//默认按升序排列,相当于:scoreList.Sort((x,y)=>x.CompareTo(y))
    
    scoreList.Sort((x,y)=>-x.CompareTo(y));//降序排列

    2.对于非数值类型或者自定义类型,可通过实现IComparable接口重写CompareTo方法来排序:

    public class Person : IComparable<Person>
        {
            public string Name { get; set; }
            public int Age { get; set; }
    
            //ComparetTo:大于 1; 等于 0; 小于 -1;
            public int CompareTo(Person p)
            {
                int result;
                if (this.Name == p.Name && this.Age == p.Age)
                {
                    result = 0;
                }
                else
                {
                    //this.Name表示后面的 Mary p.Name表示前面的 Bob
                    //Mary 跟Bob 由小到大比较,如果Mary 与 Bob 比较 大于0(说明Mary 大于Bob),则 result=1(说明是由小到大的顺序)
                    if (this.Name.CompareTo(p.Name) > 0)//先按名字小到大排列
                    {
                        result = 1;
                    }
                    else if (this.Name == p.Name && this.Age > p.Age)//名字相同则按年龄由小到大排列
                    {
                        result = 1;
                    }
                    else
                    {
                        result = -1;
                    }
                }
                return result;
            }
    
            public override string ToString()
            {
                return this.Name + "-" + this.Age;
            }
        }
              List<Person> lstPerson = new List<Person>();
                lstPerson.Add(new Person() { Name = "Bob", Age = 19 });
                lstPerson.Add(new Person() { Name = "Mary", Age = 18 });
                lstPerson.Add(new Person() { Name = "Mary", Age = 17 });
                lstPerson.Add(new Person() { Name = "Lily", Age = 20 });
                lstPerson.Sort();
                foreach (Person item in lstPerson)
                {
                    Console.WriteLine(item.ToString());
                }
                Console.ReadKey();

    输出:Bob-19 Lily-20 Mary-17 Mary-18
    或不实现IComparable接口而使用linq排序:

      List<Person> lstPerson = new List<Person>();
                lstPerson.Add(new Person() { Name = "Bob", Age = 19 });
                lstPerson.Add(new Person() { Name = "Mary", Age = 18 });
                lstPerson.Add(new Person() { Name = "Mary", Age = 17 });
                lstPerson.Add(new Person() { Name = "Lily", Age = 20 });
                lstPerson.Sort();
    
                lstPerson.Sort((x, y) => {
                    int result;
                    if (x.Name == y.Name && x.Age == y.Age)
                    {
                        result = 0;
                    }
                    else
                    {
                        if (x.Name.CompareTo(y.Name) > 0)
                        {
                            result = 1;
                        }
                        else if (x.Name == y.Name && x.Age > y.Age)
                        {
                            result = 1;
                        }
                        else
                        {
                            result = -1;
                        }
                    }
                    return result;
                });
    
    
                foreach (Person item in lstPerson)
                {
                    Console.WriteLine(item.ToString());
                }
                Console.ReadKey();
    输出:Bob-19 Lily-20 Mary-17 Mary-18



    展开全文
  • C#之ArraySort(一)

    2019-02-15 21:26:03
    C#里的 Array.Sort 主要采用了 3 种排序算法,根据每种算法的特性,合理使用,达到更优。 3种排序 插入排序 快速排序 堆排序 全部代码 1. 插入排序(InsertionSort) 插入排序在数据量少,且大多有序...

    C#之ArraySort (一)

    本文主要记录一下自己的学习过程,如有误,请指正
    
    C#里的 Array.Sort 主要采用了 3 种排序算法,根据每种算法的特性,合理使用,达到更优。
    


    1. 插入排序(InsertionSort)

    插入排序在数据量少,且大多有序的情况下,效率不错。

    • 时间复杂度 :

      • best - case :O(n).
      • worst - case : O(n2).
    • wiki上的算法图解:


    2. 快速排序(QuickSort)

    快速排序,如其名字一样,它很快。

    • 基本思想

      采用分治思想,选区一个pivot作为基准,左边元素都小于它,右边则大与它,分割成两个区间。再按此方法进行分割,直到排序完成。

    • 时间复杂度 :

      • best - case : O(nlogn).
      • worst - case : O(n2).
      • avg - case : O(nlogn).
    • 算法图解 :

      1. 选取一个pivot作为基准,这里取最右边的元素。
      2. left指针右移,直到 T[left] >= pivot;right指针左移,直到T[right] <= pivot。
        交换 T[right] 、T[left]。
      3. 重复步骤 2,直到 left >= right。交换T[left]、 pivot。T[left]作为新基准,分割区间。
      4. 重复步骤2 步骤3
    • 优化:三数中值法

      对最左,最右,以及中间的元素进行排序,如红框所示,pivot-> M,right->红箭头。

      此外,还进行了一次额外交换,保证pivot的位置在右端,如蓝框所示,pivot值不变(仍然为5),位置改变,right->蓝箭头。

      细心的读者,参考源码后可能会发现,.net中Sort采用的递归方式与一些教科书的写法有一点差异。有兴趣的童鞋,可以自行研究。


    3. 堆排序(HeapSort)

    堆排利用了堆这种数据结构。

    • 堆的性质

      • 总是一颗完全二叉树
      • 大顶堆、小顶堆 满足任意一个。
        • 大顶堆,堆中节点的值 总大于或等于 其孩子节点的值。
        • 小顶堆,堆中节点的值 总小于或等于 其孩子节点的值。
    • 性质简析

      • 非叶节点个数 n = arr.Length / 2, 每个非叶节点元素则为 arr[n - 1], 其孩子节点则为 arr[2n - 1]、 arr[2n]。 当第n个节点 只有一个孩子时, arr[2n] 不存在
      • 大顶堆: arr[n - 1] >= arr[2n - 1] , arr[n - 1] >= arr[2n]
      • 小顶堆: arr[n - 1] <= arr[2n - 1] , arr[n - 1] <= arr[2n]
    • 基本思想

      构建大顶堆,交换首尾元素。断尾,重构大顶堆,再交换首尾元素。直到没有尾巴去断。

    • 时间复杂度:

      • any - case : O(nlogn).
    • 算法图解:

      • 无序堆和大根堆

      • 构建大根堆

      • 排序过程
      1. 构建大顶堆。从最后一个非叶节点arr[n - 1]开始。
        判断两个 孩节点 的大小,其中最大的孩节点 继续与 非叶节点比较,若大于,则交换。接着调整 arr[n -2],直到arr[0],即根节点。
      2. 交换首元素和末元素,去除末元素。
      3. 重构大顶堆,由于交换的是根节点,所以我们从 arr[0] 开始, 判断方法与 步骤 1 类似。但这里,由于是从根节点arr[0]开始的,所以需要执行到到最后一个非叶节点,即 arr[n - 1]。
      4. 重复 步骤2 步骤3 直到完成排序。

    4. 简单测试

    • 测试条件
      模式: release
      次数:2k
      数组:随机数组,可重复,大小N(100,1000,5000,10000,100000,1000000)
      时间单位:s

    • 在这里插入图片描述

    5. 全部代码

    using System;
    namespace Sort {
        public class Sorts<T> where T : IComparable<T> {
            
            #region  插排
            public static void InsertionSort (T[] keys, int l, int r) {
                T d;
                int i, j;
                for (i = l; i < r; i++) {
                    j = i;
                    d = keys[i + 1];
                    while (j >= l && d.CompareTo (keys[j]) < 0) {
                        keys[j + 1] = keys[j];
                        j--;
                    }
                    keys[j + 1] = d;
                }
            }
            #endregion
    
            #region 快排
            public static void QSort (T[] keys, int l, int r) {
                //标准写法
                if (l >= r) return;
                int p = PickPivotAndPartition (keys, l, r);
                QSort (keys, p + 1, r);
                QSort (keys, l, p - 1);
    
                //尾递归写法
                // while (l < r) {
                //     int p = PickPivotAndPartition (keys, l, r);
                //     QSort (keys, p + 1, r);
                //     r = p - 1;
                // }
            }
    
            static int PickPivotAndPartition (T[] keys, int l, int r) {
                //三点中值法
                int m = l + ((r - l) >> 1);
                SwapIfGreater (keys, l, m);
                SwapIfGreater (keys, l, r);
                SwapIfGreater (keys, m, r);
    
                T pivot = keys[m];
                Swap (keys, m, r - 1);
                int left = l, right = r - 1;
    
                while (left < right) {
    
                    while (pivot.CompareTo (keys[++left]) > 0);
                    while (right > l && pivot.CompareTo (keys[--right]) < 0);
    
                    if (left >= right)
                        break;
                    Swap (keys, left, right);
                }
                SwapIfGreater (keys, left, r - 1);
                return left;
            }
            #endregion
    
            #region  堆排
            public static void HeapSort (T[] keys, int l, int r) {
                int len = r - l + 1;
                for (int n = len >> 1; n > 0; n--) {
                    //构建大顶堆
                    DownHeap (keys, n, l, len);
                }
    
                for (int i = len; i > 1; i--) {
                    //交换首尾元素
                    Swap (keys, l, l + i - 1);
                    //重构大顶堆
                    DownHeap (keys, 1, l, i - 1);
                }
            }
    
            static void DownHeap (T[] keys, int n, int l, int length) {
                T d = keys[l + n - 1];
                int child; 
                //判断 是否为 非叶节点
                while (n <= length >> 1) {
                    child = n << 1;
                    if (child < length && keys[l + child - 1].CompareTo (keys[l + child]) < 0)
                        child++;
                    if (d.CompareTo (keys[l + child - 1]) >= 0)
                        break;
                    keys[l + n - 1] = keys[l + child - 1];
                    n = child;//child是否为非叶节点,若是,则还要判断
                }
                keys[l + n - 1] = d;
            }
            #endregion
    
            static void SwapIfGreater (T[] k, int a, int b) {
                if (a != b) {
                    if (k[a].CompareTo (k[b]) > 0) {
                        T t = k[a];
                        k[a] = k[b];
                        k[b] = t;
                    }
                }
            }
    
            static void Swap (T[] k, int a, int b) {
                if (a != b) {
                    T t = k[a];
                    k[a] = k[b];
                    k[b] = t;
                }
            }
       }
    展开全文
  • 诸如List等泛型集合类,直接提供了sort()方法用于将集合中的元素进行排序。 但是,其前提是集合中存放的是可直接排序的基本类型,如List, List,如果 我们定义了一个自定义类型 Class MyClass,并创建一个...
    

    诸如List<T>等泛型集合类,直接提供了sort()方法用于将集合中的元素进行排序。

    但是,其前提是集合中存放的是可直接排序的基本类型,如List<int>, List<double>,如果

    我们定义了一个自定义类型 Class MyClass,并创建一个自定义类型的集合如List<MyClass>,

    那么无参的sort()方法就不可用了,因为不知道如何排序了。这时就需要借助:

    IComparer 和 IComparable

    首先,我们来看一下c#泛型List提供的Sort方法:

    泛型List类的Sort方法有四种形式,分别是

    1,不带有任何参数的Sort方法----Sort();

    2,带有比较器参数的Sort方法 ----Sort(IComparer<T>)

    3,带有比较代理方法参数的Sort方法----Sort(Comparison<(Of <(T>)>))

    4,带有比较器参数,可以指定排序范围的Sort方法----Sort(Int32, Int32 IComparer(T))

    【解析:】第一种方法

    使用这种方法不是对List中的任何元素对象都可以进行排序,List中的元素对象必须继承IComparable接口,并且要实现IComparable接口中的CompareTo()方法,在CompareTo()方法中要自己实现对象的比较规则。

    例如,Int32和Double都是实现了IComparable接口并重载了CompareTo方法的结构。(注:int和double都是Int32和Double的别名(alias))

    【解析:】第二种方法

    2,带有比较器参数的Sort方法 ----Sort(IComparer<T>),

    1)创建一个额外的比较器类:其实就相当于将排序功能中的比较操作,留个使用者来完成。这个比较操作必须在实现了IComparer接口的自定义比较类中完成;如:

    class myComparer:IComparer<MyClass>

    2)制定比较规则实现比较方法:因为接口中有一个用于比较的重载函数Compare,所在在比较器类中我们必须实现它,完成自己希望的比较。所谓自己希望的比较就是说自己实现自定义对象的比较规则,例如你知道自定义类MyClass中哪个属性适合用来排序,那么就选择这个属性作为整个自定义类对象的排序属性,如该类中有年龄,学号,入学日期等属性,你可以选择年龄属性作为排序属性。如:

    public class myComparer:IComparer<MyClass>

    {

    //实现按年龄升序排列

    public int Compare(MyClass x, MyClass y)

    {

    return (x.age.CompareTo(y.age)); //age代表年龄属性是整型,即其已支持CompareTo方法

    }

    }

    3)使用比较器的排序方法调用:然后,在自定义类型的集合如List<MyClass> myList,上就可以进行sort排序了,如

    myList.Sort(new myComparer());

    【解析:】第三种方法

    3,带有比较代理方法参数的Sort方法----Sort(Comparison<(Of <(T>)>))

    Comparison<(Of <(T>)>是一种泛型委托。所以,需要编写一个对象排序比较的方法,对List中的元素对象没有特殊的要求,但在比

    较方法中需要实现对象比较规则,这个方法实现后,就可以把这方名字作为参数委托给List的Sort方法,Sort方法在排序时会执行这个方法对List中的对象进行比较需要编写一个对象排序比较的方法,对List中的元素对象没有特殊的要求,但在比较方法中需要实现对象比较规则,这个方法实现后,就可以把这方名字作为参数委托给List的Sort方法,Sort方法在排序时会执行这个方法对List中的对象进行比较

    【解析:】第四种方法

    4,带有比较器参数,可以指定排序范围的Sort方法----Sort(Int32, Int32 IComparer(T))

    对于第四排序方法,实际是第二种比较器排序的一个扩展,在指定排序比较器的同时,指定排序范围,即List中准备排序的开始元素索引和结束元素索引



    ==========

    排序示例 来源: http://www.cnblogs.com/hont/p/4375635.html

    很多人可能喜欢Linq的orderBy排序,可惜U3D里面linq在Ios上会报错,所以就必须使用list的排序。

    其实理解了并不难

    sort有三种结果 1,-1,0分别是大,小,相等

    升序降序比较

    默认List的排序是升序排序

    如果要降序排序,也很简单,只需要在前面加一个负号

    List<int> tmp = new List<int>(){5,1,22,11,4};
    tmp.Sort((x, y) => -x.CompareTo(y));
    Console.WriteLine(tmp);
    //22,11,5,4,1

    对于非数值类型比较用.CompareTo(...),基于IComparable接口。基本上C#的值类型都有实现这个接口,包括string。

    而数值类型也可以自己比较。排序时左右两个变量必须是左-比较-右,切记不可反过来比较。

    sort方法官方推荐的 命名方式是x(左),y(右) 。对于复杂的比较 可以分出来,单独写成函数

    多权重比较

    假设需要tuple里item2的值优先于item1。这个时候只要给比较结果*2即可。

    List<Tuple<int, int>> tmp = new List<Tuple<int, int>>()
    {
    	new Tuple<int,int>(2,1),
    	new Tuple<int,int>(53,1),
    	new Tuple<int,int>(12,1),
    	new Tuple<int,int>(22,3),
    	new Tuple<int,int>(1,2),
    };
    tmp.Sort((x, y) => -(x.Item1.CompareTo(y.Item1) + x.Item2.CompareTo(y.Item2) * 2));
    Console.WriteLine(tmp);
    //22,3
    //1,2
    //53,1
    //12,1
    //2,1
    

    如果单独对升序降序控制,可以去掉大括号,分开进行配置


    展开全文
  • C# sort 委托使用

    2015-05-24 19:29:17
    1、List.Sort(),只能在集合元素实现了IComparable泛型接口时使用 2、List.Sort(Comparison),Comparison是一个方法委托,它带有2个参数T,返回int类型,可以灵活指定如何排序,但是需要编码时手动指定如何排序; ...
  • C# Sort

    2012-06-26 18:34:37
    There is a natural order of things. Day alternates with night. Human beings also impose order where previously there was none. Numbers and letters come one after another. All these things can be ...
  • C#Sort排序

    2017-09-26 15:07:39
    本文转载自http://blog.csdn.net/zhulongxi/article/details/51457891 同时也加入了自己制作的一个例子供大家学习参考,以便更好的理解这个排序
  • C# list sort 排序

    2016-06-21 16:59:25
    前几天看到C#的一个排序,感觉很奇怪,于是抽出时间来研究一下。 list的排序方法为Sort,有4种重载形式: 1 public void Sort(); 使用默认比较器对整个 System.Collections.Generic.List 中的元素进行排序。 2...
  •  2,带有比较器参数的Sort方法 ----Sort(IComparer) 3,带有比较代理方法参数的Sort方法----Sort(Comparison)>)) 4,带有比较起参数,可以指定排序范围的Sort方法----Sort(Int32, Int32 IComp
  • c#List.Sort(比较的方法)返回值意义 值 含义 小于零 此实例按排序顺序在 obj 前面。 零 此实例与 obj 在排序顺序中出现的位置相同。 大于零 此实例按排序顺序在 obj 后面。 List.Sort()多条件排序: player_...
  • 快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略,通常称其为分治法(Divide-and-ConquerMethod)。 该方法的基本思想是:  1.先从数列中取出一个数作为基准数。... 2.... 3....
  • C#使用sort方法对数组进行快速排序
  • C#sort 的重载

    2018-08-14 21:02:42
    List&lt;T&gt; LIS = new List&lt;T&gt;();  int[] arr = { 9, 9, 9, 9, 9, };  list.addrange{ arr};  for (int i = 0; i &lt; list.count; i++)  {  ...
  • sort()函数默认是升序排序,只能应用于C#指定数据类型,但这里要和大家分享的是自定义Sort函数排序的对象和规则,方便大家去选择适合自己项目的排序。 代码实现: using System; using System.Collections; using...
  • C#视频的看到冒泡排序以后,小杨老师讲了一个更简单的排序方法,这个方法就是Array.Sort()函数,利用这个函数可直接对数组中的数字进行排序,比冒泡排序简单得多了,仅仅只需要一行代码,下面是代码和运行结果。...
  • C# List Sort的三种方法

    2016-12-01 11:33:09
    using System; using System.Collections.Generic; class Program { static void Main(string[] args) { List list = new List(); list.Add(new Person("AA", 50)); list.Add(new
  • 可以实现一个IComparable接口的CompareTo方法,或者是给予List的Sort扩展方法,传入委托实现,举个例子: list.Sort((a, b) => { var o = a.sortIndex - b.sortIndex; return o; }) 其实我们还可以...
  • C# List.Sort(IComparer\踩坑 使用List.Sort(IComparer<T> comparer)进行自定义排序时,发现关键字相等的元素排序后先后顺序发生改变。检查自己实现的ICompare<T>.Compare方法逻辑没发现问题。后来...
  • List.Sort() 为我们提供了4种自定义排序方法,通过对这些方法改进我们可以轻松做到对多参数、多规则的复杂排序: List<T>.Sort(); List<T>.Sort(IComparer<T> Comparer); List<T>.Sort...
1 2 3 4 5 ... 20
收藏数 38,434
精华内容 15,373