JAVA实现最短距离算法之迪杰斯特拉算法

最短路径问题是图论研究中的一个经典的算法问题，旨在寻找图中两个节点之间的最短路径，最经常使用的算法有Dijkstra算法、SPFA算法\Bellman-Ford算法、Floyd算法\Floyd-Warshall算法、Johnson算法等，这篇博客将重点介绍Dijkstra算法。

 

迪杰斯特拉算法

      迪杰斯特拉算法是由荷兰计算机科学家狄克斯特拉于1959 年提出的，所以又叫狄克斯特拉算法。是从一个顶点到其他各顶点的最短路径算法，解决的是有向图中最短路径问题。迪杰斯特拉算法主要特色是以起始点为中心向外层层扩展，直到扩展到终点为止。具体的计算规则咱们能够经过下图进行查看。

      经过这幅图（若是图片没法正确显示，请经过百度百科查看）咱们能够简单的理解迪杰斯特拉算法算法的基础思路，下面咱们就经过Java来实现这个算法。

 

先给出一个无向图

用Dijkstra算法找出以A为起点的单源最短路径步骤以下

 

算法实现

      在具体的实现以前，咱们先有一个基础的约定，就是途中的每个节点咱们都用正整数进行编码，相邻两点之间的距离是正整数，图中两个直接相邻两点的距离咱们保存到map中，也就是求最短距离咱们须要实现这样的一个方法：

 

[java] view plain copy

 print?

1. public MinStep getMinStep(int start, int end, final HashMap<Integer, HashMap<Integer, Integer>> stepLength);  

 

      第一个参数是起始节点的编号，第二个参数是终点节点的编号，第三个参数是图中直接相邻两个节点的距离组成的map。关于第三个参数，会在后面作详细的介绍。这里咱们定义一个接口，用于计算两点之间的最短路径，具体以下：

 

[java] view plain copy

 print?

1.  /**   
2.  *@Description:      
3.  */   
4. package com.lulei.distance;    
5.   
6. import java.util.HashMap;  
7.   
8. import com.lulei.distance.bean.MinStep;  
9.     
10. public interface Distance {  
11.     public static final MinStep UNREACHABLE = new MinStep(false, -1);  
12.     /** 
13.      * @param start 
14.      * @param end 
15.      * @param stepLength 
16.      * @return 
17.      * @Author:lulei   
18.      * @Description: 起点到终点的最短路径 
19.      */  
20.     public MinStep getMinStep(int start, int end, final HashMap<Integer, HashMap<Integer, Integer>> stepLength);  
21. }  

 

 

1、方法返回值介绍

      上面方法的返回值是咱们自定义的一个数据类型，下面咱们经过代码来看其具体的数据结构：

 

[java] view plain copy

 print?

1. /**   
2.  *@Description:      
3.  */  
4. package com.lulei.distance.bean;  
5.   
6. import java.util.List;  
7.   
8. public class MinStep {  
9.     private boolean reachable;//是否可达  
10.     private int minStep;//最短步长  
11.     private List<Integer> step;//最短路径  
12.   
13.     public MinStep() {  
14.     }  
15.       
16.     public MinStep(boolean reachable, int minStep) {  
17.         this.reachable = reachable;  
18.         this.minStep = minStep;  
19.     }  
20.   
21.     public boolean isReachable() {  
22.         return reachable;  
23.     }  
24.     public void setReachable(boolean reachable) {  
25.         this.reachable = reachable;  
26.     }  
27.     public int getMinStep() {  
28.         return minStep;  
29.     }  
30.     public void setMinStep(int minStep) {  
31.         this.minStep = minStep;  
32.     }  
33.     public List<Integer> getStep() {  
34.         return step;  
35.     }  
36.     public void setStep(List<Integer> step) {  
37.         this.step = step;  
38.     }  
39. }  

      其中最短路径的那个List数组保存了从起点到终点最短路径所经历的节点。

 

 

