数据结构 Dijkstra(迪杰斯特拉)算法

Dijkstra(迪杰斯特拉)算法
是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径，该算法要求图中不存在负权边。
主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。

算法思想： 图 G=(V,E) 中，假设每条边E[i]的长度为w[i]，找到由顶点V0到其余各点的最短路径
设G=(V,E)是一个带权有向图，把图中顶点集合V分成两组：
第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径 , 就将加入到集合S中，直到全部顶点都加入到S中，算法就结束了），
第二组为其余未确定最短路径的顶点集合（用U表示），
按最短路径长度的递增次序依次把第二组的顶点加入S中。在加入的过程中，总保持从源点v到S中各顶点的最短路径长度不大于从源点v到U中任何顶点的最短路径长度。
每个顶点对应一个距离：
S中的顶点的距离是从v到此顶点的最短路径长度，
U中的顶点的距离是从v到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。

算法步骤：
1、初始化：
S只包含源点，即S＝{v}，v的距离为0。
U包含除v外的其他顶点，即:U={其余顶点}，
若v与U中顶点u有边，则

import java.io.IOException;
import java.util.Scanner;

public class MatrixUDG2 {

    private int mEdgNum;        // 边的数量
    private char[] mVexs;       // 顶点集合
    private int[][] mMatrix;    // 邻接矩阵
    private static final int INF = 100;//Integer.MAX_VALUE;   // 最大值

    public MatrixUDG2(char[] vexs, int[][] matrix) {     
        int vlen = vexs.length; // 初始化"顶点数"和"边数"    
        mVexs = new char[vlen]; // 初始化"顶点"
        for (int i = 0; i < mVexs.length; i++)
            mVexs[i] = vexs[i];

        mMatrix = new int[vlen][vlen]; // 邻接矩阵： 初始化"边" mMatrix[i][j]=1，则表示"顶点i(即mVexs[i])"和"顶点j(即mVexs[j])"是邻接点；mMatrix[i][j]=0，则表示它们不是邻接点
        for (int i = 0; i < vlen; i++)
            for (int j = 0; j < vlen; j++)
                mMatrix[i][j] = matrix[i][j];
        // 统计"边"
        mEdgNum = 0;
        for (int i = 0; i < vlen; i++)
            for (int j = i+1; j < vlen; j++)
                if (mMatrix[i][j]!=INF)
                    mEdgNum++;
    }

    //返回顶点v的第一个邻接顶点的索引，失败则返回-1
    private int firstVertex(int v) {
        if (v<0 || v>(mVexs.length-1))
            return -1;
        for (int i = 0; i < mVexs.length; i++)
            if (mMatrix[v][i]!=0 && mMatrix[v][i]!=INF)
                return i;

        return -1;
    }

    // 返回顶点v相对于w的下一个邻接顶点的索引，失败则返回-1
    private int nextVertex(int v, int w) {
        if (v<0 || v>(mVexs.length-1) || w<0 || w>(mVexs.length-1))
            return -1;
        for (int i = w + 1; i < mVexs.length; i++)
            if (mMatrix[v][i]!=0 && mMatrix[v][i]!=INF)
                return i;
        return -1;
    }

    // 返回顶点v相对于w的下一个邻接顶点的索引，失败则返回-1
    private int nextVertexs(int v) {
        if (v<0 || v>(mVexs.length-1))
            return -1;
        for (int i=0; i < mVexs.length; i++) {
            if (mMatrix[v][i]!=0 && mMatrix[v][i]!=INF) {
                System.out.print("邻接点"+mVexs[i]+"权重("+mMatrix[v][i]+")");
            }
        }
        return -1;
    }

    //获取图中的边
    private void getEdges() {
        System.out.print("edges = "+mEdgNum);
        System.out.println();
        for (int i=0; i < mVexs.length; i++) {
            for (int j=0; j < mVexs.length; j++) {
                if (mMatrix[i][j]!=INF && mMatrix[i][j] != 0) {
                    System.out.println("结点"+mVexs[i]+"和结点"+mVexs[j]+"的边，权重"+mMatrix[i][j]);
                }
            }
        }
        System.out.println();
    }

