图之kruskal算法

最新推荐文章于 2024-06-15 09:15:00 发布
最新推荐文章于 2024-06-15 09:15:00 发布
阅读量7.4k 收藏 11
点赞数 3
分类专栏： 算法 算法系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TODD911/article/details/9257255
版权

kruskal算法是一种最小生成树算法。基本思想如下：

设有一个有n个顶点的连通网N={V,E},最初先构造一个只有n个顶点，没有边的非连通图T={V, E},图中每个顶点自成一个连通分量。当在E中选到一条具有最小权值的边时,若该边的两个顶点落在不同的连通分量上，则将此边加入到T中；否则将此边舍去，重新选择一条权值最小的边。如此重复下去，直到所有顶点在同一个连通分量上为止。

下面举例说明kruskal算法：






c语言实现如下：（使用邻接矩阵存储）

#include <stdio.h>
#include <malloc.h>

#define VERTEXNUM 6
#define TRUE 1
#define FALSE 0

void createGraph(int (*edge)[VERTEXNUM], int start, int end, int value);
void displayGraph(int (*edge)[VERTEXNUM]);
void kruskal(int (*edge)[VERTEXNUM], int (**tree)[VERTEXNUM]);
void selectEdge(int (*edge)[VERTEXNUM], int (*tree)[VERTEXNUM], int* start, int* end, int* value);
int isInSeparate(int (*tree)[VERTEXNUM], int start, int end);
void isInSeparateCore(int (*tree)[VERTEXNUM], int vertex, int end, int* vertexStatusArr, int* result);
int isNotInTree(int (*tree)[VERTEXNUM], int start, int end);
int isTree(int (*tree)[VERTEXNUM]);
void isTreeCore(int (*tree)[VERTEXNUM], int vertex, int* vertexStatusArr, int* vertexNum);

int main(void){
	//动态创建存放边的二维数组 
        int (*edge)[VERTEXNUM] = (int (*)[VERTEXNUM])malloc(sizeof(int)*VERTEXNUM*VERTEXNUM);
        int i,j;
        for(i=0;i<VERTEXNUM;i++){
                for(j=0;j<VERTEXNUM;j++){
                        edge[i][j] = 0;
                }
        }

	//打印图
        printf("after init:\n");
        displayGraph(edge);
	//创建图(从顶点0到1有一条权值为6的边，从顶点1到0有一条权值为6的边，依次类推)
        createGraph(edge,0,1,6);
        createGraph(edge,0,3,5);
        createGraph(edge,0,2,1);
        createGraph(edge,1,2,5);
        createGraph(edge,1,4,3);
        createGraph(edge,2,4,6);
        createGraph(edge,2,3,5);
        createGraph(edge,2,5,4);
        createGraph(edge,3,5,2);
        createGraph(edge,4,5,6);

	//打印图
        printf("after create:\n");
        displayGraph(edge);

	//最小生成树 
        int (*tree)[VERTEXNUM] = NULL;
        kruskal(edge, &tree);
        printf("after generate tree:\n");
        displayGraph(tree);
	
	//释放占用的资源 
        free(edge);
        free(tree);
        return 0;
}
//创建图，从start顶点到end顶点，权值为value；从end顶点到start顶点，权值为value；
void createGraph(int (*edge)[VERTEXNUM], int start, int end, int value){
        edge[start][end] = value;
        edge[end][start] = value;
}
//打印图
void displayGraph(int (*edge)[VERTEXNUM]){
        int i,j;
        for(i=0;i<VERTEXNUM;i++){
                for(j=0;j<VERTEXNUM;j++){
                        printf("%d ",edge[i][j]);
                }
                printf("\n");
        }
}
//最小生成树 
void kruskal(int (*edge)[VERTEXNUM], int (**tree)[VERTEXNUM]){
	//申请最小生成树占用的资源 
        *tree = (int (*)[VERTEXNUM])malloc(sizeof(int)*VERTEXNUM*VERTEXNUM);
        int i,j;
        for(i=0;i<VERTEXNUM;i++){
                for(j=0; j<VERTEXNUM; j++){
                        (*tree)[i][j] = 0;
                }
        }

        int start,end,value;
	//如果目前为止生成的还不是树
        while(!isTree(*tree)){
                start = end = -1;
                value = 999;
		//选择合适的边
                selectEdge(edge, *tree, &start, &end, &value);
                if(start != -1 && end != -1 && value != 999){
			//将边保存到tree中
                        createGraph(*tree, start, end, value);
                }
        }
}
//选择合适的边
void selectEdge(int (*edge)[VERTEXNUM], int (*tree)[VERTEXNUM], int* start, int* end, int* value){
        if(edge == NULL || tree == NULL || start == NULL || end == NULL || value == NULL){
                printf("parameter error.\n");
                return;
        }

        int i,j;
	//访问所有的边，只需要访问一部分就可以了,另外一部分是相同的
        for(i=0; i<VERTEXNUM-1; i++){
                for(j=i+1; j<VERTEXNUM; j++){
			//如果权值最小，并且不在生成的tree中，并且在不同的连通分量中，则选择该边  
                        if(edge[i][j] != 0 && edge[i][j] < *value && isNotInTree(tree, i, j) && isInSeparate(tree, i, j)){
                                *start = i;
                                *end = j;
                                *value = edge[i][j];
                        }
                }
        }
}

