prim最小生成树算法

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

edge.h

#ifndef _EDGE_H_
#define _EDGE_H_

typedef struct
{
    int     v;          //顶点之一
    int     w;          //另一个顶点
    double  weight;     //边的权重
} EDGE;

void edgeInit(EDGE* pEdge,  int v, int w, double weight);
int  edgeWeight(EDGE* pEdge);
int  edgeOther(EDGE* pEdge, int vertex);
int  edgeCompareTo(EDGE* pThis, EDGE* pThat);

#endif

edge.c 

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

//加权边对象初始化
void edgeInit(EDGE* pEdge,  int v, int w, double weight)
{
    if ( pEdge == NULL )
    {
        return; 
    }

    pEdge->v = v;
    pEdge->w = w;
    pEdge->weight = weight;
}

//返回加权边对象任意一个顶点
int edgeWeight(EDGE* pEdge)
{
    if ( pEdge == NULL )
    {
        return -1; 
    }

    return pEdge->v;
}

//返回加权边对象的另一个顶点
int edgeOther(EDGE* pEdge, int vertex)
{
    if ( pEdge->v == vertex )  
    {
        return pEdge->w; 
    }
    else if ( pEdge->w == vertex )  
    {
        return pEdge->v; 
    }

    return -1;
}

//比较加权边对象的加权值
int edgeCompareTo(EDGE* pThis, EDGE* pThat)
{
    if ( pThis == NULL || pThat == NULL )
    {
        return -2;
    }

    if ( pThis->weight < pThat->weight )
    {
        return -1;
    }
    else if ( pThis->weight > pThat->weight )
    {
        return 1; 
    }

    return 0;
}

edgeWeightedGraph.h 

#ifndef _EDGE_WEIGHTED_GRAPH_H_
#define _EDGE_WEIGHTED_GRAPH_H_

#include "edge.h"

#define EDGE_WEIGHTED_GRAPH_TEST  0

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

typedef struct _ADJ_ENTRY
{
    EDGE                edge;
    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_GRAPH;

void edgeWeightedGraphInit(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph, int V);
void edgeWeightedGraphUninit(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph);
int  V(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph);
int  E(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph);
void addEdge(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph, EDGE* pEdge);
void showGraph(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph);

#endif

edgeWeightedGraph.c 

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "edgeWeightedGraph.h"
#include "edge.h"

//加权无向图对象初始化
void edgeWeightedGraphInit(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph, int V)
{
    int i = 0; 

    if ( pEdgeWeightedGraph == NULL )
    {
        return; 
    }

    pEdgeWeightedGraph->V = V;
    pEdgeWeightedGraph->E = 0;

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

//加权无向图去初始化
void edgeWeightedGraphUninit(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph)
{
    if ( pEdgeWeightedGraph == NULL )
    {
        return; 
    }

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

    memset(pEdgeWeightedGraph, 0, sizeof(EDGE_WEIGHTED_GRAPH));
}

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

    return pEdgeWeightedGraph->V;
}

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

    return pEdgeWeightedGraph->E;
}

//邻接表添加条目
static int adjAdd(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph, int x, EDGE* pEdge)
{
    ADJ_HEAD  *pAdjHead = NULL;
    ADJ_ENTRY *pNewAdjEntry = NULL;

    if ( pEdgeWeightedGraph == NULL || pEdge == NULL )
    {
        return -1; 
    }

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

    pNewAdjEntry = (ADJ_ENTRY *)malloc(sizeof(ADJ_ENTRY));
    CHECK_NULL_AND_RET(pNewAdjEntry);
    memset(pNewAdjEntry, 0, sizeof(ADJ_ENTRY));
    pNewAdjEntry->edge = *pEdge;

    pAdjHead = (pEdgeWeightedGraph->adjTable + x);

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

    return 0;
}

