数据结构-第四部分.ppt

《数据结构-第四部分.ppt》由会员分享，可在线阅读，更多相关《数据结构-第四部分.ppt（191页珍藏版）》请在三一办公上搜索。

1、1,第12章 图的基本概念,图的定义图的术语图的运算图的存储图的遍历图遍历的应用,2,图的定义,图可以用G=(V,E)表示。其中，V是顶点的集合，E是连接顶点的边（弧）的集合。如果边是有方向的，称为有向图。有向图的边用表示。表示从A出发到B的一条边。在有向图中，和是不一样的。如果边是无方向的，称为无向图。无向图的边通常用圆括号表示。（A，B）表示顶点A和B之间有一条边。无向图也称为双向图。加权图：边被赋予一个权值的图称为加权图。如果图是有向的，称为加权有向图，如果是无向的，称为加权无向图。,3,如G1：V=A，B，C，D，E=,表示的图如下所示,4,V=A，B，C，D，E，E=（A，B），（A

2、，C），（B，D），（B,E),（D，E），（C，E）,无向图,5,加权图中边的表示：或(Vi,Vj,W),加权图,6,第12章 图的基本概念,图的定义图的术语图的运算图的存储图的遍历图遍历的应用,7,图的基本术语,邻接：如（Vi，Vj）是图中的一条边，则称Vi和Vj是邻接的。如是图中的一条边，则称Vi邻接到Vj，或Vj和Vi邻接。度：无向图中邻接于某一结点的边的总数。入度：有向图中进入某一结点的边数，称为该结点的入度出度：有向图中离开某一结点的边数，称为该结点的出度,8,子图,A,A,C,D,A,C,A,B,C,D,有向图G1的子图,A,B,C,D,有向图 G1,设有两个图G=（V，E）和G

3、=（V，E），如果,则称G是G的子图,9,无向图 G2,A,B,C,D,E,A,B,D,E,A,A,B,C,D,A,B,C,D,E,无向图G2的子图,10,路径和路径长度,对1 E，那么，w1,w2,wN是图中的一条路径。非加权的路径长度就是组成路径的边数，对于路径w1,w2,wN，非加权路径长度为N-1。加权路径长度是指路径上所有边的权值之和。简单路径和环：如果一条路径上的所有结点，除了起始结点和终止结点可能相同外，其余的结点都不相同，则称其为简单路径。一个回路或环是一条简单路径，其起始结点和终止结点相同，且路径长度至少为1。,11,无向图的连通性,连通：顶点v至v 之间有路径存在连通图：无

4、向图 G 的任意两点之间都是连通的，则称 G 是连通图。连通分量：非连通图中的极大连通子图,12,无向图G,无向图G的三个连通分量,13,有向图的连通性,强连通图：有向图 G 的任意两点之间都是连通的，则称 G 是强连通图。强连通分量：极大连通子图弱连通图：如有向图G不是强连通的，但如果把它看成是无向图时是连通的，则称该图是弱连通的,14,有向图G,有向图G的两个强连通分量,不是强连通图。因为B到其他结点都没有路径。但此图是弱连通的。,15,完全图,完全图：每两个节点之间都有边的无向图称为完全图。完全图有 n(n-1)/2 条边的无向图。其中 n 是结点个数。即有向完全图：每两个节点之间都有两

5、条弧的有向图称为有向完全图。有向完全图有 n(n-1)条边。其中 n 是结点个数。即如果一个有向图中没有环，则称为有向无环图，简写为DAG,无向完全图,16,生成树,A,B,C,D,E,H,M,A,B,C,D,E,H,M,无向图G,无向图G的生成树,生成树是连通图的极小连通子图。包含图的所有 n 个结点，但只含图的 n-1 条边。在生成树中添加一条边之后，必定会形成回路或环。,17,第12章 图的基本概念,图的定义图的术语图的运算图的存储图的遍历图遍历的应用,18,图的运算,常规操作：构造一个由若干个结点、若干条边组成的图；判断两个结点之间是否有边存在；在图中添加或删除一条边；返回图中的结点数

