[从今天开始修炼数据结构]图的最短路径 —— 迪杰斯特拉算法和弗洛伊德算法的详解与Java实现

在网图和非网图中，最短路径的含义不一样。非网图中边上没有权值，所谓的最短路径，其实就是两顶点之间通过的边数最少的路径；而对于网图来讲，最短路径，是指两顶点之间通过的边上权值之和最少的路径，咱们称路径上第一个顶点是源点，最后一个顶点是终点。

咱们讲解两种求最短路径的算法。第一种，从某个源点到其他各顶点的最短路径问题。

　　1，迪杰斯特拉(Dijkstra)算法

　　　　迪杰斯特拉算法是一个按路径长度递增的次序产生最短路径的算法，每次找到一个距离V0最短的点，不断将这个点的邻接点加入判断，更新新加入的点到V0的距离，而后再找到如今距离V0最短的点，循环以前的步骤。有些相似以前的普里姆算法，是针对点进行运算，贪心算法。

　　　　这里咱们首先约定，Vi在vertex[]中存储的index = i，以方便阐述思路。思路以下：

　　　　（1）咱们拿到网图，以下.咱们要找到从V0到V8的最短路径，使用邻接矩阵存储的图结构。咱们寻找距离V0最近的顶点，找到了邻接点V1，距离是1，将其连入最短路径。

 

　　

　　（2）修正与V1直接相关联的全部点到V0的最短路径。好比本来V2到V0的路径是5，如今经过V1，将其修改成1+3 = 4.，将V4置为6，V3置为8.咱们如今就须要一个数组来存储每一个点到V0的最短路径了。咱们设置一个数组ShortPathTable[numVertex]来存储。

　　　　同时咱们还须要存储每一个点到V0的最短路径，为此咱们设置一个数组Patharc[numVertex]，P[i] = k表示Vi到V0的最短路径中，Vi的前驱是Vk。咱们还须要一个数组来存储某个顶点是否已经找到了到V0的最短路径，为此咱们设置finals[numVertex]。此时

    S[] = { 0 , 1 , 4 , 8 , 6 , I , I , I , I }
    P[] = { 0 , 0 , 1 , 1 , 1 , 0 , 0 , 0 , 0 }
    f[] = { 1 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 }

　　（3）此时拿到与V0距离最短的点（尚未加入最短路径的，即final[i] = 0的点），这里是V2，而后更新V2的邻接点V4，V5到V0的最短路径分别为1+3+1=5和1+3+7=11，并将V2加入最短路径

    S[] = { 0 , 1 , 4 , 8 , 5 , I , I , I , I }
    P[] = { 0 , 0 , 1 , 1 , 2 , 0 , 0 , 0 , 0 }
    f[] = { 1 , 1 , 1 , 0 , 0 , 0 , 0 , 0 , 0 }

　　

 

 

　　　　接下来的步骤跟前面相似，我就再也不重复了，你们应该也理解迪杰斯特拉算法的步骤了，下面来看代码实现。

    public void ShortestPath_Dijkstra(){
        int[] ShortPathTable= new int[numVertex];
        int[] Patharc = new int[numVertex];
        int[] finals = new int[numVertex];

        //初始化
        for (int i = 0; i < numVertex; i++){
            ShortPathTable[i] = edges[0][i];    //初始化为v0的邻接边
            Patharc[i] = 0;
            finals[i] = 0;
        }
        finals[0] = 1;  //v0无需找本身的邻边

        int minIndex = 0;   //用来保存当前已经发现的点中到V0距离最短的点
        for (int i = 1; i < numVertex; i++){
            //找到目前距离V0最近的点
            int min = INFINITY;
            for (int index = 0; index < numVertex; index++){
                if (finals[index] != 1 && ShortPathTable[index] < min){
                    minIndex = index;
                    min = ShortPathTable[index];
                }
            }
            finals[minIndex] = 1;
            //更新还未加入最短路径的点到V0的距离
            for (int index = 0; index < numVertex; index++){
                if (finals[index] != 1 && (ShortPathTable[index] > (min + edges[minIndex][index]))){
                    ShortPathTable[index] = min + edges[minIndex][index];
                    Patharc[index] = minIndex;
                }
            }
        }
        //输出最短路径
        int s = 8;
        System.out.println(8);
        while ( s != 0){
            s = Patharc[s];
            System.out.println(s);
        }
    }

