七、图

最新推荐文章于 2022-08-10 18:16:07 发布

lssssssssy

最新推荐文章于 2022-08-10 18:16:07 发布

阅读量104

点赞数

分类专栏：数据结构_C语言描述

本文链接：https://blog.csdn.net/lsssssssssssy/article/details/105008733

版权

数据结构_C语言描述专栏收录该内容

8 篇文章 0 订阅

订阅专栏

图

图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，
通常表示为：G(V,E)
- G表示一个图
- V是图G中顶点的集合
- E是图G中边的集合

与线性表、树的区别

1
- 线性表中：数据元素叫【元素】
- 树结构中：数据元素叫【结点】
- 图结构中：数据元素叫【顶点(Vertex)】
2
- 线性表中：可以为【空表】
- 树结构中：可以为【空树】
- 图结构中：顶点集合V要有穷非空
3
- 线性表中：相邻的数据元素之间具有线性关系
- 树结构中：相邻两层的结点具有层次关系
- 图结构中：任意两个顶点之间都可能有关系，顶点之间的逻辑关系用边来表示，边集可以是空的

图的相关定义

【无向边】(Vi,Vj)：顶点Vi到Vj之间的边没有方向
【有向边】<Vi,Vj>：顶点Vi到Vj之间的边有方向，又称弧(Arc)，V_i是弧尾
【简单图】：在图结构中，若不存在顶点到其自身的边，且同一条边不重复出现
【无向完全图】：无向图中任意两个顶点之间都存在边
- 含有n个顶点的无向完全图有 n*(n-1)/2 条边
【有向完全图】：有向图中任意两个顶点之间都存在方向互为相反的两条弧
- 含有n个顶点的有向完全图有n*(n-1)条边
【稀疏图】和【稠密图】：边少为稀疏
【权(Weight)】：与图的边或弧相关的数
【网(Network)】：带权的图
【子图(Subgraph)】：G1=(V1,E1)，G2=(V2,E2)，V2⊆V1，E2⊆E1，则称G2为G1的子图
【路径】：一个顶点序列
【路径长度】：路径上边或弧的数目
【回路】或【环(Cycle)】：第一个顶点到最后一个顶点相同的路径
【简单路径】：序列中顶点不重复出现的路径
【简单回路】或【简单环】：除了第一个顶点和最后一个顶点之外，其余顶点不重复出现的回路

度

对于无向图G=(V,E)，边(V1,V2)∈E
- 顶点V1和V2互为邻接点(Adjacent)，即V1和V2【相邻接】
- 边(V1,V2)依附(incident)于顶点V1和V2，或者说边(V1,V2)与顶点V1和V2【相关联】
- 【顶点V的度(Degree)】TD(V)：和V相关联的边的数目
对于有向图G=(V,E)，<V1,V2>∈E
- 顶点V1邻接到顶点V2，顶点V2邻接自顶点V1
- 【入度(InDegree)】ID(V)：顶点V为头的弧的数目
- 【出度(OutDegree)】OD(V)：V为尾的弧的数目
- TD(V) = ID(V) + OD(V)

连通图

在无向图G中
- 如果从顶点V1到顶点V2有路径，则称V1和V2是连通的，
- 如果对于图中任意两个顶点Vi和Vj都是连通的，则称G是【连通图】
- 【连通分量】：无向图中的极大连通子图
  - 首先要是子图，并且子图是要连通的
  - 连通子图含有极大顶点数
  - 具有极大顶点数的连通子图包含依附于这些顶点的所有边
- 【连通图生成树】：一个连通图的生成树是一个极小的连通子图，它含有图中全部的n个顶点，但只有足以构成一棵树的n-1条边
在=有向图G中
- 对于每一对Vi到Vj都存在路径，则称G是【强连通图】
- 【强连通分量】：有向图中的极大强连通子图
- 如果一个有向图恰有一个顶点入度为0，其余顶点的入度均为1，则是一棵【有向树】
- 【有向图生成森林】由若干有向树组成，包含所有顶点，但只包含构成若干不相交的有向树的弧

ADT

ADT 图(Graph)
Data  
	顶点的有穷非空集合和边的集合
