Java实现迪杰斯特拉算法

迪杰斯特拉算法（Dijkstra's algorithm）是一种用于求解带权有向图中单源最短路径的算法，其时间复杂度为O(V^2)，其中V为图中节点的数量。该算法适用于边的权重非负的情况。

以下是Java实现迪杰斯特拉算法的示例代码：

import java.util.*;

public class DijkstraAlgorithm {
    private static final int NO_PARENT = -1;

    private static void dijkstra(int[][] adjacencyMatrix, int startVertex) {
        int nVertices = adjacencyMatrix[0].length;

        // shortestDistances[i]会存储从startVertex到i的最短距离
        int[] shortestDistances = new int[nVertices];

        // visited[i]会标记是否已经访问过节点i
        boolean[] visited = new boolean[nVertices];

        // 初始情况下，从startVertex到所有节点的距离都为无穷大
        for (int i = 0; i < nVertices; i++) {
            shortestDistances[i] = Integer.MAX_VALUE;
        }

        // 从startVertex到自身的距离为0
        shortestDistances[startVertex] = 0;

        // parentVertices[i]会存储从startVertex到i的最短路径上i的前一个节点
        int[] parentVertices = new int[nVertices];

        // 初始情况下，从startVertex到所有节点的最短路径上不存在前一个节点
        parentVertices[startVertex] = NO_PARENT;

        // 根据Dijkstra算法，依次访问所有节点
        for (int i = 1; i < nVertices; i++) {
            int nearestVertex = -1;
            int shortestDistance = Integer.MAX_VALUE;
            // 选择当前未访问的距离startVertex最近的节点
            for (int j = 0; j < nVertices; j++) {
                if (!visited[j] && shortestDistances[j] < shortestDistance) {
                    nearestVertex = j;
                    shortestDistance = shortestDistances[j];
                }
            }
            // 将该节点标记为已访问
            visited[nearestVertex] = true;

            // 更新最短距离和前一个节点
            for (int k = 0; k < nVertices; k++) {
                int edgeDistance = adjacencyMatrix[nearestVertex][k];
                if (edgeDistance > 0 && (shortestDistance + edgeDistance) < shortestDistances[k]) {
                    parentVertices[k] = nearestVertex;
                    shortestDistances[k] = shortestDistance + edgeDistance;
                }
            }
        }

        printSolution(startVertex, shortestDistances, parentVertices);
    }

    private static void printSolution(int startVertex, int[] distances, int[] parents) {
        int nVertices = distances.length;
        System.out.print("Vertex\t Distance\tPath");
          
        for (int i = 0; i < nVertices; i++) {
            if (i != startVertex) {
                System.out.print("\n" + startVertex + " -> " + i + " \t\t " + distances[i] + "\t\t");
                printPath(i, parents);
            }
        }
    }

    private static void printPath(int currentVertex, int[] parents) {
        if (currentVertex == NO_PARENT) {
            return;
        }
        printPath(parents[currentVertex], parents);
        System.out.print(currentVertex + " ");
    }

    public static void main(String[] args) {
        int[][] adjacencyMatrix = {
            {0, 1, 4, 0, 0},
            {0, 0, 2, 5, 0},
            {0, 0, 0, 0, 3},
            {0, 0, 0, 0, 2},
            {0, 0, 0, 0, 0}
        };
        dijkstra(adjacencyMatrix, 0);
    }
}

该示例代码实现了Dijkstra算法，并输出了从起点到其他节点的最短路径和距离。在该示例代码中，我们使用邻接矩阵来表示图，其中0表示两个节点之间没有边，非零值表示两个节点之间的边的权重。在示例代码中，我们使用了一个二维数组adjacencyMatrix来存储邻接矩阵。我们还定义了一个dijkstra方法，该方法接受一个邻接矩阵和起点的索引作为参数，并使用Dijkstra算法计算从起点到所有其他节点的最短路径。最后，我们在main方法中创建了一个邻接矩阵，并调用dijkstra方法来计算最短路径。