leetcode——第108题——将有序数组转换为二叉搜索树

题目：
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

/**
 * 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* sortredBST(vector<int>& nums, int begin, int end)
    // {
    //     // 终止条件
    //     // 不知道这个终止条件是啥，傻瓜 ~ 就是两个边界的来限定嘛
    //     // 既然是数组，应该是可以想到数组的！！！！！！
    //     if(begin>end)
    //     {
    //         return nullptr;
    //     }

    //     // 单层递归逻辑
    //     // 这里写错一个很重要的是 就是在处理区间的时候，这个处理错了 begin + (end-begin) / 2
    //     // 我没有写上  begin + ，感觉用第一次的来举例子很容易陷入这样的误区
    //     // 你想想，如果在第二次，第三次递归的时候，左端点和右端点都变了
    //     // 也就是初始的位置是变了的，啊呀呀，反正得记得加上 begin 才是正确的
    //     int val = nums[begin+(end-begin) / 2];      //  错误1
    //     TreeNode* root = new TreeNode(val);
    //     root->left = sortredBST(nums, begin, begin+(end-begin)/2-1);  // 错误2
    //     root->right = sortredBST(nums, begin+(end-begin)/2+1,end);     // 错误3
    //     return root;
    // }
    // TreeNode* sortedArrayToBST(vector<int>& nums) 
    // {
    //     return sortredBST(nums, 0, nums.size()-1);
    // }

/******************************法二：迭代法****************************************/
    TreeNode* sortedArrayToBST(vector<int>& nums)
    {
        // 迭代法就是用三个队列来模拟，一个队列放遍历的节点，一个队列放左区间下标，衣蛾队列放右区间下标
        // 其实就是模拟不断分割的过程
        if(nums.size() == 0)
        {
            return nullptr;
        }
        TreeNode* root = new TreeNode(0);   // 初始根节点
        queue<TreeNode*> nodeQue;           // 放遍历的节点
        queue<int> leftQue;                 // 保存左区间下标
        queue<int> rightQue;                // 保存右区间下标
        nodeQue.push(root);                 // 根节点入队列
        leftQue.push(0);                    // 0为左区间下标的初始位置
        rightQue.push(nums.size() - 1);     // 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 - left) / 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;
    }
};