對字典排序<object, List<int> &gt; 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() 中的排序算法不穩定。 但它使用更少的內存和更少的臨時對象