Python刷leetcode--102.二叉树的层序遍历

一般来说 数据结构 左面都是头，右面都是尾。新增操作也一般在右面。 [在右侧操作 ]

二叉树的层次遍历 [普通]

import collections


class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution:
    def levelOrder(self, root):
        # def levelOrder(self, root: TreeNode) -> List[List[int]]
        # 一、广度优先
        # 二、深入的时候+1  深度加一
        def generate_next_nodes(node, que):
            if node.left is not None:
                que.append(node.left)
            if node.right is not None:
                que.append(node.right)

        def bfs(a):
            que = collections.deque()
            que.append(a)
            while que:
                node = que.popleft()  # 先弹出来处理一下
                print(node.val)  # 弹出来的时候才会打印值或者处理
                generate_next_nodes(node, que)  # 他失效了不能让他的孩子也失效。存下来

        bfs(root)


# leetcode submit region end(Prohibit modification and deletion)


if __name__ == '__main__':
    sol = Solution()
    node1 = TreeNode(1)
    node2 = TreeNode(2)
    node3 = TreeNode(3)
    node4 = TreeNode(4)
    node5 = TreeNode(5)
    node1.left = node2
    node1.right = node3
    node3.left = node4
    node3.right = node5
    sol.levelOrder(node1)

题解

import collections


class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution:
    def levelOrder(self, root):
        # def levelOrder(self, root: TreeNode) -> List[List[int]]
        # 一、广度优先
        # 二、深入的时候+1  深度加一
        if root is None:
            return []
        def generate_next_nodes(node, que):
            if node.left is not None:
                que.append(node.left)
            if node.right is not None:
                que.append(node.right)

        def bfs(a):
            que = collections.deque()
            que.append(a)
            res = []
            while que:
                current_level = []
                for _ in range(len(que)):
                    node = que.popleft()  # 先弹出来处理一下
                    current_level.append(node.val)  # 弹出来的时候才会打印值或者处理
                    generate_next_nodes(node, que)  # 他失效了不能让他的孩子也失效。存下来
                res.append(current_level)
            return res

        return bfs(root)

• 弹出来的时候才会打印值或者处理 [processing]
• 在这时候他工作完成了，但是要把孩子节点留下来。访问完这层还得用。所以保持顺序的状态加入队列
• 注意每层结束的时候，准备弹出的时候，其实队列的长度极为，每一层要弹出的个数

第二次刷这个题，看不懂当时的思路了。。。但是貌似这种更好理解。这个是个扩展题：需要正序逆序的打印，整个标志位

每次都记录下一层的节点和当前层的节点，但是分开记录，在两个队列中中操作，每次大循环只需要判断下一层是否有元素，然后把这个下一层赋值为当前层，当前层直接

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        # leetcode submit region end(Prohibit modification and deletion)
        next_lay = deque()
        next_lay.append(root)
        ans = []
        flag = 1
        if not root:
            return []
        while next_lay:
            cur_lay = next_lay
            next_lay = deque()
            lay_val = []
            while cur_lay:
                cur = cur_lay.popleft()  # 栈是右侧进右侧出、队列是右侧进左侧出
                lay_val.append(cur.val)
                if cur.left:
                    next_lay.append(cur.left)
                if cur.right:
                    next_lay.append(cur.right)
            if flag:
                ans.append(lay_val)
                flag = 0
            else:
                ans.append(lay_val[::-1])
                flag = 1
        return ans

扩展一个知识点

python里面的判断条件，只要不是None、0、False都可以是true