学习 严蔚敏讲数据结构笔记15

广度优先搜索遍历图

从图中的某个顶点V₀出发，并在访问此顶点之后依次访问V₀的所有未被访问的邻接点，之后按这些顶点被访问的先后次序依次访问它们的邻接点，直至图中所有和V₀有路径相通的顶点都被访问到。若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作为起始点，重复上述过程，直至图中所有顶点都被访问到为止。

26_002

void BFSTraverse(Graph G, Status(*  Visit)(int v)) {          for(v  = 0; v < G.vexnum; ++ v)          {                    visited[v]  = FALSE;          }          InitQueue(Q);  //置空的辅助队列Q          for(v  = 0; v < G.vexnum; ++ v)          {                    if(!  visited[v])                    {                             //v尚未访问                             EnQueue(Q,  v); //v入队列                             visited[u]  = TRUE;                             Visti(u);  //访问u                             while(!  QueueEmpty(Q))                             {                                      DeQueue(Q,  u); //对头元素的出队并置u                                      //访问u                                      for(w  = FirstAdjVex(G, u); w != 0; w = NextAdjVex(G, u, w))                                      {                                                if(!  visited[w])                                                {                                                         EnQueue(Q,  w);                                                         visited[w]  = TRUE;                                                         Visit(w);                                                }                                                //u的尚未访问的邻接顶点w入队列Q                                      }                             };                    }          } }//BFSTraverse

 

遍历的简单应用

1.      求一条从顶点i到顶点s的简单路径

27_001

void DFSearch(int v, int s, char *PATH) {          //从第v个顶点出发递归地深度优先遍历图G          //求得一条从v到s的简单路径，并记录在PATH中          visited[v]  = TRUE; //访问第v个顶点          Append(PATH,  getVertex(v));          for(w  = FirstAdjVex(v); w != 0 && !found; w = NextAdjVex(v))          {                    if(w  = s)                    {                             found  = TRUE;                             Append(PATH,  W);                    }                    else                    {                             if(!  visited[w])                             {                                                DFSearch(w,  LP);                             }                    }                    if(!  found)                    {                             Delete(PATH);                    }          } }

2.      求两个顶点之间的一条路径长度最短的路径

基于广度优先搜索遍历，并修改链队列的结点结构及其入队列和出队列的算法。

1）  将链队列的结点改为“双链”结点，即结点中包含next和priou两个指针；

2）  修改入队列的操作，插入新的的队尾结点时，令其priou域的指针指向刚刚出队列的结点，即当前的对头指针所指结点；

3）  修改出队列的操作，出队列时，仅移动对头指针，而不将对头结点从链表中删除。

27_003

typedef DuLinkList QueuePtr; void InitQueue(LinkQueue &Q) {          Q.front  = Q.rear = (QueuePtr) malloc (sizeof(QNode));          Q.front->next  = Q.rear->next = NULL; }   void EnQueue(LinkQueue &Q, QelemType  e) {          p  = (QueuePtr) malloc(sizeof(QNode));          p->data  = e;          p->next  = NULL;          p->priou  = Q.front;          Q.rear->next  = p;          Q.rear  = p; }   void DeQueue(LinkQueue &Q, QelemType  &e) {          Q.front  = Q.front->next;          e  = Q.front->data; }

 

7.4 最小生成树

问题：假设要在n个城市之间建立通讯网络，则连同n个城市只需要修n-1条线路，如何在最节省经费的前提下建立这个通讯网？

该问题等价于：构造网的一棵最小生成树，即：在e条带权的边中选取n-1条（不构成回路），使“权值之和“为最小。

算法一：（普里姆算法）

可取图中任意一个顶点v作为生成树的根，之后若要网生成树上添加顶点w，则在顶点v和顶点w之间必定存在一条边，并且该边的权值在所有连同顶点v和w之间的边中取最小值。

一般情况下，假设n个顶点分成两个集合：U（包含已落在生成树上的结点）和V-U（尚未落在生成树上的顶点），则在所有连通U中顶点和V-U中顶点的边中选取权值最小的边。

记录从顶点集U到V-U的代价最小的边的辅助数组：

27_004

struct {          VertexType  adjvex;          VRTyped  lowcost; }closedge[MAX_VERTEX_NUM]; k = LocateVex(G, u); for(j = 0; j < G.vexnum; ++ j) {          //辅助数组初始化          if(j  != k)          {                    closedge[j]  = (u, G.arcs[k][j].adj);          }          closeedge[k].lowcoset  = 0; //初始，U-(u)          for(j  = 0; i < G.vexnum; ++ i)          {                    //在其余顶点中选择                    k  = minimum(closedge); //求出T的一个小节点(k)                    printf(colsedge[k].adjvex,  G.vexs[k]);                    closedge[k].lowcost  = 0; //第k顶点并入U集                    for(j  = 0; j < G.vexnum; ++ j)                    {                             if(G.arcs[k][j].adj  < closedge[j].lowcost)                             {                                      closedge[j]  = (G.vexs[k], G.arcs[k][j].adj);                             }                    }          } }

算法二：（克鲁斯卡尔算法）

为使生成树上边的权值之和最小，显然，其中每一台边的权值应该尽可能地小。克鲁斯卡尔算法的做法吉局势：先构造一个只含有n个顶点的子图SG，然后从权值最小的边喀什，若它的添加不使SG中产生回路，则在SG上加上这条边，如此重复，直至加上n-1条边为止。

算法：

构造非连通图ST=(V,{});k=i=0; while(k<n-1){++I; 从边集E中选取第i条权值最小的边(u,v)；若(u,v)加入ST后不会使ST中产生回路，则输出边(u,v);且k++;}

由于普里姆算法的时间复杂度为O(n²)，则适用于稠密图；而克鲁斯卡尔算法则需对e条边按权值进行排序，其时间复杂度为O(eloge)，则适用域稀疏图。

 

7.5重（双）连通图和关节点

问题：若从一个连通图中删去任何一个顶点及其相关联的边，它仍为一个连通图的话，则该连通图被称为重（双）连通图。

若连通图中的某个顶点和其相关联的边被删去之后，该连通图被分割成两个或两个以上的连同分量，则称此顶点为关节点。

没有关节点的连通图为双连通图。

 

关节点的特征：

假设从某个顶点V₀出发对连通图进行深度优先搜索遍历，则可得到一棵深度优先生成树，树上包含图的所有顶点。

若生成树的根结点，有两个或两个以上的分支，则此顶点（生成树的根）必为关节点；

对生成树上的任意一个“顶点”，若其某棵子树的跟或子树中的其它“顶点”没有和其祖先相通的回边，则该“顶点”必为关节点。

1)      设V0为深度优先遍历的出发点

28_001

p = G.vertices[0].firstarc; v = p->adjvex; DFSArticul(G, v); //从第v顶点出发深度优先搜素 if(count < G.vexnum) {          //生成树的根至少有两棵子树          printf(0,  G.vertices[0].data);//根是关节点 }

2)      对生成树上的顶点定义一个函数

29_002

low(v)=Min{visited[v], low[w], visted[k]}

对顶点v，若（在生成树上）存在一个子树根w，且low[w]>=visited[v]则顶点v为关节点。

对深度优先遍历算法作如下修改：

1.      visited[v]的值改为遍历过程中顶点的访问次序count值

2.      遍历过程中求得low[v]=Min{visited[v],low[w],visited[k]}

3.      从子树遍历返回时，判别low[w]>=visited[v]?

29_003

min = visited[v0] = ++count; //设定low[v0]的初始值count计顶点访问次序 for(p = G.vertices[v0].firstarc; p;  p=p->nextarc) {          w  = p->adjvex; //w为v0的邻接顶点          if(visited[w]  == 0)          {                    //w未曾访问                    DFSArticul(G,  w); //返回前求得low[w]                    if(low[w]  < min)                    {                             min  = low[w];                             if(low[w]  >= visited[v0])                             {                                      printf(v0,  G.vertices[v0].data); //输出关节点                             }                    }          }          else          {                    //w是回边上的顶点                    if(visited[w]  < min)                    {                             min  = visited[w];                    }          }          low[v0]  = min; }