狄克斯特拉算法与贝尔曼—福德算法原来如此简单（C语言实现）

已于 2022-05-24 19:12:04 修改
阅读量456 收藏 1
点赞数 1
CC 4.0 BY-SA版权
文章标签： 算法 c语言 图论 数据结构 矩阵
于 2022-05-24 19:00:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/C_say_easy_to_me/article/details/124952031
本文详细介绍了图算法中的狄克斯特拉算法和贝尔曼—福德算法，用于求解最短路径问题。狄克斯特拉算法适用于无负边权的图，而贝尔曼—福德算法能够处理包含负边权的情况。代码示例展示了两种算法的实现，并提供了测试案例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录：

1.狄克特斯拉算法

2.贝尔曼—福德算法

3.测试案例

1.狄克特斯拉算法算法讲解

假设起点为顶点vs，由于vs=>vs距离为0，所欲dist[0]=0；

 dist[vs] = 0;

首先找到第一个vs能前往的最短距离，前往的点即为到达这个点的最短距离 （去往其他地方一定比这个距离长）

 // 寻找当前最小的路径；
 // 即，在未获取最短路径的顶点中，找到离vs最近的顶点(k)。
    min = INF;
        for (j = 0; j < G.vexnum; j++)
        {
            if (flag[j] == 0 && dist[j] < min)
            {
                min = dist[j];
                k = j;
            }
        }

对A点进行标记已经来过

     // 标记"顶点k"为已经获取到最短路径
        flag[k] = 1;

站在顶点k更新vs能够前往的地方及距离

    for (j = 0; j < G.vexnum; j++)//之前最短路径加最短路径顶点到这个顶点距离与起始点到这个顶点的距离比较
        {
            tmp = (G.matrix[k][j] == INF ? INF : (min + G.matrix[k][j])); // 防止溢出
            if (flag[j] == 0 && (tmp < dist[j]))
            {
                dist[j] = tmp;//到j点的最短距离
                prev[j] = k;//j的前驱顶点为k
            }
        }

狄克特斯拉算法代码：

void dijkstra(Graph G, int vs, int prev[], int dist[])
{
    int i, j, k;
    int min;
    int tmp;
    int flag[MAX];      // flag[i]=1表示"顶点vs"到"顶点i"的最短路径已成功获取。

    // 初始化
    for (i = 0; i < G.vexnum; i++)
    {
        flag[i] = 0;              // 顶点i的最短路径还没获取到。
        prev[i] = 0;              // 顶点i的前驱顶点为0。
        dist[i] = G.matrix[vs][i];// 顶点i的最短路径为"顶点vs"到"顶点i"的权。
    }

    // 对"顶点vs"自身进行初始化
    flag[vs] = 1;
    dist[vs] = 0;

    // 遍历G.vexnum-1次；每次找出一个顶点的最短路径。
    for (i = 1; i < G.vexnum; i++)
    {
        // 寻找当前最小的路径；
        // 即，在未获取最短路径的顶点中，找到离vs最近的顶点(k)。
        min = INF;
        for (j = 0; j < G.vexnum; j++)
        {
            if (flag[j] == 0 && dist[j] < min)
            {
                min = dist[j];
                k = j;
            }
        }
        // 标记"顶点k"为已经获取到最短路径
        flag[k] = 1;

        // 修正当前最短路径和前驱顶点
        // 即，当已经"顶点k的最短路径"之后，更新"未获取最短路径的顶点的最短路径和前驱顶点"。
        for (j = 0; j < G.vexnum; j++)//之前最短路径加最短路径顶点到这个顶点距离与起始点到这个顶点的距离比较
        {
            tmp = (G.matrix[k][j] == INF ? INF : (min + G.matrix[k][j])); // 防止溢出
            if (flag[j] == 0 && (tmp < dist[j]))
            {
                dist[j] = tmp;//到j点的最短距离
                prev[j] = k;//j的前驱顶点为k
            }
        }
    }

    // 打印dijkstra最短路径的结果
    printf("dijkstra(%c): \n", G.vexs[vs]);
    for (i = 0; i < G.vexnum; i++)
        printf("  shortest(%c, %c)=%d\n", G.vexs[vs], G.vexs[i], dist[i]);
}

