Given an array where elements are sorted in ascending order, convert it to a height balanced BST.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

Example:

Given the sorted array: [-10,-3,0,5,9],
One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:

      0
     / \
   -3   9
   /   /
 -10  5

A BST has the feature that:
left children are all smaller than root and right children are always greater than the root.

So as given a sorted array, we want to find the middle element as the root.

And this has become a binary-search (Since we are building a BST, so, yeah).

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        if(nums.length==0) return null;
        return helper(nums, 0, nums.length-1);

    }
    public TreeNode helper(int[] nums, int start, int end){

        if(start<=end){
            int mid = start + (end - start)/2;
            TreeNode root = new TreeNode(nums[mid]);
            root.left=helper(nums, start, mid-1);
            root.right=helper(nums, mid+1, end);
            return root;
        } 
        return null;

    }

}

One thinking is that, for binary search, always keep in mind that we should use (mid-1) and (mid+1) for the iteration.
And the iterative method to loop through a tree often requires extra data structures such as queue and stack.