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

这节，我们来重点讨论一下 这个树形结构的相应的源代码的实现了。

真的我们首先介绍一下无向图邻接表类的实现来说明图的邻接表类的实现。 

无向图邻接表的邻接表结点类 adjListNode<T>有两个成员字段，一个是1adjvex，存储邻接顶点的信息，类型是整型；一个是 next，存储下一个邻接表结点的地址，类型是 adjListNode<T>。adjListNode<T>的实现如下所示。

public class adjListNode<T>
{
private int adjvex; //邻接顶点，连接定点
private adjListNode<T> next; //下一个邻接表结点  指向邻接表结点 

//邻接顶点属性
public int Adjvex
{
get
{

return adjvex;
}
set
{
adjvex = value;
}
}

//下一个邻接表结点属性
public adjListNode<T> Next
{
get
{
return next;
}
set
{
next = value;
}
}

//构造器    指向 邻接顶点

//下一个结点为空。
public adjListNode(int vex)
{
adjvex = vex;
next = null;
}

具体情况，如图所示：

}

 而具体的图连接表应该是这样的。

无向图邻接表的顶点结点类 VexNode<T>有两个成员字段，一个 data，它存储图的顶点本身的信息，类型是 Node<T>；一个是 firstAdj，存储顶点的邻接表的第1个结点的地址，类型是 adjListNode<T>。VexNode<T>的实现如下所示。

public class VexNode<T>
{
private Node<T> data; //图的顶点   存储的图的顶点
private adjListNode<T> firstAdj; //邻接表的第1个结点

//图的顶点属性
public Node<T> Data
{
get
{
return data;
}
set

{
data = value;
}
}

//邻接表的第1个结点属性
public adjListNode<T> FirstAdj
{
get
{
return firstAdj;
}
set
{
firstAdj = value;
}
}

//构造器
public VexNode()
{
data = null;
firstAdj = null;
}

//构造器
public VexNode(Node<T> nd)
{
data = nd;
firstAdj = null;
}

//构造器
public VexNode(Node<T> nd, adjListNode<T> alNode)
{
data = nd;
firstAdj = alNode;
}

这个具体的情况，如图所示：

}

无向图邻接表类 GraphAdjList<T>有一个成员字段 adjList， 表示邻接表数组，数组元素的类型是 VexNode<T>。 GraphAdjList<T>实现了接口 IGraph<T>中的方法。与无向图邻接矩阵类 GraphAdjMatrix<T>一样，GraphAdjList<T>实现了两个成员方法 IsNode 和 GetIndex。功能与 GraphAdjMatrix<T>一样。无向图表GraphAdjList<T>的源代码实现如下所示。

