c语言图的遍历，邻接表存储，深度，广度优先遍历

Posted 2023-04-17

c语言图的遍历，邻接表存储，深度，广度优先遍历代码

参考技术A （1） 图的建立，按采用邻接表作为存储结构。
（2） 从指定顶点出发进行深度优先搜索遍历。
（3） 从指定顶点出发进行广度优先搜索遍历。

#include"stdio.h"
#include"string.h"
#include"stdlib.h"
#include"math.h"

#define MAX_INT 1000
#define MAX_VERTEX_NUM 20
#define MAX_QUEUE_NUMBER 20

typedef struct ArcNode

int adjvex;
double adj;
struct ArcNode *nextarc;
ArcNode;
typedef struct VexNode

char szName[40];
ArcNode *firstarc;
VexNode,AdjList[MAX_VERTEX_NUM];
typedef struct

AdjList vexs;
int vexnum,arcnum;
Net;
//定义队列
typedef struct
int *elem;
int front, rear;
Queue;
void InitQueue(Queue &Q)

Q.elem = new int[MAX_QUEUE_NUMBER];
Q.front = Q.rear = 0;

int EmptyQueue(Queue Q)

if(Q.front==Q.rear)
return 0;
else
return 1;

void DestroyQueue(Queue &Q)
delete []Q.elem;
Q.front = Q.rear = 0;


void EnterQueue(Queue &Q, int e)

if((Q.rear + 1)%MAX_QUEUE_NUMBER != Q.front)
Q.elem[Q.rear ] = e;
else
printf("队列满!\n");
Q.rear = (Q.rear + 1)%MAX_QUEUE_NUMBER;

void LeaveQueue(Queue &Q, int &e)

if(Q.rear != Q.front)
e = Q.elem[Q.front];
else
printf("队列空!\n");
Q.front = (Q.front+1)%MAX_QUEUE_NUMBER;

int LocateVex(Net ga,char *name)

int i;
for(i=0;i<ga.vexnum;i++)
if(strcmp(name,ga.vexs[i].szName)==0)
return i;
return -1;


void crt_net(Net &ga)

ArcNode *p;
char name1[40],name2[40];
int i,j,k;
double w;
printf("请输入顶点数和弧数：");
scanf("%d%d",&ga.vexnum,&ga.arcnum);
printf("请依次输入顶点名：\n");
for(i=0;i<ga.vexnum;i++)

scanf("%s",ga.vexs[i].szName);
ga.vexs[i].firstarc=NULL;

for(k=0;k<ga.arcnum;k++)

printf("请输入相邻的两个定点和权值：");
scanf("%s%s%lf",name1,name2,&w);
i=LocateVex(ga,name1);
j=LocateVex(ga,name2);
p=new ArcNode;
p->adjvex=j;
p->adj=w;
p->nextarc=ga.vexs[i].firstarc;
ga.vexs[i].firstarc=p;



void DFS(Net ga,char *name,int *visited)

int v,w;
ArcNode *p;
v=LocateVex(ga,name);
visited[v]=1;
printf("%s ",ga.vexs[v].szName);
p=ga.vexs[v].firstarc;
while(p!=NULL)

w=p->adjvex;
if(visited[w]==0)
DFS(ga,ga.vexs[w].szName,visited);
p=p->nextarc;



void DFSTravel(Net ga,char *name)

int v,k=0;
int visited[20];
for(v=0;v<ga.vexnum;v++)
visited[v]=0;
for(v=LocateVex(ga,name);k!=2;v=(v+1)%(ga.vexnum-1))

if(v+1==LocateVex(ga,name))
k++;
if(visited[v]==0)
DFS(ga,ga.vexs[v].szName,visited);




void BFSTravel(Net ga,char *name)

ArcNode *p;
int v,w,u,k=0;
Queue Q;
int visited[20];
for(v=0;v<ga.vexnum;v++)
visited[v]=0;
InitQueue(Q);
for(v=LocateVex(ga,name);k!=2;v=(v+1)%(ga.vexnum-1))

if(v+1==LocateVex(ga,name))
k++;
if(visited[v]==0)

