剑指offer7 重建二叉树

题目

输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。

假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

样例

思路

代码

package 剑指offer.分治算法.offer7;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Solution {

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

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


    }

    public static void main(String[] args) {

//        int[] preorder = {3,9,20,15,7};
//        int[] inorder = {9,3,15,20,7};
        int[] preorder = {1,2};
        int[] inorder = {1,2};
        TreeNode treeNode = new Solution().buildTree(preorder, inorder);

        System.out.println(treeNode);
    }

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        //todo:对于特殊值null的处理
        if(preorder.length == 0 || inorder.length == 0){
            return null;
        }


        TreeNode root = new TreeNode(preorder[0]);

        //转化为List便于操作
        List<Integer> preorderList = Arrays.stream(preorder).boxed().collect(Collectors.toList());
        List<Integer> inorderList = Arrays.stream(inorder).boxed().collect(Collectors.toList());

        buildTreeImp(preorderList,inorderList,root);

        return root;

    }

    /**
     * 思路分析：
     * 1. 由先序可得到这一部分的头节点
     * 2. 由中序可以得到这一部分的左右有哪些
     * 3. 然后再去先序中，寻找左右的头节点
     */
    public void buildTreeImp(List<Integer> preorderList, List<Integer> inorderList,TreeNode root) {

        //todo:递归的终结条件
        if(preorderList.size() == 1 || preorderList.size() == 0){
            return;
        }
        if(inorderList.size() == 1 || inorderList.size() == 0){
            return;
        }

        int rootVal = preorderList.get(0);
        //取到左边有多长，就可以寻找到左右的分界点，就可以寻找到右节点
        int rootInorderIndex = inorderList.indexOf(rootVal);
        int leftLength = rootInorderIndex - 0;

        int leftIndex = 1;
        int rightIndex = leftLength + 1;

        TreeNode leftNode = null;
        TreeNode rightNode = null;


        //判断该头结点，是否存在左子节点
        if(rootInorderIndex == 0){
            root.left = null;

        }else {
            leftNode = new TreeNode(preorderList.get(leftIndex));
            root.left = leftNode;
        }


        //判断该头结点是否存在右子节点
        if(rootInorderIndex == inorderList.size()){
            root.right = null;

        }else {
            rightNode = new TreeNode(preorderList.get(rightIndex));
            root.right = rightNode;
        }


        //递归操作
        //截取子串

        List<Integer> leftPreorder = preorderList.subList(leftIndex, rightIndex);
        List<Integer> leftInorder = inorderList.subList(0, rootInorderIndex);
        buildTreeImp(leftPreorder,leftInorder,leftNode);

        List<Integer> rightPreorder = preorderList.subList(rightIndex, preorderList.size());
        List<Integer> rightInorder = inorderList.subList(rootInorderIndex+1, inorderList.size());
        buildTreeImp(rightPreorder,rightInorder,rightNode);

    }
}