A*寻路算法的探寻与改良（二）

A*寻路算法的探寻与改良（二）

by:田宇轩                                                    

第二部分：这部分内容主要是使用C语言编程实现A*，想了解A*算法的优化内容的朋友们可以跳过这部分并阅读稍后更新的其他内容

2.1 回顾

       你可以点击这里回顾文章的第一部分。

在我的上一篇文章中，我们通过抽象的思维方式得出了A*算法的概念和原理，这一章内容中主要探讨如何用编程实现A*算法。

在数据结构与算法的学习中，每个算法都应该结合一定的数据结构在计算机中存储，然后用对应的函数操控这些数据结构，A*算法也不例外，从上一篇文章中，我们知道，A*算法需要：

（1）地图，这是一个存储静态路网的结构，由格子组成

（2）格子，格子是组成地图的基本单位，每个格子都有坐标，F，G，H，父节点这五种属性；

（3）开启列表，用于记录等待处理的格子；

（4）关闭列表，用于记录已经处理的格子；

（5）起点和终点，用于接受用户输入指定哪个点为起点，哪个点为终点；

这些存储结构都是A*算法需要的，其实为了实现A*算法，我们还需要更多的存储结构，这些结构我们将会在用到的时候抽象出来的。弄清思路之后，我们先用C语言定义一下这些结构，如果您是其他语言的使用者，也可以按照这些结构的描述用其他语言的定义和实现。下面就是C语言对A*所需结构的实现，下面这段代码可以单独定义在一个头文件中，拥有全局作用域，其实让这些代码拥有全局作用域的方式我们并不提倡，这里只是方便教学和理解用。

 #define MAX_number 5   //这是地图的最大值，可以自己修改以符合实际需求

 //一个比较基础的结构体，用于和地图联动
 struct baseNode
 {
     int i;
     int j;
     int weigt;

     int f;
     int g;
     int h;

     struct baseNode *father;
 };

 //定义了一个全局变量用来存储二维矩阵地图
 struct baseNode map[MAX_number][MAX_number];

 //记录起点和终点的数组，起点为Ascenery[0],终点为Ascenery[1]
 struct baseNode AsceneryList[];

 //开启列表，用于A*算法
 struct baseNode OpenList[MAX_number*MAX_number];

 //关闭列表，用于A*算法
 struct baseNode CloseList[MAX_number*MAX_number];

 //用于记录开启列表中元素的个数
 int openListCount = ;

 //用于记录关闭列表中元素的个数
 int closeListCount = ;

代码2.1.1—A*的基本存储结构

2.2 A*算法的流程

2.2.1 设计代码体系结构

为了方便用户输入和输出，也方便我们直观地看到A*的结果，在代码结构上，我们准备设计三个头文件：data.h，用于存储A*依赖的结构，func.h，用于写一些功能，process_control.h，用于显示一个简单的用户界面，控制用户流程，识别用户的输入是否在合法范围内，最后，我们用main.c调用所有这些内容。主函数很简单，这里先写出来：

 #include "process_control.h"

 int main()
 {
     testStart();

     return ;
 }

代码2.2.1.1—主函数

2.2.2 流程控制函数

