题目：

给定一个有序整数数组，元素各不相同且按升序排列，编写一个算法，创建一棵高度最小的二叉搜索树。
示例:
给定有序数组: [-10,-3,0,5,9],
一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：
          0 
         / \ 
       -3   9 
       /   / 
     -10  5 

题目的理解：

看到题目的时候还是觉得很奇怪的，觉得有很多很多可能性啊。当去搜索了二叉搜索树的定义后明白了思路。

二叉查找树（Binary Search Tree），
（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 
若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉排序树。

基本思路就是找到数组的中心点，创建一个节点，然后左边和右边的数组分别再继续查找中心点创建节点。

python实现

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        node, left, right = self.initial(nums)

        self.create(node, left, right)

        return node

    def create(self, node: TreeNode, left_list: List[int], right_list: List[int]):
        if node is None:
            return

        if left_list is not None and 0 < len(left_list):
            left_node, left_left, left_right = self.initial(left_list)
            node.left = left_node
            self.create(left_node, left_left, left_right)

        if right_list is not None and 0 < len(right_list):
            right_node, right_left, right_right = self.initial(right_list)
            node.right = right_node
            self.create(right_node, right_left, right_right)

    def initial(self, nums: List[int]) -> (TreeNode, List[int], List[int]):
        if nums is None or 0 >= len(nums):
            return None, None, None

        middle = int(len(nums) / 2)
        if middle >= len(nums):
            return None, None, None

        node = TreeNode(nums[middle])
        left = nums[0:middle]
        right_middel = middle + 1
        if right_middel < len(nums):
            right = nums[middle + 1: len(nums)]
        else:
            right = None

        return node, left, right

提交

感觉已经不是简单算法了吧，难道是我的认知低了吗！！！

还可以

// END 感觉还行吧，思考了半个小时而已