java深度搜索与广度优先搜索

图结构展示：

实现过程：

首先，我们来看看图结构在代码中的实现。有三块逻辑：

1.图中的节点：

1. public class GraphNode {
2. public List<GraphEdge> edgeList = null;
3. private String label = "";
4. public GraphNode(String label) {
5. this.label = label;
6. if (edgeList == null) {
7. edgeList = new ArrayList<GraphEdge>();
8. }
9. }
10. /**
11. * 给当前节点添加一条边
12. * GraphNode
13. * @param edge
14. *          添加的边
15. */
16. public void addEdgeList(GraphEdge edge) {
17. edgeList.add(edge);
18. }
19. public String getLabel() {
20. return label;
21. }
22. }

2.图中的边：

1. public class GraphEdge {
2. private GraphNode nodeLeft;
3. private GraphNode nodeRight;
4. /**
5. * @param nodeLeft
6. *          边的左端
7. * @param nodeRight
8. *          边的右端
9. */
10. public GraphEdge(GraphNode nodeLeft, GraphNode nodeRight) {
11. this.nodeLeft = nodeLeft;
12. this.nodeRight = nodeRight;
13. }
14. public GraphNode getNodeLeft() {
15. return nodeLeft;
16. }
17. public GraphNode getNodeRight() {
18. return nodeRight;
19. }
20. }

3.把节点和边组合成一个图结构：

1. public class MyGraph {
2. private List<GraphNode> nodes = null;
3. public void initGraph(int n) {
4. if (nodes == null) {
5. nodes = new ArrayList<GraphNode>();
6. }
7. GraphNode node = null;
8. for (int i = 0; i < n; i++) {
9. node = new GraphNode(String.valueOf(i));
10. nodes.add(node);
11. }
12. }
13. public void initGraph(int n, boolean b) {
14. initGraph(n);
15. GraphEdge edge01 = new GraphEdge(nodes.get(0), nodes.get(1));
16. GraphEdge edge02 = new GraphEdge(nodes.get(0), nodes.get(2));
17. GraphEdge edge13 = new GraphEdge(nodes.get(1), nodes.get(3));
18. GraphEdge edge14 = new GraphEdge(nodes.get(1), nodes.get(4));
19. GraphEdge edge25 = new GraphEdge(nodes.get(2), nodes.get(5));
20. GraphEdge edge26 = new GraphEdge(nodes.get(2), nodes.get(6));
21. GraphEdge edge37 = new GraphEdge(nodes.get(3), nodes.get(7));
22. GraphEdge edge47 = new GraphEdge(nodes.get(4), nodes.get(7));
23. GraphEdge edge56 = new GraphEdge(nodes.get(5), nodes.get(6));
24. nodes.get(0).addEdgeList(edge01);
25. nodes.get(0).addEdgeList(edge02);
26. nodes.get(1).addEdgeList(edge13);
27. nodes.get(1).addEdgeList(edge14);
28. nodes.get(2).addEdgeList(edge25);
29. nodes.get(2).addEdgeList(edge26);
30. nodes.get(3).addEdgeList(edge37);
31. nodes.get(4).addEdgeList(edge47);
32. nodes.get(5).addEdgeList(edge56);
33. }
34. public void initGraph() {
35. initGraph(8, false);
36. }
37. public List<GraphNode> getGraphNodes() {
38. return nodes;
39. }
40. }

有了图的结构，我们就可以进行一些实际的操作了。

深度优先搜索：

1. public class DFSearch {
2. /**
3. * 深度遍历
4. * DFSearch
5. * @param node
6. *          当前节点
7. * @param visited
8. *          被访问过的节点列表
9. */
10. public void searchTraversing(GraphNode node, List<GraphNode> visited) {
11. // 判断是否遍历过
12. if (visited.contains(node)) {
13. return;
14. }
15. visited.add(node);
16. System.out.println("节点：" + node.getLabel());
17. for (int i = 0; i < node.edgeList.size(); i++) {
18. searchTraversing(node.edgeList.get(i).getNodeRight(), visited);
19. }
20. }
21. }

广度优先搜索：

1. public class BFSearch {
2. /**
3. * 广度优先搜索
4. * BFSearch
5. * @param node
6. *          搜索的入口节点
7. */
8. public void searchTraversing(GraphNode node) {
9. List<GraphNode> visited = new ArrayList<GraphNode>(); // 已经被访问过的元素
10. Queue<GraphNode> q = new LinkedList<GraphNode>(); // 用队列存放依次要遍历的元素
11. q.offer(node);
12. while (!q.isEmpty()) {
13. GraphNode currNode = q.poll();
14. if (!visited.contains(currNode)) {
15. visited.add(currNode);
16. System.out.println("节点：" + currNode.getLabel());
17. for (int i = 0; i < currNode.edgeList.size(); i++) {
18. q.offer(currNode.edgeList.get(i).getNodeRight());
19. }
20. }
21. }
22. }
23. }

运行结果：