剑指offer-重建二叉树

题目描述

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

 

二叉树的前序，中序，后序遍历的顺序分别是：

前序遍历：先访问根节点，再访问左子结点，最后访问右子结点；（根左右）

中序遍历：先访问左子结点，再访问根结点，最后访问右子结点；（左根右）

后序遍历：先访问左子结点，再访问右子结点，最后访问根结点；（左右根）

这三种遍历方式都可以采用递归和循环的方式实现。

一般遇到这个问题，我们都先自己手动推一下，手动建立一棵二叉树。手动建立二叉树可以参考这篇博客，

https://blog.csdn.net/jarviskao/article/details/75012218，写的很清晰了。

解题思路：

题中给出了二叉树前序遍历和中序遍历的结果，在二叉树的前序遍历中，第一个数字总是树的根结点的值。

而在中序遍历序列中，根结点的值在序列的中间，左子树的结点的值位于根结点的值的左边，而右子树的结点的值位于根结点的值的右边。

我们可以先通过前序遍历结果找到根节点的值，再通过中序遍历找到根节点在中序遍历结果中的位置，则左边为左子树对应的元素，右边为右子树对应的元素。

我们可以通过两个序列再次确定左子树和右子树的前序遍历结果和中序遍历结果。对接下来的左右子树继续遍历，也是通过上面相同的方法。

由于在中序遍历序列中，有3个数字是左子树结点的值，因此左子树总共有3个左子结点。同样，在前序遍历的序列中，根结点后面的3个数字就是3个左子树结点的值，再后面的所有数字都是右子树结点的值。这样就在前序和中序遍历的两个序列中，分别找到了左右子树对应的子序列。

我们已经分别找到了左右子树的前序和中序遍历，我们可以用同样的方法分别去构建左右子树，即递归实现。

class ConstructTree {
    //二叉树节点
    class TreeNode{
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x){
            this.val=x;
        }
    }
    
    /*
     * 给定二叉树的前序和中序遍历结果，重构二叉树
     * pre:前序遍历
     * in:中序遍历
     * return：二叉树根节点
     * */
    public TreeNode reConstructBinaryTree(int[] pre,int[] in){
        //输入合法性判断，不能为空，前序和中序长度要一致
        if(pre==null||in==null||pre.length!=in.length){
            return null;
        }
        return construct(pre,0,pre.length-1,in,0,in.length-1);
        
    }
    /*
     * pre:前序遍历   ps:前序遍历的开始节点  pe:前序遍历的结束节点
     * in:中序遍历    is:中序遍历的开始节点   ie:中序遍历的结束节点 
     * return:树的根节点
     * */

    private TreeNode construct(int[] pre, int ps, int pe, int[] in, int is, int ie) {
        // TODO Auto-generated method stub
        if(ps>pe){
            return null;
        }
        //取前序遍历的第一个数字，为根节点
        int value=pre[ps];
        //从中序遍历中寻找根节点对应的位置
        int index=is;
        while(index<ie&&value!=in[index]){
            index++;
        }
        //如果整个中序遍历的数组都没有找到，说明输入的参数是不合法的，抛出异常
        if(index>ie){
            throw new RuntimeException("Invalid input!");
        }
        //此时也找到了根节点在中序遍历中的位置
        //创建当前根节点，并为根节点赋值
        TreeNode node=new TreeNode(value);
        //当前节点的左子树的个数为index-is，左子树长度Llength=index-is
        int Llength=index-is;    
        //左子树对应的前序遍历的位置在preOrder[ps+1,ps+Llenght]
        //左子树对应的中序遍历的位置在inOrder[is,index-1]
        node.left=construct(pre, ps+1, ps+Llength, in, is, index-1);
        //当前节点的右子树的个数为ie-index,Rlength=ie-index
//        int rLength=ie-index;
        //右子树对应的前序遍历位置在preOrder[ps+index-is+1,pe]
        //右子树对应的中序遍历位置在inOrder[index+1,ie]
        node.right=construct(pre, ps+Llength+1, pe, in, index+1, ie);
        return node;
    }
    //中序递归打印
    private void printTree(TreeNode root){
        if(root!=null){
            printTree(root.left);
            System.out.println(root.val+" ");
            printTree(root.right);
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ConstructTree ct = new ConstructTree();
        int[] pre = {1, 2, 4, 7, 3, 5, 6, 8};
        int[] in = {4, 7, 2, 1, 5, 3, 8, 6};
        TreeNode node = ct.reConstructBinaryTree(pre, in);
        ct.printTree(node);

    }

}

 

下面是一个更清晰的解题思路:

/**
 * 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 pLen=pre.length;
        int iLen=in.length;
        if(pLen==0||iLen==0)
        {
        return null;
        }else{
            return btConstruct(pre,in,0,pLen-1,0,iLen-1);
        }
        
    }
    private TreeNode btConstruct(int[] pre, int[] in, int pStart, int pEnd, int iStart, int iEnd) {
        // TODO Auto-generated method stub
        //建立根节点
        TreeNode tree=new TreeNode(pre[pStart]);
        tree.left=null;
        tree.right=null;
        if(pStart==pEnd&&iStart==iEnd){
            return tree;
        }
        
        int root=0;
        //找中序遍历中根节点所在的位置
        for (root = iStart; root < iEnd; root++) {
            if(in[root]==pre[pStart]){
                break;
            }
            
        }
        //划分左右子树
        int leftLength=root-iStart;   //左子树
        int rightLength=iEnd-root;    //右子树
        //递归遍历左子树
        if(leftLength>0){
            tree.left=btConstruct(pre, in, pStart+1, pStart+leftLength, iStart, root-1);
        }
        if(rightLength>0){
            tree.right=btConstruct(pre, in, pStart+1+leftLength, pEnd, root+1, iEnd);
        }
        return tree;
    }
}