代码随想录算法训练营day19||二叉树part06、654.最大二叉树 ● 617.合并二叉树 ● 700.二叉搜索树中的搜索 ● 98.验证二叉搜索树

轻舟未过万重山ing

已于 2024-02-22 21:36:39 修改

阅读量870

点赞数 18

分类专栏：代码随想录文章标签：算法数据结构

于 2024-02-22 21:31:29 首次发布

本文链接：https://blog.csdn.net/qq_40222433/article/details/136236741

版权

代码随想录专栏收录该内容

29 篇文章 0 订阅

订阅专栏

654.最大二叉树

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

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

返回 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;
}

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

先要找到数组中最大的值和对应的下标，最大的值构造根节点，下标用来下一步分割数组
最大值所在的下标左区间构造左子树，这里要判断maxValueIndex > 0，因为要保证左区间至少有一个数值。
最大值所在的下标右区间构造右子树，判断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 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

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

思路

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

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

#递归

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

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

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

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

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

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

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)中，我们已经讲过了二叉搜索树。

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

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

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

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

递归法

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

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

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) {
        //若根节点为空，则返回true
        if(root == null) return true; 

        //递归检查 左子树
        boolean left = isValidBST(root.left);
        //若左子树不是二叉搜索树，（递归函数返回的是false复制给left），则直接返回false
        if(!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);
    }
}

轻舟未过万重山ing

关注

18
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营day19||二叉树part06、654.最大二叉树 ● 617.合并二叉树 ● 700.二叉搜索树中的搜索 ● 98.验证二叉搜索树

这道题目其实和二叉树：构造二叉树登场！是一个思路，比二叉树：构造二叉树登场！还简单一些。注意类似用数组构造二叉树的题目，每次分隔尽量不要定义新的数组，而是通过下标索引直接在原数组上操作，这样可以节约时间和空间上的开销。一些同学也会疑惑，什么时候递归函数前面加if，什么时候不加if，这个问题我在最后也给出了解释。其实就是不同代码风格的实现，一般情况来说：如果让空节点（空指针）进入递归，就不加if，如果不让空节点进入递归，就加if限制一下，终止条件也会相应的调整。
复制链接

扫一扫