三种遍历方式构造二叉树

105. 从前序与中序遍历序列构造二叉树

给定一棵树的前序遍历 preorder 与中序遍历 inorder。请构造二叉树并返回其根节点。

解题思路：

• 求出根结点的值 rootVal（前序遍历第一个）
• 求出根结点在中序遍历的位置rootIndex（预先存储在map中）
• 求出左子树的个数 leftNum = rootIndex - inStart
• 中序遍历中，左子树：[inStart, rootIndex - 1], 右子树：[rootIndex + 1, inEnd]
• 前序遍历中，左子树：[preStart + 1, preStart + leftNum]，右子树：[ preStart + leftNum + 1, preEnd]

代码实现：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    Map<Integer, Integer> map = new HashMap<>();
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder.length == 0) {
            return null;
        }
        for (int i = 0;i < inorder.length;i++) {
            map.put(inorder[i], i);
        }
        return build(preorder, 0, preorder.length, inorder, 0, inorder.length);
    }

    public TreeNode build(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd) {
        if (preStart == preEnd) {
            return null;
        }
        int rootVal = preorder[preStart];
        TreeNode root = new TreeNode(rootVal);
        int rootIndex = map.get(rootVal);
        int leftNum = rootIndex - inStart;
        root.left = build(preorder, preStart + 1, preStart + leftNum + 1, inorder, inStart, rootIndex);
        root.right = build(preorder, preStart + leftNum + 1, preEnd, inorder, rootIndex + 1, inEnd);
        return root;
    }
}

复杂度分析

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

106. 从中序与后序遍历序列构造二叉树

根据一棵树的中序遍历与后序遍历构造二叉树。

注意: 你可以假设树中没有重复的元素。

解题思路：

• 求出根结点的值 rootVal（后序遍历最后一个）
• 求出根结点在中序遍历的位置rootIndex（预先存储在map中）
• 求出左子树的个数 leftNum = rootIndex - inStart
• 中序遍历中，左子树：[inStart, rootIndex - 1], 右子树：[rootIndex+1, inEnd]
• 后序遍历中，左子树：[postStart + 1, postStart + leftNum - 1]，右子树：[ postStart + leftNum, postEnd - 1]

代码实现：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    Map<Integer, Integer> map = new HashMap<>();
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        if (inorder.length == 0 || postorder.length == 0) {
            return null;
        }
        for (int i = 0; i < inorder.length; i++) {
            map.put(inorder[i], i);
        }
        return build(inorder, 0, inorder.length - 1, postorder, 0, postorder.length - 1);
    }

    public TreeNode build(int[] inorder, int inStart, int inEnd, int[] postorder, int postStart, int postEnd) {
        if (inStart > inEnd || postStart > postEnd) {
            return null;
        }
        int rootVal = postorder[postEnd];
        TreeNode root = new TreeNode(rootVal);
        int rootIndex = map.get(rootVal);
        int leftNum = rootIndex - inStart;
        root.left = build(inorder, inStart, rootIndex - 1, postorder, postStart, postStart + leftNum - 1);
        root.right = build(inorder, rootIndex + 1, inEnd, postorder, postStart + leftNum, postEnd - 1);
        return root;
    }
}

复杂度分析

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

889. 根据前序和后序遍历构造二叉树

返回与给定的前序和后序遍历匹配的任何二叉树。

pre 和 post 遍历中的值是不同的正整数。

提示：

• 1 <= pre.length == post.length <= 30
• pre[] 和 post[] 都是 1, 2, …, pre.length 的排列
• 每个输入保证至少有一个答案。如果有多个答案，可以返回其中一个。

解题思路：

• 求出根结点的值 rootVal（前序遍历第一个）
• 求出左子树在后序遍历的最后一个结点位置leftIndex（预先存储在map中）
• 求出左子树的个数 leftNum = leftIndex- postStart + 1
• 前序遍历中，左子树：[preStart + 1, preStart + leftNum]，右子树：[ preStart + leftNum + 1, preEnd]
• 后序遍历中，左子树：[postStart + 1, postStart + leftNum - 1]，右子树：[ postStart + leftNum, postEnd - 1]

代码实现：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    Map<Integer, Integer> map = new HashMap<>();
    public TreeNode constructFromPrePost(int[] preorder, int[] postorder) {
        if (preorder.length == 0 || postorder.length == 0) {
            return null;
        }
        for (int i = 0; i < postorder.length; i++) {
            map.put(postorder[i], i);
        }
        return build(preorder, 0, preorder.length - 1, postorder, 0, postorder.length - 1);
    }

    public TreeNode build(int[] preorder, int preStart, int preEnd, int[] postorder, int postStart, int postEnd) {
        if (preStart > preEnd || postStart > postEnd) {
            return null;
        }
        int rootVal = preorder[preStart];
        TreeNode root = new TreeNode(rootVal);
         if(preStart == preEnd){
            return root;
        }
        int leftIndex = map.get(preorder[preStart + 1]);
        int leftNum = leftIndex - postStart + 1;
        root.left = build(preorder, preStart + 1, preStart + leftNum, postorder, postStart, leftIndex);
        root.right = build(preorder, preStart + leftNum + 1, preEnd, postorder, leftIndex + 1, preEnd);
        return root;
    }
}

复杂度分析

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