LeetCode 第十九天

654. 最大二叉树
类似前序中序构造二叉树

class Solution {
public:
    TreeNode* traversal(vector<int>& nums)
    {
        // 空节点直接判断
        if(nums.size() == 0){
            return nullptr;
        }
        // 找到最大值及其角标
        int rootValue;
        int index;
        for(int i = 0; i < nums.size(); i++){
            if(nums[i] > rootValue){
                rootValue = nums[i];
                index = i;
            }
        }
        // 新创建一个节点
        TreeNode* root = new TreeNode(rootValue);
        // 此句可有可无，加上就到叶子结点就返回了，不用再多一层递归
        if (nums.size() == 1){
            return root;
        }
        // 分割左右
        vector<int> leftVec(nums.begin(), nums.begin() + index);
        vector<int> rightVec(nums.begin() + index + 1, nums.end());

        // 连接左右节点
        root->left = traversal(leftVec);
        root->right = traversal(rightVec);

        // 返回节点
        return root;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.size() == 0)
            return nullptr;
        return traversal(nums);
    }
};

617. 合并二叉树

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        // 以root1作为基准保存合并树
        // 若root1为空，直接接上root2
        if (root1 == nullptr) return root2;
        // 若root2为空，直接接上root1
        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;
    }
};

700. 二叉搜索树中的搜索

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        // 没有利用二叉搜索树的特性
        // if (root == nullptr) return nullptr;
        // if (root->val == val)
        //     return root;
        // TreeNode* left = searchBST(root->left, val);
        // TreeNode* right = searchBST(root->right, val);
        // if(left)
        //     return left;
        // else
        //     return right;

        // 利用特性进行递归二叉搜索
        // if (root == nullptr || root->val == val) 
        //     return root;
        // // TreeNode* res = nullptr;
        // if (val < root->val){
        //     return searchBST(root->left, val);
        // }
        // else{
        //     return searchBST(root->right, val);
        // }
        // return res;

        // 令人痛哭流涕的迭代法（太简单辣）
        while (root){
            if(root->val > val) 
                root = root->left;
            else if(root->val < val)
                root = root->right;
            else
                return root;
        }
        return nullptr;
    }
};

98. 验证二叉搜索树

class Solution {
public:
    TreeNode* pre = nullptr;
    bool isValidBST(TreeNode* root) {
        // static int preValue = INT_MIN;
        // static bool flag = true;
        // cout<
        // if (root){
        //     isValidBST(root->left);
        //     if (root->val > preValue)
        //         preValue = root->val;
        //     else
        //         flag = false;
        //     isValidBST(root->right);
        // }
        // return flag;
        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;
    }
};

今天的题不算难，但是也很重要，盲猜明天真的要构造平衡二叉树了。最近真的没时间写思路，但是代码注释基本有了