无向图的打印和遍历 有向图的实现

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

#define MAX_VERTEX_NUM 100 // 最大节点数

// 邻接矩阵结构体
typedef struct {
    int vertex[MAX_VERTEX_NUM]; // 存储节点
    int edge[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 存储边
    int vertex_num; // 节点数量
    int edge_num; // 边数量
} Graph;

// 初始化无向图
void init(Graph *G) {
    int i, j;
    printf("请输入节点数量和边数量：\n");
    scanf("%d %d", &(G->vertex_num), &(G->edge_num));
    printf("请输入节点信息（编号）：\n");
    for (i = 0; i < G->vertex_num; i++) {
        scanf("%d", &(G->vertex[i]));
    }
    // 初始化边矩阵
    for (i = 0; i < G->vertex_num; i++) {
        for (j = 0; j < G->vertex_num; j++) {
            G->edge[i][j] = 0;
        }
    }
    printf("请输入边信息（两个节点编号之间用空格隔开）：\n");
    for (i = 0; i < G->edge_num; i++) {
        int v1, v2;
        scanf("%d %d", &v1, &v2);
        // 无向图需要将边双向添加
        G->edge[v1 - 1][v2 - 1] = 1;
        G->edge[v2 - 1][v1 - 1] = 1;
    }
}
// 打印邻接矩阵
void printGraph(Graph *G) {
    int i, j;
    printf("Adjacency Matrix:\n");
    for (i = 0; i < G->vertex_num; i++) {
        for (j = 0; j < G->vertex_num; j++) {
            printf("%d ", G->edge[i][j]);
        }
        printf("\n");
    }
}

// DFS遍历
void DFS(Graph *G, int v, int *visited) {
    int i;
    printf("%d ", G->vertex[v]);
    visited[v] = 1;
    for (i = 0; i < G->vertex_num; i++) {
        if (G->edge[v][i] == 1 && visited[i] == 0) {
            DFS(G, i, visited);
        }
    }
}

// BFS遍历
void BFS(Graph *G, int v, int *visited) {
    int queue[MAX_VERTEX_NUM];
    int front = 0, rear = 0;
    int i;
    printf("%d ", G->vertex[v]);
    visited[v] = 1;
    queue[rear++] = v;
    while (front != rear) {
        int u = queue[front++];
        for (i = 0; i < G->vertex_num; i++) {
            if (G->edge[u][i] == 1 && visited[i] == 0) {
                printf("%d ", G->vertex[i]);
                visited[i] = 1;
                queue[rear++] = i;
            }
        }
    }
}

int main() {
    Graph G;
    int visited[MAX_VERTEX_NUM];
    int i;
    init(&G);
    printGraph(&G); 
    printf("DFS遍历结果：");
    for (i = 0; i < G.vertex_num; i++) {
        visited[i] = 0;
    }
    DFS(&G, 0, visited);
    printf("\n");
    printf("BFS遍历结果：");
    for (i = 0; i < G.vertex_num; i++) {
        visited[i] = 0;
    }
    BFS(&G, 0, visited);
    printf("\n");
    return 0;
}

有向图：

#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTEX_NUM 20   // 最大顶点数
// 边结构体
typedef struct ArcNode {
    int adjvex;             // 邻接点在顶点数组中的下标
    struct ArcNode *nextarc;// 指向下一条边的指针
} ArcNode;
// 顶点结构体
typedef struct VertexNode {
    int data;               // 顶点数据
    ArcNode *firstarc;      // 指向第一条依附该顶点的边的指针
} VertexNode;
// 图结构体
typedef struct {
    VertexNode vertex[MAX_VERTEX_NUM];  // 顶点数组
    int vexnum, arcnum;                 // 顶点数和弧数
} Graph;
// 建立有向图的邻接表
void createGraph(Graph *G) {
    printf("请输入顶点数和弧数：");
    scanf("%d%d", &G->vexnum, &G->arcnum);
    getchar();                          // 把回车符从缓冲区中读取并抛弃
    // 初始化每个顶点的指针域为空
    for (int i = 0; i < G->vexnum; i++) {
        G->vertex[i].firstarc = NULL;
    }
    // 输入每个顶点的数据
    printf("请输入每个顶点的数据：\n");
    for (int i = 0; i < G->vexnum; i++) {
        scanf("%d", &G->vertex[i].data);
    }
    getchar();                          // 把回车符从缓冲区中读取并抛弃
    // 输入每条边的信息
    printf("请输入每条边的信息：\n");
    for (int k = 0; k < G->arcnum; k++) {
        int i, j;
        printf("请输入弧头和弧尾（用空格分隔）：");
        scanf("%d%d", &i, &j);
        // 创建一条新的边
        ArcNode *arc = (ArcNode *)malloc(sizeof(ArcNode));
        arc->adjvex = j;
        // 把这条边插入到顶点 i 的邻接表中
        arc->nextarc = G->vertex[i].firstarc;
        G->vertex[i].firstarc = arc;
    }
}
// 测试
int main() {
    Graph G;
    createGraph(&G);
    return 0;
}