第20天-代码随想录刷题训练-第六章 ● 654.最大二叉树 ● 617.合并二叉树 ● 700.二叉搜索树中的搜索 ● 98.验证二叉搜索树

1. 最大二叉树 （思考为什么构建二叉树都是前序遍历）

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:
创建一个根节点，其值为 nums 中的最大值。
递归地在最大值 左边 的 子数组前缀上 构建左子树。
递归地在最大值 右边 的 子数组后缀上 构建右子树。

前序遍历二叉树：前序遍历二叉树的流程是 中左右，先确定根节点后再确定左右子节点

本题的递归函数实现思路：

1.确定递归函数的参数和返回值，每次传入数组，左右边界点(nums, left, right)，返回的是当前递归层确定的一个根节点
2.判断终止条件 当nums.size()==1的时候代表到达了叶子结点
3.确定单层递归逻辑：先寻找数组中的最大值；

class Solution {
public:

    TreeNode* traversal(vector<int>& nums, int left, int right){
        // 1.先判断终止条件
        if(left >= right) return nullptr;

        int maxIndex = left;
        // 2.统一使用左闭右开的方式
        for(int i=left+1; i<right; i++){
            if(nums[i] > nums[maxIndex]){
                maxIndex = i;
            }
        }
        TreeNode* root = new TreeNode(nums[maxIndex]);

        root->left = traversal(nums, left, maxIndex);
        root->right = traversal(nums, maxIndex+1, right);

        return root;
    }

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

2. 合并二叉树

LeetCode链接

给你两棵二叉树： root1 和 root2 。
想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。
返回合并后的二叉树。

• 确定终止条件的时候，t1为空返回t2和t2为空返回t1已经包含了 t1和t2同时为空的情况
• 当一棵树的一个节点是null，另一个不是的话就直接将节点转接过来

class Solution {
public:
	// 递归法
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
    	// 1.确定终止条件
        if(t1 == NULL) return t2;
        if(t2 == NULL) return t1;
		
		// 2.确定每层的遍历逻辑
        t1->val += t2->val;
        t1->left = mergeTrees(t1->left, t2->left);
        t1->right = mergeTrees(t1->right, t2->right);
        return t1;
    }
    
 	// 迭代法
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if(t1 == NULL) return t2;
        if(t2 == NULL) return t1;

        queue<TreeNode*> que;
        que.push(t1);
        que.push(t2);

        while(!que.empty()){
            TreeNode *node1 = que.front(); que.pop();
            TreeNode *node2 = que.front(); que.pop();
            node1->val += node2->val;

            // 两棵树的左节点都不为空
            if(node1->left != NULL && node2->left != NULL){
                que.push(node1->left);
                que.push(node2->left);
            }

            // 两棵树的右节点都不为空
            if(node1->right != NULL && node2->right != NULL){
                que.push(node1->right);
                que.push(node2->right);
            }


            // 这里不进行 push 是因为有一颗树的当前节点已经没有子节点了，直接将另一棵树的子节点拿过来就可以
            if(node1->left == NULL && node2->left != NULL){
                node1->left = node2->left;
            }

            if(node1->right == NULL && node2->right != NULL){
                node1->right = node2->right;
            }

        }

        return t1;
    }
};

3.二叉树中的搜索

LeetCode链接

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。
你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

class Solution {
public:
    // 递归法
    // 1.确定参数和返回值
    TreeNode* searchBST(TreeNode* root, int val) {
        // 2. 确定终止条件
        if(root==NULL || root->val == val) return root;

        // 3.单层逻辑
        TreeNode* result = NULL;
        if(root->val > val) {
            result = searchBST(root->left, val);
        }else {
            result = searchBST(root->right, val);
        }
        return result;
    }

    // 迭代法
    TreeNode* searchBST(TreeNode* root, int val) {
        while(root != NULL){
            if(root->val == val) return root;
            else if(root->val > val) root = root->left;
            else root = root->right;
        }
        return NULL;
    }

4.验证二叉搜索树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

• 注意点
  • 遍历的时候只判断根节点 和 左右子节点的话， 可能会不满足 左右子节点不小于/大于 父节点的父节点的条件
  • 普通的递归是不满足当前题目的，应当使用中序递归，而且需要记录前一个节点的值，来判断与当前节点的大小

class Solution {
public:
	// 正确的递归写法
    TreeNode* pre = NULL;
    bool isValidBST(TreeNode* root) {
        if(root == NULL) return true;
        bool left = isValidBST(root->left);

        if(pre != NULL && pre->val >= root->val) return false;
        pre = root;

        bool right = isValidBST(root->right);
        return left && right;
    }

	// 错误的递归方法
    bool isValidBST_False(TreeNode* root) {
        // 确定终止条件
        if(root == NULL) return true;
        else if(root->left != NULL && root->left->val > root->val) return false;
        else if(root->right != NULL && root->right->val < root->val) return false;

        bool left = isValidBST(root->left);
        bool right = isValidBST(root->right);

        return left && right;
    }

	// 正确的递归方法

    // 中序遍历，正确的二叉树会得到一个有序序列
    void midOrder(TreeNode* root, vector<int>& iv){
        if(root == NULL) return;

        midOrder(root->left, iv);
        iv.push_back(root->val);
        midOrder(root->right, iv);
    }

    bool isValidBST1(TreeNode* root) {
        vector<int> result;
        midOrder(root, result);

        for(int i=0; i<result.size()-1; i++){
            if(result[i] >= result[i+1]){
                return false;
            }
        }

        return true;
    }
};