C#数据结构与算法揭秘11

这节，我们说一说，图的基本源代码的源代码实现。具体情况，请听我一一给大家娓娓道来。

图的基本操作用一个接口来表示，为表示图的基本操作，同时给出了顶点类的实现。由于顶点只保存自身信息，所以顶点类 Node<T>很简单，里面只有一个字段 data。

顶点的类 Node<T>的实现如下所示。
public Class Node<T>
{
private T data; //数据域

//构造器
public Node(T v)
{
data = v;
}

//数据域属性
public T Data
{
get
{
return data;
}
set
{
data = value;

}
}

结构如图所示：



}

图的接口IGraph<T>的定义如下所示。
public interface IGraph<T>
{
//获取顶点数
int GetNumOfVertex();

初始条件：图存在；
操作结果：返回图中的顶点数 由于用到循环的计数的方式。所以其算法的时间的复杂度是O(n2) 如图所示：



//获取边或弧的数目
int GetNumOfEdge();

初始条件：图存在；
操作结果：返回图中的边或弧的数目.由于用到循环的计数的方式。所以其算法的时间的复杂度是O(n2) 如图所示：



//在两个顶点之间添加权为v的边或弧
void SetEdge(Node<T> v1, Node<T> v2, int v);

初始条件：图存在，顶点 v1 和 v2 是图的两个顶点；
操作结果：在顶点 v1 和 v2 之间添加一条边或弧并设边或弧的值为 v。由于用到循环的发送方式，时间复杂度是O(n2) 如图所示：



//删除两个顶点之间的边或弧
void DelEdge(Node<T> v1, Node<T> v2);

初始条件：图存在，顶点 v1 和 v2 是图的两个顶点并且 v1 和 v2 之间有一条边或弧；
操作结果：删除顶点 v1 和 v2 之间的边或弧。 如图所示：



//判断两个顶点之间是否有边或弧
bool IsEdge(Node<T> v1, Node<T> v2);

初始条件：图存在，顶点 v1 和 v2 是图的两个顶点；
操作结果：如果 v1 和 v2 之间有一条边或弧，返回 true,否则返回 false。 由于用到了循环，算法的时间的复杂度是O(n2)，如图所示：



}

讨论了这些图的结源代码基本实现，我们进入了下一个议题，讨论了图的存储结构。

图是一种复杂的数据结构，顶点之间是多对多的关系，即任意两个顶点之间都可能存在联系。 所以， 无法以顶点在存储区的位置关系来表示顶点之间的联系，即顺序存储结构不能完全存储图的信息，但可以用数组来存储图的顶点信息。要存储顶点之间的联系必须用链式存储结构或者二维数组。图的存储结构有多种，这里只介绍两种基本的存储结构：邻接矩阵和邻接表。

什么是邻接矩阵，所谓邻接矩阵（Adjacency Matrix）是用两个数组来表示图，一个数组是一维数组，存储图中顶点的信息，一个数组是二维数组，即矩阵，存储顶点之间相邻的信息，也就是边（或弧）的信息，这是邻接矩阵名称的由来。

假设图G=（V，E）中有n个顶点，即V={v0,v1,…,vn-1}，用矩阵A[i][j]表示边
（或弧）的信息。矩阵A[i][j]是一个n×n的矩阵，矩阵的元素为：
A[i][j]=1若（v[i],v[j]）是E(G)的边和元素

A[i][j]=0若（v[i],v[j]）不是E(G)的边和元素

若 G 是网，则邻接矩阵可定义为：

A[i][j]=wij若（v[i],v[j]）是E(G)的边和元素

A[i][j]=∞若（v[i],v[j]）不是E(G)的边和元素

其中，wij 表示边(vi,vj)或弧<vi,vj>上的权值；∞表示一个计算机允许的大于
所有边上权值的数。





从图的邻接矩阵表示法可以看出这种表示法的特点是：
（1）无向图或无向网的邻接矩阵一定是一个对称矩阵。因此，在具体存放邻接矩阵时只需存放上（或下）三角矩阵的元素即可。
（2）可以很方便地查找图中任一顶点的度。对于无向图或无向网而言，顶点 vi 的度就是邻接矩阵中第 i 行或第 i 列中非 0 或非∞的元素的个数。对于有向图或有向网而言，顶点 vi 的入度是邻接矩阵中第 i 列中非 0 或非∞的元素的个数，顶点 vi 的出度是邻接矩阵中第 i 行中非 0 或非∞的元素的个数。
（3）可以很方便地查找图中任一条边或弧的权值，只要 A[i][j]为 0 或∞，就说明顶点 vi 和 vj 之间不存在边或弧。但是，要确定图中有多少条边或弧，则必须按行、按列对每个元素进行检测，所花费的时间代价是很大的。这是用邻接矩阵存储图的局限性。
下面以无向图的邻接矩阵类的实现来说明图的邻接矩阵表示的类的实现。
无向图邻接矩阵类 GraphAdjMatrix<T>中有三个成员字段， 一个是 Node<T>类型的一维数组 nodes，存

