每日一题：重建二叉树（DFS超时）

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

此算法超时

package com.three;

import java.util.HashMap;
import java.util.Map;

/**
 * @author huxia
 * @version 1.0
 * @date 2020-04-22 23:07
 *
 * 题目描述
 *      1
 *    2     3
 * 4       5   6
 *   7        8
 *
 * 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
 * 例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
 */
public class 重建二叉树 {


    public  static  StringBuffer frontStr = new StringBuffer("1,2,4,6,7,3,5,");
    public  static  StringBuffer midStr = new StringBuffer("4,6,7,2,1,5,3,");

    public  static  int x = 1;

    public static void main(String[] args) {
        TreeNode node = new TreeNode(1);
        node.left = new TreeNode(2);
        node.left.left = new TreeNode(4);
        node.left.left.right = new TreeNode(6);
        node.left.left.right.right = new TreeNode(7);
        node.right = new TreeNode(3);
        node.right.left = new TreeNode(5);
        System.out.println(midErgodic(node,new StringBuffer()));
       System.out.println(midStr);
        int [] pre = {1,2,4,7,3,5,6,8};
        int [] in = {4,7,2,1,5,3,8,6};
        node =  reConstructBinaryTree(pre,in);

    }

    //主方法
    public static  TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        TreeNode node =  new TreeNode(pre[0]);
        dfs(pre,in,new TreeNode(1),1);

        return node;

    }

    //深度搜索算法
    public static boolean dfs(int [] pre ,int [] in,TreeNode node,int index){
        if(index ==pre.length){
            StringBuffer sbfron = new StringBuffer();
            frontErgodic(node,sbfron);
            StringBuffer sbmid= new StringBuffer();
            midErgodic(node,sbmid);

            //当前序中序搜索一致时返回true
            if(frontStr.toString().equals(sbfron.toString())&&midStr.toString().equals(sbmid.toString())){
                return true;
            }else{
                return  false;
            }
        }
        boolean res = false;

        //查找新val可能存在的位置
        HashMap<Integer ,TreeNode>  map = new HashMap<>();
        possibleSite(node,map);
        //遍历所有可能，性能是不是在这边加
        for (Integer x: map.keySet()) {
            if(!res){
                //
                if(x%2==0){
                    map.get(x).left = new TreeNode(pre[index]);
                }else{
                    map.get(x).right = new TreeNode(pre[index]);
                }
                //暂时确定此节点位置，往下遍历
                res = dfs(pre, in, node,index+1);
            }
            //如果失败、将tree还原
            if(!res){
                if(x%2==0){
                    map.get(x).left = null;
                }else{
                    map.get(x).right =null;
                }
            }
        }


        return res;
    }


    //算出可能存在的位置
    public  static void possibleSite(TreeNode node,HashMap<Integer ,TreeNode> map){
        //定义KEY为偶数是左边。key是奇数在右边
        if(node.left==null){
            map.put(2*(++x),node);
        }else{
            possibleSite(node.left,map);
        }
        if(node.right==null){
            map.put(2*(++x)+1,node);
        }else{
            possibleSite(node.right,map);
        }
    }



    //前序遍历
    public  static  StringBuffer frontErgodic(TreeNode node,StringBuffer sb){
        sb.append(node.val+",");
        if(node.left!=null){
            frontErgodic(node.left,sb);
        }
        if(node.right!=null){
            frontErgodic(node.right,sb);
        }
        return  sb;
    }

    //中序遍历
    public  static  StringBuffer midErgodic(TreeNode node,StringBuffer sb){
        if(node.left!=null){
            midErgodic(node.left,sb);
        }
        sb.append(node.val+",");
        if(node.right!=null){
            midErgodic(node.right,sb);
        }
        return sb;
    }


}

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