用类c语言在有向图的邻接表存储结构上实现：输出某顶点出发的所有长度等于k的简单路径

以下是使用邻接表存储结构实现输出某顶点出发的所有长度等于k的简单路径的示例代码：

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

#define MAX_VERTEX_NUM 100 // 最大顶点数

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

// 顶点表结点
typedef struct VNode {
    int data;         // 顶点数据
    ArcNode* first;   // 指向第一条依附于该顶点的边的指针
} VNode, AdjList[MAX_VERTEX_NUM];

// 图结构
typedef struct {
    AdjList vertices;  // 邻接表
    int vexnum;        // 顶点数
    int arcnum;        // 边数
} ALGraph;

// 初始化图
void init(ALGraph* G, int n) {
    G->vexnum = n;
    G->arcnum = 0;
    for (int i = 0; i < n; i++) {
        G->vertices[i].data = i;
        G->vertices[i].first = NULL;
    }
}

// 添加边
void addEdge(ALGraph* G, int u, int v) {
    ArcNode* p = (ArcNode*)malloc(sizeof(ArcNode));
    p->adjvex = v;
    p->next = G->vertices[u].first;
    G->vertices[u].first = p;
    G->arcnum++;
}

// 输出所有长度为k的路径
void printPath(ALGraph* G, int u, int k, int* path, int d) {
    if (k == 0) {  // 找到一条长度为k的路径
        printf("%d", path[0]);
        for (int i = 1; i <= d; i++) {
            printf("->%d", path[i]);
        }
        printf("\n");
    } else {
        ArcNode* p = G->vertices[u].first;
        while (p != NULL) {  // 对于每个邻接点递归搜索
            int v = p->adjvex;
            bool isDuplicate = false;
            for (int i = 0; i <= d; i++) {  // 判断是否已经在路径上出现过
                if (path[i] == v) {
                    isDuplicate = true;
                    break;
                }
            }
            if (!isDuplicate) {
                path[d+1] = v;
                printPath(G, v, k-1, path, d+1);
            }
            p = p->next;
        }
    }
}

int main() {
    int n, m, u, v, k;
    printf("请输入顶点数和边数：");
    scanf("%d %d", &n, &m);
    ALGraph G;
    init(&G, n);
    printf("请输入每条边的起点和终点：\n");
    for (int i = 0; i < m; i++) {
        scanf("%d %d", &u, &v);
        addEdge(&G, u, v);
    }
    printf("请输入起点和路径长度：");
    scanf("%d %d", &u, &k);
    int* path = (int*)malloc(k * sizeof(int));  // 分配存储路径的空间
    path[0] = u;
    printf("长度为%d的路径有：\n", k);
    printPath(&G, u, k, path, 0);
    free(path);
    return 0;
}

在该代码中，我们使用邻接表存储结构来表示有向图。对于输出某顶点出发的所有长度等于k的简单路径，我们使用递归深度优先搜索算法来实现。具体来说，我们从起点u开始，对于每个邻接点v，如果它没有出现在路径中，就将它加入路径中，并递归搜索从v出发长度为k-1的路径。当搜索到长度为0时，即找到了一条长度为k的路径，就输出该路径。注意，在搜索过程中需要判断某个点是否已经在路径上出现过，避免出现环和重复路径。

该算法的时间复杂度为O(n^k)，其中n为顶点数，k为路径长度。因此，当k较大时，算法效率会很低。