java数据结构----图的基本操作

java数据结构----图的基本操作

 实验四、图的基本操作

一、实验目的

1、熟练掌握图的邻接矩阵和邻接表存储结构；

2、掌握图的创建方法；

3、掌握求顶点度的方法；

4、掌握图的深度优先和广度优先遍历方法；

二、实验内容

1、分别定义图的邻接矩阵和邻接表存储结构；

2、分别在两种存储结构下根据输入的顶点和边（或弧）创建图；

3、分别在两种存储结构下实现求顶点度的操作；

3、分别在两种存储结构下实现图的深度和广度优先遍历算法。

三、实验环境

eclipse环境

四、实验步骤

1、定义图的存储结构

2、实现图的创建方法，并创建一个如下的图：

3、实现求第一个邻接点firstAdjVex()和下一个邻接点nextAdjVex()的操作；

4、写一个算法，求各个顶点的度；

5、对创建的图进行深度优先和广度优先遍历。

五、问题讨论

1、图的邻接矩阵和邻接表的存储结构各有什么特点？

2、对于稀疏图和稠密图分别选择邻接矩阵和邻接表中的哪个存储更合适？

六、实验报告内容

1、实验目的

2、实验内容和具体要求

3、完成情况和实验记录，实验记录为实验过程中遇到的问题及解决方法

4、程序清单

5、所输入的数据及相应的运行结果

6、问题讨论回答

7、实验心得

pre：图分两种存储结构，矩阵存储和链式存储，此处矩阵存储较易（老师说真正的矩阵存储很难），链式稍难，与树类似（存储时用到链式结构）。

code:

邻接矩阵存储法：

package DSexp4;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class GraphByMatrix<Anytype extends Comparable> {

	int size;
	boolean g[][]=new boolean[100][100],vis[]=new boolean[100];
	int id[]=new int[100],od[]=new int[100];
	Queue<Integer>q=new LinkedList<Integer>();
//	Anytype[]vertex=(Anytype[])new Comparable[100];
	Vertex<Anytype> vv[];
	public GraphByMatrix(int s,Anytype v[],boolean g[][]){
		this.size=s;
		vv=new Vertex[1000];
		for(int i=0;i<size;i++){
//			vertex[i]=v[i];
			vv[i]=new Vertex<Anytype>(v[i]);
		}
		for(int i=0;i<size;i++){
			for(int j=0;j<size;j++){
				this.g[i][j]=g[i][j];
			}
		}
	}
	public int firstAdjVex(int v){
		for(int i=0;i<size;i++){
			if(g[v][i])return i;
		}
		return -1;
	}
	public int nextAdjVex(int v,int u){
		if(g[v][u])
		for(int i=u+1;i<size;i++){
			if(g[v][i])return i;
		}
		return -1;
	}
	public void indegreeCounting(){
		for(int i=0;i<size;i++){
			for(int j=0;j<size;j++){
				id[i]+=g[j][i]?1:0;
			}
		}
	}
	public void outdegreeCounting(){
		for(int i=0;i<size;i++){
			for(int j=0;j<size;j++){
				od[i]+=g[i][j]?1:0;
			}
		}
	}
	public void bfs(){
		for(int i=0;i<size;i++){
			vis[i]=false;
		}
		q.clear();
		for(int i=0;i<size;i++){
			if(!vis[i])bfs(i);
		}
	}
	public void bfs(int v){
		if(vis[v])return;
		q.add(v);
		while(!q.isEmpty()){
			for(int i=0;i<size;i++){
				if(vis[i]||!g[q.peek()][i])continue;
				q.add(i);
				System.out.println(vv[i].data);
				vis[i]=true;
			}
			q.remove();
		}
	}
	public void dfs(){
		for(int i=0;i<size;i++){
			vis[i]=false;
		}
		for(int i=0;i<size;i++){
			if(!vis[i])dfs(i);
		}
	}
	public void dfs(int v){
		if(vis[v])return;
		for(int i=0;i<size;i++){
			if(vis[i]||!g[v][i])continue;
			System.out.println(vv[i].data);
			vis[i]=true;
			dfs(i);
		}
	}
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int n=in.nextInt();
		Integer[]v=new Integer[100];
		for(int i=0;i<n;i++){
			v[i]=in.nextInt();
		}
		boolean g[][]=new boolean[100][100];
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				g[i][j]=in.nextInt()==0?false:true;
			}
		}
		GraphByMatrix<Integer> gbm=new GraphByMatrix<Integer>(n,v,g);
		System.out.println("ŽËÍŒ¹²ÓÐ"+n+"žöœáµã");
		System.out.println("œÚµãÄÚÈÝΪ£º");
		String s="";
		for(int i=0;i<gbm.size;i++){
			s+=(Integer)gbm.vv[i].data+" ";
		}
		System.out.println(s);
		gbm.bfs();
		gbm.indegreeCounting();
		gbm.outdegreeCounting();
		System.out.println("入度：");
		s="";
		for(int i=0;i<gbm.size;i++){
			s+=gbm.id[i]+" ";
		}
		System.out.println(s+"\n出度：");
		s="";
		for(int i=0;i<gbm.size;i++){
			s+=gbm.od[i]+" ";
		}
		System.out.println(s);
	}

}
class Vertex<Anytype>{
	Anytype data;
	public Vertex(Anytype d){
		this.data=d;
	}
}
/*
4
1 5 7 9
1 0 0 0
0 0 1 0
1 1 0 1
0 0 0 0
*/

