图的深度和广度遍历 - 实验报告

实验报告

一、实验目的和内容

1.实验目的

掌握图的邻接矩阵的存储结构；实现图的两种遍历：深度优先遍历和广度优先遍历。

2.实验内容

1．图的初始化；

2．图的遍历：深度优先遍历和广度优先遍历。

二、实验方案

程序主要代码：

///

///邻接矩阵的节点数据

///

public struct ArcCell

{

public int Type; //顶点的关系类型，对无权图，用1或0表示相邻；

//对带权图，则为权值类型。

public object Data; //该弧相关信息

public ArcCell(int type,object data)

{

Type = type;

Data = data;

}

}

///

///图的类型

///

public enum GKind {DG,DN,UDG,UDN}; //有向图，有向网，无向图，无向网

///

///图类

///

public class Graph

{

public static int Max_Vertex_Num = 20; //最大顶点数

private object [] Vexs; //顶点数据数组

private ArcCell [,] Arcs; //邻接矩阵

private GKind Kind; //图的种类

private int VexNum,ArcNum; //当前顶点数和弧数

///

///图的初始化方法

///

///顶点数

///弧数

///图的类型

public Graph(int vexnum,int arcnum,GKind k)

{

VexNum = vexnum;

ArcNum = arcnum;

Kind = k;

Vexs = new object[Max_Vertex_Num];

Arcs = new ArcCell[Max_Vertex_Num,Max_Vertex_Num];

}

///

///设置v1，v2之间的弧的权值，顶点的关系类型，对无权图，用1或0表示相邻；

///对带权图，则为权值类型。

///

///顶点1

///顶点2

///权

///成功返回真，否则返回假

public bool SetArcInfo(int v1,int v2,int adj,object data)

{

if(v1

{

Arcs[v1,v2].Type = adj;

Arcs[v1,v2].Data = data;

switch(Kind)

{

case GKind.DG:

break;

case GKind.UDG:

Arcs[v2,v1].Type = adj;

Arcs[v2,v1].Data = data;

break;

case GKind.DN:

break;

case GKind.UDN:

break;

}

return true;

}

else

return false;

}

///

///设置指定顶点的信息

///

///顶点号

///要设置的信息

///成功返回真，否则返回假

public bool SetVexInfo(int v,object info)

{

if(v

{

Vexs[v] = info;

return true;

}

else

return false;

}

///

///返回v的第一个邻接顶点，若没有则返回-1

///

public int FirstAdjVex(int v)

{

for(int j=0;j

{

if((this.Arcs[v,j].Type>0)&&(this.Arcs[v,j].Type

return j;

}

}

return -1;

}

//指定节点vex的(相对于Fvex)下一个邻接顶点，若没有则返回-1

public int NextAdjVex(int vex,int Fvex)

{

for(int j=0;j

{

if((this.Arcs[vex,j].Type>0)&&(this.Arcs[vex,j].TypeFvex))

{

return j;

}

}

return -1;

}

public static bool [] visited; //访问标志数组

///

///深度遍历，递归算法

///

public string DFSTraverse()

{

visited = new bool[this.VexNum]; //初始化访问标志数组

string str ="";

for(int v=0;v

{

visited[v] = false;

}

for(int v=0;v

{

if(!visited[v])

str +=DFS(v);

}

return str;

}

///

///从第v个顶点出发递归地深度优先遍历

///

public string DFS(int v)

{

string str ="";

visited[v] = true;

str +=" "+ this.Vexs[v];

for(int i=FirstAdjVex(v);i>=0;i=NextAdjVex(v,i))

if(!visited[i])

str +=DFS(i);

return str;

}

///

///深度优先遍历，非递归算法

///

public string DFSTrav()

{

visited = new bool[this.VexNum]; //初始化访问标志数组

string str ="";

for(int v=0;v

{

visited[v] = false;

}

System.Collections.Stack st = new Stack(); //初始化辅助栈

for(int v=0;v

{

if(!visited[v])

{

visited[v] = true;

str +=" "+this.Vexs[v];

st.Push(v); //v入栈

while(st.Count>0)

{

int u = (int)st.Pop();

for(int w=FirstAdjVex(u);w>=0;w=NextAdjVex(u,w))

{

if(!visited[w])

{

visited[w] = true;

str +=" "+this.Vexs[w];

st.Push(w);

break;

}

}

}

}

}

return str;

}

///

///广度优先遍历，非递归算法

///

public string BFSTraverse()

{

visited = new bool[this.VexNum]; //初始化访问标志数组

string str ="";

for(int v=0;v

{

visited[v] = false;

}

System.Collections.Queue Q = new Queue(); //初始化辅助队列for(int v=0;v

{

if(!visited[v])

{

visited[v] = true;

str +=" "+this.Vexs[v];

Q.Enqueue(v); //v入队列

while(Q.Count>0)

{

int u = (int)Q.Dequeue();

for(int w=FirstAdjVex(u);w>=0;w=NextAdjVex(u,w))

{

if(!visited[w])

{

visited[w] = true;

str +=" "+this.Vexs[w];

Q.Enqueue(w);

}

}

}

}

}

return str;

}

///

///显示邻接矩阵

///

public string Display()

{

string graph = "";

for(int i=0;i

{

for(int j=0;j

{

graph +=" "+ this.Arcs[i,j].Type;

}

graph +="\n";

}

return graph;

}

}

///

///应用程序的主入口点。

///

[STAThread]

static void Main(string[] args)

{

string a="";

while(true)

{

Graph g = new Graph(8,9,GKind.UDG);

g.SetArcInfo(0,1,1,0);

g.SetArcInfo(0,2,1,0);

g.SetArcInfo(1,3,1,0);

g.SetArcInfo(1,4,1,0);

g.SetArcInfo(2,5,1,0);

g.SetArcInfo(2,6,1,0);

g.SetArcInfo(3,7,1,0);

g.SetArcInfo(4,7,1,0);

g.SetArcInfo(5,6,1,0);

g.SetVexInfo(0,"V1");

g.SetVexInfo(1,"V2");

g.SetVexInfo(2,"V3");

g.SetVexInfo(3,"V4");

g.SetVexInfo(4,"V5");

g.SetVexInfo(5,"V6");

g.SetVexInfo(6,"V7");

g.SetVexInfo(7,"V8");

System.Console.WriteLine(" 8顶点，9弧无向图的邻接矩阵：\n");

System.Console.Write(g.Display());

System.Console.WriteLine("\n 深度优先遍历(递归算法)：\n");

System.Console.WriteLine(g.DFSTraverse());

System.Console.WriteLine("\n 深度优先遍历(非递归算法)：

\n");

System.Console.WriteLine(g.DFSTrav());

System.Console.WriteLine("\n 广度优先遍历(非递归算法)：\n");

System.Console.WriteLine(g.BFSTraverse());

System.Console.WriteLine("\n 输入：exit ，退出程序");

a = System.Console.ReadLine();

if(a =="exit")

break;

if(a.Trim().Length ==0 )

continue;

System.Console.WriteLine("

------------------------------------------------------\n");

}

}

三、实验数据、结果分析

程序运行结果：

图如下：

理论结果如下：

深度优先遍历：V1 –> V2 -> V4 -> V8 -> V5 -> V3 -> V6 -> V7 广度优先遍历：V1 –> V2 -> V3 -> V4 -> V5 -> V6 -> V7 -> V8

实验结果与理论结果一致。

四、总结

图的遍历类似树的遍历，但图的遍历要比树的遍历要复杂得多。因图的任一顶点都可能与其余的顶点相邻接。

遍历包括：深度优先遍历和广度优先遍历。

图的遍历算法是求解图的连通性问题、拓扑排序和求关键路径等算法的基础。

五、教师意见