用c语言写一段代码实现以下功能：构建无向带权图的邻接矩阵存储结构；分别使用普里姆算法和克鲁斯卡尔算法生成该图的最小生成树。

好的，下面是代码实现：

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

#define MAX_VERTEX_NUM 20
#define INFINITY 65535

typedef struct {
    int weight;
    int start;
    int end;
} Edge;

typedef struct {
    int vertex[MAX_VERTEX_NUM];
    int edge[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int vertex_num;
    int edge_num;
} Graph;

void create_graph(Graph *graph);
void prim(Graph *graph, int start);
void kruskal(Graph *graph);

int main() {
    Graph graph;
    create_graph(&graph);

    printf("Prim algorithm:\n");
    prim(&graph, 0);

    printf("\nKruskal algorithm:\n");
    kruskal(&graph);

    return 0;
}

void create_graph(Graph *graph) {
    printf("Please input the number of vertexes and edges:\n");
    scanf("%d %d", &graph->vertex_num, &graph->edge_num);

    for (int i = 0; i < graph->vertex_num; i++) {
        printf("Please input the vertex %d:\n", i);
        scanf("%d", &graph->vertex[i]);
    }

    for (int i = 0; i < graph->vertex_num; i++) {
        for (int j = 0; j < graph->vertex_num; j++) {
            graph->edge[i][j] = INFINITY;
        }
    }

    for (int i = 0; i < graph->edge_num; i++) {
        int start, end, weight;
        printf("Please input the start vertex, end vertex and weight of edge %d:\n", i);
        scanf("%d %d %d", &start, &end, &weight);

        graph->edge[start][end] = weight;
        graph->edge[end][start] = weight;
    }
}

void prim(Graph *graph, int start) {
    Edge edges[MAX_VERTEX_NUM];
    int visited[MAX_VERTEX_NUM] = {0};
    visited[start] = 1;

    for (int i = 0; i < graph->vertex_num - 1; i++) {
        int min = INFINITY;
        int index = -1;

        for (int j = 0; j < graph->vertex_num; j++) {
            if (visited[j]) {
                for (int k = 0; k < graph->vertex_num; k++) {
                    if (!visited[k] && graph->edge[j][k] < min) {
                        min = graph->edge[j][k];
                        index = k;
                    }
                }
            }
        }

        edges[i].weight = min;
        edges[i].start = index;
        edges[i].end = visited[index];
        visited[index] = 1;
    }

    printf("The minimum spanning tree:\n");
    for (int i = 0; i < graph->vertex_num - 1; i++) {
        printf("(%d, %d, %d) ", edges[i].start, edges[i].end, edges[i].weight);
    }
}

void kruskal(Graph *graph) {
    Edge edges[MAX_VERTEX_NUM];
    int index = 0;

    for (int i = 0; i < graph->vertex_num; i++) {
        for (int j = i + 1; j < graph->vertex_num; j++) {
            if (graph->edge[i][j] != INFINITY) {
                edges[index].start = i;
                edges[index].end = j;
                edges[index].weight = graph->edge[i][j];
                index++;
            }
        }
    }

    for (int i = 0; i < graph->edge_num - 1; i++) {
        int min = i;

        for (int j = i + 1; j < graph->edge_num; j++) {
            if (edges[j].weight < edges[min].weight) {
                min = j;
            }
        }

        if (min != i) {
            Edge temp = edges[i];
            edges[i] = edges[min];
            edges[min] = temp;
        }
    }

    printf("The minimum spanning tree:\n");
    int parent[MAX_VERTEX_NUM] = {0};
    for (int i = 0; i < graph->vertex_num; i++) {
        parent[i] = i;
    }

    for (int i = 0; i < graph->edge_num; i++) {
        int start = edges[i].start;
        int end = edges[i].end;
        int weight = edges[i].weight;
        int parent_start = parent[start];
        int parent_end = parent[end];

        if (parent_start != parent_end) {
            printf("(%d, %d, %d) ", start, end, weight);

            for (int j = 0; j < graph->vertex_num; j++) {
                if (parent[j] == parent_end) {
                    parent[j] = parent_start;
                }
            }
        }
    }
}

以上代码实现了构建无向带权图的邻接矩阵存储结构，以及使用普里姆算法和克鲁斯卡尔算法生成该图的最小生成树。