2、每个节点的最优前一节点

      在迪杰斯特拉算法中咱们须要保存从起点开始到每个节点最短步长，这也是图中须要比较得出的步长，同时咱们还须要存储该步长下的前一个节点是哪一个，这样咱们就能够经过终点一个一个往前推到起点，这样就出来了完整的最优路径。

 

[java] view plain copy

 print?

1. /**   
2.  *@Description:      
3.  */  
4. package com.lulei.distance.bean;  
5.   
6. public class PreNode {  
7.     private int preNodeNum;// 最优 前一个节点  
8.     private int nodeStep;// 最小步长  
9.   
10.     public PreNode(int preNodeNum, int nodeStep) {  
11.         this.preNodeNum = preNodeNum;  
12.         this.nodeStep = nodeStep;  
13.     }  
14.   
15.     public int getPreNodeNum() {  
16.         return preNodeNum;  
17.     }  
18.     public void setPreNodeNum(int preNodeNum) {  
19.         this.preNodeNum = preNodeNum;  
20.     }  
21.     public int getNodeStep() {  
22.         return nodeStep;  
23.     }  
24.     public void setNodeStep(int nodeStep) {  
25.         this.nodeStep = nodeStep;  
26.     }  
27. }  

3、迪杰斯特拉算法计算过程当中须要关注的变量

 

      从介绍迪杰斯特拉算法的图中，咱们知道在计算的过程当中咱们须要保存起点到各个节点的最短距离、已经计算过的节点、下次须要计算节点队列和图中相邻两个节点的距离。咱们经过代码来看下具体的定义：

 

[java] view plain copy

 print?

1. //key1节点编号，key2节点编号，value为key1到key2的步长  
2. private HashMap<Integer, HashMap<Integer, Integer>> stepLength;  
3. //非独立节点个数  
4. private int nodeNum;  
5. //移除节点  
6. private HashSet<Integer> outNode;  
7. //起点到各点的步长，key为目的节点，value为到目的节点的步长  
8. private HashMap<Integer, PreNode> nodeStep;  
9. //下一次计算的节点  
10. private LinkedList<Integer> nextNode;  
11. //起点、终点  
12. private int startNode;  
13. private int endNode;  

 

      咱们这里看下stepLength这个属性，它保存了图中相邻两个节点之间的距离，好比key1=1;key2=3;value=9;这表明的意义就是从节点1到节点3的距离是9。经过这样的存储，咱们就须要把图中每两个相邻的点保存到这个类型的map中。

 

4、属性初始化

      在开始计算以前，咱们须要对这些属性进行初始化，具体以下：

 

[java] view plain copy

 print?

1. private void initProperty(int start, int end) {  
2.     outNode = new HashSet<Integer>();  
3.     nodeStep = new HashMap<Integer, PreNode>();  
4.     nextNode = new LinkedList<Integer>();  
5.     nextNode.add(start);  
6.     startNode = start;  
7.     endNode = end;  
8. }  

       这一步咱们须要把起点添加到下一次须要计算的节点队列中。

 

 

5、迪杰斯特拉算法

      这一步也就是迪杰斯特拉算法的核心部分，在计算的过程当中，咱们须要进行以下步骤：

1）判断是否达到终止条件，若是达到终止条件，结束本次算法，若是没有达到，执行下一步；（终止条件：下一次须要计算的节点队列没有数据或已经计算过的节点数等于节点总数）

2）获取下一次计算的节点A；

3）从起点到各节点之间的最短距离map中获取到达A点的最小距离L；

4）获取A节点的可达节点B，计算从起点先到A再到B是否优于已有的其余方式到B，若是优于，则更新B节点，不然不更新；

5）判断B是不是已经移除的节点，若是不是移除的节点，把B添加到下一次须要计算的节点队列中，不然不作操做；

6）判断A节点是否还有除B之外的其余节点，若是有，执行第4）步，不然执行下一步；

7）将A节点从下一次须要计算的节点中移除添加到已经计算过的节点中；

8）执行第一步。

      咱们来看下具体的代码实现：

 

