LeetCode 108. Convert Sorted Array to Binary Search Tree

题目：

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

---

这道题刚开始也没想到怎么去构造，后来看了discussion以后才发现原来和之前在剑指上做过的重建二叉树挺像的，也是先拎出父节点（数组最中间的元素），然后递归构造左右子树（数组的左半边和右半边）。知道思路以后就开始构造递归函数，由于要分开左右两棵子树，而它们分属不同的vector代表区间，于是参数就传原始数组和起始位置。每次遇到这种类似于分治、二分的题目我都会特别纠结边界条件，至今还没搞懂究竟要怎么去判断。这次的题目也是被边界条件搞死了，并且依旧没有理解。这道题其实答案不唯一，因为可以有多种构造方式，而边界条件设置的不同也会导致最终构造出的树的结构不同。比如下面代码中的第一种解法构造出来的树和示例的相同，而第二种解法构造出来的树则不同，分别如下：

猜了好久出现这样的情况的原因，把每一次递归的begin、end和nums[mid]都打印出来看了一下，观察出了一点规律：

由于第一种解法在nums.size()和mid都不-1导致每次mid的选择都会尽量靠后的那一个，所以靠近根节点的数字会偏大，并且在比较begin和end的时候，由于尽可能地靠后选择了，所以数字一般出现在左边，NULL在右边，到最后begin==end时就不需要再重复打印；而第二种解法的nums.size()和mid都-1了，因此每次mid的选择都会选前面那个，所以靠近根节点的数字会偏小，在比较begin和end的时候，由于mid-1，所以可能会出现begin>end的情况，而前面一种顶多就是begin==end，在这种情况下，在判断递归结束的条件时，就只需要begin>end了。说了这么多，还是搞不懂，到底是怎么推算出边界条件的对应关系的呢QAQ

另外还看到了java版的迭代版本，但是看起来实在是太复杂了，就，放弃了orz 链接：Loading...

首先是第一种解法，时间20ms，92.98%，空间24.97%，生成效果和示例相同：

/*
 * @lc app=leetcode id=108 lang=cpp
 *
 * [108] Convert Sorted Array to Binary Search Tree
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if (nums.size() == 0) {
            return NULL;
        }

        return buildTree(nums, 0, nums.size());  // nums.size()
    }

    TreeNode* buildTree(vector<int>& nums, int begin, int end) {
        if (begin >= end) {  // >=
            return NULL;
        }

        int mid = (begin + end) / 2;
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = buildTree(nums, begin, mid);  // mid
        root->right = buildTree(nums, mid + 1, end);
        return root;
    }
};

第二种解法，时间20ms，92.98%，空间27.73%，生成的是另一种二叉树：

/*
 * @lc app=leetcode id=108 lang=cpp
 *
 * [108] Convert Sorted Array to Binary Search Tree
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if (nums.size() == 0) {
            return NULL;
        }

        return buildTree(nums, 0, nums.size() - 1);  // nums.size() - 1
    }

    TreeNode* buildTree(vector<int>& nums, int begin, int end) {
        if (begin > end) {  // >
            return NULL;
        }

        int mid = (begin + end) / 2;
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = buildTree(nums, begin, mid - 1);  // mid - 1
        root->right = buildTree(nums, mid + 1, end);
        return root;
    }
};

/*
      0
     / \
   -10  5
     \   \
     -3   9
*/

最后，据说在递归函数的参数中，采用引用的方式比不采用引用的方式快，试了一下果真是这样的，引用20ms，传值288ms，具体原因我给忘了哈哈哈，以后再说吧。

---

2020.10.15 Java

一年了，还是不会做这道题，卑微。二分的条件还是习惯用上面解法二的，还是要多复习。

Runtime: 0 ms, faster than 100.00% of Java online submissions for Convert Sorted Array to Binary Search Tree.

Memory Usage: 38.7 MB, less than 6.09% of Java online submissions for Convert Sorted Array to Binary Search Tree.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return buildTree(nums, 0, nums.length - 1);
    }
    
    private TreeNode buildTree(int[] nums, int start, int end) {
        if (start > end) {
            return null;
        }
        int mid = start + (end - start) / 2;
        TreeNode node = new TreeNode(nums[mid]);
        node.left = buildTree(nums, start, mid - 1);
        node.right = buildTree(nums, mid + 1, end);
        return node;
    }
}

2022.10.24

两年过去了，居然会做这道题了？但是helper里的边界条件判断还是搞错了。刚开始想的是start == end，回头看了答案才意识到应该是start > end，因为存在start和mid相等的情况，所以start可能 < mid - 1。主要是这一点需要注意一下。