Operation
     CreateGraph( *G, V, VR )
					     初始条件：V是图的顶点集，VR是图中弧的集合。  
					     操作结果：按V和VR的定义构造图G。  
     DestroyGraph( *G )  
					     初始条件：图G存在。  
					     操作结果：销毁图G。  
     LocateVex( G, u )  
					     初始条件：图G存在，u和G中顶点有相同特征。  
					     操作结果：若G中存在顶点u，则返回该顶点在图中位置；否则返回其它信息。  
     GetVex( G, v )  
					     初始条件：图G存在，v是G中某个顶点。  
					     操作结果：返回v的值。  
     PutVex( G, v, value )  
					     初始条件：图G存在，v是G中某个顶点。  
					     操作结果：对v赋值value。  
     FirstAdjVex( G, *v )  
					     初始条件：图G存在，v是G中某个顶点。  
					     操作结果：返回v的第一个邻接顶点。若顶点在G中没有邻接顶点，则返回“空”。  
     NextAdjVex( G, v, *w )  
					     初始条件：图G存在，v是G中某个顶点，w是v的邻接顶点。  
					     操作结果：返回v的（相对于w的）下一个邻接顶点。若w是v的最后一个邻接点，则返回“空”。  
     InsertVex( *G, v )  
					     初始条件：图G存在，v和图中顶点有相同特征。  
					     操作结果：在图G中增添新顶点v。  
     DeleteVex( *G, v )  
					     初始条件：图G存在，v是G中某个顶点。  
					     操作结果：删除G中顶点v及其相关的弧。  
     InsertArc( *G, v, w )  
					     初始条件：图G存在，v和w是G中两个顶点。  
					     操作结果：在G中增添弧<v,w>，若G是无向的，则还增添对称弧<v,w>。  
     DeleteArc( *G, v, w )  
					     初始条件：图G存在，v和w是G中两个顶点。  
					     操作结果：在G中删除弧<v,w>，若G是无向的，则还删除对称弧<v,w>。  
     DFSTraverse( G, Visit() )  
					     初始条件：图G存在，Visit是顶点的应用函数。  
					     操作结果：对图进行【深度优先遍历】。在遍历过程中对每个顶点调用函数Visit一次且仅一次。一旦visit()失败，则操作失败。  
     BFSTraverse( G, Visit() )  
					     初始条件：图G存在，Visit是顶点的应用函数。  
					     操作结果：对图进行【广度优先遍历】。在遍历过程中对每个顶点调用函数Visit一次且仅一次。一旦visit()失败，则操作失败。  
endADT

图的存储结构

邻接矩阵（稠密图）

图的【邻接矩阵(Adjacency Matrix)】存储方式是用两个数组来表示图：
- 顶点数组为vertex[4]={V0,V1,V2,V3}
- 边数组arc[4][4]为对称矩阵( 0 表示不存在顶点间的边，1 表示顶点间存在边 )
由邻接矩阵可知：
- 两顶点是否有边
- 某个顶点的 (出 \ 入) 度 = 顶点 Vi 在邻接矩阵中第 i 行 \ 列的元素之和
- 顶点Vi的所有邻接点
arc[i][j] 的值

图	Value
无向图	1、0
有向图	1、0
网	W_ij (权值)、 0 (i=j)、 ∞

在这里插入图片描述

邻接矩阵存储结构

typedef char VertexType;          // 用户定义顶点类型
typedef int EdgeType;             // 用户定义边上权值类型
#define MAXVEX 100		          // 用户定义最大顶点数
#define INFINITY 65535	          // 65535代表 ∞

typedef struct
{
	VertexType vexs[MAXVEX];		// 顶点表
	EdgeType arc[MAXVEX][MAXVEX];	// 边表
	int numVertexes, numEdges;	    // 图当前顶点数和边数
} MGraph;

由邻接矩阵构造图

// 建立无向网图的邻接矩阵表示
void CreateMGraph(MGraph *G)
{
	int i, j, k, w;
	printf("输入顶点数和边数：\n");
	scanf("%d %d", &G->numVertexes, &G->numEdges);
	for( i=0; i < G->numVertexes; i++ ){           // 读入顶点信息，建立顶点表
		scanf("%c", &G->vexs[i]);
	}
	for( i=0; i < G->numVertexes; i++ ){
		for( j=0; j < G->numVertexes; j++ ){
			G->arc[i][j] = INFINITY;	           // 邻接矩阵初始化	
		}
	}
	for( k=0; k < G->numEdges; k++ ){
		printf("输入边（Vi,Vj）上的下标i，下标j，和权值W:\n");	
		scanf("%d %d %d", &i, &j, &w);
		G->arc[i][j] = w;
		G->arc[j][i] = G->arc[i][j];			   // 无向图矩阵对称
	}
}

