c语言，图采用邻接表作为存储结构，编写算法对图进行深度优先遍历和广度优先遍历。

好的，我来为你解答这个问题。

首先，我们需要定义图的邻接表存储结构。邻接表是一种链式存储结构，其中每个顶点对应一个链表，链表中存储该顶点所连的边。

下面是一个邻接表存储结构的定义：

#define MAX_VERTEX_NUM 100  // 最大顶点数

// 边结构体
typedef struct ArcNode {
    int adjvex;            // 该边指向的顶点在顶点数组中的下标
    struct ArcNode *next;  // 指向下一条边的指针
} ArcNode;

// 顶点结构体
typedef struct VNode {
    int data;        // 顶点的数据
    ArcNode *first;  // 指向第一条边的指针
} VNode;

// 图结构体
typedef struct {
    VNode vertices[MAX_VERTEX_NUM];  // 顶点数组
    int vexnum, arcnum;              // 顶点数和边数
} Graph;

接下来，我们分别来介绍深度优先遍历和广度优先遍历的算法实现。

1. 深度优先遍历

深度优先遍历是一种先访问深度较深的顶点的搜索策略。具体实现时，可以使用递归或栈的方式来对图进行深度优先遍历。

下面是使用递归方式实现的深度优先遍历算法：

// 访问顶点 v
void visit(int v) {
    printf("%d ", v);
}

// 从顶点 v 开始进行深度优先遍历
void DFS(Graph *G, int v, int visited[]) {
    visited[v] = 1;  // 标记顶点 v 已访问
    visit(v);        // 访问顶点 v

    // 遍历顶点 v 的所有邻接顶点
    ArcNode *p = G->vertices[v].first;
    while (p != NULL) {
        int w = p->adjvex;
        if (!visited[w])  // 如果顶点 w 未被访问，则递归访问它
            DFS(G, w, visited);
        p = p->next;
    }
}

// 对图 G 进行深度优先遍历
void DFSTraverse(Graph *G) {
    int visited[MAX_VERTEX_NUM] = {0};  // 初始化所有顶点均未访问

    // 遍历所有连通分量
    for (int v = 0; v < G->vexnum; v++) {
        if (!visited[v])  // 如果顶点 v 未被访问，则从它开始进行深度优先遍历
            DFS(G, v, visited);
    }
}

2. 广度优先遍历

广度优先遍历是一种先访问离起始顶点最近的顶点的搜索策略。具体实现时，可以使用队列来对图进行广度优先遍历。

下面是使用队列方式实现的广度优先遍历算法：

// 访问顶点 v
void visit(int v) {
    printf("%d ", v);
}

// 从顶点 v 开始进行广度优先遍历
void BFS(Graph *G, int v, int visited[]) {
    int queue[MAX_VERTEX_NUM], front = 0, rear = 0;

    visited[v] = 1;  // 标记顶点 v 已访问
    visit(v);        // 访问顶点 v
    queue[rear++] = v;

    while (front != rear) {
        int w = queue[front++];  // 出队一个顶点 w

        // 遍历顶点 w 的所有邻接顶点
        ArcNode *p = G->vertices[w].first;
        while (p != NULL) {
            int u = p->adjvex;
            if (!visited[u]) {  // 如果顶点 u 未被访问，则访问它并将它入队
                visited[u] = 1;
                visit(u);
                queue[rear++] = u;
            }
            p = p->next;
        }
    }
}

// 对图 G 进行广度优先遍历
void BFSTraverse(Graph *G) {
    int visited[MAX_VERTEX_NUM] = {0};  // 初始化所有顶点均未访问

    // 遍历所有连通分量
    for (int v = 0; v < G->vexnum; v++) {
        if (!visited[v])  // 如果顶点 v 未被访问，则从它开始进行广度优先遍历
            BFS(G, v, visited);
    }
}

以上就是图的深度优先遍历和广度优先遍历的算法实现。