Dijkstra最短路径算法(针对加权有向图)

最新推荐文章于 2023-04-21 16:52:57 发布
最新推荐文章于 2023-04-21 16:52:57 发布
阅读量5.2k 收藏 6
点赞数
分类专栏： 算法学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liujianfeng1984/article/details/48177245
版权

indexMinPQ.h

#ifndef _INDEX_MIN_PQ_H_
#define _INDEX_MIN_PQ_H_

#define INDEX_MIN_PQ_TEST  0

typedef struct
{
    int     index;
    double  cmpNum;
} INDEX_MIN_PQ_DATA;

typedef struct
{
    int                 n;
    int                 maxN;
    INDEX_MIN_PQ_DATA*  data;
} INDEX_MIN_PQ;

void  indexMinPQInit(INDEX_MIN_PQ* pIndexMinPQ, int maxN);
void  indexMinPQUninit(INDEX_MIN_PQ* pIndexMinPQ);
int   indexMinPQInert(INDEX_MIN_PQ* pIndexMinPQ, int index, double cmpNum);
int   indexMinPQDelMin(INDEX_MIN_PQ* pIndexMinPQ);
int   indexMinPQIsEmpty(INDEX_MIN_PQ* pIndexMinPQ);
int   indexMinPQContains(INDEX_MIN_PQ* pIndexMinPQ, int index);
int   indexMinPQChange(INDEX_MIN_PQ* pIndexMinPQ, int index, double cmpNum);

#endif

indexMinPQ.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "indexMinPQ.h"

//最小优先队列初始化
void  indexMinPQInit(INDEX_MIN_PQ* pIndexMinPQ, int maxN)
{
    if ( pIndexMinPQ == NULL )
    {
        return; 
    }

    pIndexMinPQ->data = (INDEX_MIN_PQ_DATA *)malloc(sizeof(INDEX_MIN_PQ_DATA) * maxN);
    if ( pIndexMinPQ->data == NULL )
    {
        printf("failed to malloc\r\n");
        return; 
    }

    pIndexMinPQ->maxN = maxN;
    pIndexMinPQ->n = 0;
}

//最小优先队列去初始化
void  indexMinPQUninit(INDEX_MIN_PQ* pIndexMinPQ)
{
    if ( pIndexMinPQ == NULL )
    {
        return; 
    }

    if ( pIndexMinPQ->data != NULL )
    {
        free(pIndexMinPQ->data); 
        pIndexMinPQ->data = NULL;
    }

    memset(pIndexMinPQ, 0, sizeof(INDEX_MIN_PQ));
}

//最小优先队列的元素比较，是否小于
static int indexMinPQisLess(INDEX_MIN_PQ* pIndexMinPQ, int x, int y)
{
    if ( pIndexMinPQ == NULL )
    {
        return 0; 
    }

    return pIndexMinPQ->data[x].cmpNum < pIndexMinPQ->data[y].cmpNum;
}

//最小优先队列的元素交换
static void indexMinPQExchange(INDEX_MIN_PQ* pIndexMinPQ, int x, int y)
{
    INDEX_MIN_PQ_DATA tmpData = {0};

    if ( pIndexMinPQ == NULL )
    {
        return; 
    }

    tmpData.index = pIndexMinPQ->data[x].index;
    tmpData.cmpNum = pIndexMinPQ->data[x].cmpNum;

    pIndexMinPQ->data[x].index = pIndexMinPQ->data[y].index;
    pIndexMinPQ->data[x].cmpNum = pIndexMinPQ->data[y].cmpNum;

    pIndexMinPQ->data[y].index = tmpData.index;
    pIndexMinPQ->data[y].cmpNum = tmpData.cmpNum;
}

//最小优先队列指定索引的上升有序化
static void indexMinPQSwim(INDEX_MIN_PQ* pIndexMinPQ, int k)
{
    while ( k > 1 && indexMinPQisLess(pIndexMinPQ, k, k/2) )
    {
        indexMinPQExchange(pIndexMinPQ, k/2, k);
        k = k/2;
    }
}

//最小优先队列指定索引的下沉有序化
static void indexMinPQSink(INDEX_MIN_PQ* pIndexMinPQ, int k)
{
    while ( (k*2) <= pIndexMinPQ->n )
    {
        void* tmp = NULL;
        int j = k * 2;

        //如果存在右孩子，则先找出两个孩子之间的最小值
        if ( (j < pIndexMinPQ->n) && indexMinPQisLess(pIndexMinPQ, j+1, j) )
        { 
            j++;
        }

        //之后在比较当前父亲与最小的孩子之间的最小值
        if ( !indexMinPQisLess(pIndexMinPQ, j, k) )
        {
            break; 
        }

        indexMinPQExchange(pIndexMinPQ, k, j);

        k = j;
    }
}

