力扣第108题将有序数组转二叉搜索树 c++

题目

简单

思路和解题方法

将有序数组转换为平衡二叉搜索树（BST）的功能。

traversal 函数是辅助函数，用于构建平衡BST。

如果左指针 left 大于右指针 right，说明已经没有元素可以构建节点了，返回空指针。

计算数组中间元素的索引 mid。

创建根节点，并赋值为数组中间元素的值。

递归构建左子树，范围为 [left, mid-1]。

递归构建右子树，范围为 [mid+1, right]。

返回根节点。

sortedArrayToBST 函数是主函数，用于调用辅助函数将有序数组转换为平衡BST。

调用辅助函数 traversal，传入数组和范围 [0, nums.size() - 1]。

返回根节点。

通过不断递归地构建左右子树，最终得到平衡的BST。

复杂度

时间复杂度:

O(n)

时间复杂度：O(n)，其中 n 是数组的长度。每个数字只访问一次。

空间复杂度

O(log n)

空间复杂度：O(log⁡n)，其中 n 是数组的长度。空间复杂度不考虑返回值，因此空间复杂度主要取决于递归栈的深度，递归栈的深度是 O(log⁡n)。

c++ 代码

cpp 复制代码

class Solution {
public:
    // 辅助函数，用于将有序数组转换为平衡二叉搜索树
    TreeNode* traversal(vector<int>& nums, int left, int right)
    {
        // 左指针大于右指针，说明已经没有元素可以构建节点了，返回空指针
        if(left > right) return NULL;
        
        // 计算数组中间元素的索引
        int mid = left + ((right - left) / 2);
        
        // 创建根节点，并赋值为数组中间元素的值
        TreeNode* root = new TreeNode(nums[mid]);
        
        // 递归构建左子树，范围为[left, mid-1]
        root->left = traversal(nums, left, mid - 1);
        
        // 递归构建右子树，范围为[mid+1, right]
        root->right = traversal(nums, mid + 1, right);
        
        // 返回根节点
        return root;
    }
    
    // 主函数，将有序数组转换为平衡二叉搜索树
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        // 调用辅助函数，传入数组和范围[0, nums.size() - 1]
        TreeNode* root = traversal(nums, 0, nums.size() - 1);
        
        // 返回根节点
        return root;
    }
};

下附迭代法版本代码

cpp 复制代码

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);                    // 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);

            curNode->val = nums[mid];       // 将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;
    }
};

觉得有用的话可以点点赞，支持一下。

如果愿意的话关注一下。会对你有更多的帮助。

每天都会不定时更新哦 >人< 。

力扣第108题 将有序数组转二叉搜索树 c++

题目

思路和解题方法

复杂度

时间复杂度:

空间复杂度

c++ 代码

下附 迭代法版本代码

力扣第108题将有序数组转二叉搜索树 c++

下附迭代法版本代码