如果你是一個遊戲開發者，或者開發過一些關於人工智慧的遊戲，你一定知道A*演算法，如果沒有接觸過此類的東東，那麼看了這一篇文章，你會對A*演算法從不知道變得了解，從瞭解變得理解。
我不是一個純粹的遊戲開發者，我只是因為喜歡而研究，因為興趣而開發，從一些很小的遊戲開始，直到接觸到了尋路等人工智慧，才開始查詢一些關於尋路方面的文章，從而知道了A*演算法，因為對於初期瞭解的我這個演算法比較複雜，開始只是copy而已，現在我們一起來精密的研究一下A*演算法，以及提高它的速度的方法。

一，A*演算法原理

我看過Panic翻譯的國外高手Patrick Lester的一篇關於A*演算法初探的文章，現在我就根據回憶，來慢慢認識A*演算法的原理。
我們先來看一張圖

圖中從起點到終點，需要繞過一些遮擋，也許我們看的比較簡單，但是實際上，交給電腦來實現卻要經過一番周折，電腦如何知道哪裡有遮擋物，又是如何找到從起點到終點的最短路徑的呢？
瞭解這些，我們首先要知道一個公式：
F = G + H
其中，F 是從起點經過該點到終點的總路程，G 為起點到該點的“已走路程”，H 為該點到終點的“預計路程”。
A*演算法，要從起點開始，按照它的演算法，逐步查詢，直到找到終點。
初期，地圖上的節點都是未開啟也未關閉的初始狀態，我們每檢測一個節點，就要開啟一些節點，檢測完之後，要把檢測完的節點，就要把它關閉。
我們需要一個開啟列表和關閉列表，用來儲存已經被開啟的節點和被關閉的節點。
這些就讓我們在實際過程中來深入瞭解吧。
看下面的圖

首先，我們來從起點出發，開啟它周圍的所有點，因為遮擋是無法通過的，我們不去管它，這樣，被我們開啟的節點，就是圖中的三個節點，它們的父節點就是起點，所以圖中的箭頭指向起點，計算相應的FGH值，如圖所視，檢測完畢，將起點放入關閉列表。
這個時候，我們從被開啟的所有節點中查詢F值最小的節點，做為下一次檢測的節點，然後開啟它周圍的點。
這時候起點左方和下方的F值都是70，我們根據自己的喜好選擇任意一個，這裡先選擇下方的節點進行檢測。
如下圖

首先把未被開啟的剩下的節點的父節點指向檢測點。
已經開啟的點，我們不去開啟第二遍，但是我們計算一下從檢測點到達它們的新的G值是否更小，如果更小則代表目前的路徑是最優的路徑，那麼把這個節點的父節點改為目前的檢測點，並重新計算這個點的FGH的值，全部檢測完畢之後，關閉檢測點，然後開始尋找下一個節點，如此迴圈，直到找到終點。
然後從終點開始，按照每個節點的父節點，倒著畫出路徑，如下圖

這個就是A*演算法的原理，說難倒是不難，但是對於初步接觸的人來說有點費勁而已。

二，A*演算法的速度

前面，我們瞭解了A*演算法的原理，發現，在每次查詢最小節點的時候，我們需要在開啟列表中查詢F值最小的節點，研究A*的速度，這裡就是關鍵，如何更快的找出這個最小節點呢？

1，普通查詢演算法

我們先來看看，最簡單的做法，就是每次都把開啟列表中所有節點檢測一遍，從而找到最小節點

private function getMin():uint { var len:uint = _open.length; var min:Object = new Object(); min.value_f = 100000; min.i = 0; for (var i:uint = 0; i<len; i++) { if (min.value_f>_open[i].value_f) { min.value_f = _open[i].value_f; min.i = i; } } return min.i; }

這裡我用了一張很簡單的地圖來驗證此方法
執行結果如圖

我們看到，耗時38毫秒，其實這個數字是不準確的，我們權且當作參考

2，排序查詢演算法

顧名思義，這個演算法就是，始終維持開啟列表的排序，從小到大，或者從大到小，這樣當我們查詢最小值時，只需要把第一個節點取出來就行了
維持列表的排序，方法是在太多了，我的方法也許很笨，勉強參考一下吧，我們每次排序的同時，順便計算列表中的平均值，這樣插入新節點的時候，根據這個平均值來判斷從前面開始判斷還是從後面開始判斷