//向最小优先队列中插入元素
//1、首先将元素插入到堆末尾
//2、之后比较新的元素是否小于父元素，如果小于，则不断进行上浮处理，直到孩子不再小于
//   父亲为止，或者已经上俘到最顶端。
int indexMinPQInert(INDEX_MIN_PQ* pIndexMinPQ, int index, double cmpNum)
{
    if ( pIndexMinPQ->n >= pIndexMinPQ->maxN )
    {
        printf("already full.\r\n"); 
        return -1;
    }

    //数组索引0没有使用，直接从1开始，主要是
    //方便计算孩子、父亲索引之间的关系
    pIndexMinPQ->n++;
    pIndexMinPQ->data[pIndexMinPQ->n].index = index;
    pIndexMinPQ->data[pIndexMinPQ->n].cmpNum = cmpNum;

    indexMinPQSwim(pIndexMinPQ, pIndexMinPQ->n);

    return 0;
}

//删除最小优先队列的最小值
//1、头部的最小值取出后，将尾部的元素填充到头部
//2、进行尾部复位，及减小总元素个数
//3、对头部元素进行下降处理
int indexMinPQDelMin(INDEX_MIN_PQ* pIndexMinPQ)
{
    int retIndex = -1;

    if ( indexMinPQIsEmpty(pIndexMinPQ) )
    {
        printf("already empty.\r\n");
        return -1; 
    }

    //数组索引0没有使用，直接从1开始，主要是
    //方便计算孩子、父亲索引之间的关系
    retIndex = pIndexMinPQ->data[1].index; 
    indexMinPQExchange(pIndexMinPQ, 1, pIndexMinPQ->n);

    pIndexMinPQ->n--;

    indexMinPQSink(pIndexMinPQ, 1);

    return retIndex;
}

//检查最小优先队列是否为空
int indexMinPQIsEmpty(INDEX_MIN_PQ* pIndexMinPQ)
{
    if ( pIndexMinPQ == NULL )
    {
        return 1; 
    }

    return pIndexMinPQ->n <= 0;
}

//查找匹配最小优先队列数据index的数组索引
static int indexMinPQGetDataArrayIndex(INDEX_MIN_PQ* pIndexMinPQ, int index)
{
    int i = 0;

    if ( pIndexMinPQ == NULL )
    {
        return 0; 
    }

    //数组索引0没有使用，直接从1开始，主要是
    //方便计算孩子、父亲索引之间的关系
    for ( i = 1; i <= pIndexMinPQ->n; i++ )
    {
        if ( pIndexMinPQ->data[i].index == index ) 
        {
            return i; 
        }
    }

    return 0;
}

//检查最小优先队列是否含有该数据index
int indexMinPQContains(INDEX_MIN_PQ* pIndexMinPQ, int index)
{
    return indexMinPQGetDataArrayIndex(pIndexMinPQ, index) > 0;
}

//最小优先队列中指定数据的比较值进行了更改
int indexMinPQChange(INDEX_MIN_PQ* pIndexMinPQ, int index, double cmpNum)
{
    int dataArrayIndex = -1;

    if ( pIndexMinPQ == NULL )
    {
        return -1; 
    }

    dataArrayIndex = indexMinPQGetDataArrayIndex(pIndexMinPQ, index);
    if ( dataArrayIndex == 0 )
    {
        return -1; 
    }

    if ( cmpNum > pIndexMinPQ->data[dataArrayIndex].cmpNum )
    {
        pIndexMinPQ->data[dataArrayIndex].cmpNum = cmpNum;
        indexMinPQSink(pIndexMinPQ, dataArrayIndex);
    }
    else if ( cmpNum < pIndexMinPQ->data[dataArrayIndex].cmpNum )
    {
        pIndexMinPQ->data[dataArrayIndex].cmpNum = cmpNum;
        indexMinPQSwim(pIndexMinPQ, dataArrayIndex);
    }
    
    return 0;
}

