共计 5978 个字符，预计需要花费 15 分钟才能阅读完成。
读完本文，你不仅学会了算法套路，还能够顺便去 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 变成了最初一个元素，再改改递归函数的参数而已，只有明确二叉树的个性，也不难写进去。
最初响应下前文，做二叉树的问题，要害是把题目的要求细化，搞清楚根节点应该做什么，而后剩下的事件抛给前 / 中 / 后序的遍历框架就行了。
当初你是否明确其中的玄妙了呢？