常用的十种算法--迪杰斯特拉(Dijkstra)算法

1.迪杰斯特拉(Dijkstra)算法介绍：

        迪杰斯特拉(Dijkstra)算法是 典型最短路径算法，用于计算一个结点到其他结点的最短路径。它的主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。

2.在有向图 G=(V,E) 中，假设每条边 E[i] 的长度为 w[i]，找到由顶点 V0 到其余各点的最短值。

本节将对算法流程进行模拟，设置Graph为包含7个顶点和9条边的有向无环图，源点为0，计算从源点0到剩余节点的最短路径，Graph如下：

        每个节点将维护shortest和visited两个数据结构，shortest存储v0到该节点的最短路径，visited存储v0到该节点的最短路径是否求出。S为已求出最短路径的节点，T为未求出最短路径的节点。源节点只允许将S中的节点作为中间节点来计算到达其它节点的最短路径，不允许将T中的节点作为中间节点来计算到达其它节点的最短路径。随着S中节点的增加，源节点可达的节点才会增加。初始状态下，源节点只可达节点1和节点3。

 3.代码实现：

package algorithm;

/**
 * @author WuChenGuang
 */
public class DijstraAlgorithm {

    public static int MaxValue = 100000;

    public static void main(String[] args) {

        // 顶点数
        int vertex = 7;
        // 边数
        int edge = 10;

        int[][] matrix = new int[vertex][vertex];

        for (int i = 0; i < vertex; i++) {
            for (int j = 0; j < vertex; j++) {
                matrix[i][j] = MaxValue;
            }
        }

        matrix[0][1] = 6;
        matrix[1][2] = 5;
        matrix[0][3] = 2;
        matrix[3][1] = 7;
        matrix[3][4] = 5;
        matrix[1][2] = 5;
        matrix[1][5] = 3;
        matrix[4][5] = 5;
        matrix[5][4] = 2;
        matrix[4][6] = 1;

        int source = 0;
        dijstra(matrix, source);
    }

    /**
     * 迪杰斯特拉算法
     */
    public static void dijstra(int[][] matrix, int source) {
        // 最短路径长度
        int[] shortTest = new int[matrix.length];

        // 判断是否能够算出该顶点的最短距离
        int[] visited = new int[matrix.length];

        // 拼接有效的路径
        String[] path = new String[matrix.length];

        // 初始化路径
        for (int i = 0; i < matrix.length; i++) {
            path[i] = source + "-->" + i;
        }
        // 源点有效距离
        shortTest[source] = 0;
        // 有效的路径
        visited[source] = 1;

        for (int i = 1; i < matrix.length; i++) {
            int min = Integer.MAX_VALUE;
            int index = -1;

            for (int j = 0; j < matrix.length; j++) {
                if (visited[j] == 0 && matrix[source][j] < min) {
                    min = matrix[source][j];
                    index = j;
                }
            }

            shortTest[index] = min;
            visited[index] = 1;

            for (int m = 0; m < matrix.length; m++) {
                if (visited[m] == 0 && matrix[source][index] + matrix[index][m] < matrix[source][m]) {
                    matrix[source][m] = matrix[source][index] + matrix[index][m];
                    path[m] = path[index] + "--->" + m;
                }
            }
        }

        for (int i = 0; i < matrix.length; i++) {
            if (i != source) {
                if (shortTest[i] == MaxValue) {
                    System.out.println(source + "到" + i + "不可以直接到达");
                } else {
                    System.out.println(source + "到" + i + "的最短路径是:" + path[i] + " 最短距离是:" + shortTest[i]);
                }
            }
        }
    }
}

运行结果：