基于邻接表的无向图的深度广度遍历实现

原创 2016年08月30日 11:48:00

邻接表,无向图,深度、广度遍历,测试通过

基本构建图的邻接表结构以及深度广度遍历

public class ALGraph {
	AdjList[] vertices;
	int vexNum;
	int arcNum;
	boolean[] visited;
	public ALGraph(int vexNum,int arcNum){
		this.vexNum = vexNum;
		this.arcNum = arcNum;
	}
	//建立有vexNum个结点arcNum条边的无向图的邻接表存储结构
	public void createAlGraph(){
		vertices = new AdjList[vexNum];
		Scanner in1 = new Scanner(System.in);
		visited = new boolean[vexNum];
		for(int i=0;i<vexNum;i++ ){
			//输入顶点的信息
			System.out.print("please input the info of vex");

vertices[i] = new AdjList(in1.next(),null);
		}
		//输入边的信息
		Scanner in2 = new Scanner(System.in);
		for(int k=0;k<arcNum;k++){
			System.out.print("please input the info of arc one:");
			int i=in2.nextInt();
			System.out.print("please input the info of arc two:");
			int j=in2.nextInt();//顶点ij之间存在边,我们要把这条边链上
			//将j链接到i上,由于是无向图,同时将i也链接到j上
			ArcNode nodei = new ArcNode(j,null);
		    ArcNode p = vertices[i].firstArc;
		    if(p==null){
		            vertices[i].firstArc = nodei;
		            nodei.nextarc = null;
		    }
		    else{
		    	while(p.nextarc!=null)
		    		p=p.nextarc;
		    	p.nextarc = nodei;
		    	 nodei.nextarc = null;
		    }
			ArcNode nodej = new ArcNode(i,null);
			p = vertices[j].firstArc;
			if(p==null){
				 vertices[j].firstArc = nodej;
				 nodej.nextarc = null;
		    }
		    else{
		    	while(p.nextarc!=null)
		    		p=p.nextarc;
		    	p.nextarc = nodej;
		    	 nodej.nextarc = null;
		    }
			
		}
	}
	public void visit(AdjList v){
		if(v!=null){System.out.print(MessageFormat.format("结点值为{0}:",v.data));
		System.out.println();
		}
		
	}
	 public void dFS(int k){
		
		if(!visited[k]){
			visit(vertices[k]);
			visited[k]=true;
			for(ArcNode p= vertices[k].firstArc;p!=null;p=p.nextarc){
				int w = p.adjvex;
				if(!visited[w]){
					dFS(w);
				}
			}
			
		}
		
	}
	public void dFSTrave(){
		System.out.print(vexNum);
		for(int i=0;i<vexNum;i++){
			visited[i] = false;
			
		}
		for(int j=0;j<vexNum;j++){
			if(!visited[j]){
				dFS(j);
			}
		}
	}
	public void bFSTrave(){
		
		for(int j=0;j<vexNum;j++){
			visited[j] = false;
		}
		Queue queue = new Queue(100);
		for(int i=0;i<vexNum;i++){
			if(!visited[i]){
				visit(vertices[i]);
				visited[i]=true;
				queue.EnQueue(queue, i);
				while(!queue.isEmpty(queue)){
					int w = queue.DeQueue(queue);
					ArcNode p = vertices[w].firstArc;
					while(p!=null){
						if(p!=null){
							int k = p.adjvex;
							if(!visited[k]){
								visit(vertices[k]);
								visited[k] = true;
								queue.EnQueue(queue, k);
							}
						}
						
						p=p.nextarc;
					}
				}
				
			}
		}
		
	}
	

}

队列结构,主要是用来辅助广度遍历

public class Queue {
	private static int maxSize=100;
	private int[] data;
	private int front;
	private int rear;
	
