Need help finalizing breadth-first search function...

Question

I have a map with bidirectional links and I am to find the shortest path so the first path found will be good for me. I tried follow the algorithm for BFS and it shows below. However, I am not sure when/where/what I should return per loop. I would like to get a list of Nodes (map represented by numeric node numbers). I dont think returning a list is right for this recursion so i put down int for now... I think the steps are right but just not sure how to get the result.... Please help! thanks!
public int(?) getShortestPath() {
          int currentNode = bfsQueue.remove();//already has Root from start
          if (currentNode == destNode) {
               shortestPathFound = true;
          } else {
               ArrayList<Integer> temp = getChildrenLinks(currentNode);
               for (int x=0; x< temp.size(); x++) {
                    bfsQueue.add(temp.get(x));
          if (bfsQueue.size() == 0) {
               return null;
          } else if (shortestPathFound == false){
               getShortestPath();
          return null;
     }

Answer 1

You have almost all variable defined outside your method. You "should" declare them inside. Also, there is no need to make a recursive call (which makes it easier to return your path).
Here's a debugged version of a BFS:
Say you have the following edges:
1 <--> 2
1 <--> 3
2 <--> 5
2 <--> 6
3 <--> 4
4 <--> 5
5 <--> 6
5 <--> 7
7 <--> 8
7 <--> 9
8 <--> 9
8 <--> 10A picture of this would look like:
1 --- 2 --- 6
|      \___ |     9
|          \|    /|
3 --- 4 --- 5   / |
            |  /  |
            | /   |
            7 --- 8 --- 10And you want to find the shortest path from 1 to 8.
Create a stack that holds all "layers" (a list of numbers) that you are discovering. So you start with an empty STACK and push the start node (in a list) on it:
STACK {
  {1} // layer 1
}Pop the last "layer" from your STACK and collect all it's unvisited neighbours. All these unvisited neighbours are the next layer which should be pushed on your STACK. Now your STACK looks like:
STACK {
  {1}   // layer 1
  {2,3} // layer 2
}Again pop the last layer from your stack (this is now {2,3}) and collect all it's unvisited neighbours and push these on your STACK. Now your STACK looks like:
STACK {
  {1}     // layer 1
  {2,3}   // layer 2
  {4,5,6} // layer 3
}Keep pushing new "layers" on your STACK until you stumble upon your destination node (8 in this example). So, when you get to your destination node, your STACK looks like:
STACK {
  {1}     // layer 1
  {2,3}   // layer 2
  {4,5,6} // layer 3
  {7}     // layer 4
  {8,9}   // layer 5
}Now that you have gotten to your destination, it's time to find the actual path by back-tracking through your "layers" where you must "jump" from "layer" N to a "layer" N-1 (you can only "jump" to a lower "layer"):
The back-tracking will look like:
STACK {
  {1}     // layer 1
   | 
  {2,3}   // layer 2
  {4,5,6} // layer 3
  {7}     // layer 4
   |
  {8,9}   // layer 5
- 8 (in layer 5) is connected to 7 (in layer 4)
- 7 (in layer 4) is connected to 5 (in layer 3)
- 5 (in layer 3) is connected to 2 (in layer 2)
- 2 (in layer 2) is connected to 1 (in layer 1)So, your shortest path is: [1,2,5,7,8]
HTH