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

原创 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;
	}

}


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

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

花了点时间,写了下 无向图lingjieb
  • abyssguru
  • abyssguru
  • 2014年11月24日 17:21
  • 1509

图简介2- 邻接表实现无向图+深度/广度优先搜索

用邻接表实现了一个无向图,在实现时,包含了添加和删除顶点,添加和删除边,size方法(顶点个数),isEmpty方法,广度和深度优先迭代器 1,成员变量,构造方法,数组扩展 pri...
  • mengzhejin
  • mengzhejin
  • 2014年07月15日 18:58
  • 788

无向图的构建及广度优先遍历---邻接表实现

无向图的构建及广度优先遍历---邻接表实现
  • cjc211322
  • cjc211322
  • 2014年03月21日 17:04
  • 1306

无向图邻接表的深度优先遍历(DFS)

邻接表是图的一种链式存储结构。对图的每个顶点建立一个单链表(n个顶点建立n个单链表)   头文件:Graph.h #ifndef GRAPH_H #define GRAPH_H #defin...
  • flying0033
  • flying0033
  • 2011年11月15日 10:05
  • 5151

无向图邻接表的深度优先遍历

#include #include #define Max 50 int visited[Max]; //边表节点 typedef struct EdgeNode { ...
  • zp961213
  • zp961213
  • 2016年11月23日 22:45
  • 1421

基于邻接矩阵和邻接表的两种方法实现无向图的BFS和DFS

广度优先搜索(Breadth-First-Search)和深度优先搜索(Deep-First-Search)是搜索策略中最经常用到的两种方法,特别常用于图的搜索. BFS的思想:     ...
  • lxpaopao
  • lxpaopao
  • 2015年04月01日 14:18
  • 2084

c语言实现无向图的邻接表储存

图有一种邻接表储存结构,这里以无向图为例,输入图的参数,构造并输出图的邻接表。 #include #include #define MAX_VERTEX_NUM 100 typedef struct...
  • L_BestCoder
  • L_BestCoder
  • 2016年03月02日 21:46
  • 5141

无向图的构建及深度优先遍历---邻接表实现

无向图的构建及深度遍历---临接表实现
  • cjc211322
  • cjc211322
  • 2014年03月21日 16:22
  • 1751

无向图--邻接矩阵、连接矩阵、深度遍历、广度遍历、生成树

1、开始生成的无向图 2、由图深度优先遍历生成的树  package graph;import java.util.ArrayList;import java.util.Iterator;import...
  • liangyihuai
  • liangyihuai
  • 2015年09月15日 13:46
  • 943

无向图的深度优先遍历和广度优先遍历(递归)

无向图的深度优先遍历和广度优先遍历(递归)     queue.h源代码 注释:包括队列数据类型的定义和相关操作    (出队,入队,判断队空,判断队列中是否存在某元素)     ...
  • Heated_Youth
  • Heated_Youth
  • 2016年05月23日 20:43
  • 3104
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:基于邻接表的无向图的深度广度遍历实现
举报原因:
原因补充:

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