单源最短路径（dijkstra）

算法分析：

首先，Dijkstra算法实现上需要这些前提:

• Dijkstra处理的是带正权值的有权图，那么就需要一个二维数组(如果空间大用List数组)存储各个点到点之间边的权值大小 (邻接矩阵或者邻接表存储) ，各个点距离初始化为无穷大。

• 需要一个boolean数组判断哪些点已经确定最短⻓度路径，哪些点没有确定。用一个 int数组记录距离（在算法执行过程有些点最短路径可能被多次更新）。

• 需要优先队列加入已经确定点的周围点。每次抛出从起点最短路径的那个点，直到所有点路径确定最短为止。

简单的概括流程为:

• 第一步一般从选定点开始抛入优先队列(路径一般为0)，boolean数组标记0的位置(最短为0) ， 然后0周围连通的点抛入优先队列中(可能是node类)，并把各个点的距离记录到对应数组内，此时周围点只是等待调度可能是最短距离，也可能被更新。(如果小于就更新，大于就不动，初始第一次是无穷肯定会更新)，第一次就结束了。

• 从等待调度队列中抛出距离最近的那个点B(第一次就是0周围邻居)。这个点距离一定是最近可以确定的(所有权值都是正的，点的距离只能越来越⻓，而它的路径是所有可能中的最小的)标记这个点为true表示已经确定，并且将这个点的邻居加入队列(下一次等待调度点为队列中原有的和这个点周围未确定的邻居)，并同时判断是否更新B点邻居⻓度，如果小于则更新!

• 重复二操作，直到所有的点都确定。

 算法实现：

package 图论;
 
import java.util.ArrayDeque;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
 
public class dijkstra {
    static class node
    {
        int x; //节点编号
        int lenth;//长度
        public node(int x,int lenth) {
            this.x=x;
            this.lenth=lenth;
        }
    }
 
    public static void main(String[] args) {
 
        int[][] map = new int[6][6];//记录权值，顺便记录链接情况，可以考虑附加邻接表
        initmap(map);//初始化
        boolean bool[]=new boolean[6];//判断是否已经确定
        int len[]=new int[6];//长度
        for(int i=0;i<6;i++)
        {
            len[i]=Integer.MAX_VALUE;
        }
        Queue<node>q1=new PriorityQueue<node>(com);
        len[0]=0;//从0这个点开始
        q1.add(new node(0, 0));
        int count=0;//计算执行了几次dijkstra
        while (!q1.isEmpty()) {
            node t1=q1.poll();
            int index=t1.x;//节点编号
            int length=t1.lenth;//节点当前点距离
            bool[index]=true;//抛出的点确定
            count++;//其实执行了6次就可以确定就不需要继续执行了  这句可有可无，有了减少计算次数
            for(int i=0;i<map[index].length;i++)
            {
                if(map[index][i]>0&&!bool[i])
                {
                    node node=new node(i, length+map[index][i]);
                    if(len[i]>node.lenth)//需要更新节点的时候更新节点并加入队列
                    {
                        len[i]=node.lenth;
                        q1.add(node);
                    }
                }
            }
        }       
        for(int i=0;i<6;i++)
        {
            System.out.println(len[i]);
        }
    }
    static Comparator<node>com=new Comparator<node>() {
 
        public int compare(node o1, node o2) {
            return o1.lenth-o2.lenth;
        }
    };
 
    private static void initmap(int[][] map) {
        map[0][1]=2;map[0][2]=3;map[0][3]=6;
        map[1][0]=2;map[1][4]=4;map[1][5]=6;
        map[2][0]=3;map[2][3]=2;
        map[3][0]=6;map[3][2]=2;map[3][4]=1;map[3][5]=3;
        map[4][1]=4;map[4][3]=1;
        map[5][1]=6;map[5][3]=3;    
    }
}

        更详细内容，点击下方原文链接：

        转自：https://blog.csdn.net/qq_40693171/article/details/119723211。