	public static int getMaxSize() {
		return maxSize;
	}
	public static void setMaxSize(int maxSize) {
		Queue.maxSize = maxSize;
	}
	public int[] getData() {
		return data;
	}
	public void setData(int[] data) {
		this.data = data;
	}
	public int getFront() {
		return front;
	}
	public void setFront(int front) {
		this.front = front;
	}
	public int getRear() {
		return rear;
	}
	public void setRear(int rear) {
		this.rear = rear;
	}
	public 	Queue(int maxSize){
		data = new int[maxSize];
		front = 0;
		rear = 0;
		
	}
	public static boolean isEmpty(Queue q){
		if (q.front==q.rear){
			return true;
		}
		else return false;
		
	}
	public static void EnQueue(Queue q,int node){
		
		if((q.rear+1)%maxSize==q.front){
			System.out.print("队列已经满了");
			return;
			
		}else{
			q.data[q.rear]=node;
			q.rear =( q.rear+1)%maxSize;
		}
		
	}
	public static int DeQueue(Queue q){
		if(isEmpty(q)){
			System.out.print("该队列为空");
			return 0;
			
		}
		else{
			int node = q.data[q.front];
			q.front = (q.front+1)%maxSize;
			return node;
		}
		
	}
	

}

基本存储结构

public class ArcNode {
	public int adjvex;
	public ArcNode nextarc;
	public ArcNode(int adjvex,ArcNode nextarc){
		this.adjvex = adjvex;
		this.nextarc = nextarc;
		
		
	}
	public ArcNode(int adjvex){
		this.adjvex = adjvex;
	}
	

}
public class AdjList {
	public String data;
/*	public ArcNode node;*/
	public ArcNode firstArc;
	public AdjList(String data,ArcNode firstArc){
		this.data = data;
/*		this.node = new ArcNode(Integer.parseInt(data));*/
		this.firstArc = firstArc;
	}

}


版权声明:本文为博主原创文章,未经博主允许不得转载。 举报

相关文章推荐

基于邻接表的无向图的深度广度遍历实现

邻接表,无向图,深度、广度遍历,测试通过 基本构建图的邻接表结构以及深度广度遍历 public class ALGraph { AdjList[] vertices; int vexNum; ...

基于邻接矩阵的无向图的深度广度遍历实现

图的创建及深度广度遍历的代码实现,基于的是邻接矩阵,图这里是无向图,并且两个顶点之间有连接则邻接矩阵非零,如果没有连接则为零 public class Graph { //图的邻接矩阵形式 pri...

精选:深入理解 Docker 内部原理及网络配置

网络绝对是任何系统的核心,对于容器而言也是如此。Docker 作为目前最火的轻量级容器技术,有很多令人称道的功能,如 Docker 的镜像管理。然而,Docker的网络一直以来都比较薄弱,所以我们有必要深入了解Docker的网络知识,以满足更高的网络需求。

Java实现基于邻接表的图的深度和广度遍历

Java实现基于邻接表的图的深度和广度遍历 Graph类: package graph1; import java.util.LinkedList; import graph.Graph....

邻接表-图的遍历-广度和深度优先遍历

数据结构目前学习的基本大概已经完成了,图的讲解也基本结束,本次试验就是图的遍历。   将常用的头文件放在t11.h中   #include"stdio.h" #include"string....

基于邻接矩阵的图的深度和广度遍历

描述输入指定的边数m和顶点数n建立图(无向图),对每个顶点1-n编号并输出从1号顶点深度优先遍历和广度优先遍历的结果(数据保证图是连通的)。 输入首先输入两个正整数n,m分别表示顶点数和边数(1<=n...

C++ 无向图 邻接表创建 广度遍历 深度遍历

花了点时间,写了下 无向图lingjieb

基于邻接矩阵实现图的深度和广度遍历(JAVA实现)

基于邻接矩阵实现图的深度和广度遍历(JAVA实现) package matrix; import java.util.LinkedList; import java.util.Queue; /...

无向图的广度优先遍历---邻接矩阵实现

基本思想: 1、从图中某个顶点V0出发,并访问此顶点; 2、从V0出发,访问V0的各个未曾访问的邻接点W1,W2,…,Wk;然后,依次从W1,W2,…,Wk出发访问各自未被访问的邻接点; 3、重复步骤...

图---邻接表(建立,深度遍历,广度遍历)

图的邻接表表示法类似于树的孩子链表表示法。对于图G中的每个顶点vi,该方法把所有邻接于vi的顶点vj链成一个带头结点的单链表,这个单链表就称为顶点vi的邻接表(Adjacency List)。 ...

图(邻接表)的深度、广度优先遍历

/******************************************************************************* * ...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)