//加入開放列表 private function setOpen(newNode:Object):void { newNode.open = true; var __len:int = _open.length; if (__len==0) { _open.push(newNode); _aveOpen = newNode.value_f; }else { //和F平均值做比較，決定從前面或者後面開始判斷 if (newNode.value_f<=_aveOpen) { for (var i:int=0; i<__len; i++) { //找到比F值小的值，就插在此值之前 if (newNode.value_f<=_open[i].value_f) { _open.splice(i, 0, newNode); break; } } } else { for (var j:int=__len; j>0; j--) { //找到比F值大的值，就插在此值之前 if (newNode.value_f>=_open[(j-1)].value_f) { _open.splice(j, 0, newNode); break; } } } //計算開放列表中F平均值 _aveOpen += (newNode.value_f-_aveOpen)/_open.length; } } //取開放列表裡的最小值 private function getOpen():Object { var __next:Object = _open.splice(0,1)[0]; //計算開放列表中F平均值 _aveOpen += (_aveOpen-__next.value_f)/_open.length; return __next; }

執行結果如圖

我們看到，耗時25毫秒，這個數字雖然不準確的，但是與普通查詢演算法相比較，速度確實是提高了

3，二叉樹查詢演算法
(參考了火夜風舞的C++新霖花園中的文章)
這個演算法可以說是A*演算法的黃金搭檔，也是被稱為苛求速度的binary heap”的方法
就是根據二叉樹原理，來維持開啟列表的“排序”，這裡說的排序只是遵循二叉樹的原理的排序而已，即父節點永遠比子節點小,就像下面這樣
   1
|    |
5    9
|   |  |
7  12 10
二叉樹每個節點的父節點下標 = n / 2;(小數去掉)
二叉樹每個節點的左子節點下標 = n * 2;右子節點下標 = n * 2 +1
注意，這裡的下標和它的值是兩個概念

//加入開放列表 private function setOpen(newNode:Object,newFlg:Boolean = false):void { var new_index:int; if(newFlg){ newNode.open = true; var new_f:int = newNode.value_f; _open.push(newNode); new_index = _open.length - 1; }else{ new_index = newNode.index; } while(true){ //找到父節點 var f_note_index:int = new_index/2; if(f_note_index > 0){ //如果父節點的F值較大，則與父節點交換 if(_open[new_index].value_f < _open[f_note_index].value_f){ var obj_note:Object = _open[f_note_index]; _open[f_note_index] = _open[new_index]; _open[new_index] = obj_note; _open[f_note_index].index = f_note_index; _open[new_index].index = new_index; new_index = f_note_index; }else{ break; } }else{ break; } } } //取開放列表裡的最小值 private function getOpen():Object { if(_open.length <= 1){ return null; } var change_note:Object; //將第一個節點，即F值最小的節點取出，最後返回 var obj_note:Object = _open[1]; _open[1] = _open[_open.length - 1]; _open.pop(); _open[1].index = 1; var this_index:int = 1; while(true){ var left_index:int = this_index * 2; var right_index:int = this_index * 2 + 1; if(left_index >= _open.length){ break; }else if(left_index == _open.length - 1){ //當二叉樹只存在左節點時，比較左節點和父節點的F值，若父節點較大，則交換 if(_open[this_index].value_f > _open[left_index].value_f){ change_note = _open[left_index]; _open[left_index] = _open[this_index]; _open[this_index] = change_note; _open[left_index].index = left_index; _open[this_index].index = this_index; this_index = left_index; }else{ break; } }else if(right_index < _open.length){ //找到左節點和右節點中的較小者 if(_open[left_index].value_f <= _open[right_index].value_f){ //比較左節點和父節點的F值，若父節點較大，則交換 if(_open[this_index].value_f > _open[left_index].value_f){ change_note = _open[left_index]; _open[left_index] = _open[this_index]; _open[this_index] = change_note; _open[left_index].index = left_index; _open[this_index].index = this_index; this_index = left_index; }else{ break; } }else{ //比較右節點和父節點的F值，若父節點較大，則交換 if(_open[this_index].value_f > _open[right_index].value_f){ change_note = _open[right_index]; _open[right_index] = _open[this_index]; _open[this_index] = change_note; _open[right_index].index = right_index; _open[this_index].index = this_index; this_index = right_index; }else{ break; } } } } return obj_note; }

執行結果如圖

我們看到，耗時15毫秒，速度是這三個方法裡最快的，但是因為這個數字是不夠準確的，實際上，用二叉樹查詢法，會讓A*演算法的速度提高几倍到10幾倍，在一些足夠複雜的地圖裡，這個速度是成指數成長的。

4，總結
得出結論，用了A*演算法，就要配套的用它的黃金搭檔，二叉樹，它可以讓你的遊戲由完美走向更完美。