代码随想录算法训练营第十七天打卡

 654.最大二叉树

代码如下：

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) { //递归法，递归顺序是：中左右（前序遍历）
        TreeNode* node = new TreeNode(0);
        if (nums.size() == 1) { //如果数组中只有一个数字了，也就是说遍历到叶子节点了，直接返回该节点
            node->val = nums[0];
            return node;
        }
        int maxValue = 0;
        int maxIndex = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > maxValue) {
                maxValue = nums[i];
                maxIndex = i;
            }
        }
        node->val = maxValue;
        if (maxIndex > 0) {
            vector<int> temp(nums.begin(), nums.begin() + maxIndex);
            node->left = constructMaximumBinaryTree(temp);
        }
        if (maxIndex < nums.size() - 1) {
            vector<int> temp(nums.begin() + maxIndex + 1, nums.end());
            node->right = constructMaximumBinaryTree(temp);
        }
        return node;
    }
};

617.合并二叉树 

代码如下：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (root1 == nullptr) {
            return root2;
        }
        if (root2 == nullptr) {
            return root1;
        }
        root1->val += root2->val; //中
        root1->left = mergeTrees(root1->left, root2->left); //左
        root1->right = mergeTrees(root1->right, root2->right); //右
        return root1;
    }
};

700.二叉搜索树中的搜索

代码如下：

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) { //方法二：递归法
        if (root == nullptr || root->val == val) { // 终止条件：找到目标节点或者当前节点为空
            return root;
        }

        // 在左子树中递归搜索
        TreeNode* leftResult = searchBST(root->left, val);
        if (leftResult) {
            return leftResult; // 如果在左子树中找到目标节点，直接返回结果
        }

        // 如果左子树中没有找到目标节点，再在右子树中递归搜索
        return searchBST(root->right, val);
    }
};

 98.验证二叉搜索树 

代码如下：

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) { //方法一：迭代法
        if (root == nullptr) {
            return nullptr;
        }
        queue<TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            int size = q.size();
            for (int i = 0; i < size; i++) {
                TreeNode* curr = q.front();
                q.pop();
                if (curr->val == val) {
                    return curr;
                } 
                if (curr->left) {
                    q.push(curr->left);
                }
                if (curr->right) {
                    q.push(curr->right);
                }
            }
        }
        return nullptr;
    }
};

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) { //方法二：递归法
        if (root == nullptr || root->val == val) { // 终止条件：找到目标节点或者当前节点为空
            return root;
        }
        // 在左子树中递归搜索
        TreeNode* leftResult = searchBST(root->left, val);
        if (leftResult) {
            return leftResult; // 如果在左子树中找到目标节点，直接返回结果
        }
        // 如果左子树中没有找到目标节点，再在右子树中递归搜索
        return searchBST(root->right, val);
    }
};

今毕。