【笔记】图的连通性

最新推荐文章于 2023-12-03 16:44:32 发布

Time-space

最新推荐文章于 2023-12-03 16:44:32 发布

阅读量2.9k

点赞数 2

分类专栏：数据结构数据结构文章标签：克鲁斯卡尔算法普里姆算法最小生成树图的最短路径图的连通性

本文链接：https://blog.csdn.net/cbwem/article/details/78682706

版权

数据结构同时被 2 个专栏收录

42 篇文章 5 订阅

订阅专栏

数据结构

24 篇文章 1 订阅

订阅专栏

无向图的连通分量
最小生成树的概念
普里姆算法
克鲁斯卡尔算法
应用示例

1.无向图的连通分量

在对无向图进行遍历时，对于连通图，仅需从图的任何一个顶点出发进行深度优先搜索遍历或广度优先搜索遍历就可访问到图中的所有顶点；对于非连通图，则需从多个顶点出发进行搜索，而且每一次从一个新的起始点出发进行搜索过程中得到的顶点访问序列恰为其各个连通分量中的顶点集。
如下图所示，图 $G_3$ 是非连通图且有3个连通分量，因此在对图 $G_3$ 进行深度优先遍历时，需要从图的至少3个顶点出发，才能完成对图中的每个顶点的访问。

设E(G)为连通图G中所有边的集合，则从图中任意顶点出发遍历图时，必定将E(G)分成两个集合T(G)和B(G)，其中T(G)是遍历图过程中经过的边的集合，B(G)是剩余边的集合。显然，T(G)和图G中所有的顶点一起构成连通图G的极小连通子图，它是连通图的一棵生成树。由深度优先搜索得到的为深度优先生成树，由广度优先爱你搜索得到的为广度优先生成树。

对于非连通图，从某一个顶点出发，对图进行深度优先搜索遍历或者广度优先搜索遍历，按照访问路径会得到若干颗生成树，这些生成树放在一起就构成了森林。

为了判断一个图是否为连通图，可通过对图进行深度优先搜索或广度优先搜索，若调用遍历图的函数不止一次，则说明该图是非连通的，否则该图为连通图。

2.最小生成树的概念

设G=(V,E)是连通图，E中每条边(u,v)的权为c(u,v)，也叫边长。图G的一棵生成树是连接V中所有顶点的一棵开放树。将生成树中所有边长的总和称为生成树的价。使这个价最小的生成树称为图G的最小生成树。

最小生成树的性质：设G=(V,E)是一个连通图，在E上定义一个权函数C，且 $\{(V_1,T_1),(V_2,T_2),…,(V_k,T_k)\}$ 是G的任意生成森林。令
$T = U k i = 1 T i (K > 1)$ $T=U^k_{i=1}T_i (K>1)$
又设e=(v,w)是E-T中的一条边，其权值C[v][w]最小，而且 $v \in V_1$ 、 $w \in V_1$ ，则图中G有一棵包含 $T \cup \{e\}$ 的生成树，其价不大于T的任何生成树的价。

证明：用反证法。假设所有的最小生成树都不存在这样的一条边(u,v)。设T是连通网N中的一棵最小生成树，如果将边(u,v)加入T中，根据生成树的定义，T一定出现包含(u,v)的回路。另外，T中一定存在一条边(u’,v’)的权值大于或等于(u,v)的最小生成树，这与假设矛盾。由此性质得证。

普里姆(prim)算法和克鲁斯卡尔(kruskal)算法就是利用MST性质构造的最小生成树的算法。

3.普里姆算法

假设N={V,E}是连通网，TE是N的最小生成树边的集合，执行如下操作：

初始时，令 $U={u_0}(u_0\in V)$ ， $TE=\emptyset$ 。
对于所有边 $u \in U ,v \in V-U$ 的边 $(u,v)\in E$ ，将一条代价最小的边 $(u_0,v_0)$ 放到集合TE中，同时将顶点 $v_0$ 放进集合U中。
重复执行步骤2，直到U=V为止。

这时，边集合TE一定有n-1条边，T={V,TE}就是连通网N的最小生成树。

这里写图片描述

为了实现这个算法，需附设一个辅助数组closeedge[MaxSize]，以记录U到U-V最小代价的边。对于每个顶点 $v\in V-U$ ，在辅助数组中存在一个相应分量closeedge[v]，它包括adjvex和lowcost两个域，adjvex域用来表示该边中属于U中的顶点，lowcost域存储该边对应的权值，即

