Dijkstra最短路径算法

引入：

Dijkstra(迪杰斯特拉)算法是典型的最短路径路由算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低。

代码：

package Dijkstra;



public class Node {

    private char id;

    private boolean isInTree;

    

    public Node(char id) {

        this.setId(id);

        setInTree(false);

    }



    public char getId() {

        return id;

    }



    public void setId(char id) {

        this.id = id;

    }



    public boolean isInTree() {

        return isInTree;

    }



    public void setInTree(boolean isInTree) {

        this.isInTree = isInTree;

    }

}

package Dijkstra;



public class DistPare {

    private int parentNode;

    private int distance;

    public DistPare(int parentNode, int distance) {

        this.setParentNode(parentNode);

        this.distance = distance;

    }



    public int getParentNode() {

        return parentNode;

    }



    public void setParentNode(int parentNode) {

        this.parentNode = parentNode;

    }

    

    public int getDistance() {

        return distance;

    }

    

    public void setDistance(int distance) {

        this.distance = distance;

    }



}

package Dijkstra;



public class Graph {

    private final int MAXNUM = 20;

    private final int MAXINT = 999999;

    private int nodeNum;       //number of the nodes in Graph

    private int treeNum;       //number of the nodes in tree

    private int adjMatrix[][]; //distance between two nodes

    private Node nodeList[];   //all nodes 

    private DistPare sPath[];  //shortest path between parent node and i  

    private int currentNode;

    private int currentDist;



    public Graph(){

        adjMatrix = new int[MAXNUM][MAXNUM];

        nodeList = new Node[MAXNUM];

        sPath = new DistPare[MAXNUM];

        nodeNum = 0;

        treeNum = 0;

        for(int i=0; i<MAXNUM; i++)

             for(int j=0; j<MAXNUM; j++)

                  adjMatrix[i][j] = MAXINT;

    }

    

    public void addVertex(char id) {

        nodeList[nodeNum++] = new Node(id);

    }

    

    //directed graph

    public void addEdge(int start, int end, int weight) {

        adjMatrix[start][end] = weight;

    }

    

    public void dijkstra() {

        int sourceNode = 0;

        nodeList[sourceNode].setInTree(true);

        treeNum++;

        for(int i = 0; i < nodeNum; i++) {

            int weight = adjMatrix[sourceNode][i];

            sPath[i] = new DistPare(sourceNode, weight);

        }        

        while(treeNum < nodeNum) {

            int minNode = getMin();

            int minDist = sPath[minNode].getDistance();            

            if(minDist == MAXINT) {

                System.out.println("The node can't be reached!");

           }

           else {

                currentNode = minNode;

                currentDist = minDist;

           }

           nodeList[currentNode].setInTree(true);

           treeNum++;

           adjustPath();

        }

        displayPath();

    }

    

    private void adjustPath() {

        // TODO Auto-generated method stub

        int num = 1;

        while(num < nodeNum) {

             if(nodeList[num].isInTree()) {

                  num ++;

                  continue;

             }

             int currentToFringe = adjMatrix[currentNode][num];

             int startToFringe = currentDist + currentToFringe;

             int sPathDist = sPath[num].getDistance();

             if(startToFringe<sPathDist) {

                  sPath[num].setParentNode(currentNode);

                  sPath[num].setDistance(startToFringe);;

             }

             num ++;

        }

    }



    private void displayPath() {

        // TODO Auto-generated method stub

        for(int i=0; i<nodeNum; i++) {

            System.out.print(nodeList[i].getId() + "=");

            if(sPath[i].getDistance() == MAXINT)

                 System.out.print("infinity");

            else

                 System.out.print(sPath[i].getDistance());

            char parent = nodeList[sPath[i].getParentNode()].getId();

            System.out.print("(" + parent + ") ");

       }

       System.out.println(" ");

    }



    /**

     * get the minimum DistPare

     * @return

     */

    private int getMin() {

        int minDist = MAXINT;

        int indexMin = 0;

        for(int j=0; j<nodeNum; j++) {

             if(!nodeList[j].isInTree() && sPath[j].getDistance()<minDist) {

                  minDist = sPath[j].getDistance();

                  indexMin = j;

             }

        }

        return indexMin;

    }

    

}

package Dijkstra;



public class DijkstraTest {

    public static void main(String[] args) {

        Graph theGraph = new Graph();

        theGraph.addVertex('A');//0

        theGraph.addVertex('B');//1

        theGraph.addVertex('C');//2

        theGraph.addVertex('D');//3

        theGraph.addVertex('E');//4



        theGraph.addEdge(0, 1, 50);//AB 50

        theGraph.addEdge(0, 3, 80);//AD 80

        theGraph.addEdge(1, 2, 60);//BC 60

        theGraph.addEdge(1, 3, 90);//BD 90

        theGraph.addEdge(2, 4, 40);//CE 40

        theGraph.addEdge(3, 2, 20);//DC 20

        theGraph.addEdge(3, 4, 70);//DE 70

        theGraph.addEdge(4, 1, 50);//EB 50

       

        System.out.println("Dijkstra: ");

        theGraph.dijkstra();

    }

}