最小代价生成树实现（算法与数据结构设计）

最新推荐文章于 2024-07-13 13:36:16 发布
最新推荐文章于 2024-07-13 13:36:16 发布
阅读量579 收藏 13
点赞数 31
分类专栏： 算法与数据结构设计实验 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DAOkonglong/article/details/140234801
版权

课题内容和要求

最小代价生成树的实现，分别以普利姆算法和克鲁斯卡尔算法实现最小代价生成树，并分析两种算法的适用场合。

数据结构说明

普利姆算法实现最小代价生成树的图采用邻接表存储结构，还有辅助数据结构，数组nearest，数组lowcost，数组mark。克鲁斯卡尔算法实现最小代价生成树的图采用邻接矩阵存储结构，其中还定义了辅助数据结构用于存放边。

算法设计

普利姆算法。
辅助数据结构说明：
（1）一维数组nearest，nearest[v]存放与v距离最近的顶点编号u，距离最近是指边（u，v）是所有与顶点v关联的边中权值最小的边。初始时，nearest[v] = -1.
（2）一维数组lowcost，lowcost[v]用于存放边（nearest[v],v）的权值。初始时lowcost[v]=INFINITY。INFINITY是假定的极大值。
（3）一维数组mark，mark[v]用于标记顶点v是否在生成树中，若mark[v]=0，表示顶点v未加入生成树；否则，表示v已加入生成树。初始时，mark[v]=0。
算法步骤：
（1）分别将数组nearest，lowcost，mark初始化并将源点加入生成树。
（2）循环n-1次，重复以下操作。
a.查找顶点k的未加入生成树的所有邻接顶点j，若边（k,j）的权值比lowcost[j]小，则将lowcost[j]更新为此权值，并令lowcost[j]=k。
b.在未加入生成树的顶点中，查找具有最小lowcost的顶点k。
c.将k加入生成树。

克鲁斯卡尔算法。
辅助数据结构说明：
（1）一维数组Edge,从邻接矩阵中获取所有边以及边对应的顶点保存在数组Edge中，并且采用排序算法对边按照权值递增排序。
（2）一维数组parent，用于标识各个顶点所属的连通分量，若两个顶点属于不同的连通分量，则将这两个顶点关联的边加入到生成树中。parent[i]表示顶点i所属的连通分量，初始时parent[i]=i，表示各顶点自成一个连通分量。
算法步骤：
（1）从邻接矩阵中获取所有边存储于数组Edge。
（2）调用快速排序对数组Edge边按权值从小到大排序
（3）变量k表示当前构造的最小代价生成树中的边数，其初始值为0，若k<n-1，则循环执行以下操作。
a.依次从Edge中取出边（u，v）
对u和v所在连通分量paren[u]和parent[v]进行判断，若两者不相等，表示两顶点属于不同连通分量，输出此边，并合并paren[u]和parent[v]两个连通分量；若paren[u]和parent[v]相等，表示属于同一连通分量，舍去此边而选择下一条最小的边。

详细设计

普利姆算法生成最小代价生成树文件Prim_main.c、Prim.c、Prim.h
Prim_main.c

