算法训练第16天|530.二叉搜索树的最小绝对差|501.二叉搜索树中的众数|236. 二叉树的最近公共祖先

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

题目链接：530.二叉搜索树的最小绝对差

题目讲解：代码随想录

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

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func getMinimumDifference(root *TreeNode) int {
    var prev *TreeNode
    min := math.MaxInt64

    var f func(node *TreeNode)
    f = func(node *TreeNode){
        if node == nil{
            return 
        }

        f(node.Left)
        if prev != nil && node.Val - prev.Val < min{
            min = node.Val - prev.Val
        }
        prev = node
        f(node.Right)
    }

    f(root)
    return min
}

LeetCode 501.二叉搜索树中的众数

题目链接：501.二叉搜索树中的众数

题目讲解：代码随想录

题目描述：给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有众数（即，出现频率最高的元素）。如果树中有不止一个众数，可以按 任意顺序 返回。

假定 BST 满足如下定义：

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

因为是二叉搜索树，所以要考虑使用中序遍历。 

最简单的思路就是 先中序遍历拿到有序的数组，然后再根据有序数组统计出现频率最高的元素。但这样要经历中序遍历+有序数组统计每个元素的出现频次+找出所有出现频次等于最大频次的元素。

另一种思路直接通过一次中序遍历得到众数：

• 中序遍历的过程中，如果当前节点的值等于前一个节点的值，则count++；如果不等于则count置为1。
• 当count的值大于等于最大值max时（说明当前的值为众数），把当前节点的值放入结果集中。如果count的值大于max并且结果集不为空，则把当前结果集重新初始化并把当前值放入结果集中。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func findMode(root *TreeNode) []int {
    res := make([]int, 0)
    count := 1
    max := 1

    var prev *TreeNode
    var travel func(node *TreeNode)
    travel = func(node *TreeNode){
        if node == nil{
            return 
        }

        travel(node.Left)

        if prev != nil && prev.Val == node.Val{
            count++
        }else{
            count = 1 // 当前
        }

        if count >= max{
            if count > max && len(res) > 0{
                res = []int{node.Val} // 重置res
            }else{
                res = append(res, node.Val)
            }
            max = count
        }
        prev = node
        travel(node.Right)
    }
    travel(root)
    return res
}

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

题目链接：236. 二叉树的最近公共祖先

题目讲解：代码随想录

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

遇到这个题目首先想的是要是能自底向上查找就好了，这样就可以找到公共祖先了。

后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。

判断逻辑是 如果递归遍历遇到q，就将q返回，遇到p 就将p返回，那么如果 左右子树的返回值都不为空，说明此时的中节点，一定是q 和p 的最近祖先。

使用递归：       

• 确定递归函数返回值以及参数，需要递归函数返回值，来告诉我们是否找到节点q或者p。
• 确定终止条件，遇到空的话，因为树都是空了，所以返回空；如果 root == q，或者 root == p，说明找到 q p ，则将其返回。
• 确定单层递归逻辑，值得注意的是 本题函数有返回值，是因为回溯的过程需要递归函数的返回值做判断，但本题我们依然要遍历树的所有节点。如果递归函数有返回值，如何区分要搜索一条边，还是搜索整个树呢？

搜索一条边的写法：

if (递归函数(root->left)) return ;

if (递归函数(root->right)) return ;

搜索整个树的写法：

left = 递归函数(root->left);  // 左
right = 递归函数(root->right); // 右
left与right的逻辑处理;         // 中 

在递归函数有返回值的情况下：如果要搜索一条边，递归函数返回值不为空的时候，立刻返回，如果搜索整个树，直接用一个变量left、right接住返回值，这个left、right后序还有逻辑处理的需要，也就是后序遍历中处理中间节点的逻辑（也是回溯）。 

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
 func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
    if root == nil{
        return root
    }

    if root == p || root == q{
        return root 
    }

    // 判断当前节点是否为p或者q
    left := lowestCommonAncestor(root.Left, p, q)
    right := lowestCommonAncestor(root.Right, p, q)

    if left != nil && right != nil{
        return root
    }

    if left != nil{
        return left
    }

    if right != nil{
        return right
    }
    
    return nil
}