数据结构（图遍历--广度优先遍历）

今天给大家说下图的广度优先遍历（BFS）：

    图的广度优先搜索是树的按层次遍历的推广，它的基本思想是：首先访问初始点vi，并将其标记为已访问过，接着访问vi的所有未被访问过的邻接点 vi1,vi2, …, vi t，并均标记已访问过，然后再按照vi1,vi2, …, vi t的次序，访问每一个顶点的所有未被访问过的邻接点，并均标记为已访问过，依次类推，直到图中所有和初始点vi有路径相通的顶点都被访问过为止。

如图：

 

       首先发下用邻接链表法实现的广度优先遍历代码（如果不理解邻接链表法，请在本博客数据结构系列中查找，里面有详细介绍），代码是基于本博客数据结构系列讲解邻接链表法实现图写的，大家可以把这段代码加在那些代码中就可以运行：：

 static void recursive_bfs(TLGraph* tGraph, int v, int visited[], LGraph_Printf* pFunc)
 {
     LinkQueue* queue = LinkList_Create();

     if(NULL != queue)
     {
         LinkQueue_Append(queue, tGraph->v + v);

         while(0 < LinkQueue_Length(queue))
         {
             int i = 0;

             v = (LVertex**)LinkQueue_Retrieve(queue) - tGraph->v;

             pFunc(tGraph->v[v]);

             printf(", ");

             for(i=0; ila[v]; i++)
             {
                 TListNode* node = (TListNode*)LinkList_Get(tGraph->la[v], i);

                 if(!visited[node->v])
                 {
                     LinkQueue_Append(queue, tGraph->v + node->v);

                     visited[node->v] = 1;
                 }
             }
         }
     }

     LinkQueue_Destroy(queue);
 }

 void LGraph_BFS(LGraph* graph, int v, LGraph_Printf* pFunc)
 {
     TLGraph* tGraph = (TLGraph*)graph;

     int* visited = NULL;

     int condition = (NULL != tGraph);
     condition = condition && (0 <= v) && (v < tGraph->count);
     condition = condition && (NULL != pFunc);
     condition = condition && (NULL != (visited = (int*)calloc(tGraph->count, sizeof(int))));

     if(condition)
     {
         int i = 0;

         recursive_bfs(tGraph, v, visited, pFunc);

         for(i=0; icount; i++)
         {
             if(!visited[i])
             {
                 recursive_bfs(tGraph, i, visited, pFunc);
             }
         }

         printf("\n");
     }

     free(visited);
 }

 

最后发下用邻接矩阵法实现的广度优先遍历代码（如果不理解邻接矩阵法，请在本博客数据结构系列中查找，里面有详细介绍），代码是基于本博客数据结构系列讲解邻接矩阵法实现图写的，大家可以把这段代码加在那些代码中就可以运行：    

 static void recursive_bfs(TMGraph* tGraph, int v, int visited[], MGraph_Printf* pFunc)
 {
     LinkQueue* queue = LinkQueue_Create();

     if(NULL != queue)
     {
         LinkQueue_Append(queue, tGraph->v + v);

         visited[v] = 1;

         while(0 < LinkQueue_Length(queue))
         {
             int i = 0;

             v = (MVertex**)LinkQueue_Retrieve(queue) - tGraph->v;

             pFunc(tGraph->v[v]);

             printf(", ");

             for(i=0; icount; i++)
             {
                 if((0 != tGraph->matrix[v][i]) && (!visited[i]))
                 {
                     LinkQueue_Append(queue, tGraph->v + i);

                     visited[i] = 1;
                 }
             }
         }
     }

     LinkQueue_Destroy(queue);
 }

 void MGraph_BFS(MGraph* graph, int v, MGraph_Printf* pFunc)
 {
     TMGraph* tGraph = (TMGraph*)graph;

     int* visited = NULL;

     int condition = (NULL != tGraph);
     condition = condition && (0 <= v) && (v < tGraph->count);
     condition = condition && (NULL != pFunc);
     condition = condition && (NULL != (visited = (int*)calloc(tGraph->count, sizeof(int))));

     if(condition)
     {
         int i = 0;

         recursive_bfs(tGraph, v, visited, pFunc);

         for(i=0; icount; i++)
         {
             if(!visited[i])
             {
                 recursive_bfs(tGraph, i, visited, pFunc);
             }
         }

         printf("\n");
     }

     free(visited);
 }

