离散数学应用实践

《离散数学应用实践》
实验报告
课序号： 07
学号： 1143041254
姓名：姚发权
任课教师：陈瑜
评阅成绩：
评阅意见：
提交报告时间：2012年 12 月 27 日
实验五：判断图是否是树
（一）问题描述
编写一个程序，从控制台输入一个用邻接矩阵表示的图，程序实现判断该图是不是树，并从控制台输出判断结果。

（二）实验准备
《离散数学》《数据结构》《Java程序设计语言》
开发环境：eclipse
编程语言：Java
（三）算法分析
该程序运用的是定理“T连通且m=n-1”“T连通且无圈”“连通且不含圈的图称为数”《离散数学》P226.
实验中，为图的每个的节点设置一个flag标志，标记每个节点是否被访问过，我用广度遍历从其中一个节点开始沿边遍历，如果图是连通的，那无论从哪个顶点开始遍历，每个顶点都会被访问过，既被访问过的节点数=图的节点数。

这可以证明图是连通的；
接下来，计算出图的边数m；
继而可以判断m是否等于图的节点数n-1；
“T连通且m=n-1”“T连通且无圈”“连通且不含圈的图称为数”
最终证明图是树。

判断连通性，如图：
A a
B b
C c
D d
（1）（2）
图（1）中，图是连通的，无论从哪个节点遍历，都能把整个图遍历了，m=n-1；
图（2）中，图是不连通的，对其的遍历要么只遍历c，要么只遍历了abd，m！=n-1。

计算图的边数，如图
对图的邻接矩阵进行遍历，计算出边的数目m；
（四）程序源代码
import java.util.Scanner;
public class isTree {
private Integer[][] elems;//图的邻接矩阵表示
private Boolean[] flag;//对元素是否被访问进行标记private int vexNum;//图的顶点数
private class Queue//队列
{
private Integer[] qs;
private int capacity;
private int pFront=0;
private int pBack=0;
public Queue(int n)
{
capacity=n;
qs=new Integer[n];
}
public Integer QueueOut()
{
int a= (qs[pFront]).intValue();
pFront=(++pFront)%capacity;
return a;
}
public void QueueIn(int n)
{
pBack=(pBack++)%capacity;
qs[pBack]=new Integer(n);
}
public Boolean isEmpty()
{
return pBack==pFront;
}
}
public void SetElems(Integer[][]elems)
{
this.elems=elems;
}
public void SetThisElems(String s,int i)
{
for(int j=0;j<this.vexNum;j++)
{
elems[i][j]=Integer.parseInt(""+s.charAt(j));
}
}
public void SetNum(int vexNum)
{
this.vexNum=vexNum;
elems=new Integer[vexNum][vexNum];
flag=new Boolean[vexNum];
}
public Integer[][] GetElems()
{
return this.elems;
}
public Boolean[] GetFlag()
{
return this.flag;
}
public int GetVexNum()
{
return this.vexNum;
}
public void BFSTraverse()//对图的广度遍历
{
Queue qu=new Queue(this.vexNum);
qu.QueueIn(0);
while(!qu.isEmpty())
{
//System.out.println("x");
int a=qu.QueueOut();
flag[a]=true;
for(int i=0;i<this.vexNum;i++)
{
if(flag[i]!=true&&elems[a][i]==1)
{
qu.QueueIn(i);
}
//System.out.println(i);
}
}
}
public int GetEdgeNum()//返回一个图的边数{
int num=0;
for(int i=0;i<this.vexNum;i++)
{
for(int j=0;j<this.vexNum;j++)
{
if(this.elems[i][j]!=0)num++;
}
return num/2;
}
public boolean IsConnectedGraph()//判断一个图是否连通{
int n=0;
BFSTraverse();
for(int i=0;i<this.vexNum;i++)
{
if(this.flag[i]=true)n++;
}
return n==this.vexNum;
}
public boolean IsTree()
{
boolean b=IsConnectedGraph();
int n=GetEdgeNum();
return b&&(n==this.vexNum-1);
}
public isTree() {
// TODO Auto-generated constructor stub
elems=new Integer[20][20];
flag=new Boolean[20];
vexNum=20;
}
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
isTree e=new isTree();
System.out.printf("请输入图中节点的数目：\n");
@SuppressWarnings("resource")
Scanner input=new Scanner(System.in);
String is=input.nextLine();
int n=Integer.parseInt(is);
e.SetNum(n);
System.out.printf("请输入用邻接矩阵表示的图("+e.GetVexNum()+"x"+e.GetVexNum()+"):\n");
for(int i=0;i<e.GetVexNum();i++)
{
e.SetThisElems(input.nextLine(), i);
}
System.out.printf("您输入的图是树吗？"+(e.IsTree()?"是的！\n":"不是！
\n"));
}
}
（五）测试数据与运行结果
测试数据：
i.是树的图：
01000
10111
01000
01000
01000 ii.不是数的图：
01100
10111
11000
01000
01000实验结果：
i.是树的图：
ii.不是树的图：
（六）算法复杂性分析与讨论
“T连通且m=n-1”“T连通且无圈”
这次试验的理论难点在于程序理论依据，既：
“连通且不含圈的图称为数”的证明。

实现难点在于图的遍历（本实验用了广度遍历）。

本程序的空间复杂度:图的邻接矩阵的存储n^2,flag的存储n，既空间复杂度O（n^2）；时间复杂度为O（n^2）。