无向图的连通分量

无向图的连通分量

一、对无向图进行遍历时

（一）对于连通图，仅需要从图中任一顶点出发，进行深度优先搜索或广度优先搜索，便可访问到图中所有顶点。

（二）对于非连通图，则需从多个顶点出发进行搜索，而每一次从一个新的起始点出发进行搜索过程中得到的顶点访问序列恰为其各个连通分量中的顶点集。

 

二、连通分量举例

　　　　　　　　　(a) 无向图G3 　　　 　(b) G3的深度优先搜索森林

图7-13

对于图7-13a中的无向图G3，采用深度优先搜索DFS[cl]方法进行遍历，当从A出发可以访问到的顶点序列依次为A、L、M、J、B、F、C。这个过程调用了DFS一次；接着从D出发遍历剩下的顶点，从D出发可以访问的顶点序列为D、E。这个过程又调用了DFS一次；最后从G出发遍历图中的其余顶点K、H、I，这是第三次调用DFS。

因此，对于无向图进行DFS遍历，每一次调用DFS后都得到此非连通图的一个连通分量，调用DFS的次数就是连通分量的个数。

[cpp]  view plain copy

1. /* 
2. 图的深度优先遍历 
3. 出处：一条鱼@博客园 http://www.cnblogs.com/yanlingyin/ 
4. 2011-12-26  
5.  
6. */  
7. #include <stdlib.h>  
8. #include <stdio.h>  
9.   
10. struct node                       /* 图顶点结构定义     */  
11. {  
12.    int vertex;                    /* 顶点数据信息       */  
13.    struct node *nextnode;         /* 指下一顶点的指标   */  
14. };  
15. typedef struct node *graph;       /* 图形的结构新型态   */  
16. struct node head[9];              /* 图形顶点数组       */  
17. int visited[9];                   /* 遍历标记数组       */  
18. int id[9];                        /*标记连通分量的编号*/  
19. int count = 0;                    /*连通分量编号*/  
20. /********************根据已有的信息建立邻接表********************/  
21. void creategraph(int node[12][2],int num)/*num指的是图的边数*/  
22. {  
23.    graph newnode;                 /*指向新节点的指针定义*/  
24.    graph ptr;  
25.    int from;                      /* 边的起点          */  
26.    int to;                        /* 边的终点          */  
27.    int i;  
28.    for ( i = 0; i < num; i++ )    /* 读取边线信息，插入邻接表*/  
29.    {  
30.       from = node[i][0];         /*    边线的起点            */  
31.       to = node[i][1];           /*   边线的终点             */  
32.         
33.    /* 建立新顶点 */  
34.       newnode = ( graph ) malloc(sizeof(struct node));  
35.       newnode->vertex = to;        /* 建立顶点内容       */  
36.       newnode->nextnode = NULL;    /* 设定指标初值       */  
37.       ptr = &(head[from]);         /* 顶点位置           */  
38.       while ( ptr->nextnode != NULL ) /* 遍历至链表尾   */  
39.          ptr = ptr->nextnode;     /* 下一个顶点         */  
40.       ptr->nextnode = newnode;    /* 插入节点        */  
41.    }  
42. }  
43.   
44. /**********************  图的深度优先搜寻法********************/  
45. void dfs(node head[9],int current){/*非递归深度优先遍历算法*/  
46.     node* p;  
47.     node* stack[9];  
48.     int top=-1,vertex;  
49.     printf("%d\t",current);  
50.     visited[current] = 1;  
51.     stack[++top] = head[current].nextnode;  
52.     id[current] = count;  
53.     while(top > -1){  
54.         p = stack[top];  
55.         while(p != NULL){  
56.             vertex = p->vertex;  
57.             if(visited[vertex] == 0){  
58.                 printf("%d\t",vertex);  
59.                 visited[vertex] = 1;  
60.                 id[vertex] = count;  
61.                 stack[++top] = head[vertex].nextnode;  
62.             }  
63.             p = p->nextnode;  
64.         }  
65.         if(p == NULL){  
66.             top--;  
67.         }  
68.     }  
69. }  
70. /**********************判断两点是否连通********************/  
71. bool connect(int v ,int w){         /**/  
72.     return id[v] == id[w];  
73. }  
74. /**********************连通编号********************/  
75. int _id(int v){  
76.     return id[v];  
77. }  
78. /**********************连通分量个数********************/  
79. int _count(){  
80.     return count;  
81. }  
82. /****************************** 主程序******************************/  
83. int main()  
84. {  
85.    graph ptr;  
86.    int node[12][2] = { {1, 2}, {2, 1},  /* 边线数组     */  
87.                        {1, 3}, {3, 1},  
88.                        //{1, 4}, {4, 1},  
89.                        //{2, 5}, {5, 2},  
90.                        //{2, 6}, {6, 2},  
91.                        //{3, 7}, {7, 3},  
92.                        {4, 7}, {4, 4},  
93.                        {5, 8}, {8, 5},  
94.                        {6, 7}, {7, 6},  
95.                        {7, 8}, {8, 7} };  
96.    int i;  
97.    //clrscr();  
98.    for ( i = 1; i <= 8; i++ )      /*   顶点数组初始化  */  
99.    {  
100.       head[i].vertex = i;         /*    设定顶点值      */  
101.       head[i].nextnode = NULL;    /*       指针为空     */  
102.       visited[i] = 0;             /* 设定遍历初始标志   */  
103.    }  
104.    creategraph(node,12);          /*    建立邻接表      */  
105.    printf("Content of the gragh's ADlist is:\n");  
106.    for ( i = 1; i <= 8; i++ )  
107.    {  
108.       printf("vertex%d ->",head[i].vertex); /* 顶点值    */  
109.       ptr = head[i].nextnode;             /* 顶点位置   */  
110.       while ( ptr != NULL )       /* 遍历至链表尾       */  
111.       {  
112.          printf(" %d ",ptr->vertex);  /* 印出顶点内容   */  
113.          ptr = ptr->nextnode;         /* 下一个顶点     */  
114.       }  
115.       printf("\n");               /*   换行             */  
116.    }  
117.    printf("\nThe end of the dfs are:\n");  
118.    for(i=1;i<=8;i++){  
119.         if(visited[i] == 0){  
120.         dfs(head,1);                        /* 打印输出遍历过程   */  
121.         count++;
122. printf("\n");     
123.     }  
124.    }  
125. 
     
126. }