【力扣hot100】刷题笔记Day13

小涛44

已于 2024-08-23 15:42:22 修改

阅读量915

点赞数 5

分类专栏：力扣hot100刷题笔记文章标签： leetcode 笔记算法职场和发展数据结构 python

于 2024-02-24 16:28:22 首次发布

本文链接：https://blog.csdn.net/qq_56077562/article/details/136268905

版权

力扣hot100刷题笔记专栏收录该内容

27 篇文章 0 订阅

订阅专栏

前言

元宵节快乐 ~ 周六在图书馆快乐刷题！继续二叉树🍴

543. 二叉树的直径 - 力扣（LeetCode）

递归后序

class Solution:
    def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
        self.res = 0  # 记录最长路径
        # 递归求最大深度
        def depth(node):
            if not node:
                return 0
            l = depth(node.left)   # 左子树最大深度
            r = depth(node.right)  # 右子树最大深度
            self.res = max(self.res, l + r)  # 两边深度相加就是最长路径
            return max(l, r) + 1  # 返回当前最大深度
        depth(root)
        return self.res

108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode）

递归前序

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        def helper(left, right):
            if left > right: return     # left == right也可以返回一个结点
            mid = (left + right) // 2
            root = TreeNode(nums[mid])         # 构造根节点
            root.left = helper(left, mid-1)    # 比根节点小的为左子树
            root.right = helper(mid+1, right)  # 比根节点大的为右子树
            return root
        return helper(0, len(nums)-1)

98. 验证二叉搜索树 - 力扣（LeetCode）

递归BST

容易忽略上下界问题，详看题解

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        # 递归判断当前结点的值是否在上下界内
        def helper(node, minVal, maxVal):
            if not node:
                return True
            # 每个节点如果超过这个范围，直接返回false
            if node.val >= maxVal or node.val <= minVal:
                return False
            # 左子树范围的最小值是minVal，最大值是当前节点的值，因为左子树的值要比当前节点小
            l = helper(node.left, minVal, node.val)
            # 右子树范围的最大值是maxVal，最小值是当前节点的值，因为右子树的值要比当前节点大
            r = helper(node.right, node.val, maxVal)
            return l and r
        # 初始上下界无限大，python用浮点数表示整数最大最小
        return helper(root, -float('inf'), float('inf'))

递归中序

class Solution:
    # def __init__(self):
    #     self.pre = None  # 公共变量
    
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        self.pre = None  # 私有变量，记录上一个结点
        def helper(root):
            if not root: return True
            l = helper(root.left)   # 左
            if self.pre and self.pre.val >= root.val:
                return False        # 中
            self.pre = root
            r = helper(root.right)  # 右
            return l and r
        return helper(root)

迭代中序

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        st = []
        pre = -float('inf')
        while st or root:
            while root:
                st.append(root)
                root = root.left
            temp = st.pop()
            if temp.val <= pre:
                return False
            pre = temp.val
            root = temp.right
        return True

230. 二叉搜索树中第K小的元素 - 力扣（LeetCode）

迭代中序

class Solution:
    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
        st = []
        while st or root:
            while root:
                st.append(root)
                root = root.left
            temp = st.pop()
            k -= 1
            if k == 0: 
                return temp.val  # 遍历到第k个结点
            root = temp.right

优化查找

# 扩展TreeNode
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
        self.node_num = 0  # 以该结点为根结点的子树的结点数

# 构造可供查找的MyBst类
class MyBst:
    def __init__(self, root: TreeNode):
        self.root = root
        self._count_node_num(root)  # 初始化时计算每个结点为根结点的子树的结点数

    def kth_smallest(self, k: int):
        node = self.root
        while node:
            left = node.left.node_num if node.left else 0  # 获取左子树的结点数
            if left < k - 1:
                node = node.right  # 移动到右子树查找
                k -= left + 1  # 更新 k 值
            elif left == k - 1:
                return node.val  # 当前结点即为第 k 小的结点
            else:
                node = node.left  # 移动到左子树查找

    def _count_node_num(self, node) -> int:
        if not node:
            return 0
        # 递归计算以当前结点为根结点的子树的结点数
        node.node_num = 1 + self._count_node_num(node.left) + self._count_node_num(node.right)
        return node.node_num  # 返回以当前结点为根结点的子树的结点数

class Solution:
    def kthSmallest(self, root: TreeNode, k: int) -> int:
        bst = MyBst(root)
        return bst.kth_smallest(k)  # 调用 MyBst 类的方法来找出第 k 小的结点的值

199. 二叉树的右视图 - 力扣（LeetCode）

迭代层序BFS

class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if not root: return []
        res = []
        q = deque()
        q.append(root)
        while q:
            n = len(q)  # 先存长度以防变化
            for i in range(n):
                cur = q.popleft()
                if cur.left: q.append(cur.left)
                if cur.right: q.append(cur.right)
                if i == n - 1:  # 本层最后一个结点
                    res.append(cur.val)
        return res

递归逆先序DFS

# 思路类似【层序遍历】的 DFS递归
class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        self.res = []
        # 传入层当前深度
        def dfs(root, depth):
            if not root: return
            if depth == len(self.res):
                self.res.append(root.val)  # 中
            dfs(root.right, depth + 1)     # 右
            dfs(root.left, depth + 1)      # 左
        dfs(root, 0)
        return self.res