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;
}
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;
}
}
6条答案
按热度按时间fiei3ece1#
Check the answer from Marc from C#: Good/best implementation of Swap method .
which can be linq-i-fied like
o8x7eapl2#
也许有人会想到一个聪明的方法来实现这一点,但你不应该这样做。交换列表中的两个项本来就有很多副作用,但LINQ操作应该没有副作用。因此,只需使用一个简单的扩展方法:
shyt4zoc3#
List<T>
有一个Reverse()
方法,但是它只反转两个(或更多)***连续***项的顺序。其中,第二个参数
2
表示我们正在颠倒2个项的顺序,从给定index
处的项开始。来源:https://msdn.microsoft.com/en-us/library/hf2ay11y(v=vs.110).aspx
jxct1oxe4#
没有现成的Swap方法,所以你必须自己创建一个。当然你可以链接它,但必须记住一个(不成文的?)规则:LINQ操作不会更改输入参数!
在其他“linqify”的回答中,(输入)列表被修改并返回,但是这个操作阻止了这个规则。如果你有一个未排序的列表,那么做一个LINQ“OrderBy”操作,然后发现输入列表也被排序了(就像结果一样)。这是不允许发生的!
那么...我们该怎么做
我的第一个想法是在完成迭代后恢复集合。但是这是一个脏的解决方案,所以不要使用它:
这个解决方案是脏的,因为它确实修改了输入列表,即使它将其恢复到原始状态。这可能会导致几个问题:
1.该列表可能是只读的,这将引发异常。
1.如果该列表由多个线程共享,则在此函数执行期间,该列表将针对其他线程发生变化。
1.如果在迭代过程中发生异常,列表将不会被恢复(这可以通过在Swap函数中编写try-finally并将restore-code放在finally-block中来解决)。
有一个更好(更短)的解决方案:只需制作原始列表的副本。(这也使得使用IEnumerable作为参数而不是IList成为可能):
这种解决方案的一个缺点是它复制整个列表,这将消耗存储器,并且这使得该解决方案相当慢。
您可以考虑以下解决方案:
如果您希望输入参数为IEnumerable:
Swap 4也会复制源代码的一个子集,所以在最坏的情况下,它和Swap 2一样慢,消耗内存。
7cwmlq895#
从C# 7开始,您可以
3lxsmp7m6#
如果顺序很重要,您应该在列表中的“T”对象上保留一个表示顺序的属性。为了交换它们,只需交换该属性的值,然后在.Sort(与sequence属性比较)中使用它。