From 22ffd963804bd51eb3e0b572e2583749f271538a Mon Sep 17 00:00:00 2001
From: Jonathan Turner <turner@atlantissrv.com]>
Date: Sun, 11 Feb 2024 21:58:12 -0500
Subject: [PATCH] Implemented functionality to record number of nodes used.

---
 .../Assignments/A1/models/helper/Solver.java  |  2 +-
 .../A1/solving_algorithms/DFS.java            | 16 +++++++++-
 .../solving_algorithms/PriorityTraversal.java | 32 ++++++++++++++++++-
 3 files changed, 47 insertions(+), 3 deletions(-)

diff --git a/src/main/java/Assignments/A1/models/helper/Solver.java b/src/main/java/Assignments/A1/models/helper/Solver.java
index c59c87d..e6b5f17 100644
--- a/src/main/java/Assignments/A1/models/helper/Solver.java
+++ b/src/main/java/Assignments/A1/models/helper/Solver.java
@@ -19,7 +19,7 @@ public interface Solver {
      *
      * @return the number of nodes from the interation.
      */
-    int getNumberOfNodes();
+    int getNumOfNodes();
 
     /**
      * Solves for, finds and creates a spanning representing the solving pattern.
diff --git a/src/main/java/Assignments/A1/solving_algorithms/DFS.java b/src/main/java/Assignments/A1/solving_algorithms/DFS.java
index fe61403..0f52e8a 100644
--- a/src/main/java/Assignments/A1/solving_algorithms/DFS.java
+++ b/src/main/java/Assignments/A1/solving_algorithms/DFS.java
@@ -17,6 +17,7 @@ public class DFS implements Solver {
     /* Private Fields for Searching */
     private final Board solved = new Board();
     private final List<String> tried = new ArrayList<>();
+    private int numOfNodes = 1;
 
     /**
      * Traverses through a Board using a Stack, allowing for DFS LIFO.
@@ -33,7 +34,7 @@ public class DFS implements Solver {
         BoardNode rootNode = new BoardNode(root, null);
         rootNode.depth = 0;
         stack.push(rootNode);
-
+        numOfNodes = 1;
         while (!stack.isEmpty()) {
             BoardNode current = stack.pop();
 
@@ -54,8 +55,21 @@ public class DFS implements Solver {
                 childNode.depth = current.depth+1;
                 stack.push(childNode);
                 current.addChild(childNode);
+                numOfNodes++;
             }
         }
         return null;
     }
+
+    /**
+     * Returns the number of nodes from the previous iterations.
+     *
+     * @precondition none
+     * @postcondition none
+     *
+     * @return the number of nodes from the interations.
+     */
+    public int getNumOfNodes() {
+        return numOfNodes;
+    }
 }
diff --git a/src/main/java/Assignments/A1/solving_algorithms/PriorityTraversal.java b/src/main/java/Assignments/A1/solving_algorithms/PriorityTraversal.java
index ddf0838..e023d84 100644
--- a/src/main/java/Assignments/A1/solving_algorithms/PriorityTraversal.java
+++ b/src/main/java/Assignments/A1/solving_algorithms/PriorityTraversal.java
@@ -10,23 +10,39 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.PriorityQueue;
 
+/**
+ * Used to traverse a Spanning Tree of 8 Puzzle using a provided comparitor for a Priority Queue.
+ *
+ * @author Jonathan Turner
+ * @version Spring 2024
+ */
 public class PriorityTraversal implements Solver {
 
     private final Board solved = new Board();
     private final HashSet<Board> visited = new HashSet<>();
-
     private final Comparator<BoardNode> comparator;
+    private int numOfNodes = 1;
 
     public PriorityTraversal(Comparator<BoardNode> type) {
         this.comparator = type;
     }
 
+    /**
+     * Traverses through the list using a priority queue which is specified by the comparitor at constructor.
+     *
+     * @precondition root != null
+     * @postcondition a spanning tree is created.
+     *
+     * @param root the first node/initial start.
+     * @return the solved leaf node.
+     */
     public BoardNode traverse(Board root) {
         visited.clear();
         PriorityQueue<BoardNode> boards = new PriorityQueue<>(comparator);
         boards.add(new BoardNode(root, null));
         BoardNode node = null;
         Board current = new Board(root);
+        numOfNodes = 1;
         while (!current.equals(solved) && !boards.isEmpty()) {
             node = boards.poll();
             current = node.board;
@@ -41,8 +57,22 @@ public class PriorityTraversal implements Solver {
                 BoardNode childNode = new BoardNode(child, node);
                 boards.add(childNode);
                 node.addChild(childNode);
+                numOfNodes++;
             }
         }
         return node;
     }
+
+    /**
+     * Returns the number of nodes from the previous iterations.
+     *
+     * @precondition none
+     * @postcondition none
+     *
+     * @return the number of nodes from the interation.
+     */
+    @Override
+    public int getNumOfNodes() {
+        return this.numOfNodes;
+    }
 }