图的表示方法与深度优先搜索

图的表示方法：

1.邻接矩阵：

使用二维数组，matrix [ i ][ j ] 表示从 i 到 j 的边，无向图通常会把matrix [ i ][ j ]和matrix [ j ][ i ]同时设置

#include <iostream>
#include <vector>

using namespace std;

const int MAX_VERTICES = 100;

class Graph {
private:
    int V; // 图的顶点数
    bool adjMatrix[MAX_VERTICES][MAX_VERTICES];

public:
    Graph(int V) {
        this->V = V;
        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
                adjMatrix[i][j] = false;
            }
        }
    }

    // 添加边
    void addEdge(int v, int w) {
        adjMatrix[v][w] = true;
        // 如果是无向图，则需要设置对称的边
        adjMatrix[w][v] = true;
    }
};

2.邻接表：

邻接表使用一组链表来表示图的连接关系。对于每个顶点，都有一个与之相邻的顶点链表，这个链表存储与该顶点直接相连的边。

#include <iostream>
#include <vector>

using namespace std;

class Graph {
private:
    int V; // 图的顶点数
    vector<vector<int>> adjList; // 邻接表

public:
    Graph(int V) {
        this->V = V;
        adjList.resize(V);
    }

    // 添加边
    void addEdge(int v, int w) {
        adjList[v].push_back(w);
        // 如果是无向图，需要添加对称的边
        // adjList[w].push_back(v);
    }
};

 

 深度优先搜索：

1.基于堆栈实现：

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

using namespace std;

// 用邻接表表示图的结构
class Graph {
private:
    int V; // 图的顶点数
    vector<vector<int>> adjList; // 邻接表

public:
    Graph(int V) {
        this->V = V;
        adjList.resize(V);
    }

    // 添加边
    void addEdge(int v, int w) {
        adjList[v].push_back(w);
    }

    // 深度优先搜索
    void DFS(int start) {

// 记录顶点是否被访问过，避免无限循环或遗漏
        vector<bool> visited(V, false); 
        stack<int> dfsStack;

        dfsStack.push(start);
        visited[start] = true;

        while (!dfsStack.empty()) {
            int currVertex = dfsStack.top();
            dfsStack.pop();

            cout << currVertex << " "; // 处理当前顶点

            // 遍历当前顶点的所有邻接顶点
            for (int neighbor : adjList[currVertex]) {
                if (!visited[neighbor]) {
                    dfsStack.push(neighbor);
                    visited[neighbor] = true;
                }
            }
        }
    }
};

int main() {
    // 创建一个有向图
    Graph g(6);
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 3);
    g.addEdge(1, 4);
    g.addEdge(2, 4);
    g.addEdge(3, 4);
    g.addEdge(3, 5);
    g.addEdge(4, 5);

    cout << "Depth First Traversal (starting from vertex 0): ";
    g.DFS(0);

    return 0;
}

2. 基于递归实现

#include <iostream>
#include <vector>

using namespace std;

class Graph {
private:
    int V; // 图的顶点数
    vector<vector<int>> adjList; // 邻接表
    vector<bool> visited; // 记录顶点是否被访问过

public:
    Graph(int V) {
        this->V = V;
        adjList.resize(V);
        visited.resize(V, false);
    }

    // 添加边
    void addEdge(int v, int w) {
        adjList[v].push_back(w);
        // 如果是无向图，需要添加对称的边
        // adjList[w].push_back(v);
    }

    // 深度优先搜索
    void DFS(int v) {
        visited[v] = true;
        cout << v << " "; // 处理当前顶点

        // 递归遍历所有未访问的邻接顶点
        for (int neighbor : adjList[v]) {
            if (!visited[neighbor]) {
                DFS(neighbor);
            }
        }
    }
};

int main() {
    // 创建一个有向图
    Graph g(5);
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 3);
    g.addEdge(2, 4);

    cout << "Depth First Traversal (starting from vertex 0): ";
    g.DFS(0);

    return 0;
}