二叉树题目：最大二叉树

题目

标题和出处

标题：最大二叉树

出处：654. 最大二叉树

难度

5 级

题目描述

要求

给定一个没有重复元素的整数数组 $\text{nums}$。最大二叉树可以用下面的算法从 $\text{nums}$ 递归地构建:

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

返回从 $\text{nums}$ 构建的最大二叉树。

示例

示例 1：

输入：$\text{nums = [3,2,1,6,0,5]}$
输出：$\text{[6,3,5,null,2,0,null,null,1]}$
解释：递归调用如下所示：

• $\text{[3,2,1,6,0,5]}$ 中的最大值是 $\text{6}$，左边部分是 $\text{[3,2,1]}$，右边部分是 $\text{[0,5]}$。
  • $\text{[3,2,1]}$ 中的最大值是 $\text{3}$，左边部分是 $\text{[]}$，右边部分是 $\text{[2,1]}$。
    • 空数组，无子结点。
    • $\text{[2,1]}$ 中的最大值是 $\text{2}$，左边部分是 $\text{[]}$，右边部分是 $\text{[1]}$。
      • 空数组，无子结点。
      • 只有一个元素，所以子结点是一个值为 $\text{1}$ 的结点。
  • $\text{[0,5]}$ 中的最大值是 $\text{5}$，左边部分是 $\text{[0]}$，右边部分是 $\text{[]}$。
    • 只有一个元素，所以子结点是一个值为 $\text{0}$ 的结点。
    • 空数组，无子结点。

示例 2：

输入：$\text{nums = [3,2,1]}$
输出：$\text{[3,null,2,null,1]}$

数据范围

• $\text{1}\le \text{nums.length}\le \text{1000}$
• $\text{0}\le \text{nums[i]}\le \text{1000}$
• $\text{nums}$ 中的所有整数各不相同

解法一

思路和算法

由于给定的数组中的整数各不相同，因此可以唯一地确定最大二叉树的根结点，以及每个子树中的根结点。

遍历数组得到最大值所在的下标，使用该下标处的值创建根结点，使用该下标左边的子数组创建左子树，使用该下标右边的子数组创建右子树。对于左边的子数组和右边的子数组，使用同样的方法构造最大子二叉树。

上述构造最大二叉树的过程是一个递归分治的过程。将二叉树分成根结点、左子树和右子树三部分，首先构造左子树和右子树，然后构造原始二叉树，构造左子树和右子树是原始问题的子问题。

分治的终止条件是子数组为空，此时构造的子树为空。当子数组不为空时，子数组中一定存在整数，因此存在最大值，得到最大值所在的下标之后，即可得到左子树和右子树对应的子数组，然后递归地构造左子树和右子树。

实现方面，为了降低时间复杂度和空间复杂度，每个子数组使用开始下标和结束下标确定，当开始下标大于结束下标时表示子数组为空，则不用新建数组和复制数组元素。

代码

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return constructMaximumBinaryTree(nums, 0, nums.length - 1);
    }

    public TreeNode constructMaximumBinaryTree(int[] nums, int start, int end) {
        if (start > end) {
            return null;
        }
        int maximumValueIndex = getMaximumValueIndex(nums, start, end);
        TreeNode root = new TreeNode(nums[maximumValueIndex]);
        root.left = constructMaximumBinaryTree(nums, start, maximumValueIndex - 1);
        root.right = constructMaximumBinaryTree(nums, maximumValueIndex + 1, end);
        return root;
    }

    public int getMaximumValueIndex(int[] nums, int start, int end) {
        int maximumValueIndex = start;
        for (int i = start + 1; i <= end; i++) {
            if (nums[i] > nums[maximumValueIndex]) {
                maximumValueIndex = i;
            }
        }
        return maximumValueIndex;
    }
}

复杂度分析

• 时间复杂度：$O(n^2)$，其中 $n$ 是数组 $\text{nums}$ 的长度，即二叉树的结点数。二叉树有 $n$ 个结点，需要分别构造 $n$ 个子树，对于每个子树最多需要 $O(n)$ 的时间定位到根结点和 $O(1)$ 的时间构造，因此总时间复杂度是 $O(n^2)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度，即二叉树的结点数。空间复杂度主要是递归调用的栈空间，取决于二叉树的高度，最坏情况下二叉树的高度是 $O(n)$。

解法二

思路和算法

注意到从给定的数组 $\text{nums}$ 构造的最大二叉树中，结点值的左右相对位置和数组 $\text{nums}$ 中的左右相对位置保持一致。对于数组 $\text{nums}$ 中的任意两个元素 $x$ 和 $y$，其中 $x$ 在 $y$ 的左侧，当 $x>y$ 时 $y$ 在 $x$ 的右子树中，当 $x<y$ 时 $x$ 在 $y$ 的左子树中。

对于数组 $\text{nums}$ 中的每个整数，为了得到该结点的父结点，需要在数组 $\text{nums}$ 中找到比该整数大的最小整数。可以使用单调栈，单调栈存储结点，满足从栈底到栈顶的结点值单调递减。

从左到右遍历数组 $\text{nums}$，对于每个整数，执行如下操作。

