Dijkstra算法的Java实现

package main.java;

import main.java.utils.GraphUtil;

import java.util.ArrayDeque;
import java.util.List;
import java.util.Queue;


/**
 * @Tme 2019/9/12 10:40
 * @Author chenhaisheng
 * @Email:ecjutsbs@foxmail.com
 */
public class DijkstraTest {

    //邻接矩阵的表示
    public final static double[][] GRAPH_DISTANCE = GraphUtil.getDijkstraGraph();

    //起点到某节点的临时最短距离
    public static double distance[] = new double[GRAPH_DISTANCE.length];

    //某节点的前驱节点
    public static int pre[] = new int[GRAPH_DISTANCE.length];

    static int originIndex = 0, toIndex = 4;


    public static void main(String[] args) {

        init();
        findDijkstraShortestPath();
    }

    /*
    **初始化distance[]   pre[]
     */
    public static void init() {

        for (int i = 0; i < distance.length; i++) {
            if (i == originIndex) {
                distance[i] = 0.0;
                continue;
            }
            distance[i] = Double.MAX_VALUE;
        }

        for (int i = 0; i < pre.length; i++) {
            pre[i] = -1;
        }
    }

    public static void findDijkstraShortestPath() {

        //queue用于保存尚待搜索的节点
        Queue<Integer> queue = new ArrayDeque<>();

        //起始，将起始节点添加到queue
        queue.add(originIndex);

        while (queue.size() != 0) {

            Integer currentIndex = queue.poll();

            //获取当前节点的out-edges
            List<Integer> neighbours = getNeighbours(currentIndex);

            for (int i = 0; i < neighbours.size(); i++) {

                //获取邻居节点的索引值
                int neighbourIndex = neighbours.get(i);

                //若起点经当前节点到邻居节点的距离 比直接到邻居节点的距离还小
                if (distance[currentIndex] + getDistance(currentIndex, neighbourIndex) < distance[neighbourIndex]) {

                    //更新起点到邻居节点的距离
                    distance[neighbourIndex] = distance[currentIndex] + getDistance(currentIndex, neighbourIndex);

                    //设置下一个节点的前驱节点为当前节点
                    pre[neighbourIndex] = currentIndex;

                    //由于distance[neighbourIndex]已经改变，因此需要重新搜索neighbourIndex
                    queue.add(neighbourIndex);
                }
            }
        }

        //输出从originIndex到toIndex的路径
        printPath(pre, originIndex, toIndex);
    }


    public static void printPath(int pre[], int from, int to) {

        //栈
        Deque<Integer> path = new ArrayDeque<>();

        path.push(to);

        int preIndex = pre[to];
        while (preIndex != from) {
            path.push(preIndex);
            preIndex = pre[preIndex];
        }

        path.push(from);

        while (!path.isEmpty()) {
            System.out.print(path.poll() + (path.size() > 0 ? "------>" : " "));
        }
        System.out.println(" ");
    }


    //获取当前节点所有的out-edges
    public static List getNeighbours(int index) {

        List<Integer> res = new ArrayList();

        //距离不为Double.MAX_VALUE,代表与当前节点连通
        for (int i = 0; i < GRAPH_DISTANCE[index].length; i++) {
            if (GRAPH_DISTANCE[index][i] != Double.MAX_VALUE)
                res.add(i);
        }
        return res;
    }

    public static double getDistance(int from, int to) {
        return GRAPH_DISTANCE[from][to];
    }
}

 

package main.java.utils;

/**
 * @Tme ${DATA} 19:10
 * @Author chenhaisheng
 * @Email:ecjutsbs@foxmail.com
 */
public class GraphUtil<T> {

    public static double[][] getDijkstraGraph(){
        double max=Double.MAX_VALUE;
        double[][] graph={
                {max,5,max,7,15},
                {max,max,5,max,max},
                {max,max,max,max,1},
                {max,max,2,max,max},
                {max,max,max,max,max}
        };
        return  graph;
    }
}

 

对应的图：

图的结构Ref：https://wenku.baidu.com/view/9fdeaa3c2b160b4e767fcff7.html

 

小结：

最重要的是记住：在搜索过程中，若节点i对应的distance[i]发生改变，那么对其任意一个邻居节点j，对应的distance[j]都要重新计算，继而引发连锁反应。

对某一个节点k，distance[k]通常会发生会多次改变。