//向加权无向图中添加加权边
void addEdge(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph, EDGE* pEdge)
{
    int v = 0;
    int w = 0;

    if ( pEdgeWeightedGraph == NULL || pEdge == NULL )
    {
        return; 
    }

    v = edgeWeight(pEdge);
    w = edgeOther(pEdge, v);

    adjAdd(pEdgeWeightedGraph, v, pEdge);
    adjAdd(pEdgeWeightedGraph, w, pEdge);

    pEdgeWeightedGraph->E++;
}

//打印加权无向图信息
void showGraph(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph)
{
    int i = 0;

    if ( pEdgeWeightedGraph == NULL )
    {
        return; 
    }

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

    for ( i = 0; i < V(pEdgeWeightedGraph); i++ )
    {
        ADJ_ENTRY* pCurEntry = (pEdgeWeightedGraph->adjTable + i)->entryHead;

        while ( pCurEntry != NULL ) 
        {
            printf("[%d] %d <--> %d (weight %f)\r\n", \
                i, pCurEntry->edge.v, pCurEntry->edge.w, pCurEntry->edge.weight); 

            pCurEntry = pCurEntry->pNext;
        }
    }

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

#if EDGE_WEIGHTED_GRAPH_TEST
int main()
{
    EDGE edgeObj = {0};

    EDGE_WEIGHTED_GRAPH graph = {0};

    edgeWeightedGraphInit(&graph, 10);

    edgeInit(&edgeObj, 0, 1, 0.5);
    addEdge(&graph, &edgeObj);

    edgeInit(&edgeObj, 1, 2, 1.5);
    addEdge(&graph, &edgeObj);

    edgeInit(&edgeObj, 2, 3, 2.8);
    addEdge(&graph, &edgeObj);

    edgeInit(&edgeObj, 0, 4, 9.6);
    addEdge(&graph, &edgeObj);

    edgeInit(&edgeObj, 4, 7, 0.3);
    addEdge(&graph, &edgeObj);

    showGraph(&graph);

    edgeWeightedGraphUninit(&graph);

    return 0;
}
#endif

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

primMST.c

//Prim最小生成树算法

#include <stdio.h>
#include <stdlib.h>
#include <float.h>
#include "edge.h"
#include "indexMinPQ.h"
#include "edgeWeightedGraph.h"

#define POSITIVE_INFINITY DBL_MAX 

//当前Prim最小生成树算法使用了如下数据结构，其中edgeTo\distTo\marked相当于
//对应元素类型的数组，minPQObj为优先权队列．

EDGE *           edgeTo = NULL;   //记载每个顶点与最小生成树最近的边
double*          distTo = NULL;   //记载每个顶点与最小生成树最近的边的权值
int*             marked = NULL;   //记载每个顶点是否已经在最小生成树中
INDEX_MIN_PQ     minPQObj = {0};  //在最小生成树算法运算时，根据边的权值临时记载横切边

//算法初始化，根据图的顶点数分配资源
int primMSTInit(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph)
{
    int i = 0;
    int v = 0;

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

    v = V(pEdgeWeightedGraph);

    edgeTo = (EDGE *)malloc(sizeof(EDGE) * v);
    if ( edgeTo == NULL )
    {
        return -1; 
    }

    distTo = (double *)malloc(sizeof(double) * v);
    if ( distTo == NULL )
    {
        return -1; 
    }

    marked = (int *)malloc(sizeof(int) * v);
    if ( marked == NULL )
    {
        return -1; 
    }

    indexMinPQInit(&minPQObj, v);

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

    return 0;
}

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

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

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

    indexMinPQUninit(&minPQObj);
}

