剑指 Offer 07. 重建二叉树

题目：

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

限制：

0 <= 节点个数 <= 5000

难度：中等

代码：

//前序根-左-右，中序左-根-右，可以看出从前序取出一个值，再在中序找到其位置，可以发现，中序位置左侧是其左子树，右侧是右子树。通过中序可以得到其左右子树的长度，根据长度

//可以在递归时确定先序遍历数组左、右子树的下标位置，以及中序数组左、右子树的下标位置，从而可以确定递归方法的参数。

/**
 * 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[] preorder, int[] inorder) {
        if(preorder.length==0){return null;}
        if(preorder.length==1){return new TreeNode(preorder[0]);}  //空树和只有根节点树单独处理，可以提高执行效率
        return fun1(preorder,0,preorder.length-1,inorder,0,inorder.length-1);
    }

    public static TreeNode fun1(int[] preorder,int leftp,int rightp, int[] inorder,int lefti,int righti){
        if(leftp<=rightp){  //递归终止条件
            int rootNum=preorder[leftp]; //当前树的根的值
            int t=0;
            for(int i=lefti;i<=righti;i++){
                if(inorder[i]==rootNum){
                    t=i;
                }
            }

            int len1=t-lefti;  //左子树的长度
            int len2=righti-t; //右子树的长度                                         
            TreeNode root=new TreeNode(rootNum);
            root.left=fun1(preorder,leftp+1,leftp+len1,inorder,lefti,t-1);  //循环左子树
            root.right=fun1(preorder,rightp-len2+1,rightp,inorder,t+1,righti);  //循环右子树
            return root;
        }
        return null;
    }
}

 

代码2：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    Map<Integer,Integer> map=new HashMap<>();  //利用map存放后序遍历的值和下标，避免每次使用for循环查找根节点的中序下标，提高效率。
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length==0){return null;}
        if(preorder.length==1){return new TreeNode(preorder[0]);}
        for(int i=0;i<inorder.length;++i){
            map.put(inorder[i],i);
        }
        return fun1(preorder,0,preorder.length-1,inorder,0,inorder.length-1);
    }

    public TreeNode fun1(int[] preorder,int leftp,int rightp, int[] inorder,int lefti,int righti){
        if(leftp<=rightp){  //递归终止条件
            int rootNum=preorder[leftp]; //当前树的根的值
            int t=map.get(rootNum); //根节点在中序中的下标
            int len1=t-lefti;  //左子树的长度
            int len2=righti-t; //右子树的长度                                         
            TreeNode root=new TreeNode(rootNum);
            root.left=fun1(preorder,leftp+1,leftp+len1,inorder,lefti,t-1);  //循环左子树
            root.right=fun1(preorder,rightp-len2+1,rightp,inorder,t+1,righti);  //循环右子树
            return root;
        }
        return null;
    }
}