重建二叉树

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

虽然效率低但好歹解出来了 🙃

感觉在纸上写的时候有思路但落实到代码就很尴尬😅

/**
 * 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(in.length==0){
            return null;
        }
        if(in.length==1){
            return new TreeNode(in[0]);
        }else{
            int pl = pre.length;
            int il = in.length;
            TreeNode THead = new TreeNode(pre[0]);
            int nodeindex = location(pre[0],in);
            int[] tpreleft = new int[nodeindex];//去掉根节点的左子树前序遍历
            int[] tpreright = new int[pl-nodeindex-1];//右子树前序遍历
            int[] tinleft = new int[nodeindex];//左子树中序遍历
            int[] tinright = new int[il-nodeindex-1];//右子树中序遍历
            if(nodeindex!=0){
                for(int i=0;i<nodeindex;i++){
                    tpreleft[i] = pre[i+1];
                }
                for(int k=0;k<nodeindex;k++){
                    tinleft[k] = in[k];
                }
            }
            if((pl-nodeindex-1)!=0){
                for(int j=0;j<pl-nodeindex-1;j++){
                    tpreright[j] = pre[(j+nodeindex+1)];
                }
                for(int l=0;l<in.length-nodeindex-1;l++){
                    tinright[l] = in[l+nodeindex+1];
                }
            }
            THead.left = reConstructBinaryTree(tpreleft,tinleft);//递归获得左子树
            THead.right = reConstructBinaryTree(tpreright,tinright);//递归获得右子树
            return THead;
        }
    }
    public int location(int key,int[] in){/*获取根节点在中序遍历中的位置，以此分辨左子树和右子树*/
        int l = in.length;
        for(int i=0;i<l;i++){
            if(key==in[i])
                return i;
        }
        return -1;
    }
}

 

下面贴一下推荐代码（简洁）

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);
                      break;
            }
                 
        return root;
    }
}

思路大体上差不多虽然本人实现很复杂。。。

继续加油