vlambda博客
学习文章列表

手把手刷二叉树 （二）

首先复习一下，写树的算法，关键思路是什么？

把题目的要求细化，搞清楚根节点应该做什么，然后剩下的事情抛给前/中/后序的遍历框架就行了，最重要的是不要跳进递归的细节，你以为你的脑袋可以压几个栈？

构造最大二叉树 LeetCode 654 Medium

题目：给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：

1. 二叉树的根式数组中的最大元素。

2. 左子树是通过数组中最大值的左边部分构造出的最大二叉树。

3. 右子树是通过数组中最大值的右边部分构造出的最大二叉树。

函数签名如下：

TreeNode constructMaxinumBinaryTree(int[] nums);

先明确根节点做什么？对于构造二叉树的问题，根节点要做的就是想办法把自己构造出来。

我们肯定要遍历数组找到最大值 maxVal ，把根节点 root 做出来，然后对 maxVal 左边的数组和右边的数组进行递归调用，作为 root 的左右子树。

假设输入的数组为 [3, 2, 1, 6, 0, 5] ，对于整个树的根节点来说，其实在做这件事：

TreeNode constructMaximumBinaryTree([3, 2, 1, 6, 0, 5]) {
    // 找到数组中的最大值
    TreeNode root  = new TreeNode(6);
    // 递归调用构造左右子树
    root.left = constructMaximumBinaryTree([3, 2, 1]);
    root.right = constructMaximumBinaryTree([0, 5]);
    return root;
}

再详细一点，就是如下伪码：

TreeNode constructMaximumBinaryTree(int[] nums) {
    if (num is empty) return null;
    int maxVal = Integer.MIN_VALUE;
    int index = 0;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] > maxVal) {
            maxVal = nums[i];
            index = i;
        }
    }
    
    TreeNode root = new TreeNode(maxVal);
    // 递归调用构造左右子树
    root.left = constructMaximumBinaryTree(nums[0..index-1]);
    root.right = constructMaximumBinaryTree(nums[index + 1..nums.length -1]);
    return root;
}

对于每个根节点，只需要找到当前 nums 中的最大值和对应的索引，然后递归调用左右数组构造左右子树即可。

明确了思路，我们可以重新写一个辅助函数 bulid ，来控制 nums 的索引：

/* 主函数 */
TreeNode constructMaximumBinaryTree(int[] nums) {
    return build(nums, 0, nums.length - 1);
}

/* 将nums[lo..hi] 构造成符合条件的树，返回根节点*/
TreeNode bulid(int[] nums, int lo, int hi) {
    // base case
    if (lo > hi) {
        return null;
    }
    
    // 找到数组中的最大值和对应的索引
    int index = -1, maxVal = Integer.MIN_VALUE;
    for (int i = lo; i <= hi; i++) {
        if (maxVal < nums[i]) {
            index = i;
            maxVal = nums[i];
        }
    }
    
    TreeNode root = new TreeNode(maxVal);
    // 左右递归调用构造左右子树
    root.left = build(nums, lo, index - 1);
    root.right = build(nums, index + 1, hi);
    
    return root;
}

这道题还算简单对吗？还有两道更困难的常见算法题：用前序/中序遍历结果还原二叉树，以及用后序/中序遍历结果还原二叉树。

通过前序和中序遍历结果构造二叉树 LeetCode 105  Medium

函数签名如下：

TreeNode buildTree(int[] preorder, int[] inorder);

废话不多说，直接思考，根节点应该做什么。

类似上一题，我们肯定要想办法确定根节点的值，把根节点做出来，然后递归调用左右子树即可。

我们首先回顾一下，前序遍历和中序遍历的结果有什么特点？

void traverse(TreeNode root) {
    // 前序遍历
    preorder.add(root.val);
    traverse(root.left);
    traverse(root.right);
}