6、或边数；按某种规则遍历图中的所有结点。和应用紧密结合的运算：拓扑排序找最小生成树找最短路径等。,19,图的抽象类,template class graph public:virtual bool insert(int u,int v,TypeOfEdge w)=0;virtual bool remove(int u,int v)=0;virtual bool exist(int u,int v)const=0;virtual numOfVer()const return Vers;virtual numOfEdge()const return Edges;protected:int Vers,

7、Edges;,20,第12章 图的基本概念,图的定义图的术语图的运算图的存储图的遍历图遍历的应用,21,图的存储,邻接矩阵和加权邻接矩阵邻接表,22,邻接矩阵有向图,设有向图具有 n 个结点，则用 n 行 n 列的布尔矩阵 A 表示该有向图如果i 至 j 有一条有向边,Ai,j=1,如果 i 至 j 没有一条有向边,Ai,j=0,表示成右图矩阵,0 1 1 00 0 0 00 0 0 11 0 0 0,注意：出度:i行之和。入度:j列之和。,23,邻接矩阵有向图,表示成右图矩阵,0 1 1 00 0 0 00 0 0 11 0 0 0,在物理实现时的考虑：分别用 0、1、2、3 分别标识结点A

8、、B、C、D。而将真正的数据字段之值放入一个一维数组之中。,0 1 2 3,0123,D,A,B,C,0 1 2 3,24,邻接矩阵无向图,设无向图具有 n 个结点，则用 n 行 n 列的布尔矩阵 A 表示该无向图；并且 Ai,j=1,如果i 至 j 有一条无向边；Ai,j=0如果 i 至 j 没有一条无向边,表示成右图矩阵,0 1 1 0 01 0 0 1 11 0 0 0 10 1 0 0 10 1 1 1 0,在物理实现时的考虑，和前一页的无向图类似。,注意：无向图的邻接矩阵是一个对称矩阵 i 结点的度:i 行或 i 列之和。,25,加权的邻接矩阵有向图,设有向图具有 n 个结点，则用

9、n 行 n 列的矩阵 A 表示该有向图；如果i 至 j 有一条有向边且它的权值为a，则Ai,j=a。如果 i 至 j 没有一条有向边。则Ai,j=空 或其它标志,表示成右图矩阵,a b b ba a,26,邻接矩阵的特点,优点：判断任意两点之间是否有边方便，仅耗费 O(1)时间。缺点：即使 n2 条边，也需内存 n2 单元，太多;仅读入数据耗费 O(n2)时间，太长。而大多数的图的边数远远小于n2。,27,邻接矩阵类的定义,template class adjMatrixGraph:public graph public:adjMatrixGraph(int vSize,const TypeO

10、fVer d,TypeOfEdge noEdgeFlag);bool insert(int u,int v,TypeOfEdge w);bool remove(int u,int v);bool exist(int u,int v)const;adjMatrixGraph()；private:TypeOfEdge*edge;/存放邻接矩阵TypeOfVer*ver;/存放结点值TypeOfEdge noEdge;/邻接矩阵中的的表示值;,28,构造函数,template adjMatrixGraph:adjMatrixGraph(int vSize,const TypeOfVer d,Type

11、OfEdge noEdgeFlag)int i,j;Vers=vSize;Edges=0;noEdge=noEdgeFlag;/存放结点的数组的初始化 ver=new TypeOfVervSize;for(i=0;ivSize;+i)veri=di;,29,/邻接矩阵的初始化 edge=new TypeOfEdge*vSize;for(i=0;ivSize;+i)edgei=new TypeOfEdgevSize;for(j=0;jvSize;+j)edgeij=noEdge;,30,析构函数,template adjMatrixGraph:adjMatrixGraph()delete ver

12、;for(int i=0;iVers;+i)delete edgeidelete edge;,31,Insert函数,template bool adjMatrixGraph:insert(int u,int v,TypeOfEdge w)if(u Vers-1|v Vers-1)return false;if(edgeuv!=noEdge)return false;edgeuv=w;+Edges;return true;,32,Remove函数,template bool adjMatrixGraph:remove(int u,int v)if(u Vers-1|v Vers-1)retur

