Dijkstra(迪杰斯特拉)算法

一.简介

迪克斯特拉算法又名Dijkstra算法(属于贪心算法)。Dijkstra算法是从一节点到其余各节点最短路径计算方法。

迪杰斯特拉算法以起始点为中心向外层层扩展，直到扩展到终点为止。

算法思想：
1.设S集合表示开始节点到其余节点的最短路径，U集合表示还未加入S集合的开始节点到其余各节点的距离（没有与开始节点直接连通的节点表示为无穷大），初始时S集合只有开始节点一个，其自身到自身距离设为0

2.设L(s,u)表示开始节点s到节点u的最短路径，从U集合选择离开始节点s最短的一个节点加入S集合，并更新U集合中开始节点到其余节点的路径min(L(s,u),L(s,k)+L(k,u))

二.实现

package com.vincent;


import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        char[] datas = {'a','b','c','d','e','f'};
        int[][] graph = new int[datas.length][];

        final int M = Integer.MAX_VALUE;
		//M表示节点之间没有直接连通
        graph[0] = new int[]{0,2,3,M,M,5};
        graph[1] = new int[]{2,M,M,4,M,M};
        graph[2] = new int[]{3,M,M,M,5,M};
        graph[3] = new int[]{M,4,M,M,M,6};
        graph[4] = new int[]{M,M,5,M,M,8};
        graph[5] = new int[]{5,M,M,6,8,M};

        for(int i=0;i<datas.length;i++){
            System.out.println(Arrays.toString(graph[i]));
        }

        System.out.println();
        System.out.println(Arrays.toString(dijkstra(graph,datas,5)));
    }

    /**
     *迪杰斯特拉算法
     * @param graph         图的邻接矩阵
     * @param datas         节点值
     * @param from          开始节点索引
     * @return
     */
    public static int[] dijkstra(int[][] graph,char[] datas,int from){
        //记录访问过的节点
        int[] book = new int[datas.length];
        //dis[i] 表示开始节点到i节点的最短路径
        int[] dis = new int[datas.length];

        book[from] = 1;
        dis[from] = 0;

        //n个节点的图，还需要加入n-1个节点
        for(int i=1;i<datas.length;i++){
            int minDis = Integer.MAX_VALUE;
            int minIndex = -1;

            //计算开始节点到未计算节点的最小路径
            for(int j=0;j<datas.length;j++){
                if(book[j] == 0 && graph[from][j] <= minDis){
                    minDis = graph[from][j];
                    minIndex = j;
                }
            }
            book[minIndex] = 1;
            dis[minIndex] = minDis;

            //更新开始节点到未计算节点的最短路径
            for(int j=0;j<datas.length;j++){
                //设L(v,u)表示v节点到u节点的路径,则L(v,k) L(k,u) 也是从v节点到u节点的路径
                //防止计算移除变成负数
                int lenDis = graph[minIndex][j] == Integer.MAX_VALUE ? Integer.MAX_VALUE : dis[minIndex] + graph[minIndex][j];
                if(lenDis < graph[from][j]){
                    graph[from][j] = lenDis;
                }
            }
        }
        return dis;
    }
}

效果：

三.总结

Dijkstra算法属于贪心算法/BFS算法，其时间复杂度为O(n ^ 2)