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

1. 第一想法

深度优先遍历，最好是中序遍历（因为是二叉搜索数），得到的结果一定是一个有序数组，然后就挨个做差，找最小就行。

# 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.ordered_list = []
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        node_stack = [root]
        while node_stack:
            node = node_stack.pop()
            if (not node.left) and (not node.right):
                self.ordered_list.append(node.val)
                continue
            if node.right:
                node_stack.append(node.right)
            node_stack.append(TreeNode(node.val))
            if node.left:
                node_stack.append(node.left)
        self.ordered_list
        min_diff = self.ordered_list[-1] - self.ordered_list[0]
        for idx in range(len(self.ordered_list) - 1):
            diff = abs(self.ordered_list[idx + 1] - self.ordered_list[idx])
            min_diff = min(diff, min_diff)
        return min_diff

2. 学习时长

20分钟。

501. 二叉搜索树中的众数

1. 第一想法

可以是直接中序遍历得到一个有序数组，然后在数组上实现众数统计。

2. 文档

代码随想录 (programmercarl.com)

用双指针遍历一次二叉搜索树即可。

中序遍历的过程中，pre指针和cur指针不断前进。

# 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.count = 0
        self.max_count = 0
        self.res_list = []

    def mid_dfs(self, cur):
        if cur is None:
            return
        else:
            self.mid_dfs(cur=cur.left)
            
            if self.pre is None:
                self.count = 1
            elif self.pre.val == cur.val:
                self.count += 1
            else:
                self.count = 1

            self.pre = cur

            if self.count == self.max_count:
                self.res_list.append(cur.val)
            if self.count > self.max_count:
                self.max_count = self.count
                self.res_list = []
                self.res_list.append(cur.val)
            
            self.mid_dfs(cur=cur.right)

            return

            self.mid_dfs(cur=cur.right)

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

3. 学习时长

30分钟 好难，下次应该再做一次。这两个指针的移动时机，以及结果的更新时机。

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

1. 直接看文章

代码随想录 (programmercarl.com) 如果递归遍历遇到q，就将q返回，遇到p 就将p返回，那么如果 左右子树的返回值都不为空，说明此时的中节点，一定是q 和p 的最近祖先。 如果找到一个节点，发现左子树出现结点p，右子树出现节点q，或者 左子树出现结点q，右子树出现节点p，那么该节点就是节点p和q的最近公共祖先。

# 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 (not root) or (root.val == p.val) or (root.val == q.val):
            return root
        else:
            node1 = self.lowestCommonAncestor(root.left, p, q)
            node2 = self.lowestCommonAncestor(root.right, p, q)
            if node1 and node2:
                return root
            if (not node1) and node2:
                return node2
            if node1 and (not node2):
                return node1
            if (not node1) and (not node2):
                return None

2. 学习时长

20分钟，需要重写。