图的遍历——深度优先搜索+广度优先搜索

清疚 2022-04-03 04:40 301阅读 0赞

# **一：图的遍历——深度优先搜索** #

**在本文其他内容中只是大体概括了主要的图论内容，更加详细的代码实现及算法分析在此给出。**

**深度优先搜索（DFS）类似树的先序遍历。**

**假设初始状态是图中所有顶点未曾被访问，则深度优先搜索可从图中某个顶点发，访问此顶点,然后依次从v的未被访问的邻接点出发深度优先遍历图，直至图中阶和V有路径相通的顶点都被访问到;若此时图中尚有顶点未被访问则另选图中一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。**

**以下图为例，假设从V1出发开始搜索，在访问了V1之后选择邻接点V2，因为V2未被访问，**

**则从V2出发进行搜索。依次类推,接着从V4\\V8V5出发进行搜索。在访问了V5之后，由于V5的邻接点都已被访问，则搜索回到V1。此时由于V1的另一个邻接点未被访问，则搜索又从V1到V3，再继续进行下去。由此，得到的顶点访问序列为:  
  
V1->V2->V4->V8->V5->V3->V6->V7;  
显然，这是一个递归的过程。为了在遍历过程中便于区分顶点是否已被访问需附设访问标志数组visited\[n-1\]其初值为false一 且某个顶点被访问，则其相应的分量置"true"。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70][]

**具体代码用C语言实现如下：**

#include<string.h>
     #include<ctype.h>
     #include<malloc.h> /* malloc()等 */
     #include<limits.h> /* INT_MAX等 */
     #include<stdio.h> /* EOF(=^Z或F6),NULL */
     #include<stdlib.h> /* atoi() */
     #include<io.h> /* eof() */
     #include<math.h> /* floor(),ceil(),abs() */
     #include<process.h> /* exit() */
     /* 函数结果状态代码 */
     #define TRUE 1
     #define FALSE 0
     #define OK 1
     #define ERROR 0
     #define INFEASIBLE -1
     typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
     typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
     #define MAX_NAME 5 /* 顶点字符串的最大长度 */
     typedef int InfoType;
     typedef char VertexType[MAX_NAME]; /* 字符串类型 */
     /* 图的邻接表存储表示 */
     #define MAX_VERTEX_NUM 20
     typedef enum{DG,DN,AG,AN}GraphKind; /* {有向图,有向网,无向图,无向网} */
     typedef struct ArcNode
     {
       int adjvex; /* 该弧所指向的顶点的位置 */
       struct ArcNode *nextarc; /* 指向下一条弧的指针 */
       InfoType *info; /* 网的权值指针） */
     }ArcNode; /* 表结点 */
     typedef struct
     {
       VertexType data; /* 顶点信息 */
       ArcNode *firstarc; /* 第一个表结点的地址,指向第一条依附该顶点的弧的指针 */
     }VNode,AdjList[MAX_VERTEX_NUM]; /* 头结点 */
     typedef struct
     {
       AdjList vertices;
       int vexnum,arcnum; /* 图的当前顶点数和弧数 */
       int kind; /* 图的种类标志 */
     }ALGraph;
    
    
    
    Boolean visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */
     void(*VisitFunc)(char* v); /* 函数变量(全局量) */
     void DFS(ALGraph G,int v)
     { /* 从第v个顶点出发递归地深度优先遍历图G。算法7.5 */
       int w;
       VertexType v1,w1;
       strcpy(v1,*GetVex(G,v));
       visited[v]=TRUE; /* 设置访问标志为TRUE(已访问) */
       VisitFunc(G.vertices[v].data); /* 访问第v个顶点 */
       for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w))))
         if(!visited[w])
           DFS(G,w); /* 对v的尚未访问的邻接点w递归调用DFS */
     }
    
     void DFSTraverse(ALGraph G,void(*Visit)(char*))
     { /* 对图G作深度优先遍历。算法7.4 */
       int v;
       VisitFunc=Visit; /* 使用全局变量VisitFunc,使DFS不必设函数指针参数 */
       for(v=0;v<G.vexnum;v++)
         visited[v]=FALSE; /* 访问标志数组初始化 */
       for(v=0;v<G.vexnum;v++)
         if(!visited[v])
           DFS(G,v); /* 对尚未访问的顶点调用DFS */
       printf("\n");
     }

# **二：广度优先搜索** #

**广度优先搜索(BFS)遍历类似于树的层序遍历。**

**假设从图中某顶点V出发，在访问了V之后依次访问V的未曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问，直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作起始点,重复上述过程,直至图中所有顶点都被访问到为止。换句话说广度优先搜索遍历图的过程是以V为起始点，由近至远.依次访问和V有路径相通且路径长度为1，2，...的顶点。  
对上图得到的顶点访问序列为V1->V2->V3->V4->V5->V6->V7->v8。**