邻接表（稀疏图）

数组 + 链表
- 顶点用一个一维数组存储：【data】+【firstedge】
- 每个顶点Vi的所有邻接点构成一个线性表，用单链表存储，采用头插法
  - 无向图——边表：【adjvex】+【next】
  - 有向图——出边表：【adjvex】+【next】
  - 网：【adjvex】+【weight】+【next】

在这里插入图片描述

邻接表存储结构

typedef char VertexType;          // 用户定义顶点类型
typedef int EdgeType;             // 用户定义边上权值类型
#define MAXVEX 100                // 用户定义最大顶点数

typedef struct EdgeNode		      // 边表结点
{
	int adjvex;				      // 邻接点对应的下标
	EdgeType weight;			  // 网存储权值 
	struct EdgeNode *next;	      // 指向下一个邻接点
} EdgeNode;

typedef struct VertexNode		  // 顶点表结点
{
	VertexType data;			  // 顶点信息
	EdgeNode *firstEdge;		  // 边表头指针
} VertexNode, AdjList[MAXVEX];

typedef struct
{
	AdjList adjList;
	int numVertexes, numEdges;	  // 图当前顶点数和边数
} GraphAdjList;

由邻接表构造图

// 建立无向图的邻接表表示
void CreateALGraph(GraphAdjList *G)
{
	int i, j, k;
	EdgeNode *e;
	printf("输入顶点数和边数\n");
	scanf("%d %d", &G->numVertexes, &G->numEdges);
	for( i=0; i < G->numVertexes; i++ ){             // 建立顶点表
		scanf("%c", &G->adjList[i].data);            // 读入顶点信息
		G->adjList[i].firstEdge = NULL;	             // 边表初始化为空
	}
	for( k=0; k < G->numEdges; k++ ){                // 建立边表
		printf("输入边（Vi,Vj）上的顶点序号：\n");
		scanf("%d %d", &i, &j);
		e = (EdgeNode *)malloc(sizeof(EdgeNode));    // 申请边表结点内存空间
		e->adjvex = j;				                 // 邻接序号为j	
		e->next = G->adjList[i].firstEdge;           // e指向当前顶点指向的结点，头插法
		G->adjList[i].firstEdge = e;                 // 当前顶点指向e
		
		e = (EdgeNode *)malloc(sizeof(EdgeNode));    // 申请边表结点内存空间
		e->adjvex = i;					             // 邻接序号为i
		e->next = G->adjList[j].firstEdge;           // e指向当前顶点指向的结点，头插法
		G->adjList[j].firstEdge = e;                 // 当前顶点指向e
	}
}

十字链表（有向图）

邻接表 + 逆邻接表
- 顶点表结点：【data】+【firstin】+【firstout】
  - firstin：入边表指针
  - firstout：出边表指针
- 边表结点：【tailvex】+【headvex】+【headlink】+【taillink】
  - tailvex：弧起点在顶点表的下标
  - headvex：弧终点在顶点表的下标
  - headlink：入边表指针域，指向终点相同的下一条边
  - taillink：出边表指针域，指向起点相同的下一条边
  - weight：网中权值
特点：
- 既容易找到以Vi为尾的弧，也容易找到以Vi为头的弧
- 容易求得顶点的出度和入度

邻接多重表（无向图）

关注对边的操作，比如对已经访问过的边做标记、删除某一条边等
顶点表结点：【data】+【firstedge】
边表结点：【ivex】+【ilink】+【jvex】+【jlink】
- ivex 和 jvex 是与某条边依附的两个顶点在顶点表中的下标
- ilink 指向依附顶点 ivex 的下一条边
- jlink 指向依附顶点 jvex 的下一条边

边集数组

由两个一维数组构成，一个是存储顶点的信息，另一个是存储边的信息
边数组每个数据元素由一条边的起点下标(begin)、终点下标(end)和权(weight)组成

在这里插入图片描述

typedef struct{
	int begin;
	int end;
	int weight;
}Edge

图的遍历

从图中某一顶点出发访遍图中其余顶点，每一顶点仅被访问一次

深度优先遍历（Depth_First_Search）

