Split IEnumerable in drei Teilen: „oben“, „Artikel“, „unten“ mit Effizienz

Question

IEnumerable<int> list = new[] { 1, 2, 7, 3, 11, 5 }; 
int item = (from x in list where (x == list.Max()) select x).First(); 
IEnumerable<int> above = from x in list where list.ToList().IndexOf(item) > list.ToList().IndexOf(x) select x; 
IEnumerable<int> below = from x in list where list.ToList().IndexOf(item) < list.ToList().IndexOf(x) select x; 

Ich möchte ein Element in einem IEnumerable und spaltete die IEnumerable in IEnumerable s finden, die nicht mehr das Element enthält, die ich gefunden . Der obige Code veranschaulicht das Ergebnis, das ich erreichen möchte, jedoch musste ich IEnumerable in eine Liste konvertieren.

Ich denke, es muss eine Möglichkeit geben, das nur mit LinQ und IEnumerable zu tun. Wie kann das gemacht werden?

Answer 1

So haben wir hier einige Teilprobleme. Das erste Problem besteht darin, das Objekt in einer Sammlung mit dem höchsten Wert eine Projektion dieses Elements zurückzugeben. Max vergleicht nur das Objekt selbst oder gibt bei einer Projektion das Ergebnis dieser Projektion zurück.

public static TSource MaxBy<TSource, TKey>(this IEnumerable<TSource> source 
    , Func<TSource, TKey> selector 
    , IComparer<TKey> comparer = null) 
{ 
    if (comparer == null) 
    { 
     comparer = Comparer<TKey>.Default; 
    } 
    using (IEnumerator<TSource> iterator = source.GetEnumerator()) 
    { 
     if (!iterator.MoveNext()) 
     { 
      throw new ArgumentException("Source was empty"); 
     } 

     TSource maxItem = iterator.Current; 
     TKey maxValue = selector(maxItem); 

     while (iterator.MoveNext()) 
     { 
      TKey nextValue = selector(iterator.Current); 
      if (comparer.Compare(nextValue, maxValue) > 0) 
      { 
       maxValue = nextValue; 
       maxItem = iterator.Current; 
      } 
     } 
     return maxItem; 
    } 
} 

So können wir viel effizienter den Index des Elements mit dem größten Wert erhalten:

var splitPoint = list.Select((index, number) => new { index, number }) 
    .MaxBy(pair => pair.number) 
    .index; 

Weiter, um die Sammlung teilen Sie einfach überspringen können/nehmen:

var firstHalf = list.Take(index); 
var secondHalf = list.Skip(index + 1); 

Es gibt eine Reihe von verschiedenen Problemen mit dem Code, den Sie haben, die hier gelöst werden.

Sie berechnen den Wert Maxfür jeden einzelnen Artikel in Ihrer Abfrage item zu bekommen, anstatt sie einmal Berechnung und dass die berechneten Wert verwenden.

Sie gehen dann, für jedes Element in der Liste, und kopieren Sie alle Elemente in eine neue Liste, zweimal, durchsuchen Sie diese Liste, um zu versuchen, die Position des maximalen Elements zu finden, und dann versuchen, zu finden die Position des aktuellen Artikels. Sie tun dann die ganze Sache zweimal. Das bedeutet, dass Sie das gesamte Array viermal für jedes Element in eine Liste kopieren, viermal pro Element in der Auflistung nach der Position des maximalen Elements suchen und die Liste linear durchsuchen, um den Index des aktuellen Elements zu finden (etwas Sie könnten in kürzester Zeit rechnen, indem Sie für jedes Element zweimal zählen. Dies wird ... schlecht skalieren, da die Anzahl der Gegenstände zunimmt.

Der Code hier findet den Index des Max-Objekts in einem einzigen Durchgang der Sammlung und erstellt dann Sequenzen, die jede Hälfte darstellen, die über die einfache Iteration hinausgehen.

Answer 2

Verwenden Sie die Erweiterungsmethoden, in denen Sie den Index verwenden können. Schau dir das Beispiel unten mit den Kommentaren an.

// define the list 
IEnumerable<int> list = new[] { 1, 2, 7, 3, 11, 5 }; 

// define some value (max in your sample) 
int value = list.Max(); 

// get the index of the value you want 
int indexValue = list.ToList().IndexOf(value); 

// find collections 
IEnumerable<int> above = list.Where((value, index) => index < indexValue); 
IEnumerable<int> below = list.Where((value, index) => index > indexValue); 

Answer 3

Zuerst müssen Sie den (ersten) Index des maximalen Elements finden. Als eine Variation von Servys Antwort kann dies unter Verwendung von Select und Aggregate durchgeführt werden. Dann, bevor die Elemente aufzählen über und nach diesem Index:

 var indexOfMax = list 
      .Select((value, index) => new KeyValuePair<int, int>(index, value)) 
      .Aggregate(new KeyValuePair<int, int>(-1, -1), (min, cur) => 
       { 
        if (min.Key == -1 || cur.Value > min.Value) 
         return cur; 
        return min; 
       }).Key; 

     var beginning = list.Take(indexOfMax); 
     var end = list.Skip(indexOfMax + 1); 

Answer 4

Zuerst müssen Sie garantieren, dass Ihre IEnumerable<T> Objektpositionen in irgendeiner bestimmten Reihenfolge enthalten. Dies kann entweder mit IOrderedEnumerable<T> anstelle von unformatierten IEnumerable<T>, oder mit IList<T> gehen, die Elemente per Index referenzieren können.

Wenn Sie das herausgefunden haben, wird das Teilen ziemlich trivial: Iterieren Sie die Elemente nach Index oder nach Reihenfolge und fügen Sie sie zu IList<T> above hinzu, bis Sie Ihr Element finden. Überspringe dieses Element und fahre fort, die Elemente zu durchlaufen, während du sie zu IList<T> below hinzufügst.