Dijkstra algorithm to find the shortest path (Java)

SOURCE Link: Dijkstra Algorithm for Shortest path (Java) Task description: Gets the shortest path description of the starting node to all other nodes in an no-map diagram

The Dijkstra (Dijkstra) algorithm is a typical shortest path routing algorithm used to calculate the shortest path of a node to all other nodes. The main feature is to extend from the center of the starting point to the outer layer until it expands to the end point.

Dijkstra general expressions usually have two ways, a permanent and temporary marking method, one is open, close table
Using the method of Open,close table, it uses the greedy algorithm strategy, the approximate process is as follows:
1. Declare two collections, open and Close,open to store the nodes that are not traversed, and close to store the traversed nodes
2. Initial phase, put the initial node in close, all other nodes into the open
3. Traverse the outer layer at the center of the initial node, get the child node closest to the specified node and place it in close and calculate the new path until close contains all child nodes

The code example is as follows:
The node object is used to encapsulate the nodes ' information, including the name and child nodes
[Java]View PlainCopy

2. Public class Node {
4. private String name;
6. Private map<node,integer> child=new hashmap<node,integer> ();
8. Public Node (String name) {
10. This.name=name;
12. }
14. Public String GetName () {
16. return name;
18. }
20. public void SetName (String name) {
22. this.name = name;
24. }
26. Public Map<node, integer> getchild () {
28. return child;
30. }
32. public void SetChild (Map<node, integer> child) {
34. this.child = child;
36. }
38. }

Mapbuilder used to initialize the data source, returning the starting node of the graph
[Java]View PlainCopy

2. Public class Mapbuilder {
4. Public Node Build (set<node> Open, set<node> close) {
6. Node nodea=new node ("A");
8. Node nodeb=new node ("B");
10. Node nodec=new node ("C");
12. Node noded=new node ("D");
14. Node nodee=new node ("E");
16. Node nodef=new node ("F");
18. Node nodeg=new node ("G");
20. Node nodeh=new node ("H");
22. Nodea.getchild (). Put (NodeB, 1);
24. Nodea.getchild (). Put (NodeC, 1);
26. Nodea.getchild (). Put (noded, 4);
28. Nodea.getchild (). Put (Nodeg, 5);
30. Nodea.getchild (). Put (Nodef, 2);
32. Nodeb.getchild (). Put (NodeA, 1);
34. Nodeb.getchild (). Put (Nodef, 2);
36. Nodeb.getchild (). Put (Nodeh, 4);
38. Nodec.getchild (). Put (NodeA, 1);
40. Nodec.getchild (). Put (Nodeg, 3);
42. Noded.getchild (). Put (NodeA, 4);
44. Noded.getchild (). Put (NodeE, 1);
46. Nodee.getchild (). Put (noded, 1);
48. Nodee.getchild (). Put (Nodef, 1);
50. Nodef.getchild (). Put (NodeE, 1);
52. Nodef.getchild (). Put (NodeB, 2);
54. Nodef.getchild (). Put (NodeA, 2);
56. Nodeg.getchild (). Put (NodeC, 3);
58. Nodeg.getchild (). Put (NodeA, 5);
60. Nodeg.getchild (). Put (Nodeh, 1);
62. Nodeh.getchild (). Put (NodeB, 4);
64. Nodeh.getchild (). Put (Nodeg, 1);
66. Open.add (NodeB);
68. Open.add (NODEC);
70. Open.add (noded);
72. Open.add (NodeE);
74. Open.add (NODEF);
76. Open.add (NODEG);
78. Open.add (Nodeh);
80. Close.add (NodeA);
82. return NodeA;
84. }
86. }

The structure of the diagram is as follows:


The Dijkstra object is used to calculate the shortest path from the starting node to all other nodes
[Java]View PlainCopy

2. Public class Dijkstra {
4. set<node> open=New hashset<node> ();
6. set<node> close=New hashset<node> ();
8. map<string,integer> path=New hashmap<string,integer> (); Package path Distance
10. map<string,string> pathinfo=New hashmap<string,string> (); Package path Information
12. Public Node Init () {
14. //initial path, because there is no a->e this path, so path (E) is set to Integer.max_value
16. Path.put ("B", 1);
18. Pathinfo.put ("B", "a->b");
20. Path.put ("C", 1);
22. Pathinfo.put ("C", "a->c");
24. Path.put ("D", 4);
26. Pathinfo.put ("D", "a->d");
28. Path.put ("E", Integer.max_value);
30. Pathinfo.put ("E", "A");
32. Path.put ("F", 2);
34. Pathinfo.put ("F", "a->f");
36. Path.put ("G", 5);
38. Pathinfo.put ("G", "a->g");
40. Path.put ("H", Integer.max_value);
42. Pathinfo.put ("H", "A");
44. //Put the initial node in close and the other nodes into the open
46. Node start=New Mapbuilder (). Build (Open,close);
48. return start;
50. }
52. public void Computepath (Node start) {
54. Node Nearest=getshortestpath (start); //Take the nearest child node of the start node and put the close
56. if (nearest==null) {
58. return;
60. }
62. Close.add (nearest);
64. Open.remove (nearest);
66. Map<node,integer> Childs=nearest.getchild ();
68. For (Node Child:childs.keySet ()) {
70. if (open.contains (child)) {//If sub-nodes are in open
72. Integer Newcompute=path.get (Nearest.getname ()) +childs.get (child);
74. if (Path.get (Child.getname ()) >newcompute) {//previously set distance is greater than the newly calculated distance
76. Path.put (Child.getname (), newcompute);
78. Pathinfo.put (Child.getname (), Pathinfo.get (Nearest.getname ()) +"--" +child.getname ());
80. }
82. }
84. }
86. Computepath (start); //Repeat yourself to ensure that all child nodes are traversed
88. Computepath (nearest); //outward layer recursively until all vertices are traversed
90. }
92. public void Printpathinfo () {
94. Set<map.entry<string, string>> pathinfos=pathinfo.entryset ();
96. for (map.entry<string, string> Pathinfo:pathinfos) {
98. System.out.println (Pathinfo.getkey () +":" +pathinfo.getvalue ());
100. }
102. }
104. /** 
106. * Get the nearest child node with node
108. */
110. Private node Getshortestpath (node node) {
112. Node res=null;
114. int mindis=integer.max_value;
116. Map<node,integer> Childs=node.getchild ();
118. For (Node Child:childs.keySet ()) {
120. if (open.contains (child)) {
122. int Distance=childs.get (child);
124. if (Distance<mindis) {
126. Mindis=distance;
128. Res=child;
130. }
132. }
134. }
136. return res;
138. }
140. }

Main for testing Dijkstra objects
[Java]View PlainCopy

1. Public class Main {
2. public static void Main (string[] args) {
3. Dijkstra test=New Dijkstra ();
4. Node Start=test.init ();
5. Test.computepath (start);
6. Test.printpathinfo ();
7. }
8. }

Print out the following:
D:a->d
E:a->f->e
F:a->f
G:a->c->g
B:a->b
C:a->c
H:a->b->h Reference Link: Java implementation Dijkstra algorithm to find the shortest path in Java to write a Dijkstra algorithm (single source shortest path algorithm, Dijkstra algorithm) shortest path-dijkstra algorithm and Floyd algorithm

Dijkstra algorithm for Shortest Path (Java) (RPM)