A*算法的C#实现

最新推荐文章于 2024-08-13 12:00:43 发布
最新推荐文章于 2024-08-13 12:00:43 发布
阅读量5.3k 收藏 46
点赞数 5
分类专栏： 数据结构和算法 文章标签： A*算法 网格寻路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/f1033774377/article/details/82290602
版权

目录

1，概述

2，A *算法的基本原理

3，A *算法的实现步骤

4，A *算法的C＃实现

5，测试

 

1，概述

        本文的主要内容是讲述A *寻路算法的基本原理，实现步骤以及对应的C＃代码，适合读者用于学习A *算法或

使用此代码提供的接口完成游戏中的寻路功能。

        详细的A *算法的原理，请参照：https://blog.csdn.net/denghecsdn/article/details/78778769

        详细的A *算法的实现，请参照：https://www.cnblogs.com/zhoug2020/p/3468167.html

2，A *算法的基本原理

        A *算法是一种经典的启发式算法，算法的核心是将节点n到目标点的代价定义为f（n）= g（n）+ h（n），其中 g（n）表示出发点到节点ñ的距离，h（n）是一种启发式函数，表示节点ñ到目标点的评估代价，通常为了简化我们采用曼哈顿距离来模拟。知道 f（n）如何计算后，A *算法还有两个重要的集合——open列表和closed列表，open列表用于存储当前可以选择移动的所有节点，closed列表用于存储走过的所有节点。首先，我们将出发点加入open列表中，然后每次从open列表中选择f（n）最小的节点，然后将该节点从open列表中移除，并加入到closed列表中，并将该节点周围没有走过的所有可达节点加入或更新到open列表中，重复选择节点直到目标点在closed列表中为止，再通过存储节点的parent回溯，这样就可以得到两个点之间的一条最短路径。

3，A *算法的实现步骤

①将出发点加入到open列表中。

②从open列表中选择 f（n）最小的节点k，将节点k从open列表中移除，并将其加入到closed列表中。

③对于节点ķ周围距离为1的每个可达节点t，执行以下操作：

        a.如果t在closed列表中，丢弃这个节点;

        b.如果t不在open列表中，将其加入open列表中;

        c.如果t在open列表中，计算其f（n）并和open列表中该节点的f（n）的对比，如果它的f（n）更小，则更新open列表中该节点的信息。

④重复②③直到目标点在closed列表中（表明求得最短路径）或open列表为空（表明终点不可达）。

4，A *算法的C＃实现

文件名：

AStar.cs

算法执行接口：

AStar.Instance.Execute（int [，] map，int srcX，int srcY，int distX，int distY，int reachableVal = 0，bool allowDiagonal = false）;

输出路径接口：

AStar.Instance.DisplayPath（ANode aNode）;

完整代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

/******************************************************************************** 
** auth：    FengLinyi
** date：    2018/09/01
** desc：    A*算法的实现
** Ver.:     V1.0.0
*********************************************************************************/

namespace DeepCSharp
{
    class AStar
    {
        /// <summary>
        /// 二维坐标点
        /// </summary>
        public struct Point
        {
            public int x, y;
            public Point(int _x, int _y)
            {
                x = _x;
                y = _y;
            }
        }
        /// <summary>
        /// A*的每个节点
        /// </summary>
        public class ANode
        {
            public Point point;
            public ANode parent;
            public int fn, gn, hn;
        }
        private AStar() { }
        public static AStar Instance { get; } = new AStar();
        private int[,] map = null;
        private Dictionary<Point, ANode> openList = null;
        private HashSet<Point> closedList = null;
        private Point dist;
        private int reachableVal;

