Day 21 530.二叉搜索树的最小绝对差 501.二叉搜索树中的众数 236. 二叉树的最近公共祖先

二叉树的最小绝对差

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。

示例：

提示：树中至少有 2 个节点。

​ 直观想法：二叉搜索树中序遍历，得到数组后求相邻元素最小绝对差；

​ 考虑到上道题就是使用的双指针方法，可以直接求前后节点的差值，并用一个min值来存放得到最小值并返回即可；

	int res = INT_MAX;//记录最小值
	TreeNode* pre = NULL;//记录前一个节点的pre
	void traversal(TreeNode* cur){//函数参数和返回值
        //终止条件
        if(cur == NULL)	return;
        //单层递归
        traversal(cur->left);//此处是有回溯逻辑的
        if(pre != NULL){
            res = min(res, cur->val - pre->val);
        }
        pre = cur;
        traversal(cur->right);
    }

​ 整体代码如下：

class Solution {
private:
    int res = INT_MAX;//记录最小值
	TreeNode* pre = NULL;//记录前一个节点的pre
	void traversal(TreeNode* cur){//函数参数和返回值
        //终止条件
        if(cur == NULL)	return;
        //单层递归
        traversal(cur->left);//此处是有回溯逻辑的
        if(pre != NULL){
            res = min(res, cur->val - pre->val);
        }
        pre = cur;
        traversal(cur->right);
    }
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return res;
    }
};

二叉搜索树中的众数

给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。

假定 BST 有如下定义：

• 结点左子树中所含结点的值小于等于当前结点的值
• 结点右子树中所含结点的值大于等于当前结点的值
• 左子树和右子树都是二叉搜索树

例如：

给定 BST [1,null,2,2],

返回[2].

提示：如果众数超过1个，不需考虑输出顺序

进阶：你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）

​ 按题目要求，依然使用双指针思路；

	int maxCount = 0;//最大频率
	int count = 0;//统计频率
	TreeNode* pre = NULL;
	vector<int> res;
	void traversal(TreeNode* cur){
        //终止条件
        if(cur == NULL)	return;
        //左
        traversal(cur->left);
        //中
        if(pre == NULL){//第一个节点出现
            count = 1;
        }
        else if(pre->val == cur->val)	count++;//相等，则频率++
        else count =1;
        pre = cur;
        
        if(count == maxCount)	res.push_back(cur->val);
        if(count > maxCount){//更新最大值
            maxCount = count;
            res.clear();
            res.push_back(cur->val);
        }
        //右
        traversal(cur->right);
        return;
    }

​ 整体代码如下：

/**
 * 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 {
private:
	int maxCount = 0;//最大频率
	int count = 0;//统计频率
	TreeNode* pre = NULL;// 记录前一个节点
	vector<int> res;
	void traversal(TreeNode* cur){
        //终止条件
        if(cur == NULL)	return;
        //左
        traversal(cur->left);
        //中
        if(pre == NULL){//第一个节点出现
            count = 1;
        }
        else if(pre->val == cur->val)	count++;//相等，则频率++
        else count =1;
        pre = cur;
        
        if(count == maxCount)	res.push_back(cur->val);
        if(count > maxCount){//更新最大值
            maxCount = count;
            res.clear();
            res.push_back(cur->val);
        }
        //右
        traversal(cur->right);
        return;
    }
public:
    vector<int> findMode(TreeNode* root) {
        count = 0;
        maxCount = 0;
        pre = NULL; 
        res.clear();

        traversal(root);
        return res;
    }
};

二叉树最近的公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]

示例 1: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解释: 节点 5 和节点 1 的最近公共祖先是节点 3。

示例 2: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

说明:

• 所有节点的值都是唯一的。
• p、q 为不同节点且均存在于给定的二叉树中。

​ 虽然二叉树只能从根节点向下遍历，但是处理过程可以从下往上处理啊；

​ 回溯啊，后序遍历左右中不就可以实现这个效果了；

​ 接下来就看如何判断一个节点是节点q和节点p的公共祖先呢。

​ 首先最容易想到的一个情况：如果找到一个节点，发现左子树出现结点p，右子树出现节点q，或者 左子树出现结点q，右子树出现节点p，那么该节点就是节点p和q的最近公共祖先。

​ 即情况一：

​ 其实还有容易被忽视的情况2：

​

​ 在递归函数有返回值的情况下：如果要搜索一条边，递归函数返回值不为空的时候，立刻返回；

​ 如果搜索整个树，直接用一个变量left、right接住返回值，这个left、right后序还有逻辑处理的需要，也就是后序遍历中处理中间节点的逻辑（也是回溯）

​ 遍历代码如下所示：

	TreeNode* traversal(TreeNode* root, TreeNode* p, TreeNode* q){
        if(root == NULL)	return NULL;
        if(root == p || root == q)	return root;//第二种情况已经包含在情况一里了
        
        TreeNode* left = traversal(root->left, p, q);//查询左子树中是否有p q
        TreeNode* right = traversal(root->right, p, q);
        if(left && right)	return root;//左右子树都有p q
        if(!left && right)	return right;//左子树没有p q，右子树有
        else if(left && !right)	return left;//左子树有p q,右子树没有
        else return NULL;
    }

​ 题解代码精简后如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == p || root == q || root == NULL)	return root;//第二种情况已经包含在情况一里了   
        TreeNode* left = lowestCommonAncestor(root->left, p, q);//查询左子树中是否有p q
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        if(left && right)	return root;//左右子树都有p q
        if(!left)   return right;//左子树没有p q，右子树有
        else return left;//左子树有p q,右子树没有
    }
};