2.贝尔曼—福德算法

使用原因：由于狄克斯特拉算法对负边权问题不能进行处理，于是便有了贝尔曼—福德算法，否定了狄克斯特拉获取最短路径后便对获取后的路线进行标记，不在进行改变，而一旦出现负数，便使得到达这条路径的最短距离有了更多的可能；；

算法思路：用自顶向下思考，如果到第n点距离要最短，而第n个点的距离为 dist[edge[j].end] =
dist[edge[j].start] +
edge[j].weight;，所以要第n-1个点距离最短，而第n-1个点距离最短则要n-2个的距离最短，以此类推，要求得到到达每个点的值最短，就要不断更新每一条边dist[edge[j].end]
= dist[edge[j].start] + edge[j].weight;，使得每一条边达到最短，于是便可得到到达该点的值最短。

 for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
        {
            if (dist[edge[j].end] > dist[edge[j].start] + edge[j].weight)
                dist[edge[j].end] = dist[edge[j].start] + edge[j].weight;
             prev[edge[j].end] = edge[j].start;//edge[j].end的前驱顶点为edge[j].start
        }
    }

贝尔曼—福德算法代码：

void befd(int n,int s,int dist[], int prev[], Graph G) {
    int i, j;
    for (i = 1; i <= n; i++) dist[i] = INF;//初始化
    dist[s] = 0;
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
        {
            if (dist[edge[j].end] > dist[edge[j].start] + edge[j].weight)
                dist[edge[j].end] = dist[edge[j].start] + edge[j].weight;
             prev[edge[j].end] = edge[j].start;//edge[j].end的前驱顶点为edge[j].start
        }
    }
    // 打印dijkstra最短路径的结果
    printf("dijkstra(%c): \n", G.vexs[s]);
    for (i = 0; i < G.vexnum; i++)
        printf("  shortest(%c, %c)=%d\n", G.vexs[s], G.vexs[i], dist[i]);
}

最全邻接矩阵路径代码：

/**
 * C: Dijkstra算法获取最短路径(邻接矩阵)
 *
 * @author skywang
 * @date 2014/04/24
 */

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#include<iostream>
using namespace std;
#define N 2010
#define MAX         100                 // 矩阵最大容量
#define INF         (~(0x1<<31))        // 最大值(即0X7FFFFFFF)
#define isLetter(a) ((((a)>='a')&&((a)<='z')) || (((a)>='A')&&((a)<='Z')))//字母判断
#define LENGTH(a)   (sizeof(a)/sizeof(a[0]))//数组长度

 // 邻接矩阵
typedef struct _graph
{
    char vexs[MAX];       // 顶点集合
    int vexnum;           // 顶点数
    int edgnum;           // 边数
    int matrix[MAX][MAX]; // 邻接矩阵
}Graph, * PGraph;

// 边的结构体
typedef struct _EdgeData
{
    char start; // 边的起点
    char end;   // 边的终点
    int weight; // 边的权重
}EData;
EData edge[MAX];//边的起 始点与权用于贝尔曼—福德算法
/*
 * 返回ch在matrix矩阵中的位置
 */
static int get_position(Graph G, char ch)
{
    int i;
    for (i = 0; i < G.vexnum; i++)
        if (G.vexs[i] == ch)
            return i;
    return -1;
}

/*
 * 读取一个输入字符
 */
static char read_char()
{
    char ch;

    do {
        ch = getchar();
    } while (!isLetter(ch));

    return ch;
}

/*
 * 创建图(自己输入)
 */
