图的邻接矩阵表示方式——无权图的最短路径

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

#define OK 1
#define NO 0
#define TRUE 1
#define FALSE 0
#define ERROR -1 

#define MaxVerTexNum 100
#define INFINITY 65535
typedef int ElementType;
typedef int Status;
typedef int WeightType;
typedef int Vertex;
typedef char DataType;

typedef int Position;
typedef struct QNode{
    ElementType *Data;
    Position Front, Rear;
    int MaxSize;  
}QNode,*Queue;

typedef  struct  ENode{
    Vertex V1,V2;     //有向边<v1,V2>
    WeightType Weight;//权重
}ENode,*PtrToENode ;

typedef PtrToENode Edge;

Status IsFull( Queue Q );

typedef struct GNode{
    int Nv;//顶点数
    int Ne;//边数
    WeightType G[MaxVerTexNum][MaxVerTexNum];//邻接矩阵
    DataType Data[MaxVerTexNum];//save data of the Vertex;
}GNode,*PtrToGNode;

typedef PtrToGNode MGraph;

ElementType DeleteQ( Queue Q );

Queue CreateQueue( int MaxSize );

Status IsEmpty( Queue Q );

Status AddQ( Queue Q, ElementType X );

MGraph CreateGraph(int VertexNum);//Create a Graph with VertexNum Vertex but without an ege;

void InsertEdge(MGraph Graph,Edge E);

MGraph BuildGraph();

Status IsEdge(MGraph Graph,Vertex V,Vertex W);//检查<V,W>是不是图中的一条边，即W是不是V的邻接点

void BFS(MGraph Graph,Vertex S);

void Unweighted(MGraph Graph,int dist[],int path[],Vertex);

int main(int argc,char** argv)
{
    MGraph Graph;
    Graph=BuildGraph();

    int i,j;
    int dist[100];
    int path[100];

    Vertex S=1;
    int sum;
    for(i=0;i<=99;i++)
    {
        dist[i]=path[i]=-1;
    }

    printf("无向图最短路径\n");
    Unweighted(Graph,dist,path,S);

    for(j=0;j<Graph->Nv;j++){     //出现死循环要多调试
        i=j;
        sum=0;
    while(i!=-1){
        
        printf("%d",i);
        i=path[i];
        if(i!=-1){
            printf("<--");
            sum++;
        }
        
    }
    printf("\n");
    printf("从%d到%d的无权图最短路径为%d\n",S,j,sum);
    printf("\n");
    }

    //DFS(Graph, 1);
    return 0;
}

MGraph CreateGraph(int VertexNum){
    Vertex V,W;
    MGraph Graph;
    Graph=(MGraph)malloc(sizeof(GNode));//form a Graph
    Graph->Nv=VertexNum;
    Graph->Ne=0;//
    for(V=0;V<Graph->Nv;V++)
        for(W=0;W<Graph->Nv;W++)
            Graph->G[V][W]=INFINITY;
        return Graph;
}

void InsertEdge(MGraph Graph,Edge E){
    Graph->G[E->V1][E->V2]=E->Weight;
    //若是无向图还要插入
    Graph->G[E->V2][E->V1]=E->Weight;
}

MGraph BuildGraph(){
    MGraph Graph;
    Edge E;
    Vertex V;
    int Nv,i;
    printf("输入结点的个数\n");
    scanf("%d",&Nv);//the number of vertex
    Graph=CreateGraph(Nv);//initate graph with Nv vertexs  !!return 回去要赋值给Graph；
    //getchar();
    printf("输入弧的个数\n");
    scanf("%d",&(Graph->Ne));//read the number of ege
    if(Graph->Ne!=0)
    {
        E=(Edge)malloc(sizeof(ENode));
        for(i=0;i<Graph->Ne;i++){
            // getchar();
            printf("输入弧的信息V1 V2 Weight\n");
            scanf("%d %d %d",&(E->V1),&(E->V2),&(E->Weight));
            InsertEdge(Graph,E);
        }
    }
    // for(V=0;V<Graph->Nv;V++)
    //     scanf("%c",&(Graph->Data[V]));
    return Graph;

}

void Visit(Vertex V){
    printf("正在访问顶点%d\n",V);
}

Status IsEdge(MGraph Graph,Vertex V,Vertex W){
    return Graph->G[V][W]<INFINITY?TRUE:FALSE;
}

Queue CreateQueue( int MaxSize )
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MaxSize;
    return Q;
}
 
Status AddQ( Queue Q, ElementType X )
{
    if ( IsFull(Q) ) {
        printf("队列满");
        return FALSE;
    }
    else {
        Q->Rear = (Q->Rear+1)%Q->MaxSize;
        Q->Data[Q->Rear] = X;
        return FALSE;
    }
}
ElementType DeleteQ( Queue Q )
{
    if ( IsEmpty(Q) ) { 
        printf("队列空");
        return ERROR;
    }
    else  {
        Q->Front =(Q->Front+1)%Q->MaxSize;
        return  Q->Data[Q->Front];
    }
}

Status IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}
Status IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}

void Unweighted(MGraph Graph,int dist[],int path[],Vertex S){
    Queue Q;
    Vertex V,W;
    int MaxSize=100;
    Q=CreateQueue(MaxSize);
    dist[S]=0;
    AddQ(Q,S);
    while(!IsEmpty(Q))
    {
        V=DeleteQ(Q);
        for(W=0;W<Graph->Nv;W++)
            if(Graph->G[V][W]!=0&&Graph->G[V][W]!=INFINITY){
                if(dist[W]==-1){
                    dist[W]=dist[V]+1;
                    path[W]=V;
                AddQ(Q,W);
            }
            }
    }
}

输入输出示例：