¿Hay una manera fácil de combinar dos secuencias ordenadas usando LINQ?

Question

Dado

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

y que tanto first y second están clasificadas por un comparador Func<T, T, int> que devuelve 0 por la igualdad, -1 cuando el primero es "más pequeño" y 1 cuando el segundo es "más pequeño".

¿Existe una forma sencilla de usar LINQ para unir las dos secuencias de forma que la secuencia resultante también sea ordenada por el mismo comparador?

Actualmente estamos usando un algoritmo hecho a mano que funciona, pero la legibilidad de una declaración directa de LINQ sería preferible.

Answer 1

Puede definir un método de extensión para esto. Algo así como

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

Uso:

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

Salida:

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

Answer 2

Creo que convertir el primer elemento enumerable en una lista y agregar un segundo elemento a esta lista, y luego llamar al género hará el truco.

 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>