这节，我们主要讨论，一下克鲁斯卡尔算法实现 最小生成树。
克鲁斯卡尔算法的基本思想是：对一个有 n个顶点的无向连通网，将图中的边按权值大小依次选取，若选取的边使生成树不形成回路，则把它加入到树中；若形成回路，则将它舍 弃。如此进行下去，直到树中包含有 n-1条边为止。
以下图 (a)为例说明用克鲁斯卡尔算法求无向连通网最小生成树的过程。
第一步：首先比较网中所有边的权值，找到最小的权值的边(D,E)，加入到生成树的边集 TE 中，TE={(D,E)}。
第二步：再比较图中除边(D,E)的边的权值，又找到最小权值的边(A,D)并且不会形成回路，加入到生成树的边集 TE 中，TE={(A,D),(D,E)}。
第三步： 再比较图中除 TE 以外的所有边的权值， 找到最小的权值的边(A,B) 并且不会形成回路，加入到生成树的边集 TE 中，TE={(A,D),(D,E),(A,B)}。
第四步：再比较图中除 TE 以外的所有边的权值，找到最小的权值的边(E,C) 并且不会形成回路，加入到生成树的边集 TE 中，TE={(A,D),(D,E),(A,B),(E,C)}。 此时，边集 TE 中已经有 n-1条边，如下图（b） 所示。这个结果与用普里姆算法得到的结果相同。
实现源代码如下：
public int[] Klausi()
{
int[] lowcost = new int[nodes.Length]; //权值数组 保存权值的数组
int[] closevex = new int[nodes.Length]; //顶点数组 保存 相应各个顶点的数组
int mincost = int.MaxValue; //最小权值 默认是 int的最大值 表示无穷大
//辅助数组初始化 对摸个 权值数组赋值 保存 最小值
for (int i = 1; i < nodes.Length; ++i)
{
lowcost[i] = matrix[0, i];
closevex[i] = 0;
}
//某个顶点加入集合U
lowcost[0] = 0;
closevex[0] = 0;
//判断最小的权值通过的顶点的循环就此开始
for(int i=0; i<nodes.Length; ++i)
{
int k = 1;
int j = 1;
//选取权值最小的边和相应的顶点
while(j < nodes.Length)
{
if (lowcost[j] < mincost && lowcost[j] != 0)
{
k = j;
}
++j;
}
//新顶点加入集合U
lowcost[k] = 0;
//重新计算该顶点到其余顶点的边的权值
for (j = 1; j < nodes.Length; ++j)
{
if (matrix[k, j] < lowcost[j])
{
lowcost[j] = matrix[k, j];
closevex[j] = k;
}
}
}
return closevex;
}
//我们明显的看出来，由于用到了双重循环，其算法的时间的复杂度是O(n^2)介绍了最短路径的概念
最短路径问题是图的又一个比较典型的应用问题。例如，n个城市之间的一个公路网，给定这些城市之间的公路的距离，能否找到城市 A 到城市 B 之间一条距离最近的通路呢？如果城市用顶点表示，城市间的公路用边表示，公路的长度作为边的权值。那么，这个问题就可归结为在网中求顶点 A 到顶点 B 的所有路径中边的权值之和最小的那一条路径， 这条路径就是两个顶点之间的最短路径(Shortest Path)，并称路径上的第一个顶点为源点（Source） ，最后一个顶点为终点（Destination） 。在不带权的图中，最短路径是指两个顶点之间经历的边数最少的路径。 最短路径可以是求某个源点出发到其它顶点的最短路径， 也可以是求网中任意两个顶点之间的最短路径。这里只讨论单源点的最短路径问题，感兴趣的读者可参考有关文献，了解每一对顶点之间的最短路径。 网分为无向网和有向网，当把无向网中的每一条边(vi,vj)都定义为弧<vi,vj>和弧<vj,vi>，则有向网就变成了无向网。因此，不失一般性，我们这里只讨论有向网上的最短路径问题。 下图是一个有向网及其邻接矩阵。该网从顶点 A 到顶点 D 有 4条路径，分别是：路径（A,D） ，其带权路径长度为 30；路径（A,C,F,D） ，其带权路径长度为 22；路径（A,C,B,E,D） ，其带权路径长度为 32；路径（A,C,F,E,D） ，其带权路径长度为 34。路径（A,C,F,D）称为最短路径，其带权路径长度 22称为最短距离。
他用的是狄克斯特拉（Dikastra）算法
对于求单源点的最短路径问题，狄克斯特拉（Dikastra）提出了一个按路径长度递增的顺序逐步产生最短路径的构造算法。狄克斯特拉的算法思想是：设置两个顶点的集合 S 和T， 集合 S 中存放已找到最短路径的顶点， 集合 T 中存放当前还未找到最短路径的顶点。初始状态时，集合 S 中只包含源点，设为 v0，然后从集合 T 中选择到源点 v0路径长度最短的顶点 u加入到集合 S 中，集合 S 中每加入一个新的顶点 u都要修改源点 v0到集合 T 中剩余顶点的当前最短路径长度值，集合 T 中各顶点的新的最短路径长度值为原来的当前最短路径长度值与从源点过顶点 u到达该顶点的新的最短路径长度中的较小者。此过程不断重复，直到集合 T 中的顶点全部加到集合 S 中为止。
以下图为例说明用狄克斯特拉算法求有向网的从某个顶点到其余顶点最短路径的过程。
第一步：列出顶点 A 到其余各顶点的路径长度，它们分别为 0、∞、5、30、∞、∞。从中选取路径长度最小的顶点 C（从源点到顶点 C 的最短路径为 5） 。
第二步：找到顶点 C 后，再观察从源点经顶点 C 到各个顶点的路径是否比第一步所找到的路径要小（已选取的顶点则不必考虑） ，可发现，源点到顶点 B的路径长度更新为 20（A，C，B） ，源点到顶点 F 的路径长度更新为 12（A，C，F） ， 其余的路径则不变。 然后， 从已更新的路径中找出路径长度最小的顶点 F （从源点到顶点 F 的最短路径为 12） 。
第三步：找到顶点 C、F 以后，再观察从源点经顶点 C、F 到各顶点的路径是否比第二步所找到的路径要小（已被选取的顶点不必考虑） ，可发现，源点到顶点 D 的路径长度更新为 22（A，C，F，D） ，源点到顶点 E 的路径长度更新为30（A，C，F，E） ，其余的路径不变。然后，从已更新的路径中找出路径长短最小的顶点 D（从源点到顶点 D 的最短路径为 22） 。
第四步：找到顶点 C、F、D 后，现在只剩下最后一个顶点 E 没有找到最短路径了，再观察从源点经顶点 C、F、D 到顶点 E 的路径是否比第三步所找到的路径要小（已选取的顶点则不必考虑） ，可以发现，源点到顶点 E 的路径长度更新为 28（A，B，E） ，其余的路径则不变。然后，从已更新的路径中找出路径长度最小的顶点 E（从源点到顶点 E 的最短路径为 28）。
、有向网的邻接矩阵类的实现
本书以有向网的邻接矩阵类 DirecNetAdjMatrix<T>来实现狄克斯特拉算法。DirecNetAdjMatrix<T>有三个成员字段， 一个是 Node<T>类型的一维数组 nodes，存放有向网中的顶点信息，一个是整型的二维数组 matirx，表示有向网的邻接矩阵，存放弧的信息，一个是整数 numArcs，表示有向网中弧的数目，有向网的邻接矩阵类 DirecNetAdjMatrix<T>源代码的实现如下所示。
public class DirecNetAdjMatrix<T> : IGraph<T>//继承图形的接口
{
private Node<T>[] nodes; //顶点数组 存取相应的结点的 泛型数组
private int numEdges; //边的数目 上图边数字是6
private int[,] matrix; //邻接矩阵数组 存取相应的互相的权值
//构造器 进行数据的初始化 边的数目是0
public NetAdjMatrix (int n)
{
nodes = new Node<T>[n];
matrix = new int[n,n];
numEdges = 0;
}
//获取索引为index的顶点的信息 算法的时间复杂度是O(1)
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, int v)
{
matrix[index1, index2] = v;
}
//获取顶点的数目 算法的时间的复杂度是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)
{
//如果顶点nd与v相等，则v是图的顶点，返回索引值
if (nodes[i].Equals(v))
{
return i;
}
}
return i;
}
//在顶点v1、v2之间添加权值为v的边
//添加相应的权值的v的边， 这是一个对称矩阵。
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;
}
//矩阵是对称矩阵
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)] != int.MaxValue)
{
//矩阵是对称矩阵
matrix[GetIndex(v1), GetIndex(v2)] = int.MaxValue;
matrix[GetIndex(v2), GetIndex(v1)] = int.MaxValue;
--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)] != int.MaxValue)
{
return true;
}
Else //v1和v2之间不存在边
{
return false;
}
}
} 为实现狄克斯特拉算法，引入两个数组，一个一维数组 ShortPathArr，用来保存从源点到各个顶点的最短路径的长度，一个二维数组 PathMatrixArr，用来保存从源点到某个顶点的最短路径上的顶点，如 PathMatrix[v][w]为 true，则 w从源点到顶点 v 的最短路径上的顶点。为了该算法的结果被其他算法使用，把这两个数组作为算法的参数使用。另外，为了表示某顶点的最短路径是否已经找到，在算法中设了一个一维数组 final,如果 final[i]为 true,则表示已经找到第 i 个顶点的最短路径。i 是该顶点在邻接矩阵中的序号。同样，把该算法作为类DirecNetAdjMatrix<T>的成员方法来实现。
//pathMatricArr用来保存从源点到某个顶点的最短路径上的顶点
//ShortPathArr用来保存从源点到各个顶点的最短路径的长度
//n 结点的泛型数组
1 public void Dijkstra(ref bool[,] pathMatricArr,
2 ref int[] shortPathArr, Node<T> n)
3 {
4 int k = 0;
//结点是否访问
5 bool[] final = new bool[nodes.Length];
6
7 //初始化
8 for (int i = 0; i < nodes.Length; ++i)
9 {
10 final[i] = false;
11 shortPathArr[i] = matrix[GetIndex(n),i];
12
13 for (int j = 0; j < nodes.Length; ++j)
14 {
15 pathMatricArr[i,j] = false;
16 }
17 if (shortPathArr[i] != 0 && shortPathArr[i] < int.MaxValue)
18 {
19 pathMatricArr[i,GetIndex(n)] = true;
20 pathMatricArr[i,i] = true;
21 }
22 }
23
24 // n为源点
25 shortPathArr[GetIndex(n)] = 0;
26 final[GetIndex(n)] = true;
27
28 //处理从源点到其余顶点的最短路径
29 for (int i = 0; i < nodes.Length; ++i)
30 {
31 int min = int.MaxValue;
32
33 //比较从源点到其余顶点的路径长度
34 for (int j = 0; j < nodes.Length; ++j)
35 {
36 //从源点到j顶点的最短路径还没有找到
37 if (!final[j])
38 {
39 /从源点到j顶点的路径长度最小
40 if (shortPathArr[j] < min)
41 {
42 k = j;
43 min = shortPathArr[j];
44 }
45 }
46 }
47
48 //源点到顶点k的路径长度最小
49 final[k] = true;
50
51 //更新当前最短路径及距离
52 for (int j = 0; j < nodes.Length; ++j)
53 {
54 if (!final[j] && (min + matrix[k,j] < shortPathArr[j]))
55 {
56 shortPathArr[j] = min + matrix[k,j];
57 for (int w = 0; w < nodes.Length; ++w)
58 {
59 pathMatricArr[j,w] = pathMatricArr[k,w];
60 }
61 pathMatricArr[j,j] = true;
62 }
63 }
64 }
65 }
//由于是，双层循环 时间复杂度是O(n2)
如图所示：
当然，图的应用还有很多了，点到为止。
至于图的总结是：
所谓的图是图状结构简称图，是另一种非线性结构，它比树形结构更复杂。树形结构中的结点是一对多的关系，结点间具有明显的层次和分支关系。每一层的结点可以和下一层的多个结点相关，但只能和上一层的一个结点相关。而图中的顶点（把图中的数据元素称为顶点）是多对多的关系，即顶点间的关系是任意的，图中任意两个顶点之间都可能相关。也就是说，图的顶点之间无明显的层次关系，这种关系在现实世界中大量存在。因此，图的应用相当广泛，在自然科学、社会科学和人文科学等许多领域都有着非常广泛的应用。例如搜索引擎，地图等等。
扫一扫
256
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
