剑指offer-4.重建二叉树、LeetCode105.从前序与中序遍历序列构造二叉树、LeetCode106.从中序与后序遍历构造二叉树(Java)

力扣题解：https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/solution/

剑指offer-4.重建二叉树、LeetCode105.从前序与中序遍历序列构造二叉树

题目描述

剑指： 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。、

力扣： 根据一棵树的前序遍历与中序遍历构造二叉树。
注意:
你可以假设树中没有重复的元素。
例如，给出

解题思路

1.先序遍历第一个为根节点
2.中序遍历中，找到根节点，左侧为左子树，右侧为右子树
3.左子树中，先序第一个节点为左子树根节点。

举例：
pre数组{1,2,4,7,3,5,6,8}
in数组{4,7,2,1,5,3,8,6}
1.根据先序，根节点为1号，中序以根节点分开，左侧为左子树，右侧为右子树。

2.左子树中，先序，第一个为2，即左子树根节点为2，4和7是其左子树
右子树中，先序，第一个为3，即右子树根节点为3，5为左孩子，8和6为其右子树

3.4和7中，先序，第一个为4，中序，7为4右孩子
8和6中，先序，第一个为6，中序，8为6左孩子

也就是说

• 先序遍历，第一个数为根节点
• 在中序遍历中，找到根节点位置mid
• 左子树节点个数left为，mid-中序遍历左边界；右子树个数right为，中序遍历右边界-mid
• 先序遍历中，左子树为 [先序遍历左边界+1，先序遍历左边界+left]；右子树为 [先序遍历右边界-right+1，先序遍历右边界]
• 中序遍历中，左子树为 [中序遍历左边界，中序遍历左边界+left-1]；右子树为 [中序遍历右边界-right+1，中序遍历右边界]
• 当边界取值不合法时，返回null；

递归

**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {        
        int pr = pre.length - 1;
        int ir = in.length -1;
        
        return tral(pre,in,0,pr,0,ir); //注意return
        
    }
    
    public TreeNode tral(int[] pre,int[] in,int prel,int prer,int inl,int inr){ 
        if(prel>prer || inl>inr)
        {
            return null;
        }
        
        int val = pre[prel];
        TreeNode root = new TreeNode(val); //注意！！
        int mid =0;
        
        //找到在中序遍历中根节点的位置
        for(int i = inl; i<in.length; i++){
            if(in[i] == val){
                mid = i;
                break;
            }
        }
        
        //中序遍历中，左右子树节点个数
        int left = mid - inl;
        int right = inr - mid;
        
        //前序遍历中，左子树prel+1,prel+left, 右子树prer-right+1,prer
        //中序遍历中，左子树inl,inl+left-1, 右子树inr-right+1,inr
        
        root.left = tral(pre,in,prel+1,prel+left,inl,inl+left-1);
        root.right = tral(pre,in,prer-right+1,prer,inr-right+1,inr);
        
        return root;
        
    }
}

改进一 利用copyOfRange()

Arrays.copyOfRange(T[ ] original,int from,int to)

将一个原始的数组original，从下标from开始复制，复制到上标to，生成一个新的数组。

注意：左闭右开，包括下标from，不包括上标to。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.Arrays;
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        //左子树或右子树是否为空
        if(pre.length ==0 || in.length == 0)
            return null;
        
        //根节点为先序第一个点
        TreeNode root = new TreeNode(pre[0]); 
        
        int mid = 0; //mid为根节点在中序序列的位置
        
        //找到根节点在中序序列中的位置
        for(int i=0;i<in.length;i++)
        {
            if(in[i] == pre[0]){
                mid = i;
           
             break;
            }           
        }
         //左子树根节点
            //先序，左子树为[1，mid+1）
        //中序 左子树为[0，mid）
        
        root.left = reConstructBinaryTree(Arrays.copyOfRange(pre,1,mid+1),
                                          Arrays.copyOfRange(in,0,mid));
             //右子树根节点
        //先序，右子树为[mid+1,pre.length)
        //中序，右子树为[mid+1,in.length)
        root.right = reConstructBinaryTree(Arrays.copyOfRange(pre,mid+1,pre.length),
                                          Arrays.copyOfRange(in,mid+1,in.length));
        
       
        return root;    
        
    }
}

