Java 迪克斯特拉'；s算法打印最新的前置路径，而不是最短路径

目前，我的打印功能打印最近访问的节点到目的地的路径，而不是最短路径。例如，如果最短路径是a，c，e，a=1，c=1，e=4，另一条路径是a，d，e，权重为a=1，d=4，e=4，那么我的算法将沿着这个方向运行：a，c，d，e，但会打印一个d e，因为最近访问了这些路径，并且我的setPreference（）方法被设置为错误的前置。任何关于这方面的想法都将非常感激，无论是修复我当前的代码还是以不同的方式尝试

class ShortestPathFinder {
        private  Graph graph = new Graph();
        private  Vertex source = new Vertex(0, null);
        private Vertex destination = new Vertex(0,null);
        private  Map<Vertex,Vertex> previousVertex = new HashMap();

    public void  findShortestPath(Graph graph, Vertex source, Vertex destination, ReadInput graphReader) {
        this.destination = destination;
        this.source = source;

        source.setDistanceFromSource(0);
        PriorityQueue<Vertex> priorityQueue = new PriorityQueue<>();
        priorityQueue.add(source);
        source.setVisited(true);
        boolean destinationFound = false;

        while( !priorityQueue.isEmpty() && destinationFound == false){
            // Getting the minimum distance vertex from priority queue
            Vertex actualVertex = priorityQueue.poll();
            System.out.println("working on: " + actualVertex.getID());

            actualVertex = graphReader.SetAdjList(actualVertex);


            for(Edge edge : actualVertex.getAdjacenciesList()){
                Vertex v = edge.getTargetVertex();
                System.out.println("a Neighbor is: " + v.getID());
                if(!v.isVisited()) {
                    if(v.getID() == destination.getID() || edge.getStartVertex().getID() == destination.getID()) {
                        System.out.println("Destination found");
                            destination.setPredecessor(actualVertex);
                            destination.setDistanceFromSource(actualVertex.getDistanceFromSource() + edge.getWeight());
                            destinationFound = true;
                            break;  
                    }
                    double newDistance = actualVertex.getDistanceFromSource() + edge.getWeight();

                    if( newDistance < v.getDistanceFromSource() ){
                        priorityQueue.remove(v);
                        v.setDistanceFromSource(newDistance);
                        v.setPredecessor(actualVertex);
                        priorityQueue.add(v);
                        System.out.println("Added: " + v.getID());
                    }
                }
            }
            actualVertex.setVisited(true);
        }       
    }

    public List<Vertex> getPath() {
        List<Vertex> path = new ArrayList<>();
        for(Vertex vertex=destination;vertex!=null;vertex=vertex.getPredecessor()){
                path.add(vertex);
        }
        Collections.reverse(path);
        return path;
    }       
} 

class ShortestPathFinder{
私有图=新图（）；
私有顶点源=新顶点（0，空）；
私有顶点目标=新顶点（0，空）；
private Map previousVertex=新HashMap（）；
public void FindShortPath（图形、顶点源、顶点目标、ReadInput GraphThreader）{
this.destination=目的地；
this.source=源；
source.setDistanceFromSource（0）；
PriorityQueue PriorityQueue=新的PriorityQueue（）；
priorityQueue.add（源）；
source.setvisted（true）；
布尔destinationFound=false；
而（！priorityQueue.isEmpty（）&&destinationFound==false）{
//从优先级队列获取最小距离顶点
顶点actualVertex=priorityQueue.poll（）；
System.out.println（“处理：+actualVertex.getID（））；
actualVertex=graphhreader.SetAdjList（actualVertex）；
对于（边缘：actualVertex.GetAdjanceList（））{
顶点v=边。getTargetVertex（）；
println（“邻居是：+v.getID（））；
如果（！v.isvisted（））{
如果（v.getID（）==destination.getID（）| | edge.getStartVertex（）.getID（）==destination.getID（））{
System.out.println（“找到目的地”）；
destination.setpreceptor（actualVertex）；
destination.setDistanceFromSource（actualVertex.getDistanceFromSource（）+edge.getWeight（））；
destinationFound=true；
打破
}
double newDistance=actualVertex.getDistanceFromSource（）+edge.getWeight（）；
if（newDistance

如果删除行会发生什么

destinationFound=true和
中断？我不相信Dijkstra的标准实现在第一次找到目的地时一定会停止，而是继续搜索以确保找到绝对最短路径。标准实现没有，我只是在使用它们，所以我的程序不会运行，因为我的“图”非常大，除去它们，我也会得到同样的结果。我可能会尝试更多的输入案例，我相信我基于代码的测试案例可能计算不正确和
中断？我不相信Dijkstra的标准实现在第一次找到目的地时一定会停止，而是继续搜索以确保找到绝对最短路径。标准实现没有，我只是在使用它们，所以我的程序不会运行，因为我的“图”非常大，除去它们，我也会得到同样的结果。我可能会尝试更多的输入案例，我相信我基于代码的测试案例可能无法正确计算。