visited[v]=1;
printf("%s ",ga.vexs[v].szName);
EnterQueue(Q,v);
while(EmptyQueue(Q)!=0)

LeaveQueue(Q,u);
p=ga.vexs[u].firstarc;
while(p!=NULL)

w=p->adjvex;
if(visited[w]==0)

printf("%s ",ga.vexs[w].szName);
visited[w]=1;
EnterQueue(Q,w);

p=p->nextarc;







void main()

char name[40];
Net ga;
crt_net(ga);
printf("请输入深度优先遍历开始点的名：");
scanf("%s",name);
printf("深度优先遍历：");
DFSTravel(ga,name);
printf("\n");
printf("请输入广度优先遍历开始点的名：");
scanf("%s",name);
printf("广度优先遍历：");
BFSTravel(ga,name);
printf("\n");

本回答被提问者采纳

求图的深度优先遍历程序 c语言版

求一个图的遍历程序 深度或者广度的都行 要C语言版的 最好附截图 谢谢啊

邻接表表示的图：#include"stdio.h"
#include"stdlib.h"#define MaxVertexNum 50 //定义最大顶点数typedef struct node //边表结点
int adjvex; //邻接点域
struct node *next; //链域
EdgeNode;
typedef struct vnode //顶点表结点
char vertex; //顶点域
EdgeNode *firstedge; //边表头指针
VertexNode;
typedef VertexNode AdjList[MaxVertexNum]; //AdjList是邻接表类型
typedef struct
AdjList adjlist; //邻接表
int n,e; //图中当前顶点数和边数
ALGraph; //图类型//=========建立图的邻接表=======
void CreatALGraph(ALGraph *G)

int i,j,k;
char a;
EdgeNode *s; //定义边表结点
printf("Input VertexNum(n) and EdgesNum(e): ");
scanf("%d,%d",&G->n,&G->e); //读入顶点数和边数
fflush(stdin); //清空内存缓冲
printf("Input Vertex string:");
for(i=0;i<G->n;i++) //建立边表

scanf("%c",&a);
G->adjlist[i].vertex=a; //读入顶点信息
G->adjlist[i].firstedge=NULL; //边表置为空表

printf("Input edges,Creat Adjacency List\n");
for(k=0;k<G->e;k++) //建立边表
scanf("%d%d",&i,&j); //读入边（Vi，Vj）的顶点对序号
s=(EdgeNode *)malloc(sizeof(EdgeNode)); //生成边表结点
s->adjvex=j; //邻接点序号为j
s->next=G->adjlist[i].firstedge;
G->adjlist[i].firstedge=s; //将新结点*S插入顶点Vi的边表头部
s=(EdgeNode *)malloc(sizeof(EdgeNode));
s->adjvex=i; //邻接点序号为i
s->next=G->adjlist[j].firstedge;
G->adjlist[j].firstedge=s; //将新结点*S插入顶点Vj的边表头部


//=========定义标志向量，为全局变量=======
typedef enumFALSE,TRUE Boolean;
Boolean visited[MaxVertexNum];
//========DFS：深度优先遍历的递归算法======
void DFSM(ALGraph *G,int i)
//以Vi为出发点对邻接链表表示的图G进行DFS搜索
EdgeNode *p;
printf("%c",G->adjlist[i].vertex); //访问顶点Vi
visited[i]=TRUE; //标记Vi已访问
p=G->adjlist[i].firstedge; //取Vi边表的头指针
while(p) //依次搜索Vi的邻接点Vj，这里j=p->adjvex
if(! visited[p->adjvex]) //若Vj尚未被访问
DFSM(G,p->adjvex); //则以Vj为出发点向纵深搜索
p=p->next; //找Vi的下一个邻接点


void DFS(ALGraph *G)

