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

文档讲解：代码随想录

视频讲解：代码随想录B站账号

状态：看了视频题解和文章解析后做出来了

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

# 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.pre = None
        self.result = float('inf')

    def traversal(self, cur):
        if not cur:
            return
        self.traversal(cur.left)
        if self.pre:
            self.result = min(self.result, cur.val - self.pre.val)
        self.pre = cur
        self.traversal(cur.right)

    def getMinimumDifference(self, root):
        self.traversal(root)
        return self.result

中序遍历法：因为是二叉搜索树，所以使用中序遍历会从大到小遍历节点，就是一个升序的列表。通过遍历这个列表，计算相邻元素的差并更新class variable result上面。

class Solution:
    def getMinimumDifference(self, root):
        stack = []
        pre = None
        cur = root
        result = float('inf')

        while cur is not None or len(stack) > 0:
            if cur is not None:
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()
                if pre is not None:
                    result = min(result, cur.val - pre.val)
                pre = cur
                cur = cur.right

        return result

回溯法：回溯法也是先一路向北，遇到null节点再开始处理，然后处理右节点，和中序遍历一个道理。值得注意的是，代码使用了if else条件，使得没有左节点的时候再进入else语句。

501.二叉搜索树中的众数

class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        stack = []
        pre = None
        cur = root
        mode_num = 1
        cur_num = 1
        result = []

        while cur or len(stack) > 0:
            if cur:
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()
                if pre and pre.val == cur.val:
                    cur_num += 1
                    mode_num = max(mode_num, cur_num)
                else:
                    cur_num = 1
                pre = cur
                cur = cur.right

        stack = []
        pre = None
        cur = root

        while cur or len(stack) > 0:
            if cur:
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()
                if pre and pre.val == cur.val:
                    cur_num += 1
                    if cur_num == mode_num:
                        result.append(cur.val)
                else:
                    cur_num = 1
                    if cur_num == mode_num:
                        result.append(cur.val)

                pre = cur
                cur = cur.right

        return result

回溯法：因为还是二叉搜索树，使用中序的方法遍历树形成升序数组。本题需要遍历两次树，第一次得到众数的出现次数，第二次遍历得到出现了这么多次的数字，并加入到结果列表中。

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

class Solution:
    def lowestCommonAncestor(self, root, p, q):
        if root == q or root == p or root is None:
            return root

        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)

        if left is not None and right is not None:
            return root

        if left is None and right is not None:
            return right
        elif left is not None and right is None:
            return left
        else: 
            return None