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

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

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

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

一： 概念

       图是由“顶点”的集合和“边”的集合组成。记作：G=（V,E)；

无向图

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

有向图

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

邻接点

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

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

顶点的度

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

完全图

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

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

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

子图

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

路径，路径长度和回路（这些概念还是比较重要的）

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

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

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

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

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

连通图和连通分量（针对无向图而言的）

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

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

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

强连通图和强连通分量（针对有向图而言）

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

网

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

二：存储

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

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

                    缺点就是比较耗费空间。

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

三： 创建图

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

 1 #region 邻接矩阵的结构图
 2     /// 

 3 /// 邻接矩阵的结构图
 4 /// 
 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         /// 

26 /// 存储容量的初始化
27 /// 
28 /// 
29 /// 
30 /// 
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  #region 图的创建
 2         /// 

 3 /// 图的创建
 4 /// 
 5 /// 
 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  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

广度优先

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

次访问，可以将”顶点的下标”存放在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         /// 

 3 /// 广度优先
 4 /// 
 5 /// 
 6         public void BFSTraverse(MatrixGraph graph)
 7         {
 8             //访问标记默认初始化
 9             for (int i = 0; i 
26 /// 广度遍历具体算法
27 /// 
28 /// 
29         public void BFSM(ref MatrixGraph graph, int vertex)
30         {
31             //这里就用系统的队列
32             Queue queue = new Queue();
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.vertex[i]);
59                     }
60                 }
61             }
62         }
63         #endregion

深度优先

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

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

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

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

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

 1 #region 深度优先
 2         /// 

 3 /// 深度优先
 4 /// 
 5 /// 
 6         public void DFSTraverse(MatrixGraph graph)
 7         {
 8             //访问标记默认初始化
 9             for (int i = 0; i 
27 /// 深度递归的具体算法
28 /// 
29 /// 
30 /// 
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 
 
最后上一下总的代码
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     /// 

 34 /// 邻接矩阵的结构图
 35 /// 
 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         /// 

 57 /// 存储容量的初始化
 58 /// 
 59 /// 
 60 /// 
 61 /// 
 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     /// 

 77 /// 图的操作类
 78 /// 
 79     public class MatrixGraphManager
 80     {
 81         #region 图的创建
 82         /// 

 83 /// 图的创建
 84 /// 
 85 /// 
 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  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         /// 

134 /// 输出矩阵数据
135 /// 
136 /// 
137         public void OutMatrix(MatrixGraph graph)
138         {
139             for (int i = 0; i 
153 /// 广度优先
154 /// 
155 /// 
156         public void BFSTraverse(MatrixGraph graph)
157         {
158             //访问标记默认初始化
159             for (int i = 0; i 
176 /// 广度遍历具体算法
177 /// 
178 /// 
179         public void BFSM(ref MatrixGraph graph, int vertex)
180         {
181             //这里就用系统的队列
182             Queue queue = new Queue();
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.vertex[i]);
209                     }
210                 }
211             }
212         }
213         #endregion
214 
215         #region 深度优先
216         /// 

217 /// 深度优先
218 /// 
219 /// 
220         public void DFSTraverse(MatrixGraph graph)
221         {
222             //访问标记默认初始化
223             for (int i = 0; i 
241 /// 深度递归的具体算法
242 /// 
243 /// 
244 /// 
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 
 
代码中我们构建了如下的“图”。