数据结构编程笔记二十一：第七章 图 最短路径算法的实现

最新推荐文章于 2024-07-24 23:35:41 发布
原创 最新推荐文章于 2024-07-24 23:35:41 发布 · 687 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #图 #迪杰斯特拉算法 #弗洛伊德算法 #拓扑排序

本文介绍基于邻接矩阵的最短路径算法实现，包括迪杰斯特拉算法和弗洛伊德算法。通过示例展示了如何求解单源最短路径和所有顶点间的最短路径。

上次我们介绍了图的最小生成树算法的实现，这次介绍基于邻接矩阵的最短路径算法的实现。

还是老规矩：

程序在码云上可以下载。
地址：https://git.oschina.net/601345138/DataStructureCLanguage.git

本次最短路径共用到以下源文件，有一些已经在之前的文章介绍过。还是和以前一样，所有源文件需要放在同一目录下编译。
my_constants.h 各种状态码定义
MGraph.h 图的邻接矩阵存储结构表示定义
MGraph.cpp 基于邻接矩阵的基本操作实现
ShortestPath.cpp 最短路径算法实现
最短路径测试.cpp 主函数，调用算法完成最短路径程序的演示

邻接矩阵在《数据结构编程笔记十八：第七章 图 图的邻接矩阵存储表示及各基本操作的实现》一文有所介绍，my_constants.h、MGraph.h 和MGraph.cpp三个源文件与此文中的同名源文件内容完全一致，没有修改。这里不再重复贴了（否则文章会很长，不能突出重点），但在码云上你可以下载到全部源文件，我会把它放在一个目录下。

本次只贴最短路径的核心代码和主函数：

源文件：ShortestPath.cpp

//--------------- 最短路径 ------------------- 

//---------------------------迪杰斯特拉算法辅助数组的定义--------------------------------

//P[][]记录了v->v0的最短路径经过哪些路径，
//当P[i][j] = TRUE，说明i->j这样一条边在最短路径上
//当P[i][j] = FALSE，说明i->j不在最短路径上 
typedef int PathMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

//D[]记录了v0到各个顶点的最短距离 
typedef int ShortPathTable[MAX_VERTEX_NUM];

/* （迪斯特拉算法求单源最短路径） 
    函数：ShortestPath_DIJ
    参数：MGraph G 图G 
          int v0 出发点v0
          PathMatrix &P 记录最短路径经过哪些路径的P数组
          ShortPathTable &D 记录v0到各个顶点的最短距离的D数组 
    返回值： 无 
    作用：用Dijkstra算法求有向图G的顶点v0顶点到其余顶点v的最短路径P[v]及其带权长度D[v]
          若P[v][w]为TRUE，则w是从v0到v当前求得最小路径上的顶点
          final[v]为TRUE当且仅当v∈S，即已经求得v0到v的最短路径
*/
void ShortestPath_DIJ(MGraph G, int v0, PathMatrix &P, ShortPathTable &D){  //

    //临时变量 
    int v, w, j, min;

    //final数组的作用是记录各个顶点是否已经找到最短路径 
    Status final[MAX_VERTEX_NUM];

    //初始化数据 
    for(v = 0; v < G.vexnum; ++v) {

        //final数组中的值为FALSE表示还未求得最短路径 
        final[v] = FALSE;

        //将与v相邻的顶点加上权值 
        D[v] = G.arcs[v0][v].adj;

        //设P数组的初始值为没有路径
        for(w = 0; w < G.vexnum; ++w) {
            P[v][w] = FALSE;
        }//for

        //D数组有权值即P数组对应位置存在路径 
        //也就是v和v0之间存在路径 
        if(D[v] < INFINITY){

            //经过v0 
            P[v][v0] = TRUE;

            //经过v 
            P[v][v] = TRUE;
        }//if
    }//for

    //v0->v0的距离是0 
    D[v0] = 0;

    //v0顶点并入S集 
    final[v0] = TRUE;

    //开始主循环，每次求得v0到某个顶点v的最短路径，并加v到S集 
    for(int i = 0; i < G.vexnum; ++i){   //其余G.vexnum-1个顶点 

        //当前所知离v0顶点最近距离，设置初始值∞ 
        min = INFINITY;

        //扫描所有顶点 
        for(int w = 0; w < G.vexnum; ++w) {

            //w顶点没有并入集合S中 
            if(!final[w]) {

                //w顶点离v0顶点更近 
                if(D[w] < min){

                    //v记录了离v0最近的顶点 
                    v = w;

                    //min记录了到v0的最短路径 
                    min = D[w];
                }//if 
            }//if 
        }//for 

        //离v0顶点最近的v加入S集
        final[v] = TRUE;

        //更新当前最短路径及距离
        //根据新并入的顶点，更新不在S集的顶点到V0的距离和路径数组 
        for(int w = 0; w < G.vexnum; ++w) {

            //修改D[w]和P[w]，w∈V-S 
            if(!final[w] && (min + G.arcs[v][w].adj < D[w])){

                //更新D[w] 
                D[w] = min + G.arcs[v][w].adj;

                //修改P[w]，v0到w经过的顶点包括v0到v经过的顶点再加上顶点w 
                //P[w] = P[v] + [w]
                for(int j = 0; j < G.vexnum; ++j) {
                    P[w][j] = P[v][j];
                }//for

                //最短路径经过w点 
                P[w][w] = TRUE;    
            }//if
        }//for 
    }//for  
}//ShortestPath_DIJ

