更新拓扑排序代码模版

Author: itcharge

Templates/08.Graph/Graph-Topological-Sorting-DFS.py

@@ -0,0 +1,48 @@
+import collections
+
+class Solution:
+    # 拓扑排序，graph 中包含所有顶点的有向边关系（包括无边顶点）
+    def topologicalSortingDFS(self, graph: dict):
+        visited = set()                     # 记录当前顶点是否被访问过
+        onStack = set()                     # 记录同一次深搜时，当前顶点是否被访问过
+        order = []                          # 用于存储拓扑序列
+        hasCycle = False                    # 用于判断是否存在环
+        
+        def dfs(u):
+            nonlocal hasCycle
+            if u in onStack:                # 同一次深度优先搜索时，当前顶点被访问过，说明存在环
+                hasCycle = True
+            if u in visited or hasCycle:    # 当前节点被访问或者有环时直接返回
+                return
+            
+            visited.add(u)                  # 标记节点被访问
+            onStack.add(u)                  # 标记本次深搜时，当前顶点被访问
+    
+            for v in graph[u]:              # 遍历顶点 u 的邻接顶点 v
+                dfs(v)                      # 递归访问节点 v
+                    
+            order.append(u)                 # 后序遍历顺序访问节点 u
+            onStack.remove(u)               # 取消本次深搜时的 顶点访问标记
+        
+        for u in graph:
+            if u not in visited:
+                dfs(u)                      # 递归遍历未访问节点 u
+        
+        if hasCycle:                        # 判断是否存在环
+            return []                       # 存在环，无法构成拓扑序列
+        order.reverse()                     # 将后序遍历转为拓扑排序顺序
+        return order                        # 返回拓扑序列
+    
+    def findOrder(self, n: int, edges):
+        # 构建图
+        graph = dict()
+        for i in range(n):
+            graph[i] = []
+        for v, u in edges:
+            graph[u].append(v)
+        
+        return self.topologicalSortingDFS(graph)
+    
+print(Solution().findOrder(2, [[1,0]]))
+print(Solution().findOrder(4, [[1,0],[2,0],[3,1],[3,2]]))
+print(Solution().findOrder(1, []))

Templates/08.Graph/Graph-Topological-Sorting-Kahn.py

@@ -1,25 +1,41 @@
 import collections
 
-class solution:
-    def topologicalSorting(graph):
-        indegrees = {u: 0 for u in graph}
+class Solution:
+    # 拓扑排序，graph 中包含所有顶点的有向边关系（包括无边顶点）
+    def topologicalSortingKahn(self, graph: dict):
+        indegrees = {u: 0 for u in graph}   # indegrees 用于记录所有节点入度
         for u in graph:
             for v in graph[u]:
-                indegrees[v] += 1
-        
+                indegrees[v] += 1           # 统计所有节点入度
 
+        # 将入度为 0 的顶点存入集合 S 中
         S = collections.deque([u for u in indegrees if indegrees[u] == 0])
-        order = []
+        order = []                          # order 用于存储拓扑序列
 
         while S:
-            u = S.pop()
-            order.append(u)
-            for v in graph[u]:
-                indegrees[v] -= 1
-                if indegrees[v] == 0:
-                    S.append(v)
+            u = S.pop()                     # 从集合中选择一个没有前驱的顶点 0
+            order.append(u)                 # 将其输出到拓扑序列 order 中
+            for v in graph[u]:              # 遍历顶点 u 的邻接顶点 v
+                indegrees[v] -= 1           # 删除从顶点 u 出发的有向边
+                if indegrees[v] == 0:       # 如果删除该边后顶点 v 的入度变为 0
+                    S.append(v)             # 将其放入集合 S 中
 
-        size = len(indegrees)
-        if size == len(S):
-            return order
-        return None
+        if len(indegrees) != len(order):    # 还有顶点未遍历（存在环），无法构成拓扑序列
+            return []
+        return order                        # 返回拓扑序列
+    
+    
+    def findOrder(self, n: int, edges):
+        # 构建图
+        graph = dict()
+        for i in range(n):
+            graph[i] = []
+            
+        for u, v in edges:
+            graph[u].append(v)
+            
+        return self.topologicalSortingKahn(graph)
+    
+print(Solution().findOrder(2, [[1,0]]))
+print(Solution().findOrder(4, [[1,0],[2,0],[3,1],[3,2]]))
+print(Solution().findOrder(1, []))