[LeetCode#108]Convert Sorted Array to Binary Search Tree

The problem:

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

My analysis:

The recursion is the best way to solve this kind of problem: At each step, we follow the same pattern to divide the problem into subproblems, and merge the answers together as the original problem. (divide - conqueror)
The problem's pattern is:
1. we find the mid of the given array, and set it as the current tree's root(new a node).
2. we set the left pointer to the result of tree ([low ... mid - 1]).
3. we set the right pointer to the result of tree ([mid + 1 ... high]).
4. then we return the node.

On thing we should be bery careful is the base case.
It's very easy to wrongly write the base case as:

if (low == high) {
    return TreeNode(num[low]);
}

This problem is arisen from the wrong conception that: in binary search(divide), we could always reach the (low == high) as termination condition. In fact this idea is absolutely wrong!!! That's way we use "while(low <= high)" as condition for loop in binary search.
In fact, we could not always reach "low == high", considering following cases:

ret.left = helper(num, low, mid - 1);
ret.right = helper(num, mid + 1, high);

1. num[] = [0, 1]
low = 0, high = 1, mid = (low + high) / 2 = 0.
helper (num, low, mid - 1) ===> helper(num, 0, -1); //low == high could not be used. 
helper (num, mid + 1, high) ===> helper(num, 1, 1);

2. num[] = [0, 1, 2]
low = 0, high = 1, mid = (low + high) / 2 = 1.
helper (num, low, mid - 1) ===> helper(num, 0, 0);
helper (num, mid + 1, high) ===> helper(num, 1, 1);

From aboving analysis, we could find out that, when the searched array is in odds length, we would meet "low == high".
However, when the array is in even length, we would not meet "low == high".

We could fix this problem by using "low > high" as termination condition.
For this case, we use following base case:

if (low > high) { //we use a violation as base case!!! beautiful!
    return null;
}

1. num[] = [0, 1]
low = 0, high = 1, mid = (low + high) / 2 = 0.
helper (num, low, mid - 1) ===> helper(num, 0, -1); //violation happens, return null 
helper (num, mid + 1, high) ===> helper(num, 1, 1); 
===>
low =  1, high = 1, mid = (low + high) / 2 = 1.
helper (num, low, mid - 1) ===> helper(num, 1, 0); //violation happens, return null
helper (num, mid + 1, high) ===> helper(num, 2, 1); //violation happens, return null

Thus, we could perfectly reach the right termination state!

My solution:

/**
 * 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) {
        if (num == null || num.length == 0)
            return null;
        
        return helper(num, 0, num.length - 1);
    }
    
    public TreeNode helper(int[] num, int low, int high) {
        
        if (low > high) {
            return null;
        }
        
        int mid = (low + high) / 2;
        TreeNode ret = new TreeNode(num[mid]); //partion the num array into two part 
        ret.left = helper(num, low, mid - 1); //point the left child pointer to the left part of the tree
        ret.right = helper(num, mid + 1, high); //point the right child pointer to the right part of the tree
        
        return ret;
    }
}