迪杰斯特拉算法代码详解（java)

迪杰斯特拉这是一个按路径长度递增次序产生最短路径的算法。具体代码如下：

/*1*/import java.util.Scanner;
/*2*/class Graph{                         
/*3*/ int[][] edge;   //图的邻接矩阵                    
/*4*/ int numPoint;   //图中顶点数目                   
/*5*/ int numEdeges;  //图中的边数目                 
/*6*/ public Graph() {}
/*7*/ public Graph(int numPoint,int numEdeges)
/*8*/ {
/*9*/  this.numEdeges=numEdeges;
/*10*/  this.numPoint=numPoint;
/*11*/  int a=2000;
/*12*/  edge= new int[][]{
/*13*/    {a,1,5,a,a,a,a,a,a},
/*14*/    {1,a,3,7,5,a,a,a,a},
/*15*/    {5,3,a,a,1,7,a,a,a},
/*16*/    {a,7,a,a,2,a,3,a,a},
/*17*/    {a,5,1,2,a,3,6,9,a},
/*18*/    {a,a,7,a,3,a,a,5,a},
/*19*/    {a,a,a,3,6,a,a,2,7},
/*20*/    {a,a,a,a,9,5,2,a,4},
/*21*/    {a,a,a,a,a,a,7,4,a}
/*22*/        };
/*23*/ }
/*24*/}
/*25*/public class dsd {
/*26*/    public static void Shortest_path_Dijstra(Graph a,int[] Pathara,int[] ShortPath_table)
/*27*/    {
/*28*/   int v,w,k = 0,min;
/*29*/   int[] km=new int[a.numPoint];
/*30*/   for(v=0;v<a.numPoint;v++)
/*31*/   {
/*32*/  km[v]=0;                         
/*33*/  ShortPath_table[v]=a.edge[0][v];         
/*34*/  Pathara[v]=0;            
/*35*/   }
/*36*/   ShortPath_table[0]=0;              
/*37*/   km[0]=1;                            
/*38*/   for(v=1;v<a.numPoint;v++)
/*39*/   {
/*40*/  min=2000;
/*41*/  for(w=0;w<a.numPoint;w++)
/*42*/  {
/*43*/   if(km[w]==0&&ShortPath_table[w]<min)
/*44*/   {
/*45*/    k=w;
/*46*/    min=ShortPath_table[w];
/*47*/   }
/*48*/  }
/*49*/  km[k]=1;                       
/*50*/  for(w=0;w<a.numPoint;w++)
/*51*/  {
/*52*/   if(km[w]==0&&(min+a.edge[k][w])<ShortPath_table[w])
/*53*/   {
/*54*/    ShortPath_table[w]=min+a.edge[k][w];
/*55*/    Pathara[w]=k;
/*56*/   }
/*57*/  }
/*58*/      }
/*59*/   for(int i=0;i<a.numPoint;i++)
/*60*/   {
/*61*/    System.out.println("Pathara:"+Pathara[i]);
/*62*/    System.out.println("ShortPath_table:"+ShortPath_table[i]);
/*63*/   }
/*64*/    }
/*65*/ public static void main(String[] args)
/*66*/   {
/*67*/  Graph a=new Graph(9,16);
/*68*/  int[] Pathara=new int[a.numPoint];
/*69*/  int[] ShortPath_table=new int[a.numPoint]
/*70*/  Shortest_path_Dijstra(a,Pathara,ShortPath_table);
/*71*/   }
/*72*/}

上述代码是找出v0，到v8的最短路径，代码所用到的图如下：

代码讲解：
**1~24行代码：**这几行代码是用来创建具体实例所用到的图，这两我们用的是上面所展示的图，其中a代表的是一个最大值，既图中所有权值都无法到达的一个距离，值可以任取，但条件是不能小于图中权值的最大值。表示图的方式用到的是邻接矩阵。
**26~64行代码：**这几行代码是我们具体实现迪杰斯特拉算法的核心代码，详细讲解见下：
**29行代码：**这里定义了一个数组，数组用来标记顶点是否已经被访问，或者理解为顶点是否已经包含在最短路径中
**30~34行代码：**这几行代码主要是为了给数组赋初值，km数组全部赋值为0表示顶点均未被访问 过，ShortPath_table数组这里是用来保存最短路径的长度，ShortPath_table[2]就表示v0到v2的最短路径长度，即为1，这里将其赋值为邻接矩阵的第一行，是应为这里我们用到的是v0做为路径的起点，最后Pathara数组用来记录最短路径，打个比方，这个程序到最后Pathara数组变为了{0,0,1,4,2,4,3,6,7},如何理解这个数组，假如我们要查找v0到v8的最短路径，从Pathara[8]=7开始就是v8->v7，再看Pathara[7]=6，所以v8->v7->v6，再看Pathara[6]=3，则路径变为v8->v7->v6->v3，接着看Pathara[3]=4，路径变为v8->v7->v6->v3->v4，然后Pathara[4]=2，路径继续变化v8->v7->v6->v3->v4->v2，接下来Pathara[2]=1，路径延长到v8->v7->v6->v3->v4->v2->v1，最后Pathara[1]=0，到达v0，也得出v8到v0最短路径v8->v7->v6->v3->v4->v2->v1->v0，以上述的方法，可以从Pathara数组中得出任何点到v0得最短路径。这里将Pathara数组元素全部初始化为0。
**36~37行代码：**这两行代码ShortPath_table[0]=0表示v0到v0得最短路径显而易见为0，km[0]=1，表示v0已加入最短路径中
**38行代码：**这个for循环每一个循环都可以求出v0到一个顶点的最短路径
**41行代码：**这个嵌套的for循环的作用是找出ShortPath_table数组中的最小值，由上面我们知道ShortPath_table数组用来记录v0到各个顶点最短路径的长度，并记录最短路径上顶点的下标。
**49行代码：**将km[k]设置为1，k表示已知v0到vk最短路径上，因此将km[k]设置为1，表示vk已经加人最短路径中
**50行代码：**这个循环主要是用来修改ShortPath_table数组和记录Pathara数组。这里比较难理解一点，打个比方我由41行那个for循环可以找出v0到v1比v0到v2路径要短，所以k值会记为1，min值为1，km[1]会设置为1，此时到了50行循环，我吗们会发现ShortPath_table[2]会大于1+3即v1到v2的路径长度会小于v0直接到v2的长度，所以我们得修改ShortPath_table数组保存的最短路径值得值，并得到了v0到v2的最短路径并记录到Pathara数组中。