java写个迪杰斯特拉算法

### 回答1：
在 Java 中实现 Dijkstra 算法，你需要建立一张图并定义边的权值，然后对于给定的起点，使用 Dijkstra 算法寻找到其他所有点的最短路径。

这里是一个 Java 示例，其中包含了 Dijkstra 算法的实现：

import java.util.ArrayList;
import java.util.List;

public class Dijkstra {
  // 邻接表存储图
  private static List<List<Node>> adjacencyList;
  // 最短路径数组
  private static int[] shortestPaths;
  // 起点
  private static int start;

  public static void main(String[] args) {
    // 初始化图
    initGraph();
    // 运行 Dijkstra 算法
    runDijkstra(start);
    // 输出最短路径数组
    for (int i = 0; i < shortestPaths.length; i++) {
      System.out.println("起点到" + i + "的最短路径长度为：" + shortestPaths[i]);
    }
  }

  // 初始化图
  private static void initGraph() {
    // 省略图的初始化代码
  }

  // 运行 Dijkstra 算法
  private static void runDijkstra(int start) {
    // 初始化最短路径数组
    shortestPaths = new int[adjacencyList.size()];
    // 未被处理的点的集合
    List<Integer> unprocessed = new ArrayList<>();
    // 初始化未被处理的点的集合
    for (int i = 0; i < adjacencyList.size(); i++) {
      unprocessed.add(i);
    }
    // 将起点的最短路径设为 0
    shortestPaths[start] = 0;
    // 循环处理未被处理的点
    while (!unprocessed.isEmpty()) {
      // 获取最短路径最小的未被处理的点
      int minIndex = getMinimumUnprocessed(unprocess  

### 回答2：
迪杰斯特拉算法是一种用于求解带权重有向图中单源最短路径的算法。下面是用Java语言实现迪杰斯特拉算法的代码：

import java.util.Arrays;

public class DijkstraAlgorithm {
private static final int INFINITY = Integer.MAX_VALUE;

public void dijkstra(int[][] graph, int source) {
int numVertices = graph.length;
boolean[] visited = new boolean[numVertices];
int[] distance = new int[numVertices];
Arrays.fill(distance, INFINITY);
distance[source] = 0;

for (int i = 0; i < numVertices - 1; i++) {
int minDistance = findMinDistance(distance, visited);
visited[minDistance] = true;

for (int j = 0; j < numVertices; j++) {
if (!visited[j] && graph[minDistance][j] != 0 && distance[minDistance] != INFINITY
&& distance[minDistance] + graph[minDistance][j] < distance[j]) {
distance[j] = distance[minDistance] + graph[minDistance][j];
}
}
}

System.out.println("最短路径：");
for (int i = 0; i < numVertices; i++) {
System.out.println(source + " 到 " + i + " 的最短距离为：" + distance[i]);
}
}

private int findMinDistance(int[] distance, boolean[] visited) {
int minDistance = INFINITY;
int minDistanceVertex = -1;

for (int i = 0; i < distance.length; i++) {
if (!visited[i] && distance[i] < minDistance) {
minDistance = distance[i];
minDistanceVertex = i;
}
}

return minDistanceVertex;
}

public static void main(String[] args) {
int[][] graph = {
{0, 4, 0, 0, 0, 0, 0, 8, 0},
{4, 0, 8, 0, 0, 0, 0, 11, 0},
{0, 8, 0, 7, 0, 4, 0, 0, 2},
{0, 0, 7, 0, 9, 14, 0, 0, 0},
{0, 0, 0, 9, 0, 10, 0, 0, 0},
{0, 0, 4, 14, 10, 0, 2, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 6},
{8, 11, 0, 0, 0, 0, 1, 0, 7},
{0, 0, 2, 0, 0, 0, 6, 7, 0}
};

DijkstraAlgorithm dijkstraAlgorithm = new DijkstraAlgorithm();
dijkstraAlgorithm.dijkstra(graph, 0);
}
}

以上代码演示了如何使用Java语言实现迪杰斯特拉算法。通过给定的带权重有向图，算法会计算出起点到其他顶点的最短路径，并输出结果。  

### 回答3：
迪杰斯特拉(Dijkstra)算法是一种用于带权重图中寻找最短路径的算法。在Java中，我们可以使用图的邻接矩阵表示，并使用数组和集合来实现这个算法。下面是Java的迪杰斯特拉算法代码示例：

public class DijkstraAlgorithm {
public static void dijkstra(int[][] graph, int start, int[] distance, boolean[] visited) {
int numVertices = graph[0].length;

// 初始化距离数组和访问数组
for (int i = 0; i < numVertices; i++) {
distance[i] = Integer.MAX_VALUE;
visited[i] = false;
}

// 起点到起点的距离为0
distance[start] = 0;

// 寻找最短路径
for (int i = 0; i < numVertices - 1; i++) {
int minDistance = Integer.MAX_VALUE;
int minIndex = -1;

// 选择距离起点最近的未访问节点
for (int j = 0; j < numVertices; j++) {
if (!visited[j] && distance[j] < minDistance) {
minDistance = distance[j];
minIndex = j;
}
}

// 标记节点为已访问
visited[minIndex] = true;

// 更新与选定节点相邻节点的距离
for (int j = 0; j < numVertices; j++) {
if (!visited[j] && graph[minIndex][j] != 0 && distance[minIndex] != Integer.MAX_VALUE
&& distance[minIndex] + graph[minIndex][j] < distance[j]) {
distance[j] = distance[minIndex] + graph[minIndex][j];
}
}
}
}

public static void main(String[] args) {
int[][] graph = {{0, 4, 0, 0, 0, 0, 0, 8, 0},
{4, 0, 8, 0, 0, 0, 0, 11, 0},
{0, 8, 0, 7, 0, 4, 0, 0, 2},
{0, 0, 7, 0, 9, 14, 0, 0, 0},
{0, 0, 0, 9, 0, 10, 0, 0, 0},
{0, 0, 4, 0, 10, 0, 2, 0, 0},
{0, 0, 0, 14, 0, 2, 0, 1, 6},
{8, 11, 0, 0, 0, 0, 1, 0, 7},
{0, 0, 2, 0, 0, 0, 6, 7, 0}};

int numVertices = graph[0].length;
int[] distance = new int[numVertices];
boolean[] visited = new boolean[numVertices];

int start = 0;

dijkstra(graph, start, distance, visited);

System.out.println("节点到起点的最短距离：");
for (int i = 0; i < numVertices; i++) {
System.out.println(i + ": " + distance[i]);
}
}
}

在上面的代码中，我们使用了一个邻接矩阵来表示图。我们从起点开始，选择距离起点最近的未访问节点，并更新与该节点相邻节点的距离，以求得最短路径。最后，我们输出每个节点到起点的最短距离。这段代码的输出结果为：

节点到起点的最短距离：
0: 0
1: 4
2: 12
3: 19
4: 21
5: 11
6: 9
7: 8
8: 14

这表示起点到其他节点的最短距离分别为0、4、12、19、21、11、9、8和14。希望以上回答能对您有帮助！