图的相关知识
来源:互联网 发布:软件安装手册 编辑:程序博客网 时间:2024/05/29 13:30
一、 相关概念
图的定义:图是由顶点的有穷非空集合和顶点之间的边的集合组成,通常表示为:G(V,E),其中,G表示一个图,V是图G中顶点的集合,E是图G中边的集合。
无向边:若顶点Vi 到Vj 的边没有方向,则称这条边为无向边,用无序偶对(Vi ,Vj)来表示。
如果图中任意两个顶点之间的边都是无向边,则称该图为无向图。
有向边:若从顶点Vi 到Vj的边有方向,则称这条边为有向边,也称为弧。用有序偶对(Vi ,Vj)来表示。Vi称为弧尾,Vj称为弧头。
如果图中任意顶点之间的边都是有向边,则称该图为有向图。
简单图:在图中,若不存在顶点到其自身的边,且同一条边不重复出现,则称这样的图为简单图。
无向完全图:在无向图中,如果任意两个顶点之间都存在边,则称该图为无向完全图。含有n个顶点的无向完全图有n(n-1)/2条边。
有向完全图:在有向图中,如果任意两个顶点之间都存在方向互为相反的两条弧,则称该图为有向完全图。含有n个顶点的有向完全图有n(n-1)条边。
因此,对于有n个顶点和e条边数的图,无向图0<=e<=n(n-1)/2,有向图0<=e<=n(n-1)。
有很少条边或弧的图称为稀疏图,反之称为稠密图。
路径的长度是路径上的边或弧的数目。
第一个顶点与最后一个顶点相同路径称为回路或环。序列中顶点不重复出现的路径称为简单路径。除了第一个顶点和最后一个顶点之外,其余顶点不重复出现的回路,称为简单回路或简单环。
连通图相关术语
在无向图G中,如果从顶点v到顶点w有路径,则称v和w是相通的。如果对图中任意两个顶点Vi和Vj 属于E,则两个顶点是连通的,则称G是连通图。如下图1,它的顶点A都顶点B、C、D都是连通的,但显然顶点A与顶点E或F就无路径,因此不能算是连通图。而图2,顶点A、B、C、D相互都是连通的,所以它本身是连通图。
无向图中的极大连通子图称为连通分量。注意连通分量的概念,它强调:
(1)要是子图;
(2)子图要是连通的;
(3)连通子图含有极大顶点数;
(4)具有极大顶点树的连通子图包含依附于这些顶点的所有边。
在有向图G中,如果对于每一对Vi和Vj 属于顶点集V,Vi不等于Vj ,从Vi到Vj和从Vj到Vi都存在路径,则称G是强连通图。有向图中的极大强连通子图称做有向图的强连通分量。
所谓的一个连通图的生成树是一个极小的连通子图,它含有图中全部的n个顶点,但只有足以构成一棵树的n-1条边。比如下图的图1是一个普通图,但显然它不是生成树,当去掉两条构成环的边后,比如图2或图3,就满足n个顶点n-1条边且连通的定义了。它们都是一棵生成树。从这里也知道,如果一个图有n个顶点和小于n-1条边,则是非连通图,如果它多于n-1条边,必定构成一个环,因为这条边使得它依附的那两个顶点之间有了第二条路径。比如图2和图3,随便加哪两顶点的边都将构成环。不过有n-1条边并不一定是生成树,比如图4。
二、 图的存储结构
1. 邻接矩阵
图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息,一个二维数组(邻接矩阵)存储图中的边或弧的信息。设无向图G有n个顶点,则邻接矩阵是一个n*n的方阵,定义为:
从上面可以看出,无向图的边数组是一个对称矩阵。
从这个矩阵中,很容易知道图中的信息。
(1)要判断任意两顶点是否有边无边就很容易了;
(2)要知道某个顶点的度,其实就是这个顶点vi在邻接矩阵中第i行或(第i列)的元素之和;
(3)求顶点vi的所有邻接点就是将矩阵中第i行元素扫描一遍,arc[i][j]为1就是邻接点;
而有向图讲究入度和出度,顶点vi的入度为1,正好是第i列各数之和。顶点vi的出度为2,即第i行的各数之和。
#include <stdio.h>#include <stdlib.h>#include <curses.h>typedef char VertexType; //顶点类型应由用户定义typedef int EdgeType; //边上的权值类型应由用户定义#define MAXVEX 100 //最大顶点数,应由用户定义#define INFINITY 65535 //用65535来代表无穷大#define DEBUGtypedef struct{ VertexType vexs[MAXVEX]; //顶点表 EdgeType arc[MAXVEX][MAXVEX]; //邻接矩阵,可看作边 int numVertexes, numEdges; //图中当前的顶点数和边数}Graph;//定位int locates(Graph *g, char ch){ int i = 0; for(i = 0; i < g->numVertexes; i++) { if(g->vexs[i] == ch) { break; } } if(i >= g->numVertexes) { return -1; } return i;}//建立一个无向网图的邻接矩阵表示void CreateGraph(Graph *g){ int i, j, k, w; printf("输入顶点数和边数:\n"); scanf("%d,%d", &(g->numVertexes), &(g->numEdges)); #ifdef DEBUG printf("%d %d\n", g->numVertexes, g->numEdges); #endif for(i = 0; i < g->numVertexes; i++) { g->vexs[i] = getchar(); while(g->vexs[i] == '\n') { g->vexs[i] = getchar(); } } #ifdef DEBUG for(i = 0; i < g->numVertexes; i++) { printf("%c ", g->vexs[i]); } printf("\n"); #endif for(i = 0; i < g->numEdges; i++) { for(j = 0; j < g->numEdges; j++) { g->arc[i][j] = INFINITY; //邻接矩阵初始化 } } for(k = 0; k < g->numEdges; k++) { char p, q; printf("输入边(vi,vj)上的下标i,下标j和权值:\n"); p = getchar(); while(p == '\n') { p = getchar(); } q = getchar(); while(q == '\n') { q = getchar(); } scanf("%d", &w); int m = -1; int n = -1; m = locates(g, p); n = locates(g, q); if(n == -1 || m == -1) { fprintf(stderr, "there is no this vertex.\n"); return; } //getchar(); g->arc[m][n] = w; g->arc[n][m] = g->arc[m][n]; //因为是无向图,矩阵对称 }}//打印图void printGraph(Graph g){ int i, j; for(i = 0; i < g.numVertexes; i++) { for(j = 0; j < g.numVertexes; j++) { printf("%d ", g.arc[i][j]); } printf("\n"); }}int main(int argc, char **argv){ Graph g; //邻接矩阵创建图 CreateGraph(&g); printGraph(g); return 0;}
2. 邻接表
邻接矩阵是不错的一种图存储结构,但是,对于边数相对顶点较少的图,这种结构存在对存储空间的极大浪费。因此,找到一种数组与链表相结合的存储方法称为邻接表。
邻接表的处理方法是这样的:
(1)图中顶点用一个一维数组存储,当然,顶点也可以用单链表来存储,不过,数组可以较容易的读取顶点的信息,更加方便。
(2)图中每个顶点vi的所有邻接点构成一个线性表,由于邻接点的个数不定,所以,用单链表存储,无向图称为顶点vi的边表,有向图则称为顶点vi作为弧尾的出边表。
例如,下图就是一个无向图的邻接表的结构。
从图中可以看出,顶点表的各个结点由data和firstedge两个域表示,data是数据域,存储顶点的信息,firstedge是指针域,指向边表的第一个结点,即此顶点的第一个邻接点。边表结点由adjvex和next两个域组成。adjvex是邻接点域,存储某顶点的邻接点在顶点表中的下标,next则存储指向边表中下一个结点的指针。
对于带权值的网图,可以在边表结点定义中再增加一个weight的数据域,存储权值信息即可。如下图所示。
/* 邻接表表示的图结构 */#include <stdio.h>#include<stdlib.h>#define DEBUG#define MAXVEX 1000 //最大顶点数typedef char VertexType; //顶点类型应由用户定义typedef int EdgeType; //边上的权值类型应由用户定义typedef struct EdgeNode //边表结点{ int adjvex; //邻接点域,存储该顶点对应的下标 EdgeType weigth; //用于存储权值,对于非网图可以不需要 struct EdgeNode *next; //链域,指向下一个邻接点}EdgeNode;typedef struct VertexNode //顶点表结构{ VertexType data; //顶点域,存储顶点信息 EdgeNode *firstedge; //边表头指针}VertexNode, AdjList[MAXVEX];typedef struct{ AdjList adjList; int numVertexes, numEdges; //图中当前顶点数和边数}GraphList;int Locate(GraphList *g, char ch){ int i; for(i = 0; i < MAXVEX; i++) { if(ch == g->adjList[i].data) { break; } } if(i >= MAXVEX) { fprintf(stderr,"there is no vertex.\n"); return -1; } return i;}//建立图的邻接表结构void CreateGraph(GraphList *g){ int i, j, k; EdgeNode *e; EdgeNode *f; printf("输入顶点数和边数:\n"); scanf("%d,%d", &g->numVertexes, &g->numEdges); #ifdef DEBUG printf("%d,%d\n", g->numVertexes, g->numEdges); #endif for(i = 0; i < g->numVertexes; i++) { printf("请输入顶点%d:\n", i); g->adjList[i].data = getchar(); //输入顶点信息 g->adjList[i].firstedge = NULL; //将边表置为空表 while(g->adjList[i].data == '\n') { g->adjList[i].data = getchar(); } } //建立边表 for(k = 0; k < g->numEdges; k++) { printf("输入边(vi,vj)上的顶点序号:\n"); char p, q; p = getchar(); while(p == '\n') { p = getchar(); } q = getchar(); while(q == '\n') { q = getchar(); } int m, n; m = Locate(g, p); n = Locate(g, q); if(m == -1 || n == -1) { return; } #ifdef DEBUG printf("p = %c\n", p); printf("q = %c\n", q); printf("m = %d\n", m); printf("n = %d\n", n); #endif //向内存申请空间,生成边表结点 e = (EdgeNode *)malloc(sizeof(EdgeNode)); if(e == NULL) { fprintf(stderr, "malloc() error.\n"); return; } //邻接序号为j e->adjvex = n; //将e指针指向当前顶点指向的结构 e->next = g->adjList[m].firstedge; //将当前顶点的指针指向e g->adjList[m].firstedge = e; f = (EdgeNode *)malloc(sizeof(EdgeNode)); if(f == NULL) { fprintf(stderr, "malloc() error.\n"); return; } f->adjvex = m; f->next = g->adjList[n].firstedge; g->adjList[n].firstedge = f; }}void printGraph(GraphList *g){ int i = 0; #ifdef DEBUG printf("printGraph() start.\n"); #endif while(g->adjList[i].firstedge != NULL && i < MAXVEX) { printf("顶点:%c ", g->adjList[i].data); EdgeNode *e = NULL; e = g->adjList[i].firstedge; while(e != NULL) { printf("%d ", e->adjvex); e = e->next; } i++; printf("\n"); }}int main(int argc, char **argv){ GraphList g; CreateGraph(&g); printGraph(&g); return 0;}
本算法的时间复杂度,对于n个顶点e条边来说,很容易得出是O(n+e)。
3. 十字链表
对于有向图来说,邻接表是有缺陷的。关心了出度问题,想了解入度就必须要遍历整个图才知道,反之,逆邻接表解决了入度却不了解出度情况。下面介绍的这种有向图的存储方法:十字链表,就是把邻接表和逆邻接表结合起来的。
其中,tailvex是指弧起点在顶点表的下表,headvex是指弧终点在顶点表的下标,headlink是指入边表指针域,指向终点相同的下一条边,taillink是指边表指针域,指向起点相同的下一条边。如果是网,还可以增加一个weight域来存储权值。
比如下图,顶点依然是存入一个一维数组,实线箭头指针的图示完全与邻接表相同。就以顶点v0来说,firstout指向的是出边表中的第一个结点v3。所以,v0边表结点hearvex = 3,而tailvex其实就是当前顶点v0的下标0,由于v0只有一个出边顶点,所有headlink和taillink都是空的。
重点需要解释虚线箭头的含义。它其实就是此图的逆邻接表的表示。对于v0来说,它有两个顶点v1和v2的入边。因此的firstin指向顶点v1的边表结点中headvex为0的结点,如上图圆圈1。接着由入边结点的headlink指向下一个入边顶点v2,如上图圆圈2。对于顶点v1,它有一个入边顶点v2,所以它的firstin指向顶点v2的边表结点中headvex为1的结点,如上图圆圈3。
十字链表的好处就是因为把邻接表和逆邻接表整合在一起,这样既容易找到以v为尾的弧,也容易找到以v为头的弧,因而比较容易求得顶点的出度和入度。
而且除了结构复杂一点外,其实创建图算法的时间复杂度是和邻接表相同的,因此,在有向图应用中,十字链表是非常好的数据结构模型。
三、 图的遍历
1. 深度优先遍历
也有称为深度优先搜索,简称DFS。其实,就像是一棵树的前序遍历。 它从图中某个结点v出发,访问此顶点,然后从v的未被访问的邻接点出发深度优先遍历图,直至图中所有和v有路径相通的顶点都被访问到。若图中尚有顶点未被访问,则另选图中一个未曾被访问的顶点作起始点,重复上述过程,直至图中的所有顶点都被访问到为止。
对比两个不同的存储结构的深度优先遍历算法,对于n个顶点e条边的图来说,邻接矩阵由于是二维数组,要查找某个顶点的邻接点需要访问矩阵中的所有元素,因为需要O(n2)的时间。而邻接表做存储结构时,找邻接点所需的时间取决于顶点和边的数量,所以是O(n+e)。显然对于点多边少的稀疏图来说,邻接表结构使得算法在时间效率上大大提高。
#define MAXVEX 100 //最大顶点数typedef int Boolean; //Boolean 是布尔类型,其值是TRUE 或FALSEBoolean visited[MAXVEX]; //访问标志数组#define TRUE 1#define FALSE 0//邻接矩阵的深度优先递归算法void DFS(Graph g, int i){ int j; visited[i] = TRUE; printf("%c ", g.vexs[i]); //打印顶点,也可以其他操作 for(j = 0; j < g.numVertexes; j++) { if(g.arc[i][j] == 1 && !visited[j]) { DFS(g, j); //对为访问的邻接顶点递归调用 } }}//邻接矩阵的深度遍历操作void DFSTraverse(Graph g){ int i; for(i = 0; i < g.numVertexes; i++) { visited[i] = FALSE; //初始化所有顶点状态都是未访问过状态 } for(i = 0; i < g.numVertexes; i++) { if(!visited[i]) //对未访问的顶点调用DFS,若是连通图,只会执行一次 { DFS(g,i); } }}
//如果使用的是邻接表存储结构,其DFSTraverse函数的代码几乎是相同的,只是在递归函数中因为将数组换成了链表而有不同,代码如下。//邻接表的深度递归算法void DFS(GraphList g, int i){ EdgeNode *p; visited[i] = TRUE; printf("%c ", g->adjList[i].data); //打印顶点,也可以其他操作 p = g->adjList[i].firstedge; while(p) { if(!visited[p->adjvex]) { DFS(g, p->adjvex); //对访问的邻接顶点递归调用 } p = p->next; }}//邻接表的深度遍历操作void DFSTraverse(GraphList g){ int i; for(i = 0; i < g.numVertexes; i++) { visited[i] = FALSE; } for(i = 0; i < g.numVertexes; i++) { if(!visited[i]) { DFS(g, i); } }}
2. 广度优先遍历
又称为广度优先搜索,简称BFS。图的广度优先遍历就类似于树的层序遍历了。
对比图的深度优先遍历与广度优先遍历算法,会发现,它们在时间复杂度上是一样的,不同之处仅仅在于对顶点的访问顺序不同。可见两者在全图遍历上是没有优劣之分的,只是不同的情况选择不同的算法。
//邻接矩阵的广度遍历算法void BFSTraverse(Graph g){ int i, j; Queue q; for(i = 0; i < g.numVertexes; i++) { visited[i] = FALSE; } InitQueue(&q); for(i = 0; i < g.numVertexes; i++)//对每个顶点做循环 { if(!visited[i]) //若是未访问过 { visited[i] = TRUE; printf("%c ", g.vexs[i]); //打印结点,也可以其他操作 EnQueue(&q, i); //将此结点入队列 while(!QueueEmpty(q)) //将队中元素出队列,赋值给 { int m; DeQueue(&q, &m); for(j = 0; j < g.numVertexes; j++) { //判断其他顶点若与当前顶点存在边且未访问过 if(g.arc[m][j] == 1 && !visited[j]) { visited[j] = TRUE; printf("%c ", g.vexs[j]); EnQueue(&q, j); } } } } }} 对于邻接表的广度优先遍历,代码与邻接矩阵差异不大, 代码如下//邻接表的广度遍历算法void BFSTraverse(GraphList g){ int i; EdgeNode *p; Queue q; for(i = 0; i < g.numVertexes; i++) { visited[i] = FALSE; } InitQueue(&q); for(i = 0; i < g.numVertexes; i++) { if(!visited[i]) { visited[i] = TRUE; printf("%c ", g.adjList[i].data); //打印顶点,也可以其他操作 EnQueue(&q, i); while(!QueueEmpty(q)) { int m; DeQueue(&q, &m); p = g.adjList[m].firstedge; 找到当前顶点边表链表头指针 while(p) { if(!visited[p->adjvex]) { visited[p->adjvex] = TRUE; printf("%c ", g.adjList[p->adjvex].data); EnQueue(&q, p->adjvex); } p = p->next; } } } }}
四、 最小生成树
一个连通图的生成树是一个极小的连通子图,它含有图中全部顶点,但只有足以构成一棵树的n-1条边。那么我们把构造连通网的最小代价生成树称为最小生成树。
找连通网的最小生成树,经典的有两种算法,普里姆算法和克鲁斯卡尔算法。下面分别介绍两种算法。
1. 普里姆(Prim)算法
普里姆算法,图论中的一种算法,可在加权连通图里搜索最小生成树。意即此算法搜索到的边子集所构成的树中,不但包括连通图里的所有顶点,且其所有边的权值之和亦为最小。
1.1 算法描述
从单一顶点开始,普里姆算法按照以下步骤逐步扩大树中所含顶点的数目,直到遍及连通图的所有顶点。
(1)输入:一个加权连通图,其中顶点集合为V,边集合为E;
(2)初始化:Vnew = {x},其中x为集合V中的任一节点(起始点),Enew = {};
(3)重复下列操作,直到Vnew = V:在集合E中选取权值最小的边(u, v),其中u为集合Vnew中的元素,而v则不是(如果存在有多条满足前述条件即具有相同权值的边,则可任意选取其中之一);将v加入集合Vnew中,将(u, v)加入集合Enew中;
(4)输出:使用集合Vnew和Enew来描述所得到的最小生成树。
2. 克鲁斯卡尔(Kruskal)算法
普力马算法是以某顶点为起点,逐步找各顶点上最小权值的边来构建最小生成树的。同样的思路,我们也可以直接就以边来构建生成树也是很自然的想法,只不过构建时要考虑是否会形成环路而已。此时,我们就用到了图的存储结构中的边集数组结构。
我们可以通过程序将邻接矩阵通过程序转化为边集数组,并且对它们的按权值从小到大排序.
克鲁斯卡尔算法的Find函数由边数e决定,时间复杂度为O(loge),而外面有一个for循环e次,所以克鲁斯卡尔算法的时间复杂度为O(eloge)。《此处不包括由邻接矩阵转为边集数组》
对比两个算法,克鲁斯尔算法主要是针对边来展开,边数少时效率会非常高,所以对于稀疏图有很大的优势;而普里姆算法对于稠密图,即边数非常多的情况会更好一些
/* 邻接矩阵表示的图结构*/#include <stdio.h>#include <stdlib.h>typedef char VertexType; //顶点类型应由用户定义typedef int EdgeType; //边上的权值类型应由用户定义#define MAXVEX 100 //最大顶点数,应由用户定义#define INFINITY 65535 //用65535来代表无穷大#define DEBUG//邻接矩阵结构typedef struct{ VertexType vexs[MAXVEX]; //顶点表 EdgeType arc[MAXVEX][MAXVEX]; //邻接矩阵,可看作边 int numVertexes, numEdges; //图中当前的顶点数和边数}Graph;//边集数组#define MAXEDGE 100typedef struct{ int begin; int end; int weight;}Edge;//定位int locates(Graph *g, char ch){ int i = 0; for(i = 0; i < g->numVertexes; i++) { if(g->vexs[i] == ch) { break; } } if(i >= g->numVertexes) { return -1; } return i;}//建立一个无向网图的邻接矩阵表示void CreateGraph(Graph *g){ int i, j, k, w; printf("输入顶点数和边数:\n"); scanf("%d,%d", &(g->numVertexes), &(g->numEdges)); #ifdef DEBUG printf("%d %d\n", g->numVertexes, g->numEdges); #endif for(i = 0; i < g->numVertexes; i++) { printf("请输入顶点%d:\n", i); g->vexs[i] = getchar(); while(g->vexs[i] == '\n') { g->vexs[i] = getchar(); } } #ifdef DEBUG for(i = 0; i < g->numVertexes; i++) { printf("%c ", g->vexs[i]); } printf("\n"); #endif for(i = 0; i < g->numEdges; i++) { for(j = 0; j < g->numEdges; j++) { g->arc[i][j] = INFINITY; //邻接矩阵初始化 } } for(k = 0; k < g->numEdges; k++) { char p, q; printf("输入边(vi,vj)上的下标i,下标j和权值:\n"); p = getchar(); while(p == '\n') { p = getchar(); } q = getchar(); while(q == '\n') { q = getchar(); } scanf("%d", &w); int m = -1; int n = -1; m = locates(g, p); n = locates(g, q); if(n == -1 || m == -1) { fprintf(stderr, "there is no this vertex.\n"); return; } //getchar(); g->arc[m][n] = w; g->arc[n][m] = g->arc[m][n]; //因为是无向图,矩阵对称 }}//打印图void printGraph(Graph g){ int i, j; printf("构建的邻接矩阵如下所示.\n"); for(i = 0; i < g.numVertexes; i++) { for(j = 0; j < g.numVertexes; j++) { printf("%5d ", g.arc[i][j]); } printf("\n"); }}//prime算法最小生成树void MiniSpanTree_Prime(Graph g){ int min, i, j, k; int adjvex[MAXVEX]; //保存相关顶点下标 int lowcost[MAXVEX]; //保存相关顶点间边的权值 lowcost[0] = 0; //初始化第一个权值为0,即v0加入生成树 adjvex[0] = 0; //初始化第一个顶点下标为0 for(i = 1; i < g.numVertexes; i++) { //循环除下标为0外的全部顶点 lowcost[i] = g.arc[0][i]; //将v0顶点与之有边的权值存入数组 adjvex[i] = 0; //初始化都为v0下标 } for(i = 1; i < g.numVertexes; i++) { min = INFINITY; //初始化最小权值为无穷大 j = 1; k = 0; while(j < g.numVertexes) //循环全部顶点 { //如果权值不为0,且权值小于min if(lowcost[j] != 0 && lowcost[j] < min) { min = lowcost[j]; //则让当前权值成为最小值 k = j; //将当前最小值的下标存入k } j++; } printf("(%d,%d)", adjvex[k], k); //打印当前顶点边中权值最小边 lowcost[k] = 0; //将当前顶点的权值设置为0,表示此顶点已经完成任务 for(j = 1; j < g.numVertexes; j++)//循环所有顶点 { if(lowcost[j] != 0 && g.arc[k][j] < lowcost[j]) { //若下标为k的顶点各边权值小于此前这些顶点未被加入的生成树权值 lowcost[j] = g.arc[k][j]; adjvex[j] = k; //将下标为k的顶点存入adjvex } } } printf("\n");}//查找连线顶点的尾部int Find(int *parent, int f){ while(parent[f] > 0) { f = parent[f]; } return f;}//直接插入排序void InsertSort(Edge edges[], int k){ int i, j; Edge ss; for(i = 1; i <= k; i++) { if(edges[i].weight < edges[i - 1].weight) { ss = edges[i]; for(j = i - 1; edges[j].weight > ss.weight; j--) { edges[j + 1] = edges[j]; } edges[j + 1] = ss; } }}//将邻接矩阵转化为边集数组void Convert(Graph g, Edge edges[]){ int i; int j; int k; k = 0; for(i = 0; i < g.numVertexes; i++) { for(j = i; j < g.numVertexes; j++) { if(g.arc[i][j] < 65535) { edges[k].begin = i; edges[k].end = j; edges[k].weight = g.arc[i][j]; k++; } } } k--;#ifdef DEBUG printf("k = %d\n", k); printf("边集数组排序前,如下所示.\n"); printf("edges[] beign end weight\n"); for(i = 0; i < k; i++) { printf("%d", i); printf(" %d", edges[i].begin); printf(" %d", edges[i].end); printf(" %d", edges[i].weight); printf("\n"); }#endif //下面进行排序 InsertSort(edges, k);#ifdef DEBUG printf("边集数组排序后,如下所示.\n"); printf("edges[] beign end weight\n"); for(i = 0; i < k; i++) { printf("%d", i); printf(" %d", edges[i].begin); printf(" %d", edges[i].end); printf(" %d", edges[i].weight); printf("\n"); }#endif}//克鲁斯卡尔算法实现void MiniSpanTree_Kruskal(Graph g) { int i, n, m; Edge edges[MAXEDGE]; //定义边集数组 int parent[MAXVEX]; //定义一数组用来判断边与边是否形成环 //此处为将邻接矩阵转化为边集数组edges并按权值由小到大排序 Convert(g, edges); // for(i = 0; i < g.numVertexes; i++) { parent[i] = 0; //初始化数组值为0 } for(i = 0; i < g.numEdges; i++) //循环每一条边 { n = Find(parent, edges[i].begin); m = Find(parent, edges[i].end); if(n != m) //假如n与m不等,说明此边没有与现有生成树形成环路 { parent[n] = m; //将此边的结尾顶点放入下标为起点的parent中 //表示此顶点已经在生成树集合中 printf("(%d,%d) %d ", edges[i].begin, edges[i].end, edges[i].weight); } } printf("\n");}int main(int argc, char **argv){ Graph g; //邻接矩阵创建图 CreateGraph(&g); //打印网图 printGraph(g); //普里姆算法求最小生成树 MiniSpanTree_Prime(g); //克鲁斯卡尔算法求最小生成树 MiniSpanTree_Kruskal(g); return 0;}
- 图的相关知识
- 7.18 图的相关知识
- 相关reactjs的相关知识
- iOS CALayer (图层的相关知识)
- OPC的相关知识
- JDBC的相关知识
- 事务的相关知识
- 编译器的相关知识
- 编译器的相关知识
- OPC的相关知识
- IUnKnown的相关知识
- 噪音的相关知识
- xml的相关知识
- sql的相关知识
- JavaScript的相关知识
- 虚拟主机的相关知识
- 声音的相关知识
- 事务的相关知识
- Uart串口通信的理解
- 解决IDEA、PyCharm、PhpStorm及Android Studio中输入法卡住、光标不跟随的问题
- Java 随机给二维数组赋值,打印输出每个元素
- async和await简化回调函数嵌套
- Test 4 for NOIP- Result for Day3(误)
- 图的相关知识
- Java.Reader_Writer
- bzoj 4025: 二分图 cdq分治+并查集
- mybatis入门之CURD
- hibernate问题解决
- json生成html
- n阶 行列式计算
- Arpa’s obvious problem and Mehrdad’s terrible solution
- Win10下安装Tensorflow(GPU)+CUDA8.0+cudnn6