LeetCode 654.最大二叉树

LeetCode 654.最大二叉树

1、题目

题目链接：654. 最大二叉树

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

1. 创建一个根节点，其值为 nums 中的最大值。
2. 递归地在最大值 左边 的 子数组前缀上 构建左子树。
3. 递归地在最大值 右边 的 子数组后缀上 构建右子树。

返回 nums 构建的 最大二叉树 。

示例 1：

输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
解释：递归调用如下所示：
- [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。
    - [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
        - 空数组，无子节点。
        - [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。
            - 空数组，无子节点。
            - 只有一个元素，所以子节点是一个值为 1 的节点。
    - [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。
        - 只有一个元素，所以子节点是一个值为 0 的节点。
        - 空数组，无子节点。

示例 2：

输入：nums = [3,2,1]
输出：[3,null,2,null,1]

提示：

• 1 <= nums.length <= 1000
• 0 <= nums[i] <= 1000
• nums 中的所有整数 互不相同

2、递归（前序）

思路

构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树。

1. 确定递归函数的参数和返回值

参数传入的是存放元素的数组，返回该数组构造的二叉树的头结点，返回类型是指向节点的指针。
代码如下：

TreeNode* constructMaximumBinaryTree(vector<int>& nums)

2. 确定终止条件

题目中说了输入的数组大小一定是大于等于1的，所以我们不用考虑小于1的情况，那么当递归遍历的时候，如果传入的数组大小为1，说明遍历到了叶子节点了。
那么应该定义一个新的节点，并把这个数组的数值赋给新的节点，然后返回这个节点。 这表示一个数组大小是1的时候，构造了一个新的节点，并返回。
代码如下：

TreeNode* node = new TreeNode(0);
if (nums.size() == 1) {
    node->val = nums[0];
    return node;
}

3. 确定单层递归的逻辑

这里有三步工作

1. 先要找到数组中最大的值和对应的下标， 最大的值构造根节点，下标用来下一步分割数组。

代码如下：

int maxValue = 0;
int maxIndex = 0;
for (int i = 0; i < nums.size(); i++) {
    if (nums[i] > maxValue) {
        maxValue = nums[i];
        maxIndex = i;
    }
}
TreeNode* node = new TreeNode(0);
node->val = maxValue;

2. 最大值所在的下标左区间 构造左子树

这里要判断 maxIndex > 0，因为要保证左区间至少有一个数值。
代码如下：

if (maxIndex > 0) {
    vector<int> newVec(nums.begin(), nums.begin() + maxIndex);
    node->left = constructMaximumBinaryTree(newVec);
}

3. 最大值所在的下标右区间 构造右子树

判断maxIndex < (nums.size() - 1)，确保右区间至少有一个数值。
代码如下：

if (maxValueIndex < (nums.size() - 1)) {
    vector<int> newVec(nums.begin() + maxValueIndex + 1, nums.end());
    node->right = constructMaximumBinaryTree(newVec);
}

代码

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        // 创建一个值为0的节点作为根节点
        TreeNode* node = new TreeNode(0);
        // 如果数组只有一个元素
        if (nums.size() == 1) {
            // 将根节点的值设置为数组的唯一元素
            node->val = nums[0];
            // 返回根节点
            return node;
        }

        // 初始化最大值和最大值的索引
        int maxValue = 0;
        int maxIndex = 0;
        // 遍历数组找到最大值和最大值的索引
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > maxValue) {
                maxValue = nums[i];
                maxIndex = i;
            }
        }

        // 将根节点的值设置为最大值
        node->val = nums[maxIndex];

        // 如果最大值索引大于0，说明左子树非空
        if (maxIndex > 0) {
            // 截取数组中的左子树部分
            vector<int> newVec(nums.begin(), nums.begin() + maxIndex);
            // 递归构建左子树
            node->left = constructMaximumBinaryTree(newVec);
        }

        // 如果最大值索引小于数组长度减1，说明右子树非空
        if (maxIndex < nums.size() - 1) {
            // 截取数组中的右子树部分
            vector<int> newVec(nums.begin() + maxIndex + 1, nums.end());
            // 递归构建右子树
            node->right = constructMaximumBinaryTree(newVec);
        }
        // 返回根节点
        return node;
    }
};

