求助：无向图的连通性判断算法

[erroric]

算法包含以下几个函数：firstadj（G，v）返回G中结点v的第一个邻点，若不存在，则返回0；nextadj（G，v，w）返回图G中结点v的邻结点钟处于w结点之后的结点，若不存在，返回0。给一个执行实例

[苍蝇①号]

自己搞定去

[selooloo]

主要是遍历图
先找一个联通子图，再判断其他的点，边，子图和该图是否联通，有一个不联通就是不连通了

[xdyong2009]

这是我写的一个用邻接表存储判断连通图及连通分量的程序：

#include <stdio.h>
#include <malloc.h>
#include <math.h>
#include <string.h>

typedef int QElemType;
typedef char vertexType[3];
typedef int status;
typedef int Booleam;
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OK 1
#define MAXNUM 10
typedef char InfoType;

Booleam visited[MAXNUM ];
typedef struct ArcNode{
int adjvex;
struct ArcNode *nextarc;
InfoType *info;
}ArcNode;
typedef struct VNode{
vertexType data;
ArcNode *firstarc;
}VNode,adjlist[MAXNUM];
typedef struct{
adjlist vex;
int vexnum,arcnum;
int kind;
}Graph;
typedef struct QNode{
QElemType data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
QueuePtr front;
QueuePtr rear;
}Queue;

status InitQueue(Queue &Q)
{ // 构造一个空队列Q
if(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))
return ERROR;
Q.front->next=NULL;
return OK;
}


status EnQueue(Queue &Q,QElemType e)
{ // 插入元素e为Q的新的队尾元素
QueuePtr p;
if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败
return ERROR;
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return OK;
}
status QueueEmpty(Queue Q)
{ // 若Q为空队列，则返回TRUE，否则返回FALSE
if(Q.front->next==NULL)
return TRUE;
else
return FALSE;
}
status DeQueue(Queue &Q,QElemType &e)
{ // 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR
QueuePtr p;
if(Q.front==Q.rear)
return ERROR;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
free(p);
return OK;
}


void DFS(Graph G,int v)
{
ArcNode *p;
int j;
printf("%s ",G.vex[v].data);
visited[v]=1;
for(p=G.vex[v].firstarc;p;p=p->nextarc)
{
j=p->adjvex;
if(!visited[j])
DFS(G,j);
}
}

void DFSTravel(Graph G)
{

int v;
for(v=0;v<G.vexnum;v++)
visited[v]=0;
for(v=0;v<G.vexnum;v++)
if(!visited[v])
DFS(G,v);
printf("\n");

}

void connected(Graph G)//判断连通图及连通分量
{
int v,count;
for(v=0;v <G.vexnum;v++)
visited[v]=0;
count=0;
for(v=0;v <G.vexnum;v++)
if(!visited[v])
{
count++;
DFS(G,v);
}
if(count==1)
printf("图是连通图\n");
else
printf("图是非连通图，且有%d个连通分量",count);
}


status Locate(Graph G,vertexType e)
{
int i;
for(i=0;i <G.vexnum;i++)
if(strcmp(G.vex[i].data,e)==0)
return i;
return OK;
}

status Create(Graph &G)
{
int i,j,k;ArcNode *p;

vertexType a,b;
printf("请输入顶点数，边数：");
scanf("%d%d",&G.vexnum,&G.arcnum);

printf("\n请输入顶点向量:");
for(i=0;i <G.vexnum;i++)
{
scanf("%s",&G.vex[i].data);
G.vex[i].firstarc=NULL;
}

printf("\n你刚才输入的数据是:");
for(i=0; i<G.vexnum; i++) printf("[%s] ",G.vex[i].data);
printf("\n");

printf("\n请输入边依附两顶点:\n");
for(k=0;k <G.arcnum;k++)
{

scanf("%s%s",a,b);

printf("你输入的是[%s] [%s]\n",a,b);

i=Locate(G,a);
j=Locate(G,b);
p=(ArcNode*)malloc(sizeof(ArcNode));
p->nextarc=G.vex[i].firstarc;
p->adjvex=j;
p->info=NULL;
G.vex[i].firstarc=p;
p=(ArcNode*)malloc(sizeof(ArcNode));
p->nextarc=G.vex[j].firstarc;
p->adjvex=i;
p->info=NULL;
G.vex[j].firstarc=p;
}
return OK;
}


void print(Graph G)
{
int i;
ArcNode *p;
for(i=0;i <G.vexnum;i++)
{
p=G.vex[i].firstarc;
while(p && i <p->adjvex) ///////////////////////////////////
{
printf("\n%s-%s",G.vex[i].data,G.vex[p->adjvex].data);
p=p->nextarc;
}
}
printf("\n");
}


void main()
{
Graph G;
Create(G);
print(G);
printf("深度优先遍历图：\n");
DFSTravel(G);
printf("判断是否是连通图时(深度优先遍历图)：\n");
connected(G);
print(G);
}