106. 从中序与后序遍历序列构造二叉树、105. 从前序与中序遍历序列构造二叉树、654. 最大二叉树

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

根据一棵树的中序遍历与后序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

题解

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
  //后序为切割点，在中序寻找切割点，先切割中序，再按照中序切割的大小，去切割后序（区间都是左闭右开）
class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        return build(inorder,0,inorder.length,postorder,0,postorder.length);
    }

    //区间是左闭右开
    public TreeNode build(int[] inorder,int inBegin,int inEnd, 
                          int[] postorder,int poBegin,int poEnd){

        //没有元素了                
        if(inEnd-inBegin < 1){
            return null;
        }   
        //只剩一个元素                
        if(inEnd-inBegin==1){
            return new TreeNode(inorder[inBegin]);
        }   
        //后序数组最后一个元素为切割点
        int rootValue=postorder[poEnd-1];
        TreeNode root=new TreeNode(rootValue);
        int index=-1;
        //在中序数组中找切割点
        for(int i=0;i<inorder.length;i++){
            if(inorder[i]==rootValue){
                index=i;
                break;
            }
        }
        //区间是左闭右开
        //切割中序数组、后序数组得到中序左数组、后序左数组
        //（后序数组的切割是按照中序切割后数组的大小切分的，且后序切割的右数组的最后一位应该舍弃）
        root.left=build(inorder,inBegin,index,
                        postorder,poBegin,poBegin+(index-inBegin));
        //切割中序数组、后序数组得到中序右数组、后序右数组
        root.right=build(inorder,index+1,inEnd,
                        postorder,poBegin+(index-inBegin),poEnd-1);

        return root;

    }
}

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

给定一棵树的前序遍历 preorder 与中序遍历 inorder。请构造二叉树并返回其根节点。

题解

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
 //前序为切割点，在中序寻找切割点，先切割中序，再按照中序切割的大小，去切割前序（区间都是左闭右开）
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return build(inorder,0,inorder.length,preorder,0,preorder.length);
    }

    public TreeNode build(int[] inorder,int inBegin,int inEnd,
                          int[] preorder,int preBegin,int preEnd){
        //没有元素了
        if(inEnd-inBegin<1){
            return null;
        }               
        //只有一个元素
        if(inEnd-inBegin==1){
            return new TreeNode(inorder[inBegin]);
        } 

        //在前序数组中得到切割点
        int rootValue=preorder[preBegin];
        TreeNode root=new TreeNode(rootValue);
        //在中序数组中寻找切割点
        int index=0;
        for(int i=0;i<inorder.length;i++){
            if(inorder[i]==rootValue){
                index=i;
                break;
            }
        }      

        //切割中序数组、前序数组得到中序左数组、前序左数组
        root.left=build(inorder,inBegin,index,
                        preorder,preBegin+1,preBegin+1+(index-inBegin));
        //切割中序数组、前序数组得到中序右数组、前序右数组                
        root.right=build(inorder,index+1,inEnd,
                        preorder,preBegin+1+(index-inBegin),preEnd);

        return root;
    }
}

总结：

上面两道题会一题，另外一题就可以很轻松地写出来。
同样的逻辑：

1、先在A数组中找到切割数值，即根节点，建立根节点。
2、之后再在B数组中找到根节点数值所在的索引。
3、以该索引前后切割B数组，得到B数组的左数组，也就是根节点的左孩子，同时A数组参照B左数组的长度进行切割得到A左数组。
4、切割得到B数组的右数组，根节点的右孩子，同时A数组参照B右数组的长度进行切割得到A右数组。

切割A数组的时候要注意在下一次递归时将切割数值舍去。

下面这道也是一样的思路，比上面的还简单点。

654. 最大二叉树

给定一个不含重复元素的整数数组 nums 。一个以此数组直接递归构建的 最大二叉树 定义如下：

二叉树的根是数组 nums 中的最大元素。
左子树是通过数组中 最大值左边部分 递归构造出的最大二叉树。
右子树是通过数组中 最大值右边部分 递归构造出的最大二叉树。

返回有给定数组 nums 构建的 最大二叉树 。

题解

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
      return  build(nums,0,nums.length);
    }

    public TreeNode build(int[] nums,int begin,int end){
        //没有元素了
        if(end-begin<1){
            return null;
        }
        //只剩一个元素了
        if(end-begin==1){
            return new TreeNode(nums[begin]);
        }

        //找切割点(每次都假设开始位置是最大值，再从它的下一位开始比较找最大值)，
        int max=nums[begin];
        int maxIndex=begin;
        for(int i=begin+1;i<end;i++){
            if(nums[i]>max){
                max=nums[i];
                maxIndex=i;
            }
        }
        TreeNode root=new TreeNode(max);

        //递归切割成左数组
        root.left=build(nums,begin,maxIndex);
        //递归切割右数组
        root.right=build(nums,maxIndex+1,end);

        return root;

    }
}