编辑“︁搜索算法概述”︁

= 搜索算法概述 =

'''搜索算法'''是计算机科学中用于在数据集合中查找特定元素或满足特定条件的元素的一类算法。它们在各种应用场景中发挥着重要作用，从数据库查询到人工智能，再到日常的网页搜索。搜索算法可以分为两大类：'''线性搜索'''和'''二分搜索'''（适用于有序数据），以及更复杂的'''图搜索算法'''如深度优先搜索（DFS）和广度优先搜索（BFS）。

== 基本概念 ==

搜索算法的核心目标是在给定的数据集中高效地找到目标值或满足条件的元素。算法的效率通常通过'''时间复杂度'''和'''空间复杂度'''来衡量。以下是两种最基本的搜索算法：

=== 1. 线性搜索（Linear Search） ===

线性搜索是最简单的搜索算法，它逐个检查数据集中的每个元素，直到找到目标值或遍历完整个数据集。

==== 算法步骤 ====
1. 从数据集的第一个元素开始。
2. 比较当前元素与目标值。
3. 如果匹配，返回当前元素的索引。
4. 如果不匹配，移动到下一个元素。
5. 如果遍历完所有元素仍未找到目标值，返回“未找到”。

==== 代码示例 ====
<syntaxhighlight lang="python">
def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1  # 未找到

# 示例输入
arr = [10, 20, 30, 40, 50]
target = 30

# 调用函数
result = linear_search(arr, target)

# 输出
print(f"目标值 {target} 的索引是: {result}")  # 输出: 目标值 30 的索引是: 2
</syntaxhighlight>

==== 复杂度分析 ====
* 时间复杂度：<math>O(n)</math>，其中<math>n</math>是数据集的大小。
* 空间复杂度：<math>O(1)</math>，不需要额外空间。

=== 2. 二分搜索（Binary Search） ===

二分搜索是一种高效的搜索算法，但要求数据集是'''有序的'''。它通过反复将搜索区间分成两半来缩小范围。

==== 算法步骤 ====
1. 确定数据集的中间元素。
2. 如果中间元素等于目标值，返回其索引。
3. 如果目标值小于中间元素，在左半部分继续搜索。
4. 如果目标值大于中间元素，在右半部分继续搜索。
5. 重复直到找到目标值或区间为空。

==== 代码示例 ====
<syntaxhighlight lang="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  # 未找到

# 示例输入（必须是有序数组）
arr = [10, 20, 30, 40, 50]
target = 40

# 调用函数
result = binary_search(arr, target)

# 输出
print(f"目标值 {target} 的索引是: {result}")  # 输出: 目标值 40 的索引是: 3
</syntaxhighlight>

==== 复杂度分析 ====
* 时间复杂度：<math>O(\log n)</math>，因为每次迭代都将搜索范围减半。
* 空间复杂度：<math>O(1)</math>。

== 图搜索算法 ==

对于更复杂的数据结构（如图或树），需要使用专门的图搜索算法，如'''深度优先搜索（DFS）'''和'''广度优先搜索（BFS）'''。

=== 深度优先搜索（DFS） ===
DFS 沿着图的深度遍历节点，尽可能深地搜索分支，直到无法继续为止，然后回溯。

==== 算法步骤 ====
1. 从起始节点开始。
2. 访问当前节点，并标记为已访问。
3. 递归访问所有未访问的相邻节点。

==== 代码示例 ====
<syntaxhighlight lang="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')  # 输出: A B D E F C
</syntaxhighlight>

=== 广度优先搜索（BFS） ===
BFS 按层次遍历图，先访问起始节点的所有邻居，再访问邻居的邻居。

==== 算法步骤 ====
1. 创建一个队列，将起始节点加入队列。
2. 从队列中取出一个节点并访问。
3. 将该节点的所有未访问邻居加入队列。
4. 重复直到队列为空。

==== 代码示例 ====
<syntaxhighlight lang="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')  # 输出: A B C D E F
</syntaxhighlight>

==== 复杂度分析 ====
* DFS 和 BFS 的时间复杂度均为 <math>O(V + E)</math>，其中<math>V</math>是顶点数，<math>E</math>是边数。
* 空间复杂度取决于实现方式，通常为 <math>O(V)</math>。

== 实际应用案例 ==

搜索算法在现实中有广泛的应用：
1. '''数据库查询'''：SQL 中的 `WHERE` 子句通常使用索引和搜索算法优化。
2. '''路径规划'''：GPS 导航系统使用 BFS 或 Dijkstra 算法（一种加权图的搜索算法）计算最短路径。
3. '''网页爬虫'''：搜索引擎使用 DFS 或 BFS 遍历网页链接。
4. '''游戏 AI'''：棋盘游戏（如象棋）使用搜索算法评估可能的走法。

== 总结 ==

搜索算法是计算机科学的基础工具，适用于从简单数组到复杂图结构的各种场景。选择正确的搜索算法可以显著提高程序的效率。对于初学者，建议从线性搜索和二分搜索开始，逐步学习更复杂的图搜索算法。

[[Category:计算机科学]]
[[Category:数据结构与算法]]
[[Category:搜索算法]]