算法训练营第二十天|Leetcode654.最大二叉树 Leetcode617.合并二叉树 Leetcode700.二叉搜索树中的搜索 Leetcode98.验证二叉搜索树

Leetcode654.最大二叉树

文章链接：代码随想录
题目链接：654.最大二叉树

思路：和 06.从中序与后序遍历序列构造二叉树 一样找到分割点分割数组，递归构建。

/**
 * 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* traversal(vector<int>& nums){
        if (nums.size() == 0) return NULL;
        
        int max = INT_MIN;
        for(int i = 0; i < nums.size(); i++){
            max = max < nums[i] ? nums[i] : max;
        }
        TreeNode* node = new TreeNode(max);
        
        int mid;
        for (mid = 0; mid < nums.size(); mid++){
            if (nums[mid] == max) break;
        }
        vector<int> lnums (nums.begin(), nums.begin() + mid);
        vector<int> rnums (nums.begin() + mid + 1, nums.end());
        
/*      // 日志
        cout << "lnums" << endl;
        for (int j = 0; j < lnums.size(); j++){
            cout << lnums[j];
        }
        cout << endl;
        cout << "rnums" << endl;
        for (int j = 0; j < rnums.size(); j++){
            cout << rnums[j];
        }
        cout << endl;
*/
        node->left = traversal(lnums);
        node->right = traversal(rnums);
        return node;
    }

    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums);
    }
};

或者不新建vector，直接在原数组上分割，节省空间。

class Solution {
public:
    TreeNode* traversal(vector<int>& nums, int l, int r){
        if (l >= r) return NULL;
        
        int max = INT_MIN;
        int mid;
        for(int i = l; i < r; i++){
            if (max < nums[i]){
                max = nums[i];
                mid = i;
            }
        }
        TreeNode* node = new TreeNode(max);

        node->left = traversal(nums, l, mid);
        node->right = traversal(nums, mid + 1, r);
        return node;
    }
    
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        int l = 0;
        int r = nums.size();
        return traversal(nums, l, r);
    }
};

Leetcode617.合并二叉树

文章链接：代码随想录
题目链接：617.合并二叉树

思路：采用迭代法时，注意用一个队列存储两棵树比较，和 101.对称二叉树 一样；或者采用递归。
迭代法：

/**
 * 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* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (root1 == NULL) return root2;
        if (root2 == NULL) return root1;
        
        queue<TreeNode*> que;
        que.push(root1);
        que.push(root2);

        while (!que.empty()){
            TreeNode* node1 = que.front();
            que.pop();
            TreeNode* node2 = que.front();
            que.pop();

            node1->val += node2->val;
            if (node1->left && node2->left){
                que.push(node1->left);
                que.push(node2->left);
            }
            if (node1->right && node2->right){
                que.push(node1->right);
                que.push(node2->right);
            }
            if (!node1->left && node2->left){
                node1->left = node2->left;
            }
            if (!node1->right && node2->right){
                node1->right = node2->right;
            }

        }
        return root1;
    }
};

递归：

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

        root1->val += root2->val;

        root1->left = traversal(root1->left, root2->left);
        root1->right = traversal(root1->right, root2->right);
        
        return root1;
    }

    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        return traversal(root1, root2);
    }
};

Leetcode700.二叉搜索树中的搜索

文章链接：代码随想录
题目链接：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* traversal(TreeNode* node, int& val){
        if (node == NULL) return NULL;
        if (node->val == val) return node;

        else if (node->val > val) return traversal(node->left, val);
        else return traversal(node->right, val);

        return NULL;
    }
    
    TreeNode* searchBST(TreeNode* root, int val) {
        return traversal(root, val);
    }
};

迭代：

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        while(root){
            if (root->val == val) return root;
            else if (root->val > val) root = root->left;
            else root = root->right;
        }
        return NULL;
    }
};

Leetcode98.验证二叉搜索树

文章链接：代码随想录
题目链接：[98.验证二叉搜索树(https://leetcode.cn/problems/validate-binary-search-tree/description/)

思路：注意搜索树是右子树所有节点都大于中间节点，相等不行，下面的节点小于等于也不行，所以这样写是错误的。

 bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;

        if (root->left && root->left->val >= root-> val) return false;
        if (root->right && root->right->val <= root-> val) return false;

        return isValidBST(root->left) && isValidBST(root->right);
    }

忽略了搜索树的性质。
利用中序遍历搜索树，可以得到有序数组，检查这个数组是否有序即可。

/**
 * 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:
    void traversal(TreeNode* node, vector<int>& vec){
        if (node == NULL) return ;
        
        traversal(node->left, vec);
        vec.push_back(node->val);
        traversal(node->right, vec);
    }
    
    bool isValidBST(TreeNode* root) {
        vector<int> vec;
        traversal(root, vec);
        for (int i = 1; i < vec.size(); i++){
            if (vec[i] <= vec[i - 1]) return false;
        }
        return true;
    }
};

或者记录前一个节点，直接递归比较是否有序。

class Solution {
public:    
    TreeNode* pre = NULL;
    bool traversal(TreeNode* node){
        if (node == NULL) return true;

        bool l = traversal(node->left);
        if (pre != NULL && pre->val >= node->val) return false;
        pre = node;
        bool r = traversal(node->right);
        
        return l && r;
    }
    
    bool isValidBST(TreeNode* root) {
        return traversal(root);
    }
};

或者定义一个全局最小值记录比较，由于本题数据最小为 int 最小值，故采用 LONG_INT，为避免题目数据影响，还是采取上一种写法比较好。

class Solution {
public:    
    long long pre = LONG_MIN;
    bool traversal(TreeNode* node){
        if (node == NULL) return true;

        bool l = traversal(node->left);
        if (pre >= node->val) return false;
        pre = node->val;
        bool r = traversal(node->right);
        
        return l && r;
    }
    
    bool isValidBST(TreeNode* root) {
        return traversal(root);
    }
};

第十九天休息，第二十天打卡，感觉二叉树写的逐渐有感觉了，今天的几题基本是在没看解析和题解前就独立写出来了。
加油！！！