数据结构与算法--普里姆算法

最新推荐文章于 2023-11-19 15:36:39 发布
最新推荐文章于 2023-11-19 15:36:39 发布
阅读量132 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wu996/article/details/134252598
版权

普里姆算法–用邻接表的方法进行实现。邻接表的实现
实现步骤：
1.首先创建一个邻接表
2.使用一个空链表用于存信息
3.每次将顶点的信息进行入队
4.从链表中选取边最短的边
5.将节点的信息保存在数组miniPrime中，并将指向的顶点保存在Point数组
6.然后将链表中以这些Point的值为起点的或者重点的结点删除掉
7.直到将所有的顶点都选完

结构体定义

#include <stdio.h>
#include <malloc.h>
#define MAX_VERTEX_NUM 20 
typedef enum
{
    DN,//DiGraph 有向图
    UN //UndiGraph 无向图
}GraphType;
typedef struct ArcNode
{
    int startVex;//起始顶点
    int adjVex; //指向顶点的位置
    struct ArcNode *next;
    int data;
}ArcNode;

typedef struct  VNode
{
    int vexNode;
    ArcNode *firstNode;
}VNode;
typedef struct miniPrime
{
    int startPoint;
    int edgeData;
    int endPoint;
}MiniPrime;
typedef struct ALGraph
{
    VNode vertices[MAX_VERTEX_NUM];
    int vexNum;  //顶点个数。
    GraphType kind;   //图的种类标记 
}ALGraph;
ALGraph *createGraph();
void printfGraph(ALGraph *alGraph );
void MiniSpanTree_Prime(ALGraph *alGraph ,int vertice);
void printfList(ArcNode  *NodeList);

主要方法，每次从链表中选取值最小的边。

ArcNode *miniEdge(ArcNode  *NodeList, ALGraph *alGraph,int startPoint,int  Point[])
{
    //printf("startPoint %d \n" ,startPoint);
    ArcNode *vexNodeList = alGraph->vertices[startPoint].firstNode->next;
    ArcNode *returnNode = (ArcNode *)malloc(sizeof(ArcNode));
    int  flag = 0;
    ArcNode *List ;
    returnNode->data =  1000;
    //printfList(alGraph->vertices[startPoint].firstNode);
    while(NULL != vexNodeList)
    {//将节点加入链表


        for(int i = 0; i < alGraph->vexNum ; i++)
        {
            //printf("point[%d]",Point[i]);
            for(int j = i+1; j < alGraph->vexNum ; j++)
            {
                if(Point[i] == -1 || Point[j] ==-1)
                {
                    break;
                }
                 if((vexNodeList->adjVex == Point[j] &&  vexNodeList->startVex == Point[i])||
                        (vexNodeList->adjVex == Point[i] &&  vexNodeList->startVex == Point[j]))
                {
                    if(vexNodeList->next != NULL)
                    {
                        //printf("list is not NULL\n");
                        vexNodeList = vexNodeList->next;
                        break;
                    }
                    else
                    {
                        //printf("list is NULL\n");
                        flag = 1;
                        break;
                    }
                }
            }
        }
        if(flag == 1)
        {
            break;
        }
        ArcNode *tmpNode = (ArcNode *)malloc(sizeof(ArcNode));
        tmpNode->adjVex = vexNodeList->adjVex;
        tmpNode->data = vexNodeList->data;
        tmpNode->startVex =  vexNodeList->startVex;
        addarcNodetail(NodeList,tmpNode);
        vexNodeList = vexNodeList->next;
    }
    //printfList(NodeList);
    List = NodeList->next;
    while( NULL != List)
    {
        if(returnNode->data > List->data)
        {   
            //printf("returnNode->data %d  List->data,%d\n", returnNode->data ,List->data);
            returnNode->adjVex = List->adjVex;
            returnNode->data = List->data;
            returnNode->startVex = List->startVex;
        }
        
        List = List->next;
    }
    return returnNode;
}

所有函数

#include "Graph.h"
typedef struct Data
{
    int a ;
    int b ;
}Data;

