Heap+Dijkstra堆优化的Dijkstra

标签：单源最短路径   dijkstra   heap   性能   优化   

前面说到“原生的Dijkstra”，由于Dijkstra采用的是贪心策略，在贪心寻找当前距离源结点最短的结点时需要遍历所有的结点，这必然会导致效率的下降，时间复杂度为n^n。因此当数据量较大时会消耗较长时间。为了提高Dijkstra的效率，只有对Dijkstra的贪心策略进行改进。

由于Dijkstra采用的贪心策略是每次寻找最短距离的结点并将其放入存放所有已知最短距离结点的S集合中，可以联想到堆以及优先级队列这些数据结构，这些结构都能非常高效地提供当前状态距离最短的结点。实践也可以证明这两种优化对于Dijkstra的效率提升是非常明显的。

另外需要提到的是优先队列优化的Dijkstra和堆优化的Dijkstra效率相差不多，但是优先队列优化的方式却非常好实现，因为java类库中有PriorityQueue对象，该对象就是优先队列。但是对于堆优化来说就比较复杂了，因为需要自己动手实现最小堆，这样既复杂又容易出错，因此如果是想对Dijksra进行优化的话，首推PriorityQueue+Dijkstra即优先队列优化的Dijkstra。

下面还是以蓝桥杯的那道”最短路“题目为例展示Heap+Dijkstra堆优化的Dijkstra

下面是堆优化的Dijkstra代码：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

/**
 * Heap + Dijkstra算法求单源最短路径 
 * 采用邻接表存储图数据 
 * 邻接表结构: 
 * 头结点--Node对象数组
 * 邻接节点--Node对象中的HashMap
 * 
 * @author DuXiangYu
 * 
 */
public class DijKstra_link_Heap {

	static int nodeCount;
	static int edgeCount;
	// 邻接表表头数组
	static Node[] firstArray;
	// 最短路径数组
	static int[][] dist;
	static int[] ref;
	static int max = 1000000;

	/**
	 * 结点类
	 * 
	 * @author DuXiangYu
	 */
	static class Node {
		// 邻接顶点map
		private HashMap<Integer, Integer> map = null;

		public void addEdge(int end, int edge) {
			if (this.map == null) {
				this.map = new HashMap<Integer, Integer>();
			}
			this.map.put(end, edge);
		}

	}

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		nodeCount = sc.nextInt();
		edgeCount = sc.nextInt();

		firstArray = new Node[nodeCount + 1];

		for (int i = 0; i < nodeCount + 1; i++) {
			firstArray[i] = new Node();
		}

		for (int i = 0; i < edgeCount; i++) {
			int begin = sc.nextInt();
			int end = sc.nextInt();
			int edge = sc.nextInt();
			firstArray[begin].addEdge(end, edge);
		}
		sc.close();

		long begin = System.currentTimeMillis();

		djst();

		long end = System.currentTimeMillis();

		System.out.println(end - begin + "ms");
	}

	/**
	 * Heap + Dijkstra算法实现
	 */
	private static void djst() {

		dist = new int[2][nodeCount + 1];
		ref = new int[nodeCount + 1];
		Node tempNode = firstArray[1];
		for (int i = 2; i < nodeCount + 1; i++) {
			HashMap<Integer, Integer> tempMap = tempNode.map;
			dist[0][i] = tempMap.containsKey(i) ? tempMap.get(i) : max;
			dist[1][i] = i;
			ref[i] = i;
			minUp(i);
		}

		int flag = nodeCount;
		while (flag >= 2) {
			int index = dist[1][2];
			changeKey(2, flag);
			maxDown(2, --flag);

			// 用indx这个点去更新它的邻接点到开始点的距离
			HashMap<Integer, Integer> m = firstArray[index].map;
			if (m == null) {
				continue;
			}
			Set<Integer> set = m.keySet();
			Iterator<Integer> it = set.iterator();
			while (it.hasNext()) {
				int num = it.next();
				if (m.get(num) + dist[0][flag + 1] < dist[0][ref[num]]) {
					dist[0][ref[num]] = m.get(num) + dist[0][flag + 1];
					minUp(ref[num]);
				}
			}
		}

		for (int i = 2; i < nodeCount + 1; i++) {
			System.out.println(dist[0][ref[i]]);
		}

	}

	/**
	 * 最大值下沉
	 * 
	 * @param index
	 * @param end
	 */
	private static void maxDown(int index, int end) {
		int temp = dist[0][index];
		int left = index * 2 - 1;

		while (left <= end) {

			// 判断左右子节点大小
			if (left + 1 <= end && dist[0][left + 1] < dist[0][left]) {
				left++;
			}
			// 如果左右子节点都比temp大的话结束下沉操作
			if (dist[0][left] > temp) {
				break;
			}
			// 交换子节点和父节点
			changeKey(index, left);

			index = left;
			left = index * 2 - 1;

		}
	}

	/**
	 * 小值上升
	 * 
	 * @param n
	 */
	private static void minUp(int n) {
		int f = (n + 1) / 2;
		while (f >= 2 && dist[0][f] > dist[0][n]) {
			changeKey(f, n);
			n = f;
			f = (n + 1) / 2;
		}
	}

	/**
	 * 交换两个值
	 * 
	 * @param a
	 * @param b
	 */
	private static void changeKey(int a, int b) {
		int n = dist[1][a];
		int m = dist[1][b];
		int temp = ref[n];
		ref[n] = ref[m];
		ref[m] = temp;
		temp = dist[0][a];
		dist[0][a] = dist[0][b];
		dist[0][b] = temp;
		temp = dist[1][a];
		dist[1][a] = dist[1][b];
		dist[1][b] = temp;
	}

}

对于“原生的Dijkstra”中的那个较大测试数据：10000个结点和100000条边来说，该优化的Dijkstra执行实现平均为250ms，而无优化的Dijkstra对于该数据的平均执行实现为2200ms，性能提升了88%，可以看得出来对于性能的提升是非常明显的：

Heap+Dijkstra堆优化的Dijkstra

标签：单源最短路径   dijkstra   heap   性能   优化   

原文地址：http://blog.csdn.net/u011333588/article/details/45640091