A*尋路算法的探尋與改良（三）

by:田宇軒                                       

第三分：這部分內容基於樹、查找算法等對A*算法的執行效率進行了改良，想了解細化后的A*算法和變種A*算法內容的朋友們可以跳過這部分並閱讀稍后更新的其他內容

3.1 回顧

      你可以點擊這里回顧文章的第二部分。

       在我的上一篇文章中，我們探討了如何用編程實現A*算法，並給出了C語言的算法實現，這一章內容中我們主要研究如何提高A*算法的執行效率。拋開時間復雜度的復雜計算，我們大概可以知道，函數對數據的操作次數越少，達成目的越快，算法的效率也就越高。沿着這個思路，我們可以先從研究函數對存儲結構做的操作頻率和具體內容改造它們，使A*更高效。如果前兩部分只是初學者的新手教程，那么從本章開始，我們進入了更難的部分。

 

3.2 分析A*函數的中代價高的操作

      在A*中，我們把起點放入iter，然后就重復for循環，可見for循環中重復執行的函數對於A*算法性能的影響是非常重要的，我們就從這個Astar里的最外層for循環開始看，一個函數一個函數地分析出哪個部分可以如何提高A*算法的效率。

     （一）首先我們分析的就是這個for循環的循環條件，這個循環的條件在每一次循環發生的時候都會進行判定。最外層的for循環里，我們只判定這么兩項內容：

     （1）開啟列表是否為空。開啟列表如果是空的，這就代表我們沒有待處理的格子了，已經無路可走，因此開啟列表一旦為空，A*算法也就不用執行了。但是看過上一篇文章的朋友應該記得，我們用一個有全局作用域的變量openListCount（引用代碼內容用基佬紫色，下同）來記錄開啟列表里格子的個數，因此，這個判定就只是判定openListCount這個參數是否為0，這種判定很簡單，因此不用優化。

     （2）終點是否在關閉列表中。一旦終點在關閉列表之中，就說明我們已經找到了最優路徑，並且把路徑的最有一個格子——終點也進行了父節點標記的操作，這一操作之后，A*也不必繼續下去了。回顧上一篇文章，我們是在關閉列表中逐一匹配里面格子的坐標是否和終點坐標相等，這其實是很麻煩的方法。那么，怎么檢測終點是否在關閉列表中呢，這里有一個更好的思路：我們都知道起點是唯一一個G值為0的格子（起點距離自己的距離為0），相應的，終點也是唯一一個H值為0的格子。在求曼哈頓距離時，如果發現一個格子的H值為0，那么毫無疑問，這個格子就是終點。我們可以用一個標記（類似process_control.h里面的參數flag一樣）來使主循環停止而不用一一匹配新格子與關閉列表。

    （二）主循環分析完了，我們來看看迭代器進入循環體內部發生的事情。之后首先發生的事情，是一個查找操作，開啟列表中F值最小的（之一）會被找出來並設為當前格。然后是一個把當前格放入關閉列表的操作。先分析這兩步操作：

    （1）查找開啟列表中的最小值。之前這一步操作中我們用的是冒泡排序的一層循環，把它們中最小的數（之一）沉到底，但是這種查找方法顯然並不快，開啟列表是在稍后的迭代操作中一步一步建立起來的，因此我們每次把東西加入開啟列表可以按照最小二叉堆的添加操作做，這樣數組的最后一個元素自然就是開啟列表中最大的元素（之一）了。

    （2）往開啟列表中插入新的元素。開啟列表是最小二叉堆，因此插入元素要根據最小二叉堆的性質。

    （3）刪除開啟列表中最小的元素。開啟列表是最小二叉堆，因此刪除元素要根據最小二叉堆的性質。

    （4）刪除開啟列表中指定的元素。開啟列表中元素的f值可能會隨着重新計算NewG的值而改變，因此我們會先刪除指定的元素。這個過程可以有很多種方式實現，這里，我的例子選擇完全重新排序開啟列表，其實不是很有效率。

    （5）把當前元素加入關閉列表，用方便查找的方式構建關閉列表使其易於查找。

    （6）搜索關閉列表，配合關閉列表結構提高效率。

     因此，我們可以總結出7條可以優化的操作（函數）：

     （1）void putInOpenList(struct baseNode inList),把一個元素插入開啟列表中。開啟列表主要是插入刪除，因此用最小二叉堆就好了，每次都出隊列最小的數字，改進后要求格子按照最小二叉堆的性質進行插入操作。

     （2）struct baseNode readTopOpenList()，取出開啟列表中最小的數字。改進后這個函數根據最小二叉堆的性質直接獲取列表頂部格子即可。

     （3）void putInCloseList(struct baseNode temp)，當前點加入到關閉列表中。關閉列表只有插入和搜索操作，為了方便檢索，可以按照二叉排序樹、AVL樹或者紅黑樹的性質做一個關閉列表的操作（然而我並不會紅黑樹，（逃（嗶站粉用於標記吐槽和沒什么卵用的內心獨白，下同），等我學完紅黑樹就回來補完這個~QwQ），這里，為了簡單（其實只是自己水平有限），做一個方便查找的普通排序列表配合折半查找好了。

     （4）void outOpenList(struct baseNode iter），把開啟列表中的當前節點刪除。既然開啟列表是最小二叉堆，刪除也要按照這個性質來。
     （5）void outopenlist2(struct baseNode iter), 重新排序最小二叉堆，並刪除指定的點。

     （6）int isInCloseList(struct baseNode temp)，查看指定的temp在不在關閉列表中的函數，用折半查找提高效率就好了。

     （7）int manhatten(int i, int j)，求曼哈頓函數的值，當值為零，趕緊立一個flag，讓主循環停止。

      OpenList和CloseList的存儲結構也隨着新設計的數據結構改變就好，明確了這些重點，剩下的活只要實現這些函數，然后把函數覆蓋原來的函數（位於func.h中）就好。

 

3.3 實現7條優化

      下面的內容就是這些函數的具體實現。

3.3.1 優化終點在不在關閉列表的判定

      首先，我們對比較簡單的（7）int manhatten(int i, int j)，進行改造如下：

//A*中的啟發式函數，用於求指定位置和終點之間的曼哈頓距離
int manhatten(int i, int j)
{
    int a= (abs(AsceneryList[1].node.i - i) + abs(AsceneryList[1].node.j - j));
    if (a==0)
    {
        FLAG = 1;
    }

    return a*10;
}

代碼3.3.1.1——改造后的manhatten

    這里，我們在data.h里定義一個全局變量，int FLAG=0;,這個FLAG初值為0，每當Astar執行中發現某個格子曼哈頓距離為0,相應地，就把這個FLAG的值改為1，然后Astar內最外層for循環判定條件發現FLAG等於1，就意味着終點已經在關閉列表內，可以松口氣了（以前是遍歷關閉列表找終點在不在里面，這顯然是一步優化）。但是相應地，改變Astar最外層for語句為for (;  openListCount != 0 && FLAG==0;)。

    同時別忘了每次執行Astar前都重置FLAG值為1，只需在Astar函數內開始加上一句FLAG=0;。

3.3.2 優化開啟列表

    函數（1）（2）（4）（5）都和開啟列表有關，分別對應着開啟列表的添加元素，最小值出隊列，刪除元素和搜索，我們這里再處理他們，改為下面這樣的函數：

//把一個元素插入開啟列表中/////////
void putInOpenList(struct baseNode inList)
{
    ++openListCount;

    OpenList[openListCount - 1] = inList;
    for (int i = openListCount - 1; i >0; i=(i-1)/2)
    {
        if (OpenList[i].f<OpenList[(i-1)/2].f)
        {
            OpenList[i]=OpenList[(i - 1) / 2];
            OpenList[(i - 1) / 2] = inList;
        }
        else
        {
            break;
        }
    }
}

//取出開啟列表中最小的數
struct baseNode readTopOpenList()
{
    return OpenList[0];
}

//把開啟列表中的當前節點刪除
void outOpenList()
{
    --openListCount;

    OpenList[0]=OpenList[openListCount];
    struct baseNode temp;

    for (int i = 0,p=0; 2*i+1<openListCount;i=p)
    {
        if (2*i+2>openListCount-1)
        {
            p = 2 * i + 1;
        }
        else
        {
            if (OpenList[2 * i + 1].f<OpenList[2 * i + 2].f)
            {
                p = 2 * i + 1;
            }
            else
            {
                p = 2 * i + 2;
            }
        }

        if (OpenList[p].f<OpenList[i].f)
        {
            temp=OpenList[p];
            OpenList[p]=OpenList[i];
            OpenList[i] = temp;
        }
        else
        {
            break;
        }
    }
}

//刪除開啟列表中指定的元素，重構最小二叉堆
//（注：這個可以用很多方法實現，示例並非最優）
void outOpenList2(struct baseNode iter)
{
    int number=openListCount-1;
    struct baseNode openlist2[MAX_number*MAX_number];
    for (int i = 0; i < openListCount; ++i)
    {
        if (OpenList[i].i==iter.i&&OpenList[i].j==iter.j)
        {
            continue;
        }
        openlist2[i]=OpenList[i];
    }

    openListCount = 0;
    for (int i = 0; i < number; ++i)
    {
        putInOpenList(openlist2[i]);
    }
}

代碼3.2.2.1——優化開啟列表

 3.3.3 優化關閉列表

       關閉列表中的元素是只進不出的，因此這里用簡單的排序+折半查找優化效率，注意：對於關閉列表中的排序，應該用唯一值做key方便折半查找，這里，唯一key被設置成為格子的i坐標乘地圖邊的最大值加上格子的j坐標：

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

    struct baseNode iter;
    for (int i = closeListCount; i>0; --i)
    {
        if ((CloseList[i].i*MAX_number+CloseList[i].j+1)<(CloseList[i-1].i*MAX_number + CloseList[i-1].j + 1))
        {
            iter = CloseList[i];
            CloseList[i]=CloseList[i - 1];
            CloseList[i - 1] = iter;
        }
        else
        {
            break;
        }
    }
    ++closeListCount;
}