今天给大家说下图的广度优先遍历（BFS）：

    图的广度优先搜索是树的按层次遍历的推广，它的基本思想是：首先访问初始点vi，并将其标记为已访问过，接着访问vi的所有未被访问过的邻接点 vi1,vi2, …, vi t，并均标记已访问过，然后再按照vi1,vi2, …, vi t的次序，访问每一个顶点的所有未被访问过的邻接点，并均标记为已访问过，依次类推，直到图中所有和初始点vi有路径相通的顶点都被访问过为止。

如图：

 

       首先发下用邻接链表法实现的广度优先遍历代码（如果不理解邻接链表法，请在本博客数据结构系列中查找，里面有详细介绍），代码是基于本博客数据结构系列讲解邻接链表法实现图写的，大家可以把这段代码加在那些代码中就可以运行：：

 static void recursive_bfs(TLGraph* tGraph, int v, int visited[], LGraph_Printf* pFunc)
 {
     LinkQueue* queue = LinkList_Create();

     if(NULL != queue)
     {
         LinkQueue_Append(queue, tGraph->v + v);

         while(0 < LinkQueue_Length(queue))
         {
             int i = 0;

             v = (LVertex**)LinkQueue_Retrieve(queue) - tGraph->v;

             pFunc(tGraph->v[v]);

             printf(", ");

             for(i=0; ila[v]; i++)
             {
                 TListNode* node = (TListNode*)LinkList_Get(tGraph->la[v], i);

                 if(!visited[node->v])
                 {
                     LinkQueue_Append(queue, tGraph->v + node->v);

                     visited[node->v] = 1;
                 }
             }
         }
     }

     LinkQueue_Destroy(queue);
 }

 void LGraph_BFS(LGraph* graph, int v, LGraph_Printf* pFunc)
 {
     TLGraph* tGraph = (TLGraph*)graph;

     int* visited = NULL;

     int condition = (NULL != tGraph);
     condition = condition && (0 <= v) && (v < tGraph->count);
     condition = condition && (NULL != pFunc);
     condition = condition && (NULL != (visited = (int*)calloc(tGraph->count, sizeof(int))));

     if(condition)
     {
         int i = 0;

         recursive_bfs(tGraph, v, visited, pFunc);

         for(i=0; icount; i++)
         {
             if(!visited[i])
             {
                 recursive_bfs(tGraph, i, visited, pFunc);
             }
         }

         printf("\n");
     }

     free(visited);
 }

 

最后发下用邻接矩阵法实现的广度优先遍历代码（如果不理解邻接矩阵法，请在本博客数据结构系列中查找，里面有详细介绍），代码是基于本博客数据结构系列讲解邻接矩阵法实现图写的，大家可以把这段代码加在那些代码中就可以运行：    

 static void recursive_bfs(TMGraph* tGraph, int v, int visited[], MGraph_Printf* pFunc)
 {
     LinkQueue* queue = LinkQueue_Create();

     if(NULL != queue)
     {
         LinkQueue_Append(queue, tGraph->v + v);

         visited[v] = 1;

         while(0 < LinkQueue_Length(queue))
         {
             int i = 0;

             v = (MVertex**)LinkQueue_Retrieve(queue) - tGraph->v;

             pFunc(tGraph->v[v]);

             printf(", ");

             for(i=0; icount; i++)
             {
                 if((0 != tGraph->matrix[v][i]) && (!visited[i]))
                 {
                     LinkQueue_Append(queue, tGraph->v + i);

                     visited[i] = 1;
                 }
             }
         }
     }

     LinkQueue_Destroy(queue);
 }

 void MGraph_BFS(MGraph* graph, int v, MGraph_Printf* pFunc)
 {
     TMGraph* tGraph = (TMGraph*)graph;

     int* visited = NULL;

     int condition = (NULL != tGraph);
     condition = condition && (0 <= v) && (v < tGraph->count);
     condition = condition && (NULL != pFunc);
     condition = condition && (NULL != (visited = (int*)calloc(tGraph->count, sizeof(int))));

     if(condition)
     {
         int i = 0;

         recursive_bfs(tGraph, v, visited, pFunc);

         for(i=0; icount; i++)
         {
             if(!visited[i])
             {
                 recursive_bfs(tGraph, i, visited, pFunc);
             }
         }

         printf("\n");
     }

     free(visited);
 }