Refactoring on DFS

Add unit test

Author: evilz

src/Algorithms/GraphTraversal/DepthFirstSearch.cs

@@ -9,59 +9,55 @@ public static class DepthFirstSearch
         public static IEnumerable<T> Explore<T>(T start, Func<T, IEnumerable<T>> getNeighbours, Func<T, bool> isEnd = null)
         {
             var visited = new HashSet<T>();
-            var stack = new Stack<T>();
+            var toVisit = new Stack<T>();
 
-            stack.Push(start);
+            toVisit.Push(start);
 
-            while (stack.Any())
+            while (toVisit.Any())
             {
-                var current = stack.Pop();
-                
-                if (!visited.Add(current)) { continue; }
+                var current = toVisit.Pop();
+
+                visited.Add(current);
 
                 yield return current;
 
                 if (isEnd != null && isEnd(current))
                     break;
 
-                var neighbours = getNeighbours(current)
-                                .Where(n => !visited.Contains(n));
+                var neighbours = GetNotVisitiedNeighbours(getNeighbours, current, visited);
 
-                foreach (var neighbour in neighbours.Reverse())
-                    stack.Push(neighbour);
+                neighbours.ForEach(toVisit.Push);
             }
 
         }
-
+        
         public static IEnumerable<T> FindPath<T>(T start, Func<T, IEnumerable<T>> getNeighbours, Func<T, bool> isEnd)
         {
             var visited = new HashSet<T>();
-            var stack = new Stack<T>();
+            var toVisit = new Stack<T>();
             var path = new Stack<T>();
 
-            stack.Push(start);
+            toVisit.Push(start);
 
-            while (stack.Any())
+            while (toVisit.Any())
             {
-                var current = stack.Pop();
+                var current = toVisit.Pop();
                 path.Push(current);
 
                 visited.Add(current);
 
                 if (isEnd(current))
                     return path.Reverse();
 
-                var neighbours = getNeighbours(current)
-                                    .Where(n => !visited.Contains(n))
-                                    .ToArray();
+                var neighbours = GetNotVisitiedNeighbours(getNeighbours, current, visited);
 
                 if (!neighbours.Any())
                 {
-                    if(!stack.Any()) { break; }
+                    if(!toVisit.Any()) { break; }
 
                     var lastInPath = path.Peek();
                     var lastInPathNeighbours = getNeighbours(lastInPath);
-                    var next = stack.Peek();
+                    var next = toVisit.Peek();
                     while (!lastInPathNeighbours.Contains(next))
                     {
                         path.Pop();
@@ -70,14 +66,22 @@ public static IEnumerable<T> FindPath<T>(T start, Func<T, IEnumerable<T>> getNei
                     }
 
                 }
-    
-
-                foreach (var neighbour in neighbours.Reverse())
-                    stack.Push(neighbour);
+                else
+                {
+                    neighbours.ForEach(toVisit.Push);
+                }
             }
 
             return Enumerable.Empty<T>();
 
         }
+
+        private static List<T> GetNotVisitiedNeighbours<T>(Func<T, IEnumerable<T>> getNeighbours, T current, HashSet<T> visited)
+        {
+            return getNeighbours(current)
+                .Where(n => !visited.Contains(n))
+                .Reverse()
+                .ToList();
+        }
     }
 }

tests/AlgorithmTests/GraphTraversal/DepthFirstSearchTests.cs

