编一个c语言程序1建立一个图的邻接矩阵和图的邻接表，并输出该图； 2.邻接矩阵表示的图的深度遍历和广度遍历 3.邻接表表示的图的深度遍历和广度遍历

好的，以下是一个实现题目要求的C语言程序：

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

#define MAX_VERTEX_NUM 20

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

typedef struct VNode{
    char data;
    ArcNode *first;
}VNode, AdjList[MAX_VERTEX_NUM];

typedef struct {
    AdjList vertices;
    int vexnum, arcnum;
}ALGraph;

// 初始化邻接表
void InitGraph(ALGraph *G, int n) {
    G->vexnum = n;
    G->arcnum = 0;
    for (int i = 0; i < G->vexnum; i++) {
        G->vertices[i].data = 'A' + 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++;
}

// 打印邻接表
void PrintGraph(ALGraph *G) {
    printf("邻接表：\n");
    for (int i = 0; i < G->vexnum; i++) {
        printf("%c -> ", G->vertices[i].data);
        ArcNode *p = G->vertices[i].first;
        while (p) {
            printf("%c ", G->vertices[p->adjvex].data);
            p = p->next;
        }
        printf("\n");
    }
}

// 初始化邻接矩阵
void InitMat(int mat[][MAX_VERTEX_NUM], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            mat[i][j] = 0;
        }
    }
}

// 添加边
void AddEdgeMat(int mat[][MAX_VERTEX_NUM], int u, int v) {
    mat[u][v] = 1;
}

// 打印邻接矩阵
void PrintMat(int mat[][MAX_VERTEX_NUM], int n) {
    printf("邻接矩阵：\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", mat[i][j]);
        }
        printf("\n");
    }
}

// 深度优先遍历邻接矩阵
void DFSMat(int mat[][MAX_VERTEX_NUM], int visited[], int n, int v) {
    visited[v] = 1;
    printf("%c ", 'A' + v);
    for (int i = 0; i < n; i++) {
        if (mat[v][i] && !visited[i]) {
            DFSMat(mat, visited, n, i);
        }
    }
}

// 广度优先遍历邻接矩阵
void BFSMat(int mat[][MAX_VERTEX_NUM], int visited[], int n, int v) {
    int queue[MAX_VERTEX_NUM], front = 0, rear = 0;
    queue[rear++] = v;
    visited[v] = 1;
    while (front != rear) {
        int u = queue[front++];
        printf("%c ", 'A' + u);
        for (int i = 0; i < n; i++) {
            if (mat[u][i] && !visited[i]) {
                visited[i] = 1;
                queue[rear++] = i;
            }
        }
    }
}

// 深度优先遍历邻接表
void DFSList(ALGraph *G, int visited[], int v) {
    visited[v] = 1;
    printf("%c ", G->vertices[v].data);
    ArcNode *p = G->vertices[v].first;
    while (p) {
        if (!visited[p->adjvex]) {
            DFSList(G, visited, p->adjvex);
        }
        p = p->next;
    }
}

// 广度优先遍历邻接表
void BFSList(ALGraph *G, int visited[], int v) {
    int queue[MAX_VERTEX_NUM], front = 0, rear = 0;
    queue[rear++] = v;
    visited[v] = 1;
    while (front != rear) {
        int u = queue[front++];
        printf("%c ", G->vertices[u].data);
        ArcNode *p = G->vertices[u].first;
        while (p) {
            if (!visited[p->adjvex]) {
                visited[p->adjvex] = 1;
                queue[rear++] = p->adjvex;
            }
            p = p->next;
        }
    }
}

int main() {
    int mat[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    ALGraph G;
    int n = 5; // 顶点数
    InitGraph(&G, n);
    InitMat(mat, n);

    // 添加边
    AddEdge(&G, 0, 1);
    AddEdge(&G, 0, 2);
    AddEdge(&G, 1, 2);
    AddEdge(&G, 1, 3);
    AddEdge(&G, 3, 4);

    AddEdgeMat(mat, 0, 1);
    AddEdgeMat(mat, 0, 2);
    AddEdgeMat(mat, 1, 2);
    AddEdgeMat(mat, 1, 3);
    AddEdgeMat(mat, 3, 4);

    // 打印邻接表和邻接矩阵
    PrintGraph(&G);
    PrintMat(mat, n);

    // 深度优先遍历邻接矩阵和邻接表
    int visited[MAX_VERTEX_NUM] = {0};
    printf("邻接矩阵的深度优先遍历：");
    DFSMat(mat, visited, n, 0);
    printf("\n");
    printf("邻接表的深度优先遍历：");
    DFSList(&G, visited, 0);
    printf("\n");

    // 广度优先遍历邻接矩阵和邻接表
    for (int i = 0; i < n; i++) {
        visited[i] = 0;
    }
    printf("邻接矩阵的广度优先遍历：");
    BFSMat(mat, visited, n, 0);
    printf("\n");
    printf("邻接表的广度优先遍历：");
    BFSList(&G, visited, 0);
    printf("\n");

    return 0;
}

该程序实现了题目要求的功能，包括邻接表和邻接矩阵的建立、深度优先遍历和广度优先遍历的实现等。其中，邻接表和邻接矩阵的定义分别用了结构体和二维数组来表示，两种方式都可以实现图的存储和操作。在深度优先遍历和广度优先遍历的实现过程中，使用了递归和队列等数据结构来辅助遍历。