重建二叉树

先来看两种写法：

第一种：

/**
 * 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) {
         
        if (pre == null || in == null ) { 
            return null; 
        } 
        try { 
            return ConstructCore(pre, 0, pre.length - 1, in, 0,in.length - 1); 
        } catch (InvalidPutException e) { 
            e.printStackTrace(); 
            return null; 
        } 
 
         
    }
     
    public static TreeNode ConstructCore(int[] preOrder,int startPreIndex, int endPreIndex,  
            int[] inOrder,int startInIndex, int endInIndex) throws InvalidPutException { 
   
        int rootValue = preOrder[startPreIndex]; 
        System.out.println("rootValue = " + rootValue); 
        TreeNode root = new TreeNode(rootValue); 
   
        // 只有一个元素 
        if (startPreIndex == endPreIndex) { 
            if (startInIndex == endInIndex 
                    && preOrder[startPreIndex] == inOrder[startInIndex]) { 
                System.out.println("only one element"); 
                return root; 
            } else { 
                throw new InvalidPutException(); 
            } 
        } 
   
        // 在中序遍历中找到根结点的索引 
        int rootInIndex = startInIndex; 
   
        while (rootInIndex <= endInIndex && inOrder[rootInIndex] != rootValue) { 
            ++rootInIndex; 
        } 
   
        if (rootInIndex == endInIndex && inOrder[rootInIndex] != rootValue) { 
            throw new InvalidPutException(); 
   
        } 
   
        int leftLength = rootInIndex - startInIndex; 
   
        int leftPreOrderEndIndex = startPreIndex + leftLength; 
   
        if (leftLength > 0) { 
            // 构建左子树 
            root.left = ConstructCore(preOrder, startPreIndex + 1, 
                    leftPreOrderEndIndex, inOrder, startInIndex, 
                    rootInIndex - 1); 
        } 
   
        if (leftLength < endPreIndex - startPreIndex) { 
            // 右子树有元素,构建右子树 
            root.right = ConstructCore(preOrder, leftPreOrderEndIndex + 1, 
                    endPreIndex, inOrder, rootInIndex + 1, endInIndex); 
        } 
        return root; 
    } 
     
    static class InvalidPutException extends Exception { 
   
        private static final long serialVersionUID = 1L; 
   
    } 
}

第二种：

public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        TreeNode root=reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);
        return root;
    }
    //前序遍历{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}
    private TreeNode reConstructBinaryTree(int [] pre,int startPre,int endPre,int [] in,int startIn,int endIn) {
         
        if(startPre>endPre||startIn>endIn)
            return null;
        TreeNode root=new TreeNode(pre[startPre]);
         
        for(int i=startIn;i<=endIn;i++)
            if(in[i]==pre[startPre]){
                root.left=reConstructBinaryTree(pre,startPre+1,startPre+i-startIn,in,startIn,i-1);
                root.right=reConstructBinaryTree(pre,i-startIn+startPre+1,endPre,in,i+1,endIn);
            }
                 
        return root;
    }
}

显然第二种更好。显著的减少了if语句