我们把前面定义的存储结构写在了data.h里面。然后我们稍微设计一下控制流程的process.h。这是main.c唯一引用的头文件，里面包含一个testStart函数。

 #pragma once

 #include "funcs.h"

 //用于控制整个校园导航系统流程
 void testStart()
 {
         //flag用于辅助程序判断有没有足够条件执行各功能
     int flag1 = , flag2 = ;

         //不断的让用户选择菜单
     for (;;)
     {
         printf("基于A*算法的校园导航系统程序\n\n");

         printf("你可以进行以下操作：\n");
         printf("1.设定校园地图地形\n");
         printf("2.设定寻径的起点和终点\n");
         printf("3.找出最佳路径\n");
         printf("0.退出系统\n\n");

                 //让用户输入自己的选择
         int userInput = ;
         scanf("%d", &userInput);

                //根据自己的选择分别执行inputmap,setroad,Astar三个函数
         switch (userInput)
         {
         case :
             inputmap();
             flag1 = ;
             printf("设定校园地图地形成功\n\n");
             break;

         case :
             if (flag1 == )
             {
                 setRoad();
                 flag2 = ;
                 printf("起点终点设定完毕\n\n");
             }
             else
             {
                 printf("请先完成地图设定\n");
             }
             break;

         case :
             if (flag1 == &&flag2==)
             {
                 Astar();
                 printf("寻径完毕\n\n");
             }
             else
             {
                 printf("请先完成地图、起点终点设定\n");
             }
             break;

         case :
             exit();
             break;

         default:
             printf("输入不在指定范围内，请重新输入\n\n");
             break;
         }
     }
 }

代码2.2.2.1—流程控制函数

2.2.3 设定地图样式的函数inputmap和设定起点终点的函数setroad

     让我们先设定好地图再进行A*算法本体的编写，这部分没有什么难度，因此也不先写伪代码和分析逻辑了，对此不感兴趣的朋友可以直接往后看Astar函数的实现。

 #pragma once

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
 #include "data_define.h"

 //设定地图的函数
 void inputmap()
 {
     printf("目前地图大小为%d * %d。\n",MAX_number,MAX_number);
     printf("请通过输入整数的形式填充地图，0代表地形不可通过，\n其他正整数代表权值，权值越大，地形越不方便通过\n\n");

     for (int i = ; i <MAX_number; ++i)
     {
         for (int j = ; j < MAX_number; ++j)
         {
             scanf("%d", &map[i][j].weigt);

             map[i][j].i = i;
             map[i][j].j = j;
         }
         printf("第%d行输入完毕,共%d行\n\n",i+,MAX_number);
     }
 }

 //设定起点和终点的函数
 void setRoad()
 {
     int i = , j = , p = , q = ;

         printf("地图坐标从【1，1】开始\n");
         printf("请输入起点的横坐标:\n");
         scanf("%d", &i);
         printf("请输入起点的纵坐标:\n");
         scanf("%d", &j);

         AsceneryList[].i = i - ;
         AsceneryList[].j = j - ;

         printf("请输入终点的横坐标:\n");
         scanf("%d", &p);
         printf("请输入终点的纵坐标:\n");
         scanf("%d", &q);

         AsceneryList[].i = p - ;
         AsceneryList[].j = q - ;

 }

代码2.2.3.1—设定地图样式和起点终点的函数

2.2.4 Astar函数的设计

     由于Astar算法需要对每个点的邻居都分析其F值，而且这里我们用二维矩阵来设定地图，因此一个格子最多有8个邻居格子，为了一一处理这些邻居格子，我们设计一种大小为8的邻居数组，用循环从邻居数组的第一个元素处理到邻居数组的最大第八个元素。邻居数组定义如下：

 //邻居列表，用于记录每个当前点的所有邻居
 struct baseNode Neibo[];

 //用于记录邻居的个数
 int neibNum = ;

代码2.2.4.1—邻居列表的定义

接下来我们按照上前文章总结的流程编写一个代码框架，先不实现各个函数的具体功能。先回顾一下上一篇文章的A*寻路流程：

2.2.4.1—A*寻路流程

