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

654.最大二叉树

文档讲解：代码随想录.最大二叉树
视频讲解：又是构造二叉树，又有很多坑！| LeetCode：654.最大二叉树
状态：已完成

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 * right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {

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

        // 确定中间节点
        int max_num = 0;
        int max_index = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > max_num) {
                max_num = nums[i];
                max_index = i;
            }
        }
        node->val = max_num;

        // 确定左节点
        if (max_index > 0) { // 说明最大值左侧最少有一个数
            vector<int> new_left(nums.begin(), nums.begin() + max_index);//构造新的数组
            node->left = constructMaximumBinaryTree(new_left);
        }

        // 确定右节点
        if (max_index < (nums.size() - 1)) { // 说明最大值右侧最少有一个值
            vector<int> new_right(nums.begin() + max_index + 1, nums.end());
            node->right = constructMaximumBinaryTree(new_right);
        }

        return node;
    }
};

心得体会

1. 构造二叉树的题目一定要选择前序遍历，前序遍历的顺序为中左右
2. 需要梳理清楚递归的三要素，不要被内容吓到，逻辑框架清楚，就比较好掌握
3. 有时需要判断是否进行左右子树递归，这里需要通过中止条件判断

617.合并二叉树

文档讲解：代码随想录.合并二叉树
视频讲解：一起操作两个二叉树？有点懵！| LeetCode：617.合并二叉树
状态：已完成

代码实现

/**
 1. Definition for a binary tree node.
 2. struct TreeNode {
 3.     int val;
 4.     TreeNode *left;
 5.     TreeNode *right;
 6.     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 7.     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 8.     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 9. right(right) {}
 10. };
 */
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;
    }
};

心得体会

1.可以使用多种遍历方式，应该有自己熟练的方法即可

700.二叉搜索树中的搜索

文档讲解：代码随想录.二叉搜索树中的搜索
视频讲解：不愧是搜索树，这次搜索有方向了！| LeetCode：700.二叉搜索树中的搜索
状态：已完成

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 * right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        // 第一种方法，递归法
        // if (root == nullptr || root->val == val) {
        //     return root;
        // }

        // TreeNode* result = new TreeNode(0);
        // if (root->val > val)
        //     result = searchBST(root->left, val);
        // if (root->val < val)
        //     result = searchBST(root->right, val);

        // return result;

        // 第二种方法,迭代法
        while (root != nullptr) {
            if (root->val > val) {
                root = root->left;
            } else if (root->val < val) {
                root = root->right;
            } else {
                return root;
            }
        }

        return nullptr;
    }
};

98.验证二叉搜索树

文档讲解：代码随想录.验证二叉搜索树
视频讲解：你对二叉搜索树了解的还不够！ | LeetCode：98.验证二叉搜索树
状态：已完成

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 * right(right) {}
 * };
 */
class Solution {

private:
    vector<int> nums;
    void traversal(TreeNode* root) {

        if (root == nullptr) {
            return;
        }
        traversal(root->left);
        nums.push_back(root->val);
        traversal(root->right);
    }

public:
    bool isValidBST(TreeNode* root) {
        nums.clear();
        traversal(root);

        // 遍历确定是否满足条件
        for (int i = 1; i < nums.size(); i++) {
            if (nums[i - 1] >= nums[i]) {
                return false;
            }
        }

        return true;
    }
};

心得体会

1.二叉搜索树的概念需要理解，所以一般采用中序遍历，左中右，符合有序的特征

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

2.目前先理解最直接的这种方法，另外递归和迭代法暂时先不看