a*算法初步（源代码）

最新推荐文章于 2024-03-09 23:30:18 发布
最新推荐文章于 2024-03-09 23:30:18 发布
阅读量2.9k 收藏 1
点赞数
分类专栏： 测试 文章标签： 算法 struct null c insert winapi
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dfman/article/details/201918
版权

关于a*算法的文章和代码有很多，这里是我整理的一份源代码，从别人的例子中修改过来的。在这个代码示例中加入了地图信息对寻址结果的影响，可以用在包含不同种类的地形信息的地图中寻址。由于代码可以调试，你可以看清楚每一个步骤是怎么做的，在这里我就不多做讲解了。
#include <windows.h>
#include <stdio.h>

#define COLS 3 //地图
#define ROWS 3
#define TOTAL_TILES 9

#define TileNum( x, y ) ( y * COLS + x + 1 ) //判断是地图上的第几个格子

struct NODE {
 long f,h,i; //在这里，我增加了一个i函数，主要用于地图信息
 int g;
 int x,y;
 int NodeNum;
 struct NODE *Parent;
 struct NODE *Child[8];       /* a node may have upto 8+(NULL) children. */
 struct NODE *NextNode;       /* for filing purposes */
};

struct NODE *OPEN;
struct NODE *CLOSED;

int TileMap[TOTAL_TILES] = { /  
1, 1, 1, /
1, 2, 1, /
1, 1, 1
};
//地图信息，目前由(0,0)点到(2,2)点的寻址结果是(0,0)->(1,1)->(2,2)。如果中间的那个2修改成4，表明不能行走或者是沼泽路面行走困难，寻址结果是(0,0)->(0,1)->(1,2)->(2,2)。

struct STACK {
    struct NODE *NodePtr;
    struct STACK *NextStackPtr;
};
struct STACK *Stack;

void Push(struct NODE *Node)
{
    struct STACK *tmp;
    tmp = ( struct STACK *)calloc(1,sizeof(struct STACK));
    tmp->NodePtr = Node;
    tmp->NextStackPtr = Stack->NextStackPtr;
    Stack->NextStackPtr = tmp;
}

struct NODE *Pop()
{
    struct NODE *tmp;
    struct STACK *tmpSTK;
    tmpSTK = Stack->NextStackPtr;
    tmp = tmpSTK->NodePtr;
    Stack->NextStackPtr = tmpSTK->NextStackPtr;
    free( tmpSTK );
    return( tmp );
}

struct NODE *CheckOPEN(int tilenum)
{
 struct NODE *tmp = OPEN->NextNode;
 while( tmp ) {
  if( tmp->NodeNum == tilenum )
   return( tmp );
  else
   tmp = tmp->NextNode;
 }
 return( NULL );
}

struct NODE *CheckCLOSED(int tilenum)
{
 struct NODE *tmp = CLOSED->NextNode;
 while( tmp ) {
  if( tmp->NodeNum == tilenum )
   return( tmp );
  else
   tmp = tmp->NextNode;
 }
 return( NULL );
}

void PropagateDown(struct NODE *Old)
{
 int c,g;
 struct NODE *Child, *Father;

 g = Old->g;
 for( c = 0; c < 8; c ++ ) {
  if( ( Child = Old->Child[c] ) == NULL ) break;
  if( g + 1 < Child->g ) {
   Child->g = g + 1;
   Child->f = Child->g + Child->h + Child->i;
   //Child->f = Child->g + Child->h;
   Child->Parent = Old;
   Push( Child );
  }
 }
 while( Stack->NextStackPtr != NULL ) {
  Father = Pop();
  for( c = 0; c < 8; c ++ ) {
   if( ( Child = Father->Child[c] ) == NULL ) break;
   if( Father->g + 1 < Child->g ) {
    Child->g = Father->g + 1;
    Child->f = Child->g + Child->h + Child->i;
    //Child->f = Child->g + Child->h;
    Child->Parent = Father;
    Push( Child );
   }
  }
 }
}