类似树的先序遍历
递归工作栈，空间复杂度O(|V|)
时间复杂度：
- 邻接矩阵：O(|V|²)
- 邻接表：O(|V|+|E|)
深度优先生成树、森林：遍历过程中得到的遍历树
- 连通图：生成树
- 非连通图：生成森林
- 邻接矩阵：唯一
- 邻接表：不唯一

邻接矩阵

#define TRUE 1
#define FALSE 0
#define MAX 256

typedef int Boolean;	        // 布尔类型
Boolean visited[MAX];	        // 定义一个全局访问标志的数组

// 邻接矩阵的深度优先递归算法
void DFS(MGraph G, int i)
{
	int j;
	visited[j] = 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(MGraph 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);            // 对未访问过的结点调用DFS，若是连通图只执行一次
		}
	}
}

邻接表

#define TRUE 1
#define FALSE 0
#define MAX 256

typedef int Boolean;	 
Boolean visited[MAX]; 

// 邻接表的深度优先递归算法
void DFS(GraphAdjList GL, int i)
{
	EdgeNode *p;
	visited[i] = TRUE;
	printf("%c " GL->adjList[i].data);
	p = GL->adjList[i].firstEdge;
	while(p)
	{
		if( !visited[p->adjvex] )
		{
			DFS(GL, p->adjvex);        // 对未访问的邻接顶点递归调用
		}
		p = p->next;
	}
}

// 邻接表的深度遍历操作
void DFSTraverse(GraphAdjList GL)
{
	int i;
	for( i=0; i < GL->numVertexes; i++ )
	{
		visited[i] = FALSE;	           // 初始所有顶点都是未访问状态
	}
	for( i=0; i < GL->numVertexes; i++ )
	{
		if( !visited[i] )	 
		{
			DFS(GL, i);                // 对未访问过的结点调用DFS，若是连通图只执行一次
		}
	}
}

广度优先遍历（Breadth_First_Search）

类似树的层序遍历
辅助队列，空间复杂度O(|V|)
时间复杂度：
- 邻接矩阵：O(|V|²)
- 邻接表：O(|V|+|E|)
广度优先生成树：遍历过程中得到的遍历树
- 邻接矩阵：唯一
- - 邻接表：不唯一

邻接矩阵

// 邻接矩阵的广度遍历算法
void BFSTraverse(MGraph 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.vex[i]);
			EnQueue(&Q, i);                      // 将此顶点入队
			while( !QueueEmpty(Q) )              // 若当前队列不空
			{
				DeQueue(&Q, &i);                 // 队中元素出队，赋值给i
				for( j=0; j < G.numVertexes; j++ )
				{
					if( G.art[i][j]==1 && !visited[j] )  // 其他顶点与当前顶点存在边且未访问过
					{
						visited[j] = TRUE;
						printf("%c ", G.vex[j]);
						EnQueue(&Q, j);
					}
				}
			}
		}
	}
}

邻接表

void BFSTraverse(GraphAdjList GL)
{
	int i;
	EdgeNode *p;
	Queue Q;
	for(i = 0; i < GL->numVertexes; i++)
		visited[i] = FALSE;
	InitQueue(&Q);
	for(i = 0; i < GL->numVertexes; i++)
	{
		if(!visited[i])
		{
			visited[i] = TRUE;
			printf("%c ",GL->adjList[i].data);
			EnQueue(&Q,i);                           // 将此顶点入队
			while(!QueueEmpty(Q))
			{
				DeQueue(&Q,&i);                      // 队中元素出队，赋值给i
				p = GL->adjList[i].firstedge;        // 找到当前顶点边表链表头指针
				while(p)
				{
					if(!visited[p->adjvex])          // 若此顶点未被访问
					{
						visited[p->adjvex]=TRUE;
						printf("%c ",GL->adjList[p->adjvex].data);
						EnQueue(&Q,p->adjvex);       // 将此顶点入队列
					}
					p = p->next;                     // 指针指向下一个邻接点
				}
			}
		}
	}
}

最小生成树

带权连通无向图
连通图的生成树是图的极小连通子图
【最小生成树】：权值之和最小的生成树
若任一环中边的权值互不相等则最小生成树唯一

普里姆(Prim)算法（稠密图）

O(|V|²)

