c/c++ 用克鲁斯卡尔(kruskal)算法构造最小生成树

最小生成树(Minimum Cost Spanning Tree)的概念:

假设要在n个城市之间建立公路,则连通n个城市只需要n-1条线路。这时,自然会考虑,如何在最节省经费的前提下建立这个公路网络。

每2个城市之间都可以设置一条公路,相应地都要付出一定的经济代价。n个城市之间,最多可以设置n(n-1)/2条线路,那么,如何在这些可能的线路中选择n-1条,以使总的耗费最少?

克鲁斯卡尔(kruskal)算法的大致思路:

把每条边的权重按照从小到大排序后,连接。连接时,需要查看要连接的两个顶点的父节点是否相同,不同才可以连接,连接后,更新父节点。

图为下图:

第一步

图1

第二步

图2

第三步

图3

第四步

A->D,C->D,B->C的权重都是5,这时就不知道连哪个了,所以要创建2个辅助函数is_same,mark_same。

is_same用来判断要连接的2个点的父节点是否相同,如果相同就说明了,连接后,图就存在了环,所以不可以连接,放弃这条边,去寻找下一条边。

mark_same用来更新节点的父节点。

当拿到的节点是AD时,发现AD的父节点都是A,所以放弃;

当拿到的节点是CD时,发现AD的父节点都是A,所以放弃;

当拿到的节点是BC时,发现B的父节点是自己,C的父节点是A,父节点不同,所以连接,并更父节点

图4

找一半的矩阵,把各条边的起点,终点,权重,放到edge数组里

图5

mixSpanTree.h

#ifndef __mixspantree__
#define __mixspantree__ #include <stdio.h>
#include <malloc.h>
#include <assert.h>
#include <memory.h>
#include <stdlib.h>
#include <stdbool.h> #define Default_vertex_size 20 #define T char//dai biao ding dian de lei xing
#define E int
#define MAX_COST 0x7FFFFFFF typedef struct GraphMtx{
int MaxVertices;//zui da ding dian shu liang]
int NumVertices;//shi ji ding dian shu liang
int NumEdges;//bian de shu lian T* VerticesList;//ding dian list
int** Edge;//bian de lian jie xin xi, bu shi 0 jiu shi 1
}GraphMtx; typedef struct Edge{
int begin;//边的起点
int end; //边的终点
E cost; //边的权重
}Edge; //chu shi hua tu
void init_graph(GraphMtx* gm);
//打印二维数组
void show_graph(GraphMtx* gm);
//插入顶点
void insert_vertex(GraphMtx* gm, T v);
//添加顶点间的线
void insert_edge(GraphMtx* gm, T v1, T v2, E cost); //用kruskal算法构造最小生成树
void minSpanTree_kruskal(GraphMtx* gm); #endif

mixSpanTree.c

#include "mixSpanTree.h"

