代码随想录算法训练营第二十一天| LeetCode530.二叉搜索树的最小绝对差 、LeetCode501.二叉搜索树中的众数、LeetCode236. 二叉树的最近公共祖先

一、LeetCode530.二叉搜索树的最小绝对差

        1：题目描述（530.二叉搜索树的最小绝对差）

        给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

        差值是一个正数，其数值等于两值之差的绝对值。

        2：解题思路

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        # 二叉搜索树，使用中序遍历得到的节点数值是递增的
        # 所以使用中序遍历，判断两个相邻节点的差值是否为最小差值
        # 递归
        # 使用中序遍历，将节点的值写入数组，然后取比较数组中相邻两个数的最小差值
        min_val = float("INF")         # 比较最小值，初始化为最大值
        res = []
        def getmin(cur):
            if not cur:
                return 
            # 向左遍历
            if cur.left:
                getmin(cur.left)
            res.append(cur.val)
            # 向右遍历
            if cur.right:
                getmin(cur.right)
            return res
        getmin(root)
        for i in range(len(res)-1):
            min_val = min(min_val, res[i+1]-res[i])
        return min_val

        # 迭代法-中序遍历
        stack = []            # 定义一个栈，用来存遍历过的节点
        cur = root            # 定义一个指针，指向当前遍历的节点
        pre = None            # 指针，指向上一个节点
        min_val = float("INF")
        while cur or stack:
            if cur:
                # 指针访问节点，一直访问到叶子节点
                stack.append(cur.val)
                cur = cur.left
            else:
                # 当碰到叶子节点，就从栈stack中弹出节点
                cur = stack.pop()
                if pre:
                    # pre不为空，就比较最小差值与当前节点和上一个节点的差值
                    min_val = min(min_val, cur.val - pre.val)
                # pre为空，或比较完之后，将当前节点赋值给pre，进行下一次比较
                pre = cur
                cur = cur.right
        return min_val

二、LeetCode501.二叉搜索树中的众数

        1：题目描述（501.二叉搜索树中的众数）

        给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。

        如果树中有不止一个众数，可以按 任意顺序 返回。

        假定 BST 满足如下定义：

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

        2：解题思路

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def __init__(self):
        self.res = []
        self.count = 0
        self.maxcount = 0
        self.pre = TreeNode()

    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        
        self.getcount(root)
        return self.res

    def getcount(self, cur):
        if cur == None:
            return 
        # 向左遍历
        self.getcount(cur.left)
        # 如果pre为None，则说明是遍历的是第一个节点,统计当前节点的次数，为1
        if self.pre == None: self.count = 1
        # 如果pre指针的对应节点的值，等于当前节点的值,节点出现的次数+1
        if self.pre.val == cur.val: self.count += 1
        # 如果pre指针的对应节点的值小于当前节点的值，则将当前节点出现的次数置为1
        else: self.count = 1
        # 比较完值之后，需要将当前节点赋值给pre，以便进行下次遍历
        self.pre = cur

        # 如果count==maxcount，则说明有多个节点出现的次数一样
        if self.count == self.maxcount: self.res.append(cur.val)
        # 如果count>maxcount ，则说明当前节点出现的次数大于之前的节点
        if self.count > self.maxcount:
            self.maxcount = self.count
            # 先清空res
            self.res.clear()
            # 再加入当前节点
            self.res.append(cur.val)
        # 向右遍历
        self.getcount(cur.right)

        return self.res

三、LeetCode236. 二叉树的最近公共祖先

        1：题目描述（236. 二叉树的最近公共祖先）

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

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

        2：解题思路

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if root == None:
            return None
        # 当当前节点等于p或q时，向上返回当前节点
        if root == p or root == q:
            return root
        # 向左遍历
        left = self.lowestCommonAncestor(root.left, p, q)
        # 向右遍历
        right = self.lowestCommonAncestor(root.right, p, q)
        # 中，处理中间逻辑
        if left != None and right != None:
            # 当当前节点的左右子树的返回值均不为None时，说明找到了两个节点最近的公共祖先
            # 就返回当前节点
            return root
        elif left == None and right != None:
            # 当当前节点的左子树为空，右子树不为空，说明在右子树中找到了其中p、q其中的一个
            # 返回右子树中找到的节点
            return right
        elif left != None and right == None:
            # 当当前节点的左子树不为空，右子树为空，说明在左子树中找到了其中p、q其中的一个
            # 返回左子树中找到的节点
            return left
        # 当前节点的左右子树均为空，说明没有找到p、q，返回None
        return None