Dijkstra最短路径实现（java）

1.算法解决的问题：从某个源点到其余各顶点的最短路径问题。

该算法并不是一下子就求出了源点到终点的最短路径，而是一步步求出它们之间顶点的最短路径，过程中都是基于已经求出的最短路径的基础上，求得更远顶点的最短路径，最终得到你要的结果。

/Dijkstra算法，求有向网G的v0顶点到其余顶点v最短路径P[v]及带权长度D[v]。 P[v]的值为前驱顶点下标，D[v]表示v0到v的最短路径长度和。/
Void shortpath_dijkstra(G,v0,P[],D[]);//G中有邻接矩阵。过程中需要final[]数组判断是否已求得最短路径。

java实现如下：

package mianshiti;

import java.util.Stack;

public class Dijkstra {
    public static final int Maxvex=9;
    public static final int INF=999;
    public static void shortpath_Dijkstra(int[][] maxtirx,int v0,int[] pre,int[] dis){
        int v,min,w,k=0;
        boolean[] fina=new boolean[Maxvex];
        //初始化
        for(v=0;v<Maxvex;v++){
            fina[v]=false;
            pre[v]=-1;//-1表明的是出发节点到节点v是直接路径，没有中途节点.
            dis[v]=maxtirx[v0][v];
        }
        fina[v0]=true;
        dis[v0]=0;
        //对v0以外的点都搜一次
        for(v=0;v<Maxvex;v++){
            min=INF;
            for(w=0;w<Maxvex;w++){
                if(!fina[w]&&(dis[w]<min)) {//没有被找到最短距离，并且找更近一点的
                    min=dis[w];
                    k=w;
                }
            }
            //找到离当前v最近的k，并更新最短
            fina[k]=true;
            for(w=0;w<Maxvex;w++){
                if(!fina[w]&&(min+maxtirx[k][w]<dis[w])){
                    dis[w]=min+maxtirx[k][w];
                    pre[w]=k;
                }
            }
        }

    }
    public static void print_shortpath(int v0,int[] pre,int[] dis){//打印最短路径函数
        int i,j;
        Stack<Integer> stack=new Stack<>();
        for(i=0;i<Maxvex;i++){
            j=i;
            while (pre[j]!=-1){
                stack.push(j);
                j=pre[j];
            }
            stack.push(j);
            System.out.printf("%d->%d,length:%d,path:%d->",v0,i,dis[i],v0);
            while (!stack.empty()){
                if(stack.peek()==i){
                    System.out.printf("%d",stack.pop());
                }else {
                    System.out.printf("%d->",stack.pop());
                }
            }
            System.out.println();
        }
    }

    public static void main(String[] args){
        int[][] maxtir=new int[Maxvex][Maxvex];
        int[] pre=new int[Maxvex];
        int[] dis=new int[Maxvex];
        for(int i=0;i<Maxvex;i++){
            for(int j=0;j<Maxvex;j++){
                if(i==j){
                    maxtir[i][j]=0;
                }else
                    maxtir[i][j]=INF;
            }
        }
        maxtir[0][1]=1;maxtir[0][2]=5;
        maxtir[1][0]=1;maxtir[1][2]=3; maxtir[1][3]=7;maxtir[1][4]=5;
        maxtir[2][0]=5;maxtir[2][1]=3; maxtir[2][4]=1;maxtir[2][5]=7;
        maxtir[3][1]=7;maxtir[3][4]=2; maxtir[3][6]=3;
        maxtir[4][1]=5;maxtir[4][2]=1; maxtir[4][3]=2;maxtir[4][5]=3;maxtir[4][6]=6;maxtir[4][7]=9;
        maxtir[5][2]=7;maxtir[5][4]=3; maxtir[5][7]=5;
        maxtir[6][3]=3;maxtir[6][4]=6; maxtir[6][7]=2;maxtir[6][8]=7;
        maxtir[7][4]=9;maxtir[7][5]=5; maxtir[7][6]=2;maxtir[7][8]=4;
        maxtir[8][6]=7;maxtir[8][7]=4;

        shortpath_Dijkstra(maxtir,0,pre,dis);
        print_shortpath(0,pre,dis);

    }
}

图中的数据来自《大话数据结构》7.7.1 迪杰斯特拉（Dijkstra）算法