Merge branch 'master' of https://github.com/eugenp/tutorials

.gitignore

@@ -30,7 +30,7 @@ out/
 .DS_Store
 
 # Maven
-log/
+log/*
 target/
 
 # Gradle
@@ -83,4 +83,11 @@ 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
+
+apache-cxf/cxf-aegis/baeldung.xml
+apache-fop/src/test/resources/input.xml
+apache-fop/src/test/resources/output_herold.pdf
+apache-fop/src/test/resources/output_html2fo.pdf
+apache-fop/src/test/resources/output_jtidy.pdf

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,13 @@
-## 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-2/src/test/java/com/baeldung/algorithms/astar/Graph.java

@@ -0,0 +1,30 @@
+package com.baeldung.algorithms.astar;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+
+public class Graph<T extends GraphNode> {
+    private final Set<T> nodes;
+
+    private final Map<String, Set<String>> connections;
+
+    public Graph(Set<T> nodes, Map<String, Set<String>> connections) {
+        this.nodes = nodes;
+        this.connections = connections;
+    }
+
+    public T getNode(String id) {
+        return nodes.stream()
+            .filter(node -> node.getId().equals(id))
+            .findFirst()
+            .orElseThrow(() -> new IllegalArgumentException("No node found with ID"));
+    }
+
+    public Set<T> getConnections(T node) {
+        return connections.get(node.getId()).stream()
+            .map(this::getNode)
+            .collect(Collectors.toSet());
+    }
+}

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/astar/GraphNode.java

@@ -0,0 +1,5 @@
+package com.baeldung.algorithms.astar;
+
+public interface GraphNode {
+    String getId();
+}

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/astar/RouteFinder.java

@@ -0,0 +1,66 @@
+package com.baeldung.algorithms.astar;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.stream.Collectors;
+
+public class RouteFinder<T extends GraphNode> {
+    private final Graph<T> graph;
+    private final Scorer<T> nextNodeScorer;
+    private final Scorer<T> targetScorer;
+
+    public RouteFinder(Graph<T> graph, Scorer<T> nextNodeScorer, Scorer<T> targetScorer) {
+        this.graph = graph;
+        this.nextNodeScorer = nextNodeScorer;
+        this.targetScorer = targetScorer;
+    }
+
+    public List<T> findRoute(T from, T to) {
+        Map<T, RouteNode<T>> allNodes = new HashMap<>();
+        Queue<RouteNode> openSet = new PriorityQueue<>();
+
+        RouteNode<T> start = new RouteNode<>(from, null, 0d, targetScorer.computeCost(from, to));
+        allNodes.put(from, start);
+        openSet.add(start);
+
+        while (!openSet.isEmpty()) {
+            System.out.println("Open Set contains: " + openSet.stream().map(RouteNode::getCurrent).collect(Collectors.toSet()));
+            RouteNode<T> next = openSet.poll();
+            System.out.println("Looking at node: " + next);
+            if (next.getCurrent().equals(to)) {
+                System.out.println("Found our destination!");
+
+                List<T> route = new ArrayList<>();
+                RouteNode<T> current = next;
+                do {
+                    route.add(0, current.getCurrent());
+                    current = allNodes.get(current.getPrevious());
+                } while (current != null);
+
+                System.out.println("Route: " + route);
+                return route;
+            }
+
+            graph.getConnections(next.getCurrent()).forEach(connection -> {
+                double newScore = next.getRouteScore() + nextNodeScorer.computeCost(next.getCurrent(), connection);
+                RouteNode<T> nextNode = allNodes.getOrDefault(connection, new RouteNode<>(connection));
+                allNodes.put(connection, nextNode);
+
+                if (nextNode.getRouteScore() > newScore) {
+                    nextNode.setPrevious(next.getCurrent());
+                    nextNode.setRouteScore(newScore);
+                    nextNode.setEstimatedScore(newScore + targetScorer.computeCost(connection, to));
+                    openSet.add(nextNode);
+                    System.out.println("Found a better route to node: " + nextNode);
+                }
+            });
+        }
+
+        throw new IllegalStateException("No route found");
+    }
+
+}

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/astar/RouteNode.java

@@ -0,0 +1,67 @@
+package com.baeldung.algorithms.astar;
+
+import java.util.StringJoiner;
+
+class RouteNode<T extends GraphNode> implements Comparable<RouteNode> {
+    private final T current;
+    private T previous;
+    private double routeScore;
+    private double estimatedScore;
+
+    RouteNode(T current) {
+        this(current, null, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
+    }
+
+    RouteNode(T current, T previous, double routeScore, double estimatedScore) {
+        this.current = current;
+        this.previous = previous;
+        this.routeScore = routeScore;
+        this.estimatedScore = estimatedScore;
+    }
+
+    T getCurrent() {
+        return current;
+    }
+
+    T getPrevious() {
+        return previous;
+    }
+
+    double getRouteScore() {
+        return routeScore;
+    }
+
+    double getEstimatedScore() {
+        return estimatedScore;
+    }
+
+    void setPrevious(T previous) {
+        this.previous = previous;
+    }
+
+    void setRouteScore(double routeScore) {
+        this.routeScore = routeScore;
+    }
+
+    void setEstimatedScore(double estimatedScore) {
+        this.estimatedScore = estimatedScore;
+    }
+
+    @Override
+    public int compareTo(RouteNode other) {
+        if (this.estimatedScore > other.estimatedScore) {
+            return 1;
+        } else if (this.estimatedScore < other.estimatedScore) {
+            return -1;
+        } else {
+            return 0;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", RouteNode.class.getSimpleName() + "[", "]").add("current=" + current)
+            .add("previous=" + previous).add("routeScore=" + routeScore).add("estimatedScore=" + estimatedScore)
+            .toString();
+    }
+}

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/astar/Scorer.java

@@ -0,0 +1,5 @@
+package com.baeldung.algorithms.astar;
+
+public interface Scorer<T extends GraphNode> {
+    double computeCost(T from, T to);
+}

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/astar/underground/HaversineScorer.java

@@ -0,0 +1,19 @@
+package com.baeldung.algorithms.astar.underground;
+
+import com.baeldung.algorithms.astar.Scorer;
+
+public class HaversineScorer implements Scorer<Station> {
+    @Override
+    public double computeCost(Station from, Station to) {
+        double R = 6372.8; // In kilometers
+
+        double dLat = Math.toRadians(to.getLatitude() - from.getLatitude());
+        double dLon = Math.toRadians(to.getLongitude() - from.getLongitude());
+        double lat1 = Math.toRadians(from.getLatitude());
+        double lat2 = Math.toRadians(to.getLatitude());
+
+        double a = Math.pow(Math.sin(dLat / 2),2) + Math.pow(Math.sin(dLon / 2),2) * Math.cos(lat1) * Math.cos(lat2);
+        double c = 2 * Math.asin(Math.sqrt(a));
+        return R * c;
+    }
+}

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/astar/underground/Station.java

@@ -0,0 +1,42 @@
+package com.baeldung.algorithms.astar.underground;
+
+import java.util.StringJoiner;
+
+import com.baeldung.algorithms.astar.GraphNode;
+
+public class Station implements GraphNode {
+    private final String id;
+    private final String name;
+    private final double latitude;
+    private final double longitude;
+
+    public Station(String id, String name, double latitude, double longitude) {
+        this.id = id;
+        this.name = name;
+        this.latitude = latitude;
+        this.longitude = longitude;
+    }
+
+    @Override
+    public String getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public double getLatitude() {
+        return latitude;
+    }
+
+    public double getLongitude() {
+        return longitude;
+    }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", Station.class.getSimpleName() + "[", "]").add("id='" + id + "'")
+            .add("name='" + name + "'").add("latitude=" + latitude).add("longitude=" + longitude).toString();
+    }
+}

algorithms-miscellaneous-3/README.md

@@ -14,4 +14,6 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [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)
-- More articles: [[<-- prev]](/algorithms-miscellaneous-2) [[next -->]](/algorithms-miscellaneous-4)
+- [The K-Means Clustering Algorithm in Java](https://www.baeldung.com/java-k-means-clustering-algorithm)
+- [Creating a Custom Annotation in Java](https://www.baeldung.com/java-custom-annotation)
+- More articles: [[<-- prev]](/algorithms-miscellaneous-2) [[next -->]](/algorithms-miscellaneous-4)

algorithms-miscellaneous-4/README.md

@@ -1,9 +1,14 @@
-## Relevant articles:
+## Algorithms - Miscellaneous
+
+This module contains articles about algorithms. Some classes of algorithms, e.g., [sorting](https://github.com/eugenp/tutorials/blob/algorithms-sorting) and [genetic algorithms](https://github.com/eugenp/tutorials/blob/algorithms-genetic), have their own dedicated modules.
+
+### Relevant articles:
 
 - [Multi-Swarm Optimization Algorithm in Java](https://www.baeldung.com/java-multi-swarm-algorithm)
-- [String Search Algorithms for Large Texts](https://www.baeldung.com/java-full-text-search-algorithms)
 - [Check If a String Contains All The Letters of The Alphabet](https://www.baeldung.com/java-string-contains-all-letters)
 - [Find the Middle Element of a Linked List](https://www.baeldung.com/java-linked-list-middle-element)
 - [Find Substrings That Are Palindromes in Java](https://www.baeldung.com/java-palindrome-substrings)
 - [Find the Longest Substring without Repeating Characters](https://www.baeldung.com/java-longest-substring-without-repeated-characters)
-- [Permutations of an Array in Java](https://www.baeldung.com/java-array-permutations)
+- [Permutations of an Array in Java](https://www.baeldung.com/java-array-permutations)
+- [Find the Smallest Missing Integer in an Array](https://www.baeldung.com/java-smallest-missing-integer-in-array)
+- More articles: [[<-- prev]](/algorithms-miscellaneous-3) [[next -->]](/algorithms-miscellaneous-5)

algorithms-miscellaneous-4/src/main/java/com/baeldung/algorithms/smallestinteger/SmallestMissingPositiveInteger.java

@@ -0,0 +1,37 @@
+package com.baeldung.algorithms.smallestinteger;
+
+import java.util.Arrays;
+
+public class SmallestMissingPositiveInteger {
+    public static int searchInSortedArray(int[] input) {
+        for (int i = 0; i < input.length; i++) {
+            if (i != input[i]) {
+                return i;
+            }
+        }
+
+        return input.length;
+    }
+
+    public static int searchInUnsortedArraySortingFirst(int[] input) {
+        Arrays.sort(input);
+        return searchInSortedArray(input);
+    }
+
+    public static int searchInUnsortedArrayBooleanArray(int[] input) {
+        boolean[] flags = new boolean[input.length];
+        for (int number : input) {
+            if (number < flags.length) {
+                flags[number] = true;
+            }
+        }
+
+        for (int i = 0; i < flags.length; i++) {
+            if (!flags[i]) {
+                return i;
+            }
+        }
+
+        return flags.length;
+    }
+}

algorithms-miscellaneous-4/src/main/java/com/baeldung/algorithms/string/search/StringSearchAlgorithms.java

@@ -1,194 +0,0 @@
-package com.baeldung.algorithms.string.search;
-
-import java.math.BigInteger;
-import java.util.Random;
-
-public class StringSearchAlgorithms {
-    public static long getBiggerPrime(int m) {
-        BigInteger prime = BigInteger.probablePrime(getNumberOfBits(m) + 1, new Random());
-        return prime.longValue();
-    }
-
-    public static long getLowerPrime(long number) {
-        BigInteger prime = BigInteger.probablePrime(getNumberOfBits(number) - 1, new Random());
-        return prime.longValue();
-    }
-
-    private static int getNumberOfBits(final int number) {
-        return Integer.SIZE - Integer.numberOfLeadingZeros(number);
-    }
-
-    private static int getNumberOfBits(final long number) {
-        return Long.SIZE - Long.numberOfLeadingZeros(number);
-    }
-
-    public static int simpleTextSearch(char[] pattern, char[] text) {
-        int patternSize = pattern.length;
-        int textSize = text.length;
-
-        int i = 0;
-
-        while ((i + patternSize) <= textSize) {
-            int j = 0;
-            while (text[i + j] == pattern[j]) {
-                j += 1;
-                if (j >= patternSize)
-                    return i;
-            }
-            i += 1;
-        }
-
-        return -1;
-    }
-
-    public static int RabinKarpMethod(char[] pattern, char[] text) {
-        int patternSize = pattern.length; // m
-        int textSize = text.length; // n
-
-        long prime = getBiggerPrime(patternSize);
-
-        long r = 1;
-        for (int i = 0; i < patternSize - 1; i++) {
-            r *= 2;
-            r = r % prime;
-        }
-
-        long[] t = new long[textSize];
-        t[0] = 0;
-
-        long pfinger = 0;
-
-        for (int j = 0; j < patternSize; j++) {
-            t[0] = (2 * t[0] + text[j]) % prime;
-            pfinger = (2 * pfinger + pattern[j]) % prime;
-        }
-
-        int i = 0;
-        boolean passed = false;
-
-        int diff = textSize - patternSize;
-        for (i = 0; i <= diff; i++) {
-            if (t[i] == pfinger) {
-                passed = true;
-                for (int k = 0; k < patternSize; k++) {
-                    if (text[i + k] != pattern[k]) {
-                        passed = false;
-                        break;
-                    }
-                }
-
-                if (passed) {
-                    return i;
-                }
-            }
-
-            if (i < diff) {
-                long value = 2 * (t[i] - r * text[i]) + text[i + patternSize];
-                t[i + 1] = ((value % prime) + prime) % prime;
-            }
-        }
-        return -1;
-
-    }
-
-    public static int KnuthMorrisPrattSearch(char[] pattern, char[] text) {
-        int patternSize = pattern.length; // m
-        int textSize = text.length; // n
-
-        int i = 0, j = 0;
-
-        int[] shift = KnuthMorrisPrattShift(pattern);
-
-        while ((i + patternSize) <= textSize) {
-            while (text[i + j] == pattern[j]) {
-                j += 1;
-                if (j >= patternSize)
-                    return i;
-            }
-
-            if (j > 0) {
-                i += shift[j - 1];
-                j = Math.max(j - shift[j - 1], 0);
-            } else {
-                i++;
-                j = 0;
-            }
-        }
-        return -1;
-    }
-
-    public static int[] KnuthMorrisPrattShift(char[] pattern) {
-        int patternSize = pattern.length;
-
-        int[] shift = new int[patternSize];
-        shift[0] = 1;
-
-        int i = 1, j = 0;
-
-        while ((i + j) < patternSize) {
-            if (pattern[i + j] == pattern[j]) {
-                shift[i + j] = i;
-                j++;
-            } else {
-                if (j == 0)
-                    shift[i] = i + 1;
-
-                if (j > 0) {
-                    i = i + shift[j - 1];
-                    j = Math.max(j - shift[j - 1], 0);
-                } else {
-                    i = i + 1;
-                    j = 0;
-                }
-            }
-        }
-        return shift;
-    }
-
-    public static int BoyerMooreHorspoolSimpleSearch(char[] pattern, char[] text) {
-        int patternSize = pattern.length;
-        int textSize = text.length;
-
-        int i = 0, j = 0;
-
-        while ((i + patternSize) <= textSize) {
-            j = patternSize - 1;
-            while (text[i + j] == pattern[j]) {
-                j--;
-                if (j < 0)
-                    return i;
-            }
-            i++;
-        }
-        return -1;
-    }
-
-    public static int BoyerMooreHorspoolSearch(char[] pattern, char[] text) {
-
-        int shift[] = new int[256];
-
-        for (int k = 0; k < 256; k++) {
-            shift[k] = pattern.length;
-        }
-
-        for (int k = 0; k < pattern.length - 1; k++) {
-            shift[pattern[k]] = pattern.length - 1 - k;
-        }
-
-        int i = 0, j = 0;
-
-        while ((i + pattern.length) <= text.length) {
-            j = pattern.length - 1;
-
-            while (text[i + j] == pattern[j]) {
-                j -= 1;
-                if (j < 0)
-                    return i;
-            }
-
-            i = i + shift[text[i + pattern.length - 1]];
-
-        }
-        return -1;
-    }
-}

algorithms-miscellaneous-4/src/test/java/com/baeldung/algorithms/StringSearchAlgorithmsUnitTest.java

@@ -1,25 +0,0 @@
-package com.baeldung.algorithms;
-
-
-import org.junit.Assert;
-import org.junit.Test;
-
-import com.baeldung.algorithms.string.search.StringSearchAlgorithms;
-
-public class StringSearchAlgorithmsUnitTest {
-	
-	
-	@Test
-	public void testStringSearchAlgorithms(){
-		String text = "This is some nice text.";
-		String pattern = "some";
-		
-		int realPosition = text.indexOf(pattern);
-        Assert.assertTrue(realPosition == StringSearchAlgorithms.simpleTextSearch(pattern.toCharArray(), text.toCharArray()));
-        Assert.assertTrue(realPosition == StringSearchAlgorithms.RabinKarpMethod(pattern.toCharArray(), text.toCharArray()));
-        Assert.assertTrue(realPosition == StringSearchAlgorithms.KnuthMorrisPrattSearch(pattern.toCharArray(), text.toCharArray()));
-        Assert.assertTrue(realPosition == StringSearchAlgorithms.BoyerMooreHorspoolSimpleSearch(pattern.toCharArray(), text.toCharArray()));
-        Assert.assertTrue(realPosition == StringSearchAlgorithms.BoyerMooreHorspoolSearch(pattern.toCharArray(), text.toCharArray()));
-	}
-
-}

algorithms-miscellaneous-4/src/test/java/com/baeldung/algorithms/smallestinteger/SmallestMissingPositiveIntegerUnitTest.java

@@ -0,0 +1,88 @@
+package com.baeldung.algorithms.smallestinteger;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class SmallestMissingPositiveIntegerUnitTest {
+    @Test
+    void givenArrayWithThreeMissing_whenSearchInSortedArray_thenThree() {
+        int[] input = new int[] {0, 1, 2, 4, 5};
+
+        int result = SmallestMissingPositiveInteger.searchInSortedArray(input);
+
+        assertThat(result).isEqualTo(3);
+    }
+
+    @Test
+    void givenArrayWithOneAndThreeMissing_whenSearchInSortedArray_thenOne() {
+        int[] input = new int[] {0, 2, 4, 5};
+
+        int result = SmallestMissingPositiveInteger.searchInSortedArray(input);
+
+        assertThat(result).isEqualTo(1);
+    }
+
+    @Test
+    void givenArrayWithoutMissingInteger_whenSearchInSortedArray_thenArrayLength() {
+        int[] input = new int[] {0, 1, 2, 3, 4, 5};
+
+        int result = SmallestMissingPositiveInteger.searchInSortedArray(input);
+
+        assertThat(result).isEqualTo(input.length);
+    }
+
+    @Test
+    void givenArrayWithThreeMissing_whenSearchInUnsortedArraySortingFirst_thenThree() {
+        int[] input = new int[] {1, 4, 0, 5, 2};
+
+        int result = SmallestMissingPositiveInteger.searchInUnsortedArraySortingFirst(input);
+
+        assertThat(result).isEqualTo(3);
+    }
+
+    @Test
+    void givenArrayWithOneAndThreeMissing_whenSearchInUnsortedArraySortingFirst_thenOne() {
+        int[] input = new int[] {4, 2, 0, 5};
+
+        int result = SmallestMissingPositiveInteger.searchInUnsortedArraySortingFirst(input);
+
+        assertThat(result).isEqualTo(1);
+    }
+
+    @Test
+    void givenArrayWithoutMissingInteger_whenSearchInUnsortedArraySortingFirst_thenArrayLength() {
+        int[] input = new int[] {4, 5, 1, 3, 0, 2};
+
+        int result = SmallestMissingPositiveInteger.searchInUnsortedArraySortingFirst(input);
+
+        assertThat(result).isEqualTo(input.length);
+    }
+
+    @Test
+    void givenArrayWithThreeMissing_whenSearchInUnsortedArrayBooleanArray_thenThree() {
+        int[] input = new int[] {1, 4, 0, 5, 2};
+
+        int result = SmallestMissingPositiveInteger.searchInUnsortedArrayBooleanArray(input);
+
+        assertThat(result).isEqualTo(3);
+    }
+
+    @Test
+    void givenArrayWithOneAndThreeMissing_whenSearchInUnsortedArrayBooleanArray_thenOne() {
+        int[] input = new int[] {4, 2, 0, 5};
+
+        int result = SmallestMissingPositiveInteger.searchInUnsortedArrayBooleanArray(input);
+
+        assertThat(result).isEqualTo(1);
+    }
+
+    @Test
+    void givenArrayWithoutMissingInteger_whenSearchInUnsortedArrayBooleanArray_thenArrayLength() {
+        int[] input = new int[] {4, 5, 1, 3, 0, 2};
+
+        int result = SmallestMissingPositiveInteger.searchInUnsortedArrayBooleanArray(input);
+
+        assertThat(result).isEqualTo(input.length);
+    }
+}

algorithms-miscellaneous-5/README.md

@@ -1,5 +1,13 @@
-## 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:
 
 - [Converting Between Byte Arrays and Hexadecimal Strings in Java](https://www.baeldung.com/java-byte-arrays-hex-strings)
 - [Reversing a Binary Tree in Java](https://www.baeldung.com/java-reversing-a-binary-tree)
-- [Find If Two Numbers Are Relatively Prime in Java](https://www.baeldung.com/java-two-relatively-prime-numbers)
+- [Find If Two Numbers Are Relatively Prime in Java](https://www.baeldung.com/java-two-relatively-prime-numbers)
+- [Knapsack Problem Implementation in Java](https://www.baeldung.com/java-knapsack)
+- [How to Determine if a Binary Tree is Balanced](https://www.baeldung.com/java-balanced-binary-tree)
+- More articles: [[<-- prev]](/../algorithms-miscellaneous-4)

algorithms-miscellaneous-5/pom.xml

@@ -17,6 +17,11 @@
             <artifactId>commons-codec</artifactId>
             <version>${commons-codec.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>${commons-math3.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
@@ -28,6 +33,7 @@
             <artifactId>tradukisto</artifactId>
             <version>${tradukisto.version}</version>
         </dependency>
+
         <dependency>
             <groupId>org.assertj</groupId>
             <artifactId>assertj-core</artifactId>
@@ -52,6 +58,7 @@
         <tradukisto.version>1.0.1</tradukisto.version>
         <org.assertj.core.version>3.9.0</org.assertj.core.version>
         <commons-codec.version>1.11</commons-codec.version>
+        <commons-math3.version>3.6.1</commons-math3.version>
     </properties>
 
 </project>

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/balancedbinarytree/BalancedBinaryTree.java

@@ -0,0 +1,33 @@
+package com.baeldung.algorithms.balancedbinarytree;
+
+public class BalancedBinaryTree {
+
+    public static boolean isBalanced(Tree tree) {
+        return isBalancedRecursive(tree, -1).isBalanced;
+    }
+
+    private static Result isBalancedRecursive(Tree tree, int depth) {
+        if (tree == null) {
+            return new Result(true, -1);
+        }
+
+        Result leftSubtreeResult = isBalancedRecursive(tree.left(), depth + 1);
+        Result rightSubtreeResult = isBalancedRecursive(tree.right(), depth + 1);
+
+        boolean isBalanced = Math.abs(leftSubtreeResult.height - rightSubtreeResult.height) <= 1;
+        boolean subtreesAreBalanced = leftSubtreeResult.isBalanced && rightSubtreeResult.isBalanced;
+        int height = Math.max(leftSubtreeResult.height, rightSubtreeResult.height) + 1;
+
+        return new Result(isBalanced && subtreesAreBalanced, height);
+    }
+
+    private static final class Result {
+        private final boolean isBalanced;
+        private final int height;
+
+        private Result(boolean isBalanced, int height) {
+            this.isBalanced = isBalanced;
+            this.height = height;
+        }
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/balancedbinarytree/Tree.java

@@ -0,0 +1,34 @@
+package com.baeldung.algorithms.balancedbinarytree;
+
+public class Tree {
+    private final int value;
+    private final Tree left;
+    private final Tree right;
+
+    public Tree(int value, Tree left, Tree right) {
+        this.value = value;
+        this.left = left;
+        this.right = right;
+    }
+
+    public int value() {
+        return value;
+    }
+
+    public Tree left() {
+        return left;
+    }
+
+    public Tree right() {
+        return right;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("[%s, %s, %s]",
+            value,
+            left == null ? "null" : left.toString(),
+            right == null ? "null" : right.toString()
+        );
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/binarygap/BinaryGap.java

@@ -0,0 +1,17 @@
+package com.baeldung.algorithms.binarygap;
+
+public class BinaryGap {
+    static int calculateBinaryGap(int n) {
+        return calculateBinaryGap(n >>> Integer.numberOfTrailingZeros(n), 0, 0);
+    }
+
+    static int calculateBinaryGap(int n, int current, int maximum) {
+        if (n == 0) {
+            return maximum;
+        } else if ((n & 1) == 0) {
+            return calculateBinaryGap(n >>> 1, current + 1, maximum);
+        } else {
+            return calculateBinaryGap(n >>> 1, 0, Math.max(maximum, current));
+        }
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/caesarcipher/CaesarCipher.java

@@ -0,0 +1,83 @@
+package com.baeldung.algorithms.caesarcipher;
+
+import org.apache.commons.math3.stat.inference.ChiSquareTest;
+
+import java.util.Arrays;
+import java.util.stream.IntStream;
+
+public class CaesarCipher {
+    private static final char LETTER_A = 'a';
+    private static final char LETTER_Z = 'z';
+    private static final int ALPHABET_SIZE = LETTER_Z - LETTER_A + 1;
+    private static final double[] ENGLISH_LETTERS_PROBABILITIES = {0.073, 0.009, 0.030, 0.044, 0.130, 0.028, 0.016, 0.035, 0.074, 0.002, 0.003, 0.035, 0.025, 0.078, 0.074, 0.027, 0.003, 0.077, 0.063, 0.093, 0.027, 0.013, 0.016, 0.005, 0.019, 0.001};
+
+    public String cipher(String message, int offset) {
+        StringBuilder result = new StringBuilder();
+
+        for (char character : message.toCharArray()) {
+            if (character != ' ') {
+                int originalAlphabetPosition = character - LETTER_A;
+                int newAlphabetPosition = (originalAlphabetPosition + offset) % ALPHABET_SIZE;
+                char newCharacter = (char) (LETTER_A + newAlphabetPosition);
+                result.append(newCharacter);
+            } else {
+                result.append(character);
+            }
+        }
+
+        return result.toString();
+    }
+
+    public String decipher(String message, int offset) {
+        return cipher(message, ALPHABET_SIZE - (offset % ALPHABET_SIZE));
+    }
+
+    public int breakCipher(String message) {
+        return probableOffset(chiSquares(message));
+    }
+
+    private double[] chiSquares(String message) {
+        double[] expectedLettersFrequencies = expectedLettersFrequencies(message.length());
+
+        double[] chiSquares = new double[ALPHABET_SIZE];
+
+        for (int offset = 0; offset < chiSquares.length; offset++) {
+            String decipheredMessage = decipher(message, offset);
+            long[] lettersFrequencies = observedLettersFrequencies(decipheredMessage);
+            double chiSquare = new ChiSquareTest().chiSquare(expectedLettersFrequencies, lettersFrequencies);
+            chiSquares[offset] = chiSquare;
+        }
+
+        return chiSquares;
+    }
+
+    private long[] observedLettersFrequencies(String message) {
+        return IntStream.rangeClosed(LETTER_A, LETTER_Z)
+          .mapToLong(letter -> countLetter((char) letter, message))
+          .toArray();
+    }
+
+    private long countLetter(char letter, String message) {
+        return message.chars()
+          .filter(character -> character == letter)
+          .count();
+    }
+
+    private double[] expectedLettersFrequencies(int messageLength) {
+        return Arrays.stream(ENGLISH_LETTERS_PROBABILITIES)
+          .map(probability -> probability * messageLength)
+          .toArray();
+    }
+
+    private int probableOffset(double[] chiSquares) {
+        int probableOffset = 0;
+        for (int offset = 0; offset < chiSquares.length; offset++) {
+            System.out.println(String.format("Chi-Square for offset %d: %.2f", offset, chiSquares[offset]));
+            if (chiSquares[offset] < chiSquares[probableOffset]) {
+                probableOffset = offset;
+            }
+        }
+
+        return probableOffset;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/combinatorics/Combinatorics.java

@@ -0,0 +1,67 @@
+package com.baeldung.algorithms.combinatorics;
+
+import java.util.*;
+
+import static java.util.Collections.swap;
+
+public class Combinatorics {
+
+    public static List<List<Integer>> permutations(List<Integer> sequence) {
+        List<List<Integer>> results = new ArrayList<>();
+        permutationsInternal(sequence, results, 0);
+        return results;
+    }
+
+    private static void permutationsInternal(List<Integer> sequence, List<List<Integer>> results, int index) {
+        if (index == sequence.size() - 1) {
+            results.add(new ArrayList<>(sequence));
+        }
+
+        for (int i = index; i < sequence.size(); i++) {
+            swap(sequence, i, index);
+            permutationsInternal(sequence, results, index + 1);
+            swap(sequence, i, index);
+        }
+    }
+
+    public static List<List<Integer>> combinations(List<Integer> inputSet, int k) {
+        List<List<Integer>> results = new ArrayList<>();
+        combinationsInternal(inputSet, k, results, new ArrayList<>(), 0);
+        return results;
+    }
+
+    private static void combinationsInternal(
+      List<Integer> inputSet, int k, List<List<Integer>> results, ArrayList<Integer> accumulator, int index) {
+        int leftToAccumulate = k - accumulator.size();
+        int possibleToAcculumate = inputSet.size() - index;
+
+        if (accumulator.size() == k) {
+            results.add(new ArrayList<>(accumulator));
+        } else if (leftToAccumulate <= possibleToAcculumate) {
+            combinationsInternal(inputSet, k, results, accumulator, index + 1);
+
+            accumulator.add(inputSet.get(index));
+            combinationsInternal(inputSet, k, results, accumulator, index + 1);
+            accumulator.remove(accumulator.size() - 1);
+        }
+    }
+
+    public static List<List<Character>> powerSet(List<Character> sequence) {
+        List<List<Character>> results = new ArrayList<>();
+        powerSetInternal(sequence, results, new ArrayList<>(), 0);
+        return results;
+    }
+
+    private static void powerSetInternal(
+      List<Character> set, List<List<Character>> powerSet, List<Character> accumulator, int index) {
+        if (index == set.size()) {
+            powerSet.add(new ArrayList<>(accumulator));
+        } else {
+            accumulator.add(set.get(index));
+
+            powerSetInternal(set, powerSet, accumulator, index + 1);
+            accumulator.remove(accumulator.size() - 1);
+            powerSetInternal(set, powerSet, accumulator, index + 1);
+        }
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/knapsack/Knapsack.java

@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.knapsack;
+
+public class Knapsack {
+
+    public int knapsackRec(int[] w, int[] v, int n, int W) {
+        if (n <= 0) {
+            return 0;
+        } else if (w[n - 1] > W) {
+            return knapsackRec(w, v, n - 1, W);
+        } else {
+            return Math.max(knapsackRec(w, v, n - 1, W), v[n - 1] + knapsackRec(w, v, n - 1, W - w[n - 1]));
+        }
+    }
+
+    public int knapsackDP(int[] w, int[] v, int n, int W) {
+        if (n <= 0 || W <= 0) {
+            return 0;
+        }
+
+        int[][] m = new int[n + 1][W + 1];
+        for (int j = 0; j <= W; j++) {
+            m[0][j] = 0;
+        }
+
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= W; j++) {
+                if (w[i - 1] > j) {
+                    m[i][j] = m[i - 1][j];
+                } else {
+                    m[i][j] = Math.max(m[i - 1][j], m[i - 1][j - w[i - 1]] + v[i - 1]);
+                }
+            }
+        }
+        return m[n][W];
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/balancedbinarytree/BalancedBinaryTreeUnitTest.java

@@ -0,0 +1,26 @@
+package com.baeldung.algorithms.balancedbinarytree;
+
+import org.junit.Test;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+
+public class BalancedBinaryTreeUnitTest extends BinaryTreeDataProvider {
+
+    @Test
+    public void givenBalancedTrees_whenCallingIsBalanced_ShouldReturnTrue() {
+        for (Tree tree : balancedTrees()) {
+            assertTrue(toString(tree) + " should be balanced", BalancedBinaryTree.isBalanced(tree));
+        }
+    }
+
+    @Test
+    public void givenUnbalancedTrees_whenCallingIsBalanced_ShouldReturnFalse() {
+        for (Tree tree : unbalancedTrees()) {
+            assertFalse(toString(tree) + " should not be balanced", BalancedBinaryTree.isBalanced(tree));
+        }
+    }
+
+    private String toString(Tree tree) {
+        return tree != null ? tree.toString() : "null";
+    }
+}