void MiniSpanTree_Prim(MGraph 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 )    // 循环全部顶点 
		{
			 
			if( lowcost[j]!=0 && lowcost[j] < min )  // 权值不为0且权值小于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];     // 将较小权值存入lowcost 
				adjvex[j] = k;	              // 将下标为k的顶点存入adjvex 
			}
		}
	}
}

克鲁斯卡尔(Kruskal)算法（稀疏图）

O(|E|log|E|)

// Kruskal算法生成最小生成树
void MiniSpanTree_Kruskal(MGraph G)
{
	int i, n, m;
	Edge edges[MAGEDGE];	// 定义边集数组
	int parent[MAXVEX];		// 定义parent数组用来判断边与边是否形成环路
	
	for( i=0; i < G.numVertexes; i++ )
	{
		parent[i] = 0;
	}
	
	for( i=0; i < G.numEdges; i++ )
	{
		n = Find(parent, edges[i].begin);	// 4 2 0 1 5 3 8 6 6 6 7
		m = Find(parent, edges[i].end);		// 7 8 1 5 8 7 6 6 6 7 7
		
		if( n != m )		// 如果n==m，则形成环路，不满足！
		{
			parent[n] = m;	// 将此边的结尾顶点放入下标为起点的parent数组中，表示此顶点已经在生成树集合中
			printf("(%d, %d) %d ", edges[i].begin, edges[i].end, edges[i].weight);
		}
	}
}

int Find(int *parent, int f)
{
	while( parent[f] > 0 )
	{
		f = parent[f];
	}
	
	return f;
}

最短路径

网图是两顶点经过的边上权值之和最少的路径
非网图是两顶点之间经过的边数最少的路径

迪杰斯特拉算法（Dijkstra）

某源点到其余各顶点的最短路径
基于已求最短路径的基础求得更远顶点的最短路径

#define MAXVEX	9
#define	INFINITY	65535

typedef	int	Patharc[MAXVEX];			// 用于存储最短路径下标的数组
typedef int	ShortPathTable[MAXVEX];		// 用于存储到各点最短路径的权值和

void ShortestPath_Dijkstar(MGraph G, int V0, Patharc *P, ShortPathTable *D)
{
	int v, w, k, min;
	int final[MAXVEX];		// final[w] = 1 表示已经求得顶点V0到Vw的最短路径
	
	// 初始化数据
	for( v=0; v < G.numVertexes; v++ )
	{
		final[v] = 0;				// 全部顶点初始化为未找到最短路径
		(*D)[V] = G.arc[V0][v];		// 将与V0点有连线的顶点加上权值
		(*P)[V] = 0;				// 初始化路径数组P为0
	}
	(*D)[V0] = 0;		// V0至V0的路径为0
	final[V0] = 1;		// V0至V0不需要求路径
	
	// 开始主循环，每次求得V0到某个V顶点的最短路径
	for( v=1; v < G.numVertexes; v++ )
	{
		min = INFINITY;
		for( w=0; w < G.numVertexes; w++ )
		{
			if( !final[w] && (*D)[w]<min )
			{
				k = w;
				min = (*D)[w];
			}
		}
		final[k] = 1;	// 将目前找到的最近的顶点置1
		
		// 修正当前最短路径及距离
		for( w=0; w < G.numVextexes; w++ )
		{
			// 如果经过v顶点的路径比现在这条路径的长度短的话，更新！
			if( !final[w] && (min+G.arc[k][w] < (*D)[w]) )
			{
				(*D)[w] = min + G.arc[k][w];	// 修改当前路径长度
				(*p)[w] = k;					// 存放前驱顶点
			}
		}
	}
}

弗洛伊德算法（Floyd）

各顶点之间最短路径
逐步尝试在原路径中加入各顶点作为中间顶点，若增加后所得路径长度减少，则代替原路径

#define MAXVEX	9
#define INFINITY	65535

typedef int Pathmatirx[MAXVEX][MAXVEX];
typedef int ShortPathTable[MAXVEX][MAXVEX];

