树结构报错Cycle in directed graph的拓扑排序问题-CSDN博客

本文链接：https://blog.csdn.net/shejizuopin/article/details/148060489

树结构报错Cycle in directed graph的拓扑排序问题

在处理有向图时，经常会遇到需要判断图中是否存在环的问题。拓扑排序是一种有效的算法，用于检测有向无环图（DAG）中的环，并生成顶点的线性排序。然而，当图中存在环时，拓扑排序将无法完成，从而可能引发错误，如"Cycle in directed graph"。本文将结合CSDN网站上的实用技巧，深入探讨如何使用拓扑排序解决这一问题，并提供代码和表格示例分析。

一、拓扑排序与环检测

拓扑排序是对有向无环图（DAG）的一种排序算法，它将图中的顶点排成一个线性序列，使得对于图中的每一条有向边 (u, v)，顶点 u 在序列中都出现在顶点 v 之前。拓扑排序的前提是图必须是有向无环图（DAG），否则无法进行拓扑排序。

环检测原理

在拓扑排序过程中，如果图中存在环，那么至少有一个顶点的入度无法减至0，导致无法将所有顶点加入拓扑序列。因此，可以通过检查拓扑排序结果中的顶点数量是否等于图中的顶点数量来判断图中是否存在环。

二、拓扑排序算法实现

1. Kahn’s 算法（基于入度的算法）

Kahn’s 算法使用贪心策略，基于入度进行排序。以下是Kahn’s算法的C++实现：

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

vector<int> topologicalSort(vector<vector<int>>& graph) {
    int n = graph.size();
    vector<int> inDegree(n, 0); // 记录每个节点的入度
    vector<int> result; // 用于存储排序后的结果

    // 统计每个节点的入度
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < graph[i].size(); j++) {
            inDegree[graph[i][j]]++;
        }
    }

    queue<int> q;
    // 将入度为0的节点加入队列
    for (int i = 0; i < n; i++) {
        if (inDegree[i] == 0) {
            q.push(i);
        }
    }

    // 拓扑排序
    while (!q.empty()) {
        int node = q.front();
        q.pop();
        result.push_back(node);

        // 更新与当前节点相邻节点的入度
        for (int i = 0; i < graph[node].size(); i++) {
            int neighbor = graph[node][i];
            inDegree[neighbor]--;
            if (inDegree[neighbor] == 0) {
                q.push(neighbor);
            }
        }
    }

    // 检查是否有环
    if (result.size() != n) {
        cout << "Graph contains a cycle!" << endl;
        return vector<int>();
    }

    return result;
}

int main() {
    int n; // 节点个数
    int m; // 有向边的个数
    cout << "Enter the number of nodes: ";
    cin >> n;
    cout << "Enter the number of directed edges: ";
    cin >> m;

    vector<vector<int>> graph(n); // 定义有向图的邻接表表示
    cout << "Enter the directed edges: " << endl;
    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        graph[u].push_back(v);
    }

    vector<int> result = topologicalSort(graph);

    if (!result.empty()) {
        cout << "Topological sort: ";
        for (int i = 0; i < result.size(); i++) {
            cout << result[i] << " ";
        }
        cout << endl;
    }

    return 0;
}

2. 深度优先搜索（DFS）算法

DFS算法通过递归访问每个顶点，并在回溯时将顶点加入拓扑排序的结果中。以下是DFS算法的Python实现：

from collections import defaultdict

def topological_sort_dfs(graph):
    visited = set()
    stack = []

    def dfs(node):
        visited.add(node)
        for neighbor in graph.get(node, []):
            if neighbor not in visited:
                dfs(neighbor)
        stack.append(node)

    for node in graph:
        if node not in visited:
            dfs(node)

    stack.reverse()  # 逆拓扑排序结果反转即为拓扑排序
    return stack

# 示例图
graph = {
    'A': ['C', 'D'],
    'B': ['D', 'E'],
    'C': ['F'],
    'D': ['F'],
    'E': [],
    'F': []
}

# 检测环的辅助函数
def has_cycle_dfs(graph):
    visited = set()
    recursion_stack = set()

    def dfs_cycle(node):
        visited.add(node)
        recursion_stack.add(node)
        for neighbor in graph.get(node, []):
            if neighbor not in visited:
                if dfs_cycle(neighbor):
                    return True
            elif neighbor in recursion_stack:
                return True
        recursion_stack.remove(node)
        return False

    for node in graph:
        if node not in visited:
            if dfs_cycle(node):
                return True
    return False

if has_cycle_dfs(graph):
    print("Graph contains a cycle!")
else:
    print("Topological sort (DFS):", topological_sort_dfs(graph))

三、表格示例分析

以下是一个表格示例，展示了不同有向图（包含环和无环）的拓扑排序结果和环检测情况：

有向图描述	邻接表表示	拓扑排序结果	环检测情况
无环图1	{‘A’: [‘C’], ‘B’: [‘C’, ‘D’], ‘C’: [‘E’], ‘D’: [‘F’], ‘E’: [‘F’], ‘F’: []}	[‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’]	无环
有环图1	{‘A’: [‘B’], ‘B’: [‘C’], ‘C’: [‘A’]}	[]	有环
无环图2	{‘1’: [‘2’, ‘3’], ‘2’: [‘4’, ‘5’], ‘3’: [‘5’, ‘6’], ‘4’: [‘7’], ‘5’: [‘7’], ‘6’: [‘7’]}	[‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’]	无环
有环图2	{‘X’: [‘Y’], ‘Y’: [‘Z’], ‘Z’: [‘X’], ‘W’: [‘V’]}	[]	有环