A*寻路算法

一、算法思路：
1、两个集合：openList和closeList
openList：存放每走一步后可能的搜索节点集合。
closeList：存放已经走过的节点的集合。

2、估值函数：F = G + H
F：起始节点startNode到终止节点endNode的距离
G：起始节点startNode到当前节点的距离
H：当前节点到终止节点endNode的距离

初始条件现将startNode加入openList中
进入while主循环：
1）、以checkedNode节点为中心，分别从上下左右四个方向搜寻剩余可达的节点，如果能够搜寻到，则加入openList，同时将该搜寻到的节点标记为不可达（isOpen置为false）
2）、从openList中的所有节点中选出一个F值最小的节点（这样的节点很可能不止一个，但是这些同时获得最小F的节点都会被“走到”），这个节点将被标记为checkedNode，将checkedNode移除openList，加入closeList，至此一轮循环完毕，进入下一轮循环。
3）、直到checkedNode等于endNode，循环结束。

为方便获取路径，在第一步以checkedNode为中心搜寻剩余可达节点时，新加入openList的节点都为checkedNode的子节点。
nextNode.parent = checkedNode;

不难发现，openList和closeList中节点的父子关系共同构成了一颗搜索树。

例如
int row = 5,column = 7;
Node startNode = data[2][1];
Node endNode = data[0][2];

在不设置任何障碍的情况下，其搜索树为：

当算法结束之后，不难发现：

1、所有openList中的节点都是叶节点，所有closeList中的节点有孩子，除了endNode外其余均为非叶节点。
2、每轮搜寻都是从当前的搜索树中的叶节点中展开搜索的。
3、沿着endNode逐渐往上同过parent属性，可以获得一条最短路径。当然这唯一的最短路径。
4、最终路径中所有节点的F值均相等等于搜索树中所有节点的F值的最小值（本例minF为3）。

二、java代码实现

package agstring;

import java.util.ArrayList;
import java.util.*;
class Node{
    public final int x,y;
    public final double weight;
    public boolean isOpen = true;
    public Node parent;
    public int varF = 0,varG = 0,varH = 0;
    public Node(int x,int y,double weight){
        this.x = x;
        this.y = y;
        this.weight = weight;
    }
    public Node(int x,int y){
        this(x, y, 0.0);
    }
    public String toString(){
        return "("+"x:"+this.x+","+"y:"+this.y+","+"w:"+this.weight+")";
    }
}
public class AStar {
    
    public static Node[][] initData(int row,int column){
        Node[][] tableOf2D = new Node[row][column];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < column; j++) {
                tableOf2D[i][j] = new Node(i,j);
            }
        }
        return tableOf2D;
    }
    private static int getDistance(Node startNode,Node endNode){
        return Math.abs(endNode.x - startNode.x) + Math.abs(endNode.y - startNode.y);
    }
    
    private  static void updateFGH(Node node,Node startNode,Node endNode){
        node.varG = getDistance(startNode, node);
        node.varH = getDistance(node, endNode);
        node.varF = node.varG + node.varH;
    }
    
    public static Node[] AStarAlgo(Node[][] tableOf2D,Node startNode,Node endNode){
        int row = tableOf2D.length,column = tableOf2D[0].length;
        ArrayList<Node> openList = new ArrayList<Node>();
        ArrayList<Node> closeList = new ArrayList<Node>();
        Node nextNode,checkedNode = startNode;
        int minF;
        closeList.add(startNode);
        startNode.isOpen = false;
        while(!checkedNode.equals(endNode)){//!checkedNode.equals(endNode)
            if (checkedNode.y-1 >= 0 && tableOf2D[checkedNode.x][checkedNode.y-1].isOpen ) {
                nextNode = tableOf2D[checkedNode.x][checkedNode.y-1];
                nextNode.parent = checkedNode;
                openList.add(nextNode);
                updateFGH(nextNode,startNode,endNode);
                nextNode.isOpen = false;
            }
            if (checkedNode.y+1 <= column-1 && tableOf2D[checkedNode.x][checkedNode.y+1].isOpen ) {
                nextNode = tableOf2D[checkedNode.x][checkedNode.y+1];
                nextNode.parent = checkedNode;
                openList.add(nextNode);
                updateFGH(nextNode,startNode,endNode);
                nextNode.isOpen = false;
            }
            if (checkedNode.x-1 >= 0 && tableOf2D[checkedNode.x-1][checkedNode.y].isOpen ) {
                nextNode = tableOf2D[checkedNode.x-1][checkedNode.y];
                nextNode.parent = checkedNode;
                openList.add(nextNode);
                updateFGH(nextNode,startNode,endNode);
                nextNode.isOpen = false;
            }
            if (checkedNode.x+1 <= row-1 && tableOf2D[checkedNode.x+1][checkedNode.y].isOpen ) {
                nextNode = tableOf2D[checkedNode.x+1][checkedNode.y];
                nextNode.parent = checkedNode;
                openList.add(nextNode);
                updateFGH(nextNode,startNode,endNode);
                nextNode.isOpen = false;
            }
            
            minF = Integer.MAX_VALUE;
            for (int i = 0; i < openList.size(); i++) {
                if (openList.get(i).varF < minF) {
                    checkedNode = openList.get(i);
                    minF = checkedNode.varF;
                }
            }
            closeList.add(checkedNode);
            openList.remove(checkedNode);

        }
        return closeList.toArray(new Node[closeList.size()]);
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            int row = 5,column = 7;
            Node[][] data = initData(row, column);
//            for (int i = 0; i < row ; i++) {
//                for (int j = 0; j < column; j++) {
//                    System.out.println(data[i][j]);
//                }
//            }
//            data[1][3].isOpen = data[2][3].isOpen = data[3][3].isOpen = data[4][3].isOpen = false;
//            data[0][5].isOpen = data[1][5].isOpen = data[2][5].isOpen = data[3][5].isOpen = false;
            Node startNode = data[2][1];
            Node endNode = data[0][2];
            Node[] pathAry = AStarAlgo(data,startNode,endNode);

            Node tmpNode = endNode;
            while(!(tmpNode == null)){
                System.out.println(tmpNode);
                tmpNode = tmpNode.parent;
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }

}