//判断start和end顶点是否在不同的连通分量中 
int isInSeparate(int (*tree)[VERTEXNUM], int start, int end){
        if(tree == NULL){
                printf("parameter error.\n");
                return FALSE;
        }

        int i,j;
        int result = 0;
        int* vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);
        for(i=0;i<VERTEXNUM;i++){
                vertexStatusArr[i] = 0;
        }
        isInSeparateCore(tree, start, end, vertexStatusArr, &result);
        free(vertexStatusArr);
        if(result == 1){
                return FALSE;
        }else{
                return TRUE;
        }

}

void isInSeparateCore(int (*tree)[VERTEXNUM], int vertex, int end, int* vertexStatusArr, int* result){
        if(*result == 1){
                return;
        }

        int i;
        for(i=0; i<VERTEXNUM; i++){
                if(tree[vertex][i] != 0 && vertexStatusArr[i] == 0){
                        vertexStatusArr[i] = 1;
                        if(i == end){
                                *result = 1;
                                return;
                        }
                        isInSeparateCore(tree, i, end, vertexStatusArr, result);
                }
        }
}

//判断start和end是否已经在tree中  
int isNotInTree(int (*tree)[VERTEXNUM], int start, int end){
        if(tree == NULL){
                printf("parameter error.\n");
                return FALSE;
        }

        if(tree[start][end] == 0 && tree[end][start] == 0){
                return TRUE;
        }
        return FALSE;
}

//判断tree是否是树（从一个顶点从发，是否能够遍历到所有的点）  
int isTree(int (*tree)[VERTEXNUM]){
        if(tree == NULL){
                printf("tree is not exist.\n");
                return FALSE;
        }

        int i;
        int vertexNum = 0;
        int* vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);
        for(i=0;i<VERTEXNUM;i++){
                vertexStatusArr[i] = 0;
        }
        isTreeCore(tree, 0, vertexStatusArr, &vertexNum);

        free(vertexStatusArr);
        if(vertexNum != VERTEXNUM){
                return FALSE;
        }else{
                return TRUE;
        }
}

void isTreeCore(int (*tree)[VERTEXNUM], int vertex, int* vertexStatusArr, int* vertexNum){
        int i;
        for(i=0; i<VERTEXNUM; i++){
                if(tree[vertex][i] != 0 && vertexStatusArr[i] == 0){
                        vertexStatusArr[i] = 1;
                        (*vertexNum)++;
                        isTreeCore(tree, i, vertexStatusArr, vertexNum);
                }
        }
}

c语言实现如下：（使用邻接表存储）

