Leetcode 94 & 102 & 144 & 145. Binary Tree Traversal (dfs & bfs)

最新推荐文章于 2021-06-11 11:18:52 发布

原创最新推荐文章于 2021-06-11 11:18:52 发布 · 165 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #python

leetcode 同时被 3 个专栏收录

79 篇文章

订阅专栏

python

52 篇文章

订阅专栏

27 篇文章

订阅专栏

本文深入探讨了二叉树的遍历方法，包括深度优先搜索（DFS）的中序、前序和后序遍历，以及广度优先搜索（BFS）的层次遍历。详细介绍了每种遍历方式的递归和非递归实现，为读者提供了全面的二叉树遍历算法指南。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Binart tree traversal:

dfs: inorder & preorder & postorder
bfs: level

1. dfs

Inorder: stack & recursive

stack

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

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

recursive

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

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

Preorder: stack & recursive

stack

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

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

recursive

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

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

Postorder: stack & recursive

stack
在这里插入图片描述

recursive

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

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

2. bfs

level traversal

stack

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        stack,res=[],[]
        stack.append(root)
        while stack:
            temp=[r.val for r in stack]
            next=[]
            for node in stack:
                if node.left:
                    next.append(node.left)
                if node.right:
                    next.append(node.right)
            res.append(temp)
            stack=next
        return res

queue

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root):
        if not root: return []

        result = []
        queue = collections.deque()
        queue.append(root)
        
        while queue:
            level_size = len(queue)
            current_level = []

            for _ in range(level_size):
                node = queue.popleft()
                current_level.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)

            result.append(current_level)
        
        return result