Java：根據前序遍歷與中序遍歷構造出一個二叉樹

給你前序遍歷中序遍歷，如何構造出一個二叉樹？

思路：

1. 明確前序遍歷與中序遍歷的順序

前序遍歷：根→左子樹→右子樹

中序遍歷：左子樹→根→右子樹

2. 根據前序遍歷可確認根節點，在中序遍歷中根節點是一個分水嶺，可由根節點分辨出左右子樹

3. 對左右子樹分別重復第2步，可以找出左右子樹的子樹，也就是遞歸操作

代碼：

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

public class Solution {
    public static TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        //1.由前序遍歷確認根節點
        int node=pre[0];
        TreeNode tree=new TreeNode(node);

        //2.由中序遍歷確認左右子樹節點
        ArrayList<Integer> leftTreeForIn=new ArrayList<>();
        ArrayList<Integer> rightTreeForIn=new ArrayList<>();
        int nodePosition=-1;
        for(int i=0;i<in.length;i++){
            if(in[i]==node){
                nodePosition=i;  //確認根節點在中序遍歷中的位置
            }
            //根據根節點將左右子樹的節點分別放入兩個list中
            if(nodePosition<0){
                leftTreeForIn.add(in[i]); 
            }else if(nodePosition>=0 && nodePosition<i){
                rightTreeForIn.add(in[i]);
            }
        }

        //3.為樹添加左右子樹
        if(leftTreeForIn.size()>0){ 
            TreeNode left;
            if(leftTreeForIn.size()==1){  //判斷左子樹是否有葉子節點，左子樹只有1個節點則表示無葉子節點
                left=new TreeNode(leftTreeForIn.get(0));
            }else{ //有葉子節點則進行遞歸操作
                int[] leftTreeForPre=new int[leftTreeForIn.size()];
                for(int i=0;i<leftTreeForIn.size();i++){
                    leftTreeForPre[i]=pre[i+1];
                }
                left=reConstructBinaryTree(leftTreeForPre,Arrays.stream(leftTreeForIn.toArray(new Integer[]{})).mapToInt(Integer::valueOf).toArray());
            }
            tree.left=left;
        }

        if(rightTreeForIn.size()>0){
            TreeNode right;
            if(rightTreeForIn.size()==1){
                right=new TreeNode(rightTreeForIn.get(0));
            }else{
                int[] rightTreeForPre=new int[rightTreeForIn.size()];
                for(int i=0;i<rightTreeForIn.size();i++){
                    rightTreeForPre[i]=pre[i+1+leftTreeForIn.size()];
                }
                right=reConstructBinaryTree(rightTreeForPre,Arrays.stream(rightTreeForIn.toArray(new Integer[]{})).mapToInt(Integer::valueOf).toArray());
            }
            tree.right=right;
        }
       return tree;

    }

    public static void main(String[] args){
        int[] pre={1,2,4,7,3,5,6,8};
        int[] in={4,7,2,1,5,3,8,6};

        TreeNode tree=reConstructBinaryTree(pre,in);
        System.out.println(tree.left.left.right.val);
    }
}