通过前、中、后序遍历序列中的任意两个构造二叉树【Java实现】

二叉树的前序、中序和后序遍历是二叉树学习中的一个重点，也是二叉树中很基础的一部分，需要我们熟练的运用；通常已知二叉树，很多同学都能很轻松的得到其前序、中序和后序遍历的队列，甚至层序遍历也不在话下，如果是反过来呢？如果是理解不够的同学就会觉得头疼，有点不知道怎么下手，这里我将分享一下我的汇总，可能方法不是最优的，但是一定能帮助理解。

在此之前呢，我们需要再回顾一下二叉树的前序、中序和后序遍历的特点；

前序遍历：遍历后的序列中节点按照[ 根节点 | 左子树 | 右子树 ] 排序，以上图所示为例[ 1 | 2  4  5 | 3  6  7 ]；

中序遍历：遍历后的序列中节点按照[ 左子树 | 根节点 | 右子树 ] 排序，以上图所示为例[ 4  2  5 | 1 | 6  3  7 ]；

后序遍历：遍历后的序列中节点按照[ 左子树 | 右子树 | 根节点 ] 排序，以上图所示为例[ 4  5  2 | 6  7  3 | 1 ]；

前序和中序

解题思路

结合前序遍历和中序遍历的特点，可以顺序完成下列工作：

1. 前序遍历的首个元素就是根节点 root 的值；
2. 在中序遍历中找到根节点 root 的索引，可将中序队列中左子树和右子树划分出来，即[ 左子树 | 根节点 | 右子树 ]；
3. 根据中序队列中左（右）子树节点的数量，可将前序队列中左子树和右子树划分出来，即[ 根节点 | 左子树 | 右子树 ]；

根据子树特点，我们可以通过同样的方法对左（右）子树进行划分，每轮可确认三个节点的关系 。此递推性质让我们联想到用 递归方法 处理；但是在开始之前还有一个很重要的事情，就是先对递归进行解析；

• 递推参数： 前序遍历中根节点的索引 pre_root、中序遍历左边界 in_left、中序遍历右边界 in_right。
• 终止条件： 当 in_left > in_right ，子树中序遍历为空，说明已经越过叶子节点，此时返回 nullnull 。
• 递推工作：

1. 建立根节点 root： 值为前序遍历中索引为 pre_root 的节点值。
2. 搜索根节点root 在中序遍历的索引 i： 为了提升搜索效率，本题解使用哈希表 dic 预存储中序遍历的值与索引的映射关系，每次搜索的时间复杂度为 O(1)。
3. 构建根节点root的左子树和右子树： 通过调用 recur() 方法开启下一层递归。
   1. 左子树： 根节点索引为 pre_root + 1 ，中序遍历的左右边界分别为 in_left 和 i - 1。
   2. 右子树： 根节点索引为 i - in_left + pre_root + 1（即：根节点索引 + 左子树长度 + 1），中序遍历的左右边界分别为 i + 1 和 in_right。

• 返回值： 返回 root，含义是当前递归层级建立的根节点 root 为上一递归层级的根节点的左或右子节点

class Solution {
    //定义一个map用来存储中序序列，方便直接利用根节点的值找其在中序序列中的索引
    HashMap<Integer, Integer> in_map = new HashMap<>();
    //定义一个全局变量preArr，用于指向前序序列，方便在recur方法中使用
    int[] preArr;

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        preArr = preorder;
        for(int i = 0; i < inorder.length; i++)
            in_map.put(inorder[i], i);
        return recur(0, 0, inorder.length-1);
    }

    /**
    * recur方法开启下一层递归
    * pre_root 前序遍历中根节点的索引
    * in_left 中序遍历左边界
    * in_right 中序遍历右边界
    */
    public TreeNode recur(int pre_root, int in_left, int in_right){
        //递归先判断结束条件；当 in_left > in_right ，子树中序遍历为空，说明已经越过叶子节点，此时返回 null 。
        if(in_left > in_right)
            return null;
        //建立当前子树的根节点
        TreeNode root = new TreeNode(preArr[pre_root]);
        //搜索根节点在中序遍历中的索引，从而可对根节点、左子树、右子树完成划分
        int i = in_map.get(preArr[pre_root]);
        //开启左子树的下层递归
        root.left = recur(pre_root+1, in_left, i-1);
        //开启右子树的下层递归
        root.right = recur(pre_root+i-in_left+1, i+1, in_right);
        return root;
    }
}

中序和后序

后序和前序是比较类似的序列，前序序列的第一个元素为树的根节点，而后序序列的根节点则是在最后一个元素；因此，如果掌握了前序和中序，那么中序和后序的原理也基本相同，唯一的区别就是位置关系的计算，结合下面这张图去看代码可以帮助大家去理解；

class Solution {
    HashMap<Integer, Integer> in_map = new HashMap<>();
    int[] posArr;
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        posArr = postorder;
        for(int i = 0; i < inorder.length; i++)
            in_map.put(inorder[i], i);
        return recur(postorder.length-1, 0, 0, inorder.length-1);
    }

    public TreeNode recur(int pre_root, int pre_left, int in_left, int in_right){
        if(in_left > in_right || pre_root < pre_left)
            return null;
        TreeNode root = new TreeNode(posArr[pre_root]);
        int i = in_map.get(posArr[pre_root]);
        root.left = recur(pre_left+i-in_left-1, pre_left, in_left, i-1);
        root.right = recur(pre_root-1, pre_left+i-in_left, i+1, in_right);
        return root;
    }
}

前序和后序

前序和后序这两个序列比较相似，都能直接找到根节点，而没有任何一个序列能够将左右子树进行分离，所以实现起来更为麻烦；具体思路为，我们在前序序列中可以找到根节点和左子树的根节点（根节点后面的节点），我们可以在后序序列中找到这个左子树根节点的索引，从而得到左子树的长度，这样就可以分别在前序和后序序列中将根节点、左子树和右子树划分出来，我们还结合图形进行理解；

class Solution {
    HashMap<Integer, Integer> preMap = new HashMap<>();
    HashMap<Integer, Integer> postMap = new HashMap<>();
    int[] preArr;
    public TreeNode constructFromPrePost(int[] pre, int[] post) {
        preArr = pre;
        for(int i = 0; i < pre.length; i++)
            preMap.put(pre[i], i);
        for(int i = 0; i < post.length; i++)
            postMap.put(post[i], i);
        return recur(0, pre.length-1, 0, post.length-1);
    }

    public TreeNode recur(int pre_left, int pre_right, int post_left, int post_right){
        if(pre_left > pre_right || post_left > post_right)
            return null;
        //这里需要注意，新增加了两种判断情况，因为如果相等的时候证明这已经是叶子节点无需再向下递归
        //因为left和right都是计算出来的，所以再递归也不会满足left>right，而会出现数组下标越界的情况
        if(pre_left == pre_right)
        	return new TreeNode(preArr[pre_left]);
        if(post_left == post_right)
        	return new TreeNode(preArr[post_left]);
        
        TreeNode root = new TreeNode(preArr[pre_left]);
        int left_len = postMap.get(preArr[pre_left+1]) - post_left;
        root.left = recur(pre_left+1, pre_left+1+left_len, post_left, postMap.get(preArr[pre_left+1]));
        root.right = recur(pre_left+left_len+2, pre_right, postMap.get(preArr[pre_left+1])+1, post_right-1);
        return root;
    }
}