java 有向图找出所有环节点

原创

mob64ca12d70c79 2024-10-03 05:13:19 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12d70c79的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 有向图找出所有环节点

在计算机科学中，有向图（Directed Graph）是一种由节点（Vertex）和有向边（Edge）构成的数据结构，通常用于建模各种关系。识别有向图中的环（Cycle）对很多算法和应用（如网络流、任务调度等）至关重要。本文将介绍如何使用 Java 在有向图中找出所有环节点，并提供示例代码和流程图来阐明过程。

环的定义

在有向图中，环是指从某个节点出发，经过若干节点后又回到该节点的一条路径。我们需要找到这些构成环的节点，以便进行进一步的分析和处理。

算法步骤

要找出有向图中的所有环节点，我们可以应用深度优先搜索（DFS）。在搜索的过程中，我们使用一个栈来记录当前路径上的节点，并利用一个集合和布尔数组来跟踪访问状态，从而检测环的存在。

流程图

以下是实现环检测的流程图，采用 mermaid 语法表示：

flowchart TD
    A[开始] --> B[初始化图]
    B --> C[遍历所有节点]
    C --> D{节点未访问？}
    D -- 是 --> E[DFS访问节点]
    E --> F{发现环？}
    F -- 是 --> G[记录环节点]
    F -- 否 --> H[继续搜索]
    D -- 否 --> H
    H --> C
    C --> I[返回结果]
    I --> J[结束]

代码实现

下面的 Java 代码示例展示了如何在有向图中找到所有环节点：

import java.util.*;

public class DirectedGraph {
    private final Map<Integer, List<Integer>> graph;
    private final Set<Integer> visited = new HashSet<>();
    private final Set<Integer> stack = new HashSet<>();
    private final List<List<Integer>> cycles = new ArrayList<>();

    public DirectedGraph() {
        graph = new HashMap<>();
    }

    public void addEdge(int from, int to) {
        graph.putIfAbsent(from, new ArrayList<>());
        graph.get(from).add(to);
    }

    public List<List<Integer>> findCycles() {
        for (Integer node : graph.keySet()) {
            if (!visited.contains(node)) {
                dfs(node, new ArrayList<>());
            }
        }
        return cycles;
    }

    private void dfs(int node, List<Integer> path) {
        visited.add(node);
        stack.add(node);
        path.add(node);

        for (int neighbor : graph.getOrDefault(node, new ArrayList<>())) {
            if (stack.contains(neighbor)) {
                // Found a cycle, record it
                int cycleStart = path.indexOf(neighbor);
                cycles.add(new ArrayList<>(path.subList(cycleStart, path.size())));
            } else if (!visited.contains(neighbor)) {
                dfs(neighbor, path);
            }
        }

        stack.remove(node);
        path.remove(path.size() - 1);
    }
    
    public static void main(String[] args) {
        DirectedGraph g = new DirectedGraph();
        g.addEdge(0, 1);
        g.addEdge(1, 2);
        g.addEdge(2, 0);
        g.addEdge(1, 3);
        
        System.out.println("Cycles: " + g.findCycles());
    }
}

代码解析

数据结构: 我们使用 Map<Integer, List<Integer>> 来表示图。每个节点映射到其相邻的邻居列表。
DFS函数: dfs() 方法通过递归方式遍历图，记录访问状态。在遇到已经在访问栈中的节点时，说明发现了一个环。
结果存储: 一旦检测到环，程序将保存该环的节点路径到 cycles 集合中。

类图

以下是 DirectedGraph 类的类图，采用 mermaid 语法表示：

classDiagram
    class DirectedGraph {
        - Map<Integer, List<Integer>> graph
        - Set<Integer> visited
        - Set<Integer> stack
        - List<List<Integer>> cycles
        + void addEdge(int from, int to)
        + List<List<Integer>> findCycles()
        - void dfs(int node, List<Integer> path)
    }