图的邻接表存储 深度优先遍历 广度优先遍历 C语言实现

2023年11月28日 424次阅读 来源: 数据结构之图

ALGraph.h

view plain

  1. #pragma once  
  2. #include “Queue.h”  
  3. /************************************************************************/    
  4. /* 图的邻接表存储结构                                                   */    
  5. /************************************************************************/    
  6. #define MaxVertexNum 100    
  7. #define QueueSize 30     
  8.      
  9. bool visited[MaxVertexNum];      
  10. typedef char VertexType;    
  11. typedef int EdgeType;    
  12. typedef struct node     //边表结点    
  13. {    
  14.     int adjvex;         //邻接点域    
  15.     struct node* next;  //域链    
  16.     //若是要表示边上的权,则应增加一个数据域    
  17. }EdgeNode;    
  18. typedef struct vnode    //顶点边结点    
  19. {    
  20.     VertexType vertex;  //顶点域    
  21.     EdgeNode* firstedge;//边表头指针    
  22. }VertexNode;   
  23.    
  24. typedef VertexNode AdjList[MaxVertexNum];   //AdjList是邻接表类型    
  25. typedef struct     
  26. {    
  27.     AdjList adjlist;    //邻接表    
  28.     int n;              //图中当前顶点数  
  29.     int e;              //图中当前边数    
  30. }ALGraph;               //对于简单的应用，无须定义此类型，可直接使用AdjList类型    
  31. ALGraph* initALGraph();   
  32. bool DFS(ALGraph* a, int i);  
  33. bool DFSTraverseM(ALGraph* a);  
  34. bool BFSTraverseM(ALGraph* a);  
  35. bool BFS(ALGraph* a, int i);  

 

 

ALGraph.c

view plain

  1. #include “ALGraph.h”  
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4. ALGraph* initALGraph()       
  5. {  
  6.     ALGraph* a = NULL;  
  7.     EdgeNode* e = NULL;  
  8.     int i, j, k;  
  9.     char v1, v2;      
  10.     printf(“请输入顶点数和边数(输入格式为:顶点数,边数): “);  
  11.     scanf(“%d,%d”, &i, &j);  
  12.     if(i<0 || j<0)  
  13.         return NULL;  
  14.     a = (ALGraph*)malloc(sizeof(ALGraph));  
  15.     if(a == NULL)  
  16.         return NULL;  
  17.     a->n = i;  
  18.     a->e = j;  
  19.            
  20.     for(i=0;  i<a->n; i++)  
  21.     {  
  22.         printf(“请输入顶点信息 每个顶点以回车作为结束: “);  
  23.         fflush(stdin);  
  24.         scanf(“%c”,&(a->adjlist[i].vertex)); // 读入顶点信息       
  25.         a->adjlist[i].firstedge=NULL;            // 点的边表头指针设为空    
  26.     }  
  27.     for(k=0; k<a->e; k++)  
  28.     {  
  29.         printf(“请输入边的信息(输入格式为:i,j): “);  
  30.         fflush(stdin);  
  31.         scanf(“%c,%c”, &v1, &v2);  
  32.         for(i=0; v1!=a->adjlist[i].vertex; i++); //找到顶点对应的存储序号     
  33.         for(j=0; v2!=a->adjlist[j].vertex; j++);//找到顶点对应的存储序号  
  34.           
  35.         e = (EdgeNode*)malloc(sizeof(EdgeNode));  
  36.         e->adjvex = i;  
  37.         e->next = a->adjlist[j].firstedge;  
  38.         a->adjlist[j].firstedge = e;  
  39.         e = (EdgeNode*)malloc(sizeof(EdgeNode));  
  40.         e->adjvex = j;  
  41.         e->next = a->adjlist[i].firstedge;  
  42.         a->adjlist[i].firstedge = e;  
  43.     }  
  44.     return a;  
  45. }      
  46. /************************************************************************/    
  47. /* 深度优先遍历                                                         */    
  48. /************************************************************************/     
  49. bool DFS(ALGraph* a, int i)  
  50. {  
  51.     if(a == NULL)  
  52.         return FALSE;  
  53.     printf(“DFS: node %c:/n”, a->adjlist[i].vertex);  
  54.     visited[i] = TRUE;  
  55.     i = a->adjlist[i].firstedge->adjvex;  
  56.     if(!visited[i])  
  57.         DFS(a, i);  
  58.     return TRUE;  
  59. }  
  60. bool DFSTraverseM(ALGraph* a)  
  61. {  
  62.     int i;  
  63.     if(a == NULL)  
  64.         return FALSE;  
  65.     for(i=0; i<a->n; i++)  
  66.         visited[i] = FALSE;  
  67.     for(i=0; i<a->n; i++)  
  68.         if(!visited[i])  
  69.             DFS(a, i);  
  70.     return TRUE;  
  71. }    
  72. /************************************************************************/    
  73. /* 广度优先遍历(递归实现)                                               */    
  74. /************************************************************************/    
  75. bool BFS(ALGraph* a, int i)  
  76. {  
  77.     int j, k;  
  78.     Queue *q = NULL;  
  79.     EdgeNode *e = NULL;  
  80.     if(a == NULL)  
  81.         return FALSE;  
  82.     q = initQueue();  
  83.     if(!visited[i])  
  84.     {  
  85.         printf(“BFS: node %c/n”, a->adjlist[i].vertex);  
  86.         visited[i] = TRUE;  
  87.     }  
  88.     j = a->adjlist[i].firstedge->adjvex;  
  89.     e = a->adjlist[i].firstedge->next;  
  90.     if(!visited[j])  
  91.     {  
  92.         enQueue(q, j);  
  93.         while(e)  
  94.         {         
  95.             k = e->adjvex;  
  96.             if(!visited[k])  
  97.             {  
  98.                 enQueue(q, e->adjvex);  
  99.                 printf(“BFS: node %c/n”, a->adjlist[k].vertex);  
  100.                 visited[k] = TRUE;  
  101.             }  
  102.             e = e->next;  
  103.         }  
  104.     }  
  105.     while(q->size != 0)  
  106.     {  
  107.         j = deQueue(q);  
  108.         BFS(a, j);  
  109.     }  
  110.       
  111. }  
  112. bool BFSTraverseM(ALGraph* a)  
  113. {  
  114.     int i;  
  115.     if(a == NULL)  
  116.         return FALSE;  
  117.     for(i=0; i<a->n; i++)  
  118.         visited[i] = FALSE;  
  119.     for(i=0; i<a->n; i++)  
  120.         BFS(a, i);  
  121.     return TRUE;  
  122. }  

 

 

 

