Here you will find out about Dijkstra’s calculation in C.

Dijkstra calculation is likewise called single source briefest way calculation. It depends on the insatiable method.

The calculation keeps up a rundown visited[ ] of vertices, whose most limited good ways from the source is as of now known.

On the off chance that visited[1], rises to 1, at that point the briefest separation

of vertex I am as of now known. At first, visited[i] is set apart as, for source vertex.

At each progression, we mark visited[v] as 1. Vertex v is a vertex at most limited good

ways from the source vertex. At each progression of the calculation, most limited separation of every vertex is put away in a cluster distance[ ].

**Dijkstra’s Algorithm **

Make cost framework C[ ][ ] from nearness network adj[ ][ ]. C[i][j] is the expense of going from vertex I to vertex j.

On the off chance that there is no edge between vertices I and j, at that point C[i][j] is interminability.

Cluster visited[ ] is introduced to zero.

for(i=0;i<n;i++)

visited[i]=0;

In the event that the vertex 0 is the source vertex, at that point visited[0] is set apart as 1.

Make the separation framework, by putting away the expense of vertices from vertex no. 0 to n-1 from the source vertex 0.

for(i=1;i<n;i++)

distance[i]=cost[0][i];

At first, separation of source vertex is taken as 0. for example distance[0]=0;

for(i=1;i<n;i++)

– Choose a vertex w, with the end goal that distance[w] is least and visited[w] is 0. Imprint visited[w] as 1.

– Recalculate the most brief separation of outstanding vertices from the source.

– Only, the vertices not set apart as 1 in cluster visited[ ] ought to be considered for recalculation of separation. for example for every vertex v

if(visited[v]==0)

distance[v]=min(distance[v],

distance[w]+cost[w][v])

**Time Complexity**

The program contains two settled circles every one of which has a multifaceted nature of O(n).

n is number of vertices. So the intricacy of calculation is O(n2).

**Program for Dijkstra’s Algorithm in C**

C Program on Dijkstra Algorithm for Finding Minimum Distance of Vertices from a Given Source in a Graph

```
#include<stdio.h>
#include<conio.h>
#define INFINITY 9999
#define MAX 10
void dijkstra(int G[MAX][MAX],int n,int startnode);
int main()
{
int G[MAX][MAX],i,j,n,u;
printf("Enter no. of vertices:");
scanf("%d",&n);
printf("\nEnter the adjacency matrix:\n");
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&G[i][j]);
printf("\nEnter the starting node:");
scanf("%d",&u);
dijkstra(G,n,u);
return 0;
}
void dijkstra(int G[MAX][MAX],int n,int startnode)
{
int cost[MAX][MAX],distance[MAX],pred[MAX];
int visited[MAX],count,mindistance,nextnode,i,j;
//pred[] stores the predecessor of each node
//count gives the number of nodes seen so far
//create the cost matrix
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(G[i][j]==0)
cost[i][j]=INFINITY;
else
cost[i][j]=G[i][j];
//initialize pred[],distance[] and visited[]
for(i=0;i<n;i++)
{
distance[i]=cost[startnode][i];
pred[i]=startnode;
visited[i]=0;
}
distance[startnode]=0;
visited[startnode]=1;
count=1;
while(count<n-1)
{
mindistance=INFINITY;
//nextnode gives the node at minimum distance
for(i=0;i<n;i++)
if(distance[i]<mindistance&&!visited[i])
{
mindistance=distance[i];
nextnode=i;
}
//check if a better path exists through nextnode
visited[nextnode]=1;
for(i=0;i<n;i++)
if(!visited[i])
if(mindistance+cost[nextnode][i]<distance[i])
{
distance[i]=mindistance+cost[nextnode][i];
pred[i]=nextnode;
}
count++;
}
//print the path and distance of each node
for(i=0;i<n;i++)
if(i!=startnode)
{
printf("\nDistance of node%d=%d",i,distance[i]);
printf("\nPath=%d",i);
j=i;
do
{
j=pred[j];
printf("<-%d",j);
}while(j!=startnode);
}
}
```

**Output**

Remark beneath in the event that you discovered something incorrectly in over Dijkstra calculation in C.