Java版A星算法

A星算法步骤：
 1.起点先添加到开启列表中
 2.开启列表中有节点的话，取出第一个节点，即最小F值的节点
   判断此节点是否是目标点，是则找到了，跳出
   根据此节点取得八个方向的节点，求出G，H，F值
   判断每个节点在地图中是否能通过，不能通过则加入关闭列表中，跳出
   判断每个节点是否在关闭列表中，在则跳出
   判断每个节点是否在开启列表中，在则更新G值，F值，还更新其父节点；不在则将其添加到开启列表中，计算G值，H值，F值，添加其节点
 3.把此节点从开启列表中删除，再添加到关闭列表中
 4.把开启列表中按照F值最小的节点进行排序，最小的F值在第一个
 5.重复2，3，4步骤
   直到目标点在开启列表中，即找到了；目标点不在开启列表中，开启列表为空，即没找到

 

//A*算法
public class AStar {
	private int[][] map;//地图(1可通过 0不可通过)
	private List<Node> openList;//开启列表
	private List<Node> closeList;//关闭列表
	private final int COST_STRAIGHT = 10;//垂直方向或水平方向移动的路径评分
	private final int COST_DIAGONAL = 14;//斜方向移动的路径评分
	private int row;//行
	private int column;//列
	
	public AStar(int[][] map,int row,int column){
		this.map=map;
		this.row=row;
		this.column=column;
		openList=new ArrayList<Node>();
		closeList=new ArrayList<Node>();
	}
	
	//查找坐标（-1：错误，0：没找到，1：找到了）
	public int search(int x1,int y1,int x2,int y2){
		if(x1<0||x1>=row||x2<0||x2>=row||y1<0||y1>=column||y2<0||y2>=column){
			return -1;
		}
		if(map[x1][y1]==0||map[x2][y2]==0){
			return -1;
		}
		Node sNode=new Node(x1,y1,null);
		Node eNode=new Node(x2,y2,null);
		openList.add(sNode);
		List<Node> resultList=search(sNode, eNode);
		if(resultList.size()==0){
			return 0;
		}
		for(Node node:resultList){
			map[node.getX()][node.getY()]=-1;
		}
		return 1;
	}
	
	//查找核心算法
	private List<Node> search(Node sNode,Node eNode){
		List<Node> resultList=new ArrayList<Node>();
		boolean isFind=false;
		Node node=null;
		while(openList.size()>0){
			//取出开启列表中最低F值，即第一个存储的值的F为最低的
			node=openList.get(0);
			//判断是否找到目标点
			if(node.getX()==eNode.getX()&&node.getY()==eNode.getY()){
				isFind=true;
				break;
			}
			//上
			if((node.getY()-1)>=0){
				checkPath(node.getX(),node.getY()-1,node, eNode, COST_STRAIGHT);
			}
			//下
			if((node.getY()+1)<column){
				checkPath(node.getX(),node.getY()+1,node, eNode, COST_STRAIGHT);
			}
			//左
			if((node.getX()-1)>=0){
				checkPath(node.getX()-1,node.getY(),node, eNode, COST_STRAIGHT);
			}
			//右
			if((node.getX()+1)<row){
				checkPath(node.getX()+1,node.getY(),node, eNode, COST_STRAIGHT);
			}
			//左上
			if((node.getX()-1)>=0&&(node.getY()-1)>=0){
				checkPath(node.getX()-1,node.getY()-1,node, eNode, COST_DIAGONAL);
			}
			//左下
			if((node.getX()-1)>=0&&(node.getY()+1)<column){
				checkPath(node.getX()-1,node.getY()+1,node, eNode, COST_DIAGONAL);
			}
			//右上
			if((node.getX()+1)<row&&(node.getY()-1)>=0){
				checkPath(node.getX()+1,node.getY()-1,node, eNode, COST_DIAGONAL);
			}
			//右下
			if((node.getX()+1)<row&&(node.getY()+1)<column){
				checkPath(node.getX()+1,node.getY()+1,node, eNode, COST_DIAGONAL);
			}
			//从开启列表中删除
			//添加到关闭列表中
			closeList.add(openList.remove(0));
			//开启列表中排序，把F值最低的放到最底端
			Collections.sort(openList, new NodeFComparator());
		}
		if(isFind){
			getPath(resultList, node);
		}
		return resultList;
	}
	
