C语言迪杰斯特拉实现最短路径算法

C语言迪杰斯特拉实现最短路径算法迪杰斯特拉(Dijkstra)算法是一种用于在加权图中寻找从起点到终点的最短路径的算法。

它使用贪心算法的原理，每次选择权重最小的边进行扩展，直到找到终点或者无法扩展为止。

下面是C语言中迪杰斯特拉算法的实现。

```c
#include <stdio.h>
#include <stdbool.h>
//定义图的最大节点数
#define MAX_NODES 100
//定义无穷大的距离
#define INFINITY 9999
//自定义图的结构体
typedef struct
int distance[MAX_NODES][MAX_NODES]; // 节点间的距离
int numNodes; // 节点数
} Graph;
//初始化图
void initGraph(Graph* graph)
int i, j;
//设置所有节点之间的初始距离为无穷大
for (i = 0; i < MAX_NODES; i++)
for (j = 0; j < MAX_NODES; j++)
graph->distance[i][j] = INFINITY;
}
}
graph->numNodes = 0;
//添加边到图
void addEdge(Graph* graph, int source, int destination, int weight)
graph->distance[source][destination] = weight;
//打印最短路径
void printShortestPath(int* parent, int node)
if (parent[node] == -1)
printf("%d ", node);
return;
}
printShortestPath(parent, parent[node]);
printf("%d ", node);
//执行迪杰斯特拉算法
void dijkstra(Graph* graph, int source, int destination) int i, j;
//存储起点到各个节点的最短距离
int dist[MAX_NODES];
//存储当前节点的父节点
int parent[MAX_NODES];
//存储已访问的节点
bool visited[MAX_NODES];
//初始化所有节点的距离和父节点
for (i = 0; i < graph->numNodes; i++)
dist[i] = INFINITY;
parent[i] = -1;
visited[i] = false;
}
//设置起点的距离为0
dist[source] = 0;
//寻找最短路径
for (i = 0; i < graph->numNodes - 1; i++)
int minDist = INFINITY;
int minNode = -1;
//选择距离最小的节点作为当前节点
for (j = 0; j < graph->numNodes; j++)
if (!visited[j] && dist[j] < minDist)
minDist = dist[j];
minNode = j;
}
}
//标记当前节点为已访问
visited[minNode] = true;
//更新最短距离和父节点
for (j = 0; j < graph->numNodes; j++)
if (!visited[j] && (dist[minNode] + graph-
>distance[minNode][j]) < dist[j])
dist[j] = dist[minNode] + graph->distance[minNode][j];
parent[j] = minNode;
}
}
}
//打印最短路径及距离
printf("Shortest Path: ");
printShortestPath(parent, destination);
printf("\nShortest Distance: %d\n", dist[destination]); int mai
Graph graph;
int numNodes, numEdges, source, destination, weight;
int i;
//初始化图
initGraph(&graph);
//输入节点数和边数
printf("Enter the number of nodes: ");
scanf("%d", &numNodes);
printf("Enter the number of edges: ");
scanf("%d", &numEdges);
graph.numNodes = numNodes;
//输入边的信息
for (i = 0; i < numEdges; i++)
printf("Enter source, destination, and weight for edge %d: ", i + 1);
scanf("%d %d %d", &source, &destination, &weight);
addEdge(&graph, source, destination, weight);
}
//输入起点和终点
printf("Enter the source node: ");
scanf("%d", &source);
printf("Enter the destination node: ");
scanf("%d", &destination);
//执行迪杰斯特拉算法
dijkstra(&graph, source, destination);
return 0;
```
上述代码中，我们首先定义了一个图的结构体，里面包括节点间的距
离矩阵和节点数。

通过`initGraph`函数初始化图的距离矩阵和节点数。

然后，我们通过`addEdge`函数向图中添加边。

每条边包含源节点、
目标节点和权重。

`printShortestPath`函数用于打印最短路径，它通过递归输出父节点来输出完整路径。

`dijkstra`函数执行迪杰斯特拉算法。

它使用贪心策略，每次选择当前距离最小的节点作为当前节点，然后更新其他节点的距离和父节点。

最后，在`main`函数中，我们从用户输入中获取图的信息，包括节点数、边数、每条边的起点、终点和权重。

然后调用`dijkstra`函数执行算法，打印最短路径和距离。

这就是C语言中迪杰斯特拉算法的实现。

通过这个算法，我们可以在加权图中找到从起点到终点的最短路径。