Dijkstra最短路径算法的java实现

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()) {
Syst
8c0f
em.out.print(node.getIdentifier()+"-->");
}else{
System.out.print(node.getIdentifier());
}
}
}

}
结果：