单源点最短路径（广度优先算法实现）

单源点最短路径（广度优先算法实现）

求无向图中某一点到图中其他所有端点的路径长度和要经过的点

代码实现：

#include<iostream>
#include<malloc.h>
#define MaxVertexNum 100
#define INFINITY 10000 
using namespace std;
typedef struct{
	int vertex[MaxVertexNum];
	int Edge[MaxVertexNum][MaxVertexNum];
	int vertexNum,EdgeNum;
}MGraph;

//队、队结点的存储结构 
typedef struct LinkNode{
	int data;
	struct LinkNode *next;
}LinkNode;
typedef struct {
	LinkNode *front,*rear; 
}LinkQueue,*PLinkQueue;

//初始化队列
void InitQueue(LinkQueue &Q)
{
	Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));//头指针和尾指针指向同一节点，该节点无内容 
	Q.front->next=NULL; 
	Q.rear->next=NULL;
}

//判队空
bool EmptyQueue(LinkQueue Q)
{
	if(Q.front==Q.rear)
	return true;
	else
	return false; 
}

//入队
void EnQueue(LinkQueue &Q,int x)
{
	LinkNode *S=(LinkNode*)malloc(sizeof(LinkNode));
	S->data=x;
	S->next=NULL;
	Q.rear->next=S;
	Q.rear=S;
}
//出队
bool DeQueue(LinkQueue &Q,int &T)
{
	if(EmptyQueue(Q))
		return false;
	LinkNode *p=Q.front->next;
	T=p->data;
	Q.front->next=p->next;
	if(Q.rear==p)//出队前只有一个结点，出队后变成空 
		Q.rear=Q.front;
	free(p); 
	return true;	
} 

//邻接矩阵法创建一个图 
void CreateMGraph(MGraph *G)
{
	int i,j,k,w;
	printf("请输入图的顶点数和边数：");
	cin>>G->vertexNum>>G->EdgeNum;
	printf("请输入图的各个顶点的信息（A,B…）：");
	for(i=1;i<=G->vertexNum;i++)
		cin>>G->vertex[i];//"%c"中%c后面要有空格 
	for(i=1;i<=G->vertexNum;i++)
	{
		for(j=1;j<=G->vertexNum;j++)
			G->Edge[i][j]=0;		
	} 
	printf("请输入各条边的信息（例：1 2表示在A顶点和B顶点之间有一条边）:\n");
	for(k=1;k<=G->EdgeNum;k++)
	{//此为创建有向图的邻接矩阵 
		int Iindex,Jindex; 
		cin>>Iindex>>Jindex;
		G->Edge[Iindex][Jindex]=1;
		//如果加上G->Edge[j][i]=1;则建立的是无向图的邻接矩阵 
		G->Edge[Jindex][Iindex]=1;
	}		
} 

int FirstNeighbor(MGraph G,int x)
{
	int k;
	for(k=1;k<=G.vertexNum;k++)
	{
		if(G.Edge[x][k]==1)
			break; 
	}
	if(k<=G.vertexNum)
		return k; 
	else
		return -1;
}

int NextNeighbor(MGraph G,int x,int y)
{
	int j;
	for(j=y+1;j<=G.vertexNum;j++)
	{
		if(G.Edge[x][j]==1)
			break;
	}
	if(j<=G.vertexNum)
		return j;
	else
		return -1;
}

//单点到图中其他所有节点的最短路径。针对无向图 
int shortestPathBFS(MGraph G,int u)
{//u为起始点的下标，计算u点到各点的最短路径 
	int i,temp=u;				//temp暂存u的值由于后续输出 
	int distance[G.vertexNum+1];//存放u点到每一点的最短距离，从下标为1的内存单元开始 
	int parentPath[G.vertexNum+1];//parentPath[i]存放i的父节点/前驱 
	bool visited[G.vertexNum+1]={false};
	LinkQueue Q;
	InitQueue(Q);
	for(i=1;i<=G.vertexNum;i++)
	{
		distance[i]=INFINITY;//初始到各点的距离为无穷
		parentPath[i]=-1;//初始父节点下标都为-1 
	}
	visited[u]=true;//对u结点初始化，距离为0 
	distance[u]=0;	
	EnQueue(Q,u);//u节点入队 
	while(!EmptyQueue(Q))
	{
		int i;
		DeQueue(Q,u);
		for(i=FirstNeighbor(G,u);i>0;i=NextNeighbor(G,u,i))
		{
			if(!visited[i])
			{
				distance[i]=distance[u]+1;
				parentPath[i]=u;
				visited[i]=true;
				EnQueue(Q,i);
			}
		} 
	} 
	printf("\n\n%d顶点到各点的最短距离为：\n",temp);
	printf("顶点\t    最短距离\n");
	for(i=1;i<=G.vertexNum;i++)
	{
		printf("  %d\t\t%d\n",i,distance[i]);	
	} 
	
	printf("\n%d顶点到各顶点的最短路径为：\n");
	printf("顶点\t最短路径\n");
	for(i=1;i<=G.vertexNum;i++)
	{
		int temp=parentPath[i]; 
		printf("%d\t%d",i,i);
		while(temp!=-1)
		{
			printf("<-%d",temp);
			temp=parentPath[temp];
		}
		printf("\n");
	}
} 
int main()
{
	MGraph G;
	CreateMGraph(&G);
	shortestPathBFS(G,2); 
	return 0; 
}

测试数据：

注：BFS只适合无权图。

8 10
1 2 3 4 5 6 7 8
1 2
1 5
2 6
3 4
3 6
3 7
4 7
4 8
6 7
7 8

测试结果：