获取 List<Struct.int> 的最小值 [重复]

Question

我有一个struct，其中包含一些int 和bool 成员，我希望从列表中获得最低值（实际上是在制作基于A* 搜索的路径查找器）。

基本上，我的对象如下所示：

    public struct Tile
    {
        public int id;
        public int x;
        public int y;
        public int cost;
        public bool walkable;
        public int distanceLeft;
        public int parentid;
    }

我想得到距离Left最小的项目。列表声明如下：

        List<Structs.Tile> openList = new List<Structs.Tile>();

并以这种方式分配值：

        while (pathFound == null)
        {
            foreach (Structs.Tile tile in map)
            {
                foreach (Structs.Tile tile1 in getSurroundingTiles(Current))
                {
                    if (tile1.x == tile.x && tile1.y == tile.y)
                    {
                        Structs.Tile curTile = tile1;
                        curTile.parentid = Current.id;
                        curTile.distanceLeft = (Math.Abs(tile.x - goalx) + Math.Abs(tile.y - goaly));
                        if (curTile.distanceLeft == 0)
                        {
                            pathFound = true;
                        }
                        openList.Add(curTile);
                    }
                }
            }
            foreach (Structs.Tile tile in openList)
            {

            }
        }

如果我不得不猜测，我会说这要么非常困难，要么比我说的要复杂得多，或者非常简单，我只是感到困惑。

我确实考虑过滚动列表并将每个项目与其较低的对应项进行比较，但考虑到我们所处的时代，这似乎不合理，似乎会有更简单的方法。我不关心列表的顺序，因为我为每个项目分配了一个索引，我可以从中调用它。

提前致谢！

Answer 1

没有一种 LINQ 扩展方法可以返回具有最小值的对象，但您可以自己编写一个。以下类对任何非空枚举执行您想要的操作：

public static class MyExtensions
{
    public static TSource MinOf<TSource>(
        this IEnumerable<TSource> source,
        Func<TSource, int> selector)
    {
        // Get the enumerator.
        var enumerator = source.GetEnumerator();
        if (!enumerator.MoveNext())
            throw new InvalidOperationException("The source sequence is empty.");

        // Take the first value as a minimum.
        int minimum = selector(enumerator.Current);
        TSource current = enumerator.Current;

        // Go through all other values...
        while (enumerator.MoveNext())
        {
            int value = selector(enumerator.Current);
            if (value < minimum)
            {
                // A new minimum was found. Store it.
                minimum = value;
                current = enumerator.Current;
            }
        }

        // Return the minimum value.
        return current;
    }
}

把它放在你项目中的一个文件中，这样调用它：

openList.MinOf(tile => tile.distanceLeft);

这比排序整个序列（使用OrderBy）然后取第一个值（使用First）更有效。

Answer 2

要获得Tile 和最低distanceLeft，试试这个：

Tile tile = openList.OrderByAscending(t => t.distanceLeft).First();

编辑：

这样做将返回一个IEnumerable<Tile>，它将按升序排序 - openList 本身不会被修改。

Answer 3

或者，如果由于某种原因您不能使用 LINQ：

int lowest = 0;
for (int i = 1; i < openList.Count; ++i)
{
    if (openList[i].distanceLeft < openList[lowest].distanceLeft)
    {
        lowest = i;
    }
}
// lowest contains the index of the item with the lowest 'distanceLeft' value.
// You can return the item itself by indexing into the list.
var lowestItem = openList[lowest];

Answer 4

其他答案解释了如何使用 LINQ 执行此操作 - 但是，它们都是 O(n) 或更慢。使用其中一种方法会显着减慢您的寻路算法。

相反，您应该使用正确的数据结构。您应该将节点存储在 Priority Queue 中，而不是列表，以便在O(log n) 中获得（并删除）最小值。

有关 .Net 中的优先级队列列表，请参阅 this question。