13、n false;if(edgeuv=noEdge)return false;edgeuv=noEdge;-Edges;return true;,33,Exist函数,template bool adjMatrixGraph:exist(int u,int v)const if(u Vers-1|v Vers-1)return false;if(edgeuv=noEdge)return false;else return true;,34,图的存储,邻接矩阵和加权邻接矩阵邻接表,35,邻接表,设有向图或无向图具有 n 个结点，则用结点表、边表表示该有向图或无向图。结点表：用数组或单链表的形式存放

14、所有的结点值。如果结点数n已知，则采用数组形式，否则应采用单链表的形式。边表（边结点表）：每条边用一个结点进行表示。同一个结点出发的所有的边形成它的边结点单链表。,36,无向图 G2,有向图 G1,37,邻接表的特点,邻接表是图的标准存储方式优点：内存 结点数 边数，处理时间也是结点数 边数，即为O(|V|+|E|)。当我们谈及图的线性算法时，一般指的是O(|V|+|E|)缺点：确定 i-j 是否有边，最坏需耗费 O(n)时间。无向图同一条边表示两次。边表空间浪费一倍。有向图中寻找进入某结点的边，非常困难。,38,邻接表类的定义,template class adjListGraph:publ

15、ic graph public:adjListGraph(int vSize,const TypeOfVer d);bool insert(int u,int v,TypeOfEdge w);bool remove(int u,int v);bool exist(int u,int v)const;adjListGraph();,39,private:struct edgeNode/邻接表中存储边的结点类int end;/终点编号TypeOfEdge weight;/边的权值edgeNode*next;edgeNode(int e,TypeOfEdge w,edgeNode*n=NULL)en

16、d=e;weight=w;next=n;struct verNode/保存顶点的数据元素类型TypeOfVer ver;/顶点值edgeNode*head;/对应的单链表的头指针verNode(edgeNode*h=NULL)head=h;verNode*verList;,40,构造函数,template adjListGraph:adjListGraph(int vSize,const TypeOfVer d)Vers=vSize;Edges=0;verList=new verNodevSize;for(int i=0;i Vers;+i)verListi.ver=di;,41,析构函数,t

