数据结构——图
2015-07-30 22:17
627 查看
图是一种较为复杂的非线性结构,数据结构和算法都比较复杂,对于我来说默写图的相关算法还是很有难度的。所以,我这里只描述图的常用数据结构,常用算法原理。
声明:下面的算法都是基于以上的邻接表来实现。
简言之,任取一未被访问顶点A,在ENode表中找出未被访问的顶点B,然后再找B中未被访问的顶点C,依此循环。
简言之,任取顶点A,依次访问A的邻接表中的各个顶点(BCD),再从B出发依次访问B的邻接表中的所有顶点,依此循环。
两栖边:设V是一个图的顶点集合,U是V中的一个非空真子集(即U中有元素),U中顶点和非U中顶点(即V-U)的连接边称为两栖边。
具体做法:首先构造一个只含n个顶点的森林,然后依权值从小到大从连通网中选择边加入到森林中,并使森林中不产生回路,直至森林变成一棵树为止
它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想),直到扩展到终点为止。。
基本思想
通过Dijkstra计算图G中的最短路径时,需要指定起点s(即从顶点s开始计算)。此外,引进两个集合S和U。S的作用是记录已求出最短路径的顶点(以及相应的最短路径长度),而U则是记录还未求出最短路径的顶点(以及该顶点到起点s的距离)。初始时,S中只有起点s;U中是除s之外的顶点,并且U中顶点的路径是”起点s到该顶点的路径”。然后,从U中找出路径最短的顶点,并将其加入到S中;接着,更新U中的顶点和顶点对应的路径。 然后,再从U中找出路径最短的顶点,并将其加入到S中;接着,更新U中的顶点和顶点对应的路径。 … 重复该操作,直到遍历完所有顶点。
这样说,可能理解起来比较抽象。下面通过简单的例子进行说明!
例如,一个项目包括A、B、C、D四个子部分来完成,并且A依赖于B和D,C依赖于D。现在要制定一个计划,写出A、B、C、D的执行顺序。这时,就可以利用到拓扑排序,它就是用来确定事物发生的顺序的。
在拓扑排序中,如果存在一条从顶点A到顶点B的路径,那么在排序结果中B出现在A的后面。
最短路径:找出两个顶点路径的最优解
拓扑排布:AOV网中顶点间存在前驱后继的关系,它是确定事件的进程,如制定学生学习计划,安排施工进程等。
图的算法还有:关键路径,Floyd等。
这里我只是对图的基本算法做一个总结,部分内容来自以下博客:(http://www.cnblogs.com/skywang12345/p/3603935.html)
数据结构
邻接矩阵
邻接矩阵的有向图和无向图数据结构相同,其中无向图的邻接矩阵是对称的所以可以采用三角矩阵进行压缩存储,其存储空间只需n(n+1)/2。而有向图则需要n*n。[code]// 邻接矩阵 #define MAXSIZE 20 typedef struct graph { char vexs[MAXSIZE]; // 顶点集合 int vexnum; // 顶点数 int edgnum; // 边数 int matrix[MAXSIZE][MAXSIZE]; // 邻接矩阵 }Graph, *PGraph;
邻接表
邻接表比邻接矩阵节省存储空间。邻接表无向图和有向图数据结构相同,只是有向图需要出边表和入边表两张表来表示边之间的关系。[code]// 邻接表中表对应的链表的顶点 typedef struct ENode { int ivex; // 该边所指向的顶点的位置 struct ENode *next_edge; // 指向下一条弧的指针 }ENode, *PENode; // 邻接表中表的顶点 typedef struct VNode { char data; // 顶点信息 ENode *first_edge; // 指向第一条依附该顶点的弧 }VNode; // 邻接表 typedef struct LGraph { int vexnum; // 图的顶点的数目 int edgnum; // 图的边的数目 VNode vexs[MAXSIZE]; }LGraph;
声明:下面的算法都是基于以上的邻接表来实现。
深度优先遍历DFS
它的思想:假设初始状态是图中所有顶点均未被访问,则从某个顶点v出发,首先访问该顶点,然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图,直至图中所有和v有路径相通的顶点都被访问到。 若此时尚有其他顶点未被访问到,则另选一个未被访问的顶点作起始点,重复上述过程,直至图中所有顶点都被访问到为止。简言之,任取一未被访问顶点A,在ENode表中找出未被访问的顶点B,然后再找B中未被访问的顶点C,依此循环。
[code]/* * 深度优先搜索遍历图的递归实现 */ static void DFS(LGraph G, int i, int *visited) { int w; ENode *node; visited[i] = 1; printf("%c ", G.vexs[i].data); node = G.vexs[i].first_edge; while (node != NULL) { if (!visited[node->ivex]) DFS(G, node->ivex, visited); node = node->next_edge; } } /* * 深度优先搜索遍历图 */ void DFSTraverse(LGraph G) { int i; int visited[MAX]; // 顶点访问标记 // 初始化所有顶点都没有被访问 for (i = 0; i < G.vexnum; i++) visited[i] = 0; printf("DFS: "); for (i = 0; i < G.vexnum; i++) { if (!visited[i]) DFS(G, i, visited); } printf("\n"); }
广度优先遍历BFS
它的思想是:从图中某顶点v出发,在访问了v之后依次访问v的各个未曾访问过的邻接点,然后分别从这些邻接点出发依次访问它们的邻接点,并使得“先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问,直至图中所有已被访问的顶点的邻接点都被访问到。如果此时图中尚有顶点未被访问,则需要另选一个未曾被访问过的顶点作为新的起始点,重复上述过程,直至图中所有顶点都被访问到为止。简言之,任取顶点A,依次访问A的邻接表中的各个顶点(BCD),再从B出发依次访问B的邻接表中的所有顶点,依此循环。
[code]/* * 广度优先搜索(类似于树的层次遍历) */ void BFS(LGraph G) { int head = 0; int rear = 0; int queue[MAX]; // 辅组队列 int visited[MAX]; // 顶点访问标记 int i, j, k; ENode *node; for (i = 0; i < G.vexnum; i++) visited[i] = 0; printf("BFS: "); for (i = 0; i < G.vexnum; i++) { if (!visited[i]) { visited[i] = 1; printf("%c ", G.vexs[i].data); queue[rear++] = i; // 入队列 } while (head != rear) { j = queue[head++]; // 出队列 node = G.vexs[j].first_edge; while (node != NULL) { k = node->ivex; if (!visited[k]) { visited[k] = 1; printf("%c ", G.vexs[k].data); queue[rear++] = k; } node = node->next_edge; } } } printf("\n"); } /* * 打印邻接表图 */ void print_lgraph(LGraph G) { int i,j; ENode *node; printf("List Graph:\n"); for (i = 0; i < G.vexnum; i++) { printf("%d(%c): ", i, G.vexs[i].data); node = G.vexs[i].first_edge; while (node != NULL) { printf("%d(%c) ", node->ivex, G.vexs[node->ivex].data); node = node->next_edge; } printf("\n"); } }
最小生成树——prim算法
算法简单描述:首先选一顶点A,找出A的最小权值两栖边B,将B加入A的集合,再找AB中的最小两栖边,依此找最小两栖边,直到所有顶点被并入A的集合。两栖边:设V是一个图的顶点集合,U是V中的一个非空真子集(即U中有元素),U中顶点和非U中顶点(即V-U)的连接边称为两栖边。
[code]/* * 获取G中边<start, end>的权值;若start和end不是连通的,则返回无穷大。 */ int getWeight(LGraph G, int start, int end) { ENode *node; if (start==end) return 0; node = G.vexs[start].first_edge; while (node!=NULL) { if (end==node->ivex) return node->weight; node = node->next_edge; } return INF; } /* * prim最小生成树 * * 参数说明: * G -- 邻接表图 * start -- 从图中的第start个元素开始,生成最小树 */ void prim(LGraph G, int start) { int min,i,j,k,m,n,tmp,sum; int index=0; // prim最小树的索引,即prims数组的索引 char prims[MAX]; // prim最小树的结果数组 int weights[MAX]; // 顶点间边的权值 // prim最小生成树中第一个数是"图中第start个顶点",因为是从start开始的。 prims[index++] = G.vexs[start].data; // 初始化"顶点的权值数组", // 将每个顶点的权值初始化为"第start个顶点"到"该顶点"的权值。 for (i = 0; i < G.vexnum; i++ ) weights[i] = getWeight(G, start, i); for (i = 0; i < G.vexnum; i++) { // 由于从start开始的,因此不需要再对第start个顶点进行处理。 if(start == i) continue; j = 0; k = 0; min = INF; // 在未被加入到最小生成树的顶点中,找出权值最小的顶点。 while (j < G.vexnum) { // 若weights[j]=0,意味着"第j个节点已经被排序过"(或者说已经加入了最小生成树中)。 if (weights[j] != 0 && weights[j] < min) { min = weights[j]; k = j; } j++; } // 经过上面的处理后,在未被加入到最小生成树的顶点中,权值最小的顶点是第k个顶点。 // 将第k个顶点加入到最小生成树的结果数组中 prims[index++] = G.vexs[k].data; // 将"第k个顶点的权值"标记为0,意味着第k个顶点已经排序过了(或者说已经加入了最小树结果中)。 weights[k] = 0; // 当第k个顶点被加入到最小生成树的结果数组中之后,更新其它顶点的权值。 for (j = 0 ; j < G.vexnum; j++) { // 获取第k个顶点到第j个顶点的权值 tmp = getWeight(G, k, j); // 当第j个节点没有被处理,并且需要更新时才被更新。 if (weights[j] != 0 && tmp < weights[j]) weights[j] = tmp; } } // 计算最小生成树的权值 sum = 0; for (i = 1; i < index; i++) { min = INF; // 获取prims[i]在G中的位置 n = get_position(G, prims[i]); // 在vexs[0...i]中,找出到j的权值最小的顶点。 for (j = 0; j < i; j++) { m = get_position(G, prims[j]); tmp = getWeight(G, m, n); if (tmp < min) min = tmp; } sum += min; } // 打印最小生成树 printf("PRIM(%c)=%d: ", G.vexs[start].data, sum); for (i = 0; i < index; i++) printf("%c ", prims[i]); printf("\n"); }
最小生成树——Kruskal算法
基本思想:按照权值从小到大的顺序选择n-1条边,并保证这n-1条边不构成回路。具体做法:首先构造一个只含n个顶点的森林,然后依权值从小到大从连通网中选择边加入到森林中,并使森林中不产生回路,直至森林变成一棵树为止
[code]/* * 获取图中的边 */ EData* get_edges(LGraph G) { int i,j; int index=0; ENode *node; EData *edges; edges = (EData*)malloc(G.edgnum*sizeof(EData)); for (i=0; i<G.vexnum; i++) { node = G.vexs[i].first_edge; while (node != NULL) { if (node->ivex > i) { edges[index].start = G.vexs[i].data; // 起点 edges[index].end = G.vexs[node->ivex].data; // 终点 edges[index].weight = node->weight; // 权 index++; } node = node->next_edge; } } return edges; } /* * 对边按照权值大小进行排序(由小到大) */ void sorted_edges(EData* edges, int elen) { int i,j; for (i=0; i<elen; i++) { for (j=i+1; j<elen; j++) { if (edges[i].weight > edges[j].weight) { // 交换"第i条边"和"第j条边" EData tmp = edges[i]; edges[i] = edges[j]; edges[j] = tmp; } } } } /* * 获取i的终点 */ int get_end(int vends[], int i) { while (vends[i] != 0) i = vends[i]; return i; } /* * 克鲁斯卡尔(Kruskal)最小生成树 */ void kruskal(LGraph G) { int i,m,n,p1,p2; int length; int index = 0; // rets数组的索引 int vends[MAX]={0}; // 用于保存"已有最小生成树"中每个顶点在该最小树中的终点。 EData rets[MAX]; // 结果数组,保存kruskal最小生成树的边 EData *edges; // 图对应的所有边 // 获取"图中所有的边" edges = get_edges(G); // 将边按照"权"的大小进行排序(从小到大) sorted_edges(edges, G.edgnum); for (i=0; i<G.edgnum; i++) { p1 = get_position(G, edges[i].start); // 获取第i条边的"起点"的序号 p2 = get_position(G, edges[i].end); // 获取第i条边的"终点"的序号 m = get_end(vends, p1); // 获取p1在"已有的最小生成树"中的终点 n = get_end(vends, p2); // 获取p2在"已有的最小生成树"中的终点 // 如果m!=n,意味着"边i"与"已经添加到最小生成树中的顶点"没有形成环路 if (m != n) { vends[m] = n; // 设置m在"已有的最小生成树"中的终点为n rets[index++] = edges[i]; // 保存结果 } } free(edges); // 统计并打印"kruskal最小生成树"的信息 length = 0; for (i = 0; i < index; i++) length += rets[i].weight; printf("Kruskal=%d: ", length); for (i = 0; i < index; i++) printf("(%c,%c) ", rets[i].start, rets[i].end); printf("\n"); }
最短路径——Dijkstra算法
迪杰斯特拉(Dijkstra)算法是典型最短路径算法,用于计算一个节点到其他节点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想),直到扩展到终点为止。。
基本思想
通过Dijkstra计算图G中的最短路径时,需要指定起点s(即从顶点s开始计算)。此外,引进两个集合S和U。S的作用是记录已求出最短路径的顶点(以及相应的最短路径长度),而U则是记录还未求出最短路径的顶点(以及该顶点到起点s的距离)。初始时,S中只有起点s;U中是除s之外的顶点,并且U中顶点的路径是”起点s到该顶点的路径”。然后,从U中找出路径最短的顶点,并将其加入到S中;接着,更新U中的顶点和顶点对应的路径。 然后,再从U中找出路径最短的顶点,并将其加入到S中;接着,更新U中的顶点和顶点对应的路径。 … 重复该操作,直到遍历完所有顶点。
[code]/* * Dijkstra最短路径。 * 即,统计图(G)中"顶点vs"到其它各个顶点的最短路径。 * * 参数说明: * G -- 图 * vs -- 起始顶点(start vertex)。即计算"顶点vs"到其它顶点的最短路径。 * prev -- 前驱顶点数组。即,prev[i]的值是"顶点vs"到"顶点i"的最短路径所经历的全部顶点中,位于"顶点i"之前的那个顶点。 * dist -- 长度数组。即,dist[i]是"顶点vs"到"顶点i"的最短路径的长度。 */ void dijkstra(LGraph G, int vs, int prev[], int dist[]) { int i,j,k; int min; int tmp; int flag[MAX]; // flag[i]=1表示"顶点vs"到"顶点i"的最短路径已成功获取。 // 初始化 for (i = 0; i < G.vexnum; i++) { flag[i] = 0; // 顶点i的最短路径还没获取到。 prev[i] = 0; // 顶点i的前驱顶点为0。 dist[i] = get_weight(G, vs, i); // 顶点i的最短路径为"顶点vs"到"顶点i"的权。 } // 对"顶点vs"自身进行初始化 flag[vs] = 1; dist[vs] = 0; // 遍历G.vexnum-1次;每次找出一个顶点的最短路径。 for (i = 1; i < G.vexnum; i++) { // 寻找当前最小的路径; // 即,在未获取最短路径的顶点中,找到离vs最近的顶点(k)。 min = INF; for (j = 0; j < G.vexnum; j++) { if (flag[j]==0 && dist[j]<min) { min = dist[j]; k = j; } } // 标记"顶点k"为已经获取到最短路径 flag[k] = 1; // 修正当前最短路径和前驱顶点 // 即,当已经"顶点k的最短路径"之后,更新"未获取最短路径的顶点的最短路径和前驱顶点"。 for (j = 0; j < G.vexnum; j++) { tmp = get_weight(G, k, j); tmp = (tmp==INF ? INF : (min + tmp)); // 防止溢出 if (flag[j] == 0 && (tmp < dist[j]) ) { dist[j] = tmp; prev[j] = k; } } } // 打印dijkstra最短路径的结果 printf("dijkstra(%c): \n", G.vexs[vs].data); for (i = 0; i < G.vexnum; i++) printf(" shortest(%c, %c)=%d\n", G.vexs[vs].data, G.vexs[i].data, dist[i]); }
拓扑排序
拓扑排序(Topological Order)是指,将一个有向无环图(Directed Acyclic Graph简称DAG)进行排序进而得到一个有序的线性序列。这样说,可能理解起来比较抽象。下面通过简单的例子进行说明!
例如,一个项目包括A、B、C、D四个子部分来完成,并且A依赖于B和D,C依赖于D。现在要制定一个计划,写出A、B、C、D的执行顺序。这时,就可以利用到拓扑排序,它就是用来确定事物发生的顺序的。
在拓扑排序中,如果存在一条从顶点A到顶点B的路径,那么在排序结果中B出现在A的后面。
[code]/* * 拓扑排序 * * 参数说明: * G -- 邻接表表示的有向图 * 返回值: * -1 -- 失败(由于内存不足等原因导致) * 0 -- 成功排序,并输入结果 * 1 -- 失败(该有向图是有环的) */ int topological_sort(LGraph G) { int i,j; int index = 0; int head = 0; // 辅助队列的头 int rear = 0; // 辅助队列的尾 int *queue; // 辅组队列 int *ins; // 入度数组 char *tops; // 拓扑排序结果数组,记录每个节点的排序后的序号。 int num = G.vexnum; ENode *node; ins = (int *)malloc(num*sizeof(int)); // 入度数组 tops = (char *)malloc(num*sizeof(char));// 拓扑排序结果数组 queue = (int *)malloc(num*sizeof(int)); // 辅助队列 assert(ins!=NULL && tops!=NULL && queue!=NULL); memset(ins, 0, num*sizeof(int)); memset(tops, 0, num*sizeof(char)); memset(queue, 0, num*sizeof(int)); // 统计每个顶点的入度数 for(i = 0; i < num; i++) { node = G.vexs[i].first_edge; while (node != NULL) { ins[node->ivex]++; node = node->next_edge; } } // 将所有入度为0的顶点入队列 for(i = 0; i < num; i ++) if(ins[i] == 0) queue[rear++] = i; // 入队列 while (head != rear) // 队列非空 { j = queue[head++]; // 出队列。j是顶点的序号 tops[index++] = G.vexs[j].data; // 将该顶点添加到tops中,tops是排序结果 node = G.vexs[j].first_edge; // 获取以该顶点为起点的出边队列 // 将与"node"关联的节点的入度减1; // 若减1之后,该节点的入度为0;则将该节点添加到队列中。 while(node != NULL) { // 将节点(序号为node->ivex)的入度减1。 ins[node->ivex]--; // 若节点的入度为0,则将其"入队列" if( ins[node->ivex] == 0) queue[rear++] = node->ivex; // 入队列 node = node->next_edge; } } if(index != G.vexnum) { printf("Graph has a cycle\n"); free(queue); free(ins); free(tops); return 1; } // 打印拓扑排序结果 printf("== TopSort: "); for(i = 0; i < num; i ++) printf("%c ", tops[i]); printf("\n"); free(queue); free(ins); free(tops); return 0; }
小结
最小生成树:找出连接所有顶点的最优解最短路径:找出两个顶点路径的最优解
拓扑排布:AOV网中顶点间存在前驱后继的关系,它是确定事件的进程,如制定学生学习计划,安排施工进程等。
图的算法还有:关键路径,Floyd等。
这里我只是对图的基本算法做一个总结,部分内容来自以下博客:(http://www.cnblogs.com/skywang12345/p/3603935.html)
相关文章推荐
- Linux 网卡驱动学习(三)(net_device 等数据结构)
- 华为2012机试第三题
- 数据结构---二叉树(3)
- JAVA数据结构 线性表的链式存储及其实现
- Redis源代码-数据结构Adlist双端列表
- 数据结构复习之用两个栈模拟队列操作
- 【数据结构】红黑树
- 数据结构基本概念
- 数据结构 并查集 路径压缩
- [数据结构]最小堆的类模板实现
- JAVA数据结构---------绪论
- 查看链表是否有环(数据结构C++表示)
- 数据结构---数组(2)
- 数据结构实验之求二叉树后序遍历和层次遍历 SDUT
- 一些比较经典的题目
- 希尔排序
- 冒泡排序
- 线段树学习
- 数据结构的结构
- C++程序设计_part 3 数据结构 chap15 模板