C# 不带ForLoops的列表操作

我的班级有以下成员：

• X
• Y
• 宽度
• 高度

可以使用这些参数创建一个矩形

现在我的问题是我有一个这个类的列表，

list

我需要将列表中的每个对象与所有剩余对象进行比较，如果

currentObject.Location（X，Y）

位于另一个对象的

矩形（X，Y，Width，Height）

，我需要从列表中删除另一个对象

我用for循环实现了它

但主要问题是：性能。 我的最低名单数是30万

使用任何.Net版本（包括LINQ）是否有任何过程来提高此任务的性能

`公共类基 { 私有整数； 专用点定位； 私有大小

    public RectBase()
    {
        _rectId = -911;
        _rectLocation = new PointF(0, 0);
        _rectSize = new SizeF(0, 0);
    }
    public RectBase(int id, PointF loc, SizeF size)
    {
        _rectId = id;
        _rectLocation = loc;
        _rectSize = size;
    }
    public bool IsIntersected(RectBase otherRectObject)
    {
        RectangleF currentRect = new RectangleF(_rectLocation, _rectSize);
        if (currentRect.Contains(otherRectObject.RectLocation))
            return true;
        else
            return false;
    }
    public int RectId
    {
        get { return _rectId; }
        set { _rectId = value; }
    }
    public PointF RectLocation
    {
        get { return _rectLocation; }
        set { _rectLocation = value; }
    }
    public SizeF RectSize
    {
        get { return _rectSize; }
        set { _rectSize = value; }
    }
}


public class RectProcessor
{
    List<RectBase> _rectList;
    int maxCount = 300000;

    public RectProcessor()
    {
        _rectList = new List<RectBase>();
        FillList();
    }

    private void FillList()
    {
        //  Adding the items to the list with dummy values
        for (int i = 0; i < maxCount; i++)
        {
            int id = i+1;
            PointF loc = new PointF(id, id);
            SizeF sz = new SizeF(id, id);

            RectBase obj = new RectBase(id, loc, sz);

            _rectList.Add(obj);
        }
    }

    private void RemoveIntersectedObjects()
    {
        List<RectBase> filteredList = new List<RectBase>();
        bool isIntersected = false;

        for (int i = 0; i < maxCount; i++)
        {
            for (int j = 0; j < maxCount; j++)
            {
                if (_rectList[i].IsIntersected(_rectList[j]))
                {
                    isIntersected = true;
                    break;
                }
            }
            if (!isIntersected)
            {
                filteredList.Add(_rectList[i]); 
            }
            isIntersected = false;
        }
    }
}

public RectBase（）
{
_直肠=-911；
_rectLocation=新的点f（0,0）；
_rectSize=newsizef（0,0）；
}
公共RectBase（int-id、PointF-loc、SizeF-size）
{
_rectId=id；
_直肠位置=loc；
_矩形尺寸=尺寸；
}
公共布尔值已相交（RectBase otherRectObject）
{
矩形F currentRect=新矩形F（_rectLocation，_rectSize）；
if（currentRect.Contains（otherRectObject.RectLocation））
返回true；
其他的
返回false；
}
公共整数矩形
{
获取{return}rectId；}
设置{u rectId=value；}
}
公共点定位
{
获取{return\rectLocation；}
设置{rectLocation=value；}
}
公共大小
{
获取{return}rectSize；}
设置{rectSize=value；}
}
}
公共类处理器
{
列表(rectList),；
int最大计数=300000；
公共处理器（）
{
_rectList=新列表（）；
填充列表（）；
}
私有无效填充列表（）
{
//使用虚拟值将项目添加到列表中
对于（int i=0；i

---

`

问题并不是消除

for

循环，至少在您的思维方式上是如此。在LINQ中重写它只会隐藏

for

循环，但它们仍然存在。这是根本问题。正如所写的那样，您的算法是

O（n^2）

，这就是为什么当您从20000个元素增加到300000个元素时，会看到时间上的荒谬爆炸。在第一种情况下，您正在进行400000000次比较，在第二种情况下，您正在进行9000000000次比较，并且它将继续像

O（n^2）

一样增长

所以，你真正想问的问题是：对于这个问题，有没有一种算法的时间复杂度比

O（n^2）

更好

坦率地说，我不知道这个问题的答案。我怀疑答案是否定的：如果不将某个点与所有矩形进行比较，就无法知道某个点是否包含在某个矩形中，并且必须检查所有点。但也许有一种聪明的方法可以做到这一点，比如计算所有矩形的凸包，然后以某种方式使用它

---

这个问题就是这个领域的一个例子。

感觉四叉树可以帮助您解决这个问题……请发布一个代码示例，这样我们就可以看到您是如何解决这个问题的。Linq不会再快了。你需要的是这个问题的优化算法。听起来矩形的顺序很重要——“对于所有的R[i=0..n]，对于所有的R[j=i+1..n]，如果R[i]与R[j]重叠，那么移除R[i]”。如果是这样的话，我想你被卡住了。任何形式的问题划分都会影响矩形的顺序，因此会删除错误的矩形。您可以获得的最佳性能是对

n*（n-1）/2

矩形进行

n

操作。这是问题的正确陈述吗：“给定一个矩形列表，从列表中删除完全包含在列表中任何其他矩形边界内的任何矩形。”？完全正确。我需要用更少的时间消除重复项。换句话说，我希望修改RemoveIntersectedObjects方法。我的第一个想法是遍历列表并找到最大的矩形。然后遍历该列表，并删除最大列表中包含的所有矩形。这个线性（2x）过程是否会将列表的大小减少到可以通过蛮力方法处理的程度？或者您是否考虑过将列表拆分为子集，并行处理它们，然后对组合的结果集执行蛮力方法？