[剑指offer_07] 由前序和中序遍历重建二叉树

[剑指offer_07] 由前序和中序遍历重建二叉树

1.由前序和中序遍历重建二叉树

题目描述：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
思路：先找出根节点，然后利用递归方法构造二叉树

2.递归

/**
 * 解法一：递归（传入数组的拷贝）
 * 时间复杂度：O(n)，空间复杂度：O(n)
 *
 * @param preorder 前序遍历
 * @param inorder 中序遍历
 * @return 二叉树树节点
 */
public static TreeNode buildTree(int[] preorder, int[] inorder) {
    if (preorder == null || inorder == null || preorder.length == 0 || inorder .length ==0) {
        return null;
    }
    if (preorder.length != inorder.length) {
        return null;
    }

    //找到第一个根节点,是前序遍历的第一个元素
    TreeNode root = new TreeNode(preorder[0]);
    for (int i = 0; i < preorder.length; i++) {
        if (preorder[0] == inorder[i]) {//找到下标
            root.left = buildTree(Arrays.copyOfRange(preorder, 1, i + 1),
                    Arrays.copyOfRange(inorder, 0, i));//注意这里包括下标from，不包括上标to。
            root.right = buildTree(Arrays.copyOfRange(preorder, i + 1, preorder.length),
                    Arrays.copyOfRange(inorder, i + 1, inorder.length));
        }
    }
    return root;
}

public static TreeNode buildTree2(int[] preorder, int[] inorder) {
    if (preorder == null || inorder == null || preorder.length == 0 || inorder .length ==0) {
        return null;
    }
    if (preorder.length != inorder.length) {
        return null;
    }

    //找到第一个根节点,是前序遍历的第一个元素
    TreeNode root = new TreeNode(preorder[0]);
    int index = -1;
    for (int i = 0; i < preorder.length; i++) {
        //找到根节点的下标
        if (preorder[0] == inorder[i]) {
            index = i;
            break;
        }
    }
    root.left = buildTree2(Arrays.copyOfRange(preorder, 1, index + 1),
            Arrays.copyOfRange(inorder, 0, index));//注意这里包括下标from，不包括上标to。
    root.right = buildTree2(Arrays.copyOfRange(preorder, index + 1, preorder.length),
            Arrays.copyOfRange(inorder, index + 1, inorder.length));
    return root;
}

3.递归：传入子数组的边界索引

/**
 * 解法二：递归：传入左右子数组的边界索引
 * 时间复杂度:O(n),空间复杂度：O(n)
 *
 * @param preorder 前序遍历
 * @param inorder 后序遍历
 * @return 二叉树的节点
 */
public static TreeNode buildTree3(int[] preorder, int[] inorder) {
    if (preorder == null || preorder.length ==0 || inorder == null || inorder.length == 0){
        return null;
    }
    if (preorder.length != inorder.length) {
        return null;
    }
    return helper(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
}

/**
 *
 * @param preorder 前序遍历
 * @param preL 前序遍历左边界
 * @param preR 前序遍历右边界
 * @param inorder 中序遍历
 * @param inL 中序遍历左边界
 * @param inR 中序遍历右边界
 * @return TreeNode
 */
private static TreeNode helper(int[] preorder, int preL, int preR, int[] inorder, int inL, int inR) {
    if (preL > preR || inL > inR) {
        return null;
    }
    int rootVal = preorder[preL];
    int index = 0;
    while (index <= inR && inorder[index] != rootVal) {
        index++;
    }
    TreeNode root = new TreeNode(rootVal);
    root.left = helper(preorder, preL + 1, preL - inL + index, inorder, inL, index);
    root.right = helper(preorder, preL - inL + index + 1, preR, inorder, index + 1, inR);
    return root;
}

4.测试用例

@Test
public void test7() {
    //前序遍历结果
    int[] preOrder = {1, 2, 4, 7, 3, 5, 6, 8};
    //后续遍历结果
    int[] inOrder  = {4, 7, 2, 1, 5, 3, 8, 6};
    TreeNode root1 = BuildTree7.buildTree1(preOrder, inOrder);
    TreeNode root2 = BuildTree7.buildTree2(preOrder, inOrder);
    TreeNode root3 = BuildTree7.buildTree3(preOrder, inOrder);

    //System.out.println(root.val);
    System.out.println("重建后的二叉树(递归1):" + Arrays.toString(new LevelOrder32().levelOrder(root1)));
    System.out.println("重建后的二叉树（递归2）:" + Arrays.toString(new LevelOrder32().levelOrder(root2)));
    System.out.println("重建后的二叉树（边界索引+递归3）:" + Arrays.toString(new LevelOrder32().levelOrder(root3)));
}