#if INDEX_MIN_PQ_TEST
int main()
{
    INDEX_MIN_PQ indexMinPQObj = {0};

    indexMinPQInit(&indexMinPQObj, 10);

    indexMinPQInert(&indexMinPQObj, 0, 1.4);
    indexMinPQInert(&indexMinPQObj, 1, 5.9);
    indexMinPQInert(&indexMinPQObj, 2, 2.8);
    indexMinPQInert(&indexMinPQObj, 3, 7.1);
    indexMinPQInert(&indexMinPQObj, 4, 9.4);
    indexMinPQInert(&indexMinPQObj, 5, 2.2);
    indexMinPQInert(&indexMinPQObj, 6, 5.2);
    indexMinPQInert(&indexMinPQObj, 7, 1.6);
    indexMinPQInert(&indexMinPQObj, 8, 6.3);

    printf("have index %d : %s\r\n", 8, \
            indexMinPQContains(&indexMinPQObj, 8) ? "TRUE" : "FALSE");
    printf("have index %d : %s\r\n", 9, \
            indexMinPQContains(&indexMinPQObj, 9) ? "TRUE" : "FALSE");

    indexMinPQChange(&indexMinPQObj, 3, 0.4);
    indexMinPQChange(&indexMinPQObj, 6, 6.6);

    printf("[0] delete index %d.\r\n", indexMinPQDelMin(&indexMinPQObj));
    printf("[1] delete index %d.\r\n", indexMinPQDelMin(&indexMinPQObj));
    printf("[2] delete index %d.\r\n", indexMinPQDelMin(&indexMinPQObj));
    printf("[3] delete index %d.\r\n", indexMinPQDelMin(&indexMinPQObj));
    printf("[4] delete index %d.\r\n", indexMinPQDelMin(&indexMinPQObj));
    printf("[5] delete index %d.\r\n", indexMinPQDelMin(&indexMinPQObj));
    printf("[6] delete index %d.\r\n", indexMinPQDelMin(&indexMinPQObj));
    printf("[7] delete index %d.\r\n", indexMinPQDelMin(&indexMinPQObj));
    printf("[8] delete index %d.\r\n", indexMinPQDelMin(&indexMinPQObj));
    printf("[9] delete index %d.\r\n", indexMinPQDelMin(&indexMinPQObj));

    indexMinPQUninit(&indexMinPQObj);

    return 0;
}
#endif

directedEdge.h

#ifndef _DIRECTED_EDGE_H_
#define _DIRECTED_EDGE_H_

#define DIRECTED_EDGE_TEST  0

typedef struct
{
    int     from;       //加权有向边的一个顶点
    int     to;         //加权有向边的另一个顶点
    double  weight;     //加权有向边的权重
} DIRECTED_EDGE;

void    directedEdgeInit(DIRECTED_EDGE* pDiedge, int v, int w, double weight);
int     directedEdgeGetFrom(DIRECTED_EDGE* pDiedge);
int     directedEdgeGetTo(DIRECTED_EDGE* pDiedge);
int     directedEdgeIsValid(DIRECTED_EDGE* pDiedge);
double  directedEdgeGetWeight(DIRECTED_EDGE* pDiedge);
void    directedEdgeDump(DIRECTED_EDGE* pDiedge);

#endif

directedEdge.c

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

//加权有向边初始化
void directedEdgeInit(DIRECTED_EDGE* pDiedge, int v, int w, double weight)
{
    if ( pDiedge == NULL )
    {
        return; 
    }

    pDiedge->from = v;
    pDiedge->to = w;
    pDiedge->weight = weight;
}

//获取加权有向边的起始点
int directedEdgeGetFrom(DIRECTED_EDGE* pDiedge)
{
    if ( pDiedge == NULL )
    {
        return -1; 
    }

    return pDiedge->from;
}

//获取加权有向边的终止点
int directedEdgeGetTo(DIRECTED_EDGE* pDiedge)
{
    if ( pDiedge == NULL )
    {
        return -1; 
    }

    return pDiedge->to;
}

//获取加权有向边的权重值
double directedEdgeGetWeight(DIRECTED_EDGE* pDiedge)
{
    if ( pDiedge == NULL )
    {
        return 0.0; 
    }

    return pDiedge->weight;
}

//检测加权有向边是否有效
int directedEdgeIsValid(DIRECTED_EDGE* pDiedge)
{
    if ( pDiedge == NULL )
    {
        return 0; 
    }

    return (pDiedge->to != pDiedge->from);
}

void directedEdgeDump(DIRECTED_EDGE* pDiedge)
{
    if ( pDiedge == NULL )
    {
        return; 
    }

    printf("from %d to %d, weight is %f\r\n", \
            directedEdgeGetFrom(pDiedge), directedEdgeGetTo(pDiedge), \
            directedEdgeGetWeight(pDiedge));
}

#if DIRECTED_EDGE_TEST
int main()
{
    DIRECTED_EDGE diedge = {0};

    directedEdgeInit(&diedge, 3, 4, 8.8);
    directedEdgeDump(&diedge);

    directedEdgeInit(&diedge, 2, 6, 3.5);
    directedEdgeDump(&diedge);

    directedEdgeInit(&diedge, 1, 0, 2.7);
    directedEdgeDump(&diedge);

    return 0;
}
#endif


