617. 合并二叉树、700.二叉搜索树中的搜索、98. 验证二叉搜索树

617. 合并二叉树

题目描述：

给你两棵二叉树： root1 和 root2 。

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

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始

解答：

首先来一个比较直白的思路，遍历两棵树，对比节点，创建一棵新树。

至于遍历方法，前中后三种遍历均可。此处采用先序遍历。

分两种情况：

（1）节点重叠：二者之和，再递归访问左右子树。

（2）节点不重叠：直接将非空部分放到新树中即可。

代码实现：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (root1 == NULL && root2 == NULL)
            return NULL;

        TreeNode* root = new TreeNode();
        if (root1 == NULL && root2 != NULL)
            root = root2; 
        else if (root1 != NULL && root2 == NULL)
            root = root1;
        else{
            root->val = root1->val + root2->val;
            root->left = mergeTrees(root1->left, root2->left);
            root->right = mergeTrees(root1->right, root2->right);
        }
        return root;
    }
};

精简后：

不使用额外的树空间，直接合并到树1中。

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2
        if (t2 == NULL) return t1; // 如果t2为空，合并之后就应该是t1
        // 修改了t1的数值和结构
        t1->val += t2->val;                             // 中
        t1->left = mergeTrees(t1->left, t2->left);      // 左
        t1->right = mergeTrees(t1->right, t2->right);   // 右
        return t1;
    }
};

700.二叉搜索树中的搜索

题目描述：

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

解答：

二叉搜索树是一个有序树：其根节点左子树中的节点一定小于根，右子树中的节点一定大于根。

法一：递归法

采用递归法进行实现，考虑递归三要素。

（1）参数和返回值：参数有根节点root、要找的数val；返回值为寻址的结果。

此处再次回顾一下，递归是否需要返回值。（递归是否需要返回值）112.路径总和、113. 路径总和 II_清榎的博客-CSDN博客

 本题只要找到一个节点满足条件便结束，和上文中找一条路径类似，故需要返回值。

（2）终止条件：root为空则返回NULL

（3）处理逻辑：如果根节点的值等于val则直接返回根节点，如果不等于根据根节点和val之间的大小关系进行递归访问。

代码实现：

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

法二：迭代法

深度优先遍历可以拿栈模拟，广度优先遍历可以使用队列，但是此处由于二叉搜索树节点的有序性，可以不使用辅助栈或者队列就可以写出迭代法。

对于一般二叉树，递归过程中还有回溯的过程，例如走一个左方向的分支走到头了，那么要调头，在走右分支。

对于二叉搜索树，不需要回溯的过程，因为节点的有序性就帮我们确定了搜索的方向。

代码实现：

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

98. 验证二叉搜索树

题目描述：

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

解答：

法一： 

考虑到二叉搜索树是一个有序序列，可以先进行中序遍历，检查遍历后的结果集是否有序即可。

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

法二：递归法

这道题使用递归法需要注意的第一个地方是：并不是左孩子小于根节点、右孩子大于根就一定满足二叉搜索树（左孩子的右孩子大于根情况无法识别）。

所以我采用的办法是，创建一个全局变量，用来比较遍历的节点是否有序。

考虑递归三要素：

（1）参数和返回值：参数为根节点；返回值为bool类型，与之前找路径类似，此处只要发现不满足二叉搜索树就要直接返回。

（2）终止条件：节点为空，返回true

（3）内部处理逻辑：按照中序遍历（左中右）进行处理。遇到maxVal大于根节点值时直接返回false。

代码实现：

class Solution {
public:
    long long maxVal = LONG_MIN; // 因为后台测试数据中有int最小值
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;

        bool left = isValidBST(root->left);
        // 中序遍历，验证遍历的元素是不是从小到大
        if (maxVal < root->val) maxVal = root->val;
        else return false;
        bool right = isValidBST(root->right);

        return left && right;
    }
};