用C语言实现(1) 键盘输入数据，建立一个有向图的邻接表。 (2) 输出该邻接表。 (3) 在有向图的邻接表的基础上计算各顶点的度，并输出。的难点

实现这个任务的难点主要在于以下几个方面：

1. 键盘输入数据：需要使用C语言的输入函数来获取用户输入的数据，如scanf()函数。对于图的邻接表的输入，需要先确定图中有多少个顶点，然后针对每个顶点输入它的出边集合。

2. 建立邻接表：建立一个邻接表需要使用到指针和动态内存分配。具体来说，可以使用一个数组来存储每个顶点的出边集合，每个出边集合都是一个链表，链表中的每个节点表示一条有向边。

3. 输出邻接表：遍历每个顶点的出边集合，输出每条有向边的终点。

4. 计算各顶点的度：对于每个顶点，需要遍历它的出边集合，计算其出度；同时需要遍历每个顶点的入边集合，计算其入度。计算度数时，可以使用一个数组来存储每个顶点的度数。

总体来说，实现这个任务需要掌握C语言的基本语法和数据结构，能够熟练使用指针和动态内存分配，理解图的邻接表的基本概念和实现方法，具备遍历链表的能力。

相关问题

用C语言实现(1) 键盘输入数据，建立一个有向图的邻接表。 (2) 输出该邻接表。 (3) 在有向图的邻接表的基础上计算各顶点的度，并输出。

好的，我可以为您解答这个问题。

首先，我们需要了解邻接表的定义和有向图的定义。

邻接表是一种表示图的数据结构，它将每个顶点的所有邻接点都保存在一个链表中，它是一种比邻接矩阵更节省空间的存储方式。

有向图是一种图，它的边有方向，即从一个顶点到另一个顶点有一个箭头指向。

接下来，我们来看看如何用C语言实现。

1. 键盘输入数据，建立一个有向图的邻接表。

我们可以先定义一个结构体表示每个顶点和它所连接的边：

// 边节点结构体
typedef struct EdgeNode {
    int adjvex;             // 邻接点的下标
    struct EdgeNode *next;  // 下一个邻接点
} EdgeNode;

// 顶点结构体
typedef struct VertexNode {
    char data;              // 顶点的数据
    EdgeNode *first_edge;   // 指向第一个邻接点的指针
} VertexNode;

然后，我们可以通过循环输入每个顶点和它所连接的边来建立邻接表：

VertexNode G[MAX_VEX];      // 定义邻接表
int vex_num, edge_num;      // 顶点数和边数

// 输入顶点数和边数
scanf("%d %d", &vex_num, &edge_num);

// 输入顶点数据
for (int i = 0; i < vex_num; i++) {
    scanf(" %c", &G[i].data);
    G[i].first_edge = NULL; // 初始化每个顶点的邻接表为空
}

// 输入边信息，建立邻接表
for (int i = 0; i < edge_num; i++) {
    int start, end;
    scanf("%d %d", &start, &end);

    // 新建一个边节点，并将它插入到对应的链表中
    EdgeNode *edge = (EdgeNode*)malloc(sizeof(EdgeNode));
    edge->adjvex = end;
    edge->next = G[start].first_edge;
    G[start].first_edge = edge;
}

2. 输出该邻接表。

我们可以依次遍历每个顶点的邻接表，并输出它所连接的边：

// 输出邻接表
for (int i = 0; i < vex_num; i++) {
    printf("%c -> ", G[i].data);
    EdgeNode *p = G[i].first_edge;
    while (p) {
        printf("%c ", G[p->adjvex].data);
        p = p->next;
    }
    printf("\n");
}

3. 在有向图的邻接表的基础上计算各顶点的度，并输出。

对于有向图，每个顶点的度分为入度和出度，分别表示指向该顶点的边数和从该顶点出发的边数。

我们可以通过遍历每个顶点的邻接表来计算它的出度，并遍历所有边来计算它的入度：

// 计算顶点的出度
int out_degree(int v) {
    int count = 0;
    EdgeNode *p = G[v].first_edge;
    while (p) {
        count++;
        p = p->next;
    }
    return count;
}

// 计算顶点的入度
int in_degree(int v) {
    int count = 0;
    for (int i = 0; i < vex_num; i++) {
        EdgeNode *p = G[i].first_edge;
        while (p) {
            if (p->adjvex == v) {
                count++;
            }
            p = p->next;
        }
    }
    return count;
}

// 输出各顶点的度
for (int i = 0; i < vex_num; i++) {
    printf("%c: in=%d, out=%d\n", G[i].data, in_degree(i), out_degree(i));
}

这样，我们就完成了用C语言实现键盘输入数据，建立一个有向图的邻接表，并输出该邻接表，最后计算各顶点的度，并输出的过程。

用一串C语言实现(1) 键盘输入数据，建立一个有向图的邻接表。 (2) 输出该邻接表。 (3) 在有向图的邻接表的基础上计算各顶点的度，并输出。

以下是一段C语言代码，实现(1) 键盘输入数据，建立一个有向图的邻接表。 (2) 输出该邻接表。 (3) 在有向图的邻接表的基础上计算各顶点的度，并输出。

#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTEX_NUM 100

typedef struct ArcNode { // 边表结点
    int adjvex; // 邻接点在顶点数组中的下标
    struct ArcNode* next; // 指向下一个邻接点的指针
} ArcNode;

typedef struct VertexNode { // 顶点表结点
    int data; // 顶点信息
    ArcNode* firstarc; // 指向第一个邻接点的指针
} VertexNode, AdjList[MAX_VERTEX_NUM];

typedef struct { // 邻接表
    AdjList vertices; // 顶点数组
    int vexnum, arcnum; // 顶点数和边数
} ALGraph;

// 建立邻接表
void CreateALGraph(ALGraph* G) {
    printf("请输入顶点数和边数：");
    scanf("%d%d", &G->vexnum, &G->arcnum);

    for (int i = 0; i < G->vexnum; i++) {
        printf("请输入第%d个顶点的信息：", i + 1);
        scanf("%d", &G->vertices[i].data);
        G->vertices[i].firstarc = NULL;
    }

    for (int i = 0; i < G->arcnum; i++) {
        int v1, v2;
        printf("请输入第%d条边的两个端点的下标：", i + 1);
        scanf("%d%d", &v1, &v2);

        ArcNode* arcnode = (ArcNode*)malloc(sizeof(ArcNode));
        arcnode->adjvex = v2;
        arcnode->next = G->vertices[v1].firstarc;
        G->vertices[v1].firstarc = arcnode;
    }
}

// 输出邻接表
void PrintALGraph(ALGraph G) {
    printf("邻接表如下：\n");
    for (int i = 0; i < G.vexnum; i++) {
        printf("%d", G.vertices[i].data);
        ArcNode* p = G.vertices[i].firstarc;
        while (p != NULL) {
            printf("->%d", G.vertices[p->adjvex].data);
            p = p->next;
        }
        printf("\n");
    }
}

// 计算各顶点的度并输出
void PrintDegree(ALGraph G) {
    printf("各顶点的度如下：\n");
    for (int i = 0; i < G.vexnum; i++) {
        int degree = 0;
        ArcNode* p = G.vertices[i].firstarc;
        while (p != NULL) {
            degree++;
            p = p->next;
        }
        printf("顶点%d的度为%d\n", G.vertices[i].data, degree);
    }
}

int main() {
    ALGraph G;
    CreateALGraph(&G);
    PrintALGraph(G);
    PrintDegree(G);

    return 0;
}

注意：在本代码中，我们假设顶点的信息为整数，顶点的下标从0开始，且输入的边是有向边。