package graph;

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;

/**
 * @author wyhong
 *
 */
public class Dijkstra {

	public class Node{
		/**
		 * 節點的識別符號
		 */
		private Integer identifier;
		/**
		 * 該節點是否被訪問過
		 */
		private boolean visited = false;
		/**
		 * 該節點與其他節點的對映關係
		 */
		private Map<Node,Integer> mapping = new HashMap<Node,Integer>();
		
		public Integer getIdentifier() {
			return identifier;
		}
		public void setIdentifier(Integer identifier) {
			this.identifier = identifier;
		}
		public boolean isVisited() {
			return visited;
		}
		public void setVisited(boolean visited) {
			this.visited = visited;
		}
		public Map<Node, Integer> getMapping() {
			return mapping;
		}
	}
	
	/**
	 * Getting optimal path by Dijkstra algorithm
	 * @param src
	 * @param dest
	 * @return
	 */
	public static LinkedList<Node> getOptimalPath(Node src, Node dest){
		return dijkstra(src, dest, 0, 0, new LinkedList<Node>());
	}
	
	/**
	 * Dijkstra algorithm
	 * @param src 起始節點
	 * @param dest 目標節點
	 * @param adjacentDist 起始節點與目標節點相鄰時的距離
	 * @param optimalDist 最短路徑權值之和
	 * @param optimalPath 最短路徑
	 * @return
	 */
	private static LinkedList<Node> dijkstra(Node src, Node dest, int adjacentDist, int optimalDist, LinkedList<Node> optimalPath){
		if(optimalPath.size()==0){
			optimalPath.add(src);
		}
		//當前節點與其他節點的對映關係
		Map<Node,Integer> mapping = src.getMapping();
		//當前節點與其相鄰節點的最小距離
		int partialMinDist = 0;
		//當前預選的下一最優節點
		Node partialOptimalNode = null;
		Iterator<Entry<Node, Integer>> entryIterator = mapping.entrySet().iterator();
		while (entryIterator.hasNext()) {
			Entry<Node, Integer> entry = (Entry<Node, Integer>) entryIterator.next();
			Node nextNode = entry.getKey();
			//判斷該相鄰節點是否被訪問過
			if (nextNode.isVisited()) continue;
			int dist = entry.getValue(); 
			//終點與起點相鄰，但未必路徑最短
			if(nextNode.getIdentifier() == dest.getIdentifier() && optimalPath.size() == 1) adjacentDist = dist;
			if (partialMinDist != 0) {
				boolean currentIsOptimal = partialMinDist > dist ? false : true;
				if(!currentIsOptimal){
					partialMinDist = dist;
					partialOptimalNode = nextNode;
				}
			}else{
				partialMinDist = dist;
				partialOptimalNode = nextNode;
			}
		}
		//設定當前節點已被訪問
		src.setVisited(true);
		//加入連結串列
		optimalPath.add(partialOptimalNode);
		optimalDist += partialMinDist;
		if(partialOptimalNode.getIdentifier()!=dest.getIdentifier()){
			//若未到終點時當前最優路徑長度已大於終點與起點相鄰的距離，則最短路徑為起點--->終點
			if(adjacentDist != 0 && optimalDist > adjacentDist) {
				src = optimalPath.removeFirst();
				optimalPath.clear();
				optimalPath.add(src);
				optimalPath.add(dest);
				optimalDist = adjacentDist;
				return optimalPath;
			}
			//否則以當前節點遞迴
			return dijkstra(partialOptimalNode, dest, adjacentDist, optimalDist, optimalPath);
		}else{
			return optimalPath;
		}
	}
}
 

測試用例：

package graph.test;

import graph.Dijkstra;
import graph.Dijkstra.Node;

import java.util.Iterator;
import java.util.LinkedList;

public class DijkstraTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dijkstra dijkstra = new Dijkstra();
		Dijkstra.Node node_1 = dijkstra.new Node();
		Dijkstra.Node node_2 = dijkstra.new Node();
		Dijkstra.Node node_3 = dijkstra.new Node();
		Dijkstra.Node node_4 = dijkstra.new Node();
		Dijkstra.Node node_5 = dijkstra.new Node();
		Dijkstra.Node node_6 = dijkstra.new Node();
		
		node_1.setIdentifier(1);
		node_1.getMapping().put(node_2, 7);
		node_1.getMapping().put(node_3, 9);
		node_1.getMapping().put(node_6, 14);
		
		node_2.setIdentifier(2);
		node_2.getMapping().put(node_1, 7);
		node_2.getMapping().put(node_3, 10);
		node_2.getMapping().put(node_4, 15);
		
		node_3.setIdentifier(3);
		node_3.getMapping().put(node_1,7);
		node_3.getMapping().put(node_2,10);
		node_3.getMapping().put(node_4,11);
		node_3.getMapping().put(node_6,2);
		
		node_4.setIdentifier(4);
		node_4.getMapping().put(node_3, 11);
		node_4.getMapping().put(node_2, 15);
		node_4.getMapping().put(node_5, 6);
		
		node_5.setIdentifier(5);
		node_5.getMapping().put(node_4, 6);
		node_5.getMapping().put(node_6, 9);
		
		node_6.setIdentifier(6);
		node_6.getMapping().put(node_5, 9);
		node_6.getMapping().put(node_1, 14);
		
		LinkedList<Node> optimalPath = Dijkstra.getOptimalPath(node_1, node_5);
		System.out.println("-------The optimal path--------");
		for (Iterator<Node> iterator = optimalPath.iterator(); iterator.hasNext();) {
			Node node = (Node) iterator.next();
			if (iterator.hasNext()) {
				System.out.print(node.getIdentifier()+"-->");
			}else{
				System.out.print(node.getIdentifier());
			}
		}
	}

}