复习了流程之后，我们就可以按照流程上面的大致打一个框架：

 //假设我们预先把起点放入迭代器iter，终点设为ender
 //把起点放入开启列表
     putInOpenList(iter);

     //当开启列表为空或者终点在关闭列表中，结束寻径
     for (;  openListCount !=  && isInCloseList(ender)==;)
     {
         //取出开启列表中f值最小的节点（之一），并设为iter（当前点）
         iter = readTopOpenList();

         //把当前点从开启列表中删除
         outOpenList(iter);

         //把当前点记录在关闭列表中
         putInCloseList(iter);

         //把当前点的邻居加入邻居列表
         addNeibo(iter);

         //对于每个邻居，分三种情况进行操作
         for (int i = ; i < neibNum; ++i)
         {
             //如果这个邻居节点不可通过，或者这个邻居节点在关闭列表中，略过它
             if (Neibo[i].weigt== || isInCloseList(Neibo[i]))
             {
             }
             //如果这个邻居节点已经在开启列表中
             else if(isInOpenList(Neibo[i]))
             {   //看看以当前格子为父节点，算出来的新G值是不是比原来的G值小，如果更小，就改变这一格的父节点，G值，重新计算F值
                 if (NewG(Neibo[i],iter)<Neibo[i].g)
                 {
                     map[Neibo[i].i][Neibo[i].j].father = &map[iter.i][iter.j];
                     map[Neibo[i].i][Neibo[i].j].g = map[iter.i][iter.j].g + increment(Neibo[i]);
                     map[Neibo[i].i][Neibo[i].j].f = map[Neibo[i].i][Neibo[i].j].g + map[Neibo[i].i][Neibo[i].j].h;
                     //把这一格的旧记录从开启列表删除，把更新后的这一格的值加入开启列表等待处理
                     outOpenList(Neibo[i]);
                     putInOpenList(Neibo[i]);
                 }
             }
             //如果这个邻居节点不在开启列表中
             else
             {
                 map[Neibo[i].i][Neibo[i].j].father= Neibo[i].father = &map[iter.i][iter.j];
                 map[Neibo[i].i][Neibo[i].j].g = map[iter.i][iter.j].g + increment(Neibo[i]);
                 map[Neibo[i].i][Neibo[i].j].f = map[Neibo[i].i][Neibo[i].j].g + map[Neibo[i].i][Neibo[i].j].h;

                 Neibo[i] = map[Neibo[i].i][Neibo[i].j];
                 putInOpenList(Neibo[i]);
             }
         }
     }

代码2.2.4.2—A*寻路流程的代码

然后，只要分别实现上面代码逻辑中的函数就好了：

 //以下函数都是A*算法的一部分///////////////////////////

 //把一个元素插入开启列表中/////////
 void putInOpenList(struct baseNode inList)
 {
     OpenList[openListCount] = inList;
     ++openListCount;
 }

 //取出开启列表中最小的数
 struct baseNode readTopOpenList()
 {
     struct baseNode temp;

     for (int i = ; i < openListCount-; ++i)
     {
         if (OpenList[i].f<OpenList[i+].f)
         {
             temp=OpenList[i];
             OpenList[i]=OpenList[i + ];
             OpenList[i + ] = temp;
         }
     }

     return OpenList[openListCount-];
 }

 //把一个元素加入关闭列表中
 void putInCloseList(struct baseNode temp)
 {
     CloseList[closeListCount] = temp;

     ++closeListCount;
 }

 //把开启列表中的当前节点删除
 void outOpenList(struct baseNode iter)
 {
     int i = openListCount - ;
     for (; i >= ;--i)
     {
         if (OpenList[i].i==iter.i&&OpenList[i].j==iter.j)
         {
             break;
         }
     }

     for (int j = i; j < openListCount-; ++j)
     {
         OpenList[j] = OpenList[j+];
     }
     --openListCount;
 }

 //对于一路上的每个点，分析它的最多八个邻居，并加入邻居列表
 void addNeibo(struct baseNode iter)
 {
     neibNum = ;

     for (int i = iter.i - ; i <= iter.i + ; ++i)
     {
         for (int j = iter.j - ; j <= iter.j + ; ++j)
         {
             if (i >=  && i <= MAX_number -  && j >=  && j <= MAX_number - )
             {
                 if (i == iter.i&&j == iter.j)
                 {
                 }
                 else
                 {
                     map[i][j].h = manhatten(i, j);

                     Neibo[neibNum] = map[i][j];
                     ++neibNum;
                 }
             }
         }
     }
 }

 //查看临近格在不在开启列表中的函数
 int isInOpenList(struct baseNode neibo)
 {
     for (int i = ; i < openListCount - ; ++i)
     {
         if (OpenList[i].i == neibo.i&&OpenList[i].j == neibo.j)
         {
             return ;
         }
     }
     return ;
 }

 //查看指定的temp在不在关闭列表中的函数
 int isInCloseList(struct baseNode temp)
 {
     for (int i = ; i < closeListCount-; ++i)
     {
         if (CloseList[i].i == temp.i&&CloseList[i].j == temp.j)
         {
             return ;
         }
     }
     return ;
 }

 //A*中的启发式函数，用于求指定位置和终点之间的曼哈顿距离
 int manhatten(int i, int j)
 {
     return (abs(AsceneryList[].node.i - i) + abs(AsceneryList[].node.j - j))*;
 }

 //求当前点与父亲节点的距离
 int increment(struct baseNode this)
 {
     if ((abs(this.father->i-this.i)==) && (abs(this.father->j - this.j) == ))
     {
         return *this.weigt;
     }
     else if ((this.father->i - this.i) ==  && (this.father->j - this.j) == )
     {
         return ;
     }
     else
     {
         return *this.weigt;
     }
 }

 //求出用当前点作为父节点时这个点的G值
 int NewG(struct baseNode this,struct baseNode father)
 {
     if (abs(father.i - this.i) ==  && abs(father.j - this.j) == )
     {
         return father.g+;
     }
     else if (abs(father.i - this.i) ==  && abs(father.j - this.j) == )
     {
         return father.g;
     }
     else
     {
         return father.g+;
     }
 }

