代码随想录day15

要设立一个size，记录每层的个数，双层while循环

# Definition for a binary tree node.
class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
from collections import deque
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        que=deque()
        res=[]
        if root:
            que.append(root)
        while que:
            size=len(que)
            layer=[]
            while size:
                node=que.popleft()
                layer.append(node.val)
                size-=1
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            res.append(layer)
        return res

                

题目二

前序和后续一样，中序代码不一样

分期递归中最后return 是最后一步才执行，还是中间就执行

return只被最后一步调用（迭代过程中不会出现返回值）

# Definition for a binary tree node.
class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution(object):
    def invertTree(self, root):
        if not root:
            return None
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
      
        return root  #这步的return最后才执行

# Definition for a binary tree node.
class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution(object):
    def invertTree(self, root):
        if not root:
            return None
        self.invertTree(root.left)
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
      
        return root  #这步的return最后才执行

题目三：

采用后续遍历的思想，先判断左右子节点，在判断父节点

return被反复调用（迭代过程中会出现返回值）

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return True
        return self.compare(root.right,root.left)

    def compare(self,left,right):
        if left is None and right is not None: return False
        elif left is not None and right is None: return False
        elif left is None and right is 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