Queue.h

view plain

  1. #pragma once  
  2. typedef enum{FALSE, TRUE}bool;  
  3. #define CAPACITY 10  
  4. typedef int ElemType;  
  5. typedef struct   
  6. {  
  7.     int front;  
  8.     int rear;  
  9.     int size;  
  10.     ElemType data[CAPACITY];  
  11. }Queue;  
  12. Queue* initQueue();  
  13. ElemType deQueue(Queue* q);  
  14. bool enQueue(Queue* q, ElemType data);  

 

 

Queue.c

view plain

  1. #include “Queue.h”  
  2. #include <stdlib.h>  
  3. #include <string.h>  
  4. /************************************************************************/    
  5. /* 初始化队列                                                            */    
  6. /************************************************************************/    
  7. Queue* initQueue()  
  8. {  
  9.     Queue *q = NULL;  
  10.     q = (Queue*)malloc(sizeof(Queue));  
  11.     if(q == NULL)  
  12.         return NULL;  
  13.       
  14.     memset(q->data, 0, CAPACITY);  
  15.       
  16.     q->front = q->rear = 0;  
  17.     q->size = 0;  
  18.       
  19.     return q;  
  20. }  
  21. /************************************************************************/    
  22. /* 队尾入队                                                             */    
  23. /************************************************************************/  
  24. bool enQueue(Queue* q, ElemType data)  
  25. {  
  26.     if(q == NULL)  
  27.         return FALSE;  
  28.     if(q->size == CAPACITY)  
  29.         return FALSE;  
  30.     q->data[q->rear] = data;  
  31.     q->rear = (q->rear+1) % CAPACITY;  
  32.     q->size++;  
  33.       
  34.     return TRUE;  
  35. }  
  36. /************************************************************************/    
  37. /* 队首出队                                                             */    
  38. /************************************************************************/  
  39. ElemType deQueue(Queue* q)  
  40. {  
  41.     ElemType res;  
  42.     if(q == NULL)  
  43.         exit(0);  
  44.     if(q->size == 0)  
  45.         return FALSE;  
  46.     res = q->data[q->front];  
  47.     q->front = (q->front+1) % CAPACITY;  
  48.     q->size–;  
  49.       
  50.     return res;  
  51. }  

 

 

main.c

view plain

  1. #include “ALGraph.h”  
  2. int main()  
  3. {  
  4.     ALGraph* a = initALGraph();  
  5.     BFSTraverseM(a);  
  6.     return 0;     
  7. }  
    原文作者：数据结构之图
    原文地址: https://blog.csdn.net/eric491179912/article/details/6695160
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