　　其实根据这个算法获得了v0到任意一个顶点的最短路径和路径长度的。时间复杂度O(n方)。

　　若是咱们想获得v1，或者v2等到任意一个顶点的最短路径呢？咱们要再跑一次这个算法才能获得这样复杂度就达到了O(n³)，这是咱们所不能接受的。下面咱们来介绍一种直接获得每个顶点到另一个顶点的最短路径。

　　2，弗洛伊德(Floyd)算法

　　　　弗洛伊德算法的想法是，若是V1到V2的距离，大于V1到V0再从V0到V2的距离，那么就把V1到V0的权值的拷贝，改成V1到V0+V0到V2. 同时把储存的最短路径也改掉，直到网中的每一条边都被遍历。

　　　　咱们用二维矩阵ShortPathTable存储行号到列号的最短路径的权值之和（初始化为邻接矩阵）；Patharc存储行号到列号的最短路径中列号元素的前驱。初始化以下

　　　　举例以下：

 

 

 　　　　ShortPathTable矩阵： 　　Patharc矩阵：

 

 

 　　　　（1）从V0进入网图中，此时没有什么须要变化的。

　　　　 （2）到达V1，让全部的顶点的路径都从V1通过，发现V0到V2的路径大于先到V1再到V2的路径，因此将S矩阵和P矩阵中的相应位置更改。同理S[0][3] = 8, S[0][4] = 6。

 

 

 

 

后面同理，依次循环V2~V8，针对每一个顶点做为中转获得计算结果。这样咱们的最短路径就完成了。

实现代码以下：

    public void ShortestPath_Floyd(){
        int[][] ShortPathTable = new int[numVertex][numVertex];
        int[][] Patharc = new int[numVertex][numVertex];
        //初始化两个矩阵
        for (int row = 0; row < numVertex; row++){
            for (int col = 0; col < numVertex; col++){
                ShortPathTable[row][col] = edges[row][col];
                Patharc[row][col] = col;
            }
        }

        for (int path = 0; path < numVertex; path++){
            for (int row = 0; row < numVertex; row++){
                for (int col = 0; col < numVertex; col++){
                    if (ShortPathTable[row][col] > (ShortPathTable[row][path] + ShortPathTable[path][col])){
                        ShortPathTable[row][col] = (ShortPathTable[row][path] + ShortPathTable[path][col]);
                        Patharc[row][col] = Patharc[row][path];
                    }
                }
            }
        }

        //打印看结果
        for (int row = 0; row < numVertex; row++) {
            for (int col = 0; col < numVertex; col++) {
                System.out.print(ShortPathTable[row][col] + "\t");
            }
            System.out.println();
        }
        System.out.println("***********************************");
        for (int row = 0; row < numVertex; row++) {
            for (int col = 0; col < numVertex; col++) {
                System.out.print(Patharc[row][col] + "\t");
            }
            System.out.println();
        }
    }

结果：

0    1    4    7    5    8    10    12    16    
1    0    3    6    4    7    9     11    15    
4    3    0    3    1    4    6     8    12    
7    6    3    0    2    5    3     5    9    
5    4    1    2    0    3    5     7    11    
8    7    4    5    3    0    7     5    9    
10   9    6    3    5    7    0     2    6    
12   11   8    5    7    5    2     0    4    
16   15   12   9    11   9    6     4    0    
***********************************
0    1    1    1    1    1    1    1    1    
0    1    2    2    2    2    2    2    2    
1    1    2    4    4    4    4    4    4    
4    4    4    3    4    4    6    6    6    
2    2    2    3    4    5    3    3    3    
4    4    4    4    4    5    7    7    7    
3    3    3    3    3    7    6    7    7    
6    6    6    6    6    5    6    7    8    
7    7    7    7    7    7    7    7    8    

咱们能够发现，P矩阵的第一列与迪杰斯特拉算法的结果是同样的。它的时间复杂度是三次方的，但它能够解决多个顶点到多个顶点的最短路径问题，比一样场景下的迪杰斯特拉算法要省时得多。

上面是两个算法对于无向图的应用，实际上对于有向图，也是一样的使用效果。由于无向图和有向图的区别仅仅是邻接矩阵是否对称而已。