LeetCode 108. Convert Sorted Array to Binary Search Tree （将有序数组转换成BST）

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

/**
 * 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;
        if (nums.size() == 1)
        {
            return new TreeNode(nums[0]);
        }
        
        int mid = nums.size() / 2;
        TreeNode *root = new TreeNode(nums[mid]);
        
        vector<int> leftNs(nums.begin(), nums.begin() + mid);     
        vector<int> rightNs(nums.begin() + mid + 1, nums.end());
        
        root->left = sortedArrayToBST(leftNs);
        root->right = sortedArrayToBST(rightNs);
        
        return root;
    }
};

 法二：

/**
 * 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 nullptr;
       }
       
       if(nums.size() == 1)
       {
           return new TreeNode(nums[0]);
       }
       
       int mid = (0 + nums.size()) / 2;
        
       TreeNode *root = new TreeNode(nums[mid]);
       root->left = sortedArrayToBST(nums, 0, mid - 1);
       root->right = sortedArrayToBST(nums, mid + 1, nums.size() - 1);
    
       return root;
    }
    
    TreeNode* sortedArrayToBST(vector<int>& nums, int start, int end){
    
        if (start > end) return nullptr;
        
        int mid = (start + end) / 2;
        TreeNode *root = new TreeNode(nums[mid]);
        root->left = sortedArrayToBST(nums, start, mid - 1);
        root->right = sortedArrayToBST(nums, mid + 1, end);
        
        return root;
        
    }

};