广度优先遍历求指定顶点之间的最短路径

问题描述：

设图中的各边的权值均为相等，以邻接表为存储结构，求顶点v到顶点u的最短路径长度，要求输出路径上的每一个顶点。

算法思路：采用广度优先遍历算法，当访问到的当前顶点为所指定的终点时，结束遍历，利用队列中每中元素的pre值寻找起点到终点的最短路径（当前顶点的pre值即为链接以当前顶点为终点的弧的表头结点序号）。

算法实现：

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define MAXSIZE 100
typedef char InfoType;
typedef char vertex;
typedef struct ANode
{
int adjvex;
struct ANode *nextarc;
InfoType Info;
}ArcNode;
typedef struct
{
vertex data;
ArcNode *fistarc;
}VertexNode;
typedef struct
{
VertexNode adjlist[MAXSIZE];
int n,e;
}ALGraph;
struct QUEUE
{
int _vertex;
int pre;
}queue[MAXSIZE];
int front=-1,rear=-1;
void _print(int);
void CreateALGraph(ALGraph*&,int**,int);
void shortest_path(ALGraph*,int,int,int*);
void CreateALGraph(ALGraph *&g,int array[][MAXSIZE],int k)
{
g=(ALGraph *)malloc(sizeof(ALGraph));
for(int i=0;i<k;i++)
g->adjlist[i].fistarc=NULL;
int cnt=0;
ArcNode *p;
for(i=0;i<k;i++)
for(int j=0;j<k;j++)
if(array[i][j]!=0)
{
p=(ArcNode *)malloc(sizeof(ArcNode));
p->adjvex=j;
p->nextarc=g->adjlist[i].fistarc;
g->adjlist[i].fistarc=p;
}
g->n=k;g->e=cnt;
}
void shortest_path(ALGraph *g,int v,int u,int visited[])
{
ArcNode *p;
int m,find=0;
rear++;
queue[rear]._vertex=v;
queue[rear].pre=-1;
visited[v]=1;
while(front!=rear&&!find)
{
front++;
m=queue[front]._vertex;
if(m==u)
{
find=1;
_print(front);
return;
}
p=g->adjlist[m].fistarc;
while(p!=NULL)
{
if(visited[p->adjvex]==0)
{
visited[p->adjvex]=1;
rear++;
queue[rear]._vertex=p->adjvex;
queue[rear].pre=front;
}
p=p->nextarc;
}
}
}
void _print(int front)
{
int k=front,j,cnt=0;
do
{
j=k;
k=queue[k].pre;
queue[j].pre=-1;
}while(k!=0);
k=0;
while(k<MAXSIZE)
{
if(queue[k].pre==-1)
{
printf("%d ",queue[k]._vertex);
cnt++;
}
k++;
}
printf("/n%d/n",cnt-1);
}
int main()
{
int graph_array[ ][MAXSIZE]={
{1,0,1,0,1,0},
{1,0,1,0,0,0},
{0,1,0,1,1,1},
{1,0,1,0,1,0},
{0,1,0,1,1,0},
{1,0,0,0,1,0}
};
ALGraph *g;
CreateALGraph(g,graph_array,6);
int visited[MAXSIZE]={0};
shortest_path(g,0,5,visited);
return 0;
}