Gibt es einen besseren Weg, um das nächste Element in einer Liste und Schleife vom Ende nach vorne zu bringen?

Question

Ich habe die folgende Liste von verschiedenen Strings:

"A"
"B"
"C"

Wenn ich das Produkt nach der A möge, erhalte ich B. Nach B, Ich bekomme C. Nach C bekomme ich A. Zur Zeit habe ich den folgenden Code, aber aus irgendeinem Grund fühlt es sich für mich an, dass es einen besseren Weg gibt (vielleicht?).

private string GetNext(IList<string> items, string curr) 
{ 
    if (String.IsNullOrWhitespace(curr)) 
     return items[0]; 

    var index = items.IndexOf(curr); 
    if (index == -1) 
     return items[0]; 

    return (index + 1 == items.Count) ? items[0] : items[index + 1]; 
} 

Ich bin auf jeden Fall offen für eine LINQ-artige Möglichkeit, dies auch zu tun :)

Answer 1

Ich denke, vielleicht können Sie die Zeile ändern

return (index + 1 == items.Count) ? items[0] : items[index + 1]; 

für so etwas wie

return items[(index + 1) % items.Count]; 

Answer 2

Sie können den Mod-Operator verwenden, um dies ein wenig zu vereinfachen und alles in einer Anweisung zu kombinieren:

return items[((String.IsNullOrWhitespace(curr) 
       ? 0 
       : items.IndexOf(curr)) + 1) % items.Count] 

Sein definitiv kürzer, aber ich bin sicher nicht Wetter.Seine besser lesbar, auch :)

Answer 3

ich einige Optimierungen sehen kann, wenn Sie den aktuellen Index verfolgen, anstatt die aktuelle Zeichenfolge, aber das das zu tun Liste der Elemente müsste festgelegt werden, dh nicht ändern.

Sie könnten auch return items[(index + 1) % items.Count];

Ansonsten dass Code sieht für mich in Ordnung, aber vielleicht hat jemand eine clevere Lösung.

Answer 4

Die Lösung, die Sie haben, ist funktional korrekt, aber die Leistung lässt ein wenig zu wünschen übrig. Wenn Sie mit einer List-Stilstruktur arbeiten, würden Sie normalerweise erwarten, dass GetNext ein Ergebnis in O (1) -Zeit zurückgibt, aber diese Lösung ist O (N).

public sealed class WrappingIterator<T> { 
    private IList<T> _list; 
    private int _index; 
    public WrappingIterator<T>(IList<T> list, int index) { 
    _list = list; 
    _index = index; 
    } 
    public T GetNext() { 
    _index++; 
    if (_index == _list.Count) { 
     _index = 0; 
    } 
    return _list[_index]; 
    } 

    public static WrappingIterator<T> CreateAt(IList<T> list, T value) { 
    var index = list.IndexOf(value); 
    return new WrappingIterator(list, index); 
    } 
} 

Der erste Aufruf von CreateAt ist O (N) hier aber nachfolgende Aufrufe GetNext sind O (1).

IList<string> list = ...; 
var iterator = WrappingIterator<string>.CreateAt(list, "B"); 
Console.WriteLine(iterator.GetNext()); // Prints C 
Console.WriteLine(iterator.GetNext()); // Prints A 
Console.WriteLine(iterator.GetNext()); // Prints B 

Answer 5

LINQ ist nicht das geeignete Werkzeug hier.

Es klingt, als ob ein LinkedList<T> die bessere Sammlung hier wäre:

var linkedItems = new LinkedList<String>(items); 
LinkedListNode current = linkedItems.Find("C"); 
String afterC = current.Next == null ? linkedItems.First.Value : current.Next.Value; 

Here die Vor- und Nachteile einer LinkedList im Vergleich zu einer Liste sind.

Answer 6

Ich denke, die beste Lösung ist in der unten stehenden Link, ich habe es ausprobiert und funktioniert wie Charme.

http://www.dotnetperls.com/sort-list

Answer 7

A Linq Weg:

var result = (from str in list 
       let index = list.IndexOf(curr) + 1 
       select list.ElementAtOrDefault(index) ?? list[0]).First();