使用邻接矩阵和邻接表存储结构存储图，并分别对这两种存储结构存储的图进行DFS和BFS

邻接矩阵存储图：

邻接矩阵是用一个二维数组表示的图，数组中每个元素表示两个顶点之间是否存在一条边。如果两个顶点之间存在边，则该元素的值为1，否则为0。在无向图中，邻接矩阵是对称的，即A[i][j]=A[j][i]。

下面是使用邻接矩阵存储图的DFS和BFS算法实现：

// DFS算法实现
void DFS(int v, int visited[], int n, int A[][n]) {
    visited[v] = 1;  // 标记当前节点已被访问
    printf("%d ", v);

    for (int i = 0; i < n; i++) {  // 遍历当前节点的所有邻居
        if (A[v][i] == 1 && visited[i] == 0) {
            DFS(i, visited, n, A);  // 递归访问邻居节点
        }
    }
}

// BFS算法实现
void BFS(int s, int n, int A[][n]) {
    int visited[n];
    memset(visited, 0, sizeof(visited));  // 初始化visited数组

    queue<int> q;
    visited[s] = 1;
    q.push(s);

    while (!q.empty()) {
        int v = q.front();
        q.pop();
        printf("%d ", v);

        for (int i = 0; i < n; i++) {
            if (A[v][i] == 1 && visited[i] == 0) {
                visited[i] = 1;
                q.push(i);
            }
        }
    }
}

邻接表存储图：

邻接表是由一个数组和若干个链表组成的数据结构，数组中每个元素对应一个顶点，链表中存储该顶点的所有邻居。在链表中，每个节点表示一个邻居，包含两个字段：邻居节点的编号和指向下一个邻居节点的指针。

下面是使用邻接表存储图的DFS和BFS算法实现：

// DFS算法实现
void DFS(int v, int visited[], vector<int> adj[]) {
    visited[v] = 1;  // 标记当前节点已被访问
    printf("%d ", v);

    for (auto u : adj[v]) {  // 遍历当前节点的所有邻居
        if (visited[u] == 0) {
            DFS(u, visited, adj);  // 递归访问邻居节点
        }
    }
}

// BFS算法实现
void BFS(int s, vector<int> adj[]) {
    int visited[adj.size()];
    memset(visited, 0, sizeof(visited));  // 初始化visited数组

    queue<int> q;
    visited[s] = 1;
    q.push(s);

    while (!q.empty()) {
        int v = q.front();
        q.pop();
        printf("%d ", v);

        for (auto u : adj[v]) {
            if (visited[u] == 0) {
                visited[u] = 1;
                q.push(u);
            }
        }
    }
}