图的实现和图的广度遍历 Gragh's BFS

2019年3月16日 428次阅读 来源: 数据结构之图

图的实现方法有2种，在之前的一篇博文图的深度遍历中有介绍。在同样的2种图的存储方式的基础上，可以进行图的广度遍历。

图的邻接矩阵法，依然是申请完全连续的空间。通过二维数组空间来存储和访问图中每个边的存在性（或权值）。

int (*edge)[VERTEXNUM] = (int (*)[VERTEXNUM])malloc(sizeof(int)*VERTEXNUM*VERTEXNUM);

edge是一个数组指针。

图的邻接表法，是利用单链式结构（邻接表）存储每个点的可直达节点。并申请连续的空间存储这些邻接表的首结点地址（如果该点没有可直达节点，那首结点位置就为NULL）。

typedef struct edge{
int vertex;
struct edge* next;
}st_edge;

st_edge** edge = (st_edge**)malloc(sizeof(st_edge*)*VERTEXNUM);

在DFS中，访问的顺序是受到递归逻辑控制的。而BFS中，我们需要借助队列来控制访问的顺序。在另一篇博文中，实现的是线性物理结构的队列。这一次使用链式物理结构来实现队列。我们使用双向链表来存储队列，这样的好处是表头可以快速删除节点，表尾可以快速插入节点。

[cpp] 
view plain
copy

  1. typedef struct  qElement{  
  2.     int value;  
  3.     struct  qElement* pre;  
  4.     struct  qElement* next;  
  5. }st_qElement;  
  6.   
  7. st_qElement* front = NULL;  
  8. st_qElement* rear = NULL;  

对队列的操作：

1. 入队：将一个新元素加入队列（插在队尾）

2. 出队：将队尾元素删除

[cpp] 
view plain
copy

  1. void putQueue(int vertex)  
  2. {  
  3.     st_qElement* qe = (st_qElement*)malloc(sizeof(st_qElement));  
  4.     qe->value = vertex;  
  5.     qe->next = NULL;  
  6.     qe->pre = NULL;  
  7.   
  8.     if(front == NULL || rear == NULL)  
  9.         front = rear = qe;  
  10.     else{  
  11.         rear->next = qe;  
  12.         qe->pre = rear;  
  13.         rear = qe;  
  14.     }  
  15. }  
  16.   
  17. int* getQueue()  
  18. {  
  19.     if(front ==NULL || rear == NULL)  
  20.         return NULL;  
  21.     else{  
  22.         int* res = (int*)malloc(sizeof(int));  
  23.         *res = front->value;  
  24.         st_qElement* p = front;  
  25.         front = front->next;  
  26.         if(front == NULL)  
  27.             rear = front;  
  28.         else  
  29.         {  
  30.             front->pre = NULL;  
  31.         }  
  32.         free(p);  
  33.         p = NULL;  
  34.         return res;  
  35.     }  
  36. }  

怎么在BFS中使用队列？

BFS的遍历顺序是按层序。每一层的访问顺序都是由上一层访问的顺序决定好的，这个顺序是存储在队列中。

当访问某一个节点时，就为下一层访问其所有邻接节点做好准备，即将其所有邻接节点依次入队。

那么，整个BFS的访问就是依次从队列中取队头元素，访问它。（当然，首个节点是主动放进队中的。）

邻接矩阵的BFS实现：

[cpp] 
view plain
copy

  1. void bfs(int (*edge)[VERTEXNUM], int* vetexStatusArr)  
  2. {  
  3.     printf(“BFS: “);  
  4.     int i;  
  5.     for(i=0;i<VERTEXNUM;i++)  
  6.         bfscore(edge, i, vetexStatusArr);  
  7.     printf(“\n”);  
  8. }  
  9.   
  10. void bfscore(int (*edge)[VERTEXNUM], int i, int* vetexStatusArr)  
  11. {  
  12.     putQueue(i);  
  13.     int* qeValue = NULL;  
  14.     while((qeValue = getQueue()) != NULL)  
  15.     {  
  16.         if(vetexStatusArr[*qeValue] == 0)  
  17.         {  
  18.             printf(“%d “, *qeValue);  
  19.             vetexStatusArr[*qeValue] = 1;  
  20.   
  21.             //把与点vertex邻接的点都加进队列  
  22.             for(int k=0;k<VERTEXNUM;k++)  
  23.                 if(edge[*qeValue][k]==1)  
  24.                     putQueue(k);  
  25.         }  
  26.         free(qeValue);  
  27.         qeValue = NULL;  
  28.     }  
  29. }  

邻接表的实现BFS实现：

