图->连通性->无向图的连通分量和生成树

文字描述

　　对无向图进行遍历时，对于连通图，仅需从图中任一顶点出发，进行深度优先搜索或广度优先搜索，便可访问到图中所有顶点。但对非连通图，则需从多个顶点出发搜索，每一次从一个新的起始点出发进行搜索过程得到的顶点访问序列恰为其各个连通分量中的顶点集。

　　对于非连通图,每个连通分量中的顶点集,和遍历时走过的边一起构成若干棵生成树,这些连通分量的生成树组成非连通图的生成森林.

示意图

算法分析

求无向图的连通分量的生成森林的算法时间复杂度和遍历相同.

代码实现

//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
", 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("!以邻接表作为图的存储结构创建无向图!
");
    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	", G.vertices[i].data);
        p = G.vertices[i].firstarc;
        while(p){
            if(p->adjvex != None){
                printf("%d	", p->adjvex);
            }
            p = p->nextarc;
        }
        printf("
");
    }
    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->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->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("
");
    //中根遍历该生成树
    InOrderTraverse(T);printf("
");
    return 0;
}

代码运行