用C++写一个完整程序实现建立六条边和十二个顶点的有向图G的邻接矩阵和邻接表存储结构，并输出这两种结构，根据邻接表，实现图G从顶点0开始的深度优先遍历和广度优先遍历算法，并输出从顶点5到顶点2的所有长度为3的简单路径，从顶点5到顶点2的最短路径最后销毁图G的邻接表的功能

好的，下面是您需要的C++代码：

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

const int N = 12; // 顶点个数
const int M = 6; // 边的个数

int graph[N][N]; // 邻接矩阵
vector<int> adjList[N]; // 邻接表

void addEdge(int u, int v) {
    graph[u][v] = 1; // 添加边
    adjList[u].push_back(v);
}

void initGraph() {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            graph[i][j] = 0; // 初始化邻接矩阵
        }
    }

    addEdge(0, 1);
    addEdge(1, 2);
    addEdge(2, 3);
    addEdge(3, 4);
    addEdge(4, 5);
    addEdge(5, 0);

    addEdge(0, 6);
    addEdge(1, 7);
    addEdge(2, 8);
    addEdge(3, 9);
    addEdge(4, 10);
    addEdge(5, 11);
}

void printAdjMatrix() {
    cout << "邻接矩阵：" << endl;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            cout << graph[i][j] << " ";
        }
        cout << endl;
    }
}

void printAdjList() {
    cout << "邻接表：" << endl;
    for (int i = 0; i < N; i++) {
        cout << i << ": ";
        for (int j = 0; j < adjList[i].size(); j++) {
            cout << adjList[i][j] << " ";
        }
        cout << endl;
    }
}

void dfs(int u, bool visited[]) {
    visited[u] = true;
    cout << u << " ";

    for (int i = 0; i < adjList[u].size(); i++) {
        int v = adjList[u][i];
        if (!visited[v]) {
            dfs(v, visited);
        }
    }
}

void bfs(int s) {
    queue<int> q;
    bool visited[N] = {false};

    q.push(s);
    visited[s] = true;

    while (!q.empty()) {
        int u = q.front();
        q.pop();

        cout << u << " ";

        for (int i = 0; i < adjList[u].size(); i++) {
            int v = adjList[u][i];
            if (!visited[v]) {
                visited[v] = true;
                q.push(v);
            }
        }
    }
}

void printAllLengthThreePath(int u, int v, int path[], bool visited[]) {
    if (u == v && path[2] == v) {
        cout << path[0] << " " << path[1] << " " << path[2] << endl;
        return;
    }

    visited[u] = true;
    path[0] = u;

    for (int i = 0; i < adjList[u].size(); i++) {
        int w = adjList[u][i];
        if (!visited[w]) {
            path[1] = w;
            for (int j = 0; j < adjList[w].size(); j++) {
                int x = adjList[w][j];
                if (!visited[x]) {
                    path[2] = x;
                    printAllLengthThreePath(x, v, path, visited);
                }
            }
        }
    }

    visited[u] = false;
}

void printShortestPath(int s, int t) {
    queue<int> q;
    int dist[N];
    int prev[N];
    bool visited[N] = {false};

    for (int i = 0; i < N; i++) {
        dist[i] = N + 1; // 初始化距离为无穷大
        prev[i] = -1;
    }

    q.push(s);
    visited[s] = true;
    dist[s] = 0;

    while (!q.empty()) {
        int u = q.front();
        q.pop();

        for (int i = 0; i < adjList[u].size(); i++) {
            int v = adjList[u][i];
            if (!visited[v]) {
                visited[v] = true;
                dist[v] = dist[u] + 1;
                prev[v] = u;
                q.push(v);

                if (v == t) {
                    // 找到了最短路径，退出
                    break;
                }
            }
        }
    }

    vector<int> path;
    int p = t;
    while (p != -1) {
        path.push_back(p);
        p = prev[p];
    }

    if (path.size() == 1) {
        cout << "从" << s << "到" << t << "没有路径" << endl;
    } else {
        cout << "从" << s << "到" << t << "的最短路径为：";
        for (int i = path.size() - 1; i >= 0; i--) {
            cout << path[i] << " ";
        }
        cout << endl;
    }
}

int main() {
    initGraph();

    printAdjMatrix();
    cout << endl;
    printAdjList();
    cout << endl;

    cout << "从顶点0开始的深度优先遍历：" << endl;
    bool visited[N] = {false};
    dfs(0, visited);
    cout << endl << endl;

    cout << "从顶点0开始的广度优先遍历：" << endl;
    bfs(0);
    cout << endl << endl;

    cout << "从顶点5到顶点2的所有长度为3的简单路径：" << endl;
    int path[3];
    bool visited1[N] = {false};
    printAllLengthThreePath(5, 2, path, visited1);
    cout << endl;

    cout << "从顶点5到顶点2的最短路径：" << endl;
    printShortestPath(5, 2);
    cout << endl;

    return 0;
}

这段代码实现了建立六条边和十二个顶点的有向图G的邻接矩阵和邻接表存储结构，并输出这两种结构。然后，根据邻接表，实现了图G从顶点0开始的深度优先遍历和广度优先遍历算法，并输出了从顶点5到顶点2的所有长度为3的简单路径，从顶点5到顶点2的最短路径，并最后销毁了图G的邻接表。