edgeWeightedDigraph.h

#ifndef _EDGE_WEIGHTED_DIGRAPH_H_
#define _EDGE_WEIGHTED_DIGRAPH_H_

#include "directedEdge.h"

#define EDGE_WEIGHTED_DIGRAPH_TEST  0

#define CHECK_NULL_AND_RET(x) { if((x) == NULL) return -1; }

typedef struct _ADJ_ENTRY
{
    DIRECTED_EDGE       diedge;
    struct _ADJ_ENTRY*  pNext;
} ADJ_ENTRY;

typedef struct
{
    struct _ADJ_ENTRY*  entryHead;
} ADJ_HEAD;

typedef struct
{
    int         V;             //顶点数
    int         E;             //边数
    ADJ_HEAD*   adjTable;      //邻接表
} EDGE_WEIGHTED_DIGRAPH;

void edgeWeightedDigraphInit(EDGE_WEIGHTED_DIGRAPH* pGraph, int V);
void edgeWeightedDigraphUninit(EDGE_WEIGHTED_DIGRAPH* pGraph);
int  V(EDGE_WEIGHTED_DIGRAPH* pGraph);
int  E(EDGE_WEIGHTED_DIGRAPH* pGraph);
void addEdge(EDGE_WEIGHTED_DIGRAPH* pGraph, DIRECTED_EDGE* pDiedge);
void showGraph(EDGE_WEIGHTED_DIGRAPH* pGraph);

#endif

edgeWeightedDigraph.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "edgeWeightedDigraph.h"
#include "directedEdge.h"

//加权有向图对象初始化
void edgeWeightedDigraphInit(EDGE_WEIGHTED_DIGRAPH* pGraph, int V)
{
    if ( pGraph == NULL )
    {
        return; 
    }

    pGraph->V = V;
    pGraph->E = 0;

    pGraph->adjTable = (ADJ_HEAD *)malloc(sizeof(ADJ_HEAD) * V);
    if ( pGraph->adjTable == NULL )
    {
        return; 
    }
}

//加权有向图去初始化
void edgeWeightedDigraphUninit(EDGE_WEIGHTED_DIGRAPH* pGraph)
{
    if ( pGraph == NULL )
    {
        return; 
    }

    if ( pGraph->adjTable == NULL )
    {
        free(pGraph->adjTable);
        pGraph->adjTable = NULL;
    }

    memset(pGraph, 0, sizeof(EDGE_WEIGHTED_DIGRAPH));
}

//获取加权有向图的顶点数
int V(EDGE_WEIGHTED_DIGRAPH* pGraph)
{
    if ( pGraph == NULL )
    {
        return -1; 
    }

    return pGraph->V;
}

//获取加权有向图的边数
int E(EDGE_WEIGHTED_DIGRAPH* pGraph)
{
    if ( pGraph == NULL )
    {
        return -1; 
    }

    return pGraph->E;
}

//邻接表添加条目
static int adjAdd(EDGE_WEIGHTED_DIGRAPH* pGraph, int x, DIRECTED_EDGE* pDiedge)
{
    ADJ_HEAD  *pAdjHead = NULL;
    ADJ_ENTRY *pNewAdjEntry = NULL;

    if ( pGraph == NULL || pDiedge == NULL )
    {
        return -1; 
    }

    if ( x >= V(pGraph) || x < 0 )
    {
        return -1; 
    }

    pNewAdjEntry = (ADJ_ENTRY *)malloc(sizeof(ADJ_ENTRY));
    CHECK_NULL_AND_RET(pNewAdjEntry);
    memset(pNewAdjEntry, 0, sizeof(ADJ_ENTRY));
    pNewAdjEntry->diedge = *pDiedge;

    pAdjHead = (pGraph->adjTable + x);

    pNewAdjEntry->pNext = pAdjHead->entryHead;
    pAdjHead->entryHead = pNewAdjEntry;

    return 0;
}

//向加权有向图中添加边
void addEdge(EDGE_WEIGHTED_DIGRAPH* pGraph, DIRECTED_EDGE* pDiedge)
{
    if ( pGraph == NULL || pDiedge == NULL )
    {
        return; 
    }

    if ( adjAdd(pGraph, directedEdgeGetFrom(pDiedge), pDiedge) == 0 )
    {
        pGraph->E++;
    }
}

