圖->連通性->無向圖的連通分量和生成樹

文字描述

　　對無向圖進行遍歷時，對於連通圖，僅需從圖中任一頂點出發，進行深度優先搜索或廣度優先搜索，便可訪問到圖中所有頂點。但對非連通圖，則需從多個頂點出發搜索，每一次從一個新的起始點出發進行搜索過程得到的頂點訪問序列恰為其各個連通分量中的頂點集。

　　對於非連通圖,每個連通分量中的頂點集,和遍歷時走過的邊一起構成若干棵生成樹,這些連通分量的生成樹組成非連通圖的生成森林.

示意圖

 

算法分析

求無向圖的連通分量的生成森林的算法時間復雜度和遍歷相同.

代碼實現

//1.建立無向圖
//2.建立無向圖的深度優先生成森林, 森林轉換成二叉樹結構,並采用孩子兄弟鏈表存儲
//https://www.cnblogs.com/tgycoder/p/5048898.html
//https://blog.csdn.net/qq_16234613/article/details/77431043

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

///for debug start///
#include <stdarg.h>
#define DEBUG(args...) debug_(__FILE__, __FUNCTION__, __LINE__, ##args)
void debug_(const char* file, const char* function, const int line, const char *format, ...)
{
    char buf[1024] = {0};
    sprintf(buf, "[%s,%s,%d]", file, function, line);

    va_list list;
    va_start(list, format);
    vsprintf(buf+strlen(buf), format, list);
    va_end(list);

    printf("%s\n", buf);

}
///for debug end///

#define INFINITY        100000
#define MAX_VERTEX_NUM    20
#define None -1
typedef enum {DG, DN, UDG, UDN} GraphKind;
typedef char VertexType;
typedef struct{char note[10];}InfoType;
//弧結點
typedef struct ArcNode{
    int adjvex;//該弧所指向的頂點的位置
    struct ArcNode *nextarc;//指向下一條弧的結點
    InfoType *info;//與該弧相關的其他信息
}ArcNode;
typedef struct VNode{
    VertexType data;//頂點信息
    ArcNode *firstarc;//指向第一條依附該頂點的弧的指針
}VNode, AdjList[MAX_VERTEX_NUM];

typedef struct{
    AdjList vertices;//存放圖的頭結點的鏈表
    int vexnum;//圖的頂點數
    int arcnum;//圖的弧數
    int kind;//圖類型
}ALGraph;

//返回圖G中頂點信息委v的頂點位置
int LocateVex(ALGraph G, VertexType v)
{
    int i = 0;
    for(i=0; i<G.vexnum; i++){
        if(G.vertices[i].data == v){
            return i;
        }
    }
    return -1;
}

//返回圖G的頂點位置為loc的頂點信息
VertexType GetVex(ALGraph G, int loc)
{
    return G.vertices[loc].data;
}

//在鏈表L的頭部插入頂點v
int InsFirst(ArcNode *L, int v)
{
    ArcNode *n = (ArcNode *)malloc(sizeof(struct ArcNode));
    n->adjvex = v;
    n->nextarc = L->nextarc;
    L->nextarc = n;
    return 0;
}

//返回圖G中與頂點v相連的第一個頂點在圖中的位置
int FirstAdjVex(ALGraph G, int v)
{
    return G.vertices[v].firstarc->nextarc->adjvex;
}

//返回圖G中與頂點v相鄰的w的下一個相鄰的定點在圖中的位置
int NextAdjVex(ALGraph G, int v, int w)
{
    ArcNode *arc = G.vertices[v].firstarc;
    while(arc && arc->adjvex != w){
        arc = arc->nextarc;
    }
    if(arc && arc->nextarc){
        return arc->nextarc->adjvex;
    }
    return None;
}

//創建一個無向圖
int CreateUDG(ALGraph *G){
    printf("!以鄰接表作為圖的存儲結構創建無向圖!\n");
    G->kind = UDG;
    int i = 0, j = 0, k = 0, IncInfo = 0;
    int v1 = 0, v2 = 0;
    char tmp[10] = {0};
    printf("輸入頂點數，弧數:");
    scanf("%d,%d", &G->vexnum, &G->arcnum);
    for(i=0; i<G->vexnum; i++){
        printf("輸入第%d個頂點: ", i+1);
        memset(tmp, 0, sizeof(tmp));
        scanf("%s", tmp);
        G->vertices[i].data = tmp[0];
        G->vertices[i].firstarc = malloc(sizeof(struct ArcNode));
        G->vertices[i].firstarc->adjvex = None;
        G->vertices[i].firstarc->nextarc = NULL;
    }
    for(k=0; k<G->arcnum; k++){
        printf("輸入第%d條弧(頂點1, 頂點2): ", k+1);
        memset(tmp, 0, sizeof(tmp));
        scanf("%s", tmp);
        sscanf(tmp, "%c,%c", (char *)&v1, (char *)&v2);
        i = LocateVex(*G, v1);
        j = LocateVex(*G, v2);
        InsFirst(G->vertices[i].firstarc, j);
        InsFirst(G->vertices[j].firstarc, i);
        if(IncInfo){}
    }
    return 0;
}

