用c++写图的基本操作实现包含两种存储结构，图的邻接矩阵的建立，邻接表，广度优先遍历和深度优先遍历

好的，我来回答你的问题。首先，我们先来了解一下图的基本概念和两种存储结构。

图是由一组顶点和一组边组成的数据结构，可以用来表示各种实际问题。图的存储结构主要有两种：邻接矩阵和邻接表。

- 邻接矩阵

邻接矩阵是用二维数组来表示图的存储结构，其中矩阵的行和列分别表示图中的顶点，矩阵的元素表示两个顶点之间是否有边相连。

- 邻接表

邻接表是用链表来表示图的存储结构，其中每个顶点对应一条链表，链表中存储着该顶点所连接的其他顶点。

接下来，我们就来看一下如何用C++实现图的基本操作。

1. 邻接矩阵的建立

邻接矩阵的建立可以通过二维数组来实现，其中数组的行和列分别表示图中的顶点，数组元素的值表示两个顶点之间是否有边相连。具体代码如下：

const int MAXN = 100; // 最大顶点数
int G[MAXN][MAXN]; // 邻接矩阵
int n, m; // n为顶点数，m为边数

// 建立邻接矩阵
void buildGraph() {
    memset(G, 0, sizeof(G)); // 初始化邻接矩阵
    cin >> n >> m; // 输入顶点数和边数
    for (int i = 1; i <= m; i++) {
        int u, v;
        cin >> u >> v; // 输入边的两个端点
        G[u][v] = G[v][u] = 1; // 表示两个顶点之间有边相连
    }
}

2. 邻接表的建立

邻接表的建立可以通过链表来实现，其中每个顶点对应一条链表，链表中存储着该顶点所连接的其他顶点。具体代码如下：

const int MAXN = 100; // 最大顶点数
struct Edge {
    int to, next;
}; // 边的结构体
Edge edges[MAXN * 2]; // 边的数组
int head[MAXN], cnt; // head数组存储每个顶点对应的链表头，cnt表示边的数量
int n, m; // n为顶点数，m为边数

// 建立邻接表
void buildGraph() {
    memset(head, -1, sizeof(head)); // 初始化邻接表
    cnt = 0;
    cin >> n >> m; // 输入顶点数和边数
    for (int i = 1; i <= m; i++) {
        int u, v;
        cin >> u >> v; // 输入边的两个端点
        edges[cnt].to = v; // 存储边的信息
        edges[cnt].next = head[u];
        head[u] = cnt++;
        edges[cnt].to = u;
        edges[cnt].next = head[v];
        head[v] = cnt++;
    }
}

3. 广度优先遍历

广度优先遍历（BFS）是一种基于队列的遍历算法，从图的某个顶点开始，访问其所有相邻的顶点，再依次访问这些相邻顶点的相邻顶点，直到遍历完所有能够到达的顶点。具体代码如下：

const int MAXN = 100; // 最大顶点数
int G[MAXN][MAXN]; // 邻接矩阵
int n; // 顶点数

// 广度优先遍历
void bfs(int s) {
    queue<int> q; // 定义队列
    bool vis[MAXN] = {false}; // 标记数组，用于记录每个顶点是否被访问过
    q.push(s); // 将起点加入队列
    vis[s] = true; // 标记起点为已访问
    while (!q.empty()) {
        int u = q.front();
        q.pop(); // 取出队首顶点
        cout << u << " "; // 输出顶点
        for (int v = 1; v <= n; v++) {
            if (G[u][v] && !vis[v]) { // 如果顶点v与u相邻且未访问过
                q.push(v); // 将v加入队列
                vis[v] = true; // 标记v为已访问
            }
        }
    }
}

4. 深度优先遍历

深度优先遍历（DFS）是一种基于栈的遍历算法，从图的某个顶点开始，访问其一个未被访问过的相邻顶点，然后再访问这个相邻顶点的一个未被访问过的相邻顶点，直到遍历到某个顶点的所有可达顶点都被访问过，然后回溯到上一个顶点，继续访问其其他未被访问过的相邻顶点。具体代码如下：

const int MAXN = 100; // 最大顶点数
int G[MAXN][MAXN]; // 邻接矩阵
int n; // 顶点数
bool vis[MAXN]; // 标记数组，用于记录每个顶点是否被访问过

// 深度优先遍历
void dfs(int u) {
    vis[u] = true; // 标记顶点u为已访问
    cout << u << " "; // 输出顶点
    for (int v = 1; v <= n; v++) {
        if (G[u][v] && !vis[v]) { // 如果顶点v与u相邻且未访问过
            dfs(v); // 继续访问顶点v
        }
    }
}

至此，我们已经学习了如何用C++实现图的基本操作，包括邻接矩阵和邻接表的建立，广度优先遍历和深度优先遍历。