A*算法求最短路径 java 源码(拿来即可用)

偶然看到最短路劲问题,在游戏、导航等领域都有所应用,觉着挺有意思的,便打算自己也实现一版 。最后选择了高效简洁的A*算法。

A*确实是一个非常优秀的实现,比起迪杰特斯拉、best-first等算法,这里省去1万字的赞美……

A*算法简绍可以看该文:

http://blog.csdn.net/pi9nc/article/details/8779503

A*的实现却并不复杂,关键第一点:判断当前每一步后,下一步怎么走,一般用一个开集和一个闭集分别来存储下一步待走的格子 和已经走过的格子;第二点:如何判断下一步走哪一个格子,这也是A*的优秀之处,它考虑了走过的距离(成本)和预期将要走的距离(期望),拥有快速有效的寻路能力;此处再省略1万字的赞美……

本文稍加改进,用最小堆来存储下一步可以走的格子,并用倒树(指结点中仅有指向父结点的指针的树,姑且让我这么说吧)来记录路劲。

最小堆参看:http://blog.csdn.net/abcd_d_/article/details/40379125

总共四各类:

1、MyCompare.java 是一个接口 

2、MinHeap.java 泛型最小堆 , 实现参照了java API中的ArrayList  ,代码可重用

3、Grid.java格子类,用于记录格子信息和简单操作

4、AStar.javaA* 算法主要逻辑类 


上代码:

package com.study.algorithm;

/**
 * 比较大小的函数接口
 * @author zhangshaoliang
 * 2015-5-7下午12:28:12
 */
public interface MyCompare {
	
	public boolean isLarger(MyCompare m2);
	
	public boolean isSmaller(MyCompare m2);
	
	public boolean isEqual(MyCompare m2);
}
package com.study.algorithm;

/**
 * pojo ,格子
 * <pre> F = G + H
 * G 表示从起点 A 移动到网格上指定方格的移动耗费 (可沿斜方向移动,斜方向的代价为对角线长度)
 * H 表示从指定的方格移动到终点 B 的预计耗费 (H 有很多计算方法, 这里我们设定只可以上下左右移动).</pre>
 * @author zhangshaoliang
 * 2015-5-7下午1:00:09
 */
public class Grid implements MyCompare{

	private double F;
	private double H;
	private double G;
	
	private int i ;
	private int j;
	
	private Grid parent; ///该格子的父格子
	
	/**
	 * pojo ,格子
	 * @param F F = G + H
	 * @param G 表示从起点 A 移动到网格上指定方格的移动耗费 (可沿斜方向移动,斜方向的代价为对角线长度)
	 * @param H	表示从指定的方格移动到终点 B 的预计耗费 (H 有很多计算方法, 这里我们设定只可以上下左右移动).
	 * @param i 纵坐标i
	 * @param j 横坐标j
	 * @param parent  父结点
	 */
	public Grid(double F,double G,double H,int i,int j,Grid parent){
		this.F = F;
		this.G = G;
		this.H = H;
		this.i = i;
		this.j = j;
		this.parent = parent;
	}
	public Grid(){}
	
	

	public Grid getParent() {
		return parent;
	}
	public void setParent(Grid parent) {
		this.parent = parent;
	}
	
	public int getI() {
		return i;
	}
	public int getJ() {
		return j;
	}
	public void setI(int i) {
		this.i = i;
	}
	public void setJ(int j) {
		this.j = j;
	}
	
	
	/**
	 * 经过当前点到终点B的总耗费  期望值
	 * @return
	 */
	public double getF() {
		return F;
	}
	
	/**
	 * H 表示从指定的方格移动到终点 B 的预计耗费 (H 有很多计算方法, 这里我们设定只可以上下左右移动)
	 * @return
	 */
	public double getH() {
		return H;
	}
	/**
	 * 表示从起点 A 移动到当前网格上的移动耗费 (可沿斜方向移动,斜方向的代价为对角线长度)
	 * @return
	 */
	public double getG() {
		return G;
	}
	
	
	
	public void setF(double f) {
		F = f;
	}
	public void setH(double h) {
		H = h;
	}
	public void setG(double g) {
		G = g;
	}
	
