【二叉树】最大二叉树

题目描述

给定一个不重复的整数数组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 的节点。
        - 空数组，无子节点。

解题思路 

这个就是找到数组指定范围内最大的元素，然后按照题目要要求将最大元素的左边放到左子树中，将最大元素的右边放到右子树中。

这里使用 [3,2,1,6,0,5] 来做分析：

• 找到 [3,2,1,6,0,5]中最大元素：6；左子树元素 [3,2,1] ; 右子树元素 [0,5] ;
• 构造左子树： [3,2,1]；
• 构造右子树： [3,2,1]；
• 最后返回最大元素6，作为根节点。

按照上述思路代码实现如下：

import org.example.TreeNode;

class Solution3 {

    public TreeNode constructMaximumBinaryTree(int[] nums) {
        int maxIndex = findMax(nums, 0, nums.length - 1);

        TreeNode root = new TreeNode(nums[maxIndex]);
        if (0 <= maxIndex - 1) {
            constructLeft(root, 0, maxIndex - 1, nums);
        }
        if (maxIndex + 1 <= nums.length - 1) {
            constructRight(root, maxIndex + 1, nums.length - 1, nums);
        }

        return root;
    }

    /**
     * 构造左子树
     *
     * @param root
     * @param start
     * @param end
     * @param nums
     */
    private void constructLeft(TreeNode root, int start, int end, int[] nums) {

        if (start == end) {
            TreeNode node = new TreeNode(nums[start]);
            root.left = node;
            return;
        }

        int maxIndex = findMax(nums, start, end);

        TreeNode node = new TreeNode(nums[maxIndex]);
        root.left = node;
        if (start <= maxIndex - 1) {
            constructLeft(node, start, maxIndex - 1, nums);
        }
        if (maxIndex + 1 <= end) {
            constructRight(node, maxIndex + 1, end, nums);
        }
    }

    /**
     * 构造右子树
     *
     * @param root
     * @param start
     * @param end
     * @param nums
     */
    private void constructRight(TreeNode root, int start, int end, int[] nums) {

        if (start == end) {
            TreeNode node = new TreeNode(nums[start]);
            root.right = node;
            return;
        }

        int maxIndex = findMax(nums, start, end);

        TreeNode node = new TreeNode(nums[maxIndex]);

        root.right = node;
        if (start <= maxIndex - 1) {
            constructLeft(node, start, maxIndex - 1, nums);
        }
        if (maxIndex + 1 <= end) {
            constructRight(node, maxIndex + 1, end, nums);
        }
    }

    /**
     * 找到最大的元素的下标
     *
     * @param nums
     * @param start
     * @param end
     * @return
     */
    private int findMax(int[] nums, int start, int end) {
        int max = nums[start];
        int maxIndex = start;
        for (int i = start + 1; i <= end; i++) {
            if (max < nums[i]) {
                max = nums[i];
                maxIndex = i;
            }
        }
        return maxIndex;
    }

    public static void main(String[] args) {
        Solution3 solution = new Solution3();
        solution.constructMaximumBinaryTree(new int[]{3, 2, 1, 6, 0, 5});
    }

新解题思路

这里考虑直接拿到一个元素进行遍历，准备TreeNode[] array记录每次生成的二叉树，准备List<Integer> indexStack 记录下标位置。

• 取出一个元素，num=nums[i]，array[i] = new TreeNode(nums[i]);
• 判断条件1，如果nums[indexStack.get(indexStack.size()-1)] > nums[i]，则array[i].left=array[indexStack.get(indexStack.size()-1)]; 并且执行indexStack.remove(indexStack.size()-1);
• 判断条件2，如果nums[indexStack.get(indexStack.size()-1)] < nums[i]，则array[indexStack.get(indexStack.size()-1)].right=array[i];
• 最后执行indexStack.add(i)
• 遍历结束后，返回array[indexStack.get(0)]

代码实现如下：

import org.example.TreeNode;

import java.util.ArrayList;
import java.util.List;

class Solution4 {

    public TreeNode constructMaximumBinaryTree(int[] nums) {

        List<Integer> indexStack = new ArrayList<>(nums.length);
        TreeNode[] array = new TreeNode[nums.length];

        for (int i = 0; i < nums.length; i++) {

            array[i] = new TreeNode(nums[i]);

            // 添加左子树
            while (!indexStack.isEmpty() && nums[i] > nums[indexStack.get(indexStack.size() - 1)]) {
                array[i].left = array[indexStack.get(indexStack.size() - 1)];
                indexStack.remove(indexStack.get(indexStack.size() - 1));
            }

            // 添加右子树
            if (!indexStack.isEmpty() && nums[i] < nums[indexStack.get(indexStack.size() - 1)]) {
                array[indexStack.get(indexStack.size() - 1)].right = array[i];
            }

            indexStack.add(i);
        }

        return array[indexStack.get(0)];
    }


    public static void main(String[] args) {
        Solution4 solution = new Solution4();
        solution.constructMaximumBinaryTree(new int[]{3, 2, 1, 6, 0, 5});
    }
}

 

总结

这道题第一种实现方案耗时更低，但是大家分析时间复杂度是第一种方案时间复杂度更高；欢迎有更简洁高效的解法回复。