[cpp] 
view plain
copy

  1. void bfscore(st_edge** edge, int i, int *vertexStatusArr)  
  2. {  
  3.     putQueue(i);  
  4.     int *qeValue = NULL;  
  5.     while((qeValue = getQueue()) != NULL)  
  6.     {  
  7.         if(vertexStatusArr[*qeValue] == 0)  
  8.         {  
  9.             vertexStatusArr[*qeValue] = 1;  
  10.             printf(“%d “, *qeValue);  
  11.             st_edge *p = *(edge + *qeValue);  
  12.             while(p != NULL)  
  13.             {  
  14.                 putQueue(p->vertex);  
  15.                 p = p->next;  
  16.             }  
  17.         }  
  18.         free(qeValue);  
  19.         qeValue = NULL;  
  20.     }  
  21. }  
  22.   
  23. void bfs(st_edge** edge, int* vertexStatusArr)  
  24. {  
  25.     printf(“BFS: “);  
  26.     int i;  
  27.     for(i=0;i<VERTEXNUM;i++)  
  28.         bfscore(edge, i, vertexStatusArr);  
  29.     printf(“\n”);  
  30. }  

邻接矩阵存储方式的BFS完整代码：

[cpp] 
view plain
copy

  1. #include <stdio.h>  
  2. #include <malloc.h>  
  3. #define VERTEXNUM 5  
  4.   
  5. //双向链表存储的队列  
  6. typedef struct  qElement{  
  7.     int value;  
  8.     struct  qElement* pre;  
  9.     struct  qElement* next;  
  10. }st_qElement;  
  11.   
  12. st_qElement* front = NULL;  
  13. st_qElement* rear = NULL;  
  14.   
  15. void putQueue(int vertex);  
  16. int* getQueue();  
  17.   
  18. void createGraph(int (*edge)[VERTEXNUM], int start, int end);  
  19. void display(int (*edge)[VERTEXNUM]);  
  20.   
  21. void bfs(int (*edge)[VERTEXNUM],int i,int* vetexStatusArr);  
  22. void bfscore(int (*edge)[VERTEXNUM], int i, int* vetexStatusArr);  
  23.   
  24.   
  25. void putQueue(int vertex)  
  26. {  
  27.     st_qElement* qe = (st_qElement*)malloc(sizeof(st_qElement));  
  28.     qe->value = vertex;  
  29.     qe->next = NULL;  
  30.     qe->pre = NULL;  
  31.   
  32.     if(front == NULL || rear == NULL)  
  33.         front = rear = qe;  
  34.     else{  
  35.         rear->next = qe;  
  36.         qe->pre = rear;  
  37.         rear = qe;  
  38.     }  
  39. }  
  40.   
  41. int* getQueue()  
  42. {  
  43.     if(front ==NULL || rear == NULL)  
  44.         return NULL;  
  45.     else{  
  46.         int* res = (int*)malloc(sizeof(int));  
  47.         *res = front->value;  
  48.         st_qElement* p = front;  
  49.         front = front->next;  
  50.         if(front == NULL)  
  51.             rear = front;  
  52.         else  
  53.         {  
  54.             front->pre = NULL;  
  55.         }  
  56.         free(p);  
  57.         p = NULL;  
  58.         return res;  
  59.     }  
  60. }  
  61.   
  62. void createGraph(int (*edge)[VERTEXNUM], int start, int end)  
  63. {  
  64.     edge[start][end] = 1;  
  65. }  
  66.   
  67. void display(int (*edge)[VERTEXNUM])  
  68. {  
  69.     int i,j;  
  70.     for(i=0;i<VERTEXNUM;i++)  
  71.     {  
  72.         for(j=0;j<VERTEXNUM;j++)  
  73.             printf(“%d “, edge[i][j]);  
  74.   
  75.         printf(“\n”);  
  76.     }  
  77. }  
  78.   
  79. void bfs(int (*edge)[VERTEXNUM], int* vetexStatusArr)  
  80. {  
  81.     printf(“BFS: “);  
  82.     int i;  
  83.     for(i=0;i<VERTEXNUM;i++)  
  84.         bfscore(edge, i, vetexStatusArr);  
  85.     printf(“\n”);  
  86. }  
  87.   
  88. void bfscore(int (*edge)[VERTEXNUM], int i, int* vetexStatusArr)  
  89. {  
  90.     putQueue(i);  
  91.     int* qeValue = NULL;  
  92.     while((qeValue = getQueue()) != NULL)  
  93.     {  
  94.         if(vetexStatusArr[*qeValue] == 0)  
  95.         {  
  96.             printf(“%d “, *qeValue);  
  97.             vetexStatusArr[*qeValue] = 1;  
  98.   
  99.             //把与点vertex邻接的点都加进队列  
  100.             for(int k=0;k<VERTEXNUM;k++)  
  101.                 if(edge[*qeValue][k]==1)  
  102.                     putQueue(k);  
  103.         }  
  104.         free(qeValue);  
  105.         qeValue = NULL;  
  106.     }  
  107. }  
  108.   
  109. int main()  
  110. {  
  111.     int (*edge)[VERTEXNUM] = (int (*)[VERTEXNUM])malloc(sizeof(int)*VERTEXNUM*VERTEXNUM);  
  112.     int i, j;  
  113.     for(i=0;i<VERTEXNUM;i++)  
  114.         for(j=0;j<VERTEXNUM;j++)  
  115.             edge[i][j] = 0;  
  116.   
  117.     int *vetexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);  
  118.     for(i=0;i<VERTEXNUM;i++)  
  119.         vetexStatusArr[i] = 0;  
  120.   
  121.     createGraph(edge, 0, 3);  
  122.     createGraph(edge, 0, 4);  
  123.     createGraph(edge, 3, 1);  
  124.     createGraph(edge, 3, 2);  
  125.     createGraph(edge, 4, 1);  
  126.     display(edge);  
  127.   
  128.     bfs(edge, vetexStatusArr);  
  129.     free(edge);  
  130.     return 1;  
  131. }  

