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

最新推荐文章于 2025-12-05 10:55:08 发布

原创最新推荐文章于 2025-12-05 10:55:08 发布 · 703 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构

代码随想录算法训练营专栏收录该内容

50 篇文章

订阅专栏

654.最大二叉树

题目链接：最大二叉树

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

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

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

解题思想：

构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树。
在这里插入图片描述

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if (nums.size() == 0)
            return NULL;
        if (nums.size() == 1)
            return new TreeNode(nums[0]);
        int index;
        int max = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > max) {
                max = nums[i];
                index = i;
            }
        }
        TreeNode* root = new TreeNode(max);
        vector<int> leftNums(nums.begin(), nums.begin() + index);
        vector<int> rightNums(nums.begin() + index + 1, nums.end());
        root->left = constructMaximumBinaryTree(leftNums);
        root->right = constructMaximumBinaryTree(rightNums);
        return root;
    }
};

以上代码比较冗余，效率也不高，每次还要切割的时候每次都要定义新的vector（也就是数组），但逻辑比较清晰。上面代码优化思路，就是每次分隔不用定义新的数组，而是通过下标索引直接在原数组上操作。

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums, 0, nums.size());
    }

private:
    TreeNode* traversal(vector<int>& nums, int left, int right) {
        if (left >= right)
            return NULL;
        TreeNode* root = new TreeNode(0);
        if (right - left == 1) {
            root->val = nums[left];
            return root;
        }
        int index = left;
        for (int i = left + 1; i < right; i++) {
            if (nums[i] > nums[index])
                index = i;
        }
        root->val = nums[index];
        root->left = traversal(nums, left, index);
        root->right = traversal(nums, index + 1, right);
        return root;
    }
};

617.合并二叉树

题目链接：合并二叉树

题目描述给你两棵二叉树： root1 和 root2 。

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

返回合并后的二叉树。

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

递归法：

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的左/右节点为空，root2的左/右节点不为空，就赋值过去。

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (root1 == NULL)
            return root2;
        if (root2 == NULL)
            return root1;
        queue<TreeNode*> que;
        que.push(root1);
        que.push(root2);
        while (!que.empty()) {
            TreeNode* tree1 = que.front();
            que.pop();
            TreeNode* tree2 = que.front();
            que.pop();
            tree1->val += tree2->val;
            if (tree1->left != NULL && tree2->left != NULL) {
                que.push(tree1->left);
                que.push(tree2->left);
            }
            if (tree1->right != NULL && tree2->right != NULL) {
                que.push(tree1->right);
                que.push(tree2->right);
            }
            if (tree1->left == NULL && tree2->left != NULL) {
                tree1->left = tree2->left;
            }
            if (tree1->right == NULL && tree2->right != NULL) {
                tree1->right = tree2->right;
            }
        }
        return root1;
    }
};

700.二叉搜索树中的搜索

题目链接：二叉搜索树中的搜索

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

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

解题思路：

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

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

递归法：

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if (root == NULL || root->val == val) return root;
        TreeNode* result = NULL;
        if (root->val > val) result = searchBST(root->left, val);
        if (root->val < val) result = searchBST(root->right, val);
        return result;
    }
};

迭代法：

对于二叉搜索树，不需要回溯的过程，因为节点的有序性就帮我们确定了搜索的方向。

例如要搜索元素为3的节点，**我们不需要搜索其他节点，也不需要做回溯，查找的路径已经规划好了。**中间节点如果大于3就向左走，如果小于3就向右走，如图：

!https://code-thinking-1253855093.file.myqcloud.com/pics/20200812190213280.png

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        while (root != NULL) {
            if (root->val < val)
                root = root->right;
            else if (root->val > val)
                root = root->left;
            else
                return root;
        }
        return NULL;
    }
};

98.验证二叉搜索树

题目链接：验证二叉搜索树

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

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

节点的左只包含小于当前节点的数。

子树

节点的右子树只包含大于当前节点的数。

所有左子树和右子树自身必须也是二叉搜索树。

解题思路：

这里主要用到了二叉搜索树的性质，即中序遍历是单调递增的。这里注意一个树每个节点的左节点都小于该节点，右节点都大于该节点并不能说明这个树是二叉搜索树。
例如： [10,5,15,null,null,6,20] 这个case：
在这里插入图片描述

节点10大于左节点5，小于右节点15，但右子树里出现了一个6 这就不符合了！

递归法：

最直接的一种递归法就是中序遍历一遍二叉树，将数组保存在数组中，再判断数组是否单调递增。

class Solution {
private:
    vector<int> vec;
    void traversal(TreeNode* root) {
        if (root == NULL) return;
        traversal(root->left);
        vec.push_back(root->val); // 将二叉搜索树转换为有序数组
        traversal(root->right);
    }
public:
    bool isValidBST(TreeNode* root) {
        vec.clear(); // 不加这句在leetcode上也可以过，但最好加上
        traversal(root);
        for (int i = 1; i < vec.size(); i++) {
            // 注意要小于等于，搜索树里不能有相同元素
            if (vec[i] <= vec[i - 1]) return false;
        }
        return true;
    }
};

也可以不转化为数组，而在遍历的过程中使用双指针，比较当前遍历的节点和前一个节点的值。

class Solution {
public:
    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;
    }

private:
    TreeNode* pre = NULL;
};

迭代法：

使用迭代法的中序遍历，比较的逻辑和递归法一样。

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) {
                st.push(cur);
                cur = cur->left;
            } else {
                cur = st.top();
                st.pop();
                if (pre != NULL && pre->val >= cur->val)
                    return false;
                pre = cur;
                cur = cur->right;
            }
        }
        return true;
    }
};