93

有没有一种 LINQ 方法可以交换 a 中两个项目的位置List<T>？

4

6 回答 6

128

检查来自C# 的 Marc 的答案：Swap method 的良好/最佳实现。

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

可以像 linq-i-fied 一样

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);
于 2010-01-19T14:54:25.893 回答
32

也许有人会想到一个聪明的方法来做到这一点，但你不应该。交换列表中的两个项目本质上是有副作用的，但 LINQ 操作应该没有副作用。因此，只需使用一个简单的扩展方法：

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;
    }
}
于 2010-01-19T14:48:28.403 回答
19

List<T>有一个Reverse()方法，但是它只会颠倒两个（或更多）连续项目的顺序。

your_list.Reverse(index, 2);

第二个参数2表示我们正在反转 2 个项目的顺序，从给定的项目开始index。

来源：https ://msdn.microsoft.com/en-us/library/hf2ay11y(v=vs.110).aspx

于 2017-09-25T14:21:54.503 回答
10

没有现有的交换方法，所以你必须自己创建一个。当然，您可以对其进行 linqify，但必须牢记一个（不成文的？）规则：LINQ 操作不会更改输入参数！

在其他“linqify”答案中，（输入）列表被修改并返回，但这个动作打破了这个规则。如果您有一个包含未排序项目的列表会很奇怪，请执行 LINQ“OrderBy”操作，然后发现输入列表也已排序（就像结果一样）。这是不允许发生的！

那么……我们该怎么做呢？

我的第一个想法是在完成迭代后恢复集合。但这是一个肮脏的解决方案，所以不要使用它：

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

这个解决方案很脏，因为它确实修改了输入列表，即使它恢复到原始状态也是如此。这可能会导致几个问题：

  1. 该列表可能是只读的，这将引发异常。
  2. 如果该列表由多个线程共享，则该列表将在此函数执行期间为其他线程更改。
  3. 如果迭代过程中发生异常，列表将不会被恢复。（这可以通过在 Swap 函数中编写 try-finally 来解决，并将恢复代码放在 finally 块中）。

有一个更好（更短）的解决方案：只需复制原始列表即可。（这也使得使用 IEnumerable 作为参数而不是 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;
}

此解决方案的一个缺点是它会复制整个列表，这将消耗内存，这使得解决方案相当慢。

您可以考虑以下解决方案：

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

如果你想输入参数为 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 还制作了源（的子集）的副本。所以最坏的情况是，它与函数 Swap2 一样慢且消耗内存。

于 2013-04-21T21:38:01.833 回答
4

使用新版本的 .net，您可以做到

public static IList<T> Swap<T>(IList<T> list, int indexA, int indexB)
{
    (list[indexA], list[indexB]) = (list[indexB], list[indexA]);
    return list;
}
于 2021-11-12T09:14:15.617 回答
0

如果顺序很重要，您应该在列表中的“T”对象上保留一个表示顺序的属性。为了交换它们，只需交换该属性的值，然后在 .Sort(与序列属性比较)中使用它

于 2010-01-19T14:51:59.467 回答