//Prim最小生成树算法
int primMST(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph)
{
    if ( pEdgeWeightedGraph == NULL )
    {
        return -1; 
    }

    //这里将顶点０做为起始顶点，当前为只含有一个顶点的树，
    //顶点距自身距离为0.0
    distTo[0] = 0.0;
    indexMinPQInert(&minPQObj, 0, 0.0);

    //1 在上面已经将顶点０加入到最小优先队列中，这里检查优
    //　先队列是否还有待处理的数据，如果有则取出离树最近的
    //　顶点，即每次查找离树最近的边进行处理．
    //2 将取出的最近顶点标记为marked，即表示当前顶点已经加
    //　入到这棵最小生成树中
    //3 遍历这个顶点所以相关联的边（对于已经在这棵最小生成
    //　树的边则忽略），检查每个相关联的边的另一端顶点离当
    //　前这棵最小生成树的距离是否比之前记录的值更近一些,
    //　如果另一端顶点离这棵最小生成树的距离确实比之前记录
    //　的值更近了，则更新这个顶点离最小生成树的距离为更新
    //　的这个值，同时将此顶点加入到最小优先权队列中（如果
    //　之前已经在最小优先权队列，但还未处理，则进行权值更
    //  新），准备后续进行处理.
    //4 之后一直循环查找优先队列是否还有待处理的数据，如果
    //　有，则取出后，进行２～４的处理，直到优先队列是空，
    //　则算法处理完毕．
    while ( !indexMinPQIsEmpty(&minPQObj) )
    {
        ADJ_ENTRY* pCurAdjEntry = NULL;
        int x = indexMinPQDelMin(&minPQObj);

        if ( x < 0 || x >= V(pEdgeWeightedGraph) )
        {
            continue; 
        }

        marked[x] = 1;

        for ( pCurAdjEntry = pEdgeWeightedGraph->adjTable[x].entryHead; \
           pCurAdjEntry != NULL;  pCurAdjEntry = pCurAdjEntry->pNext )
        {
            EDGE* pEdgeObj = &pCurAdjEntry->edge;
            int y = edgeOther(pEdgeObj, x);

            if ( marked[y] )
            {
                continue;     
            }

            if (distTo[y] > pEdgeObj->weight)
            {
                if ( indexMinPQContains(&minPQObj, y) )
                {
                    indexMinPQChange(&minPQObj, y, pEdgeObj->weight);
                }
                else
                {
                    indexMinPQInert(&minPQObj, y, pEdgeObj->weight);
                }

                distTo[y] = pEdgeObj->weight;
                edgeTo[y] = *pEdgeObj;
            }
        }
    }

    return 0;
}

//创建加权无向图
//当前示例的图为：
// (0) <- 1.4 -> (1) <- 5.6 -> (2)
//  ^             ^
//  |             |-- 3.2 --> (3) <------- 6.6 -----> (5)
//  |             |                                    ^
//  |             |-- 7.8 -> (4)                       |-- 2.9 -> (6)
//  |                         ^                        |
//  |-- 0.2 ->(9)             |                        |-- 7.6 -> (7)
//                            |                        |
//                            |-- 2.5 -> (8) -> 3.5  <-|
//
void createGraph(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph)
{
    EDGE edgeObj = {0};

    if ( pEdgeWeightedGraph == NULL )
    {
        return; 
    }

    edgeWeightedGraphInit(pEdgeWeightedGraph, 10);

    edgeInit(&edgeObj, 0, 1, 1.4);
    addEdge(pEdgeWeightedGraph, &edgeObj);

    edgeInit(&edgeObj, 0, 9, 0.2);
    addEdge(pEdgeWeightedGraph, &edgeObj);

    edgeInit(&edgeObj, 1, 2, 5.6);
    addEdge(pEdgeWeightedGraph, &edgeObj);

    edgeInit(&edgeObj, 1, 3, 3.2);
    addEdge(pEdgeWeightedGraph, &edgeObj);

    edgeInit(&edgeObj, 1, 4, 7.8);
    addEdge(pEdgeWeightedGraph, &edgeObj);

    edgeInit(&edgeObj, 3, 5, 6.6);
    addEdge(pEdgeWeightedGraph, &edgeObj);

    edgeInit(&edgeObj, 4, 8, 2.5);
    addEdge(pEdgeWeightedGraph, &edgeObj);

    edgeInit(&edgeObj, 5, 6, 2.9);
    addEdge(pEdgeWeightedGraph, &edgeObj);

    edgeInit(&edgeObj, 5, 7, 7.6);
    addEdge(pEdgeWeightedGraph, &edgeObj);

    edgeInit(&edgeObj, 5, 8, 3.5);
    addEdge(pEdgeWeightedGraph, &edgeObj);
}

