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

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

/**
 * 图数据结构
 */
class MyGraph{
   public Node[] adjlist;
   public int n,e;
}
/**
 * 点的数据结构
 */
class Node{
    public char data;
    public Arc firstArc;
}

/**
 * 边的数据结构
 */
class Arc{
    public int value;
    public Arc nextArc;
}

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

   /**
     * 深度优先遍历
     * @param g
     * @param visit
     * @param v
     */
    public static void DFS(MyGraph g, int[] visit, int v){
        // 标记 v 为被访问过
        visit[v] = 1;
        Arc arc = g.adjlist[v].firstArc;
        while (arc!=null){
            if (visit[arc.value] == 0){
                // 边指向的节点未被 访问过则递归访问
                DFS(g, visit, arc.value);
            }
            // 后移
            arc = arc.nextArc;
        }
    }

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

    /**
     * 加入 queue 的都是被访问过的点
     * 未被访问的点在加入 queue后 第一时间设置为被访问过!
     *
     * @param g
     * @param v
     * @param visit
     */
    public static void BFS(MyGraph g, int v, int[] visit) {
        int maxSize = 100;
        int[] queue = new int[maxSize]; // 定义循环队列， 尾进头出
        int front = 0;// 队列头
        int rear = 0; // 队列尾
        Arc p;
        visit[v] = 1; // 标记为被访问
        rear = (rear + 1) % maxSize;
        queue[rear] = v;// 数据入队列
        // 如果队列不为空
        while (rear != front) {
            // 数据从队列出栈
            front = (front + 1) % maxSize;
            p = g.adjlist[queue[front]].firstArc;
            // 下一个节点存在就继续循环
            while (p != null) {
                if (visit[p.value] == 0) {
                    // 未被访问过的标记为被访问过, 然后加入队列。
                    visit[p.value] = 1;
                    rear = (rear + 1) % maxSize;
                    queue[rear] = p.value;
                }
                p = p.nextArc; // 后移
            }
        }
    }