Pre-Order Traversal Tree

Question

I seem to be having an issue adding right nodes to left nodes. I have an input file (.txt) that is listed in pre-order

Fred    1900
2
John    1925
3
Mary    1950
2
Jason   1972
0
Heather 1975
2
Sydney  2002
0
Hailey  2005
0
John    1951
1
Amy 1983
0
Fred    1953
3
Mark    1977
0
Sarah   1979
1
Michael 2005
0
Adam    1982
0
Joan    1927
2
Susan   1949
0
David   1952
1
Fred    1980
0

Here is my Node class:

public class Node {
    public String name;
    public int year;
    //this will help with determining the parent in the insertion process
    public int children;    
    public Node parent;
    public Node left;
    public Node right;


    public Node(String name, int year, int children){
        this.name = name;
        this.year = year;
        this.children = children;
    }
}

Assuming that my nodes are created successfully I seem to be having an issue creating the actual tree.

public class FamilyTree {    

    public Node familyTree;

    private Node pivotalNode;
    private Node parent;
    private int children = 0;
    //This method adds a family member to the family tree    
    public void add(Node newNode){
        familyTree = add(familyTree,newNode);
    }
    private Node add(Node familyTree, Node newNode){        
        if(familyTree == null){
            children = newNode.children;
            newNode.parent = parent;
            familyTree = newNode;

        }
        else if(children > 0){
            parent = familyTree;
            familyTree.left = add(familyTree.left, newNode);
            pivotalNode = familyTree.left;
        }
        else if(children == 0){          

            familyTree.right = add(familyTree.right, newNode);
            return pivotalNode;
        }        
        return familyTree;
    }  
} 

The Results are to show a Tree as follows:

Here is my Main method:

public class Operations {

    //Not necessary but it helps me to get more organized. Just want to extract information first.
    public static ArrayList<String> information = new ArrayList<String>();  

    public static void main(String args[]){
        //extract information from file
        getFileContents();

        //Object initialization
        FamilyTree family = new FamilyTree();

        //some useful variables for loop below
        int children =0;
        String[] splitted = null;
        Node member = null;        

        for(int i=0; i<information.size(); i++){
            //Every other line in the text file perform a different operation
            if(i % 2 == 1){
                try{
                    children = Integer.parseInt(information.get(i));
                    member = new Node(splitted[0], Integer.parseInt(splitted[1]), children);
                    family.add(member);
                }
                catch(Exception e){
                    //this determines if the pattern is broken
                    break;
                }
            }
            if(i % 2 == 0){                               
                splitted = information.get(i).split("\\s+");
                //this determines a pattern difference                
                if(splitted.length < 2){
                    break;
                }
            }
        }
        System.out.print("hi");
    }
    //Pretty self explanatory. Read each line of the file and store it into an array. 
    //Not necessary as everything could technically be done at once (insertion), but this keeps me 
    //more organized to put everything together later on 
    public static void getFileContents(){
        try{
            BufferedReader br = new BufferedReader(new FileReader("includes\\assn2in.txt"));            

            String line;
            String info;

            while ((line = br.readLine()) != null) {
                info = line.replaceAll("\\s+", " ");
                information.add(info);               
            }            
            br.close();


        }
        catch(IOException e){
            System.out.println("Error: "+e);
        }
    } 
}

Any help would be appreciated thanks.

Answer 1

One big issue you have is that your Node class models a binary tree structure--that is, it contains left and right members to represent the children--but the data itself does not conform to this structure. If you look at the diagram, you can see that some nodes have as many as three children (e.g. John 1925 and Fred 1953). You need to use an ArrayList instead of left and right so that your Node can handle an arbitrary number of children:

public class Node {
    public String name;
    public int year;
    //this will help with determining the parent in the insertion process
    public int expectedNumberOfChildren;    
    public Node parent;
    public ArrayList<Node> children;

    public Node(String name, int year, int expectedNumberOfChildren){
        this.name = name;
        this.year = year;
        this.expectedNumberOfChildren = expectedNumberOfChildren;
        this.children = new ArrayList<Node>(expectedNumberOfChildren);
    }
}

As far as building the tree from the data file, I would use a Stack structure with the following algorithm (pseudocode):

• Create an empty stack.
• Initialize a Node variable called "root" to null.
• Open the data file for reading.
• While not at the end of the file:
  • Read the next name, year and expected number of children from the file.
  • Create a new Node from the name, year and expected number of children.
  • If the root node is null:
    • Set the root node to the new node.
    • Push the new node onto the stack.
  • Otherwise:
    • Pop the last node off the stack (call this "parent").
    • Set the new node's parent to the parent just popped off the stack.
    • Add the new node to the parent's list of children.
    • If the actual size of the parent's list of children is less than the parent's expected number of children originally read from the file, push the parent back onto the stack.
    • If the expected number of children of the new node is greater than zero, push it onto the stack.
• Close the file.

And that's it. When the loop finishes, the "root" node will point to the fully-constructed tree, assuming the input file is well-formed. (The stack is no longer needed after that.)