Có cách nào dễ dàng để hợp nhất hai chuỗi được sắp xếp bằng LINQ không?

Question

Với

IEnumerable<T> first; 
IEnumerable<T> second; 

và rằng cả hai first và second được sắp xếp theo một Comparer Func<T, T, int> trả về 0 cho bình đẳng, -1 khi là người đầu tiên là "nhỏ" và 1 khi thứ hai là "nhỏ hơn".

Có cách nào thẳng về phía trước sử dụng LINQ để hợp nhất hai trình tự theo cách làm cho chuỗi kết quả cũng được sắp xếp bởi cùng một bộ so sánh không?

Hiện tại, chúng tôi đang sử dụng thuật toán thủ công, nhưng khả năng đọc của câu lệnh LINQ thẳng về phía trước sẽ thích hợp hơn.

Answer 1

Bạn có thể xác định phương thức tiện ích mở rộng cho việc này. Một cái gì đó như

public static IEnumerable<T> MergeSorted<T>(this IEnumerable<T> first, IEnumerable<T> second, Func<T, T, int> comparer) 
{ 
    using (var firstEnumerator = first.GetEnumerator()) 
    using (var secondEnumerator = second.GetEnumerator()) 
    { 

     var elementsLeftInFirst = firstEnumerator.MoveNext(); 
     var elementsLeftInSecond = secondEnumerator.MoveNext(); 
     while (elementsLeftInFirst || elementsLeftInSecond) 
     { 
      if (!elementsLeftInFirst) 
      { 
        do 
        { 
         yield return secondEnumerator.Current; 
        } while (secondEnumerator.MoveNext()); 
        yield break; 
      } 

      if (!elementsLeftInSecond) 
      { 
        do 
        { 
         yield return firstEnumerator.Current; 
        } while (firstEnumerator.MoveNext()); 
        yield break; 
      } 

      if (comparer(firstEnumerator.Current, secondEnumerator.Current) < 0) 
      { 
       yield return firstEnumerator.Current; 
       elementsLeftInFirst = firstEnumerator.MoveNext(); 
      } 
      else 
      { 
       yield return secondEnumerator.Current; 
       elementsLeftInSecond = secondEnumerator.MoveNext(); 
      } 
     } 
    } 
} 

Cách sử dụng:

var s1 = new[] { 1, 3, 5, 7, 9 }; 
var s2 = new[] { 2, 4, 6, 6, 6, 8 }; 

var merged = s1.MergeSorted(s2, (a, b) => a > b ? 1 : -1).ToList(); 

Console.WriteLine(string.Join(", ", merged)); 

Output:

1, 2, 3, 4, 5, 6, 6, 6, 7, 8, 9 

Answer 2

Tôi nghĩ rằng, chuyển đổi đầu tiên enumerable vào danh sách và thêm mục thứ hai vào danh sách này sau đó gọi sắp xếp sẽ làm các trick.

 IEnumerable<int> first = new List<int>(){1,3}; 
     IEnumerable<int> second = new List<int>(){2,4}; 

     var temp = first.ToList(); 
     temp.AddRange(second); 


     temp.Sort(new Comparison<int>(comparer)); // where comparer is Func<T,T,int>