全局最短路径搜索算法 Dijkstra

今天介绍一种简化的搜索最短路径算法Dijkstra（这里的假设是所有结点之间的边都拥有一致的权重）。

原理介绍

对于一个选中的结点（这里将其定义为原始种子结点）若要搜索其与所有结点的最短路径，可以先寻找所有与其距离为一步的结点，之后以这些节点为候选种子结点进一步搜索，寻找与其相邻近的的结点（不包括原始种子结点），这样，新找到的结点必然与原始种子结点具有最短距离，且为2步。以此类推，直到再也找不到候选种子结点，算法结束，原始结点与所有的结点之间的最短路径也都寻找完毕。

以下是算法的示意图：

算法实现：

（1）存储点边

package hmu.core;


import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;


public>
Map<String,ArrayList<String>> Node_EdgeInfor = new HashMap<String,ArrayList<String>>();
private ArrayList<String>>
public PPICalculatorBeta(File file) throws IOException{
BufferedReader>String>while((tmpStr=br.readLine())!=null){
String[]>if(!this.Node_EdgeInfor.containsKey(tmpStrs[0])){
this.vertices.add(tmpStrs[0]);
ArrayList<String>>tmpAl.add(tmpStrs[1]);
this.Node_EdgeInfor.put(tmpStrs[0], tmpAl);
}else{
this.Node_EdgeInfor.get(tmpStrs[0]).add(tmpStrs[1]);
}

if(!this.Node_EdgeInfor.containsKey(tmpStrs[1])){
this.vertices.add(tmpStrs[1]);
ArrayList<String>>tmpAl.add(tmpStrs[0]);
this.Node_EdgeInfor.put(tmpStrs[1], tmpAl);
}else{
this.Node_EdgeInfor.get(tmpStrs[1]).add(tmpStrs[0]);
}
}
br.close();
}


public void Analyze(){

}

public Map<String, ArrayList<String>> getNode_EdgeInfor() {
return Node_EdgeInfor;
}


public void setNode_EdgeInfor(Map<String, ArrayList<String>> node_EdgeInfor) {
Node_EdgeInfor = node_EdgeInfor;
}


public ArrayList<String> getVertices() {
return vertices;
}


public void setVertices(ArrayList<String> vertices) {
this.vertices = vertices;
}


}

（2）计算指定点的最短路径

package hmu.core;


import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;


public class PPIShortestPath {

private ArrayList<ArrayList<String>> results = new ArrayList<ArrayList<String>>();
private Map<String,String> Mark = new HashMap<String,String>();
private Map<String,ArrayList<String>> Node_EdgeInfor;
private String seed;

public PPIShortestPath(Map<String,ArrayList<String>> Node_EdgeInfor,String vertice){
this.Node_EdgeInfor = Node_EdgeInfor;
this.seed = vertice;
}

public void shortestPath(){
ArrayList<String> Seeds = new ArrayList<String>();
this.Mark.put(this.seed, "null");
Seeds.add(this.seed);
while(Seeds.size()>0){
Seeds=this.search(Seeds);
}
}

public ArrayList<String> search(ArrayList<String> seeds){
ArrayList<String> tmpSeeds = new ArrayList<String>();
for(int i=0;i<seeds.size();i++){
ArrayList<String> tmpLeafs = this.Node_EdgeInfor.get(seeds.get(i));
for(int j=0;j<tmpLeafs.size();j++){
if(!this.Mark.containsKey(tmpLeafs.get(j))){
tmpSeeds.add(tmpLeafs.get(j));
this.Mark.put(tmpLeafs.get(j), "null");
}
}
}
this.results.add(tmpSeeds);
return tmpSeeds;
}

public void Store(File file,boolean NotUpdate) throws IOException{
BufferedWriter bw = new BufferedWriter(new FileWriter(file,NotUpdate));
for(int i=0;i<this.results.size();i++){
ArrayList<String> al = this.results.get(i);
for(int j=0;j<al.size();j++){
bw.append(this.seed+","+al.get(j)+":"+(i+1));
bw.newLine();
}
}
bw.close();
}
}