无向图邻接矩阵类 GraphAdjMatrix<T>的实现如下所示。
public class GraphAdjMatrix<T> : IGraph<T>
{
private Node<T>[] nodes; //顶点数组
private int numEdges; //边的数目
private int[ ,] matrix; //邻接矩阵数组
如图所示：

//构造器
public GraphAdjMatrix (int n)
{

nodes = new Node<T>
;
matrix = new int[n,n];
numEdges = 0;
}

//获取索引为index的顶点的信息
public Node<T> GetNode(int index)
{
return nodes[index];
}

//设置索引为index的顶点的信息 算法的复杂度的是O(1)
public void SetNode(int index, Node<T> v)
{
nodes[index] = v;
}

//边的数目属性
public int NumEdges
{
get
{
return numEdges;
}
set
{
numEdges = value;
}
}

//获取matrix[index1, index2]的值 算法的复杂度是O(1)
public int GetMatrix(int index1, int index2)
{
return matrix[index1, index2];
}

//设置matrix[index1, index2]的值 算法的复杂度是O(1)
public void SetMatrix(int index1, int index2)
{
matrix[index1, index2] = 1;
}

//获取顶点的数目 算法的复杂度是O(1)
public int GetNumOfVertex()

{
return nodes.Length;
}

//获取边的数目 算法的复杂度是O(1)
public int GetNumOfEdge()
{
return numEdges;
}

//判断v是否是图的顶点 算法的复杂度是O(n)
public bool IsNode(Node<T> v)
{
//遍历顶点数组
foreach (Node<T> nd in nodes)
{
//如果顶点nd与v相等，则v是图的顶点，返回true
if (v.Equals(nd))
{
return true;
}
}

return false;
}

//获取顶点v在顶点数组中的索引 算法的复杂度是O(n)
public int GetIndex(Node<T> v)
{
int i = -1;

//遍历顶点数组
for (i = 0; i < nodes.Length; ++i)
{
//如果顶点v与nodes[i]相等，则v是图的顶点，返回索引值i。
if (nodes[i].Equals(v))
{
return i;
}
}
return i;
}

//在顶点v1和v2之间添加权值为v的边 算法是O(n2)

public void SetEdge(Node<T> v1, Node<T> v2，int v)
{
//v1或v2不是图的顶点
if (!IsNode(v1) || !IsNode(v2))
{
Console.WriteLine("Node is not belong to Graph!");
return;
}

//不是无向图
if(v != 1)
{
Console.WriteLine("Weight is not right!");
return;
}

//矩阵是对称矩阵
matrix[GetIndex(v1), GetIndex(v2)] = v;
matrix[GetIndex(v2), GetIndex(v1)] = v;
++numEdges;
}

//删除顶点v1和v2之间的边
public void DelEdge(Node<T> v1, Node<T> v2)
{
//v1或v2不是图的顶点
if (!IsNode(v1) || !IsNode(v2))
{
Console.WriteLine("Node is not belong to Graph!");
return;
}

//顶点v1与v2之间存在边
if (matrix[GetIndex(v1), GetIndex(v2)] == 1)
{
//矩阵是对称矩阵
matrix[GetIndex(v1), GetIndex(v2)] = 0;
matrix[GetIndex(v2), GetIndex(v1)] = 0;
--numEdges;
}
}

//判断顶点v1与v2之间是否存在边 算法的复杂度是O(1)
public bool IsEdge(Node<T> v1, Node<T> v2)

{
//v1或v2不是图的顶点
if (!IsNode(v1) || !IsNode(v2))
{
Console.WriteLine("Node is not belong to Graph!");
return false;
}

//顶点v1与v2之间存在边
if (matrix[GetIndex(v1), GetIndex(v2)] == 1)
{
return true;
}
else //不存在边
{
return false;
}
}

如图所示：



}

二。连接存储：

邻接表 （Adjacency List） 是图的一种顺序存储与链式存储相结合的存储结构，类似于树的孩子链表表示法。 顺序存储指的是图中的顶点信息用一个顶点数组来存储，一个顶点数组元素是一个顶点结点，顶点结点有两个域，一个是数据域data，存放与顶点相关的信息，一个是引用域 firstAdj，存放该顶点的邻接表的第一个结点的地址。顶点的邻接表是把所有邻接于某顶点的顶点构成的一个表，它是采用链式存储结构。所以，我们说邻接表是图的一种顺序存储与链式存储相结合的存储结构。其中，邻接表中的每个结点实际上保存的是与该顶点相关的边或弧的信息，它有两个域，一个是邻接顶点域 adjvex，存放邻接顶点的信息，实际上就是邻接顶点在顶点数组中的序号；一个是引用域 next，存放下一个邻接顶点的结点的地址。顶点结点和邻接表结点的结构如下图所示。