题目链接: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
中的所有整数 互不相同
文章讲解:代码随想录
视频讲解:又是构造二叉树,又有很多坑!| LeetCode:654.最大二叉树_哔哩哔哩_bilibili
题解1:递归法
思路:按照题目描述,进行前序遍历,取数组中最大的元素为根节点,然后将数组切割为左右两部分递归的构建左子树和右子树。
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
// 获取数组中最大元素的下标
function getMaxNumIndex(nums) {
let index = 0, max = nums[0];
for (let i = 1; i < nums.length; i++) {
if (nums[i] > max) {
index = i;
max = nums[i];
}
}
return index;
}
/**
* @param {number[]} nums
* @return {TreeNode}
*/
var constructMaximumBinaryTree = function(nums) {
if (nums.length === 0) {
return null;
}
const index = getMaxNumIndex(nums);
return new TreeNode(nums[index], constructMaximumBinaryTree(nums.slice(0, index)), constructMaximumBinaryTree(nums.slice(index + 1)));
};
分析:时间复杂度为 O(nlogn),空间复杂度为 O(nlogn)。
题解2:递归法优化
思路:上面的代码中,每次构建节点都创建一个新的数组,增加了时间和空间的消耗。可以直接定义左右指针,直接在原数组上进行操作,提高效率,降低空间消耗。
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {number[]} nums
* @return {TreeNode}
*/
var constructMaximumBinaryTree = function(nums) {
// 获取数组区间中最大元素的下标
const getMaxNumIndex = function getMaxNumIndex(left, right) {
let index = left, max = nums[left];
// 注意区间是左闭右开
for (let i = left + 1; i < right; i++) {
if (nums[i] > max) {
index = i;
max = nums[i];
}
}
return index;
};
// 根据数组区间构建最大二叉树
const build = function (left, right) {
if (left === right) {
return null;
}
const index = getMaxNumIndex(left, right);
return new TreeNode(nums[index], build(left, index), build(index + 1, right));
};
return build(0, nums.length);
};
分析:时间复杂度为 O(nlogn),空间复杂度为 O(logn)。
题解3:单调栈
思路:在数组中任选一个节点,以这个作为右孩子的节点必定是它的左边第1个比它大的节点(下面的左区间是从此节点的下一个节点到这个节点的区间),这个节点的左孩子必定是它的左区间中最大的元素。
因此可以以数组顺序构建节点,在构建的过程中以上面的规则做左孩子连接和右孩子连接,当最后一个节点构建并连接完成时,最大二叉树构建完成。可以构建单调栈来使用上面的规则,保持单调栈中元素从栈底到栈顶单调递减,单调栈中存储的是节点的下标。
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {number[]} nums
* @return {TreeNode}
*/
var constructMaximumBinaryTree = function(nums) {
const nodes = new Array(nums.length); // 节点数组
const stack = []; // 单调栈,栈底元素为当前已经创建好的最大节点的下标,栈顶元素为上次构建的节点
for (let i = 0; i < nums.length; i++) {
nodes[i] = new TreeNode(nums[i]); // 创建节点
// 当前元素比栈顶元素大时,重复构建左孩子连接
while (stack.length > 0 && nums[i] > nodes[stack[stack.length - 1]].val) {
nodes[i].left = nodes[stack.pop()]; // 将栈顶元素对应的节点设置为当前节点的左孩子,并弹出栈顶元素
}
// 因为 nums 中的元素各不相同,经过上面的步骤若此时栈中还有元素,又因为是单调栈,当前元素会比栈中的所有元素都小,构建右孩子连接
if (stack.length > 0) {
nodes[stack[stack.length - 1]].right = nodes[i]; // 将栈顶元素对应的节点的右孩子设置为当前节点
}
stack.push(i); // 将节点下标存入栈中
}
return nodes[stack[0]]; // 栈底元素即为构建的最大二叉树的根节点
};
分析:时间复杂度为 O(n),空间复杂度为 O(n)。
收获
构造二叉树时都是前序遍历,先构建根节点,然后构建左右子树,在构造过程中需要主题统一区间划分,要么都是左闭右闭,要么都是左闭右开。