	@Override
	public boolean isLarger(MyCompare m2) {
		// TODO Auto-generated method stub
		return this.F>((Grid)m2).getF();
	}
	@Override
	public boolean isSmaller(MyCompare m2) {
		// TODO Auto-generated method stub
		return this.F<((Grid)m2).getF();
	}
	@Override
	public boolean isEqual(MyCompare m2) {
		// TODO Auto-generated method stub
		return this.F==((Grid)m2).getF();
	}
	
}

package com.study.algorithm;

/**
 * 最小堆
 * @author zhangshaoliang
 * 2015-5-7上午11:08:20
 */
public class MinHeap<E extends MyCompare> {
	private int size;
	private Object[] element;
	
	public MinHeap(int maxSize){
		size = 0;
		element = new Object[maxSize];
	}
	public MinHeap(){
		this(10);
	}
	
	/**
	 * 元素入堆
	 * @param e
	 */
	public void append(E e){
		ensureCapacity(size+1);
		element[size++] = e;///put the element to the end of the heap
		
		adjustUp(); //adjust the heap to minHeap
	}
	/**
	 * 取出堆顶元素(最小元素)
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public E poll(){
		if(isEmpty()){
			return null;
		}
		
		E min = (E) element[0];
		element[0] = element[size-1];///replace the min element with the last element 
		element[size-1] = null ;///let gc do its work
		size--;
		
		adjustDown();///adjust the heap to minHeap
		
		return min;
	}
	/**
	 * 查看堆顶元素(最小元素)
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public E  peek(){
		if(isEmpty()){
			return null;
		}
		return (E) element[0];
	}
	/**
	 * 是否为空堆
	 * @return
	 */
	public boolean isEmpty(){
		return size == 0 ;
	}
	
	/**
	 * 确保容量空间足够
	 * @param minCapacity
	 */
	private void ensureCapacity(int minCapacity){
		int oldCapacity = element.length;
		if(minCapacity > oldCapacity){
			int newCapacity = (oldCapacity*3)/2+1;///每次扩容至1.5倍
			Object[] copy = new Object[newCapacity];
			///调用本地C方法进行数组复制
			System.arraycopy(element, 0, copy, 0, element.length);
			
			element = copy;
		}
	}
	
	/**
	 * 向上调整为堆,将小值往上调
	 */
	@SuppressWarnings("unchecked")
	private void adjustUp(){
		
		E temp = (E) element[size-1]; ///get the last element 
		int parent = size - 1;
		while(parent>0&&((E)element[(size - 1)/2]).isLarger(temp)){
			///if smaller than it parent
			element[parent] = element[(parent - 1)/2];
			parent = (parent - 1)/2;
		}
		element[parent] = temp;
	}
	
	/**
	 * 向下调整为堆
	 */
	@SuppressWarnings("unchecked")
	private void adjustDown(){
		E temp = (E) element[0]; ///get the first element 
		int child = 1;
		while(child<size){
			E left = (E) element[child];
			E right = (E) element[child+1];///这里的child+1不会越界(想想为什么)
			if(right!=null&&left.isLarger(right)){
				child++;
			} 
			
			if(temp.isSmaller((E)element[child])){
				break; ////如果比两个孩子中较小者都还小,则结束
			}

			element[(child-1)/2] = element[child]; ///assign the smaller to its parent
			child = child*2 + 1;
		}
		
		element[(child-1)/2] = temp;
	}
}

package com.study.algorithm;

/**
 * A*寻路算法
 * <pre>
 * 思路:	每次取期望值最小的位置作为下一步要走的位置,F = G + H 
 *  	G 表示从起点 A 移动到网格上指定方格的移动耗费 (可沿斜方向移动,斜方向的代价为对角线长度).
 *  	H 表示从指定的方格移动到终点 B 的预计耗费 (H 有很多计算方法, 这里我们设定只可以上下左右移动).
 *  	
 *  	此处用一个最小堆来记录开启列表中的格子,每个格子有一个指向父格子的指针,以此记录路劲 </pre>
 * @author zhangshaoliang
 * 2015-5-7上午10:58:54
 */
public class AStar {
	
	private static MinHeap<Grid> open ;//= new MinHeap<Grid>();
//	private static MTree close ;//= new MTree();
	private Grid last; //记录最后一个格子
	
