用c语言编写以邻接表作存储结构实现求从源点到其余各顶点的最短路径的Dijkstra算法。

好的，下面是用C语言编写以邻接表作存储结构实现求从源点到其余各顶点的最短路径的Dijkstra算法的代码示例：

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

#define V 5

// 边的结构体
struct Edge {
    int v; // 目标顶点
    int w; // 权值
    struct Edge* next; // 指向下一条边的指针
};

// 邻接表的结构体
struct Graph {
    int V; // 顶点数
    struct Edge** adj; // 指向邻接表的指针
};

// 创建一条边
struct Edge* createEdge(int v, int w) {
    struct Edge* e = (struct Edge*)malloc(sizeof(struct Edge));
    e->v = v;
    e->w = w;
    e->next = NULL;
    return e;
}

// 创建一个邻接表
struct Graph* createGraph(int V) {
    struct Graph* g = (struct Graph*)malloc(sizeof(struct Graph));
    g->V = V;
    g->adj = (struct Edge**)malloc(V * sizeof(struct Edge*));
    for (int i = 0; i < V; i++) {
        g->adj[i] = NULL;
    }
    return g;
}

// 添加一条边
void addEdge(struct Graph* g, int u, int v, int w) {
    struct Edge* e = createEdge(v, w);
    e->next = g->adj[u];
    g->adj[u] = e;
}

// Dijkstra算法
void dijkstra(struct Graph* g, int s, int* dist) {
    for (int i = 0; i < g->V; i++) {
        dist[i] = INT_MAX; // 初始化距离
    }
    dist[s] = 0; // 源点到源点的距离为0

    int* visited = (int*)calloc(g->V, sizeof(int)); // 记录顶点是否已经确定最短路径
    visited[s] = 1; // 将源点标记为已确定最短路径的顶点

    // 遍历顶点u的所有邻居v
    for (struct Edge* e = g->adj[s]; e != NULL; e = e->next) {
        int v = e->v;
        int w = e->w;
        dist[v] = w;
    }

    for (int i = 1; i < g->V; i++) {
        int minDist = INT_MAX;
        int u;
        // 从未确定最短路径的顶点中选取一个距离源点最近的顶点u
        for (int j = 0; j < g->V; j++) {
            if (!visited[j] && dist[j] < minDist) {
                minDist = dist[j];
                u = j;
            }
        }
        visited[u] = 1; // 将顶点u标记为已确定最短路径的顶点
        // 更新相邻顶点的最短路径
        for (struct Edge* e = g->adj[u]; e != NULL; e = e->next) {
            int v = e->v;
            int w = e->w;
            if (dist[u] != INT_MAX && dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
            }
        }
    }

    free(visited);
}

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

    int dist[V];
    dijkstra(g, 0, dist);

    for (int i = 0; i < V; i++) {
        printf("dist[%d] = %d\n", i, dist[i]);
    }

    return 0;
}

这里使用了动态内存分配来创建邻接表，并使用calloc来初始化visited数组。由于C语言没有STL中的优先队列，我们需要手动实现查找距离源点最近的顶点的过程。在实现过程中，我们使用了一个visited数组来记录每个顶点是否已经确定最短路径，并使用一个minDist变量来记录距离源点最近的顶点的距离。同时，由于我们需要遍历每个顶点的邻居，所以我们使用了一个for循环来遍历邻接表。