#include <stdio.h>
#include <stdlib.h>
#include "Prim.h"
int main()
{
    // 以下为图例1
    LGraph *lg = (LGraph *)malloc(sizeof(LGraph));
    if (!Init(lg, 6))
    {
        printf("邻接表初始化失败\n");
        return 0;
    }
    // 定义边集数组然后利用循环加入到图中
    int e[18][3] = {{0, 1, 10}, {1, 0, 10}, {1, 4, 2}, {4, 1, 2}, {4, 3, 9}, 
                    {3, 4, 9}, {0, 5, 4}, {5, 0, 4}, {4, 5, 7}, {5, 4, 7}, 
                    {0, 2, 7}, {2, 0, 7}, {2, 5, 6}, {5, 2, 6}, {3, 5, 5}, 
                    {5, 3, 5}, {2, 3, 8}, {3, 2, 8}};
    for (int i = 0; i < 18; i++)
    {
        if (!Insert(lg, e[i][0], e[i][1], e[i][2]))
        {
            printf("边插入失败\n");
            return 0;
        }
    }
    int nearest[6] = {0};
    int lowcost[6] = {0};
    if (!Prim(0, nearest, lowcost, *lg))    // 构造最小生成树，以结点0为源点
    {
        printf("最小生成树构造失败\n");
    }
    printf("图例1最小代价生成树的边集如下：\n");
    int sum = 0;    // 计算最小权值之和
    for (int i = 0; i < lg->n; i++) // 输出最小代价生成树的边集
    {
        printf("(%d,%d,%d) ",nearest[i],i,lowcost[i]);
        sum+=lowcost[i];
    }
    printf("\n最小权值和为%d\n",sum);
    // 以上为图例1
    printf("----------------------------\n");
    // 以下为图例2
    LGraph *lg_2 = (LGraph *)malloc(sizeof(LGraph));
    if (!Init(lg_2, 6))
    {
        printf("邻接表初始化失败\n");
        return 0;
    }
    // 定义边集数组然后利用循环加入到图中
    int e_2[20][3] = {{0, 1, 6}, {1, 0, 6}, {0, 2, 1}, {2, 0, 1}, {0, 3, 5}, 
                    {3, 0, 5}, {1, 2, 5}, {2, 1, 5}, {2, 3, 5}, {3, 2, 5}, 
                    {1, 4, 3}, {4, 1, 3}, {3, 5, 2}, {5, 3, 2}, {2, 4, 6}, 
                    {4, 2, 6}, {2, 5, 4}, {5, 2, 4}, {4, 5, 6}, {5, 4, 6}};
    for (int i = 0; i < 20; i++)
    {
        if (!Insert(lg_2, e_2[i][0], e_2[i][1], e_2[i][2]))
        {
            printf("边插入失败\n");
            return 0;
        }
    }
    int nearest_2[6] = {0};
    int lowcost_2[6] = {0};
    if (!Prim(0, nearest_2, lowcost_2, *lg_2))  // 构造最小生成树，以0为源点
    {
        printf("最小生成树构造失败\n");
    }
    printf("图例2最小代价生成树的边集如下：\n");
    sum = 0;
    for (int i = 0; i < lg_2->n; i++)   // 输出最小代价生成树的边集
    {
        printf("(%d,%d,%d) ",nearest_2[i],i,lowcost_2[i]);
        sum+=lowcost_2[i];
    }
    printf("\n最小权值和为%d\n",sum);
    printf("输入回车结束程序。\n");
    getchar();
    Destroy(lg);
    Destroy(lg_2);
}

Prim.h

#ifndef __PRIM_H__
#define __PRIM_H__
typedef struct eNode    // 边结点
{
    int adjVex;            // 顶点v
    int w;                 // 点u与点v之间的权值
    struct eNode *nextArc; // 指向下一个结点
} ENode;
typedef struct lGraph   // 邻接表
{
    int n; // 图顶点数
    int e; // 图边数
    ENode **a;  // 指向一维指针的数组
} LGraph;
#define INFINITY 65535  // 假定一个无限值

int Init(LGraph *lg, int nSize);                       // 邻接表初始化
void Destroy(LGraph *lg);                              // 邻接表的撤销
int Exist(LGraph *lg, int u, int v);                   // 边搜索
int Insert(LGraph *lg, int u, int v, int w);           // 边插入
int Prim(int k, int *nearest, int *lowcost, LGraph g); // 普利姆算法
#endif

Prim.c

