Dijkstra无向图最短路径

import java.util.ArrayList;
import java.util.HashMap;  
import java.util.HashSet;  
import java.util.Iterator;  
import java.util.Map;
import java.util.Map.Entry;  
import java.util.Set;  
  
public class ShortestPath {  
    private static final int minDis = 0;  
    private static final int maxDis = Integer.MAX_VALUE;  
    // 图的邻接矩阵  
    int[][] matrix;  
    Map<Integer,ArrayList<Integer>> pass = new HashMap<Integer,ArrayList<Integer>>();
    // 起始点  
    int startIndex;  
    // 用来存放起始点到其它点当前的距离  
    HashMap<Integer, Integer> distanceMap = new HashMap<Integer, Integer>();  
    // 用来存放已经找到最短路径的点的集合  
    Set<Integer> findedSet = new HashSet<Integer>();  
  
    public ShortestPath(int[][] matrix, int start) {  
        this.matrix = matrix;  
        this.startIndex = start;  
    }  
  
    public void find() 
    {  
        // 用start相邻的点初始化distanceMap  
        for (int i = 0; i < matrix.length; i++) 
        {  
                distanceMap.put(i, matrix[startIndex][i]);  
                ArrayList<Integer> path = new ArrayList<Integer>();
                pass.put(i, path);
        }  
        while (findedSet.size() != matrix.length) 
        {  
            int currentMinIndex = currentMinIndex();
            // 用此结点更新其它结点的距离  
            for (int i = 0; i < matrix.length; i++) 
            {  
                if (!findedSet.contains(i) && matrix[currentMinIndex][i] != maxDis  
                        && matrix[currentMinIndex][i] + distanceMap.get(currentMinIndex) < distanceMap.get(i))  
                    
                	{
                	distanceMap.put(i, matrix[currentMinIndex][i] + distanceMap.get(currentMinIndex)); 
                	pass.get(i).clear();
                	pass.get(i).addAll(pass.get(currentMinIndex));
                	pass.get(i).add(currentMinIndex);
                	}
            }             
            // 放入findedset  
            findedSet.add(currentMinIndex);  
        }  


    }  
  
    //打印从起始点到所有点的最短距离  
    public void printDistance(){  
        Iterator<Entry<Integer, Integer>> it = distanceMap.entrySet().iterator();  


        while (it.hasNext()) {  
            Entry<Integer, Integer> entry = it.next();  
            System.out.print(startIndex+"->");
            for(int i =0 ; i<pass.get(entry.getKey()).size();i++)
            {
            System.out.print(pass.get(entry.getKey()).get(i)+"->");
            }
            System.out.println(entry.getKey()+"\t:\t"+entry.getValue());
        }  
    }  
      
    // 返回当前最小距离的点(必须不包含在findedSet中)  
    private int currentMinIndex() {  
        Iterator<Entry<Integer, Integer>> it = distanceMap.entrySet().iterator(); //键-值对集合的迭代器    
        int min = Integer.MAX_VALUE;  
        int minIndex = -1;  
        while (it.hasNext()) {  
            Entry<Integer, Integer> entry = it.next();  
            if (!findedSet.contains(entry.getKey()) && entry.getValue() < min) {  
                min = entry.getValue();  
                minIndex = entry.getKey();  
            }  
        }  
        return minIndex;  
    }  
  
    public static void main(String[] args) {  
        int[][] inputMatrix = new int[][] 
        	  { { minDis,     10,      5, maxDis ,     20}, 
        		{ 10    , minDis,      2,      17, maxDis},  
                { 5     ,      2, minDis,  maxDis, maxDis}, 
                { maxDis,     17, maxDis,  minDis,      8},  
                { 20    , maxDis, maxDis,       8, minDis}};  
      for(int i=0;i<5;i++)
        {
        ShortestPath path = new ShortestPath(inputMatrix, i);  
        path.find();  
        path.printDistance();  
       }

    }  
}