void init_graph(GraphMtx* gm){
gm->MaxVertices = Default_vertex_size;
gm->NumEdges = gm->NumVertices = 0; //kai pi ding dian de nei cun kong jian
gm->VerticesList = (T*)malloc(sizeof(T) * (gm->MaxVertices));
assert(NULL != gm->VerticesList); //创建二维数组
//让一个int的二级指针,指向一个有8个int一级指针的数组
//开辟一个能存放gm->MaxVertices个int一级指针的内存空间
gm->Edge = (int**)malloc(sizeof(int*) * (gm->MaxVertices));
assert(NULL != gm->Edge);
//开辟gm->MaxVertices组,能存放gm->MaxVertices个int的内存空间
for(int i = 0; i < gm->MaxVertices; ++i){
gm->Edge[i] = (int*)malloc(sizeof(int) * gm->MaxVertices);
}
//初始化二维数组
//让每个顶点之间的边的关系都为不相连的
for(int i = 0; i < gm->MaxVertices; ++i){
for(int j = 0; j < gm->MaxVertices; ++j){
if(i == j)
gm->Edge[i][j] = 0;
else
gm->Edge[i][j] = MAX_COST;
}
}
}
//打印二维数组
void show_graph(GraphMtx* gm){
printf(" ");
for(int i = 0; i < gm->NumVertices; ++i){
printf("%c ", gm->VerticesList[i]);
}
printf("\n");
for(int i = 0; i < gm->NumVertices; ++i){
//在行首,打印出顶点的名字
printf("%c:", gm->VerticesList[i]);
for(int j = 0; j < gm->NumVertices; ++j){
if(gm->Edge[i][j] == MAX_COST){
printf("%c ", '*');
}
else{
printf("%d ", gm->Edge[i][j]);
}
}
printf("\n");
}
printf("\n");
}
//插入顶点
void insert_vertex(GraphMtx* gm, T v){
//顶点空间已满,不能再插入顶点了
if(gm->NumVertices >= gm->MaxVertices){
return;
}
gm->VerticesList[gm->NumVertices++] = v;
} int getVertexIndex(GraphMtx* gm, T v){
for(int i = 0; i < gm->NumVertices; ++i){
if(gm->VerticesList[i] == v)return i;
}
return -1;
}
//添加顶点间的线
void insert_edge(GraphMtx* gm, T v1, T v2, E cost){
if(v1 == v2)return; //查找2个顶点的下标
int j = getVertexIndex(gm, v1);
int k = getVertexIndex(gm, v2);
//说明找到顶点了,并且点之间还没有线
if(j != -1 && k != -1 ){
//因为是无方向,所以更新2个值
gm->Edge[j][k] = gm->Edge[k][j] = cost;
//边数加一
gm->NumEdges++;
}
} //比较边的权重,本函数作为快速排序函数的参数来使用。
int cmp(const void* a, const void* b){
return ((*(Edge*)a).cost - (*(Edge*)b).cost);
}
//判断参数的2个顶点的父节点是否相同
bool is_same(int* father, int begin, int end){
while(father[begin] != begin){
begin = father[begin];
}
while(father[end] != end){
end = father[end];
}
return begin == end;
}
//找到end节点的父节点x,再找到begin节点的父节点y,更新x节点的父节点为y
void mark_same(int* father, int begin, int end){
while(father[begin] != begin){
begin = father[begin];
}
while(father[end] != end){
end = father[end];
}
father[end] = begin; }
//用kruskal算法构造最小生成树
void minSpanTree_kruskal(GraphMtx* g){ int n = g->NumVertices;
Edge* edge = (Edge*)malloc(sizeof(Edge) * n*(n-1)/2);
assert(edge != NULL); int k = 0;
//查找一半的矩阵,把各条边的起点,终点,权重,放到edge数组里,参照上面的图5
for(int i = 0; i < n; ++i){
for(int j = i; j < n; j++){
if(g->Edge[i][j] != 0 && g->Edge[i][j] != MAX_COST){
edge[k].begin = i;
edge[k].end = j;
edge[k].cost = g->Edge[i][j];
k++;
}
}
} //按照权重来排序(用系统函数)
//第一个参数:要被排序的数组
//第二个参数:数组中元素的个数
//第三个参数:每个数组元素占用的内存空间
//第四个参数:函数指针,指定排序的规则
qsort(edge, k, sizeof(Edge), cmp); //初始化每个节点的父节点,让每个节点的父节点为自身
int *father = (int*)malloc(sizeof(int) * n);
assert(NULL != father);
for(int i = 0; i < n; ++i){
father[i] = i;
} for(int i = 0; i < n; ++i){
//判断2个节点的父节点是否相同,不相同就连接
if(!is_same(father, edge[i].begin, edge[i].end)){
printf("%c->%c:%d\n",g->VerticesList[edge[i].begin],g->VerticesList[edge[i].end], edge[i].cost);
//连接后,找到节点end的父节点x,再找到节点begin的父节点y,把节点x的父节点更新为y
mark_same(father, edge[i].begin, edge[i].end);
}
}
}

mixSpanTreemain.c

#include "mixSpanTree.h"

int main(){
GraphMtx gm;
//初始化图
init_graph(&gm);
//插入顶点
insert_vertex(&gm, 'A');
insert_vertex(&gm, 'B');
insert_vertex(&gm, 'C');
insert_vertex(&gm, 'D');
insert_vertex(&gm, 'E');
insert_vertex(&gm, 'F'); //添加连线
insert_edge(&gm, 'A', 'B', 6);
insert_edge(&gm, 'A', 'D', 5);
insert_edge(&gm, 'A', 'C', 1);
insert_edge(&gm, 'B', 'E', 3);
insert_edge(&gm, 'B', 'C', 5);
insert_edge(&gm, 'C', 'E', 6);
insert_edge(&gm, 'C', 'D', 5);
insert_edge(&gm, 'C', 'F', 4);
insert_edge(&gm, 'F', 'E', 6);
insert_edge(&gm, 'D', 'F', 2);
//打印图
show_graph(&gm); //kruskal
minSpanTree_kruskal(&gm); }

完整代码

编译方法:gcc -g mixSpanTree.c mixSpanTreemain.c

