程序设计之图的遍历（c语言实现图的遍历）
本篇文章给大家谈谈程序设计之图的遍历，以及c语言实现图的遍历对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
C++编写程序 关于【图的遍历】
里面多了查找路径功能。
#define t true
#define f false
#includeiostream.h
struct node//定义一个结构作为节点类型
{
int data;
bool sign;//标志位,用来标示是否遍历过
node *next;
};
node* creategraph()//建立邻接表，完成无向图的输入
{
int l,m,n;
bool g;
cout"请输入节点数: ";
cinn;
node *adjacencylist=new node[n+1];//动态分配节点数组内存
adjacencylist[0].data=n;//0地址存放的为节点数
adjacencylist[0].next=NULL;
for(int i=1;i=n;i++)//给各顶点域赋初值
{
adjacencylist[i].data=0;
adjacencylist[i].next=NULL;
adjacencylist[i].sign=f;//表示未遍历
}
cout"请依次输入各条边的始点和尾点:（以0表示结束）"endl;
cinl;
if(l!=0)//判断输入边是否结束
g=t;
while(g==t)
{
cinm;
if((l0)(l=n)(m0)(m=n))//判断输入顶点是否正确
{
node *p,*q,*top;
p=(node *)new(node);//分配边的一个顶点内存
p-data=m;
p-next=NULL;
if(adjacencylist[l].next==NULL)//为每个节点创建邻接链表
adjacencylist[l].next=p;
else
{
top=adjacencylist[l].next;
while(top-next!=NULL)
top=top-next;
top-next=p;
}
adjacencylist[l].data++;//统计邻接点的个数
q=(node *)new(node);//分配边的另一个顶点内存
q-data=l;
q-next=NULL;
if(adjacencylist[m].next==NULL)//构建邻接表
adjacencylist[m].next=q;
else
{
top=adjacencylist[m].next;
while(top-next!=NULL)
top=top-next;
top-next=q;
}
adjacencylist[m].data++;//统计邻接点的个数
}
else
cout"边"l"--"m"输入错误！"endl;//错误输入标识
cinl;
if(l==0)//边的输入结束
g=f;
}
return adjacencylist;//返回邻接表
};
void DepthFirstSearch(node *list)//深度优先搜索
{
int m,n=list[0].data,k,*a=new int[n];//设置一个数组用于存放节点
node *p;
cout"采用深度优先搜索："endl;
cout"请输入搜索起始节点：";
cink;
for(int i=0;in;i++)
{
a[i]=k;
list[k].sign=t;
if(i==n-1)
break;
m=0;
while(list[k].sign==t)
{
p=list[k].next;
while(p!=NULL)//找出list[k]链表中的未遍历节点
{
k=p-data;
p=p-next;
if(list[k].sign==f)
break;
}
m++;
if(list[k].sign!=f)//判断是否是p=NULL跳出while循环的
{
if(im)//无节点可回溯
{
cout"该图为非连通图!"endl;
break;
}
else
k=a[i-m]; //回溯
}
}
}
for(i=1;i=n;i++)//恢复原邻接表
list[i].sign=f;
cout"深度优先搜索遍历顺序为:";
for(i=0;in;i++)//输出遍历结果
couta[i]" ";
coutendl;
delete a;//释放动态数组内存
};
void BreadthFirstSearth(node *list)//广度优先搜索
{
int m,r,k,n=list[0].data,*a=new int[n+1];//设置数组存放节点
node *p;
cout"采用广度优先搜索："endl;
cout"请输入搜索起始节点：";
cink;
a[0]=n;
a[1]=k;
list[k].sign=t;//标识遍历的第一个节点
m=0;
r=1;
while(m!=r)
{
m++;
p=list[a[m]].next;
while(p!=NULL)
{
k=p-data;
if(list[k].sign==f)
{
r++;
a[r]=k;//遍历到的节点存入数组
list[k].sign=t;//标识已经遍历过的节点
}
p=p-next;
}
}
for(int i=1;i=n;i++)//恢复原邻接表
list[i].sign=f;
cout"广度优先搜索遍历顺序为: ";
for(i=1;i=n;i++)//输出遍历
couta[i]" ";
coutendl;
delete a;//释放动态数组内存
};
void PathSearth(node *list)//路径搜索
{
int *a,c,d,m,k,n=list[0].data;
cout"请输入起始点：";
cink;
cout"请输入尾节点：";
cinc;
cout"请输入要找的路径长度：";
cind;
d=d+1;
if(dn)
cout"不存在这样的简单路径！"endl;
else
{
a=new int[d];//动态分配数组内存存放路径上的节点
for(int i=0;id;i++)
a[i]=0;
a[0]=k;
node *p;
int x;
list[a[0]].sign=t;
i=1;
while(a[d-1]!=c)
{
while(id)
{
x=1;
p=list[a[i-1]].next;
while(p!=NULL)
{
m=p-data;
if(i==d-1m==a[0]a[0]==c)//路径存在且为回路
{
cout"该路径为一条回路！"endl;
a[i]=m;
i++;
break;
}
if(list[m].sign==f)
{
if(a[i]!=0)
{
if(x==0)//是否为已经判断过的错误路径
{
a[i]=m;
list[a[i]].sign=t;//标识走过节点
i++;
break;
}
if(a[i]==m)//设置错误路径标识
x=0;
}
else
{
a[i]=m;
list[a[i]].sign=t;//标识走过节点
i++;
break;
}
}
p=p-next;
}
if(p==NULL)
{
a[i]=0;
i--;//由此节点往下的路径不存在,回溯
list[a[i]].sign=f; //还原标识符
}
if(i==0)//无法回溯,路径不存在,跳出循环
{
cout"不存在这样的简单路径！"endl;
break;
}
}
if(i==0)//无法回溯,路径不存在,跳出循环
break;
if(a[d-1]!=c)//路径不是所要找的
{
i--; //回溯
if(i=0)
list[a[i]].sign=f;//还原标识符
}
}
if(a[d-1]==c)//判断路径是否找到并输出
{
cout"从节点"k"到节点"c"的一条路径为：";
for(i=0;id-1;i++)//输出路径
couta[i]"-- ";
couta[d-1]endl;
}
delete a;
}
for(int i=1;i=n;i++)//恢复原邻接表
list[i].sign=f;
};
void AdjacencyListDelete(node *list)//释放邻接表的空间
{
node *p,*q;
int n=list[0].data;
for(int i=1;i=n;i++)
{
p=list[i].next;
while(p!=NULL)
{
q=p-next;
delete p;//释放链表节点空间
p=q;
}
}
delete list;//释放邻接表空间
};
void main()
{
node *list;
list=creategraph();//以邻接表的形式建立一个无向图
char a,b;
cout"请选择遍历方法：（d:深度优先搜索;b:广度优先搜索）";
for(int i=1;i2;i++)
{
cina;
switch(a)
{
case 'd':
case 'D': DepthFirstSearch(list);
cout"是否采用广度优先搜索重新遍历？（y:是;n:否）";
cinb;
if((b=='y')||(b=='Y'))
BreadthFirstSearth(list);
break;
case 'b':
case 'B': BreadthFirstSearth(list);
cout"是否采用深度优先搜索重新遍历？（y:是;n:否）";
cinb;
if((b=='y')||(b=='Y'))
DepthFirstSearch(list);
break;
default: cout"输入错误！请重新输入！"endl;
i--;
}
}
while(1)
{
cout"是否搜索路径？（y:是;n:否）";
cina;
if((a=='y')||(a=='Y'))
PathSearth(list);
else if((a=='n')||(a=='N'))
break;
else
cout"输入错误！"endl;
}
AdjacencyListDelete(list);//释放邻接表空间
}
图的遍历（c语言）完整上机代码
//图的遍历算法程序
//图的遍历是指按某条搜索路径访问图中每个结点，使得每个结点均被访问一次，而且仅被访问一次。图的遍历有深度遍历算法和广度遍历算法，程序如下：
#include iostream
//#include malloc.h
#define INFINITY 32767
#define MAX_VEX 20 //最大顶点个数
#define QUEUE_SIZE (MAX_VEX+1) //队列长度
using namespace std;
bool *visited; //访问标志数组
//图的邻接矩阵存储结构
typedef struct{
char *vexs; //顶点向量
int arcs[MAX_VEX][MAX_VEX]; //邻接矩阵
int vexnum,arcnum; //图的当前顶点数和弧数
}Graph;
//队列类
class Queue{
public:
void InitQueue(){
base=(int *)malloc(QUEUE_SIZE*sizeof(int));
front=rear=0;
}
void EnQueue(int e){
base[rear]=e;
rear=(rear+1)%QUEUE_SIZE;
}
void DeQueue(int e){
e=base[front];
front=(front+1)%QUEUE_SIZE;
}
public:
int *base;
int front;
int rear;
};
//图G中查找元素c的位置
int Locate(Graph G,char c){
for(int i=0;iG.vexnum;i++)
if(G.vexs[i]==c) return i;
return -1;
}
//创建无向网
void CreateUDN(Graph G){
int i,j,w,s1,s2;
char a,b,temp;
printf("输入顶点数和弧数:");
scanf("%d%d",G.vexnum,G.arcnum);
temp=getchar(); //接收回车
G.vexs=(char *)malloc(G.vexnum*sizeof(char)); //分配顶点数目
printf("输入%d个顶点.\n",G.vexnum);
for(i=0;iG.vexnum;i++){ //初始化顶点
printf("输入顶点%d:",i);
scanf("%c",G.vexs[i]);
temp=getchar(); //接收回车
}
for(i=0;iG.vexnum;i++) //初始化邻接矩阵
for(j=0;jG.vexnum;j++)
G.arcs[i][j]=INFINITY;
printf("输入%d条弧.\n",G.arcnum);
for(i=0;iG.arcnum;i++){ //初始化弧
printf("输入弧%d:",i);
scanf("%c %c %d",a,b,w); //输入一条边依附的顶点和权值
temp=getchar(); //接收回车
s1=Locate(G,a);
s2=Locate(G,b);
G.arcs[s1][s2]=G.arcs[s2][s1]=w;
}
}
//图G中顶点k的第一个邻接顶点
int FirstVex(Graph G,int k){
if(k=0 kG.vexnum){ //k合理
for(int i=0;iG.vexnum;i++)
if(G.arcs[k][i]!=INFINITY) return i;
}
return -1;
}
//图G中顶点i的第j个邻接顶点的下一个邻接顶点
int NextVex(Graph G,int i,int j){
if(i=0 iG.vexnum j=0 jG.vexnum){ //i,j合理
for(int k=j+1;kG.vexnum;k++)
if(G.arcs[i][k]!=INFINITY) return k;
}
return -1;
}
//深度优先遍历
void DFS(Graph G,int k){
int i;
if(k==-1){ //第一次执行DFS时,k为-1
for(i=0;iG.vexnum;i++)
if(!visited[i]) DFS(G,i); //对尚未访问的顶点调用DFS
}
else{
visited[k]=true;
printf("%c ",G.vexs[k]); //访问第k个顶点
for(i=FirstVex(G,k);i=0;i=NextVex(G,k,i))
if(!visited[i]) DFS(G,i); //对k的尚未访问的邻接顶点i递归调用DFS
}
}
//广度优先遍历
void BFS(Graph G){
int k;
Queue Q; //辅助队列Q
Q.InitQueue();
for(int i=0;iG.vexnum;i++)
if(!visited[i]){ //i尚未访问
visited[i]=true;
printf("%c ",G.vexs[i]);
Q.EnQueue(i); //i入列
while(Q.front!=Q.rear){
Q.DeQueue(k); //队头元素出列并置为k
for(int w=FirstVex(G,k);w=0;w=NextVex(G,k,w))
if(!visited[w]){ //w为k的尚未访问的邻接顶点
visited[w]=true;
printf("%c ",G.vexs[w]);
Q.EnQueue(w);
}
}
}
}
//主函数
void main(){
int i;
Graph G;
CreateUDN(G);
visited=(bool *)malloc(G.vexnum*sizeof(bool));
printf("\n广度优先遍历: ");
for(i=0;iG.vexnum;i++)
visited[i]=false;
DFS(G,-1);
printf("\n深度优先遍历: ");
for(i=0;iG.vexnum;i++)
visited[i]=false;
BFS(G);
printf("\n程序结束.\n");
}
输出结果为（红色为键盘输入的数据，权值都置为1）：
输入顶点数和弧数:8 9
输入8个顶点.
输入顶点0:a
输入顶点1:b
输入顶点2:c
输入顶点3:d
输入顶点4:e
输入顶点5:f
输入顶点6:g
输入顶点7:h
输入9条弧.
输入弧0:a b 1
输入弧1:b d 1
输入弧2:b e 1
输入弧3:d h 1
输入弧4:e h 1
输入弧5:a c 1
输入弧6:c f 1
输入弧7:c g 1
输入弧8:f g 1
广度优先遍历: a b d h e c f g
深度优先遍历: a b c d e f g h
程序结束.
已经在vc++内运行通过，这个程序已经达到要求了呀~
C语言编程 图的创建与遍历
在C语言编程中，图的创建和遍历：
#includestdio.h
#define N 20
#define TRUE 1
#define FALSE 0
int visited[N];
typedef struct /*队列的定义*/
{
int data[N];
int front,rear;
}queue;
typedef struct /*图的邻接矩阵*/
{
int vexnum,arcnum;
char vexs[N];
int arcs[N][N];
}
graph;
void createGraph(graph *g); /*建立一个无向图的邻接矩阵*/
void dfs(int i,graph *g); /*从第i个顶点出发深度优先搜索*/
void tdfs(graph *g); /*深度优先搜索整个图*/
void bfs(int k,graph *g); /*从第k个顶点广度优先搜索*/
void tbfs(graph *g); /*广度优先搜索整个图*/
void init_visit(); /*初始化访问标识数组*/
void createGraph(graph *g) /*建立一个无向图的邻接矩阵*/
{ int i,j;
char v;
g-vexnum=0;
g-arcnum=0;
i=0;
printf("输入顶点序列(以#结束)：
");
while((v=getchar())!='#')
{
g-vexs[i]=v; /*读入顶点信息*/
i++;
}
g-vexnum=i; /*顶点数目*/
for(i=0;ig-vexnum;i++) /*邻接矩阵初始化*/
for(j=0;jg-vexnum;j++)
g-arcs[i][j]=0;
printf("输入边的信息：
");
scanf("%d,%d",i,j); /*读入边i,j*/
while(i!=-1) /*读入i,j为－1时结束*/
{
g-arcs[i][j]=1;
g-arcs[j][i]=1;
scanf("%d,%d",i,j);
}
}
void dfs(int i,graph *g) /*从第i个顶点出发深度优先搜索*/
{
int j;
printf("%c",g-vexs[i]);
visited[i]=TRUE;
for(j=0;jg-vexnum;j++)
if((g-arcs[i][j]==1)(!visited[j]))
dfs(j,g);
}
void tdfs(graph *g) /*深度优先搜索整个图*/
{
int i;
printf("
从顶点%C开始深度优先搜索序列：",g-vexs[0]);
for(i=0;ig-vexnum;i++)
if(visited[i]!=TRUE)
dfs(i,g);
}
void bfs(int k,graph *g) /*从第k个顶点广度优先搜索*/
{
int i,j;
queue qlist,*q;
q=qlist;
q-rear=0;
q-front=0;
printf("%c",g-vexs[k]);
visited[k]=TRUE;
q-data[q-rear]=k;
q-rear=(q-rear+1)%N;
while(q-rear!=q-front)
{
i=q-data[q-front];
q-front=(q-front+1)%N;
for(j=0;jg-vexnum;j++)
if((g-arcs[i][j]==1)(!visited[j]))
{
printf("%c",g-vexs[j]);
visited[j]=TRUE;
q-data[q-rear]=j;
q-rear=(q-rear+1)%N;
}
}
}
void tbfs(graph *g) /*广度优先搜索整个图*/
{
int i;
printf("
从顶点%C开始广度优先搜索序列：",g-vexs[0]);
for(i=0;ig-vexnum;i++)
if(visited[i]!=TRUE)
bfs(i,g);
printf("
");
}
void init_visit() /*初始化访问标识数组*/
{
int i;
for(i=0;iN;i++)
visited[i]=FALSE;
}
int main()
{
graph ga;
int i,j;
createGraph(ga);
printf("无向图的邻接矩阵：
");
for(i=0;iga.vexnum;i++)
{
for(j=0;jga.vexnum;j++)
printf("%3d",ga.arcs[i][j]);
printf("
");
}
init_visit();
tdfs(ga);
init_visit();
tbfs(ga);
return 0;
}
C语言编程，顾名思义，就是用C语言来进行计算机编程工作。
C语言是国际上广泛流行的,很有发展前途的计算机高级语言.它适合作为系统描述语言,即可用来编写系统软件,也可用来编写应用软件.
C语言是一种引用广泛，并且实现灵活的一种计算机编程语言，用C语言编出来的程序，可以在很多平台上运行，可移植性强。具体的C语言编程内容请参加C或者C++等。
C语言 图的遍历
思路：
以邻接表或邻接矩阵为存储结构，实现连通无向图的深度和广度优先遍历。以用户指定的结点为起始点
，分别输出每种遍历下的结点访问序列和相应的生成树的边集。
设图的结点不超过30个，每个结点用一个编号表示。通过输入图的全部边输入一个图，每个边为一个数对
可以对边的输入顺序作出某种限制。注意，生成树和生成边是有向边，端点顺序不能颠倒。
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; i num; 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; i num; 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语言实现图的遍历、程序设计之图的遍历的信息别忘了在本站进行查找喔。