public class GraphAdjList<T> : IGraph<T>
{
//邻接表数组
private VexNode<T>[] adjList;

//索引器
public VexNode<T> this[int index]
{
get
{
return adjList[index];
}
set
{
adjList[index] = value;
}
}

//构造器 构建成一个相应的图表
public GraphAdjList(Node<T>[] nodes)
{
adjList = new VexNode<T>[nodes.Length];
for (int i = 0; i < nodes.Length; ++i )
{
adjList[i].Data = nodes[i];
adjList[i].FirstAdj = null;
}
}

//获取顶点的数目
public int GetNumOfVertex()
{
return adjList.Length;
} 

算法思路：求无向图的顶点数比较简单，直接返回 adjList 数组的长度就可以了。算法的复杂度是O(1)
//获取边的数目

public int GetNumOfEdge()
{
int i = 0;

//遍历邻接表数组
foreach (VexNode<T> nd in adjList)
{
adjListNode<T> p = nd.FirstAdj;

while (p != null)
{
++i;
p = p.Next
}
}

return i / 2;
}

算法思路：求无向图的边数比求顶点数要复杂一些，需要求出所有顶点的邻接表的结点的个数，然后除以2。算法的时间的复杂度是O(n2)

//判断v是否是图的顶点
public bool IsNode(Node<T> v)
{
//遍历邻接表数组
foreach (VexNode<T> nd in adjList)
{
//如果v等于nd的data，则v是图中的顶点，返回true
if (v.Equals(nd.Data))
{
return true;
}
}

return false;
}

算法思路：首先判断顶点 v1 和 v2 是否是图的顶点。如果 v1 和 v2 不是图的顶点，不作处理。否则，在顶点 v1（或 v2）的邻接表中查找是否存在 adjVex的值等于 v2（或 v1）在 adjList 中的序号的结点，如果存在，则返回 true，否则返回 false。

//获取顶点v在邻接表数组中的索引
public int GetIndex(Node<T> v)
{
int i = -1;

//遍历邻接表数组
for (i = 0; i < adjList.Length; ++i)
{
//邻接表数组第i项的data值等于v，则顶点v的索引为i
if (adjList[i].Data.Equals(v))
{
return i;
}
}
return i;
}

//在顶点v1和v2之间添加权值为v的边
public void SetEdge(Node<T> v1, Node<T> v2,int v)
{
//v1或v2不是图的顶点或者v1和v2之间存在边
if (!IsNode(v1) || !IsNode(v2) || IsEdge(v1,v2))
{
Console.WriteLine("Node is not belong to Graph!");
return;
}

//权值不对
if(v != 1)
{
Console.WriteLine("Weight is not right!");
return;
}

//处理顶点v1的邻接表
adjListNode<T> p = new adjListNode<T>(GetIndex(v2));

//顶点v1没有邻接顶点
if (adjList[GetIndex(v1)].FirstAdj == null)
{
adjList[GetIndex(v1)].FirstAdj = p;
}
//顶点v1有邻接顶点
else
{
p.Next = adjList[GetIndex(v1)].FirstAdj;
adjList[GetIndex(v1)].FirstAdj = p;
}

//处理顶点v2的邻接表
p = new adjListNode<T>(GetIndex(v1));

//顶点v2没有邻接顶点
if (adjList[GetIndex(v2)].FirstAdj == null)
{
adjList[GetIndex(v2)].FirstAdj = p;
}
//顶点v1有邻接顶点
else
{
p.Next = adjList[GetIndex(v2)].FirstAdj;

adjList[GetIndex(v2)].FirstAdj = p;
}
}

算法思路： 首先判断顶点 v1 和 v2 是否是图的顶点和 v1 和 v2 是否存在边。如果 v1 和 v2 不是图的顶点和 v1 和 v2 存在边，不作处理。然后，判断 v 的值是否为1， 为1不作处理。 否则， 先分配一个邻接表结点， 其adjvex域是v2在adjList数组中的索引号，然后把该结点插入到顶点 v1 的邻接表的表头；然后再分配一个邻接表结点，其 adjvex 域是 v1 在 adjList 数组中的索引号，然后把该结点插入到顶点 v2 的邻接表的表头。
本算法是把邻接表结点插入到顶点邻接表的表头，当然，也可以插入到邻接表的表尾，或者按照某种要求插入，只是对插入这个操作而言，在表的头部插入是最简单的，而本书在后面关于图的处理，如图的深度优先遍历和广度优先遍历等，对图的顶点没有特殊要求，所以采用了在邻接表的头部插入结点。如果对图的顶点有特殊要求，则需要按照一定的要求进行插入，需要修改这里的代码。由于存在循环遍历，所以的算法的时间的复杂度是O(n2)

//删除顶点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 (IsEdge(v1,v2))
{
//处理顶点v1的邻接表中的顶点v2的邻接表结点
adjListNode<T> p = adjList[GetIndex(v1)].FirstAdj;
adjListNode<T> pre = null;

while (p != null)
{
if (p.Adjvex != GetIndex(v2))
{
pre = p;
p = p.Next;
}
}

pre.Next = p.Next;

//处理顶点v2的邻接表中的顶点v1的邻接表结点
p = adjList[GetIndex(v2)].FirstAdj;
pre = null;

while (p != null)
{
if (p.Adjvex != GetIndex(v1))
{
pre = p;
p = p.Next;
}
}

算法思路：首先判断顶点 v1 和 v2 是否是图的顶点以及 v1 和 v2 是否存在边。如果 v1 和 v2 不是图的顶点或 v1 和 v2 不存在边，不作处理。否则，先在顶点 v1 的邻接表中删除 adjVex 的值等于顶点 v2 在 adjList 数组中的序号结点，然后删除顶点 v2 的邻接表中 adjVex 的值等于顶点 v1 在 adjList 数组中的序号结点。由于用到了遍历的，时间的复杂度是O(n2)

//判断v1和v2之间是否存在边
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;
}

adjListNode<T> p = adjList[GetIndex(v1)].FirstAdj;
while (p != null)
{
if (p.Adjvex == GetIndex(v2))
{
return true;
}

p = p.Next;
}

return false;
}

具体情况，如图所示：

}

以上就是图的基本实现的论述，下届，我们继续介绍图遍历，敬请关注。。。。。。。。。。。。。。。。