web-dev-qa-db-fra.com

Échangez deux éléments dans la liste <T>

Existe-t-il un moyen LINQ d'échanger la position de deux éléments à l'intérieur d'un list<T>?

c#linqswap
63
Tony The Lion

Vérifiez la réponse de Marc de C #: Bonne/meilleure implémentation de la méthode Swap .

public static void Swap<T>(IList<T> list, int indexA, int indexB)
{
    T tmp = list[indexA];
    list[indexA] = list[indexB];
    list[indexB] = tmp;
}

qui peut être linq-i-fied comme

public static IList<T> Swap<T>(this IList<T> list, int indexA, int indexB)
{
    T tmp = list[indexA];
    list[indexA] = list[indexB];
    list[indexB] = tmp;
    return list;
}

var lst = new List<int>() { 8, 3, 2, 4 };
lst = lst.Swap(1, 2);
100
Jan Jongboom

Peut-être que quelqu'un pensera à une façon intelligente de le faire, mais vous ne devriez pas. L'échange de deux éléments dans une liste est intrinsèquement chargé d'effets secondaires, mais les opérations LINQ doivent être exemptes d'effets secondaires. Ainsi, utilisez simplement une méthode d'extension simple:

static class IListExtensions {
    public static void Swap<T>(
        this IList<T> list,
        int firstIndex,
        int secondIndex
    ) {
        Contract.Requires(list != null);
        Contract.Requires(firstIndex >= 0 && firstIndex < list.Count);
        Contract.Requires(secondIndex >= 0 && secondIndex < list.Count);
        if (firstIndex == secondIndex) {
            return;
        }
        T temp = list[firstIndex];
        list[firstIndex] = list[secondIndex];
        list[secondIndex] = temp;
    }
}
30
jason

Il n'y a pas de méthode Swap existante, vous devez donc en créer une vous-même. Bien sûr, vous pouvez le linqifier, mais cela doit être fait avec une règle (non écrite?) À l'esprit: les opérations LINQ ne changent pas les paramètres d'entrée!

Dans les autres réponses "linqify", la liste (d'entrée) est modifiée et renvoyée, mais cette action freine cette règle. Si ce serait bizarre si vous avez une liste avec des éléments non triés, effectuez une opération LINQ "OrderBy" et découvrez que la liste d'entrée est également triée (tout comme le résultat). Cela ne doit pas se produire!

Alors ... comment on fait ça?

Ma première pensée a été de restaurer la collection une fois l'itération terminée. Mais ceci est une solution sale, alors ne l'utilisez pas:

static public IEnumerable<T> Swap1<T>(this IList<T> source, int index1, int index2)
{
    // Parameter checking is skipped in this example.

    // Swap the items.
    T temp = source[index1];
    source[index1] = source[index2];
    source[index2] = temp;

    // Return the items in the new order.
    foreach (T item in source)
        yield return item;

    // Restore the collection.
    source[index2] = source[index1];
    source[index1] = temp;
}

Cette solution est sale car elle fait modifie la liste d'entrée, même si elle la restaure à l'état d'origine. Cela pourrait entraîner plusieurs problèmes:

  1. La liste pourrait être en lecture seule, ce qui lèvera une exception.
  2. Si la liste est partagée par plusieurs threads, la liste changera pour les autres threads pendant la durée de cette fonction.
  3. Si une exception se produit pendant l'itération, la liste ne sera pas restaurée. (Cela pourrait être résolu pour écrire un try-finally à l'intérieur de la fonction Swap et mettre le code de restauration à l'intérieur du bloc finally).

Il existe une meilleure solution (et plus courte): faites simplement une copie de la liste d'origine. (Cela permet également d'utiliser un IEnumerable comme paramètre, au lieu d'un IList):

static public IEnumerable<T> Swap2<T>(this IList<T> source, int index1, int index2)
{
    // Parameter checking is skipped in this example.

    // If nothing needs to be swapped, just return the original collection.
    if (index1 == index2)
        return source;

    // Make a copy.
    List<T> copy = source.ToList();

    // Swap the items.
    T temp = copy[index1];
    copy[index1] = copy[index2];
    copy[index2] = temp;

    // Return the copy with the swapped items.
    return copy;
}

Un inconvénient de cette solution est qu'elle copie la liste entière qui consommera de la mémoire et qui rend la solution plutôt lente.

Vous pourriez envisager la solution suivante:

static public IEnumerable<T> Swap3<T>(this IList<T> source, int index1, int index2)
{
    // Parameter checking is skipped in this example.
    // It is assumed that index1 < index2. Otherwise a check should be build in and both indexes should be swapped.

    using (IEnumerator<T> e = source.GetEnumerator())
    {
        // Iterate to the first index.
        for (int i = 0; i < index1; i++)
            yield return source[i];

        // Return the item at the second index.
        yield return source[index2];

        if (index1 != index2)
        {
            // Return the items between the first and second index.
            for (int i = index1 + 1; i < index2; i++)
                yield return source[i];

            // Return the item at the first index.
            yield return source[index1];
        }

        // Return the remaining items.
        for (int i = index2 + 1; i < source.Count; i++)
            yield return source[i];
    }
}

Et si vous voulez que le paramètre soit IEnumerable:

static public IEnumerable<T> Swap4<T>(this IEnumerable<T> source, int index1, int index2)
{
    // Parameter checking is skipped in this example.
    // It is assumed that index1 < index2. Otherwise a check should be build in and both indexes should be swapped.

    using(IEnumerator<T> e = source.GetEnumerator())
    {
        // Iterate to the first index.
        for(int i = 0; i < index1; i++) 
        {
            if (!e.MoveNext())
                yield break;
            yield return e.Current;
        }

        if (index1 != index2)
        {
            // Remember the item at the first position.
            if (!e.MoveNext())
                yield break;
            T rememberedItem = e.Current;

            // Store the items between the first and second index in a temporary list. 
            List<T> subset = new List<T>(index2 - index1 - 1);
            for (int i = index1 + 1; i < index2; i++)
            {
                if (!e.MoveNext())
                    break;
                subset.Add(e.Current);
            }

            // Return the item at the second index.
            if (e.MoveNext())
                yield return e.Current;

            // Return the items in the subset.
            foreach (T item in subset)
                yield return item;

            // Return the first (remembered) item.
            yield return rememberedItem;
        }

        // Return the remaining items in the list.
        while (e.MoveNext())
            yield return e.Current;
    }
}

Swap4 fait également une copie de (un sous-ensemble de) la source. Dans le pire des cas, il est aussi lent et gourmand en mémoire que la fonction Swap2.

10
Martin Mulder

La liste a la méthode inverse.

your_list.Reverse(i, 2) // will swap elements with indexs i, i + 1.

Source: https://msdn.Microsoft.com/en-us/library/hf2ay11y (v = vs.110) .aspx

7
user1920925

Si l'ordre est important, vous devez conserver une propriété sur les objets "T" dans votre liste qui indique la séquence. Pour les échanger, il suffit d'échanger la valeur de cette propriété, puis de l'utiliser dans le .Sort (comparaison avec la propriété de séquence)

0
CaffGeek