Data dataArray[26]=
{
    {1,6},{2,1},{3,5},{0,0},
    {0,6},{2,5},{4,3},{0,0},
    {0,1},{1,5},{3,5},{4,6},{5,4},{0,0},
    {0,5},{2,5},{5,2},{0,0},
    {1,3},{2,6},{5,6},{0,0},
    {2,4},{3,2},{4,6},{0,0}
};
void addarcNodetail(ArcNode *list , ArcNode *tmpNode)
{
    ArcNode *tmpList = list;
    while(tmpList->next != NULL)
    {
        tmpList = tmpList->next ;
    }
    tmpList->next = tmpNode;
    tmpNode->next = NULL;
    return ;
}
ALGraph *createGraph()
{
    ALGraph *alGraph = (ALGraph *) malloc(sizeof(ALGraph));
    int vexNum , data , vexarc;
    printf("please input vexNode num :");
    scanf("%d",&vexNum);
    alGraph->vexNum = vexNum;
    int j = 0 ;
    for(int i = 0 ; i < vexNum; i++)
    {
        alGraph->vertices[i].vexNode = i;
        alGraph->vertices[i].firstNode =(ArcNode *)malloc(sizeof(ArcNode));
        alGraph->vertices[i].firstNode->next = NULL;
        alGraph->vertices[i].firstNode->adjVex = 0;
        alGraph->vertices[i].firstNode->data = 0;
    }
    for(int i = 0 ; i < vexNum; j++)
    {
        ArcNode *tmpNode = (ArcNode *)malloc(sizeof(ArcNode));
        tmpNode->adjVex = dataArray[j].a;
        tmpNode->data = dataArray[j].b;
        tmpNode->startVex = i;
        if(dataArray[j].b > 0)
        {//挂载节点
            addarcNodetail(alGraph->vertices[i].firstNode,tmpNode);
        }
        else
        {
            i++;
        }
    }
    return alGraph;
}
void printfGraph(ALGraph *alGraph)
{
    for(int i = 0 ; i < alGraph->vexNum; i++)
    { 
        ArcNode *tmpNode = (ArcNode *)malloc(sizeof(ArcNode));
        printf("dingdianaaa %d->", i);
        tmpNode = alGraph->vertices[i].firstNode->next;
        while(tmpNode != NULL)
        {
            printf("tmpNode:%d->", tmpNode->adjVex);
            tmpNode = tmpNode->next;
        }
        printf("NULL\n");
    }
}
//如果图中存在顶点，则返回顶点的位置，如果没有则返回空
ArcNode *locate(ALGraph *alGraph,int vertice)
{
    for(int i = 0; i < alGraph->vexNum; i++)
    {
        if(vertice = alGraph->vertices[i].vexNode) 
        {
            return alGraph->vertices[i].firstNode;
        }   
    }
    return NULL ;
}
void printfList(ArcNode  *NodeList)
{
    ArcNode *tmpNode = (ArcNode *)malloc(sizeof(ArcNode));
        
    tmpNode = NodeList->next;
    printf("tmpList:");
    while(tmpNode != NULL)
    {
        printf("startVex%d,adjVex%d,data%d       ",tmpNode->startVex, tmpNode->adjVex, tmpNode->data);
        tmpNode = tmpNode->next;
    }
    printf("\n");
}
void deleteNode(ArcNode  *NodeList,int  Point[],int num)
{
    for(int i = 0; i < num ; i++)
    {
        //printf("point[%d]",Point[i]);
        for(int j = i+1; j < num ; j++)
        {
            if(Point[i] == -1 || Point[j] ==-1)
            {
                break;
            }
            ArcNode  *tmpNodeList = NodeList->next;
            ArcNode  *preNode = NodeList;

            while(NULL != tmpNodeList)
            {
                // printf(" node(%d,%d,%d) ,Point[%d] (%d,%d)\n",tmpNodeList->startVex,tmpNodeList->adjVex,tmpNodeList->data, i,
                //  Point[i],Point[j]);
                if((tmpNodeList->adjVex == Point[j] &&  tmpNodeList->startVex == Point[i])||
                (tmpNodeList->adjVex == Point[i] &&  tmpNodeList->startVex == Point[j]))
                {
                    //printf("delte node(%d,%d,%d)\n",tmpNodeList->startVex,tmpNodeList->adjVex,tmpNodeList->data);
                    preNode->next = tmpNodeList->next;
                    tmpNodeList = tmpNodeList->next;
                }
                else
                {
                    tmpNodeList = tmpNodeList->next;
                    preNode = preNode->next;
                }
                
            }
        }
        
    }
    
}
ArcNode *miniEdge(ArcNode  *NodeList, ALGraph *alGraph,int startPoint,int  Point[])
{
    //printf("startPoint %d \n" ,startPoint);
    ArcNode *vexNodeList = alGraph->vertices[startPoint].firstNode->next;
    ArcNode *returnNode = (ArcNode *)malloc(sizeof(ArcNode));
    int  flag = 0;
    ArcNode *List ;
    returnNode->data =  1000;
    //printfList(alGraph->vertices[startPoint].firstNode);
    while(NULL != vexNodeList)
    {//将节点加入链表


        for(int i = 0; i < alGraph->vexNum ; i++)
        {
            //printf("point[%d]",Point[i]);
            for(int j = i+1; j < alGraph->vexNum ; j++)
            {
                if(Point[i] == -1 || Point[j] ==-1)
                {
                    break;
                }
                 if((vexNodeList->adjVex == Point[j] &&  vexNodeList->startVex == Point[i])||
                        (vexNodeList->adjVex == Point[i] &&  vexNodeList->startVex == Point[j]))
                {
                    if(vexNodeList->next != NULL)
                    {
                        //printf("list is not NULL\n");
                        vexNodeList = vexNodeList->next;
                        break;
                    }
                    else
                    {
                        //printf("list is NULL\n");
                        flag = 1;
                        break;
                    }
                }
            }
        }
        if(flag == 1)
        {
            break;
        }
        ArcNode *tmpNode = (ArcNode *)malloc(sizeof(ArcNode));
        tmpNode->adjVex = vexNodeList->adjVex;
        tmpNode->data = vexNodeList->data;
        tmpNode->startVex =  vexNodeList->startVex;
        addarcNodetail(NodeList,tmpNode);
        vexNodeList = vexNodeList->next;
    }
    //printfList(NodeList);
    List = NodeList->next;
    while( NULL != List)
    {
        if(returnNode->data > List->data)
        {   
            //printf("returnNode->data %d  List->data,%d\n", returnNode->data ,List->data);
            returnNode->adjVex = List->adjVex;
            returnNode->data = List->data;
            returnNode->startVex = List->startVex;
        }
        
        List = List->next;
    }
    return returnNode;
}
//vertice表示从那个顶点开始
void MiniSpanTree_Prime(ALGraph *alGraph ,int vertice)
{
    ArcNode  *startNode = locate(alGraph,vertice);
    ArcNode  *NodeList = (ArcNode *)malloc(sizeof(ArcNode));
    NodeList->next = NULL;
    MiniPrime miniPrime[alGraph->vexNum];
    int Point[alGraph->vexNum];
    ArcNode *miniNode;
    int startPoint = vertice;
    if(startNode == NULL )
    {//没有这个顶点，
        printf("this startNode is not exist \n");
        return;
    }
    if(startNode->next == NULL )
    {
        printf("graph not have mini span tree");
    }
    for (int i = 1; i < alGraph->vexNum; i++)
    {
        miniPrime[i-1].startPoint = 0;
        miniPrime[i-1].edgeData = 0;
        miniPrime[i-1].endPoint = 0;
        Point[i] = -1;
    }
    Point[0] = startPoint;
    for (int i = 1; i < alGraph->vexNum; i++)
    {
        miniNode = miniEdge(NodeList,alGraph,startPoint,Point);
        miniPrime[i-1].startPoint = miniNode->startVex;
        miniPrime[i-1].edgeData = miniNode->data;
        miniPrime[i-1].endPoint = miniNode->adjVex;
        Point[i] = miniNode->adjVex;
        startPoint = miniNode->adjVex;
        deleteNode(NodeList,Point, alGraph->vexNum);
        //printfList(NodeList);
        printf("point(%d,%d,%d)\n", miniPrime[i-1].startPoint,  miniPrime[i-1].endPoint,miniPrime[i-1].edgeData);
    }
}

