2022.08.23-力扣刷题（222、789、199、124、257、404）

最新推荐文章于 2023-09-08 05:07:30 发布

QFIUNE

最新推荐文章于 2023-09-08 05:07:30 发布

阅读量366

点赞数

分类专栏： LeetCode 文章标签： python leetcode 二叉树递归法

本文链接：https://blog.csdn.net/weixin_42038527/article/details/119857811

版权

LeetCode 专栏收录该内容

31 篇文章 1 订阅

订阅专栏

222. 完全二叉树的节点个数

题目链接： https://leetcode-cn.com/problems/count-complete-tree-nodes/

方法一：迭代法+层序遍历

# 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 countNodes(self, root: TreeNode) -> int:

        if not root:
            return 0
        
        if not root.left and not root.left:
            return 1
        
        from collections import deque
        queue = deque()
        queue.append(root)
        res = 0

        while queue:
            for _ in range(len(queue)):
                res += 1
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        
        return res

方法二：递归法+后序遍历

【递归三部曲】

参考：https://mp.weixin.qq.com/s/YstYGsL_2QJ5VsBhgIZFBw

（1）确定递归函数的参数和返回值：参数就是传入树的根节点，返回就返回以该节点为根节点二叉树的节点数量，所以返回值为int类型。

（2）确定终止条件：如果为空节点的话，就返回0，表示节点数为0。

（3）确定单层递归的逻辑：先求它的左子树的节点数量，再求的右子树的节点数量，最后取总和再加一 （加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 countNodes(self, root: TreeNode) -> int:

        if not root:
            return 0
        
        if not root.left and not root.left:
            return 1
        
        leftNodes = self.countNodes(root.left)
        rightNodes = self.countNodes(root.right)
        res = leftNodes + rightNodes + 1

        return res


'''精简版'''
class Solution:
    def countNodes(self, root: TreeNode) -> int:
        if not root:
            return 0
        return 1 + self.countNodes(root.left) + self.countNodes(root.right)

方法三：完全二叉树 + 数学计算

# 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 countNodes(self, root: TreeNode) -> int:

        if not root:
            return 0
        
        if not root.left and not root.left:
            return 1
        
        left = root.left
        right = root.right
        leftHeight = 0
        rightHeight = 0

        while left: # 求左子树深度
            left = left.left
            leftHeight += 1
        
        while right: # 求右子树深度
            right = right.right
            rightHeight += 1
        
        if leftHeight == rightHeight:
            return (2**leftHeight) - 1
        return self.countNodes(root.left) + self.countNodes(root.right) + 1

强调一波概念：

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。

二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。

关于根节点的深度究竟是1 还是 0，不同的地方有不一样的标准，leetcode的题目中都是以节点为一度，即根节点深度是1。

1646. 获取生成数组中的最大值

