当前位置:坤哥网-gooditblog-算法系列15天速成——第十四天 图【上】

算法系列15天速成——第十四天 图【上】

2011/12/24 22:51:00 gooditblog阅读(210) 评论(13)

 

       今天来分享一下图,这是一种比较复杂的非线性数据结构,之所以复杂是因为他们的数据元素之间的关系是任意的,而不像树那样

被几个性质定理框住了,元素之间的关系还是比较明显的,图的使用范围很广的,比如网络爬虫,求最短路径等等,不过大家也不要胆怯,

越是复杂的东西越能体现我们码农的核心竞争力。

       

      既然要学习图,得要遵守一下图的游戏规则。

一: 概念

       图是由“顶点”的集合和“边”的集合组成。记作:G=(V,E);

<1> 无向图

       就是“图”中的边没有方向,那么(V1,V2)这条边自然跟(V2,V1)是等价的,无向图的表示一般用”圆括号“。

        

<2> 有向图

       “图“中的边有方向,自然<V1,V2>这条边跟<V2,V1>不是等价的,有向图的表示一般用"尖括号"表示。

             

<3> 邻接点

             一条边上的两个顶点叫做邻接点,比如(V1,V2),(V1,V3),(V1,V5),只是在有向图中有一个“入边,出边“的

       概念,比如V3的入边为V5,V3的出边为V2,V1,V4。

 

<4> 顶点的度

          这个跟“树”中的度的意思一样。不过有向图中也分为“入度”和“出度”两种,这个相信大家懂的。

 

<5> 完全图

         每两个顶点都存在一条边,这是一种完美的表现,自然可以求出边的数量。

        无向图:edges=n(n-1)/2;

        有向图:edges=n(n-1);           //因为有向图是有边的,所以必须在原来的基础上"X2"。

       

<6> 子图

        如果G1的所有顶点和边都在G2中,则G1是G2的子图,具体不说了。

 

<7> 路径,路径长度和回路(这些概念还是比较重要的)

       路径:        如果Vm到Vn之间存在一个顶点序列。则表示Vm到Vn是一条路径。

       路径长度:  一条路径中“边的数量”。

       简单路径:  若一条路径上顶点不重复出现,则是简单路径。

       回路:       若路径的第一个顶点和最后一个顶点相同,则是回路。

       简单回路:  第一个顶点和最后一个顶点相同,其它各顶点都不重复的回路则是简单回路。

 

<8> 连通图和连通分量(针对无向图而言的)

       连通图:     无向图中,任意两个顶点都是连通的则是连通图,比如V1,V2,V4之间。

       连通分量:  无向图的极大连通子图就是连通分量,一般”连通分量“就是”图“本身,除非是“非连通图”,

                       如下图就是两个连通分量。

           

<9> 强连通图和强连通分量(针对有向图而言)

        这里主要注意的是“方向性“,V4可以到V3,但是V3无法到V4,所以不能称为强连通图。

       

<10> 网

        边上带有”权值“的图被称为网。很有意思啊,呵呵。

 

二:存储

     图的存储常用的是”邻接矩阵”和“邻接表”。

     邻接矩阵: 手法是采用两个数组,一个一维数组用来保存顶点信息,一个二维数组来用保存边的信息,

                    缺点就是比较耗费空间。

     邻接表:   改进后的“邻接矩阵”,缺点是不方便判断两个顶点之间是否有边,但是相比节省空间。

 

三: 创建图

     这里我们就用邻接矩阵来保存图,一般的操作也就是:①创建,②遍历

 1 #region 邻接矩阵的结构图
2 /// <summary>
3 /// 邻接矩阵的结构图
4 /// </summary>
5 public class MatrixGraph
6 {
7 //保存顶点信息
8 public string[] vertex;
9
10 //保存边信息
11 public int[,] edges;
12
13 //深搜和广搜的遍历标志
14 public bool[] isTrav;
15
16 //顶点数量
17 public int vertexNum;
18
19 //边数量
20 public int edgeNum;
21
22 //图类型
23 public int graphType;
24
25 /// <summary>
26 /// 存储容量的初始化
27 /// </summary>
28 /// <param name="vertexNum"></param>
29 /// <param name="edgeNum"></param>
30 /// <param name="graphType"></param>
31 public MatrixGraph(int vertexNum, int edgeNum, int graphType)
32 {
33 this.vertexNum = vertexNum;
34 this.edgeNum = edgeNum;
35 this.graphType = graphType;
36
37 vertex = new string[vertexNum];
38 edges = new int[vertexNum, vertexNum];
39 isTrav = new bool[vertexNum];
40 }
41
42 }
43 #endregion