int i;
for(i=0;i<G->n;i++)
visited[i]=FALSE; //标志向量初始化
for(i=0;i<G->n;i++)
if(!visited[i]) //Vi未访问过
DFSM(G,i); //以Vi为源点开始DFS搜索
//==========BFS：广度优先遍历=========
void BFS(ALGraph *G,int k)
//以Vk为源点对用邻接链表表示的图G进行广度优先搜索
int i,f=0,r=0; EdgeNode *p;
int cq[MaxVertexNum]; //定义FIFO队列
for(i=0;i<G->n;i++)
visited[i]=FALSE; //标志向量初始化
for(i=0;i<=G->n;i++)
cq[i]=-1; //初始化标志向量
printf("%c",G->adjlist[k].vertex); //访问源点Vk
visited[k]=TRUE;
cq[r]=k; //Vk已访问，将其入队。注意，实际上是将其序号入队
while(cq[f]!=-1) // 队列非空则执行
i=cq[f]; f=f+1; //Vi出队
p=G->adjlist[i].firstedge; //取Vi的边表头指针
while(p) //依次搜索Vi的邻接点Vj（令p->adjvex=j）
if(!visited[p->adjvex]) //若Vj未访问过
printf("%c",G->adjlist[p->adjvex].vertex); //访问Vj
visited[p->adjvex]=TRUE;
r=r+1; cq[r]=p->adjvex; //访问过的Vj入队

p=p->next; //找Vi的下一个邻接点

//endwhile

//==========主函数===========
void main()

//int i;
ALGraph *G;
G=(ALGraph *)malloc(sizeof(ALGraph));
CreatALGraph(G);
printf("Print Graph DFS: ");
DFS(G);
printf("\n");
printf("Print Graph BFS: ");
BFS(G,3);
printf("\n");
邻接矩阵表示的图：
#include"stdio.h"
#include"stdlib.h"
#define MaxVertexNum 100 //定义最大顶点数
typedef struct
char vexs[MaxVertexNum]; //顶点表
int edges[MaxVertexNum][MaxVertexNum]; //邻接矩阵，可看作边表
int n,e; //图中的顶点数n和边数e
MGraph; //用邻接矩阵表示的图的类型
//=========建立邻接矩阵=======
void CreatMGraph(MGraph *G)

int i,j,k;
char a;
printf("Input VertexNum(n) and EdgesNum(e): ");
scanf("%d,%d",&G->n,&G->e); //输入顶点数和边数
scanf("%c",&a);
printf("Input Vertex string:");
for(i=0;i<G->n;i++)

scanf("%c",&a);
G->vexs[i]=a; //读入顶点信息，建立顶点表

for(i=0;i<G->n;i++)
for(j=0;j<G->n;j++)
G->edges[i][j]=0; //初始化邻接矩阵
printf("Input edges,Creat Adjacency Matrix\n");
for(k=0;k<G->e;k++) //读入e条边，建立邻接矩阵
scanf("%d%d",&i,&j); //输入边（Vi，Vj）的顶点序号
G->edges[i][j]=1;
G->edges[j][i]=1; //若为无向图，矩阵为对称矩阵；若建立有向图，去掉该条语句


//=========定义标志向量，为全局变量=======
typedef enumFALSE,TRUE Boolean;
Boolean visited[MaxVertexNum];
//========DFS：深度优先遍历的递归算法======
void DFSM(MGraph *G,int i)
//以Vi为出发点对邻接矩阵表示的图G进行DFS搜索，邻接矩阵是0，1矩阵
int j;
printf("%c",G->vexs[i]); //访问顶点Vi
visited[i]=TRUE; //置已访问标志
for(j=0;j<G->n;j++) //依次搜索Vi的邻接点
if(G->edges[i][j]==1 && ! visited[j])
DFSM(G,j); //（Vi，Vj）∈E，且Vj未访问过，故Vj为新出发点

void DFS(MGraph *G)

int i;
for(i=0;i<G->n;i++)
visited[i]=FALSE; //标志向量初始化
for(i=0;i<G->n;i++)
if(!visited[i]) //Vi未访问过
DFSM(G,i); //以Vi为源点开始DFS搜索