//---------------------弗洛伊德算法辅助数组的定义------------------------

//P[][][]记录了最短路径经过了哪些路径 
typedef int PathMatrix1[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM];

//D[][]记录了各顶点之间最短路径的值 
typedef int DistanceMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

/* （弗洛伊德算法求各顶点之间的最短路径） 
    函数：ShortestPath_FLOYD
    参数：MGraph G 图G
          PathMatrix1 &P 记录最短路径经过哪些路径的P数组
          DistanceMatrix &D 记录了各顶点之间最短路径值的D数组 
    返回值： 无 
    作用：用Floyd算法求有向网G中各对顶点v和w之间的最短路径P[v][w]及其带权长度D[v][w]。
          若P[v][w][u]为TRUE，则u是从v到w当前求得最短路径上的顶点。
*/
void ShortestPath_FLOYD(MGraph G, PathMatrix1 &P, DistanceMatrix &D){

    //各对结点之间的初始已知路径及距离
    for(int v = 0; v < G.vexnum; ++v) {      
        for(int w = 0; w < G.vexnum; ++w){

            //顶点v到顶点w的直接距离 
            D[v][w] = G.arcs[v][w].adj;

            //路径矩阵的初值为FALSE 
            for(int u = 0; u < G.vexnum; ++u) {
                P[v][w][u] = FALSE;
            }//for

            //从v到w有直接路径 
            if(D[v][w]<INFINITY){

                //从v到w的路径经过v和w两点 
                P[v][w][v] = TRUE;
                P[v][w][w] = TRUE; 
            }//if 
        }//for
    }//for 

    //从v经u到w的一条路径更短 
    for(int u = 0; u < G.vexnum; ++u) {
        for(int v = 0; v < G.vexnum; ++v) {
            for(int w = 0; w < G.vexnum; ++w) {

                //从v经u到w的一条路径更短 
                if(D[v][u] + D[u][w] < D[v][w]){ 

                    //更新最短距离 
                    D[v][w] = D[v][u] + D[u][w];

                    //从v到w的路径经过从v到u和从u到w的所有路径 
                    for(int i = 0; i < G.vexnum; ++i) {
                        P[v][w][i] = P[v][u][i] || P[u][w][i];
                    }//for 
                }//if
            }//for
        }//for 
    }//for
}//ShortestPath_FLOYD

源文件：最短路径测试.cpp

