leetcode654.最大二叉树

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

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

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

 

输入：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 的节点。
        - 空数组，无子节点。

目录

递归法：

单调栈：

---

 

递归法：

实现思路：我们需要对原数组不断地进行递归分割，从而来确定左右子树。

代码实现：

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

    }

    public TreeNode creatTree(int[] nums,int left,int right){
        //如果left > right,表示nums数组在以left到right索引之间没有值，无法创建子树
        if(left > right){
            return null;
        }
        //在left和right之间找最大值
           int max = 0;
           //记录最大值索引
           int index = left;
        for (int i = left; i <= right; i++) {
            if (nums[i] > max) {
                max = nums[i];
                index = i;
            }
        }
        //将最大值封装为节点
        TreeNode root = new TreeNode(max);
        //递归创建左子树
        root.left = creatTree(nums,left,index - 1);
        //递归创建右子树
        root.right = creatTree(nums,index + 1,right);

        return root;

    }

    
}

笔者在第一次解答时，由于将 index 初始化为0，导致栈溢出，后初始化  index = left  解决报错。

单调栈：

        上述递归法虽然解决了问题，但是在每次递归遍历数组找最大值时存在多次重复遍历，这样实现若是在数据量很大的情况下，时间复杂度很高（O()）使用单调栈我们就可以只对数组进行一次遍历的情况下完成最大二叉树的构建。

单调栈实现思路：

1。如果栈顶节点值大于待入栈节点值，则直接入栈

2。如果栈顶节点值小于待入栈节点值，则将栈顶节点pop出来，知道栈顶结点值大于待入栈节点值，再将待入栈节点值入栈

最大二叉树的构建就是在每次的出入栈操作中进行构建。

① 当栈顶节点值（topNode）大于待入栈节点值（node）时，将 topNode.right = node，并将node入栈

② 当栈顶结点值小于待入栈节点值时，将 node.left = topNode ,并将栈顶节点pop。（第二种可能不止pop栈顶一次，有可能栈顶下面节点值也小于node.val，这时就需要重复执行第二步，node.left 也会一次次的更新）

图解单调栈

 代码实现：

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        //创建栈
        Stack<TreeNode> stack = new Stack<TreeNode>();
        //遍历数组
        for(int i = 0; i < nums.length; i++){
            //封装当前数组元素
            TreeNode node = new TreeNode(nums[i]);
            //判断栈是否为空
            while(!stack.isEmpty()){
                //取栈顶节点
                TreeNode topNode = stack.peek();
                //判断栈顶结点值是否大于node.val
                if(topNode.val > node.val){
                    //直接入栈
                    stack.push(node);
                    topNode.right = node;
                    //一定要break，否则会栈溢出
                    break;
                    
                }else{
                    //栈顶节点值小于node.val，出栈
                    topNode = stack.pop();
                    node.left = topNode;
                    
                }
            }
            //栈空就将node入栈
            stack.push(node);
            
        }
        //此时栈底的节点就是节点值最大的节点，也就是根节点，返回即可
        while(stack.size() != 1){
            stack.pop();    
        }
        return stack.pop();
    }
}