//打印加权有向图信息
void showGraph(EDGE_WEIGHTED_DIGRAPH* pGraph)
{
    int i = 0;

    if ( pGraph == NULL )
    {
        return; 
    }

    printf("point count: %d\r\n", V(pGraph));
    printf("edge  count: %d\r\n", E(pGraph));
    printf("-----------------------------------------\r\n");

    for ( i = 0; i < V(pGraph); i++ )
    {
        ADJ_ENTRY* pCurEntry = NULL;

        for ( pCurEntry = (pGraph->adjTable + i)->entryHead; \
            pCurEntry != NULL; pCurEntry = pCurEntry->pNext )
        {
            directedEdgeDump(&pCurEntry->diedge);
        }
    }

    printf("-----------------------------------------\r\n");
}

#if EDGE_WEIGHTED_DIGRAPH_TEST
int main()
{
    DIRECTED_EDGE diedge = {0};
    EDGE_WEIGHTED_DIGRAPH graph = {0};

    edgeWeightedDigraphInit(&graph, 10);

    directedEdgeInit(&diedge, 0, 1, 0.5);
    addEdge(&graph, &diedge);

    directedEdgeInit(&diedge, 1, 2, 1.5);
    addEdge(&graph, &diedge);

    directedEdgeInit(&diedge, 2, 3, 2.8);
    addEdge(&graph, &diedge);

    directedEdgeInit(&diedge, 0, 4, 9.6);
    addEdge(&graph, &diedge);

    directedEdgeInit(&diedge, 4, 7, 0.3);
    addEdge(&graph, &diedge);

    showGraph(&graph);

    edgeWeightedDigraphUninit(&graph);

    return 0;
}
#endif

dijkstraSP.c

//Dijkstra最短路径算法(针对加权有向图)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include "directedEdge.h"
#include "edgeWeightedDigraph.h"
#include "indexMinPQ.h"

#define POSITIVE_INFINITY DBL_MAX 

//最短路径使用的数据结构
int             g_start = -1;       //起始点
double*         g_distTo = NULL;    //记载图中每个顶点到起始点的最短路径权值
DIRECTED_EDGE*  g_edgeTo = NULL;    //记载图中每个顶点连接起始点的最短路径上的最后一条边
INDEX_MIN_PQ    g_minPQ = {0};      //使用最小优先队列临时记载待处理的顶点

//创建加权有向图
//当前构建的加权有向图示例为：
//
//0 --(1.2)--> 1 --(5.6)--> 2
//             |
//             | --(1.5)--> 3 --(0.6)--> 4 --(0.2)--> 8
//             |                                      ^
//             | -----(7.8)------> 5 -----(5.3)-------|
//             |                                      ^
//             | --(2.3)--> 6 --(2.8)--> 7 --(4.3)----|
//
void createGraph(EDGE_WEIGHTED_DIGRAPH* pGraph)
{
    int    i = 0;
    int    froms[]   = {0,   1,   1,   1,   1,   3,   4,   5,   6,   7};
    int    tos[]     = {1,   2,   3,   5,   6,   4,   8,   8,   7,   8};
    double weights[] = {1.2, 5.6, 1.5, 7.8, 2.3, 0.6, 0.2, 5.3, 2.8, 4.3};
    DIRECTED_EDGE diedge = {0};

    if ( pGraph == NULL )
    {
        return; 
    }

    edgeWeightedDigraphInit(pGraph, 9);

    for ( i = 0; i < sizeof(froms)/sizeof(froms[0]); i++ )
    {
        directedEdgeInit(&diedge, froms[i], tos[i], weights[i]);
        addEdge(pGraph, &diedge);
    }
}

//销毁加权有向图
void destroyGraph(EDGE_WEIGHTED_DIGRAPH* pGraph)
{
    if ( pGraph == NULL )
    {
        return; 
    }

    edgeWeightedDigraphUninit(pGraph);
}

//算法初始化
int dijkstraSPInit(EDGE_WEIGHTED_DIGRAPH* pGraph, int start)
{
    int i = 0;
    int v = V(pGraph);

    if ( pGraph == NULL )
    {
        return -1; 
    }

    g_distTo = (double *)malloc(sizeof(double) * v);
    if ( g_distTo == NULL )
    {
        return -1; 
    }
    memset(g_distTo, 0, sizeof(double) * v);

    g_edgeTo = (DIRECTED_EDGE *)malloc(sizeof(DIRECTED_EDGE) * v);
    if ( g_edgeTo == NULL )
    {
        free(g_distTo);
        g_distTo = NULL;
        return -1; 
    }
    memset(g_edgeTo, 0, sizeof(DIRECTED_EDGE) * v);

    for ( i = 0; i < v; i++)
    {
        g_distTo[i] = POSITIVE_INFINITY;
    }

    indexMinPQInit(&g_minPQ, v);

    g_start = start;

    return 0;
}