Graph* create_graph()
{
    char c1, c2;
    int v, e;
    int i, j, weight, p1, p2;
    Graph* pG;
   
    // 输入"顶点数"和"边数"
    printf("input vertex number: ");
    scanf("%d", &v);
    printf("input edge number: ");
    scanf("%d", &e);
    if (v < 1 || e < 1 || (e > (v * (v - 1))))
    {
        printf("input error: invalid parameters!\n");
        return NULL;
    }

    if ((pG = (Graph*)malloc(sizeof(Graph))) == NULL)
        return NULL;
    memset(pG, 0, sizeof(Graph));

    // 初始化"顶点数"和"边数"
    pG->vexnum = v;
    pG->edgnum = e;
    // 初始化"顶点"
    for (i = 0; i < pG->vexnum; i++)
    {
        printf("vertex(%d): ", i);
        pG->vexs[i] = read_char();
    }

    // 1. 初始化"边"的权值
    for (i = 0; i < pG->vexnum; i++)
    {
        for (j = 0; j < pG->vexnum; j++)
        {
            if (i == j)
                pG->matrix[i][j] = 0;
            else
                pG->matrix[i][j] = INF;
        }
    }
    // 2. 初始化"边"的权值: 根据用户的输入进行初始化
    for (i = 0; i < pG->edgnum; i++)
    {
        // 读取边的起始顶点，结束顶点，权值
        printf("edge(%d):", i);
        c1 = read_char();
        c2 = read_char();
        scanf("%d", &weight);

        p1 = get_position(*pG, c1);
        p2 = get_position(*pG, c2);
        if (p1 == -1 || p2 == -1)
        {
            printf("input error: invalid edge!\n");
            free(pG);
            return NULL;
        }
        edge[i].start = p1;
        edge[i].end = p2;
        edge[i].weight = weight;
        pG->matrix[p1][p2] = weight;
        pG->matrix[p2][p1] = weight;
    }

    return pG;
}

/*
 * 创建图(用已提供的矩阵)
 */