void Insert(struct NODE *Successor)
{
 struct NODE *tmp1,*tmp2;
 long f;

 if(OPEN->NextNode == NULL) {
  OPEN->NextNode = Successor;
  return;
 }

 f = Successor->f;
 tmp1 = OPEN;
 tmp2 = OPEN->NextNode;
 while( ( tmp2 != NULL ) && ( tmp2->f < f ) ) {
  tmp1 = tmp2;
  tmp2 = tmp2->NextNode;
 }
 Successor->NextNode = tmp2;
 tmp1->NextNode = Successor;
}

void GenerateSucc(struct NODE *BestNode,long x, long y, long dx, long dy)
{
 int g, TileNumS, c;
 struct NODE *Old,*Successor;

 TileNumS = TileNum( x, y );
 //g = BestNode->g + TileMap[TileNumS];
 g = BestNode->g + 1;

 if( ( Old = CheckOPEN(TileNumS) ) != NULL ) {
  for( c = 0; c < 8; c ++ ) {
   if( BestNode->Child[c] == NULL ) break;
  }
  BestNode->Child[c] = Old;
  if( g < Old->g ) {
   Old->Parent = BestNode;
   Old->g = g;
   Old->f = g + Old->h + Old->i;
   //Old->f = g + Old->h;
  }
 }
 else if( ( Old = CheckCLOSED(TileNumS) ) != NULL ) {
  for( c = 0; c < 8; c ++ ) {
   if( BestNode->Child[c] == NULL ) break;
  }
  BestNode->Child[c] = Old;
  if( g < Old->g ) {
   Old->Parent = BestNode;
   Old->g = g;
   //Old->f = g + Old->h;
   Old->f = g + Old->h + Old->i;
   PropagateDown( Old );
  }
 }
 else {
  Successor = (struct NODE *)calloc(1,sizeof( struct NODE ));
  Successor->Parent = BestNode;
  Successor->NodeNum = TileNumS;
  Successor->g = g;
  //Successor->h = abs( x - dx ) + abs( y - dy );
  Successor->h = ( x - dx ) * ( x - dx ) + ( y - dy ) * ( y - dy );
  Successor->i = TileMap[Successor->NodeNum-1];
  Successor->f = g + Successor->h + Successor->i;
  //Successor->f = g + Successor->h;
  Successor->x = x;
  Successor->y = y;
  Insert(Successor);
  for( c = 0; c < 8; c ++ ) {
   if( BestNode->Child[c] == NULL ) break;
  }
  BestNode->Child[c]=Successor;
 }
}

void GenerateSuccessors(struct NODE *BestNode,long dx,long dy)
{
 long x,y;

 /* Upper-Left  */
 x = BestNode->x - 1; y = BestNode->y - 1;
 if( x >= 0 && y >= 0 )
  GenerateSucc(BestNode,x,y,dx,dy);

 /* Upper       */
 x = BestNode->x; y = BestNode->y - 1;
 if( y >= 0 )
  GenerateSucc(BestNode,x,y,dx,dy);

 /* Upper-Right */
 x = BestNode->x + 1; y = BestNode->y - 1;
 if( x < COLS && y >= 0 )
  GenerateSucc(BestNode,x,y,dx,dy);

 /* Right       */
 x = BestNode->x + 1; y = BestNode->y;
 if( x < COLS )
  GenerateSucc(BestNode,x,y,dx,dy);

 /* Lower-Right */
 x = BestNode->x + 1; y = BestNode->y + 1;
 if( x < COLS && y < ROWS )
  GenerateSucc(BestNode,x,y,dx,dy);

 /* Lower       */
 x = BestNode->x; y = BestNode->y + 1;
 if( y < ROWS )
  GenerateSucc(BestNode,x,y,dx,dy);

 /* Lower-Left  */
 x = BestNode->x - 1; y = BestNode->y + 1;
 if( x >= 0 && y < ROWS )
  GenerateSucc(BestNode,x,y,dx,dy);

 /* Left        */
 x = BestNode->x - 1; y = BestNode->y;
 if( x >= 0 )
  GenerateSucc(BestNode,x,y,dx,dy);
}