[java] view plain copy

 print?

1. private void step() {  
2.     if (nextNode == null || nextNode.size() < 1) {  
3.         return;  
4.     }  
5.     if (outNode.size() == nodeNum) {  
6.         return;  
7.     }  
8.     //获取下一个计算节点  
9.     int start = nextNode.removeFirst();  
10.     //到达该节点的最小距离  
11.     int step = 0;  
12.     if (nodeStep.containsKey(start)) {  
13.         step = nodeStep.get(start).getNodeStep();  
14.     }  
15.     //获取该节点可达节点  
16.     HashMap<Integer,Integer> nextStep = stepLength.get(start);  
17.     Iterator<Entry<Integer, Integer>> iter = nextStep.entrySet().iterator();  
18.     while (iter.hasNext()) {  
19.         Entry<Integer, Integer> entry = iter.next();  
20.         Integer key = entry.getKey();  
21.         //若是是起点到起点，不计算之间的步长  
22.         if (key == startNode) {  
23.             continue;  
24.         }  
25.         //起点到可达节点的距离  
26.         Integer value = entry.getValue() + step;  
27.         if ((!nextNode.contains(key)) && (!outNode.contains(key))) {  
28.             nextNode.add(key);  
29.         }  
30.         if (nodeStep.containsKey(key)) {  
31.             if (value < nodeStep.get(key).getNodeStep()) {  
32.                 nodeStep.put(key, new PreNode(start, value));  
33.             }  
34.         } else {  
35.             nodeStep.put(key, new PreNode(start, value));  
36.         }  
37.     }  
38.     //将该节点移除  
39.     outNode.add(start);  
40.     //计算下一个节点  
41.     step();  
42. }  

 

6、组装最短路径返回结果

      经过前面的计算，已经计算出了起点到各个节点的最短路径，下面就须要组装起点到终点的最短路径，在计算最短距离下的路径方式，咱们须要从终点依次往前推，即到达终点最短距离下的前一个节点是A，到达A节点最短距离下的前一节点是B，直到找到起点终止。

 

[java] view plain copy

 print?

1. private MinStep changeToMinStep() {  
2.     MinStep minStep = new MinStep();  
3.     minStep.setMinStep(nodeStep.get(endNode).getNodeStep());  
4.     minStep.setReachable(true);  
5.     LinkedList<Integer> step = new LinkedList<Integer>();  
6.     minStep.setStep(step);  
7.     int nodeNum = endNode;  
8.     step.addFirst(nodeNum);  
9.     while (nodeStep.containsKey(nodeNum)) {  
10.         int node = nodeStep.get(nodeNum).getPreNodeNum();  
11.         step.addFirst(node);  
12.         nodeNum = node;  
13.     }  
14.     return minStep;  
15. }  

7、接口定义方法实现

 

 

[java] view plain copy

 print?

1. public MinStep getMinStep(int start, int end, final HashMap<Integer, HashMap<Integer, Integer>> stepLength) {  
2.     this.stepLength = stepLength;  
3.     this.nodeNum = this.stepLength != null ? this.stepLength.size() : 0;  
4.     //起点、终点不在目标节点内，返回不可达  
5.     if (this.stepLength == null || (!this.stepLength.containsKey(start)) || (!this.stepLength.containsKey(end))) {  
6.         return UNREACHABLE;  
7.     }  
8.     initProperty(start, end);  
9.     step();  
10.     if (nodeStep.containsKey(end)) {  
11.         return changeToMinStep();  
12.     }  
13.     return UNREACHABLE;  
14. }  

8、迪杰斯特拉算法完整代码

 

 

[java] view plain copy

 print?

