将有序数组转化为二叉树

一、递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

    TreeNode* sorted(vector<int>& nums, int i, int j){
        if(i >= j ) return NULL;

        int mid = (i + j) / 2;

        TreeNode* root = new TreeNode(nums[mid]);

        root->left = sorted(nums, i, mid);
        root->right = sorted(nums, mid + 1, j);

        return root;

    }

    // 递归算法
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return sorted(nums, 0, nums.size());
    }
};

二、迭代

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

    // 迭代算法
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        TreeNode* root = new TreeNode(0);   
        queue<TreeNode*> nodeQue;           
        queue<int> leftQue;                 
        queue<int> rightQue;                
        nodeQue.push(root);                 
        leftQue.push(0);                    
        rightQue.push(nums.size() - 1); 


        while(!nodeQue.empty()){
            TreeNode* curNode = nodeQue.front();
            nodeQue.pop();

            int left = leftQue.front();
            int right = rightQue.front();
            int mid = (left + right) / 2;

            leftQue.pop();
            rightQue.pop();

            curNode->val = nums[mid];

            // 左子树
            if(mid > left){
                TreeNode* left_node = new TreeNode(0); 
                leftQue.push(left);
                rightQue.push(mid - 1);
                nodeQue.push(left_node);
                curNode->left = left_node;
            }

            // 右子树
            if(mid < right){
                TreeNode* right_node = new TreeNode(0); 
                leftQue.push(mid + 1);
                rightQue.push(right);
                nodeQue.push(right_node);
                curNode->right = right_node;
            }
        }

        return root;
    }
};