迪杰斯特拉算法

求解最短路径（一个顶点到任意顶点的最短距离）

基本思路
（1）选取一个结点index,从index结点出发更新它到其余各点的距离(dis[i]=Min(dis[index]+matrix[index][i],dis[i]))
（2）进行更新时，要判断该点是否已经被访问过，如果访问换取下一个节点。
（3）更新完index结点的周围结点后，在dis数组中找出一个距离最短且没有被访问的结点，在重复（1）（2），直至所有顶点全被加入到already_arr数组中。
 ##dis[i]:表示选取的结点index到i结点的最短距离

java代码实现

import java.util.Arrays;

public class Dijkstra {
    public static void main(String[] args) {
        char[] vertex={'A','B','C','D','E','F','G'};
        int [][]matrix=new int[vertex.length][vertex.length];
        final int N=65535;
        matrix[0]=new int[]{N,5,7,N,N,N,2};
        matrix[1]=new int[]{5,N,N,9,N,N,3};
        matrix[2]=new int[]{7,N,N,N,8,N,N};
        matrix[3]=new int[]{N,9,N,N,N,4,N};
        matrix[4]=new int[]{N,N,8,N,N,5,4};
        matrix[5]=new int[]{N,N,N,4,5,N,6};
        matrix[6]=new int[]{2,3,N,N,4,6,N};
        Graph graph=new Graph(vertex,matrix, vertex.length);
        graph.dijkstra(6);
        graph.showDsj();

    }
}
class Graph{
    char[] vertex;
    int [][]matrix;
    int length;
    private VistedVertex vv;

    public Graph(char[] vertex, int[][] matrix,int length) {
        this.vertex = vertex;
        this.matrix = matrix;
        this.length=length;

    }

    public void dijkstra(int index){
        vv=new VistedVertex(length,index);
        update(index);
        int arr;
        for (int i=1;i<length;i++){
            arr=vv.updateArr();
            update(arr);
        }
    }
    //更新index节点到周围节点的前驱和距离
    public void update(int index){
        int len=0;
        for (int i=0;i<length;i++){
            len=matrix[index][i]+vv.getDis(index);
            if (!vv.IsAlready(i)&&len<vv.getDis(i)){
                vv.updateDis(i,len);
                vv.updatePre(i,index);

            }
        }
    }
    public void showDsj(){
        vv.show();
    }


}
class VistedVertex {
    private int[] already_arr;
    private int[] pre_visited;
    private int[] dis;

    public VistedVertex(int length,int index) {
        this.already_arr=new int[length];
        this.dis=new int[length];
        this.pre_visited=new int[length];
        Arrays.fill(dis,65535);
        already_arr[index]=1;
        this.dis[index]=0;
    }
    //判断该节点是否被访问过 访问过：true 没有：false
    public boolean IsAlready(int index){
        return already_arr[index]==1;
    }

    //获取某一点的距离
    public int getDis(int index){
        return dis[index];
    }


    //更新前驱节点
    public void updatePre(int i,int index){
        pre_visited[i]=index;
    }
    //更新距离
    public void updateDis(int index,int len){
        dis[index]=len;
    }
    public int updateArr(){
        int min=65535;
        int index=0;
        for (int i=0;i<already_arr.length;i++){
            if (!IsAlready(i)&&dis[i]<min){
                min=dis[i];
                index=i;
            }
        }
        already_arr[index]=1;
        return index;
    }

    //显示最后的结果
    public void show(){
        char[] vertex={'A','B','C','D','E','F','G'};
        System.out.println("================");
        //输出already_arr
        for (int i=0;i<already_arr.length;i++){
            System.out.print(vertex[i]+" ");
        }
        System.out.println();
        for (int i:pre_visited){
            System.out.print(vertex[i]+" ");
        }
        System.out.println();
        for (int i:dis){
            System.out.print(i+" ");
        }

    }
}