复杂度分析

• 时间复杂度: O(n^2)
• 空间复杂度: O(n)

3、递归（使用索引）

思路

代码

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return construct(nums, 0, nums.size());
    }

    TreeNode* construct(vector<int>& nums, int left, int right) {
        // 如果左边界大于等于右边界，返回空指针
        if (left >= right) {
            return nullptr;
        }
        // 找到数组中最大元素的索引作为分割点
        int maxIndex = left;
        for (int i = left; i < right; i++) {
            if (nums[i] > nums[maxIndex]) {
                maxIndex = i;
            }
        }
        // 创建当前最大元素为根节点的树节点
        TreeNode* node = new TreeNode(nums[maxIndex]);
        // 递归构造左子树
        node->left = construct(nums, left, maxIndex);
        // 递归构造右子树
        node->right = construct(nums, maxIndex + 1, right);
        // 返回根节点
        return node;
    }
};

复杂度分析

• 时间复杂度: O(n^2)
• 空间复杂度: O(n)

4、单调栈

思路

代码

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        int n = nums.size();
        vector<int> stk;
        vector<int> left(n, -1), right(n, -1);
        vector<TreeNode*> tree(n);
        for (int i = 0; i < n; ++i) {
            tree[i] = new TreeNode(nums[i]);
            // 如果栈不为空且当前数字大于栈顶元素，则将当前数字作为栈顶元素的右子树
            while (!stk.empty() && nums[i] > nums[stk.back()]) {
                right[stk.back()] = i;
                stk.pop_back();
            }
            // 如果栈不为空，则将当前数字作为栈顶元素的左子树
            if (!stk.empty()) {
                left[i] = stk.back();
            }
            stk.push_back(i);
        }

        TreeNode* root = nullptr;
        for (int i = 0; i < n; ++i) {
            // 如果当前节点的左右子树都为空，则该节点为根节点
            if (left[i] == -1 && right[i] == -1) {
                root = tree[i];
            }
            // 如果当前节点的右子树为空或者左子树的值小于右子树的值，则将当前节点作为左子树的右子树
            else if (right[i] == -1 || (left[i] != -1 && nums[left[i]] < nums[right[i]])) {
                tree[left[i]]->right = tree[i];
            }
            // 否则，将当前节点作为右子树的左子树
            else {
                tree[right[i]]->left = tree[i];
            }
        }
        return root;
    }
};

复杂度分析

• 时间复杂度: O(n)
• 空间复杂度: O(n)

5、单调栈（优化）

思路

我们还可以把最后构造树的过程放进单调栈求解的步骤中，省去用来存储左右边界的数组。

代码

lass Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        int n = nums.size();
        vector<int> stk;
        vector<TreeNode*> tree(n);

        // 遍历数组中的每个元素
        for (int i = 0; i < n; ++i) {
            // 创建一个新的树节点
            tree[i] = new TreeNode(nums[i]);

            // 当栈不为空且当前元素大于栈顶元素时
            while (!stk.empty() && nums[i] > nums[stk.back()]) {
                // 将当前节点的左子节点指向栈顶元素对应的树节点
                tree[i]->left = tree[stk.back()];
                // 弹出栈顶元素
                stk.pop_back();
            }

            // 如果栈不为空，则将栈顶元素对应的树节点的右子节点指向当前节点
            if (!stk.empty()) {
                tree[stk.back()]->right = tree[i];
            }

            // 将当前元素的索引压入栈中
            stk.push_back(i);
        }

        // 返回栈底元素对应的树节点作为整棵树的根节点
        return tree[stk[0]];
    }
};

复杂度分析

• 时间复杂度: O(n)
• 空间复杂度: O(n)