一个无向图 V（G1)={0,1,2,3,4,5,6,7,8,9,10} 边集合 E（G1）={(0,1),(0,2),(0,3),(1,4),(1,5),(2,5),(2,6),(3,7),(6,8),(6,9),(7,10)}由用户输入一个结点的值，输出该结点的深度优先遍历和广度优先遍历序列，用c语言完成上述代码,不要出现c++中类型转化的语句

以下是实现深度优先遍历和广度优先遍历的C语言代码：

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

#define MAX_VERTICES 11

typedef struct GraphNode {
    int vertex;
    struct GraphNode* next;
} GraphNode;

typedef struct Graph {
    int numVertices;
    GraphNode* adjLists[MAX_VERTICES];
    int visited[MAX_VERTICES];
} Graph;

GraphNode* createGraphNode(int v) {
    GraphNode* newNode = (GraphNode*)malloc(sizeof(GraphNode));
    newNode->vertex = v;
    newNode->next = NULL;
    return newNode;
}

Graph* createGraph() {
    Graph* graph = (Graph*)malloc(sizeof(Graph));
    graph->numVertices = MAX_VERTICES;
    for (int i = 0; i < MAX_VERTICES; i++) {
        graph->adjLists[i] = NULL;
        graph->visited[i] = 0;
    }
    return graph;
}

void addEdge(Graph* graph, int src, int dest) {
    GraphNode* newNode = createGraphNode(dest);
    newNode->next = graph->adjLists[src];
    graph->adjLists[src] = newNode;

    newNode = createGraphNode(src);
    newNode->next = graph->adjLists[dest];
    graph->adjLists[dest] = newNode;
}

void dfs(Graph* graph, int vertex) {
    graph->visited[vertex] = 1;
    printf("%d ", vertex);

    GraphNode* adjList = graph->adjLists[vertex];
    while (adjList != NULL) {
        int adjVertex = adjList->vertex;
        if (!graph->visited[adjVertex]) {
            dfs(graph, adjVertex);
        }
        adjList = adjList->next;
    }
}

void bfs(Graph* graph, int startVertex) {
    int queue[MAX_VERTICES];
    int front = -1, rear = -1;

    graph->visited[startVertex] = 1;
    queue[++rear] = startVertex;

    while (front != rear) {
        int currentVertex = queue[++front];
        printf("%d ", currentVertex);

        GraphNode* adjList = graph->adjLists[currentVertex];
        while (adjList != NULL) {
            int adjVertex = adjList->vertex;
            if (!graph->visited[adjVertex]) {
                graph->visited[adjVertex] = 1;
                queue[++rear] = adjVertex;
            }
            adjList = adjList->next;
        }
    }
}

int main() {
    Graph* graph = createGraph();
    addEdge(graph, 0, 1);
    addEdge(graph, 0, 2);
    addEdge(graph, 0, 3);
    addEdge(graph, 1, 4);
    addEdge(graph, 1, 5);
    addEdge(graph, 2, 5);
    addEdge(graph, 2, 6);
    addEdge(graph, 3, 7);
    addEdge(graph, 6, 8);
    addEdge(graph, 6, 9);
    addEdge(graph, 7, 10);

    int startVertex;
    printf("Enter the starting vertex: ");
    scanf("%d", &startVertex);

    printf("Depth First Traversal: ");
    dfs(graph, startVertex);

    printf("\n");

    for (int i = 0; i < MAX_VERTICES; i++) {
        graph->visited[i] = 0;
    }

    printf("Breadth First Traversal: ");
    bfs(graph, startVertex);

    printf("\n");

    return 0;
}

以上代码可以通过以下方式编译并运行：

gcc graph-traversal.c -o graph-traversal
./graph-traversal

在程序中，我们首先定义了一个 `GraphNode` 结构体来表示图中的每个节点，包含一个整数 `vertex` 和一个指向下一个邻接节点的指针 `next`。然后我们定义了一个 `Graph` 结构体来表示整个图，包含节点数量 `numVertices`、邻接列表 `adjLists` 和一个用于记录节点是否被访问过的数组 `visited`。

我们使用 `createGraphNode` 函数来创建一个新的节点，并使用 `createGraph` 函数来创建一个新的图。我们还使用 `addEdge` 函数来向图中添加一条边，该函数会创建两个新的节点，一个添加到源节点的邻接列表中，另一个添加到目标节点的邻接列表中。

对于深度优先遍历，我们使用 `dfs` 函数来递归地遍历每个节点。我们首先标记当前节点为已访问，并输出其值。然后，我们遍历当前节点的邻接列表中的每个节点，如果邻接节点还没有被访问过，我们递归地调用 `dfs` 函数来访问邻接节点。

对于广度优先遍历，我们使用 `bfs` 函数来使用队列遍历每个节点。我们首先将起始节点标记为已访问，并将其添加到队列中。然后，我们循环处理队列中的每个节点，输出其值并遍历其邻接列表中的每个节点。如果邻接节点还没有被访问过，我们将其标记为已访问，并将其添加到队列的末尾。

最后，我们在 `main` 函数中创建了一个图，并向其添加了一些边。然后，我们从用户输入中获取起始节点，并分别调用 `dfs` 和 `bfs` 函数来遍历图并输出节点序列。