数据结构之图 最短路径算法

最短路径：计算从Vi到Vj的权总和最小的路径

/**
 * 	贪婪算法实现
 * @author 陈鑫
 *	有权无负值图最短路径算法
 */
public class ShortestPath {
	
	static class Vertex{
		public List<Vertex> adj;//邻接顶点集合
		public Boolean known;//是否遍历过，防止有圈图
		public Integer dist;//距离
		public Vertex path;//路径
		public String vertexName;//名称，代号
		
		public List<Vertex> getAdj() {
			return adj;
		}
		public void setAdj(List<Vertex> adj) {
			this.adj = adj;
		}
		public Boolean getKnown() {
			return known;
		}
		public void setKnown(Boolean known) {
			this.known = known;
		}
		public Integer getDist() {
			return dist;
		}
		public void setDist(Integer dist) {
			this.dist = dist;
		}
		public Vertex getPath() {
			return path;
		}
		public void setPath(Vertex path) {
			this.path = path;
		}
		public String getVertexName() {
			return vertexName;
		}
		public void setVertexName(String vertexName) {
			this.vertexName = vertexName;
		}
		
		
	}
	/**
	 * dijkstra
	 * @param s
	 * @param adjacencyList
	 * @param weightArray
	 */
	public static void dijkstra(Vertex s,ArrayList<Vertex> adjacencyList,int[][] weightArray) {
		//数据初始化
		for(Vertex v:adjacencyList) {
			v.dist = 999;
			v.known = false;
		}
		s.setDist(0);
		//优先队列
		Queue<Vertex> vertexQueue = new LinkedList<Vertex>();
		vertexQueue.add(s);//入队
		
		while(!vertexQueue.isEmpty()) {
			Vertex vertex = vertexQueue.poll();
			if(vertex.getAdj() != null) {
				for(Vertex w : vertex.getAdj()) {
					//通过顶点在adjacencyList集合保存的位置确定它的权重
					int weight = weightArray[adjacencyList.indexOf(vertex)][adjacencyList.indexOf(w)];
					//防止出现圈
					if(w.path != vertex) {
						vertexQueue.add(w); 
					}
					//将比较总权重并将小的保存，赋值
					if(vertex.dist + weight < w.dist ){ 
						w.dist = vertex.dist + weight;
						w.path = vertex;
					}
				}
				
			}
		}
	}
	
	public static void printPath(Vertex s) {
		if(s.path != null) {
			printPath(s.path);
			System.out.print(" to ");
		}
		System.out.print(s.vertexName);
	}
	
	public static void main(String[] args) {
		//数据准备
		
		//邻接表
		ArrayList<Vertex> adjacencyList = new ArrayList<Vertex>();
		
		Vertex vertex1 = new Vertex();
		Vertex vertex2 = new Vertex();
		Vertex vertex3 = new Vertex();
		Vertex vertex4 = new Vertex();
		Vertex vertex5 = new Vertex();
		Vertex vertex6 = new Vertex();
		Vertex vertex7 = new Vertex();
		vertex1.setVertexName("v1");
		vertex2.setVertexName("v2");
		vertex3.setVertexName("v3");
		vertex4.setVertexName("v4");
		vertex5.setVertexName("v5");
		vertex6.setVertexName("v6");
		vertex7.setVertexName("v7");
		
		ArrayList<Vertex> adjacentVertexList1 = new ArrayList<Vertex>();
		ArrayList<Vertex> adjacentVertexList2 = new ArrayList<Vertex>();
		ArrayList<Vertex> adjacentVertexList3 = new ArrayList<Vertex>();
		ArrayList<Vertex> adjacentVertexList4 = new ArrayList<Vertex>();
		ArrayList<Vertex> adjacentVertexList5 = new ArrayList<Vertex>();
		ArrayList<Vertex> adjacentVertexList6 = new ArrayList<Vertex>();
		ArrayList<Vertex> adjacentVertexList7 = new ArrayList<Vertex>();
		
		adjacentVertexList1.add(vertex4);
		adjacentVertexList1.add(vertex2);
		
		vertex1.setAdj(adjacentVertexList1);
		
		adjacentVertexList2.add(vertex4);
		adjacentVertexList2.add(vertex5);
		vertex2.setAdj(adjacentVertexList2);
		
		adjacentVertexList3.add(vertex6);
		adjacentVertexList3.add(vertex1);
		vertex3.setAdj(adjacentVertexList3);
		
		adjacentVertexList4.add(vertex6);
		adjacentVertexList4.add(vertex7);
		adjacentVertexList4.add(vertex3);
		adjacentVertexList4.add(vertex5);
		vertex4.setAdj(adjacentVertexList4);
		
		adjacentVertexList5.add(vertex7);
		vertex5.setAdj(adjacentVertexList5);
		
		adjacentVertexList7.add(vertex6);
		vertex7.setAdj(adjacentVertexList7);
		
		adjacencyList.add(vertex1);
		adjacencyList.add(vertex2);
		adjacencyList.add(vertex3);
		adjacencyList.add(vertex4);
		adjacencyList.add(vertex5);
		adjacencyList.add(vertex6);
		adjacencyList.add(vertex7);
		
		//邻接矩阵表示权
		int[][] weightArray = { {999,2,999,1,999,999,999},
								{999,999,999,3,10,999,999},
								{4,999,999,999,999,5,999},
								{999,999,2,999,2,8,5},
								{999,999,999,999,999,999,1},
								{999,999,999,999,999,999,999},
								{999,999,999,999,999,1,999}};
		//调用dijkstra算法
		dijkstra(vertex1,adjacencyList,weightArray);
		
		for(Vertex  v : adjacencyList) {
			System.out.println(v.getVertexName()+":" + v.getDist());
		}
		
		printPath(vertex6);
	}

}