¿Hay una forma mejor de devolver el siguiente artículo en una lista y pasar del extremo al frente?

Question

tengo la siguiente lista de distintas cadenas:

"A"
"B"
"C"

Si quiero el artículo después de una, me sale B. Después de B, Obtengo C. Después de C, obtengo A. Actualmente tengo el siguiente código, pero por alguna razón siento que hay una mejor manera de hacerlo (¿quizás?).

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

definitivamente estoy abierto a una forma de LINQ-esque de hacer esto, así :)

Answer 1

creo que tal vez puede cambiar la línea

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

para algo así como

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

Answer 2

Puede usar el operador mod para simplificar esto un poco y combinar todo en una sola declaración:

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

Su definitivamente más cortos, pero no estoy seguro de tiempo es más legible, también :)

Answer 3

puedo ver algunos optimización si la pista del índice actual en lugar de la cadena actual, pero para hacer que la la lista de elementos debería ser fija, es decir, no cambiar.

Usted también podría return items[(index + 1) % items.Count];

lo contrario que el código se ve bien para mí, pero tal vez alguien tiene una solución más inteligente.

Answer 4

La solución que tiene es funcionalmente correcta, pero su rendimiento deja un poco que desear. Normalmente, cuando se trata de una estructura de estilo de lista, cabría esperar que GetNext devolviera un resultado en O (1) tiempo, pero esta solución es 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 llamada inicial a CreateAt es O (N) aquí, pero las posteriores llamadas a GetNext son 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 no es la herramienta adecuada aquí.

Suena como si un LinkedList<T> sería la mejor colección aquí:

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

Here son los pros y los contras de una LinkedList en comparación con una lista.

Answer 6

Creo que la mejor solución está en el siguiente enlace, lo probé y funciona como el encanto.

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

Answer 7

Una forma de LINQ:

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