#include "Prim.h"
#include <stdlib.h>
#include <stdio.h>
/**
 * @brief 邻接表初始化
 * @param lg 指向邻接表的指针
 * @param nSize 顶点个数
 * @return 0，初始化失败；1，初始化成功
*/
int Init(LGraph *lg, int nSize)
{
    lg->n = nSize;
    lg->e = 0;
    lg->a = (ENode **)malloc(nSize * sizeof(ENode *)); // 动态生成长度为n的一维指针数组
    if (!lg->a)   // 判断空间申请是否成功
    {
        return 0; // 申请空间失败
    }
    else
    {
        for (int i = 0; i < lg->n; i++)
        {
            lg->a[i] = NULL; // 将指针数组a置空
        }
        return 1; // 申请空间成功
    }
}
/**
 * @brief 邻接表的撤销
 * @param lg 指向邻接表的指针
 * @return void
*/
void Destroy(LGraph *lg)
{
    int i;
    ENode *p,*q;
    for(i = 0;i<lg->n;i++)
    {
        p = lg->a[i];
        q=p;
        while(p)
        {
            p = p->nextArc;
            free(q);
            q=p;
        }
    }
    free(lg->a);
}
// 边搜索
/**
 * @brief 边搜索
 * @param lg 指向邻接表的指针
 * @param u 边的始点
 * @param v 边的终点
 * @return 0，搜索失败或顶点有误；1，搜索成功
*/
int Exist(LGraph *lg, int u, int v)
{
    ENode *p = NULL;
    if(u<0||v<0||u>lg->n-1||v>lg->n-1||u==v)
    {

        return 0;  // 判断顶点是否有误
    }
    p=lg->a[u];
    while(p&&p->adjVex != v)
    {
        p = p->nextArc;
    }
    if(!p)
    {
        return 0;  // 未找到边
    }
    else
    {
        return 1;   // 找到边
    }
}
// 边插入
/**
 * @brief 边插入
 * @param lg 指向邻接表的指针
 * @param u 边的始点
 * @param v 边的终点
 * @param w 边的权值
 * @return 0，插入失败或边已存在；1，插入成功
*/
int Insert(LGraph *lg, int u, int v, int w)
{
    ENode *p = NULL;
    if(u<0||v<0||u>lg->n-1||v>lg->n-1||u==v)
    {

        return 0;  // 判断顶点是否有误
    }
    if(Exist(lg,u,v))
    {
        printf("边已存在。\n");
        return 0;
    }
    p = (ENode*)malloc(sizeof(ENode));  // 为新结点分配空间
    p->adjVex = v;
    p->w = w;
    
    // 将新结点插入单链表的最前面，头插
    p->nextArc = lg->a[u];  
    lg->a[u] = p;
    
    lg->e++;
    return 1;
}
// 普利姆算法
/**
 * @brief 普利姆算法生成最小代价生成树
 * @param k 源点
 * @param nearest 存放顶点的最近顶点编号
 * @param lowcost 存放顶点距离最近点的距离
 * @param g 邻接表
 * @return 0,失败；1，成功
*/
int Prim(int k, int *nearest, int *lowcost, LGraph g)
{
    ENode *p;
    int i,j;
    int *mark = (int*)malloc(g.n*sizeof(int));  // 辅助数组
    if(k<0||k>g.n-1)    // 判断源点是否有效
    {
        return 0;
    }
    for(i = 0;i<g.n;i++)    // nearest数组，lowcost数组和mark数组初始化
    {
        nearest[i] = -1;
        lowcost[i] = INFINITY;
        mark[i]=0;  // 赋值为1表示结点加入生成树，0表示未加入
    }

    // 源点k加入生成树
    lowcost[k] = 0;
    nearest[k]=k;
    mark[k] = 1;
    
    for(i = 1;i<g.n;i++)    // 将其余n-1条边加入生成树
    {
        for(p = g.a[k];p;p = p->nextArc)    // 更新生成树外的顶点lowcost值
        {
            j=p->adjVex;
            if((!mark[j])&&(lowcost[j]>p->w))
            {
                lowcost[j] = p->w;
                nearest[j] = k;
            }
        }
        int min = INFINITY;
        for(j = 0;j<g.n;j++)    // 找生成树外顶点中具有最小lowcost值的顶点k
        {
            if((!mark[j])&&(lowcost[j]<min))
            {
                min = lowcost[j];
                k = j;
            }
        }
        mark[k]=1;  // 将顶点k加入生成树
    }
    return 1;
}

克鲁斯卡尔算法生成最小代价生成树文件Kruskal_main.c、Kruskal.h、Kruskal.c
Kruskal_main.c

