Merge pull request amjadparacha#1 from eugenp/master

syncing

Author: sumit-bhawsar

.gitignore

@@ -30,7 +30,7 @@ out/
 .DS_Store
 
 # Maven
-log/
+log/*
 target/
 
 # Gradle
@@ -83,4 +83,5 @@ jta/transaction-logs/
 software-security/sql-injection-samples/derby.log
 spring-soap/src/main/java/com/baeldung/springsoap/gen/
 /report-*.json
-transaction.log
+transaction.log
+*-shell.log

akka-http/README.md

@@ -1,3 +1,7 @@
-## Relevant articles:
+## Akka HTTP
+
+This module contains articles about Akka HTTP. 
+
+### Relevant articles:
 
 - [Introduction to Akka HTTP](https://www.baeldung.com/akka-http)

akka-streams/README.md

@@ -1,3 +1,7 @@
+## Akka Streams
+
+This module contains articles about Akka Streams. 
+
 ### Relevant articles
 
 - [Guide to Akka Streams](https://www.baeldung.com/akka-streams)

algorithms-genetic/README.md

@@ -1,4 +1,8 @@
-## Relevant articles:
+## Genetic Algorithms
+
+This module contains articles about genetic algorithms. 
+
+### Relevant articles:
 
 - [Introduction to Jenetics Library](https://www.baeldung.com/jenetics)
 - [Ant Colony Optimization](https://www.baeldung.com/java-ant-colony-optimization)

algorithms-miscellaneous-1/README.md

@@ -1,9 +1,15 @@
-## Relevant articles:
+## Algorithms - Miscellaneous
+
+This module contains articles about algorithms. Some classes of algorithms, e.g., [sorting](/../algorithms-sorting) and
+[genetic algorithms](/../algorithms-genetic), have their own dedicated modules. 
+
+### Relevant articles:
 
 - [Validating Input With Finite Automata in Java](https://www.baeldung.com/java-finite-automata)
 - [Example of Hill Climbing Algorithm](https://www.baeldung.com/java-hill-climbing-algorithm)
 - [Monte Carlo Tree Search for Tic-Tac-Toe Game](https://www.baeldung.com/java-monte-carlo-tree-search)
 - [Binary Search Algorithm in Java](https://www.baeldung.com/java-binary-search)
 - [Introduction to Minimax Algorithm](https://www.baeldung.com/java-minimax-algorithm)
 - [How to Calculate Levenshtein Distance in Java?](https://www.baeldung.com/java-levenshtein-distance)
-- [How to Find the Kth Largest Element in Java](https://www.baeldung.com/java-kth-largest-element)
+- [How to Find the Kth Largest Element in Java](https://www.baeldung.com/java-kth-largest-element)
+- More articles: [[next -->]](/../algorithms-miscellaneous-2)

algorithms-miscellaneous-2/README.md

@@ -1,4 +1,9 @@
-## Relevant articles:
+## Algorithms - Miscellaneous
+
+This module contains articles about algorithms. Some classes of algorithms, e.g., [sorting](/../algorithms-sorting) and
+[genetic algorithms](/../algorithms-genetic), have their own dedicated modules. 
+
+### Relevant articles:
 
 - [Dijkstra Shortest Path Algorithm in Java](https://www.baeldung.com/java-dijkstra)
 - [Introduction to Cobertura](https://www.baeldung.com/cobertura)
@@ -8,3 +13,4 @@
 - [Create a Sudoku Solver in Java](https://www.baeldung.com/java-sudoku)
 - [Displaying Money Amounts in Words](https://www.baeldung.com/java-money-into-words)
 - [A Collaborative Filtering Recommendation System in Java](https://www.baeldung.com/java-collaborative-filtering-recommendations)
+- More articles: [[<-- prev]](/../algorithms-miscellaneous-1) [[next -->]](/../algorithms-miscellaneous-3)

algorithms-miscellaneous-3/README.md

@@ -1,3 +1,8 @@
+## Algorithms - Miscellaneous
+
+This module contains articles about algorithms. Some classes of algorithms, e.g., [sorting](/algorithms-sorting) and
+[genetic algorithms](/algorithms-genetic), have their own dedicated modules. 
+
 ## Relevant Articles:
 
 - [Java Two Pointer Technique](https://www.baeldung.com/java-two-pointer-technique)
@@ -9,3 +14,6 @@
 - [A Guide to the Folding Technique in Java](https://www.baeldung.com/folding-hashing-technique)
 - [Creating a Triangle with for Loops in Java](https://www.baeldung.com/java-print-triangle)
 - [Efficient Word Frequency Calculator in Java](https://www.baeldung.com/java-word-frequency)
+- [Interpolation Search in Java](https://www.baeldung.com/java-interpolation-search)
+- [The K-Means Clustering Algorithm in Java](https://www.baeldung.com/java-k-means-clustering-algorithm)
+- More articles: [[<-- prev]](/algorithms-miscellaneous-2) [[next -->]](/algorithms-miscellaneous-4)

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/breadthfirstsearch/BreadthFirstSearchAlgorithm.java

@@ -0,0 +1,54 @@
+package com.baeldung.algorithms.breadthfirstsearch;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+
+public class BreadthFirstSearchAlgorithm {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(BreadthFirstSearchAlgorithm.class);
+
+    public static <T> Optional<Tree<T>> search(T value, Tree<T> root) {
+        Queue<Tree<T>> queue = new ArrayDeque<>();
+        queue.add(root);
+
+        Tree<T> currentNode;
+        while (!queue.isEmpty()) {
+            currentNode = queue.remove();
+            LOGGER.info("Visited node with value: {}", currentNode.getValue());
+
+            if (currentNode.getValue().equals(value)) {
+                return Optional.of(currentNode);
+            } else {
+                queue.addAll(currentNode.getChildren());
+            }
+        }
+
+        return Optional.empty();
+    }
+
+    public static <T> Optional<Node<T>> search(T value, Node<T> start) {
+        Queue<Node<T>> queue = new ArrayDeque<>();
+        queue.add(start);
+
+        Node<T> currentNode;
+        Set<Node<T>> alreadyVisited = new HashSet<>();
+
+        while (!queue.isEmpty()) {
+            currentNode = queue.remove();
+            LOGGER.info("Visited node with value: {}", currentNode.getValue());
+
+            if (currentNode.getValue().equals(value)) {
+                return Optional.of(currentNode);
+            } else {
+                alreadyVisited.add(currentNode);
+                queue.addAll(currentNode.getNeighbors());
+                queue.removeAll(alreadyVisited);
+            }
+        }
+
+        return Optional.empty();
+    }
+
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/breadthfirstsearch/Node.java

@@ -0,0 +1,31 @@
+package com.baeldung.algorithms.breadthfirstsearch;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Node<T> {
+
+    private T value;
+    private Set<Node<T>> neighbors;
+
+    public Node(T value) {
+        this.value = value;
+        this.neighbors = new HashSet<>();
+    }
+
+    public T getValue() {
+        return value;
+    }
+
+    public Set<Node<T>> getNeighbors() {
+        return Collections.unmodifiableSet(neighbors);
+    }
+
+    public void connect(Node<T> node) {
+        if (this == node) throw new IllegalArgumentException("Can't connect node to itself");
+        this.neighbors.add(node);
+        node.neighbors.add(this);
+    }
+
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/breadthfirstsearch/Tree.java

@@ -0,0 +1,34 @@
+package com.baeldung.algorithms.breadthfirstsearch;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Tree<T> {
+
+    private T value;
+    private List<Tree<T>> children;
+
+    private Tree(T value) {
+        this.value = value;
+        this.children = new ArrayList<>();
+    }
+
+    public static <T> Tree<T> of(T value) {
+        return new Tree<>(value);
+    }
+
+    public T getValue() {
+        return value;
+    }
+
+    public List<Tree<T>> getChildren() {
+        return Collections.unmodifiableList(children);
+    }
+
+    public Tree<T> addChild(T value) {
+        Tree<T> newChild = new Tree<>(value);
+        children.add(newChild);
+        return newChild;
+    }
+}