数据结构与算法（11）—— 图_设无向图g中的边的集合e

第五章：图

图的基本概念

• 定义：
  树是N（N≥0）个结点的有限集合，N=0时，称为空树，这是一种特殊情况。在任意一棵非空树中应满足：
  1）有且仅有一个特定的称为根的结点。
  2）当N>1时，其余结点可分为m（m>0）个互不相交的有限集合T1，T2，…，Tm，其中每一个集合本身又是一棵树，并且称为根结点的子树。
  • 图G由顶点集V和边集E组成，记为G=(V，E)
    • V(G)表示图G中顶点的有限非空集。
      用|V|表示图G中顶点的个数，也称为图G的阶
    • E(G)表示图G中顶点之间的关系（边）集合。
      用|E|表示图G中边的条数。
• 分类
  • 有向图
    • 有向边（弧）的有限集合
      • 弧是顶点的有序对
      • <v,w>
      • v是弧尾，w是弧头
      • v邻接到w或w邻接自v
  • 无向图
    • 无向边的有限集合
      • 边是顶点的无序对
      • （v,w）
      • （v,w）=(w,v)
      • w，v互为邻接点
• 简单图
  • 1.不存在顶点到自身的边
  • 2.同一条边不重复出现
• 多重图
  • 若图G中某两个结点之间的边数多于一条，又允许顶点通过通过同一个边和自己关联
• 完全图
  • 无向完全图
    • 如果任意两个顶点之间都存在边
  • 有向完全图
    • 如果任意两个顶点之间都存在方向相反的两条弧
• 子图
• 连通图：图中任意两个顶点都是连通的
• 连通分量：无向图中的极大连通子图
  • 连通
    • 顶点A到顶点B有路径
  • 极大
    • 1.顶点足够多
    • 2.极大连通子图包含这些依附这些顶点的所有边
  • 结论1:如果一个图有n个顶点，并且有小于n-1条边，则此图必是非连通图。
  • 概要: 找连通分量的方法：
    从选取一个顶点开始，以这个顶点作为一个子图，然后逐个添加与这个子图相连的顶点和边直到所有相连的顶点都加入该子图
• 强连通：顶点V到顶点W和顶点W到顶点V都有路径
• 强连通图：图中任一对顶点都是强连通的
• 连通图的生成树：包含图中全部n个顶点，但是只有n-1条边的极小连通子图
  • 结论2:生成树去掉一条边则变成非连通图，加上一条边就会形成回路。
• 度：以该顶点为一个端点的边数目
  • 无向图中顶点V的度是指依附于该顶点的边的条数，记为TD(v)
  • 有向图中顶点V的度分为出度和入度
    • 入度（ID）是以顶点v为终点的有向边的数目
    • 出度（OD）是以顶点V为起点的有向边的数目
• 简单路径和简单回路：顶点不重复出现的路径称为简单路径。对于回路，除了第一个和最后一个顶点其余顶点不重复出现的回路称为简单回路
• 权和网：图中每条边考研赋予一定意义的数值，这个数值叫做这条边的权，有权值得图称为带权图，也叫做网
• 路径和路径长度：顶点p到q之间的路径是指顶点序列怕保存的，p,a,b,c,d,……q。路径上边的数目就是路径长度
• 回路（环）：第一个和最后一个顶点相同的路径称为回路或者环
• 距离：从顶点u到v的最短路径长度。不存在路径则为无穷

图的存储结构

• 邻接矩阵（顺序存储）
  
  特征：
• 对角线元素全 0
• 关于对角线对称
  优点：
• 直观、简单、好理解
• 方便检查任意一对顶点间是否存在边
• 方便找任一顶点的所有邻接点
• 方便计算任一顶点的度
• 无向图：对应行（或列）非 0 元素的个数
• 有向图：对应行非 0 元素的个数是出度；对应列非 0 元素的个数是入度
  缺点：
• 浪费空间——存稀疏图
• 浪费时间——统计稀疏图的边

#include<stdio.h>
#include<stdlib.h>
#define MaxVertexNum 100
typedef int weightType;
typedef int Vertex;
typedef int DataType;
typedef struct GNode *ptrToGNode;
struct GNode{   // 图 
	int Nv;   // 顶点数 
	int Ne;   // 边数
	weightType G[MaxVertexNum][MaxVertexNum];
	DataType Data[MaxVertexNum]; // 存顶点的数据 
}; 
typedef ptrToGNode MGraph;
typedef struct ENode *ptrToENode;
struct ENode{  // 边 
	Vertex V1,V2;    // 有向边<V1,V2> 
	weightType Weight;  // 权重 
};
typedef ptrToENode Edge;

// 初始化图 
MGraph Create(int VertexNum){
	Vertex v,w;
	MGraph Graph;
	
	Graph = (MGraph)malloc(sizeof(struct GNode));
	Graph->Nv = VertexNum;
	Graph->Ne = 0;
	
	for(v=0;v<VertexNum;v++)
		for(w=0;w<VertexNum;w++)
			Graph->G[v][w] = 0;
	return Graph;
}