//**************************引入头文件*****************************
#include <stdio.h>   //使用了标准库函数 
#include <stdlib.h>  //使用了动态内存分配函数

#include "my_constants.h" //引入自定义的符号常量，主要是状态码 
#include "MGraph.h"       //引入图的邻接矩阵表示法的基本定义 
#include "MGraph.cpp"     //引入图的主要操作
#include "ShortestPath.cpp" //引入图的最短路径算法实现 


//----------------------主函数----------------------
int main(int argc, char *argv[]){

    printf("\n-------------基于邻接矩阵的最短路径算法测试程序--------------\n\n"); 

    //图G 
    MGraph G; 

    //临时变量，保存输入的顶点 
    VertexType v1, v2;

    //临时变量，保存输入的顶点数 
    int n;

    //图的创建
    printf("->测试图的创建：（最短路径算法要求图必须是有向网，请选择1）\n");
    CreateGraph(G);

    //打印邻接矩阵
    printf("\n->创建成功后图的邻接矩阵:\n\n"); 
    PrintAdjMatrix(G);

    //测试最短路径 
    if(G.kind == DN){

        //迪杰斯特拉算法用到的临时变量： 
        int v0 = 0;       //源点
        PathMatrix P;     //P数组 
        ShortPathTable D; //D数组 

        printf("\n->测试求有向网的最短路径：\n\n");

        //测试迪杰斯特拉算法 
        printf("->使用迪杰斯特拉算法求单源最短路径：\n"); 
        ShortestPath_DIJ(G, v0, P, D);

        //打印迪杰斯特拉算法用的P数组 
        printf("->迪杰斯特拉算法用到的最短路径数组P[i][j]如下(T表示TRUE，F表示FALSE)：\n");
        for(int i = 0; i < G.vexnum; ++i) {
            for(int j = 0; j < G.vexnum; ++j) { 
                printf(" %3c ", P[i][j] == 1 ? 'T' : 'F');
            }//for 
            printf("\n");
        }//for

        //打印迪杰斯特拉算法用的D数组 
        printf("顶点%d到其他顶点的最短路径如下：\n", v0);
        for(int i = 0; i < G.vexnum; ++i) { 
            printf("%d ---> %d ：%3d\n", v0, G.vexs[i], D[i]);
        }//for

        //弗洛伊德算法用到的两个数组 
        //这两个数组和迪斯特拉算法的两个数组虽然同名但没有关系 
        PathMatrix1 P1;    //P数组 
        DistanceMatrix D1; //D数组 

        //测试弗洛伊德算法 
        printf("->使用弗洛伊德算法求任意两顶点最短路径：\n");
        //ShortestPath_FLOYD()要求对角线元素为0 
        for(int i = 0; i < G.vexnum; ++i) { 
            G.arcs[i][i].adj = 0;
        }//for

        printf("->执行算法前的邻接矩阵如下：\n");
        PrintAdjMatrix(G);

        //执行弗洛伊德算法 
        ShortestPath_FLOYD(G, P1, D1);

        //打印弗洛伊德算法用的D数组 
        printf("->弗洛伊德算法用的D数组：\n\n");

        //输出左上角多余的空白 
        printf("      ");

        //输出邻接矩阵的上坐标（全部顶点） 
        for(int i = 0; i < G.vexnum; i++) {

            printf(" %3d ", i);     
        }//for 

        printf("\n"); 

        //输出左上角多余的空白 
        printf("     +");

        //输出一条横线
        for(int i = 0; i < G.vexnum; i++) {
            printf("-----"); 
        }//for 

        printf("\n"); 

        for(int i = 0; i < G.vexnum; ++i) {

            //输出邻接矩阵左边的坐标
            printf(" %3d |", G.vexs[i]);  

            for(int j = 0; j < G.vexnum; ++j) {
                if(D1[i][j] == INFINITY) {
                   printf("  ∞ ");
                }//if 
                else {
                   printf(" %3d ", D1[i][j]);
                }//else 
            }//for   
            printf("\n     |\n");
        }//for

        //打印计算得到的最短路径 
        printf("\n->最短路径的计算结果：\n");
        for(int i = 0; i < G.vexnum; ++i) { 
            for(int j = 0; j < G.vexnum; ++j) { 
                printf(" %d--->%d ：%-6d ", G.vexs[i], G.vexs[j], D1[i][j]);
            }//for
            printf("\n"); 
        }//for

        //打印弗洛伊德算法用的P数组 
        printf("\n->弗洛伊德算法用的最短路径数组P[i][j][k]如下(T表示TRUE，F表示FALSE)：\n");
        for(int i = 0; i < G.vexnum; ++i) {
            for(int j = 0; j < G.vexnum; ++j) {
                for(int k = 0; k < G.vexnum; ++k){
                    printf("P[%d][%d][%d] = %c  ", i, j, k, P1[i][j][k] == 1 ? 'T' : 'F');
                }//for
                printf("\n");
            }//for
        }//for 
    }//if 

    //测试销毁 
    printf("\n->测试销毁图： ");
    DestroyGraph(G); 
    printf("成功！\n");

    printf("演示结束，程序退出！\n");

    return 0;
}

