Dijkstra 算法 Java实现

本算法是求V0到各个点的最短距离

import java.util.Arrays;

class Vertex{

    int distance;//到这个点的距离
    int preVertexIndex;//为了到达此点的前一个点的下标
    boolean sure = false;//标志这个点是否被确定，默认未确定
    public Vertex(int distance, int preVertexIndex){
        this.distance = distance;
        this.preVertexIndex = preVertexIndex;
    }

    @Override
    public String toString() {
        return "["+distance+","+preVertexIndex+"]";
    }
}

public class Main {

    //矩阵阶数
    static int matrixOrder = 6;

    //无穷距离
    static int MD = 999;

    //距离数组
    static Vertex[] distance = new Vertex[matrixOrder];


    //邻接矩阵
    //第一行表示V0->Vi(i=0,1,2,3,4,5)的距离，其它类似
    static int[][] arcs = {
            {0,       50,     10,     MD,    45,     MD},
            {MD,      0,      15,     MD,     5,     MD},
            {20,      MD,      0,     15,    MD,     MD},
            {MD,      20,     MD,      0,    35,     MD},
            {MD,      MD,     MD,     30,     0,     MD},
            {MD,      MD,     MD,      3,    MD,     0 }} ;

    //从距离数组中查找距离值最短的节点下标
    static int findShortestDistanceVertexIndexFromDistanceArray(){
        int shortestDistance = MD;
        int shortestVertexIndex = matrixOrder;
        for(int i = 0; i < matrixOrder; i++){
            if(distance[i].sure == false && distance[i].distance <= shortestDistance){
                shortestDistance = distance[i].distance;
                shortestVertexIndex = i;
            }
        }
        return shortestVertexIndex;
    }

    //判断是否结束
    static boolean isOver(){
        for(int i = 0; i < matrixOrder; i++){
            if(distance[i].sure == false)
                return false;
        }
        return true;
    }

    static void calculateShortestDistance(){

        //初始化距离数组
        for(int i = 0; i < matrixOrder; i++){
            Vertex vertex;
            if(arcs[0][i] != MD){
                vertex = new Vertex(arcs[0][i], 0);
            }else {
                vertex = new Vertex(arcs[0][i], -1);
            }
            distance[i] = vertex;
        }

        while (true){
            if(isOver())
                break;
            int shortestVertexIndex = findShortestDistanceVertexIndexFromDistanceArray();
            for(int i = 0; i < matrixOrder; i++){
                if(distance[i].sure)
                    continue;
                if(distance[shortestVertexIndex].distance + arcs[shortestVertexIndex][i] < distance[i].distance){
                    distance[i].preVertexIndex = shortestVertexIndex;
                    distance[i].distance = distance[shortestVertexIndex].distance + arcs[shortestVertexIndex][i];
                }
            }
            distance[shortestVertexIndex].sure = true;
        }
    }

    public static void main(String[] args) {
        calculateShortestDistance();
        System.out.println(Arrays.toString(distance));
    }

}