代码随想录算法训练营Day20 | 二叉树part06

654.最大二叉树

leetcode链接
代码随想录链接
一刷状态：未通过

思路

思路类似构造二叉树的思路，先找出最大值，再划分为左右数组，左右数组分别为左右孩子，实现递归。注意区间是左闭右开

class Solution {
public:
    TreeNode* traversal(vector<int>& nums, int left, int right)
    {
        if(left>=right) return nullptr;

        // 找到最大值，分割数组
        int maxValueIndex = left;
        for(int i=left; i<right; i++)
        {
            if(nums[i]>nums[maxValueIndex]) maxValueIndex = i;
        }
        cout<<nums[maxValueIndex]<<maxValueIndex<<endl;

        TreeNode* root = new TreeNode(nums[maxValueIndex]);

        root->left = traversal(nums, left, maxValueIndex);
        root->right = traversal(nums, maxValueIndex+1, right);

        return root;

    }

    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums, 0, nums.size());

    }
};

617.合并二叉树

leetcode链接
代码随想录链接
一刷状态：通过

思路

前序遍历
结束条件：遍历到空指针
遍历逻辑：新建节点，新节点的值为两个数的和，合并两棵树。

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

        TreeNode* root = new TreeNode;
        root->val = root1->val + root2->val;

        root->left = mergeTrees(root1->left, root2->left);
        root->right = mergeTrees(root1->right, root2->right);

        return root;
    }
};

700.二叉搜索树中的搜索

leetcode链接
代码随想录链接
一刷状态：通过

思路

递归法

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

98.验证二叉搜索树

leetcode链接
代码随想录链接
一刷状态：通过

思路

二叉搜索树的中序遍历为升序排列的数组。
中序遍历，将二叉搜索树保存到vector中，然后测试vector数组是否按顺序排列。

class Solution {
public:
    vector<int> vec;
    void traversal(TreeNode* root) {
        if(root==nullptr) return;
        traversal(root->left);
        vec.push_back(root->val);
        traversal(root->right);
    }
    bool isValidBST(TreeNode* root) {
        if(root==nullptr) return true;
        traversal(root);
        int pre = vec[0];
        for(int i=1; i<vec.size(); i++)
        {
            if(vec[i]<=pre) return false;
            pre = vec[i];
        }
        return true;
    }
};

中序遍历，判断遍历到的数值是否大于前一个数值。

class Solution {
public:
    TreeNode* preNode = nullptr;
    bool isValidBST(TreeNode* root) {
        if(root==nullptr) return true;
        bool left = isValidBST(root->left);

        if(preNode!=nullptr&&preNode->val>=root->val) return false;
        preNode = root; 

        bool right = isValidBST(root->right);

        return left&&right;

    }
};