图的DFS和BFS代码实现

### 回答1：
下面是图的DFS和BFS代码实现。其中，我们假设节点编号从 0 开始。

DFS：

void dfs(int node, vector<vector<int>>& adj, vector<bool>& visited) {
    visited[node] = true;
    cout << node << " ";
    for (int i = 0; i < adj[node].size(); ++i) {
        int next = adj[node][i];
        if (!visited[next]) {
            dfs(next, adj, visited);
        }
    }
}

void dfsTraversal(vector<vector<int>>& adj) {
    int n = adj.size();
    vector<bool> visited(n, false);
    for (int i = 0; i < n; ++i) {
        if (!visited[i]) {
            dfs(i, adj, visited);
        }
    }
}

BFS：

void bfsTraversal(vector<vector<int>>& adj) {
    int n = adj.size();
    vector<bool> visited(n, false);
    queue<int> q;
    for (int i = 0; i < n; ++i) {
        if (!visited[i]) {
            q.push(i);
            visited[i] = true;
            while (!q.empty()) {
                int node = q.front();
                q.pop();
                cout << node << " ";
                for (int j = 0; j < adj[node].size(); ++j) {
                    int next = adj[node][j];
                    if (!visited[next]) {
                        q.push(next);
                        visited[next] = true;
                    }
                }
            }
        }
    }
}

### 回答2：
图的DFS（深度优先搜索）和BFS（广度优先搜索）是两种常用的图遍历算法。

首先，我们来讨论图的DFS代码实现。DFS是一种先根后子树的搜索方式。其基本思想是从图中的一个顶点开始，沿着一条路径一直往下搜索，直到不能再继续下去为止，然后回溯到上一个节点，继续搜索未被访问过的路径，直到所有节点都被访问过为止。

下面是图的DFS代码实现（以邻接表形式存储的无向图为例）：

def dfs(graph, start, visited):
    visited[start] = True
    print(start, end=" ")

    for v in graph[start]:
        if not visited[v]:
            dfs(graph, v, visited)

在上述代码中，`graph`是图的邻接表表示，`start`是起始顶点，`visited`是用于标记节点是否已被访问的列表。首先，我们将起始顶点标记为已访问，并输出其值。然后，递归地遍历与起始顶点相邻的未被访问过的节点。

接下来，我们来讨论图的BFS代码实现。BFS是一种逐层遍历的搜索方式。其基本思想是从图中的一个顶点开始，先访问其所有直接相邻的节点，然后再依次访问这些节点的相邻节点，依次类推，直到所有节点都被访问过为止。

下面是图的BFS代码实现（以邻接表形式存储的无向图为例）：

def bfs(graph, start):
    visited = [False] * len(graph)
    queue = []

    visited[start] = True
    queue.append(start)

    while queue:
        vertex = queue.pop(0)
        print(vertex, end=" ")

        for v in graph[vertex]:
            if not visited[v]:
                visited[v] = True
                queue.append(v)

在上述代码中，`graph`是图的邻接表表示，`start`是起始顶点。首先，我们将起始顶点标记为已访问，并加入队列。然后，重复以下步骤直到队列为空：从队列中取出一个顶点，并输出其值；将其未被访问过的相邻节点标记为已访问，并加入队列。

通过以上代码实现，我们可以使用DFS和BFS算法对图进行深度优先搜索和广度优先搜索。

### 回答3：
图的深度优先搜索（DFS）和广度优先搜索（BFS）是两种常用的图遍历算法。它们用于访问和搜索图中的节点。

DFS代码实现：
1. 首先，创建一个辅助数据结构，例如栈（Stack），用于存储待访问节点。
2. 将初始节点放入栈中。
3. 当栈不为空时，执行以下步骤：
- 弹出栈顶节点，并将其标记为已访问。
- 遍历该节点的所有邻居节点，如果该邻居节点未访问，则将其放入栈中。
4. 重复步骤3，直到栈为空。

BFS代码实现：
1. 首先，创建一个辅助数据结构，例如队列（Queue），用于存储待访问节点。
2. 将初始节点放入队列中。
3. 当队列不为空时，执行以下步骤：
- 弹出队列头节点，并将其标记为已访问。
- 遍历该节点的所有邻居节点，如果该邻居节点未访问，则将其放入队列中。
4. 重复步骤3，直到队列为空。

DFS和BFS的区别在于访问节点的顺序不同：
- DFS优先访问深度方向，先访问与初始节点相连的所有节点，再递归深入访问其他节点。
- BFS优先访问广度方向，先访问初始节点相邻的节点，然后逐层访问与初始节点距离更近的邻居节点。

这两种算法适用于不同的场景。DFS在找到目标节点的情况下可能效率更高，而BFS适用于需要找到最短路径的情况。在实际应用中，可以根据具体需求选择合适的算法。