c语言做图的广度遍历函数 图的广度遍历算法

图的深度/广度优先遍历C语言程序这是我们老师给我们上数据结构课的课件
#include "stdio.h"
typedefintdatatype;/*假定线性表元素的类型为整型*/
#definemaxsize1024/*假定线性表的最大长度为1024*/
# define n 100/* 图的顶点最大个数 */
typedef char VEXTYPE;/* 顶点的数据类型 */
typedef float ADJTYPE;/* 权值类型 */
typedef struct
{ VEXTYPE vexs[n] ;/* 顶点信息数组 */
ADJTYPE arcs[n][n] ; /* 边权数组 */
int num ;/* 顶点的实际个数 */
}GRAPH;
/***********************1 。置空图**********************/
void GraphInit(GRAPH*L)
{
L-num=0;
}
/***********************2 。求结点数**********************/
int GraphVexs(GRAPH*L)
{
return(L-num);
}
/***********************3 。创建图**********************/
void GraphCreate(GRAPH*L)
{
int i,j;
GraphInit(L);
printf("请输入顶点数目:");
scanf("%d",L-num);
printf("请输入各顶点的信息(单个符号):");
for(i=0;iL-num;i)
{
fflush(stdin);
scanf("%c",L-vexs[i]);
}
printf("请输入边权矩阵的信息:");
for(i=0;iL-num;i)
{
for(j=0;jL-num;j)
{
scanf("%f",L-arcs[i][j]);
}
}
printf("图已经创建完毕!");
}
/***********************4 。图的输出**********************/
void GraphOut(GRAPHL)
{
int i,j;
printf("\n图的顶点数目为:%d",L.num);
printf("\n图的各顶点的信息为:\n");
for(i=0;iL.num;i)
printf("%c",L.vexs[i]);
printf("\n图的边权矩阵的信息为:\n");
for(i=0;iL.num;i)
{
for(j=0;jL.num;j)
{
printf("%6.2f ",L.arcs[i][j]);
}
printf("\n");
}
printf("图已经输出完毕!");
}
/***********************5 。图的深度周游**********************/
void DFS(GRAPHg,int qidian,int mark[])
//从第qidian个点出发深度优先周游图g中能访问的各个顶点
{
int v1;
mark[qidian]=1;
printf("%c",g.vexs[qidian]);
for(v1=0;v1g.num;v1)
{
if(g.arcs[qidian][v1]!=0mark[v1]==0)
DFS(g,v1,mark);
}
}
/***********************6 。图的深度周游**********************/
void GraphDFS(GRAPHg)
//深度优先周游图g中能访问的各个顶点
{
int qidian,v,v1,mark[maxsize];
printf("\n深度周游:");
printf("\n请输入起点的下标:");
scanf("%d",qidian);
for(v=0;vg.num;v)
{
mark[v]=0;
}
for(v=qidian;vg.num qidian;v)
{
//printf("v=%d",v);
v1=v%g.num;
if(mark[v1]==0)
DFS(g,v1,mark);
}
}
typedefint DATATYPE;//队列元素的数据类型
typedefstruct
{
DATATYPE data[maxsize]; //队中元素
int front,rear;//队头元素下标、队尾元素后面位置的下标
} SEQQUEUE;
/*****************************************************************************/
void QueueInit(SEQQUEUE *sq)
//将顺序循环队列sq置空(初始化)
{
sq-front=0;
sq-rear=0;
}
/*****************************************************************************/
int QueueIsEmpty(SEQQUEUE sq)
//如果顺序循环队列sq为空,成功返回1,否则返回0
{
if (sq.rear==sq.front)
return(1);
else
return(0);
}
/*****************************************************************************/
int QueueFront(SEQQUEUE sq,DATATYPE *e)
//将顺序循环队列sq的队头元素保存到e所指地址 , 成功返回1,失败返回0
{
if (QueueIsEmpty(sq))
{ printf("queue is empty!\n");return 0;}
else
{ *e=sq.data[(sq.front)]; return 1;}
【c语言做图的广度遍历函数 图的广度遍历算法】}
/*****************************************************************************/
int QueueIn (SEQQUEUE *sq,DATATYPE x)
//将元素x入队列sq的队尾,成功返回1,失败返回0
{
if (sq-front==(sq-rear 1)%maxsize)
{
printf("queue is full!\n");
return 0;
}
else
{
sq-data[sq-rear]=x;
sq-rear=(sq-rear 1)%maxsize;
return(1);
}
}
/*****************************************************************************/
int QueueOut(SEQQUEUE *sq)
//将队列sq队首元素出队列,成功返回1,失败返回0
{
if (QueueIsEmpty(*sq))
{
printf("queue is empty!\n");
return 0;
}
else
{
sq-front=(sq-front 1)%maxsize;
return1;
}
}
/***********************7 。图的广度周游**********************/
void BFS(GRAPH g,int v,int mark[])
//从v出发广度优先周游图g中能访问的各个顶点
{
int v1,v2;
SEQQUEUE q;
QueueInit(q);
QueueIn(q,v);
mark[v]=1;
printf("%c",g.vexs[v]);
while(QueueIsEmpty(q)==0)
{
QueueFront(q,v1);
QueueOut(q);
for(v2=0;v2g.num;v2)
{
if(g.arcs[v1][v2]!=0mark[v2]==0)
{
QueueIn(q,v2);
mark[v2]=1;
printf("%c",g.vexs[v2]);
}
}
}
}
/***********************8 。图的广度周游**********************/
void GraphBFS(GRAPHg)
//深度优先周游图g中能访问的各个顶点
{
int qidian,v,v1,mark[maxsize];
printf("\n广度周游:");
printf("\n请输入起点的下标:");
scanf("%d",qidian);
for(v=0;vg.num;v)
{
mark[v]=0;
}
for(v=qidian;vg.num qidian;v)
{
v1=v%g.num;
if(mark[v1]==0)
BFS(g,v1,mark);
}
}
/***********************主函数**********************/
void main()
{
GRAPH tu;
GraphCreate(tu);
GraphOut(tu);
GraphDFS(tu);
GraphBFS(tu);
}
求大神帮写一个c语言图的深度优先遍历,和广度优先遍历??/*深度优先*/
#includestdio.h
#includestdlib.h
struct node/*图的顶点结构*/
{
int vertex;
int flag;
struct node *nextnode;
};
typedef struct node *graph;
struct node vertex_node[10];
void creat_graph(int *node,int n)
{
graph newnode,p;/*定义一个新结点及指针*/
int start,end,i;
for(i=0;in;i)
{
start=node[i*2];/*边的起点*/
end=node[i*2 1];/*边的终点*/
newnode=(graph)malloc(sizeof(struct node));
newnode-vertex=end;/*新结点的内容为边终点处顶点的内容*/
newnode-nextnode=NULL;
p=(vertex_node);/*设置指针位置*/
while(p-nextnode!=NULL)
p=p-nextnode;/*寻找链尾*/
p-nextnode=newnode;/*在链尾处插入新结点*/
}
}
void dfs(int k)
{
graph p;
vertex_node[k].flag=1;/*将标志位置1,证明该结点已访问过*/
printf("vertex[%d]",k);
p=vertex_node[k].nextnode;/*指针指向下个结点*/
while(p!=NULL)
{
if(vertex_node[p-vertex].flag==0)/*判断该结点的标志位是否为0*/
dfs(p-vertex);/*继续遍历下个结点*/
p=p-nextnode;/*若已遍历过p指向下一个结点*/
}
}
main()
{
graph p;
int node[100],i,sn,vn;
printf("please input the number of sides:\n");
scanf("%d",sn);/*输入无向图的边数*/
printf("please input the number of vertexes\n");
scanf("%d",vn);
printf("please input the vertexes which connected by the sides:\n");
for(i=0;i4*sn;i)
scanf("%d",node[i]);/*输入每个边所连接的两个顶点,起始及结束位置不同,每边输两次*/
for(i=1;i=vn;i)
{
vertex_node[i].vertex=i;/*将每个顶点的信息存入数组中*/
vertex_node[i].nextnode=NULL;
}
creat_graph(node,2*sn);/*调用函数创建邻接表*/
printf("the result is:\n");
for(i=1;i=vn;i)/*将邻接表内容输出*/
{
printf("vertex%d:",vertex_node[i].vertex);/*输出顶点内容*/
p=vertex_node[i].nextnode;
while(p!=NULL)
{
printf("-=",p-vertex);/*输出邻接顶点的内容*/
p=p-nextnode;/*指针指向下个邻接顶点*/
}
printf("\n");
}
printf("the result of depth-first search is:\n");
dfs(1);/*调用函数进行深度优先遍历*/
printf("\n");
}
/***************************广度优先*******************************/
#include stdio.h
#include stdlib.h
struct node
{
int vertex;
struct node *nextnode;
};
typedef struct node *graph;
struct node vertex_node[10];
#define MAXQUEUE 100
int queue[MAXQUEUE];
int front =- 1;
int rear =- 1;
int visited[10];
void creat_graph(int *node, int n)
{
graph newnode, p; /*定义一个新结点及指针*/
int start, end, i;
for (i = 0; in; i)
{
start = node[i *2]; /*边的起点*/
end = node[i *2 1]; /*边的终点*/
newnode = (graph)malloc(sizeof(struct node));
newnode-vertex = end; /*新结点的内容为边终点处顶点的内容*/
newnode-nextnode = NULL;
p = (vertex_node); /*设置指针位置*/
while (p-nextnode != NULL)
p = p-nextnode;
/*寻找链尾*/
p-nextnode = newnode; /*在链尾处插入新结点*/
}
}
int enqueue(int value) /*元素入队列*/
{
if (rear = MAXQUEUE)
return- 1;
rear; /*移动队尾指针*/
queue[rear] = value;
}
int dequeue() /*元素出队列*/
{
if (front == rear)
return- 1;
front; /*移动队头指针*/
return queue[front];
}
void bfs(int k) /*广度优先搜索*/
{
graph p;
enqueue(k); /*元素入队*/
visited[k] = 1;
printf("vertex[%d]", k);
while (front != rear)
/*判断是否对空*/
{
k = dequeue(); /*元素出队*/
p = vertex_node[k].nextnode;
while (p != NULL)
{
if (visited[p-vertex] == 0)
/*判断其是否被访问过*/
{
enqueue(p-vertex);
visited[p-vertex] = 1; /*访问过的元素置1*/
printf("vertex[%d]", p-vertex);
}
p = p-nextnode; /*访问下一个元素*/
}
}
}
main()
{
graph p;
int node[100], i, sn, vn;
printf("please input the number of sides:\n");
scanf("%d", sn); /*输入无向图的边数*/
printf("please input the number of vertexes\n");
scanf("%d", vn);
printf("please input the vertexes which connected by the sides:\n");
for (i = 0; i4 *sn; i)
scanf("%d", node[i]);
/*输入每个边所连接的两个顶点,起始及结束位置不同,每边输两次*/
for (i = 1; i = vn; i)
{
vertex_node[i].vertex = i; /*将每个顶点的信息存入数组中*/
vertex_node[i].nextnode = NULL;
}
creat_graph(node, 2 *sn); /*调用函数创建邻接表*/
printf("the result is:\n");
for (i = 1; i = vn; i)
/*将邻接表内容输出*/
{
printf("vertex%d:", vertex_node[i].vertex); /*输出顶点内容*/
p = vertex_node[i].nextnode;
while (p != NULL)
{
printf("-=", p-vertex); /*输出邻接顶点的内容*/
p = p-nextnode; /*指针指向下个邻接顶点*/
}
printf("\n");
}
printf("the result of breadth-first search is:\n");
bfs(1); /*调用函数进行深度优先遍历*/
printf("\n");
}
用C语言编程实现图的遍历算法图c语言做图的广度遍历函数的遍历是指按某条搜索路径访问图中每个结点,使得每个结点均被访问一次,而且仅被访问一次 。图的遍历有深度遍历算法和广度遍历算法,最近阿杰做c语言做图的广度遍历函数了关于图的遍历的算法,下面是图的遍历深度优先的算法(C语言程序)c语言做图的广度遍历函数:
#includestdio.h
#includemalloc.h
#define MaxVertexNum 5
#define m 5
#define TRUE 1
#define NULL 0
typedefstructnode
{
intadjvex;
structnode*next;
}JD;
typedefstructEdgeNode
{
intvexdata;
JD*firstarc;
}TD;
typedef struct
{
TDag[m];
int n;
}ALGRAPH;
void DFS(ALGRAPH *G,int i)
{
JD *p;
int visited[80];
printf("visit vertex:%d-",G-ag[i].vexdata);
visited[i]=1;
p=G-ag[i].firstarc;
while(p)
{
if (!visited[p-adjvex])
DFS(G,p-adjvex);
p=p-next;
}
}
void creat(ALGRAPH *G)
{
int i,m1,j;
JD *p,*p1;
printf("please input the number of graph\n");
scanf("%d",G-n);
for(i=0;iG-n;i)
{
printf("please input the info of node %d",i);
scanf("%d",G-ag[i].vexdata);
printf("please input the number of arcs which adj to%d",i);
scanf("%d",m1);
printf("please input the adjvex position of the first arc\n");
p=(JD *)malloc(sizeof(JD));
scanf("%d",p-adjvex);
p-next=NULL;
G-ag[i].firstarc=p;
p1=p;
for(j=2 ;j=m1;j)
{
printf("please input the position of the next arc vexdata\n");
p=(JD *)malloc(sizeof(JD));
scanf("%d",p-adjvex);
p-next=NULL;
p1-next=p;
p1=p;
}
}
}
intvisited[MaxVertexNum];
void DFSTraverse(ALGRAPH *G)
{
int i;
for(i=0;iG-n;i)
visited[i]=0;
for(i=0;iG-n;i)
if(!visited[i])
DFS(G,i);
}
int main()
{
ALGRAPH *G;
printf("下面以临接表存储一个图c语言做图的广度遍历函数;\n");
creat(G);
printf("下面以深度优先遍历该图 \n");
DFSTraverse(G);
getchar();
}
图的广度优先遍历的C语言程序(有头文件的)// bo7-2.cpp 图的邻接表存储(存储结构由c7-2.h定义)的基本操作(15个)
int LocateVex(ALGraph G,VertexType u)
{ // 初始条件: 图G存在,u和G中顶点有相同特征
// 操作结果: 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1
int i;
for(i=0;iG.vexnum;i)
if(strcmp(u,G.vertices[i].data)==0)
return i;
return -1;
}
Status CreateGraph(ALGraph G)
{ // 采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造4种图)
int i,j,k;
int w; // 权值
VertexType va,vb;
ArcNode *p;
printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
scanf("%d",G.kind);
printf("请输入图的顶点数,边数: ");
scanf("%d,%d",G.vexnum,G.arcnum);
printf("请输入%d个顶点的值(%d个字符):\n",G.vexnum,MAX_NAME);
for(i=0;iG.vexnum;i) // 构造顶点向量
{
scanf("%s",G.vertices[i].data);
G.vertices[i].firstarc=NULL;
}
if(G.kind==1||G.kind==3) // 网
printf("请顺序输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):\n");
else // 图
printf("请顺序输入每条弧(边)的弧尾和弧头(以空格作为间隔):\n");
for(k=0;kG.arcnum;k) // 构造表结点链表
{
if(G.kind==1||G.kind==3) // 网
scanf("%d%s%s",w,va,vb);
else // 图
scanf("%s%s",va,vb);
i=LocateVex(G,va); // 弧尾
j=LocateVex(G,vb); // 弧头
p=(ArcNode*)malloc(sizeof(ArcNode));
p-adjvex=j;
if(G.kind==1||G.kind==3) // 网
{
p-info=(int *)malloc(sizeof(int));
*(p-info)=w;
}
else
p-info=NULL; // 图
p-nextarc=G.vertices[i].firstarc; // 插在表头
G.vertices[i].firstarc=p;
if(G.kind=2) // 无向图或网,产生第二个表结点
{
p=(ArcNode*)malloc(sizeof(ArcNode));
p-adjvex=i;
if(G.kind==3) // 无向网
{
p-info=(int*)malloc(sizeof(int));
*(p-info)=w;
}
else
p-info=NULL; // 无向图
p-nextarc=G.vertices[j].firstarc; // 插在表头
G.vertices[j].firstarc=p;
}
}
return OK;
}
void DestroyGraph(ALGraph G)
{ // 初始条件: 图G存在 。操作结果: 销毁图G
int i;
ArcNode *p,*q;
G.vexnum=0;
G.arcnum=0;
for(i=0;iG.vexnum;i)
{
p=G.vertices[i].firstarc;
while(p)
{
q=p-nextarc;
if(G.kind%2) // 网
free(p-info);
free(p);
p=q;
}
}
}
VertexType GetVex(ALGraph G,int v)
{ // 初始条件: 图G存在,v是G中某个顶点的序号 。操作结果: 返回v的值
if(v=G.vexnum||v0)
exit(ERROR);
return G.vertices[v].data;
}
Status PutVex(ALGraph G,VertexType v,VertexType value)
{ // 初始条件: 图G存在,v是G中某个顶点
// 操作结果: 对v赋新值value
int i;
i=LocateVex(G,v);
if(i-1) // v是G的顶点
{
strcpy(G.vertices[i].data,value);
return OK;
}
return ERROR;
}
int FirstAdjVex(ALGraph G,VertexType v)
{ // 初始条件: 图G存在,v是G中某个顶点
// 操作结果: 返回v的第一个邻接顶点的序号 。若顶点在G中没有邻接顶点,则返回-1
ArcNode *p;
int v1;
v1=LocateVex(G,v); // v1为顶点v在图G中的序号
p=G.vertices[v1].firstarc;
if(p)
return p-adjvex;
else
return -1;
}
int NextAdjVex(ALGraph G,VertexType v,VertexType w)
{ // 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点
// 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号 。
//若w是v的最后一个邻接点,则返回-1
ArcNode *p;
int v1,w1;
v1=LocateVex(G,v); // v1为顶点v在图G中的序号
w1=LocateVex(G,w); // w1为顶点w在图G中的序号
p=G.vertices[v1].firstarc;
while(pp-adjvex!=w1) // 指针p不空且所指表结点不是w
p=p-nextarc;
if(!p||!p-nextarc) // 没找到w或w是最后一个邻接点
return -1;
else // p-adjvex==w
return p-nextarc-adjvex; // 返回v的(相对于w的)下一个邻接顶点的序号
}
void InsertVex(ALGraph G,VertexType v)
{ // 初始条件: 图G存在,v和图中顶点有相同特征
// 操作结果: 在图G中增添新顶点v(不增添与顶点相关的弧,留待InsertArc()去做)
strcpy(G.vertices[G.vexnum].data,v); // 构造新顶点向量
G.vertices[G.vexnum].firstarc=NULL;
G.vexnum; // 图G的顶点数加1
}
Status DeleteVex(ALGraph G,VertexType v)
{ // 初始条件: 图G存在,v是G中某个顶点
// 操作结果: 删除G中顶点v及其相关的弧
int i,j;
ArcNode *p,*q;
j=LocateVex(G,v); // j是顶点v的序号
if(j0) // v不是图G的顶点
return ERROR;
p=G.vertices[j].firstarc; // 删除以v为出度的弧或边
while(p)
{
q=p;
p=p-nextarc;
if(G.kind%2) // 网
free(q-info);
free(q);
G.arcnum--; // 弧或边数减1
}
G.vexnum--; // 顶点数减1
for(i=j;iG.vexnum;i) // 顶点v后面的顶点前移
G.vertices[i]=G.vertices[i 1];
for(i=0;iG.vexnum;i) // 删除以v为入度的弧或边且必要时修改表结点的顶点位置值
{
p=G.vertices[i].firstarc; // 指向第1条弧或边
while(p) // 有弧
{
if(p-adjvex==j)
{
if(p==G.vertices[i].firstarc) // 待删结点是第1个结点
{
G.vertices[i].firstarc=p-nextarc;
if(G.kind%2) // 网
free(p-info);
free(p);
p=G.vertices[i].firstarc;
if(G.kind2) // 有向
G.arcnum--; // 弧或边数减1
}
else
{
q-nextarc=p-nextarc;
if(G.kind%2) // 网
free(p-info);
free(p);
p=q-nextarc;
if(G.kind2) // 有向
G.arcnum--; // 弧或边数减1
}
}
else
{
if(p-adjvexj)
p-adjvex--; // 修改表结点的顶点位置值(序号)
q=p;
p=p-nextarc;
}
}
}
return OK;
}
Status InsertArc(ALGraph G,VertexType v,VertexType w)
{ // 初始条件: 图G存在,v和w是G中两个顶点
// 操作结果: 在G中增添弧v,w,若G是无向的,则还增添对称弧w,v
ArcNode *p;
int w1,i,j;
i=LocateVex(G,v); // 弧尾或边的序号
j=LocateVex(G,w); // 弧头或边的序号
if(i0||j0)
return ERROR;
G.arcnum; // 图G的弧或边的数目加1
if(G.kind%2) // 网
{
printf("请输入弧(边)%s→%s的权值: ",v,w);
scanf("%d",w1);
}
p=(ArcNode*)malloc(sizeof(ArcNode));
p-adjvex=j;
if(G.kind%2) // 网
{
p-info=(int*)malloc(sizeof(int));
*(p-info)=w1;
}
else
p-info=NULL;
p-nextarc=G.vertices[i].firstarc; // 插在表头
G.vertices[i].firstarc=p;
if(G.kind=2) // 无向,生成另一个表结点
{
p=(ArcNode*)malloc(sizeof(ArcNode));
p-adjvex=i;
if(G.kind==3) // 无向网
{
p-info=(int*)malloc(sizeof(int));
*(p-info)=w1;
}
else
p-info=NULL;
p-nextarc=G.vertices[j].firstarc; // 插在表头
G.vertices[j].firstarc=p;
}
return OK;
}
Status DeleteArc(ALGraph G,VertexType v,VertexType w)
{ // 初始条件: 图G存在,v和w是G中两个顶点
// 操作结果: 在G中删除弧v,w,若G是无向的,则还删除对称弧w,v
ArcNode *p,*q;
int i,j;
i=LocateVex(G,v); // i是顶点v(弧尾)的序号
j=LocateVex(G,w); // j是顶点w(弧头)的序号
if(i0||j0||i==j)
return ERROR;
p=G.vertices[i].firstarc; // p指向顶点v的第一条出弧
while(pp-adjvex!=j) // p不空且所指之弧不是待删除弧v,w
{ // p指向下一条弧
q=p;
p=p-nextarc;
}
if(pp-adjvex==j) // 找到弧v,w
{
if(p==G.vertices[i].firstarc) // p所指是第1条弧
G.vertices[i].firstarc=p-nextarc; // 指向下一条弧
else
q-nextarc=p-nextarc; // 指向下一条弧
if(G.kind%2) // 网
free(p-info);
free(p); // 释放此结点
G.arcnum--; // 弧或边数减1
}
if(G.kind=2) // 无向,删除对称弧w,v
{
p=G.vertices[j].firstarc; // p指向顶点w的第一条出弧
while(pp-adjvex!=i) // p不空且所指之弧不是待删除弧w,v
{ // p指向下一条弧
q=p;
p=p-nextarc;
}
if(pp-adjvex==i) // 找到弧w,v
{
if(p==G.vertices[j].firstarc) // p所指是第1条弧
G.vertices[j].firstarc=p-nextarc; // 指向下一条弧
else
q-nextarc=p-nextarc; // 指向下一条弧
if(G.kind==3) // 无向网
free(p-info);
free(p); // 释放此结点
}
}
return OK;
}
Boolean visited[MAX_VERTEX_NUM]; // 访问标志数组(全局量)
void(*VisitFunc)(char* v); // 函数变量(全局量)
void DFS(ALGraph G,int v)
{ // 从第v个顶点出发递归地深度优先遍历图G 。算法7.5
int w;
VertexType v1,w1;
strcpy(v1,GetVex(G,v));
visited[v]=TRUE; // 设置访问标志为TRUE(已访问)
VisitFunc(G.vertices[v].data); // 访问第v个顶点
for(w=FirstAdjVex(G,v1);w=0;w=NextAdjVex(G,v1,strcpy(w1,GetVex(G,w))))
if(!visited[w])
DFS(G,w); // 对v的尚未访问的邻接点w递归调用DFS
}
void DFSTraverse(ALGraph G,void(*Visit)(char*))
{ // 对图G作深度优先遍历 。算法7.4
int v;
VisitFunc=Visit; // 使用全局变量VisitFunc,使DFS不必设函数指针参数
for(v=0;vG.vexnum;v)
visited[v]=FALSE; // 访问标志数组初始化
for(v=0;vG.vexnum;v)
if(!visited[v])
DFS(G,v); // 对尚未访问的顶点调用DFS
printf("\n");
}
typedef int QElemType; // 队列类型
#include"c3-2.h"
#include"bo3-2.cpp"
void BFSTraverse(ALGraph G,void(*Visit)(char*))
{//按广度优先非递归遍历图G 。使用辅助队列Q和访问标志数组visited 。算法7.6
int v,u,w;
VertexType u1,w1;
LinkQueue Q;
for(v=0;vG.vexnum;v)
visited[v]=FALSE; // 置初值
InitQueue(Q); // 置空的辅助队列Q
for(v=0;vG.vexnum;v) // 如果是连通图,只v=0就遍历全图
if(!visited[v]) // v尚未访问
{
visited[v]=TRUE;
Visit(G.vertices[v].data);
EnQueue(Q,v); // v入队列
while(!QueueEmpty(Q)) // 队列不空
{
DeQueue(Q,u); // 队头元素出队并置为u
strcpy(u1,GetVex(G,u));
for(w=FirstAdjVex(G,u1);w=0;w=NextAdjVex(G,u1,strcpy(w1,GetVex(G,w))))
if(!visited[w]) // w为u的尚未访问的邻接顶点
{
visited[w]=TRUE;
Visit(G.vertices[w].data);
EnQueue(Q,w); // w入队
}
}
}
printf("\n");
}
void Display(ALGraph G)
{ // 输出图的邻接矩阵G
int i;
ArcNode *p;
switch(G.kind)
{
case DG: printf("有向图\n");
break;
case DN: printf("有向网\n");
break;
case AG: printf("无向图\n");
break;
case AN: printf("无向网\n");
}
printf("%d个顶点:\n",G.vexnum);
for(i=0;iG.vexnum;i)
printf("%s ",G.vertices[i].data);
printf("\n%d条弧(边):\n",G.arcnum);
for(i=0;iG.vexnum;i)
{
p=G.vertices[i].firstarc;
while(p)
{
if(G.kind=1) // 有向
{
printf("%s→%s ",G.vertices[i].data,G.vertices[p-adjvex].data);
if(G.kind==DN) // 网
printf(":%d ",*(p-info));
}
else // 无向(避免输出两次)
{
if(ip-adjvex)
{
printf("%s-%s ",G.vertices[i].data,G.vertices[p-adjvex].data);
if(G.kind==AN) // 网
printf(":%d ",*(p-info));
}
}
p=p-nextarc;
}
printf("\n");
}
}
// c7-2.h 图的邻接表存储表示
#define MAX_VERTEX_NUM 20
enum GraphKind{DG,DN,AG,AN}; // {有向图,有向网,无向图,无向网}
struct ArcNode
{
int adjvex; // 该弧所指向的顶点的位置
ArcNode *nextarc; // 指向下一条弧的指针
InfoType *info; // 网的权值指针
}; // 表结点
typedef struct
{
VertexType data; // 顶点信息
ArcNode *firstarc; // 第一个表结点的地址,指向第一条依附该顶点的弧的指针
}VNode,AdjList[MAX_VERTEX_NUM]; // 头结点
struct ALGraph
{
AdjList vertices;
int vexnum,arcnum; // 图的当前顶点数和弧数
int kind; // 图的种类标志
};
// c3-2.h 单链队列--队列的链式存储结构
typedef struct QNode
{
QElemType data;
QNode *next;
}*QueuePtr;
struct LinkQueue
{
QueuePtr front,rear; // 队头、队尾指针
};
// bo3-2.cpp 链队列(存储结构由c3-2.h定义)的基本操作(9个)
Status InitQueue(LinkQueue Q)
{ // 构造一个空队列Q
if(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))
exit(OVERFLOW);
Q.front-next=NULL;
return OK;
}
Status DestroyQueue(LinkQueue Q)
{ // 销毁队列Q(无论空否均可)
while(Q.front)
{
Q.rear=Q.front-next;
free(Q.front);
Q.front=Q.rear;
}
return OK;
}
Status ClearQueue(LinkQueue Q)
{ // 将Q清为空队列
QueuePtr p,q;
Q.rear=Q.front;
p=Q.front-next;
Q.front-next=NULL;
while(p)
{
q=p;
p=p-next;
free(q);
}
return OK;
}
Status QueueEmpty(LinkQueue Q)
{ // 若Q为空队列,则返回TRUE,否则返回FALSE
if(Q.front==Q.rear)
return TRUE;
else
return FALSE;
}
int QueueLength(LinkQueue Q)
{ // 求队列的长度
int i=0;
QueuePtr p;
p=Q.front;
while(Q.rear!=p)
{
i;
p=p-next;
}
return i;
}
Status GetHead(LinkQueue Q,QElemType e)
{ // 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR
QueuePtr p;
if(Q.front==Q.rear)
return ERROR;
p=Q.front-next;
e=p-data;
return OK;
}
Status EnQueue(LinkQueue Q,QElemType e)
{ // 插入元素e为Q的新的队尾元素
QueuePtr p;
if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败
exit(OVERFLOW);
p-data=https://www.04ip.com/post/e;
p-next=NULL;
Q.rear-next=p;
Q.rear=p;
return OK;
}
Status DeQueue(LinkQueue 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;
}
Status QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
{ // 从队头到队尾依次对队列Q中每个元素调用函数vi() 。一旦vi失败,则操作失败
QueuePtr p;
p=Q.front-next;
while(p)
{
vi(p-data);
p=p-next;
}
printf("\n");
return OK;
}
C语言实现图的广度优先搜索遍历算法先写个大题思路c语言做图的广度遍历函数,楼主先自己想想c语言做图的广度遍历函数,想不出来c语言做图的广度遍历函数的话c语言做图的广度遍历函数,2天后给代码 。
queuenode q;
q.push(start);
bool canVisit[][];
node cur;
while(!q.empty()){
cur = q.top();
q.pop();
foreach(node is connected by cur){
if(canVisit[node.x][node.y])
{
printf("访问结点(%d,%d)",node.x,node.y);
canVisit[node.x][node.y]=false;
q.push(node);
}
}
}
C语言编写程序实现图的遍历操作楼主你好,下面是源程序!
/*/////////////////////////////////////////////////////////////*/
/*图的深度优先遍历*/
/*/////////////////////////////////////////////////////////////*/
#include stdlib.h
#include stdio.h
struct node/* 图顶点结构定义*/
{
int vertex;/* 顶点数据信息*/
struct node *nextnode;/* 指下一顶点的指标*/
};
typedef struct node *graph;/* 图形的结构新型态*/
struct node head[9];/* 图形顶点数组*/
int visited[9];/* 遍历标记数组*/
/********************根据已有的信息建立邻接表********************/
void creategraph(int node[20][2],int num)/*num指的是图的边数*/
{
graph newnode;/*指向新节点的指针定义*/
graph ptr;
int from;/* 边的起点*/
int to;/* 边的终点*/
int i;
for ( i = 0; inum; i)/* 读取边线信息,插入邻接表*/
{
from = node[i][0];/*边线的起点*/
to = node[i][1];/*边线的终点*/
/* 建立新顶点 */
newnode = ( graph ) malloc(sizeof(struct node));
newnode-vertex = to;/* 建立顶点内容*/
newnode-nextnode = NULL;/* 设定指标初值*/
ptr = (head[from]);/* 顶点位置*/
while ( ptr-nextnode != NULL ) /* 遍历至链表尾*/
ptr = ptr-nextnode;/* 下一个顶点*/
ptr-nextnode = newnode;/* 插入节点*/
}
}
/**********************图的深度优先搜寻法********************/
void dfs(int current)
{
graph ptr;
visited[current] = 1;/* 记录已遍历过*/
printf("vertex[%d]\n",current);/* 输出遍历顶点值*/
ptr = head[current].nextnode;/* 顶点位置*/
while ( ptr != NULL )/* 遍历至链表尾*/
{
if ( visited[ptr-vertex] == 0 )/* 如过没遍历过 */
dfs(ptr-vertex);/* 递回遍历呼叫 */
ptr = ptr-nextnode;/* 下一个顶点*/
}
}
/****************************** 主程序******************************/
void main()
{
graph ptr;
int node[20][2] = { {1, 2}, {2, 1},/* 边线数组*/
{1, 3}, {3, 1},
{1, 4}, {4, 1},
{2, 5}, {5, 2},
{2, 6}, {6, 2},
{3, 7}, {7, 3},
{4, 7}, {4, 4},
{5, 8}, {8, 5},
{6, 7}, {7, 6},
{7, 8}, {8, 7} };
int i;
clrscr();
for ( i = 1; i = 8; i)/*顶点数组初始化*/
{
head[i].vertex = i;/*设定顶点值*/
head[i].nextnode = NULL;/*指针为空*/
visited[i] = 0;/* 设定遍历初始标志*/
}
creategraph(node,20);/*建立邻接表*/
printf("Content of the gragh's ADlist is:\n");
for ( i = 1; i = 8; i)
{
printf("vertex%d -",head[i].vertex); /* 顶点值*/
ptr = head[i].nextnode;/* 顶点位置*/
while ( ptr != NULL )/* 遍历至链表尾*/
{
printf(" %d ",ptr-vertex);/* 印出顶点内容*/
ptr = ptr-nextnode;/* 下一个顶点*/
}
printf("\n");/*换行*/
}
printf("\nThe end of the dfs are:\n");
dfs(1);/* 打印输出遍历过程*/
printf("\n");/* 换行*/
puts(" Press any key to quit...");
getch();
}
/*//////////////////////////////////////////*/
/*图形的广度优先搜寻法*/
/* ///////////////////////////////////////*/
#include stdlib.h
#include stdio.h
#define MAXQUEUE 10/* 队列的最大容量*/
struct node/* 图的顶点结构定义*/
{
int vertex;
struct node *nextnode;
};
typedef struct node *graph;/*图的结构指针*/
struct node head[9];/* 图的顶点数组*/
int visited[9];/* 遍历标记数组*/
int queue[MAXQUEUE];/* 定义序列数组*/
int front = -1;/* 序列前端*/
int rear = -1;/* 序列后端*/
/***********************二维数组向邻接表的转化****************************/
void creategraph(int node[20][2],int num)
{
graph newnode;/*顶点指针*/
graph ptr;
int from;/* 边起点*/
int to;/* 边终点*/
int i;
for ( i = 0; inum; i)/* 第i条边的信息处理*/
{
from = node[i][0];/* 边的起点*/
to = node[i][1];/* 边的终点*/
/*建立新顶点*/
newnode = ( graph ) malloc(sizeof(struct node));
newnode-vertex = to;/*顶点内容*/
newnode-nextnode = NULL;/* 设定指针初值*/
ptr = (head[from]);/* 顶点位置*/
while ( ptr-nextnode != NULL ) /* 遍历至链表尾*/
ptr = ptr-nextnode;/* 下一个顶点*/
ptr-nextnode = newnode;/* 插入第i个节点的链表尾部 */
}
}
/************************ 数值入队列************************************/
int enqueue(int value)
{
if ( rear = MAXQUEUE )/* 检查伫列是否全满*/
return -1;/* 无法存入*/
rear;/* 后端指标往前移*/
queue[rear] = value;/* 存入伫列*/
}
/************************* 数值出队列*********************************/
int dequeue()
{
if ( front== rear )/* 队列是否为空*/
return -1;/* 为空 , 无法取出*/
front;/* 前端指标往前移*/
return queue[front];/* 从队列中取出信息*/
}
/***********************图形的广度优先遍历************************/
void bfs(int current)
{
graph ptr;
/* 处理第一个顶点 */
enqueue(current);/* 将顶点存入队列*/
visited[current] = 1;/* 已遍历过记录标志置疑1*/
printf(" Vertex[%d]\n",current);/* 打印输出遍历顶点值 */
while ( front != rear )/* 队列是否为空*/
{
current = dequeue();/* 将顶点从队列列取出*/
ptr = head[current].nextnode;/* 顶点位置*/
while ( ptr != NULL )/* 遍历至链表尾*/
{
if ( visited[ptr-vertex] == 0 ) /*顶点没有遍历过*/
{
enqueue(ptr-vertex);/* 奖定点放入队列*/
visited[ptr-vertex] = 1; /* 置遍历标记为1*/
printf(" Vertex[%d]\n",ptr-vertex);/* 印出遍历顶点值 */
}
ptr = ptr-nextnode;/* 下一个顶点*/
}
}
}
/***********************主程序************************************/
/*********************************************************************/
void main()
{
graph ptr;
int node[20][2] = { {1, 2}, {2, 1},/* 边信息数组*/
{6, 3}, {3, 6},
{2, 4}, {4, 2},
{1, 5}, {5, 1},
{3, 7}, {7, 3},
{1, 7}, {7, 1},
{4, 8}, {8, 4},
{5, 8}, {8, 5},
{2, 8}, {8, 2},
{7, 8}, {8, 7} };
int i;
clrscr();
puts("This is an example of Width Preferred Traverse of Gragh.\n");
for ( i = 1; i = 8; i)/*顶点结构数组初始化*/
{
head[i].vertex = i;
head[i].nextnode = NULL;
visited[i] = 0;
}
creategraph(node,20);/* 图信息转换,邻接表的建立 */
printf("The content of the graph's allist is:\n");
for ( i = 1; i = 8; i)
{
printf(" vertex%d =",head[i].vertex); /* 顶点值*/
ptr = head[i].nextnode;/* 顶点位置*/
while ( ptr != NULL )/* 遍历至链表尾*/
{
printf(" %d ",ptr-vertex);/* 打印输出顶点内容*/
ptr = ptr-nextnode;/* 下一个顶点*/
}
printf("\n");/* 换行*/
}
printf("The contents of BFS are:\n");
bfs(1);/* 打印输出遍历过程*/
printf("\n");/* 换行*/
puts(" Press any key to quit...");
getch();
}
c语言做图的广度遍历函数的介绍就聊到这里吧,感谢你花时间阅读本站内容,更多关于图的广度遍历算法、c语言做图的广度遍历函数的信息别忘了在本站进行查找喔 。

    推荐阅读