图（图的宽度优先遍历（BFS）＆＆图的深度优先遍历（DFS）＆＆图的拓扑排序）

宽度优先遍历（BFS）

先遍历与当前结点相邻的结点，再遍历深一层的结点，层层递进。

1. 利用队列实现
2. 从源节点开始依次按照宽度进队列，然后弹出
3. 每弹出一个点，把该节点所有没有进过队列的邻接点放入队列
4. 直到队列变空

public class BSF {
    // 从node出发，进行宽度优先遍历
    public static void bfs(Node start) {
        if (start == null) {
            return;
        }
        Queue<Node> queue = new LinkedList<>();
        HashSet<Node> set = new HashSet<>();
        queue.add(start);
        set.add(start);
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            System.out.println(cur.value);
            for (Node next : cur.nexts) {
                if (!set.contains(next)) {
                    set.add(next);
                    queue.add(next);
                }
            }
        }
    }
}

深度优先遍历（DFS）

一条路走到黑，走不通了再回到上一个岔路口，直到走完整个结构。

1. 利用栈实现（代表走过的深度路径）
2. 从源节点开始把节点按照深度放入栈，然后弹出
3. 每弹出一个点，把该节点下一个没有进过栈的邻接点放入栈
4. 直到栈变空

public class DSF {
    public static void dsf(Node start) {
        if (start == null) {
            return;
        }
        Stack<Node> stack = new Stack<>();
        HashSet<Node> set = new HashSet<>();
        stack.add(start);
        set.add(start);
        System.out.println(start);
        while (!stack.isEmpty()) {
            Node cur = stack.pop();
            for (Node next : cur.nexts) {
				if (!set.contains(next)) {
					stack.push(cur);
					stack.push(next);
					set.add(next);
					System.out.println(next.value);
					break;
				}
			}
        }
    }
}

图的拓扑排序算法

1）在图中找到所有入度为0的点输出

2）把所有入度为0的点在图中删掉，继续找入度为0的点输出，周而复始

3）图的所有点都被删除后，依次输出的顺序就是拓扑排序

要求：有向图且其中没有环

应用：事件安排、编译顺序

如果有这样的一个图结构，A依赖D，B依赖D，C依赖D

那么拓扑排序的结果为D一定在ABC后，但是ABC的顺序不一定

public class TopologySort {
    public static List<Node> sortTopology(Graph graph) {
        // key 某个节点   value 剩余的入度
        HashMap<Node, Integer> inMap = new HashMap<>();
        // 只有剩余入度为0的点，才进入这个队列
        Queue<Node> zeroInQueue = new LinkedList<>();
        for (Node node : graph.nodes.values()) {
            inMap.put(node, node.in);
            if (node.in == 0) {
                zeroInQueue.add(node);
            }
        }
        List<Node> result = new ArrayList<>();
        while (!zeroInQueue.isEmpty()) {
            Node cur = zeroInQueue.poll();
            result.add(cur);
            for (Node next : cur.nexts) {
                inMap.put(next, inMap.get(next) - 1);
                if (inMap.get(next) == 0) {
                    zeroInQueue.add(next);
                }
            }
        }
        return result;
    }
}