//查看指定的temp在不在關閉列表中的函數
int isInCloseList(struct baseNode temp)
{
    int low = 0, high = closeListCount - 1, mid = (low + high) / 2;

    for (; low<=high; mid = (low + high) / 2)
    {
        if ((CloseList[mid].i*MAX_number + CloseList[mid].j + 1)==(temp.i*MAX_number + temp.j + 1))
        {
            return 1;
        }
        else if((CloseList[mid].i*MAX_number + CloseList[mid].j + 1) > (temp.i*MAX_number + temp.j + 1))
        {
            high = mid - 1;
        }
        else
        {
            low = mid + 1;
        }
    }
    return 0;
}

代碼3.3.3.1——優化關閉列表

      這里要說明一下思路，我們為了使關閉列表方便查找，使用了插入新元素時排序關閉列表的方式，排序依賴的值應該類似主碼，是格子唯一的標記，格子存儲在二維數組中，唯一標記顯然是格子的坐標，不過坐標是兩個值，我們不想弄一個結構體儲存格子的key，所以就采用哈希表的思路把格子的橫縱坐標轉換為一個唯一值，那就是一個格子在二維列表的次序（這個格子在二維列表中是第幾個格子）。

3.3 回顧

      這樣所有的函數就優化完了，這組優化只改動了func.h和data.h，現在我們把改進后的這兩個文件重新貼在下方（默認折疊），如果大家在自己按照這種思路寫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[20];
};