代码2.2.4.3—刚才代码中具体函数的分别实现

经过函数实现之后，我们就得出来了一条最短的从起点A到终点B的路径，这条路径上（包含A和B），每一个格子都指向它的父节点，因此我们可以从终点开始，一直遍历父节点，并设置一个迭代器，把每个格子的父节点赋值给迭代器，再储存入一个存储路径的数组里，我们就得到了这条路径：

 //用来记录路径经过的点的个数
 int AstackCount = ;

 //用来储存整理后的路径
 struct baseNode Astack[MAX_number*MAX_number];

代码2.2.4.4—存储最佳路线的数组

 //把A*算法的节点按倒序整理到Astack里面
 void arrange(struct baseNode iter)
 {
     AstackCount = ;
     for (; ; iter=map[iter.father->i][iter.father->j])
     {
         Astack[AstackCount] = iter;
         ++AstackCount;
         if (iter.i == AsceneryList[].node.i&&iter.j == AsceneryList[].node.j)
         {
             break;
         }
     }
 }

 //打印出A*算法的路径矩阵
 printAstar()
 {
     printf("A为最佳路径，Q为不经过区域\n\n");
     int boole = ;

     for (int i = ; i < MAX_number; ++i)
     {
         for (int j = ; j < MAX_number; ++j)
         {
             for (int w=; w<AstackCount; ++w)
             {
                 if (Astack[w].i==i&&Astack[w].j==j)
                 {
                     boole = ;
                     break;
                 }
             }

             if (boole==)
             {
                 printf("A ");
                 boole = ;
             }
             else
             {
                 printf("Q ");
             }
         }
         printf("\n");
     }
 }

代码2.2.4.5—迭代整理和输出

大功告成......等等，还差一步，我们在做A*操作时曾经假设iter初始化为起点，ender为终点，记得吗？因此，我们在做A*算法之前还要做这种类似初始化的操作：

