如何使用广度优先搜索在树中找到从一个顶点到另一个顶点的路径？

Question

I am trying to implement a BFS that returns a path from a to b in form of a list of vertices. I am implementing this BFS on a tree so I know it will be the shortest path if I can find one. However, so far my research has only led me to find BSF algorithms that search and find nodes, rather than return a path.

The input that I am dealing with is an adjacency matrix of the Minimum Spanning Tree. I must take this and find path from one point to the other.

Answer 1

If you really want to use BFS to solve this, to trace the path from source to destination you need to store the parent of each node visited. Here's a sample BFS without optimizations.

import java.util.*;

public class bfs {

    static class Node {
        Node parent;
        int x;

        Node (int x) {
            this (x, null);
        }

        Node (int x, Node parent) {
            this.parent = parent;
            this.x = x;
        }

        void trace () {
            if (parent == null) {
                System.out.print (x);
            } else {
                parent.trace ();
                System.out.print ("->" + x);
            }
        }
    }

    static void bfs (int start, int goal, int[][] adj) {
        List<Node> list = new ArrayList<> ();

        list.add (new Node (start));

        while (!list.isEmpty ()) {
            Node cur = list.remove (0);

            if (cur.x == goal) {
                cur.trace ();
                break;
            } else {
                for (int i = 0; i < adj[cur.x].length; i++) {
                    if (adj[cur.x][i] == 1) {
                        list.add (new Node (i, cur));
                    }
                }
            }
        }
    }

    public static void main (String[] args) {
        int[][] adjacency_matrix = {
            {0, 1, 1, 0, 0},
            {1, 0, 0, 1, 0},
            {1, 0, 0, 0, 0},
            {0, 1, 0, 0, 1},
            {0, 0, 0, 1, 0}
        };
        int start = 0;
        int goal = 4;

        bfs (start, goal, adjacency_matrix);
    }

}

Answer 2

Dijkstra or A* is probably what you want to use. It depends, though. What you seem to be describing is a pathfinding algorithm, not a node search.