使用c语言代码展示djikstra算法

### 回答1：

可以使用下面的C语言代码来实现Dijkstra算法： #include <stdio.h>
#define INF 9999 // 图的邻接矩阵
int G[10][10] = {
{0, 5, INF, 10},
{INF, 0, 3, INF},
{INF, INF, 0, 1},
{INF, INF, INF, 0}
}; // 存放最短路径的前驱顶点
int pre[4] = {-1, -1, -1, -1}; // 存放到各个顶点的最短路径
int D[4]; int main()
{
int v;
int i, j, k;

// 初始化
for (i=0; i<4; i++)
{
D[i] = G[0][i];
pre[i] = 0;
}

// 进行n-1次循环，每次找出一个顶点的最短路径
for (i=0; i<3; i++)
{
// 寻找当前最短路径的顶点
int min = INF;
for (j=0; j<4; j++)
{
if (D[j]<min && D[j]>0)
{
v = j;
min = D[j];
}
}

// 标记当前顶点v为已求出最短路径
D[v] = -1;

// 更新当前最短路径和前驱顶点
for (k=0; k<4; k++)
{
if (D[k]>D[v]+G[v][k])
{
D[k] = D[v]+G[v][k];
pre[k] = v;
}
}
}

// 打印最短路径
for (i=0; i<4; i++)
{
printf("v%d->v%d: %d\n", 0, i, D[i]);
}

return 0;
}

### 回答2：
以下是使用C语言的代码展示Dijkstra算法：

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

#define V 6 // 图的顶点数量

int minDistance(int dist[], bool visited[]) {
    int min = INT_MAX, min_index;
  
    for (int v = 0; v < V; v++)
        if (visited[v] == false && dist[v] <= min)
            min = dist[v], min_index = v;
  
    return min_index;
}

void printSolution(int dist[]) {
    printf("顶点   距离源点\n");
    for (int i = 0; i < V; i++)
        printf("%d    %d\n", i, dist[i]);
}

void dijkstra(int graph[V][V], int src) {
    int dist[V]; // 存储源点到每个顶点的最短距离
  
    bool visited[V]; // 判断顶点是否被访问
  
    // 初始化距离数组和访问数组
    for (int i = 0; i < V; i++)
        dist[i] = INT_MAX, visited[i] = false;
  
    dist[src] = 0; // 源点到自己的距离为0
  
    // 计算最短路径
    for (int count = 0; count < V - 1; count++) {
        int u = minDistance(dist, visited);
  
        visited[u] = true; // 标记顶点已访问
  
        // 更新邻接顶点的最短距离
        for (int v = 0; v < V; v++)
            if (!visited[v] && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v])
                dist[v] = dist[u] + graph[u][v];
    }
  
    printSolution(dist);
}

int main() {
    int graph[V][V] = { { 0, 4, 0, 0, 0, 0 },
                        { 4, 0, 8, 0, 0, 0 },
                        { 0, 8, 0, 7, 0, 4 },
                        { 0, 0, 7, 0, 9, 14 },
                        { 0, 0, 0, 9, 0, 10 },
                        { 0, 0, 4, 14, 10, 0 } };
  
    dijkstra(graph, 0); // 从顶点0开始计算最短路径
  
    return 0;
}

以上代码展示了使用C语言实现的Dijkstra算法。算法首先对距离数组和访问数组进行初始化，然后从源点开始计算最短路径。通过使用minDistance函数选择未被访问的顶点中距离源点最短的顶点，然后更新该顶点的邻接顶点的最短距离。最后，使用printSolution函数打印各顶点与源点的最短距离。在main函数中，我们提供了一个示例图，并从顶点0开始计算最短路径。

### 回答3：
Dijkstra算法是一种用于寻找图中最短路径的算法。下面是使用C语言代码展示Dijkstra算法的示例：

#include <stdio.h>
#include <stdbool.h>
#define INF 9999
#define V 5

// 找到dist数组中的最小值
int minDistance(int dist[], bool sptSet[])
{
    int min = INF, min_index;
    
    for (int v = 0; v < V; v++)
    {
        if (sptSet[v] == false && dist[v] <= min)
        {
            min = dist[v];
            min_index = v;
        }
    }

    return min_index;
}

// 打印最终的最短路径结果
void printSolution(int dist[])
{
    printf("顶点\t最短距离\n");
    for (int i = 0; i < V; i++)
    {
        printf("%d\t%d\n", i, dist[i]);
    }
}

// 使用Dijkstra算法找到源顶点（src）到其他顶点的最短距离
void dijkstra(int graph[V][V], int src)
{
    int dist[V];
    bool sptSet[V];

    // 初始化所有距离为无穷大，sptSet为false
    for (int i = 0; i < V; i++)
    {
        dist[i] = INF;
        sptSet[i] = false;
    }

    dist[src] = 0;

    // 找到最短路径
    for (int count = 0; count < V - 1; count++)
    {
        int u = minDistance(dist, sptSet);
        sptSet[u] = true;

        for (int v = 0; v < V; v++)
        {
            if (!sptSet[v] && graph[u][v] && dist[u] != INF && dist[u] + graph[u][v] < dist[v])
            {
                dist[v] = dist[u] + graph[u][v];
            }
        }
    }

    printSolution(dist);
}

int main()
{
    int graph[V][V] = {
        {0, 4, 0, 0, 2},
        {4, 0, 1, 5, 0},
        {0, 1, 0, 6, 0},
        {0, 5, 6, 0, 3},
        {2, 0, 0, 3, 0}
    };

    dijkstra(graph, 0);

    return 0;
}

在这个示例中，我们使用邻接矩阵表示图的连接关系，其中元素graph[i][j]表示从顶点i到顶点j的距离。运行结果将打印出从源顶点到其他顶点的最短距离。请注意，该示例仅适用于有向无环图(DAG)。