乐趣区

关于算法:东哥手把手带你刷二叉树第二期

jiezi

读完本文，你不仅学会了算法套路，还能够顺便去 LeetCode 上拿下如下题目：

654. 最大二叉树

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

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

———–

上篇文章 手把手教你刷二叉树（第一篇）连刷了三道二叉树题目，很多读者直呼外行。其实二叉树相干的算法真的不难，本文再来三道，手把手带你看看树的算法到底怎么做。

先来温习一下，咱们说过写树的算法，要害思路如下：

把题目的要求细化，搞清楚根节点应该做什么，而后剩下的事件抛给前 / 中 / 后序的遍历框架就行了，咱们千万不要跳进递归的细节里，你的脑袋能力压几个栈呀。

兴许你还不太了解这句话，咱们上面来看例子。

结构最大二叉树

先来道简略的，这是力扣第 654 题，题目如下：

函数签名如下：

TreeNode constructMaximumBinaryTree(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 (nums 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 中的最大值和对应的索引，而后递归调用左右数组结构左右子树即可。

明确了思路，咱们能够从新写一个辅助函数 build，来管制 nums 的索引：

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

/* 将 nums[lo..hi] 结构成符合条件的树，返回根节点 */
TreeNode build(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;
}

至此，这道题就做完了，还是挺简略的对吧，上面看两道更艰难一些的。

通过前序和中序遍历后果结构二叉树

经典问题了，面试 / 口试中常考，力扣第 105 题就是这个问题：

函数签名如下：

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 和 inorder 数组中的元素散布有如下特点：

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

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

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

/* 
   若前序遍历数组为 preorder[preStart..preEnd]，后续遍历数组为 postorder[postStart..postEnd]，结构二叉树，返回该二叉树的根节点 
*/
TreeNode build(int[] preorder, int preStart, int preEnd, 
               int[] inorder, int inStart, int inEnd) {
    // root 节点对应的值就是前序遍历数组的第一个元素
    int rootVal = preorder[preStart];
    // rootVal 在中序遍历数组中的索引
    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;
}

对于代码中的 rootVal 和 index 变量，就是下图这种状况：

当初咱们来看图做填空题，上面这几个问号处应该填什么：

root.left = build(preorder, ?, ?,
                  inorder, ?, ?);

root.right = build(preorder, ?, ?,
                   inorder, ?, ?);

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

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

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

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

这个能够通过左子树的节点数推导进去，假如左子树的节点数为 leftSize，那么 preorder 数组上的索引状况是这样的：

看着这个图就能够把 preorder 对应的索引写进去了：

int leftSize = index - inStart;

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 (preStart > preEnd) {return null;}

    // root 节点对应的值就是前序遍历数组的第一个元素
    int rootVal = preorder[preStart];
    // rootVal 在中序遍历数组中的索引
    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 函数即可，你看着函数这么多参数，解法这么多代码，仿佛比咱们下面讲的那道题难很多，让人望而却步，实际上呢，这些参数无非就是管制数组起止地位的，画个图就能解决了。

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

相似上一题，这次咱们利用 后序 和中序 遍历的后果数组来还原二叉树，这是力扣第 106 题：

函数签名如下：

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

相似的，看下后序和中序遍历的特点：

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

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

这样的遍历程序差别，导致了 preorder 和 inorder 数组中的元素散布有如下特点：

这道题和上一题的要害区别是，后序遍历和前序遍历相同，根节点对应的值为 postorder 的最初一个元素。

整体的算法框架和上一题十分相似，咱们仍然写一个辅助函数 build：

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

TreeNode build(int[] inorder, int inStart, int inEnd,
               int[] postorder, int postStart, int postEnd) {
    // root 节点对应的值就是后序遍历数组的最初一个元素
    int rootVal = postorder[postEnd];
    // rootVal 在中序遍历数组中的索引
    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;
}

当初 postoder 和 inorder 对应的状态如下：

咱们能够依照上图将问号处的索引正确填入：

int leftSize = index - inStart;

root.left = build(inorder, inStart, index - 1,
                  postorder, postStart, postStart + leftSize - 1);

root.right = build(inorder, index + 1, inEnd,
                   postorder, postStart + leftSize, postEnd - 1);

综上，能够写出残缺的解法代码：

TreeNode build(int[] inorder, int inStart, int inEnd,
               int[] postorder, int postStart, int postEnd) {if (inStart > inEnd) {return null;}
    // root 节点对应的值就是后序遍历数组的最初一个元素
    int rootVal = postorder[postEnd];
    // rootVal 在中序遍历数组中的索引
    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;
}

有了前一题的铺垫，这道题很快就解决了，无非就是 rootVal 变成了最初一个元素，再改改递归函数的参数而已，只有明确二叉树的个性，也不难写进去。

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

当初你是否明确其中的玄妙了呢？

退出移动版