使用C语言写出实现图的创建、输出、遍历、显示深度和最小生成树的完整代码

对于这个问题，我们需要先确定图的数据结构。这里我们选择使用邻接矩阵来表示图。邻接矩阵是一个二维数组，其中每个元素表示两个顶点之间是否有边，如果有则为1，否则为0。

下面是实现图的完整代码：

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

#define MAX_VERTICES 100

typedef struct {
    int matrix[MAX_VERTICES][MAX_VERTICES];
    int num_vertices;
} Graph;

void initialize_graph(Graph *g) {
    int i, j;
    g->num_vertices = 0;
    for (i = 0; i < MAX_VERTICES; i++) {
        for (j = 0; j < MAX_VERTICES; j++) {
            g->matrix[i][j] = 0;
        }
    }
}

void add_edge(Graph *g, int u, int v, int weight) {
    g->matrix[u][v] = weight;
}

void print_graph(Graph *g) {
    int i, j;
    for (i = 0; i < g->num_vertices; i++) {
        for (j = 0; j < g->num_vertices; j++) {
            printf("%d ", g->matrix[i][j]);
        }
        printf("\n");
    }
}

void depth_first_search(Graph *g, bool visited[], int vertex) {
    int i;
    visited[vertex] = true;
    printf("%d ", vertex);
    for (i = 0; i < g->num_vertices; i++) {
        if (g->matrix[vertex][i] && !visited[i]) {
            depth_first_search(g, visited, i);
        }
    }
}

void display_dfs(Graph *g, int start_vertex) {
    bool visited[MAX_VERTICES] = {false};
    depth_first_search(g, visited, start_vertex);
}

int get_min_distance_vertex(Graph *g, int distances[], bool visited[]) {
    int min_distance = INT_MAX;
    int min_vertex = -1;
    int i;
    for (i = 0; i < g->num_vertices; i++) {
        if (!visited[i] && distances[i] < min_distance) {
            min_distance = distances[i];
            min_vertex = i;
        }
    }
    return min_vertex;
}

void prim_minimum_spanning_tree(Graph *g) {
    int parent[MAX_VERTICES];
    int distances[MAX_VERTICES];
    bool visited[MAX_VERTICES] = {false};
    int i, j;
    for (i = 0; i < g->num_vertices; i++) {
        distances[i] = INT_MAX;
    }
    distances[0] = 0;
    parent[0] = -1;
    for (i = 0; i < g->num_vertices - 1; i++) {
        int u = get_min_distance_vertex(g, distances, visited);
        visited[u] = true;
        for (j = 0; j < g->num_vertices; j++) {
            if (g->matrix[u][j] && !visited[j] && g->matrix[u][j] < distances[j]) {
                parent[j] = u;
                distances[j] = g->matrix[u][j];
            }
        }
    }
    printf("Edge weight:\n");
    for (i = 1; i < g->num_vertices; i++) {
        printf("%d - %d: %d\n", parent[i], i, g->matrix[i][parent[i]]);
    }
}

int main() {
    Graph g;
    initialize_graph(&g);
    g.num_vertices = 5;
    add_edge(&g, 0, 1, 2);
    add_edge(&g, 0, 2, 1);
    add_edge(&g, 1, 2, 3);
    add_edge(&g, 1, 3, 4);
    add_edge(&g, 2, 3, 5);
    add_edge(&g, 2, 4, 6);
    add_edge(&g, 3, 4, 7);
    printf("Graph adjacency matrix:\n");
    print_graph(&g);
    printf("Depth first search:\n");
    display_dfs(&g, 0);
    printf("\nMinimum spanning tree using Prim's algorithm:\n");
    prim_minimum_spanning_tree(&g);
    return 0;
}

我们首先定义了一个 `Graph` 结构体，其中包含一个邻接矩阵和顶点数。`initialize_graph` 函数用来初始化图，将所有元素置为0。`add_edge` 函数用来添加边，将矩阵中对应位置的值设为权重。`print_graph` 函数用来打印邻接矩阵。

接下来是深度优先搜索。我们使用一个 `visited` 数组来记录每个顶点是否已经被访问过。`depth_first_search` 函数实现了递归的深度优先搜索算法，从起点开始访问所有可达顶点。`display_dfs` 函数封装了深度优先搜索，从指定顶点开始搜索并输出搜索结果。

最后是最小生成树。我们使用 Prim 算法来构造最小生成树。`get_min_distance_vertex` 函数用来获取未访问的顶点中距离起点最近的顶点。`prim_minimum_spanning_tree` 函数实现了 Prim 算法，使用一个 `parent` 数组记录每个顶点在最小生成树中的父节点，使用一个 `distances` 数组记录每个顶点到起点的距离。最后输出最小生成树的边权重。

在主函数中，我们创建了一个包含7个顶点的无向图，添加了若干条边，并依次输出了邻接矩阵、深度优先搜索结果和最小生成树。