BFS和DFS的java实现

原创 2015年07月07日 14:41:01
<pre name="code" class="java">
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;

/*广度遍历是遍历到某个顶点,然后访问其连接点a,b;接着访问a的连接表,
 很自然的,这种数据结构就是HashMap,以顶点为key,保存每个顶点的连接表
 */
public class BFS {
	static int count=0;
	/*
	 * HashMap<Character,LinkedList<Character>> graph 这个HashMap是用于存放图中每个node的邻接表
	 * 表示此映射所维护的键的类型为Character,此映射值的类型为LinkedList<Character> graph
	 * 表示将映射关系存放在graph此映射中
	 * 
	 * LinkedList<Character> 表示在此Collection中保持元素类型为Character
	 * 
	 * HashMap<Character,Integer> dist 这个HashMap 是用于存放每个node与距离顶点s的距离的映射关系
	 * 表示此映射所维护的键的类型为Character 此映射所维护的值的类型为Integer,dist表示将映射关系存放到dist此映射中
	 */
	private void bfs(HashMap<Character, LinkedList<Character>> graph,
			HashMap<Character, Integer> dist, char start) {
		// Queue<Character> 表示在此Collection中所保存的元素的类型为Character
		Queue<Character> q = new LinkedList<Character>();
		q.add(start);// 将指定元素s插入队列,成功时返回true,如果没有可用空间,则返回illegalStateException
		//put(start,0) start为指定值将要关联的键,0为指定值将要关联的值, 如果start与0的映射关系已存在,则返回并替换旧值0
		//如果 start与0的映射关系不存在,则返回null
		dist.put(start, 0);
		int i = 0;
		while (!q.isEmpty())//
		{
			char top = q.poll();// 获取并移除队列的头,返回队列的头,如果队列为空,返回null
			i++;
			// dist.get(top) 返回指定键top所映射的值
			System.out.println("The " + i + "th element:" + top+ " Distance from s is:" + dist.get(top));
			int d = dist.get(top) + 1;// 得出其周边还未被访问的节点的距离
			/*
			 * graph.get(top)如果此映射包含一个满足 (key==null ? k==null : key.equals(k))
			 * 的从 k 键到 v 值的映射关系,则此方法返回 v;否则返回 null。(最多只能有一个这样的映射关系。)
			 * for(元素变量:元素集合),如果元素集合中所有元素都已遍历过,则结束此循环, 否则执行for循环里的程序块
			 */
			for (Character c : graph.get(top)) {
				// containskey(key) 如果此映射包含对于指定键key的映射关系,则返回true
				if (!dist.containsKey(c))// 如果dist中还没有该元素说明还没有被访问
				{
					//关联指定键c与指定值d,如果关联关系已存在,则替换旧值d,返回旧值d, 如果无映射关系,则返回null
					dist.put(c, d);
					q.add(c); // 将指定元素c插入队列,成功时返回true,如果没有可用空间,则返回illegalStateException
				}
			}
		}
	}	
	private static void dfs(HashMap<Character , LinkedList<Character>> graph,HashMap<Character, Boolean> visited)
	{
	    visit(graph, visited, 's');
	}
	private static void visit(HashMap<Character , LinkedList<Character>> graph,HashMap<Character, Boolean> visited,char start)
	{
		
		if (!visited.containsKey(start)) {
			count++;
			System.out.println("The time into element " + start + ":" + count);// 记录进入该节点的时间
			visited.put(start, true);
			for (Character c : graph.get(start)) {
				if (!visited.containsKey(c)) {
					visit(graph, visited, c);// 递归访问其邻近节点
				}
			}
			count++;
			System.out.println("The time out element " + start + ":" + count);// 记录离开该节点的时间
		}
	}
	public static void main(String args[]) {
		BFS bb = new BFS();
		// s顶点的邻接表
		LinkedList<Character> list_s = new LinkedList<Character>();
		list_s.add('w');
		list_s.add('r');
		LinkedList<Character> list_w = new LinkedList<Character>();
		list_w.add('s');
		list_w.add('x');
		list_w.add('i');
		LinkedList<Character> list_r = new LinkedList<Character>();
		list_r.add('s');
		list_r.add('v');
		LinkedList<Character> list_x = new LinkedList<Character>();
		list_x.add('w');
		list_x.add('y');
		list_x.add('u');
		LinkedList<Character> list_v = new LinkedList<Character>();
		list_v.add('r');
		LinkedList<Character> list_i = new LinkedList<Character>();
		list_i.add('w');
		LinkedList<Character> list_u = new LinkedList<Character>();
		list_u.add('x');
		LinkedList<Character> list_y = new LinkedList<Character>();
		list_y.add('x');
		HashMap<Character, LinkedList<Character>> graph = new HashMap<Character, LinkedList<Character>>();
		graph.put('s', list_s);
		graph.put('w', list_w);
		graph.put('r', list_r);
		graph.put('x', list_x);
		graph.put('v', list_v);
		graph.put('i', list_i);
		graph.put('y', list_y);
		graph.put('u', list_u);
		System.out.println("BFS starts:");
		HashMap<Character, Integer> dist = new HashMap<Character, Integer>();
		char start = 's';
		bb.bfs(graph, dist, start);
		System.out.println("DFS starts:");
		HashMap<Character, Boolean> visited=new HashMap<Character, Boolean>();
		bb.dfs(graph, visited);
	}
}



                    