c/c++ 用克鲁斯卡尔(kruskal)算法构造最小生成树的更多相关文章

  1. 克鲁斯卡尔(Kruskal)算法求最小生成树

    /* *Kruskal算法求MST */ #include <iostream> #include <cstdio> #include <cstring> #inc ...

  2. 图的生成树(森林)(克鲁斯卡尔Kruskal算法和普里姆Prim算法)、以及并查集的使用

    图的连通性问题:无向图的连通分量和生成树,所有顶点均由边连接在一起,但不存在回路的图. 设图 G=(V, E) 是个连通图,当从图任一顶点出发遍历图G 时,将边集 E(G) 分成两个集合 T(G) 和 ...

  3. 洛谷P3366【模板】最小生成树-克鲁斯卡尔Kruskal算法详解附赠习题

    链接 题目描述 如题,给出一个无向图,求出最小生成树,如果该图不连通,则输出orz 输入输出格式 输入格式: 第一行包含两个整数N.M,表示该图共有N个结点和M条无向边.(N<=5000,M&l ...

  4. Kruskal算法构造最小生成树

    Kruskal算法来构造最小生成树,我总结了分为以下步骤: (1)建图,构造Kruskal边集,边集元素应该包括该边的起始顶点.终止顶点.权值: (2)将边集按权值从小到大的顺序进行排序: (3)从小 ...

  5. 克鲁斯卡尔(Kruskal)算法

    # include <stdio.h> # define MAX_VERTEXES //最大顶点数 # define MAXEDGE //边集数组最大值 # define INFINITY ...

  6. 图解最小生成树 - 克鲁斯卡尔(Kruskal)算法

    我们在前面讲过的<克里姆算法>是以某个顶点为起点,逐步找各顶点上最小权值的边来构建最小生成树的.同样的思路,我们也可以直接就以边为目标去构建,因为权值为边上,直接找最小权值的边来构建生成树 ...

  7. 经典问题----最小生成树(kruskal克鲁斯卡尔贪心算法)

    题目简述:假如有一个无向连通图,有n个顶点,有许多(带有权值即长度)边,让你用在其中选n-1条边把这n个顶点连起来,不漏掉任何一个点,然后这n-1条边的权值总和最小,就是最小生成树了,注意,不可绕成圈 ...

  8. 最小生成树——Kruskal(克鲁斯卡尔)算法

    [0]README 0.1) 本文总结于 数据结构与算法分析, 源代码均为原创, 旨在 理解 Kruskal(克鲁斯卡尔)算法 的idea 并用 源代码加以实现: 0.2)最小生成树的基础知识,参见 ...

  9. c/c++ 用普利姆(prim)算法构造最小生成树

    c/c++ 用普利姆(prim)算法构造最小生成树 最小生成树(Minimum Cost Spanning Tree)的概念: ​ 假设要在n个城市之间建立公路,则连通n个城市只需要n-1条线路.这时 ...

随机推荐

  1. 【学习笔记】node.js重构路由功能

    摘要:利用node.js模块化实现路由功能,将请求路径作为参数传递给一个route函数,这个函数会根据参数调用一个方法,最后输出浏览器响应内容 1.介绍 node.js是一个基于Chrome V8引擎 ...

  2. awk知识点总结

    find+xargs+grep+sed+awk系列文章:http://www.cnblogs.com/f-ck-need-u/p/7048359.html 0.学习资料推荐 1.awk入门:看视频.找 ...

  3. Django 系列博客(二)

    Django 系列博客(二) 前言 今天博客的内容为使用 Django 完成第一个 Django 页面,并进行一些简单页面的搭建和转跳. 命令行搭建 Django 项目 创建纯净虚拟环境 在上一篇博客 ...

  4. 另类爬虫:从PDF文件中爬取表格数据

    简介   本文将展示一个稍微不一样点的爬虫.   以往我们的爬虫都是从网络上爬取数据,因为网页一般用HTML,CSS,JavaScript代码写成,因此,有大量成熟的技术来爬取网页中的各种数据.这次, ...

  5. [转]Docker和Rancher的安装与基本使用

    本文转自:https://blog.csdn.net/wangshouhan/article/details/80405672 一.Docker1.CentOS下Docker安装 安装 $ yum - ...

  6. 阿里云redis映射到阿里云服务器

    参考文档:https://help.aliyun.com/document_detail/43850.html?spm=a2c4g.11186623.2.3.7yg9VH ECS Windows 篇 ...

  7. MHA高可用

    MHA(Master High Availability)目前在 MySQL 高可用方面是一个相对成熟的解决方案,它由日本 DeNA 公司 youshimaton(现就职于 Facebook 公司)开 ...

  8. 从零开始学安全(六)●黑客常用的Dos命令

    cd   文件路径                      要切换的路径cd \                                     直接回根目录dir              ...

  9. C# 中 FindControl 方法及使用

    FindControl 的使用方法 FindControl (String  id): 在页命名容器中搜索带指定标识符的服务器控件.(有点类似javascript中的getElementById(st ...

  10. 推送GitHub报错 fatal: Out of memory, malloc failed 解决办法

    现象: 推送GitHub时,出现如下报错 fatal: Out of memory, malloc failed (tried to allocate XXXXXX bytes)error: fail ...