        /// <summary>
        /// 执行算法
        /// </summary>
        /// <param name="map">二维网格地图，边缘需要用不可达的值填充</param>
        /// <param name="srcX">当前点X坐标</param>
        /// <param name="srcY">当前点Y坐标</param>
        /// <param name="distX">目标点X坐标</param>
        /// <param name="distY">目标点Y坐标</param>
        public ANode Execute(int[,] map, int srcX, int srcY, int distX, int distY, int reachableVal = 0, bool allowDiagonal = false)
        {
            openList = new Dictionary<Point, ANode>();
            closedList = new HashSet<Point>();
            this.map = map;
            this.dist = new Point(distX, distY);
            this.reachableVal = reachableVal;
            //将初始节点加入到open列表中
            ANode aNode = new ANode();
            aNode.point = new Point(srcX, srcY);
            aNode.parent = null;
            aNode.gn = 0;
            aNode.hn = ManHattan(aNode.point, dist);
            aNode.fn = aNode.gn + aNode.hn;
            openList.Add(aNode.point, aNode);

            while (openList.Count > 0)
            {
                //从open列表中找到f(n)最小的结点
                ANode minFn = FindMinFn(openList);
                Point point = minFn.point;
                //判断是否到达终点
                if (point.x == dist.x && point.y == dist.y) return minFn;
                //去除minFn，加入到closed列表中
                openList.Remove(minFn.point);
                closedList.Add(minFn.point);
                //将minFn周围的节点加入到open列表中
                AddToOpenList(new Point(point.x - 1, point.y), minFn); //左
                AddToOpenList(new Point(point.x + 1, point.y), minFn); //右
                AddToOpenList(new Point(point.x, point.y - 1), minFn); //上
                AddToOpenList(new Point(point.x, point.y + 1), minFn); //下
                if(allowDiagonal)
                {
                    AddToOpenList(new Point(point.x - 1, point.y - 1), minFn); //左上
                    AddToOpenList(new Point(point.x + 1, point.y - 1), minFn); //右上
                    AddToOpenList(new Point(point.x - 1, point.y + 1), minFn); //左下
                    AddToOpenList(new Point(point.x + 1, point.y + 1), minFn); //右下
                }
            }
            return null;
        }

        /// <summary>
        /// 输出最短路径
        /// </summary>
        /// <param name="aNode"></param>
        public void DisplayPath(ANode aNode)
        {
            while(aNode != null)
            {
                Console.WriteLine(aNode.point.x + "," + aNode.point.y);
                aNode = aNode.parent;
            }
        }

        /// <summary>
        /// 判断节点是否可达，可达则将节点加入到open列表中
        /// </summary>
        /// <param name="a"></param>
        /// <param name="parent"></param>
        private void AddToOpenList(Point point, ANode parent)
        {
            if(IsReachable(point) && !closedList.Contains(point))
            {
                ANode aNode = new ANode();
                aNode.point = point;
                aNode.parent = parent;
                aNode.gn = parent.gn + 1;
                aNode.hn = ManHattan(point, dist);
                aNode.fn = aNode.gn + aNode.hn;
                if (openList.ContainsKey(aNode.point))
                {
                    if (aNode.fn < openList[aNode.point].fn)
                    {
                        openList[aNode.point] = aNode;
                    }
                }
                else
                    openList.Add(aNode.point, aNode);
            }
        }

        /// <summary>
        /// 判定该点是否可达
        /// </summary>
        /// <param name="a"></param>
        /// <returns></returns>
        private bool IsReachable(Point a)
        {
            return map[a.y, a.x] == this.reachableVal;
        }

        /// <summary>
        /// 计算两个点之间的曼哈顿距离
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        private int ManHattan(Point a, Point b)
        {
            return Math.Abs(a.x - b.x) + Math.Abs(a.y - b.y);
        }

        /// <summary>
        /// 从open列表中获取最小f(n)的节点
        /// </summary>
        /// <param name="aNodes"></param>
        /// <returns></returns>
        private ANode FindMinFn(Dictionary<Point, ANode> aNodes)
        {
            ANode minANode = null;
            foreach(var e in aNodes)
            {
                if(minANode == null || e.Value.fn < minANode.fn)
                {
                    minANode = e.Value;
                }
            }
            return minANode;
        }
    }
}

5，测试

主函数中的代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DeepCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            int[,] map =
            {
                {1,1,1,1,1,1,1,1 },
                {1,0,0,0,1,1,1,1 },
                {1,1,1,0,1,1,1,1 },
                {1,1,0,0,1,0,0,1 },
                {1,1,0,0,0,0,0,1 },
                {1,1,1,1,1,1,1,1 },
            };
            var node = AStar.Instance.Execute(map, 1, 1, 6, 4);
            AStar.Instance.DisplayPath(node);
        }
    }
}

测试结果：