void traverse(TreeNode root) {
    traverse(root.left);
    // 中序遍历
    inorder.add(root.val);
    traverse(root.right);
}

找到根节点是很简单的，前序遍历的第一个值 preorder[0] 就是根节点的值，关键在于如何通过根节点的值，将 preorder 和 poster 数组划分为两半，构造根节点的左右子树？

换句话说，对于以下代码中的 ? 部分应该填入什么：

/* 主函数 */
TreeNode buildTree(int[] preorder, int[] inorder) {
    return build(preoerder, 0, preorder.length - 1,
                inoder, 0, inorder.length - 1);
}

TreeNode build(int[] preorder, int preStart, int preEnd,
              int[] inorder, int inStart, int inEnd) {
    int rootVal = preorder[preStart];
    int index = 0;
    for (int i = inStart; i <= inEnd; i++) {
        if (inorder[i] == rootVal) {
            index = i;
            break;
        }
    }
    
    TreeNode root = new TreeNode(rootVal);
    root.left = build(preorder, ?, ?,
                     inorder, ?, ?);
    root.right = build(preorder, ?, ?,
                     inorder, ?, ?);
    return root;
}

对于左右子树对应的 inorder 数组的起始索引和终止索引比较容易确定：

    root.left = build(preorder, ?, ?,
                     inorder, inStart, index - 1);
    root.right = build(preorder, ?, ?,
                     inorder, index + 1, inEnd);

对于 preorder 数组呢？如何确定左右数组对应的起始索引和终止索引？

这个可以通过左子树的节点数推导出来，假设左子树的节点数为 leftSize ，那么 preorder 数组上的索引情况是这样：

    root.left = build(preorder, preStart + 1, preStart + leftSize,
                     inorder, inStart, index - 1);
    root.right = build(preorder, preStart + leftSize + 1, preEnd,
                     inorder, index + 1, inEnd);

至此，整个算法思路就完成了，再补全 base case 即可写出解法代码：

TreeNode build(int[] preorder, int preStart, int preEnd,
              int[] inorder, int inStart, int inEnd) {
    if (preSatrt > preEnd) {
        return null;
    }
    int rootVal = preorder[preStart];
    int index = 0;
    for (int i = inStart; i <= inEnd; i++) {
        if (inorder[i] == rootVal) {
            index = i;
            break;
        }
    }
    
    int leftSize = index - inStart;
    
    TreeNode root = new TreeNode(rootVal);
    root.left = build(preorder, preStart + 1, preStart + leftSize,
                     inorder, inStart, index - 1);
    root.right = build(preorder, preStart + leftSize + 1, preEnd,
                     inorder, index + 1, inEnd);
    return root;
}

主函数只需要调用 build 函数即可，看起来函数参数很多，写了很多代码，似乎比前一道题难很多，让人望而生畏，但是，实际上这些参数无非就是控制数组起止位置的，画个图就可以解决。

通过后序和中序遍历结果构造二叉树 LeetCode Medium

有了前一题的铺垫，很快就能写出完整的解法代码：

TreeNode build(int[] inorder, int inStart, int inEnd,
              int[] postorder, int postStart, int postEnd) {
    if (inStart > inEnd) {
        return null;
    }
    
    int rootVal = postorder[postEnd];
    int index = 0;
    for (int i = inStart; i < inEnd; i++) {
        if (inorder[i] == rootVal) {
            index = i;
            break;
        }
    }
    
    int leftSize = index - inStart;
    TreeNode root = new TreeNode(rootVal);
    root.left = build(inorder, inStart, index - 1,
                     postorder, postStart, postStart + leftSize - 1);
    root.right = build(inorder, index + 1, inEnd,
                      postorder, postStart + leftSize, postEnd - 1);
    return root;
}

最后呼应一下前文，做二叉树的问题，关键是把题目的要求细化，搞清楚根节点该做什么，然后剩下的事情抛给前/中/后序的遍历框架就行了。