时间复杂度：O(n)
空间复杂度：O(n)

改进2：利用HashMap映射

建立中序数组值到数组下标的映射
在中序序列中找到根节点时，直接利用已经构造好的哈希函数去找到数组下标

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
//前序遍历第一个点为二叉树的根节点
//中序遍历中，该点的左右两边分为左子树和右子树
import java.util.*;
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length==0||inorder.length==0)
            return null;
        
        //序列长度length
        int length = preorder.length;
        
        //建立数组值与下标的映射，目的是在中序数组中找到根节点
        Map<Integer,Integer> map = new HashMap<>();
        for(int i=0; i<length; i++){
            map.put(inorder[i],i);
        }

        return travel(preorder,0,length-1,inorder,0,length-1,map);

    }

    public TreeNode travel(int[] pre, int prefrom, int preto, int[]in, int infrom, int into, Map<Integer,Integer> inmap){
        //数组不合法
        if(prefrom > preto || infrom > into){
            return null;
        }

        //前序遍历第一个点为树的根节点
        TreeNode root = new TreeNode(pre[prefrom]);

        //在中序序列中找到值为root.val点的下标，其左侧为左子树，右侧为右子树
        int n = inmap.get(root.val);
        //中序遍历，左子树范围[infrom,n-1],右子树范围[n+1,into]
        //先序遍历，左子树范围[prefrom+1,prefrom +(n-1-infrom+1)],即[prefrom+1,prefrom+n-infrom]
        //先序遍历，右子树范围[prefrom+n-infrom+1,preto]

        root.left = travel(pre,prefrom+1,prefrom+n-infrom,in,infrom,n-1,inmap);
        root.right = travel(pre,prefrom+n-infrom+1,preto,in,n+1,into,inmap);

        return root;

    }
}

时间复杂度：O(n)，其中 nn 是树中的节点个数。
空间复杂度：O(n)，除去返回的答案需要的 O(n)空间之外，我们还需要使用 O(n)的空间存储哈希映射，以及O(h)（其中 h 是树的高度）的空间表示递归时栈空间。这里 h < n，所以总空间复杂度为 O(n)。
来源：力扣题解分析

迭代法

https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/solution/cong-qian-xu-yu-zhong-xu-bian-li-xu-lie-gou-zao-9/

若题目改为给出后序和中序求二叉树，则根节点为后序序列中最后一个节点。

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

题目描述

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

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

例如，给出

中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]

返回如下的二叉树：

递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        if(inorder.length==0 || postorder.length==0){
            return null;
        }

        int length = postorder.length;
        Map<Integer,Integer> map = new HashMap<>();
        for(int i=0;i<length;i++)
        {
            map.put(inorder[i],i);
        }

        return travel(inorder,0,length-1,postorder,0,length-1,map);
    }

    public TreeNode travel(int[] inorder, int ifr,int it,int[] postorder,int pf,int pt,Map<Integer,Integer> map){
        if(ifr > it || pf>pt)
            return null;

        TreeNode root = new TreeNode(postorder[pt]);

        int spit = map.get(root.val);

        //中序左子树[ifr,spit-1]
        int left = spit-ifr;//左子树节点个数
        //后序左子树[pf,pf+left-1]

        //中序右子树[spit+1,it]
        //后序右子树[pf+left,pt-1]

        root.left = travel(inorder,ifr,spit-1,postorder,pf,pf+left-1,map);
        root.right = travel(inorder,spit+1,it,postorder,pf+left,pt-1,map);

        return root;

    }
}