void ShortestPath_Floyd(MGraph G, Pathmatirx *P, ShortPathTable *D)
{
	int v, w, k;
	
	// 初始化D和P
	for( v=0; v < G.numVertexes; v++ )
	{
		for( w=0; w < G.numVertexes; w++ )
		{
			(*D)[v][w] = G.matirx[v][w];
			(*P)[v][w] = w;
		}
	}
	
	// 优美的弗洛伊德算法
	for( k=0; k < G.numVertexes; k++ )
	{
		for( v=0; v < G.numVertexes; v++ )
		{
			for( w=0; w < G.numVertexes; w++ )
			{
				if( (*D)[v][w] > (*D)[v][k] + (*D)[k][w] )
				{
					(*D)[v][w] = (*D)[v][k] + (*D)[k][w];
					(*P)[v][w] = (*P)[v][k];		
				}
			}
		}
	}
}

拓扑排序

【DAG图】无环图（Directed Acyclic Graph）：一个无环的有向图
【AOV网】（Active On Vertex Network）：一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系
【拓扑序列】：设G=(V,E)是一个具有n个顶点的有向图，V中的顶点序列V1,V2,……,Vn满足若从顶点Vi到Vj有一条路径，则在顶点序列中顶点Vi必在顶点Vj之前
每个DAG图都有一个或多个拓扑排序序列
步骤：
- 从AOV网中选择一个没有前趋的顶点（该顶点的入度为0）并且输出它；
- 从网中删去该顶点，并且删去从该顶点发出的全部有向边；
- 重复上述两步，直到剩余网中不再存在没有前趋的顶点为止。
算法时间复杂度：
- 对一个具有n个顶点，e条边的网来说，初始建立入度为零的顶点栈，要检查所有顶点一次，执行时间为O(n)。
- 排序中，若AOV网无回路，则每个顶点入、出栈各一次，每个表结点被检查一次，因而执行时间是 O(n+e)。
- 所以，整个算法的时间复杂度是 O(n+e)

// 边表结点声明
typedef struct EdgeNode
{
	int adjvex;
	struct EdgeNode *next;
}EdgeNode;

// 顶点表结点声明
typedef struct VertexNode
{
	int in;			// 顶点入度
	int data;
	EdgeNode *firstedge;
}VertexNode, AdjList[MAXVEX];

typedef struct
{
	AdjList adjList;
	int numVertexes, numEdges;
}graphAdjList, *GraphAdjList;

// 拓扑排序算法
// 若GL无回路，则输出拓扑排序序列并返回OK，否则返回ERROR
Status TopologicalSort(GraphAdjList GL)
{
	EdgeNode *e;
	int i, k, gettop;
	int top = 0;		// 用于栈指针下标索引
	int count = 0;		// 用于统计输出顶点的个数
	int *stack;			// 用于存储入度为0的顶点
	
	stack = (int *)malloc(GL->numVertexes * sizeof(int));
	
	for( i=0; i < GL->numVertexes; i++ )
	{
		if( 0 == GL->adjList[i].in )
		{
			stack[++top] = i;	// 将度为0的顶点下标入栈
		}
	}
	
	while( 0 != top )
	{
		gettop = stack[top--];	// 出栈
		printf("%d -> ", GL->adjList[gettop].data);
		count++;				
		
		for( e=GL->adjList[gettop].firstedge; e; e=e->next )
		{
			k = e->adjvex;
			// 注意：下边这个if条件是分析整个程序的要点！
			// 将k号顶点邻接点的入度-1，因为他的前驱已经消除
			// 接着判断-1后入度是否为0，如果为0则也入栈
			if( !(--GL->adjList[k].in) )	
			{
				stack[++top] = k;
			}
		}
	}
	
	if( count < GL->numVertexes )	// 如果count小于顶点数，说明存在环
	{
		return ERROR;
	}
	else
	{
		return OK;
	}
}

关键路径

【AOE网】（Activity On Edge Network）：在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，用边上的权值表示活动的持续时间
没有入边的顶点称为始点或【源点】
没有出边的顶点称为终点或【汇点】
etv(Earliest Time Of Vertex)：事件最早发生时间，就是顶点的最早发生时间；
ltv(Latest Time Of Vertex)：事件最晚发生时间，就是每个顶点对应的事件最晚需要开始的时间，如果超出此时间将会延误整个工期。
ete(Earliest Time Of Edge)：活动的最早开工时间，就是弧的最早发生时间。
lte(Latest Time Of Edge)：活动的最晚发生时间，就是不推迟工期的最晚开工时间。

// 边表结点声明
typedef struct EdgeNode
{
	int adjvex;
	struct EdgeNode *next;
}EdgeNode;