//算法去初始化
void dijkstraSPUninit()
{
    if ( g_distTo != NULL )
    {
        free(g_distTo);
        g_distTo = NULL; 
    }

    if ( g_edgeTo != NULL )
    {
        free(g_edgeTo); 
        g_edgeTo = NULL;
    }

    indexMinPQUninit(&g_minPQ);

    g_start = -1;
}

//顶点的松驰处理
//
//* 边的松驰处理
//如下图示例所示，当前起始点为S，假设之前顶点W
//到起始点S的权重为8，顶点V到起始点S的权重为1,
//这时候对V-W边进行处理，发现 V到S的权重 + V-W边的权重 < W到S的权重，
//这时候更新W到S的权重为2+1，以及更新W到S的最短路径的最后一条边为W-V，
//这就是对V-W边进行松驰处理。
//
// W--(2)--> V --(1)--> S
// |                    ^
// |--------(8)---------|
//
//* 顶点的松驰处理
//假设上面示例中，顶点V刚确定好到起始点S的最短路径（也可以说V-S边做
//了边松驰处理），此时由于顶点V的到起始点S的权重值已经有了更新，所以
//需要对顶点V相关联的所有边都进行检查，查看是否相关联的边可以进行边
//松驰处理，对于这种操作就叫做对顶点V进行松驰处理。
//
int relax(EDGE_WEIGHTED_DIGRAPH* pGraph, int v)
{
    ADJ_ENTRY *pCurAdjEntry = NULL;

    if ( pGraph == NULL )
    {
        return -1; 
    }

    if ( v < 0 || v >= V(pGraph) )
    {
        return -1; 
    }

    //遍历当前顶点相关联的所有边
    for ( pCurAdjEntry = pGraph->adjTable[v].entryHead; \
        pCurAdjEntry != NULL; \
        pCurAdjEntry = pCurAdjEntry->pNext )
    {
        int    edgeTo = directedEdgeGetTo(&pCurAdjEntry->diedge);
        double edgeWeight = directedEdgeGetWeight(&pCurAdjEntry->diedge);

        //检测当前顶点相关联边的另一端顶点到起始点的权重是否大于当前顶点到起始点权重与当前关联边权重之和。
        //如果条件成立，则表示需要对该边进行松驰处理。
        if ( g_distTo[edgeTo] > g_distTo[v] + edgeWeight ) 
        {
            //更新关联边另一端顶点到起始点的最短路径权重，并记载到最短路径
            //的最后一条边。
            g_distTo[edgeTo] = g_distTo[v] + edgeWeight;
            g_edgeTo[edgeTo] = pCurAdjEntry->diedge;

            //由于关联边做了松驰操作，也就是说该边的另一端顶点到最短路径的
            //权重值有了变化，所以需要把该顶点加入到优先队列中，因为该顶点
            //受牵连的边都需要进行松驰检测。
            if ( indexMinPQContains(&g_minPQ, edgeTo) )
            {
                indexMinPQChange(&g_minPQ, edgeTo, edgeWeight);
            }
            else
            {
                indexMinPQInert(&g_minPQ, edgeTo, edgeWeight);
            }
        }
    }

    return 0;
}

//Dijkstra最短路径算法的主处理流程
//采用图的广度优先搜索处理方式，不断针对离起始点最短路径最近的顶
//点进行顶点松驰处理，直到不存在有效边时处理完成。
void dijkStraSP(EDGE_WEIGHTED_DIGRAPH* pGraph)
{
    if ( pGraph == NULL )
    {
        return; 
    }

    //将起始点加到的最短路径中，其中起始点到自身的权重为0
    g_distTo[g_start] = 0.0;

    //将起始点及到自身的权重值插入到优先队列中，准备进行当前
    //顶点的松驰处理。
    indexMinPQInert(&g_minPQ, g_start, 0.0);

    //采用图的广度优先搜索处理方式，不断从优先队列中找到
    //离最短路径最近的顶点，之后对该顶点进行松驰处理，处
    //理完成后，该顶点需要从优先队列中删除，之后继续处理
    //离最短路径次近的顶点，并进行顶点松驰处理，直到优先
    //队列中没有待处理的顶点。
    while ( !indexMinPQIsEmpty(&g_minPQ) )
    {
        relax(pGraph, indexMinPQDelMin(&g_minPQ)); 
    }
}

