2021.05.11
学习于极客时间 [time.geekbang.org/column/arti…]
我们用 vertexes 数组，记录从起始顶点到每个顶点的距离（dist）。起初，我们把所有顶点的 dist 都初始化为无穷大（也就是代码中的 Integer.MAX_VALUE）。我们把起始顶点的 dist 值初始化为 0，然后将其放到优先级队列中。
我们从优先级队列中取出 dist 最小的顶点 minVertex，然后考察这个顶点可达的所有顶点（代码中的 nextVertex）。如果 minVertex 的 dist 值加上 minVertex 与 nextVertex 之间边的权重 w 小于 nextVertex 当前的 dist 值，也就是说，存在另一条更短的路径，它经过 minVertex 到达 nextVertex。那我们就把 nextVertex 的 dist 更新为 minVertex 的 dist 值加上 w。然后，我们把 nextVertex 加入到优先级队列中。重复这个过程，直到找到终止顶点 t 或者队列为空。
predecessor 数组的作用是为了还原最短路径，它记录每个顶点的前驱顶点。
inqueue 数组是为了避免将一个顶点多次添加到优先级队列中。我们更新了某个顶点的 dist 值之后，如果这个顶点已经在优先级队列中了，就不要再将它重复添加进去了。
// 因为Java提供的优先级队列，没有暴露更新数据的接口，所以我们需要重新实现一个 private class PriorityQueue { // 根据vertex.dist构建小顶堆 private Vertex[] nodes; private int count; public PriorityQueue(int v) { this.nodes = new Vertex[v+1]; this.count = v; } public Vertex poll() { } public void add(Vertex vertex) { } // 更新结点的值，并且从下往上堆化，重新符合堆的定义。时间复杂度O(logn)。 public void update(Vertex vertex) { } public boolean isEmpty() { } }
public void dijkstra(int s, int t) { // 从顶点s到顶点t的最短路径 int[] predecessor = new int[this.v]; // 用来还原最短路径 Vertex[] vertexes = new Vertex[this.v]; for (int i = 0; i < this.v; ++i) { vertexes[i] = new Vertex(i, Integer.MAX_VALUE); } PriorityQueue queue = new PriorityQueue(this.v);// 小顶堆 boolean[] inqueue = new boolean[this.v]; // 标记是否进入过队列 vertexes[s].dist = 0; queue.add(vertexes[s]); inqueue[s] = true; while (!queue.isEmpty()) { Vertex minVertex= queue.poll(); // 取堆顶元素并删除 if (minVertex.id == t) break; // 最短路径产生了 for (int i = 0; i < adj[minVertex.id].size(); ++i) { Edge e = adj[minVertex.id].get(i); // 取出一条minVetex相连的边 Vertex nextVertex = vertexes[e.tid]; // minVertex-->nextVertex if (minVertex.dist + e.w < nextVertex.dist) { // 更新next的dist nextVertex.dist = minVertex.dist + e.w; predecessor[nextVertex.id] = minVertex.id; if (inqueue[nextVertex.id] == true) { queue.update(nextVertex); // 更新队列中的dist值 } else { queue.add(nextVertex); inqueue[nextVertex.id] = true; } } } } // 输出最短路径 System.out.print(s); print(s, t, predecessor); }
private void print(int s, int t, int[] predecessor) { if (s == t) return; print(s, predecessor[t], predecessor); System.out.print("->" + t); } Dijkstra 时间复杂度：
while 循环最多会执行 V 次，而内部的 for 循环最大也不会超过图中所有边的个数 E。for 循环内部的优先队列是用堆实现的，时间复杂度都是 O(logV)。所以，整个代码的时间复杂度就是 O(E*logV)。
- Prim
Prim算法使用了贪心策略，相对比较简单，直接上代码理解。
public static void primTree() {
buildGraph();
Vertex start = vertexList.get(0);
newVertex.add(start);
for (int n = 0; n < vertexList.size() - 1; n++) {
Vertex temp = new Vertex(start.key);
Edge tempedge = new Edge(start, start, 1000);
for (Vertex v : newVertex) {
for (Edge e : EdgeQueue) {
if (e.start == v && !containVertex(e.end)) {
if (e.key < tempedge.key) {
temp = e.end;
tempedge = e;
}
}
}
}
newVertex.add(temp);
}
Iterator it = newVertex.iterator();
while (it.hasNext()) {
Vertex v = (Vertex) it.next();
System.out.println(v.key);
}
}
public static boolean containVertex(Vertex vte) {
for (Vertex v : newVertex) {
if (v.key.equals(vte.key))
return true;
}
return false;
}
Prim 时间复杂度：
通过邻接矩阵的实现中，找到所有最小权边共需O(V^2)的运行时间。
