前序和中序构造二叉树

题目链接：

涉及知识：二叉树的遍历

分析：

二叉树的前序遍历：根节点 —> 左子树 —> 右子树

二叉树的中序遍历：左子树 —> 根节点 —> 右子树

由此可知：前序遍历中访问到的第一个元素便是根节点，通过该点便可以将中序遍历分成左右两部分，左部分的元素用来生成该二叉树的左子树，右部分用来生成二叉树的右子树。

同样，左右两部分的元素中，首先在前序遍历中出现的便是该子树的根节点，很明显符合递归的定义。

代码如下：

/*
 * @lc app=leetcode.cn id=105 lang=java
 *
 * [105] 从前序与中序遍历序列构造二叉树
 */
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private int[] preorder;
    private int[] inorder;
    private int tag;  //指向下一个要找的根节点

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        this.preorder = preorder;
        this.inorder = inorder;
        this.tag = 0;

        return generateTree(0, preorder.length - 1);
    }

    //用中序 s 到 e 的元素生成二叉树，并返回根节点
    public TreeNode generateTree(int s, int e){
        if(s > e){
            return null;
        }

        TreeNode node = null;
        for(int i = s; i <= e; ++i){
            if(inorder[i] == preorder[tag]){
                node = new TreeNode(preorder[tag++]);
                
                //首先左半边元素生成左子树
                node.left = generateTree(s, i - 1);
                
                //再生成右子树
                node.right = generateTree(i + 1, e);
                break;
            }
        }

        return node;
    }
}

复杂度分析：

时间复杂度：

• 如果该树是一颗右单枝树的时候，树的高度为 n，在该种情况下，中序遍历和前序遍历相同，在 中序遍历中查找一个根节点的时间复杂度为O(1)，由于 n 个结点均被当做根节点返回，时间复杂度O(n)
• 如果该树是一棵相对比较平衡的二叉树的时候，T(n) = n/2 + 2*T(n/2)，由主定理得，时间复杂度为O(nlogn)
• 如果该树是一棵左单枝树的时候，从中序遍历中找根节点所花费的时间：T(n) = n + (n - 1) + ... + 2 + 1，时间复杂度为\(O(n^2)\)。

空间复杂度：空间复杂度与树的高度有关，最差的情况下为O(n)

优化：

可以使用 HashMap 存储中序遍历的下标和元素之间的对应关系，减少查询根节点所用的时间。

class Solution {
    private int[] preorder;
    private int[] inorder;
    private int tag;
    private HashMap<Integer, Integer> map = new HashMap<>();

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        this.preorder = preorder;
        this.inorder = inorder;
        this.tag = 0;

        //将中序遍历存入哈希表
        for(int i = 0; i < inorder.length; ++i){
            map.put(inorder[i], i);
        }

        return generateTree(0, preorder.length - 1);
    }

    //用中序的 s 到 e 生成二叉树，并返回根节点
    public TreeNode generateTree(int s, int e){
        if(s > e){
            return null;
        }

        int index = map.get(preorder[tag]);
        TreeNode node = new TreeNode(preorder[tag++]);
        node.left = generateTree(s, index - 1);
        node.right = generateTree(index + 1, e);

        return node;
    }
}

复杂度分析：

时间复杂度：简单理解，每一个元素均作为根节点被返回一次，花费O(n)，查询根节点的时间复杂度为O(1)，因此总的时间复杂度为O(n)；或者使用上述的主定理计算。

空间复杂度：主要为递归栈的消耗和哈希表存图，各自均为O(n)，总的空间复杂度为O(n)