C++实现树和图的深度优先搜索

深度优先搜索（Depth-First Search，DFS）是一种用于遍历或搜索树或图的算法。它从起始节点开始，尽可能深地访问每个节点的后继节点，直到达到没有未访问的后继节点为止，然后回溯到前一个节点，继续深入访问其它未被访问的后继节点。这一过程可以递归或利用栈来实现。

深度优先搜索通常用于解决以下问题：

1. 图的连通性：通过深度优先搜索可以判断图中两个节点之间是否存在路径。

2. 寻找图的环：在有向图中，深度优先搜索可以用来检测是否存在环。

3. 拓扑排序：通过深度优先搜索可以对有向无环图进行拓扑排序。

4. 解决迷宫问题：通过深度优先搜索可以在迷宫中找到从起点到终点的路径。

深度优先搜索的基本思想可以用以下步骤来描述：

1. 从起始节点开始，将其标记为已访问，并将其加入遍历路径中。

2. 对于当前节点的每个未被访问的后继节点，递归地对其进行深度优先搜索。

3. 如果当前节点没有未被访问的后继节点，或者已经达到目标节点，则返回上一层，并继续搜索其它未被访问的后继节点。

4. 重复步骤 2 和步骤 3，直到所有节点都被访问过。

深度优先搜索的实现可以利用递归或栈来实现。递归实现方式简单直观，而栈的实现方式更灵活，可以在非递归的环境中使用。

下面是一个使用C++实现深度优先搜索（DFS）的示例，针对树的结构进行搜索。

假设我们有以下树结构：

        1
       / \
      2   3
     / \   \
    4   5   6

我们的目标是通过深度优先搜索遍历这棵树，按照先序遍历的方式访问节点。这意味着我们首先访问根节点，然后递归地访问其左子树，最后递归地访问其右子树。

#include <iostream>
#include <vector>
using namespace std;

// 树节点的定义
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 深度优先搜索函数
void dfs(TreeNode* root) {
    // 如果当前节点为空，直接返回
    if (root == NULL) return;

    // 访问当前节点的值
    cout << root->val << " ";

    // 递归访问左子树
    dfs(root->left);

    // 递归访问右子树
    dfs(root->right);
}

int main() {
    // 构造树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->right = new TreeNode(6);

    // 深度优先搜索
    cout << "Depth First Traversal (Preorder): ";
    dfs(root);
    cout << endl;

    return 0;
}

在这个示例中，我们首先定义了一个树节点的结构 TreeNode，包含一个整数值和左右子节点指针。然后，我们实现了一个名为 dfs 的深度优先搜索函数，通过递归的方式来遍历树。在 main() 函数中，我们构造了一个示例树，并调用 dfs 函数来进行深度优先搜索，并以先序遍历的方式输出节点值。

输出结果将会是：

Depth First Traversal (Preorder): 1 2 4 5 3 6

下面是一个使用C++实现深度优先搜索（DFS）的示例，针对图的结构进行搜索。

#include <iostream>
#include <vector>
#include <unordered_set>
using namespace std;

// 图的邻接表表示
class Graph {
private:
    int V; // 图中顶点的数量
    vector<unordered_set<int>> adj; // 邻接表

public:
    // 构造函数，初始化图的顶点数量和邻接表
    Graph(int V) : V(V), adj(V) {}

    // 添加边
    void addEdge(int u, int v) {
        adj[u].insert(v);
        adj[v].insert(u); // 无向图需要加上这一行
    }

    // 深度优先搜索函数
    void dfs(int v, vector<bool>& visited) {
        // 标记当前顶点为已访问
        visited[v] = true;
        cout << v << " ";

        // 递归访问当前顶点的所有未访问的邻接顶点
        for (int neighbor : adj[v]) {
            if (!visited[neighbor]) {
                dfs(neighbor, visited);
            }
        }
    }

    // 深度优先搜索函数的入口
    void dfsTraversal() {
        vector<bool> visited(V, false); // 初始化所有顶点均未访问
        cout << "Depth First Traversal: ";
        // 对每个顶点进行深度优先搜索，如果尚未访问过，则调用dfs函数进行搜索
        for (int v = 0; v < V; ++v) {
            if (!visited[v]) {
                dfs(v, visited);
            }
        }
        cout << endl;
    }
};

int main() {
    // 创建一个图对象
    Graph graph(6);
    
    // 添加边
    graph.addEdge(0, 1);
    graph.addEdge(0, 2);
    graph.addEdge(1, 3);
    graph.addEdge(2, 4);
    graph.addEdge(2, 5);

    // 进行深度优先搜索
    graph.dfsTraversal();

    return 0;
}

在这个示例中，我们首先定义了一个名为 Graph 的类，用于表示图结构，并实现了添加边和深度优先搜索的功能。我们使用邻接表来表示图，其中 adj 是一个 vector，每个元素是一个 unordered_set，用于存储每个顶点的邻接顶点。

在 dfs 函数中，我们使用递归的方式进行深度优先搜索。首先标记当前顶点为已访问，并输出其值，然后递归地访问当前顶点的所有未访问的邻接顶点。

在 dfsTraversal 函数中，我们对每个顶点进行深度优先搜索，如果顶点尚未访问过，则调用 dfs 函数进行搜索。

在 main 函数中，我们创建了一个示例图，并添加了一些边，然后调用 dfsTraversal 函数进行深度优先搜索。

输出结果将会是：

Depth First Traversal: 0 1 3 2 4 5

这个结果符合预期，根据深度优先搜索的性质，我们按照深度优先的顺序遍历了图的所有顶点。