有向图的广度、深度优先遍历

基于List存储的邻接表，一个工具类，创建一个有向图：

代码如下：

package com.daxin;

import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author  daxin
 *
 * @email [email protected]
 *
 * @date 2017年9月24日 下午5:36:56
 *
 */
class Node {

    public Node(int val) {
        this.val = val;
    }

    int val;
    boolean visited;

}

public class BuildGraph {
    /**
     * 基于邻接表存储的有向图
     *
     *
     *
     * @return 返回有向图
     */
    public static List<List<Node>> buildGraph() {
        List<List<Node>> G = new ArrayList<>();

        Node a = new Node(0);
        Node b = new Node(1);
        Node c = new Node(2);
        Node d = new Node(3);
        Node e = new Node(4);

        List<Node> al = new ArrayList<>();
        al.add(a);
        al.add(b);
        al.add(c);
        List<Node> bl = new ArrayList<>();
        List<Node> cl = new ArrayList<>();
        List<Node> dl = new ArrayList<>();
        List<Node> el = new ArrayList<>();
        bl.add(b);
        bl.add(d);
        cl.add(c);
        cl.add(d);
        dl.add(d);
        dl.add(e);
        el.add(e);

        G.add(al);
        G.add(bl);
        G.add(cl);
        G.add(dl);
        G.add(el);

        return G;

    }
}

有向图的深度优先遍历：

package com.daxin;

import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author daxin
 * @email [email protected]
 * @date 2017年9月24日 下午3:08:20
 *
 */

public class Dfs {

    public static void main(String[] args) {
        dfsGraph(BuildGraph.buildGraph());
    }

    public static void dfsGraph(List<List<Node>> adjacencyList) {

        // vl是邻接表中的每一行的一个list
        for (List<Node> vl : adjacencyList) {
            dfs(adjacencyList, vl);

        }

    }

    public static void dfs(List<List<Node>> adjacencyList, List<Node> vhead) {

        for (int i = 0; i < vhead.size(); i++) {
            if (vhead.get(i).visited == false) {
                // 设置访问过
                vhead.get(i).visited = true;
                // 遍历其value
                System.out.println(vhead.get(i).val);
                // 递归调用，进行深度遍历
                dfs(adjacencyList, adjacencyList.get(vhead.get(i).val));
            }
        }

    }

}

有向图的广度优先遍历：

package com.daxin;

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 *
 * @author daxin
 *
 * @email [email protected]
 *
 * @date 2017年9月24日 下午5:39:19
 *
 */
public class Bfs {
    public static void main(String[] args) {
        bfsGraph(BuildGraph.buildGraph());
    }

    public static void bfsGraph(List<List<Node>> adjacencyList) {

        for (int i = 0; i < adjacencyList.size(); i++) {
            bfs(adjacencyList, adjacencyList.get(i));
        }

    }

    public static void bfs(List<List<Node>> adjacencyList, List<Node> vhead) {

        Queue<Node> q = new LinkedList<>();
        q.add(vhead.get(0));

        while (!q.isEmpty()) {
            Node n = q.remove();
            List<Node> vl = adjacencyList.get(n.val);
            if (n.visited == false) {
                System.out.println(n.val);
                n.visited = true;
            }
            for (int i = 0; i < vl.size(); i++) {
                //如果没有访问的话，则追加到队列
                if (adjacencyList.get(n.val).get(i).visited == false)
                    q.add(adjacencyList.get(n.val).get(i));
            }

        }

    }
}