1：Dijkstra算法

　　本算法可以算是贪心算法的实现，通过从起点出发去寻找与其他点的最短距离，找到该最短距离的顶点，然后里该顶点为中转点，去寻找

以中转点出发的到其他顶点更近的距离，从而通过一步步的选择找到最优的路径！

2：算法流程

流程如上图所示，v0到其他顶点的距离设置成一个数组path[0,1,5,65535,65535,65535,65535,65535,65535]其中，65535代v0待这个点之间距离无穷大。首先在path中找到最近的一个顶点为v1，然后我们以v1为中转点来更新该数组，怎么更新尼？加入以v0过v1然后达到其他顶点的路径小于v0直接到达其他顶点的路径，则直接用该较小路径来替代数组中数值。依次不断循环来去找到v0到v2，到v3，到v4，到v5，到v6，到v7，到v8的距离。就可以了。

3：代码示例

package nearstWay;

import sun.security.util.Length;

/**
 * @author ：dazhu
 * @date ：Created in 2020/3/18 11:37
 * @description：最短路径
 * @modified By：
 * @version: $
 */
public class Main {
    public static void main(String[] args){
        //制作顶点数组，邻接矩阵
        int inf = 65535;
        Vertex[] vertexList = new Vertex[]{
                new Vertex("v0"),
                new Vertex("v1"),
                new Vertex("v2"),
                new Vertex("v3"),
                new Vertex("v4"),
                new Vertex("v5"),
                new Vertex("v6"),
                new Vertex("v7"),
                new Vertex("v8")
        };
        int[][] adjMat = new int[][]{
                {  0,  1,  5,inf,inf,inf,inf,inf,inf},
                {  1,  0,  3,  7,  5,inf,inf,inf,inf},
                {  5,  3,  0,inf,  1,  7,inf,inf,inf},
                {inf,  7,inf,  0,  2,inf,  3,inf,inf},
                {inf,  5,  1,  2,  0,  3,  6,  9,inf},
                {inf,inf,  7,inf,  3,  0,inf,  5,inf},
                {inf,inf,inf,  3,  6,inf,  0,  2,  7},
                {inf,inf,inf,inf,  9,  5,  2,  0,  4},
                {inf,inf,inf,inf,inf,inf,  7,  4,  0},
        };
        Graph g = new Graph(vertexList,adjMat);
        Dijkstra djk = new Dijkstra(g);
        djk.findNearestWay(0);
    }
}
class Dijkstra{
    public Graph g = null;
    public int nVertex;
    public int[] pathMatirx;//用于存储最短路径下表的数组
    public int[] shortPathTable;//用于存储个点最短路径的权重值
    public int[] markArr;//markArr[k] = 1代表求得v0到vk的最短路径了
    public Dijkstra(Graph g){
        this.g = g;
        this.nVertex = g.vertexList.length;
        //根据输出的graph顶点数量来初始化数组
        this.pathMatirx =new int[nVertex];
        this.shortPathTable = new int[nVertex];
        this.markArr = new int[nVertex];
    }

    public void findNearestWay(int v0){
        int v=0,w=0,k=0;
        int min;
        //初始化数据
        for(int i=0;i<nVertex;i++){
            this.markArr[i] = 0;
            //初始化shotPathTable为v0到其他顶点的距离
            this.shortPathTable[i] = g.adjMat[v0][i];
            //初始化路径数组为0
            this.pathMatirx[i] = 0;
        }
        //代表v0到v0之间不需要求路径！！
        this.markArr[0] = 1;
        //开始主循环，每次循环求的v0到某个顶点v之间的最短路径，直到所有顶点都求的了！！！
        for(v=1;v<nVertex;v++){
            min = 65535;//当前所知离v0最近的距离，初始化成适当大的值
            //寻找里v0最近的顶点
            for(w =0;w<nVertex;w++) {
                //当且仅当该点没有被寻找最短路径且路径小于min下
                if ((markArr[w]==0)&&shortPathTable[w]<min){
                    //保存最短路径中的顶点于k
                    k = w;
                    //将min替换为该最短路径
                    min = shortPathTable[w];
                }
            }
            //将目前找到的最近顶点置为1，代表着v0到vk已经找到了最短路径
            this.markArr[k] = 1;

            //修正当前最短路径及距离！！
            //如果v0经过前面求得vk到达其他顶点的距离，小于v0直接道道其他顶点的距离
            //则更新v0的shortPathTable[]为最短距离
            for(w =0;w<nVertex;w++){
                if(markArr[w]==0&&min+g.adjMat[k][w]<shortPathTable[w]){
                    shortPathTable[w] = min+g.adjMat[k][w];
                    pathMatirx[w] = k;
                }
            }
        }
    }
}

class Graph{
    public  Vertex[] vertexList;
    public int adjMat[][];
    public int nVerts;

    public Graph(Vertex[] vertexList,int[][] adjMat){
        //初始化，顶点数组
        this.vertexList = vertexList;
        //创建边矩阵
        this.adjMat = adjMat;
        //初始顶点顺序
        this.nVerts = 0;

    }
    //添加顶点到顶点数组
    public void addVertex(String lab){
        vertexList[nVerts++] = new Vertex(lab);
    }

    //添加边到边矩阵
    //weight 0:权值为0的相连
    //weight k:权值为k的相连
    //weight 无穷大:不相连
    public void addEdge(int start,int end,int weight){
        adjMat[start][end] = weight;
        adjMat[end][start] = weight;
    }

    //显示所有顶点
    public void showVertexs(){
        for(int i=0;i<vertexList.length;i++){
            System.out.println(vertexList[i]);
        }
    }
    //打印指定顶点
    public void printVertex(int v){
        System.out.println(vertexList[v].label);
    }

}

//顶点类的结构
//顶点可以存在数组中，用index来表示，
//当然也可以存在链表中
class Vertex{
    public String label;//label
    public boolean wasVisited;//是否遍历过的标记。
    public Vertex(String label){
        this.label = label;
        wasVisited = false;
    }
}

原文地址：https://www.cnblogs.com/dazhu123/p/12519611.html