C++的数据结构(十三）：图的深度优先遍历（DFS）

        在计算机科学中，图是一种非线性数据结构，由顶点和边组成。图的遍历是图论中的一个基本问题，而深度优先遍历（DFS）是其中的一种重要方法。

        深度优先遍历的核心思想是尽可能深地搜索图的分支。它通常使用递归或栈来实现。遍历过程如下：

        1. 选择一个起始节点，并将其标记为已访问。
        2. 遍历该节点的所有邻居节点，对于每个未访问过的邻居节点，递归地执行深度优先遍历。
        3. 当所有邻居节点都被访问过后，回溯到上一个节点，继续遍历其他未访问过的邻居节点。
        4. 重复上述步骤，直到所有节点都被访问过为止。

        下面是一个使用邻接表表示图和实现深度优先遍历的C++示例，代码如下。

#include <iostream>
#include <vector>
#include <list>

using namespace std;

// 定义图的节点类
class GraphNode {
public:
    int value;
    list<GraphNode*> neighbors;

    GraphNode(int val) : value(val) {}
};

// 深度优先遍历函数
void DFS(GraphNode* node, vector<bool>& visited) {
    if (node == nullptr || visited[node->value]) {
        return;
    }
    visited[node->value] = true; // 标记当前节点为已访问
    cout << node->value << " "; // 访问当前节点
    for (auto neighbor : node->neighbors) {
        DFS(neighbor, visited); // 递归遍历邻居节点
    }
}

int main() {
    // 创建图的节点和边
    GraphNode* node1 = new GraphNode(1);
    GraphNode* node2 = new GraphNode(2);
    GraphNode* node3 = new GraphNode(3);
    GraphNode* node4 = new GraphNode(4);
    GraphNode* node5 = new GraphNode(5);
    node1->neighbors.push_back(node2);
    node1->neighbors.push_back(node3);
    node2->neighbors.push_back(node4);
    node3->neighbors.push_back(node4);
    node3->neighbors.push_back(node5);
    node4->neighbors.push_back(node5);

    // 初始化访问状态数组
    vector<bool> visited(6, false); // 假设图中节点编号从1到5

    // 执行深度优先遍历
    DFS(node1, visited);

    return 0;
}

        结果如下图所示。 

        在这个示例中，我们首先定义了一个`GraphNode`类来表示图的节点，每个节点包含一个值和一个邻居节点的链表。然后，我们实现了`DFS`函数来执行深度优先遍历。在`main`函数中，我们创建了一个包含5个节点的图，并初始化了访问状态数组。最后，我们从节点1开始执行深度优先遍历，并打印出访问的节点顺序。

        下面我们将通过两个实例，使用C++语言来实现图的DFS算法，并分别用于检测无向图和有向图是否连通。代码如下。

#include <iostream>
#include <vector>
#include <stack>

using namespace std;

class Graph {
    int numVertices;    // 顶点的数量
    vector<vector<int>> adjList; // 邻接表

public:
    Graph(int vertices) {
        numVertices = vertices;
        adjList.resize(vertices);
    }

    // 添加边
    void addEdge(int src, int dest) {
        adjList[src].push_back(dest);
        // 对于无向图，我们也需要添加反向边
        adjList[dest].push_back(src);
    }

    // DFS 遍历函数
    void DFS(int v, vector<bool>& visited) {
        // 标记当前节点为已访问
        visited[v] = true;
        cout << v << " ";

        // 遍历所有与当前节点相邻的节点
        for (int i = 0; i < adjList[v].size(); i++) {
            int n = adjList[v][i];
            if (!visited[n]) {
                DFS(n, visited);
            }
        }
    }

    // 检测图是否连通（无向图）
    bool isConnected() {
        vector<bool> visited(numVertices, false);
        // 从第一个顶点开始进行DFS
        if (!visited[0]) {
            DFS(0, visited);
        }

        // 检查是否所有顶点都被访问
        for (bool visitedVertex : visited) {
            if (!visitedVertex) {
                return false; // 存在未访问的顶点，则图不是连通的
            }
        }
        return true; // 所有顶点都被访问，图是连通的
    }

    // 检测有向图是否单源连通
    // 这里检测从某个指定源点是否可以到达所有其他顶点
    bool isSingleSourceConnected(int source) {
        vector<bool> visited(numVertices, false);
        DFS(source, visited);

        // 检查是否所有顶点都被访问
        for (bool visitedVertex : visited) {
            if (!visitedVertex) {
                return false; // 存在未访问的顶点，则图不是单源连通的
            }
        }
        return true; // 所有顶点都被访问，图是单源连通的
    }
};
int main() {
    // 创建一个包含5个顶点的无向图
    Graph g(5);

    // 添加边
    g.addEdge(0, 1);
    g.addEdge(0, 4);
    g.addEdge(1, 2);
    g.addEdge(1, 3);
    g.addEdge(1, 4);
    g.addEdge(2, 3);
    g.addEdge(3, 4);

    // 检测图是否连通
    if (g.isConnected()) {
        cout << "图形已连接." << endl;
    } else {
        cout << "图形未连接." << endl;
    }
    
	// 创建一个包含5个顶点的有向图
    Graph h(5); 
    // 添加边
    h.addEdge(0, 1);
    h.addEdge(0, 2);
    h.addEdge(1, 2);
    h.addEdge(2, 0);
    h.addEdge(2, 3);
    h.addEdge(3, 3); // 自环
     // 从顶点0开始进行DFS检测
    if (h.isSingleSourceConnected(0)) {
        cout << "有向图是从顶点0连接,是单源连通的." << endl;
    } else {
        cout << "有向图不是从顶点0连接,不是单源连通的." << endl;
    }

    return 0;
}

         结果如下图所示。

        请注意，以上代码中`isSingleSourceConnected` 方法仅用于检测从指定源点出发的图是否单源连通。若要检测整个有向图是否强连通（即从任意一点都能到达其他任意一点），则需要一个不同的算法，如Kosaraju算法或Tarjan算法。这里只是简单展示了单源连通性的检测。 

        在实际应用中，可能还需要进行错误处理（比如检查添加的边是否合法，是否重复等），以及图的可视化等，以便更好地理解和使用图结构及其算法。此外，上述代码是基于邻接列表表示的图结构，这种表示方法对于稀疏图比较高效。对于稠密图，邻接矩阵可能更合适。