1. 如果栈不为空且栈顶结点值小于当前整数，则将栈顶结点出栈，由于结点出栈的顺序对应数组中从右到左的顺序，因此如果有多个结点出栈，则每次将出栈结点的右子结点设为上一个出栈的结点。重复该操作，直到栈为空或者栈顶结点值大于当前整数时，停止该操作。

2. 用当前整数创建结点，将当前结点的左子结点设为最后一个出栈的结点，然后将当前结点入栈。

遍历结束后，每个结点的左子树构造完毕，除了栈内的结点以外的每个结点的右子树也构造完毕。栈内的每个结点的右侧都不存在更大的整数，因此除了根结点以外，每个结点都是其父结点的右子结点。栈底结点为值最大的结点，因此作为根结点。当栈内结点数大于 $1$ 时，每次将一个结点出栈，然后将新的栈顶结点的右子结点设为出栈结点。当栈内只剩 $1$ 个结点时，该结点即为最大二叉树的根结点，将该结点出栈并返回。

上述做法的正确性可以根据单调栈的性质和操作过程得到。对于整数 $x$，考虑如下情况。

• 如果 $x$ 是数组中的最大整数，则结点 $x$ 即为根结点。

• 如果只有 $x$ 的一侧存在比 $x$ 大的整数，则比 $x$ 大的最小整数对应的结点即为结点 $x$ 的父结点。

• 如果 $x$ 的两侧都存在比 $x$ 大的整数，用 $y$ 表示 $x$ 的左侧的整数中比 $x$ 大的最小整数，用 $z$ 表示 $x$ 的右侧的整数中比 $x$ 大的最小整数，则 $x$ 的父结点值为 $y$ 和 $z$ 中的最小整数，考虑 $y$ 和 $z$ 的大小关系。

  • 如果 $y<z$，则当遍历到 $z$ 时，结点 $x$ 和 $y$ 依次出栈，将结点 $y$ 的右子结点设为结点 $x$，结点 $z$ 的左子结点设为结点 $y$，此时结点 $x$ 的父结点为结点 $y$。

  • 如果 $y>z$，则当遍历到 $z$ 时，结点 $x$ 出栈，将结点 $z$ 的左子结点设为结点 $x$，此时结点 $x$ 的父结点为结点 $z$。

以下是示例 1 的构造过程，其中 $\text{nums}=[3,2,1,6,0,5]$。

1. 下标 $0$ 处的整数是 $3$，创建结点 $3$ 并入栈，$\text{stack}=[3]$，其中左边为栈底，右边为栈顶，栈内元素为结点，此处用数字表示结点且省略父结点和子结点的关系。

2. 下标 $1$ 处的整数是 $2$，创建结点 $2$ 并入栈，$\text{stack}=[3,2]$。

3. 下标 $2$ 处的整数是 $1$，创建结点 $1$ 并入栈，$\text{stack}=[3,2,1]$。

4. 下标 $3$ 处的整数是 $6$，由于栈内的结点 $1$、$2$、$3$ 的结点值都小于 $6$，因此需要将结点出栈并更新每个结点的子结点。

   1. 依次将结点 $1$、$2$、$3$ 出栈并更新每个结点的右子结点，将结点 $2$ 的右子结点设为结点 $1$，将结点 $3$ 的右子结点设为结点 $2$。

   2. 创建结点 $6$，将结点 $6$ 的左子结点设为结点 $3$，将结点 $6$ 入栈，$\text{stack}=[6]$。

5. 下标 $4$ 处的整数是 $0$，创建结点 $0$ 并入栈，$\text{stack}=[6,0]$。

6. 下标 $5$ 处的整数是 $5$，由于栈内的结点 $0$ 的结点值小于 $5$，因此需要将结点出栈并更新每个结点的子结点。

   1. 将结点 $0$ 出栈。

   2. 创建结点 $5$，将结点 $5$ 的左子结点设为结点 $0$，将结点 $5$ 入栈，$\text{stack}=[6,5]$。

7. 遍历结束，此时栈内有 $2$ 个结点。将结点 $5$ 出栈，将结点 $6$ 的右子结点设为结点 $5$。

8. 栈内剩余的结点 $6$ 即为最大二叉树的根结点，将结点 $6$ 出栈并返回。

代码

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        int length = nums.length;
        for (int i = 0; i < length; i++) {
            int num = nums[i];
            TreeNode prev = null;
            while (!stack.isEmpty() && stack.peek().val < num) {
                TreeNode curr = stack.pop();
                curr.right = prev;
                prev = curr;
            }
            TreeNode node = new TreeNode(num);
            node.left = prev;
            stack.push(node);
        }
        while (stack.size() > 1) {
            TreeNode curr = stack.pop();
            stack.peek().right = curr;
        }
        return stack.pop();
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度，即二叉树的结点数。需要遍历数组 $\text{nums}$，每个结点最多入栈和出栈各一次，更新每个结点的子结点的时间是 $O(1)$，因此总时间复杂度是 $O(n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度，即二叉树的结点数。空间复杂度主要是栈空间，栈内元素个数不超过 $n$。