代码随想录第17天|最大二叉树&合并二叉树&二叉搜索树

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* construct(vector<int> r) {
        if (r.size() == 0)
            return nullptr;
        int maxindex = 0;
        int maxvalue = r[0];
        for (int i = 1; i < r.size(); i++) {
            if (r[i] > maxvalue) {
                maxindex = i;
                maxvalue = r[i];
            }
        }
        TreeNode* n = new TreeNode(maxvalue);
        vector<int> leftvec(r.begin(), r.begin() + maxindex);
        vector<int> rightvec(r.begin() + maxindex + 1, r.end());
        n->left = construct(leftvec);
        n->right = construct(rightvec);
        return n;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode* root = construct(nums);
        return root;
    }
};

617.合并二叉树

/**
 * 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* merge(TreeNode* cur1, TreeNode* cur2) {
        if (cur1 != nullptr && cur2 == nullptr)
            return cur1;
        if (cur1 == nullptr && cur2 != nullptr)
            return cur2;
        if (cur1 == nullptr && cur2 == nullptr)
            return nullptr;
        TreeNode* cur = new TreeNode(cur1->val + cur2->val);
        cur->left = merge(cur1->left, cur2->left);
        cur->right = merge(cur1->right, cur2->right);
        return cur;
    }
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        TreeNode* root = merge(root1, root2);
        return root;
    }
};

递归法

/**
 * 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 == nullptr)
            return root2;
        if (root2 == nullptr)
            return root1;
        queue<TreeNode*> q;
        q.push(root1);
        q.push(root2);
        while (!q.empty()) {
            TreeNode* cur1 = q.front();
            q.pop();
            TreeNode* cur2 = q.front();
            q.pop();
            cur1->val += cur2->val;
            if (cur1->left != nullptr && cur2->left != nullptr) {
                q.push(cur1->left);
                q.push(cur2->left);
            }
            if (cur1->right != nullptr && cur2->right != nullptr) {
                q.push(cur1->right);
                q.push(cur2->right);
            }
            // 该情况不用放入队列，因为后续的子树直接就是为cur2的那一边，直接赋值即可
            if (cur1->left == nullptr && cur2->left != nullptr)
                cur1->left = cur2->left;
            if (cur1->right == nullptr && cur2->right != nullptr)
                cur1->right = cur2->right;
        }
        return root1;
    }
};

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)
            return nullptr;
        if (root->val == val)
            return root;
        else if (val > root->val)
            return searchBST(root->right, val);
        else
            return searchBST(root->left, val);
    }
};

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 {
public:
    vector<int> res;
    void inorder(TreeNode* cur){
        if(cur == nullptr) return;
        inorder(cur->left);
        res.push_back(cur->val);
        inorder(cur->right);
    }
    bool isValidBST(TreeNode* root) {
        inorder(root);
        for(int i = 0; i < res.size() - 1; i++){
            if(res[i] >= res[i + 1]) return false;
        }
        return true;
    }
};

使用中序遍历法

/**
 * 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* pre = nullptr;
    bool isValidBST(TreeNode* root) {
        if (root == nullptr)
            return true;
        bool left = isValidBST(root->left);
        if (pre != nullptr && pre->val >= root->val)
            return false;
        pre = root;
        bool right = isValidBST(root->right);
        return left && 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:
    TreeNode* pre = nullptr;
    bool isValidBST(TreeNode* root) {
        if (root == nullptr)
            return true;
        stack<TreeNode*> st;
        st.push(root);
        while (!st.empty()) {
            TreeNode* cur = st.top();
            st.pop();
            if (cur != nullptr) {
                if (cur->right)
                    st.push(cur->right);
                st.push(cur);
                st.push(nullptr);
                if (cur->left)
                    st.push(cur->left);
            } else {
                cur = st.top();
                st.pop();
                if (pre != nullptr && pre->val >= cur->val)
                    return false;
                pre = cur;
            }
        }
        return true;
    }
};