1. /**   
2.  *@Description:      
3.  */  
4. package com.lulei.distance.dijkstra;  
5.   
6. import java.util.HashMap;  
7. import java.util.HashSet;  
8. import java.util.Iterator;  
9. import java.util.LinkedList;  
10. import java.util.Map.Entry;  
11.   
12. import com.lulei.distance.Distance;  
13. import com.lulei.distance.bean.MinStep;  
14. import com.lulei.distance.bean.PreNode;  
15.   
16. public class DistanceDijkstraImpl implements Distance{  
17.     //key1节点编号，key2节点编号，value为key1到key2的步长  
18.     private HashMap<Integer, HashMap<Integer, Integer>> stepLength;  
19.     //非独立节点个数  
20.     private int nodeNum;  
21.     //移除节点  
22.     private HashSet<Integer> outNode;  
23.     //起点到各点的步长，key为目的节点，value为到目的节点的步长  
24.     private HashMap<Integer, PreNode> nodeStep;  
25.     //下一次计算的节点  
26.     private LinkedList<Integer> nextNode;  
27.     //起点、终点  
28.     private int startNode;  
29.     private int endNode;  
30.       
31.     /** 
32.      * @param start 
33.      * @param end 
34.      * @param stepLength 
35.      * @return 
36.      * @Author:lulei   
37.      * @Description: start 到 end 的最短距离 
38.      */  
39.     public MinStep getMinStep(int start, int end, final HashMap<Integer, HashMap<Integer, Integer>> stepLength) {  
40.         this.stepLength = stepLength;  
41.         this.nodeNum = this.stepLength != null ? this.stepLength.size() : 0;  
42.         //起点、终点不在目标节点内，返回不可达  
43.         if (this.stepLength == null || (!this.stepLength.containsKey(start)) || (!this.stepLength.containsKey(end))) {  
44.             return UNREACHABLE;  
45.         }  
46.         initProperty(start, end);  
47.         step();  
48.         if (nodeStep.containsKey(end)) {  
49.             return changeToMinStep();  
50.         }  
51.         return UNREACHABLE;  
52.     }  
53.       
54.     /** 
55.      * 返回最短距离以及路径 
56.      */  
57.     private MinStep changeToMinStep() {  
58.         MinStep minStep = new MinStep();  
59.         minStep.setMinStep(nodeStep.get(endNode).getNodeStep());  
60.         minStep.setReachable(true);  
61.         LinkedList<Integer> step = new LinkedList<Integer>();  
62.         minStep.setStep(step);  
63.         int nodeNum = endNode;  
64.         step.addFirst(nodeNum);  
65.         while (nodeStep.containsKey(nodeNum)) {  
66.             int node = nodeStep.get(nodeNum).getPreNodeNum();  
67.             step.addFirst(node);  
68.             nodeNum = node;  
69.         }  
70.         return minStep;  
71.     }  
72.       
73.     /** 
74.      * @param start 
75.      * @Author:lulei   
76.      * @Description: 初始化属性 
77.      */  
78.     private void initProperty(int start, int end) {  
79.         outNode = new HashSet<Integer>();  
80.         nodeStep = new HashMap<Integer, PreNode>();  
81.         nextNode = new LinkedList<Integer>();  
82.         nextNode.add(start);  
83.         startNode = start;  
84.         endNode = end;  
85.     }  
86.       
87.     /** 
88.      * @param end 
89.      * @Author:lulei   
90.      * @Description: 
91.      */  
92.     private void step() {  
93.         if (nextNode == null || nextNode.size() < 1) {  
94.             return;  
95.         }  
96.         if (outNode.size() == nodeNum) {  
97.             return;  
98.         }  
99.         //获取下一个计算节点  
100.         int start = nextNode.removeFirst();  
101.         //到达该节点的最小距离  
102.         int step = 0;  
103.         if (nodeStep.containsKey(start)) {  
104.             step = nodeStep.get(start).getNodeStep();  
105.         }  
106.         //获取该节点可达节点  
107.         HashMap<Integer,Integer> nextStep = stepLength.get(start);  
108.         Iterator<Entry<Integer, Integer>> iter = nextStep.entrySet().iterator();  
109.         while (iter.hasNext()) {  
110.             Entry<Integer, Integer> entry = iter.next();  
111.             Integer key = entry.getKey();  
112.             //若是是起点到起点，不计算之间的步长  
113.             if (key == startNode) {  
114.                 continue;  
115.             }  
116.             //起点到可达节点的距离  
117.             Integer value = entry.getValue() + step;  
118.             if ((!nextNode.contains(key)) && (!outNode.contains(key))) {  
119.                 nextNode.add(key);  
120.             }  
121.             if (nodeStep.containsKey(key)) {  
122.                 if (value < nodeStep.get(key).getNodeStep()) {  
123.                     nodeStep.put(key, new PreNode(start, value));  
124.                 }  
125.             } else {  
126.                 nodeStep.put(key, new PreNode(start, value));  
127.             }  
128.         }  
129.         //将该节点移除  
130.         outNode.add(start);  
131.         //计算下一个节点  
132.         step();  
133.     }  
134. }  

 

 

