排序字典<object，List<int>> c#

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

所以，基本上我必须对列表中的第一项进行排序，然后是第二项，然后是第三项，使用 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() 中的排序算法不稳定。 但它使用更少的内存和更少的临时对象