Add strategy pattern to graph search functionality.

src/main/java/Context.java

@@ -0,0 +1,16 @@
+import org.jgrapht.Graph;
+import org.jgrapht.graph.DefaultEdge;
+
+public class Context {
+    SearchStrategy strategy;
+    Context(SearchStrategy strategy)
+    {
+        this.strategy = strategy;
+    }
+
+    Path searchByStrategy(){
+        strategy.selectAlgorithm();
+        strategy.executeAlgorithm();
+        return strategy.getPath();
+    }
+}

src/main/java/GraphData.java

@@ -141,18 +141,19 @@ public boolean addEdge(String srcLabel, String dstLabel) {
     }
 
     public Path GraphSearch(String src, String dst, Algorithm algo) {
-        GraphSearchAlgorithm searchAlgorithm;
+        SearchStrategy strategy;
         switch(algo) {
             case BFS:
-                searchAlgorithm = new BFS(src, dst, graphObject);
+                strategy = new BFS(src, dst, graphObject);
                 break;
             case DFS:
-                searchAlgorithm = new DFS(src, dst, graphObject);
+                strategy = new DFS(src, dst, graphObject);
                 break;
             default:
                 throw new IllegalArgumentException("Invalid choice of algorithm");
         }
-        return searchAlgorithm.graphSearch();
+        Context searchContext = new Context(strategy);
+        return searchContext.searchByStrategy();
     }
     public void removeEdge(String srcLabel, String dstLabel) throws Exception {
         DefaultEdge edgeexisting = graphObject.getEdge(srcLabel, dstLabel);

src/main/java/GraphSearch.java

@@ -33,21 +33,22 @@ public Path graphSearch() {
     protected abstract Path getPath();
 }
 
-class BFS extends GraphSearchAlgorithm {
+class BFS extends GraphSearchAlgorithm implements SearchStrategy {
     private LinkedList<String> queue;
 
     public BFS(String src, String dst, Graph graph) {
         super(src, dst, graph);
         queue = new LinkedList<>();
     }
 
-    protected void selectAlgorithm() {
+    @Override
+    public void selectAlgorithm() {
         System.out.println("Using BFS");
         visited.put(source, true);
         queue.add(source);
     }
-
-    protected void executeAlgorithm() {
+    @Override
+    public void executeAlgorithm() {
         while (!queue.isEmpty()) {
             String src = queue.poll();
             if (src.equals(destination)) {
@@ -64,7 +65,8 @@ protected void executeAlgorithm() {
         }
     }
 
-    protected Path getPath() {
+    @Override
+    public Path getPath() {
         String node = destination;
         path.add(node);
         if (visited.get(destination) != null) {
@@ -81,21 +83,23 @@ protected Path getPath() {
     }
 }
 
-class DFS extends GraphSearchAlgorithm {
+class DFS extends GraphSearchAlgorithm implements SearchStrategy {
     private Stack<String> stack;
 
     public DFS(String src, String dst, Graph graph) {
         super(src, dst, graph);
         stack = new Stack<>();
     }
 
-    protected void selectAlgorithm() {
+    @Override
+    public void selectAlgorithm() {
         System.out.println("Using DFS");
         visited.put(source, true);
         stack.push(source);
     }
 
-    protected void executeAlgorithm() {
+    @Override
+    public void executeAlgorithm() {
         while (!stack.isEmpty()) {
             String src = stack.pop();
             if (src.equals(destination)) {
@@ -112,7 +116,8 @@ protected void executeAlgorithm() {
         }
     }
 
-    protected Path getPath() {
+    @Override
+    public Path getPath() {
         String node = destination;
         path.add(node);
         if (visited.get(destination) != null) {

src/main/java/SearchStrategy.java

@@ -0,0 +1,6 @@
+public interface SearchStrategy {
+    void selectAlgorithm();
+    void executeAlgorithm();
+    Path getPath();
+}
+