// 顶点表结点声明
typedef struct VertexNode
{
	int in;			// 顶点入度
	int data;
	EdgeNode *firstedge;
}VertexNode, AdjList[MAXVEX];

typedef struct
{
	AdjList adjList;
	int numVertexes, numEdges;
}graphAdjList, *GraphAdjList;

int *etv, *ltv;
int *stack2;			// 用于存储拓扑序列的栈
int top2;				// 用于stack2的栈顶指针

// 拓扑排序算法
// 若GL无回路，则输出拓扑排序序列并返回OK，否则返回ERROR
Status TopologicalSort(GraphAdjList GL)
{
	EdgeNode *e;
	int i, k, gettop;
	int top = 0;		// 用于栈指针下标索引
	int count = 0;		// 用于统计输出顶点的个数
	int *stack;			// 用于存储入度为0的顶点
	
	stack = (int *)malloc(GL->numVertexes * sizeof(int));
	
	for( i=0; i < GL->numVertexes; i++ )
	{
		if( 0 == GL->adjList[i].in )
		{
			stack[++top] = i;	// 将度为0的顶点下标入栈
		}
	}
	
	// 初始化etv都为0
	top2 = 0;
	etv = (int *)malloc(GL->numVertexes*sizeof(int));
	for( i=0; i < GL->numVertexes; i++ )
	{
		etv[i] = 0;
	}
	stack2 = (int *)malloc(GL->numVertexes*sizeof(int));
	
	while( 0 != top )
	{
		gettop = stack[top--];		// 出栈
		// printf("%d -> ", GL->adjList[gettop].data); 
		stack2[++top2] = gettop;	// 保存拓扑序列顺序 C1 C2 C3 C4 .... C9
		count++;				
		
		for( e=GL->adjList[gettop].firstedge; e; e=e->next )
		{
			k = e->adjvex;
			// 注意：下边这个if条件是分析整个程序的要点！
			// 将k号顶点邻接点的入度-1，因为他的前驱已经消除
			// 接着判断-1后入度是否为0，如果为0则也入栈
			if( !(--GL->adjList[k].in) )	
			{
				stack[++top] = k;
			}
			
			if( (etv[gettop]+e->weight) > etv[k] )
			{
				etv[k] = etv[gettop] + e->weight;
			}
		}
	}
	
	if( count < GL->numVertexes )	// 如果count小于顶点数，说明存在环
	{
		return ERROR;
	}
	else
	{
		return OK;
	}
}

// 求关键路径，GL为有向图，输出GL的各项关键活动
void CriticalPath(GraphAdjList GL)
{
	EdgeNode *e;
	int i, gettop, k, j;
	int ete, lte;
	
	// 调用改进后的拓扑排序，求出etv和stack2的值
	TopologicalSort(GL);
	
	// 初始化ltv都为汇点的时间
	ltv = (int *)malloc(GL->numVertexes*sizeof(int));
	for( i=0; i < GL->numVertexes; i++ )
	{
		ltv[i] = etv[GL->numVertexes-1];
	}
	
	// 从汇点倒过来逐个计算ltv
	while( 0 != top2 )
	{
		gettop = stack2[top2--];	// 注意，第一个出栈是汇点
		for( e=GL->adjList[gettop].firstedge; e; e=e->next )
		{
			k = e->adjvex;
			if( (ltv[k] - e->weight) < ltv[gettop] )
			{
				ltv[gettop] = ltv[k] - e->weight;
			}
		}
	}
	
	// 通过etv和ltv求ete和lte
	for( j=0; j < GL->numVertexes; j++ )
	{
		for( e=GL->adjList[j].firstedge; e; e=e->next )
		{
			k = e->adjvex;
			ete = etv[j];
			lte = ltv[k] - e->weight;
			
			if( ete == lte )
			{
				printf("<v%d,v%d> length: %d , ", GL->adjList[j].data, GL->adjList[k].data, e->weight );
			}
		}
	}
}

lssssssssy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
七、图

目录图与线性表、树的区别图的相关定义度连通图ADT图的存储结构邻接矩阵（稠密图）邻接矩阵存储结构由邻接矩阵构造图邻接表（稀疏图）邻接表存储结构由邻接表构造图十字链表（有向图）邻接多重表（无向图）图图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)G表示一个图V是图G中顶点的集合E是图G中边的集合与线性表、树的区别1线性表中：数据元...
复制链接

扫一扫

专栏目录