【刷题1】LeetCode 105. 从前序与中序遍历序列构造二叉树 java题解

n刷：自己写出来了！开心开心开心
剑指Offer里也有盒盒盒，剑指 Offer 07 重建二叉树java题解，我莫得脑子

题目

方法一：递归

class Solution {
    HashMap<Integer,Integer> map=new HashMap<>();//<数值，位置>
    int len1,len2;
    int[] preorder,inorder;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
    /*
    根据前序序列，找到在中序序列的位置，在中序序列中划分左子树和右子树
    */
        this.preorder=preorder;
        this.inorder=inorder;
        len1=preorder.length;
        len2=inorder.length;
        for(int i=0;i<len2;i++){
            map.put(inorder[i],i);
        }
        return build(0,0,len2-1);
    }
    //根节点，中序序列左端，中序序列右端
    public TreeNode build(int pre_index,int start,int end){
        if(start>end){
            return null;
        }
        if(pre_index>=len1)
            return null;
        TreeNode root=new TreeNode(preorder[pre_index]);//构建根节点
        int in_index=map.get(preorder[pre_index]);
        root.left=build(pre_index+1,start,in_index-1);
        root.right=build(pre_index+in_index-1-start+1+1,in_index+1,end);
        return root;
    }
}

代码

class Solution {
    int[] preorder;
    HashMap<Integer, Integer> dic = new HashMap<>();
    public TreeNode buildTree(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);
    }
    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;                                           // 回溯返回根节点
    }
}

复杂度

时间复杂度：O(n)，其中 n 是树中的节点个数。

空间复杂度：O(n)，除去返回的答案需要的 O(n) 空间之外，我们还需要使用O(n) 的空间存储哈希映射，以及 O(h)（其中 h是树的高度）的空间表示递归时栈空间。这里 h < n，所以总空间复杂度为 O(n)。

结果

方法二：迭代

我还不懂

分析

对于前序遍历的任意两个连续节点a和b，根据前序遍历的流程，我们可以知道a和b只有两种可能的关系：
1.b是a的左儿子。因为在遍历到a之后，下一个遍历的节点就是a的左儿子，即b。
2.a没有左儿子，并且b是a的某个祖先节点（或者a本身）的右儿子。如果a没有左儿子，那么下一个遍历的节点就是a的右儿子。如果a没有右儿子，我们就会向上回溯，直到遇到第一个有右儿子（且a不在它的右儿子的子树中）的节点aa，那么a就是aa的右儿子。

我们用一个栈和一个指针辅助进行二叉树的构造。初始时栈中存放了根节点（前序遍历的第一个节点），指针指向中序遍历的第一个节点；
我们依次枚举前序遍历中除了第一个节点以外的每个节点。如果 index 恰好指向栈顶节点，那么我们不断地弹出栈顶节点并向右移动 index，并将当前节点作为最后一个弹出的节点的右儿子；如果 index 和栈顶节点不同，我们将当前节点作为栈顶节点的左儿子；
无论是哪一种情况，我们最后都将当前的节点入栈。

复杂度

时间复杂度：O(n)，其中 n 是树中的节点个数。

空间复杂度：O(n)，除去返回的答案需要的 O(n) 空间之外，我们还需要使用 O(h)（其中 h 是树的高度）的空间存储栈。这里 h < n，所以（在最坏情况下）总空间复杂度为 O(n)。

代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder==null||preorder.length==0)
            return null;
        Deque<TreeNode> stack=new LinkedList<TreeNode>();
        TreeNode root=new TreeNode(preorder[0]);
        stack.push(root);
        int inorderIndex=0;
        for(int i=1;i<preorder.length;i++){
            int preVal=preorder[i];
            TreeNode node1=stack.peek();
            if(node1.val!=inorder[inorderIndex]){
                node1.left=new TreeNode(preVal);
                stack.push(node1.left);
            }
            else{
                while(!stack.isEmpty()&&stack.peek().val==inorder[inorderIndex]){
                    node1=stack.pop();
                    inorderIndex++;
                }
                node1.right=new TreeNode(preVal);
                stack.push(node1.right);
            }
        }
        return root;
    }
}

结果