图的最短路径（Dijkstra算法）

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

#define MAX 32767
#define SIZE 100
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status ;
typedef char VertexType ;

typedef struct
{
int vex ;
int weight ;
ArcNode *next ;
}ArcNode;

typedef struct
{
VertexType data ;
ArcNode *first ;
}VList[SIZE] ;

typedef struct
{
VList vertices ;
int vernum , arcnum ;
}ALGraph ;

ALGraph *G = (ALGraph *)malloc(sizeof(ALGraph));

int Locate(ALGraph *G , char a )
{
int i = 0 ;
while(i < G->vernum)
{
if(G->vertices[i].data == a)
{
return i ;
}
++i ;
}
return -1 ;
}

构建邻接表
Status CreateALGraph(ALGraph *G )
{
int i , j , k ;
int w ;
char v1 , v2 ;
ArcNode *p ;

for(i = 0 ; i < G->vernum ; ++i)
{
	scanf_s("%c",&G->vertices[i].data, sizeof(char));
	G->vertices[i].first = NULL ;
}

for(k = 0 ; k< G->arcnum ; ++k)
{
	scanf_s("%c%c%d", &v1 ,sizeof(char) , &v2, sizeof(char) , &w , sizeof(int)) ;
	i = Locate(G , v1) ;
	j = Locate(G , v2) ;

	p = (ArcNode *)malloc(sizeof(ArcNode)) ;
	p->next = G->vertices[i].first ;
	G->vertices[i].first = p ;

	p = (ArcNode *)malloc(sizeof(ArcNode)) ;
	p->next = G->vertices[j].first ;
	G->vertices[j].first = p ;
}
return OK ;

}

int *visited = (int *)calloc(G->vernum , sizeof(int)) ;//是否被访问过
int *min = (int *)calloc(G->vernum , sizeof(int)) ;//记录从顶点到该点的最短距离
char path = (char)calloc(G->vernum , (G->vernum+1) * sizeof(char)) ;//申请二维动态数组保存路径

void Dijkstra(ALGraph *G , int v1 )//贪心算法(记录的是从起点到全部顶点的最短距离)
{
int i , j , k;
int dmin ;//记录最小权值顶点下标(即要加入的下一个顶点)
ArcNode *p ;

//申请二维动态数组保存路径
for(i = 0 ; i < G->vernum ; ++i )
{
	path[i] = (char *)calloc(G->vernum+1 ,sizeof(char)) ;
}

//初始化路径距离
memset(min , MAX , G->vernum*sizeof(int)) ;
min[0] = 0 ;
visited[0] = 1 ;
//记录起点位置
path[0][0] = G->vertices[0].data ;
path[0][1] = '\0' ;

for(i = 0 ; i < G->vernum-1 ; ++i )//n-1个顶点
{
	for(j = 0 ; j < G->vernum ; ++j )//寻找下一个权值最小的点加入
	{
		if(visited[j] == 1)
		{
			p = G->vertices[j].first ;
			while(p && visited[p->vex] == 0)
			{
				if(p->weight + min[j] < min[p->vex] ) //如果有更短的路径，调整距离
				{
					min[p->vex] = p->weight + min[j] ;
					strncpy(path[p->vex] , path[j] , (G->vernum +1) * sizeof(char)) ;
					k = 0 ;
					while(path[p->vex][k] );
					path[p->vex][k] = G->vertices[p->vex].data ;
					path[p->vex][++k] = '\0' ;
					dmin = p->vex ;
				}
			}
		}
	}
	visited[dmin] = 1 ; 
}

}