Graph* create_example_graph()
{
    char vexs[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
    int matrix[][9] = {
        /*A*//*B*//*C*//*D*//*E*//*F*//*G*/
        /*A*/ {   0,  12, INF, INF, INF,  16,  14},
        /*B*/ {  12,   0,  10, INF, INF,   7, INF},
        /*C*/ { INF,  10,   0,   3,   5,   6, INF},
        /*D*/ { INF, INF,   3,   0,   4, INF, INF},
        /*E*/ { INF, INF,   5,   4,   0,   2,   8},
        /*F*/ {  16,   7,   6, INF,   2,   0,   9},
        /*G*/ {  14, INF, INF, INF,   8,   9,   0} };
    int vlen = LENGTH(vexs);//定义长度
    int i, j;
    Graph* pG;

    // 输入"顶点数"和"边数"
    if ((pG = (Graph*)malloc(sizeof(Graph))) == NULL)
        return NULL;
    memset(pG, 0, sizeof(Graph));//初始化邻接矩阵

    // 初始化"顶点数"
    pG->vexnum = vlen;
    // 初始化"顶点"
    for (i = 0; i < pG->vexnum; i++)
        pG->vexs[i] = vexs[i];

    // 初始化"边"
    for (i = 0; i < pG->vexnum; i++)
        for (j = 0; j < pG->vexnum; j++)
            pG->matrix[i][j] = matrix[i][j];

    // 统计边的数目
    for (i = 0; i < pG->vexnum; i++)
        for (j = 0; j < pG->vexnum; j++)
            if (i != j && pG->matrix[i][j] != INF)
                pG->edgnum++;
    pG->edgnum /= 2;

    return pG;
}

/*
 * 返回顶点v的第一个邻接顶点的索引，失败则返回-1
 */
static int first_vertex(Graph G, int v)
{
    int i;

    if (v<0 || v>(G.vexnum - 1))
        return -1;

    for (i = 0; i < G.vexnum; i++)
        if (G.matrix[v][i] != 0 && G.matrix[v][i] != INF)
            return i;

    return -1;
}

/*
 * 返回顶点v相对于w的下一个邻接顶点的索引，失败则返回-1
 */
static int next_vertix(Graph G, int v, int w)
{
    int i;

    if (v<0 || v>(G.vexnum - 1) || w<0 || w>(G.vexnum - 1))
        return -1;

    for (i = w + 1; i < G.vexnum; i++)
        if (G.matrix[v][i] != 0 && G.matrix[v][i] != INF)
            return i;

    return -1;
}

/*
 * 深度优先搜索遍历图的递归实现
 */
static void DFS(Graph G, int i, int* visited)
{
    int w;

    visited[i] = 1;//拜访置1
    printf("%c ", G.vexs[i]);
    // 遍历该顶点的所有邻接顶点。若是没有访问过，那么继续往下走
    for (w = first_vertex(G, i); w >= 0; w = next_vertix(G, i, w))
    {
        if (!visited[w])
            DFS(G, w, visited);
    }

}

/*
 * 深度优先搜索遍历图
 */
void DFSTraverse(Graph G)
{
    int i;
    int visited[MAX];       // 顶点访问标记

    // 初始化所有顶点都没有被访问
    for (i = 0; i < G.vexnum; i++)
        visited[i] = 0;

    printf("DFS: ");
    for (i = 0; i < G.vexnum; i++)
    {
        //printf("\n== LOOP(%d)\n", i);
        if (!visited[i])//未被访问则调用
            DFS(G, i, visited);
    }
    printf("\n");
}

/*
 * 广度优先搜索（类似于树的层次遍历）
 */
void BFS(Graph G)
{
    int head = 0;
    int rear = 0;
    int queue[MAX];     // 辅组队列
    int visited[MAX];   // 顶点访问标记
    int i, j, k;
        /*访问初始化*/
    for (i = 0; i < G.vexnum; i++)
        visited[i] = 0;

    printf("BFS: ");
    for (i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
        {
            visited[i] = 1;
            printf("%c ", G.vexs[i]);
            queue[rear++] = i;  // 入队列
        }
        while (head != rear)
        {
            j = queue[head++];  // 出队列
            for (k = first_vertex(G, j); k >= 0; k = next_vertix(G, j, k)) //k是为访问的邻接顶点
            {
                if (!visited[k])
                {
                    visited[k] = 1;
                    printf("%c ", G.vexs[k]);
                    queue[rear++] = k;
                }
            }
        }
    }
    printf("\n");
}

/*
 * 打印矩阵队列图
 */
void print_graph(Graph G)
{
    int i, j;

    printf("Martix Graph:\n");
    for (i = 0; i < G.vexnum; i++)
    {
        for (j = 0; j < G.vexnum; j++)
            printf("%10d ", G.matrix[i][j]);
        printf("\n");
    }
}

/*
 * prim最小生成树
 *
 * 参数说明：
 *       G -- 邻接矩阵图
 *   start -- 从图中的第start个元素开始，生成最小树
 */
void prim(Graph G, int start)
{
    int min, i, j, k, m, n, sum;
    int index = 0;         // prim最小树的索引，即prims数组的索引
    char prims[MAX];     // prim最小树的结果数组
    int weights[MAX];    // 顶点间边的权值

    // prim最小生成树中第一个数是"图中第start个顶点"，因为是从start开始的。
    prims[index++] = G.vexs[start];

    // 初始化"顶点的权值数组"，
    // 将每个顶点的权值初始化为"第start个顶点"到"该顶点"的权值。
    for (i = 0; i < G.vexnum; i++)
        weights[i] = G.matrix[start][i];
    // 将第start个顶点的权值初始化为0。
    // 可以理解为"第start个顶点到它自身的距离为0"。
    weights[start] = 0;

    for (i = 0; i < G.vexnum; i++)
    {
        // 由于从start开始的，因此不需要再对第start个顶点进行处理。
        if (start == i)
            continue;

        j = 0;
        k = 0;
        min = INF;
        // 在未被加入到最小生成树的顶点中，找出权值最小的顶点。
        while (j < G.vexnum)
        {
            // 若weights[j]=0，意味着"第j个节点已经被排序过"(或者说已经加入了最小生成树中)。
            if (weights[j] != 0 && weights[j] < min)
            {
                min = weights[j];
                k = j;
            }
            j++;
        }

        // 经过上面的处理后，在未被加入到最小生成树的顶点中，权值最小的顶点是第k个顶点。
        // 将第k个顶点加入到最小生成树的结果数组中
        prims[index++] = G.vexs[k];
        // 将"第k个顶点的权值"标记为0，意味着第k个顶点已经排序过了(或者说已经加入了最小树结果中)。
        weights[k] = 0;
        // 当第k个顶点被加入到最小生成树的结果数组中之后，更新其它顶点的权值。
        for (j = 0; j < G.vexnum; j++)
        {
            // 当第j个节点没有被处理，并且需要更新时才被更新。
            if (weights[j] != 0 && G.matrix[k][j] < weights[j])
                weights[j] = G.matrix[k][j];
        }
    }

    // 计算最小生成树的权值
    sum = 0;
    for (i = 1; i < index; i++)
    {
        min = INF;
        // 获取prims[i]在G中的位置
        n = get_position(G, prims[i]);
        // 在vexs[0...i]中，找出到j的权值最小的顶点。
        for (j = 0; j < i; j++)
        {
            m = get_position(G, prims[j]);
            if (G.matrix[m][n] < min)
                min = G.matrix[m][n];
        }
        sum += min;
    }
    // 打印最小生成树
    printf("PRIM(%c)=%d: ", G.vexs[start], sum);
    for (i = 0; i < index; i++)
        printf("%c ", prims[i]);
    printf("\n");
}

/*
 * 获取图中的边
 */
EData* get_edges(Graph G)
{
    int i, j;
    int index = 0;
    EData* edges;

    edges = (EData*)malloc(G.edgnum * sizeof(EData));
    for (i = 0; i < G.vexnum; i++)
    {
        for (j = i + 1; j < G.vexnum; j++)
        {
            if (G.matrix[i][j] != INF)
            {
                edges[index].start = G.vexs[i];
                edges[index].end = G.vexs[j];
                edges[index].weight = G.matrix[i][j];
                index++;
            }
        }
    }

    return edges;
}

/*
 * 对边按照权值大小进行排序(由小到大)
 */
void sorted_edges(EData* edges, int elen)
{
    int i, j;

    for (i = 0; i < elen; i++)
    {
        for (j = i + 1; j < elen; j++)
        {
            if (edges[i].weight > edges[j].weight)
            {
                // 交换"第i条边"和"第j条边"
                EData tmp = edges[i];
                edges[i] = edges[j];
                edges[j] = tmp;
            }
        }
    }
}

/*
 * 获取i的终点
 */
int get_end(int vends[], int i)
{
    while (vends[i] != 0)
        i = vends[i];
    return i;
}

/*
 * 克鲁斯卡尔（Kruskal)最小生成树
 */
void kruskal(Graph G)
{
    int i, m, n, p1, p2;
    int length;
    int index = 0;          // rets数组的索引
    int vends[MAX] = { 0 };     // 用于保存"已有最小生成树"中每个顶点在该最小树中的终点。
    EData rets[MAX];        // 结果数组，保存kruskal最小生成树的边
    EData* edges;           // 图对应的所有边

    // 获取"图中所有的边"
    edges = get_edges(G);
    // 将边按照"权"的大小进行排序(从小到大)
    sorted_edges(edges, G.edgnum);

    for (i = 0; i < G.edgnum; i++)
    {
        p1 = get_position(G, edges[i].start);   // 获取第i条边的"起点"的序号
        p2 = get_position(G, edges[i].end);     // 获取第i条边的"终点"的序号

        m = get_end(vends, p1);                 // 获取p1在"已有的最小生成树"中的终点
        n = get_end(vends, p2);                 // 获取p2在"已有的最小生成树"中的终点
        // 如果m!=n，意味着"边i"与"已经添加到最小生成树中的顶点"没有形成环路
        if (m != n)
        {
            vends[m] = n;                       // 设置m在"已有的最小生成树"中的终点为n
            rets[index++] = edges[i];           // 保存结果
        }
    }
    free(edges);

    // 统计并打印"kruskal最小生成树"的信息
    length = 0;
    for (i = 0; i < index; i++)
        length += rets[i].weight;
    printf("Kruskal=%d: ", length);
    for (i = 0; i < index; i++)
        printf("(%c,%c) ", rets[i].start, rets[i].end);
    printf("\n");
}
int edgetest(Graph G) {
    for (int i = 0; i < G.edgnum; i++)
        if (edge[i].weight >= 0);
        else return 1;
    return 0;
}
/*
 * Dijkstra最短路径。
 * 即，统计图(G)中"顶点vs"到其它各个顶点的最短路径。
 *
 * 参数说明：
 *        G -- 图
 *       vs -- 起始顶点(start vertex)。即计算"顶点vs"到其它顶点的最短路径。
 *     prev -- 前驱顶点数组。即，prev[i]的值是"顶点vs"到"顶点i"的最短路径所经历的全部顶点中，位于"顶点i"之前的那个顶点。
 *     dist -- 长度数组。即，dist[i]是"顶点vs"到"顶点i"的最短路径的长度。
 */
void dijkstra(Graph G, int vs, int prev[], int dist[])
{
    int i, j, k;
    int min;
    int tmp;
    int flag[MAX];      // flag[i]=1表示"顶点vs"到"顶点i"的最短路径已成功获取。

    // 初始化
    for (i = 0; i < G.vexnum; i++)
    {
        flag[i] = 0;              // 顶点i的最短路径还没获取到。
        prev[i] = 0;              // 顶点i的前驱顶点为0。
        dist[i] = G.matrix[vs][i];// 顶点i的最短路径为"顶点vs"到"顶点i"的权。
    }

    // 对"顶点vs"自身进行初始化
    flag[vs] = 1;
    dist[vs] = 0;

    // 遍历G.vexnum-1次；每次找出一个顶点的最短路径。
    for (i = 1; i < G.vexnum; i++)
    {
        // 寻找当前最小的路径；
        // 即，在未获取最短路径的顶点中，找到离vs最近的顶点(k)。
        min = INF;
        for (j = 0; j < G.vexnum; j++)
        {
            if (flag[j] == 0 && dist[j] < min)
            {
                min = dist[j];
                k = j;
            }
        }
        // 标记"顶点k"为已经获取到最短路径
        flag[k] = 1;

        // 修正当前最短路径和前驱顶点
        // 即，当已经"顶点k的最短路径"之后，更新"未获取最短路径的顶点的最短路径和前驱顶点"。
        for (j = 0; j < G.vexnum; j++)//之前最短路径加最短路径顶点到这个顶点距离与起始点到这个顶点的距离比较
        {
            tmp = (G.matrix[k][j] == INF ? INF : (min + G.matrix[k][j])); // 防止溢出
            if (flag[j] == 0 && (tmp < dist[j]))
            {
                dist[j] = tmp;//到j点的最短距离
                prev[j] = k;//j的前驱顶点为k
            }
        }
    }

    // 打印dijkstra最短路径的结果
    printf("dijkstra(%c): \n", G.vexs[vs]);
    for (i = 0; i < G.vexnum; i++)
        printf("  shortest(%c, %c)=%d\n", G.vexs[vs], G.vexs[i], dist[i]);
}

void befd(int n,int s,int dist[], int prev[], Graph G) {
    int i, j;
    for (i = 1; i <= n; i++) dist[i] = INF;//初始化
    dist[s] = 0;
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
        {
            if (dist[edge[j].end] > dist[edge[j].start] + edge[j].weight)
                dist[edge[j].end] = dist[edge[j].start] + edge[j].weight;
             prev[edge[j].end] = edge[j].start;//edge[j].end的前驱顶点为edge[j].start
        }
    }
    // 打印dijkstra最短路径的结果
    printf("dijkstra(%c): \n", G.vexs[s]);
    for (i = 0; i < G.vexnum; i++)
        printf("  shortest(%c, %c)=%d\n", G.vexs[s], G.vexs[i], dist[i]);
}

