算法D19 | 二叉树6 | 654.最大二叉树 617.合并二叉树 700.二叉搜索树中的搜索 98.验证二叉搜索树

654.最大二叉树 

又是构造二叉树，昨天大家刚刚做完 中序后序确定二叉树，今天做这个 应该会容易一些， 先看视频，好好体会一下 为什么构造二叉树都是 前序遍历 

题目链接/文章讲解：代码随想录

视频讲解：又是构造二叉树，又有很多坑！| LeetCode：654.最大二叉树_哔哩哔哩_bilibili

和105， 106类似。

Python递归：

该优化版本通过索引操作。

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if len(nums)==0: return

        max_val = max(nums)
        root = TreeNode(max_val)

        seperate_idx = nums.index(max_val)

        left_prefix = nums[:seperate_idx]
        right_prefix = nums[seperate_idx+1:]

        root.left = self.constructMaximumBinaryTree(left_prefix)
        root.right = self.constructMaximumBinaryTree(right_prefix)

        return root

C++递归：

语法上有一些区别，1. vector没有max的方法，需要冒泡比较； 2. vector切片的方式需要call begin(), end()； 3. 数组的index需要判断是否在区间内再进行操作。

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode* root = new TreeNode(0);
        if (nums.size()==1) {
            root->val = nums[0];
            return root;
        }

        int max_val = 0;
        int seperate_idx = 0;
        for (int i=0; i<nums.size(); i++) {
            if (nums[i]>max_val) {
                max_val = nums[i];
                seperate_idx = i;
            }
        }
        root->val = max_val;

        if (seperate_idx>0) {
            vector<int> newVec(nums.begin(), nums.begin()+seperate_idx);
            root->left = constructMaximumBinaryTree(newVec);
        }
        if (seperate_idx<nums.size()-1) {
            vector<int> newVec(nums.begin()+seperate_idx+1, nums.end());
            root->right = constructMaximumBinaryTree(newVec);
        }

        return root;
    }
};

617.合并二叉树 

这次是一起操作两个二叉树了， 估计大家也没一起操作过两个二叉树，也不知道该如何一起操作，可以看视频先理解一下。 优先掌握递归。

题目链接/文章讲解：代码随想录

视频讲解：一起操作两个二叉树？有点懵！| LeetCode：617.合并二叉树_哔哩哔哩_bilibili

这个题遍历顺序不重要，前中后都可以，在其中一棵树上修改会更简洁一些。

Python递归：

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root1: 
            return root2
        if not root2: 
            return root1
        root1.val += root2.val
        root1.left = self.mergeTrees(root1.left, root2.left)
        root1.right = self.mergeTrees(root1.right, root2.right)
        return root1

C++递归：

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;
    }
};

700.二叉搜索树中的搜索 

递归和迭代 都可以掌握以下，因为本题比较简单， 了解一下 二叉搜索树的特性

题目链接/文章讲解: 代码随想录

视频讲解：不愧是搜索树，这次搜索有方向了！| LeetCode：700.二叉搜索树中的搜索_哔哩哔哩_bilibili

二叉搜索树是有序的，和普通的二叉树不同，左子树>根节点>右子树。

若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉搜索树

Python递归:

注意需要一个载体存左右子树的搜索结果。

class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root: return
        if root.val == val:
            return root
        elif root.val > val:
            result = self.searchBST(root.left, val)
        else:
            result = self.searchBST(root.right, val)
        return result
        

C++版本：

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

98.验证二叉搜索树 

遇到 搜索树，一定想着中序遍历，这样才能利用上特性。 

但本题是有陷阱的，可以自己先做一做，然后在看题解，看看自己是不是掉陷阱里了。这样理解的更深刻。

题目链接/文章讲解：代码随想录

视频讲解：你对二叉搜索树了解的还不够！ | LeetCode：98.验证二叉搜索树_哔哩哔哩_bilibili

本题的核心是：中序遍历搜索树出来的数组是递增的有序数组。

Python递归：

class Solution:
    def traversal(self, node, vec):
        if not node: return
        self.traversal(node.left, vec)
        vec.append(node.val)
        self.traversal(node.right, vec)
        return

    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        vec = []
        self.traversal(root, vec)
        for i in range(1, len(vec)):
            if vec[i] <= vec[i-1]:
                return False
        return True

C++递归：

class Solution {
public:
    vector<int> vec;
    void traversal(TreeNode* node) {
        if (node==NULL) return;
        traversal(node->left);
        vec.push_back(node->val);
        traversal(node->right);
    }
    bool isValidBST(TreeNode* root) {
        traversal(root);
        for (int i=1; i<vec.size(); i++) {
            if (vec[i]<=vec[i-1]) return false;
        }
        return true;
    }
};