//显示任意顶点到起始点的最短路径信息
void showShortPathFromStartToV(int v)
{
    DIRECTED_EDGE* pCurEdge = &g_edgeTo[v];

    printf("from %d to %d (total weight %f):\r\n", g_start, v, g_distTo[v]);

    printf("---------------------------------\r\n");

    //由于g_edgeTo中记载的是每个顶点到起始点最短路径上的最后一条边，所以
    //这里使用倒序的流程显示从顶点V到起始点的路径信息，如果确实需要显示从
    //起始点到顶点V的路径信息则可以采用先入栈再出栈的方式实现，这里为了简
    //化没有那样处理。
    while ( directedEdgeIsValid(pCurEdge) )
    {
        int    edgeFrom = directedEdgeGetFrom(pCurEdge);
        int    edgeTo   = directedEdgeGetTo(pCurEdge);
        double edgeWeight = directedEdgeGetWeight(pCurEdge);

        printf("%d <-- %d (weight %f)\r\n", edgeFrom, edgeTo, edgeWeight); 

        pCurEdge = &g_edgeTo[edgeFrom];
    }

    printf("---------------------------------\r\n");
}

int main()
{
    EDGE_WEIGHTED_DIGRAPH graph = {0};

    createGraph(&graph);
    showGraph(&graph);

    dijkstraSPInit(&graph, 0);

    dijkStraSP(&graph);
    showShortPathFromStartToV(8);

    dijkstraSPUninit(&graph);

    destroyGraph(&graph);

    return 0;
}


技术人生LJF
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图的类型：无向图有向图加权图树
AGI通用人工智能之禅
06-13 25
图的类型：无向图、有向图、加权图、树 1. 背景介绍 图论是数学的一个分支，它研究图的性质和图之间的关系。在计算机科学中，图论的概念被广泛应用于数据结构和算法设计中，尤其是在网络路由、社交网络、推荐系统等领域。图可以根据其性质被分类为无向图、有向图、加权图和树，每种类型的图都有其独特的
Dijkstra最短路径算法的C++实现
07-24
Dijkstra最短路径算法是一种经典的图论算法，用于寻找图中节点间的最短路径。它由荷兰计算机科学家艾兹格·迪科斯彻在1956年提出，广泛应用于路由选择、网络优化以及各种距离计算问题。在这个C++实现中，我们将探讨...
Radvision H248 DNS解析机制实现
技术人生
11-19 1471
一、初始化 //获取select引擎对象 RvSelectGetThreadEngine(pRslvMgr->pLogMgr,&pSelect);   //构造DNS引擎对象 RvAresConstruct(.....); dnsEngine->userQueryId  = 1; //请求ID dnsEngine->selectEngine = selectEngine; //关联s
网络发起重认证
技术人生
06-27 929
 网络发起重认证 终端注册成功后，协商的注册刷新周期在以前SIP网络的机制中不可临时由S-CSCF进行改变，但有些情况下确实需要S-CSCF对终端进行重认证。   在IMS机制中，S-CSCF通过之前与终端注册订阅基础上，向终端发起Notify请求来缩短注册周期，完成由网络侧发起重认证的目的。   S-CSCF发送Notify信令如下： NOTIFYs