**具体代码用C语言实现如下：**

typedef int QElemType; /* 队列类型 */
     /* c3-2.h 单链队列－－队列的链式存储结构 */
     typedef struct QNode
     {
       QElemType data;
       struct QNode *next;
     }QNode,*QueuePtr;
    
     typedef struct
     {
       QueuePtr front,rear; /* 队头、队尾指针 */
     }LinkQueue;
    /* bo3-2.c 链队列(存储结构由c3-2.h定义)的基本操作(9个) */
     Status InitQueue(LinkQueue *Q)
     { /* 构造一个空队列Q */
       (*Q).front=(*Q).rear=(QueuePtr)malloc(sizeof(QNode));
       if(!(*Q).front)
         exit(OVERFLOW);
       (*Q).front->next=NULL;
       return OK;
     }
    
     Status DestroyQueue(LinkQueue *Q)
     { /* 销毁队列Q(无论空否均可) */
       while((*Q).front)
       {
         (*Q).rear=(*Q).front->next;
         free((*Q).front);
         (*Q).front=(*Q).rear;
       }
       return OK;
     }
    
     Status ClearQueue(LinkQueue *Q)
     { /* 将Q清为空队列 */
       QueuePtr p,q;
       (*Q).rear=(*Q).front;
       p=(*Q).front->next;
       (*Q).front->next=NULL;
       while(p)
       {
         q=p;
         p=p->next;
         free(q);
       }
       return OK;
     }
    
     Status QueueEmpty(LinkQueue Q)
     { /* 若Q为空队列,则返回TRUE,否则返回FALSE */
       if(Q.front==Q.rear)
         return TRUE;
       else
         return FALSE;
     }
    
     int QueueLength(LinkQueue Q)
     { /* 求队列的长度 */
       int i=0;
       QueuePtr p;
       p=Q.front;
       while(Q.rear!=p)
       {
         i++;
         p=p->next;
       }
       return i;
     }
    
     Status GetHead_Q(LinkQueue Q,QElemType *e) /* 避免与bo2-6.c重名 */
     { /* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
       QueuePtr p;
       if(Q.front==Q.rear)
         return ERROR;
       p=Q.front->next;
       *e=p->data;
       return OK;
     }
    
     Status EnQueue(LinkQueue *Q,QElemType e)
     { /* 插入元素e为Q的新的队尾元素 */
       QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
       if(!p) /* 存储分配失败 */
         exit(OVERFLOW);
       p->data=e;
       p->next=NULL;
       (*Q).rear->next=p;
       (*Q).rear=p;
       return OK;
     }
    
     Status DeQueue(LinkQueue *Q,QElemType *e)
     { /* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
       QueuePtr p;
       if((*Q).front==(*Q).rear)
         return ERROR;
       p=(*Q).front->next;
       *e=p->data;
       (*Q).front->next=p->next;
       if((*Q).rear==p)
         (*Q).rear=(*Q).front;
       free(p);
       return OK;
     }
    
     Status QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
     { /* 从队头到队尾依次对队列Q中每个元素调用函数vi()。一旦vi失败,则操作失败 */
       QueuePtr p;
       p=Q.front->next;
       while(p)
       {
         vi(p->data);
         p=p->next;
       }
       printf("\n");
       return OK;
     }
    
    
    
    
    
    
    
    
    
     void BFSTraverse(ALGraph G,void(*Visit)(char*))
     {/*按广度优先非递归遍历图G。使用辅助队列Q和访问标志数组visited。算法7.6 */
       int v,u,w;
       VertexType u1,w1;
       LinkQueue Q;
       for(v=0;v<G.vexnum;++v)
         visited[v]=FALSE; /* 置初值 */
       InitQueue(&Q); /* 置空的辅助队列Q */
       for(v=0;v<G.vexnum;v++) /* 如果是连通图,只v=0就遍历全图 */
         if(!visited[v]) /* v尚未访问 */
         {
           visited[v]=TRUE;
           Visit(G.vertices[v].data);
           EnQueue(&Q,v); /* v入队列 */
           while(!QueueEmpty(Q)) /* 队列不空 */
           {
             DeQueue(&Q,&u); /* 队头元素出队并置为u */
             strcpy(u1,*GetVex(G,u));
             for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w))))
               if(!visited[w]) /* w为u的尚未访问的邻接顶点 */
               {
                 visited[w]=TRUE;
                 Visit(G.vertices[w].data);
                 EnQueue(&Q,w); /* w入队 */
               }
           }
         }
       printf("\n");
     }

# **欢迎关注本博主**    #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70]: /images/20220403/7cd691405d6b482d9a9f0ad3e390702d.png