在C语言中，如何使用邻接矩阵创建一个有向图，并计算顶点的度？请提供示例代码。

在C语言中实现有向图的邻接矩阵存储，首先需要定义图的数据结构，包括顶点数组、邻接矩阵、顶点数、边数以及图的类型。接下来，通过`create_MG`函数初始化图，设置边的连接，并通过`getIndexOfVexs`函数查找顶点索引。为了计算顶点的度，需要遍历邻接矩阵的每一行来统计非零元素的个数，即为该顶点的度。示例代码如下：

参考资源链接：[C语言实现图的邻接矩阵存储及操作](https://wenku.csdn.net/doc/6412b66dbe7fbd1778d46b04?spm=1055.2569.3001.10343)

（示例代码）

在这段代码中，我们首先定义了图的数据结构`MGraph`，然后通过`create_MG`函数初始化了一个有向图，并通过用户输入构建了邻接矩阵。计算每个顶点的度是通过循环每一行并统计非零元素的数量来完成的。这样，我们不仅能够创建并初始化图，还能够计算出每个顶点的度，这对于后续的图论算法实现是十分关键的一步。

如果你对图的邻接矩阵存储操作感兴趣，并希望深入学习更多相关的数据结构和算法知识，可以参考这篇辅助资料：《C语言实现图的邻接矩阵存储及操作》。本文详细介绍了创建邻接矩阵、查找顶点索引以及初始化图的过程，非常适合希望提升自己图论实现能力的读者。

参考资源链接：[C语言实现图的邻接矩阵存储及操作](https://wenku.csdn.net/doc/6412b66dbe7fbd1778d46b04?spm=1055.2569.3001.10343)

相关问题

邻接矩阵创建有向图并输出每个顶点的度C语言

好的，下面是邻接矩阵创建有向图并输出每个顶点的度的C语言代码：

#include <stdio.h>

#define MAX_VERTEX_NUM 100 // 最大顶点数

typedef struct {
    int vertex[MAX_VERTEX_NUM]; // 顶点数组
    int arc[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 邻接矩阵
    int vertex_num; // 顶点数
    int edge_num; // 边数
} Graph;

// 创建有向图的邻接矩阵
void createGraph(Graph *G) {
    printf("请输入顶点数和边数：\n");
    scanf("%d%d", &G->vertex_num, &G->edge_num);
    printf("请输入顶点信息：\n");
    for (int i = 0; i < G->vertex_num; i++) {
        scanf("%d", &G->vertex[i]);
    }
    // 初始化邻接矩阵
    for (int i = 0; i < G->vertex_num; i++) {
        for (int j = 0; j < G->vertex_num; j++) {
            G->arc[i][j] = 0;
        }
    }
    printf("请依次输入边的两个顶点的序号：\n");
    for (int k = 0; k < G->edge_num; k++) {
        int i, j;
        scanf("%d%d", &i, &j);
        G->arc[i][j] = 1;
    }
}

// 输出每个顶点的度
void printDegree(Graph G) {
    printf("每个顶点的度为：\n");
    for (int i = 0; i < G.vertex_num; i++) {
        int in_degree = 0; // 入度
        int out_degree = 0; // 出度
        for (int j = 0; j < G.vertex_num; j++) {
            if (G.arc[j][i] == 1) {
                in_degree++;
            }
            if (G.arc[i][j] == 1) {
                out_degree++;
            }
        }
        printf("顶点 %d 的入度为 %d，出度为 %d\n", G.vertex[i], in_degree, out_degree);
    }
}

int main() {
    Graph G;
    createGraph(&G);
    printDegree(G);
    return 0;
}

这段代码中，我们首先定义了一个结构体 `Graph`，用于存储有向图的信息，包括顶点数组、邻接矩阵、顶点数和边数。然后我们使用 `createGraph` 函数创建有向图的邻接矩阵，其中通过用户的输入来确定顶点数、边数和每个顶点的信息，并初始化邻接矩阵。最后，我们使用 `printDegree` 函数输出每个顶点的入度和出度，这里使用两个循环分别计算每个顶点的入度和出度，并输出结果。

用c语言实现邻接矩阵创建一个带权有向图并实现计算各顶点的入度，深度优先遍历，广度优先遍历

好的，下面是基于邻接矩阵的带权有向图的实现和相关操作的代码（使用 C 语言实现）：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <limits.h> // 定义一个无穷大的数

#define MAX_SIZE 100 // 最大顶点数
#define INF INT_MAX // 定义一个无穷大的数

typedef struct {
    int vertex_num; // 顶点数
    int edge_num; // 边数
    int matrix[MAX_SIZE][MAX_SIZE]; // 邻接矩阵
} Graph;

// 创建一个新的图
Graph* createGraph(int n, int m) {
    Graph* graph = (Graph*)malloc(sizeof(Graph));
    graph->vertex_num = n;
    graph->edge_num = m;
    // 初始化邻接矩阵
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            graph->matrix[i][j] = INF;
        }
    }
    return graph;
}

// 添加一条从 u 到 v 的边，权值为 w
void addEdge(Graph* graph, int u, int v, int w) {
    graph->matrix[u][v] = w;
}

// 计算各个顶点的入度
void calcInDegree(Graph* graph) {
    int in_degree[MAX_SIZE] = {0};
    for (int j = 1; j <= graph->vertex_num; j++) {
        for (int i = 1; i <= graph->vertex_num; i++) {
            if (graph->matrix[i][j] != INF) {
                in_degree[j]++;
            }
        }
    }
    for (int i = 1; i <= graph->vertex_num; i++) {
        printf("顶点 %d 的入度为 %d\n", i, in_degree[i]);
    }
}

// 深度优先遍历
void dfs(Graph* graph, int u, bool visited[]) {
    visited[u] = true;
    printf("%d ", u);
    for (int v = 1; v <= graph->vertex_num; v++) {
        if (graph->matrix[u][v] != INF && !visited[v]) {
            dfs(graph, v, visited);
        }
    }
}

// 从顶点 s 开始进行深度优先遍历
void dfsTraversal(Graph* graph, int s) {
    bool visited[MAX_SIZE] = {false};
    dfs(graph, s, visited);
    printf("\n");
}

// 广度优先遍历
void bfsTraversal(Graph* graph, int s) {
    bool visited[MAX_SIZE] = {false};
    int queue[MAX_SIZE];
    int front = 0, rear = 0;
    queue[rear++] = s;
    visited[s] = true;
    while (front < rear) {
        int u = queue[front++];
        printf("%d ", u);
        for (int v = 1; v <= graph->vertex_num; v++) {
            if (graph->matrix[u][v] != INF && !visited[v]) {
                queue[rear++] = v;
                visited[v] = true;
            }
        }
    }
    printf("\n");
}

int main() {
    int n, m;
    printf("请输入顶点数和边数：");
    scanf("%d%d", &n, &m);

    Graph* graph = createGraph(n, m);

    printf("请依次输入边的起点、终点和权值：\n");
    for (int i = 1; i <= m; i++) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        addEdge(graph, u, v, w);
    }

    printf("各个顶点的入度为：\n");
    calcInDegree(graph);

    printf("深度优先遍历结果为：");
    dfsTraversal(graph, 1);

    printf("广度优先遍历结果为：");
    bfsTraversal(graph, 1);

    return 0;
}

示例输入：

请输入顶点数和边数：5 6
请依次输入边的起点、终点和权值：
1 2 1
1 3 2
2 4 3
2 5 4
3 5 5
4 5 6

示例输出：

各个顶点的入度为：
顶点 1 的入度为 0
顶点 2 的入度为 1
顶点 3 的入度为 1
顶点 4 的入度为 1
顶点 5 的入度为 3
深度优先遍历结果为：1 2 4 5 3
广度优先遍历结果为：1 2 3 4 5