如何使用来自3个数组的数据实现对二叉树的有序，前序和后序遍历

Question

I understand that the binary tree can be implemented easily this way:

class Node {
    int key;
    Node left, right;
    public Node(int item) {
        key = item;
        left = right = null;
    }
}

class BinaryTree {
    Node root;
    public BinaryTree() {
      root = null;
    }
}

Also the methods for traversal that I've figured out are:

void printInorder(Node node) {
    if (node == null) return;
    printInorder(node.left);
    System.out.print(node.key + " ");
    printInorder(node.right);
}

void printPreorder(Node node) {
    if (node == null) return;
    System.out.print(node.key + " ");
    printPreorder(node.left);
    printPreorder(node.right);
}

void printPostorder(Node node) {
    if (node == null) return;
    printPostorder(node.left);
    printPostorder(node.right);
    System.out.print(node.key + " ");
}

However, I'm given this starter file where the tree data is in 3 arrays: key[],left[] and right[], so key[] elements are the data of the nodes, left and right elements are the indexes of the left and right child of the ith node, so Node root is keys[0], with left child keys[left[0]] and keys[right[0].

I'm not sure how (or if I need) to convert the 3 arrays into a Binary tree using the Node and BinaryTree classes. Where should the Node and BinaryTree classes should go? Outside of tree_orders? Inside of tree_orders but outside of TreeOrders? (sorry about the "creative" naming convention, not mine)

Do I need to iterate over the three arrays to build the tree nodes?

I tried implementing the insert(int data) and insert(Node n, int data) methods below to convert the arrays into nodes but it doesn't seem to fill the tree.

Node insert(int data) {
     root = insert(root, data);
     return node;
}

Node insert(Node node, int data) {
     if (node == null) {
          node = new Node(data)         
     }
     else {
          if (node.left == null) insert(node.left, data);
          else insert(node.right, data);
     }
     return node;
}

It's just 5 months that I've started learning programming (picked Java) and I've worked with Trees before but this starter is an OOP puzzle for me, I'll need to recheck my OOP knowledge.

This is an example of how the input and output should show (-1 = null node / 5 = number of given nodes):

Input:
5
4 1 2
2 3 4
5 -1 -1
1 -1 -1
3 -1 -1

Output:
1 2 3 4 5
4 2 1 3 5
1 3 2 5 4 

Answer 1

Your question is not very clear. The title asks about traversal but you also have worries about reading 100.000 nodes and about giving nodes a name, and about iteration/recursion slowness. That's a whole muddled bundle of confusion!

The traversal logic you show looks OK at first glance.

Assuming you want to build a binary tree using your Node class from the three arrays you could do this (you don't need the BinaryTree class, it only contains the root Node):

class TreeMaker {

    private int[] keys, left, right;

    TreeMaker(int[] keys, int[] left, int[] right) {
        this.keys = keys;
        this.left = left;
        this.right = right;
    }

    public Node make() {
        return makeNode(0);
    }

    private Node makeNode(int index) {
        if (index < 0 || index >= keys.length) {
            return null;
        }
        Node node = new Node(keys[index]);
        node.left = makeNode(left[index]);
        node.right = makeNode(right[index]);
        return node;
    }
}

I think 100.000 nodes is not that much. Making it should not pose a problem either memory wise or speed wise (unless you start doing complex searching, indexing or other fun stuff). NOTE: after seeing the artificial limitations imposed on the Thread running this code, it might be a problem.

You don't have to store nodes in named variables or otherwise name them. Just making sure the binary tree nodes refer to the correct children is enough.

EDIT: about your starter file

This is total crap:

while (!tok.hasMoreElements())
            tok = new StringTokenizer(in.readLine());

Firstly StringTokenizer is a legacy class that should no longer be used (for new code). String.split() is the alternative to use nowadays. Furthermore, creating a new instance of StringTokenizer for each line is unnecessary and wasteful. Are you bound to use this code as-is?

And do I understand that you're supposed to enter your tree data from the command line? Why not read the data from a file so you only have to type it in once?

And how are you supposed to type in a valid binary tree? The values in left[] and right[] are actually indices of the key[], so you will have to figure out, whilst typing, in which index each child node will be stored? Crazy stuff. The person setting you this task much be a little bit sadistic. There are much better ways to store binary trees in a single array, see for example this lecture .

This is also remarkable:

static public void main(String[] args) throws IOException {
        new Thread(null, new Runnable() {
                public void run() {
                    try {
                        new tree_orders().run();
                    } catch (IOException e) {
                    }
                }
            }, "1", 1 << 26).start();
}

Here the class tree_orders (sic.) is run in a Thread with a stack size of 1 << 23 . This stack size is a hint to the Java runtime to limit the memory needed to keep track of nested method calls to 8388608 bytes. This is probably intended to either make you hit a limit when implementing this recursively, or to ensure that you don't (I haven't figured out which one it is).

In order to apply my TreeMaker in this example, you could use in the run() method :

public void run() throws IOException {
    TreeOrders tree = new TreeOrders();
    tree.read();

    TreeMaker treeMaker = new TreeMaker(tree.keys, tree.left, tree.right);
    Node root = treeMaker.make();

    printInorder(root);
    printPreorder(root);
    printPostorder(root);
}

But I get the impression you are supposed to just implement the three given methods and do the traversal on the existing data structure (3 arrays).

Answer 2

What a poor design, those arrays. Anyway, if you want or need to stick to it, traversing the tree is not too bad:

void printInorder(int index) {
    if (index == -1) return;
    printInorder(left[index]);
    System.out.print(keys[index] + " ");
    printInorder(right[index]);
}

Similarly for the other traversal orders. I am assuming -1 in either left or right means no decendant. To print the whole tree, call printInOrder(0) since the root is in index 0.

Edit: I believe your example gives the following arrays:

    int[] keys = { 4, 2, 5, 1, 3 };
    // indices 0..4
    int[] left = { 1, 3, -1, -1, -1 };
    int[] right = { 2, 4, -1, -1, -1 };

With these, calling printInorder(0) and then System.out.println() prints:

1 2 3 4 5