算法(14)-leetcode-explore-learn-数据结构-二叉树的遍历

本系列博文为leetcode-explore-learn子栏目学习笔记，如有不详之处，请参考leetcode官网：https://leetcode-cn.com/explore/learn/card/data-structure-binary-tree/2/traverse-a-tree/7/

所有例题的编程语言为python
二叉树节点结构：

class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

1.二叉树的深度优先遍历

二叉树的深度优先的三种遍历方式：这个序就是根节点在什么时候遍历

1.1前序遍历：中左右

递归的框架有了，如何在res list中加入答案，在内层再定义一个函数，

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res=[]
        def dfs_pre(node):
            if node==None:
                return
            res.append(node.val)
            dfs_pre(node.left)
            dfs_pre(node.right)
        dfs_pre(root)
        return res

迭代的框架：当前节点的右子树放入堆栈，存起来。将当前节点的值放入res，当前节点更新为当前节点的左子树节点。

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        stack=[]
        res=[]
        node=root
        while(node or stack):
            if node:
                res.append(node.val)
                if node.right:
                    stack.append(node.right)
                node=node.left
            else:
                node=stack.pop()
        return res

1.2中序遍历：左中右

递归的框架和先序遍历一样。

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res=[]
        def dfs_inorder(node):
            if node==None:
                return
            dfs_inorder(node.left)
            res.append(node.val)
            dfs_inorder(node.right)
        dfs_inorder(root)
        return res

迭代框架：需要将什么放stack中呢，根节点一路向左遍历到底部。将根节点都放进去，放进去的就是有的节点。遍历到底端之后，逐个弹出；然后去该节点的右子树，如果右子树为空，就会弹该节点的父亲节点；如果右子树不为空，就可以迭代进去处理右子树。

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        stack=[]
        res=[]
        node=root
        while(stack or node):
            if node:
                stack.append(node)
                node=node.left
            else:
                node=stack.pop()
                res.append(node.val)
                node=node.right
        return res

1.3后序遍历：左右中

递归的框架和先序，中序遍历一致

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res=[]
        def dfs_post(node):
            if node==None:
                return
            dfs_post(node.left)
            dfs_post(node.right)
            res.append(node.val)
        dfs_post(root)
        return res

迭代的框架：中右左的逆序，就是左右中。在伪前序遍历（保存左节点）的结果下，逆序输出即可。

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        stack=[]
        res=[]
        node=root
        while(stack or node):
            if node:
                res.append(node.val)
                if node.left:
                    stack.append(node.left)
                node=node.right
            else:
                node=stack.pop()
        return res[::-1]

2.二叉树的广度优先遍历

–层次遍历，用队列来帮助实现广度优先遍历

递归框架： 需要有一个level信息用于存储该节点所处的层次。问题：在哪里新增res的层次呢–解决方案，先判断l层次是否存在，不在的话新增。

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if root==None:
            return []
        res=[]
        def bfs(node,l):
            if node==None:
                return
            if l>len(res)-1:
                res.append([])
            res[l].append(node.val)
            bfs(node.left,l+1)
            bfs(node.right,l+1)
        bfs(root,0)
        return res
        

迭代框架：队列，先进先出，每层先统计队列的长度，确认要弹出的元素个数。

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if root==None:
            return []
        que=[root]
        res=[]
        l=0
        while(que):
            n=len(que)
            res.append([])
            for i in range(n):
                node=que.pop(0)
                res[l].append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            l+=1
        return res