有向图广度优先遍历

jiaoshou3471 2014-08-25 10:31:18
已知顶点集v与边集e，输入某个顶点x，打印以该点为顶点的广度优先遍历。

Graph g=new Graph(v,e);
g.bfs(x);

哪位高手写过，求粘贴下，图的不想写了。。。。
...全文
818 6 打赏 收藏 举报
写回复
用AI写文章
6 条回复
切换为时间正序
请发表友善的回复…
发表回复
鱿鱼x 2014-08-27
  • 打赏
  • 举报
 回复
3楼代码齐全了，你想要一个方法调用，就自定义一个方法把代码扔进去。改一下，也算是对图的认识。
qzw1210 2014-08-26
  • 打赏
  • 举报
 回复 

package des;

import java.util.*;

public class GraphErgodic {
	// 存储节点信息
	private Object[] vertices;
	// 存储边的信息
	private int[][] arcs;
	private int vexnum;
	// 记录第i个节点是否被访问过
	private boolean[] visited;

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		GraphErgodic g = new GraphErgodic(8);
		Character[] vertices = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' };
		g.addVertex(vertices);
		g.addEdge(0, 1);
		g.addEdge(0, 2);
		g.addEdge(1, 3);
		g.addEdge(1, 4);
		g.addEdge(3, 7);
		g.addEdge(4, 7);
		g.addEdge(2, 5);
		g.addEdge(2, 6);
		System.out.println("深度优先遍历：");
		g.depthTraverse();
		System.out.println();

		System.out.println("广度优先遍历：");
		g.broadTraverse();
		System.out.println();

		System.out.println("深度优先遍历非递归：");
		g.depth();
		System.out.println();
	}

	public GraphErgodic(int n) {
		vexnum = n;
		vertices = new Object[n];
		arcs = new int[n][n];
		visited = new boolean[n];
		for (int i = 0; i < vexnum; i++) {
			for (int j = 0; j < vexnum; j++) {
				arcs[i][j] = 0;
			}
		}

	}

	public void addVertex(Object[] obj) {
		this.vertices = obj;
	}

	public void addEdge(int i, int j) {
		if (i == j)
			return;
		arcs[i][j] = 1;
		arcs[j][i] = 1;
	}

	public int firstAdjVex(int i) {
		for (int j = 0; j < vexnum; j++) {
			if (arcs[i][j] > 0)
				return j;
		}
		return -1;
	}

	public int nextAdjVex(int i, int k) {
		for (int j = k + 1; j < vexnum; j++) {
			if (arcs[i][j] > 0)
				return j;
		}
		return -1;
	}

	// 深度优先遍历
	public void depthTraverse() {
		for (int i = 0; i < vexnum; i++) {
			visited[i] = false;
		}
		for (int i = 0; i < vexnum; i++) {
			if (!visited[i])
				traverse(i);
		}
	}

	// 一个连通图的深度递归遍历
	public void traverse(int i) {
		// TODO Auto-generated method stub
		visited[i] = true;
		visit(i);
		for (int j = this.firstAdjVex(i); j >= 0; j = this.nextAdjVex(i, j)) {
			if (!visited[j])
				this.traverse(j);
		}
	}

	// 广度优先遍历
	public void broadTraverse() {
		// LinkedList实现了Queue接口
		Queue<Integer> q = new LinkedList<Integer>();
		for (int i = 0; i < vexnum; i++) {
			visited[i] = false;
		}
		for (int i = 0; i < vexnum; i++) {
			if (!visited[i]) {
				q.add(i);
				visited[i] = true;
				visit(i);
				while (!q.isEmpty()) {
					int j = (Integer) q.remove().intValue();

					for (int k = this.firstAdjVex(j); k >= 0; k = this
							.nextAdjVex(j, k)) {
						if (!visited[k]) {
							q.add(k);
							visited[k] = true;
							visit(k);
						}
					}

				}
			}
		}
	}

	private void visit(int i) {
		// TODO Auto-generated method stub
		System.out.print(vertices[i] + " ");
	}

	// 深度非递归遍历
	public void depth() {
		Stack<Integer> s = new Stack<Integer>();
		for (int i = 0; i < vexnum; i++) {
			visited[i] = false;
		}
		for (int i = 0; i < vexnum; i++) {
			if (!visited[i]) {
				s.add(i);
				// 设置第i个元素已经进栈
				visited[i] = true;
				while (!s.isEmpty()) {
					int j = (Integer) s.pop();
					visit(j);
					for (int k = this.lastAdjVex(j); k >= 0; k = this
							.lastAdjVex(j, k)) {
						if (!visited[k]) {
							s.add(k);
							visited[k] = true;
						}
					}
				}
			}
		}
	}

	// 最后一个
	public int lastAdjVex(int i) {
		for (int j = vexnum - 1; j >= 0; j--) {
			if (arcs[i][j] > 0)
				return j;
		}
		return -1;
	}

	// 上一个
	public int lastAdjVex(int i, int k) {
		for (int j = k - 1; j >= 0; j--) {
			if (arcs[i][j] > 0)
				return j;
		}
		return -1;
	}
}
jiaoshou3471 2014-08-26
  • 打赏
  • 举报
 回复
