每天一道编程题07--重构二叉树

1.题目：

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

    题目意思很简单，知道二叉树的中序和先序遍历，还原二叉树，只不过用代码来实现而已。

分析：

    首先需要明白的是：中序遍历一定是 这个结构 ：{ 左子树中的节点集合 }，root，{ 右子树中的节点集合 }，前序遍历的作用就是找到每颗子树的root位置。

   算法分析：

    1.首先根据前序遍历可以找到整棵树的根节点1，那么根据先序历遍的结果{4，7，2}就是左子树的集合，{5，3，8，6}就是右子树的集合。

    2.根据中序左子树{4，7，2}在前序历遍的结果{2，4，7}来看，可知2是左子树的根节点，根节点在中序左子树的末端，说明以2为根节点的树没有右子树，那么他就只剩下以2为根节点的左子树，剩下前序的结果为{4，7}，那么4为根节点，4为根节点以后再看中序{4，7}，说明根节点4没有左子树，那么整棵树的左子树结构就出来了：

                                 

  3.继续分析右子树，中序为{5，3，8，6}。前序为{3,5,6,8}，说明3是根节点，观察中序为{5，3，8，6}可知，左子树为{5}，右子树为{8，6}，继续看{6，8}的前序，说明6为根，看中序{8，6}，说明{8}是6的左节点.那么整棵树就如图了： 并且这是一个递归的问题。

                                 

  现在就是代码实现了：

  分析一下具体代码实现的思路，首先需要根据先序找到根，再把树分为新的左右两颗子树，左右两颗子树即是树的左右节点，这个左右节点再递归调用直到根节点为空为止。

package com.wx.concurrent10;

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

package com.wx.concurrent10;


import java.util.ArrayList;
import java.util.List;

public class Test3 {
    public static void main(String[] args) {
        /**
         * 输入某二叉树的前序遍历和中序遍历的结果，
         * 请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
         * 例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
         */
        int[] pre = {1, 2, 3, 4, 5, 6, 7, 8};
        int[] in = {4, 7, 2, 1, 5, 3, 8, 6};
        Test3 test3 = new Test3();
        TreeNode treeNode = test3.reConstructBinaryTree(pre, in);
        System.out.println("");
    }
    //递归调用的两个条件，有一个递归结束的条件，外层结果依赖内层的结果
    public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
        //这是一个递归的条件
        if (pre.length == 0) {
            //返回一个空树
            return null;
        }
        TreeNode root = new TreeNode(pre[0]);
        //这是另外一个递归的条件,如果只有根
        if (pre.length == 1) {
            root.left = null;
            root.right = null;
            return root;
        }
        //还需要每次拿到中序根节点的index
        int indexnode = 0;
        for (int i = 0; i < in.length; i++) {
            if (in[i] == pre[0]) {
                indexnode = i;
            }
        }
        //如果有子树，那就分为左右子树，然后左右子树递归直到子树只剩根为止。
        //这就需要重新计算左右子树的先序，中序的序列，然后分别递归调用
        List<Integer> leftNewPre = new ArrayList<Integer>();
        List<Integer> leftNewIn = new ArrayList<Integer>();
        List<Integer> rightNewPre = new ArrayList<Integer>();
        List<Integer> rightNewIn = new ArrayList<Integer>();
        //计算左子树中序遍历序列
        for (int i = 0; i < in.length; i++) {
            if (in[i] == pre[0]) {
                break;
            }
            leftNewIn.add(in[i]);
        }
        //计算左子树先序遍历序列
        for (int i = 0; i < pre.length; i++) {
            for (int j = 0; j < leftNewIn.size(); j++) {
                if (leftNewIn.get(j) == pre[i]) {
                    leftNewPre.add(pre[i]);
                }
            }
        }
        int[] arrayleftNewPre = new int[leftNewPre.size()];
        for (int i = 0; i < leftNewPre.size(); i++) {
            arrayleftNewPre[i] = leftNewPre.get(i);
        }
        int[] arrayleftNewIn = new int[leftNewIn.size()];
        for (int i = 0; i < leftNewIn.size(); i++) {
            arrayleftNewIn[i] = leftNewIn.get(i);
        }
        root.left = reConstructBinaryTree(arrayleftNewPre, arrayleftNewIn);
        //右子树继续 计算中序遍历序列
        for (int i = indexnode + 1; i < in.length; i++) {
            if (in[i] == pre[0]) {
                break;
            }
            rightNewIn.add(in[i]);
        }
        //右子树继续 计算先序遍历序列
        for (int i = 0; i < pre.length; i++) {
            for (int j = 0; j < rightNewIn.size(); j++) {
                if (rightNewIn.get(j) == pre[i]) {
                    rightNewPre.add(pre[i]);
                }
            }
        }
        int[] arrayrightNewPre = new int[rightNewPre.size()];
        for (int i = 0; i < rightNewPre.size(); i++) {
            arrayrightNewPre[i] = rightNewPre.get(i);
        }
        int[] arrayrightNewIn = new int[rightNewIn.size()];
        for (int i = 0; i < rightNewIn.size(); i++) {
            arrayrightNewIn[i] = rightNewIn.get(i);
        }
        root.right = reConstructBinaryTree(arrayrightNewPre, arrayrightNewIn);
        return root;
    }
}

   调试结果：

 

 

  参考博客：

        https://www.cnblogs.com/xinchrome/p/4905608.html