Print Specific nodes at a every level calculated by a given function

Question

In an interview, i was given a function:

f(n)= square(f(n-1)) - square(f(n-2)); for n>2
f(1) = 1;
f(2) = 2;
Here n is the level of an n-array tree. f(n)=1,2,3,5,16...

For every level n of a given N-Array I have to print the f(n) node at every level. For example:

At level 1 print node number 1 (i.e. root) 
At level 2 print node number 2 (from left)
At level 3 print node number 3 (from left)
At level 4 print node number 5... and so on

If the number of nodes(say nl) at any level n is less than f(n), then have to print node number nl%f(n) counting from the left.

I did a basic level order traversal using a queue, but I was stuck at how to count nodes at every level and handle the condition when number of nodes at any level n is less than f(n).

Suggest a way to proceed for remaining part of problem.

Answer 1

You need to perform Level Order Traversal.

In the code below I am assuming two methods:

• One is getFn(int level) which takes in an int and returns the f(n) value;
• Another is printNth(int i, Node n) that takes in an int and Node and beautifully prints that "{n} is the desired one for level {i}".

The code is simple to implement now. Comments explain it like a story...

public void printNth throws IllegalArgumentException (Node root) {

    if (root == null) throw new IllegalArgumentException("Null root provided");

    //Beginning at level 1 - adding the root. Assumed that levels start from 1
    LinkedList<Node> parent = new LinkedList<>();
    parent.add(root)
    int level = 1;

    printNth(getFn(level), root);

    //Now beginning from the first set of parents, i.e. the root itself,
    //we dump all the children from left to right in another list.
    while (parent.size() > 0) { //Last level will have no children. Loop will break there.

        //Starting with a list to store the children
        LinkedList<Node> children = new LinkedList<>();

        //For each parent node add both children, left to right
        for (Node n: parent) {
            if (n.left != null) children.add(n.left);
            if (n.right != null) children.add(n.right);
        }

        //Now get the value of f(n) for this level
        level++;
        int f_n = getFn(level);

        //Now, if there are not sufficient elements in the list, print the list size
        //because children.size()%f(n) will be children.size() only!
        if (children.size() < f_n) System.out.println(children.size()); 
        else printNth(level, children.get(f_n - 1)); //f_n - 1 because index starts from 0

        //Finally, the children list of this level will serve as the new parent list 
        //for the level below.
        parent = children;
    }
}