代码随想录：二叉树18-21（Java）

目录

105.从前序与中序遍历序列构造二叉树

题目

代码（递归）

106.从中序与后序遍历序列构造二叉树

题目

代码

654.最大二叉树

题目

代码

617.合并二叉树

题目

代码

---

105.从前序与中序遍历序列构造二叉树

题目

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

代码（递归）

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length == 0 || inorder.length == 0){
            return null;
        }
        
        return build(inorder,0,inorder.length-1,preorder,0,preorder.length-1);
    }
    //左闭右闭
    public TreeNode build(int[] in,int in1,int in2,int[] pre,int pre1,int pre2){
        //终止条件
        if(pre1 > pre2 || in1 > in2){
            return null;
        }
        int rootval = pre[pre1]; //根节点是前序的第一个节点
        TreeNode root = new TreeNode(rootval); //创建根节点

        //获取前序的第一个节点在中序的索引
        int index = 0;
        for(int i=in1;i <= in2;i++){
            if(in[i] ==rootval){
                index = i;
            }
        }
        
        //切分中序区间
        int a1 = in1;  //中序左边开始
        int a2 = index - 1; //中序左边结束
        int a3 = index + 1;  //中序右边开始
        int a4 = in2;  //中序右边结束

        //切分前序区间
        int b1 = pre1 + 1;  //前序左边开始
        int b2 = b1 + (a2 - a1); //前序左边结束
        int b3 = b2 + 1; //前序右边开始
        int b4 = pre2;  //前序右边结束

        root.left = build(in,a1,a2,pre,b1,b2);
        root.right = build(in,a3,a4,pre,b3,b4);
        return root;
    }
}

106.从中序与后序遍历序列构造二叉树

题目

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

示例 1:

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]

代码

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        if(inorder.length == 0){
            return null;
        }
        return build(inorder,0,inorder.length-1,postorder,0,postorder.length-1);
    }
    //左闭右闭
    public TreeNode build(int[] in,int in1,int in2,int[] post,int post1,int post2){
        //终止逻辑
        if(post1 > post2 || in1 > in2){
            return null;
        }
        //单层逻辑
        int rootval = post[post2]; //根节点是post后序的最后一个节点
        TreeNode root = new TreeNode(rootval);  //创建根节点

        int index = 0;
        //在中序in中找到rootval的下标
        for(int i=in1;i <= in2;i++){
            if(in[i] == rootval){
                index = i;
                break;
            }
        }

        //a是中序区间
        int a1 = in1; //中序左边的开始
        int a2 = index - 1;  //中序左边的结束
        int a3 = index + 1;  //中序右边的开始
        int a4 = in2; //中序右边的结束

        //b是后序区间
        int b1 = post1;   //后序左边的开始
        int b2 = post1 + (a2 - a1); //后序左边的结束
        int b3 = b2 + 1;  //后序右边的开始
        int b4 = post2 - 1; //后序右边的结束

        //递归左孩子
        root.left = build(in,a1,a2,post,b1,b2);
        //递归右孩子
        root.right = build(in,a3,a4,post,b3,b4);
        return root;
    }
}

654.最大二叉树

题目

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

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

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

示例 1：

输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]

代码

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

    }
    //左闭右闭区间
    public TreeNode build(int[] nums,int start,int end){
        //终止条件1,没有节点
        if(start > end){
            return null;
        }

        //终止条件2，还有一个节点（可以省略）
        if(start == end){
            return new TreeNode(nums[start]);
        }

        //单层逻辑
        //获取nums最大元素的下标
        int max = nums[start];
        int index = start;  //这里index不能写0，要递归用的
        for(int i=start;i <= end;i++){
            if(max < nums[i]){
                max = nums[i];
                index = i;
            }
        }

        TreeNode root = new TreeNode(max); //最大元素作为根节点（中）
        root.left = build(nums,start,index-1); //处理左子树（左边区间）
        root.right = build(nums,index+1,end); //处理右子树（右边区间）

        return root;
    }
}

617.合并二叉树

题目

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

示例 1：

输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出：[3,4,5,5,4,null,7]

代码

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        //终止条件1：都为空
        if(root1 == null && root2 == null){
            return null;
        }
        //终止条件2：root1为空
        if(root1 == null && root2 != null){
            return root2;
        }
        //终止条件3：root2为空
        if(root1 != null && root2 == null){
            return root1;
        }
        //单层逻辑(两个树的节点重合，都不为空)
        TreeNode root = new TreeNode(root1.val + root2.val); //处理重合节点（中）
        root.left = mergeTrees(root1.left,root2.left);  //递归两棵树的左子树（左）
        root.right = mergeTrees(root1.right,root2.right); //递归两棵树的右子树（右）
        return root;
    }
}