坐等大神~
jiaoshou3471 2014-08-26
  • 打赏
  • 举报
 回复
引用 3 楼 qu1210 的回复:

package des;

import java.util.*;

public class GraphErgodic {
	// 存储节点信息
	private Object[] vertices;
	// 存储边的信息
	private int[][] arcs;
	private int vexnum;
	// 记录第i个节点是否被访问过
	private boolean[] visited;

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		GraphErgodic g = new GraphErgodic(8);
		Character[] vertices = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' };
		g.addVertex(vertices);
		g.addEdge(0, 1);
		g.addEdge(0, 2);
		g.addEdge(1, 3);
		g.addEdge(1, 4);
		g.addEdge(3, 7);
		g.addEdge(4, 7);
		g.addEdge(2, 5);
		g.addEdge(2, 6);
		System.out.println("深度优先遍历：");
		g.depthTraverse();
		System.out.println();

		System.out.println("广度优先遍历：");
		g.broadTraverse();
		System.out.println();

		System.out.println("深度优先遍历非递归：");
		g.depth();
		System.out.println();
	}

	public GraphErgodic(int n) {
		vexnum = n;
		vertices = new Object[n];
		arcs = new int[n][n];
		visited = new boolean[n];
		for (int i = 0; i < vexnum; i++) {
			for (int j = 0; j < vexnum; j++) {
				arcs[i][j] = 0;
			}
		}

	}

	public void addVertex(Object[] obj) {
		this.vertices = obj;
	}

	public void addEdge(int i, int j) {
		if (i == j)
			return;
		arcs[i][j] = 1;
		arcs[j][i] = 1;
	}

	public int firstAdjVex(int i) {
		for (int j = 0; j < vexnum; j++) {
			if (arcs[i][j] > 0)
				return j;
		}
		return -1;
	}

	public int nextAdjVex(int i, int k) {
		for (int j = k + 1; j < vexnum; j++) {
			if (arcs[i][j] > 0)
				return j;
		}
		return -1;
	}

	// 深度优先遍历
	public void depthTraverse() {
		for (int i = 0; i < vexnum; i++) {
			visited[i] = false;
		}
		for (int i = 0; i < vexnum; i++) {
			if (!visited[i])
				traverse(i);
		}
	}

	// 一个连通图的深度递归遍历
	public void traverse(int i) {
		// TODO Auto-generated method stub
		visited[i] = true;
		visit(i);
		for (int j = this.firstAdjVex(i); j >= 0; j = this.nextAdjVex(i, j)) {
			if (!visited[j])
				this.traverse(j);
		}
	}

	// 广度优先遍历
	public void broadTraverse() {
		// LinkedList实现了Queue接口
		Queue<Integer> q = new LinkedList<Integer>();
		for (int i = 0; i < vexnum; i++) {
			visited[i] = false;
		}
		for (int i = 0; i < vexnum; i++) {
			if (!visited[i]) {
				q.add(i);
				visited[i] = true;
				visit(i);
				while (!q.isEmpty()) {
					int j = (Integer) q.remove().intValue();

					for (int k = this.firstAdjVex(j); k >= 0; k = this
							.nextAdjVex(j, k)) {
						if (!visited[k]) {
							q.add(k);
							visited[k] = true;
							visit(k);
						}
					}

				}
			}
		}
	}

	private void visit(int i) {
		// TODO Auto-generated method stub
		System.out.print(vertices[i] + " ");
	}

	// 深度非递归遍历
	public void depth() {
		Stack<Integer> s = new Stack<Integer>();
		for (int i = 0; i < vexnum; i++) {
			visited[i] = false;
		}
		for (int i = 0; i < vexnum; i++) {
			if (!visited[i]) {
				s.add(i);
				// 设置第i个元素已经进栈
				visited[i] = true;
				while (!s.isEmpty()) {
					int j = (Integer) s.pop();
					visit(j);
					for (int k = this.lastAdjVex(j); k >= 0; k = this
							.lastAdjVex(j, k)) {
						if (!visited[k]) {
							s.add(k);
							visited[k] = true;
						}
					}
				}
			}
		}
	}

	// 最后一个
	public int lastAdjVex(int i) {
		for (int j = vexnum - 1; j >= 0; j--) {
			if (arcs[i][j] > 0)
				return j;
		}
		return -1;
	}

	// 上一个
	public int lastAdjVex(int i, int k) {
		for (int j = k - 1; j >= 0; j--) {
			if (arcs[i][j] > 0)
				return j;
		}
		return -1;
	}
}
引用 3 楼 qu1210 的回复:

package des;

import java.util.*;

public class GraphErgodic {
	// 存储节点信息
	private Object[] vertices;
	// 存储边的信息
	private int[][] arcs;
	private int vexnum;
	// 记录第i个节点是否被访问过
	private boolean[] visited;

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		GraphErgodic g = new GraphErgodic(8);
		Character[] vertices = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' };
		g.addVertex(vertices);
		g.addEdge(0, 1);
		g.addEdge(0, 2);
		g.addEdge(1, 3);
		g.addEdge(1, 4);
		g.addEdge(3, 7);
		g.addEdge(4, 7);
		g.addEdge(2, 5);
		g.addEdge(2, 6);
		System.out.println("深度优先遍历：");
		g.depthTraverse();
		System.out.println();

		System.out.println("广度优先遍历：");
		g.broadTraverse();
		System.out.println();

		System.out.println("深度优先遍历非递归：");
		g.depth();
		System.out.println();
	}

	public GraphErgodic(int n) {
		vexnum = n;
		vertices = new Object[n];
		arcs = new int[n][n];
		visited = new boolean[n];
		for (int i = 0; i < vexnum; i++) {
			for (int j = 0; j < vexnum; j++) {
				arcs[i][j] = 0;
			}
		}

	}

	public void addVertex(Object[] obj) {
		this.vertices = obj;
	}

	public void addEdge(int i, int j) {
		if (i == j)
			return;
		arcs[i][j] = 1;
		arcs[j][i] = 1;
	}

	public int firstAdjVex(int i) {
		for (int j = 0; j < vexnum; j++) {
			if (arcs[i][j] > 0)
				return j;
		}
		return -1;
	}

	public int nextAdjVex(int i, int k) {
		for (int j = k + 1; j < vexnum; j++) {
			if (arcs[i][j] > 0)
				return j;
		}
		return -1;
	}

	// 深度优先遍历
	public void depthTraverse() {
		for (int i = 0; i < vexnum; i++) {
			visited[i] = false;
		}
		for (int i = 0; i < vexnum; i++) {
			if (!visited[i])
				traverse(i);
		}
	}

	// 一个连通图的深度递归遍历
	public void traverse(int i) {
		// TODO Auto-generated method stub
		visited[i] = true;
		visit(i);
		for (int j = this.firstAdjVex(i); j >= 0; j = this.nextAdjVex(i, j)) {
			if (!visited[j])
				this.traverse(j);
		}
	}

	// 广度优先遍历
	public void broadTraverse() {
		// LinkedList实现了Queue接口
		Queue<Integer> q = new LinkedList<Integer>();
		for (int i = 0; i < vexnum; i++) {
			visited[i] = false;
		}
		for (int i = 0; i < vexnum; i++) {
			if (!visited[i]) {
				q.add(i);
				visited[i] = true;
				visit(i);
				while (!q.isEmpty()) {
					int j = (Integer) q.remove().intValue();

					for (int k = this.firstAdjVex(j); k >= 0; k = this
							.nextAdjVex(j, k)) {
						if (!visited[k]) {
							q.add(k);
							visited[k] = true;
							visit(k);
						}
					}

				}
			}
		}
	}

	private void visit(int i) {
		// TODO Auto-generated method stub
		System.out.print(vertices[i] + " ");
	}

	// 深度非递归遍历
	public void depth() {
		Stack<Integer> s = new Stack<Integer>();
		for (int i = 0; i < vexnum; i++) {
			visited[i] = false;
		}
		for (int i = 0; i < vexnum; i++) {
			if (!visited[i]) {
				s.add(i);
				// 设置第i个元素已经进栈
				visited[i] = true;
				while (!s.isEmpty()) {
					int j = (Integer) s.pop();
					visit(j);
					for (int k = this.lastAdjVex(j); k >= 0; k = this
							.lastAdjVex(j, k)) {
						if (!visited[k]) {
							s.add(k);
							visited[k] = true;
						}
					}
				}
			}
		}
	}

	// 最后一个
	public int lastAdjVex(int i) {
		for (int j = vexnum - 1; j >= 0; j--) {
			if (arcs[i][j] > 0)
				return j;
		}
		return -1;
	}

	// 上一个
	public int lastAdjVex(int i, int k) {
		for (int j = k - 1; j >= 0; j--) {
			if (arcs[i][j] > 0)
				return j;
		}
		return -1;
	}
}
这个顶点是确定的吧，我想可以变顶点~ g.broadTraverse(v);
业余草 2014-08-26
  • 打赏
  • 举报
 回复
