Convert Sorted Array to Binary Search Tree

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

Update  15/01/2014: 

Note that in terms of BST, the result of in-order traversal must be a sorted array in ASC order. 

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode sortedArrayToBST(int[] num) {
        int len=num.length;
        if(len==0) return null;
        
        TreeNode root = new TreeNode(num[len/2]);
        root.left = sortedArrayToBST(Arrays.copyOfRange(num, 0, len/2));
        root.right = sortedArrayToBST(Arrays.copyOfRange(num, len/2+1, num.length));
        
        return root;
    }
}

Analysis: 

1. Get the middle element of the current array and construct the root with such value. 

2. Do step 1 recursively, until the length of the current array is 1. At that time, the single value of the array should be a value of a leaf of the BST. 

3. Right subtree may not exist.

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode sortedArrayToBST(int[] num) {
        int len = num.length;
        if(len == 0) {
            return null;
        }
        
        TreeNode root = new TreeNode(num[len/2]);
        if(len == 1) {
            return root;
        }
        
        int [] lsubtree = Arrays.copyOfRange(num, 0, len/2);
        root.left = sortedArrayToBST(lsubtree);
        if(len/2+1 <= num.length) {
            int [] rsubtree = Arrays.copyOfRange(num, len/2+1, num.length);
            root.right = sortedArrayToBST(rsubtree);
        }
        
        return root;
    }
}