1. 深度优先搜索 (Depth-First Search, DFS)

• 原理：从起始节点开始，沿着一条路径尽可能深入地探索，直到到达目标节点或无法继续为止，然后回溯到上一个节点继续探索。
• 代码实现（使用Python实现）：

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start)
    for neighbor in graph[start] - visited:
        dfs(graph, neighbor, visited)
    return visited

2. 广度优先搜索 (Breadth-First Search, BFS)

• 原理：从起始节点开始，先访问所有相邻节点，然后逐层向外扩展，直到找到目标节点或遍历完整个图。
• 代码实现（使用Python实现）：

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    while queue:
        vertex = queue.popleft()
        if vertex not in visited:
            visited.add(vertex)
            print(vertex)
            queue.extend(graph[vertex] - visited)
    return visited

3. Dijkstra算法

• 原理：用于计算带权重图中从起始节点到其他所有节点的最短路径。
• 代码实现（使用优先队列）（使用Python实现）：

import heapq

def dijkstra(graph, start):
    distances = {node: float('infinity') for node in graph}
    distances[start] = 0
    pq = [(0, start)]
    
    while pq:
        current_distance, current_node = heapq.heappop(pq)
        if current_distance > distances[current_node]:
            continue
        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(pq, (distance, neighbor))
    
    return distances

4. A*算法

• 原理：结合了启发式函数和已走路径代价的启发式搜索算法，用于在图中找到最短路径。
• 代码实现（简化版本）（使用Python实现）：

def astar(graph, start, goal):
    open_list = [start]
    closed_list = set()
    while open_list:
        current = min(open_list, key=lambda x: graph[x]['f'])
        if current == goal:
            return reconstruct_path(graph, start, goal)
        open_list.remove(current)
        closed_list.add(current)
        for neighbor in graph[current]['neighbors']:
            if neighbor in closed_list:
                continue
            if neighbor not in open_list:
                open_list.append(neighbor)
            tentative_g = graph[current]['g'] + graph[current]['neighbors'][neighbor]
            if tentative_g >= graph[neighbor]['g']:
                continue
            graph[neighbor]['g'] = tentative_g
            graph[neighbor]['f'] = tentative_g + graph[neighbor]['h']
            graph[neighbor]['parent'] = current
    return None

这些代码示例展示了几种常见的图搜索算法的简单实现。在实际应用中，你可能需要根据具体问题和数据结构进行适当的调整和优化。