<1> 创建图很简单,让用户输入一些“边,点,权值"来构建一下图

 1  #region 图的创建
2 /// <summary>
3 /// 图的创建
4 /// </summary>
5 /// <param name="g"></param>
6 public MatrixGraph CreateMatrixGraph()
7 {
8 Console.WriteLine("请输入创建图的顶点个数,边个数,是否为无向图(0,1来表示),已逗号隔开。");
9
10 var initData = Console.ReadLine().Split(',').Select(i => int.Parse(i)).ToList();
11
12 MatrixGraph graph = new MatrixGraph(initData[0], initData[1], initData[2]);
13
14 Console.WriteLine("请输入各顶点信息:");
15
16 for (int i = 0; i < graph.vertexNum; i++)
17 {
18 Console.Write("\n第" + (i + 1) + "个顶点为:");
19
20 var single = Console.ReadLine();
21
22 //顶点信息加入集合中
23 graph.vertex[i] = single;
24 }
25
26 Console.WriteLine("\n请输入构成两个顶点的边和权值,以逗号隔开。\n");
27
28 for (int i = 0; i < graph.edgeNum; i++)
29 {
30 Console.Write("" + (i + 1) + "条边:\t");
31
32 initData = Console.ReadLine().Split(',').Select(j => int.Parse(j)).ToList();
33
34 int start = initData[0];
35 int end = initData[1];
36 int weight = initData[2];
37
38 //给矩阵指定坐标位置赋值
39 graph.edges[start - 1, end - 1] = weight;
40
41 //如果是无向图,则数据呈“二,四”象限对称
42 if (graph.graphType == 1)
43 {
44 graph.edges[end - 1, start - 1] = weight;
45 }
46 }
47
48 return graph;
49 }
50 #endregion

 

<2>广度优先

      针对下面的“图型结构”,我们如何广度优先呢?其实我们只要深刻理解"广搜“给我们定义的条条框框就行了。 为了避免同一个顶点在遍历时被多

次访问,可以将”顶点的下标”存放在sTrav[]的bool数组,用来标识是否已经访问过该节点。  

    第一步:首先我们从isTrav数组中选出一个未被访问的节点,如V1。

    第二步:访问V1的邻接点V2,V3,V5,并将这三个节点标记为true。

    第三步:第二步结束后,我们开始访问V2的邻接点V1,V3,但是他们都是被访问过的。

    第四步:我们从第二步结束的V3出发访问他的邻接点V2,V1,V5,V4,还好V4是未被访问的,此时标记一下。

    第五步:我们访问V5的邻接点V1,V3,V4,不过都是已经访问过的。

    第六步:有的图中通过一个顶点的“广度优先”不能遍历所有的顶点,此时我们重复(1-5)的步骤就可以最终完成广度优先遍历。

                

 1 #region 广度优先
2 /// <summary>
3 /// 广度优先
4 /// </summary>
5 /// <param name="graph"></param>
6 public void BFSTraverse(MatrixGraph graph)
7 {
8 //访问标记默认初始化
9 for (int i = 0; i < graph.vertexNum; i++)
10 {
11 graph.isTrav[i] = false;
12 }
13
14 //遍历每个顶点
15 for (int i = 0; i < graph.vertexNum; i++)
16 {
17 //广度遍历未访问过的顶点
18 if (!graph.isTrav[i])
19 {
20 BFSM(ref graph, i);
21 }
22 }
23 }
24
25 /// <summary>
26 /// 广度遍历具体算法
27 /// </summary>
28 /// <param name="graph"></param>
29 public void BFSM(ref MatrixGraph graph, int vertex)
30 {
31 //这里就用系统的队列
32 Queue<int> queue = new Queue<int>();
33
34 //先把顶点入队
35 queue.Enqueue(vertex);
36
37 //标记此顶点已经被访问
38 graph.isTrav[vertex] = true;
39
40 //输出顶点
41 Console.Write(" ->" + graph.vertex[vertex]);
42
43 //广度遍历顶点的邻接点
44 while (queue.Count != 0)
45 {
46 var temp = queue.Dequeue();
47
48 //遍历矩阵的横坐标
49 for (int i = 0; i < graph.vertexNum; i++)
50 {
51 if (!graph.isTrav[i] && graph.edges[temp, i] != 0)
52 {
53 graph.isTrav[i] = true;
54
55 queue.Enqueue(i);
56
57 //输出未被访问的顶点
58 Console.Write(" ->" + graph.vertex[i]);
59 }
60 }
61 }
62 }
63 #endregion


