A*算法（附c源码）

关于A*算法网上介绍的有很多，我只是看了之后对这个算法用c写了一下，并测试无误后上传以分享一下，欢迎指正！下面是我找的一个介绍，并主要根据这个实现的。

        寻路算法不止 A* 这一种, 还有递归, 非递归, 广度优先, 深度优先, 使用堆栈等等, 有兴趣的可以研究研究~~

        如图所示简易地图, 其中绿色方块的是起点 (用 A 表示), 中间蓝色的是障碍物, 红色的方块 (用 B 表示) 是目的地. 为了可以用一个二维数组来表示地图, 我们将地图划分成一个个的小方块.

        二维数组在游戏中的应用是很多的, 比如贪吃蛇和俄罗斯方块基本原理就是移动方块而已. 而大型游戏的地图, 则是将各种"地貌"铺在这样的小方块上.

寻路步骤

        1. 从起点A开始, 把它作为待处理的方格存入一个"开启列表", 开启列表就是一个等待检查方格的列表.

        2. 寻找起点A周围可以到达的方格, 将它们放入"开启列表", 并设置它们的"父方格"为A.

        3. 从"开启列表"中删除起点 A, 并将起点 A 加入"关闭列表", "关闭列表"中存放的都是不需要再次检查的方格

        图中浅绿色描边的方块表示已经加入 "开启列表" 等待检查. 淡蓝色描边的起点 A 表示已经放入 "关闭列表" , 它不需要再执行检查.

        从 "开启列表" 中找出相对最靠谱的方块, 什么是最靠谱? 它们通过公式 F=G+H 来计算.

        F = G + H

                G 表示从起点 A 移动到网格上指定方格的移动耗费 (可沿斜方向移动).

                H 表示从指定的方格移动到终点 B 的预计耗费 (H 有很多计算方法, 这里我们设定只可以上下左右移动).

        我们假设横向移动一个格子的耗费为10, 为了便于计算, 沿斜方向移动一个格子耗费是14. 为了更直观的展示如何运算 FGH, 图中方块的左上角数字表示 F, 左下角表示 G, 右下角表示 H. 看看是否跟你心里想的结果一样?

        从 "开启列表" 中选择 F 值最低的方格 C (绿色起始方块 A 右边的方块), 然后对它进行如下处理:

        4. 把它从 "开启列表" 中删除, 并放到 "关闭列表" 中.

        5. 检查它所有相邻并且可以到达 (障碍物和 "关闭列表" 的方格都不考虑) 的方格. 如果这些方格还不在 "开启列表" 里的话, 将它们加入 "开启列表", 计算这些方格的 G, H 和 F 值各是多少, 并设置它们的 "父方格" 为 C.

        6. 如果某个相邻方格 D 已经在 "开启列表" 里了, 检查如果用新的路径 (就是经过C 的路径) 到达它的话, G值是否会更低一些, 如果新的G值更低, 那就把它的 "父方格" 改为目前选中的方格 C, 然后重新计算它的 F 值和 G 值 (H 值不需要重新计算, 因为对于每个方块, H 值是不变的). 如果新的 G 值比较高, 就说明经过 C 再到达 D 不是一个明智的选择, 因为它需要更远的路, 这时我们什么也不做.

        如图, 我们选中了 C 因为它的 F 值最小, 我们把它从 "开启列表" 中删除, 并把它加入 "关闭列表". 它右边上下三个都是墙, 所以不考虑它们. 它左边是起始方块, 已经加入到 "关闭列表" 了, 也不考虑. 所以它周围的候选方块就只剩下 4 个. 让我们来看看 C 下面的那个格子, 它目前的 G 是14, 如果通过 C 到达它的话, G将会是 10 + 10, 这比 14 要大, 因此我们什么也不做.

        然后我们继续从 "开启列表" 中找出 F 值最小的, 但我们发现 C 上面的和下面的同时为 54, 这时怎么办呢? 这时随便取哪一个都行, 比如我们选择了 C 下面的那个方块 D.

        D 右边已经右上方的都是墙, 所以不考虑, 但为什么右下角的没有被加进 "开启列表" 呢? 因为如果 C 下面的那块也不可以走, 想要到达 C 右下角的方块就需要从 "方块的角" 走了, 在程序中设置是否允许这样走. (图中的示例不允许这样走)

        就这样, 我们从 "开启列表" 找出 F 值最小的, 将它从 "开启列表" 中移掉, 添加到 "关闭列表". 再继续找出它周围可以到达的方块, 如此循环下去...

        那么什么时候停止呢? —— 当我们发现 "开始列表" 里出现了目标终点方块的时候, 说明路径已经被找到.

