algorithm problem with recursion

[Max Vandenburg]

I have an algorithm problem with recursion:

i have a route from A to D and it looks like this

[A, B, C, D]

the alphabet in the above list is an object of a class, lets call that class Nodes

each of this Nodes object they have some attributes... these are of type set..

the first set will store a bunch of other Nodes (these represent the current nodes neighbour)
the second set will store a bunch of tracks (Integer object representing what tracks the current nodes belong to)

(... bare with me here... )

so now i write up some code that initialise all the nodes... and here is the output...

A: [B, Z, E] // A's next neighbour
A: [2, 1, 3] // A belongs to these tracks
B: [C, A]
B: [1]
C: [B, D]
C: [4, 1]
D: [F, C]
D: [4]

and here is the code: (i removed the System.out... to shorten the code..)

public class Path {
    private Nodes a, b, c, d, e, f, z;
    private List path = new ArrayList();
    /** Creates a new instance of path */
    public Path() {
     
         a = new Nodes("A"); //used nodes
         b = new Nodes("B"); //used nodes
         c = new Nodes("C"); //used nodes
         d = new Nodes("D"); //used nodes
         e = new Nodes("E"); // wont be used directly
         f = new Nodes("F"); // wont be used directly
         z = new Nodes("Z"); // wont be used directly
         path.add(a);
         path.add(b);
         path.add(c);
         path.add(d);
         
        // setting Nodes a 
        a.getNext().add(b);
        a.getNext().add(e);
        a.getNext().add(z);
 
        Integer[] iA = {1, 2, 3};
        a.getTrackID().addAll(Arrays.asList(iA));
 
        // setting Nodes b 
        b.getNext().add(a);
        b.getNext().add(c);
        b.getTrackID().add(Integer.valueOf(1));
 
        // setting Nodes c 
        c.getNext().add(b);
        c.getNext().add(d); 
        c.getTrackID().add(Integer.valueOf(1));
        c.getTrackID().add(Integer.valueOf(4));
 
        // setting Nodes d 
        d.getNext().add(c);   
        d.getNext().add(f);   
        d.getTrackID().add(Integer.valueOf(4));
 
    }
    
    public static void main(String[] args) { new Path();}
}
 
class Nodes{
    private Set next = new HashSet();
    private Set trackID = new HashSet();
    private String name = "";
    Nodes(String name){ this.name = name;}
    public Set getNext() {   return next;} 
    public Set getTrackID() { return trackID;} 
    public String toString() {return this.name;}    
}

what i want to do is to come up with some recursive algorithm so that it would print out something like this...

Path = A - B - C - D
A to C track 1
C to D track 4

so i've come up with a pseudo code...

method1(Node startNode, List path){
 
iterate through startNode.getNext set
 
if nodes return is in the list path{
newNodes = returned nodes;
path.remove(startNodes);
if(startNodes.getTrack() == newNodes.getTrack())
{ // if startNodes shares the same track as the next nodes 
then line = the track;
method1(newNodes, path);
}else{
   print startNode "to" newNodes "track" line
if there is still some journey
method(newNodes, path)
}
}
}

i've also come up with an actuall code but for some reason it'll only prints out the first step...

the code for this to follow...

[Steve Fahlbusch]

Given the data shouldn't your output be:

A - B - C - D
 
A - B track 2
B - C track 1
C - D track 1

Or are there some other rules here?

[Max Vandenburg]

No. Here is the output from again

A: [B, Z, E] // A's next neighbour
A: [2, 1, 3] // A belongs to these tracks
B: [C, A]
B: [1]
C: [B, D]
C: [4, 1]
D: [F, C]
D: [4]

here A has 3 next neighbours that is B Z and E
and A has a/belongs to 3 tracks 1, 2, and 3

and we are given a route from A - B - C - D

so from A we are only interested with B (dont care about Z & E)
then we look at the what track A has and we also look at what track B has...
in this case track 1 is a match...

so then we do a next matching

B neighbour is A and C. A is already been visited... so we only care about C... see for macthing line and between B and C which is 1... and so on...