Merge branch 'master' of https://github.com/exterkamps/Python-Data-Structures

Author: exterkamp

README.md

@@ -28,6 +28,7 @@ $ coverage report -m
 * [Mergesort](sorts/mergesort.py)
 * [Radixsort](sorts/radixsort.py)
 * [Heapsort](sorts/heapsort.py)
+* [Topological Sort](structures/graph.py)
 
 ### Searching Algorithms
 * [BinarySearch](searches/binary_search.py)

structures/graph.py

@@ -1,3 +1,5 @@
+from collections import defaultdict
+
 class GraphNode():
 
     def __init__(self, val):
@@ -9,10 +11,65 @@ def add_adjacent(self, node):
 
     def remove_adjacent(self, node):
         self.adjacent_list.remove(node)
+
+class Graph():
+    """
+    A directed graph represented with an adjacency list.
+    """
+
+    def __init__(self, verticies):
+        self.graph = defaultdict(list)
+        self.verticies = verticies
 
-    def contains_universal_sink(self):
+    def add_edge(self, source, destination):
+        """
+        Add an edge to the graph.
+
+        Add an edge pointing from source vertex
+        to destination vertex.
+
+        Args:
+            source: the source vertex
+            destination: the destination vertex
+
         """
-        Check if this node is part of a graph with a universal sink.
+        self.graph[source].append(destination)
 
+    def topological_sort(self):
         """
-        
+        Sort the graph topologically.
+
+        A topological sort lists nodes in such a way
+        that every node 's' in 's' -> 'd' directed pairs
+        is listed before 'd.'  This will not work in a 
+        graph that contains cycles.
+
+        The algorithm looks at every node, and does a
+        dfs for each node adjacent to the node and then adds
+        the originating node to a stack once all adjacent
+        nodes have been searched.  In the end, the stack
+        will be in order of a possible topological sort.
+
+        Topological sorts are not necessarily unique.
+
+        Returns:
+            A list of vertices in a topological ordering.
+
+        """
+        visited = set()
+        stack = []
+
+        def dfs(vertex):
+            visited.add(vertex)
+            for i in self.graph[vertex]:
+                if i not in visited:
+                    dfs(i)
+            
+            stack.insert(0, vertex)
+        
+        for i in range(self.verticies):
+            if i not in visited:
+                dfs(i)
+        
+        return stack
+    

tests/test_topological_sort.py

@@ -0,0 +1,21 @@
+import unittest
+from structures.graph import Graph
+
+class TestGraphTopoSort(unittest.TestCase):
+
+    def test_topological_sort(self):
+        graph = Graph(6)
+        graph.add_edge(5,2)
+        graph.add_edge(5,0)
+
+        graph.add_edge(4,0)
+        graph.add_edge(4,1)
+
+        graph.add_edge(2,3)
+
+        graph.add_edge(3,1)
+
+        self.assertEqual([5, 4, 2, 3, 1, 0], graph.topological_sort())
+
+
+