Python遍历算法案例如何遍历数据

wen python案例 2026-06-30 193

本文目录导读：

Python遍历算法案例如何遍历数据

线性遍历（顺序遍历）
二维数据遍历
树结构遍历
图结构遍历
高级遍历技巧
实际应用案例

我来为你详细介绍Python中常用的遍历算法案例,这些是处理数据的基础操作。

线性遍历（顺序遍历）

数组遍历

# 基本数组遍历
arr = [1, 2, 3, 4, 5]
# 方法1：直接遍历
for item in arr:
    print(item, end=' ')  # 输出: 1 2 3 4 5
# 方法2：索引遍历
for i in range(len(arr)):
    print(f"索引{i}: {arr[i]}")
# 方法3：枚举遍历
for index, value in enumerate(arr):
    print(f"位置{index}: {value}")

链表遍历

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
# 创建链表: 1 -> 2 -> 3
head = ListNode(1, ListNode(2, ListNode(3)))
# 遍历链表
current = head
while current:
    print(current.val, end=' ')  # 输出: 1 2 3
    current = current.next

二维数据遍历

矩阵遍历

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
# 逐行遍历
print("逐行遍历:")
for row in matrix:
    for element in row:
        print(element, end=' ')
    print()
# 逐列遍历
print("\n逐列遍历:")
for col in range(len(matrix[0])):
    for row in range(len(matrix)):
        print(matrix[row][col], end=' ')
    print()
# 对角线遍历
print("\n对角线遍历:")
for i in range(len(matrix)):
    print(matrix[i][i], end=' ')  # 输出: 1 5 9

树结构遍历

二叉树遍历

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
# 创建二叉树:
#     1
#    / \
#   2   3
#  / \
# 4   5
root = TreeNode(1, 
    TreeNode(2, TreeNode(4), TreeNode(5)),
    TreeNode(3))
# 前序遍历（根-左-右）
def preorder(node):
    if node:
        print(node.val, end=' ')
        preorder(node.left)
        preorder(node.right)
print("前序遍历:")
preorder(root)  # 输出: 1 2 4 5 3
# 中序遍历（左-根-右）
def inorder(node):
    if node:
        inorder(node.left)
        print(node.val, end=' ')
        inorder(node.right)
print("\n中序遍历:")
inorder(root)  # 输出: 4 2 5 1 3
# 后序遍历（左-右-根）
def postorder(node):
    if node:
        postorder(node.left)
        postorder(node.right)
        print(node.val, end=' ')
print("\n后序遍历:")
postorder(root)  # 输出: 4 5 2 3 1

广度优先遍历（层序遍历）

from collections import deque
def level_order(root):
    if not root:
        return []
    result = []
    queue = deque([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
print("层序遍历:", level_order(root))  # 输出: [[1], [2, 3], [4, 5]]

图结构遍历

深度优先搜索 (DFS)

graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}
def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start, end=' ')
    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)
print("DFS遍历:")
dfs(graph, 'A')  # 输出: A B D E F C

广度优先搜索 (BFS)

from collections import deque
def bfs(graph, start):
    visited = {start}
    queue = deque([start])
    while queue:
        vertex = queue.popleft()
        print(vertex, end=' ')
        for neighbor in graph[vertex]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)
print("BFS遍历:")
bfs(graph, 'A')  # 输出: A B C D E F

高级遍历技巧

带条件的过滤遍历

# 遍历并过滤
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 只遍历偶数
even_numbers = [num for num in numbers if num % 2 == 0]
print("偶数:", even_numbers)  # 输出: [2, 4, 6, 8, 10]
# 带条件的累加
sum_of_large = sum(num for num in numbers if num > 5)
print("大于5的和:", sum_of_large)  # 输出: 40

并行遍历多个序列

# 使用zip并行遍历
names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]
grades = ['B', 'A', 'C']
for name, score, grade in zip(names, scores, grades):
    print(f"{name}: {score}分, 等级{grade}")

反向遍历

# 反向遍历
arr = [1, 2, 3, 4, 5]
# 方法1：reversed()
for item in reversed(arr):
    print(item, end=' ')  # 输出: 5 4 3 2 1
print()
# 方法2：负步长
for i in range(len(arr)-1, -1, -1):
    print(arr[i], end=' ')  # 输出: 5 4 3 2 1

实际应用案例

文件系统遍历

import os
def walk_directory(path):
    """遍历目录结构"""
    for root, dirs, files in os.walk(path):
        level = root.replace(path, '').count(os.sep)
        indent = ' ' * 4 * level
        print(f'{indent}{os.path.basename(root)}/')
        subindent = ' ' * 4 * (level + 1)
        for file in files:
            print(f'{subindent}{file}')
# 使用示例
# walk_directory('./')  # 遍历当前目录

JSON数据遍历

def traverse_json(data, indent=0):
    """递归遍历JSON结构"""
    prefix = ' ' * indent
    if isinstance(data, dict):
        for key, value in data.items():
            print(f"{prefix}{key}:", end=' ')
            if isinstance(value, (dict, list)):
                print()
                traverse_json(value, indent + 2)
            else:
                print(value)
    elif isinstance(data, list):
        for index, item in enumerate(data):
            print(f"{prefix}[{index}]:", end=' ')
            if isinstance(item, (dict, list)):
                print()
                traverse_json(item, indent + 2)
            else:
                print(item)
# 示例数据
data = {
    "name": "产品目录",
    "items": [
        {"id": 1, "name": "手机", "price": 2999},
        {"id": 2, "name": "电脑", "price": 5999}
    ],
    "metadata": {
        "version": "1.0",
        "updated": "2024-01-01"
    }
}
print("JSON遍历:")
traverse_json(data)

这些遍历算法覆盖了Python中常见的数据结构操作，通过灵活运用这些方法，你可以高效地处理各种类型的数据,选择哪种遍历方式取决于你的具体需求和数据结构的特性。

本文地址： https://www.bmjup.com/post/12643.html