dijkstra这个算法的意思百度下大概就能明白。我主要讲的是如何实现。
首先，我们如何用java去保存一张有向图？
我用hashmap去存它的起点位置，然后value用list加节点的方式，感觉就像链表一样。去存储
地图模板
//创建地图
/* * S——16——>C—— 2——>D * | \ ^ ^ ^ * 4 8 | \ | * | \ 7 5 6 * v v | \ | * A—— 3——>B—— 1——>E */
class Graph
{
Map<Character,List<Node>> map=new HashMap<Character,List<Node>>();//输出的地图
Graph()
{
List<Node> list=new ArrayList<Node>();
list.add(new Node('S','A',4));
list.add(new Node('S','B',8));
list.add(new Node('S','C',16));
list.add(new Node('A','B',3));
list.add(new Node('B','C',7));
list.add(new Node('B','E',1));
list.add(new Node('C','D',2));
list.add(new Node('E','C',5));
list.add(new Node('E','D',6));
for(int i=0;i<list.size();i++)
{
List<Node> temp=map.get(list.get(i).getSrc());
if(temp==null)
temp=new ArrayList<Node>();
temp.add(list.get(i));
map.put(list.get(i).getSrc(), temp);
}
}
}
class Node
{
private Character src;//起点
private Character des;//终点
private int len; //距离长度
private int path=Integer.MAX_VALUE;//初始设置为无穷长
boolean die=false; //访问过一次后就死亡
Node(){}
Node(Character src,Character des,int len)
{
this.src=src;
this.des=des;
this.len=len;
}
void setPath(int path)
{
this.path=path;
}
int getPath()
{
return path;
}
Character getSrc()
{
return src;
}
Character getDes()
{
return des;
}
int getLen()
{
return len;
}
}
然后为了凸显出链表的效率。我们先来个普通模式的dijkstra算法的实现，这个方式去实现其算法复杂度是O（V^2）V是节点数量
public class Dijkstra
{
public static Map<Character,Integer> dijkstra(Map<Character,List<Node>> map,Character c)
{
Queue<Node> heap=new LinkedList<Node>();
//初始节点
Node root=new Node(c,c,0);
root.setPath(0);
heap.add(root);
Map<Character,Integer> result=new HashMap<Character,Integer>();
while(!heap.isEmpty())
{
Node x=heap.poll(),y = null;
List<Node> temp=map.get(x.getDes());
if(temp==null)
continue;
for(int i=0;i<temp.size();i++)
{
y=temp.get(i);
if(y.getPath()>x.getPath()+y.getLen())
{
temp.get(i).setPath(x.getPath()+y.getLen());
if(temp.get(i).die==false)
{
heap.add(temp.get(i));
temp.get(i).die=true;
}
if(result.get(temp.get(i).getDes())==null)
{
result.put(temp.get(i).getDes(),temp.get(i).getPath());
}
if(result.get(temp.get(i).getDes())>temp.get(i).getPath())
{
result.put(temp.get(i).getDes(),temp.get(i).getPath());
}
}
}
}
return result;
}
public static void main(String[] argc)
{
Graph graph=new Graph();
Map<Character,Integer> result=dijkstra(graph.map,'S');
for(Map.Entry<Character,Integer> entry:result.entrySet())
{
System.out.println("S-->"+entry.getKey()+" 长度"+entry.getValue());
}
}
}
大致就是这样实现下。
然后我们就要讨论为什么要用有限队列？因为它是堆的形式。堆便于取出最值，如果一个算法中需要多次取最大或者最小值，那么堆就是个最好的存放容器，其建堆只要O(N)的时间，增删，堆化时间复杂度也只要O(logn)。有很大的优势。
用堆去存储 复杂度降低到O(VlogV)
代码如下
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
//创建地图
/*
* S——16——>C—— 2——>D
* | \ ^ ^ ^
* 4 8 | \ |
* | \ 7 5 6
* v v | \ |
* A—— 3——>B—— 1——>E
*/
class Graph
{
Map<Character,List<Node>> map=new HashMap<Character,List<Node>>();//输出的地图
Graph()
{
List<Node> list=new ArrayList<Node>();
list.add(new Node('S','A',4));
list.add(new Node('S','B',8));
list.add(new Node('S','C',16));
list.add(new Node('A','B',3));
list.add(new Node('B','C',7));
list.add(new Node('B','E',1));
list.add(new Node('C','D',2));
list.add(new Node('E','C',5));
list.add(new Node('E','D',6));
for(int i=0;i<list.size();i++)
{
List<Node> temp=map.get(list.get(i).getSrc());
if(temp==null)
temp=new ArrayList<Node>();
temp.add(list.get(i));
map.put(list.get(i).getSrc(), temp);
}
}
}
class Node
{
private Character src;//起点
private Character des;//终点
private int len; //距离长度
Node(){}
Node(Character src,Character des,int len)
{
this.src=src;
this.des=des;
this.len=len;
}
Character getSrc()
{
return src;
}
Character getDes()
{
return des;
}
int getLen()
{
return len;
}
}
public class Dijkstra2
{
static Map<Character, Integer> dijkstra(Map<Character,List<Node>> graph,Character source)
{
//堆的初始化
PriorityQueue<Map.Entry<Character, Integer>> queue=new PriorityQueue<Map.Entry<Character, Integer>>((a,b)->a.getValue()-b.getValue()); Map<Character, Integer> map=new HashMap<Character, Integer>(); map.put(source, 0); queue.add(map.entrySet().iterator().next()); Map<Character, Integer> visited=new HashMap<Character, Integer>(); while(!queue.isEmpty()) { //从堆中获取最小距离的节点 Entry<Character, Integer> temp=queue.poll(); //讲距离值添加到visited if(visited.get(temp.getKey())==null) visited.put(temp.getKey(), temp.getValue()); if(graph.get(temp.getKey())==null) { continue; } //更新与temp相邻各节点neighbour的distance for(int i=0; i<graph.get(temp.getKey()).size();i++) { if(visited.get(graph.get(temp.getKey()).get(i).getDes())!=null) { continue; } Map<Character, Integer> temp2=new HashMap<Character, Integer>(); temp2.put(graph.get(temp.getKey()).get(i).getDes(), temp.getValue()+graph.get(temp.getKey()).get(i).getLen()); queue.add(temp2.entrySet().iterator().next()); } } return visited; } public static void main(String[] argc) { Graph graph=new Graph(); Map<Character, Integer> result=dijkstra(graph.map,'S'); for(Map.Entry<Character,Integer> entry:result.entrySet()) { System.out.println("S-->"+entry.getKey()+" 长度"+entry.getValue()); } } } 