好高深啊，没有做过，顶你
vnvlyp 2014-08-26
  • 打赏
  • 举报
 回复
写伪代码么？
有向图的广度优先遍历
该博客介绍了如何用C++实现有向图的广度优先遍历。首先定义了有向图的数据结构MGraph，包括顶点数组和关系矩阵。然后通过CreateGraph函数创建图，并通过Locate_vex函数定位顶点位置。接着是PrintGraph函数显示图的信息，最后是BFS函数实现广度优先遍历。在main函数中，用户输入顶点数和边数，程序创建并打印图，并进行广度优先遍历。
有向图的广度优先遍历（邻接矩阵）
博客围绕有向图的广度优先遍历展开，采用邻接矩阵的方式。广度优先遍历是图的重要遍历方法，邻接矩阵是常用的图存储结构，二者结合可有效处理有向图相关问题。
用邻接表存储有向图的广度优先遍历
该代码实现了一个使用邻接表存储的有向图，并通过广度优先遍历（BFS）进行节点访问。程序首先读取顶点数和边数，然后构建有向图，接着对每个未访问过的顶点执行BFS，并打印出遍历顺序。输入样例为5个顶点和5条边，输出样例为02143，表示从顶点0开始的BFS遍历路径。
有向图的广度优先遍历_图的两种遍历方式
本文详细介绍了图的两种遍历方式：深度优先搜索(DFS)和广度优先搜索(BFS)。深度优先搜索是一个递归过程，通过栈进行回溯，而广度优先搜索类似树的层次遍历，借助队列逐层访问。两者在遍历连通图时都能访问所有顶点，但在非连通图中可能无法覆盖全部节点。
用邻接矩阵存储有向图的广度优先遍历
该代码实例展示了如何使用C++通过邻接矩阵存储的有向图进行广度优先遍历（BFS）。程序首先读取图的顶点数和边数，然后构建有向图，并通过队列实现BFS。最后，输出遍历的顺序。这个程序对于理解图的遍历算法和数据结构操作具有教育意义。
Java SE

62,620

社区成员

307,251

社区内容

发帖
与我相关
我的任务
社区描述
Java 2 Standard Edition
社区管理员
  • Java SE
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章