【LeetCode】剑指 Offer 07. 重建二叉树

【LeetCode】剑指 Offer 07. 重建二叉树

package offer;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashMap;

public class Solution07 {
    public static void main(String[] args) {
        int[] preorder = {3,9,20,15,7};
        int[] inorder = {9,3,15,20,7};
        Solution07 solution = new Solution07();
        System.out.println(solution.levelOrder(solution.method(preorder, inorder)));
    }

    int[] preorder;
    HashMap<Integer, Integer> dic = new HashMap<>();

    private TreeNode method(int[] preorder, int[] inorder){
        this.preorder = preorder;
        for(int i = 0; i < inorder.length; i++)
            dic.put(inorder[i], i);
        return recur(0, 0, inorder.length - 1);
    }

    private TreeNode recur(int root, int left, int right){
        if(left > right) return null;
        TreeNode node = new TreeNode(preorder[root]);
        int i = dic.get(preorder[root]);
        node.left = recur(root + 1, left, i - 1);
        node.right = recur(root + i - left + 1, i + 1, right);
        return node;
    }

    private ArrayList<Integer> levelOrder(TreeNode root){
        ArrayList<Integer> res = new ArrayList<>();
        ArrayDeque<TreeNode> queue = new ArrayDeque<>();
        TreeNode temp = new TreeNode();
        queue.add(root);
        while(!queue.isEmpty()){
            temp = queue.poll();
            res.add(temp.val);
            if(temp.left != null) queue.add(temp.left);
            if(temp.right != null) queue.add(temp.right);
        }
        return res;
    }
}

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

    TreeNode(){};

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

//时间复杂度为 O(n)，n 为二叉树节点个数，初始化 HashMap 中序遍历时间复杂度为 O(n)，递归构建二叉树共 n 个节点，时间复杂度为 O(n)，层序遍历共 n 个节点，时间复杂度为 O(n)
//空间复杂度为 O(n)，n 为二叉树节点个数，HashMap、ArrayList、ArrayDeque，最多占用 O(3n)，递归深度最多为 n，占用 O(n) 的栈空间