struct NODE *ReturnBestNode(void)
{
 struct NODE *tmp;
 tmp = OPEN->NextNode;
 OPEN->NextNode = tmp->NextNode;
 tmp->NextNode = CLOSED->NextNode;
 CLOSED->NextNode = tmp;
 return(tmp);
}

struct NODE *FindPath(long sx, long sy, long dx, long dy)
{
 struct NODE *Node, *BestNode;
 int TileNumDest = TileNum(dx,dy);
 OPEN = (struct NODE *)calloc(1,sizeof( struct NODE ));
 CLOSED = (struct NODE *)calloc(1,sizeof( struct NODE ));

 Node=(struct NODE *)calloc(1,sizeof( struct NODE ));
 Node->NodeNum = TileNum(sx,sy);
 Node->g = 0;
 //Node->h = abs( sx - dx ) + abs( sy - dy );
 Node->h = ( sx - dx ) * ( sx - dx ) + ( sy - dy ) * ( sy - dy );
 Node->i = TileMap[Node->NodeNum-1];
 Node->f = Node->g + Node->h + Node->i;
 //Node->f = Node->g + Node->h;
 Node->x = sx;
 Node->y = sy;

 OPEN->NextNode=Node;
 for (;;) {
  BestNode = (struct NODE *)ReturnBestNode();
  if( BestNode->NodeNum == TileNumDest ) break;
  GenerateSuccessors( BestNode, dx, dy );
 }
 return BestNode;
};

INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
 Stack=( struct STACK *)calloc(1,sizeof(struct STACK));
 struct NODE * Path = FindPath( 0, 0, 2, 2 );
 return 0;
}

虽然用上面的算法可以找到目的地址，但是目前有几个问题：
1）效率问题：当起点到终点的路径不存在的时候，a*的花费比较大，应该加如预寻址算法或者改进当前算法。
2）当地图中不能走的地方边边角角较多的时候，寻址的结果中折线较多，此时可以寻求其次优解，将路径美化。
3）寻址方向目前有8个，对应于2D的八个方向，感觉应该能扩展到3D空间当中，做一个3D的a*寻址。3D寻址的时候应该是26个方向。

