654.最大二叉树 

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

1. 创建一个根节点，其值为 nums 中的最大值。
2. 递归地在最大值 左边 的 子数组前缀上 构建左子树。
3. 递归地在最大值 右边 的 子数组后缀上 构建右子树。

返回 nums 构建的 最大二叉树 。

解释：递归调用如下所示：
- [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。- [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。- 空数组，无子节点。- [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。- 空数组，无子节点。- 只有一个元素，所以子节点是一个值为 1 的节点。- [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。- 只有一个元素，所以子节点是一个值为 0 的节点。- 空数组，无子节点。

思路

最大二叉树的构建过程如下：

构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树。

• 确定递归函数的参数和返回值

参数传入的是存放元素的数组，返回该数组构造的二叉树的头结点，返回类型是指向节点的指针。

代码如下：

TreeNode* constructMaximumBinaryTree(vector<int>& nums)

• 确定终止条件

题目中说了输入的数组大小一定是大于等于1的，所以我们不用考虑小于1的情况，那么当递归遍历的时候，如果传入的数组大小为1，说明遍历到了叶子节点了。

那么应该定义一个新的节点，并把这个数组的数值赋给新的节点，然后返回这个节点。 这表示一个数组大小是1的时候，构造了一个新的节点，并返回。

代码如下：

TreeNode* node = new TreeNode(0);
if (nums.size() == 1) {node->val = nums[0];return node;
}

• 确定单层递归的逻辑（主要有三步工作）

1. 先要找到数组中最大的值和对应的下标， 最大的值构造根节点，下标用来下一步分割数组
2. 最大值所在的下标左区间 构造左子树，这里要判断maxValueIndex > 0，因为要保证左区间至少有一个数值。
3. 最大值所在的下标右区间 构造右子树，判断maxValueIndex < (nums.size() - 1)，确保右区间至少有一个数值。

class Solution {public TreeNode constructMaximumBinaryTree(int[] nums) {return traversal(nums,0,nums.length);}public TreeNode traversal(int[] nums,int leftIndex,int rightIndex){if(rightIndex - leftIndex < 1) //没有元素了return null;if(rightIndex - leftIndex == 1) //只有一个元素return new TreeNode(nums[leftIndex]);int maxIndex = leftIndex; //假定最大值索引maxIndex所在位置为最左边int maxVal = nums[maxIndex]; //最大值for(int i = leftIndex + 1; i < rightIndex; i++){if(nums[i] > maxVal){ //如果有更大的，交换两值和对应下标maxVal = nums[i];maxIndex = i;}}TreeNode root = new TreeNode(maxVal);//根据maxIndex递归的划分左右子树root.left = traversal(nums,leftIndex,maxIndex);root.right = traversal(nums,maxIndex + 1,rightIndex);return root;}
}

总结

这道题目其实和 二叉树：构造二叉树登场！ (opens new window)是一个思路，比二叉树：构造二叉树登场！ (opens new window)还简单一些。

注意类似用数组构造二叉树的题目，每次分隔尽量不要定义新的数组，而是通过下标索引直接在原数组上操作，这样可以节约时间和空间上的开销。

一些同学也会疑惑，什么时候递归函数前面加if，什么时候不加if，这个问题我在最后也给出了解释。

其实就是不同代码风格的实现，一般情况来说：如果让空节点（空指针）进入递归，就不加if，如果不让空节点进入递归，就加if限制一下， 终止条件也会相应的调整。

617.合并二叉树

给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

思路

相信这道题目很多同学疑惑的点是如何同时遍历两个二叉树呢？

其实和遍历一个树逻辑是一样的，只不过传入两个树的节点，同时操作。

#递归

二叉树使用递归，就要想使用前中后哪种遍历方式？

本题使用哪种遍历都是可以的！

我们下面以前序遍历为例。

那么我们来按照递归三部曲来解决：

1. 确定递归函数的参数和返回值：

首先要合入两个二叉树，那么参数至少是要传入两个二叉树的根节点，返回值就是合并之后二叉树的根节点。

TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {

        2.确定终止条件：

因为是传入了两个树，那么就有两个树遍历的节点t1 和 t2，如果t1 == NULL 了，两个树合并就应该是 t2 了（如果t2也为NULL也无所谓，合并之后就是NULL）。

反过来如果t2 == NULL，那么两个数合并就是t1（如果t1也为NULL也无所谓，合并之后就是NULL）。

if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2
if (t2 == NULL) return t1; // 如果t2为空，合并之后就应该是t1

        3.确定单层递归的逻辑：

单层递归的逻辑就比较好写了，这里我们重复利用一下t1这个树，t1就是合并之后树的根节点（就是修改了原来树的结构）。

那么单层递归中，就要把两棵树的元素加到一起。

t1->val += t2->val;

接下来t1 的左子树是：合并 t1左子树 t2左子树之后的左子树。

t1 的右子树：是 合并 t1右子树 t2右子树之后的右子树。

最终t1就是合并之后的根节点。

t1->left = mergeTrees(t1->left, t2->left);
t1->right = mergeTrees(t1->right, t2->right);
return t1;

最终代码如下：（Java版本）

class Solution {public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {//递归法，前序遍历//首先判断，若其中一个根节点为空，则返回另一个根节点if(root1 == null) return root2;if(root2 == null) return root1;//将两个根节点的值相加root1.val += root2.val;  //中//递归地合并左子树和右子树root1.left = mergeTrees(root1.left,root2.left);  //左root1.right = mergeTrees(root1.right,root2.right); //右return root1; // 返回合并后的根节点}
}

        root1.val += root2.val;  //中//递归地合并左子树和右子树root1.left = mergeTrees(root1.left,root2.left);  //左root1.right = mergeTrees(root1.right,root2.right); //右

可以改变 root1.val += root2.val;  //中 的顺序，

就改为中序 遍历 （左中右）和后序遍历 （左右中）了。

700.二叉搜索树中的搜索

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

 思路

之前我们讲的都是普通二叉树，那么接下来看看二叉搜索树。

在关于二叉树，你该了解这些！ (opens new window)中，我们已经讲过了二叉搜索树。

【二叉搜索树】是一个有序树：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉搜索树

这就决定了，二叉搜索树，递归遍历和迭代遍历和普通二叉树都不一样。

本题，其实就是在二叉搜索树中搜索一个节点。那么我们来看看应该如何遍历。

递归法

1. 确定递归函数的参数和返回值

递归函数的参数传入的就是根节点和要搜索的数值，返回的就是以这个搜索数值所在的节点。

TreeNode* searchBST(TreeNode* root, int val)

        2.确定终止条件

如果root为空，或者找到这个数值了，就返回root节点。

if (root == NULL || root->val == val) return root;

        3.确定单层递归的逻辑

看看二叉搜索树的单层递归逻辑有何不同。

因为二叉搜索树的节点是有序的，所以可以有方向的去搜索。

如果root->val > val，搜索左子树，如果root->val < val，就搜索右子树，最后如果都没有搜索到，就返回NULL。

TreeNode* result = NULL;
if (root->val > val) result = searchBST(root->left, val);
if (root->val < val) result = searchBST(root->right, val);
return result;

很多人写递归函数的时候 习惯直接写 searchBST(root->left, val)，却忘了递归函数还有返回值。

递归函数的返回值是什么? 是 左子树如果搜索到了val，要将该节点返回。 如果不用一个变量将其接住，那么返回值不就没了。

所以要 result = searchBST(root->left, val)。

 // 递归法，针对普通二叉树

class Solution {public TreeNode searchBST(TreeNode root, int val) {// 递归法，针对普通二叉树，递归搜索二叉搜索树中值为 val 的节点// 若根节点为空或者根节点的值等于目标值 val，则直接返回根节点if(root == null || root.val == val) return root;// 递归搜索左子树，如果找到了目标节点，则直接返回TreeNode left = searchBST(root.left,val);if(left != null) return left;// 若左子树中未找到目标节点，则递归搜索右子树TreeNode right = searchBST(root.right,val);return right;}
}

if (left != null) return left; 的意思是如果在左子树中找到了目标值为 val 的节点，则直接返回该节点。

why？：这是因为如果 left 不为空，意味着在 root.left 的子树中找到了目标值为 val 的节点。因为递归调用 searchBST(root.left, val) 返回的是以 root.left 为根节点的子树中找到的目标节点，如果它不为空，就表示在左子树中找到了目标值为 val 的节点。

这行代码的逻辑是，如果在递归搜索左子树的过程中找到了目标节点，则将该节点返回，整个搜索过程终止，不再继续搜索右子树。这是因为在普通二叉树中，一个节点只会有一个父节点，所以如果目标节点存在于左子树中，就不可能存在于右子树中。

 //递归法，利用二叉搜索树特点，优化

class Solution {public TreeNode searchBST(TreeNode root, int val) {// 递归，利用二叉搜索树特点，优化if(root == null || root.val == val) return root;if(val < root.val){ // 若目标值 val 小于根节点的值，则在左子树中继续搜索return searchBST(root.left,val);}else{ // 否则，在右子树中继续搜索return searchBST(root.right,val);}}
}

• 这段代码利用了二叉搜索树的特点，即左子树中的节点值都小于根节点的值，右子树中的节点值都大于根节点的值。所以在搜索过程中，可以根据目标值 val 与当前节点值的大小关系，来决定是继续在左子树中搜索还是在右子树中搜索。
• 如果目标值 val 小于当前节点值，则递归地在左子树中搜索；如果目标值 val 大于当前节点值，则递归地在右子树中搜索。直到找到目标值为止，或者搜索到叶子节点时返回空节点表示未找到。

98.验证二叉搜索树 

题目：给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

• 节点的左子树只包含 小于 当前节点的数。
• 节点的右子树只包含 大于 当前节点的数。
• 所有左子树和右子树自身必须也是二叉搜索树。

 思路

• 要知道在中序遍历下，输出的二叉搜索树节点的数值是有序序列。

有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。

递归法

可以递归中序遍历将二叉搜索树转变成一个数组，代码如下：

vector<int> vec;
void traversal(TreeNode* root) {if (root == NULL) return;traversal(root->left);vec.push_back(root->val); // 将二叉搜索树转换为有序数组traversal(root->right);
}

然后只要比较一下，这个数组是否是有序的，注意二叉搜索树中不能有重复元素。

traversal(root);
for (int i = 1; i < vec.size(); i++) {// 注意要小于等于，搜索树里不能有相同元素if (vec[i] <= vec[i - 1]) return false;
}
return true;

以上代码中，我们把二叉树转变为数组来判断，是最直观的，但其实不用转变成数组，可以在递归遍历的过程中直接判断是否有序。

这道题目比较容易陷入两个陷阱：

• 陷阱1

不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。

写出了类似这样的代码：

if (root->val > root->left->val && root->val < root->right->val) {return true;
} else {return false;
}

 我们要比较的是 左子树所有节点小于中间节点，右子树所有节点大于中间节点。所以以上代码的判断逻辑是错误的。

• 陷阱2

样例中最小节点 可能是int的最小值，如果这样使用最小的int来比较也是不行的。

此时可以初始化比较元素为longlong的最小值。

问题可以进一步演进：如果样例中根节点的val 可能是longlong的最小值 又要怎么办呢？文中会解答。

了解这些陷阱之后我们来看一下代码应该怎么写：

递归三部曲：

• 确定递归函数，返回值以及参数

要定义一个longlong的全局变量，用来比较遍历的节点是否有序，因为后台测试数据中有int最小值，所以定义为longlong的类型，初始化为longlong最小值。

注意递归函数要有bool类型的返回值， 我们在二叉树：递归函数究竟什么时候需要返回值，什么时候不要返回值？ (opens new window)中讲了，只有寻找某一条边（或者一个节点）的时候，递归函数会有bool类型的返回值。

其实本题是同样的道理，我们在寻找一个不符合条件的节点，如果没有找到这个节点就遍历整个树，如果找到不符合的节点了，立刻返回。

代码如下：

long long maxVal = LONG_MIN; // 因为后台测试数据中有int最小值
bool isValidBST(TreeNode* root)

• 确定终止条件

如果是空节点 是不是二叉搜索树呢？

是的，二叉搜索树也可以为空！

if (root == NULL) return true;

• 确定单层递归的逻辑

中序遍历，一直更新maxVal，一旦发现maxVal >= root->val，就返回false，注意元素相同时候也要返回false。

bool left = isValidBST(root->left);         // 左// 中序遍历，验证遍历的元素是不是从小到大
if (maxVal < root->val) maxVal = root->val; // 中
else return false;bool right = isValidBST(root->right);       // 右
return left && right;

整体代码如下：（C++版本）

class Solution {
public:long long maxVal = LONG_MIN; // 因为后台测试数据中有int最小值bool isValidBST(TreeNode* root) {if (root == NULL) return true;bool left = isValidBST(root->left);// 中序遍历，验证遍历的元素是不是从小到大if (maxVal < root->val) maxVal = root->val;else return false;bool right = isValidBST(root->right);return left && right;}
};

以上代码是因为后台数据有int最小值测试用例，所以都把maxVal改成了longlong最小值。

如果测试数据中有 longlong的最小值，怎么办？

不可能在初始化一个更小的值了吧。 建议避免 初始化最小值，如下方法取到最左面节点的数值来比较。 代码如下：

class Solution {
public:TreeNode* pre = NULL; // 用来记录前一个节点bool isValidBST(TreeNode* root) {if (root == NULL) return true;bool left = isValidBST(root->left);if (pre != NULL && pre->val >= root->val) return false;pre = root; // 记录前一个节点bool right = isValidBST(root->right);return left && right;}
};

最后这份代码看上去整洁一些，思路也清晰。

 综上所述，java版本：

class Solution {// 声明一个全局变量 pre，用于记录当前节点的前驱节点TreeNode pre;//递归函数，用于检查一颗二叉树是否是二叉搜索树，中序遍历（中 左 右）public boolean isValidBST(TreeNode root) {//若根节点为空，则返回trueif(root == null) return true; //递归检查 左子树boolean left = isValidBST(root.left);//若左子树不是二叉搜索树，（递归函数返回的是false复制给left），则直接返回falseif(!left) return false;//检查当前节点是否满足BST的性质（若前一个节点值不为空且>=当前节点值）if(pre != null && pre.val >= root.val) return false;pre =  root; //否则，更新pre为当前节点，即前驱节点//递归检查 右子树 boolean right = isValidBST(root.right);return right;//返回右子树是否是二叉搜索树的结果}
}

这段代码使用了中序遍历的思想，递归地检查每个节点是否符合二叉搜索树的性质。首先检查左子树，然后检查当前节点，如果当前节点小于等于前驱节点的值，则不满足 BST 的性质，返回 false。最后，检查右子树，如果左子树、当前节点、右子树都符合 BST 的性质，则返回 true。

注意开篇提到的：

要知道在中序遍历下，输出的二叉搜索树节点的数值是有序序列。

有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。

// 简洁实现·中序遍历
class Solution {private long prev = Long.MIN_VALUE;public boolean isValidBST(TreeNode root) {if (root == null) {return true;}if (!isValidBST(root.left)) {return false;}if (root.val <= prev) { // 不满足二叉搜索树条件return false;}prev = root.val;return isValidBST(root.right);}
}