利用广度优先遍历(BFS)计算最短路径 - Java实现

我们用字符串代表图的顶点(vertax),来模拟学校中Classroom, Square, Toilet, Canteen, South Gate, North Gate几个地点,然后计算任意两点之间...

图的BFS和DFS原理及实例分析(java)

BFS和DFS是图的两种遍历方式,是最简单的图搜索算法。本文将给出给出BFS和DFS的以下几种实现方式: 1、使用队列Queue实现图的BFS遍历 2、递归实现图的DFS遍历 3、使用栈Stac...

每天一道算法题(六)深度优先算法(DFS)学习及Java实现

DFS的思想是从一个顶点V0开始,沿着一条路一直走到底,如果发现不能到达目标解,那就返回到上一个节点,然后从另一条路开始走到底...

【数据结构】Java实现图的DFS和BFS

图的深度优先遍历(DFS)和广度优先遍历(BFS),DFS利用递归来实现比较易懂,DFS非递归就是将需要的递归的元素利用一个栈Stack来实现,以达到递归时候的顺序,而BFS则是利用一个队列Queue...

DFS深度优先算法java算法

 我学习算法,按照老师给的算法弄的…… 完成时间2014年11月24日

深度优先遍历DFS 与 广度优先遍历BFS(java实现)

图的遍历方式有俩种: 深度优先遍历(DFS) 广度优先遍历(BFS) (1)深度优先遍历(利用栈和递归来实现) 思路:先以一个点为起点,这里假如是点A,那么就将A相邻的点放入堆栈...
  • Healist
  • Healist
  • 2017年01月21日 19:40
  • 566

Java实现数据结构之深度优先搜索DFS和广度优先搜索BFS

数据结构之深度优先搜索DFS和广度优先搜索BFS

java实现DFS求路径是否有解问题

今天回顾了DFS——Depth First Search——深度优先遍历,这个算法主要有两个用途:一是用于对于未知解的探索,一个典型的例子是走迷宫,也就是我们要列出所有的可能性来穷举,如果找到一条可行...

【数据结构与算法】自己动手实现图的BFS和DFS(附完整源码)

本文的重点在于图的深度优先搜索(DFS)和广度优先搜索(BFS),因此不再对图的基本概念做过多的介绍,但是要先大致了解下图的几种常见的存储结构。 邻接矩阵既可以用来存储无向图,也可以用来存储有...

经典图算法Java代码实践:BFS,DFS以及几种最短路径算法

public class City { String name; int id; static int idCounter = 0; public City(String name) ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:BFS和DFS的java实现
举报原因:
原因补充:

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