我在 Java 中的 BFS 最短路径实现有什么问题

Question

import java.io.*;
import java.util.*;

class Graph
{
    private int V;   // No. of vertices
    private LinkedList<Integer> adj[]; //Adjacency Lists
    private LinkedList<Integer> path[];


    Graph(int v)
    {
        V = v;
        adj = new LinkedList[v];
        for (int i=0; i<v; ++i)
            adj[i] = new LinkedList();
        path = new LinkedList[v];
        for(int i=0;i<v;++i)
            adj[i]=new LinkedList();
    }


    void addEdge(int v,int w)
    {
        adj[v].add(w);
    }

    // prints BFS traversal from a given source s
    void BFS(int s,int d)
    {
        boolean visited[] = new boolean[V];
        LinkedList<Integer> queue = new LinkedList<Integer>();


        visited[s]=true;
        queue.add(s);
        path[s].addLast(s);
        while (queue.size() != 0)
        {

            s = queue.poll();
            //System.out.print(s+" ");


            Iterator<Integer> i = adj[s].listIterator();
            while (i.hasNext())
            {
                int n = i.next();
                if (!visited[n])
                {
                    visited[n] = true;
                    queue.add(n);
                    path[n]=path[s];
                    path[n].addLast(n);
                }
            }
        }

        System.out.print("Following is the path from source to destination\n");
        while(path[d].size()!=0)
        {
            int xyz=path[d].getFirst();
            path[d].poll();
            System.out.print(xyz+" ");
        }
    }

    // Driver method to
    public static void main(String args[])
    {
        Graph g = new Graph(4);

        g.addEdge(0, 1);
        g.addEdge(0, 2);
        g.addEdge(1, 2);
        g.addEdge(2, 0);
        g.addEdge(2, 3);
        g.addEdge(3, 3);

        System.out.println("Following is the desired path\n");

        g.BFS(2,3);
    }
}

I need to get the shortest path between nodes 2 and 3.

Answer 1

You're attempting to add an element to a linked list that is null. You need to initialize the linked list at index s before you can add to it.

path[s] = new LinkedList();
path[s].addLast(s);

Additionally, your code is failing because you don't clone the path array when setting the value of path[n]:

path[n]=path[s];

You need to change this to:

path[n]= (LinkedList) path[s].clone();

This way the list for n won't retain a reference to the list of s. Currently, the reference is retained, so that whenever you add something to the list for n, that thing will also be added to s.

Answer 2

As there is no information what exactly isn't behaving as expected, it is a bit difficult to say what the error is. But I see two problems with the code:

First, you don't initialize the elements of the path . Instead, in the constructor you initialize the elements of adj twice. So, you should replace one of the lines that say

for(int i=0; i<v; ++i)
     adj[i] = new LinkedList();

with

for(int i=0; i<v; ++i)
     path[i] = new LinkedList();

or you can just delete the two lines as you will see now:

The second problem is that you set the different elements of path as the reference to another LinkedList and edit it:

path[n] = path[s];
path[n].addLast(n);

This has as result that every element of path uses the same LinkedList with the same elements. Instead you should create a new LinkedList containing the same elements:

path[n] = new LinkedList(path[s]);
path[n].addLast(n);

EDIT: As Soggiorno said in his answer, you must at least initialize path[s] at the beginning of the BFS -method before adding an element to it:

path[s] = new LinkedList();
path[s].addLast(s);

If you do the initialization for all the elements of path this isn't needed, of course.