int main()
{
    int prev[MAX] = { 0 };
    int dist[MAX] = { 0 };
    int test;
    Graph* pG;

    // 自定义"图"(输入矩阵队列)
    pG = create_graph();
    // 采用已有的"图"
    //pG = create_example_graph();\

   
    //print_graph(*pG);       // 打印图
    //DFSTraverse(*pG);       // 深度优先遍历 遍历每一个点的路径
    //BFS(*pG);               // 广度优先遍历
    //prim(*pG, 0);           // prim算法生成最小生成树
    //kruskal(*pG);           // kruskal算法生成最小生成树
    test = edgetest(*pG);
   
    if (test == 0) { //测试是否有负边权
        // dijkstra算法获取"第4个顶点"到其它各个顶点的最短距离
        dijkstra(*pG, 0, prev, dist);
    }
        // 贝尔曼—福德算法处理负边权问题
    else befd(pG->vexnum, 1, dist, prev, *pG);
   
    return 0;
}

3.测试案例：

注意：源码中进行了边权测试，会对不同边权进行选择算法；

请添加图片描述
负边权测试
在这里插入图片描述
请添加图片描述

环测试
带有环
借鉴：
1.https://github.com/wangkuiwu/datastructs_and_algorithm/blob/br07_graph_10_topsort_pic/source/graph/dijkstra/udg/c/list_udg.c
2.https://www.cnblogs.com/skywang12345/p/3711512.html#anchor2

