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

  1. 云栖社区>
  2. 博客>
  3. 正文

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

laozhu1124 2016-04-15 13:04:03 浏览1074
展开阅读全文

  好久, 没写blog了,今天,多写点。 

    上节说到那里了,是不是说图的遍历,这节,我们来通过图的具体的应用了。

    首先,看看最小生成树的应用了。 什么是最小生成树了?

   由生成树的定义可知,无向连通图的生成树不是唯一的,对连通图的不同遍历就得到不同的生成树。图 b 所示是图 (a)所示的无向连通图的部分生成树。

   

 所谓最小生成树是 如果是一个无向连通网, 那么它的所有生成树中必有一棵边的权值总和最小的生成树,我们称这棵生成树为最小代价生成树(Minimum Cost Spanning Tree).

许多应用问题都是一个求无向连通网的最小生成树问题。例如,要在 n个城市之间铺设光缆, 铺设光缆的费用很高, 并且各个城市之间铺设光缆的费用不同。一个目标是要使这 n个城市的任意两个之间都可以直接或间接通信, 另一个目标是要使铺设光缆的总费用最低。如果把 n个城市看作是图的 n个顶点,两个城市之间铺设的光缆看作是两个顶点之间的边, 这实际上就是求一个无向连通网的最小生成树问题。

由最小生成树的定义可知, 构造有 n个顶点的无向连通网的最小生成树必须满足以下三个条件: 

(1)构造的最小生成树必须包括 n个顶点;
(2)构造的最小生成树有且仅有 n-1条边;
(3)构造的最小生成树中不存在回路。
构造最小生成树的方法有许多种,典型的方法有两种,一种是普里姆(Prim)算法,一种是克鲁斯卡尔(Kruskal)算法。

 

一普里姆(Prim)算法

 

假设 G=(V,E)为一无向连通网,其中,V 为网中顶点的集合,E 为网中边的集合。设置两个新的集合 U 和 T,其中,U 为 G 的最小生成树的顶点的集合,T 为 G 的最小生成树的边的集合。普里姆算法的思想是:令集合 U 的初值为 U={u1}(假设构造最小生成树时从顶点 u1开始) ,集合 T 的初值为 T={}。从所有的顶点 u∈U 和顶点 v∈V-U 的带权边中选出具有最小权值的边(u,v) ,将顶点 v 加入集合 U 中,将边(u,v)加入集合 T 中。如此不断地重复直到 U=V 时,最小生成树构造完毕。此时,集合 U 中存放着最小生成树的所有顶点,集合 T中存放着最小生成树的所有边。

以下图(a)为例,说明用普里姆算法构造图的无向连通网的最小生成树的过程。

 

为了分析问题的方便,无向连通网如图(a)所示。 初始时, 算法的集合 U={A}, 集合 V-U={B,C,D,E}, 集合 T={},如图(b)所示。在所有 u 为集合 U 中顶点、v 为集合 V-U 中顶点的边(u,v)中寻找具有最小权值的边,寻找到的边是(A,D),权值为 20,把顶点 B 加入到集合U 中, 把边(A,D)加入到集合 T 中, 如图 (c)所示。 在所有 u为集合 U 中顶点、v 为集合 V-U 中顶点的边(u,v)中寻找具有最小权值的边, 寻找到的边是(D,E), 权值为 10,把顶点 E 加入到集合 U 中,把边(D,E)加入到集合 T 中,如图(d)所示。随后依次从集合 V-U 中加入到集合 U 中的顶点为 B、C,依次加入到集合T中的边为(A,B)(权值为 60) 、(E,C) (权值为 70) ,分别如图 (e)、(f)所示。最后得到的图(f)所示就是原无向连通网的最小生成树。

本书以无向网的邻接矩阵类 NetAdjMatrix<T>来实现普里姆算法。NetAdjMatrix<T>类的成员字段与无向图邻接矩阵类 GraphAdjMatrix<T>的成员字段一样,不同的是,当两个顶点间有边相连接时,matirx 数组中相应元素的值是边的权值,而不是 1

无向网邻接矩阵类 NetAdjMatrix<T>源代码的实现如下所示:


public class NetAdjMatrix<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; 
            } 
        } 
} 

 具体如图所示:

 

为实现普里姆算法, 需要设置两个辅助一维数组 lowcost和 closevex, lowcost用来保存集合 V-U 中各顶点与集合 U 中各顶点构成的边中具有最小权值的边的权值;closevex 用来保存依附于该边的在集合 U 中的顶点。假设初始状态时,U={u1}(u1为出发的顶点) ,这时有 lowcost[0]=0,它表示顶点 u1已加入集合 U中。数组 lowcost 元素的值是顶点 u1 到其他顶点所构成的直接边的权值。然后不断选取权值最小的边(ui,uk)(ui∈U,uk∈V-U),每选取一条边,就将 lowcost[k]置为 0,表示顶点 uk 已加入集合 U 中。由于顶点 uk 从集合 V-U 进入集合 U 后,这两个集合的内容发生了变化, 就需要依据具体情况更新数组lowcost和closevex中部分元素的值。把普里姆算法 PrimNetAdjMatrix<T>类的成员方法,实现的源代码如下:


public int[] Prim() 
    { 
        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)

具体实现,如图所示:

 

 

在普里姆算法中,第一个for循环的执行次数为n-1,第二个for循环中又包括了一个while循环和一个for循环,执行次数为 2(n-1)2,所以普里姆算法的时间复杂度为O(n2)。

这节,我们队图的引用做了一个抛砖引玉的介绍,主要是普利姆算法,解决 最小生成树问题。下节,我们介绍一下克鲁斯卡尔算法解决最小生成树的问题,和其他的应用。对图做一个总结等等。



网友评论

登录后评论
0/500
评论
laozhu1124
+ 关注