#include <stdio.h>
#include <stdlib.h>
#include "Kruskal.h"
int main()
{
    // 图例1
    MGraph *mg = (MGraph*)malloc(sizeof(MGraph));
    if(!Init(mg,6))
    {
        printf("邻接矩阵初始化失败\n");
    }
    // 定义边集数组然后利用循环加入到图中
    int e[9][3] = {{0,1,10},{1,4,2},{0,2,7},{0,5,4},{4,5,7},
                        {3,4,9},{2,5,6},{3,5,5},{2,3,8}};
    
    for(int i = 0;i<9;i++)
    {
        if(!Insert(mg,e[i][0],e[i][1],e[i][2]))
        {
            printf("边插入失败\n");
        }
    }
    Edge *edg = (Edge*)malloc(mg->e*sizeof(Edge));  // 辅助数据结构，存放边集
    int k = 0;
    for(int i = 0;i<mg->n;i++)
    {
        for(int j = 0; j<i;j++)
        {
            if(mg->a[i][j]!=0&&mg->a[i][j]!=INFINITY)
            {
                edg[k].u = i;
                edg[k].v = j;
                edg[k].w = mg->a[i][j];
                k++;
            }
        }
    }
    int sum = 0;    // 计算最小代价生成树权值和
    printf("图例1最小代价生成树的边集如下：\n");
    Kruskal(mg,edg,&sum);
    printf("\n最小代价生成树权值和为：%d\n",sum);
    // 以上为图例1
    printf("-------------------------\n");
    // 以下为图例2
    MGraph *mg_2 = (MGraph*)malloc(sizeof(MGraph));
    if(!Init(mg_2,6))
    {
        printf("邻接矩阵初始化失败\n");
    }
    // 定义边集数组然后利用循环加入到图中
    int e_2[10][3] = {{0,1,6},{0,2,1},{0,3,5},{1,2,5},{2,3,5},
                    {1,4,3},{2,4,6},{2,5,4},{3,5,2},{4,5,6}};
    for(int i = 0;i<10;i++)
    {
        if(!Insert(mg_2,e_2[i][0],e_2[i][1],e_2[i][2]))
        {
            printf("边插入失败\n");
        }
    }
    Edge *edg_2 = (Edge*)malloc(mg_2->e*sizeof(Edge));
    k = 0;
    for(int i = 0;i<mg_2->n;i++)
    {
        for(int j = 0; j<i;j++)
        {
            if(mg_2->a[i][j]!=0&&mg_2->a[i][j]!=INFINITY)
            {
                edg_2[k].u = i;
                edg_2[k].v = j;
                edg_2[k].w = mg_2->a[i][j];
                k++;
            }
        }
    }
    sum = 0;    // 计算最小代价生成树权值和
    printf("图例2最小代价生成树的边集如下：\n");
    Kruskal(mg_2,edg_2,&sum);
    printf("\n最小代价生成树权值和为：%d\n",sum);
    printf("输入回车结束程序。\n");
    getchar();
    Destroy(mg);
    Destroy(mg_2);
}

Kruskal.h

#ifndef __KRUSKAL_H__
#define __DRUSKAL_H__
typedef struct mGraph
{
    int **a; // 邻接矩阵
    int n;   // 图的顶点数
    int e;   // 图的边数
} MGraph;
typedef struct edge // 辅助数据结构，保存邻接矩阵的边
{
    int u;  // 边的始点
    int v;  // 边的终点
    int w;  // 边的权值
} Edge;
#define INFINITY 65535  // 假定一个最大值，给边赋值表示顶点间不可达
int Init(MGraph *mg, int nSize);                // 邻接矩阵初始化
void Destroy(MGraph *mg);                       // 邻接矩阵的撤销
int Insert(MGraph *mg, int u, int v, int w);    // 边插入
int FindParent(int *parent, int a);             // 查结点树根
void Swap(Edge *edg, int i, int j);             // 交换函数
int Partition(Edge *edg, int left, int right);  // 分划函数
void QuickSort(Edge *edg, int left, int right); // 快速排序
void Kruskal(MGraph *mg, Edge *edg,int *sum);            // 克鲁斯卡尔算法生成最小代价生成树
#endif

Kruskal.c

