有向图采用邻接表为存储结构，编写算法Degree，计算各个顶点的入度和出度，结果分别存放在数组inDegree和outDegree中。 typedef struct eNode{ int adjVex; struct eNode *nextarc; }ENode; typedef struct lGraph{ int n; int e; ENode **a; }LGraph; void Degree(int *inDegree , int *outDegree ,LGraph *g) { }

算法Degree的实现如下：

void Degree(int *inDegree , int *outDegree ,LGraph *g)
{
    // 初始化入度和出度数组
    for (int i = 0; i < g->n; i++) {
        inDegree[i] = 0;
        outDegree[i] = 0;
    }

    // 遍历邻接表，统计入度和出度
    for (int i = 0; i < g->n; i++) {
        ENode *p = g->a[i];
        while (p != NULL) {
            outDegree[i]++;
            inDegree[p->adjVex]++;
            p = p->nextarc;
        }
    }
}

首先初始化入度和出度数组，然后遍历邻接表，对于每个顶点，遍历其邻接表，统计其出度和邻接点的入度。遍历完成后，inDegree和outDegree数组分别存放了各个顶点的入度和出度。

相关问题

数据结构 C+＋实现 有向图的邻接表存储，并输出 顶点的出度和入度

下面是一个简单的 C++ 实现，使用邻接表存储有向图，并输出每个顶点的出度和入度：

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

class Graph {
private:
    int V; // 图中顶点的数量
    vector<vector<int>> adj; // 邻接表

public:
    // 构造函数
    Graph(int V) {
        this->V = V;
        adj.resize(V);
    }

    // 添加一条从 u 到 v 的边
    void addEdge(int u, int v) {
        adj[u].push_back(v);
    }

    // 输出每个顶点的出度和入度
    void printDegree() {
        for (int i = 0; i < V; i++) {
            int out_degree = adj[i].size(); // 出度
            int in_degree = 0; // 入度

            // 计算入度
            for (int j = 0; j < V; j++) {
                for (auto k : adj[j]) {
                    if (k == i) {
                        in_degree++;
                        break;
                    }
                }
            }

            cout << "顶点 " << i << " 的出度为 " << out_degree << "，入度为 " << in_degree << endl;
        }
    }
};

int main() {
    // 创建图
    Graph g(5);
    g.addEdge(0, 1);
    g.addEdge(1, 2);
    g.addEdge(2, 0);
    g.addEdge(3, 4);

    // 输出每个顶点的出度和入度
    g.printDegree();

    return 0;
}

输出结果如下：

顶点 0 的出度为 1，入度为 1
顶点 1 的出度为 1，入度为 1
顶点 2 的出度为 1，入度为 1
顶点 3 的出度为 1，入度为 0
顶点 4 的出度为 0，入度为 1

用c语言写求有向图中每个顶点的入度和出度的程序并用文字说明其储存结构和算法设计

好的，我会为您解答。首先，对于有向图中每个顶点的入度和出度，我们可以通过遍历图的所有边，统计每个顶点的入度和出度来实现。具体来说，我们可以采用邻接矩阵或邻接表来存储有向图。

邻接矩阵是一个二维数组，其中每个元素表示一条边的权重。对于有向图，如果从顶点i到顶点j存在一条边，则邻接矩阵的第i行第j列的元素为1；否则为0。因此，我们可以通过遍历邻接矩阵的每一行或每一列来计算每个顶点的出度或入度。

邻接表则是由每个顶点的出边链表组成的数组。每个链表中的元素表示从该顶点出发的一条边。因此，我们可以通过遍历每个顶点的出边链表来计算该顶点的出度，遍历每个顶点的入边链表来计算该顶点的入度。

下面是一个使用邻接矩阵的C语言程序，用于计算有向图的每个顶点的入度和出度：

#include <stdio.h>

#define MAX_VERTEX_NUM 100

typedef struct {
    int edges[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 邻接矩阵
    int vertex_num, edge_num; // 顶点数和边数
} Graph;

void init_graph(Graph* g, int vertex_num) {
    g->vertex_num = vertex_num;
    g->edge_num = 0;
    for (int i = 0; i < vertex_num; ++i) {
        for (int j = 0; j < vertex_num; ++j) {
            g->edges[i][j] = 0; // 初始化邻接矩阵
        }
    }
}

void add_edge(Graph* g, int from, int to) {
    g->edges[from][to] = 1; // 添加一条边
    ++g->edge_num;
}

void calculate_degree(const Graph* g, int vertex) {
    int in_degree = 0, out_degree = 0;
    for (int i = 0; i < g->vertex_num; ++i) {
        if (g->edges[vertex][i] == 1) { // 出度
            ++out_degree;
        }
        if (g->edges[i][vertex] == 1) { // 入度
            ++in_degree;
        }
    }
    printf("Vertex %d: in-degree = %d, out-degree = %d\n", vertex, in_degree, out_degree);
}

int main() {
    Graph g;
    int vertex_num = 5;
    init_graph(&g, vertex_num);
    add_edge(&g, 0, 1);
    add_edge(&g, 0, 2);
    add_edge(&g, 1, 2);
    add_edge(&g, 1, 3);
    add_edge(&g, 2, 3);
    add_edge(&g, 3, 4);
    for (int i = 0; i < vertex_num; ++i) { // 计算每个顶点的入度和出度
        calculate_degree(&g, i);
    }
    return 0;
}

在这个程序中，我们通过邻接矩阵来存储有向图，并使用add_edge函数来添加边。在calculate_degree函数中，我们遍历邻接矩阵的每一行和每一列，分别计算每个顶点的入度和出度。最后，我们在main函数中遍历每个顶点，调用calculate_degree函数来计算它的入度和出度。

当然，如果我们使用邻接表来存储有向图，我们的程序也会有一些不同。不过，基本的思路是一样的，我们仍然需要遍历每个顶点的出边链表或入边链表来计算入度和出度。

希望这个回答能够帮助您理解如何用C语言编写求有向图中每个顶点的入度和出度的程序，并且了解其储存结构和算法设计。