测试的有向网使用书上P188页的图7.34，可以直接去该页寻找最短路径的正确结果，以便于验证算法正确与否。

测试过程中程序的输入和输出：

-------------基于邻接矩阵的最短路径算法测试程序--------------

->测试图的创建：（最短路径算法要求图必须是有向网，请选择1）
请输入您想构造的图的类型:有向图输入0,有向网输入1,无向图输入2,无向网输入3):1
请依次输入有向网G的顶点数，弧数，用逗号隔开
6,8
请依次输入有向网G的顶点名称，用空格隔开
0 1 2 3 4 5
请依次输入有向网G每条弧依附的两顶点名称及权值，输完一组按回车
0 5 100
0 4 30
0 2 10
1 2 5
2 3 50
4 3 20
4 5 60
3 5 10

->创建成功后图的邻接矩阵:

         0    1    2    3    4    5
     +------------------------------
   0 |  ∞   ∞   10   ∞   30  100
     |
   1 |  ∞   ∞    5   ∞   ∞   ∞
     |
   2 |  ∞   ∞   ∞   50   ∞   ∞
     |
   3 |  ∞   ∞   ∞   ∞   ∞   10
     |
   4 |  ∞   ∞   ∞   20   ∞   60
     |
   5 |  ∞   ∞   ∞   ∞   ∞   ∞
     |

->测试求有向网的最短路径：

->使用迪杰斯特拉算法求单源最短路径：
->迪杰斯特拉算法用到的最短路径数组P[i][j]如下(T表示TRUE，F表示FALSE)：
   F    F    F    F    F    F
   F    F    F    F    F    F
   T    F    T    F    F    F
   T    F    F    T    T    F
   T    F    F    F    T    F
   T    F    F    T    T    T
顶点0到其他顶点的最短路径如下：
0 ---> 0 ：  0
0 ---> 1 ：65535
0 ---> 2 ： 10
0 ---> 3 ： 50
0 ---> 4 ： 30
0 ---> 5 ： 60
->使用弗洛伊德算法求任意两顶点最短路径：
->执行算法前的邻接矩阵如下：
         0    1    2    3    4    5
     +------------------------------
   0 |   0   ∞   10   ∞   30  100
     |
   1 |  ∞    0    5   ∞   ∞   ∞
     |
   2 |  ∞   ∞    0   50   ∞   ∞
     |
   3 |  ∞   ∞   ∞    0   ∞   10
     |
   4 |  ∞   ∞   ∞   20    0   60
     |
   5 |  ∞   ∞   ∞   ∞   ∞    0
     |