#include <stdio.h>
#include <malloc.h>

#define VERTEXNUM 6
#define TRUE 1
#define FALSE 0
//存放顶点的邻接表元素
typedef struct edge{
        int vertex;
        int value;
        struct edge* next;
}st_edge;

void createGraph(st_edge** edge, int start, int end, int value);
void displayGraph(st_edge** edge);
void delGraph(st_edge** edge);
void kruskal(st_edge** edge, st_edge*** tree);
void selectEdge(st_edge** edge, st_edge** tree, int* start, int* end, int* value);
void saveEdge(st_edge** tree, int start, int end, int value);
int isInSeparate(st_edge** tree, int start, int end);
void isInSeparateCore(st_edge** tree, st_edge* node, int end, int* vertexStatusArr, int* result);
int isNotInTree(st_edge** tree, int start, int end);
int isTree(st_edge** tree);
void isTreeCore(st_edge** tree, st_edge* node, int* vertexStatusArr, int* vertexNum);

int main(void){
	//动态创建存放边的指针数组
        st_edge** edge = (st_edge**)malloc(sizeof(st_edge*)*VERTEXNUM);
        int i;
        for(i=0;i<VERTEXNUM;i++){
                edge[i] = NULL;
        }
	//打印图
        printf("after init:\n");
        displayGraph(edge);
	//创建图
        createGraph(edge,0,1,6);
        createGraph(edge,0,3,5);
        createGraph(edge,0,2,1);
        createGraph(edge,1,2,5);
        createGraph(edge,1,4,3);
        createGraph(edge,2,4,6);
        createGraph(edge,2,3,5);
        createGraph(edge,2,5,4);
        createGraph(edge,3,5,2);
        createGraph(edge,4,5,6);
	//打印图
        printf("after create:\n");
        displayGraph(edge);
	
        st_edge** tree = NULL;
	//最小生成树
        kruskal(edge, &tree);
	//打印图
        printf("after generate tree:\n");
        displayGraph(tree);
	
	//释放占用的资源
        if(edge != NULL){
                delGraph(edge);
                edge = NULL;
        }

        if(tree != NULL){
                delGraph(tree);
                tree = NULL;
        }

        return 0;
}

//创建图，从start顶点到end顶点，权值为value；从end顶点到start顶点，权值为value；
void createGraph(st_edge** edge, int start, int end, int value){
        if(edge == NULL){
                printf("no space for graph.\n");
                return;
        }
        st_edge* newedge1 = (st_edge*)malloc(sizeof(st_edge));
        newedge1->vertex = end;
        newedge1->value = value;
        newedge1->next = NULL;
        st_edge** edge1 = edge + start;
        while(*edge1 != NULL){
                edge1 = &((*edge1)->next);
        }
        *edge1 = newedge1;

        st_edge* newedge2 = (st_edge*)malloc(sizeof(st_edge));
        newedge2->vertex = start;
        newedge2->value = value;
        newedge2->next = NULL;
        st_edge** edge2 = edge + end;
        while(*edge2 != NULL){
                edge2 = &((*edge2)->next);
        }
        *edge2 = newedge2;
}
//打印图
void displayGraph(st_edge** edge){

        if(edge == NULL){
                printf("graph is not exist.\n");
                return;
        }

        int i;
        st_edge* p;
        for(i=0;i<VERTEXNUM;i++){
                printf("%d:",i);
                p = *(edge+i);
                while(p != NULL){
                        printf("%d(%d) ",p->vertex,p->value);
                        p = p->next;
                }
                printf("\n");
        }
}
//删除图
void delGraph(st_edge** edge){
        if(edge == NULL){
                printf("graph is not exist.\n");
                return;
        }

        int i;
        st_edge* p;
        st_edge* del;
        for(i=0;i<VERTEXNUM;i++){
                p = *(edge+i);
                while(p != NULL){
                        del = p;
                        p = p->next;
                        free(del);
                }
                edge[i] = NULL;
        }
        free(edge);
}
//最小生成树
void kruskal(st_edge** edge, st_edge*** tree){
	//申请最小生成树占用的资源
        *tree = (st_edge**)malloc(sizeof(st_edge*)*VERTEXNUM);
        int i;
        for(i=0;i<VERTEXNUM;i++){
                (*tree)[i] = NULL;
        }

        int start,end,value;
	//如果目前为止生成的还不是树
        while(!isTree(*tree)){
                start = end = -1;
                value = 999;
		//选择合适的边
                selectEdge(edge, *tree, &start, &end, &value);
                if(start != -1 && end != -1 && value != 999){
			//将边保存到tree中
                        createGraph(*tree, start, end, value);
                }
        }
}
//选择合适的边
void selectEdge(st_edge** edge, st_edge** tree, int* start, int* end, int* value){
        if(edge == NULL || tree == NULL || start == NULL || end == NULL || value == NULL){
                printf("parameter error.\n");
                return;
        }

        int i;
        st_edge* p = NULL;
	//遍历所有的边
        for(i=0; i<VERTEXNUM; i++){
                p = edge[i];
                while(p != NULL){
			//如果权值最小，并且不在生成的tree中，并且在不同的连通分量中，则选择该边
                        if(p->value < *value && isNotInTree(tree, i, p->vertex) && isInSeparate(tree, i, p->vertex)){
                                *start = i;
                                *end = p->vertex;
                                *value = p->value;
                        }
                        p = p->next;
                }
        }
}

