代码随想录第21天 | 530. 二叉搜索树的最小绝对差、501. 二叉搜索树中的众数、236. 二叉树的最近公共祖先

一定要先想遍历顺序！！！
如果是二叉搜索树，必须第一时间想到中序遍历！！！

530. 二叉搜索树的最小绝对差

因为是二叉搜索树，求树中的最小绝对差直接比较中序遍历下相邻节点的差就行了。

在树中也可以用双指针法，用一个pre节点记录一下cur节点的前一个节点。pre的初始值为空，因为中序遍历开始第一个节点是叶子节点，那么它的前一个节点就是空了。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var getMinimumDifference = function (root) {
    let result = Infinity;
    let pre = null;
    const inorder = node => {
        if (node === null) return;
        inorder(node.left);
        if (pre !== null) {
            result = Math.min(result, node.val - pre.val);   
        }
        pre = node;
        inorder(node.right);
    }
    inorder(root);
    return result;
};

501. 二叉搜索树中的众数

既然是二叉搜索树，那么中序遍历就是有顺序的，继续使用双指针，弄一个指针指向前一个节点，这样每次cur（当前节点）才能和pre（前一个节点）作比较。而且初始化的时候pre = NULL，这样当pre为NULL时候，我们就知道这是比较的第一个元素。

如果 频率count 等于 maxCount（最大频率），当然要把这个元素加入到结果集中。频率count 大于 maxCount的时候，不仅要更新maxCount，而且要清空结果集，因为结果集之前的元素都失效了。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var findMode = function (root) {
    let count = 0, maxCount = 1;
    let pre = null, res = [];
    const travelTree = function (cur) {
        if (cur === null) {
            return;
        }
        travelTree(cur.left);
        if (pre === null) {
            count++;
        }
        else if (pre.val === cur.val) {
            count++;
        }
        else {
            count = 1;
        }
        pre = cur;
        if (count === maxCount) {
            res.push(cur.val);
        }
        if (count > maxCount) {
            res = [];
            maxCount = count;
            res.push(cur.val);
        }
        travelTree(cur.right);
    }
    travelTree(root);
    return res;
};

236. 二叉树的最近公共祖先

想找到祖先，就要自底向上查找。后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。

递归三部曲：

1. 如果遇到p或者q，就把q或者p返回，返回值不为空，就说明找到了q或者p。
2. 遇到空的话，因为树都是空了，所以返回空。如果 root == q，或者 root == p，说明找到 q p ，则将其返回，这个返回值，后面在中节点的处理过程中会用到。
3. 如果 root == q，或者 root == p，说明找到 q p ，则将其返回，这个返回值，后面在中节点的处理过程中会用到。在递归函数有返回值的情况下：如果要搜索一条边，递归函数返回值不为空的时候，立刻返回，如果搜索整个树，直接用一个变量left、right接住返回值，这个left、right后序还有逻辑处理的需要，也就是后序遍历中处理中间节点的逻辑（也是回溯）。

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function (root, p, q) {
    if (root === null) return null;
    if (root === p || root === q) return root;
    let left = lowestCommonAncestor(root.left, p, q);
    let right = lowestCommonAncestor(root.right, p, q);
    if (left === null && right === null) return null;
    else if (left !== null && right !== null) return root;
    else if (left === null && right !== null) return right;
    else if (left !== null && right === null) return left;
};