求采用邻接矩阵作为存储结构的有向图各顶点的出度

邻接矩阵是一种常用的有向图存储结构，可以用来表示图中各个顶点之间的关系。对于有向图中的每个顶点，其出度表示从该顶点出发可以到达的其他顶点的数量。

要求有向图各顶点的出度，可以通过遍历邻接矩阵中每个顶点的行来实现。具体地，对于邻接矩阵中的第i行，统计其中非零元素的个数即为第i个顶点的出度。

需要注意的是，在有向图中，一个顶点的出度可能为，即该顶点没有指向其他顶点的边。因此，在统计出度时，需要考虑到这种情况。

相关问题

用C语言写出：已知有向图采用邻接矩阵作为存储结构，设计算法求该图中每个顶点的出度和入度

以下是用C语言实现求有向图邻接矩阵中每个顶点的出度和入度的算法：

#include <stdio.h>

#define MAX_VERTEX_NUM 100 // 最大顶点数

// 定义邻接矩阵类型
typedef struct {
    int vexs[MAX_VERTEX_NUM]; // 存储顶点信息
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 存储边的信息
    int vex_num, arc_num; // 顶点数、边数
} MGraph;

// 初始化邻接矩阵
void InitMGraph(MGraph *G) {
    int i, j;
    printf("请输入顶点数和边数：");
    scanf("%d%d", &(G->vex_num), &(G->arc_num));
    printf("请输入顶点信息：");
    for (i = 0; i < G->vex_num; ++i) {
        scanf("%d", &(G->vexs[i]));
    }
    for (i = 0; i < G->vex_num; ++i) {
        for (j = 0; j < G->vex_num; ++j) {
            G->arcs[i][j] = 0; // 初始化为0，即无连接边
        }
    }
    printf("请输入边的信息：\n");
    for (i = 0; i < G->arc_num; ++i) {
        int v1, v2;
        printf("请输入第%d条边的两个顶点序号：", i+1);
        scanf("%d%d", &v1, &v2);
        G->arcs[v1][v2] = 1; // 有连接边的位置置为1
    }
}

// 计算每个顶点的出度和入度
void CalInOutDegree(MGraph G, int *in_degree, int *out_degree) {
    int i, j;
    for (i = 0; i < G.vex_num; ++i) {
        int in = 0, out = 0;
        for (j = 0; j < G.vex_num; ++j) {
            if (G.arcs[i][j] == 1) { // 有连接边，则出度+1
                out++;
            }
            if (G.arcs[j][i] == 1) { // 有连接边，则入度+1
                in++;
            }
        }
        in_degree[i] = in;
        out_degree[i] = out;
    }
}

// 输出每个顶点的出度和入度
void PrintInOutDegree(MGraph G, int *in_degree, int *out_degree) {
    int i;
    printf("每个顶点的出度和入度如下：\n");
    for (i = 0; i < G.vex_num; ++i) {
        printf("顶点%d：出度%d，入度%d\n", G.vexs[i], out_degree[i], in_degree[i]);
    }
}

int main() {
    MGraph G;
    int in_degree[MAX_VERTEX_NUM], out_degree[MAX_VERTEX_NUM];
    InitMGraph(&G);
    CalInOutDegree(G, in_degree, out_degree);
    PrintInOutDegree(G, in_degree, out_degree);
    return 0;
}

注意：该算法实现的是有向图邻接矩阵的存储结构，且默认顶点信息为整数，因此输入信息时顶点信息也需为整数。

用C语言写出代码和输入实例及结果：已知有向图采用邻接矩阵作为存储结构，设计算法求该图中每个顶点的出度和入度,

代码如下：

#include <stdio.h>

#define MAX_VERTEX_NUM 100

typedef struct {
    int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 邻接矩阵
    int vex_num, arc_num; // 顶点数、弧数
} Graph;

// 初始化有向图
void init_graph(Graph *g, int vex_num, int arc_num) {
    g->vex_num = vex_num;
    g->arc_num = arc_num;
    for (int i = 0; i < MAX_VERTEX_NUM; ++i) {
        for (int j = 0; j < MAX_VERTEX_NUM; ++j) {
            g->arcs[i][j] = 0; // 初始化邻接矩阵
        }
    }
}

// 添加弧
void add_arc(Graph *g, int start, int end) {
    g->arcs[start][end] = 1;
}

// 求每个顶点的出度和入度
void get_degree(Graph g, int out_degree[], int in_degree[]) {
    for (int i = 0; i < g.vex_num; ++i) {
        out_degree[i] = 0;
        in_degree[i] = 0;
        for (int j = 0; j < g.vex_num; ++j) {
            if (g.arcs[i][j]) { // 如果有弧 i -> j
                out_degree[i]++; // i 的出度加 1
                in_degree[j]++; // j 的入度加 1
            }
        }
    }
}

int main() {
    Graph g;
    int out_degree[MAX_VERTEX_NUM], in_degree[MAX_VERTEX_NUM];
    int vex_num, arc_num;
    printf("请输入顶点数和弧数：");
    scanf("%d%d", &vex_num, &arc_num);
    init_graph(&g, vex_num, arc_num);
    printf("请输入每条弧的起点和终点：\n");
    for (int i = 0; i < arc_num; ++i) {
        int start, end;
        scanf("%d%d", &start, &end);
        add_arc(&g, start, end);
    }
    get_degree(g, out_degree, in_degree);
    printf("每个顶点的出度和入度分别为：\n");
    for (int i = 0; i < vex_num; ++i) {
        printf("顶点 %d：出度 %d，入度 %d\n", i, out_degree[i], in_degree[i]);
    }
    return 0;
}

输入实例：

请输入顶点数和弧数：4 5
请输入每条弧的起点和终点：
0 1
1 2
2 0
1 3
3 2

输出结果：

每个顶点的出度和入度分别为：
顶点 0：出度 1，入度 1
顶点 1：出度 2，入度 1
顶点 2：出度 1，入度 2
顶点 3：出度 1，入度 1