力扣刷题0712

102. 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

题目链接：链接

自己理解题目：利用左节点遍历，先统计共有多少层，再通过while cnt>0循环：先判断根节点是否为空（第一层），不为空再判断左右节点是否为空，不为空的都加入到列表中（第二层）。。。

def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        l,res=[],[]
        if root==None:
            return res
        l.append(root.val)
        res.append(l)
        cntl=0
        cur=None
        while cur:
            cur=cur.left
            cntl+=1
        cntr=0
        cur=None
        while cur:
            cur=cur.right
            cntr+=1
        cnt=max(cntl,cntr)
        while cnt>0:
            node=l.pop(0)
            if node.left:
                l.append(node.left)
            if node.right:
                l.append(node.right)
            res.append(l)
            l=[]
            cnt-=1
        return res

参考答案：

# 利用长度法
# 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:#判断根节点
            return []
        queue = collections.deque([root])#建立双向队列
        result = []
        while queue:#当队列不为空时循环
            level = []
            for _ in range(len(queue)):#循环队列长度
                cur = queue.popleft()#每次从队列左端拿出节点
                level.append(cur.val)#添加左端节点的值到每层结果列表中
                if cur.left:#判断当前节点的左节点是否存在
                    queue.append(cur.left)#存在加入到队列中
                if cur.right:#判断当前节点的右节点是否存在
                    queue.append(cur.right)#存在加入到队列中
            result.append(level)#添加每层结果列表到最终结果列表中
        return result

# 递归法
# 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        levels = []#存储最终结果
        self.helper(root, 0, levels)#函数调用
        return levels
    
    def helper(self, node, level, levels):#递归函数
        if not node:#判断当前节点是否存在
            return
        if len(levels) == level:#当结果列表的长度与层数相等时
            levels.append([])
        levels[level].append(node.val)
        self.helper(node.left, level + 1, levels)
        self.helper(node.right, level + 1, levels)

反思总结：思路很混乱，写代码时对循环内部的顺序不能合理安排，删除自己写的代码，根据优先队列的思路，写出正确代码，但递归思路还没完全明白思路。

def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        l,res=[],[]
        if not root:
            return res
        q=[root]
        while q:
            l=[]
            for i in range(len(q)):
                node=q.pop(0)
                l.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            res.append(l)
        return res

226. 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

题目链接：链接

自己理解题目：左右节点交换。

参考代码：

递归法：前序遍历：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:#判断根节点
            return None
        root.left, root.right = root.right, root.left#交换根节点的左右子节点------------根
        self.invertTree(root.left)#同样的方式去判断和交换左子树----左
        self.invertTree(root.right)#同样的方式去交换右子树-----右
        return root

迭代法：前序遍历：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:#判断根节点
            return None      
        stack = [root]        
        while stack:
            node = stack.pop()   #每次弹出一个节点
            node.left, node.right = node.right, node.left #交换这个节点的左右子节点                  
            if node.left:#如果左节点不为空，加入列表参与下一步的循环
                stack.append(node.left)
            if node.right:#如果右节点不为空，加入列表参与下一步的循环
                stack.append(node.right)  
        return root

递归法：中序遍历：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        self.invertTree(root.left)#-----左
        root.left, root.right = root.right, root.left#-----中
        self.invertTree(root.left)#-----右，由于中节点处做了交换，所以要再次翻转左节点，不然就一直是对一个节点操作
        return root

迭代法：中序遍历：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None      
        stack = [root]        
        while stack:
            node = stack.pop()                   
            if node.left:
                stack.append(node.left)
            node.left, node.right = node.right, node.left               
            if node.left:
                stack.append(node.left)       
        return root

递归法：后序遍历：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        self.invertTree(root.left)
        self.invertTree(root.right)
        root.left, root.right = root.right, root.left
        return root

迭代法：后序遍历：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None      
        stack = [root]        
        while stack:
            node = stack.pop()                   
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)  
            node.left, node.right = node.right, node.left               
     
        return root

迭代法：广度优先遍历（层序遍历）：

# 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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root: 
            return None

        queue = collections.deque([root])    
        while queue:
            for i in range(len(queue)):
                node = queue.popleft()
                node.left, node.right = node.right, node.left
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
        return root   

反思总结：先理解吧

101. 对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

题目链接：链接

自己理解题目：没有思路。。。

参考代码：

递归法:

class Solution:
    def isSymmetric(self, root: 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 False
        elif left != None and right == None: return False
        elif left == None and right == 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

迭代法： 使用队列

import collections
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        queue = collections.deque()
        queue.append(root.left) #将左子树头结点加入队列
        queue.append(root.right) #将右子树头结点加入队列
        while queue: #接下来就要判断这这两个树是否相互翻转
            leftNode = queue.popleft()
            rightNode = queue.popleft()
            if not leftNode and not rightNode: #左节点为空、右节点为空，此时说明是对称的
                continue
            
            #左右一个节点不为空，或者都不为空但数值不相同，返回false
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            queue.append(leftNode.left) #加入左节点左孩子
            queue.append(rightNode.right) #加入右节点右孩子
            queue.append(leftNode.right) #加入左节点右孩子
            queue.append(rightNode.left) #加入右节点左孩子
        return True

迭代法：使用栈

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        st = [] #这里改成了栈
        st.append(root.left)
        st.append(root.right)
        while st:
            rightNode = st.pop()
            leftNode = st.pop()
            if not leftNode and not rightNode:
                continue
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            st.append(leftNode.left)
            st.append(rightNode.right)
            st.append(leftNode.right)
            st.append(rightNode.left)
        return True

层次遍历

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        
        queue = collections.deque([root.left, root.right])
        
        while queue:
            level_size = len(queue)
            
            if level_size % 2 != 0:#如果每层节点个数不为偶数
                return False
            
            level_vals = []
            for i in range(level_size):
                node = queue.popleft()
                if node:
                    level_vals.append(node.val)
                    queue.append(node.left)
                    queue.append(node.right)
                else:
                    level_vals.append(None)
                    
            if level_vals != level_vals[::-1]:#判断每层节点的值是否对称，对称即列表对称
                return False
            
        return True

反思总结：方法很多，暂时先理解递归法吧