// 插入边 
MGraph Insert(MGraph Graph,Edge E){
	
	// 插入边 <V1,V2>
	Graph->G[E->V1][E->V2] = E->Weight;
	
	// 如果是无向图，还需要插入边 <V2,V1>
	Graph->G[E->V2][E->V1] = E->Weight;
	
} 

// 建图 
MGraph BuildGraph(){
	MGraph Graph;
	Edge E;
	Vertex V;
	int Nv,i;
	scanf("%d",&Nv);   // 读入顶点数 
	Graph = Create(Nv);
	scanf("%d",&(Graph->Ne));  // 读入边数 
	if(Graph->Ne != 0){   
		E = (Edge)malloc(sizeof(struct ENode));
		for(i=0;i<Graph->Ne;i++){
			scanf("%d %d %d",&E->V1,&E->V2,&E->Weight);  // 读入每个边的数据 
			Insert(Graph,E);
		}
	}
	return Graph;
}

// 遍历图
void print(MGraph Graph){
	Vertex v,w;
	for(v=0;v<Graph->Nv;v++){
		for(w=0;w<Graph->Nv;w++)
			printf("%d ",Graph->G[v][w]);
		printf("\n");
	}
} 

int main(){
	MGraph Graph;
	Graph = BuildGraph();
	print(Graph);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

• 邻接表（链式存储）
  • 十字链表（有向图）
  • 邻接多重表（无向图）
    
    特点：
• 方便找任一顶点的所有邻接顶点
• 节省稀疏图的空间
  　* 需要 N 个头指针 + 2E 个结点（每个结点至少 2 个域）
• 对于是否方便计算任一顶点的度
  　* 无向图：方便
  　* 有向图：只能计算出度
• 不方便检查任意一对顶点间是否存在边

#include<stdio.h>
#include<stdlib.h>
#define MaxVertexNum 100
typedef int Vertex; 
typedef int DataType; 
typedef int weightType;  

typedef struct ENode *ptrToENode;
struct ENode{  // 边 
	Vertex V1,V2;    // 有向边<V1,V2> 
	weightType Weight;  // 权重 
};
typedef ptrToENode Edge;

typedef struct AdjVNode *ptrToAdjVNode;
struct AdjVNode{  // 邻接表内元素 
	Vertex AdjV;  // 邻接点下标 
	weightType Weight;  // 权值 
	ptrToAdjVNode Next;  // 下一个 
};

typedef struct VNode{  // 邻接表头 
	ptrToAdjVNode FirstEdge;  // 存每个顶点指针
	DataType Data;  // 顶点数据 
}AdjList[MaxVertexNum];

typedef struct GNode *ptrToGNode;
struct GNode{  // 图 
	int Nv;  // 顶点
	int Ne;  // 边数 
	AdjList G; // 邻接表 
}; 
typedef ptrToGNode LGraph;

// 初始化 
LGraph create(int VertexNum){
	Vertex v,w;
	LGraph Graph;
	
	Graph = (LGraph)malloc(sizeof(struct GNode));
	Graph->Nv = VertexNum;  // 初始化边
	Graph->Ne = 0;   // 初始化点
	
	// 每条边的 FirstEdge 指向 NULL 
	for(v=0;v<Graph->Nv;v++)
		Graph->G[v].FirstEdge = NULL;
	return Graph;
}

// 插入一条边到邻接表的顶点指针之后 
void InsertEdge(LGraph Graph,Edge E){
	ptrToAdjVNode newNode; 
	
	/**************** 插入边<V1,V2> ******************/ 
	// 为 V2 建立新的结点 
	newNode = (ptrToAdjVNode)malloc(sizeof(struct AdjVNode));
	newNode->AdjV = E->V2;
	newNode->Weight = E->Weight;
	
	// 将 V2 插入到邻接表头 
	newNode->Next = Graph->G[E->V1].FirstEdge;
	Graph->G[E->V1].FirstEdge = newNode;
	
	/*************** 若为无向图，插入边<V2,V1> *************/ 
	newNode = (ptrToAdjVNode)malloc(sizeof(struct AdjVNode));
	newNode->AdjV = E->V1;
	newNode->Weight = E->Weight;
	
	newNode->Next = Graph->G[E->V2].FirstEdge;
	Graph->G[E->V2].FirstEdge = newNode;
} 

// 建图
LGraph BuildGraph(){
	LGraph Graph;
	Edge E;
	Vertex V;
	int Nv,i;
	scanf("%d",&Nv);
	Graph = create(Nv);
	scanf("%d",&(Graph->Ne));
	if(Graph->Ne != 0){
		for(i=0;i<Graph->Ne;i++){
			E = (Edge)malloc(sizeof(struct ENode));
			scanf("%d %d %d",&E->V1,&E->V2,&E->Weight);
			InsertEdge(Graph,E);
		}
	}
	return Graph;
} 

// 打印 
void print(LGraph Graph){
	Vertex v;
	ptrToAdjVNode tmp;
	for(v=0;v<Graph->Nv;v++){
		tmp = Graph->G[v].FirstEdge;
		printf("%d ",v);
		while(tmp){
			printf("%d ",tmp->AdjV);
			tmp = tmp->Next;
		}
		printf("\n");
	}
}

int main(){
	LGraph Graph;
	Graph = BuildGraph();
	print(Graph);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112