拓扑依赖算法（依赖关系）

Posted 2023-05-19 百小僧

拓扑依赖算法（依赖关系）

 

internal static List<Type> SortDependencies(Dictionary<Type, List<Type>> dependencies)
    
        var sortedList = new List<Type>();
        var visitedNodes = new HashSet<Type>();
        var temporaryMarkedNodes = new HashSet<Type>();

        foreach (var node in dependencies.Keys)
        
            if (!visitedNodes.Contains(node))
            
                VisitNode(node, dependencies, visitedNodes, sortedList, temporaryMarkedNodes);
            
        

        return sortedList;
    

    internal static void VisitNode(Type node, Dictionary<Type, List<Type>> dependencies, HashSet<Type> visitedNodes, List<Type> sortedList, HashSet<Type> temporaryMarkedNodes)
    
        if (temporaryMarkedNodes.Contains(node))
        
            throw new ArgumentException("The graph contains a cycle.");
        

        if (!visitedNodes.Contains(node))
        
            temporaryMarkedNodes.Add(node);

            foreach (var dependentNode in dependencies[node])
            
                VisitNode(dependentNode, dependencies, visitedNodes, sortedList, temporaryMarkedNodes);
            

            visitedNodes.Add(node);
            temporaryMarkedNodes.Remove(node);
            sortedList.Insert(0, node);
        
    

　　

如果您觉得本文对你有用，不妨帮忙点个赞，或者在评论里给我一句赞美，小小成就都是今后继续为大家编写优质文章的动力，百小僧拜谢！ 欢迎您持续关注我的博客：)

作者：百小僧

版权所有，欢迎保留原文链接进行转载：)

数据结构与算法简记--拓扑排序

拓扑排序

---

问题

一个完整的项目往往会包含很多代码源文件。编译器在编译整个项目的时候，需要按照依赖关系，依次编译每个源文件。比如，A.cpp 依赖 B.cpp，那在编译的时候，编译器需要先编译 B.cpp，才能编译 A.cpp。

解析

解决思路与“图”这种数据结构的一个经典算法“拓扑排序算法”有关

拓扑排序

凡是需要通过局部顺序来推导全局顺序的，一般都能用拓扑排序来解决。

具体实现

把源文件与源文件之间的依赖关系，抽象成一个有向图。

每个源文件对应图中的一个顶点，源文件之间的依赖关系就是顶点之间的边。

如果 a 先于 b 执行，也就是说 b 依赖于 a，那么就在顶点 a 和顶点 b 之间，构建一条从 a 指向 b 的边。

而且，这个图不仅要是有向图，还要是一个有向无环图，也就是不能存在像 a->b->c->a 这样的循环依赖关系。

因为图中一旦出现环，拓扑排序就无法工作了。

数据结构

实际上，拓扑排序本身就是基于有向无环图的一个算法。

• public class Graph {
    private int v; // 顶点的个数
    private LinkedList<Integer> adj[]; // 邻接表
  
    public Graph(int v) {
      this.v = v;
      adj = new LinkedList[v];
      for (int i=0; i<v; ++i) {
        adj[i] = new LinkedList<>();
      }
    }
  
    public void addEdge(int s, int t) { // s先于t，边s->t
      adj[s].add(t);
    }
  }

   

算法实现

•  Kahn 算法
  • 贪心算法思想
  • 定义数据结构的时候，如果 s 需要先于 t 执行，那就添加一条 s 指向 t 的边。所以，如果某个顶点入度为 0， 也就表示，没有任何顶点必须先于这个顶点执行，那么这个顶点就可以执行了。
    • 先从图中，找出一个入度为 0 的顶点，将其输出到拓扑排序的结果序列中（对应代码中就是把它打印出来），
    • 并且把这个顶点从图中删除（也就是把这个顶点可达的顶点的入度都减 1）。
    • 循环执行上面的过程，直到所有的顶点都被输出。
    • 最后输出的序列，就是满足局部依赖关系的拓扑排序。

    • public void topoSortByKahn() {
        int[] inDegree = new int[v]; // 统计每个顶点的入度
        for (int i = 0; i < v; ++i) {
          for (int j = 0; j < adj[i].size(); ++j) {
            int w = adj[i].get(j); // i->w
            inDegree[w]++;
          }
        }
        LinkedList<Integer> queue = new LinkedList<>();
        for (int i = 0; i < v; ++i) {
          if (inDegree[i] == 0) queue.add(i);
        }
        while (!queue.isEmpty()) {
          int i = queue.remove();
          System.out.print("->" + i);
          for (int j = 0; j < adj[i].size(); ++j) {
            int k = adj[i].get(j);
            inDegree[k]--;
            if (inDegree[k] == 0) queue.add(k);
          }
        }
      }

       

• DFS 深度优先搜索算法

  • public void topoSortByDFS() {
      // 先构建逆邻接表，边s->t表示，s依赖于t，t先于s
      LinkedList<Integer> inverseAdj[] = new LinkedList[v];
      for (int i = 0; i < v; ++i) { // 申请空间
        inverseAdj[i] = new LinkedList<>();
      }
      for (int i = 0; i < v; ++i) { // 通过邻接表生成逆邻接表
        for (int j = 0; j < adj[i].size(); ++j) {
          int w = adj[i].get(j); // i->w
          inverseAdj[w].add(i); // w->i
        }
      }
      boolean[] visited = new boolean[v];
      for (int i = 0; i < v; ++i) { // 深度优先遍历图
        if (visited[i] == false) {
          visited[i] = true;
          dfs(i, inverseAdj, visited);
        }
      }
    }
    
    private void dfs(
        int vertex, LinkedList<Integer> inverseAdj[], boolean[] visited) {
      for (int i = 0; i < inverseAdj[vertex].size(); ++i) {
        int w = inverseAdj[vertex].get(i);
        if (visited[w] == true) continue;
        visited[w] = true;
        dfs(w, inverseAdj, visited);
      } // 先把vertex这个顶点可达的所有顶点都打印出来之后，再打印它自己
      System.out.print("->" + vertex);
    }

     

  • 重要部分
    1. 通过邻接表构造逆邻接表。邻接表中，边 s->t 表示 s 先于 t 执行，也就是 t 要依赖 s。在逆邻接表中，边 s->t 表示 s 依赖于 t，s 后于 t 执行。为什么这么转化呢？这个跟我们这个算法的实现思想有关。
    2. 递归处理每个顶点。对于顶点 vertex 来说，我们先输出它可达的所有顶点，也就是说，先把它依赖的所有的顶点输出了，然后再输出自己。

复杂度

O（V+E）

引申

一个用法：检测环，即循环依赖

对于kahn算法，如果输出的顶点少于图中顶点个数，则说明存在环。