代码随想录算法训练营第十五天

最新推荐文章于 2024-10-16 19:08:56 发布

0Oo�

最新推荐文章于 2024-10-16 19:08:56 发布

阅读量251

点赞数 1

文章标签：算法 leetcode 职场和发展

本文链接：https://blog.csdn.net/weixin_52746258/article/details/139460038

版权

102. 二叉树的层序遍历

非递归写法

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

队列先进先出，用来对层遍历

1、每一层对应一次for循环，从左至右每个元素以此出队列，并将左节点和右节点入队列。

2、使用temp暂存每一层的遍历结果，每完成一层后将结果加入result。

3、最终生成的是一个二维列表，每一个子列表都是每一层的节点值。

116. 填充每个节点的下一个右侧节点指针

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if root is None: return root
        queue = deque()
        queue.append(root)
        while queue:
            pre = None
            for i in range(len(queue)):
                cur = queue.popleft()
                if pre:
                    pre.next = cur
                pre = cur
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
        return root

在遍历每层节点之前，定义一个前缀节点为None，这个空节点指向每层节点的第一个元素。

每遍历一个节点就将指针向右推一次，保证每个pre都能指向当前遍历的节点

111. 二叉树的最小深度

104. 二叉树的最大深度

for最大深度，直接按层序遍历的方法输出len(result)即可

for最小深度：

只有当左右孩子都为空的时候，才说明遍历的最低点了，如果其中一个孩子为空则不是最低点

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        depth = 0
        queue = deque()       
        queue.append(root) 
        while queue:
            depth += 1 
            for _ in range(len(queue)):
                node = queue.popleft()                
                if not node.left and not node.right:
                    return depth           
                if node.left:
                    queue.append(node.left)                   
                if node.right:
                    queue.append(node.right)
        return depth

226. 翻转二叉树

递归写法：

确定递归参数和返回值，确定终止条件，确定单层递归的逻辑

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if root is None: return 
        tmp = root.left
        root.left = self.invertTree(root.right)
        root.right = self.invertTree(tmp)
        return root

非递归写法（层序遍历）

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root: 
            return 
        queue = deque([root])    
        while queue:
            for i in range(len(queue)):
                node = queue.popleft()
                node.left, node.right = node.right, node.left
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
        return root

101. 对称二叉树

对称二叉树的判断：

左树的左节点和右树的右节点，左树的右节点和右树的左节点是否相同

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if root is None:return True
        def compare(left,right):
            if left is None and right is None:
                return True
            elif left is None or right is None or left.val != right.val:
                return False
            else:
                return compare(left.left,right.right) and compare(left.right,right.left)
        return compare(root.left,root.right)