Question

请教关于C#里面List.Sort的写法。

namespace ConsoleApplication7
{
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" });

//我想按照C的n来排序，直接这样sort会出错，因此请教
//Sort(Comparison<T>),Sort(IComparer<T>)怎么写
//请直接修改Sort或者增加其他代码，不要改动其他代码。
L.Sort();

foreach (C x in L)
Console.WriteLine(string.Format("n={0} s={1}", x.n, x.s));
Console.ReadLine();
}
}

public class C
{
public int n;
public string s;
}
}
发的时候请使用C#格式化的代码，如果不能运行成功肯定不会采纳，谢谢！

Answer 1

一共给出了3种实现方式，运行前需要自己将其他的方法注释掉。

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" });

            // 方法1 使用Comparison<T>委托。下面代码使用的是lamda表达是。也可以使用匿名委托之类的，效果是一样的。
            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();

            L.ForEach((c) =>
            {
                Console.WriteLine(c.n);
            });            

            Console.Read();
        }
    }

    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;
        }
    }

    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;
        }
    }
}

Answer 2

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" });
        //我想按照C的n来排序，直接这样sort会出错，因此请教
        //Sort(Comparison<T>),Sort(IComparer<T>)怎么写
        //请直接修改Sort或者增加其他代码，不要改动其他代码。
        var query = from a in L
                    orderby a.n descending//descending 可以不要descending 排序方向
                    select a;
        L = query.ToList();

哥们 试试吧

追问

你这个应该是可以，但是你没见我上面已经给出限制使用Sort函数？

追答

http://msdn.microsoft.com/zh-cn/library/tfakywbh.aspx
自己去看吧

追问

如果我要看还需要提问么？

Answer 3

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" });

//我想按照C的n来排序，直接这样sort会出错，因此请教
//Sort(Comparison<T>),Sort(IComparer<T>)怎么写
//请直接修改Sort或者增加其他代码，不要改动其他代码。
QuickSort(L);

foreach (C x in L)
Console.WriteLine(string.Format("n={0} s={1}", x.n, x.s));
Console.ReadLine();
}
public static void QuickSort(List<C> items)
{
RecQuickSort(items, 0, items.Count - 1);
}

private static void RecQuickSort(List<C> items, int low, int high)
{
if (low < high)
{
int i = Partition(items, low, high);
RecQuickSort(items, low, i - 1);
RecQuickSort(items, i + 1, high);
}
}

private static int Partition(List<C> items, int low, int high)
{
C c = items[low];
int tmp = items[low].n;
while (low < high)
{
while (low < high && items[high].n >= tmp)
high--;

// 换位后不能将low加1,防止跳位
if (low < high)
items[low] = items[high];

while (low < high && items[low].n <= tmp)
low++;

if (low < high)
{
items[high] = items[low];
// 有low < high，可将high向前推一位
high--;
}
}
items[low] = c;

return low;
}
}

public class C
{
public int n;
public string s;
}

sort方法可以排序自定义类型吗我不清楚，不过sort用的是快排，我自己写了个快排改了点参数你可以参考下，希望有帮助。

追问

算你牛，但是不符合题意。

追答

我想说你要是硬要用sort（）函数要么写个委托要么重写比较器，或者这样
把你的那个c类改成这样
public class C : IComparable
{
public int n;
public string s;
public int CompareTo(object obj)
{
int res = 0;
try
{
C sObj = (C)obj;
if (this.n > sObj.n)
{
res = 1;
}
else if (this.n < sObj.n)
{
res = -1;
}
}
catch (Exception ex)
{
throw new Exception("比较异常", ex.InnerException);
}
return res;
}
}

追问

其他人都比你先实现。

Answer 4

  public int ComparerByN(C c1,C c2)
  {
   return c1.n > c2.n ? 0 : 1;//倒序为0：1，正序1：0，看自个的需求吧。
  }
  //L.Sort(ComparerByN);//调用方式
  

  //L.Sort((c1, c2) => { return c1.n > c2.n ? 0 : 1; });//简写

另外注意你的变量命名，任何一个变量的命名应该是意义的

  

追问

你这两种本质上好像还是一种，能不能写出另外一种？

追答

你另外一种是指的什么？重写sort?

追问

不是写了两个重载吗？

Answer 5

List<int> p = new List<int>();
            
            p.Add(1);
            p.Add(3);
            p.Add(5);
            p.Add(2);
            p.Sort((x, y) => { return x > y ? 1 : -1; });
            
            
          //  换你的就是 
            
          L.Sort((x,y)=> { return x.n > y.n ? 1 :-1});

追问

能不能给出另外一种，你只给了一种。