如何找回路径

        如上图所示, 除了起始方块, 每一个曾经或者现在还在 "开启列表" 里的方块, 它都有一个 "父方块", 通过 "父方块" 可以索引到最初的 "起始方块", 这就是路径.

以上转自http://www.cnblogs.com/technology/archive/2011/05/26/2058842.html

下面是我的代码(c)：

一共三个文件：Apath.h 、Apath.c 、main.c 代码中有详细注释。

 1  #include <stdio.h>
 2  #include <stdlib.h>
 3  #include <string.h>
 4  #include <stddef.h>
 5  #include <stdbool.h>
 6 
 7  #ifndef APATH_H
 8  #define APATH_H
 9  #endif
10 
11  #define TURE 1
12  #define FAULT 0
13 
14  //约定：0是可走的，1表示障碍物不可走，2表示起点，3表示终点，4表示路径
15  #define int_0 0
16  #define int_1 1
17  #define int_2 2
18  #define int_3 3
19  #define int_4 4
20 
21  #define MAP_MAX_X 10 //地图边界，二维数组大小
22  #define MAP_MAX_Y 10
23 
24 typedef struct LNode {
25     int data;                   //对应数组中的数值
26     int F;                      //F = G + H;
27     int G;                      //G：从起点 A 移动到指定方格的移动代价，沿着到达该方格而生成的路径
28     int H;                      //H：从指定的方格移动到终点 B 的估算成本
29     int x, y;                   //对应数组中的坐标
30     bool OPen_flag;             //在开放列表中为1，不在为0
31     bool Close_flag;            //在关闭列表中为1，不在为0
32     struct LNode* next;         //用于链表排序
33     struct LNode* path_next;    //用于最终找到的路径
34 }LNode, *LinkList;
35 
36  LinkList InitList(); //返回一个初始化的链表
37  LNode** malloc_array2D(int row, int col);
38  void free_array2D(LNode **arr);
39  LNode** Translate_array(int array[][10], int row, int col); //将一个普通数组翻译为单链表节点的数组
40  void output(LNode **array, int row, int col);
41 
42  LNode* find_start_LNode(LNode** Arr, int row, int col); //从数组中找到始点
43  LNode* find_end_LNode(LNode** Arr, int row, int col); //从数组中找到终点
44 
45  //忘记这些要干嘛了，重写吧
46  //bool isExist_ALNode_in_List(LNode* curLNode, LinkList L_OpenList); //查看节点是否在链表中，在返回ture,不在返回fault
47  //对关闭列表中的当前节点进行检查，看它周围的节点是否在OpenList链表里，不在:添加进去；在：检查经过它到达起点的G是否最小，是：修改，不是：不修改
48  //LNode* check_CloseList_curLNode(LNode* curLNode, LNode* endLNode, LinkList L_OpenList, LinkList L_CloseList, LNode** Arr);
49 
50  LNode* pop_OpenList_minNode(LinkList L_OpenList); //返回开放列表中F值最小的节点
51  void push_OpenList_Node(LinkList L, LNode *elem); //插入一个节点并排序
52  bool insert_Into_CloseList(LNode* min_Open, LinkList L_CloseList);//插入OpenList中F值最小的节点到CloseList中去
53 
54 
55  int count_LNode_G(LNode* curLNode, LNode* aheadLNode); //计算节点的G值
56  int count_LNode_H(LNode* curLNode, LNode* endLNode); //计算节点的H值
57  int count_LNode_F(LNode* curLNode); //计算节点的F值
58 
59  bool isExist_openList(LNode* curLNode); //查看节点是否在链表中，在返回ture,不在返回fault
60  bool isExist_closeList(LNode* curLNode);
61  bool isobstacle(LNode* curLNode);
62  void check_around_curNode(LNode* cur, LNode* endLNode, LinkList open_list, LNode** Arr); //检查周围的节点，是否合适加入开放列表

Apath.h