鬼王的兽妃 蛮荒 完结:图的遍历(pascal)程序怎么写

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:graph; i: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:graph; i: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:=p; q:=p; end
else begin q^.next:=p; q:=p; end;
end;
readln(fin); {*** 文件指针指向下一行 ***}
end;
end;
procedure dfs(g:graph; i: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:=p; q:=p; end
else begin q^.next:=p; q:=p; end;
end;
readln(fin); {*** 文件指针指向下一行 ***}
end;
end;
procedure dfs(g:graph; i: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:graph; i: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:graph; i: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:=p; q:=p; end
else begin q^.next:=p; q:=p; end;
end;
readln(fin); {*** 文件指针指向下一行 ***}
end;
end;
procedure bfs(g:graph; i: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]:=true; front:=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:=p; q:=p; end
else begin q^.next:=p; q:=p; end;
end;
readln(fin); {*** 文件指针指向下一行 ***}
end;
end;
procedure bfs(g:graph; i:integer); {*** 输出从顶点i开始的连通分量 ***}
var p:nodep; t: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.

先问一下，你要那种“图”的遍历？有向，无向，简单图……？那种，还是都可以的代码？
还有你用那种方式存图，你都要先说清楚。
procedure dfs ( now,color: integer);
begin
for i:=1 to n do
if a[now,i] and c[i]=0 then begin { 对结点I 染色}
c[i]:=color;
dfs(I,color);
end;
end;