代码随想录Day16 | 二叉树part 2

昨天所学的迭代遍历和递归遍历都属于二叉树的深度优先遍历方法。今天所做的第一道题，层序遍历，选择的则是广度优先的方法。

102. 二叉树的层序遍历

第一种方法是利用长度法，把每一层的节点都放入到一个先入先出的collections.deque()，然后挨个leftpop出来。

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

对于二叉树的层序遍历2，最后返回result[::-1]即可。

199. 二叉树的右视图

class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            for i in range(len(queue)-1):
                cur = queue.popleft()
                if cur.left: queue.append(cur.left)
                if cur.right: queue.append(cur.right)
            cur = queue.popleft()
            result.append(cur.val)
            if cur.left: queue.append(cur.left)
            if cur.right: queue.append(cur.right)
        return result

429. N叉树的层序遍历

这道题重点是看children怎么遍历，记住for children in cur.children再来判断。

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        if not root:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            row = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                row.append(cur.val)
                for children in cur.children:
                    queue.append(children)
            result.append(row)
        return result

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

这道题和层序遍历完全相同。只是要加上一些细节，并且注意返回的不是result数组，只是root而已，即可。

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

111

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

翻转二叉树

这道题其实很好做，关键是要明白是前序、中序还是后序遍历，同时要只要递归和栈的不同使用方法。然后注意：深度优先是迭代，广度优先是层序遍历。就不贴代码啦，具体使用方法看代码随想录噢。

对称二叉树

这道题还是有迭代和递归两种方法。迭代法的时候要注意思路，确定考虑到所有情形的方法。并且在确认左右节点有值且相等之后，再考虑一下如何完成不同的内外节点的比较。

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 True
        elif left != None and right == None: return False
        elif left == None and right != None: return False
        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

至于迭代法的话，用队列或者用栈都是一样的，只是deque和list的区别，都可以。

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        #que = collections.deque()
        que = []
        que.append(root.left)
        que.append(root.right)
        while que:
            #left = que.popleft()
            #right = que.popleft()
            right = que.pop()
            left = que.pop()
            if not left and not right: continue
            if not left or not right or left.val != right.val:
                return False
            que.append(left.left)
            que.append(right.right)
            que.append(left.right)
            que.append(right.left)
        return True