LeetCode 654.最大二叉树

1、题目

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

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

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

返回 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、递归（前序）

思路

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

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

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

TreeNode* constructMaximumBinaryTree(vector<int>& nums)

确定终止条件

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

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;}
}
TreeNode* node = new TreeNode(0);
node->val = maxValue;

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

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

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

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

判断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]];}
};