Optimize BreadthFirstSearch implementation with bug fixes and improvements

- Fix potential infinite loop by adding cycle detection using HashSet
- Add null value and null node handling for better robustness
- Optimize visited node lookups from O(n) to O(1) using HashSet
- Clear previous search results for multiple search support
- Add defensive copying in getVisited() to prevent external state modification
- Improve code organization and documentation
- Add consistent node visitation handling
- Fix root node visitation order inconsistency
- Prevent redundant node processing

Author: manishraj27

src/main/java/com/thealgorithms/searches/BreadthFirstSearch.java

@@ -3,47 +3,67 @@
 import com.thealgorithms.datastructures.Node;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
 import java.util.Queue;
+import java.util.Set;
 
 /**
- * @author: caos321
- * @date: 31 October 2021 (Sunday)
- * @wiki: https://en.wikipedia.org/wiki/Breadth-first_search
+ * Breadth-First Search implementation for tree/graph traversal.
+ * @author caos321
+ * @co-author manishraj27
+ * @see <a href="https://en.wikipedia.org/wiki/Breadth-first_search">Breadth-first search</a>
  */
 public class BreadthFirstSearch<T> {
 
     private final List<T> visited = new ArrayList<>();
+    private final Set<T> visitedSet = new HashSet<>();
 
-    public Optional<Node<T>> search(final Node<T> node, final T value) {
-        if (node == null) {
+    /**
+     * Performs a breadth-first search to find a node with the given value.
+     *
+     * @param root The root node to start the search from
+     * @param value The value to search for
+     * @return Optional containing the found node, or empty if not found
+     */
+    public Optional<Node<T>> search(final Node<T> root, final T value) {
+        if (value == null || root == null) {
             return Optional.empty();
         }
-        if (node.getValue().equals(value)) {
-            // add root node to visited
-            visited.add(value);
-            return Optional.of(node);
-        }
-        visited.add(node.getValue());
 
-        Queue<Node<T>> queue = new ArrayDeque<>(node.getChildren());
+        visited.clear();
+        visitedSet.clear();
+
+        Queue<Node<T>> queue = new ArrayDeque<>();
+        queue.offer(root);
+        visitedSet.add(root.getValue());
+        visited.add(root.getValue());
 
         while (!queue.isEmpty()) {
             final Node<T> current = queue.poll();
-            visited.add(current.getValue());
 
-            if (current.getValue().equals(value)) {
+            if (value.equals(current.getValue())) {
                 return Optional.of(current);
             }
 
-            queue.addAll(current.getChildren());
+            for (Node<T> child : current.getChildren()) {
+                if (child != null && !visitedSet.contains(child.getValue())) {
+                    queue.offer(child);
+                    visitedSet.add(child.getValue());
+                    visited.add(child.getValue());
+                }
+            }
         }
-
         return Optional.empty();
     }
 
+    /**
+     * Returns the list of nodes in the order they were visited.
+     *
+     * @return A new list containing the visited nodes
+     */
     public List<T> getVisited() {
-        return visited;
+        return new ArrayList<>(visited);
     }
 }