Java中的A*(A star)寻径实现

据我个人所知，目前流行的寻径方法大体有两种，即A* 和Dijkstra（SP算法）

Dijkstra算法：

   
  
    由Edsger Wybe Dijkstra先生发明（已故）
    Dijkstra算法是典型的最短路算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低。Dijkstra算法是一种逐步搜索算法，通过为每个顶点n保留目前为止所找到的从m到n的最短路径来工作的。

    搜索过程：
   假如在第m步搜索到一个最短路径，而该路径上有n个距离源节点最近的节点，则将他们认为是一个节点集合N；在第m+1步，搜索不属于N的距离源节点最近的节点，并搜索到的节点加入到N中；继续搜索，直至到达目的节点，N中的节点集合便是从源节点到目的节点的最短路径。

    算法描述：

    Dijkstra算法是通过为每个顶点v保留目前为止所找到的从s到v的最短路径来工作的。初始时，源点s的路径长度值被赋为0（d[s]=0）， 同时把所有其他顶点的路径长度设为无穷大，即表示我们不知道任何通向这些顶点的路径（对于V中所有顶点v除s外d[v]= ∞）。当算法结束时，d[v]中储存的便是从s到v的最短路径，或者如果路径不存在的话是无穷大。 Dijstra算法的基础操作是边的拓展：如果存在一条从u到v的边，那么从s到u的最短路径可以通过将边(u,v)添加到尾部来拓展一条从s到v的路径。这条路径的长度是d[u]+w(u,v)。如果这个值比目前已知的d[v]的值要小，我们可以用新值来替代当前d[v]中的值。拓展边的操作一直执行到所有的d[v]都代表从s到v最短路径的花费。这个算法经过组织因而当d[u]达到它最终的值的时候没条边(u,v)都只被拓展一次。算法维护两个顶点集S和Q。集合S保留了我们已知的所有d[v]的值已经是最短路径的值顶点，而集合Q则保留其他所有顶点。集合S 初始状态为空，而后每一步都有一个顶点从Q移动到S。这个被选择的顶点是Q中拥有最小的d[u]值的顶点。当一个顶点u从Q中转移到了S中，算法对每条外接边(u,v)进行拓展。

A*（A Star）算法：

  

    A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。
    公式表示为：f(n)=g(n)+h(n), 其中f(n) 是节点n从初始点到目标点的估价函数，g(n) 是在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。

     搜索过程：
    
     创建两个表，OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。遍历当前节点的各个节点，将n节点放入CLOSE中，取n节点的子节点X,->算X的估价值.

        While(OPEN!=NULL)
        {
        从OPEN表中取估价值f最小的节点n;
        if(n节点==目标节点) break;
        else
        {
        if(X in OPEN) 比较两个X的估价值f //注意是同一个节点的两个不同路径的估价值
        if( X的估价值小于OPEN表的估价值 )
        　　　更新OPEN表中的估价值; //取最小路径的估价值
        if(X in CLOSE) 比较两个X的估价值 //注意是同一个节点的两个不同路径的估价值
        if( X的估价值小于CLOSE表的估价值 )
        　　　更新CLOSE表中的估价值; 把X节点放入OPEN //取最小路径的估价值
        if(X not in both)
        求X的估价值;
        　　　并将X插入OPEN表中;　//还没有排序
        }
        将n节点插入CLOSE表中;
        按照估价值将OPEN表中的节点排序; //实际上是比较OPEN表内节点f的大小，从最小路径的节点向下进行。
        }


就实际应用而言，A*算法和Dijistra算法的最大区别就在于有无估价值，本质上Dijistra算法相当于A*算法中估价值为0的情况。所以此次我选取A*算法进行Java实现。

抛开理论性的数学概念，通常的A*算法，其实只有两个步骤，一是路径评估，以保证移动的下一个位置离目标最近，评估的结果越精确则寻径的效率也将越高。二是路径查询，也即将评估结果进行反应，而后从新位置再次进行评估指导无路可走为止，以此遍历出可行的路径。

在A*算法的程序实现中，本质上我们只需要关心三点，即起点、终点和地图信息，有了这三项基本数据，我们就可以构建任何情况下的A*实现。

下面我现在提供的是一个A*的Java静态寻径算法实现，逻辑见代码注释。

 运行效果如下图(1,1 to 10,13)：


(1,1 to 7,9 小房子门口中间)


(1,1 to 6,7 小房子内部)



Node.java

package  org.test.astar;

import  java.awt.Point;
import  java.util.LinkedList;

/** */ /**
 * <p>
 * Title: LoonFramework
 * </p>
 * <p>
 * Description:描述路径节点用类
 * </p>
 * <p>
 * Copyright: Copyright (c) 2008
 * </p>
 * <p>
 * Company: LoonFramework
 * </p>
 * <p>
 * License: http://www.apache.org/licenses/LICENSE-2.0
 * </p>
 * 
 * @author chenpeng
 * @email：ceponline@yahoo.com.cn
 * @version 0.1
 */
public   class  Node  implements  Comparable  ... {
    // 坐标
    public Point _pos;

    // 开始地点数值
    public int _costFromStart;

    // 目标地点数值
    public int _costToObject;

    // 父节点
    public Node _parentNode;

    private Node() ...{
    }

    /** *//**
     * 以注入坐标点方式初始化Node
     * 
     * @param _pos
     */
    public Node(Point _pos) ...{
        this._pos = _pos;
    }

    /** *//**
     * 返回路径成本
     * 
     * @param node
     * @return
     */
    public int getCost(Node node) ...{
        // 获得坐标点间差值 公式：(x1, y1)-(x2, y2)
        int m = node._pos.x - _pos.x;
        int n = node._pos.y - _pos.y;
        // 取两节点间欧几理德距离（直线距离）做为估价值，用以获得成本
        return (int) Math.sqrt(m * m + n * n);
    }

    /** *//**
     * 检查node对象是否和验证对象一致
     */
    public boolean equals(Object node) ...{
        // 验证坐标为判断依据
        if (_pos.x == ((Node) node)._pos.x && _pos.y == ((Node) node)._pos.y) ...{
            return true;
        }
        return false;
    }

    /** *//**
     * 比较两点以获得最小成本对象
     */
    public int compareTo(Object node) ...{
        int a1 = _costFromStart + _costToObject;
        int a2 = ((Node) node)._costFromStart + ((Node) node)._costToObject;
        if (a1 < a2) ...{
            return -1;
        } else if (a1 == a2) ...{
            return 0;
        } else ...{
            return 1;
        }
    }

    /** *//**
     * 获得上下左右各点间移动限制区域
     * 
     * @return
     */
    public LinkedList getLimit() ...{
        LinkedList limit = new LinkedList();
        int x = _pos.x;
        int y = _pos.y;
        // 上下左右各点间移动区域(对于斜视地图，可以开启注释的偏移部分，此时将评估8个方位)
        // 上
        limit.add(new Node(new Point(x, y - 1)));
        // 右上
        // limit.add(new Node(new Point(x+1, y-1)));
        // 右