Add Depth First Search and Graph structure

allalgorithms/searches/__init__.py

@@ -1,3 +1,4 @@
 from .binary_search import *
 from .fibonacci_search import *
 from .jump_search import *
+from .depth_first_search import *

allalgorithms/searches/depth_first_search.py

@@ -0,0 +1,30 @@
+# -*- coding: UTF-8 -*-
+#
+# Depth first search works for a graph structure, comprised of adjacency lists.
+# The All ▲lgorithms library for python
+#
+# Contributed by: Thomas Basche
+# Github: @tombasche
+#
+from graph import Graph
+
+
+def dfs(graph: Graph, source: str, target: str):
+    """
+    Given a graph and a source node, find a target using Depth-first search
+
+    Great for traversing directed acyclic graphs, and thus job scheduling.
+    """
+    visited = [source]
+    path = []
+    steps = 1
+    while visited:
+        node = visited.pop()
+        if node == target:
+            return target, path
+        if node in path:
+            continue
+        path.append(node)
+        for neighbour in graph.neighbours(node):
+            visited.append(neighbour)
+            steps += 1

allalgorithms/structures/__init__.py

@@ -0,0 +1 @@
+from .graph import *

allalgorithms/structures/graph.py

@@ -0,0 +1,29 @@
+"""
+Simple graph class
+
+Contributed by: Thomas Basche
+GitHub: @tombasche
+
+"""
+from typing import Dict, List
+
+
+class Graph:
+    """
+    A graph represented by a dictionary of adjacency lists
+    """
+    def __init__(self):
+        self.edges = {}
+
+    def neighbours(self, node: str) -> List:
+        return self.edges[node]
+
+    def __str__(self) -> Dict:
+        return self.edges
+
+    def __unicode__(self) -> Dict:
+        return self.edges
+
+    def __repr__(self) -> Dict:
+        return self.edges
+

docs/searches/depth-first-search.md

@@ -0,0 +1,44 @@
+# Depth first Search
+
+Depth first search enables the finding of a specific node within a graph structure by traversing down the deepest paths first. 
+## Install
+
+```
+pip install allalgorithms
+```
+
+## Usage
+
+```py
+from allalgorithms.structures import Graph
+from allalgorithms.searches import dfs
+
+g = Graph()
+g.edges = {
+    'A': ['B', 'C', 'G'],
+    'B': ['A', 'C', 'D'],
+    'C': ['A', 'B'],
+    'D': ['B', 'F', 'E'],
+    'E': ['D', 'F'],
+    'F': ['D', 'E'],
+    'G': ['A', 'H'],
+    'H': ['G'],
+}
+
+print(dfs(g, 'A', 'F))
+# -> 'F', ['A', 'G', 'H', 'C', 'B', 'D', 'E']
+
+
+```
+
+## API
+
+### dfs(array, source_node, query)
+
+> Return node name if its found, otherwise returns `None`, as well as the path it took.
+
+##### Params:
+
+- `graph`: Graph object
+- `source node`: Element to start search from
+- `query`: Element to search for in the array

tests/test_searches.py

@@ -3,31 +3,50 @@
 from allalgorithms.searches import (
     binary_search,
     fibonacci_search,
-    jump_search
+    dfs
 )
+from allalgorithms.structures import Graph
+
 
 class TestSearches(unittest.TestCase):
 
-	def test_binary_search(self):
-		arr = [1, 2, 3, 7, 10, 19, 27, 77]
-		self.assertEqual(3, binary_search(arr, 7))
-		self.assertEqual(7, binary_search(arr, 77))
-		self.assertEqual(None, binary_search(arr, 8))
-		self.assertEqual(None, binary_search(arr, -1))
-
-	def test_fibonacci_search(self):
-		arr = [1, 2, 3, 7, 10, 19, 27, 77]
-		self.assertEqual(3, fibonacci_search(arr, 7))
-		self.assertEqual(7, fibonacci_search(arr, 77))
-		self.assertEqual(None, fibonacci_search(arr, 8))
-		self.assertEqual(None, fibonacci_search(arr, -1))
-
-	def test_jump_search(self):
-		arr = [1, 2, 3, 7, 10, 19, 27, 77]
-		self.assertEqual(3, binary_search(arr, 7))
-		self.assertEqual(7, binary_search(arr, 77))
-		self.assertEqual(None, binary_search(arr, 8))
-		self.assertEqual(None, binary_search(arr, -1))
+    def test_binary_search(self):
+        arr = [1, 2, 3, 7, 10, 19, 27, 77]
+        self.assertEqual(3, binary_search(arr, 7))
+        self.assertEqual(7, binary_search(arr, 77))
+        self.assertEqual(None, binary_search(arr, 8))
+        self.assertEqual(None, binary_search(arr, -1))
+
+    def test_fibonacci_search(self):
+        arr = [1, 2, 3, 7, 10, 19, 27, 77]
+        self.assertEqual(3, fibonacci_search(arr, 7))
+        self.assertEqual(7, fibonacci_search(arr, 77))
+        self.assertEqual(None, fibonacci_search(arr, 8))
+        self.assertEqual(None, fibonacci_search(arr, -1))
+
+    def test_jump_search(self):
+        arr = [1, 2, 3, 7, 10, 19, 27, 77]
+        self.assertEqual(3, binary_search(arr, 7))
+        self.assertEqual(7, binary_search(arr, 77))
+        self.assertEqual(None, binary_search(arr, 8))
+        self.assertEqual(None, binary_search(arr, -1))
+
+    def test_dfs_search(self):
+        g = Graph()
+        g.edges = {
+            'A': ['B', 'C', 'G'],
+            'B': ['A', 'C', 'D'],
+            'C': ['A', 'B'],
+            'D': ['B', 'F', 'E'],
+            'E': ['D', 'F'],
+            'F': ['D', 'E'],
+            'G': ['A', 'H'],
+            'H': ['G'],
+        }
+        result = dfs(g, 'A', 'F')
+        path = ['A', 'G', 'H', 'C', 'B', 'D', 'E']
+        self.assertEqual(('F', path), result)
+
 
 if __name__ == '__main__':
-	unittest.main()
+    unittest.main()