//打印無向圖G的鄰接表信息
void printALG(ALGraph G)
{
    int i = 0;
    ArcNode *p = NULL;
    for(i=0; i<G.vexnum; i++){
        printf("%c\t", G.vertices[i].data);
        p = G.vertices[i].firstarc;
        while(p){
            if(p->adjvex != None){
                printf("%d\t", p->adjvex);
            }
            p = p->nextarc;
        }
        printf("\n");
    }
    return;
}

typedef VertexType TElemType;
//采用孩子兄弟鏈表存儲結構
typedef struct{
    TElemType data;
    struct CSNode *firstchild;
    struct CSNode *nextsibling;
}CSNode, *CSTree;

//先根遍歷樹T
void PreOrderTraverse(CSTree T){
    if(T){
        printf("%c\t", T->data);
        PreOrderTraverse((CSTree)T->firstchild);
        PreOrderTraverse((CSTree)T->nextsibling);
        return ;
    }else{
        return ;
    }
}

//中根遍歷樹T
void InOrderTraverse(CSTree T){
    if(T){
        InOrderTraverse((CSTree)T->firstchild);
        printf("%c\t", T->data);
        InOrderTraverse((CSTree)T->nextsibling);
        return ;
    }else{
        return ;
    }
}

int visited[MAX_VERTEX_NUM];
CSTree DFSTree_q = NULL;
int ISFirst = 1;
//從第v個頂點出發深度優先遍歷圖G，建立以T為根的生成樹
void DFSTree(ALGraph G, int V, CSTree *T)
{
    int w = 0;
    CSTree p = NULL;
    visited[V] = 1;
    for(w=FirstAdjVex(G, V); w>=0; w=NextAdjVex(G, V, w)){
        if(!visited[w]){
            //分配孩子結點
            p = (CSTree)malloc(sizeof(CSNode));
            p->data = GetVex(G, w);
            p->firstchild = NULL;
            p->nextsibling = NULL;
            if(ISFirst){
                //w是v的第一個未被訪問的鄰接頂點
                ISFirst = 0;
                (*T)->firstchild = (struct CSNode *)p;
            }else{
                //w是v的其它未被訪問的鄰接頂點
                //是上一個鄰接頂點的右兄弟結點 
                DFSTree_q->nextsibling = (struct CSNode *)p;
            }
            DFSTree_q = p;
            //從第w個頂點出發深度優先遍歷圖G，建立子生成樹DFSTree_q
            DFSTree(G, w, &DFSTree_q);
        }
    }
}

//建立無向圖G的深度優先生成森林的孩子兄弟鏈表T
void DFSForest(ALGraph G, CSTree *T)
{
    CSTree p = NULL;
    CSTree q = NULL;
    *T = NULL;
    int v = 0;
    for(v=0; v<G.vexnum; v++){
        visited[v] = 0;
    }
    for(v=0; v<G.vexnum; v++){
        if(!visited[v]){
            //第v個頂點為新的生成樹的根結點
            p = (CSTree)malloc(sizeof(CSNode));
            p->data = GetVex(G, v);
            p->firstchild = NULL;
            p->nextsibling = NULL;
            if(!(*T)){
                //是第一顆生成樹的根
                *T = p;
            }else{
                //是其他生成樹的根(前一顆的根的“兄弟”)
                q->nextsibling = (struct CSNode *)p;
            }
            //q指示當前生成樹的根
            q = p;
            //建立以p為根的生成樹
            ISFirst = 1;
            DFSTree(G, v, &p);
        }
    }
}

int main(int argc, char *argv[])
{
    ALGraph G;
    //創建一個無向圖
    CreateUDG(&G);
    //打印無向圖中的信息
    printALG(G);
    
    CSTree T;
    //依照無向圖G，建立一顆生成森林，並將其轉換成成二叉樹存儲，二叉樹以孩子兄弟鏈表存儲結構存儲
    DFSForest(G, &T);
    //先根遍歷該生成樹
    PreOrderTraverse(T);printf("\n");
    //中根遍歷該生成樹
    InOrderTraverse(T);printf("\n");
    return 0;
}

代碼運行