//鄰居列表，用於記錄每個當前點的所有鄰居
struct baseNode Neibo[8];

//記錄景點，起點和終點的數組
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 = 2;

//用於記錄開啟列表中元素的個數
int openListCount = 0;

//用於記錄關閉列表中元素的個數
int closeListCount = 0;

//用於記錄鄰居的個數
int neibNum = 0;

//用來儲存整理后的路徑
struct baseNode Astack[MAX_number*MAX_number];

//用來記錄路徑經過的點的個數
int AstackCount = 0;

//用於記錄關閉列表里是否有終點
int FLAG = 0;

 

#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 = 0; i <MAX_number; ++i)
    {
        for (int j = 0; 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+1,MAX_number);
    }
}

//設定校園景點的函數
void setView()
{
    for (; ; )
    {
        int inputI = 0;
        int inputJ = 0;
        char inputS[20];

        printf("請輸入景點的名稱，輸入done結束景點錄入\n");
        scanf("%s", inputS);

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

            printf("地圖坐標從【1，1】開始\n");
            printf("請輸入景點的橫坐標:\n");
            scanf("%d", &inputI);
            AsceneryList[sceneryCount].node.i = inputI-1;

            printf("請輸入景點的縱坐標:\n");
            scanf("%d", &inputJ);
            AsceneryList[sceneryCount].node.j = inputJ-1;

            printf("成功輸入一個景點:\n");
            ++sceneryCount;
        }
    }
}

