Java实现图的深度和广度优先遍历算法

概述：

  最近要学习写网络爬虫，所以把图的深度和广度搜索都再温习一下。

图结构展示：

实现过程：

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

1.图中的节点：

[java]  view plain  copy

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

 

2.图中的边：

 

[java]  view plain  copy

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

 

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

 

[java]  view plain  copy

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

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

深度优先搜索：

 

[java]  view plain  copy

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

 

广度优先搜索：

 

[java]  view plain  copy

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

 

运行结果：

源码下载：

http://download.csdn.net/detail/u013761665/8968443

https://blog.csdn.net/lemon_tree12138/article/details/47319659