Question3Max. score: 100.00Level Order of TreeGiven an array of unique elements, construct a Binary Search Tree and print the Level Order of the tree.Input FormatFirst line of each test case contains N - number of nodes in the BST. The next line contains N unique integers - value of the nodes.ConstraintsPrint the Level Order of the Binary Search Tree, separate each level by newline.Output Format1 <= N <= 10000 <= ar[i] <= 10000Sample input6 10 5 15 2 7 12Sample output10 5 15 2 7 12

The question is asking to implement a Binary Search Tree (BST) from an array of unique elements and then print the level order traversal of the tree. Here are the steps to solve this problem:

The problem is asking to construct a Binary Search Tree (BST) from a given array of unique elements and then print the level order traversal of the tree.

Here are the steps to solve this problem:

1. First, we need to construct the BST from the given array. We start by initializing the root of the tree with the first element of the array. Then for each subsequent element in the array, we insert it into the BST. To insert an element, we start from the root and if the element is less than the root, we go to the left child, otherwise we go to the right child. We continue this process until we find an empty spot where we can insert the new element.

2. Once we have constructed the BST, we need to print the level order traversal of the tree. We can do this by using a queue data structure. We start by pushing the root of the tree into the queue. Then while the queue is not empty, we remove the front element from the queue, print it, and then push its left and right children (if they exist) into the queue. We continue this process until the queue is empty.

3. The level order traversal of the tree is the sequence of elements printed in step 2. Each level is separated by a newline.

Here is a Python solution for the problem:

from collections import deque

class Node:
    def __init__(self, key):
        self.left = None
        self.right = None
        self.val = key

def insert(root, key):
    if root is None:
        return Node(key)
    else:
        if root.val < key:
            root.right = insert(root.right, key)
        else:
            root.left = insert(root.left, key)
    return root

def printLevelOrder(root):
    if root is None:
        return
    queue = deque()
    queue.append(root)
    while queue:
        nodeCount = len(queue)
        while nodeCount > 0:
            node = queue.popleft()
            print(node.val, end=' ')
            if node.left is not None:
                queue.append(node.left)
            if node.right is not None:
                queue.append(node.right)
            nodeCount -= 1
        print()

n = int(input())
arr = list(map(int, input().split()))
root = None
for i in range(n):
    root = insert(root, arr[i])
printLevelOrder(root)

This solution reads the number of nodes and the nodes' values from the input, constructs the BST, and then prints the level order traversal of the tree.