//設定起點和終點的函數
void setRoad()
{
    printf("你可以進行以下操作\n");
    printf("1.尋找一個景點\n");
    printf("2.手動設定起點終點坐標\n");

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

    if (user_input==1)
    {
        int i = 2;

        char inputS[20];
        printf("請輸入想查找的景點的名稱:\n這個景點將作為起點\n");
        scanf("%s", inputS);

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

                i = 0;
                printf("成功把%s設置為起點\n",inputS);
                break;
            }
        }
        if (i != 0)
        {
            printf("找不到這個景點\n");
        }

        int j = 2;

        char inputM[20];
        printf("請輸入想查找的景點的名稱:\n這個景點將作為終點\n");
        scanf("%s", inputM);

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

                j = 0;
                printf("成功把%s設置為終點\n",inputM);
                break;
            }
        }
        if (j!=0)
        {
            printf("找不到這個景點\n");
        }
    }
    else if(user_input==2)
    {
        int i = 0, j = 0, p = 0, q = 0;

        printf("地圖坐標從【1，1】開始\n");
        printf("請輸入起點的橫坐標:\n");
        scanf("%d", &i);
        printf("請輸入起點的縱坐標:\n");
        scanf("%d", &j);

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

        printf("請輸入終點的橫坐標:\n");
        scanf("%d", &p);
        printf("請輸入終點的縱坐標:\n");
        scanf("%d", &q);

        AsceneryList[1].node.i = p - 1;
        AsceneryList[1].node.j = q - 1;
    }
    else
    {
        printf("輸入錯誤\n");
    }
}

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

//把一個元素插入開啟列表中，使開啟列表符合最小二叉堆的性質/////////
void putInOpenList(struct baseNode inList)
{
    ++openListCount;

    OpenList[openListCount - 1] = inList;
    for (int i = openListCount - 1; i >0; i=(i-1)/2)
    {
        if (OpenList[i].f<OpenList[(i-1)/2].f)
        {
            OpenList[i]=OpenList[(i - 1) / 2];
            OpenList[(i - 1) / 2] = inList;
        }
        else
        {
            break;
        }
    }
}

//取出開啟列表（最小二叉堆）中最小的數
struct baseNode readTopOpenList()
{
    return OpenList[0];
}

//把一個元素加入關閉列表中，使關閉列表有序
void putInCloseList(struct baseNode temp)
{
    CloseList[closeListCount] = temp;

    struct baseNode iter;
    for (int i = closeListCount; i>0; --i)
    {
        if ((CloseList[i].i*MAX_number+CloseList[i].j+1)<(CloseList[i-1].i*MAX_number + CloseList[i-1].j + 1))
        {
            iter = CloseList[i];
            CloseList[i]=CloseList[i - 1];
            CloseList[i - 1] = iter;
        }
        else
        {
            break;
        }
    }
    ++closeListCount;
}

//把開啟列表中的當前節點刪除，使其符合最小二叉堆的性質
void outOpenList()
{
    --openListCount;

    OpenList[0]=OpenList[openListCount];
    struct baseNode temp;

    for (int i = 0,p=0; 2*i+1<openListCount;i=p)
    {
        if (2*i+2>openListCount-1)
        {
            p = 2 * i + 1;
        }
        else
        {
            if (OpenList[2 * i + 1].f<OpenList[2 * i + 2].f)
            {
                p = 2 * i + 1;
            }
            else
            {
                p = 2 * i + 2;
            }
        }

        if (OpenList[p].f<OpenList[i].f)
        {
            temp=OpenList[p];
            OpenList[p]=OpenList[i];
            OpenList[i] = temp;
        }
        else
        {
            break;
        }
    }
}

//刪除開啟列表中指定的元素，重構最小二叉堆
//（注：這個可以用很多方法實現，示例並非最優）
void outOpenList2(struct baseNode iter)
{
    int number=openListCount-1;
    struct baseNode openlist2[MAX_number*MAX_number];
    for (int i = 0; i < openListCount; ++i)
    {
        if (OpenList[i].i==iter.i&&OpenList[i].j==iter.j)
        {
            continue;
        }
        openlist2[i]=OpenList[i];
    }

    openListCount = 0;
    for (int i = 0; i < number; ++i)
    {
        putInOpenList(openlist2[i]);
    }
}