对sip中的realm理解
技术人生
06-25 5167
应该很少有同仁注意过sip中的relam存在，目前所接触到的
Dijkstra、BFS求有权图、无权图最短路径[Java]
weixin_55488173的博客
04-21 844
Dijkstra迪杰斯特拉、BFS宽度优先遍历
利用代码具体实现加权有向图中的dijkstra算法
weixin_35755434的博客
02-18 163
我们可以使用C / C ++或Java来实现Dijkstra算法。首先，定义一个图，其中包含每个节点的邻接表，以及节点之间的距离。然后，定义一个数组来存储每个节点到起始节点的最短距离，并将其初始化为无穷大。接下来，从起始节点开始，检查该节点的邻接节点，更新最短路径数组，如果当前节点到该邻接节点的距离更短，则更新最短路径数组。然后，选择一个未被处理的节点，距离起始节点最近，重复以上步骤，直到所有节点...
Dijkstra最短路径算法动态链接库vb.net
01-10
2. `GraphBuilder`类：用于构造各种类型的图，包括加权无向图和有向图。 3. `ResultDisplay`类：负责将计算出的最短路径和距离以用户友好的方式呈现出来。 详细说明文件可能包含了算法的原理介绍、如何使用DLL的...
Dijkstra算法找最短路径代码_dijkstra_Dijkstra算法找最短路径代码_dijkstra算法_
10-03
它适用于加权有向图或无向图，且所有边的权重都是非负的。这个算法的核心思想是通过逐步扩展最短路径树来找到起点到所有其他顶点的最短路径。 1. **算法描述**： - 初始化：设置起点的距离为0，其他所有顶点的距离...
VB.net dijkstra最短路径算法 源代码
04-08
这个算法主要用于寻找图中两个节点之间的最短路径，特别适用于加权有向图。在VB.NET中实现Dijkstra算法，可以帮助开发者解决各种实际问题，例如网络路由、交通路线规划等。 首先，我们需要理解Dijkstra算法的基本...
最短路径算法
04-14
1. **Dijkstra算法**：由荷兰计算机科学家艾兹格·迪科斯彻提出，适用于有向图或无向图，且边的权重非负。Dijkstra算法采用贪心策略，逐步扩展最短路径树，每次选取当前未访问节点中距离源节点最近的一个加入树中。...
最短路径(加权有向图)
一名小白的博客
08-28 4577
最短路径 1. 最短路径定义以及性质 定义： 在一副加权有向图中，从顶点s到顶点t的最短路径是所有从顶点s到顶点t的路径中总权重最小的那条路径。 性质： 路径具有方向性。 权重不一定等于距离。权重可以是距离、时间、花费等内容，权重最小指的是成本最低。 只考虑连通图。一副图中并不是所有的顶点都是可达的，如果s和t不可达，那么它们之间也就不存在最短路径，所以只考虑连通图。 最短路径不一定是唯一的。从一个顶点到达另外一个顶点的权重最小的路径可能会有很多条，所以只需要找出一条即可。 最短路径树： 给定一副加权
基于Dijkstra算法的带权有向图最短路径问题求解Python实现
weixin_59450364的博客
04-12 4435
基于Dijkstra算法的带权有向图最短路径问题求解，用Python实现
带权有向图最短路径之Dijkstra和Floyd
weixin_39861267的博客
11-09 1140
最短路径
IMS系统的一些常见知识
weixin_30315723的博客
06-30 203
IMS系统的一些博客； http://blog.csdn.net/liujianfeng1984/article/list/3 http://blog.csdn.net/liujianfeng1984/article/list/3 转载于:https://www.cnblogs.com/moon-lights/p/7097427.html...
图解迪杰斯特拉（Dijkstra）最短路径算法
热门推荐
ZER00000001的博客
06-22 7万+
【干货满满！】在介绍最短路径之前我们首先要明白两个概念：什么是源点，什么是终点？在一条路径中，起始的第一个节点叫做源点；终点：在一条路径中，最后一个的节点叫做终点；注意！源点和终点都只是相对于一条路径而言，每一条路径都会有相同或者不相同的源点和终点。而最短路径这个词不用过多解释，就是其字面意思：在图中，对于非带权无向图而言，从源点到终点边最少的路径（也就是BFS广度优先的方法）；而对于带权图而言，从源点到终点权值之和最少的路径叫最短路径；最短路径应用：道路规划；我们最关心的就是去实现寻找最短路径，通过实现.
算法4第4章加权有向图Dijkstra/BellmanFord最短路径算法关键路径算法讲解
cyj88jyc的专栏
06-29 1072
最短路径即从一个顶点到达另一个顶点成本最小的路径，例如利用导航软件获取从一个地方到达另一个地方的路径，顶点对应路口，边对应公路，边的权重对应经过该路段的成本,可以是时间或距离，如果有单行线，那就要考虑加权有向图。 加权有向图的数据结构实现如下 public class EdgeWeightedDigraph { private static final String NEWLINE =...
算法16-加权有向图的数据结构及Dijkstra算法
起舞的日子
04-25 486
读者盆友，下午好啊！终于来到图中最复杂的部分了：加权又向图。 本博客代码示例均来自：算法 Algorithmes Forth Edition [美] Robert Sedgewick Kevin Wayne 著 谢路云译 文章目录一、加权有向边的数据类型二、加权有向图的数据类型三、最短路径的Dijkstra算法四、源码 一、加权有向边的数据类型 package com.cmh.algorith...
最短路径（有权重）
LuciferFISH的博客
12-03 578
#include <stdio.h> #include <stdlib.h> typedef struct table { int known; int dist; int path; }TABLE; typedef struct table Table; void Dijkstra(int graph[8][8],int a, int b) { Table T[9]; int V=a,W; int check=0; in..
dijkstra最短路径算法
最新发布
05-28
Dijkstra最短路径算法是一种用于解决加权有向图或无向图中，从一个源点到所有其他点的最短路径问题的贪心算法。该算法的基本思想是通过不断地扩展已经找到最短路径的顶点集合，从而逐步确定从源点到其它所有顶点的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值