[Python手撕]深度优先遍历

递归写法

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


node1 = TreeNode(1)
node2 = TreeNode(2)
node3 = TreeNode(3)
node4 = TreeNode(4)
node5 = TreeNode(5)
node6 = TreeNode(6)
node7 = TreeNode(7)

node1.left = node2
node1.right = node5
node2.left = node3
node2.right = node4
node5.left = node6
node5.right = node7

root = node1


def pre_order(root):
    if root:
        print(root.val, end=' ')
        pre_order(root.left)
        pre_order(root.right)


pre_order(root)
print()


def in_order(root):
    if root:
        in_order(root.left)
        print(root.val, end=' ')
        in_order(root.right)


in_order(root)
print()


def post_order(root):
    if root:
        post_order(root.left)
        post_order(root.right)
        print(root.val, end=' ')


post_order(root)

栈写法

先序遍历

# 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 preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []

        stack = [root]
        res = []
        while stack:
            t = stack.pop(-1)
            res.append(t.val)
            if t.right:
                stack.append(t.right)
            if t.left:
                stack.append(t.left)
        return res

中序遍历

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

def inorderTraversal(root):
    stack = []
    result = []
    current = root
    
    while stack or current:
        # 将当前节点及其左子树压入栈中
        while current:
            stack.append(current)
            current = current.left
        
        # 弹出栈顶元素并处理
        current = stack.pop()
        result.append(current.val)  # 访问当前节点
        
        # 转向右子树
        current = current.right
    
    return result