dfman
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
A*算法代码
gulan0的博客
02-23 2535
local _map_data         -- 地图数据 local _open_list        -- 开放节点 local _open_map         -- 开放节点，为了提高性能而加 local _close_map        -- 关闭节点 local _deleget          -- 代理 local _dest_point       -- 目标点 lo...
前向算法(Forward Algorithm)
热门推荐
jeiwt的专栏
10-16 1万+
本文直接举实例说明ForwardAlgorithm (前向算法) 由马尔科夫模型MM可知:对于一个系统，由一个状态转至另一个状态的转换过程中，存在着转移概率，并且这种转移概率可以依据其紧接的前一种状态推算出来，与该系统的原始状态和此次转移前的马尔可夫过程无关。 隐马尔可夫模型（HiddenMarkov models，HMM）是马尔可夫链的一种，它的状态不能直接观察到，但能通过观测向量序列观察到
A*算法源码
08-11
A星寻路算法（A*算法）源码实现，用MFC程序模拟动态寻路过程。只实现了最简单的A*算法，MFC消息处理的也不好，仅作参考。
A*寻路算法，循序渐进，附完整源码
Q540670228的博客
02-27 2193
A*寻路算法—循序渐进(附完整源码) 用途 ​ A*寻路算法的一般用途即为灵活地寻找初始点到目标点的最短路径。 概述 ​ 灵活是A*算法更为注重的特性，可以任意添加障碍物，可以对不同地形的寻路损耗赋予不同的权重，可以设置优先级等等。最短路的算法有很多，Dijkstra，BFS(广度优先搜索)等等，本文着重介绍基于BFS实现的A星寻路算法。 BFS算法原理 ​ 在介绍A星算法前，先介绍一下BFS求最短路的方法。广度优先搜索主要用到的是队列，求最短路的基本思路即为，每走一步都遍历以当前格子的九宫格范围内满足条件
Navigation中A*算法源码解释
lovebc的博客
09-08 1765
A*算法原理 A*算法原理在之前的文章中也有提到，这次主要就是和Navigation中对应起来。 A*算法原理 A*源码 示例图 nx_ = 6, ny_ = 6; 其中A为起始点，(1,2)。B为goal_i 为(4,4)。 calculatePotential 函数是对堆中Pentential值最小的索引值取出，然后进行下一次的更新。 其中toIndex函数返回值为 start_x + nx_*start_y; 即索引 queue_.clear(); //首先将堆清空 //x,y点是全部数据的第几
混合A*源码解读（c++）
最新发布
hooksten的博客
03-09 1239
基于ros中通过slam建立的栅格地图，使用混合A*进行路径规划。 首先是run_hybrid_astar.cpp: #include "hybrid_a_star/hybrid_a_star_flow.h" #include "3rd/backward.hpp" #include <ros/ros.h> namespace backward { backward::SignalHandling sh; } int main(int argc, char **argv) { ros:
路径规划算法之A*算法（附代码及函数功能和参数详细注释）
acanab的博客
08-24 2933
A*（A star）算法是一种在图或网络中寻找从起始节点到目标节点的最短路径的启发式搜索算法。A* 算法结合了 Dijkstra 算法的最短路径搜索和贪心算法的启发式搜索，因此在许多情况下比其他算法更高效地找到最优路径。它常用于路径规划、游戏中的路径查找以及人工智能领域的图搜索问题。A* 算法的主要思想是维护两个集合：一个是已探索的节点集合，另一个是待探索的节点集合。算法在每一步选择待探索集合中的节点，计算该节点的代价（包括实际代价和启发式代价），然后选取代价最小的节点进行探索。
ACNN:论文基于注意力机制的卷积神经网络模型源代码-源码网
03-24
论文基于注意力机制的卷积神经网络模型源代码 要求 python2.7 keras 2.0 斯克莱恩 麻木 keras后端= theano 论文中提出一种基于注意力机制的卷积神经网络模型 文件说明： 先生：电影评论数据集，分为两个文件，一个...
基于行块分布函数的通用网页正文抽取算法优化，Python实现+源代码+文档说明
12-01
为了提高准确率，在去掉噪声的网页A中全文搜索初步正文Text中的块信息，一般为“p“标签，再计算得到该标签的父节点。将所有获得的父节点存储下来，出现次数最多的父节点标签记为包含整个正文区域的标签。直接从该...
C语言源代码格式化 完工 V1.08 20120801 1627.7z
08-01
C语言源代码格式化。 处理文件夹。 PLT2KMLX14解决最后一行的问题 20110721 0931.7z PLT2KML 改CString完工 20120731 1632.7z WPT2KMLx4解决空行末行 20110721 0948.7z WPT2KML 改CString完工 20120731 1700.7z ...
A*算法改进程序
12-27
借鉴了原程序，稍加改进，提供了一种新思路，跟大家交流
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>
ClassAStart(经典A*算法C++版)
09-29
初识A*算法和深入A*算法中提到的源程序，也是最经典的A* C++源代码。
C语言源代码格式化 完工 小文版本 V1.10 20120831 0955.zip
08-31
C语言源代码格式化。 处理文件夹。 PLT2KMLX14解决最后一行的问题 20110721 0931.7z PLT2KML 改CString完工 20120731 1632.7z PLT2KML 20110811 1047 处理单文件.7z PLT2KML 20120813 1815 处理子目录.7z PLT2...
C语言源代码格式化 完工 V1.09 20120821 2116.7z
08-21
C语言源代码格式化。 处理文件夹。 PLT2KMLX14解决最后一行的问题 20110721 0931.7z PLT2KML 改CString完工 20120731 1632.7z PLT2KML 20110811 1047 处理单文件.7z PLT2KML 20120813 1815 处理子目录.7z WPT2...
A*寻路：源代码实现及使用
Mr. Code的技术游记
11-28 980
文章目录一、本篇目的二、开发环境三、简介四、程序结构五、寻路库的使用1、库添加到引用2、例子13、例子24、例子3六、使用`Excel`画地形图 一、本篇目的 学习了A*寻路基础之后，发现源码下载不了了，自己实现一下，并做一些扩展记录以及测试。 本文所述完整源代码在这里下载。 二、开发环境 VS2017 C# 三、简介 关于A*寻路，这篇文章说得很清楚：A* Pathfinding for Beginners 有人翻译成中文了，中文可以看这个：A*寻路入门 这篇文章说得很清楚，想调试源代码加深理解，但是
机器人路径规划之A*算法(附C++源码)
3D视觉工坊
01-19 1970
来源丨古月居点击进入—>3D视觉工坊学习交流群1. 基本原理A*算法的本质是广度优先的图搜索.意在寻找一个从起点到目标节点的最短路径.A*算法在Dijkstra的基础上加入了启发式变量,一般用启发式距离(两点的直线距离)表示.启发式距离2. 算法伪代码本伪代码摘取自Principles of Robot Motion其中O代表优先队列,C存放着已访问过的节点.3. 关键C++代码剖析先来看...
A*算法
木牛的博客
03-25 1万+
from：https://www.cnblogs.com/21207-iHome/p/6048969.html Dijkstra算法 　　迪杰斯特拉（Dijkstra）算法是典型的最短路径的算法，由荷兰计算机科学家迪杰斯特拉于1959年提出，用来求得从起始点到其他所有点最短路径。该算法采用了贪心的思想，每次都查找与该点距离最近的点，也因为这样，它不能用来解决存在负权边的图。解决的问题可描述为：...
基于a*算法的matlab代码
01-21
A*算法是一种常用的启发式搜索算法，用于求解图的最短路径问题。它结合了广度优先搜索和启发式搜索的特点，能够高效地找到最优路径。 下面是一个基于A*算法的Matlab代码示例： ```matlab function path = aStarAlgorithm(graph, start, goal) openList = PriorityQueue(); % 创建一个优先队列用于存放待扩展的节点 openList.insert(start, 0); % 将起始节点加入openList中 cameFrom = containers.Map; % 存放节点的父节点，用于回溯路径 gScore = containers.Map; % 存放节点的实际代价 gScore(start) = 0; % 起始节点的实际代价为0 fScore = containers.Map; % 存放节点的估计代价 fScore(start) = heuristicCostEstimate(start, goal); % 起始节点的估计代价为启发式函数值 while ~openList.isEmpty() current = openList.pop(); % 从openList中取出fScore最小的节点 if current == goal path = reconstructPath(cameFrom, goal); % 回溯路径 return; end neighbors = getNeighbors(graph, current); % 获取当前节点的邻居节点 for i = 1:length(neighbors) neighbor = neighbors(i); tentativeGScore = gScore(current) + distance(current, neighbor); % 计算从起始节点到邻居节点的实际代价 if ~isKey(gScore, neighbor) || tentativeGScore < gScore(neighbor) cameFrom(neighbor) = current; gScore(neighbor) = tentativeGScore; fScore(neighbor) = gScore(neighbor) + heuristicCostEstimate(neighbor, goal); if ~openList.contains(neighbor) openList.insert(neighbor, fScore(neighbor)); % 将邻居节点加入openList中 end end end end end ``` 以上代码是一个简单的A*算法实现，其中包括了节点的存储、优先队列的使用、启发式函数的定义等基本步骤。通过这个示例，我们可以看到A*算法的基本思想和实现方式，能够帮助我们更好地理解和应用这个经典的搜索算法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值