题目链接：1646. 获取生成数组中的最大值 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def getMaximumGenerated(self, n: int) -> int:
        dp = [0 for _ in range(n+1)]

        if n<2: return n

        dp[0] = 0
        dp[1] = 1

        for i in range(2, n+1):
            if i % 2 == 0:
                dp[i] = dp[i//2]  
            if i % 2 == 1:
                dp[i] = dp[i//2] + dp[i//2+1]

        return max(dp)

789. 逃脱阻碍者

题目链接：789. 逃脱阻碍者 - 力扣（LeetCode） (leetcode-cn.com)

class Solution:
    def escapeGhosts(self, ghosts: List[List[int]], target: List[int]) -> bool:
        '''曼哈顿距离'''
        dis = abs(target[0]-0) + abs(target[1]-0)

        for ghost in ghosts:
            if abs(ghost[0]-target[0]) + abs(ghost[1]-target[1]) <= dis:
                return False
        return True

199. 二叉树的右视图

题目链接：199. 二叉树的右视图 - 力扣（LeetCode） (leetcode-cn.com)

方法一：层序遍历

# 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 rightSideView(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        
        from collections import deque
        queue = deque()
        ans = []
        queue.append(root)
        
        while queue:
            cur = []

            for _ in range(len(queue)):
                node = queue.popleft()
                cur.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            
            ans.append(cur)
        
        res = [num[-1] for num in ans]

        return res

方法二：深度优先 + 层级前序遍历

# 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 rightSideView(self, root: TreeNode) -> List[int]:
        '''dfs-->层级前序遍历'''
        ans = []
        def dfs(root,level):
            if not root:
                return
            if len(ans) <= level:
                ans.append(root.val)
            else:
                ans[level] = root.val
            
            dfs(root.left, level+1)
            dfs(root.right, level+1)

            return
        
        dfs(root, 0)
        return ans

方法三：深度优先 + 层级逆序后序遍历

# 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 rightSideView(self, root: TreeNode) -> List[int]:
        '''dfs-->层级逆序后序遍历'''
        def dfs(root,level):
            if not root:
                return
            dfs(root.right, level+1)
            dfs(root.left, level+1)
            if level not in ans:
                ans[level] = root.val
        
        ans = {}
        dfs(root, 0)

        return list(i[1] for i in sorted(ans.items(), key=lambda item:item[0]))

124. 二叉树中的最大路径和

题目链接：124. 二叉树中的最大路径和 - 力扣（LeetCode） (leetcode-cn.com)

二叉树路径的问题大致可以分为两类：
1. 自顶向下：
顾名思义，就是从某一个节点(不一定是根节点)，从上向下寻找路径，到某一个节点(不一定是叶节点)结束
具体题目如下：
257. 二叉树的所有路径
面试题 04.12. 求和路径
112. 路径总和
113. 路径总和 II
437. 路径总和 III
988. 从叶结点开始的最小字符串

而继续细分的话还可以分成一般路径与给定和的路径

2. 非自顶向下：
就是从任意节点到任意节点的路径，不需要自顶向下
124. 二叉树中的最大路径和
687. 最长同值路径
543. 二叉树的直径

解题模板
这类题通常用深度优先搜索(DFS)和广度优先搜索(BFS)解决

作者：eh-xing-qing
链接：https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/solution/yi-pian-wen-zhang-jie-jue-suo-you-er-cha-kcb0/
来源：力扣（LeetCode）

参考：「手画图解」别纠结递归的细节 | 124.二叉树中的最大路径和 - 二叉树中的最大路径和 - 力扣（LeetCode） (leetcode-cn.com)

# 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 maxPathSum(self, root: TreeNode) -> int:
        '''后序遍历'''
        self.res = root.val
        def dfs(root):
            if not root: return 0
            l = dfs(root.left)
            r = dfs(root.right)

            self.res = max(self.res, root.val + l + r)
            maxSum = max(root.val + l, root.val + r)

            if maxSum < 0:
                return 0
            else: 
                return maxSum
        
        dfs(root)
        return self.res

257. 二叉树的所有路径

题目地址：https://leetcode-cn.com/problems/binary-tree-paths/

# 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 binaryTreePaths(self, root: TreeNode) -> List[str]:
        res = []
        path = []

        def dfs(root):
            if not root: return 
            path.append(root.val)
            # 到叶子节点就返回
            if not root.left and not root.right:
                # 将path[:]添加到结果中
                '''
                QFIUNE: 你帮我看看这个dfs里面的path加不进去res里面
                Julse: 你要加入到ans中的是切片
                Julse: 现在加进去的是地址，后面修改的时候就被改掉了
                '''
                res.append(path[:])
               
            dfs(root.left)
            dfs(root.right)
            path.pop()

        dfs(root)
        return ["->".join(list(map(str,i))) for i in res]

404.左叶子之和

题目地址：https://leetcode-cn.com/problems/sum-of-left-leaves/

方法一：迭代法 + stack

# 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 sumOfLeftLeaves(self, root: TreeNode) -> int:
        if not root:
            return 0
        
        stack = []
        stack.append(root)
        ans = 0

        while stack:
            curNode = stack.pop()
            
            # 判断是否是左叶子节点
            if curNode.left and not curNode.left.left and not curNode.left.right:
                ans += curNode.left.val
            
            if curNode.left:
                stack.append(curNode.left)
            if curNode.right:
                stack.append(curNode.right)
        
        return ans

方法二：递归 + 先序遍历

# 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 sumOfLeftLeaves(self, root: TreeNode) -> int:
        
        self.ans = 0

        def dfs(root):
            if not root: return 0
            if root.left and not root.left.left and not root.left.right:
                self.ans += root.left.val
            dfs(root.left)
            dfs(root.right)

        dfs(root)
        return self.ans

方法三：递归 + 后序遍历

# 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 sumOfLeftLeaves(self, root: TreeNode) -> int:
        
        self.ans = 0

        def dfs(root):
            if not root: return 0
            dfs(root.left)
            dfs(root.right)
            if root.left and not root.left.left and not root.left.right:
                self.ans += root.left.val

        dfs(root)
        return self.ans