c l o s e e d g e [v] . l o w c o s t = M i n (c o s t (u, v) | u \in U)

$closeedge[v].lowcost=Min({cost(u,v)|u \in U})$

根据普里姆算法构造最小生成树，其对应过程中各个参数的变化情况如下表所示。

// 记录从顶点集U到V-U的代价最小的边的辅助数组定义
typedef struct
{
    VertexType adjvex;
    VRType lowcost;
}Closedge[MAX_VERTEX_NUM];
// 用普里姆算法从第u个顶点出发构造网G的最小生成树T,输出T的各条边
void MiniSpanTree_PRIM(MGraph G,VertexType u)
{
    int i,j,k;
    Closedge closedge;
    k=LocateVex(G,u);
    for(j=0;j<G.vexnum;++j) // 辅助数组初始化 
    {
        if(j!=k)
        {
            strcpy(closedge[j].adjvex,u);
            closedge[j].lowcost=G.arcs[k][j].adj;
        }
    }
    closedge[k].lowcost=0; // 初始时,U={u} 
    printf("最小代价生成树的各条边为:\n");
    for(i=1;i<G.vexnum;++i)
    { // 选择其余G.vexnum-1个顶点 
        k=MiniNum(closedge,G); // 求出T的下一个结点：第K顶点 
        printf("(%s-%s)\n",closedge[k].adjvex,G.vexs[k]); // 输出生成树的边 
        closedge[k].lowcost=0; // 第K顶点并入U集 
        for(j=0;j<G.vexnum;++j)
            if(G.arcs[k][j].adj<closedge[j].lowcost)
            {
                // 新顶点并入U集后重新选择最小边 
                strcpy(closedge[j].adjvex,G.vexs[k]);
                closedge[j].lowcost=G.arcs[k][j].adj;
            }
    }
}

程序疑难详解：
数组closedge的变化，数组closedege的adjvx域存放的是每条边的起始点名字，closedge的下标表示每条边的终结点下标，closedge表示边的最小代价。在MiniSpanTree_PRIM算法中，先确定集合U的元素，即出发顶点。

    k=LocateVex(G,u);

然后对closedge进行初始化，即把初始顶点赋给closedge的adjvex域，最小代价边赋给lowcost域，并将第一个顶点加入U集。

for(j=0;j<G.vexnum;++j) // 辅助数组初始化 
    {
        if(j!=k)
        {
            strcpy(closedge[j].adjvex,u);
            closedge[j].lowcost=G.arcs[k][j].adj;
        }
    }
    closedge[k].lowcost=0; // 初始时,U={u}

调用函数MiniNum求代价最小的边，k为终结点的序号。例如无向网N第一条代价最小的边为(a,c)，则有k=2，所以closedge[2].adjvex为a，G.vexs[2]为c，输出(a,c)，并将第k个顶点加入U集。

for(i=1;i<G.vexnum;++i)
    { // 选择其余G.vexnum-1个顶点 
        k=MiniNum(closedge,G); // 求出T的下一个结点：第K顶点 
        printf("(%s-%s)\n",closedge[k].adjvex,G.vexs[k]); // 输出生成树的边 
        closedge[k].lowcost=0; // 第K顶点并入U集

更新closedge数组中的lowcost域，使其为当前状况下边的代价最小。

for(j=0;j<G.vexnum;++j)
            if(G.arcs[k][j].adj<closedge[j].lowcost)
            {
                // 新顶点并入U集后重新选择最小边 
                strcpy(closedge[j].adjvex,G.vexs[k]);
                closedge[j].lowcost=G.arcs[k][j].adj;
            }
    }

普里姆算法有两个嵌套的for循环，假设顶点个数是n，则第一层循环的频度为n-1，第二层循环的频度为n，因此该算法的时间复杂度为 $O(n^2)$ ，与网中的边数无关，因此普里姆算法适用于求边稠密的最小生成树。

4.克鲁斯卡尔算法

假设N={V,E}是连通网，TE是N的最小生成树边的集合，执行如下操作：

初始时，最小生成树中只有n个顶点，这n个顶点分别属于不同的集合，而边的集合 $TE=\emptyset$ 。
从连通网N中选择一个嗲家最小的边，如果边所依附的两个顶点在不同的集合中，将该边加入到最小生成树中TE中，并将该边衣服的两个顶点合并到一个集合中。
重复执行步骤2，直到所有的顶点都属于同一个顶点集合为止。