17、emplate adjListGraph:adjListGraph()int i;edgeNode*p;for(i=0;i next;delete p;delete verList;,42,Insert函数,template bool adjListGraph:insert(int u,int v,TypeOfEdge w)verListu.head=new edgeNode(v,w,verListu.head);+Edges;return true;,43,Remove函数,template bool adjListGraph:remove(int u,int v)edgeNode*p=ve

18、rListu.head,*q;if(p=NULL)return false;/结点u没有相连的边 if(p-end=v)/单链表中的第一个结点就是被删除的边 verListu.head=p-next;delete p;-Edges;return true;while(p-next!=NULL,44,Exist函数,template bool adjListGraph:exist(int u,int v)const edgeNode*p=verListu.head;while(p!=NULL,45,第12章 图的基本概念,图的定义图的术语图的运算图的存储图的遍历图遍历的应用,46,邻接矩阵有向图

19、,设有向图具有 n 个结点，则用 n 行 n 列的布尔矩阵 A 表示该有向图如果i 至 j 有一条有向边,Ai,j=1,如果 i 至 j 没有一条有向边,Ai,j=0,表示成右图矩阵,0 1 1 00 0 0 00 0 0 11 0 0 0,注意：出度:i行之和。入度:j列之和。,47,有向图 G1,邻接表有向图,设有向图或无向图具有 n 个结点，则用结点表、边表表示该有向图或无向图。,48,邻接表有向图,编号0,49,图的遍历,深度优先搜索广度优先搜索,对有向图和无向图进行遍历是按照某种次序系统地访问图中的所有顶点，并且使得每个顶点只能被访问一次。在图中某个顶点可能和图中的多个顶点邻接并且存

20、在回路，因此在图中访问一个顶点u之后，在以后的访问过程中，又可能再次返回到顶点u，所以图的遍历要比树的遍历更复杂,50,深度优先搜索,1、选中第一个被访问的顶点；2、对顶点作已访问过的标志；3、依次从顶点的未被访问过的第一个、第二个、第三个 邻接顶点出发，进行深度优先搜索；4、如果还有顶点未被访问，则选中一个起始顶点，转向2；5、所有的顶点都被访问到，则结束。,51,从结点5开始进行深度优先的搜索，则遍历序列可以为：5，7，6，2，4，3，1，也可以为：5，6，2，3，1，4，7。,深度优先生成树,52,深度优先生成森林,在进行深度优先搜索 DFS 时，有时并不一定能够保证从某一个结点出发能访

21、问到所有的顶点在这种情况下，必须再选中一个未访问过的顶点，继续进行深度优先搜索。直至所有的顶点都被访问到为止。这时，得到的是一组树而不是一棵树，这一组树被称为深度优先生成森林。,53,从结点1开始深度优先搜索,54,深度优先搜索的实现,深度优先搜索DFS的实现方法和树的前序遍历算法类似，但必须对访问过的顶点加以标记dfs函数不需要参数，也没有返回值。它从编号最小的结点出发开始搜索，并将对当前对象的深度优先搜索的序列显示在显示器上。,55,深度优先搜索的实现,以邻接表为例设置一个数组visited，记录节点是否被访问过设计一个私有的深度优先搜索的函数，从某一节点出发访问所有可达节点如果是无向非连

22、通图的或有向非强连通，则对图中尚未访问的节点反复调用深度优先搜索，形成深度优先搜索的森林。,56,公有的dfs函数,void dfs()对每个节点 v visited v=false;while(v=尚未访问的节点）dfs(v，visited);,57,template void adjListGraph:dfs()constbool*visited=new boolVers;for(int i=0;i Vers;+i)visitedi=false;cout 当前图的深度优先遍历序列为：endl;for(i=0;i Vers;+i)if(visitedi=true)continue;dfs(i

23、,visited);cout endl;,58,私有的dfs,void dfs(v，visited)visitedv=true;for 每个 v的邻接点w if(!Visitedw)dfs(w,visited);,访问从结点v出发可以访问到的所有结点,59,template void adjListGraph:dfs(int start,bool visited)const edgeNode*p=verListstart.head;cout end=false)dfs(p-end,visited);p=p-next;,60,对图调用dfs,结果为：当前图的深度优先搜索序列为：1 2 4 37

24、6即对应于左图的深度优先生成森林,61,时间性能分析,dfs函数将对所有的顶点和边进行访问，因此它的时间代价和顶点数|V|及边数|E|是相关的，即是O(|V|+|E|)。如果图是用邻接矩阵来表示，则所需要的时间是O（|V|2）。,62,图的遍历,深度优先搜索广度优先搜索,对有向图和无向图进行遍历是按照某种次序系统地访问图中的所有顶点，并且使得每个顶点只能被访问一次。在图中某个顶点可能和图中的多个顶点邻接并且存在回路，因此在图中访问一个顶点u之后，在以后的访问过程中，又可能再次返回到顶点u，所以图的遍历要比树的遍历更复杂,63,广度优先搜索 BFS,1、选中第一个被访问的顶点；2、对顶点作已访问

25、过的标志；3、依次访问已访问顶点的未被访问过的第一个、第二个、第三个第 m 个邻接顶点 W1、W2、W3 Wm，进行访问且进行标记，转向3；4、如果还有顶点未被访问，则选中一个起始顶点，转向2；5、所有的顶点都被访问到，则结束。,广度优先搜索类似于树的从树根出发的按照层次的遍历。它的访问方式如下：,64,按照顶点序号小的先访问，序号大的后访问的原则，则它的广度优先访问序列为：1，2，4，3，5，6，7。对应的广度优先生成森林为,65,从不同的结点开始可以得到不同的搜索序列。例如，从5开始广度优先搜索这个图，得到的遍历序列为：5，6，7，2，4，3，1。,1,2,4,3,5,6,7,66,广度优

26、先搜索的实现,需要记录每个结点是否已被访问需要记住每个已被访问的结点的后继结点，然后依次访问这些后继结点。这可以用一个队列来实现过程：将序号最小的顶点放入队列重复取队列的队头元素进行处理，直到队列为空。对出队的每个元素，首先检查该元素是否已被访问。如果没有被访问过，则访问该元素，并将它的所有的没有被访问过的后继入队检查是否还有结点未被访问。如果有，重复上述两个步骤,67,template void adjListGraph:bfs()const bool*visited=new boolVers;int currentNode;linkQueue q;edgeNode*p;for(int i=

27、0;i Vers;+i)visitedi=false;cout 当前图的广度优先遍历序列为：endl;,68,for(i=0;i end=false)q.enQueue(p-end);p=p-next;cout endl;,69,对图调用bfs,结果为：当前图的广度优先搜索序列为：1 2 4 36 7即对应于左图的深度优先生成森林,70,时间性能分析,在广度优先搜索中，每个顶点都入队一次。对于每个出队的结点，需要查看它的所有邻接结点。假如图是用邻接表存储，查看所有的邻接结点需要O（|E|）的时间，每个结点入队一次需要O（|V|）的时间，因此广度优先遍历的时间复杂度为O（|E|+|V|）。如果图

28、是用邻接矩阵存储，查看某个结点所有的边需要O（|V|）的时间，因此广度优先搜索的时间复杂度为O（|V|2）,71,第12章 图的基本概念,图的定义图的术语图的运算图的存储图的遍历图遍历的应用,72,图遍历的应用,无向图的连通性欧拉回路有向图的连通性拓扑排序,73,无向图的连通性,深度优先搜索和广度优先搜索都可以用来测试无向图的连通性。如果无向图是连通的，则从无向图中的任意结点出发进行深度优先搜索或广度优先搜索都可以访问到每一个结点。访问的次序是一棵深度/广度优先生成树。如果图是非连通的，深度/广度优先搜索可以找到一片深度/广度优先生成森林。每棵树就是一个连通分量。对无向图来说，深度/广度优先搜

29、索可以找到了它的所有连通分量。前面介绍的讨论的深度优先和广度优先遍历中，都已实现了这个功能。在这两个函数的输出中，每一行代表一个连通分量。,74,图遍历的应用,无向图的连通性欧拉回路有向图的连通性拓扑排序,75,欧拉回路,哥尼斯堡七桥问题就是：能否找到一条走遍这七座桥，而且每座桥只经过一次，最后又回到原出发点的路径。,76,七桥问题的抽象,77,欧拉的证明,如果有奇数桥的地方不止两个，满足要求的路径是找不到的。如果只有两个地方有奇数桥，可以从这两个地方之一出发，经过所有的桥一次，再回到另一个地方。如果都是偶数桥，从任意地方出发都能回到原点。,78,欧拉回路和欧拉路径,如果能够在一个图中找到一条

30、路径，使得该路径对图的每一条边正好经过一次，这条路径被称为欧拉路径。如果再增加一个附加条件，即起点和终点是相同的，这条路径被称为欧拉回路。,79,基本想法,执行一次深度优先的搜索。从起始结点开始，沿着这条路一直往下走，直到无路可走。而且在此过程中不允许回溯。因此欧拉回路问题也被称为一笔画问题。但是有很多的搜索方案是行不通的。,80,对于上图，它的所有结点的度均为偶数，应该存在欧拉回路。但如果从结点5出发开始深度优先的访问，选择的路径为5-4-3-5，则此时，就无法访问其他结点了,因为5没有其他的尚未被访问的边了。,81,解决方法,找出路径上的另外一个尚有未访问的边的顶点，开始另一次深度优先的搜

31、索，将得到的遍历序列拼接到原来的序列中，直到所有的边都已被访问。,82,先找到 5-4-3-5,在路径上找一个尚有边未被访问的结点，如：4，开始另一次深度优先遍历。得到路径4-2-1-4,将第二条路径拼接到第一条路径上，得到：5-4-2-1-4-3-5,3号结点还有未访问的边，从3号结点再开始一次深度优先遍历，得到路径3-1-0-2-3,将第三条路径拼接到第一条路径上，得到：5-4-2-1-4-3-1-0-2-3-5,83,寻找欧拉回路,检查存在性找出回路：执行一次深度优先的搜索。从起始结点开始，沿着这条路一直往下走，直到无路可走。而且在此过程中不允许回溯。路径上是否有一个尚有未访问的边的顶点

32、。如果有，开始另一次深度优先的搜索，将得到的遍历序列拼接到原来的序列中，直到所有的边都已被访问。,84,欧拉回路的实现,欧拉回路是由一段一段的路径拼接起来的。为此，设计了一个私有的成员函数EulerCircuit来获得一段路径。公有的EulerCircuit函数调用私有的EulerCircuit函数获得一段段的路径，并将它们拼接起来，形成一条完整的欧拉回路。为了拼接方便起见，找到的欧拉回路被保存在一个单链表中，单链表的结点类型为EulerNode。EulerNode保存两个内容：结点的编号和下一结点的指针。它被定义为邻接表类的私有的内嵌类。,85,欧拉回路的实现 续,欧拉回路中，一条边不能走两

33、遍。为此，当一条边被访问以后，就将这条边删除Clone函数创建一份邻接表的拷贝，以便在找完路径后能恢复这个图的邻接表,86,公有的EulerCircuit函数,template void adjListGraph:EulerCircuit(TypeOfVer start)EulerNode*beg,*end,*p,*q,*tb,*te;int numOfDegree;edgeNode*r;verNode*tmp;/检查是否存在欧拉回路 for(int i=0;inext;if(numOfDegree=0|numOfDegree%2)cout 不存在欧拉回路 endl;return;,87,/寻

34、找起始结点的编号for(i=0;iVers;+i)if(verListi.ver=start)break;if(i=Vers)cout 起始结点不存在 endl;return;/创建一份邻接表的拷贝tmp=clone();,88,/寻找从i出发的路径，/路径的起点和终点地址分别是beg和endbeg=EulerCircuit(i,end);while(true)p=beg;while(p-next!=NULL)if(verListp-next-NodeNum.head!=NULL)break;else p=p-next;if(p-next=NULL)break;q=p-next;tb=Eule

35、rCircuit(q-NodeNum,te);te-next=q-next;p-next=tb;delete q;,89,/恢复原图 delete verList;verList=tmp;/显示得到的欧拉回路 cout NodeNum.ver next;delete p;cout endl;,90,欧拉路径中的结点类,struct EulerNodeint NodeNum;EulerNode*next;EulerNode(int ver)NodeNum=ver;next=NULL;,91,clone函数的实现,template adjListGraph:verNode*adjListGraph

36、:clone()const verNode*tmp=new verNodeVers;edgeNode*p;for(int i=0;i end,p-weight,tmpi.head);p=p-next;return tmp;,92,私有的EulerCircuit函数,template adjListGraph:EulerNode*adjListGraph:EulerCircuit(int start,EulerNode*,93,哈密尔顿回路问题,该回路通过图的每一个结点一次，且仅通过一次。一个图是否存在哈密尔顿回路至今仍未找到满足该问题的充要条件。,94,图遍历的应用,无向图的连通性欧拉回路有向

37、图的连通性拓扑排序,95,对有向图，深度优先搜索可以测试是否强连通，并找出所有强连通分量找强连通分量的方法从任意节点开始深度优先遍历G。对森林中的每棵树进行深度优先遍历，并按遍历的顺序给每个节点编号将G的每条边逆向，形成Gr。从编号最大的节点开始深度优先遍历Gr。得到的深度优先遍历森林的每棵树就是G的强连通分量。,有向图的连通性,96,97,Gr,因此，图G有5个强连通分量,98,图遍历的应用,无向图的连通性欧拉回路有向图的连通性拓扑排序,99,拓扑排序,设G=（V，E）是一个具有n个顶点的有向无环图。V中的顶点序列V1，V2，Vn称为一个拓扑序列，当且仅当该序列满足下列条件：若在G中，从Vi

38、到Vj有一条路径，则序列中Vi必须排在Vj的前面。,100,下述集合 M 代表课程的集合1 代表数学，2 代表程序设计，3 代表离散数学，4 代表汇编程序设计，5 代表数据结构，6 代表结构化程序设计,7 代表编译原理关系R表示课程学习的先后关系，如数学必须在离散数学之前学习。要求排一张学习的先后次序表。,拓扑排序的应用,101,用有向图表示关系R。节点集为课程集合。如果课程i和j有关系R，则有一条边。,102,可行的排课：方案1：1，2，3，4，5，6，7方案2：1，2，3，5，6，4，7方案3：1，2，3，5，6，7，4。,103,找出拓扑排序的过程,第一个输出的结点（序列中的第一个元素）

39、：必须无前驱，即入度为0后驱：必须等到它的前驱输出之后才输出。无前驱及后件的结点：任何时候都可输出。逻辑删除法：当某个节点被输出后，就作为该节点被删除。所有以该节点作为前驱的所有节点的入度减1。,104,105,0,0,0,1,1,1,汇编程序设计,0,0,1,1,1,结构化程序设计,0,1,2,2,数据结构,0,1,2,2,3,3,编译原理,0,0,1,程序设计,0,1,离散数学,0,数学,输出：,数学，,离散数学，,程序设计，,数据结构，,结构化程序设计，,编译原理，,汇编程序设计,106,拓扑排序的实现,计算每个结点的入度，保存在数组inDegree中；检查inDegree中的每个元素，

40、将入度为0的结点入队；不断从队列中将入度为0的结点出队，输出此结点，并将该结点的后继结点的入度减1；如果某个邻接点的入度为0，则将其入队。,107,template void adjListGraph:topSort()const linkQueue q;edgeNode*p;int current,*inDegree=new intVers;for(int i=0;i next)+inDegreep-end;for(i=0;i next)if(-inDegreep-end=0)q.enQueue(p-end);cout endl;,108,时间复杂度,如果图以邻接表表示计算入度需要O（|V|

41、+|E|）的时间，搜索入度为0的结点需要O（|V|）的时间。每个结点入一次队、出一次队。每出一次队，需要检查它的所有后继结点，因此也需要O（|V|+|E|）的时间。所以总的执行时间也是O（|V|+|E|）,109,总结,图是一种最一般的数据结构，有着广泛的用途。图可以用邻接矩阵、邻接表和其他方法来存储图的遍历：深度优先搜索和广度优先搜索，并给出了它们在邻接表的存储方式下的实现。图的应用：检测无向图的连通性寻找无向图的欧拉回路寻找有向图的强连通分量拓扑排序,110,第13章 最小生成树,生成树与最小生成树Kruskal算法Prim算法算法的正确性,111,生成树,生成树是无向连通图的极小连通子图

42、。包含图的所有 n 个结点，但只含图的 n-1 条边。在生成树中添加一条边之后，必定会形成回路或环。,112,最小生成树,定义：加权无向图的所有生成树中边的权值（代价）之和最小的树。实例：,左图的最小代价生成树,113,第13章 最小生成树,生成树与最小生成树Kruskal算法Prim算法算法的正确性,114,Kruscal 算法,基本思想：考虑图中权值最小的边。如果加入这条边不会导致回路，则加入；否则考虑下一条边，直到包含了所有的顶点实现：初始时，设置生成树为（V，），如果V有n个顶点，则初始的生成树为具有n个连通分量的树。按权值的大小逐个考虑所有的边，如果改变的加入能连接两个连通分量，则加

43、入。当生成树只有一个连通分量时，算法结束。,115,1、初始连通分量：1,2,3,4,5,62、反复执行添加、放弃动作。边 动作 连通分量(1,3)添加1,3,4,5,6,2(4,6)添加1,3,4,6,2,5(2,5)添加1,3,4,6,2,5(3,6)添加1,3,4,6,2,5(1,4)放弃因构成回路(3,4)放弃因构成回路(2,3)添加1,3,4,5,6,2,最小代价生成树,1,2,4,3,5,6,1,5,3,4,2,116,算法难点及解决方案,如何从所有边中选择代价最小的边：用一个优先级队列来实现。将所有的边放入一个优先级队列，边的优先级就是它的权值。权值越小，优先级越高。如何判断加入

44、一条边后会不会形成回路：用并查集来实现。将一个连通分量表示为并查集中的一个子集，检查一条边加入后会不会形成回路可以通过对边的两个端点分别执行Find操作。如果两个Find的结果相同，则表示两个端点已连通，加入这条边会形成回路，否则将这条边加入生成树。添加边的操作就是一个Union操作，将两个端点所属的子集归并起来，表示其中的所有顶点都已连通。,117,定义优先级队列中的元素类型,struct edge int beg,end;TypeOfEdge w;bool operator(const edge,118,kruskal算法的实现,template void adjListGraph:kru

45、skal()const int edgesAccepted=0，u,v;edgeNode*p;edge e;DisjointSet ds(Vers);/定义并查集 priorityQueue pq;/定义优先队列/生成优先级队列 for(int i=0;inext)if(i end)e.beg=i;/无向图 e.end=p-end;e.w=p-weight;pq.enQueue(e);,119,/开始归并 while(edgesAccepted Vers-1)e=pq.deQueue();u=ds.Find(e.beg);v=ds.Find(e.end);if(u!=v)edgesAccept

46、ed+;ds.Union(u,v);cout(verListe.beg.ver,verListe.end.ver)t;,120,时间复杂度,生成优先级队列的for循环将所有的边入队。需要的时间是O（|E|log|E|）在最坏的情况下，归并的循环可能需要检查所有的边。对于每条边，最多需要执行两次Find操作和一次Union操作。因此，归并循环的最坏情况的时间复杂度是O（|E|log|V|）。在一个连通图中，一般边数总比结点数大，所以，Kruskal算法的时间复杂度是O（|E|log|E|）,121,第13章 最小生成树,生成树与最小生成树Kruskal算法Prim算法算法的正确性,122,Pri

47、m算法,从顶点的角度出发。初始时，顶点集U为空，然后逐个加入顶点，直到包含所有顶点。过程：首先选择一个顶点，加入顶点集。然后重复下列工作，直到U=V选择连接 U 和 V-U 中代价最小的边（u，v）把（u，v）加入生成树的边集，v加入到U,123,1,124,Prim算法的实现,用一个布尔型的一维数组flag来保存哪些结点在U中，哪些结点不在U中的信息。用两个一维数组lowCost和startNode来记录U中的结点到V-U中结点的权值最小的边。lowCosti表示U中的结点到结点i的边的最小权值。startNodei表示从U中的哪一个结点出发到结点i的权值是lowCosti。,125,Pri

48、m算法的伪代码,Void prim（）初始化：将flag的元素全部置成false；将lowCost的元素全部置成无穷大。设start=0，表示第一个放入U的结点是0号结点；重复n-1次下列操作：对于start的每一条边（start，v）如果v不在生成树中，并且边的权值w小于lowCostv lowCostv=w；startNodev=start；flagstart=true；从lowCost中寻找最小的元素，将下标存入start,126,prim算法运行过程中startNode和lowCost数组的变化,随机值,随机值,随机值,随机值,随机值,随机值,lowCost,startNode,6,5

49、,1,F,F,F,F,F,F,visited,T,5,5,6,4,T,2,6,T,T,3,T,T,0,0,0,2,2,2,5,5,2,1,127,邻接表类中prim算法的实现,template void adjListGraph:prim(TypeOfEdge noEdge)const bool*flag=new boolVers;TypeOfEdge*lowCost=new TypeOfEdgeVers;int*startNode=new intVers;edgeNode*p;TypeOfEdge min;int start,i,j;for(i=0;i Vers;+i)flagi=false

50、;lowCosti=noEdge;,128,start=0;for(i=1;i next)if(!flagp-end,129,时间复杂度,函数的主体是一个嵌套循环，外层循环执行|V|次，内层循环也执行|V|次。所以，Prim算法的时间复杂度是O（|V|2）。,130,第13章 最小生成树,生成树与最小生成树Kruskal算法Prim算法算法的正确性,131,算法的正确性,定理13.1：假设 G=V,E 是一个连通图，U 是顶点集合 V 的一个非空子集。若(u,v)是一条代价最小的边，且 u U,v VU，则必存在一棵包括边(u,v)在内的最小生成树。,132,定理的证明,用反证法证明。假定在图