代码随想录算法训练营第十五天 | 层序遍历 10道题、226.翻转二叉树、101.对称二叉树 2

ordaaaaaa

已于 2023-04-24 21:38:00 修改

阅读量50

点赞数

文章标签： html 前端

于 2023-04-24 21:35:56 首次发布

本文链接：https://blog.csdn.net/ordaaaaaa/article/details/130318771

版权

层序遍历 10

102.二叉树的层序遍历

注意一开始要定义一个二维数组，一个个一维数组组成二维数组

# 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        results = []  #二维数组
        if not root:
            return results
        
        from collections import deque
        que = deque([root])    #把根节点加入队列里

        #开始遍历，终止条件是队列空
        while que:
            size = len(que)
            result = []   #一维数组
            for _ in range(size):
                cur = que.popleft()
                result.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            results.append(result)
        return results

107.二叉树的层次遍历II

# 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 levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        results = []
        if not root:
            return results

        from collections import deque
        que = deque([root])

        while que:
            result = []
            size = len(que)
            for _ in range(size):
                cur = que.popleft()
                result.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            results.append(result)

        results.reverse()
        return results

199.二叉树的右视图

每次都取最后一个node

# 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: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        
        from collections import deque
        que = deque([root])
        result = []

        while que:
            node = que[-1]
            result.append(node.val)
            size = len(que)
            for _ in range(size):
                node = que.popleft()
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)

        return result

637.二叉树的层平均值

# 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 averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        result = []
        if not root:
            return result

        from collections import deque
        que = deque([root])

        while que:
            size = len(que)
            sum = 0
            for _ in range(size):
                cur = que.popleft()
                sum += cur.val
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            result.append(sum/size)
        return result

429.N叉树的层序遍历

list.extend(L) 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):]= L

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        results = []
        if not root:
            return results

        from collections import deque
        que = deque([root])

        while que:
            result = []
            size = len(que)
            for _ in range(size):
                cur = que.popleft()
                result.append(cur.val)
                if cur.children:
                    que.extend(cur.children)
            results.append(result)
        return results

515.在每个树行中找最大值

class Solution:
    def largestValues(self, root: TreeNode) -> List[int]:
        if root is None:
            return []
        queue = [root]
        out_list = []
        while queue:
            length = len(queue)
            in_list = []
            for _ in range(length):
                curnode = queue.pop(0)
                in_list.append(curnode.val)
                if curnode.left: queue.append(curnode.left)
                if curnode.right: queue.append(curnode.right)
            out_list.append(max(in_list))
        return out_list

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

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if not root:
            return
        que = [root]
        while que:
            size = len(que)
            for i in range(size):
                node = que.pop(0)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
                if i == size - 1:
                    break
                node.next = que[0]
        return root

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

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return
        que = [root]
        while que:
            size = len(que)
            tail = None
            for i in range(size):
                cur = que.pop(0)
                if tail:
                    tail.next = cur
                tail = cur
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return root

104.二叉树的最大深度

# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0
        que = [root]
        depth = 0
        while que:
            size = len(que)
            for i in range(size):
                node = que.pop(0)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            depth += 1
        return depth

111.二叉树的最小深度

# 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 minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        que = [root]
        res = 1  #初始值为1
        while que:
            size = len(que)
            for _ in range(size):
                node = que.pop(0)
                if not node.left and not node.right:
                    return res
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            res += 1

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if root == None:
            return 0

        #根节点的深度为1
        queue_ = [(root,1)]
        while queue_:
            cur, depth = queue_.pop(0)

            if cur.left == None and cur.right == None:
                return depth
            #先左子节点，由于左子节点没有孩子，则就是这一层了
            if cur.left:
                queue_.append((cur.left,depth + 1))
            if cur.right:
                queue_.append((cur.right,depth + 1))

        return 0

226.翻转二叉树

注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果

使用前序遍历和后序遍历都比较方便，唯独中序遍历，因为中序遍历会把某些节点的左右孩子翻转了两次,所以中序遍历需要处理两边左孩子

