c++实现邻接矩阵存储和邻接表存储，并增加求顶点的度、求某顶点的所有邻接点、增加一个顶点、删除一条边等成员函数

好的，我来解答你的问题。

首先，邻接矩阵存储和邻接表存储是两种常见的图的存储方式，它们分别适用于不同的图算法和问题。

邻接矩阵存储：将图的所有顶点用一个一维数组存储，然后将每个顶点的邻接点用一个二维矩阵表示，矩阵的每个元素表示该位置的两个顶点之间是否有边。具体实现如下：

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

// 在顶点u和v之间添加一条边
void add_edge(int u, int v) {
    G[u][v] = 1;
    G[v][u] = 1;
}

// 删除顶点u和v之间的边
void remove_edge(int u, int v) {
    G[u][v] = 0;
    G[v][u] = 0;
}

// 获取顶点v的度数
int get_degree(int v) {
    int degree = 0;
    for (int i = 0; i < n; i++) {
        if (G[v][i]) degree++;
    }
    return degree;
}

// 获取顶点v的所有邻接点
vector<int> get_neighbors(int v) {
    vector<int> neighbors;
    for (int i = 0; i < n; i++) {
        if (G[v][i]) neighbors.push_back(i);
    }
    return neighbors;
}

// 添加一个新顶点
void add_vertex() {
    n++;
}

// 删除一个顶点及其所有边
void remove_vertex(int v) {
    for (int i = 0; i < n; i++) {
        G[v][i] = 0;
        G[i][v] = 0;
    }
    for (int i = v + 1; i < n; i++) {
        for (int j = 0; j < n; j++) {
            G[i - 1][j] = G[i][j];
        }
    }
    for (int i = v + 1; i < n; i++) {
        for (int j = 0; j < n; j++) {
            G[j][i - 1] = G[j][i];
        }
    }
    n--;
}

邻接表存储：将图的所有顶点用一个链表或数组存储，然后将每个顶点的邻接点用一个链表或数组表示。具体实现如下：

const int MAXN = 100; // 最大顶点数
vector<int> G[MAXN]; // 邻接表表示图
int n; // 顶点数

// 在顶点u和v之间添加一条边
void add_edge(int u, int v) {
    G[u].push_back(v);
    G[v].push_back(u);
}

// 删除顶点u和v之间的边
void remove_edge(int u, int v) {
    for (int i = 0; i < G[u].size(); i++) {
        if (G[u][i] == v) {
            G[u].erase(G[u].begin() + i);
            break;
        }
    }
    for (int i = 0; i < G[v].size(); i++) {
        if (G[v][i] == u) {
            G[v].erase(G[v].begin() + i);
            break;
        }
    }
}

// 获取顶点v的度数
int get_degree(int v) {
    return G[v].size();
}

// 获取顶点v的所有邻接点
vector<int> get_neighbors(int v) {
    return G[v];
}

// 添加一个新顶点
void add_vertex() {
    n++;
}

// 删除一个顶点及其所有边
void remove_vertex(int v) {
    for (int i = 0; i < G[v].size(); i++) {
        int u = G[v][i];
        for (int j = 0; j < G[u].size(); j++) {
            if (G[u][j] == v) {
                G[u].erase(G[u].begin() + j);
                break;
            }
        }
    }
    G[v].clear();
    n--;
}

以上就是实现邻接矩阵存储和邻接表存储，并增加求顶点的度、求某顶点的所有邻接点、增加一个顶点、删除一条边等成员函数的代码。