	//查询此路是否能走通
	private boolean checkPath(int x,int y,Node parentNode,Node eNode,int cost){
		Node node=new Node(x, y, parentNode);
		//查找地图中是否能通过
		if(map[x][y]==0){
			closeList.add(node);
			return false;
		}
		//查找关闭列表中是否存在
		if(isListContains(closeList, x, y)!=-1){
			return false;
		}
		//查找开启列表中是否存在
		int index=-1;
		if((index=isListContains(openList, x, y))!=-1){
			//G值是否更小，即是否更新G，F值
			if((parentNode.getG()+cost)<openList.get(index).getG()){
				node.setParentNode(parentNode);
				countG(node, eNode, cost);
				countF(node);
				openList.set(index, node);
			}
		}else{
			//添加到开启列表中
			node.setParentNode(parentNode);
			count(node, eNode, cost);
			openList.add(node);
		}
		return true;
	}
	
	//集合中是否包含某个元素(-1：没有找到，否则返回所在的索引)
	private int isListContains(List<Node> list,int x,int y){
		for(int i=0;i<list.size();i++){
			Node node=list.get(i);
			if(node.getX()==x&&node.getY()==y){
				return i;
			}
		}
		return -1;
	}
	
	//从终点往返回到起点
	private void getPath(List<Node> resultList,Node node){
		if(node.getParentNode()!=null){
			getPath(resultList, node.getParentNode());
		}
		resultList.add(node);
	}
	
	//计算G,H,F值
	private void count(Node node,Node eNode,int cost){
		countG(node, eNode, cost);
		countH(node, eNode);
		countF(eNode);
	}
	//计算G值
	private void countG(Node node,Node eNode,int cost){
		if(node.getParentNode()==null){
			node.setG(cost);
		}else{
			node.setG(node.getParentNode().getG()+cost);
		}
	}
	//计算H值
	private void countH(Node node,Node eNode){
		node.setF(Math.abs(node.getX()-eNode.getX())+Math.abs(node.getY()-eNode.getY()));
	}
	//计算F值
	private void countF(Node node){
		node.setF(node.getG()+node.getF());
	}
	
}
//节点类
class Node {
	private int x;//X坐标
	private int y;//Y坐标
	private Node parentNode;//父类节点
	private int g;//当前点到起点的移动耗费
	private int h;//当前点到终点的移动耗费，即曼哈顿距离|x1-x2|+|y1-y2|(忽略障碍物)
	private int f;//f=g+h
	
	public Node(int x,int y,Node parentNode){
		this.x=x;
		this.y=y;
		this.parentNode=parentNode;
	}
	
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	public Node getParentNode() {
		return parentNode;
	}
	public void setParentNode(Node parentNode) {
		this.parentNode = parentNode;
	}
	public int getG() {
		return g;
	}
	public void setG(int g) {
		this.g = g;
	}
	public int getH() {
		return h;
	}
	public void setH(int h) {
		this.h = h;
	}
	public int getF() {
		return f;
	}
	public void setF(int f) {
		this.f = f;
	}
}
//节点比较类
class NodeFComparator implements Comparator<Node>{

	@Override
	public int compare(Node o1, Node o2) {
		return o1.getF()-o2.getF();
	}
	
}

测试类：

public class Test {
	
	public static void main(String[] args){
		int[][] map=new int[][]{// 地图数组
				{1,1,1,1,1,1,1,1,1,1},
				{1,1,1,1,0,1,1,1,1,1},
				{1,1,1,1,0,1,1,1,1,1},
				{1,1,1,1,0,1,1,1,1,1},
				{1,1,1,1,0,1,1,1,1,1},
				{1,1,1,1,0,1,1,1,1,1}
		};
		AStar aStar=new AStar(map, 6, 10);
		int flag=aStar.search(4, 0, 3, 8);
		if(flag==-1){
			System.out.println("传输数据有误！");
		}else if(flag==0){
			System.out.println("没找到！");
		}else{
			for(int x=0;x<6;x++){
				for(int y=0;y<10;y++){
					if(map[x][y]==1){
						System.out.print("　");
					}else if(map[x][y]==0){
						System.out.print("〓");
					}else if(map[x][y]==-1){
						System.out.print("※");
					}
				}
				System.out.println();
			}
		}
	}
}