	private final String obstacle = "1";//障碍物标记值
	private String end = "e";	////目标标记值
	private String start = "s";////开始标记值
	 //目标坐标
	private int end_i = -1; 
	private int end_j = -1;
	//开始目标
	private int start_i = -1;
	private int start_j = -1;
	
	/**
	 * 初始化操作
	 * @param boxs
	 */
	public void init(String[][] boxs){
		for(int i=0;i<boxs.length;i++){
			for(int j=0;j<boxs[0].length;j++){
				if(boxs[i][j].equals(start)){
					start_i = i;
					start_j = j;
				}
				if(boxs[i][j].equals(end)){
					end_i = i;
					end_j = j;
				}
			}
		}
		
		Grid sGrid = new Grid(0, 0, 0, start_i, start_j, null);
		open = new MinHeap<Grid>();
		open.append(sGrid);///、将开始位置加入开集
	}
	/**
	 * 开始搜索
	 */
	public void search(String[][] boxs){
		int height = boxs.length;
		int width = boxs[0].length;
		while(open.peek()!=null){//对开集进行遍历,直到找到目标或者找不到通路
			Grid g = open.poll();
			int i = g.getI();
			int j = g.getJ();
			double pre_G = g.getG();///已耗费
			for(int h=-1;h<=1;h++){
				for(int w=-1;w<=1;w++){
					
					int next_i = i + h;	///下一个将加入open 集的格子的i
					int next_j = j + w;///下一个将加入open 集的格子的j
					
					if(next_i>=0 && next_i<=height-1 && next_j>=0 && next_j<=width-1){
						////数组不越界,则进行计算
						if(boxs[next_i][next_j].equals(obstacle) || boxs[next_i][next_j].equals("-1") ||(h==0&&w==0)){
							//如果该格子是障碍,或者格子本身,跳过
							continue;
						}
						////计算该点到终点的最短路劲
						double H =  Math.abs(end_i - next_i) + Math.abs(end_j - next_j) ;
						if(H<1){
							///找到目标,记录并结束
							last = new Grid(0, pre_G, 0, next_i, next_j,g); ;
							return ;
						}
						////如果是对角线则加1.4,否则加1
						double G = Math.sqrt((next_i-i)*(next_i-i)+(next_j-j)*(next_j-j))>1 	? 	pre_G+1.4 	: 	pre_G+1;
						//生成新格子
						Grid temp = new Grid(H+G, G, H, next_i, next_j,g);
						////加入open集
						open.append(temp);
						boxs[i][j] = "-1";///表示此处已经计算过了
					}
				}
			}
			
			last = g;
		}
		
		
	}

	/**
	 * 打印路劲
	 */
	public void printPath(){
		
		if(end_i!=last.getI()||end_j!=last.getJ()){
			System.out.println("无法到达终点!");
			return ;
		}
		
		System.out.println("路劲逆序为:");
		while(true){
			System.out.print("("+last.getI()+","+last.getJ()+")");
			last = last.getParent();
			if(last==null){
				break;
			}
			System.out.print(" <———");
		}
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*Grid g1 = new Grid(2, 1, 2, 0, 0,null);
		Grid g2 = new Grid(5, 1, 2, 0, 0,g1);
		Grid g3 = new Grid(1, 1, 2, 0, 0,g1);
		Grid g4 = new Grid(6, 1, 2, 0, 0,g2);
		Grid g5 = new Grid(3, 1, 2, 0, 0,g3);
		
		open = new MinHeap<Grid>();
		open.append(g1);
		open.append(g2);
		open.append(g3);
		open.append(g4);
		open.append(g5);
		//、测试最小堆
		while(null!=open.peek()){
			System.out.println(open.poll().getF());
		}
		*/
		String[][] boxs = {//{"0","g"},{"s","0"}};
				{"0","0","1","0","0"},	
				{"0","0","1","e","0"},	
				{"0","0","1","1","0"},	
				{"0","0","0","1","0"},	
				{"s","0","1","0","0"},	
		};
		
		AStar star = new AStar();
		star.init(boxs);
		star.search(boxs);
		star.printPath();
	}

}

输出结果:

<span style="font-size:18px;">路劲逆序为:
(1,3) <———(2,4) <———(3,4) <———(4,3) <———(3,2) <———(3,1) <———(4,0)</span>








阅读更多
个人分类: 算法 java 数据结构
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