代码测试

     对于上述代码的测试，咱们仍是使用咱们事例图形中的例子，计算从节点1到节点5的最短距离。

 

[java] view plain copy

 print?

1.  /**   
2.  *@Description:      
3.  */   
4. package com.lulei.distance.test;    
5.   
6. import java.util.HashMap;  
7.   
8. import com.lulei.distance.Distance;  
9. import com.lulei.distance.bean.MinStep;  
10. import com.lulei.distance.dijkstra.DistanceDijkstraImpl;  
11. import com.lulei.util.JsonUtil;  
12.     
13. public class DistanceTest {  
14.   
15.     public static void main(String[] args) {  
16.         // TODO Auto-generated method stub    
17.         HashMap<Integer, HashMap<Integer,Integer>> stepLength = new HashMap<Integer, HashMap<Integer,Integer>>();  
18.         HashMap<Integer,Integer> step1 = new HashMap<Integer, Integer>();  
19.         stepLength.put(1, step1);  
20.         step1.put(6, 14);  
21.         step1.put(3, 9);  
22.         step1.put(2, 7);  
23.           
24.         HashMap<Integer,Integer> step2 = new HashMap<Integer, Integer>();  
25.         stepLength.put(2, step2);  
26.         step2.put(1, 7);  
27.         step2.put(3, 10);  
28.         step2.put(4, 15);  
29.           
30.         HashMap<Integer,Integer> step3 = new HashMap<Integer, Integer>();  
31.         stepLength.put(3, step3);  
32.         step3.put(1, 9);  
33.         step3.put(2, 10);  
34.         step3.put(4, 11);  
35.         step3.put(6, 2);  
36.           
37.         HashMap<Integer,Integer> step4 = new HashMap<Integer, Integer>();  
38.         stepLength.put(4, step4);  
39.         step4.put(2, 15);  
40.         step4.put(5, 5);  
41.         step4.put(3, 11);  
42.           
43.         HashMap<Integer,Integer> step5 = new HashMap<Integer, Integer>();  
44.         stepLength.put(5, step5);  
45.         step5.put(6, 9);  
46.         step5.put(4, 5);  
47.           
48.         HashMap<Integer,Integer> step6 = new HashMap<Integer, Integer>();  
49.         stepLength.put(6, step6);  
50.         step6.put(1, 14);  
51.         step6.put(5, 9);  
52.         step6.put(3, 2);  
53.           
54.         Distance distance = new DistanceDijkstraImpl();  
55.         MinStep step = distance.getMinStep(1, 5, stepLength);  
56.         System.out.println(JsonUtil.parseJson(step));  
57.     }  
58.   
59. }  

      这里组装相邻两个节点之间的距离用了大量的代码，咱们看下输出结果：

 

 

[java] view plain copy

 print?

1. {"reachable":true,"minStep":20,"step":[1,3,6,5]}  

 

 

最后的思考

      最短路径算法在现实生活中其实有不少的用处，好比迷宫解法、路径规划、路由寻址等等，这些问题看似很复杂，其实只须要作对应的转化后仍是能够用最基础的算法解决的。