10

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.

Vishwanath Gulabal
  • 109
  • 4
  • 17
poorvank
  • 7,524
  • 19
  • 60
  • 102

2 Answers2

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;
    }
}
displayName
  • 13,888
  • 8
  • 60
  • 75
0

Added solution here

I have used queue to read all nodes at a particular level, before reading the nodes checking if given level(n) is equal to current level then checking size of the queue is greater than f(n) then just read f(n) nodes from queue and mark it as deleted otherwise perform mod operation and delete the node nl%f(n).

Raja Jain
  • 41
  • 4