python 搜索算法-优快云博客

搜索算法

搜索算法用于在数据集中查找特定元素。以下是四种常见的搜索算法及其 Python 实现：

1. 线性搜索（Linear Search）

线性搜索是一种简单的搜索算法，它从数据集的第一个元素开始，逐个检查每个元素，直到找到目标元素或遍历完整个数据集。

时间复杂度：

最坏情况：O(n)
最好情况：O(1) —— 目标元素在第一个位置。
平均情况：O(n)

Python 实现

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i  # 返回目标元素的索引
    return -1  # 如果未找到，返回 -1

# 示例使用
arr = [3, 5, 2, 8, 10]
target = 8
result = linear_search(arr, target)
print(f"目标元素 {target} 的索引: {result}")

2. 二分搜索（Binary Search）

二分搜索是一种高效的搜索算法，适用于已排序的数据集。它通过将数据集分成两半，逐步缩小搜索范围，直到找到目标元素。

时间复杂度：

最坏情况：O(log n)
最好情况：O(1) —— 目标元素在中间位置。
平均情况：O(log n)

Python 实现

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid  # 返回目标元素的索引
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1  # 如果未找到，返回 -1

# 示例使用
arr = [2, 3, 5, 8, 10]
target = 8
result = binary_search(arr, target)
print(f"目标元素 {target} 的索引: {result}")

3. 深度优先搜索（DFS, Depth-First Search）

深度优先搜索是一种用于遍历或搜索树或图的算法。它从起始节点开始，沿着一条路径尽可能深地搜索，直到到达叶子节点或目标节点，然后回溯并继续搜索其他路径。

时间复杂度：

最坏情况：O(V + E)，其中 V 是节点数，E 是边数。

Python 实现（递归版本）

def dfs(graph, node, visited=None):
    if visited is None:
        visited = set()
    visited.add(node)
    print(node, end=" ")  # 打印访问的节点
    for neighbor in graph[node]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

# 示例使用
graph = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
    'C': ['F'],
    'D': [],
    'E': ['F'],
    'F': []
}
print("DFS 遍历结果:")
dfs(graph, 'A')

4. 广度优先搜索（BFS, Breadth-First Search）

广度优先搜索是一种用于遍历或搜索树或图的算法。它从起始节点开始，逐层扩展搜索，先访问所有相邻节点，再访问相邻节点的相邻节点。

时间复杂度：

最坏情况：O(V + E)，其中 V 是节点数，E 是边数。

Python 实现

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    visited.add(start)
    while queue:
        node = queue.popleft()
        print(node, end=" ")  # 打印访问的节点
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

# 示例使用
graph = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
    'C': ['F'],
    'D': [],
    'E': ['F'],
    'F': []
}
print("BFS 遍历结果:")
bfs(graph, 'A')

总结

算法	适用场景	时间复杂度	空间复杂度
线性搜索	未排序的数据集	O(n)	O(1)
二分搜索	已排序的数据集	O(log n)	O(1)
深度优先搜索	树或图的遍历或搜索	O(V + E)	O(V)
广度优先搜索	树或图的遍历或搜索	O(V + E)	O(V)