day13 代码随想录 | 二叉树遍历 翻转二叉树

二叉树，这种结构跟常见的数组、字符串、字典等来说，不是那么好理解。

但是二叉树基础的存储方式是链表，树的节点由三部分组成，一个指向左子树的left指针，一个是指向右子树的right指针和它自己的值val。

二叉树的核心，其实就是二叉树的一个遍历。很多的leetcode就是考察你如何选择遍历方式，然后再遍历的基础上增加相应的操作。

二叉树遍历

递归遍历(深度优先)

二叉树的递归遍历看代码很简单。但是对于递归，还是有一套方法论的，需要确立如下的几步。

1. 递归函数的参数和返回值。 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。

2. 递归函数的中止条件。

3. 单层递归的操作。确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

对于二叉树，有前中后三种遍历方式，区别就是遍历中间节点的顺序。

对于这些遍历，用递归的方式。

递归函数的参数就是节点，没有返回值

中止条件就是当节点为空 直接返回

单层递归就是，对于前序遍历，先操作中间节点，再去遍历左节点，再去遍历右节点。

def preOrderTraverse(root:node):
    if not root:
        return []
    res = []
    
    def dfs(node):
        if not node:
            return
        res.append(node.val)
        dfs(node.left)
        dfs(node.right)
    
    dfs(root)
    return res

层序遍历（广度优先）

层序遍历可以用递归和迭代的方法。迭代的方法可能更加符合人类思维的习惯。

层序遍历(迭代）

以下代码是层序遍历的模板，很多问题根据以下代码的模板改一改就可以了

def levelOrder(root: node):
    if not root:
        return []

    queue = collections.deque([root])
    
    levels = []

    while queue:
        level = []
        level_size = len(queue)
        for _ in range(level_size):
            node = queue.popleft()
            level.append(node.val)
            
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

        levels.append(level)
    
    return levels

层序遍历（递归）

确定递归三要素

1. 递归函数的参数和返回值。参数肯定是有node，为了区分层，还需要加入一个计数参数level.

2. 递归函数的中止值：如果node为空，就返回

3. 递归函数的单层递归逻辑：添加当前节点到列表，再添加左右节点

def levelOrder(root):
    if not root:
        return []
    depth = 0
    levels = []
    
    def bfs(node, depth):
        if not node:
            return []

        if len(levels) == depth:
                levels.append([])
        
       levels[depth].append(node.val)
       bfs(node.left, depth+1)
       bfs(node.right, depth+1)

    bfs(root, depth)
    return levels
    

226 翻转二叉树

翻转二叉树的思路很容易，其实就是将左右节点做个交换就可以了

使用前序遍历和后序遍历都可以完成。

前序遍历翻转

def inverseTree(root: node):
    if not root:
        return
    
    def dfs(node):
        if not node:
            return
        node.left, node.right = node.right, node.left
        
        dfs(node.left)
        dfs(node.right)
    
    dfs(root)
    return root

层序遍历翻转【借鉴前面的模板】

def invertTree(root: node):
    if not root:
        return None

    queue = collections.deque([root])
    
    while queue:
        level_size = len(queue)
        
        for _ in range(level_size):
            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