JAVA实现DIJKSTRA算法

import java.util.Queue;
import java.util.LinkedList;

public class dijkstra{
public static void main(String args[]){
System.out.println("dijkstra algo");
/*construct the adjacent table begin*/
Node n0 = new Node(0);
Node n1 = new Node(1);
Node n2 = new Node(2);
Node n3 = new Node(3);
Node n4 = new Node(4);
Node n5 = new Node(5);
AdjNode n0n1 = new AdjNode(7,n1);
AdjNode n0n2 = new AdjNode(9,n2);
AdjNode n0n5 = new AdjNode(14,n5);

AdjNode n1n0 = new AdjNode(7,n0);
AdjNode n1n2 = new AdjNode(10,n2);
AdjNode n1n3 = new AdjNode(15,n3);

AdjNode n2n0 = new AdjNode(9,n0);
AdjNode n2n5 = new AdjNode(2,n5);
AdjNode n2n3 = new AdjNode(11,n3);

AdjNode n3n1 = new AdjNode(15,n1);
AdjNode n3n2 = new AdjNode(11,n2);
AdjNode n3n4 = new AdjNode(6,n4);

AdjNode n4n3 = new AdjNode(6,n3);
AdjNode n4n5 = new AdjNode(9,n5);

AdjNode n5n4 = new AdjNode(9,n4);
AdjNode n5n2 = new AdjNode(2,n2);
AdjNode n5n0 = new AdjNode(14,n0);

AdjNode[] n0adj = {n0n1,n0n2,n0n5};
AdjNode[] n1adj = {n1n0,n1n2,n1n3};
AdjNode[] n2adj = {n2n0,n2n5,n2n3};
AdjNode[] n3adj = {n3n1,n3n2,n3n4};
AdjNode[] n4adj = {n4n3,n4n5};
AdjNode[] n5adj = {n5n4,n5n2,n5n0};
n0.addAdjNodes(n0adj);
n1.addAdjNodes(n1adj);
n2.addAdjNodes(n2adj);
n3.addAdjNodes(n3adj);
n4.addAdjNodes(n4adj);
n5.addAdjNodes(n5adj);
/*construct the adjacent table end*/
Node[] G = {n0,n1,n2,n3,n4,n5};

Queue<Node> queue = new LinkedList<Node>();
AdjNode[] currAdjNodes;
n0.color = 1;
n0.vt++;
n0.setShortestPathLen(0);
queue.offer(n0);
Node currNode = queue.poll();
while(currNode != null){
currAdjNodes = currNode.getAllAdjNodes();

for(int i=0;i<currAdjNodes.length;i++){
if(currAdjNodes[i].adjNode.getShortestPathLen() > (currNode.getShortestPathLen()+currAdjNodes[i].weight)){
currAdjNodes[i].adjNode.setShortestPathLen(currNode.getShortestPathLen()+currAdjNodes[i].weight);
currAdjNodes[i].adjNode.setPreNode(currNode);
}
if(currAdjNodes[i].adjNode.color == 0){
currAdjNodes[i].adjNode.color = 1;
currAdjNodes[i].adjNode.vt++;
queue.offer(currAdjNodes[i].adjNode);
}
}

currNode.color = 2;
currNode = queue.poll();
}

for(int i=0;i<G.length;i++){
System.out.println("shortest path of " + i + "node:" + G[i].getShortestPathLen()+" vt:"+G[i].vt);
}
}
}

public class Node{
private int index = 0,shortestPathLen = 10000;
private Node preNode = null;
private AdjNode[] nodeArray;
public int color = 0;
public int vt = 0;
public Node(int ind){
index = ind;
}

public void addAdjNodes(AdjNode[] nodes){
nodeArray = nodes;
}

public AdjNode[] getAllAdjNodes(){
return nodeArray;
}

public void setPreNode(Node n){
preNode = n;
}

public void setShortestPathLen(int len){
shortestPathLen = len;
}

public int getShortestPathLen(){
return shortestPathLen;
}
}

public class AdjNode{
int weight = 0;
Node adjNode = null;
public AdjNode(int w,Node n){
adjNode = n;
weight = w;
}
}