Leetcode105：根据前序中序构建树

题目描述

思路 1

我的思路主要是递归，通过不断缩小问题的规模来解决。递归的参数还是 preorder 和 inorder 两个数组，为了操作简便，preorder 保持不变，inorder 随递归加深不断缩减。
边界条件：

• 假设 inorder 只有一个元素，直接返回节点
• 假如 inorder 为空，返回 null

代码如下：

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        List<Integer> preList = new ArrayList<>(preorder.length);
        List<Integer> inList = new ArrayList<>(inorder.length);
        for (int j : preorder) {
            preList.add(j);
        }
        for (int j : inorder) {
            inList.add(j);
        }
        return build(preList, inList);
    }

    public TreeNode build(List<Integer> preorder, List<Integer> inorder) {
        if (preorder.size() == 0 || inorder.size() == 0) {
            return null;
        }

        if (inorder.size() == 1) {
            return new TreeNode(inorder.get(0));
        }

        List<Integer> left = new ArrayList<>();
        List<Integer> right = new ArrayList<>();

        for (int pre:preorder) { // 循环是为了跳过preorder 数组中的已处理节点
            int i = inorder.indexOf(pre);
            if (i == -1) {
                continue;
            }
            for (int j = 0; j < i; j++) {
                left.add(inorder.get(j));
            }
            for (int j = i + 1; j < inorder.size(); j++) {
                right.add(inorder.get(j));
            }

            TreeNode root = new TreeNode(pre);
            root.left = build(preorder, left);
            root.right = build(preorder, right);
            return root;
        }

        return null;
    }

在测试样例中通过了，但是提交的时候，测例特别大时超时了。感觉时间主要用在了 inorder 数组的划分上面？？不清楚，明天看答案把。。。。

思路 2

查看了答案后发现，思路 1 中浪费时间和空间的部分应该有两部分：

1. 每次获得 root 之后，需要遍历 inorder 数组获得 root 的下标
2. 进入下一层递归的时候，需要再遍历一次 inorder 数组获取左右子树的节点

那么思路 2 就是提出了解决上述两个问题的方法：

1. 通过创建一个hashmap，key 和 value分别为节点值与下标，之后每次寻下标只需要 O(1)时间
2. 递归参数改用左下标和右下标来标记位置,省去了操作数组的麻烦

public class Solution2 {

    private Map<Integer, Integer> inorderMap = new HashMap<>();

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        prepare(preorder, inorder);
        return build(preorder, inorder, 0, preorder.length - 1, 0, inorder.length - 1);
    }

    public TreeNode build(int[] preorder, int[] inorder, int preLeft, int preRight, int inLeft, int inRight) {

        if (inLeft > inRight) return null;
        if (inLeft == inRight) return new TreeNode(inorder[inLeft]);

        int root = preorder[preLeft];
        TreeNode rootNode = new TreeNode(root);
        int rootIndex = inorderMap.get(root);
        int leftTreeLength = rootIndex - inLeft;
        rootNode.left = build(preorder, inorder, preLeft + 1, preLeft + leftTreeLength, inLeft, rootIndex - 1);
        rootNode.right = build(preorder, inorder, preLeft + leftTreeLength + 1, preRight, rootIndex + 1, inRight);

        return rootNode;

    }

    public void prepare(int[] preorder, int[] inorder) {
        int n = inorder.length;
        for (int i = 0; i < n; ++i) {
            inorderMap.put(inorder[i], i);
        }
    }
}

思路 3

思路 3 采用的是迭代的手法。感觉这种解法可拓展性较低，是根据前序中序输出结果进行反向分析得到的。这里直接附上链接，不详细说明。

主要思路是：

前序的顺序是根 -> 左 --> 右，中序的顺序是左 -> 根 --> 右
那么将前序不断入栈，当遇到与中序相同的节点时，代表左已经到尽头，下一个要插入右。因此将栈按与中序不同顺序一一对应不断弹出，找插入右节点的父节点。