当前位置：首页 > news >正文

第十三天-搜索算法：开启探索之门

news 来源：原创 2025/5/18 1:55:45

搜索算法是计算机科学的核心，用于在数据集合中查找特定元素。从数据库查询到 AI 路径规划，其应用场景无所不在。Python 因其简洁语法和丰富库支持，成为实现搜索算法的理想工具。

python

# 通用搜索函数示例
def search(data, target):
    for item in data:
        if item == target:
            return True
    return False

无序与有序搜索：策略的选择

无序搜索：简单直接的探索

顺序查找：逐个遍历元素，直到找到目标。适用于小规模或无序数据。

python

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1

有序搜索：利用秩序提升效率

二分查找：利用有序数组特性，每次将搜索范围减半。

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

深度优先与广度优先搜索：探索的路径

深度优先搜索（DFS）：递归与栈实现

递归版本：简洁但受限于递归深度

python

def dfs_recursive(graph, node, visited):
    if node not in visited:
        print(node)
        visited.add(node)
        for neighbor in graph[node]:
            dfs_recursive(graph, neighbor, visited)

迭代版本：显式使用栈结构

python

def dfs_iterative(graph, start):
    visited, stack = set(), [start]
    while stack:
        node = stack.pop()
        if node not in visited:
            print(node)
            visited.add(node)
            # 逆序入栈保证顺序
            stack.extend(reversed(graph[node]))

广度优先搜索（BFS）：队列实现

python

from collections import deque

def bfs(graph, start):
    visited, queue = set(), deque([start])
    visited.add(start)
    while queue:
        node = queue.popleft()
        print(node)
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

二叉搜索树：高效查找的利器

结构定义与基本操作

python

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

class BST:
    def __init__(self):
        self.root = None

    def insert(self, val):
        if not self.root:
            self.root = TreeNode(val)
        else:
            self._insert_recursive(self.root, val)

    def _insert_recursive(self, node, val):
        if val < node.val:
            if node.left:
                self._insert_recursive(node.left, val)
            else:
                node.left = TreeNode(val)
        else:
            if node.right:
                self._insert_recursive(node.right, val)
            else:
                node.right = TreeNode(val)

查找与遍历实现

python

def search_bst(root, val):
    while root and root.val != val:
        root = root.left if val < root.val else root.right
    return root

# 中序遍历（递归）
def inorder_traversal(root):
    result = []
    def dfs(node):
        if node:
            dfs(node.left)
            result.append(node.val)
            dfs(node.right)
    dfs(root)
    return result

# 层序遍历（BFS）
def level_order(root):
    if not root:
        return []
    queue, result = 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

搜索算法的 Python 实战

旋转数组搜索

python

def search_rotated(nums, target):
    left, right = 0, len(nums)-1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] == target:
            return mid
        # 左半部分有序
        if nums[left] <= nums[mid]:
            if nums[left] <= target < nums[mid]:
                right = mid - 1
            else:
                left = mid + 1
        # 右半部分有序
        else:
            if nums[mid] < target <= nums[right]:
                left = mid + 1
            else:
                right = mid - 1
    return -1

二叉搜索树专题

第 K 小元素（中序遍历特性）

python

def kth_smallest(root, k):
    stack = []
    while True:
        while root:
            stack.append(root)
            root = root.left
        root = stack.pop()
        k -= 1
        if k == 0:
            return root.val
        root = root.right

对称二叉树（BFS 验证对称性）

python

def is_symmetric(root):
    if not root:
        return True
    queue = deque([(root.left, root.right)])
    while queue:
        left, right = queue.popleft()
        if not left and not right:
            continue
        if not left or not right or left.val != right.val:
            return False
        queue.append((left.left, right.right))
        queue.append((left.right, right.left))
    return True