数据结构之---C语言实现最短路径之Dijkstra（迪杰斯特拉）算法
杨鑫newlife的专栏
08-18 3万+
数据结构之---C语言实现最短路径之Dijkstra（迪杰斯特拉）算法
C语言实现最短路径Dijkstra算法(含源码)
最新发布
BitLordX的博客
08-24 863
在主函数中，我们构造了一个包含9个节点的有向带权图，并指定源节点为节点0。在本文中，我们介绍了如何使用C语言实现Dijkstra算法来寻找有向带权图中两个节点之间的最短路径。（4）对于每个节点，遍历其所有邻居节点，计算其距离加上当前节点距离形成的总距离。如果该距离比该邻居节点的最短距离小，则更新该节点的最短距离和前驱节点。（5）将具有最小距离的节点添加到最短路径集合中，并继续执行步骤（4）直到所有节点都被添加到最短路径集合中。（3）对于其余的所有节点，将其最短距离初始化为一个很大的数，表示尚未到达该节点。
最短路径之Dijkstra算法 C语言实现
热门推荐
zhencan的博客
03-14 4万+
Dijkstra算法（单源点路径算法，要求：图中不存在负权值边）： 步骤： a.  初始时，S只包含源点，即S＝{v}，v的距离为0。U包含除v外的其他顶点，即: U={其余顶点}，若v与U中顶点u有边，则u的距离设置为相应的权值，若u v之间不存在边，则        设置u的距离为无穷大。 b.  从U中选取一个距离 v 最小的顶点k，把k，加入S中（该选定的距离就是v到k的
最短路径 Dijkstra算法C语言实现
11-13
本设计以VC++6.0作为程序开发环境，C语言作为程序开发语言，详细介绍了最短路径的求解算法及其C语言实现过程。系统主要实现了图的创建、单源点最短路径的计算功能。依照本系统可以解决实际生活中许多路径选择问题，比如交通旅游、城市规划以及电网架设等等。系统性能稳定，适应性强，界面清晰，操作简单，适合用户使用。 课程设计要求： 最短路径问题已经被应用到GIS、GPS等信息管理系统中，为人们生活带来了很大便利。它属于图结构问题，其解决方法也有不少（如Dijkstra、 A-star）。单源点最短路径问题解决的是既定起点的情况下，寻求该点到图中其它顶点的最短路径。请用C/C++语言的结构体、指针、数据结构等基础知识，编写程序实现图的结构定义、图的存储，以及求解单源点最短路径。
c语言-最短路径算法
huangmingcsdn的博客
08-15 910
c语言最短路径算法
狄克斯特拉算法
12-21
1、引入 上篇博文中讲述了广度优先搜索的算法，主要解决是否...边的权重为负数的可以参考：贝尔曼-福德算法（Bellman-Ford algorithm）。 名词解释： 最短路径：指的并不一定是物理物理，也可能是让某种度量指标最小
最短路径（C语言实现）
Li_YYang的博客
02-23 1665
Dijkstra最短路径算法(C语言）
最短路径(C语言实现)
qq_42453280的博客
05-07 1万+
Dijkstra算法具体步骤： （1）初始时，S集合只包含源点(S={v})，U集合包含剩余的点，源点v到自己的距离为0，到其他顶点的距离均为无穷大(表示不可达)，以此更新dist[]数组，除dist[v]=0之外，其余全为无穷大； （2）在dist[]数组中，找到目前在U集合中且使得源点v到其距离最小的顶点k，将该顶点加入U集合，并作为新的源点； （3）根据新源点k，更新该源点到其他顶点的最小距...
C语言实现最短路径
daqiangdetianxia的博客
05-25 5138
一：实验目的 (1)最短路径求解实验帮助学生熟练掌握图的顶点、边的概念及其存储实现。 (2)掌握图的基本运算，以及利用图解决实际问题的基本方法。 二：实验内容 （1）图的存储表示：输入图的顶点和图的边。并转换为图的存储结构表示。 （2）求解从一个城市出发到另一个城市的最短路径 三：实验要求 （1）根据实验内容编写程序，上机调试并获得运行结果。 （2）撰写实验报告。 四：程序清单、调试和测试结果及分析 //最短路径 //有向图的网络存储结构， //校园导航 //(1)计算出给定起点到终点之间的最短距离
C语言-最短路径（Dijskra算法）
Attract's Blog
06-18 1万+
1. 顶点下标查找函数（LocateVex） 2. 创建有向网（CreateDN） 3. 打印图函数（print） 4. 展示最短路径函数（displayPath） 5. 查找当前最短路径函数（FindMinDist） 6. 迪杰斯特拉算法（ShortestPath_Dijkstra）
Dijkstra最短路径算法（C语言实现）
07-09
输入各结点构成的邻接矩阵及开始结点，计算出该节点到其他各节点之间的最短距离。也可计算某一开始结点到指定结点的最短距离。
C语言编写最短路径算法（含迪杰斯特拉、弗洛伊德）
04-26
这个ZIP包含了最短路径算法中两个经典的算法（迪杰斯特拉和弗洛伊德），这个是我在大一的时候写的程序设计课程的作业之一。有需要的小伙伴可以下载学习。
c语言寻找最短路径算法
05-27
能够根据输入的个点之间的路径找到从各点之间的最短路径消耗
用C语言写的简洁的Dijkstra最短路径算法程序
07-10
本程序使用c语言编写，主要实现最短路径问题的Dijkstra算法。
C语言实现数据结构 最短路径
05-08
C语言实现数据结构 最短路径C语言实现数据结构 最短路径
C语言实现最短路径问题(Floyd算法)
weixin_45883188的博客
08-09 1527
本文收此文章启发：弗洛伊德算法 需要注意三点 ①三个循环的意义，最外层i是中转结点，然后内层是求第j个结点通过ii结点做中转到第k个结点的最短路径 ②路径的存储，注意更新的时候需要的是j->i的路径 ③一开始要给有边的路径设置名字 PS：如果自己有到自己的路径 设置的输出为路径的值，但课本输出0 测试图片： 文件内容： 在这里插入代码片 输出结果： 代码： /* 实现内容：Floyd算法 VS2019 编译通过 王大花 2020.8.9 */ #define _CRT_SECURE_NO_W
用C语言编程最短路径,C语言实现图的最短路径Floyd算法
weixin_30803379的博客
05-18 1507
C语言实现图的最短路径Floyd算法发布时间：2020-10-07 10:51:10来源：脚本之家阅读：64作者：KittyGirllllFloyd算法直接使用二维数组求出所有顶点到所有顶点的最短路径。D代表顶点到顶点的最短路径权值和的矩阵。P代表对应顶点的最小路径的前驱矩阵。以下程序在DEV C++中调试运行通过。#include #define INFINITY 65535typedef in...
c语言有向图最短路径算法,图中最短路径的算法--dijiska算法C语言实现
weixin_39881167的博客
05-23 1277
1 #include 2 #include 34 #define ERROR_NO_MEM -1 /*内存不足的错误码*/56 #define MAX_POINT_NUM 5 /*最大的点数*/7 #define MAX_EDGE_NUM 7 /*最多的边数*/89 #define MAX_VALUE 0xfffffff /*最大路径长度*/1011 /*表示每个结点的信...
C语言-最短路径
printfxgd的博客
06-24 2万+
最短路径可以是用广度或深度搜索直接暴力破解（不断的重复比较更新），时间复杂的为(n*n)，时间复杂度的降低方面有好几种方法，在这里简要介绍两种算法。 主要思想：a顶点到b顶点之间的最短距离可以查找是否有c顶点使距离缩小。 参数说明：二维数组e[a][b]，存储顶点与边之间的关系，表示a点到b点的距离为e[a][b],inf表示无法直接到达   1.Floyd-Warshall法较好理解 ...
狄克斯特拉算法可视化实现，课程设计报告佳作
综上所述，狄克斯特拉算法的可视化涵盖了图论、数据结构、算法设计和用户界面等多个方面的知识，是计算机科学与技术教学中的一个重要组成部分。通过使用这样的可视化工具，学生和开发者可以更直观地理解算法的工作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

入世浮尘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值