c# – 列出没有ForLoops的操作

我有一个有以下成员的班级：

> X.
> Y.
>宽度
>身高

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

现在我的问题是我有一个这个类的列表,List< MyClass>.

我需要将列表中的每个对象与所有剩余对象进行比较,如果currentObject.Location(X,Y)落在另一个对象的矩形(X,Y,Width,Height)中,我需要从列表中删除其他对象.

我用for循环实现了它.

但主要问题是：表现.
我的最小名单数量是300000.

有没有任何程序来改善这个任务的性能,包括LINQ在内的任何.Net版本？

`public class RectBase
    {
        private int _rectId;
        私有PointF _rectLocation;
        private Sizef _rectSize;

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

`

解决方法

问题不是消除for循环,至少在你想到它的方式.在LINQ中重写它只是隐藏for循环,但它们仍然存在.这是根本问题.你编写的算法是O(n ^ 2),这就是为什么当你从20,000个元素到300,000个元素时,你会看到一个荒谬的爆炸.你在第一种情况下进行了400,000,000次比较,在第二种情况下进行了90,它将继续像O(n ^ 2)那样增长.

所以,你真正想问的问题是：对于这个问题,是否存在时间复杂度优于O(n ^ 2)的算法？

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

此问题是computational geometry字段的示例.