将升序数组转化为平衡二叉搜索树

/**
 * #[derive(PartialEq, Eq, Debug, Clone)]
 * pub struct TreeNode {
 *     pub val: i32,
 *     pub left: Option<Box<TreeNode>>,
 *     pub right: Option<Box<TreeNode>>,
 * }
 *
 * impl TreeNode {
 *     #[inline]
 *     fn new(val: i32) -> Self {
 *         TreeNode {
 *             val: val,
 *             left: None,
 *             right: None,
 *         }
 *     }
 * }
 */
struct Solution{

}

impl Solution {
    fn new() -> Self {
        Solution{}
    }

    fn new_node(n: i32) -> Option<Box<TreeNode>> {
        Some(Box::new(TreeNode::new(n)))
    }
    fn binary_gen(nums: &Vec<i32>, left: i32, right: i32) -> Option<Box<TreeNode>> {
        if right < left {
            None
        } else {
            let mid = left + (right - left) / 2;
            let mut node = Self::new_node(nums[mid as usize]);
            node.as_mut()?.left = Self::binary_gen(nums, left, mid - 1);
            node.as_mut()?.right = Self::binary_gen(nums, mid + 1, right);
            node
        }
    }

    /**
    * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
    *
    * 
        * @param nums int整型一维数组 
        * @return TreeNode类
    */
    pub fn sortedArrayToBST(&self, nums: Vec<i32>) -> Option<Box<TreeNode>> {
        // write code here
        Self::binary_gen(&nums, 0, nums.len() as i32 - 1)
    }
}