//對於一路上的每個點，分析它的最多八個鄰居，並加入鄰居列表
void addNeibo(struct baseNode iter)
{
    neibNum = 0;

    for (int i = iter.i - 1; i <= iter.i + 1; ++i)
    {
        for (int j = iter.j - 1; j <= iter.j + 1; ++j)
        {
            if (i >= 0 && i <= MAX_number - 1 && j >= 0 && j <= MAX_number - 1)
            {
                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 = 0; i < openListCount - 1; ++i)
    {
        if (OpenList[i].i == neibo.i&&OpenList[i].j == neibo.j)
        {
            return 1;
        }
    }
    return 0;
}

//查看指定的temp在不在關閉列表中的函數，使用了折半查找
int isInCloseList(struct baseNode temp)
{
    int low = 0, high = closeListCount - 1, mid = (low + high) / 2;

    for (; low<=high; mid = (low + high) / 2)
    {
        if ((CloseList[mid].i*MAX_number + CloseList[mid].j + 1)==(temp.i*MAX_number + temp.j + 1))
        {
            return 1;
        }
        else if((CloseList[mid].i*MAX_number + CloseList[mid].j + 1) > (temp.i*MAX_number + temp.j + 1))
        {
            high = mid - 1;
        }
        else
        {
            low = mid + 1;
        }
    }
    return 0;
}

//A*中的啟發式函數，用於求指定位置和終點之間的曼哈頓距離
int manhatten(int i, int j)
{
    int a= (abs(AsceneryList[1].node.i - i) + abs(AsceneryList[1].node.j - j));
    if (a==0)
    {
        FLAG = 1;
    }

    return a*10;
}

//求當前點與父親節點的距離
int increment(struct baseNode this)
{
    if ((abs(this.father->i-this.i)==1) && (abs(this.father->j - this.j) == 1))
    {
        return 14*this.weigt;
    }
    else if ((this.father->i - this.i) == 0 && (this.father->j - this.j) == 0)
    {
        return 0;
    }
    else
    {
        return 10*this.weigt;
    }
}

//求出用當前點作為父節點時這個點的G值
int NewG(struct baseNode this,struct baseNode father)
{
    if (abs(father.i - this.i) == 1 && abs(father.j - this.j) == 1)
    {
        return father.g+14;
    }
    else if (abs(father.i - this.i) == 0 && abs(father.j - this.j) == 0)
    {
        return father.g;
    }
    else
    {
        return father.g+10;
    }
}

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

//打印出A*算法的路徑矩陣
printAstar()
{
    printf("A為最佳路徑，Q為不經過區域\n\n");
    int boole = 0;

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

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

//Astar的本體
void Astar()
{
    //FLAG用於判斷終點是否在關閉列表
    FLAG=0;
    //每次執行A*算法，都初始化開啟/關閉列表
    openListCount = 0;
    closeListCount = 0;

    //創建一個迭代器,每次都等於f值最小的節點
    struct baseNode iter;

    //讓這個迭代器的初值為起點
    iter.i = AsceneryList[0].node.i;
    iter.j = AsceneryList[0].node.j;
    iter.weigt = map[AsceneryList[0].node.i][AsceneryList[0].node.j].weigt;

    //起點的沒有父節點，且為唯一G值為0的點
    iter.g = 0;
    iter.h = manhatten(iter.i,iter.j);
    iter.f = iter.g + iter.h;

    //創建終點
    struct baseNode ender;

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

    //把起點放入開啟列表
    putInOpenList(iter);

    //當開啟列表為空或者終點在關閉列表中，結束尋徑
    for (;  openListCount != 0 && FLAG==0;)
    {
        //取出開啟列表中f值最小的節點（之一），並設為iter（當前點）
        iter = readTopOpenList();

        //把最小點從開啟列表中刪除
        outOpenList();

        //把當前點記錄在關閉列表中
        putInCloseList(iter);

        //把當前點的鄰居加入鄰居列表
        addNeibo(iter);

        //對於每個鄰居，分三種情況進行操作
        for (int i = 0; i < neibNum; ++i)
        {
            //如果這個鄰居節點不可通過，或者這個鄰居節點在關閉列表中，略過它
            if (Neibo[i].weigt==0 || 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;

                    outOpenList2(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();
}

  在下一章里，我們將嘗試用其他的方式存儲地圖並且用新的方式寫啟發函數，敬請期待。