Question

我想对对象列表进行排序，结构是Dictionary<Object, List<int>>

词典中的项目将是

item_1, (2,2,3)
item_2, (1,3,4)
item_3, (2,3,4)
item_4, (1,2)

一旦项目被排序，它们应显示为

item_4, 1,2
item_2, 1,3,4
item_1, 2,2,3
item_3, 2,3,4

所以，基本上我必须排序列表中的第一项，然后是第二项，然后是第3项，使用linq实现这样一个解决方案的简单方法

Answer 1

您需要的是一个自定义比较器，它可以根据序列中的项目比较一系列值，而不是基于对序列本身的引用（假设大多数序列不会覆盖默认的相等行为）。这很简单：

public class SequenceComparer<T> : IComparer<IEnumerable<T>>
{
    private IComparer<T> comparer;
    public SequenceComparer(IComparer<T> comparer = null)
    {
        this.comparer = comparer ?? Comparer<T>.Default;
    }

    public int Compare(IEnumerable<T> x, IEnumerable<T> y)
    {
        using (var first = x.GetEnumerator())
        using (var second = y.GetEnumerator())
        {
            while (true)
            {
                var hasFirst = first.MoveNext();
                var hasSecond = second.MoveNext();
                if (hasFirst && !hasSecond)
                    return 1;
                if (hasSecond && !hasFirst)
                    return -1;
                if (!hasFirst && !hasSecond)
                    return 0;
                var comparison = comparer.Compare(first.Current, second.Current);
                if (comparison != 0)
                    return comparison;
            }
        }
    }
}

然后，您可以使用此比较器订购集合中的项目：

var query = dictionary.OrderBy(pair => pair.Value, new SequenceComparer<int>());

如果您希望序列中的项目根据其有序值进行排序，并且序列尚未排序，则可以在查询中添加内部序列的顺序：

var query = dictionary.OrderBy(pair => pair.Value.OrderBy(x => x), 
    new SequenceComparer<int>());

Answer 2

您可以使用自定义比较方法在单独的列表中对字典值进行排序：

  static void Main()
  {
        var map = new Dictionary<object, IList<int>>();

        map.Add("item_1", new int[] { 2, 2, 4 });
        map.Add("item_2", new int[] { 1, 3, 4 });
        map.Add("item_3", new int[] { 2, 3, 4 });
        map.Add("item_4", new int[] { 1, 2});

        var list = new List<KeyValuePair<object, IList<int>>>(map);

        list.Sort(CompareSequences);


        foreach(var item in list)
        {
            Console.WriteLine("{0} ({1})", item.Key, string.Join<int>("," , item.Value));
        }

  }



    static int CompareSequences(KeyValuePair<object, IList<int>> left, 
        KeyValuePair<object, IList<int>> right)
    {
         int count = Math.Min(left.Value.Count, right.Value.Count);

        for (int i = 0; i < count; ++i)
        {
            if (left.Value[i] < right.Value[i])
            {
                return -1;
            }

            if (left.Value[i] > right.Value[i])
            {
                return 1;
            }
        }

        if (right.Value.Count > count)
        {
            return -1;
        }

        if (left.Value.Count  > count)
        {
            return 1;
        }

        return 0;
    }

OrderBy（）排序的一个区别是List.Sort（）中的排序算法不稳定。但它使用更少的内存和更少的临时对象

排序字典<object，list <int =“”>＆gt; C＃</对象，>

2 个答案: