hot100-part5-CSDN博客

本文链接：https://blog.csdn.net/weixin_51286653/article/details/147468321

41-二叉树的层序遍历

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []
        ans = []
        q = deque([root])
        while q:
            path = []
            for _ in range(len(q)):
                node = q.popleft()
                path.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            ans.append(path)
        return ans

42-将有序数组转换为二叉搜索树

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        if not nums:
            return
        n = len(nums)
        m = n // 2
        return TreeNode(
            nums[m], self.sortedArrayToBST(nums[:m]), self.sortedArrayToBST(nums[m+1:])
        )

43-验证二叉搜索树

前序：

class Solution:
    def isValidBST(self, root: Optional[TreeNode], left=-inf, right=inf) -> bool:
        if root is None:
            return True
        x = root.val
        return (
            left < x < right
            and self.isValidBST(root.left, left, x)
            and self.isValidBST(root.right, x, right)
        )

中序：

class Solution:
    pre = -inf

    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        if root is None:
            return True
        if not self.isValidBST(root.left):
            return False
        x = root.val
        if x <= self.pre:
            return False
        self.pre = x

        return self.isValidBST(root.right)

后序：

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        def dfs(node):
            if node is None:
                return inf, -inf
            l_min, l_max = dfs(node.left)
            r_min, r_max = dfs(node.right)
            x = node.val
            if x <= l_max or x >= r_min:
                return -inf, inf
            return min(x, l_min), max(x, r_max)

        return dfs(root)[1] != inf

44-二叉搜索树中第k小的元素

方法一比较好想

class Solution:
    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
        ans = 0

        def dfs(node):
            if node is None:
                return
            dfs(node.left)
            nonlocal k, ans
            k -= 1
            if k == 0:
                ans = node.val
            dfs(node.right)

        dfs(root)
        return ans

方法二：

class Solution:
    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
        def dfs(node):
            if node is None:
                return -1
            left_res = dfs(node.left)
            if left_res != -1:
                return left_res
            nonlocal k
            k -= 1
            if k == 0:
                return node.val
            return dfs(node.right)

        return dfs(root)

45-二叉树的右视图

也可以用层序

class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        ans = []

        def dfs(node, dep):
            if node is None:
                return
            dep += 1
            nonlocal ans
            if dep > len(ans):
                ans.append(node.val)
            dfs(node.right, dep)
            dfs(node.left, dep)

        dfs(root, 0)
        return ans

🌟46-二叉树展开为链表

class Solution:
    def flatten(self, root: Optional[TreeNode]) -> None:
        """
        Do not return anything, modify root in-place instead.
        """

        def dfs(node):
            if node is None:
                return
            left_tail = dfs(node.left)
            right_tail = dfs(node.right)
            if node.left:
                temp = node.right
                node.right = node.left
                node.left = None
                if left_tail:
                    left_tail.right = temp
                else:
                    node.right.right = temp
            '''
            链表合并完成后，返回合并后的链表的尾节点，也就是右子树链表的尾节点。
            如果右子树是空的，则返回左子树链表的尾节点。
            如果左右子树都是空的，返回当前节点。
            '''
            return right_tail or left_tail or node

        dfs(root)

47-从前序与中序遍历序列构造二叉树

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        if not preorder:
            return
        root = preorder[0]
        m = inorder.index(root)
        left = self.buildTree(preorder[1 : m + 1], inorder[:m])
        right = self.buildTree(preorder[m + 1 :], inorder[m + 1 :])

        return TreeNode(root, left, right)

🌟48-路径总和Ⅲ

class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> int:
        ans = 0
        cnt = Counter()
        cnt[0] = 1

        def dfs(node, s):
            if node is None:
                return
            s += node.val
            
            nonlocal ans
            ans += cnt[s - targetSum]
            cnt[s] += 1
            dfs(node.left, s)
            dfs(node.right, s)
            cnt[s] -= 1

        dfs(root, 0)
        return ans

49-二叉树的最近公共祖先

class Solution:
    def lowestCommonAncestor(
        self, root: "TreeNode", p: "TreeNode", q: "TreeNode") -> "TreeNode":
        if root in (p, q, None):
            return root
        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)

        # 如果两边都找到了说明p,q分布在两边，最近共公祖先就是当前根节点
        if right and left:
            return root
        # 如果都在一边，先找到谁谁就是最近公共祖先
        return left or right

50-二叉树中的最大路径和

class Solution:
    def maxPathSum(self, root: Optional[TreeNode]) -> int:
        ans = -inf

        def dfs(node):
            if node is None:
                return 0
            left = dfs(node.left)
            right = dfs(node.right)
            nonlocal ans
            ans = max(ans, left + right + node.val)

            return max(max(left, right) + node.val, 0)

        dfs(root)
        return ans