@@ -7,7 +7,7 @@
 
 namespace AlgorithmTests.GraphTraversal
 {
-    class DepthFirstSearchTests
+    public class DepthFirstSearchTests
     {
         [Test]
         public void Small_maze_test()
@@ -24,26 +24,13 @@ public void Small_maze_test()
 %.-----------------%  
 %%%%%%%%%%%%%%%%%%%%";
 
-            Func<Point, char> getCell = p => maze.Split(new[] { Environment.NewLine }, StringSplitOptions.None).Skip(1).ToArray()[p.Y][p.X];
-
-            Func<Point, IEnumerable<Point>> getNeighbours = p =>
-             {
-                 var allPoints = new[]
-                 {
-                    new Point(p.X, p.Y - 1), // top
-                     new Point(p.X + 1, p.Y), // right
-                     new Point(p.X, p.Y + 1), // bottom
-                     new Point(p.X - 1, p.Y), // left
-                 };
-
-                 return allPoints.Where(x => getCell(x) != '%');
-
-             };
+            Func<Point, char> getCell = GetCell(maze);
+            Func<Point, IEnumerable<Point>> getNeighbours = GetNeighbours(getCell);
 
 
             var result = DepthFirstSearch.Explore(start, getNeighbours);
 
-            List<Point> path = new List<Point>();
+            var path = new List<Point>();
             foreach (var item in result)
             {
                 path.Add(item);
@@ -110,29 +97,13 @@ public void Small_maze_FindPath_test()
 %.-----------------%  
 %%%%%%%%%%%%%%%%%%%%";
 
-            Func<Point, char> getCell = p =>
-            {
-                return maze.Split(new[] { Environment.NewLine }, StringSplitOptions.None).Skip(1).ToArray()[p.Y][p.X];
-            };
-
-            Func<Point, IEnumerable<Point>> getNeighbours = p =>
-            {
-                var allPoints = new[]
-                {
-                    new Point(p.X, p.Y - 1), // top
-                     new Point(p.X + 1, p.Y), // right
-                     new Point(p.X, p.Y + 1), // bottom
-                     new Point(p.X - 1, p.Y), // left
-                };
-
-                return allPoints.Where(x => getCell(x) != '%');
-
-            };
+            var getCell = GetCell(maze);
+            var getNeighbours = GetNeighbours(getCell);
 
 
             var result = DepthFirstSearch.FindPath(start, getNeighbours,point => point == end ).ToArray();
 
-            for (int i = 0; i < result.Count() - 1; i++)
+            for (var i = 0; i < result.Length - 1; i++)
             {
                 var twoPoints = result.Skip(i).Take(2).ToArray();
                 var point1 = twoPoints[0];
@@ -150,17 +121,14 @@ public void Tiny_maze_FindPath_test()
             var start = new Point(1, 3);
             var end = new Point(7, 3);
 
-            var maze = @"
+            const string maze = @"
 %%%%%%%%%
 %-------%
 %%%%-%%%%
 %P------%
 %%%%%%%%%";
 
-            Func<Point, char> getCell = p =>
-            {
-                return maze.Split(new[] { Environment.NewLine }, StringSplitOptions.None).Skip(1).ToArray()[p.Y][p.X];
-            };
+            Func<Point, char> getCell = p => maze.Split(new[] { Environment.NewLine }, StringSplitOptions.None).Skip(1).ToArray()[p.Y][p.X];
 
             Func<Point, IEnumerable<Point>> getNeighbours = p =>
             {
@@ -179,7 +147,7 @@ public void Tiny_maze_FindPath_test()
 
             var result = DepthFirstSearch.FindPath(start, getNeighbours, point => point == end).ToArray();
 
-            for (int i = 0; i < result.Count() - 1; i++)
+            for (var i = 0; i < result.Length - 1; i++)
             {
                 var twoPoints = result.Skip(i).Take(2).ToArray();
                 var point1 = twoPoints[0];
@@ -191,23 +159,47 @@ public void Tiny_maze_FindPath_test()
             Assert.That(result.Last(), Is.EqualTo(end));
         }
 
+        [Test]
+        public void Explore_should_stop_on_specific_condition()
+        {
+            var start = new Point(1, 3);
+            var end = new Point(1, 1);
+            Func<Point,bool> endCondition = point => point == end;
+           
+            const string maze = @"
+%%%%%%%%%
+%-------%
+%%%%-%%%%
+%P------%
+%%%%%%%%%";
+
+            var getCell = GetCell(maze);
+            var getNeighbours = GetNeighbours(getCell);
+
+            var result = DepthFirstSearch
+                .Explore(start, getNeighbours, endCondition)
+                .ToArray();
+
+            Assert.That(result.Count(), Is.EqualTo(12));
+            Assert.That(result.Last(),Is.EqualTo(end));
+        }
+
         [Test]
         public void FindPath_should_return_empty_enumerqble_when_no_path_found()
         {
             var start = new Point(1, 3);
             var end = new Point(7, 1);
 
-            var maze = @"
+            const string maze = @"
 %%%%%%%%%
 %-------%
 %%%%%%%%%
 %P------%
 %%%%%%%%%";
 
-            Func<Point, char> getCell = GetCell(maze);
-            Func<Point, IEnumerable<Point>> getNeighbours = GetNeighbours(getCell);
-
-
+            var getCell = GetCell(maze);
+            var getNeighbours = GetNeighbours(getCell);
+            
             var result = DepthFirstSearch.FindPath(start, getNeighbours, point => point == end);
 
             Assert.That(result, Is.Empty);
@@ -226,7 +218,6 @@ private static Func<Point, IEnumerable<Point>> GetNeighbours(Func<Point, char> g
                 };
 
                 return allPoints.Where(x => getCell(x) != '%');
-
             };
         }