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

501. 二叉搜索树中的众数

给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。

假定 BST 有如下定义：

结点左子树中所含结点的值小于等于当前结点的值 结点右子树中所含结点的值大于等于当前结点的值 左子树和右子树都是二叉搜索树 例如： 给定
BST [1,null,2,2],

1
\
2
/
2
返回[2].

第一种，直接用一个list存放中序遍历后的值

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

class Solution:
    def findMode(self, root: TreeNode) -> List[int]:
        # 中序遍历BST
        ls = []
        def inorder(node: TreeNode):
            if not node:
                return
            if node:
                # 先遍历当前结点的左子树
                inorder(node.left)
                # 然后遍历当前结点
                ls.append(node.val)
                # 最后遍历当前结点的右子树
                inorder(node.right)
        
        if root:
            inorder(root)

        ans = []
        if len(ls) == 0:
            return ans

        # 统计众数
        cnt = 1
        most = 1
        ans = [ls[0]]
        for i in range(1, len(ls)):
            if ls[i] == ls[i-1]:
                cnt += 1
                if cnt == most:
                    ans.append(ls[i])
                elif cnt > most:
                    most = cnt
                    ans = [ls[i]]
                else:
                    continue
            else:
                cnt = 1
                if cnt == most:
                    ans.append(ls[i])
                
            print(cnt, most)
                
        
        return ans

第二种，考虑节省空间，用一个last变量代替list

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

class Solution:
    def findMode(self, root: TreeNode) -> List[int]:
        ans = []
        cnt = 0
        most = 0
        last = None

        # 中序遍历BST，相当于升序排序
        def inorder(node: TreeNode):
            # 当前结点为空，直接返回
            if not node:
                return
            # 设置变量nonlocal，调用上层变量
            nonlocal ans, cnt, most, last
            # 左子树不为空，先去遍历左子树
            if node.left:
                inorder(node.left)
            # 遍历当前结点
            # 如果当前结点的值等于上一个值
            if node.val == last:
                # 计数器加1
                cnt += 1
            else:
                # 否则重新开始计数
                cnt = 1
            # 比较计数器和当前出现的最多次数
            # 如果相等，表明众数不止一个
            if cnt == most:
                ans.append(node.val)
            # 如果当前的值出现的次数较多
            elif cnt > most:
                # 更新most值
                most = cnt
                # 更新ans
                ans = [node.val]
            # 比较完成后，更新last为当前结点的值
            last = node.val
            # 如果右子树不为空，继续遍历右子树
            if node.right:
                inorder(node.right)
        
        inorder(root)
        return ans

补充：