邻接链表存储法：

package DSexp4;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class GraphByList<Anytype> {
	VertexL<Anytype> v[]=new VertexL[100];
	int size;
	Queue<Integer>q=new LinkedList<Integer>();
	public GraphByList(int s,Anytype v[],boolean g[][]){
		this.size=s;
		for(int i=0;i<size;i++){
			this.v[i]=new VertexL(v[i]);
			for(int j=0;j<size;j++)
				if(g[i][j]){
					Arc a=this.v[i].firstArc=new Arc(j);
					for(;j<size;j++){
						if(g[i][j]){
							a.nextArc=new Arc(j);
							a=a.nextArc; 
						}
					}
				}
		}
	}
	public int firstAdjVex(int v){
		return this.v[v].firstArc.vex;
	}
	public int nextAdjVex(int u,int v){
		Arc a=this.v[u].firstArc;
		if(a==null)return -1;
		for(int i=0;i<size;i++){
			if(a.vex==v){
				a=a.nextArc;
				break;
			}
			a=a.nextArc;
		}
		if(a==null)return -1;
		else return a.vex;
	}
	public void indegreeCounting(){
		for(int i=0;i<size;i++){
			this.v[i].indegree=0;
			System.out.println("现在求节点"+i+"的入度");
			for(int j=0;j<size;j++){
				Arc a=this.v[j].firstArc;
				while(a!=null){
					if(a.vex==i){this.v[i].indegree++;System.out.println("加了");break;}
					System.out.println("求入度时的出点："+j);
					a=a.nextArc;
				}
			}
		}
	}
	public void outdegreeCounting(){
		for(int i=0;i<size;i++){
			this.v[i].outdegree=0;
			Arc a=this.v[i].firstArc;
			while(a!=null&&a.nextArc!=null){
				this.v[i].outdegree++;
				a=a.nextArc;
			}
		}
	}
	public void bfs(){
		for(int i=0;i<size;i++){
			this.v[i].vis=false;
		}
		for(int i=0;i<size;i++){
			if(!v[i].vis)bfs(i);
		}
	}
	public void bfs(int v){
		if(this.v[v].vis)return;
//		for(int i=0;i<size;i++){
//			if(this.v[i].vis)continue;
//			this.v[i].vis=true;
//			Arc a=this.v[i].firstArc;
//			while(a!=null){
//				q.add(a.vex);
//			}
//		}
		q.add(v);
		while(!q.isEmpty()){
			Arc a=this.v[q.peek()].firstArc;
			while(a!=null){
				q.add(a.vex);
				a=a.nextArc;
			}
			System.out.println(this.v[q.remove()].data);
		}
	}
	public void dfs(){
		for(int i=0;i<size;i++){
			this.v[i].vis=false;
		}
		for(int i=0;i<size;i++){
			if(!this.v[i].vis)dfs(i);
		}
	}
	public void dfs(int v){
		if(this.v[v].vis)return;
		Arc a=this.v[v].firstArc;
		System.out.println(this.v[v].data);
		while(a!=null){
			if(this.v[a.vex].vis){
				a=a.nextArc;
			}
			else{
				this.v[a.vex].vis=true;
				System.out.println(this.v[a.vex].data);
				dfs(a.vex);
			}
		}
	}
//	public class VertexL{
//		Anytype data;
//		Arc firstArc;
//		int indegree,outdegree;
//		boolean vis;
//		public VertexL(Anytype d,Arc a){
//			this.data=d;
//			this.firstArc=a;
//		}
//	}
//	public class Arc{
//		int vex;
//		Arc nextArc;
//		public Arc(int v){
//			vex=v;
//		}
//	}
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int n=in.nextInt();
		Integer[]v=new Integer[100];
		for(int i=0;i<n;i++){
			v[i]=in.nextInt();
		}
		boolean g[][]=new boolean[100][100];
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				g[i][j]=in.nextInt()==0?false:true;
			}
		}
		GraphByList<Integer> gbl=new GraphByList<Integer>(n,v,g);
		System.out.println("此图有"+n+"个节点");
		System.out.println("分别是：");
		String s="";
		for(int i=0;i<gbl.size;i++){
			s+=gbl.v[i].data+" ";
		}
		System.out.println(s);
		gbl.dfs();
		gbl.indegreeCounting();
		gbl.outdegreeCounting();
		System.out.println("入度：");
		s="";
		for(int i=0;i<gbl.size;i++){
			s+=gbl.v[i].indegree+" ";
		}
		System.out.println(s+"\n出度：");
		s="";
		for(int i=0;i<gbl.size;i++){
			s+=gbl.v[i].outdegree+" ";
		}
		System.out.println(s);
	}
}
class VertexL<Anytype>{
	Anytype data;
	Arc firstArc;
	int indegree,outdegree;
	boolean vis;
	public VertexL(Anytype d){
		this.data=d;
	}
}
class Arc{
	int vex;
	Arc nextArc;
	public Arc(int v){
		vex=v;
	}
	public Arc(){
		super();
	}
}

PS：再难也不怕，其实心得才是最难的……