C语言实现以下代码（1）在邻接矩阵存储结构下求图G中每个顶点的入度 提示：邻接矩阵上求某点v的入度int InDegreeM （MGraph g，int v）（2）在邻接表存储结构下求图G中每个顶点的入度 提示：邻接表上求某点v的入度int InDegree （ALGraph *G，int v）（3） 在邻接表存储结构下输出图G从顶点0开始的深度优先遍历序列、广度优先遍历序列 （3）在邻接矩阵存储结构下输出图G从顶点0开始的深度优先遍历序列、广度优先遍历序列 （4） 编写主函数测试以上方法（提示：主函数中用二位数组构建邻接矩阵的边）

(1) 邻接矩阵存储结构下求图G中每个顶点的入度：

int InDegreeM (MGraph g, int v) {
    int degree = 0;
    for (int i = 0; i < g.vexnum; i++) {
        if (g.arcs[i][v] == 1) {
            degree++;
        }
    }
    return degree;
}

(2) 邻接表存储结构下求图G中每个顶点的入度：

int InDegree (ALGraph *G, int v) {
    int degree = 0;
    for (int i = 0; i < G->vexnum; i++) {
        ArcNode *p = G->vertices[i].firstarc;
        while (p != NULL) {
            if (p->adjvex == v) {
                degree++;
            }
            p = p->nextarc;
        }
    }
    return degree;
}

(3) 在邻接表存储结构下输出图G从顶点0开始的深度优先遍历序列、广度优先遍历序列：

// 深度优先遍历
void DFS(ALGraph *G, int v, bool *visited) {
    visited[v] = true;
    printf("%d ", v);
    ArcNode *p = G->vertices[v].firstarc;
    while (p != NULL) {
        if (!visited[p->adjvex]) {
            DFS(G, p->adjvex, visited);
        }
        p = p->nextarc;
    }
}

void DFSTraverse(ALGraph *G) {
    bool visited[G->vexnum];
    for (int i = 0; i < G->vexnum; i++) {
        visited[i] = false;
    }
    DFS(G, 0, visited);
}

// 广度优先遍历
void BFSTraverse(ALGraph *G) {
    bool visited[G->vexnum];
    for (int i = 0; i < G->vexnum; i++) {
        visited[i] = false;
    }
    queue<int> q;
    visited[0] = true;
    printf("%d ", 0);
    q.push(0);
    while (!q.empty()) {
        int v = q.front();
        q.pop();
        ArcNode *p = G->vertices[v].firstarc;
        while (p != NULL) {
            if (!visited[p->adjvex]) {
                visited[p->adjvex] = true;
                printf("%d ", p->adjvex);
                q.push(p->adjvex);
            }
            p = p->nextarc;
        }
    }
}

(4) 编写主函数测试以上方法：

int main() {
    MGraph g;
    int edge[5][5] = {
        {0, 1, 1, 0, 0},
        {0, 0, 0, 1, 1},
        {0, 0, 0, 0, 1},
        {0, 0, 0, 0, 1},
        {0, 0, 0, 0, 0}
    };
    CreateMGraph(&g, 5, 5, edge);

    printf("邻接矩阵存储结构下每个顶点的入度：\n");
    for (int i = 0; i < g.vexnum; i++) {
        printf("顶点%d的入度为%d\n", i, InDegreeM(g, i));
    }

    ALGraph *G;
    CreateALGraph(G, 5, 5, edge);

    printf("邻接表存储结构下每个顶点的入度：\n");
    for (int i = 0; i < G->vexnum; i++) {
        printf("顶点%d的入度为%d\n", i, InDegree(G, i));
    }

    printf("邻接表存储结构下从顶点0开始的深度优先遍历序列：\n");
    DFSTraverse(G);
    printf("\n");

    printf("邻接表存储结构下从顶点0开始的广度优先遍历序列：\n");
    BFSTraverse(G);
    printf("\n");

    return 0;
}