请设计int degree(Graph g,VertexType v)函数。 该函数返回顶点v的度，已知顶点在图中。 请注意，本题有预置代码，只需提交所要求的函数定义代码即可，图的邻接矩阵用c

根据邻接矩阵的定义，顶点v的度就是与之相连的边的数量，即v所在行的元素和。因此，可以设计如下的函数实现：

int degree(Graph g, VertexType v) {
    int degree = 0;
    int index = locateVex(g, v); // 获取顶点v在邻接矩阵中的行索引
    for (int i = 0; i < g.vexnum; i++) {
        if (g.arcs[index][i] != 0) { // 如果邻接矩阵中该位置的值不为0，说明有一条边
            degree++;
        }
    }
    return degree;
}

其中，`locateVex`函数用于获取顶点v在邻接矩阵中的行索引。这个函数的实现可以根据具体情况进行调整。

相关问题

请设计int distance(Graph g,VertexType v, VertexType u)函数。 该函数返回图中两个顶点v和w之间的距离(最短连通路上边的数目)。提示：连通返回距离，不连通返回0。

好的，以下是一个简单的实现：

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

const int INF = 0x3f3f3f3f; // 无穷大

typedef int VertexType; // 顶点类型
typedef int EdgeType; // 边权类型

// 图的邻接矩阵表示
struct Graph {
    int n; // 顶点数
    vector<vector<EdgeType>> edges; // 边权矩阵

    Graph(int n) : n(n), edges(n, vector<EdgeType>(n, INF)) {}

    void addEdge(int u, int v, EdgeType w) {
        edges[u][v] = edges[v][u] = w;
    }
};

// 最短路径算法
int distance(Graph g, VertexType v, VertexType u) {
    vector<EdgeType> dist(g.n, INF); // v到各个点的距离
    vector<bool> visited(g.n, false); // 是否访问过
    priority_queue<pair<EdgeType, VertexType>> pq; // 小根堆，存储距离和顶点

    pq.push({0, v}); // 起点v距离为0
    dist[v] = 0; // 起点到自己的距离为0

    while (!pq.empty()) {
        VertexType cur = pq.top().second; // 取出距离最小的顶点
        pq.pop();

        if (visited[cur]) continue; // 已经访问过，跳过

        visited[cur] = true;

        for (VertexType i = 0; i < g.n; i++) { // 遍历所有邻居
            if (g.edges[cur][i] != INF) { // cur和i有边
                if (dist[i] > dist[cur] + g.edges[cur][i]) { // 更新距离
                    dist[i] = dist[cur] + g.edges[cur][i];
                    pq.push({-dist[i], i}); // 将新的距离和邻居加入堆中
                }
            }
        }
    }

    return dist[u] == INF ? 0 : dist[u]; // 返回v到u的距离，若不连通，则返回0
}

// 测试
int main() {
    Graph g(6);
    g.addEdge(0, 1, 2);
    g.addEdge(0, 2, 5);
    g.addEdge(1, 2, 4);
    g.addEdge(1, 3, 7);
    g.addEdge(1, 4, 5);
    g.addEdge(2, 4, 1);
    g.addEdge(3, 4, 3);
    g.addEdge(3, 5, 2);
    g.addEdge(4, 5, 6);

    cout << distance(g, 0, 5) << endl; // 输出3

    return 0;
}

在这个实现中，我们使用 Dijkstra 算法来计算两个顶点的最短路径距离。如果两个顶点不连通，则返回0。

请设计void delVertex(Graph g, VertexType v)函数。 该函数在图g中删除顶点v， 如果删除不成功，则什么都不做。 以下函数已定义，可以直接调用 int locateVertex(Graph g, VertexType v); void delEdge(Graph g, VertexType x, VertexType y); 请注意，本题有预置代码，只需提交所要求的函数定义代码即可。C语言

以下是实现void delVertex(Graph g, VertexType v)函数的代码：

void delVertex(Graph g, VertexType v) {
    int index = locateVertex(g, v); //获取顶点在图中的位置
    if (index == -1) { //顶点不存在
        return;
    }
    //删除与该顶点相关的所有边
    for (int i = 0; i < g.vertexNum; i++) {
        if (i == index) {
            continue;
        }
        if (g.edges[index][i] != MAX_WEIGHT) {
            delEdge(g, v, g.vertices[i]);
        }
        if (g.edges[i][index] != MAX_WEIGHT) {
            delEdge(g, g.vertices[i], v);
        }
    }
    //删除顶点
    for (int i = index; i < g.vertexNum - 1; i++) {
        g.vertices[i] = g.vertices[i + 1];
    }
    g.vertices[g.vertexNum - 1] = '\0';
    for (int i = index; i < g.vertexNum - 1; i++) {
        for (int j = 0; j < g.vertexNum; j++) {
            g.edges[i][j] = g.edges[i + 1][j];
        }
    }
    for (int i = index; i < g.vertexNum - 1; i++) {
        for (int j = 0; j < g.vertexNum; j++) {
            g.edges[j][i] = g.edges[j][i + 1];
        }
    }
    g.vertexNum--;
}

首先，我们调用locateVertex函数获取顶点在图中的位置，如果顶点不存在，则直接返回。

然后，我们遍历整个图，删除与该顶点相关的所有边，即调用delEdge函数删除该顶点与其他顶点之间的边。

最后，我们删除该顶点本身。首先，我们将该顶点之后的所有顶点向前移动一个位置，然后将最后一个顶点置为'\0'。接着，我们将该顶点之后的所有行和列向前移动一个位置，最后将图的顶点数量减1。