代码随想录算法训练营第十七天 | 二叉树5

1、最大二叉树，还是和构造二叉树一个原理，主要是掌握如何切分的数组就好了，为了降低空间占用，可以直接对原数组进行操作，传入起止位置就好了（用python秒杀了）：
 

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {

        if (nums.empty())
            return nullptr;

        int max = INT_MIN;
        int idx = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] >= max) {
                max = nums[i];
                idx = i;
            }
        }

        TreeNode* node = new TreeNode(max);
        vector<int> left(nums.begin(), nums.begin() + idx);
        vector<int> right;
        if (idx != nums.size() - 1)
            right = vector<int>(nums.begin() + idx + 1, nums.end());

        node->left = constructMaximumBinaryTree(left);
        node->right = constructMaximumBinaryTree(right);
        return node;
    }
};

2、合并二叉树，用递归的方法很简单：
 

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (!root1 && !root2)
            return nullptr;

        TreeNode* node;
        if (!root1 && root2) {
            node = new TreeNode(root2->val);
            node->left = mergeTrees(nullptr, root2->left);
            node->right = mergeTrees(nullptr, root2->right);
        }

        else if (root1 && !root2) {
            node = new TreeNode(root1->val);
            node->left = mergeTrees(root1->left, nullptr);
            node->right = mergeTrees(root1->right, nullptr);
        }

        else if (root1 && root2) {
            node = new TreeNode(root1->val + root2->val);
            node->left = mergeTrees(root1->left, root2->left);
            node->right = mergeTrees(root1->right, root2->right);
        }

        return node;
    }
};

用迭代做旧有一点麻烦了，可以看做root2加到root1上，即有一个主树，构造的时候是一层一层的，广度，所有用队列：
 

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (!root1) return root2;
        if (!root2) return root1;

        // 使用队列来实现广度优先搜索
        queue<pair<TreeNode*, TreeNode*>> q;
        q.push({root1, root2});

        while (!q.empty()) {
            auto [node1, node2] = q.front();
            q.pop();

            // 合并当前节点的值
            node1->val += node2->val;

            // 如果左右子树都存在，则将它们加入队列
            if (node1->left && node2->left) {
                q.push({node1->left, node2->left});
            } else if (!node1->left) {
                node1->left = node2->left; // 如果node1的左子树为空，则直接赋值
            }

            // 如果右右子树都存在，则将它们加入队列
            if (node1->right && node2->right) {
                q.push({node1->right, node2->right});
            } else if (!node1->right) {
                node1->right = node2->right; // 如果node1的右子树为空，则直接赋值
            }
        }

        return root1;
    }

3、二叉树的搜索，简单题
 

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

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {

        while(root != nullptr)
        {
            if(root->val>val) root= root->left;
            else if(root->val<val) root = root->right;
            else{
                return root;
            }
        }
        return NULL;

    }
};