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

Binart tree traversal:

1. dfs: inorder & preorder & postorder
2. 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