算法训练（leetcode）第十五天 | 654. 最大二叉树、617. 合并二叉树、700. 二叉搜索树中的搜索、98. 验证二叉搜索树

654. 最大二叉树

leetcode题目地址

本题和106. 从中序与后序遍历序列构造二叉树的思路类似，递归建树，每次找出最大值赋值给当前节点，接着递归左子树和右子树。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

// c++
/**
 * 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* createTree(vector<int>& nums, int left, int right){
        if(left>right) return NULL;
        // 记录最大值下标
        int max_idx = left;
        int idx = left;
        // 找最大
        for(; idx<=right; idx++){
            if(nums[idx] > nums[max_idx]) {
                max_idx = idx;
            }
        }
        // 用最大值创建节点
        TreeNode* root = new TreeNode(nums[max_idx]);
        // 递归左右子树
        root->left = createTree(nums, left, max_idx-1);
        root->right = createTree(nums, max_idx+1, right);
        return root;
    }
    
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode* root = createTree(nums, 0, nums.size()-1);
        return root;
    }
};

617. 合并二叉树

leetcode题目地址

同上题思路类似，只不过是同时遍历两个树，题目新颖，第一次遇到。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

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

700. 二叉搜索树中的搜索

leetcode题目地址

借助前序遍历来查找，找到则返回该节点。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

直接前序遍历

// c++
/**
 * 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 preOrder(TreeNode* root, int val, TreeNode* &result){
        if(!root) return;
        if(root->val == val){
            result = root;
            return;
        }
        // 没找到时递归左右子树，找到了就停止
        if(!result)
            preOrder(root->left, val, result);
        if(!result)
            preOrder(root->right, val, result);
        
    }
    TreeNode* searchBST(TreeNode* root, int val) {
        TreeNode* result = nullptr;
        preOrder(root, val, result);
        return result;
    }
};

借助BST性质

借助BST左小右大的性质来提高查找效率。（其实就是改一个递归左右子树的判断）

// c++
/**
 * 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 preOrder(TreeNode* root, int val, TreeNode* &result){
        if(!root) return;
        if(root->val == val){
            result = root;
            return;
        }
        // 没找到时递归左右子树，找到了就停止
        if(root->val > val)
            preOrder(root->left, val, result);
        if(root->val < val)
            preOrder(root->right, val, result);
        
    }
    TreeNode* searchBST(TreeNode* root, int val) {
        TreeNode* result = nullptr;
        preOrder(root, val, result);
        return result;
    }
};

98. 验证二叉搜索树

leetcode题目地址

与上题类似，这里使用中序遍历。BST的中序遍历结果是一个单调递增序列，因此在遍历时出现递减（或相等）则不是BST。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

中规中矩版

// c++
/**
 * 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 inOrder(TreeNode* root, bool & result, TreeNode* &last){
        if(!root) return ;
        inOrder(root->left, result, last);
        if(last && last->val >= root->val) {
            result = false;
            return;
        }
        last = root;
        inOrder(root->right, result, last);
    }
    bool isValidBST(TreeNode* root) {
        bool result = true;
        TreeNode* last = nullptr;
        inOrder(root, result, last);
        return result;
    }
};

简洁版：

简化了一下参数传递，改成函数值返回。

// c++
/**
 * 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:
    bool inOrder(TreeNode* root,  TreeNode* &last){
        if(!root) return true;
        bool left = inOrder(root->left, last);
        if(last && last->val >= root->val) {
            return false;
        }
        last = root;
        bool right = inOrder(root->right, last);
        return left && right;
    }
    bool isValidBST(TreeNode* root) {
        TreeNode* last = nullptr;
        return inOrder(root, last);
    }
};