LINQ 中的“RemoveAll”怎么可能比迭代快得多？

Question

以下代码：

List<Interval> intervals = new List<Interval>();
List<int> points = new List<int>();

//Initialization of the two lists
// [...]

foreach (var point in points)
{
    intervals.RemoveAll (x => x.Intersects (point));
}

当列表大小约为 10000 时，至少比这快 100 倍：

List<Interval> intervals = new List<Interval>();
List<int> points = new List<int>();

//Initialization of the two lists
// [...]

foreach (var point in points)
{
    for (int i = 0; i < intervals.Count;)
    {
        if (intervals[i].Intersects(point))
        {
            intervals.Remove(intervals[i]);
        }
        else
        {
            i++;
        }
    }
}

这怎么可能？ “RemoveAll”在幕后执行了什么？根据MSDN，“RemoveAll”执行线性搜索，因此在 O(n) 中。所以我希望两者的性能相似。

当用“RemoveAt”替换“Remove”时，迭代速度要快得多，与“RemoveAll”相当。但是 both "Remove" 和 "RemoveAt" 都有 O(n) 复杂度，为什么它们之间的性能差异如此之大呢？难道仅仅是因为“Remove (item)”将列表元素与“item”进行比较，而“RemoveAt”没有进行任何比较？

Answer 1

如果您从List<T> 中删除一个项目，它后面的所有项目都将移回一个位置。所以如果你删除 n 个项目，很多项目将被移动 n 次。
RemoveAll 只会移动一次，你可以在 List<T> 的源代码中看到：source

另一件事是Remove(T item) 将在整个列表中搜索该项目，所以这是另一个 n 操作。

与您的问题无关，但我还是想指出：
如果您使用 for 循环从 List 中删除项目，则从末尾开始会容易得多：

for (int i = intervals.Count - 1; i >= 0; i--)
{
    if (intervals[i].Intersects(point))
    {
        intervals.RemoveAt(i);
    }
}

这样，你就不需要那个丑陋的 else 子句了

Answer 2

RemoveAll 可以在O(n) 中通过检查n 元素的条件并最多移动n 元素来完成。

您的循环是O(n^2)，因为每个Remove 最多需要检查n 元素。而且即使你把它改成RemoveAt，它仍然需要向上移动到n元素。

这可能是最快的解决方案： intervals.RemoveAll(x => points.Any(x.Intersects));

Answer 3

List 是一个数组，从数组中删除一个元素需要将要删除的元素之后的所有元素移动到上一个索引，因此 a[i] 被移动到 a[i-1]。

重复执行此操作需要多次移动，即使更多元素符合删除条件。 RemoveAll 可以通过在遍历列表并找到更多符合删除条件的元素时一次将元素移动超过 1 个索引来优化这一点。

Answer 4

不同的是Remove本身是一个O(n)，所以你得到O(n^2)。

将for 替换为新集合和分配。

items = items.Where(i => ...).ToList();

此方法与 RemoveAll 具有相同的算法时间复杂度，但使用额外的 O(n) 内存。