<3> 深度优先

        同样是这个图,大家看看如何实现深度优先,深度优先就像铁骨铮铮的好汉,遵循“能进则进,不进则退”的原则。

        第一步:同样也是从isTrav数组中选出一个未被访问的节点,如V1。

        第二步:然后一直访问V1的邻接点,一直到走头无路的时候“回溯”,路线为V1,V2,V3,V4,V5,到V5的时候访问邻接点V1,发现V1是访问过的,

                   此时一直回溯的访问直到V1。

        第三步: 同样有的图中通过一个顶点的“深度优先”不能遍历所有的顶点,此时我们重复(1-2)的步骤就可以最终完成深度优先遍历。

              

 1 #region 深度优先
2 /// <summary>
3 /// 深度优先
4 /// </summary>
5 /// <param name="graph"></param>
6 public void DFSTraverse(MatrixGraph graph)
7 {
8 //访问标记默认初始化
9 for (int i = 0; i < graph.vertexNum; i++)
10 {
11 graph.isTrav[i] = false;
12 }
13
14 //遍历每个顶点
15 for (int i = 0; i < graph.vertexNum; i++)
16 {
17 //广度遍历未访问过的顶点
18 if (!graph.isTrav[i])
19 {
20 DFSM(ref graph, i);
21 }
22 }
23 }
24
25 #region 深度递归的具体算法
26 /// <summary>
27 /// 深度递归的具体算法
28 /// </summary>
29 /// <param name="graph"></param>
30 /// <param name="vertex"></param>
31 public void DFSM(ref MatrixGraph graph, int vertex)
32 {
33 Console.Write("->" + graph.vertex[vertex]);
34
35 //标记为已访问
36 graph.isTrav[vertex] = true;
37
38 //要遍历的六个点
39 for (int i = 0; i < graph.vertexNum; i++)
40 {
41 if (graph.isTrav[i] == false && graph.edges[vertex, i] != 0)
42 {
43 //深度递归
44 DFSM(ref graph, i);
45 }
46 }
47 }
48 #endregion
49 #endregion

 

最后上一下总的代码

View Code
  1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5
