A*算法C实现

A*算法的C语言实现：

#include<stdio.h>
#include<math.h>

#define MaxLength 100    //用于优先队列（Open表）的数组
#define Height     15    //地图高度
#define Width      20    //地图宽度

#define Reachable   0    //可以到达的结点
#define Bar         1    //障碍物
#define Pass        2    //需要走的步数
#define Source      3    //起点
#define Destination 4    //终点

#define Sequential  0    //顺序遍历
#define NoSolution  2    //无解决方案
#define Infinity    0xfffffff

#define East       (1 << 0)
#define South_East (1 << 1)
#define South      (1 << 2)
#define South_West (1 << 3)
#define West       (1 << 4)
#define North_West (1 << 5)
#define North      (1 << 6)
#define North_East (1 << 7)

typedef struct
{
       
    signed char x, y;
} Point;  
const Point dir[8] =
{
       
     {
   0, 1},   // East    
     {
   1, 1},   // South_East    
     {
   1, 0},   // South    
     {
   1, -1},  // South_West    
     {
   0, -1},  // West    
     {
   -1, -1}, // North_West    
     {
   -1, 0},  // North    
     {
   -1, 1}   // North_East
};

unsigned char within(int x, int y)
{
       
     return (x >= 0 && y >= 0        
         && x < Height && y < Width
);

typedef struct{
   
    int x, y;
    unsigned char reachable, sur, value;
} MapNode;

typedef struct Close{
       
    MapNode *cur;
    char vis;
    struct Close *from;
    float F, G;
    int H;
}Close;

typedef struct //优先队列（Open表）
{
       
    int length;        //当前队列的长度    
    Close* Array[MaxLength];    //评价结点的指针
}Open;  

static MapNode graph[Height][Width];
static int srcX, srcY, dstX, dstY;    //起始点、终点static Close close[Height][Width];

// 优先队列基本操作
void initOpen(Open *q)    //优先队列初始化
{
       
    q->length = 0;        // 队内元素数初始为0
}  
void push(Open *q, Close cls[Height][Width], int x, int y, float g)
{
       //向优先队列（Open表）中添加元素    
     Close *t;    
     int i, mintag;    
     cls[x][y].G = g;    //所添加节点的坐标    
     cls[x][y].F = cls[x][y].G + cls[x][y].H;    
     q->Array[q->length++] = &(cls[x][y]);    
     mintag = q->length - 1;    
     for (i = 0; i < q->length - 1; i++)    
     {
           
         if (q->Array[i]->F < q->Array[mintag]->F)        
         {
               
             mintag = i;        
         }   
     }    
     t = q->Array[q->length - 1];    
     q->Array[q->length - 1] = q->Array[mintag];    
     q->Array[mintag] = t;    //将评价函数值最小节点置于队头
}

Close* shift(Open *q)
{
       
    return q->Array[--q->length]
}  

// 地图初始化操作
void initClose(Close cls[Height][Width], int sx, int sy, int dx, int dy)
{
      
     // 地图Close表初始化配置    
     int i, j;    
     for (i = 0; i < Height; i++)    
     {
           
         for (j = 0; j < Width; j++)        
         {
               
             cls[i][j].cur = &graph[i][j];        // Close表所指节点            
             cls[i][j].vis = !graph[i][j].reachable;        // 是否被访问            
             cls[i][j].from = NULL;                // 所来节点            
             cls[i][j].G = cls[i][j].F = 0;            
             cls[i][j].H = abs(dx - i) +<