DAY 15 | 102. Binary Tree Level Order Traversal | 226. Invert Binary Tree | 101. Symmetric Tree

102. Binary Tree Level Order Traversal 

Iteration:

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

226. Invert Binary Tree

post order:

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

using level traversal:

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root

        que = deque([root])

        while(que):
            size = len(que)
            for i in range(size):
                node = que.popleft()
                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. Symmetric Tree

recursion 3 steps:

1. parameters: left and right

2. when to stop: conditions when handling none or can tell it's immediatly not equal

3. the logic of a single layer: compare the inner pair and the outer pair

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:

        def compare(left, right):
            if left == None and right != None:
                return False
            if left != None and right == None:
                return False
            if left == None and right == None:
                return True
            if left.val != right.val:
                return False
            
            outside_compare = compare(left.left, right.right)
            inside_compare = compare(left.right, right.left)
            return outside_compare and inside_compare
    
        return compare(root.left, root.right)

Using a queue:

comparing the outer pairs in depth and then compare the inner pairs in depth.

we can change the queue into a stack. this will only change the traversal order: from inner pairs to outer pairs.

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

        que = deque([])
        que.append(root.left)
        que.append(root.right)

        while(que):
        
            left = que.popleft()
            right = que.popleft()

            if not left and not right:
                continue
            if not left and right:
                return False
            if left and not right:
                return False
            if left.val != right.val:
                return False
            
            que.append(left.right)
            que.append(right.left)
            que.append(left.left)
            que.append(right.right)
        
        return True

using level traversal: not very efficient because there're two for loops in each while loop. 

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