(19/60)最大二叉树、合并二叉树、二叉搜索树中的搜索、验证二叉搜索树

过外婆八十寿宴去了，补卡

最大二叉树

leetcode：654. 最大二叉树

递归法

思路

构造二叉树都要用前序遍历：先有根，才有其他。

复杂度分析

时间复杂度：O(N^2)。

空间复杂度：最差时（单调增or减-）O(N)。

注意点

1. 递归时候传入值是变量begin、end而不是写死的。

代码实现

/**
 * 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* traverse(vector<int>& nums,int begin,int end){
        // 左闭右开，相等时终止
        if(begin == end) return NULL;
        // 第一步
        int maxIndex = begin;
        for(int i = begin;i < end;i++){
            if(nums[i] > nums[maxIndex]){
                maxIndex = i;
            }
        } 
        TreeNode* root = new TreeNode(nums[maxIndex]);
        // 第二步
        root->left = traverse(nums,begin,maxIndex);
        // 第三步 
        root->right = traverse(nums,maxIndex + 1,end);

        return root;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traverse(nums,0,nums.size());
    }
};

---

合并二叉树

leetcode：617. 合并二叉树

递归构造法

思路

同时同步遍历两个二叉树，如果为空则返回另一棵树的节点；如果都不空则相加。

在第一棵树上进行操作，避免开辟不必要的空间。

复杂度分析

时间复杂度：O(N)。

空间复杂度：O(1)。

注意点

略

代码实现

/**
 * 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;
        root1->val += root2->val;
        root1->left = mergeTrees(root1->left,root2->left);
        root1->right = mergeTrees(root1->right,root2->right);
        
        return root1;
    }
};

---

二叉搜索树中的搜索

leetcode：700. 二叉搜索树中的搜索

迭代法

思路

指针一路走下来。

复杂度分析

时间复杂度：O(logN)。

空间复杂度：O(1)。

注意点

略

代码实现

/**
 * 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) {
        TreeNode* cur = root;
        while(root){
            if(root->val == val) return root;
            else if(root->val > val) root = root->left;
            else if(root->val < val) root = root->right;
        }

        return NULL;
    }
};

递归法

思路

略

复杂度分析

时间复杂度：O(logN)。

空间复杂度：

注意点

略

代码实现

/**
 * 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 == NULL) return NULL;
        
        if(root->val == val) return root;
        else if(root->val > val) return searchBST(root->left,val);
        else if(root->val < val) return searchBST(root->right,val);
        
        return NULL; // 这句其实应该不会执行
    }
};

---

验证二叉搜索树

leetcode：98. 验证二叉搜索树

双指针中序遍历法

思路

二叉搜索树中序遍历的结果严格递增，利用这一特性进行判断。

采用双指针（pre、root）法遍历。

复杂度分析

时间复杂度：O(N)。

空间复杂度：O(1)。

注意点

1. 终止条件是if(root == NULL) 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;
    // 中序遍历有序特性
    bool isValidBST(TreeNode* root) {
        if(root == NULL) return true;   // 空树也是搜索树
        bool left = isValidBST(root->left);
        if(pre && pre->val >= root->val) return false;
        else pre = root;
        bool right = isValidBST(root->right);
        return left && right;
    }
};