Array to BST [EASY]

Company: VMWare, Cisco, Amazon

Question: 

Given a sorted array. Write a program that creates a Balanced Binary Search Tree using array elements. If there are n elements in array, then floor(n/2)'th element should be chosen as root and same should be followed recursively.

Input:

The first line of input contains an integer T denoting the number of test cases.
The first line of each test case is N,N is the size of array.
The second line of each test case contains N input A[].

Output:

Print the preorder traversal of constructed BST.

Constraints:

1 ≤ T ≤ 100
1 ≤ N ≤ 1000
1 ≤ A[] ≤ 10000

Example:

Input:
1
7
7 6 5 4 3 2 1

Output:
4 6 7 5 2 3 1

CODE:

import java.util.*;

import java.lang.*;

import java.io.*;

class Node{

    int data;

    Node right,left;

    Node(int d){

        data=d;

        left=null;right=null;

    }

}

class BinaryTree {

    static Node root;

public static void main (String[] args) {

BinaryTree tree= new BinaryTree();

Scanner sc = new Scanner(System.in);

int m = sc.nextInt();

for(int mi=0;mi<m;mi++){

   int n = sc.nextInt();

   int [] a= new int [n];

   for(int i=0;i<n;i++){

       a[i]=sc.nextInt();

   }

   root=tree.findroot(a,0,n-1);

   tree.preOrder(root);

   System.out.println();

}

}

Node findroot(int arr[], int start, int end) {

        /* Base Case */

        if (start > end) {

            return null;

        }

        /* Get the middle element and make it root */

        int mid = (start + end) / 2;

        Node node = new Node(arr[mid]);

        /* Recursively construct the left subtree and make it

         left child of root */

        node.left = findroot(arr, start, mid - 1);

        /* Recursively construct the right subtree and make it

         right child of root */

        node.right = findroot(arr, mid + 1, end);

         

        return node;

    }

    void preOrder(Node node) {

        if (node == null) {

            return;

        }

        System.out.print(node.data + " ");

        preOrder(node.left);

        preOrder(node.right);

    }

}

EXECUTION TIME: 0.22s