//用克鲁斯卡尔算法求最小生成树
void Kruskal(MGraph G)
{
    int set[MAX_VERTEX_NUM],i,j;
    int a=0,b=0,min=G.arcs[a][b].adj,k=0;
    for(i=0;i<G.vexnum;i++)                  //初始时，各顶点分别属于不同的集合
        set[i]=i;
    printf("克鲁斯卡尔算法求得的最小生成树的各条边为：\n");
    while(k<G.vexnum-1)                      //查找所有最小权值的边
    {
        for(i=0;i<G.vexnum;i++)              //在矩阵的上三角查找最小权值的边
        {
            for(j=i+1;j<G.vexnum;j++)
            {
                if(G.arcs[i][j].adj<min)
                {
                    min=G.arcs[i][j].adj;
                    a=i;
                    b=j;
                }
            }
        }
        min=G.arcs[a][b].adj=INFINITY; //删除上三角中最小权值的边，下次不再查找
        if(set[a]!=set[b])            //如果边的两个顶点在不同的集合上
        {
            printf("%s-%s\n",G.vexs[a],G.vexs[b]);//输出最小权值的边
            k++;
            for(i=0;i<G.vexnum;i++)
            {
                if(set[i]==set[b])    //将顶点b所在集合并入顶点a集合中
                set[i]=set[a];
            }
        }
    }
}

克鲁斯卡尔算法的时间复杂度为 $O(eloge)$ （其中e为网中边的数目），因此它相对于普里姆算法来说，适合于求边稀疏的最小生成树。

5.应用示例

创建一个上图所示的无向网N，利用普里姆算法求无向网的最小生成树。

#include"malloc.h"
#include"stdlib.h"
#include"stdio.h"
#include <string.h>
#define MAX_VERTEX_NUM 20   /*最大顶点个数*/
#define MAX_NAME 3           /*顶点字符串的最大长度+1 */
#define INFINITY 65535        /*65535代表整型最大值*/
typedef int VRType;
typedef char InfoType;
typedef char VertexType[MAX_NAME];

// 邻接矩阵的数据结构
typedef struct
{
    VRType adj; // 顶点关系类型。对无权图，用1(是)或0(否)表示相邻否；
                // 对带权图，则为权值类型
    InfoType *info; // 该弧相关信息的指针(可无)
 }ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

// 图的数据结构
typedef struct
{
    VertexType vexs[MAX_VERTEX_NUM];    // 顶点向量
    AdjMatrix arcs;     // 邻接矩阵
    int vexnum,         // 图的当前顶点数
        arcnum;         // 图的当前弧数
} MGraph;

// 记录从顶点集U到V-U的代价最小的边的辅助数组定义
typedef struct
{
    VertexType adjvex;
    VRType lowcost;
}Closedge[MAX_VERTEX_NUM];


// 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1。
int LocateVex(MGraph G,VertexType u)
{
    int i;
    for(i = 0; i < G.vexnum; ++i)
        if( strcmp(u, G.vexs[i]) == 0)
            return i;
    return -1;
}

// 采用数组(邻接矩阵)表示法,构造无向网G。
int CreateAN(MGraph *G)
{
    int i,j,k,w;
    VertexType va,vb;
    printf("请输入无向网G的顶点数和边数(以空格作为间隔): ");
    scanf("%d%d%*c",&(*G).vexnum,&(*G).arcnum);
    printf("请输入%d个顶点的值(每个顶点的字符数<%d个字符):\n",(*G).vexnum,MAX_NAME);
    for(i=0;i<(*G).vexnum;++i) // 构造顶点向量
        scanf("%s",(*G).vexs[i]);
    for(i=0;i<(*G).vexnum;++i) // 初始化邻接矩阵
        for(j=0;j<(*G).vexnum;++j)
        {
            (*G).arcs[i][j].adj=INFINITY; // 网初始化为无穷大
            (*G).arcs[i][j].info=NULL;
        }
    printf("请输入%d条边的顶点1 顶点2 权值(以空格作为间隔): \n",(*G).arcnum);
    for(k=0;k<(*G).arcnum;++k)
    {
        scanf("%s%s%d%*c",va,vb,&w); // %*c吃掉回车符
        i=LocateVex(*G,va);
        j=LocateVex(*G,vb);
        (*G).arcs[i][j].adj=(*G).arcs[j][i].adj=w; // 无向图
    }
    return 1;
}
// 求closedge.lowcost的最小正值
int MiniNum(Closedge edge,MGraph G)
{
    int i=0,j,k,min;
    while(!edge[i].lowcost)
        i++;
    min=edge[i].lowcost; // 第一个不为0的值
    k=i;
    for(j=i+1;j<G.vexnum;j++)
        if(edge[j].lowcost>0)
            if(min>edge[j].lowcost)
            {
                min=edge[j].lowcost;
                k=j;
            }
    return k;
}