6 namespace MatrixGraph
7 {
8 public class Program
9 {
10 static void Main(string[] args)
11 {
12 MatrixGraphManager manager = new MatrixGraphManager();
13
14 //创建图
15 MatrixGraph graph = manager.CreateMatrixGraph();
16
17 manager.OutMatrix(graph);
18
19 Console.Write("广度递归:\t");
20
21 manager.BFSTraverse(graph);
22
23 Console.Write("\n深度递归:\t");
24
25 manager.DFSTraverse(graph);
26
27 Console.ReadLine();
28
29 }
30 }
31
32 #region 邻接矩阵的结构图
33 /// <summary>
34 /// 邻接矩阵的结构图
35 /// </summary>
36 public class MatrixGraph
37 {
38 //保存顶点信息
39 public string[] vertex;
40
41 //保存边信息
42 public int[,] edges;
43
44 //深搜和广搜的遍历标志
45 public bool[] isTrav;
46
47 //顶点数量
48 public int vertexNum;
49
50 //边数量
51 public int edgeNum;
52
53 //图类型
54 public int graphType;
55
56 /// <summary>
57 /// 存储容量的初始化
58 /// </summary>
59 /// <param name="vertexNum"></param>
60 /// <param name="edgeNum"></param>
61 /// <param name="graphType"></param>
62 public MatrixGraph(int vertexNum, int edgeNum, int graphType)
63 {
64 this.vertexNum = vertexNum;
65 this.edgeNum = edgeNum;
66 this.graphType = graphType;
67
68 vertex = new string[vertexNum];
69 edges = new int[vertexNum, vertexNum];
70 isTrav = new bool[vertexNum];
71 }
72
73 }
74 #endregion
75
76 /// <summary>
77 /// 图的操作类
78 /// </summary>
79 public class MatrixGraphManager
80 {
81 #region 图的创建
82 /// <summary>
83 /// 图的创建
84 /// </summary>
85 /// <param name="g"></param>
86 public MatrixGraph CreateMatrixGraph()
87 {
88 Console.WriteLine("请输入创建图的顶点个数,边个数,是否为无向图(0,1来表示),已逗号隔开。");
89
90 var initData = Console.ReadLine().Split(',').Select(i => int.Parse(i)).ToList();
91
92 MatrixGraph graph = new MatrixGraph(initData[0], initData[1], initData[2]);
93
94 Console.WriteLine("请输入各顶点信息:");
95
96 for (int i = 0; i < graph.vertexNum; i++)
97 {
98 Console.Write("\n第" + (i + 1) + "个顶点为:");
99
100 var single = Console.ReadLine();
101
102 //顶点信息加入集合中
103 graph.vertex[i] = single;
104 }
105
106 Console.WriteLine("\n请输入构成两个顶点的边和权值,以逗号隔开。\n");
107
108 for (int i = 0; i < graph.edgeNum; i++)
109 {
110 Console.Write("" + (i + 1) + "条边:\t");
111
112 initData = Console.ReadLine().Split(',').Select(j => int.Parse(j)).ToList();
113
114 int start = initData[0];
115 int end = initData[1];
116 int weight = initData[2];
117
118 //给矩阵指定坐标位置赋值
119 graph.edges[start - 1, end - 1] = weight;
120
121 //如果是无向图,则数据呈“二,四”象限对称
122 if (graph.graphType == 1)
123 {
124 graph.edges[end - 1, start - 1] = weight;
125 }
126 }
127
128 return graph;
129 }
130 #endregion
131
132 #region 输出矩阵数据
133 /// <summary>
134 /// 输出矩阵数据
135 /// </summary>
136 /// <param name="graph"></param>
137 public void OutMatrix(MatrixGraph graph)
138 {
139 for (int i = 0; i < graph.vertexNum; i++)
140 {
141 for (int j = 0; j < graph.vertexNum; j++)
142 {
143 Console.Write(graph.edges[i, j] + "\t");
144 }
145 //换行
146 Console.WriteLine();
147 }
148 }
149 #endregion
150
151 #region 广度优先
152 /// <summary>
153 /// 广度优先
154 /// </summary>
155 /// <param name="graph"></param>
156 public void BFSTraverse(MatrixGraph graph)
157 {
158 //访问标记默认初始化
159 for (int i = 0; i < graph.vertexNum; i++)
160 {
161 graph.isTrav[i] = false;
162 }
163
164 //遍历每个顶点
165 for (int i = 0; i < graph.vertexNum; i++)
166 {
167 //广度遍历未访问过的顶点
168 if (!graph.isTrav[i])
169 {
170 BFSM(ref graph, i);
171 }
172 }
173 }
174
175 /// <summary>
176 /// 广度遍历具体算法
177 /// </summary>
178 /// <param name="graph"></param>
179 public void BFSM(ref MatrixGraph graph, int vertex)
180 {
181 //这里就用系统的队列
182 Queue<int> queue = new Queue<int>();
183
184 //先把顶点入队
185 queue.Enqueue(vertex);
186
187 //标记此顶点已经被访问
188 graph.isTrav[vertex] = true;
189
190 //输出顶点
191 Console.Write(" ->" + graph.vertex[vertex]);
192
193 //广度遍历顶点的邻接点
194 while (queue.Count != 0)
195 {
196 var temp = queue.Dequeue();
197
198 //遍历矩阵的横坐标
199 for (int i = 0; i < graph.vertexNum; i++)
200 {
201 if (!graph.isTrav[i] && graph.edges[temp, i] != 0)
202 {
203 graph.isTrav[i] = true;
204
205 queue.Enqueue(i);
206
207 //输出未被访问的顶点
208 Console.Write(" ->" + graph.vertex[i]);
209 }
210 }
211 }
212 }
213 #endregion
214
215 #region 深度优先
216 /// <summary>
217 /// 深度优先
218 /// </summary>
219 /// <param name="graph"></param>
220 public void DFSTraverse(MatrixGraph graph)
221 {
222 //访问标记默认初始化
223 for (int i = 0; i < graph.vertexNum; i++)
224 {
225 graph.isTrav[i] = false;
226 }
227
228 //遍历每个顶点
229 for (int i = 0; i < graph.vertexNum; i++)
230 {
231 //广度遍历未访问过的顶点
232 if (!graph.isTrav[i])
233 {
234 DFSM(ref graph, i);
235 }
236 }
237 }
238
239 #region 深度递归的具体算法
240 /// <summary>
241 /// 深度递归的具体算法
242 /// </summary>
243 /// <param name="graph"></param>
244 /// <param name="vertex"></param>
245 public void DFSM(ref MatrixGraph graph, int vertex)
246 {
247 Console.Write("->" + graph.vertex[vertex]);
248
249 //标记为已访问
250 graph.isTrav[vertex] = true;
251
252 //要遍历的六个点
253 for (int i = 0; i < graph.vertexNum; i++)
254 {
255 if (graph.isTrav[i] == false && graph.edges[vertex, i] != 0)
256 {
257 //深度递归
258 DFSM(ref graph, i);
259 }
260 }
261 }
262 #endregion
263 #endregion
264
265 }
266 }

 

代码中我们构建了如下的“图”。


原文:http://www.cnblogs.com/huangxincheng/p/2300731.html
分类: 算法

发表评论 没有账号,注册评论