Java parse binary tree structure

Question

I'm currently going through some data structures, and I've come across some data that is stored in a binary tree and I'm not entirely sure of the best way of parsing it.

Essentially the data is stored like this:

Structure 1: 
  LeftChild: 0xaddress
    Structure 2: 
      LeftChild: 0xaddress
        Structure 3:
         LeftChild: 0xaddress
          ........
         RightChild: 0xaddress
          Structure 4:
            LeftChild: 0xaddress
            RightChild: 0xaddress
      RightChild: 0xaddress
  RightChild: 0xaddress

Now obviously it's quite hard to do a textual explanation of a binary tree, so hopefully my poor attempt above explains it a bit. Essentially it all starts with a structure, which has a left and right tree entries, each in turn has left and right, and eventually one of them will run out of nodes, and then the next branch of the tree carries on.

I'm not entirely sure of the best way of tackling this.

My first though was through the use of a while loop to just keep on chasing the tree nodes, but that seems like a bit of a headache to keep track of.

I know Java has binary tree implementations, but I don't know if it's possible to use them for this sort of work. I've never tried to use them, so I might be wrong.

If anyone has any advice or suggestions on how to tackle this, I'd greatly appreciate it.

Thanks!

Does the order matter in the way you parse it? Like in order vs pre order, etc. — But I'm Not A Wrapper Class, Aug 06 '13 at 18:28
No the order shouldn't matter, as the nodes contain enough information to put it all back together again if needed. — Tony, Aug 06 '13 at 18:29

score 2 · Accepted Answer · answered Aug 06 '13 at 19:19

One advice: if your tree can get too deep, you should avoid recursion based solution. That is because you can have a stack overflow problem.

To deal with this situation, you can make use of a stack.

The following pseudocode traverses all binary tree nodes without recursion.

visitNodes(root) 
    add the root on the stack

    while the stack is not empty
        nodeToBeProcessed <- pop the top node from the stack

        process nodeToBeProcessed

        if nodeToBeProcessed has a left child
            add the left child on the stack

        if nodeToBeprocessed has a right child
            add the right child on the stack

Note: the pop operation returns and removes the top node from the stack.

Note 2: if depth is not a problem, a recursion based solution is usually simpler.

Looks like a stack was just the ticket, and it was nice and easy to implement. No need for horrible recursion! Thanks — Tony, Aug 06 '13 at 20:03

score 1 · Answer 2 · answered Aug 06 '13 at 18:06

Recursion is the traditional way to do it in some sort of pseudo-code form:

Node { // data
    Node leftChild;
    Node rightChild;
}

handleNode(Node node) {
    if (node is missing or null or blank)
        return;
    ... handle anything on the node
    handleNode(node.leftChild);
    handleNode(node.rightChild);
}

score 1 · Answer 3 · answered Aug 06 '13 at 19:53

If I understand correctly your problem is with reading the information from a file with that format rather than traversing the tree once it is parsed. You should create the nodes and keep track of who is sibling of who using a stack you can get a way to construct your nodes.

Stack<String> stack = new Stack<String>();
try {
    BufferedReader in = new BufferedReader(new FileReader("yourfile.txt"));
    String str;
    while ((str = in.readLine()) != null)
    {

        if(str.contains("Structure"))
        {
            stack.push(str);
        }else
        {
            if(str.contains("Left"))
            {
                stack.push(str);
            }
            if(str.contains("Right"))
            {
                System.out.println(stack.pop());    
                System.out.println(str);
                System.out.println(stack.pop());
            }
        }
    }
    in.close();
} catch (IOException e) {
    e.printStackTrace();
}

Using your example this code prints:

         LeftChild: 0xaddress
         RightChild: 0xaddress
        Structure 3:
            LeftChild: 0xaddress
            RightChild: 0xaddress
          Structure 4:
      LeftChild: 0xaddress
      RightChild: 0xaddress
    Structure 2: 
  LeftChild: 0xaddress
  RightChild: 0xaddress
Structure 1:

with which you can build the nodes. Hope it helps.

score 0 · Answer 4 · edited May 23 '17 at 10:25

I'm not sure how exactly you implemented yoru stuff, but try this (you will need to make some obvious name changes):

//list to put all data into
private static ArrayList<String> list = new ArrayList<String>();

//recursive way to search binary tree
public void binaryTreeSearchAndParse(Node root)
{
    //does it exist?
    if(root != null)
    {
        list.add(root.getData());
        binaryTreeSearchAndParse(root.getLeft());
        binaryTreeSearchAndParse(root.getRight());
        //you may or may not need this depending on how you implemented your tree
        //binaryTreeSearchAndParse(root.getNextStructure());
    }    
}

public static void main(String[] args)
{

   //get tree
   //pass in root of tree
   binaryTreeSearchAndParse(tree.getRoot());

    //now all data should be added in the global ArrayList
    for(int i = 0; i<list.size(); i++)
    {
         System.out.println(list.get(i));
    }
}

I can help you more if I knew how you implemented your tree.

This is a recursive solution. If you want an iterative solution, you should use a queue:

Binary search tree level order with parent node

Java parse binary tree structure

4 Answers4