写法：
图的遍历是指按某条搜索路径访问图中每个结点，使得每个结点均被访问一次，而且仅被访问一次。图的遍历有深度遍历算法和广度遍历算法，最近阿杰做了关于图的遍历的算法，下面是图的遍历深度优先的算法（C语言程序）：
#include<stdio.h>#include<malloc.h>
#define MaxVertexNum 5
#define m 5
#define TRUE 1
#define NULL 0
typedef struct node
{
int adjvex
struct node *next
}JD
typedef struct EdgeNode
{
int vexdata
JD *firstarc
}TD
typedef struct
{
TD ag[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=0i<G->ni++)
{
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<=m1j++)
{
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
}
}
}
int visited[MaxVertexNum]
void DFSTraverse(ALGRAPH *G)
{
int i
for(i=0i<G->ni++)
visited[i]=0
for(i=0i<G->ni++)
if(!visited[i])
DFS(G,i)
}
int main()
{
ALGRAPH *G
printf("下面以临接表存储一个图；\n")
creat(G)
printf("下面以深度优先遍历该图 \n")
DFSTraverse(G)
getchar()
}
楼主你好，下面是源程序！
/*/////////////////////////////////////////////////////////////*/
/* 图的深度优先遍历 */
/*/////////////////////////////////////////////////////////////*/
#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 = 0i <numi++ )/* 读取边线信息，插入邻接表*/
{
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 = 1i <= 8i++ ) /* 顶点数组初始化 */
{
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 = 1i <= 8i++ )
{
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 = 0i <numi++ )/* 第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 = 1i <= 8i++ )/*顶点结构数组初始化*/
{
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 = 1i <= 8i++ )
{
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()
}
program graph01{******** 邻接矩阵表示的无向图DFS递归算法 **********}
{******* By DuQinglong 2005.3 *******}
const maxn=20
type graph=record
a:array[1..maxn,1..maxn]of integer
vexn:integer
end
var g:graph
f:array[1..maxn]of boolean {** flag 顶点标记数组 **}
fin,fout:text
i,j:integer
procedure dfs(g:graphi:integer)
var j:integer
begin
write(fout,'V',i:1,' ') {*** 访问顶点i ***}
f[i]:=true
for j:=1 to g.vexn do
if ((not f[j]) and (g.a[i,j]=1)) then dfs(g,j)
end
procedure trav_dfs(g:graph)
var i:integer
begin
fillchar(f,sizeof(f),false) {*** 初始化标记数组 ***}
for i:=1 to g.vexn do
if not f[i] then dfs(g,i)
end
begin
assign(fin,'a.in')
assign(fout,'a.out')
reset(fin)
rewrite(fout)
readln(fin,g.vexn)
for i:=1 to g.vexn do
for j:=1 to g.vexn do
read(fin,g.a[i,j])
close(fin)
trav_dfs(g)
close(fout)
end.
program graph02
{********邻接矩阵表示的无向图DFS非递归算法**********}
const maxn=20
type graph=record
a:array[1..maxn,1..maxn]of integer
vexn:integer
end
var g:graph
f:array[1..maxn]of boolean {**flag**}
stack:array[1..maxn]of integer
fin,fout:text
i,j,top:integer{**** top:栈顶指针 ****}
procedure dfs(g:graphi:integer)
var t:integer
begin
write(fout,'V',i:1,' '){*** 访问顶点i ***}
f[i]:=true {*** 置顶点i访问标记 ***}
top:=1
stack[top]:=i {*** 顶点i入栈 ***}
repeat
t:=1
while ((g.a[stack[top],t]=0)or f[t]) do inc(t)
if (t>g.vexn) then dec(top) {*** 没有满足条件的顶点,则退栈 ***}
else begin
write(fout,'V',t:1,' ')
f[t]:=true
inc(top)
stack[top]:=t
end
until top=0
end
procedure trav_dfs(g:graph)
var i:integer
begin
fillchar(f,sizeof(f),false) {*** 初始化标记数组 ***}
for i:=1 to g.vexn do
if not f[i] then dfs(g,i)
end
begin
assign(fin,'a.in')
assign(fout,'a.out')
reset(fin)
rewrite(fout)
readln(fin,g.vexn)
for i:=1 to g.vexn do
for j:=1 to g.vexn do
read(fin,g.a[i,j])
close(fin)
trav_dfs(g)
close(fout)
end.
program graph03
{******** 邻接表表示的无向图DFs递归算法 **********}
{******* By DuQinglong 2005.3 *******}
const maxn=10
type
datatype=integer
nodep=^node
node=record {*** 邻接表结点 ***}
vertex:1..maxn
next:nodep
end
gnode=record {*** 图中数据结点***}
data:datatype
next:nodep
end
graph=record {*** 图的类型 ***}
a:array[1..maxn]of gnode
vexn:integer
end
var g:graph
f:array[1..maxn]of boolean {**flag**}
fin,fout:text
{*** 输入文件要求：第一行数据为图顶点个数，从第二行开始，第i行第一个数据为第i个结点的数据，
后面的为第i个结点的邻接顶点的编号 ***}
procedure buildadjlist(var g:graph) {*** 建立图的结构，用邻接表表示 ***}
var i,t:integer p,q:nodep k:1..maxn
begin
readln(fin,g.vexn) {*** 读入图的顶点个数 ***}
for i:=1 to g.vexn do
begin
read(fin,g.a[i].data)
g.a[i].next:=nil
t:=0
while not eoln(fin) do{*** 采用尾插法建立链表 ***}
begin
read(fin,k)
t:=t+1
new(p)
p^.vertex:=k
p^.next:=nil
if (t=1) then begin g.a[i].next:=pq:=pend
else begin q^.next:=p q:=p end
end
readln(fin) {*** 文件指针指向下一行 ***}
end
end
procedure dfs(g:graphi:integer) {*** 输出从顶点i开始的连通分量 ***}
var p:nodep
begin
write(fout,'V',i:1,' ')
f[i]:=true
p:=g.a[i].next
while (p<>nil) do
begin
if (not f[p^.vertex]) then dfs(g,p^.vertex)
p:=p^.next
end
end
procedure trav_dfs(g:graph) {*** 访问图中所有顶点 ***}
var i:integer
begin
fillchar(f,sizeof(f),false) {*** 将访问标记数组置为false ***}
for i:=1 to g.vexn do
if (not f[i]) then dfs(g,i)
end
begin
assign(fin,'a.in')
assign(fout,'a.out')
reset(fin)
rewrite(fout)
buildadjlist(g)
close(fin)
trav_dfs(g)
close(fout)
end.
program graph02
{********邻接表表示的无向图DFS 非递归算法**********}
{******* By DuQinglong 2005.3 *******}
const maxn=10
type
datatype=integer
nodep=^node
node=record {*** 邻接表结点 ***}
vertex:1..maxn
next:nodep
end
gnode=record {*** 图中数据结点***}
data:datatype
head:nodep
end
graph=record {*** 图的类型 ***}
a:array[1..maxn]of gnode
vexn:integer
end
var g:graph
f:array[1..maxn]of boolean {**flag**}
stack:array[1..maxn]of integer top:integer
fin,fout:text
{*** 输入文件要求：第一行数据为图顶点个数，从第二行开始，第i行第一个数据为第i个结点的数据，
后面的为第i个结点的邻接顶点的编号 ***}
procedure buildadjlist(var g:graph) {*** 建立图的结构，用邻接表表示 ***}
var i,t:integer p,q:nodep k:1..maxn
begin
readln(fin,g.vexn) {*** 读入图的顶点个数 ***}
for i:=1 to g.vexn do
begin
read(fin,g.a[i].data)
g.a[i].head:=nil
t:=0
while not eoln(fin) do{*** 采用尾插法建立链表 ***}
begin
read(fin,k)
t:=t+1
new(p)
p^.vertex:=k
p^.next:=nil
if (t=1) then begin g.a[i].head:=pq:=pend
else begin q^.next:=p q:=p end
end
readln(fin) {*** 文件指针指向下一行 ***}
end
end
procedure dfs(g:graphi:integer) {*** 输出从顶点i开始的连通分量 ***}
var p:nodep
begin
write(fout,'V',i:1,' ')
f[i]:=true
top:=1 stack[top]:=i
repeat
p:=g.a[stack[top]].head
while (p<>nil)and (f[p^.vertex]) do
p:=p^.next
if p=nil then dec(top)
else begin
i:=p^.vertex
f[i]:=true
write(fout,'V',i:1,' ')
inc(top)
stack[top]:=i
end
until top=0
end
procedure trav_dfs(g:graph) {*** 访问图中所有顶点 ***}
var i:integer
begin
fillchar(f,sizeof(f),false) {*** 将访问标记数组置为false ***}
for i:=1 to g.vexn do
if (not f[i]) then dfs(g,i)
end
begin
assign(fin,'a.in')
assign(fout,'a.out')
reset(fin)
rewrite(fout)
buildadjlist(g)
close(fin)
trav_dfs(g)
close(fout)
end.
program graph05
{******** 邻接矩阵表示的无向图BFS递归算法 **********}
{******* By DuQinglong 2005.3 *******}
const maxn=20
type graph=record
a:array[1..maxn,1..maxn]of integer
vexn:integer
end
var g:graph
f:array[1..maxn]of boolean {**flag**}
qu:array[1..maxn]of integer {**队列**}
fin,fout:text
i,j,front,rear:integer {** front: 队头指针 rear: 队尾指针 **}
procedure bfs(g:graphi:integer)
var j:integer
begin
for j:=1 to g.vexn do
if ((not f[j]) and (g.a[i,j]=1)) then
begin
write(fout,'V',j:1,' '){*** 访问顶点j ***}
f[j]:=true {*** 置顶点访问标记 ***}
inc(rear)
if rear>g.vexn then rear:=1 {*** 保证队列为循环队列 ***}
qu[rear]:=j {*** 顶点j入队 ***}
end
while (front<>rear) do{*** 当队列不为空时，出队 ***}
begin
inc(front)
if front>g.vexn then front:=1
bfs(g,qu[front])
end
end
procedure trav_bfs(g:graph)
var i:integer
begin
fillchar(f,sizeof(f),false)
for i:=1 to g.vexn do
if not f[i] then
begin
write(fout,'V',i:1,' ')
f[i]:=true {*** 置访问标记 ***}
front:=1 rear:=1 {*** 初始化队列 ***}
bfs(g,i)
end
end
begin
assign(fin,'a.in')
assign(fout,'a.out')
reset(fin)
rewrite(fout)
readln(fin,g.vexn)
for i:=1 to g.vexn do
for j:=1 to g.vexn do
read(fin,g.a[i,j])
close(fin)
trav_bfs(g)
close(fout)
end.
program graph06
{******** 邻接矩阵表示的无向图BFS非递归算法 **********}
{******* By DuQinglong 2005.3 *******}
const maxn=20
type graph=record
a:array[1..maxn,1..maxn]of integer
vexn:integer
end
var g:graph
f:array[1..maxn]of boolean {**flag**}
qu:array[1..maxn]of integer {**队列**}
fin,fout:text
i,j,front,rear:integer {** front: 队头指针 rear: 队尾指针 **}
procedure bfs(g:graphi:integer)
var j,t:integer
begin
write(fout,'V',i:1,' ')
f[i]:=true front:=0 rear:=1 qu[rear]:=i
while (front<>rear) do
begin
inc(front) t:=qu[front] {*** 出队 *** 作 ***}
for j:=1 to g.vexn do {*** 邻接顶点入队 ***}
if ((not f[j]) and (g.a[t,j]=1)) then
begin
write(fout,'V',j:1,' ')
f[j]:=true
inc(rear){*** 入队 *** 作 ***}
if rear>g.vexn then rear:=1
qu[rear]:=j
end
end
end
procedure trav_bfs(g:graph)
var i:integer
begin
fillchar(f,sizeof(f),false)
for i:=1 to g.vexn do
if not f[i] then bfs(g,i)
end
begin
assign(fin,'a.in')
assign(fout,'a.out')
reset(fin)
rewrite(fout)
readln(fin,g.vexn)
for i:=1 to g.vexn do
for j:=1 to g.vexn do
read(fin,g.a[i,j])
close(fin)
trav_bfs(g)
close(fout)
end.
program graph07
{******** 邻接表表示的无向图BFs递归算法 **********}
{******* By DuQinglong 2005.3 *******}
const maxn=10
type
datatype=integer
nodep=^node
node=record {*** 邻接表结点 ***}
vertex:1..maxn
next:nodep
end
gnode=record {*** 图中数据结点***}
data:datatype
head:nodep
end
graph=record {*** 图的类型 ***}
a:array[1..maxn]of gnode
vexn:integer
end
var g:graph
f:array[1..maxn]of boolean {**flag**}
qu:array[1..maxn]of integer
front,rear:integer
fin,fout:text
{*** 输入文件要求：第一行数据为图顶点个数，从第二行开始，第i行第一个数据为第i个结点的数据，
后面的为第i个结点的邻接顶点的编号 ***}
procedure buildadjlist(var g:graph) {*** 建立图的结构，用邻接表表示 ***}
var i,t:integer p,q:nodep k:1..maxn
begin
readln(fin,g.vexn) {*** 读入图的顶点个数 ***}
for i:=1 to g.vexn do
begin
read(fin,g.a[i].data)
g.a[i].head:=nil
t:=0
while not eoln(fin) do{*** 采用尾插法建立链表 ***}
begin
read(fin,k)
t:=t+1
new(p)
p^.vertex:=k
p^.next:=nil
if (t=1) then begin g.a[i].head:=pq:=pend
else begin q^.next:=p q:=p end
end
readln(fin) {*** 文件指针指向下一行 ***}
end
end
procedure bfs(g:graphi:integer) {*** 输出从顶点i开始的连通分量 ***}
var p:nodep
begin
p:=g.a[i].head
while (p<>nil) do
begin
if (not f[p^.vertex]) then
begin
write(fout,'V',p^.vertex:1,' ')
f[p^.vertex]:=true
inc(rear)
if (rear>maxn)then rear:=1
qu[rear]:=p^.vertex
end
p:=p^.next
end
while (front<>rear) do
begin
inc(front)
if (front>maxn) then front:=1
bfs(g,qu[front])
end
end
procedure trav_bfs(g:graph) {*** 访问图中所有顶点 ***}
var i:integer
begin
fillchar(f,sizeof(f),false) {*** 将访问标记数组置为false ***}
for i:=1 to g.vexn do
if (not f[i]) then
begin
write(fout,'V',i:1,' ')
f[i]:=truefront:=1 rear:=1
bfs(g,i)
end
end
begin
assign(fin,'a.in')
assign(fout,'a.out')
reset(fin)
rewrite(fout)
buildadjlist(g)
close(fin)
trav_bfs(g)
close(fout)
end.
program graph08
{******** 邻接表表示的无向图BFS非递归算法 **********}
{******* By DuQinglong 2005.3 *******}
const maxn=20
type
datatype=integer
nodep=^node
node=record {*** 邻接表结点 ***}
vertex:1..maxn
next:nodep
end
gnode=record {*** 图中数据结点***}
data:datatype
head:nodep
end
graph=record {*** 图的类型 ***}
a:array[1..maxn]of gnode
vexn:integer
end
var g:graph
f:array[1..maxn]of boolean {**flag**}
qu:array[1..maxn]of integer
front,rear:integer
fin,fout:text
{*** 输入文件要求：第一行数据为图顶点个数，从第二行开始，第i行第一个数据为第i个结点的数据，
后面的为第i个结点的邻接顶点的编号 ***}
procedure buildadjlist(var g:graph) {*** 建立图的结构，用邻接表表示 ***}
var i,t:integer p,q:nodep k:1..maxn
begin
readln(fin,g.vexn) {*** 读入图的顶点个数 ***}
for i:=1 to g.vexn do
begin
read(fin,g.a[i].data)
g.a[i].head:=nil
t:=0
while not eoln(fin) do{*** 采用尾插法建立链表 ***}
begin
read(fin,k)
t:=t+1
new(p)
p^.vertex:=k
p^.next:=nil
if (t=1) then begin g.a[i].head:=pq:=pend
else begin q^.next:=p q:=p end
end
readln(fin) {*** 文件指针指向下一行 ***}
end
end
procedure bfs(g:graphi:integer) {*** 输出从顶点i开始的连通分量 ***}
var p:nodept:integer
begin
write(fout,'V',i:1,' ')
f[i]:=true
front:=0 rear:=1 qu[rear]:=i {*** i入队 ***}
while (front<>rear) do
begin
inc(front) {*** 出队 *** 作 ***}
if front>maxn then front:=1
t:=qu[front]
p:=g.a[t].head
while (p<>nil) do
begin
if not f[p^.vertex] then {*** 邻接顶点未被访问时 ***}
begin
write(fout,'V',p^.vertex:1,' ')
f[p^.vertex]:=true
inc(rear)
if (rear>maxn) then rear:=1
qu[rear]:=p^.vertex
end
p:=p^.next
end
end
end
procedure trav_bfs(g:graph) {*** 访问图中所有顶点 ***}
var i:integer
begin
fillchar(f,sizeof(f),false) {*** 将访问标记数组置为false ***}
for i:=1 to g.vexn do
if (not f[i]) then bfs(g,i)
end
begin
assign(fin,'a.in')
assign(fout,'a.out')
reset(fin)
rewrite(fout)
buildadjlist(g)
close(fin)
trav_bfs(g)
close(fout)
end.
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）