关于AStar的算法请参见网络.

在些大体介绍一下.

AStar算法的核心是估价函数,不同的估价函数可能会表现出不同的行为,因此效率也会有所不同.是一种启发式搜索.有一张open和close表,使用这两张表来确定哪些遍历过,确定下一个节点.

 

astar.h

 

 
  
  1. /************************ 
  2. ## author:Dante Lee 
  3. ## email:bhlzlx@gmail.com 
  4. ## qq:583035284 
  5. ************************/ 
  6. #ifndef ASTAR_H_INCLUDED 
  7. #define ASTAR_H_INCLUDED 
  8.  
  9. #include <stdio.h> 
  10. #include <stdlib.h> 
  11. #include <assert.h> 
  12.  
  13. #define MAP_INITED  1 
  14. // cell types 
  15. #define WALKABLE    0 
  16. #define UNWALKABLE  1 
  17. #define YES         1 
  18. #define NO          0 
  19.  
  20. // the struct contains all the basic information for a AStar Cell. 
  21. typedef struct AStarCell 
  22. { 
  23.     // the position 
  24.     int x; 
  25.     int y; 
  26.     // attribute 
  27.     short int cellType; 
  28. } *pAStarCell,AStarCell_; 
  29.  
  30. ///contains the enssential information for the Node, 
  31. /// for example 1.parent node 2.the node's cost and so on. 
  32. typedef struct AStarCellNode 
  33. { 
  34.     //AStarCell 
  35.     pAStarCell pCell; 
  36.     //the cost 
  37.     float staticCost; 
  38.     float predictCost; 
  39.     float totalCost; 
  40.     //neighbor cells 
  41.     struct AStarCellNode * lpUp; 
  42.     struct AStarCellNode * lpRightUp; 
  43.     struct AStarCellNode * lpRight; 
  44.     struct AStarCellNode * lpRightDown; 
  45.     struct AStarCellNode * lpDown; 
  46.     struct AStarCellNode * lpLeftDown; 
  47.     struct AStarCellNode * lpLeft; 
  48.     struct AStarCellNode * lpLeftUp; 
  49.     //neighbor nodes array 
  50.     struct AStarCellNode * neighborArray[8]; 
  51.     //parent node 
  52.     struct AStarCellNode * lpParent; 
  53. } *pAStarCellNode,AStarCellNode_; 
  54.  
  55. //AStarMap for manager the cells. 
  56. typedef struct AStarMap 
  57. { 
  58.     // 1 means inited. 
  59.     char initState; 
  60.     int width; 
  61.     int height; 
  62.     char ** lpSourceMatrix; 
  63.     AStarCellNode_ *** lpCellMatrix; 
  64. }*pAStarMap,AStarMap_; 
  65.  
  66. /*********************************** 
  67.  *Openlist & Closelist Structures 
  68.  * 
  69.  ***********************************/ 
  70. typedef struct AStarCellListNode 
  71. { 
  72.     struct AStarCellListNode * prevNode; 
  73.     struct AStarCellListNode * nextNode; 
  74.     pAStarCellNode  currentCellNode; 
  75. }*pAStarCellListNode,AStarCellListNode_; 
  76.  
  77. typedef struct AStarOpenList 
  78. { 
  79.     int nodeCount; 
  80.     pAStarMap pMap; 
  81.     char ** assertMap; 
  82.     pAStarCellListNode headNode; 
  83.     pAStarCellListNode tailNode; 
  84. }*pAStarOpenList,AStarOpenList_; 
  85.  
  86. typedef struct AStarCloseList 
  87. { 
  88.     pAStarMap pMap; 
  89.     // choose char to instead of boolean type 
  90.     char ** assertMap; 
  91. }*pAStarCloseList,AStarCloseList_; 
  92.  
  93. /*************************** 
  94.  *other structure 
  95.  * 
  96.  **************************/ 
  97.  
  98. typedef struct AStarPoint 
  99. { 
  100.     int x; 
  101.     int y; 
  102. }*pAStarPoint,AStarPoint_; 
  103.  
  104. typedef struct AStarPathNode 
  105. { 
  106.     struct AStarPathNode * prevNode; 
  107.     struct AStarPathNode * nextNode; 
  108.     pAStarCellNode currentNode; 
  109. }*pAStarPathNode,AStarPathNode_; 
  110.  
  111. typedef struct AStarPathList 
  112. { 
  113.     pAStarPathNode headNode; 
  114.     pAStarPathNode tailNode; 
  115.     int nodesCount; 
  116. }*pAStarPathList,AStarPathList_; 
  117.  
  118. typedef float (* CalculateCallBack)(pAStarCellNode,pAStarCellNode,pAStarCellNode); 
  119. typedef struct AStarMain 
  120. { 
  121.     CalculateCallBack cal_fun; 
  122.     pAStarMap  pMap; 
  123.     pAStarCloseList pCloseList; 
  124.     pAStarOpenList pOpenlist; 
  125. }*pAStar,ASTAR,AStar; 
  126.  
  127.  
  128. /// 
  129. #include <math.h> 
  130.  
  131.  
  132.  
  133. // astar cell functions 
  134. pAStarCell astar_cell_init(float x_,float y_,short int cellType); 
  135.  
  136. //astar node functions 
  137. struct AStarCellNode * astar_cellNode_init(struct AStarCell * pCell_); 
  138.  
  139. void astar_cellNode_assignNeighborNodes( 
  140.                                     struct AStarCellNode * pNode, 
  141.                                     pAStarCellNode down_, 
  142.                                     pAStarCellNode left_, 
  143.                                     pAStarCellNode leftDown_, 
  144.                                     pAStarCellNode leftUp_, 
  145.                                     pAStarCellNode right_, 
  146.                                     pAStarCellNode rightDown_, 
  147.                                     pAStarCellNode rightUp_, 
  148.                                     pAStarCellNode up_); 
  149. void astar_cellNode_cleanup(struct AStarCellNode * pNode); 
  150. void astar_cellNode_reset(struct AStarCellNode * pNode); 
  151. // astar map functions 
  152. // 
  153. pAStarMap astar_map_initFromMemery(void * bytesBuffer,int width,int height); 
  154. void astar_map_printBytesMatrix(pAStarMap pMap); 
  155. void astar_map_cleanup(pAStarMap pMap); 
  156. /**************************** 
  157.  *Openlist & Closelist utilities 
  158.  * 
  159.  ****************************/ 
  160. pAStarCellListNode  astar_cellListNode_init(pAStarCellNode pCellNode); 
  161. void astar_cellListNode_cleanup(pAStarCellListNode pCellListNode); 
  162.  
  163. pAStarOpenList astar_openList_init(pAStarMap pMap); 
  164. void astar_openList_insertCellNode(pAStarOpenList pOpenList,pAStarCellNode pCellNode); 
  165. pAStarCellNode astar_openList_removeTheLeaseCostNode(pAStarOpenList pOpenList); 
  166. pAStarCellNode astar_openList_retriveTheLeaseCostNode(pAStarOpenList pOpenList); 
  167. void astar_openList_cleanup(pAStarOpenList pOpenList); 
  168. void astar_openList_printList(pAStarOpenList pOpenList); 
  169. void astar_openList_reset(pAStarOpenList pOpenList); 
  170.  
  171. pAStarCloseList astar_closeList_init(pAStarMap pMap); 
  172. void astar_closeList_addCellNode(pAStarCloseList pCloseList,pAStarCellNode pCellNode); 
  173. char astar_closeList_assertHasCellNode(pAStarCloseList pCloseList,pAStarCellNode pCellNode); 
  174. void astar_closeList_reset(pAStarCloseList pCloseList); 
  175. void astar_closeList_cleanup(pAStarCloseList pCloseList); 
  176.  
  177. /**************************** 
  178.  *main structures function* 
  179.  ****************************/ 
  180.  
  181. ASTAR * astar_main_initAStar(void * ptr,int width,int height); 
  182. void astar_main_cleanup(pAStar astar); 
  183. void astar_main_setCalculateCallBack(pAStar astar,CalculateCallBack callbackfun); 
  184.  
  185. /**************************** 
  186.  *path finding function* 
  187.  ****************************/ 
  188.  
  189. char astar_findPath(pAStar astar,AStarPoint_ start,AStarPoint_ end,pAStarPathList pPathOuter); 
  190.  
  191. /**************************** 
  192.  *path creating function* 
  193.  ****************************/ 
  194. pAStarPathList astar_pathList_init(void); 
  195. void astar_path_insertFront(pAStarPathList pathList,pAStarCellNode pCellNode); 
  196. void astar_path_print(pAStarPathList pPathList); 
  197. void astar_path_cleanup(pAStarPathList pPathList); 
  198.  
  199. /**************************** 
  200.  *the cost calculating function* 
  201.  ****************************/ 
  202. float astar_calc_diagonal(pAStarCellNode parentNode,pAStarCellNode currentNode,pAStarCellNode destinationNode); 
  203. float astar_calc_manhatton(pAStarCellNode parentNode,pAStarCellNode currentNode,pAStarCellNode destinationNode); 
  204. float astar_calc_euclidian(pAStarCellNode parentNode,pAStarCellNode currentNode,pAStarCellNode destinationNode); 
  205. #endif // ASTAR_H_INCLUDED 
 
  
 
 
  