//===========BFS：广度优先遍历=======
void BFS(MGraph *G,int k)
//以Vk为源点对用邻接矩阵表示的图G进行广度优先搜索
int i,j,f=0,r=0;
int cq[MaxVertexNum]; //定义队列
for(i=0;i<G->n;i++)
visited[i]=FALSE; //标志向量初始化
for(i=0;i<G->n;i++)
cq[i]=-1; //队列初始化
printf("%c",G->vexs[k]); //访问源点Vk
visited[k]=TRUE;
cq[r]=k; //Vk已访问，将其入队。注意，实际上是将其序号入队
while(cq[f]!=-1) //队非空则执行
i=cq[f]; f=f+1; //Vf出队
for(j=0;j<G->n;j++) //依次Vi的邻接点Vj
if(!visited[j] && G->edges[i][j]==1) //Vj未访问
printf("%c",G->vexs[j]); //访问Vj
visited[j]=TRUE;
r=r+1; cq[r]=j; //访问过Vj入队



//==========main=====
void main()

//int i;
MGraph *G;
G=(MGraph *)malloc(sizeof(MGraph)); //为图G申请内存空间
CreatMGraph(G); //建立邻接矩阵
printf("Print Graph DFS: ");
DFS(G); //深度优先遍历
printf("\n");
printf("Print Graph BFS: ");
BFS(G,3); //以序号为3的顶点开始广度优先遍历
printf("\n");
参考技术A BFS的基本思想是：首先访问初始点v并将其标志为已经访问。接着通过邻接关系将邻接点入队。然后每访问过一个顶点则出队。按照顺序，访问每一个顶点的所有未被访问过的顶点直到所有的顶点均被访问过。广度优先遍历类似与层次遍历。其特点是尽可能先对横向进行搜索，从指定的出发点，按照该点的路径长度由短到长的顺序访问图中各顶点。下面给出bfs函数代码：void bfs(Graph *g,int vi)

int i,v;
int Q[max],front=0,rear=0;//循环队列
Edgenode *p;
for(i=0;i<g->n;i++)
visited[i]=0; //队列赋初值
visited[vi]=1; //访问初始顶点
printf("--%c--",g->v[vi].c);
rear=(rear+1)% max;
Q[rear]=vi;//初始顶点入队列
while(front!=rear) //队列不为空的时候循环

front=(front+1)%max;
v=Q[front]; //出队列
p=g->v[v].first;//查找v的第一个邻接点
while(p!=NULL)//查找v的所有邻接点

if(visited[p->b]==0)//未访问过则访问之

visited[p->b]=1;
printf("--%c--",g->v[p->b].c);//访问该点并入队
rear=(rear+1)%max;
Q[rear]=p->b;

p=p->next; //查找v的下一邻接点


请仔细理解其中队列的使用。 完整程序：#include<stdio.h>
#define max 6
typedef struct node
int b;
struct node* next;
adjnode; //定义边表节点
typedef struct vertex
int c;
adjnode *first;
vertexnode; //定义顶点
typedef struct graph
vertexnode v[max];
int vertex,edge;
adjgraph; //定义图的结构
int visited[max];
void creatg(adjgraph *g) //初始化创建图

int i,j,e,f;
adjnode *p,*q;
for(i=0;i<5;i++) //这里的4就是vertex的值可以用g->vertex换过来
g->v[i].c=getchar(); g->v[i].first=NULL; //图的顶点赋值这里就是赋的0123
for(j=0;j<5;j++) //这里的5就是edge的值也可换

printf("Please input 邻接边:\n");
scanf("\n%d,%d",&e,&f); //输入邻接边

p=(adjnode *)malloc(sizeof(adjnode));
p->b=f;
p->next=g->v[e].first; //插入领接边的表是从中间插着接的。注意了！
g->v[e].first=p; //注意这两个指针的使用。比较巧妙

q=(adjnode *)malloc(sizeof(adjnode)); //一个图只要输入相应的边即可
q->b=e; //这两个接点将两个顶点的邻接表
q->next=g->v[f].first; //的节点都接上了。注意体会
g->v[f].first=q;


void dispg(adjgraph *g) //输出图，打印出邻接表

int i,j;
adjnode *p;
for(i=0;i<4;i++) //打印4个节点的情况

printf("%c",g->v[i].c);
p=g->v[i].first;
while(p!=NULL)
printf("->%d",p->b);<br> p=p->next;
printf("\n");


