将有序数组转化为二叉树

本文参考代码随想录

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

思路：寻找分割点，分割点作为当前节点，然后递归左区间和右区间。

递归法

取中间值为root，递归左区间成为root的左孩子，右区间成为root的右孩子，最后返回root

class Solution {
private:
    TreeNode* traversal(vector<int>& nums,int left, int right){
        //若数组为空则返回
        if(left > right) return nullptr;
        int mid = left + (right - left) / 2;//防止遇到INT_MAX长度溢出
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = traversal(nums, left, mid - 1);
        root->right = traversal(nums, mid + 1, right);
        return root;
    }
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        TreeNode* root = traversal(nums, 0, nums.size() - 1);
        return root;
    }
};

迭代法

通过三个队列来模拟，一个队列放遍历的节点，一个队列放左区间下标，一个队列放右区间下标

class Solution {
public:
    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);
        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 - left) / 2;

            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;
    }
};