//每次执行A*算法，都初始化开启/关闭列表
    openListCount = ;
    closeListCount = ;

    //创建一个迭代器,每次都等于f值最小的节点
    struct baseNode iter;

    //让这个迭代器的初值为起点
    iter.i = AsceneryList[].i;
    iter.j = AsceneryList[].j;
    iter.weigt = map[AsceneryList[].i][AsceneryList[].j].weigt;

    //起点的没有父节点，且为唯一G值为0的点
    iter.g = ;
    iter.h = manhatten(iter.i,iter.j);
    iter.f = iter.g + iter.h;

    //创建终点
    struct baseNode ender;

    ender.i = AsceneryList[].i;
    ender.j = AsceneryList[].j;

    //把起点放入开启列表
    putInOpenList(iter);

代码2.2.4.6—初始化A*

2.3 A*算法总结

这里我们按顺序写一遍A*算法的完整代码，默认是折叠的。看了上文自己做代码的朋友如果实际操作遇到问题，就可以参考以下代码：（下面的代码因为课设加了一些无关紧要的功能）

 #pragma once

 #define MAX_number 5

 //一个比较基础的结构体，用于和地图联动
 struct baseNode
 {
     int i;
     int j;
     int weigt;

     int f;
     int g;
     int h;

     struct baseNode *father;
 };

 //定义了一个全局变量用来存储二维矩阵地图
 struct baseNode map[MAX_number][MAX_number];

 //用于记录景点的数组元素
 struct scenerySpotsList
 {
     struct baseNode node;
     char placeName[];
 };

 //邻居列表，用于记录每个当前点的所有邻居
 struct baseNode Neibo[];

 //记录景点，起点和终点的数组
 struct scenerySpotsList AsceneryList[MAX_number*MAX_number];

 //开启列表，用于A*算法
 struct baseNode OpenList[MAX_number*MAX_number];

 //关闭列表，用于A*算法
 struct baseNode CloseList[MAX_number*MAX_number];

 //用于记录现在的景点个数，第1个景点记录在AsceneryList【2】里，AsceneryList【0】和AsceneryList【1】分别用来记录起点和终点
 int sceneryCount = ;

 //用于记录开启列表中元素的个数
 int openListCount = ;

 //用于记录关闭列表中元素的个数
 int closeListCount = ;

 //用于记录邻居的个数
 int neibNum = ;

 //用来储存整理后的路径
 struct baseNode Astack[MAX_number*MAX_number];

 //用来记录路径经过的点的个数
 int AstackCount = ;

part1