void bfs(adjgraph *g,int vi)

int i,v;
int Q[max],front=0,rear=0;//循环队列
adjnode *p;
for(i=0;i<g->vertex;i++)
visited[i]=0; //队列赋初值
visited[vi]=1; //访问初始顶点
printf("--%c--",g->v[vi].c);
rear=(rear+1)% max;
Q[rear]=vi;//初始顶点入队列
while(front!=rear) //队列不为空的时候循环

front=(front+1)%max;
v=Q[front]; //出队列
p=g->v[v].first;//查找v的第一个邻接点
while(p!=NULL)//查找v的所有邻接点

if(visited[p->b]==0)//未访问过则访问之

visited[p->b]=1;
printf("--%c--",g->v[p->b].c);//访问该点并入队
rear=(rear+1)%max;
Q[rear]=p->b;

p=p->next; //查找v的下一邻接点


int main()

adjgraph *g;
g=(adjgraph *)malloc(sizeof(adjgraph));
creatg(g);
dispg(g);
bfs(g,0);
system("pause");
参考技术B #include "stdio.h"
#include "malloc.h"
#define MAX 20int visited[MAX];typedef struct ArcNode
int adjvex;
struct ArcNode *nextarc;
ArcNode;typedef int Vertex;typedef struct VNode
Vertex data;
struct ArcNode *firstarc;
VNode;typedef VNode AdjList[MAX];typedef struct
AdjList adjlist;
int vexnum,arcnum;
ALGraph; CreateDG(ALGraph *G) /*创建邻接表*/
int i,k,j,v1,v2;
ArcNode *p;
printf("shu ru tu de ding dian shu ,hu du:" );
scanf("%d,%d",&G->vexnum,&G->arcnum);
printf("\n");
for(i=0;i<G->vexnum;++i)
G->adjlist[i].firstarc=NULL;
for(k=0;k<G->arcnum;++k)
printf("shu ru di%dtiao de hu wei he hu tou:",k);
scanf("%d,%d",&v1,&v2);
i=v1;j=v2;
p=(ArcNode *)malloc(sizeof(ArcNode));
p->adjvex=j;
p->nextarc=G->adjlist[i].firstarc;
G->adjlist[i].firstarc=p;

DispAdj(ALGraph *G) /*输出邻接表*/
int i;
ArcNode *q;
for(i=0;i<G->vexnum;++i)
q=G->adjlist[i].firstarc;
printf("%d",i);
while(q!=NULL)
printf("->%d",q->adjvex);
q=q->nextarc;

printf("\n");


DFS(ALGraph *G,int v) /*深度优先搜索周游*/
ArcNode *p;
visited[v]=1;
printf("%d ",v);
for(p=G->adjlist[v].firstarc;p!=NULL;)
if(!visited[p->adjvex])
DFS(G,p->adjvex);
p=p->nextarc;


BFS(ALGraph *G,int v) /*广度优先搜索周游*/
int queue[MAX],front=0,rear=0;
int w,i;
ArcNode *u;
for(i=0;i<G->vexnum;++i) visited[i]=0;
visited[v]=1;
printf("%d ",v);
rear=(rear+1)%MAX;
queue[rear]=v;
while(front!=rear)
front=(front+1)%MAX;
w=queue[front];
for(u=G->adjlist[w].firstarc;u!=NULL;)
if(!visited[u->adjvex])
visited[u->adjvex]=1;
printf("%d ",u->adjvex);
rear=(rear+1)%MAX;
queue[rear]=u->adjvex;

u=u->nextarc;


printf("\n");
main() /*主函数*/
int i,j,k;
ALGraph *G;
printf("\n");
G=(ALGraph *)malloc(sizeof(ALGraph));
CreateDG(G);
printf("tu de ling jie biao wei:\n");
DispAdj(G);
printf("\n");
printf("cong ding dian 0 kai shi de shen du sou suo:\n");
DFS(G,0);
printf("\n");
printf("cong ding dian 0 kai shi de guangdu du sou suo:\n");
BFS(G,0);
printf("\n");
getch();