main.c
 
  
 
 
  
 
  
  1. #include <stdio.h> 
  2. #include <stdlib.h> 
  3. #include "astar.h" 
  4. int main() 
  5. { 
  6.     char * mem = "\0\0\0\0\0\0\0\0\0\0\1\1\0\0\0\1\1\0\0\0\0\0\0\0\0\0\0\0\1\1\0\0\0\1\1\0\0\0\0\0\0\0\0\0\0"; 
  7.     ASTAR * astar = astar_main_initAStar(mem,9,5); 
  8.     //the callback function is used to calculate the cost. 
  9.     //and it has a callback function by default., three callback can be used in this lib 
  10.     //astar_main_setCalculateCallBack(astar,astar_calc_manhatton); 
  11.     astar_main_setCalculateCallBack(astar,astar_calc_euclidian); 
  12.     AStarPoint_ start; 
  13.     start.x = 0; 
  14.     start.y = 0; 
  15.     AStarPoint_ end; 
  16.     end.x = 8; 
  17.     end.y = 4; 
  18.  
  19.     AStarPathList_ * path = astar_pathList_init(); 
  20.  
  21.     astar_map_printBytesMatrix(astar->pMap); 
  22.  
  23.     if(astar_findPath(astar,start,end,path)) 
  24.     { 
  25.         printf("found the path successfully!"); 
  26.         astar_path_print(path); 
  27.         astar_path_cleanup(path); 
  28.     } 
  29.     else 
  30.     { 
  31.         printf("can not find the path!"); 
  32.     } 
  33.  
  34.     end.x = 2; 
  35.  
  36.     astar_path_cleanup(path); 
  37.     path= astar_pathList_init(); 
  38.  
  39.     if(astar_findPath(astar,start,end,path)) 
  40.     { 
  41.         printf("found the path successfully!"); 
  42.         astar_path_print(path); 
  43.         astar_path_cleanup(path); 
  44.     } 
  45.     else 
  46.     { 
  47.         printf("can not find the path!"); 
  48.     } 
  49.  
  50.     astar_main_cleanup(astar); 
  51.     return 0; 
  52. } 
 
  
整体来说astar算法较为简单,对算法熟悉者一两个小时就可以弄懂并实现.
 
  
而且基本的astar算法掌握好之后,可以对此进行扩展比如蜂窝状寻路, 三维寻路等等.都是轻而易举的事情.