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

654.最大二叉树

利用分割数组的思想，用索引下标在原数组上进行分割；

class Solution {
public: 
    //left和right分别是当前数组的左下标和右下标
    TreeNode* traversal(vector<int>& nums, int left, int right){
        //终止条件：当数组中左下标等于或者超过右下标的时候
        if(left >= right)return nullptr;
        int maxValueIndex = left;
        //找到当前数组最大值的下标
        for(int i = left + 1; i < right; i++){
            if(nums[i] > nums[maxValueIndex]){
                maxValueIndex = i;
            }
        }
        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.合并二叉树

疑惑点：同时操纵两个二叉树，因此是同步遍历。

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

迭代法：

class Solution {
public:
    //层序遍历
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        //先判断两棵树的根节点各自为空的情况
        if(root1 == nullptr)return root2;
        if(root2 == nullptr)return root1;
        queue<TreeNode*> que1;
        queue<TreeNode*> que2;
        que1.push(root1);
        que2.push(root2);
        while(!que1.empty() && !que2.empty()){
            TreeNode* node1 = que1.front();
            TreeNode* node2 = que2.front();
            que1.pop();
            que2.pop();
            node1->val += node2->val;
            //如果两棵树的左节点都不为空
            if(node1->left != nullptr && node2->left != nullptr){
                que1.push(node1->left);
                que2.push(node2->left);
            }
            //如果两棵树的右节点都不为空
            if(node1->right != nullptr && node2->right != nullptr){
                que1.push(node1->right);
                que2.push(node2->right);
            }
            //如果t1左子树为空，另一棵树t2左子树不为空
            if(node1->left == nullptr && node2->left != nullptr){
                node1->left = node2->left;
            }
            //如果t1右子树为空，t2右子树不为空
            if(node1->right == nullptr && node2->right != nullptr){
                node1->right = node2->right;
            }
        }
        return root1;

    }
};

 700.二叉搜索树中的搜索

递归：主要找到与给定值相同的节点

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root == nullptr || root->val == val)return root;
        TreeNode* result = nullptr;
        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 != NULL){
            if(root->val > val)root = root->left;
            else if(root->val < val)root = root->right;
            else return root;
        }
        return NULL;
    }
};

98.验证二叉搜索树

解法一：将二叉树转化成数组，判断该数组是否为一个有序数组。

class Solution {
private:
    vector<int>vec;
    void traversal(TreeNode* node){
        if(node == nullptr)return;
        traversal(node->left);
        vec.push_back(node->val);   //将二叉树转化为有序数组
        traversal(node->right);
    }
public:
    bool isValidBST(TreeNode* root) {
        vec.clear();
        traversal(root);
        for(int i = 1; i < vec.size(); i++){
            if(vec[i] <= vec[i-1])return false;
        }
        return true;
    }
};

解法二：在递归遍历中直接判断数组是否有序

注意：是要比较中间节点大于左子树上的所有节点，小于右子树上的所有节点。而不是仅仅比较当前节点大于左节点，小于右节点。

使用双指针：pre指向前一个节点，因为先一直遍历到最底层的左边节点，再一层一层返回，逻辑类似从下往上进行比较。

采用中序遍历

class Solution {
public:
    TreeNode* pre = NULL;
    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;
    }
};

迭代法：

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