C语言如何销毁图的邻接表的函数，用代码显示出来

销毁图的邻接表的函数可以按照以下步骤实现：

1. 遍历所有节点，释放其邻接表中的所有边
2. 释放所有节点所占用的内存空间

具体代码实现如下：

void destroyGraph(Graph* graph) {
    int i;
    for (i = 0; i < graph->numVertices; i++) {
        AdjListNode* node = graph->adjLists[i].head;
        while (node != NULL) {
            AdjListNode* temp = node;
            node = node->next;
            free(temp);
        }
    }
    free(graph->adjLists);
    free(graph);
}

其中，`Graph` 是存储图信息的结构体，包含图中节点数量和每个节点的邻接表。每个邻接表都是一个链表，包含一个指向下一个邻接节点的指针和一个指向相邻节点的索引。

`AdjListNode` 是邻接表中存储相邻节点信息的结构体，包含一个相邻节点的索引和一个指向下一个邻接节点的指针。

在销毁图的邻接表时，我们首先遍历每个节点的邻接表，释放其中所有的边。然后，释放所有节点所占用的内存空间。最后，释放整个图所占用的内存空间。

相关问题

用C语言编程实现邻接表生成逆邻接表。

好的，以下是实现邻接表生成逆邻接表的C语言代码：

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

#define MAX_VERTEX_NUM 100 // 最大顶点数

// 邻接表的结构体
typedef struct ArcNode {
    int adjvex; // 邻接顶点的位置
    struct ArcNode *nextarc; // 指向下一个邻接点的指针
} ArcNode;

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

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

// 生成邻接表
void CreateGraph(ALGraph *G) {
    int i, j, k;
    ArcNode *p;
    printf("请输入顶点数和边数：\n");
    scanf("%d%d", &G->vexnum, &G->arcnum);
    printf("请输入顶点信息：\n");
    for (i = 0; i < G->vexnum; i++) {
        scanf("%d", &G->vertices[i].data);
        G->vertices[i].firstarc = NULL;
    }
    printf("请输入边的信息(起点 终点)：\n");
    for (k = 0; k < G->arcnum; k++) {
        scanf("%d%d", &i, &j);
        p = (ArcNode *)malloc(sizeof(ArcNode));
        p->adjvex = j;
        p->nextarc = G->vertices[i].firstarc;
        G->vertices[i].firstarc = p;
    }
}

// 生成逆邻接表
void Inverse(ALGraph *G, ALGraph *GR) {
    int i;
    ArcNode *p;
    GR->vexnum = G->vexnum;
    GR->arcnum = G->arcnum;
    for (i = 0; i < G->vexnum; i++) {
        GR->vertices[i].data = G->vertices[i].data;
        GR->vertices[i].firstarc = NULL;
    }
    for (i = 0; i < G->vexnum; i++) {
        p = G->vertices[i].firstarc;
        while (p != NULL) {
            ArcNode *q = (ArcNode *)malloc(sizeof(ArcNode));
            q->adjvex = i;
            q->nextarc = GR->vertices[p->adjvex].firstarc;
            GR->vertices[p->adjvex].firstarc = q;
            p = p->nextarc;
        }
    }
}

// 主函数测试逆邻接表生成
int main() {
    ALGraph G, GR;
    CreateGraph(&G);
    Inverse(&G, &GR);
    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->nextarc;
        }
        printf("NULL\n");
    }
    printf("逆邻接表：\n");
    for (int i = 0; i < GR.vexnum; i++) {
        printf("%d -> ", GR.vertices[i].data);
        ArcNode *p = GR.vertices[i].firstarc;
        while (p != NULL) {
            printf("%d -> ", GR.vertices[p->adjvex].data);
            p = p->nextarc;
        }
        printf("NULL\n");
    }
    return 0;
}

在这个程序中，我们首先定义了邻接表的结构体，其中`VNode`表示一个顶点，`ArcNode`表示一个邻接点，`AdjList`是邻接表的类型，用于存储所有顶点的信息和它们的邻接点信息。然后，我们实现了两个函数来生成邻接表和逆邻接表。最后，在主函数中，我们使用`CreateGraph`函数生成邻接表，并使用`Inverse`函数生成逆邻接表，然后分别输出它们的信息。

注意，这里的逆邻接表是由原来的邻接表生成的，因此逆邻接表的顶点信息和边数与原来的邻接表相同。不同之处在于，对于每个顶点，逆邻接表中存储的是指向该顶点的所有边，而不是该顶点指向的所有边。

C语言利用栈函数实现邻接表的深度优先遍历和广度优先遍历，用代码显示出来

深度优先遍历代码：

#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTEX_NUM 100

typedef struct ArcNode {
    int adjvex;
    struct ArcNode *nextarc;
} ArcNode;