->弗洛伊德算法用的D数组：

         0    1    2    3    4    5
     +------------------------------
   0 |   0   ∞   10   50   30   60
     |
   1 |  ∞    0    5   55   ∞   65
     |
   2 |  ∞   ∞    0   50   ∞   60
     |
   3 |  ∞   ∞   ∞    0   ∞   10
     |
   4 |  ∞   ∞   ∞   20    0   30
     |
   5 |  ∞   ∞   ∞   ∞   ∞    0
     |

->最短路径的计算结果：
 0--->0 ：0       0--->1 ：65535   0--->2 ：10      0--->3 ：50      0--->4 ：30      0--->5 ：60
 1--->0 ：65535   1--->1 ：0       1--->2 ：5       1--->3 ：55      1--->4 ：65535   1--->5 ：65
 2--->0 ：65535   2--->1 ：65535   2--->2 ：0       2--->3 ：50      2--->4 ：65535   2--->5 ：60
 3--->0 ：65535   3--->1 ：65535   3--->2 ：65535   3--->3 ：0       3--->4 ：65535   3--->5 ：10
 4--->0 ：65535   4--->1 ：65535   4--->2 ：65535   4--->3 ：20      4--->4 ：0       4--->5 ：30
 5--->0 ：65535   5--->1 ：65535   5--->2 ：65535   5--->3 ：65535   5--->4 ：65535   5--->5 ：0

