码迷,mamicode.com
首页 > 编程语言 > 详细

A*算法(附c源码)

时间:2015-10-27 21:47:53      阅读:373      评论:0      收藏:0      [点我收藏+]

标签:

关于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][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
技术分享
  1 #include "Apath.h"
  2 
  3 LinkList InitList()
  4 {
  5     LinkList L = (LinkList)malloc(sizeof(LNode));
  6     if (L == NULL)
  7     {
  8         printf("Defeat!");
  9         exit(1);
 10     }
 11     memset(L,0,sizeof(LNode));
 12     return L;
 13 }//LinkList()
 14 
 15 LNode** malloc_array2D(int row, int col)
 16 {
 17     LNode** map = (LNode**)malloc(row*sizeof(LNode*) + row*col*sizeof(LNode));
 18     LNode* head = (LNode*)(map + row);
 19     for (int i = 0; i < row; ++i)
 20         map[i] = head + i*col;
 21     return map;
 22 }
 23 
 24 LNode** Translate_array(int array[][10], int row, int col)
 25 {
 26     LNode **map = malloc_array2D(10, 10);
 27     for (int i = 0; i < row; ++i)
 28         for (int j = 0; j < col; ++j)
 29         {
 30             (map[i] + j)->data = array[i][j];
 31             (map[i] + j)->G = 0;
 32             (map[i] + j)->H = 0;
 33             (map[i] + j)->F = 0;    //(map[i] + j)->G + (map[i] + j)->H;
 34             (map[i] + j)->x = i;
 35             (map[i] + j)->y = j;
 36             (map[i] + j)->Close_flag = 0;
 37             (map[i] + j)->OPen_flag = 0;
 38             (map[i] + j)->next = NULL;
 39             (map[i] + j)->path_next = NULL;
 40         }
 41     return map;
 42 }//Translate_array()
 43 
 44 void free_array2D(LNode **arr)
 45 {
 46     free(arr);
 47 }
 48 
 49 void output(LNode** array, int row, int col)  //二维数组的访问必须指明位数,否则编译器不能解析
 50 {
 51     //for (int i = 0; i < row; ++i)
 52     //    for (int j = 0; j < col; ++j)
 53     //    {
 54     //        (array[i] + j)->F = j;
 55     //    }
 56     for (int i = 0; i < row; ++i)
 57     {
 58         for (int j = 0; j < col; ++j)
 59         {
 60             printf("%d\t", (array[i] + j)->data);
 61         }
 62         printf("\n");
 63     }
 64 }
 65 
 66 LNode* find_start_LNode(LNode** Arr, int row, int col)    //从数组中找到始点
 67 {
 68     LNode* start_LNode = NULL;
 69     for (int i = 0; i < row; ++i)
 70     {
 71         for (int j = 0; j < col; ++j)
 72         {
 73             if (2 == (Arr[i] + j)->data)
 74             {
 75                 start_LNode = (Arr[i] + j);
 76                 //起点H=0,G=0,F=0
 77                 start_LNode->G = 0;
 78                 start_LNode->H = 0;
 79                 start_LNode->F = 0;        //起点,则默认所有值为0
 80                 return start_LNode;        //返回节点
 81             }
 82         }
 83     }
 84     return NULL;
 85 }
 86 LNode* find_end_LNode(LNode** Arr, int row, int col)        //从数组中找到终点
 87 {
 88     LNode* end_LNode = NULL;
 89     for (int i = 0; i < row; ++i)
 90     {
 91         for (int j = 0; j < col; ++j)
 92         {
 93             if (3 == (Arr[i] + j)->data)
 94             {
 95                 end_LNode = (*(Arr + i) + j);
 96                 end_LNode->F = 0;
 97                 end_LNode->G = 0;
 98                 end_LNode->H = 0;
 99                 return end_LNode;        //返回节点
100             }
101         }
102     }
103     return NULL;
104 }
105 
106 int count_LNode_G(LNode* curLNode, LNode* aheadLNode)        //计算节点的G值
107 {
108     if (curLNode->x == aheadLNode->y && curLNode->y == aheadLNode->y)
109         return 0;
110     if (aheadLNode->x - curLNode->x != 0 && aheadLNode->y - curLNode->y !=0)
111         curLNode->G = aheadLNode->G + 14;
112     else
113         curLNode->G = aheadLNode->G + 10;
114     return curLNode->G;
115 }
116 int count_LNode_H(LNode* curLNode, LNode* endLNode)        //计算节点的H值
117 {
118     curLNode->H = abs(endLNode->x - curLNode->x) * 10 + abs(endLNode->y - curLNode->y) * 10;
119     return curLNode->H;
120 }
121 int count_LNode_F(LNode* curLNode)        //计算节点的F值
122 {
123     curLNode->F = curLNode->G + curLNode->H;
124     return curLNode->F;
125 }
126 
127 void push_OpenList_Node(LinkList L, LNode *elem)        //按从小到大的顺序
128 {
129     LNode *p, *q;
130     p = q = L;
131     while (p->next != NULL && p->F < elem->F)
132     {
133         q = p;
134         p = p->next;
135     }
136     if (p->F < elem->F) q = p;
137     elem->next = q->next;
138     q->next = elem;
139     //插入成功,更改属性值OPen_flag = 1
140     elem->OPen_flag = 1;
141 }
142 LNode* pop_OpenList_minNode(LinkList L_OpenList )        //返回开放列表中F值最小的节点
143 {
144     LNode *elem = NULL;
145     if (L_OpenList->next)        //为了安全,防止访问空指针
146     {
147         L_OpenList->next->OPen_flag = 0;
148         elem = L_OpenList->next;
149         L_OpenList->next = L_OpenList->next->next;
150         elem->next = NULL;
151     }
152     else
153         printf("have a NULL point in pop_OpenList_mimNode()");
154     return elem;
155 }
156 bool insert_Into_CloseList(LNode* min_Open, LinkList L_CloseList)//插入OpenList中F值最小的节点到CloseList中去
157 {
158     //对于CloseList中的节点并不需要排序,采用头插法
159     min_Open->next = L_CloseList->next;
160     L_CloseList->next = min_Open;
161     min_Open->Close_flag = 1;
162     return TURE;
163 }
164 
165 bool isExist_openList(LNode* curLNode)
166 {
167     return curLNode->OPen_flag;
168 }
169 bool isExist_closeList(LNode* curLNode)
170 {
171     return curLNode->Close_flag;
172 }
173 bool isobstacle(LNode* curLNode)
174 {
175     if (curLNode->data == 1)
176         return TURE;
177     else
178         return FAULT;
179 }
180 bool isJoin(LNode* cur)        //该节点是否可以加入开放列表
181 {
182     if (cur->x > -1 && cur->y > -1)            //边界检测
183     {
184         if (!isExist_closeList(cur) && !isobstacle(cur))        //既不在关闭列表里,也不是障碍物
185         {
186             return TURE;
187         }
188         else
189             return FAULT;
190     }
191     return FAULT;
192 }
193 void insert_open(LNode *Node, LNode* ahead, LNode* endLNode, LinkList open_list, LNode** Arr)
194 {
195     if (isJoin(Node))
196     {
197         if (isExist_openList(Node))
198         {
199             if (Node->x - ahead->x != 0 && Node->y - ahead->y != 0) {
200                 if (Node->F > (ahead->F + 14))
201                 {
202                     count_LNode_G(Node, ahead);
203                     count_LNode_F(Node);        //H值没有改变,所以还是原来的值
204                     Node->path_next = ahead;        //也不用再插入
205                 }
206             }
207             else {
208                 if (Node->F > (ahead->F + 10))
209                 {
210                     count_LNode_G(Node, ahead);
211                     count_LNode_F(Node);        //H值没有改变,所以还是原来的值
212                     Node->path_next = ahead;        //也不用再插入
213                 }
214             }
215         }
216         else {
217             count_LNode_G(Node, ahead);
218             count_LNode_H(Node, endLNode);
219             count_LNode_F(Node);
220             Node->path_next = ahead;
221             push_OpenList_Node(open_list, Node);
222         }
223     }
224 }
225 void check_around_curNode(LNode* cur, LNode* endLNode, LinkList open_list, LNode** Arr)
226 {
227     int x = cur->x;
228     int y = cur->y;
229     insert_open(Arr[x] + y - 1, cur, endLNode, open_list, Arr);
230     insert_open(Arr[x] + y + 1, cur, endLNode, open_list, Arr);
231     insert_open(Arr[x + 1] + y, cur, endLNode, open_list, Arr);
232     insert_open(Arr[x + 1] + y - 1, cur, endLNode, open_list, Arr);
233     insert_open(Arr[x + 1] + y + 1, cur, endLNode, open_list, Arr);
234     insert_open(Arr[x - 1] + y, cur, endLNode, open_list, Arr);
235     insert_open(Arr[x - 1] + y + 1, cur, endLNode, open_list, Arr);
236     insert_open(Arr[x - 1] + y - 1, cur, endLNode, open_list, Arr);
237 }
Apath.c
技术分享
 1 #include <stdio.h>
 2 //#ifndef APATH_H
 3 #include "Apath.h"
 4 //#endif
 5 
 6 //为简单,干脆把把下面数组转为链表结构的数组
 7 //约定:0是可走的,1表示障碍物不可走,2表示起点,3表示终点,4表示路径
 8 int array[10][10] = {
 9     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
10     { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0 },
11     { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
12     { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 },
13     { 0, 0, 0, 0, 0, 1, 3, 0, 0, 0 },
14     { 0, 0, 2, 0, 0, 1, 0, 0, 0, 0 },
15     { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 },
16     { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 },
17     { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0 },
18     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } };
19 
20 int main()
21 {
22     int row = MAP_MAX_X, col = MAP_MAX_Y;
23     printf("hello world!\n");
24     LNode **map = Translate_array(array,row, col); //这里将数组的地图转为节点map的地图
25     output(map,10,10);
26     LinkList open_List = InitList();     //定义并初始化一个开放列表
27     LinkList close_List = InitList();    //一个封闭列表
28     LNode* startLNode = find_start_LNode(map, row, col);
29     LNode* endLNode = find_end_LNode(map, row, col);
30 
31     LNode* curLNode = startLNode;        //当前节点=开始节点
32     curLNode->G = 0;        //计算节点的三个值
33     count_LNode_H(curLNode, endLNode);
34     count_LNode_F(curLNode);
35     push_OpenList_Node(open_List, curLNode);        //先将开始节点插入开放列表
36 
37     while (curLNode->data != 3)
38     {
39         //LNode *e = NULL;
40         curLNode = pop_OpenList_minNode(open_List);
41         insert_Into_CloseList(curLNode, close_List);
42         //2、查看起点周围的点是否在开放列表里,不在加入,在检测经过该点F值是否最小等;
43         check_around_curNode(curLNode, endLNode, open_List, map);
44     }
45     while (endLNode->path_next)
46     {
47         printf("x:%d---y:%d\n", endLNode->path_next->x,endLNode->path_next->y);
48         endLNode->path_next = endLNode->path_next->path_next;
49     }
50     return 0;
51 }
main.c

测试结果(红线就是要找的路线):

技术分享

技术分享

技术分享

 

A*算法(附c源码)

标签:

原文地址:http://www.cnblogs.com/mingbujian/p/4915546.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!