//判断start和end顶点是否在不同的连通分量中
int isInSeparate(st_edge** tree, int start, int end){
        if(tree == NULL){
                printf("parameter error.\n");
                return FALSE;
        }

        int i;
        st_edge* startNode = tree[start];
        int result = 0;
        int* vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);
        for(i=0;i<VERTEXNUM;i++){
                vertexStatusArr[i] = 0;
        }
        isInSeparateCore(tree, startNode, end, vertexStatusArr, &result);
	free(vertexStatusArr);

        if(result == 1){
                return FALSE;
        }else{
                return TRUE;
        }
}

void isInSeparateCore(st_edge** tree, st_edge* node, int end, int* vertexStatusArr, int* result){
        if(*result == 1){
                return;
        }

        while(node !=  NULL){
                if(vertexStatusArr[node->vertex] == 0){
                        vertexStatusArr[node->vertex] = 1;
                        if(node->vertex == end){
                                *result = 1;
                                return;
                        }
                        isInSeparateCore(tree, tree[node->vertex], end, vertexStatusArr, result);
                }
                node = node->next;
        }
}

//判断start和end是否已经在tree中
int isNotInTree(st_edge** tree, int start, int end){
        if(tree == NULL){
                printf("parameter error.\n");
                return FALSE;
        }

        int i;
        st_edge* p;
        p = tree[start];
        while(p != NULL){
                if(p->vertex == end){
                        return FALSE;
                }
                p = p->next;
        }
        return TRUE;
}

//判断tree是否是树（从一个顶点从发，是否能够遍历到所有的点）
int isTree(st_edge** tree){
        if(tree == NULL){
                printf("tree is not exist.\n");
                return FALSE;
        }

        int i;
        int vertexNum = 0;
        st_edge* startNode = tree[0];
        int* vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);
        for(i=0;i<VERTEXNUM;i++){
                vertexStatusArr[i] = 0;
        }
        isTreeCore(tree, startNode, vertexStatusArr, &vertexNum);

        free(vertexStatusArr);
        if(vertexNum != VERTEXNUM){
                return FALSE;
        }else{
                return TRUE;
        }
}

void isTreeCore(st_edge** tree, st_edge* node, int* vertexStatusArr, int* vertexNum){
        if(tree == NULL || vertexStatusArr == NULL || vertexNum == NULL){
                printf("parameter error!\n");
                return;
        }

        while(node != NULL){
                if(vertexStatusArr[node->vertex] == 0){
                        vertexStatusArr[node->vertex] = 1;
                        (*vertexNum)++;
                        isTreeCore(tree, tree[node->vertex], vertexStatusArr, vertexNum);
                }
                node = node->next;
        }
}