//销毁加权无向图
void destroyGraph(EDGE_WEIGHTED_GRAPH* pEdgeWeightedGraph)
{
    if ( pEdgeWeightedGraph == NULL )
    {
        return; 
    }

    edgeWeightedGraphUninit(pEdgeWeightedGraph);
}

int main()
{
    int i = 0;
    EDGE_WEIGHTED_GRAPH graphObj = {0};

    createGraph(&graphObj);
    showGraph(&graphObj);

    primMSTInit(&graphObj);

    primMST(&graphObj);

    for ( i = 0; i < V(&graphObj); i++ )
    {
        int x = edgeWeight(&edgeTo[i]);
        int y = edgeOther(&edgeTo[i], x);
        printf("[%d] %d<->%d weight %f\r\n", i, x, y, distTo[i]); 
    }

    primMSTUninit();

    destroyGraph(&graphObj);

    return 0;
}


技术人生LJF
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Prim最小生成树算法的动态优化.pdf
07-11
Prim最小生成树算法的动态优化 Prim最小生成树算法是一种常用的最小生成树算法，可以用于解决连通网的最小生成树问题。该算法的设计思想是从一个起始点开始，逐步添加邻接点，直到所有点都被连接。算法的时间...
10.2索引优先队列---了解
pc的博客
02-04 196
在之前实现的最大优先队列和最小优先队列，他们可以分别快速访问到队列中最大元素和最小元素，但是他们有一个缺点，就是没有办法通过索引访问已存在于优先队列中的对象，并更新它们。为了实现这个目的，在优先队列的基础上，学习一种新的数据结构，索引优先队列。接下来我们以最小索引优先队列举列。 /** * 索引优先队列 * 增加或者删除数据时候，是通过pd指针的交换达到最大堆或最小堆 * 排序 排的不是items 而是pq */ public class IndexMinPriorityQueue...
数据结构实现之最小索引优先队列
清文的博客
01-24 2738
在很多应用中，允许用例引用进入优先队列中的元素是有必要的。做到这一点的一种简单方式是给每个元素一个索引。 另外，一种常见的情况是用例已经有了总量为N的多个元素，而且可能还同时使用了多个（平行）数组来存储这些元素的信息。此时，其他无关的用例代码可能已经在使用一个整数索引来引用这些无关元素了。这些考虑引导我们设计了如下所示的API。 public class IndexMinPQ> 说明
java数据结构和算法(IndexMaxPQ)
蒙奇D许的博客
10-13 1164
package cn.xyc.sort.maxPQ; import java.util.Iterator; import java.util.NoSuchElementException; /** * * 描述：索引数组pq保存的是数据集keys中的下标，遍历索引数组可以刻画出二叉堆 * 其中keys指的是IndexMaxPQ.java里的一个成员变量 * keys={it,was,
算法 4.4节 Dijkstra算法,拓扑排序算法,bellman-ford算法(暂缺))实现最小路径
firefly
04-14 188
// Dijkstra算法 import edu.princeton.cs.algs4.IndexMinPQ; public class Dijkstra { private double[] disTo; private Edge[] edgeTo; private IndexMinPQ&lt;Double&gt; pq; public Dijkstra(Ed...
洛谷 P3366 【模板】最小生成树 prim算法思路 我自己的实现
dlwhz5934的博客
01-04 181
网上有很多prim算法 用邻接矩阵 加什么lowcost数组 我觉得不靠谱 毕竟邻接矩阵本身就不是存图的好方法 所以自己写了一个邻接表（边信息表）版本的 注意我还是用了优先队列 每次新加入一个点 立即从这个点出发去查那些没有被选择的边与对面的点 优先队列来帮助排序 保证最顶上的一定是最小边 1 #include<cstdio> 2 #include...
最小生成树算法之Prim算法
09-03
最小生成树算法是图论中的一个经典问题，其目标是在给定的加权无向连通图中找到一棵包括所有顶点的树，使得树中所有边的权重之和最小。Prim算法是一种解决这一问题的有效方法，尤其适用于稠密图。 1. **最小生成树...
实验（三）Prim最小生成树算法的实现.doc
05-06
Prim最小生成树算法的实现 一、实验目的和要求 ---------------------- 本实验的目的是掌握图的基本操作设计与实现，利用Prim算法求网络的最小生成树。实验要求掌握图的基本操作设计与实现，并利用Prim算法实现...
Prim最小生成树算法
01-07
【Prim最小生成树算法】是图论中的一个重要概念，用于寻找加权无向图中连接所有顶点的最小代价树。这个算法由捷克数学家Vojtěch Jarník提出，后由美国计算机科学家Robert C. Prim进一步发展和完善。在数据结构课程...
Dijkstra最短路径算法(针对加权有向图)
技术人生
09-02 5296
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
图论算法——最短路径算法
日积月累，天道酬勤
06-10 3084
引言 在Prim算法和Kruskal算法中，我们学习了寻找加权无向图的最小生成树的Prim算法：构造最小生成树的每一步都向生成树中添加一条新的边。 今天要学习类似的方法来计算最短路径——Dijkstra算法。 Dijkstra算法 最短路径树中的边：edgeTo[v]的值为树中连接v和它的父节点的边。 最短路径树：包含了顶点s到所有可达的顶点的最短路径 ...
MinPQ
haitaoc的博客
03-20 982
MinPQ
[C++]C++ STL priority_queue IndexPriorityQueue 索引优先队列 比较器
需要加盐吗？
09-07 2623
code#include <iostream> #include <vector> #include <queue> using namespace std;const int V = 10; double distTo[V]; // distTo[v] = shortest path of s->v struct LessThanByDist { bool operator()(con
索引优先队列的实现
陆业聪
01-07 1398
/************************************************************************* * Compilation: javac IndexMinPQ.java * Execution: java IndexMinPQ * * Minimum-oriented indexed PQ implementation u
一文带你弄懂什么是索引二叉堆
日积月累，天道酬勤
03-31 869
索引二叉堆是啥？索引二叉堆又称为最小索引优先队列。它的特点是堆元素位置不变，通常改变索引的位置来实现二叉堆的结构。
[Java]-最短路径(Dijkstra,BellmanFord,Topological算法)
renboyu010214的博客
04-08 686
最短路径 最短路径描述的是在一幅加权有向图中，从一个顶点s到任意顶点的所有路径中权重最小的一条路径 单点最短路径问题 在一幅加权有向图中，从顶点s到任意顶点v是否存在一条有向路径，如果存在，找出权重最小的那一条有向路径 最短路径树 最短路径树描述的是在一幅加权有向图中，某一顶点s到任意顶点的最短路径组成的树，这棵树的根节点是顶点s，s到树上所有子...
实验五 图的物理实现（邻接表）
悲伤无声地涌出来
11-29 772
​​​​​​2018-12-4更新 增添了memset函数对标记数组mark重置 --------------------------------------------------------------------------------------------------------------------------------------------------- 说明 基于邻接...
十八、图算法之最短路径
guanhang89的专栏
04-19 3536
最短路径 加权有向图的数据结构 Dijstra算法有向无负边 无环加权有向图中的最短路径算法 无环加权有向图中的最长路径算法 一个应用平行任务调度 优先级限制下的平行任务调度 相对最后期限下的并行任务调度 一般有向加权图的最短路径问题 基于队列的Bellman-Ford算法 套汇最短路径这里基于的是加权有向图的讨论，而且是单源最短路径问题。我们称为最短路径的结果是一棵最短路径树。给定一幅加权有向图和
HDU 1102 Constructing Roads， Prim+优先队列
weixin_34390996的博客
01-23 71
题目链接：HDU 1102 Constructing Roads Constructing Roads Problem Description There are N villages, which are numbered from 1 to N, and you should build some roads such that every two vil...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值