# 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        #递归法
        # if not root:
        #     return None
        #前序
        # root.left,root.right = root.right,root.left
        # self.invertTree(root.left)
        # self.invertTree(root.right)
        # return root
        #后序
        # self.invertTree(root.left)
        # self.invertTree(root.right)        
        # root.left,root.right = root.right,root.left
        # return root
        #中序
        # self.invertTree(root.left)
        # root.left,root.right = root.right,root.left
        # self.invertTree(root.left)  
        # return root          


        #迭代法
        #深度优先遍历（前序遍历）
        # if not root:
        #     return None
        # que = [root]
        # while que:
        #     node = que.pop()
        #     node.left,node.right = node.right,node.left  #中
        #     if node.right:
        #         que.append(node.right)    #右
        #     if node.left:
        #         que.append(node.left)     #左
        # return root


        #迭代法
        #广度优先遍历（层序遍历)
        # if not root:
        #     return None

        # que = [root]
        # while que:
        #     size = len(que)
        #     for i in range(size):
        #         node = que.pop(0)
        #         node.left,node.right = node.right,node.left
        #         if node.left:
        #             que.append(node.left)
        #         if node.right:
        #             que.append(node.right)
        # return root

101.对称二叉树 2

难点一：为什么要用后序遍历

因为要从下往上，才能告诉父节点，下面两个可以互相翻转，也就是左右中，后序

难点二：如何比较，用左孩子的左孩子和右孩子的右孩子比较

# 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 isSymmetric(self, root: Optional[TreeNode]) -> bool:

        if not root:
            return True
        return self.compare(root.left,root.right)

    def compare(self,left,right):
            #排除空节点的情况
        if left == None and right != None: return False
        elif left != None and right == None: return False
        elif left == None and right == None: return True
            #排除排除数值不相同的情况
        elif left.val != right.val: return False

            #此时就是：左右节点都不为空，且数值相同的情况
            #此时才做递归，做下一层的判断   
        outside = self.compare(left.left,right.right)#左子树：左、 右子树：右
        inside = self.compare(left.right,right.left) #左子树：右、 右子树：左
        isSame = outside and inside     #左子树：中、 右子树：中 （逻辑处理）   
        return isSame



迭代法  使用队列
import collections
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        queue = collections.deque()
        queue.append(root.left) #将左子树头结点加入队列
        queue.append(root.right) #将右子树头结点加入队列
        while queue: #接下来就要判断这这两个树是否相互翻转
            leftNode = queue.popleft()
            rightNode = queue.popleft()
            if not leftNode and not rightNode: #左节点为空、右节点为空，此时说明是对称的
                continue
            
            #左右一个节点不为空，或者都不为空但数值不相同，返回false
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            queue.append(leftNode.left) #加入左节点左孩子
            queue.append(rightNode.right) #加入右节点右孩子
            queue.append(leftNode.right) #加入左节点右孩子
            queue.append(rightNode.left) #加入右节点左孩子
        return True




迭代法：使用栈
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        st = [] #这里改成了栈
        st.append(root.left)
        st.append(root.right)
        while st:
            rightNode = st.pop()
            leftNode = st.pop()
            if not leftNode and not rightNode:
                continue
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            st.append(leftNode.left)
            st.append(rightNode.right)
            st.append(leftNode.right)
            st.append(rightNode.left)
        return True


层序遍历
class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True

        que = [root]
        while que:
            this_level_length = len(que)
            for i in range(this_level_length // 2):
                # 要么其中一个是None但另外一个不是
                if (not que[i] and que[this_level_length - 1 - i]) or (que[i] and not que[this_level_length - 1 - i]):
                    return False
                # 要么两个都不是None
                if que[i] and que[i].val != que[this_level_length - 1 - i].val:
                    return False
            for i in range(this_level_length):
                if not que[i]: continue
                que.append(que[i].left)
                que.append(que[i].right)
            que = que[this_level_length:]
        return True

今日学习的文章链接

力扣

自己看到题目的第一想法

毫无头绪

看完代码随想录之后的想法

自己实现过程中遇到哪些困难

今日收获，记录一下自己的学习时长

ordaaaaaa

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第十五天 | 层序遍历 10道题、226.翻转二叉树、101.对称二叉树 2

使用前序遍历和后序遍历都比较方便，唯独中序遍历，因为中序遍历会把某些节点的左右孩子翻转了两次,所以中序遍历需要处理两边左孩子。因为要从下往上，才能告诉父节点，下面两个可以互相翻转，也就是左右中，后序。注意一开始要定义一个二维数组，一个个一维数组组成二维数组。注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果。难点二：如何比较，用左孩子的左孩子和右孩子的右孩子比较。117.填充每个节点的下一个右侧节点指针II。116.填充每个节点的下一个右侧节点指针。102.二叉树的层序遍历。
复制链接

扫一扫