深度优先遍历DFS和广度优先遍历BFS

均以邻接矩阵方式存储数据，结构如下。

 1 /**
 2  * 图数据结构
 3  */
 4 class MyGraph{
 5    public Node[] adjlist;
 6    public int n,e;
 7 }
 8 /**
 9  * 点的数据结构
10  */
11 class Node{
12     public char data;
13     public Arc firstArc;
14 }
15 
16 /**
17  * 边的数据结构
18  */
19 class Arc{
20     public int value;
21     public Arc nextArc;
22 }

深度优先遍历 DSF代码如下:

 1    /**
 2      * 深度优先遍历
 3      * @param g
 4      * @param visit
 5      * @param v
 6      */
 7     public static void DFS(MyGraph g, int[] visit, int v){
 8         // 标记 v 为被访问过
 9         visit[v] = 1;
10         Arc arc = g.adjlist[v].firstArc;
11         while (arc!=null){
12             if (visit[arc.value] == 0){
13                 // 边指向的节点未被 访问过则递归访问
14                 DFS(g, visit, arc.value);
15             }
16             // 后移
17             arc = arc.nextArc;
18         }
19     }

广度优先遍历BFS代码如下:

 1     /**
 2      * 加入 queue 的都是被访问过的点
 3      * 未被访问的点在加入 queue后 第一时间设置为被访问过!
 4      *
 5      * @param g
 6      * @param v
 7      * @param visit
 8      */
 9     public static void BFS(MyGraph g, int v, int[] visit) {
10         int maxSize = 100;
11         int[] queue = new int[maxSize]; // 定义循环队列， 尾进头出
12         int front = 0;// 队列头
13         int rear = 0; // 队列尾
14         Arc p;
15         visit[v] = 1; // 标记为被访问
16         rear = (rear + 1) % maxSize;
17         queue[rear] = v;// 数据入队列
18         // 如果队列不为空
19         while (rear != front) {
20             // 数据从队列出栈
21             front = (front + 1) % maxSize;
22             p = g.adjlist[queue[front]].firstArc;
23             // 下一个节点存在就继续循环
24             while (p != null) {
25                 if (visit[p.value] == 0) {
26                     // 未被访问过的标记为被访问过, 然后加入队列。
27                     visit[p.value] = 1;
28                     rear = (rear + 1) % maxSize;
29                     queue[rear] = p.value;
30                 }
31                 p = p.nextArc; // 后移
32             }
33         }
34     }