代码随想录打卡第十九天

代码随想录–二叉树部分

day 19 二叉树第六天

---

---

一、力扣530–二叉搜索树的最小绝对差

代码随想录题目链接：代码随想录

给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。
差值是一个正数，其数值等于两值之差的绝对值。

用昨天的想法，对二叉搜索树中序遍历就能得到递增的数组，计算每个变量之间的差就行了

不过代码随想录在这里使用了双指针法还是挺有意思的

因为实际上中序遍历的结果是数组，对数组求最小差是可以用双指针的，即构建这个数组的同时就计算数组中连续元素的差

代码如下：

class Solution {
public:
    int result = INT_MAX;
    TreeNode * pre = nullptr;
    void traversal(TreeNode * curr)
    {
        if(!curr) return;
        traversal(curr->left);
        if(pre) result = min(curr->val - pre->val, result);
        pre = curr;
        traversal(curr->right);
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

算是对双指针加深理解

二、力扣501–二叉搜索树中的众数

代码随想录题目链接：代码随想录

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。
如果树中有不止一个众数，可以按 任意顺序 返回。
假定 BST 满足如下定义：
结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树

正常思路就是中序遍历，再记录每个数字的出现次数，返回即可

所以本质上是统计数组的众数，能不能在构建数组的时候就统计好呢，是可以的，用一个vector来记录这些结果就行

那么只需要在遍历当前节点的时候，判断一下是否与上一个节点一样，一样则计数加一

否则说明是新的数字了，那么计数清0，重新计数

同时判断计数是否是当前最大的，如果相同就记录，大于了就把结果清空，放入新的结果

代码如下：

class Solution {
public:
    vector<int> result;
    int maxCount = 0;
    int currCount = 0;
    TreeNode * pre = nullptr;
    void traversal(TreeNode * curr)
    {
        if(!curr) return;
        traversal(curr->left);

        if(!pre) currCount = 1;
        else if(pre->val == curr->val) currCount++;
        else currCount = 1;

        pre = curr;
        
        if(currCount == maxCount) result.push_back(curr->val);
        if(currCount > maxCount)
        {
            maxCount = currCount;
            result.clear();
            result.push_back(curr->val);
        }

        
        traversal(curr->right);
    }
    vector<int> findMode(TreeNode* root) {
        currCount = 0;
        maxCount = 0;
        pre = nullptr;
        result.clear();
        traversal(root);
        return result;
    }
};

三、力扣236–二叉树的最近公共祖先

代码随想录题目链接：代码随想录

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

这种涉及深度搜索的问题，应当自然地想到回溯法，尤其是需要自下而上的搜索时，基本上就是回溯法了

而设计递归算法的思路是，递归检查左右子树，当检查到q，就返回q，检查到p，就返回p，如果两个树的返回均不为空，说明本节点是最近祖先，就返回本节点

如果左子树为空，右子树不为空，就返回右子树，另外一种情况同理

因为如果搜索到了之后，祖先节点会作为本次递归的结果返回上去，没搜索到就是null，那么只要把这个节点继续往回传就行

如果写成栈就更容易理解了，一层一层传递上去

代码如下：

 class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == q || root == p || root == NULL) return root;
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);

        if(left && right) return root;
        else if(left) return left;
        else if(right) return right;
        else return NULL;
    }   
};