#include <stdio.h>
#include <stdlib.h>
#include "Kruskal.h"
/**
 * @brief 邻接矩阵初始化
 * @param mg 指向待初始化的矩阵指针
 * @param nSize 顶点数
 * @return 0，初始化失败；1，初始化成功
*/
int Init(MGraph *mg, int nSize)
{
    mg->n = nSize;  // 初始化顶点数
    mg->e = 0;
    mg->a = (int**)malloc(nSize*sizeof(int*));
    if(!mg->a)
    {
        return 0;   // 初始化失败
    }
    for(int i = 0;i<mg->n;i++)  // 循环初始化每条边
    {
        mg->a[i] = (int*)malloc(nSize*sizeof(int));
        for(int j = 0; j<mg->n; j++)
        {
            mg->a[i][j] = INFINITY;
        }
        mg->a[i][i] = 0;
    }
    return 1;   // 初始化成功
}
/**
 * @brief 邻接矩阵的撤销
 * @param mg 指向待撤销的矩阵的指针
 * @return void
*/
void Destroy(MGraph *mg)
{
    for(int i = 0; i<mg->n; i++)
    {
        free(mg->a[i]);
    }
    free(mg->a);
}
/**
 * @brief 边插入 
 * @param mg 指向待邻接矩阵的指针
 * @param u 要插入边的始点
 * @param v 要插入边的终点
 * @param w 边的权值
 * @return 0，插入失败或边已存在；1，边插入成功
*/
int Insert(MGraph *mg, int u, int v, int w)
{
    if(u<0||v<0||u>mg->n-1||v>mg->n-1||u==v)
    {
        return 0;   // 插入失败
    }
    if(mg->a[u][v] != INFINITY)
    {
        printf("边已存在\n");
        return 0;
    }
    mg->a[u][v] = w;    // 插入新边
    mg->a[v][u] = w;
    mg->e++;
    return 1;   // 插入成功
}
/**
 * @brief 查找顶点的树根
 * @param parent 存放所有结点树根的数组
 * @param a 待查找树根的结点
 * @return 返回a的树根
*/
int FindParent(int *parent,int a)
{
    int t = a;
    while(t != parent[t])
    {
        t = parent[t];
    }
    return t;
}
/**
 * @brief 交换函数
 * @param edg 存放边以及边相关信息的数组
 * @param i 数组下标
 * @param j 数组下标
 * @return void
*/
void Swap(Edge *edg,int i, int j)
{
    Edge tmp;
    tmp = edg[i];
    edg[i] = edg[j];
    edg[j] = tmp;
}
/**
 * @brief 分划函数，由快速排序调用
 * @param edg 存放边以及边相关信息的数组
 * @param left 数组下标，左边界
 * @param right 数组下标，右边界
 * @return j，快速排序分划元素的下标
*/
int Partition(Edge *edg,int left,int right)
{
    int i = left;
    int j = right+1;
    do
    {
        do
        {
            i++;
        }while(edg[i].w<edg[left].w);
        do
        {
            j--;
        } while(edg[j].w>edg[left].w);
        if(i<j)
        {
            Swap(edg,i,j);
        }
    }while(i<j);
    Swap(edg, left, j);
    return j;
}
/**
 * @brief 快速排序
 * @param edg 存放边以及边相关信息的数组
 * @param left 数组下标，左边界
 * @param right 数组下标，右边界
 * @return void
*/
void QuickSort(Edge *edg, int left, int right)
{
    if(left<right)
    {
        int j = Partition(edg, left, right);
        QuickSort(edg, left, j-1);
        QuickSort(edg, j+1,right);
    }
}
/**
 * @brief 克鲁斯卡尔算法生成最小代价生成树
 * @param mg 指向邻接矩阵的指针
 * @param edg 存放边以及边相关信息的数组
 * @param sum 计算最小代价生成树权值之和
 * @return void
*/
void Kruskal(MGraph *mg, Edge *edg,int *sum)
{
    int u1,v1;  // 记录顶点的根结点
    int *parent = (int*)malloc(mg->n*sizeof(int));  // 记录所有顶点的根结点，用于判断选取的边是否使生成的树构成回路
    for(int i = 0;i<mg->n;i++)  // 初始化使每个顶点的根结点为自己
    {
        parent[i] = i;
    }
    QuickSort(edg, 0, mg->e-1); // 将保存边的数组按权值由小到大排序
    int count = 0;
    for(int i = 0;i<mg->e;i++)
    {
        u1 = FindParent(parent,edg[i].u);   // 查找顶点的根结点
        v1 = FindParent(parent,edg[i].v);
        if(u1 != v1)    // 根结点不同，表示不属于同一颗树
        {
            count++;
            parent[u1] = v1;    // 合并根节点
            printf("(%d,%d,%d) ",edg[i].u,edg[i].v,edg[i].w); // 输出属于最小生成树的边集
            *sum += edg[i].w;
        }
        if(count == mg->n-1)    // 最小生成树边数e等于顶点数n-1，提前退出
        {
            break;
        }
    }
}

测试数据及其结果分析

普利姆算法生成最小代价生成树图例1
在这里插入图片描述
在这里插入图片描述

图例2
在这里插入图片描述
在这里插入图片描述

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