    /*
     * Dijkstra最短路径。
     * 即，统计图中"顶点vs"到其它各个顶点的最短路径。
     * vs   -- 起始顶点(start vertex)。即计算"顶点vs"到其它顶点的最短路径。
     * prev -- 前驱顶点数组。即，prev[i]的值是"顶点vs"到"顶点i"的最短路径所经历的全部顶点中，位于"顶点i"之前的那个顶点。
     * dist -- 长度数组。即，dist[i]是"顶点vs"到"顶点i"的最短路径的长度。
     */
    public void dijkstra(int vs, int[] prev, int[] dist) {
        // flag[i]=true表示"顶点vs"到"顶点i"的最短路径已成功获取
        boolean[] flag = new boolean[mVexs.length];

        // 初始化
        for (int i = 0; i < mVexs.length; i++) {
            flag[i] = false;          // 顶点i的最短路径还没获取到。
            prev[i] = 0;              // 顶点i的前驱顶点为0。
            dist[i] = mMatrix[vs][i];  // 顶点i的最短路径为"顶点vs"到"顶点i"的权。
        }

        // 对"顶点vs"自身进行初始化
        flag[vs] = true;
        dist[vs] = 0;

        // 遍历mVexs.length-1次；每次找出一个顶点的最短路径。
        int k=0;
        for (int i = 1; i < mVexs.length; i++) {
            // 寻找当前最小的路径；
            // 即，在未获取最短路径的顶点中，找到离vs最近的顶点(k)。
            int min = INF;
            for (int j = 0; j < mVexs.length; j++) {
                if (flag[j]==false && dist[j]<min) {
                    min = dist[j];
                    k = j;
                    //System.out.println("min = "+min+", k ="+k);
                }
            }
            // 标记"顶点k"为已经获取到最短路径
            flag[k] = true;

            // 修正当前最短路径和前驱顶点
            // 即，当已经"顶点k的最短路径"之后，更新"未获取最短路径的顶点的最短路径和前驱顶点"。
            for (int j = 0; j < mVexs.length; j++) {
                int tmp = (mMatrix[k][j]==INF ? INF : (min + mMatrix[k][j]));
                if (flag[j]==false && (tmp<dist[j]) ) {
                    dist[j] = tmp;
                    //System.out.println("dist[j] = "+dist[j]+", j = "+j);
                    prev[j] = k;
                }
            }
        }

        // 打印dijkstra最短路径的结果
        System.out.printf("dijkstra(%c): \n", mVexs[vs]);
        for (int i=0; i < mVexs.length; i++)
            System.out.printf("shortest(%c, %c)=%d\n", mVexs[vs], mVexs[i], dist[i]);
    }

    public static void main(String[] args) {
        char[] vexs = {
   'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int matrix[][] = { 
                 /*A*//*B*//*C*//*D*//*E*//*F*//*G*/
         /*A*/ {   0,  12, INF, INF, INF,  16,  14},
         /*B*/ {  12,   0,  10, INF, INF,   7, INF},
         /*C*/ { INF,  10,   0,   3,   5,   6, INF},
         /*D*/ { INF, INF,   3,   0,   4, INF, INF},
         /*E*/ { INF, INF,   5,   4,   0,   2,   8},
         /*F*/ {  16,   7,   6, INF,   2,   0,   9},
         /*G*/ {  14, INF, INF, INF,   8,   9,   0}};       

        int length = vexs.length;
        int i=0, j;

        System.out.print("结点表： \n");
        for(char label:vexs) {
            System.out.print("结点"+i+", 标识"+label+"\n");
            i++;
        }

        System.out.print("\n");
        System.out.print("邻接矩阵： \n");
        for(i=0; i<length; i++){
            for(j=0; j<length; j++) {
                System.out.printf("%2d  ", matrix[i][j]);
            }
            System.out.print("\n");
        }
        System.out.print("\n");

        MatrixUDG2 pG;
        pG = new MatrixUDG2(vexs, matrix);

        //pG.getEdges();
        for(i=0; i<length; i++){
            //System.out.printf("顶点%d邻接点%d\n", i, pG.firstVertex(i));
            System.out.print("顶点"+vexs[i]);
            pG.nextVertexs(i);
            System.out.print("\n");
        } 
        System.out.print("\n");

        int[] prev = new int[pG.mVexs.length];
        int[] dist = new int[pG.mVexs.length];
        // dijkstra算法获取"第4个顶点"到其它各个顶点的最短距离
        pG.dijkstra(3, prev, dist);
    }
}