设图结点的元素类型为char，建立一个不少于8个顶点的带权无向图G，实现以下图的各种基本操作的程序： ① 用邻接矩阵作为储结构存储图G并输出该邻接矩阵； ② 用邻接链表作为储结构存储图G并输出该邻接链表； ③ 按DFS算法输出图G中顶点的遍历序列； ④ 按BFS算法输出图G中顶点的遍历序列； ⑤主函数通过函数调用实现以上各项操作。并注释

好的，我会根据您的要求回答问题。以下是对问题的回答：

对于该问题，我建议您使用C++语言进行编写。以下是代码实现：

#include <iostream>
#include <queue>
#include <stack>
using namespace std;

const int MAXVEX = 8;   // 图的最大顶点数

// 邻接矩阵表示法
typedef struct {
    char vexs[MAXVEX];  // 存储顶点的数组
    int arc[MAXVEX][MAXVEX];  // 存储边的二维数组
} AdjMatrix;

// 邻接表表示法
typedef struct ArcNode {
    int adjvex;  // 该弧所指向的顶点的位置
    struct ArcNode *next;  // 指向下一条弧的指针
} ArcNode;

typedef struct VNode {
    char data;  // 顶点信息
    ArcNode *first;  // 指向第一条依附该顶点的弧
} VNode, AdjList[MAXVEX];

typedef struct {
    AdjList adjList;  // 图中每个顶点的邻接表
    int numVertexes;  // 顶点数
    int numEdges;  // 边数
} AdjListGraph;

// 深度优先搜索算法
void DFS(AdjMatrix G, int i, bool *visited) {
    visited[i] = true;
    cout << G.vexs[i] << " ";
    for (int j = 0; j < MAXVEX; j++) {
        if (G.arc[i][j] != 0 && !visited[j]) {
            DFS(G, j, visited);
        }
    }
}

// 广度优先搜索算法
void BFS(AdjMatrix G, int i, bool *visited) {
    queue<int> q;
    q.push(i);
    visited[i] = true;
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        cout << G.vexs[u] << " ";
        for (int v = 0; v < MAXVEX; v++) {
            if (G.arc[u][v] != 0 && !visited[v]) {
                visited[v] = true;
                q.push(v);
            }
        }
    }
}

// 邻接矩阵表示法
void CreateGraph(AdjMatrix &G) {
    // 输入顶点信息
    cout << "请输入" << MAXVEX << "个顶点的信息：";
    for (int i = 0; i < MAXVEX; i++) {
        cin >> G.vexs[i];
    }

    // 初始化边的矩阵
    for (int i = 0; i < MAXVEX; i++) {
        for (int j = 0; j < MAXVEX; j++) {
            G.arc[i][j] = 0;
        }
    }

    // 输入边的信息
    int n;
    cout << "请输入边的数目：";
    cin >> n;
    for (int k = 0; k < n; k++) {
        char v1, v2;
        int i, j;
        cout << "请输入边(vi, vj)的顶点序号：";
        cin >> v1 >> v2;
        i = v1 - 'A';
        j = v2 - 'A';
        G.arc[i][j] = 1;
        G.arc[j][i] = G.arc[i][j]; // 无向图矩阵对称
    }

    // 输出邻接矩阵
    cout << "邻接矩阵为：" << endl;
    for (int i = 0; i < MAXVEX; i++) {
        for (int j = 0; j < MAXVEX; j++) {
            cout << G.arc[i][j] << " ";
        }
        cout << endl;
    }
}

// 邻接表表示法
void CreateALGraph(AdjListGraph &G) {
    // 输入顶点信息
    cout << "请输入" << MAXVEX << "个顶点的信息：";
    for (int i = 0; i < MAXVEX; i++) {
        cin >> G.adjList[i].data;
        G.adjList[i].first = NULL;
    }

    // 输入边的信息
    int n;
    cout << "请输入边的数目：";
    cin >> n;
    for (int k = 0; k < n; k++) {
        char v1, v2;
        int i, j;
        cout << "请输入边(vi, vj)的顶点序号：";
        cin >> v1 >> v2;
        i = v1 - 'A';
        j = v2 - 'A';

        ArcNode *e1 = new ArcNode;
        e1->adjvex = j;
        e1->next = G.adjList[i].first;
        G.adjList[i].first = e1;

        ArcNode *e2 = new ArcNode;
        e2->adjvex = i;
        e2->next = G.adjList[j].first;
        G.adjList[j].first = e2;
    }

    G.numVertexes = MAXVEX;
    G.numEdges = n;
}

// 输出邻接表
void PrintALGraph(AdjListGraph G) {
    cout << "邻接表为：" << endl;
    for (int i = 0; i < G.numVertexes; i++) {
        cout << G.adjList[i].data << ": ";
        ArcNode *p = G.adjList[i].first;
        while (p != NULL) {
            cout << G.adjList[p->adjvex].data << " ";
            p = p->next;
        }
        cout << endl;
    }
}

// 主函数通过函数调用实现以上各项操作
int main() {
    AdjMatrix G1;
    CreateGraph(G1);

    AdjListGraph G2;
    CreateALGraph(G2);
    PrintALGraph(G2);

    // DFS算法
    bool visited[MAXVEX];
    cout << "DFS遍历序列为：";
    for (int i = 0; i < MAXVEX; i++) {
        visited[i] = false;
    }
    for (int i = 0; i < MAXVEX; i++) {
        if (!visited[i]) {
            DFS(G1, i, visited);
        }
    }
    cout << endl;

    // BFS算法
    cout << "BFS遍历序列为：";
    for (int i = 0; i < MAXVEX; i++) {
        visited[i] = false;
    }
    for (int i = 0; i < MAXVEX; i++) {
        if (!visited[i]) {
            BFS(G1, i, visited);
        }
    }
    cout << endl;

    return 0;
}

以上是一个完整的实现，其中包括邻接矩阵和邻接表两种储存结构，以及DFS和BFS两种遍历算法。