part1为数据定义的头文件

 #pragma once

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
 #include "data_define.h"

 //设定地图的函数
 void inputmap()
 {
     printf("目前地图大小为%d * %d。\n",MAX_number,MAX_number);
     printf("请通过输入整数的形式填充地图，0代表地形不可通过，\n其他正整数代表权值，权值越大，地形越不方便通过\n\n");

     for (int i = ; i <MAX_number; ++i)
     {
         for (int j = ; j < MAX_number; ++j)
         {
             scanf("%d", &map[i][j].weigt);

             map[i][j].i = i;
             map[i][j].j = j;
         }
         printf("第%d行输入完毕,共%d行\n\n",i+,MAX_number);
     }
 }

 //设定校园景点的函数
 void setView()
 {
     for (; ; )
     {
         int inputI = ;
         int inputJ = ;
         char inputS[];

         printf("请输入景点的名称，输入done结束景点录入\n");
         scanf("%s", inputS);

         if (strcmp(inputS,"done")==)
         {
             printf("结束输入:\n");
             break;
         }
         else
         {
             strcpy(AsceneryList[sceneryCount].placeName,inputS);

             printf("地图坐标从【1，1】开始\n");
             printf("请输入景点的横坐标:\n");
             scanf("%d", &inputI);
             AsceneryList[sceneryCount].node.i = inputI-;

             printf("请输入景点的纵坐标:\n");
             scanf("%d", &inputJ);
             AsceneryList[sceneryCount].node.j = inputJ-;

             printf("成功输入一个景点:\n");
             ++sceneryCount;
         }
     }
 }

 //设定起点和终点的函数
 void setRoad()
 {
     printf("你可以进行以下操作\n");
     printf("1.寻找一个景点\n");
     printf("2.手动设定起点终点坐标\n");

     int user_input = ;
     scanf("%d",&user_input);

     if (user_input==)
     {
         int i = ;

         char inputS[];
         printf("请输入想查找的景点的名称:\n这个景点将作为起点\n");
         scanf("%s", inputS);

         for (; i < sceneryCount; ++i)
         {
             if (strcmp(AsceneryList[i].placeName, inputS) == )
             {
                 AsceneryList[].node = AsceneryList[i].node;

                 i = ;
                 printf("成功把%s设置为起点\n",inputS);
                 break;
             }
         }
         if (i != )
         {
             printf("找不到这个景点\n");
         }

         int j = ;

         char inputM[];
         printf("请输入想查找的景点的名称:\n这个景点将作为终点\n");
         scanf("%s", inputM);

         for (; j < sceneryCount; ++j)
         {
             if (strcmp(AsceneryList[j].placeName, inputM) == )
             {
                 AsceneryList[].node = AsceneryList[j].node;

                 j = ;
                 printf("成功把%s设置为终点\n",inputM);
                 break;
             }
         }
         if (j!=)
         {
             printf("找不到这个景点\n");
         }
     }
     else if(user_input==)
     {
         int i = , j = , p = , q = ;

         printf("地图坐标从【1，1】开始\n");
         printf("请输入起点的横坐标:\n");
         scanf("%d", &i);
         printf("请输入起点的纵坐标:\n");
         scanf("%d", &j);

         AsceneryList[].node.i = i - ;
         AsceneryList[].node.j = j - ;

         printf("请输入终点的横坐标:\n");
         scanf("%d", &p);
         printf("请输入终点的纵坐标:\n");
         scanf("%d", &q);

         AsceneryList[].node.i = p - ;
         AsceneryList[].node.j = q - ;
     }
     else
     {
         printf("输入错误\n");
     }
 }

 //以下函数都是A*算法的一部分///////////////////////////

 //把一个元素插入开启列表中/////////
 void putInOpenList(struct baseNode inList)
 {
     OpenList[openListCount] = inList;
     ++openListCount;
 }

 //取出开启列表中最小的数
 struct baseNode readTopOpenList()
 {
     struct baseNode temp;

     for (int i = ; i < openListCount-; ++i)
     {
         if (OpenList[i].f<OpenList[i+].f)
         {
             temp=OpenList[i];
             OpenList[i]=OpenList[i + ];
             OpenList[i + ] = temp;
         }
     }

     return OpenList[openListCount-];
 }

 //把一个元素加入关闭列表中
 void putInCloseList(struct baseNode temp)
 {
     CloseList[closeListCount] = temp;

     ++closeListCount;
 }

 //把开启列表中的当前节点删除
 void outOpenList(struct baseNode iter)
 {
     int i = openListCount - ;
     for (; i >= ;--i)
     {
         if (OpenList[i].i==iter.i&&OpenList[i].j==iter.j)
         {
             break;
         }
     }

     for (int j = i; j < openListCount-; ++j)
     {
         OpenList[j] = OpenList[j+];
     }
     --openListCount;
 }

 //对于一路上的每个点，分析它的最多八个邻居，并加入邻居列表
 void addNeibo(struct baseNode iter)
 {
     neibNum = ;

     for (int i = iter.i - ; i <= iter.i + ; ++i)
     {
         for (int j = iter.j - ; j <= iter.j + ; ++j)
         {
             if (i >=  && i <= MAX_number -  && j >=  && j <= MAX_number - )
             {
                 if (i == iter.i&&j == iter.j)
                 {
                 }
                 else
                 {
                     map[i][j].h = manhatten(i, j);

                     Neibo[neibNum] = map[i][j];
                     ++neibNum;
                 }
             }
         }
     }
 }

 //查看临近格在不在开启列表中的函数
 int isInOpenList(struct baseNode neibo)
 {
     for (int i = ; i < openListCount - ; ++i)
     {
         if (OpenList[i].i == neibo.i&&OpenList[i].j == neibo.j)
         {
             return ;
         }
     }
     return ;
 }

 //查看指定的temp在不在关闭列表中的函数
 int isInCloseList(struct baseNode temp)
 {
     for (int i = ; i < closeListCount-; ++i)
     {
         if (CloseList[i].i == temp.i&&CloseList[i].j == temp.j)
         {
             return ;
         }
     }
     return ;
 }

 //A*中的启发式函数，用于求指定位置和终点之间的曼哈顿距离
 int manhatten(int i, int j)
 {
     return (abs(AsceneryList[].node.i - i) + abs(AsceneryList[].node.j - j))*;
 }

 //求当前点与父亲节点的距离
 int increment(struct baseNode this)
 {
     if ((abs(this.father->i-this.i)==) && (abs(this.father->j - this.j) == ))
     {
         return *this.weigt;
     }
     else if ((this.father->i - this.i) ==  && (this.father->j - this.j) == )
     {
         return ;
     }
     else
     {
         return *this.weigt;
     }
 }

 //求出用当前点作为父节点时这个点的G值
 int NewG(struct baseNode this,struct baseNode father)
 {
     if (abs(father.i - this.i) ==  && abs(father.j - this.j) == )
     {
         return father.g+;
     }
     else if (abs(father.i - this.i) ==  && abs(father.j - this.j) == )
     {
         return father.g;
     }
     else
     {
         return father.g+;
     }
 }

 //把A*算法的节点按倒序整理到Astack里面
 void arrange(struct baseNode iter)
 {
     AstackCount = ;
     for (; ; iter=map[iter.father->i][iter.father->j])
     {
         Astack[AstackCount] = iter;
         ++AstackCount;
         if (iter.i == AsceneryList[].node.i&&iter.j == AsceneryList[].node.j)
         {
             break;
         }
     }
 }

 //打印出A*算法的路径矩阵
 printAstar()
 {
     printf("A为最佳路径，Q为不经过区域\n\n");
     int boole = ;

     for (int i = ; i < MAX_number; ++i)
     {
         for (int j = ; j < MAX_number; ++j)
         {
             for (int w=; w<AstackCount; ++w)
             {
                 if (Astack[w].i==i&&Astack[w].j==j)
                 {
                     boole = ;
                     break;
                 }
             }

             if (boole==)
             {
                 printf("A ");
                 boole = ;
             }
             else
             {
                 printf("Q ");
             }
         }
         printf("\n");
     }
 }

 //Astar的本体
 void Astar()
 {
     //每次执行A*算法，都初始化开启/关闭列表
     openListCount = ;
     closeListCount = ;

     //创建一个迭代器,每次都等于f值最小的节点
     struct baseNode iter;

     //让这个迭代器的初值为起点
     iter.i = AsceneryList[].node.i;
     iter.j = AsceneryList[].node.j;
     iter.weigt = map[AsceneryList[].node.i][AsceneryList[].node.j].weigt;

     //起点的没有父节点，且为唯一G值为0的点
     iter.g = ;
     iter.h = manhatten(iter.i,iter.j);
     iter.f = iter.g + iter.h;

     //创建终点
     struct baseNode ender;

     ender.i = AsceneryList[].node.i;
     ender.j = AsceneryList[].node.j;

     //把起点放入开启列表
     putInOpenList(iter);

     //当开启列表为空或者终点在关闭列表中，结束寻径
     for (;  openListCount !=  && isInCloseList(ender)==;)
     {
         //取出开启列表中f值最小的节点（之一），并设为iter（当前点）
         iter = readTopOpenList();

         //把当前点从开启列表中删除
         outOpenList(iter);

         //把当前点记录在关闭列表中
         putInCloseList(iter);

         //把当前点的邻居加入邻居列表
         addNeibo(iter);

         //对于每个邻居，分三种情况进行操作
         for (int i = ; i < neibNum; ++i)
         {
             //如果这个邻居节点不可通过，或者这个邻居节点在关闭列表中，略过它
             if (Neibo[i].weigt== || isInCloseList(Neibo[i]))
             {
             }
             //如果这个邻居节点已经在开启列表中
             else if(isInOpenList(Neibo[i]))
             {
                 if (NewG(Neibo[i],iter)<Neibo[i].g)
                 {
                     map[Neibo[i].i][Neibo[i].j].father = &map[iter.i][iter.j];
                     map[Neibo[i].i][Neibo[i].j].g = map[iter.i][iter.j].g + increment(Neibo[i]);
                     map[Neibo[i].i][Neibo[i].j].f = map[Neibo[i].i][Neibo[i].j].g + map[Neibo[i].i][Neibo[i].j].h;

                     outOpenList(Neibo[i]);
                     putInOpenList(Neibo[i]);
                 }
             }
             //如果这个邻居节点不在开启列表中
             else
             {
                 map[Neibo[i].i][Neibo[i].j].father= Neibo[i].father = &map[iter.i][iter.j];
                 map[Neibo[i].i][Neibo[i].j].g = map[iter.i][iter.j].g + increment(Neibo[i]);
                 map[Neibo[i].i][Neibo[i].j].f = map[Neibo[i].i][Neibo[i].j].g + map[Neibo[i].i][Neibo[i].j].h;

                 Neibo[i] = map[Neibo[i].i][Neibo[i].j];
                 putInOpenList(Neibo[i]);
             }
         }
     }

     arrange(map[ender.i][ender.j]);
     printAstar();
 }

