Esiste un modo migliore per restituire l'elemento successivo in un elenco e passare dalla fine alla parte anteriore?

Question

Ho il seguente elenco di distinti stringhe:

"A"
"B"
"C"

Se voglio la voce dopo A, I get B. Dopo B, Ricevo C. Dopo C, ottengo A. Attualmente ho il seguente codice, ma per qualche ragione mi sembra che ci sia un modo migliore per farlo (forse?).

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]; 
} 

Sono sicuramente aperto a un modo LINQ-esque di fare questo anche :)

Answer 1

Penso che forse è possibile modificare la linea di

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

per qualcosa come

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

Answer 2

È possibile utilizzare l'operatore mod per semplificare un po 'e combinare tutto in un'unica istruzione:

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

sua sicuramente più breve, ma non sono sicuro che la sua climatiche più leggibile, anche :)

Answer 3

posso vedere qualche ottimizzazione se si traccia l'indice corrente piuttosto che la stringa corrente, ma per fare che la la lista degli articoli dovrebbe essere riparata, cioè non cambiata.

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

Altrimenti quel codice guarda bene a me, ma forse qualcuno ha una soluzione più intelligente.

Answer 4

La soluzione che hai è funzionalmente corretta ma le prestazioni lasciano un po 'a desiderare. Tipicamente quando si ha a che fare con una struttura di stile di lista ci si aspetterebbe che GetNext restituisca un risultato in tempo O (1), tuttavia questa soluzione è 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); 
    } 
} 

La chiamata iniziale a CreateAt è O (N) qui ma chiamate successive GetNext sono 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 non è lo strumento appropriato qui.

Sembra come se un LinkedList<T> sarebbe la migliore raccolta qui:

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

Here sono i pro ei contro di una LinkedList rispetto a un elenco.

Answer 6

Penso che la soluzione migliore sia nel link sottostante, l'ho provato e funziona come un incantesimo.

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

Answer 7

Un modo LINQ:

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