邻接表存储方式的BFS完整代码：

[cpp] 
view plain
copy

  1. #include <stdio.h>  
  2. #include <malloc.h>  
  3. #define VERTEXNUM 5  
  4.   
  5. typedef struct edge{  
  6.     int vertex;  
  7.     struct edge* next;  
  8. }st_edge;  
  9.   
  10. typedef struct qElement{  
  11.     int value;  
  12.     struct qElement* pre;  
  13.     struct qElement* next;  
  14. }st_qElement;  
  15.   
  16. st_qElement* front = NULL;  
  17. st_qElement* rear = NULL;  
  18.   
  19. void putQueue(int vertex)  
  20. {  
  21.     st_qElement* qe = (st_qElement*)malloc(sizeof(st_qElement));  
  22.     qe->value = vertex;  
  23.     qe->next = NULL;  
  24.     qe->pre = NULL;  
  25.     if(front == NULL || rear == NULL)  
  26.         front = rear = qe;  
  27.     else  
  28.     {  
  29.         rear->next = qe;  
  30.         qe->pre = rear;  
  31.         rear = qe;  
  32.     }  
  33. }  
  34.   
  35. int* getQueue()  
  36. {  
  37.     if(front == NULL || rear == NULL)  
  38.         return NULL;  
  39.     else  
  40.     {  
  41.         int *res = (int*)malloc(sizeof(int));  
  42.         *res = front->value;  
  43.   
  44.         st_qElement* p = front;  
  45.         front = front->next;  
  46.         if(front == NULL)  
  47.             rear = front;  
  48.         else  
  49.             front->pre = NULL;  
  50.         free(p);  
  51.         p = NULL;  
  52.         return res;  
  53.     }  
  54. }  
  55.   
  56. void display(st_edge** edge)  
  57. {  
  58.     int i;  
  59.     st_edge* p;  
  60.     for(i=0;i<VERTEXNUM;i++)  
  61.     {  
  62.         printf(“%d: “, i);  
  63.         p = *(edge+i);  
  64.         while(p != NULL)  
  65.         {  
  66.             printf(“%d “, p->vertex);  
  67.             p = p->next;  
  68.         }  
  69.         printf(“\n”);  
  70.     }  
  71. }  
  72.   
  73. void createGraph(st_edge** edge, int start, int end)  
  74. {  
  75.     st_edge* newedge = (st_edge*)malloc(sizeof(st_edge));  
  76.     newedge->vertex = end;  
  77.     newedge->next = NULL;  
  78.     edge = edge + start;  
  79.     while(*edge != NULL)  
  80.         edge = &((*edge)->next);  
  81.     *edge = newedge;  
  82. }  
  83.   
  84.   
  85. void bfscore(st_edge** edge, int i, int *vertexStatusArr)  
  86. {  
  87.     putQueue(i);  
  88.     int *qeValue = NULL;  
  89.     while((qeValue = getQueue()) != NULL)  
  90.     {  
  91.         if(vertexStatusArr[*qeValue] == 0)  
  92.         {  
  93.             vertexStatusArr[*qeValue] = 1;  
  94.             printf(“%d “, *qeValue);  
  95.             st_edge *p = *(edge + *qeValue);  
  96.             while(p != NULL)  
  97.             {  
  98.                 putQueue(p->vertex);  
  99.                 p = p->next;  
  100.             }  
  101.         }  
  102.         free(qeValue);  
  103.         qeValue = NULL;  
  104.     }  
  105. }  
  106.   
  107. void bfs(st_edge** edge, int* vertexStatusArr)  
  108. {  
  109.     printf(“BFS: “);  
  110.     int i;  
  111.     for(i=0;i<VERTEXNUM;i++)  
  112.         bfscore(edge, i, vertexStatusArr);  
  113.     printf(“\n”);  
  114. }  
  115.   
  116. int main()  
  117. {  
  118.     st_edge** edge = (st_edge**)malloc(sizeof(st_edge*)*VERTEXNUM);  
  119.     int i;  
  120.     for(i=0;i<VERTEXNUM;i++)  
  121.         edge[i] = NULL;  
  122.   
  123.     int *vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);  
  124.     for(i=0;i<VERTEXNUM;i++)  
  125.         vertexStatusArr[i] = 0;  
  126.   
  127.     createGraph(edge, 0 ,3);  
  128.     createGraph(edge, 0, 4);  
  129.     createGraph(edge, 3, 1);  
  130.     createGraph(edge, 3, 2);  
  131.     createGraph(edge, 4, 1);  
  132.   
  133.     display(edge);  
  134.     bfs(edge, vertexStatusArr);  
  135.   
  136.     return 1;  
  137. }  
    原文作者：数据结构之图
    原文地址: https://blog.csdn.net/ojshilu/article/details/12905679
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