克鲁斯卡尔算法生成最小代价生成树图例1
在这里插入图片描述
在这里插入图片描述

图例2
在这里插入图片描述
在这里插入图片描述

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

总结

由普利姆算法的时间复杂度O(n2),普利姆算法更适合当图中边的数量远大于点的数量的情形，在电路设计中可以应用于印刷电路板的布线问题以减少导线长度。由克鲁斯卡尔算法的时间复杂度O(eloge)，克鲁斯卡尔算法更适合当图中点的数量远大于边的数量的情形，与普利姆算法类似，也可以用于优化连接路径的问题。

DAOkonglong
关注
  • 31
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】最小生成树的概念
四季轮换叶，一路招摇胜
09-15 2822
最小生成树是连通图的生成树；是图的极小连通子树，它包含图中的全部顶点，但只有构成一颗树的边。
数据结构之最小生成树（Prim算法）
爱科比的博客
04-29 7660
最小生成树问题是实际生产生活中十分重要的一类问题。假设需要在n个城市之间建立通信联络网，则连通n个城市只需要n-1条线路。这时，自然需要考虑这样一个问题，即如何在最节省经费的前提下建立这个通信网。 可以用连通网来表示n个城市以及n个城市之间可能设置的通信线路，其中网的顶点表示城市，边表示两个城市之间的线路，赋于边的权值表示相应的代价。对于n个顶点的连通网可以建立许多不同的生成树，每一棵生成树都可...
数据结构—最小生成树
莫浅子的博客
12-17 9585
设R为G的所有生成树的集合，若T为R中边的权值之和最小的生成树，则T称为G的最小生成树（Minimum-Spanning-Tree,MST)。所以不选，在找，权值是5的有俩个，然而，学校和矿场确是俩通的，只能选农场和P城，选完以后发现全部连通。在从剩余的边中找到权值最小的，有俩个是P城和矿场以及P城和渔村，随便选都行。然后找那个点，到P城和学校形成的树中，最小代价的，我们可以看到，只有矿场到P城是最小的。然后看哪个点到这个三个点形成的树最小的代价，知道渔村是最小的，连接矿场和渔村。所以连接P城和矿场。
数据结构与算法——最小生成树
墨鱼菜鸡
09-09 1158
1 引言 在之前的文章中已经详细介绍了图的一些基础操作。而在实际生活中的许多问题都是通过转化为图的这类数据结构来求解的，这就涉及到了许多图的算法研究。 例如：在n个城市之间铺设光缆，以保证这n个城市中的任意两个城市之间都可以通信。由于铺设光缆的价格很高，且各个城市之间的距离不同，这就使得在各个城市之间铺设光缆的价格不同。那么如何选择...
最小代价生成树算法
qq_31220203的博客
07-27 6032
Kruskal算法 Prim算法 Sollin算法
最小生成树——Prim算法与Kruskal算法
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
07-05 1373
讲解图论中构造最小生成树的Prim算法思想，并通过C语言实现算法。
数据结构与算法之最小生成树
five-five
06-16 1069
连通图的生成树是包含图中全部顶点的一个极小连通子图。若图中顶点数为 n，则它的生成树含有 n−1n-1n−1条边。对于生成树而言，若砍去它的一条边，则会变成非连通图，若加上一条边则会形成一个回路。如下图，思考：道路规划要求：所有地方都连通，且成本尽可能的低 下面是提供的两种方案，看图： 此处引出最小生成树的概念，又称为最小代价树。对于一个带权连通无向图 G=(V,E)G=(V,E)G=(V,E)，生成树不同，每颗树的权 (即树中所有边上的权值之和) 也可能不同。设 R 为 G 的所有生成树的集合，若 T 为
【数据结构与算法】最小生成树之普里姆(Prim)算法和克鲁斯卡尔(Kruskal)算法
青竹雾色间.的博客
05-31 9627
最小生成树(Minimum Spanning Tree,简称MST)是一个无向连通图中包含所有顶点的最短边集。在许多实际问题中，找到一个最小生成树对于理解和解决这些问题至关重要。本文将介绍最小生成树的概念、求解方法以及其在实际应用中的一些例子。
【数据结构】最小生成树Prim算法
zgsdlr的博客
11-19 2452
概况 最小生成树是是原图的极小连通子图，是最小权重生成树的简称。其特点是：图中包含原图中的所有 n 个结点，并且有保持图连通的最少的边。 求最小生成树有两种算法，分别是：Kruskal（克鲁斯卡尔）算法、Prim（普里姆）算法。 本文将介绍笔者对Prim算法的理解。Kruskal算法将在后续文章介绍。 Prim算法 该算法需要用邻接矩阵存储图（使用edge数组记录边的权值，vertex数组存储顶点数据）。 class MGraph { public: MGraph(DataType a[ ], in
Java数据结构与算法——最小生成树
梦想不会灭
05-08 2124
一、关于图的几个概念定义： 连通图：在无向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该无向图为连通图。 强连通图：在有向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该有向图为强连通图。 连通网：在连通图中，若图的边具有一定的意义，每一条边都对应着一个数，称为权；权代表着连接连个顶点的代价，称这种连通图叫做连通网。 生成树：一个连通图的生成树是指一个连通子图，它含有图中全部n个顶点，但只有足以构成一棵树的n-1条边。一颗有n个顶点的生成树有且仅有n-1条边，如果生成树中再添加一条边
最小生成树(MTS)之Kruskal数据结构与算法
12-30
最小生成树：minimum spanning tree 在连通网的所有生成树中，所有边的代价和最小的生成树，称为最小生成树。 Kruskal不是最小生成树的最有效算法，但却是学习图论必不可少的一步。 本代码旨在帮助初学图论的编程...
最小生成树_prim_数据结构_课设_最小生成树_
10-04
问题描述：给定一个地区的n个城市间的距离网，用Prim算法或Kruskal算法建立最小生成树，并计算得到的最小生成树的代价。基本要求：1、城市间的距离网采用邻接矩阵表示，邻接矩阵的存储结构定义采用课本中给出的定义...
Prim算法计算最小生成树（无向图&邻接矩阵）_算法_数据结构_
10-02
Prim算法是一种求解加权无向图的最小生成树的经典算法，由Eugene W. Prim于1957年提出。本文将深入探讨Prim算法的原理、步骤以及C语言的实现。 **Prim算法的基本思想**： Prim算法的主要思想是从一个起始顶点开始，...
C++ Prim算法Kruskal算法构造可以使n个城市连接的最小生成树
06-12
（1）、实验题目：给定一个地区的n 个城市间的距离网，用Prim算法或Kruskal算法建立最小生成树，并得到的最小生成树的代价。 （2）、实验要求： 1、城市间的距离网采用的邻接矩阵表示，邻接矩阵的存储结构定义采用...
prim算法生成最小代价生成树
06-25
Prim算法通过逐步构造一棵包含越来越多顶点的树，最终形成一个覆盖所有顶点的最小代价生成树。算法从任意一个顶点开始，每次添加一条与当前树中顶点相邻的、代价最小的边，直到所有顶点都被包括在内。关键在于维护一...
代码随想录算法训练营第33天
m0_62262158的博客
07-10 156
【代码】代码随想录算法训练营第33天。
牛客小白月赛98 （个人题解）（补全）
最新发布
Wzh20060111的博客
07-13 267
前言：昨天晚上自己一个人打的小白月赛（因为准备数学期末已经写烦了），题目难度感觉越来越简单了（不在像以前一样根本写不了一点，现在看题解已经能看懂一点了），能感受到自己在不断进步，希望在暑假能更努力一点吧，，少打点游戏，多学学算法，还有web的学习也要抓起来了，这几天不是在看高数就是在打游戏，感觉好堕落。
代码随想录算法训练营Day21 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树
wonderlandlja的博客
07-11 160
【代码】代码随想录算法训练营Day21 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树。
【代码随想录算法训练营第六十二天|卡码网53.寻宝（prim算法和kruskal算法）】
weixin_46281930的博客
07-09 473
kruskal算法以边为导向，先把边按照长度从小到大排序，然后一个个检查边的两个端点是否在同一个集合中（这里使用并查集判断），在同一个集合中就不加入这个边，不在的话就加入。可以把所有已经使用过的结点看作一个整体，然后把他们相接的结点的结点顶点边中进行选择，选择最短的一条边把该结点入树，某种程度来说也是一种贪心？1.选择当前最短入树结点；3.更新结点距离最小生成树的距离。
城市通信网络建设系统.docx
03-13
。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值