GlowYi98
关注
专栏目录
C#实现A*算法
believe_s的博客
03-26 9889
理解A*寻路算法具体过程 这两天研究了下 A* 寻路算法, 主要学习了这篇文章, 但这篇翻译得不是很好, 我花了很久才看明白文章中的各种指代. 特写此篇博客用来总结, 并写了寻路算法的代码, 觉得有用的同学可以看看. 另外因为图片制作起来比较麻烦, 所以我用的是原文里的图片. 当然寻路算法不止 A* 这一种, 还有递归, 非递归, 广度优先, 深度优先, 使用堆栈等等, 有兴趣的可以研究研究...
C#实现的A*算法代码
04-18
C#实现的A*算法，C#项目，VS2005编译通过
A*算法C#实现
07-27
A*算法，A*（A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近，最终搜索速度越快。代码使用c#语言实现，欢迎下载
A*（A-Star）算法解析（附代码理解）
最新发布
LIUMAO99的博客
08-13 1031
这意味着算法会找到从起点到终点的最短路径，前提是启发式函数是可接受的（admissible），即它不会高估实际的代价。在图论中，节点代表图中的每一个顶点，可以是地图上的一个点、网络中的一个路由器或者任何可以表示为图中一个独立元素的实体。在A*算法中，节点通常代表可能的路径点，例如在地图上从一个城市到另一个城市可能的路线点。边是连接两个节点的线，在A*算法中，边代表从一个节点到另一个节点的路径。值越小，表示从起点到当前节点，再加上到目标点的估计代价越低，这个节点就越有可能是最短路径的一部分。
A* 算法（示例程序+源码）（C#版）
05-30
这是一再游戏中很著名的寻路算法，是基于曼哈顿的算法的A*算法！
A*算法 C#源代码
12-23
此为用C#写的A*算法源代码 using System; using System.Collections.Generic; using System.Text; using System.Drawing; namespace EtSoft.AStarLib { public class AStar { private StarNodeCollection openList = new StarNodeCollection(); private StarNodeCollection closeList = new StarNodeCollection(); public StarNode currentNode = null; #region 构造函数 /// <summary> /// 使用指定的地图对象、起点和终点初始化A星算法 /// </summary> /// <param name="map">地图对象</param> public AStar(Map map) { this.map = map; } /// <summary> /// /// </summary> /// <param name="map">地图对象</param> /// <param name="start">起点坐标</param> /// <param name="end">终点坐标</param> public AStar(Map map, Point start, Point end) : this(map) { this.start = new StarNode(start); this.end = new StarNode(end); openList.Add(new StarNode(start)); //AddStartNodeToOpenList(this.start); } /// <summary> /// /// </summary> /// <param name="map">地图对象</param> /// <param name="startX">起点X坐标</param> /// <param name="startY">起点Y坐标</param> /// <param name="endX">终点X坐标</param> /// <param name="endY">终点Y坐标</param> public AStar(Map map, int startX, int startY, int endX, int endY) : this(map, new Point(startX, startY), new Point(endX, endY)) { } #endregion #region 属性 protected Map map; /// <summary> /// 地图数据 /// </summary> public Map Map { get { return map; } set { map = value; } } private StarNode start = null; /// <summary> /// 起点坐标，如果没有设置起点，返回null /// </summary> public StarNode Start { get { return start; } set { start = value; openList.Clear(); openList.Add(start); //AddNodeToOpenList(start); } } private StarNode end = null; /// <summary> /// 终点坐标，如果没有设置终点，返回null /// </summary> public StarNode End { get { return end; } set { end = value; } } private StarNodeCollection path; /// <summary> /// 返回路径节点集合，没有路径则返回null /// </summary> public StarNodeCollection Path { get { return path; } } private bool allDirection = false; /// <summary> /// true，允许八方向寻路 /// </summary> public bool AllDirection { get { return allDirection; } set { allDirection = value; } } #endregion /// <summary> /// 开始寻路 /// </summary> public void StartSearchPath() { if (start == null) throw new InvalidNodeException(InvalidNodeTypes.NoStart); if (end == null) throw new InvalidNodeException(InvalidNodeTypes.NoEnd); path = null; openList.Clear(); closeList.Clear(); currentNode = start; SearchPath(currentNode); } //寻路递归，受保护的虚方法，允许在子类重写寻路算法 protected virtual void SearchPath(StarNode starNode) { //currentNode = starNode; openList.Remove(starNode); closeList.Add(starNode); AddNodeToOpenList(); if (closeList.Contains(end)) { //如果终点在关闭列表中，找到路径 StarNode node=starNode.Parent; path = new StarNodeCollection(); do { path.Add(node); node = node.Parent; } while (node != null && !node.Equals(start)); path.Reverse(); return; } else if (openList.Count == 0) { //终点不在关闭列表，开放列表已空，没有可通行的路径 return; } currentNode = GetNextNode(); //迭代过程 SearchPath(currentNode); } /// <summary> /// 获得当前节点的下一个最佳节点 /// </summary> /// <returns></returns> public StarNode GetNextNode() { openList.SortByF(); return openList[0]; } /// <summary> /// 把当前点周围可通过的点加入到开放列表中 /// </summary>
A*算法C#实现，三次B样条优化
04-12
在压缩包中的"Astar"文件可能包含了实现A*算法的源代码，你可以通过阅读和理解这些代码来学习如何在C#环境中有效地使用A*算法。同时，为了将A*找到的路径进行平滑，你可能还需要参考其他资料来了解如何实现三次B样条...
A*算法for c#演示
10-25
3. **C#实现细节** 在C#中，可以使用`List<T>`作为开放列表和关闭列表，用`Dictionary, TValue>`存储节点信息。为了实现优先队列，可以使用`System.Collections.Generic.PriorityQueue, TPriority>`。启发式函数...
A*算法解决八数码问题_C#_VS2015
12-07
在实际开发中，八数码问题的A*算法实现需要考虑如何有效地存储和操作棋盘状态，如何实现启发式函数，以及如何用C#的编程特性优化代码结构和性能。VS2015作为开发环境，提供了丰富的调试工具和IDE支持，可以帮助...
C# A*算法
qq_60125117的博客
04-24 1903
A*算法是一种广泛使用的路径搜索算法，通常用于寻找在给定地图或图形中，起点到目标点之间的最短路径。它是一种基于贪心策略的启发式搜索算法，可以在大多数情况下找到最短路径。
C#写的A*算法
07-04
C#写的A*算法，支持4发现和八方向，可以选择性绕过斜角。内有详细注释！
A*寻路算法C#
11-29
A*寻路算法，提供顶点信息矩阵和移动消耗矩阵，返回最短路径顶点列表
C# A*算法实现8数或者15数问题
aome1470的博客
03-24 111
－、问题描述 8数或15数问题是同一个问题，其就是一个随机排列的8个或15个数在一个方正格子中移动到达规定的一个目标状态。由于只有一个空格子，故只有在空格附近的棋子可以移动。 二、算法描述 F 算法选择 此问题需要对所有可能的路径进行穷举，但是由于随着树的高度的加大，其子结点的增加宿舍剧增，所以对所有的子结点进行穷举是不大现实的。而根据当前的状态和目标状态进行对比可以用一个评估函数来评估...
A*算法的一个C#实现
weixin_30485379的博客
07-22 180
最近正在读云风的《游戏之旅》，看着看着就读到了A*寻路算法，虽然以前没有接触过，但总觉得好奇。于是从网上找了一些资料便开始研究。 当然，主要参考的算法文档是“http://www.vckbase.com/document/viewdoc/?id=1422”不过这里并没有给出实际的源代码。而搜了一下A*算法的代码，大都是ActionScript的源码。毕竟用Flash做一个Demo会方便很...
A*算法的C#实现（纯代码）
chenyuan_noc的专栏
03-21 1219
#region using System.Collections.Generic; using System.Diagnostics; using System.Runtime.InteropServices; using UnityEngine; using Debug = UnityEngine.Debug; #endregion public class VAStar : Mono
A*算法C#实现（界面是WinForm）
智障侠的博客
12-29 2782
原文地址：https://blog.csdn.net/Isaac320/article/details/69400096  源码CSDN下载（需2积分）：https://download.csdn.net/download/sun_zeliang/10881332  源码百度云（不需要积分）：https://pan.baidu.com/s/1OEwCex9mpBLS1z3iPoem1w  提取...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值