算法训练营

层序遍历

题目链接: 层序遍历
文档讲解： 代码随想录
题目难度：简单

思路:递归法
时间复杂度：O(n)；空间复杂度：O(n)
下面展示 代码：

# 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 helper(self, current, res, level):
        if current == None:
            return
        if len(res) == level:
            res.append([])
        res[level].append(current.val)
        self.helper(current.left, res, level+1)
        self.helper(current.right, res, level+1)
        return res

    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        else:
            level = 0
            res = []
            return self.helper(root, res, level)

226.翻转二叉树

题目链接: 226.翻转二叉树
文档讲解： 代码随想录
题目难度：简单
思路:层序遍历+队列实现。
时间复杂度：O(n)；空间复杂度：O(n)
代码如下

from collections import deque
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
        else:
            que = deque([root])
            while que:
                for i in range(len(que)):
                    val = que.popleft()
                    val.left, val.right = val.right, val.left
                    if val.left:
                        que.append(val.left)
                    if val.right:
                        que.append(val.right)
            return root

101. 对称二叉树

题目链接: 101. 对称二叉树
文档讲解： 代码随想录
题目难度：简单
思路:个人喜欢递归法，但是层序遍历加队列也简单
时间复杂度：O(n)；空间复杂度：递归法O(1)迭代法O(n)
代码如下

# 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
from collections import deque
class Solution:

    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        # 迭代法（基于队列）
        if not root:
            return True
        else:
            que = deque()
            que.append(root.left)
            que.append(root.right)
            while que:
                cur_left = que.popleft()
                cur_right = que.popleft()
                if cur_left == None and cur_right == None:
                    continue
                if not cur_left or not cur_right or cur_left.val != cur_right.val:
                    return False
                que.append(cur_left.left)
                que.append(cur_right.right)
                que.append(cur_left.right)
                que.append(cur_right.left)
            return True


    # def helper(self, left, right):
    #     if left == None and right:
    #         return False
    #     elif left and right == None:
    #         return False
    #     elif left == None and right == None:
    #         return True
    #     elif left.val != right.val:
    #         return False
        
    #     # 单层递归逻辑
    #     outside = self.helper(left.left, right.right)
    #     inside = self.helper(left.right, right.left)
    #     return outside and inside

    # def isSymmetric(self, root: Optional[TreeNode]) -> bool:
    #     # 递归法
    #     if not root:
    #         return True
    #     else:
    #         return self.helper(root.left, root.right)