typedef struct {
    char data;
    ArcNode *firstarc;
} VNode;

typedef struct {
    VNode adjlist[MAX_VERTEX_NUM];
    int vexnum, arcnum;
} ALGraph;

typedef struct {
    int data[MAX_VERTEX_NUM];
    int top;
} Stack;

void InitStack(Stack *S) {
    S->top = -1;
}

int StackEmpty(Stack *S) {
    return S->top == -1;
}

void Push(Stack *S, int x) {
    S->data[++(S->top)] = x;
}

int Pop(Stack *S) {
    return S->data[(S->top)--];
}

void DFS(ALGraph *G, int v, int visited[]) {
    printf("%c ", G->adjlist[v].data);
    visited[v] = 1;
    ArcNode *p = G->adjlist[v].firstarc;
    while (p) {
        if (!visited[p->adjvex]) {
            DFS(G, p->adjvex, visited);
        }
        p = p->nextarc;
    }
}

void DFSTraverse(ALGraph *G) {
    int visited[MAX_VERTEX_NUM] = {0};
    for (int i = 0; i < G->vexnum; i++) {
        if (!visited[i]) {
            DFS(G, i, visited);
        }
    }
}

int main() {
    ALGraph G;
    int visited[MAX_VERTEX_NUM] = {0};
    printf("请输入图的顶点数和边数：\n");
    scanf("%d%d", &G.vexnum, &G.arcnum);
    printf("请输入%d个顶点的值：\n", G.vexnum);
    for (int i = 0; i < G.vexnum; i++) {
        scanf(" %c", &(G.adjlist[i].data));
        G.adjlist[i].firstarc = NULL;
    }
    printf("请输入%d条边的弧尾和弧头：\n", G.arcnum);
    for (int i = 0; i < G.arcnum; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        ArcNode *newArcNode = (ArcNode *)malloc(sizeof(ArcNode));
        newArcNode->adjvex = v;
        newArcNode->nextarc = G.adjlist[u].firstarc;
        G.adjlist[u].firstarc = newArcNode;
    }
    printf("深度优先遍历结果为：");
    DFSTraverse(&G);
    printf("\n");
    return 0;
}

广度优先遍历代码：

#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTEX_NUM 100

typedef struct ArcNode {
    int adjvex;
    struct ArcNode *nextarc;
} ArcNode;

typedef struct {
    char data;
    ArcNode *firstarc;
} VNode;

typedef struct {
    VNode adjlist[MAX_VERTEX_NUM];
    int vexnum, arcnum;
} ALGraph;

typedef struct {
    int data[MAX_VERTEX_NUM];
    int front, rear;
} Queue;

void InitQueue(Queue *Q) {
    Q->front = Q->rear = -1;
}

int QueueEmpty(Queue *Q) {
    return Q->front == Q->rear;
}

void EnQueue(Queue *Q, int x) {
    Q->data[++(Q->rear)] = x;
}

int DeQueue(Queue *Q) {
    return Q->data[++(Q->front)];
}

void BFS(ALGraph *G, int v, int visited[]) {
    Queue Q;
    InitQueue(&Q);
    printf("%c ", G->adjlist[v].data);
    visited[v] = 1;
    EnQueue(&Q, v);
    while (!QueueEmpty(&Q)) {
        int u = DeQueue(&Q);
        ArcNode *p = G->adjlist[u].firstarc;
        while (p) {
            int w = p->adjvex;
            if (!visited[w]) {
                printf("%c ", G->adjlist[w].data);
                visited[w] = 1;
                EnQueue(&Q, w);
            }
            p = p->nextarc;
        }
    }
}

void BFSTraverse(ALGraph *G) {
    int visited[MAX_VERTEX_NUM] = {0};
    for (int i = 0; i < G->vexnum; i++) {
        if (!visited[i]) {
            BFS(G, i, visited);
        }
    }
}

int main() {
    ALGraph G;
    printf("请输入图的顶点数和边数：\n");
    scanf("%d%d", &G.vexnum, &G.arcnum);
    printf("请输入%d个顶点的值：\n", G.vexnum);
    for (int i = 0; i < G.vexnum; i++) {
        scanf(" %c", &(G.adjlist[i].data));
        G.adjlist[i].firstarc = NULL;
    }
    printf("请输入%d条边的弧尾和弧头：\n", G.arcnum);
    for (int i = 0; i < G.arcnum; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        ArcNode *newArcNode = (ArcNode *)malloc(sizeof(ArcNode));
        newArcNode->adjvex = v;
        newArcNode->nextarc = G.adjlist[u].firstarc;
        G.adjlist[u].firstarc = newArcNode;
    }
    printf("广度优先遍历结果为：");
    BFSTraverse(&G);
    printf("\n");
    return 0;
}