最短路径问题_Floyd算法

 

Floyd算法里面是三重循环，所以时间复杂度是O(n^3).

适用于求解所有顶点至所有顶点的最短路径问题。

优缺点分析：

优点：容易理解，可以算出任意两个节点之间的最短距离，代码编写简单。

缺点：时间复杂度比较高，不适合计算大量数据。

#include <stdio.h>

#define MAXVEX 9
#define MAXEDGES 16
#define INFINITE 60000

//定义图的类型
typedef struct {
    int vexs[MAXVEX];//保存顶点名称
    int arc[MAXVEX][MAXVEX];//邻接矩阵
    int numVertexs,numEdges;
}MGraph;

typedef int Pathmatirx[MAXVEX][MAXVEX];            //vi到vj的路径最短的情况下，第一步应走哪个节点
typedef int ShortPathTable[MAXVEX][MAXVEX];    //存储所有顶点到所有顶点最短路径的长度

//构建图
void CreateMGraph(MGraph * G){
    int i,j;
    G->numEdges=16;
    G->numVertexs=9;
    //给每个顶点命名
    for(i=0; i<G->numVertexs; i++){
        G->vexs[i]=i;
    }

    for(i=0; i<G->numVertexs; i++){
        for(j=0; j<G->numVertexs; j++){
            if(i==j){
                G->arc[i][j]=0;
            }else{
                G->arc[i][j]=INFINITE;
            }
        }
    }

    G->arc[0][1]=1;
    G->arc[0][2]=5; 
    G->arc[1][2]=3; 
    G->arc[1][3]=7; 
    G->arc[1][4]=5; 

    G->arc[2][4]=1; 
    G->arc[2][5]=7; 
    G->arc[3][4]=2; 
    G->arc[3][6]=3; 
    G->arc[4][5]=3;

    G->arc[4][6]=6;
    G->arc[4][7]=9; 
    G->arc[5][7]=5; 
    G->arc[6][7]=2; 
    G->arc[6][8]=7;

    G->arc[7][8]=4;

    for(i=0;i<G->numVertexs; i++){
        for(j=0; j<i; j++){
            G->arc[i][j]=G->arc[j][i];
        }
    }
}

//Floyd算法
void ShortestPath_Floyd(MGraph G,Pathmatirx * P,ShortPathTable * D){
    int v,w,k;

    //初始化P，D
    for(v=0; v<G.numVertexs; v++){
        for(w=0; w<G.numVertexs; w++){
            (*P)[v][w]=w;
            (*D)[v][w]=G.arc[v][w];
        
        }
    }

    for(k=0; k<G.numVertexs; k++){
        for(v=0; v<G.numVertexs; v++){
            for(w=0; w<G.numVertexs; w++){
                if((*D)[v][w]>(*D)[v][k]+(*D)[k][w]){
                    (*D)[v][w]=(*D)[v][k]+(*D)[k][w];
                    (*P)[v][w]=(*P)[v][k];
                }
            }
        }
    }

}
//打印路径长度及完整路径
void Gprint(MGraph G,Pathmatirx P,ShortPathTable D){
    int v,w,t;
    for(v=0; v<G.numVertexs; v++){
        for(w=0; w<G.numVertexs; w++){
            printf("%d到%d的最短路径长度为: %d\n",v,w,D[v][w]);
            //打印完整路径
            printf("%d-->",v);
            t=P[v][w];
            while(t!=w){
                printf("%d-->",t);
                t=P[t][w];
            }
            printf("%d\n\n",w);
        }
    }
}

int main(){
    MGraph G;
    Pathmatirx P;        
    ShortPathTable D; 

        CreateMGraph(&G);
        ShortestPath_Floyd(G,&P,&D);
        Gprint(G,P,D);

    return 0;
}

 

结果：

 

转载于:https://www.cnblogs.com/Allen-win/p/7354739.html