// 用普里姆算法从第u个顶点出发构造网G的最小生成树T,输出T的各条边
void PRIM(MGraph G,VertexType u)
{
    int i,j,k;
    Closedge closedge;
    k=LocateVex(G,u);
    for(j=0;j<G.vexnum;++j) // 辅助数组初始化
    {
        if(j!=k)
        {
            strcpy(closedge[j].adjvex,u);
            closedge[j].lowcost=G.arcs[k][j].adj;
        }
    }
    closedge[k].lowcost=0; // 初始时,U={u}
    printf("普里姆算法求得的最小代价生成树的各条边为:\n");
    for(i=1;i<G.vexnum;++i)
    { // 选择其余G.vexnum-1个顶点
        k=MiniNum(closedge,G); // 求出T的下一个结点：第K顶点
        printf("(%s-%s)\n",closedge[k].adjvex,G.vexs[k]); // 输出生成树的边
        closedge[k].lowcost=0; // 第K顶点并入U集
        for(j=0;j<G.vexnum;++j)
            if(G.arcs[k][j].adj<closedge[j].lowcost)
            {
                // 新顶点并入U集后重新选择最小边
                strcpy(closedge[j].adjvex,G.vexs[k]);
                closedge[j].lowcost=G.arcs[k][j].adj;
            }
    }
}

//用克鲁斯卡尔算法求最小生成树
void Kruskal(MGraph G)
{
    int set[MAX_VERTEX_NUM],i,j;
    int a=0,b=0,min=G.arcs[a][b].adj,k=0;
    for(i=0;i<G.vexnum;i++)                  //初始时，各顶点分别属于不同的集合
        set[i]=i;
    printf("克鲁斯卡尔算法求得的最小生成树的各条边为：\n");
    while(k<G.vexnum-1)                      //查找所有最小权值的边
    {
        for(i=0;i<G.vexnum;i++)              //在矩阵的上三角查找最小权值的边
        {
            for(j=i+1;j<G.vexnum;j++)
            {
                if(G.arcs[i][j].adj<min)
                {
                    min=G.arcs[i][j].adj;
                    a=i;
                    b=j;
                }
            }
        }
        min=G.arcs[a][b].adj=INFINITY; //删除上三角中最小权值的边，下次不再查找
        if(set[a]!=set[b])            //如果边的两个顶点在不同的集合上
        {
            printf("%s-%s\n",G.vexs[a],G.vexs[b]);//输出最小权值的边
            k++;
            for(i=0;i<G.vexnum;i++)
            {
                if(set[i]==set[b])    //将顶点b所在集合并入顶点a集合中
                set[i]=set[a];
            }
        }
    }
}

void main()
{
    int i,j;
    MGraph G;
    CreateAN(&G);
    printf("图的邻接矩阵为：\n");
    for(i=0; i<G.vexnum; i++)
    {
        for(j=0; j<G.vexnum; j++)
            printf("%d       ",G.arcs[i][j].adj);
        printf("\n");
    }
    PRIM(G,G.vexs[0]);
    Kruskal(G);
}

测试结果

Time-space

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
【笔记】图的连通性

无向图的连通分量最小生成树的概念普里姆算法克鲁斯卡尔算法应用示例1.无向图的连通分量在对无向图进行遍历时，对于连通图，仅需从图的任何一个顶点出发进行深度优先搜索遍历或广度优先搜索遍历就可访问到图中的所有顶点；对于非连通图，则需从多个顶点出发进行搜索，而且每一次从一个新的起始点出发进行搜索过程中得到的顶点访问序列恰为其各个连通分量中的顶点集。如下图所示，图G3
复制链接

扫一扫