力扣算法二叉树篇：将有序数组转换为二叉搜索树

递归三部曲：
1、确定递归函数参数及其返回值

//通过左右下标来确定构造区间 避免重新定义数组作为参数传递
 TreeNode* BuildBST(vector<int>& nums,int left,int right)

2、确定递归终止条件
当左边界大于右边界时即可停止
3、确定单层递归逻辑
数组中间数值作为根节点，递归构造左右子树

/**
 * 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* BuildBST(vector<int>& nums,int left,int right){
        if(left>right){
            return NULL;
        }
        //中间结点
        int mid = (left+right)/2;
        TreeNode* root = new TreeNode(nums[mid]);
        //递归构造左右子树
        root->left = BuildBST(nums,left,mid-1);
        root->right = BuildBST(nums,mid+1,right);
        return root;

    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        //选取中间点作为分割点构造二叉树
        return BuildBST(nums,0,nums.size()-1);
    }
};

迭代：

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();
            leftQue.pop();
            int right = rightQue.front();
            rightQue.pop();
            //计算中间元素下标
            int mid = (left+right)/2;
            //将mid对应元素赋值给中间结点
            curNode->val = nums[mid];
            //处理左区间
            if(left<=mid-1){
                curNode->left = new TreeNode(0);
                nodeQue.push(curNode->left);
                //区间入队
                leftQue.push(left);
                rightQue.push(mid-1);
            }

            //处理右区间
            if(right>=mid+1){
                curNode->right = new TreeNode(0);
                nodeQue.push(curNode->right);
                leftQue.push(mid+1);
                rightQue.push(right);
            }
        }
        return root;
    }
};