->弗洛伊德算法用的最短路径数组P[i][j][k]如下(T表示TRUE，F表示FALSE)：
P[0][0][0] = T  P[0][0][1] = F  P[0][0][2] = F  P[0][0][3] = F  P[0][0][4] = F  P[0][0][5] = F
P[0][1][0] = F  P[0][1][1] = F  P[0][1][2] = F  P[0][1][3] = F  P[0][1][4] = F  P[0][1][5] = F
P[0][2][0] = T  P[0][2][1] = F  P[0][2][2] = T  P[0][2][3] = F  P[0][2][4] = F  P[0][2][5] = F
P[0][3][0] = T  P[0][3][1] = F  P[0][3][2] = F  P[0][3][3] = T  P[0][3][4] = T  P[0][3][5] = F
P[0][4][0] = T  P[0][4][1] = F  P[0][4][2] = F  P[0][4][3] = F  P[0][4][4] = T  P[0][4][5] = F
P[0][5][0] = T  P[0][5][1] = F  P[0][5][2] = F  P[0][5][3] = T  P[0][5][4] = T  P[0][5][5] = T
P[1][0][0] = F  P[1][0][1] = F  P[1][0][2] = F  P[1][0][3] = F  P[1][0][4] = F  P[1][0][5] = F
P[1][1][0] = F  P[1][1][1] = T  P[1][1][2] = F  P[1][1][3] = F  P[1][1][4] = F  P[1][1][5] = F
P[1][2][0] = F  P[1][2][1] = T  P[1][2][2] = T  P[1][2][3] = F  P[1][2][4] = F  P[1][2][5] = F
P[1][3][0] = F  P[1][3][1] = T  P[1][3][2] = T  P[1][3][3] = T  P[1][3][4] = F  P[1][3][5] = F
P[1][4][0] = F  P[1][4][1] = F  P[1][4][2] = F  P[1][4][3] = F  P[1][4][4] = F  P[1][4][5] = F
P[1][5][0] = F  P[1][5][1] = T  P[1][5][2] = T  P[1][5][3] = T  P[1][5][4] = F  P[1][5][5] = T
P[2][0][0] = F  P[2][0][1] = F  P[2][0][2] = F  P[2][0][3] = F  P[2][0][4] = F  P[2][0][5] = F
P[2][1][0] = F  P[2][1][1] = F  P[2][1][2] = F  P[2][1][3] = F  P[2][1][4] = F  P[2][1][5] = F
P[2][2][0] = F  P[2][2][1] = F  P[2][2][2] = T  P[2][2][3] = F  P[2][2][4] = F  P[2][2][5] = F
P[2][3][0] = F  P[2][3][1] = F  P[2][3][2] = T  P[2][3][3] = T  P[2][3][4] = F  P[2][3][5] = F
P[2][4][0] = F  P[2][4][1] = F  P[2][4][2] = F  P[2][4][3] = F  P[2][4][4] = F  P[2][4][5] = F
P[2][5][0] = F  P[2][5][1] = F  P[2][5][2] = T  P[2][5][3] = T  P[2][5][4] = F  P[2][5][5] = T
P[3][0][0] = F  P[3][0][1] = F  P[3][0][2] = F  P[3][0][3] = F  P[3][0][4] = F  P[3][0][5] = F
P[3][1][0] = F  P[3][1][1] = F  P[3][1][2] = F  P[3][1][3] = F  P[3][1][4] = F  P[3][1][5] = F
P[3][2][0] = F  P[3][2][1] = F  P[3][2][2] = F  P[3][2][3] = F  P[3][2][4] = F  P[3][2][5] = F
P[3][3][0] = F  P[3][3][1] = F  P[3][3][2] = F  P[3][3][3] = T  P[3][3][4] = F  P[3][3][5] = F
P[3][4][0] = F  P[3][4][1] = F  P[3][4][2] = F  P[3][4][3] = F  P[3][4][4] = F  P[3][4][5] = F
P[3][5][0] = F  P[3][5][1] = F  P[3][5][2] = F  P[3][5][3] = T  P[3][5][4] = F  P[3][5][5] = T
P[4][0][0] = F  P[4][0][1] = F  P[4][0][2] = F  P[4][0][3] = F  P[4][0][4] = F  P[4][0][5] = F
P[4][1][0] = F  P[4][1][1] = F  P[4][1][2] = F  P[4][1][3] = F  P[4][1][4] = F  P[4][1][5] = F
P[4][2][0] = F  P[4][2][1] = F  P[4][2][2] = F  P[4][2][3] = F  P[4][2][4] = F  P[4][2][5] = F
P[4][3][0] = F  P[4][3][1] = F  P[4][3][2] = F  P[4][3][3] = T  P[4][3][4] = T  P[4][3][5] = F
P[4][4][0] = F  P[4][4][1] = F  P[4][4][2] = F  P[4][4][3] = F  P[4][4][4] = T  P[4][4][5] = F
P[4][5][0] = F  P[4][5][1] = F  P[4][5][2] = F  P[4][5][3] = T  P[4][5][4] = T  P[4][5][5] = T
P[5][0][0] = F  P[5][0][1] = F  P[5][0][2] = F  P[5][0][3] = F  P[5][0][4] = F  P[5][0][5] = F
P[5][1][0] = F  P[5][1][1] = F  P[5][1][2] = F  P[5][1][3] = F  P[5][1][4] = F  P[5][1][5] = F
P[5][2][0] = F  P[5][2][1] = F  P[5][2][2] = F  P[5][2][3] = F  P[5][2][4] = F  P[5][2][5] = F
P[5][3][0] = F  P[5][3][1] = F  P[5][3][2] = F  P[5][3][3] = F  P[5][3][4] = F  P[5][3][5] = F
P[5][4][0] = F  P[5][4][1] = F  P[5][4][2] = F  P[5][4][3] = F  P[5][4][4] = F  P[5][4][5] = F
P[5][5][0] = F  P[5][5][1] = F  P[5][5][2] = F  P[5][5][3] = F  P[5][5][4] = F  P[5][5][5] = T

->测试销毁图： 成功！
演示结束，程序退出！

--------------------------------
Process exited with return value 0
Press any key to continue . . .

总结：
迪杰斯特拉算法求得的是单源最短路径，想得到所有顶点之间的最短路径只能一遍遍的循环去求。
弗洛伊德算法可以求得各顶点之间的最短路径，且形式更加优雅。

下次文章会介绍拓扑排序算法的实现。感谢大家一直以来的支持和关注。再见！