part2

part2为函数的头文件

 #pragma once

 #include "funcs.h"

 //用于控制整个校园导航系统流程
 void testStart()
 {
     int flag1 = , flag3 = ;

     for (;;)
     {
         printf("基于A*算法的校园导航系统程序\n\n");

         printf("你可以进行以下操作：\n");
         printf("1.设定校园地图地形\n");
         printf("2.设定校园景点\n");
         printf("3.设定寻径的起点和终点\n");
         printf("4.找出最佳路径\n");
         printf("0.退出系统\n\n");

         int userInput = ;
         scanf("%d", &userInput);

         switch (userInput)
         {
         case :
             inputmap();
             flag1 = ;
             printf("设定校园地图地形成功\n\n");
             break;

         case :
             if (flag1==)
             {
                 setView();
                 printf("校园景点设定完毕\n\n");
             }
             else
             {
                 printf("请先完成地图设定\n");
             }
             break;

         case :
             if (flag1 == )
             {
                 setRoad();
                 flag3 = ;
                 printf("起点终点设定完毕\n\n");
             }
             else
             {
                 printf("请先完成地图设定\n");
             }
             break;

         case :
             if (flag1 == &&flag3==)
             {
                 Astar();
                 printf("寻径完毕\n\n");
             }
             else
             {
                 printf("请先完成地图、起点终点设定\n");
             }
             break;

         case :
             exit();
             break;

         default:
             printf("输入不在指定范围内，请重新输入\n\n");
             break;
         }
     }
 }

part3

part3为控制流程的头文件，被主函数调用

 #include "process_control.h"

 int main()
 {
     testStart();

     return ;
 }

part4

part4为主函数

其实，了解数据结构的人会看出来，A*里的开启列表每次都要找出里面的最小值，本文中逐个搜索取最小值的方法并不是最好的方法，这涉及到查找，二叉排序树等等知识，在下一篇文章中，我们开始正式分析如何优化这个算法。

作为参考，这篇文章里的程序在VS2015中运行的结果差不多是这样的：

         

 点击这里查看文章第三部分的内容。