/*
 * @Author: error: error: git config user.name & please set dead value or install git && error: git config user.email & please set dead value or install git & please set dead value or install git
 * @Date: 2023-09-16 22:03:45
 * @LastEditors: error: error: git config user.name & please set dead value or install git && error: git config user.email & please set dead value or install git & please set dead value or install git
 * @LastEditTime: 2023-11-05 13:04:55
 * @FilePath: \bootstrap\main.c
 * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 */
#include <stdio.h>
#include <malloc.h>
#include <pthread.h> 
#include <stdlib.h>
#include "Graph.h"
int main(void )
{



    ALGraph *alGraph = createGraph();

    //printfGraph(alGraph);
    MiniSpanTree_Prime(alGraph,0);
    printfGraph(alGraph);
    return 0;
}

步骤图：

运行结果：
在这里插入图片描述
在这里插入图片描述

曾许人间第一流.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
回溯法 -数据结构与算法
skiwnc的博客
01-21 1815
回溯法 -数据结构与算法
邻接表实现Prim算法
weixin_43416586的博客
05-29 3604
Prim算法 Prim算法是通过连通网找最小生成树（mst）的算法 过程： 1.首先选取任意顶点作为树的根 2.遍历其他（不在树中）的顶点，对于每个顶点，找到一条到mst路径最短的边，这样，每个顶点都有一条通往mst的边（不是邻接的就设权值无限大） 3.在所有的边中，找到权值最小的一条，将对应顶点加入到mst中 循环2，3（对于n个顶点，循环n-1次） 例如，求下图的最小生成树 首先，选择v0作为起点，其他顶点到mst的距离分别为[0, 4, ∞, ∞, 3, 1] 从这6条边中选择最小的一条（非.
数据结构——普里姆（Prim）算法
热门推荐
qq_51231048的博客
10-30 1万+
普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点，且其所有边的权值之和亦为最小。以下是数据结构中关于普里姆算法的操作（编程风格参考严蔚敏版数据结构）。
b+树时间复杂度_数据结构与算法——最小生成树
weixin_39687621的博客
11-24 773
1 引言在之前的文章中已经详细介绍了图的一些基础操作。而在实际生活中的许多问题都是通过转化为图的这类数据结构来求解的，这就涉及到了许多图的算法研究。例如：在n个城市之间铺设光缆，以保证这n个城市中的任意两个城市之间都可以通信。由于铺设光缆的价格很高，且各个城市之间的距离不同，这就使得在各个城市之间铺设光缆的价格不同。那么如何选择铺设线路的方案，才能使费用最低呢？这就涉及到我们今天...
C语言实现邻接表的普里姆算法（完整代码）
weixin_43268636的博客
02-13 7021
今天我用C语言来实现下面的图的最小生成树： 它的最小生成树为： 最小生成树的思路是：先从一个顶点出发，把它加入集合V中，从与它相连接的边中找到权值最小的边，与权值最小的边的另一个顶点作为起始点，加入集合V中，再从集合V中顶点中找出未遍历的权值最小的边，找出与它的相连的另一顶点再作为起始点，以此类推下去，最小生成树就形成了。 首先我们先创建邻接表 预定义 #define MaxVertexNum...
【算法】最小生成树——普利姆 (Prim) 算法
最新发布
代码星辰的博客
11-19 3278
本文介绍了普利姆 (Prim) 算法的相关知识。
2005-数据结构与算法-期末试题1
08-03
数据结构与算法是计算机科学的基础，它涉及到如何高效地存储和处理数据，以及设计和分析解决问题的方法。在本份期末试题中，主要考察了以下几个核心知识点： 1. **栈与队列的模拟**：栈是一种后进先出（LIFO）的...
java数据结构与算法.pdf
01-04
在编程领域，数据结构与算法是核心组成部分，它们直接影响到程序的效率和性能。Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点...
【H5JS】游戏常用算法-路径搜索算法-随机迷宫算法（普里姆算法）.pdf
04-19
"H5JS游戏常用算法-路径搜索算法-随机迷宫算法（普里姆算法）" 本资源主要介绍了游戏开发中常用的路径搜索算法和随机迷宫算法，着重于普里姆算法的应用。路径搜索算法是游戏开发中非常重要的一部分，特别是在RPG、...
邻接表prim算法
02-29
用邻接表为存储结构的prim算法，程序中包括图的建立，图的深度优先遍历，和最小生成树prim算法
图的邻接表表示的各种算法
11-05
图的邻接表表示的克鲁斯卡尔算法 迪杰斯特拉算法 普里姆算法 c++实现 codeblocks编译通过
数据结构与算法图的二部分
02-20
数据结构与算法是计算机科学的基础，对于理解和优化程序性能至关重要。在给定的标题和描述中，主要涉及了数据结构中的图以及与之相关的算法，包括生成树、最小生成树、最短路径和拓扑排序。以下是这些概念的详细解释...
头歌数据结构图的最小生成树算法
05-26
头歌数据结构图的最小生成树算法 第1关求图（邻接矩阵存储）最小生成树的普里姆（Prim）算法 第2关求图（邻接表存储）最小生成树的普里姆（Prim）算法 第3关求图（邻接矩阵存储）最小生成树的克鲁斯卡尔（Kruskal）...
图论算法：普里姆算法（C++实现+图解）
ylh的博客
01-18 4432
U（s） V-E（1，2，3，4） 从V-E顶点中选择一个lowcost[i]最小的点，这个点 i 就是第一次找到的点，图中即 i=1，即构造了最小生成树（0，1），将顶点i 加入到U中，然后置lowcost[i] 为零，表示已经找到这个点了。然后重复在V-E（2，3，4）中找到lowcost[i]最小的点，为lowcost[2] =3 ，此时i=2，然后以这个点构造第二条边：U（0，1，2），将顶点 i加入到U中，置lowcost[i]=0，然后修正数组，重新执行上面的操作。的生成树叫做最小生成树。
C++：用邻接表表示普里姆算法
m0_62518283的博客
04-13 901
typedef struct ArcNode { char adjvex; ArcNode* nextArc; int weight; }ArcNode,*pArcNode; typedef struct VNode { char date; pArcNode firstArc; }VNode,*pVNode; typedef struct { pVNode vert; int vexnum, arcnum; }ALGraph; typedef struct cdge { char .
数据结构与算法 ~ 图 ~ 最小生成树 ~ 普里姆算法（图采用邻接表方式存储）
cskmyjy的博客
10-26 2651
普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。 算法描述： 1).输入：一个加权连通图，其中顶点集合为V，边集合为E； 2).初始化：Vnew = {x}，其中x为集合V中的任一节点（起始点），Enew = {...
邻接表实现PRIM算法(C++)
deanzhou717的博客
12-28 2285
参考张宪超老师《数据结构、算法及应用》原理:G=是一个连通的带权无向图。Prim算法通过不断地增加生成树的顶点来得到最小生成树。在算法的任一时刻，一部分顶点已经添加到生成树的顶点集合中，而其余顶点尚未加到生成树中。此时，Prim算法通过选择边，使得的权值是所有u（起点）在生成树中，但v（终点）不在生成树中的边的权值最小者，从而找到新的顶点v把她添加到生成树中。 详细步骤：1）初始状态，U={u1
最小生成树——普里姆算法(Prim算法)
不积极分子
03-30 7437
普里姆算法： 普里姆算法在找最小生成树时，将顶点分为两类，一类是在查找的过程中已经包含在树中的（假设为 A 类），剩下的是另一类（假设为 B 类）。 对于给定的连通网，起始状态全部顶点都归为 B 类。在找最小生成树时，选定任意一个顶点作为起始点，并将之从 B 类移至 A 类；然后找出 B 类中到 A 类中的顶点之间权值最小的顶点，将之从 B 类移至 A 类，如此重复，直到 B 类中没有顶点为止。所...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

曾许人间第一流.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值