TODD911
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Kruskal 算法介绍
实践求真知
07-10 9530
构造最小生成树还有一种算法，即 Kruskal 算法：设图 G=（V，E）是无向连通带权图，V={1,2，...n};设最小生成树 T=(V，TE)，该树的初始状态只有 n 个节点而无边的非连通图T=(V,{}),Kruskal 算法将这n 个节点看成 n 个孤立的连通分支。它首先将所有边都按权值从小到大排序，然后值要在 T 中选的边数不到 n-1,就做这样贪心选择：在边集 E 中选择权值最小的边(i,j),如果将边(i,j)加入集合 TE 中不产生回路，则将边(i,j)加入边集 TE 中，即用边(i，j)
图论之kruskal算法
Foverve1的博客
08-01 565
kruskal算法是一种生成最小生成树的经典算法，时间复杂度为eloge（e为边数）此算法主要三部分组成：  for(i=1;i father[i]=i;//节点祖先初始化为其本身 2. int find(int a)//判断两个子树是否是同一个祖先 { if(a!=father[a]) return father[a]=find(father[a]);/
图的最小生成树——Kruskal算法
weixin_33989058的博客
12-02 722
Kruskal算法的思想如下 假设有n个顶点的连通图。首先先构造有顶点构成的集合0，每个顶点都是一个集合，不含有任何边。 在边找一个最小权值的边 判断这个边的俩个顶点是否来自于两个不同的集合，若是就将它俩归并为一个集合，然后将这个边添加到要构成的图的集合中。 直到上述的边的个数为顶点个数-1；否则，重复2-3；算法构成树的过程如下： 如a图所示的图，...
Kruskal算法详解
最新发布
Weirdo的博客
06-15 692
Kruskal算法是一种基于贪心策略和并查集的数据结构来解决最小生成树问题的有效算法。它通过不断选择权值最小的边并检查是否形成环来构建最小生成树。算法的时间复杂度和空间复杂度都较为优秀，因此在实际应用中得到了广泛的应用。通过本文的详解和C++代码实现，读者可以更加深入地理解Kruskal算法的原理和实现过程。
图中的最小生成树——Kruskal算法
Lin's Blog
10-31 457
Kruskal算法描述 Kruskal算法是基于贪心的思想得到的。首先我们把所有的边按照权值先从小到大排列，接着按照顺序选取每条边，如果这条边的两个端点不属于同一集合，那么就将它们合并，直到所有的点都属于同一个集合为止。至于怎么合并到一个集合，那么这里我们就可以用到一个工具——-并查集。换而言之，Kruskal算法就是基于并查集的贪心算法。 接下来以例子说明： 忽略动态效果，这里只关注节点的连
图的Kruskal算法
coolsunxu的博客
06-11 187
#include &lt;iostream&gt; #include &lt;vector&gt; #include &lt;queue&gt; #define MaxSize 10 #define eletype int using namespace std; bool visited[MaxSize][MaxSize]; //全局数组，记录结点是否已补访问 typedef struc...
图论算法——Kruskal算法
黄子乐的博客
06-27 600
Kruskal 算法是针对最小生成树的一个算法，不优化的时间复杂度是O（e^2），用并查集优化的时间复杂度就是O（eloge）其中e为边数。 所以就可以看出，并查集对Kruskal的优化还是很大的。 我们先来看看Kruskal针对的到底是一个什么样的问题： •输入一个有权无向连通图G，在已有的边中删掉尽可能多的边得到一个新的图G’。使得G’依旧是连通图并且剩余的边权值之和最小,请输出G’中所有
Kruskal算法.docx
05-25
Kruskal算法是一种用于寻找图的最小生成树的经典算法，由Joseph Kruskal在1956年提出。它的核心思想是贪心策略，即在每次选择边时，优先选择权重最小的边，同时避免形成环路。在这个过程中，我们可以使用并查集...
代码 最小生成树kruskal算法离散型优化问题代码
06-04
代码 最小生成树kruskal算法离散型优化问题代码代码 最小生成树kruskal算法离散型优化问题代码代码 最小生成树kruskal算法离散型优化问题代码代码 最小生成树kruskal算法离散型优化问题代码代码 最小生成树kruskal...
数据结构课程设计报告最小生成树Kruskal算法
06-05
数据结构课程设计报告中，我们将使用Kruskal算法来生成最小生成树，该算法是图论中的一种经典算法，能够在给定的图中找到最小生成树。下面，我们将对Kruskal算法的实现进行详细的描述。 首先，我们需要定义图的存储...
Kruskal算法动态演示（3）
07-01
Kruskal算法是数据结构中求图的最小生成树的一个经典算法，也是数据结构课程设计的重点，这里把自己的一点工作分享给大家交流参考，希望能够造福后来者
图的最小生成树的实现(Kruskal算法)
03-01
图的最小生成树的实现(Kruskal算法)
Kruskal算法动态演示
07-01
Kruskal算法是数据结构中求图的最小生成树的一个经典算法，也是数据结构课程设计的重点，这里把自己的一点工作分享下，供大家参考
Prim与Kruskal算法的最小生成树matlab实现
05-26
在通信网理论作业3-最小生成树这个项目中，你可能会学习如何用MATLAB编写代码，实现Prim和Kruskal算法，并对给定的网络图数据进行最小生成树的构造。这将涉及到数据结构的设计、图的遍历以及最小生成树的验证等编程...
Kruskal算法python实现
06-21
Kruskal算法python实现，包括无向图的绘制，需要自己在桌面上先建关于无向图的TXT
图的最小生成树之Kruskal算法
code_peak
08-08 868
参考：https://wangkuiwu.github.io/2013/04/12/kruskal-cplus Kruskal算法介绍 克鲁斯卡尔（Kruskal）算法，和普利姆（Prim）算法类似，也是用来求加权连通图的最小生成树的算法。关于最小生成树的概念，已经在之前的图的最小生成树之Prim算法篇首介绍过。 Kruskal 与 Prim 算法思想出发点不同，Prim 算法是以顶点出发的，而 Kruskal 算法是以边出发的。 其算法思想是：按照权值从小到大的顺序选择 n-1 条边，并保证这 n-1 条
数据结构10 图的经典算法-- Kruskal算法
m0_51427019的博客
05-30 231
系列文章目录 深度优先算法 DFS 广度优先算法 BFS Prim算法 Kruskal算法 Dijkstra算法 系列文章将会写图的经典的几种，有错误的地方欢迎在评论中提出。 文章目录系列文章目录深度优先算法 DFS广度优先算法 BFSPrim算法Kruskal算法Dijkstra算法前言一、Prim算法简介二、Prim算法证明1.方法2.笔者自己的想法三.Prim算法的代码实现（c语言）1.prim算法的部分2.全部代码 前言 提示：Prim算法和Kruskal算法是为了实现图中的最小生成树的算法。不
图结构（七）- Kruskal算法
AnndyR的专栏
01-27 572
一、最小生成树 在含有n个顶点的连通图中选择n-1条边，构成一棵极小连通子图，并使该连通子图中n-1条边上权值之和达到最小，则称其为连通网的最小生成树。 例如，对于如上图G4所示的连通网可以有多棵权值总和不相同的生成树。 二、克鲁斯卡尔算法介绍 克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。 基本思想：按照权值从小到大的顺序选择n-1条边，并保证这n-
使用Kruskal算法构建最小生成树
在课程设计中，学生被要求编写一个程序，该程序能够处理带权图，并利用Kruskal算法找出图的最小生成树。 1. **课程设计内容** 学生需要实现的程序能够创建一个图，其中顶点的信息用字符串表示，权重自定义。程序...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值