算法记录 | Day15 二叉树

层序遍历：层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树

通过队列来实现的。具体步骤如下：

1. 判断二叉树是否为空，为空则直接返回。

2. 令根节点入队。

3. 当队列不为空时，求出当前队列长度 s。

4. 依次从队列中取出这 s 个元素，并对这 s个元素依次进行访问。然后将其左右孩子节点入队，然后继续遍历下一层节点。

5. 当队列为空时，结束遍历。

102.二叉树的层序遍历

# 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]]:
        results = []
        if not root:
            return results
        queue = [root]
        size = len(queue)
        while queue:
            result = []
            size = len(queue)
            for _ in range(size):
                cur = queue.pop(0)
                result.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            results.append(result)

        return results

# 递归
class Solution
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        res = []
        def helper(root,depth):
            if not root: return []
            if len(res)==depth: res.append([])
            res[depth].append(root.val)
            if root.left: helper(root.left,depth+1)
            if root.right: helper(root.right,depth+1)
        helper(root,0)
        return res

相关题目：
102.二叉树的层序遍历
107.二叉树的层次遍历II
199.二叉树的右视图
637.二叉树的层平均值
429.N叉树的层序遍历
515.在每个树行中找最大值
116.填充每个节点的下一个右侧节点指针
117.填充每个节点的下一个右侧节点指针II
104.二叉树的最大深度
111.二叉树的最小深度

226. 翻转二叉树

递归法

思路：

1.确定递归函数的参数和返回值：输入输出Node

2.确定终止条件：当前节点为空的时候，就返回

3.确定单层递归的逻辑：交换 left、right

​ 前序：中 左 右

​ 中序：左 中 左（经过处理，左边节点 全部变到右边，因此继续对左边节点进行操作）

​ 后序：左 右 中

前序遍历

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

后序遍历

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

        return root

中序遍历

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

迭代法

广度优先遍历

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root
        que = [root]
        while que:
            size = len(que)
            for _ in range(size):
                node = que.pop(0)
                node.left, node.right = node.right, node.left #节点处理
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
        return root

深度优先遍历

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root
        stack = [root]
        while stack:
            node = stack.pop()
            node.left, node.right = node.right, node.left #中
            if node.right:
                st.append(node.right) #右
            if node.left:
                st.append(node.left) #左
       	return root

101.对称二叉树

递归法

思路：

1.后序，收集左右节点信息 返回给上一层

2.递归：

• 确定递归函数的参数和返回值：输入左右子树，判断是否相等，返回bool
• 终止条件
  • 左节点为空，右节点不为空，不对称，return false
  • 左不为空，右为空，不对称 return false
  • 左右都为空，对称，返回true
  • 左右不为空，比较节点数值，不相同就return false
• 单层逻辑
  • 比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
  • 比较内测是否对称，传入左节点的右孩子，右节点的左孩子。
  • 如果左右都对称就返回true ，有一侧不对称就返回false 。

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

        return self.check(self.left,self.right)

    def check(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.check(left.left,right.right)
        inside = self.check(left.right,right.left)
        isSame = outside and inside
        return isSame

迭代法

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