(王道408考研数据结构)第六章图-第四节4：最短路径之迪杰斯特拉算法（思想、代码、演示、答题规范）
快乐江湖的博客
11-25 2763
文章目录一：BFS算法局限性二：迪杰斯特拉(dijkstra)算法基本思想三：迪杰斯特拉(dijkstra)算法代码实现四：迪杰斯特拉(dijkstra)算法代码视频演示五：迪杰斯特拉(dijkstra)算法动画演示六：迪杰斯特拉(dijkstra)算法答题规范 最短路径shortestpath)：主要有以下两类最短路径问题 单源最短路径问题：一个顶点到其他顶点最短路径 迪杰斯特拉算法(dijkstra)（带权图、无权图）-本节讲解 BFS算法(无权图)–点击跳转 各顶点间最短路径问题：也即每一对顶点间
数据结构编程笔记二十二：第七章 图 拓扑排序算法的实现
u014576141的博客
09-04 2002
上次我们介绍了图的最短路径算法的实现，这次介绍基于邻接表的拓扑排序算法的实现。还是老规矩：程序在码云上可以下载。 地址：https://git.oschina.net/601345138/DataStructureCLanguage.git本次拓扑排序程序共用到以下源文件，有一些已经在之前的文章介绍过。还是和以前一样，所有源文件需要放在同一目录下编译。 my_constants.h 各种状态
数据结构-最短路径算法实现
11-18
数据结构中求最短路径的算法实现，用C++编写
[数据结构拾遗]图的最短路径算法
weixin_34284188的博客
04-21 538
前言 本专题旨在快速了解常见的数据结构和算法。 在需要使用到相应算法时，能够帮助你回忆出常用的实现方案并且知晓其优缺点和适用环境。并不涉及十分具体的实现细节描述。 图的最短路径算法 最短路径问题是图论研究中的一个经典算法问题，旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。 算法具体的形式包括： 确定起点的最短路径问题：即已知起始结点，求最短路径的问题。适合使用Dijkstra算法。 ...
数据结构——图的最短路径 dijkstra算法
daliucheng的博客
12-15 567
算法的思想如下： 规定一个 出发点，然后先初始化距离数组。数组中的每个下标就对应一个结点，每个数据项就是出发点到每个结点的距离。 1:将一个集合分为两部分，一个是已经找过的结点U，一个是没有找到过的v 2:在距离的数组中，没有访问过的结点中找一个权重最小的边，然后将这个结点添加到u中，并且以这个结点作为中间结点，来更新数组，判断条件是i到temp+temp到j 的距离是不是小于i到j的距离，若是，...
数据结构之图的最短路径的2种算法实现【附流程图&代码&运行结果】
米莱虾
04-14 6463
一、实验目的 1）理解图最短路径的意义和相应算法，熟悉最短路径的两种算法( Dijkstra 算法和 Floyd算法)的实现 。 2）熟练掌握带权图的存储结构和处理方法。 二、实验环境 1）自备计算机，windows操作系统以及相关的编译器（如Devc++）。 三、实验要求 1）完成带权图的存储和最短路径的生成。 2）熟练掌握并实现图的最短路径Dijkstra算法和Floyd算法及其应用。 四、实验原理 五、实验内容 代码如下： 1.用Dijkstra算法实现：
数据结构之图的最短路径算法
lifeiyi的博客
06-01 548
最短路径算法在生活中和学习中是非常常见的，下面我将用代码为大家展示： 上一个文章中介绍了头文件和存储结构的代码，链接如下：https://blog.youkuaiyun.com/lifeiyi/article/details/106482870 求最短路径： void Dijkstra(AMGraph G,int src,int des) { int tmp,k,vis[MVNum],dis[MVNum]; //memset(vis,0,sizeof vis); for(int i=0; i<G.vexnum;
【数据结构与算法基础】最短路径问题
热门推荐
wayne_lee_lwc的博客
11-25 1万+
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
数据结构编程笔记二十：第七章 图 最小生成树算法的实现
u014576141的博客
09-03 1049
上次我们介绍了图的邻接表存储结构基本操作的实现，这次介绍基于邻接矩阵的两种最小生成树算法的实现。还是老规矩：程序在码云上可以下载。 地址：https://git.oschina.net/601345138/DataStructureCLanguage.git最小生成树有两个经典的算法： 1.普里姆算法：主要是针对顶点操作，选最小邻接边组成生成树。 2.克鲁斯卡尔算法：主要针对边操作，所有边里
【数学建模】——【python】实现【最短路径】【最小生成树】【复杂网络分析】
最新发布
小李很执着的博客
07-24 2315
这三个问题分别涉及图论中的最短路径问题、最小生成树问题以及结合这两种方法的复杂网络分析。第一个问题使用Dijkstra算法计算并可视化了从一个指定城市到其他所有城市的最短路径，第二个问题使用Kruskal算法找到并绘制了一个无向带权图的最小生成树，第三个问题在最小生成树的基础上，使用Dijkstra算法计算并展示了从核心城市到其他所有城市的最短路径。每个问题都结合了图的构建、算法的应用和结果的可视化。
最短路径算法实现
11-20
最短路径算法 #ifndef _topo_h__ #define _topo_h__ ////////////////////////////////////////////////////////////////////////// #define MAXWEIGHT 1000000000 #define DIFFVAL(v1, v2) (((v1) > (v2))? (v1)-(v2) : (v2)-(v1)) #pragma warning(disable:4786) #include using namespace std; struct topo_node { union { struct { long x; long y; };
求最短路径的两种算法（C语言实现）
03-24
NULL 博文链接：https://touch-2011.iteye.com/blog/1076031
最短路径 ShortestPath_DIJ
07-17
最短路径 图 数据结构 Dijkstra算法
ShortestPath_DIJ.class
04-05
迪杰斯特拉解决最短路径。
数据结构之图 最短路径算法
chenxing12345678hhh的博客
05-29 440
最短路径：计算从Vi到Vj的权总和最小的路径 /** * 贪婪算法实现 * @author 陈鑫 * 有权无负值图最短路径算法 */ public class ShortestPath { static class Vertex{ public List<Vertex> adj;//邻接顶点集合 public Boolean known;//是否遍历过，防止有圈图 public Integer dist;//距离 public Vertex path;//路径
数据结构：最短路径的算法实现
sinb妃的博客
01-09 1235
题目： 利用狄克斯特拉（Dijkstra）算法求上图中0结点到其它结点的最短路径，算法实现代码必须有注释。 思路： 采用迪杰斯特拉算法 (1)初始时，S只包含起点vs；U包含除vs外的其他顶点，且U中顶点的距离为"起点vs到该顶点的距离"[例如，U中顶点v的距离为(vs,v)的长度，然后vs和v不相邻，则v的距离为∞]。 (2)从U中选出"距离最短的顶点k"，并将顶点k加入到S中；同时，从U中移除...
算法——数据结构图的最短路径实现JAVA代码
Avril的专栏
04-07 2427
图求最短路径的Floyd和Dijkstra算法JAVA代码实现
C++数据结构之图的最短路径——Dijkstra&Floyd(包含算法实现以及gif图示)
m0_56398315的博客
09-04 4868
本文包含了对最短路径以及相关概念的解释，以及Dijkstra和Floyd算法求最短路径的C++算法实现，并包含了gif演示和相关图示
数据结构与算法（图的最短路径与拓扑排序）
八归少年
02-21 689
首语 上一篇：数据结构与算法（图的遍历与最小生成树） 图的最短路径 从某顶点出发，沿图的边到达另一顶点所经过的路径中，各边上权值之和最小的一条路径叫做最短路径，解决最短路径通常有Dijkstra算法。 迪杰斯特拉算法(Dijkstra) 迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959 年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值