Depth first search tree

Question

Hi,
I have stored some states in a vector (States are numbers). In my code i have printed out the parent nodes, the 2 elements after the parent nodes are there child.
The element placed at position 0 in the vector is the root. I do not know how to implement a depth first search tree to address unreachable node. In this case, parent node 5 is unreachable, from other nodes. But i do not know how to do this. I have spent ages reading tutorials/ book, but i cant seem to convert this knowledge into java. My code is very short and therefore easy to understand
import java.awt.*;
import java.util.*;
public class Vec{
public static void main(String argv[]){
    Vec v = new Vec();
    v.remove();
    }//End of main
public void remove(){
        Vector mv = new Vector();
        //Note how a vector can store objects
        //of different types
        mv.addElement(1);  // root and parent node of 2 elements below
        mv.addElement(2);  // child of above
        mv.addElement(1);  // child of above
        mv.addElement(2);  // parent of 2 elements below
        mv.addElement(4);
        mv.addElement(2);
        mv.addElement(3); // parent of 2 elements below
        mv.addElement(1);
        mv.addElement(3);
        mv.addElement(4); // parent of 2 elements below
        mv.addElement(3);
        mv.addElement(4);
        mv.addElement(5);  // parent of 2 elements below
        mv.addElement(2);
        mv.addElement(4);
// below identifys the parent nodes for you, but doesnt store them as parent nodes
                for(int i=0; i< mv.size(); i++){
        if (i % 3 == 0)
                  System.out.println(mv.elementAt(i));
   }//End of amethod
        

Answer 1

Ah ok, it's a graph and not a tree. In that case don't use the tree-code I posted, but model your graph as an adjacency matrix (AM) [1]. The AM for the graph you posted in reply #5 would look like this:
Node | 1  2  3  4  5
-----+--------------
   1 | 1  1  0  0  0
     |
   2 | 0  1  0  1  0
     |
   3 | 1  0  1  0  0
     |
   4 | 0  0  1  1  0
     |
   5 | 0  1  1  0  0You can implement this by using a simple 2D array of integers like this:class Graph {
    private int[][] adjacencyMatrix;
    public Graph(int numNodes) {
        adjacencyMatrix = new int[numNodes][numNodes];
    public void addEdge(int from, int to) {
        adjacencyMatrix[from-1][to-1] = 1;
    public boolean isReachable(Integer start, Integer goal) {
        // your algorithm here
        return false;
    public String toString() {
        StringBuilder strb = new StringBuilder();
        for(int i = 0; i < adjacencyMatrix.length; i++) {
            int[] row = adjacencyMatrix;
strb.append((i+1)+" | ");
for(int j = 0; j < row.length; j++) {
strb.append(adjacencyMatrix[i][j]+" ");
strb.append('\n');
return strb.toString();
public static void main(String[] args) {
Graph graph = new Graph(5);
graph.addEdge(1, 1);
graph.addEdge(1, 2);
graph.addEdge(2, 2);
graph.addEdge(2, 4);
graph.addEdge(3, 1);
graph.addEdge(3, 3);
graph.addEdge(4, 3);
graph.addEdge(4, 4);
graph.addEdge(5, 2);
graph.addEdge(5, 3);
System.out.println("Adjacency Matrix:\n"+graph);
System.out.println("Is node 5 reachable from node 1? "+
graph.isReachable(new Integer(1), new Integer(5))); // should be false
System.out.println("Is node 1 reachable from node 5? "+
graph.isReachable(new Integer(5), new Integer(1))); // should be true: a path exists from 5 -> 3 -> 1 and 5 -> 2 -> 4 -> 3 -> 1
Good luck.
[1]
http://en.wikipedia.org/wiki/Adjacency_matrix
http://mathworld.wolfram.com/AdjacencyMatrix.html