狄克斯特拉最短路径问题

import java.util.*;

//狄克斯特拉最短路径问题
public class MinPath {

 //图
 class Graph {

    public List<com.pingan.sourcecode.graph.Node> nodesList;
    public List<com.pingan.sourcecode.graph.Edge> edgesList;

    Graph(List nodesList, List edgesList){
        this.nodesList = nodesList;
        this.edgesList = edgesList;
    }

}

 //边
 static class Edge {
    public Integer length;
    public Node from;
    public Node to;

    Edge(Integer length, Node from, Node to){
        this.length = length;
        this.from = from;
        this.to = to;
    }
}

//点
static class Node {
    public Integer value;
    public int on;
    public int to;
    public List<com.pingan.sourcecode.graph.Node> nodesList;
    public ArrayList<Edge> edgesList;

    Node(Integer value){
        this.value = value;
        on = 0;
        to = 0;
        nodesList = new ArrayList<>();
        edgesList = new ArrayList<>();
    }
}

public Map getMinPath(Node from){
    HashMap<Node, Integer> nodeInstanceMap = new HashMap<>();
    HashSet<Node> nodeContainsSet = new HashSet<>();
    nodeInstanceMap.put(from,0);
    Node minNode = getMinNodeNotThroughIfNecessary(nodeInstanceMap,nodeContainsSet);
    while (minNode != null){
        List<Edge> edgesList = minNode.edgesList;
        for (Edge edge:edgesList) {
            if (nodeInstanceMap.containsKey(edge.to)){
                nodeInstanceMap.put(edge.to,Math.min(nodeInstanceMap.get(edge.from)+edge.length,nodeInstanceMap.get(edge.to)));
            }else {
                nodeInstanceMap.put(edge.to,nodeInstanceMap.get(edge.from)+edge.length);
            }
        }
        minNode = getMinNodeNotThroughIfNecessary(nodeInstanceMap,nodeContainsSet);
    }
    return nodeInstanceMap;
}

private Node getMinNodeNotThroughIfNecessary(HashMap<Node, Integer> nodeInstanceMap, HashSet<Node> nodeContainsSet) {
    int minInstance = Integer.MAX_VALUE;
    Node minNode = null;
    for (Node node: nodeInstanceMap.keySet()) {
        if (!nodeContainsSet.contains(node)){
            minInstance = nodeInstanceMap.get(node) <= minInstance ? nodeInstanceMap.get(node) : minInstance;
            minNode = nodeInstanceMap.get(node) <= minInstance ? node : minNode;
        }
    }
    nodeContainsSet.add(minNode);
    return minNode;
}

public static void main(String[] args) {
    Node node_01 = new Node(1);
    Node node_02 = new Node(2);
    Node node_03 = new Node(3);
    Node node_04 = new Node(4);
    Node node_05 = new Node(5);
    Node node_06 = new Node(6);
    ArrayList<Edge> edgeLists_01 = new ArrayList<>();
    ArrayList<Edge> edgeLists_02 = new ArrayList<>();
    ArrayList<Edge> edgeLists_03 = new ArrayList<>();
    ArrayList<Edge> edgeLists_04 = new ArrayList<>();
    ArrayList<Edge> edgeLists_05 = new ArrayList<>();
    Edge edge_01 = new Edge(1,node_01,node_04);
    Edge edge_02 = new Edge(2,node_01,node_03);
    Edge edge_03 = new Edge(8,node_01,node_02);
    edgeLists_01.add(edge_01);
    edgeLists_01.add(edge_02);
    edgeLists_01.add(edge_03);
    Edge edge_04 = new Edge(1,node_02,node_05);
    edgeLists_02.add(edge_04);
    Edge edge_05 = new Edge(1,node_03,node_05);
    Edge edge_06 = new Edge(5,node_03,node_02);
    edgeLists_03.add(edge_05);
    edgeLists_03.add(edge_06);
    Edge edge_07 = new Edge(4,node_04,node_03);
    edgeLists_04.add(edge_07);
    Edge edge_08 = new Edge(10,node_05,node_06);
    edgeLists_05.add(edge_08);
    node_01.edgesList = edgeLists_01;
    node_02.edgesList = edgeLists_02;
    node_03.edgesList = edgeLists_03;
    node_04.edgesList = edgeLists_04;
    node_05.edgesList = edgeLists_05;
    MinPath minPath = new MinPath();
    Map minPathMap = minPath.getMinPath(node_01);
    Set<Node> set = minPathMap.keySet();
    for (Node node : set){
        System.out.println(node.value + ":" + minPathMap.get(node));
    }
}

}