to byte[]
+ byte[] resultArray = new byte[result.size()];
+ for (int i = 0; i < result.size(); i++) {
+ resultArray[i] = result.get(i);
+ }
+
+ return resultArray;
+ }
+
+ /**
+ * Decodes the given Base64 encoded string to a string using UTF-8 encoding.
+ *
+ * @param input the Base64 encoded string to decode
+ * @return the decoded string
+ * @throws IllegalArgumentException if input is null or contains invalid Base64 characters
+ */
+ public static String decodeToString(String input) {
+ if (input == null) {
+ throw new IllegalArgumentException("Input cannot be null");
+ }
+
+ byte[] decodedBytes = decode(input);
+ return new String(decodedBytes, StandardCharsets.UTF_8);
+ }
+
+ /**
+ * Gets the numeric value of a Base64 character.
+ *
+ * @param c the Base64 character
+ * @return the numeric value (0-63)
+ * @throws IllegalArgumentException if character is not a valid Base64 character
+ */
+ private static int getBase64Value(char c) {
+ if (c >= 'A' && c <= 'Z') {
+ return c - 'A';
+ } else if (c >= 'a' && c <= 'z') {
+ return c - 'a' + 26;
+ } else if (c >= '0' && c <= '9') {
+ return c - '0' + 52;
+ } else if (c == '+') {
+ return 62;
+ } else if (c == '/') {
+ return 63;
+ } else {
+ throw new IllegalArgumentException("Invalid Base64 character: " + c);
+ }
+ }
+}
diff --git a/src/main/java/com/thealgorithms/conversions/BinaryToDecimal.java b/src/main/java/com/thealgorithms/conversions/BinaryToDecimal.java
index 36c0790e565f..b3783ab284b2 100644
--- a/src/main/java/com/thealgorithms/conversions/BinaryToDecimal.java
+++ b/src/main/java/com/thealgorithms/conversions/BinaryToDecimal.java
@@ -30,4 +30,30 @@ public static long binaryToDecimal(long binaryNumber) {
}
return decimalValue;
}
+
+ /**
+ * Converts a binary String to its decimal equivalent using bitwise operators.
+ *
+ * @param binary The binary number to convert.
+ * @return The decimal equivalent of the binary number.
+ * @throws IllegalArgumentException If the binary number contains digits other than 0 and 1.
+ */
+ public static long binaryStringToDecimal(String binary) {
+ boolean isNegative = binary.charAt(0) == '-';
+ if (isNegative) {
+ binary = binary.substring(1);
+ }
+
+ long decimalValue = 0;
+
+ for (char bit : binary.toCharArray()) {
+ if (bit != '0' && bit != '1') {
+ throw new IllegalArgumentException("Incorrect binary digit: " + bit);
+ }
+ // shift left by 1 (multiply by 2) and add bit value
+ decimalValue = (decimalValue << 1) | (bit - '0');
+ }
+
+ return isNegative ? -decimalValue : decimalValue;
+ }
}
diff --git a/src/main/java/com/thealgorithms/conversions/CoordinateConverter.java b/src/main/java/com/thealgorithms/conversions/CoordinateConverter.java
new file mode 100644
index 000000000000..2766a3a1cf89
--- /dev/null
+++ b/src/main/java/com/thealgorithms/conversions/CoordinateConverter.java
@@ -0,0 +1,57 @@
+package com.thealgorithms.conversions;
+
+/**
+ * A utility class to convert between Cartesian and Polar coordinate systems.
+ *
+ * This class provides methods to perform the following conversions:
+ *
+ * - Cartesian to Polar coordinates
+ * - Polar to Cartesian coordinates
+ *
+ *
+ * The class is final and cannot be instantiated.
+ */
+public final class CoordinateConverter {
+
+ private CoordinateConverter() {
+ // Prevent instantiation
+ }
+
+ /**
+ * Converts Cartesian coordinates to Polar coordinates.
+ *
+ * @param x the x-coordinate in the Cartesian system; must be a finite number
+ * @param y the y-coordinate in the Cartesian system; must be a finite number
+ * @return an array where the first element is the radius (r) and the second element is the angle (theta) in degrees
+ * @throws IllegalArgumentException if x or y is not a finite number
+ */
+ public static double[] cartesianToPolar(double x, double y) {
+ if (!Double.isFinite(x) || !Double.isFinite(y)) {
+ throw new IllegalArgumentException("x and y must be finite numbers.");
+ }
+ double r = Math.sqrt(x * x + y * y);
+ double theta = Math.toDegrees(Math.atan2(y, x));
+ return new double[] {r, theta};
+ }
+
+ /**
+ * Converts Polar coordinates to Cartesian coordinates.
+ *
+ * @param r the radius in the Polar system; must be non-negative
+ * @param thetaDegrees the angle (theta) in degrees in the Polar system; must be a finite number
+ * @return an array where the first element is the x-coordinate and the second element is the y-coordinate in the Cartesian system
+ * @throws IllegalArgumentException if r is negative or thetaDegrees is not a finite number
+ */
+ public static double[] polarToCartesian(double r, double thetaDegrees) {
+ if (r < 0) {
+ throw new IllegalArgumentException("Radius (r) must be non-negative.");
+ }
+ if (!Double.isFinite(thetaDegrees)) {
+ throw new IllegalArgumentException("Theta (angle) must be a finite number.");
+ }
+ double theta = Math.toRadians(thetaDegrees);
+ double x = r * Math.cos(theta);
+ double y = r * Math.sin(theta);
+ return new double[] {x, y};
+ }
+}
diff --git a/src/main/java/com/thealgorithms/conversions/TemperatureConverter.java b/src/main/java/com/thealgorithms/conversions/TemperatureConverter.java
new file mode 100644
index 000000000000..901db17c665d
--- /dev/null
+++ b/src/main/java/com/thealgorithms/conversions/TemperatureConverter.java
@@ -0,0 +1,46 @@
+package com.thealgorithms.conversions;
+
+/**
+ * A utility class to convert between different temperature units.
+ *
+ *
This class supports conversions between the following units:
+ *
+ * - Celsius
+ * - Fahrenheit
+ * - Kelvin
+ *
+ *
+ * This class is final and cannot be instantiated.
+ *
+ * @author krishna-medapati (https://github.com/krishna-medapati)
+ * @see Wikipedia: Temperature Conversion
+ */
+public final class TemperatureConverter {
+
+ private TemperatureConverter() {
+ }
+
+ public static double celsiusToFahrenheit(double celsius) {
+ return celsius * 9.0 / 5.0 + 32.0;
+ }
+
+ public static double celsiusToKelvin(double celsius) {
+ return celsius + 273.15;
+ }
+
+ public static double fahrenheitToCelsius(double fahrenheit) {
+ return (fahrenheit - 32.0) * 5.0 / 9.0;
+ }
+
+ public static double fahrenheitToKelvin(double fahrenheit) {
+ return (fahrenheit - 32.0) * 5.0 / 9.0 + 273.15;
+ }
+
+ public static double kelvinToCelsius(double kelvin) {
+ return kelvin - 273.15;
+ }
+
+ public static double kelvinToFahrenheit(double kelvin) {
+ return (kelvin - 273.15) * 9.0 / 5.0 + 32.0;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/conversions/TimeConverter.java b/src/main/java/com/thealgorithms/conversions/TimeConverter.java
new file mode 100644
index 000000000000..41cae37d7ad1
--- /dev/null
+++ b/src/main/java/com/thealgorithms/conversions/TimeConverter.java
@@ -0,0 +1,97 @@
+package com.thealgorithms.conversions;
+
+import java.util.Locale;
+import java.util.Map;
+
+/**
+ * A utility class to convert between different units of time.
+ *
+ *
This class supports conversions between the following units:
+ *
+ * - seconds
+ * - minutes
+ * - hours
+ * - days
+ * - weeks
+ * - months (approximated as 30.44 days)
+ * - years (approximated as 365.25 days)
+ *
+ *
+ * The conversion is based on predefined constants in seconds.
+ * Results are rounded to three decimal places for consistency.
+ *
+ *
This class is final and cannot be instantiated.
+ *
+ * @see Wikipedia: Unit of time
+ */
+public final class TimeConverter {
+
+ private TimeConverter() {
+ // Prevent instantiation
+ }
+
+ /**
+ * Supported time units with their equivalent in seconds.
+ */
+ private enum TimeUnit {
+ SECONDS(1.0),
+ MINUTES(60.0),
+ HOURS(3600.0),
+ DAYS(86400.0),
+ WEEKS(604800.0),
+ MONTHS(2629800.0), // 30.44 days
+ YEARS(31557600.0); // 365.25 days
+
+ private final double seconds;
+
+ TimeUnit(double seconds) {
+ this.seconds = seconds;
+ }
+
+ public double toSeconds(double value) {
+ return value * seconds;
+ }
+
+ public double fromSeconds(double secondsValue) {
+ return secondsValue / seconds;
+ }
+ }
+
+ private static final Map UNIT_LOOKUP
+ = Map.ofEntries(Map.entry("seconds", TimeUnit.SECONDS), Map.entry("minutes", TimeUnit.MINUTES), Map.entry("hours", TimeUnit.HOURS), Map.entry("days", TimeUnit.DAYS), Map.entry("weeks", TimeUnit.WEEKS), Map.entry("months", TimeUnit.MONTHS), Map.entry("years", TimeUnit.YEARS));
+
+ /**
+ * Converts a time value from one unit to another.
+ *
+ * @param timeValue the numeric value of time to convert; must be non-negative
+ * @param unitFrom the unit of the input value (e.g., "minutes", "hours")
+ * @param unitTo the unit to convert into (e.g., "seconds", "days")
+ * @return the converted value in the target unit, rounded to three decimals
+ * @throws IllegalArgumentException if {@code timeValue} is negative
+ * @throws IllegalArgumentException if either {@code unitFrom} or {@code unitTo} is not supported
+ */
+ public static double convertTime(double timeValue, String unitFrom, String unitTo) {
+ if (timeValue < 0) {
+ throw new IllegalArgumentException("timeValue must be a non-negative number.");
+ }
+
+ TimeUnit from = resolveUnit(unitFrom);
+ TimeUnit to = resolveUnit(unitTo);
+
+ double secondsValue = from.toSeconds(timeValue);
+ double converted = to.fromSeconds(secondsValue);
+
+ return Math.round(converted * 1000.0) / 1000.0;
+ }
+
+ private static TimeUnit resolveUnit(String unit) {
+ if (unit == null) {
+ throw new IllegalArgumentException("Unit cannot be null.");
+ }
+ TimeUnit resolved = UNIT_LOOKUP.get(unit.toLowerCase(Locale.ROOT));
+ if (resolved == null) {
+ throw new IllegalArgumentException("Invalid unit '" + unit + "'. Supported units are: " + UNIT_LOOKUP.keySet());
+ }
+ return resolved;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/conversions/TurkishToLatinConversion.java b/src/main/java/com/thealgorithms/conversions/TurkishToLatinConversion.java
index 30030de6c1bd..50726380621a 100644
--- a/src/main/java/com/thealgorithms/conversions/TurkishToLatinConversion.java
+++ b/src/main/java/com/thealgorithms/conversions/TurkishToLatinConversion.java
@@ -16,7 +16,7 @@ private TurkishToLatinConversion() {
* 2. Replace all turkish characters with their corresponding latin characters
* 3. Return the converted string
*
- * @param param String paramter
+ * @param param String parameter
* @return String
*/
public static String convertTurkishToLatin(String param) {
diff --git a/src/main/java/com/thealgorithms/datastructures/bloomfilter/BloomFilter.java b/src/main/java/com/thealgorithms/datastructures/bloomfilter/BloomFilter.java
index d60b95110fc2..90625ad1c902 100644
--- a/src/main/java/com/thealgorithms/datastructures/bloomfilter/BloomFilter.java
+++ b/src/main/java/com/thealgorithms/datastructures/bloomfilter/BloomFilter.java
@@ -1,12 +1,15 @@
package com.thealgorithms.datastructures.bloomfilter;
+import java.util.Arrays;
import java.util.BitSet;
/**
* A generic BloomFilter implementation for probabilistic membership checking.
*
- * Bloom filters are space-efficient data structures that provide a fast way to test whether an
- * element is a member of a set. They may produce false positives, indicating an element is
+ * Bloom filters are space-efficient data structures that provide a fast way to
+ * test whether an
+ * element is a member of a set. They may produce false positives, indicating an
+ * element is
* in the set when it is not, but they will never produce false negatives.
*
*
@@ -20,11 +23,14 @@ public class BloomFilter {
private final Hash[] hashFunctions;
/**
- * Constructs a BloomFilter with a specified number of hash functions and bit array size.
+ * Constructs a BloomFilter with a specified number of hash functions and bit
+ * array size.
*
* @param numberOfHashFunctions the number of hash functions to use
- * @param bitArraySize the size of the bit array, which determines the capacity of the filter
- * @throws IllegalArgumentException if numberOfHashFunctions or bitArraySize is less than 1
+ * @param bitArraySize the size of the bit array, which determines the
+ * capacity of the filter
+ * @throws IllegalArgumentException if numberOfHashFunctions or bitArraySize is
+ * less than 1
*/
@SuppressWarnings("unchecked")
public BloomFilter(int numberOfHashFunctions, int bitArraySize) {
@@ -38,7 +44,8 @@ public BloomFilter(int numberOfHashFunctions, int bitArraySize) {
}
/**
- * Initializes the hash functions with unique indices to ensure different hashing.
+ * Initializes the hash functions with unique indices to ensure different
+ * hashing.
*/
private void initializeHashFunctions() {
for (int i = 0; i < numberOfHashFunctions; i++) {
@@ -49,7 +56,8 @@ private void initializeHashFunctions() {
/**
* Inserts an element into the Bloom filter.
*
- * This method hashes the element using all defined hash functions and sets the corresponding
+ * This method hashes the element using all defined hash functions and sets the
+ * corresponding
* bits in the bit array.
*
*
@@ -65,13 +73,16 @@ public void insert(T key) {
/**
* Checks if an element might be in the Bloom filter.
*
- * This method checks the bits at the positions computed by each hash function. If any of these
- * bits are not set, the element is definitely not in the filter. If all bits are set, the element
+ * This method checks the bits at the positions computed by each hash function.
+ * If any of these
+ * bits are not set, the element is definitely not in the filter. If all bits
+ * are set, the element
* might be in the filter.
*
*
* @param key the element to check for membership in the Bloom filter
- * @return {@code true} if the element might be in the Bloom filter, {@code false} if it is definitely not
+ * @return {@code true} if the element might be in the Bloom filter,
+ * {@code false} if it is definitely not
*/
public boolean contains(T key) {
for (Hash hash : hashFunctions) {
@@ -86,7 +97,8 @@ public boolean contains(T key) {
/**
* Inner class representing a hash function used by the Bloom filter.
*
- * Each instance of this class represents a different hash function based on its index.
+ * Each instance of this class represents a different hash function based on its
+ * index.
*
*
* @param The type of elements to be hashed.
@@ -115,7 +127,7 @@ private static class Hash {
* @return the computed hash value
*/
public int compute(T key) {
- return index * asciiString(String.valueOf(key));
+ return index * contentHash(key);
}
/**
@@ -135,5 +147,31 @@ private int asciiString(String word) {
}
return sum;
}
+
+ /**
+ * Computes a content-based hash for arrays; falls back to ASCII-sum of String value otherwise.
+ */
+ private int contentHash(Object key) {
+ if (key instanceof int[]) {
+ return Arrays.hashCode((int[]) key);
+ } else if (key instanceof long[]) {
+ return Arrays.hashCode((long[]) key);
+ } else if (key instanceof byte[]) {
+ return Arrays.hashCode((byte[]) key);
+ } else if (key instanceof short[]) {
+ return Arrays.hashCode((short[]) key);
+ } else if (key instanceof char[]) {
+ return Arrays.hashCode((char[]) key);
+ } else if (key instanceof boolean[]) {
+ return Arrays.hashCode((boolean[]) key);
+ } else if (key instanceof float[]) {
+ return Arrays.hashCode((float[]) key);
+ } else if (key instanceof double[]) {
+ return Arrays.hashCode((double[]) key);
+ } else if (key instanceof Object[]) {
+ return Arrays.deepHashCode((Object[]) key);
+ }
+ return asciiString(String.valueOf(key));
+ }
}
}
diff --git a/src/main/java/com/thealgorithms/datastructures/caches/LFUCache.java b/src/main/java/com/thealgorithms/datastructures/caches/LFUCache.java
index f0d8ea8f7ff3..bf2b928ec33c 100644
--- a/src/main/java/com/thealgorithms/datastructures/caches/LFUCache.java
+++ b/src/main/java/com/thealgorithms/datastructures/caches/LFUCache.java
@@ -132,7 +132,7 @@ public void put(K key, V value) {
private void addNodeWithUpdatedFrequency(Node node) {
if (tail != null && head != null) {
Node temp = this.head;
- while (temp != null) {
+ while (true) {
if (temp.frequency > node.frequency) {
if (temp == head) {
node.next = temp;
diff --git a/src/main/java/com/thealgorithms/datastructures/graphs/BellmanFord.java b/src/main/java/com/thealgorithms/datastructures/graphs/BellmanFord.java
index 47c5f0d0b98e..5184dae58d28 100644
--- a/src/main/java/com/thealgorithms/datastructures/graphs/BellmanFord.java
+++ b/src/main/java/com/thealgorithms/datastructures/graphs/BellmanFord.java
@@ -160,7 +160,7 @@ public void show(int source, int end,
break;
}
}
- if (neg == 0) { // Go ahead and show results of computaion
+ if (neg == 0) { // Go ahead and show results of computation
System.out.println("Distance is: " + dist[end]);
System.out.println("Path followed:");
System.out.print(source + " ");
diff --git a/src/main/java/com/thealgorithms/datastructures/graphs/DialsAlgorithm.java b/src/main/java/com/thealgorithms/datastructures/graphs/DialsAlgorithm.java
new file mode 100644
index 000000000000..da3fba88c618
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/graphs/DialsAlgorithm.java
@@ -0,0 +1,114 @@
+package com.thealgorithms.datastructures.graphs;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * An implementation of Dial's Algorithm for the single-source shortest path problem.
+ * This algorithm is an optimization of Dijkstra's algorithm and is particularly
+ * efficient for graphs with small, non-negative integer edge weights.
+ *
+ * It uses a bucket queue (implemented here as a List of HashSets) to store vertices,
+ * where each bucket corresponds to a specific distance from the source. This is more
+ * efficient than a standard priority queue when the range of edge weights is small.
+ *
+ * Time Complexity: O(E + W * V), where E is the number of edges, V is the number
+ * of vertices, and W is the maximum weight of any edge.
+ *
+ * @see Wikipedia - Dial's Algorithm
+ */
+public final class DialsAlgorithm {
+ /**
+ * Private constructor to prevent instantiation of this utility class.
+ */
+ private DialsAlgorithm() {
+ }
+ /**
+ * Represents an edge in the graph, connecting to a destination vertex with a given weight.
+ */
+ public static class Edge {
+ private final int destination;
+ private final int weight;
+
+ public Edge(int destination, int weight) {
+ this.destination = destination;
+ this.weight = weight;
+ }
+
+ public int getDestination() {
+ return destination;
+ }
+
+ public int getWeight() {
+ return weight;
+ }
+ }
+ /**
+ * Finds the shortest paths from a source vertex to all other vertices in a weighted graph.
+ *
+ * @param graph The graph represented as an adjacency list.
+ * @param source The source vertex to start from (0-indexed).
+ * @param maxEdgeWeight The maximum weight of any single edge in the graph.
+ * @return An array of integers where the value at each index `i` is the
+ * shortest distance from the source to vertex `i`. Unreachable vertices
+ * will have a value of Integer.MAX_VALUE.
+ * @throws IllegalArgumentException if the source vertex is out of bounds.
+ */
+ public static int[] run(List> graph, int source, int maxEdgeWeight) {
+ int numVertices = graph.size();
+ if (source < 0 || source >= numVertices) {
+ throw new IllegalArgumentException("Source vertex is out of bounds.");
+ }
+
+ // Initialize distances array
+ int[] distances = new int[numVertices];
+ Arrays.fill(distances, Integer.MAX_VALUE);
+ distances[source] = 0;
+
+ // The bucket queue. Size is determined by the max possible path length.
+ int maxPathWeight = maxEdgeWeight * (numVertices > 0 ? numVertices - 1 : 0);
+ List> buckets = new ArrayList<>(maxPathWeight + 1);
+ for (int i = 0; i <= maxPathWeight; i++) {
+ buckets.add(new HashSet<>());
+ }
+
+ // Add the source vertex to the first bucket
+ buckets.get(0).add(source);
+
+ // Process buckets in increasing order of distance
+ for (int d = 0; d <= maxPathWeight; d++) {
+ // Process all vertices in the current bucket
+ while (!buckets.get(d).isEmpty()) {
+ // Get and remove a vertex from the current bucket
+ int u = buckets.get(d).iterator().next();
+ buckets.get(d).remove(u);
+
+ // If we've found a shorter path already, skip
+ if (d > distances[u]) {
+ continue;
+ }
+
+ // Relax all adjacent edges
+ for (Edge edge : graph.get(u)) {
+ int v = edge.getDestination();
+ int weight = edge.getWeight();
+
+ // If a shorter path to v is found
+ if (distances[u] != Integer.MAX_VALUE && distances[u] + weight < distances[v]) {
+ // If v was already in a bucket, remove it from the old one
+ if (distances[v] != Integer.MAX_VALUE) {
+ buckets.get(distances[v]).remove(v);
+ }
+ // Update distance and move v to the new bucket
+ distances[v] = distances[u] + weight;
+ buckets.get(distances[v]).add(v);
+ }
+ }
+ }
+ }
+ return distances;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/graphs/MatrixGraphs.java b/src/main/java/com/thealgorithms/datastructures/graphs/MatrixGraphs.java
index c1d47df457da..a54b0b75e4dc 100644
--- a/src/main/java/com/thealgorithms/datastructures/graphs/MatrixGraphs.java
+++ b/src/main/java/com/thealgorithms/datastructures/graphs/MatrixGraphs.java
@@ -141,7 +141,7 @@ private int[][] adjacency() {
*
* @param from the parent vertex to check for adjacency
* @param to the child vertex to check for adjacency
- * @return whether or not the vertices are adjancent
+ * @return whether or not the vertices are adjacent
*/
private boolean adjacencyOfEdgeDoesExist(int from, int to) {
return (this.adjacency()[from][to] != AdjacencyMatrixGraph.EDGE_NONE);
@@ -162,7 +162,7 @@ public boolean vertexDoesExist(int aVertex) {
*
* @param from the parent vertex to check for adjacency
* @param to the child vertex to check for adjacency
- * @return whether or not the vertices are adjancent
+ * @return whether or not the vertices are adjacent
*/
public boolean edgeDoesExist(int from, int to) {
if (this.vertexDoesExist(from) && this.vertexDoesExist(to)) {
diff --git a/src/main/java/com/thealgorithms/datastructures/graphs/TwoSat.java b/src/main/java/com/thealgorithms/datastructures/graphs/TwoSat.java
new file mode 100644
index 000000000000..835e3880428f
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/graphs/TwoSat.java
@@ -0,0 +1,265 @@
+package com.thealgorithms.datastructures.graphs;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Stack;
+
+/**
+ * This class implements a solution to the 2-SAT (2-Satisfiability) problem
+ * using Kosaraju's algorithm to find strongly connected components (SCCs)
+ * in the implication graph.
+ *
+ *
+ * Brief Idea:
+ *
+ *
+ *
+ * 1. From each clause (a ∨ b), we can derive implications:
+ * (¬a → b) and (¬b → a)
+ *
+ * 2. We construct an implication graph using these implications.
+ *
+ * 3. For each variable x, its negation ¬x is also represented as a node.
+ * If x and ¬x belong to the same SCC, the expression is unsatisfiable.
+ *
+ * 4. Otherwise, we assign truth values based on the SCC order:
+ * If SCC(x) > SCC(¬x), then x = true; otherwise, x = false.
+ *
+ *
+ *
+ * Complexities:
+ *
+ *
+ * - Time Complexity: O(n + m)
+ * - Space Complexity: O(n + m)
+ *
+ * where {@code n} is the number of variables and {@code m} is the number of
+ * clauses.
+ *
+ *
+ * Usage Example:
+ *
+ *
+ *
+ * TwoSat twoSat = new TwoSat(5); // Initialize with 5 variables: x1, x2, x3, x4, x5
+ *
+ * // Add clauses
+ * twoSat.addClause(1, false, 2, false); // (x1 ∨ x2)
+ * twoSat.addClause(3, true, 2, false); // (¬x3 ∨ x2)
+ * twoSat.addClause(4, false, 5, true); // (x4 ∨ ¬x5)
+ *
+ * twoSat.solve(); // Solve the problem
+ *
+ * if (twoSat.isSolutionExists()) {
+ * boolean[] solution = twoSat.getSolutions();
+ * for (int i = 1; i <= 5; i++) {
+ * System.out.println("x" + i + " = " + solution[i]);
+ * }
+ * }
+ *
+ * Reference
+ * CP Algorithm
+ * Wikipedia - 2 SAT
+ * @author Shoyeb Ansari
+ *
+ * @see Kosaraju
+ */
+class TwoSat {
+
+ /** Number of variables in the boolean expression. */
+ private final int numberOfVariables;
+
+ /** Implication graph built from the boolean clauses. */
+ private final ArrayList[] graph;
+
+ /** Transposed implication graph used in Kosaraju's algorithm. */
+ private final ArrayList[] graphTranspose;
+
+ /** Stores one valid truth assignment for all variables (1-indexed). */
+ private final boolean[] variableAssignments;
+
+ /** Indicates whether a valid solution exists. */
+ private boolean hasSolution = true;
+
+ /** Tracks whether the {@code solve()} method has been called. */
+ private boolean isSolved = false;
+
+ /**
+ * Initializes the TwoSat solver with the given number of variables.
+ *
+ * @param numberOfVariables the number of boolean variables
+ * @throws IllegalArgumentException if the number of variables is negative
+ */
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ TwoSat(int numberOfVariables) {
+ if (numberOfVariables < 0) {
+ throw new IllegalArgumentException("Number of variables cannot be negative.");
+ }
+ this.numberOfVariables = numberOfVariables;
+ int n = 2 * numberOfVariables + 1;
+
+ graph = (ArrayList[]) new ArrayList[n];
+ graphTranspose = (ArrayList[]) new ArrayList[n];
+ for (int i = 0; i < n; i++) {
+ graph[i] = new ArrayList<>();
+ graphTranspose[i] = new ArrayList<>();
+ }
+ variableAssignments = new boolean[numberOfVariables + 1];
+ }
+
+ /**
+ * Adds a clause of the form (a ∨ b) to the boolean expression.
+ *
+ *
+ * Example: To add (¬x₁ ∨ x₂), call:
+ *
+ *
+ * {@code
+ * addClause(1, true, 2, false);
+ * }
+ *
+ * @param a the first variable (1 ≤ a ≤ numberOfVariables)
+ * @param isNegateA {@code true} if variable {@code a} is negated
+ * @param b the second variable (1 ≤ b ≤ numberOfVariables)
+ * @param isNegateB {@code true} if variable {@code b} is negated
+ * @throws IllegalArgumentException if {@code a} or {@code b} are out of range
+ */
+ void addClause(int a, boolean isNegateA, int b, boolean isNegateB) {
+ if (a <= 0 || a > numberOfVariables) {
+ throw new IllegalArgumentException("Variable number must be between 1 and " + numberOfVariables);
+ }
+ if (b <= 0 || b > numberOfVariables) {
+ throw new IllegalArgumentException("Variable number must be between 1 and " + numberOfVariables);
+ }
+
+ a = isNegateA ? negate(a) : a;
+ b = isNegateB ? negate(b) : b;
+ int notA = negate(a);
+ int notB = negate(b);
+
+ // Add implications: (¬a → b) and (¬b → a)
+ graph[notA].add(b);
+ graph[notB].add(a);
+
+ // Build transpose graph
+ graphTranspose[b].add(notA);
+ graphTranspose[a].add(notB);
+ }
+
+ /**
+ * Solves the 2-SAT problem using Kosaraju's algorithm to find SCCs
+ * and determines whether a satisfying assignment exists.
+ */
+ void solve() {
+ isSolved = true;
+ int n = 2 * numberOfVariables + 1;
+
+ boolean[] visited = new boolean[n];
+ int[] component = new int[n];
+ Stack topologicalOrder = new Stack<>();
+
+ // Step 1: Perform DFS to get topological order
+ for (int i = 1; i < n; i++) {
+ if (!visited[i]) {
+ dfsForTopologicalOrder(i, visited, topologicalOrder);
+ }
+ }
+
+ Arrays.fill(visited, false);
+ int sccId = 0;
+
+ // Step 2: Find SCCs on transposed graph
+ while (!topologicalOrder.isEmpty()) {
+ int node = topologicalOrder.pop();
+ if (!visited[node]) {
+ dfsForScc(node, visited, component, sccId);
+ sccId++;
+ }
+ }
+
+ // Step 3: Check for contradictions and assign values
+ for (int i = 1; i <= numberOfVariables; i++) {
+ int notI = negate(i);
+ if (component[i] == component[notI]) {
+ hasSolution = false;
+ return;
+ }
+ // If SCC(i) > SCC(¬i), then variable i is true.
+ variableAssignments[i] = component[i] > component[notI];
+ }
+ }
+
+ /**
+ * Returns whether the given boolean formula is satisfiable.
+ *
+ * @return {@code true} if a solution exists; {@code false} otherwise
+ * @throws Error if called before {@link #solve()}
+ */
+ boolean isSolutionExists() {
+ if (!isSolved) {
+ throw new Error("Please call solve() before checking for a solution.");
+ }
+ return hasSolution;
+ }
+
+ /**
+ * Returns one valid assignment of variables that satisfies the boolean formula.
+ *
+ * @return a boolean array where {@code result[i]} represents the truth value of
+ * variable {@code xᵢ}
+ * @throws Error if called before {@link #solve()} or if no solution exists
+ */
+ boolean[] getSolutions() {
+ if (!isSolved) {
+ throw new Error("Please call solve() before fetching the solution.");
+ }
+ if (!hasSolution) {
+ throw new Error("No satisfying assignment exists for the given expression.");
+ }
+ return variableAssignments.clone();
+ }
+
+ /** Performs DFS to compute topological order. */
+ private void dfsForTopologicalOrder(int u, boolean[] visited, Stack topologicalOrder) {
+ visited[u] = true;
+ for (int v : graph[u]) {
+ if (!visited[v]) {
+ dfsForTopologicalOrder(v, visited, topologicalOrder);
+ }
+ }
+ topologicalOrder.push(u);
+ }
+
+ /** Performs DFS on the transposed graph to identify SCCs. */
+ private void dfsForScc(int u, boolean[] visited, int[] component, int sccId) {
+ visited[u] = true;
+ component[u] = sccId;
+ for (int v : graphTranspose[u]) {
+ if (!visited[v]) {
+ dfsForScc(v, visited, component, sccId);
+ }
+ }
+ }
+
+ /**
+ * Returns the index representing the negation of the given variable.
+ *
+ *
+ * Mapping rule:
+ *
+ *
+ *
+ * For a variable i:
+ * negate(i) = i + n
+ * For a negated variable (i + n):
+ * negate(i + n) = i
+ * where n = numberOfVariables
+ *
+ *
+ * @param a the variable index
+ * @return the index representing its negation
+ */
+ private int negate(int a) {
+ return a <= numberOfVariables ? a + numberOfVariables : a - numberOfVariables;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/hashmap/Readme.md b/src/main/java/com/thealgorithms/datastructures/hashmap/Readme.md
index 252b06ea59b0..4400a97d8128 100644
--- a/src/main/java/com/thealgorithms/datastructures/hashmap/Readme.md
+++ b/src/main/java/com/thealgorithms/datastructures/hashmap/Readme.md
@@ -2,6 +2,8 @@
A hash map organizes data so you can quickly look up values for a given key.
+> Note: The term “hash map” refers to the data structure concept, while `HashMap` refers specifically to Java’s implementation.
+
## Strengths:
- **Fast lookups**: Lookups take O(1) time on average.
- **Flexible keys**: Most data types can be used for keys, as long as they're hashable.
diff --git a/src/main/java/com/thealgorithms/datastructures/hashmap/hashing/ImmutableHashMap.java b/src/main/java/com/thealgorithms/datastructures/hashmap/hashing/ImmutableHashMap.java
new file mode 100644
index 000000000000..f6e09ec623b6
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/hashmap/hashing/ImmutableHashMap.java
@@ -0,0 +1,115 @@
+package com.thealgorithms.datastructures.hashmap.hashing;
+
+/**
+ * Immutable HashMap implementation using separate chaining.
+ *
+ * This HashMap does not allow modification of existing instances.
+ * Any update operation returns a new ImmutableHashMap.
+ *
+ * @param key type
+ * @param value type
+ */
+public final class ImmutableHashMap {
+
+ private static final int DEFAULT_CAPACITY = 16;
+
+ private final Node[] table;
+ private final int size;
+
+ /**
+ * Private constructor to enforce immutability.
+ */
+ private ImmutableHashMap(Node[] table, int size) {
+ this.table = table;
+ this.size = size;
+ }
+
+ /**
+ * Creates an empty ImmutableHashMap.
+ *
+ * @param key type
+ * @param value type
+ * @return empty ImmutableHashMap
+ */
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ public static ImmutableHashMap empty() {
+ Node[] table = (Node[]) new Node[DEFAULT_CAPACITY];
+ return new ImmutableHashMap<>(table, 0);
+ }
+
+ /**
+ * Returns a new ImmutableHashMap with the given key-value pair added.
+ *
+ * @param key key to add
+ * @param value value to associate
+ * @return new ImmutableHashMap instance
+ */
+ public ImmutableHashMap put(K key, V value) {
+ Node[] newTable = table.clone();
+ int index = hash(key);
+
+ newTable[index] = new Node<>(key, value, newTable[index]);
+ return new ImmutableHashMap<>(newTable, size + 1);
+ }
+
+ /**
+ * Retrieves the value associated with the given key.
+ *
+ * @param key key to search
+ * @return value if found, otherwise null
+ */
+ public V get(K key) {
+ int index = hash(key);
+ Node current = table[index];
+
+ while (current != null) {
+ if ((key == null && current.key == null) || (key != null && key.equals(current.key))) {
+ return current.value;
+ }
+ current = current.next;
+ }
+ return null;
+ }
+
+ /**
+ * Checks whether the given key exists in the map.
+ *
+ * @param key key to check
+ * @return true if key exists, false otherwise
+ */
+ public boolean containsKey(K key) {
+ return get(key) != null;
+ }
+
+ /**
+ * Returns the number of key-value pairs.
+ *
+ * @return size of the map
+ */
+ public int size() {
+ return size;
+ }
+
+ /**
+ * Computes hash index for a given key.
+ */
+ private int hash(K key) {
+ return key == null ? 0 : (key.hashCode() & Integer.MAX_VALUE) % table.length;
+ }
+
+ /**
+ * Node class for separate chaining.
+ */
+ private static final class Node {
+
+ private final K key;
+ private final V value;
+ private final Node next;
+
+ private Node(K key, V value, Node next) {
+ this.key = key;
+ this.value = value;
+ this.next = next;
+ }
+ }
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/heaps/FibonacciHeap.java b/src/main/java/com/thealgorithms/datastructures/heaps/FibonacciHeap.java
index 7a263fc08ac5..834de9c77881 100644
--- a/src/main/java/com/thealgorithms/datastructures/heaps/FibonacciHeap.java
+++ b/src/main/java/com/thealgorithms/datastructures/heaps/FibonacciHeap.java
@@ -387,7 +387,7 @@ public class HeapNode {
private HeapNode parent;
/*
- * a constructor for a heapNode withe key @param (key)
+ * a constructor for a heapNode with key @param (key)
* prev == next == this
* parent == child == null
*/
diff --git a/src/main/java/com/thealgorithms/datastructures/heaps/IndexedPriorityQueue.java b/src/main/java/com/thealgorithms/datastructures/heaps/IndexedPriorityQueue.java
new file mode 100644
index 000000000000..ad7229760fd0
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/heaps/IndexedPriorityQueue.java
@@ -0,0 +1,327 @@
+package com.thealgorithms.datastructures.heaps;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.IdentityHashMap;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+/**
+ * An addressable (indexed) min-priority queue with O(log n) updates.
+ *
+ * Key features:
+ *
+ * - Each element E is tracked by a handle (its current heap index) via a map,
+ * enabling O(log n) {@code remove(e)} and O(log n) key updates
+ * ({@code changeKey/decreaseKey/increaseKey}).
+ * - The queue order is determined by the provided {@link Comparator}. If the
+ * comparator is {@code null}, elements must implement {@link Comparable}
+ * (same contract as {@link java.util.PriorityQueue}).
+ * - By default this implementation uses {@link IdentityHashMap} for the index
+ * mapping to avoid issues with duplicate-equals elements or mutable equals/hashCode.
+ * If you need value-based equality, switch to {@code HashMap} and read the caveats
+ * in the class-level Javadoc carefully.
+ *
+ *
+ * IMPORTANT contracts
+ *
+ * - Do not mutate comparator-relevant fields of an element directly while it is
+ * inside the queue. Always use {@code changeKey}/{@code decreaseKey}/{@code increaseKey}
+ * so the heap can be restored accordingly.
+ * - If you replace {@link IdentityHashMap} with {@link HashMap}, you must ensure:
+ * (a) no two distinct elements are {@code equals()}-equal at the same time in the queue, and
+ * (b) {@code equals/hashCode} of elements remain stable while enqueued.
+ * - {@code peek()} returns {@code null} when empty (matching {@link java.util.PriorityQueue}).
+ * - Not thread-safe.
+ *
+ *
+ * Complexities:
+ * {@code offer, poll, remove(e), changeKey, decreaseKey, increaseKey} are O(log n);
+ * {@code peek, isEmpty, size, contains} are O(1).
+ */
+public class IndexedPriorityQueue {
+
+ /** Binary heap storage (min-heap). */
+ private Object[] heap;
+
+ /** Number of elements in the heap. */
+ private int size;
+
+ /** Comparator used for ordering; if null, elements must be Comparable. */
+ private final Comparator cmp;
+
+ /**
+ * Index map: element -> current heap index.
+ * We use IdentityHashMap by default to:
+ *
+ * - allow duplicate-equals elements;
+ * - avoid corruption when equals/hashCode are mutable or not ID-based.
+ *
+ * If you prefer value-based semantics, replace with HashMap and
+ * respect the warnings in the class Javadoc.
+ */
+ private final IdentityHashMap index;
+
+ private static final int DEFAULT_INITIAL_CAPACITY = 11;
+
+ public IndexedPriorityQueue() {
+ this(DEFAULT_INITIAL_CAPACITY, null);
+ }
+
+ public IndexedPriorityQueue(Comparator cmp) {
+ this(DEFAULT_INITIAL_CAPACITY, cmp);
+ }
+
+ public IndexedPriorityQueue(int initialCapacity, Comparator cmp) {
+ if (initialCapacity < 1) {
+ throw new IllegalArgumentException("initialCapacity < 1");
+ }
+ this.heap = new Object[initialCapacity];
+ this.cmp = cmp;
+ this.index = new IdentityHashMap<>();
+ }
+
+ /** Returns current number of elements. */
+ public int size() {
+ return size;
+ }
+
+ /** Returns {@code true} if empty. */
+ public boolean isEmpty() {
+ return size == 0;
+ }
+
+ /**
+ * Returns the minimum element without removing it, or {@code null} if empty.
+ * Matches {@link java.util.PriorityQueue#peek()} behavior.
+ */
+ @SuppressWarnings("unchecked")
+ public E peek() {
+ return size == 0 ? null : (E) heap[0];
+ }
+
+ /**
+ * Inserts the specified element (O(log n)).
+ * @throws NullPointerException if {@code e} is null
+ * @throws ClassCastException if {@code cmp == null} and {@code e} is not Comparable,
+ * or if incompatible with other elements
+ */
+ public boolean offer(E e) {
+ Objects.requireNonNull(e, "element is null");
+ if (size >= heap.length) {
+ grow(size + 1);
+ }
+ // Insert at the end and bubble up. siftUp will maintain 'index' for all touched nodes.
+ siftUp(size, e);
+ size++;
+ return true;
+ }
+
+ /**
+ * Removes and returns the minimum element (O(log n)), or {@code null} if empty.
+ */
+ @SuppressWarnings("unchecked")
+ public E poll() {
+ if (size == 0) {
+ return null;
+ }
+ E min = (E) heap[0];
+ removeAt(0); // updates map and heap structure
+ return min;
+ }
+
+ /**
+ * Removes one occurrence of the specified element e (O(log n)) if present.
+ * Uses the index map for O(1) lookup.
+ */
+ public boolean remove(Object o) {
+ Integer i = index.get(o);
+ if (i == null) {
+ return false;
+ }
+ removeAt(i);
+ return true;
+ }
+
+ /** O(1): returns whether the queue currently contains the given element reference. */
+ public boolean contains(Object o) {
+ return index.containsKey(o);
+ }
+
+ /** Clears the heap and the index map. */
+ public void clear() {
+ Arrays.fill(heap, 0, size, null);
+ index.clear();
+ size = 0;
+ }
+
+ // ------------------------------------------------------------------------------------
+ // Key update API
+ // ------------------------------------------------------------------------------------
+
+ /**
+ * Changes comparator-relevant fields of {@code e} via the provided {@code mutator},
+ * then restores the heap in O(log n) by bubbling in the correct direction.
+ *
+ * IMPORTANT: The mutator must not change {@code equals/hashCode} of {@code e}
+ * if you migrate this implementation to value-based indexing (HashMap).
+ *
+ * @throws IllegalArgumentException if {@code e} is not in the queue
+ */
+ public void changeKey(E e, Consumer mutator) {
+ Integer i = index.get(e);
+ if (i == null) {
+ throw new IllegalArgumentException("Element not in queue");
+ }
+ // Mutate fields used by comparator (do NOT mutate equality/hash if using value-based map)
+ mutator.accept(e);
+ // Try bubbling up; if no movement occurred, bubble down.
+ if (!siftUp(i)) {
+ siftDown(i);
+ }
+ }
+
+ /**
+ * Faster variant if the new key is strictly smaller (higher priority).
+ * Performs a single sift-up (O(log n)).
+ */
+ public void decreaseKey(E e, Consumer mutator) {
+ Integer i = index.get(e);
+ if (i == null) {
+ throw new IllegalArgumentException("Element not in queue");
+ }
+ mutator.accept(e);
+ siftUp(i);
+ }
+
+ /**
+ * Faster variant if the new key is strictly larger (lower priority).
+ * Performs a single sift-down (O(log n)).
+ */
+ public void increaseKey(E e, Consumer mutator) {
+ Integer i = index.get(e);
+ if (i == null) {
+ throw new IllegalArgumentException("Element not in queue");
+ }
+ mutator.accept(e);
+ siftDown(i);
+ }
+
+ // ------------------------------------------------------------------------------------
+ // Internal utilities
+ // ------------------------------------------------------------------------------------
+
+ /** Grows the internal array to accommodate at least {@code minCapacity}. */
+ private void grow(int minCapacity) {
+ int old = heap.length;
+ int pref = (old < 64) ? old + 2 : old + (old >> 1); // +2 if small, else +50%
+ int newCap = Math.max(minCapacity, pref);
+ heap = Arrays.copyOf(heap, newCap);
+ }
+
+ @SuppressWarnings("unchecked")
+ private int compare(E a, E b) {
+ if (cmp != null) {
+ return cmp.compare(a, b);
+ }
+ return ((Comparable) a).compareTo(b);
+ }
+
+ /**
+ * Inserts item {@code x} at position {@code k}, bubbling up while maintaining the heap.
+ * Also maintains the index map for all moved elements.
+ */
+ @SuppressWarnings("unchecked")
+ private void siftUp(int k, E x) {
+ while (k > 0) {
+ int p = (k - 1) >>> 1;
+ E e = (E) heap[p];
+ if (compare(x, e) >= 0) {
+ break;
+ }
+ heap[k] = e;
+ index.put(e, k);
+ k = p;
+ }
+ heap[k] = x;
+ index.put(x, k);
+ }
+
+ /**
+ * Attempts to bubble up the element currently at {@code k}.
+ * @return true if it moved; false otherwise.
+ */
+ @SuppressWarnings("unchecked")
+ private boolean siftUp(int k) {
+ int orig = k;
+ E x = (E) heap[k];
+ while (k > 0) {
+ int p = (k - 1) >>> 1;
+ E e = (E) heap[p];
+ if (compare(x, e) >= 0) {
+ break;
+ }
+ heap[k] = e;
+ index.put(e, k);
+ k = p;
+ }
+ if (k != orig) {
+ heap[k] = x;
+ index.put(x, k);
+ return true;
+ }
+ return false;
+ }
+
+ /** Bubbles down the element currently at {@code k}. */
+ @SuppressWarnings("unchecked")
+ private void siftDown(int k) {
+ int n = size;
+ E x = (E) heap[k];
+ int half = n >>> 1; // loop while k has at least one child
+ while (k < half) {
+ int child = (k << 1) + 1; // assume left is smaller
+ E c = (E) heap[child];
+ int r = child + 1;
+ if (r < n && compare(c, (E) heap[r]) > 0) {
+ child = r;
+ c = (E) heap[child];
+ }
+ if (compare(x, c) <= 0) {
+ break;
+ }
+ heap[k] = c;
+ index.put(c, k);
+ k = child;
+ }
+ heap[k] = x;
+ index.put(x, k);
+ }
+
+ /**
+ * Removes the element at heap index {@code i}, restoring the heap afterwards.
+ * Returns nothing; the standard {@code PriorityQueue} returns a displaced
+ * element in a rare case to help its iterator. We don't need that here, so
+ * we keep the API simple.
+ */
+ @SuppressWarnings("unchecked")
+ private void removeAt(int i) {
+ int n = --size; // last index after removal
+ E moved = (E) heap[n];
+ E removed = (E) heap[i];
+ heap[n] = null; // help GC
+ index.remove(removed); // drop mapping for removed element
+
+ if (i == n) {
+ return; // removed last element; done
+ }
+
+ heap[i] = moved;
+ index.put(moved, i);
+
+ // Try sift-up first (cheap if key decreased); if no movement, sift-down.
+ if (!siftUp(i)) {
+ siftDown(i);
+ }
+ }
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/lists/CircularDoublyLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/CircularDoublyLinkedList.java
new file mode 100644
index 000000000000..fbb48854c449
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/lists/CircularDoublyLinkedList.java
@@ -0,0 +1,118 @@
+package com.thealgorithms.datastructures.lists;
+
+/**
+ * This class is a circular doubly linked list implementation. In a circular
+ * doubly linked list,
+ * the last node points back to the first node and the first node points back to
+ * the last node,
+ * creating a circular chain in both directions.
+ *
+ * This implementation includes basic operations such as appending elements to
+ * the end,
+ * removing elements from a specified position, and converting the list to a
+ * string representation.
+ *
+ * @param the type of elements held in this list
+ */
+public class CircularDoublyLinkedList {
+ static final class Node {
+ Node next;
+ Node prev;
+ E value;
+
+ private Node(E value, Node next, Node prev) {
+ this.value = value;
+ this.next = next;
+ this.prev = prev;
+ }
+ }
+
+ private int size;
+ Node head = null;
+
+ /**
+ * Initializes a new circular doubly linked list. A dummy head node is used for
+ * simplicity,
+ * pointing initially to itself to ensure the list is never empty.
+ */
+ public CircularDoublyLinkedList() {
+ head = new Node<>(null, null, null);
+ head.next = head;
+ head.prev = head;
+ size = 0;
+ }
+
+ /**
+ * Returns the current size of the list.
+ *
+ * @return the number of elements in the list
+ */
+ public int getSize() {
+ return size;
+ }
+
+ /**
+ * Appends a new element to the end of the list. Throws a NullPointerException
+ * if
+ * a null value is provided.
+ *
+ * @param value the value to append to the list
+ * @throws NullPointerException if the value is null
+ */
+ public void append(E value) {
+ if (value == null) {
+ throw new NullPointerException("Cannot add null element to the list");
+ }
+ Node newNode = new Node<>(value, head, head.prev);
+ head.prev.next = newNode;
+ head.prev = newNode;
+ size++;
+ }
+
+ /**
+ * Returns a string representation of the list in the format "[ element1,
+ * element2, ... ]".
+ * An empty list is represented as "[]".
+ *
+ * @return the string representation of the list
+ */
+ public String toString() {
+ if (size == 0) {
+ return "[]";
+ }
+ StringBuilder sb = new StringBuilder("[ ");
+ Node current = head.next;
+ while (current != head) {
+ sb.append(current.value);
+ if (current.next != head) {
+ sb.append(", ");
+ }
+ current = current.next;
+ }
+ sb.append(" ]");
+ return sb.toString();
+ }
+
+ /**
+ * Removes and returns the element at the specified position in the list.
+ * Throws an IndexOutOfBoundsException if the position is invalid.
+ *
+ * @param pos the position of the element to remove
+ * @return the value of the removed element - pop operation
+ * @throws IndexOutOfBoundsException if the position is out of range
+ */
+ public E remove(int pos) {
+ if (pos >= size || pos < 0) {
+ throw new IndexOutOfBoundsException("Position out of bounds");
+ }
+ Node current = head.next;
+ for (int i = 0; i < pos; i++) {
+ current = current.next;
+ }
+ current.prev.next = current.next;
+ current.next.prev = current.prev;
+ E removedValue = current.value;
+ size--;
+ return removedValue;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/lists/FlattenMultilevelLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/FlattenMultilevelLinkedList.java
new file mode 100644
index 000000000000..3c4106f178b9
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/lists/FlattenMultilevelLinkedList.java
@@ -0,0 +1,92 @@
+package com.thealgorithms.datastructures.lists;
+/**
+ * Implements an algorithm to flatten a multilevel linked list.
+ *
+ * In this specific problem structure, each node has a `next` pointer (to the
+ * next node at the same level) and a `child` pointer (which points to the head
+ * of another sorted linked list). The goal is to merge all these lists into a
+ * single, vertically sorted linked list using the `child` pointer.
+ *
+ * The approach is a recursive one that leverages a merge utility, similar to
+ * the merge step in Merge Sort. It recursively flattens the list starting from
+ * the rightmost node and merges each node's child list with the already
+ * flattened list to its right.
+ * @see GeeksforGeeks: Flattening a Linked List
+ */
+public final class FlattenMultilevelLinkedList {
+ /**
+ * Private constructor to prevent instantiation of this utility class.
+ */
+ private FlattenMultilevelLinkedList() {
+ }
+ /**
+ * Node represents an element in the multilevel linked list. It contains the
+ * integer data, a reference to the next node at the same level, and a
+ * reference to the head of a child list.
+ */
+ static class Node {
+ int data;
+ Node next;
+ Node child;
+
+ Node(int data) {
+ this.data = data;
+ this.next = null;
+ this.child = null;
+ }
+ }
+
+ /**
+ * Merges two sorted linked lists (connected via the `child` pointer).
+ * This is a helper function for the main flatten algorithm.
+ *
+ * @param a The head of the first sorted list.
+ * @param b The head of the second sorted list.
+ * @return The head of the merged sorted list.
+ */
+ private static Node merge(Node a, Node b) {
+ // If one of the lists is empty, return the other.
+ if (a == null) {
+ return b;
+ }
+ if (b == null) {
+ return a;
+ }
+
+ Node result;
+
+ // Choose the smaller value as the new head.
+ if (a.data < b.data) {
+ result = a;
+ result.child = merge(a.child, b);
+ } else {
+ result = b;
+ result.child = merge(a, b.child);
+ }
+ result.next = null; // Ensure the merged list has no `next` pointers.
+ return result;
+ }
+
+ /**
+ * Flattens a multilevel linked list into a single sorted list.
+ * The flattened list is connected using the `child` pointers.
+ *
+ * @param head The head of the top-level list (connected via `next` pointers).
+ * @return The head of the fully flattened and sorted list.
+ */
+ public static Node flatten(Node head) {
+ // Base case: if the list is empty or has only one node, it's already flattened.
+ if (head == null || head.next == null) {
+ return head;
+ }
+
+ // Recursively flatten the list starting from the next node.
+ head.next = flatten(head.next);
+
+ // Now, merge the current list (head's child list) with the flattened rest of the list.
+ head = merge(head, head.next);
+
+ // Return the head of the fully merged list.
+ return head;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/lists/MiddleOfLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/MiddleOfLinkedList.java
new file mode 100644
index 000000000000..0ee788db2ff9
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/lists/MiddleOfLinkedList.java
@@ -0,0 +1,46 @@
+package com.thealgorithms.datastructures.lists;
+
+/**
+ * Returns the middle node of a singly linked list using the two-pointer technique.
+ *
+ * The {@code slow} pointer advances by one node per iteration while {@code fast} advances by two.
+ * When {@code fast == null} or {@code fast.next == null}, {@code slow} points to the middle node.
+ * For even-length lists, this returns the second middle node.
+ *
+ * This method does not modify the input list.
+ *
+ * Reference: https://en.wikipedia.org/wiki/Cycle_detection#Floyd's_tortoise_and_hare
+ *
+ * Complexity:
+ *
+ * - Time: {@code O(n)}
+ * - Space: {@code O(1)}
+ *
+ */
+public final class MiddleOfLinkedList {
+
+ private MiddleOfLinkedList() {
+ }
+
+ /**
+ * Returns the middle node of the list.
+ *
+ * @param head the head of the singly linked list; may be {@code null}
+ * @return the middle node (second middle for even-sized lists), or {@code null} if {@code head} is {@code null}
+ */
+ public static SinglyLinkedListNode middleNode(final SinglyLinkedListNode head) {
+ if (head == null) {
+ return null;
+ }
+
+ SinglyLinkedListNode slow = head;
+ SinglyLinkedListNode fast = head;
+
+ while (fast != null && fast.next != null) {
+ slow = slow.next;
+ fast = fast.next.next;
+ }
+
+ return slow;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/lists/README.md b/src/main/java/com/thealgorithms/datastructures/lists/README.md
index 6aefa4c98e6d..5a0a43b923e1 100644
--- a/src/main/java/com/thealgorithms/datastructures/lists/README.md
+++ b/src/main/java/com/thealgorithms/datastructures/lists/README.md
@@ -28,5 +28,6 @@ The `next` variable points to the next node in the data structure and value stor
4. `CreateAndDetectLoop.java` : Create and detect a loop in a linked list.
5. `DoublyLinkedList.java` : A modification of singly linked list which has a `prev` pointer to point to the previous node.
6. `MergeKSortedLinkedlist.java` : Merges K sorted linked list with mergesort (mergesort is also the most efficient sorting algorithm for linked list).
-7. `RandomNode.java` : Selects a random node from given linked list and diplays it.
+7. `RandomNode.java` : Selects a random node from given linked list and displays it.
8. `SkipList.java` : Data Structure used for storing a sorted list of elements with help of a Linked list hierarchy that connects to subsequences of elements.
+9. `TortoiseHareAlgo.java` : Finds the middle element of a linked list using the fast and slow pointer (Tortoise-Hare) algorithm.
diff --git a/src/main/java/com/thealgorithms/datastructures/lists/TortoiseHareAlgo.java b/src/main/java/com/thealgorithms/datastructures/lists/TortoiseHareAlgo.java
new file mode 100644
index 000000000000..9d803003c658
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/lists/TortoiseHareAlgo.java
@@ -0,0 +1,63 @@
+package com.thealgorithms.datastructures.lists;
+
+public class TortoiseHareAlgo {
+ static final class Node {
+ Node next;
+ E value;
+
+ private Node(E value, Node next) {
+ this.value = value;
+ this.next = next;
+ }
+ }
+
+ private Node head = null;
+
+ public TortoiseHareAlgo() {
+ head = null;
+ }
+
+ public void append(E value) {
+ Node newNode = new Node<>(value, null);
+ if (head == null) {
+ head = newNode;
+ return;
+ }
+ Node current = head;
+ while (current.next != null) {
+ current = current.next;
+ }
+ current.next = newNode;
+ }
+
+ public E getMiddle() {
+ if (head == null) {
+ return null;
+ }
+
+ Node slow = head;
+ Node fast = head;
+
+ while (fast != null && fast.next != null) {
+ slow = slow.next;
+ fast = fast.next.next;
+ }
+
+ return slow.value;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("[");
+ Node current = head;
+ while (current != null) {
+ sb.append(current.value);
+ if (current.next != null) {
+ sb.append(", ");
+ }
+ current = current.next;
+ }
+ sb.append("]");
+ return sb.toString();
+ }
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/queues/PriorityQueues.java b/src/main/java/com/thealgorithms/datastructures/queues/PriorityQueues.java
index a5ca48670f2c..b877a5843b98 100644
--- a/src/main/java/com/thealgorithms/datastructures/queues/PriorityQueues.java
+++ b/src/main/java/com/thealgorithms/datastructures/queues/PriorityQueues.java
@@ -9,7 +9,7 @@
* give numbers that are bigger, a higher priority. Queues in theory have no
* fixed size but when using an array implementation it does.
*
- * Additional contibutions made by: PuneetTri(https://github.com/PuneetTri)
+ * Additional contributions made by: PuneetTri(https://github.com/PuneetTri)
*/
class PriorityQueue {
@@ -32,8 +32,8 @@ class PriorityQueue {
PriorityQueue() {
/* If capacity is not defined, default size of 11 would be used
- * capacity=max+1 because we cant access 0th element of PQ, and to
- * accomodate (max)th elements we need capacity to be max+1.
+ * capacity=max+1 because we can't access 0th element of PQ, and to
+ * accommodate (max)th elements we need capacity to be max+1.
* Parent is at position k, child at position (k*2,k*2+1), if we
* use position 0 in our queue, its child would be at:
* (0*2, 0*2+1) -> (0,0). This is why we start at position 1
@@ -127,7 +127,7 @@ public int remove() {
if (isEmpty()) {
throw new RuntimeException("Queue is Empty");
} else {
- int max = queueArray[1]; // By defintion of our max-heap, value at queueArray[1] pos is
+ int max = queueArray[1]; // By definition of our max-heap, value at queueArray[1] pos is
// the greatest
// Swap max and last element
diff --git a/src/main/java/com/thealgorithms/datastructures/trees/AVLSimple.java b/src/main/java/com/thealgorithms/datastructures/trees/AVLSimple.java
index e0309122cc12..07fc5c87b6c4 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/AVLSimple.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/AVLSimple.java
@@ -1,7 +1,7 @@
package com.thealgorithms.datastructures.trees;
/*
-* Avl is algo that balance itself while adding new alues to tree
+* Avl is algo that balance itself while adding new values to tree
* by rotating branches of binary tree and make itself Binary seaarch tree
* there are four cases which has to tackle
* rotating - left right ,left left,right right,right left
diff --git a/src/main/java/com/thealgorithms/datastructures/trees/BSTRecursiveGeneric.java b/src/main/java/com/thealgorithms/datastructures/trees/BSTRecursiveGeneric.java
index 5c1334ffa0e8..2c94224ddeb4 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/BSTRecursiveGeneric.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/BSTRecursiveGeneric.java
@@ -13,6 +13,7 @@
*
*
* @author [Madhur Panwar](git-Madhur Panwar)
+ * @author [Udaya Krishnan M](git-Udaya Krishnan M) {added prettyDisplay() method}
*/
public class BSTRecursiveGeneric> {
@@ -28,6 +29,29 @@ public BSTRecursiveGeneric() {
root = null;
}
+ /**
+ * Displays the tree is a structured format
+ */
+ public void prettyDisplay() {
+ prettyDisplay(root, 0);
+ }
+
+ private void prettyDisplay(Node node, int level) {
+ if (node == null) {
+ return;
+ }
+ prettyDisplay(node.right, level + 1);
+ if (level != 0) {
+ for (int i = 0; i < level - 1; i++) {
+ System.out.print("|\t");
+ }
+ System.out.println("|---->" + node.data);
+ } else {
+ System.out.println(node.data);
+ }
+ prettyDisplay(node.left, level + 1);
+ }
+
/**
* main function for testing
*/
@@ -38,7 +62,12 @@ public static void main(String[] args) {
integerTree.add(5);
integerTree.add(10);
- integerTree.add(9);
+ integerTree.add(-9);
+ integerTree.add(4);
+ integerTree.add(3);
+ integerTree.add(1);
+ System.out.println("Pretty Display of current tree is:");
+ integerTree.prettyDisplay();
assert !integerTree.find(4)
: "4 is not yet present in BST";
assert integerTree.find(10)
@@ -54,16 +83,21 @@ public static void main(String[] args) {
assert integerTree.find(70)
: "70 was inserted but not found";
/*
- Will print in following order
- 5 10 20 70
+ Will print in following order
+ 5 10 20 70
*/
+ System.out.println("Pretty Display of current tree is:");
+ integerTree.prettyDisplay();
integerTree.inorder();
+ System.out.println("Pretty Display of current tree is:");
+ integerTree.prettyDisplay();
System.out.println();
System.out.println("Testing for string data...");
// String
BSTRecursiveGeneric stringTree = new BSTRecursiveGeneric();
stringTree.add("banana");
+ stringTree.add("apple");
stringTree.add("pineapple");
stringTree.add("date");
assert !stringTree.find("girl")
@@ -80,11 +114,15 @@ public static void main(String[] args) {
stringTree.add("hills");
assert stringTree.find("hills")
: "hills was inserted but not found";
+ System.out.println("Pretty Display of current tree is:");
+ stringTree.prettyDisplay();
/*
Will print in following order
banana hills india pineapple
*/
stringTree.inorder();
+ System.out.println("Pretty Display of current tree is:");
+ stringTree.prettyDisplay();
}
/**
diff --git a/src/main/java/com/thealgorithms/datastructures/trees/BinaryTreeToString.java b/src/main/java/com/thealgorithms/datastructures/trees/BinaryTreeToString.java
new file mode 100644
index 000000000000..2f9b3b489d56
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/trees/BinaryTreeToString.java
@@ -0,0 +1,100 @@
+package com.thealgorithms.datastructures.trees;
+
+/**
+ * Leetcode 606: Construct String from Binary Tree:
+ * https://leetcode.com/problems/construct-string-from-binary-tree/
+ *
+ * Utility class to convert a {@link BinaryTree} into its string representation.
+ *
+ * The conversion follows a preorder traversal pattern (root → left → right)
+ * and uses parentheses to denote the tree structure.
+ * Empty parentheses "()" are used to explicitly represent missing left children
+ * when a right child exists, ensuring the structure is unambiguous.
+ *
+ *
+ * Rules:
+ *
+ * - Each node is represented as {@code (value)}.
+ * - If a node has only a right child, include {@code ()} before the right
+ * child
+ * to indicate the missing left child.
+ * - If a node has no children, it appears as just {@code (value)}.
+ * - The outermost parentheses are removed from the final string.
+ *
+ *
+ * Example:
+ *
+ *
+ * Input tree:
+ * 1
+ * / \
+ * 2 3
+ * \
+ * 4
+ *
+ * Output string:
+ * "1(2()(4))(3)"
+ *
+ *
+ *
+ * This implementation matches the logic from LeetCode problem 606:
+ * Construct String from Binary Tree.
+ *
+ *
+ * @author Muhammad Junaid
+ * @see BinaryTree
+ */
+public class BinaryTreeToString {
+
+ /** String builder used to accumulate the string representation. */
+ private StringBuilder sb;
+
+ /**
+ * Converts a binary tree (given its root node) to its string representation.
+ *
+ * @param root the root node of the binary tree
+ * @return the string representation of the binary tree, or an empty string if
+ * the tree is null
+ */
+ public String tree2str(BinaryTree.Node root) {
+ if (root == null) {
+ return "";
+ }
+
+ sb = new StringBuilder();
+ dfs(root);
+
+ // Remove the leading and trailing parentheses added by the root call
+ return sb.substring(1, sb.length() - 1);
+ }
+
+ /**
+ * Performs a recursive depth-first traversal to build the string.
+ * Each recursive call appends the node value and its children (if any)
+ * enclosed in parentheses.
+ *
+ * @param node the current node being processed
+ */
+ private void dfs(BinaryTree.Node node) {
+ if (node == null) {
+ return;
+ }
+
+ sb.append("(").append(node.data);
+
+ // Recursively build left and right subtrees
+ if (node.left != null) {
+ dfs(node.left);
+ }
+
+ // Handle the special case: right child exists but left child is null
+ if (node.right != null && node.left == null) {
+ sb.append("()");
+ dfs(node.right);
+ } else if (node.right != null) {
+ dfs(node.right);
+ }
+
+ sb.append(")");
+ }
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/trees/CeilInBinarySearchTree.java b/src/main/java/com/thealgorithms/datastructures/trees/CeilInBinarySearchTree.java
index 214e111b9f1a..fff84111663b 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/CeilInBinarySearchTree.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/CeilInBinarySearchTree.java
@@ -21,7 +21,7 @@
*
* Solution 1: Brute Force Solution: Do an inorder traversal and save result
* into an array. Iterate over the array to get an element equal to or greater
- * than current key. Time Complexity: O(n) Space Complexity: O(n) for auxillary
+ * than current key. Time Complexity: O(n) Space Complexity: O(n) for auxiliary
* array to save inorder representation of tree.
*
*
@@ -29,7 +29,7 @@
* into an array.Since array is sorted do a binary search over the array to get
* an element equal to or greater than current key. Time Complexity: O(n) for
* traversal of tree and O(lg(n)) for binary search in array. Total = O(n) Space
- * Complexity: O(n) for auxillary array to save inorder representation of tree.
+ * Complexity: O(n) for auxiliary array to save inorder representation of tree.
*
*
* Solution 3: Optimal We can do a DFS search on given tree in following
diff --git a/src/main/java/com/thealgorithms/datastructures/trees/CentroidDecomposition.java b/src/main/java/com/thealgorithms/datastructures/trees/CentroidDecomposition.java
new file mode 100644
index 000000000000..0b29dd6f5f5e
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/trees/CentroidDecomposition.java
@@ -0,0 +1,217 @@
+package com.thealgorithms.datastructures.trees;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Centroid Decomposition is a divide-and-conquer technique for trees.
+ * It recursively partitions a tree by finding centroids - nodes whose removal
+ * creates balanced subtrees (each with at most N/2 nodes).
+ *
+ *
+ * Time Complexity: O(N log N) for construction
+ * Space Complexity: O(N)
+ *
+ *
+ * Applications:
+ * - Distance queries on trees
+ * - Path counting problems
+ * - Nearest neighbor searches
+ *
+ * @see Centroid Decomposition
+ * @see Centroid Decomposition Tutorial
+ * @author lens161
+ */
+public final class CentroidDecomposition {
+
+ private CentroidDecomposition() {
+ }
+
+ /**
+ * Represents the centroid tree structure.
+ */
+ public static final class CentroidTree {
+ private final int n;
+ private final List> adj;
+ private final int[] parent;
+ private final int[] subtreeSize;
+ private final boolean[] removed;
+ private int root;
+
+ /**
+ * Constructs a centroid tree from an adjacency list.
+ *
+ * @param adj adjacency list representation of the tree (0-indexed)
+ * @throws IllegalArgumentException if tree is empty or null
+ */
+ public CentroidTree(List> adj) {
+ if (adj == null || adj.isEmpty()) {
+ throw new IllegalArgumentException("Tree cannot be empty or null");
+ }
+
+ this.n = adj.size();
+ this.adj = adj;
+ this.parent = new int[n];
+ this.subtreeSize = new int[n];
+ this.removed = new boolean[n];
+ Arrays.fill(parent, -1);
+
+ // Build centroid tree starting from node 0
+ this.root = decompose(0, -1);
+ }
+
+ /**
+ * Recursively builds the centroid tree.
+ *
+ * @param u current node
+ * @param p parent in centroid tree
+ * @return centroid of current component
+ */
+ private int decompose(int u, int p) {
+ int size = getSubtreeSize(u, -1);
+ int centroid = findCentroid(u, -1, size);
+
+ removed[centroid] = true;
+ parent[centroid] = p;
+
+ // Recursively decompose each subtree
+ for (int v : adj.get(centroid)) {
+ if (!removed[v]) {
+ decompose(v, centroid);
+ }
+ }
+
+ return centroid;
+ }
+
+ /**
+ * Calculates subtree size from node u.
+ *
+ * @param u current node
+ * @param p parent node (-1 for root)
+ * @return size of subtree rooted at u
+ */
+ private int getSubtreeSize(int u, int p) {
+ subtreeSize[u] = 1;
+ for (int v : adj.get(u)) {
+ if (v != p && !removed[v]) {
+ subtreeSize[u] += getSubtreeSize(v, u);
+ }
+ }
+ return subtreeSize[u];
+ }
+
+ /**
+ * Finds the centroid of a subtree.
+ * A centroid is a node whose removal creates components with size <= totalSize/2.
+ *
+ * @param u current node
+ * @param p parent node
+ * @param totalSize total size of current component
+ * @return centroid node
+ */
+ private int findCentroid(int u, int p, int totalSize) {
+ for (int v : adj.get(u)) {
+ if (v != p && !removed[v] && subtreeSize[v] > totalSize / 2) {
+ return findCentroid(v, u, totalSize);
+ }
+ }
+ return u;
+ }
+
+ /**
+ * Gets the parent of a node in the centroid tree.
+ *
+ * @param node the node
+ * @return parent node in centroid tree, or -1 if root
+ */
+ public int getParent(int node) {
+ if (node < 0 || node >= n) {
+ throw new IllegalArgumentException("Invalid node: " + node);
+ }
+ return parent[node];
+ }
+
+ /**
+ * Gets the root of the centroid tree.
+ *
+ * @return root node
+ */
+ public int getRoot() {
+ return root;
+ }
+
+ /**
+ * Gets the number of nodes in the tree.
+ *
+ * @return number of nodes
+ */
+ public int size() {
+ return n;
+ }
+
+ /**
+ * Returns the centroid tree structure as a string.
+ * Format: node -> parent (or ROOT for root node)
+ *
+ * @return string representation
+ */
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("Centroid Tree:\n");
+ for (int i = 0; i < n; i++) {
+ sb.append("Node ").append(i).append(" -> ");
+ if (parent[i] == -1) {
+ sb.append("ROOT");
+ } else {
+ sb.append("Parent ").append(parent[i]);
+ }
+ sb.append("\n");
+ }
+ return sb.toString();
+ }
+ }
+
+ /**
+ * Creates a centroid tree from an edge list.
+ *
+ * @param n number of nodes (0-indexed: 0 to n-1)
+ * @param edges list of edges where each edge is [u, v]
+ * @return CentroidTree object
+ * @throws IllegalArgumentException if n <= 0 or edges is invalid
+ */
+ public static CentroidTree buildFromEdges(int n, int[][] edges) {
+ if (n <= 0) {
+ throw new IllegalArgumentException("Number of nodes must be positive");
+ }
+ if (edges == null) {
+ throw new IllegalArgumentException("Edges cannot be null");
+ }
+ if (edges.length != n - 1) {
+ throw new IllegalArgumentException("Tree must have exactly n-1 edges");
+ }
+
+ List> adj = new ArrayList<>();
+ for (int i = 0; i < n; i++) {
+ adj.add(new ArrayList<>());
+ }
+
+ for (int[] edge : edges) {
+ if (edge.length != 2) {
+ throw new IllegalArgumentException("Each edge must have exactly 2 nodes");
+ }
+ int u = edge[0];
+ int v = edge[1];
+
+ if (u < 0 || u >= n || v < 0 || v >= n) {
+ throw new IllegalArgumentException("Invalid node in edge: [" + u + ", " + v + "]");
+ }
+
+ adj.get(u).add(v);
+ adj.get(v).add(u);
+ }
+
+ return new CentroidTree(adj);
+ }
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/trees/ThreadedBinaryTree.java b/src/main/java/com/thealgorithms/datastructures/trees/ThreadedBinaryTree.java
new file mode 100644
index 000000000000..fd8876cecb70
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/trees/ThreadedBinaryTree.java
@@ -0,0 +1,145 @@
+/*
+ * TheAlgorithms (https://github.com/TheAlgorithms/Java)
+ * Author: Shewale41
+ * This file is licensed under the MIT License.
+ */
+
+package com.thealgorithms.datastructures.trees;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Threaded binary tree implementation that supports insertion and
+ * in-order traversal without recursion or stack by using threads.
+ *
+ * In this implementation, a node's null left/right pointers are used
+ * to point to the in-order predecessor/successor respectively. Two flags
+ * indicate whether left/right pointers are real children or threads.
+ *
+ * @see Wikipedia:
+ * Threaded binary tree
+ */
+public final class ThreadedBinaryTree {
+
+ private Node root;
+
+ private static final class Node {
+ int value;
+ Node left;
+ Node right;
+ boolean leftIsThread;
+ boolean rightIsThread;
+
+ Node(int value) {
+ this.value = value;
+ this.left = null;
+ this.right = null;
+ this.leftIsThread = false;
+ this.rightIsThread = false;
+ }
+ }
+
+ public ThreadedBinaryTree() {
+ this.root = null;
+ }
+
+ /**
+ * Inserts a value into the threaded binary tree. Duplicate values are inserted
+ * to the right subtree (consistent deterministic rule).
+ *
+ * @param value the integer value to insert
+ */
+ public void insert(int value) {
+ Node newNode = new Node(value);
+ if (root == null) {
+ root = newNode;
+ return;
+ }
+
+ Node current = root;
+ Node parent = null;
+
+ while (true) {
+ parent = current;
+ if (value < current.value) {
+ if (!current.leftIsThread && current.left != null) {
+ current = current.left;
+ } else {
+ break;
+ }
+ } else { // value >= current.value
+ if (!current.rightIsThread && current.right != null) {
+ current = current.right;
+ } else {
+ break;
+ }
+ }
+ }
+
+ if (value < parent.value) {
+ // attach newNode as left child
+ newNode.left = parent.left;
+ newNode.leftIsThread = parent.leftIsThread;
+ newNode.right = parent;
+ newNode.rightIsThread = true;
+
+ parent.left = newNode;
+ parent.leftIsThread = false;
+ } else {
+ // attach newNode as right child
+ newNode.right = parent.right;
+ newNode.rightIsThread = parent.rightIsThread;
+ newNode.left = parent;
+ newNode.leftIsThread = true;
+
+ parent.right = newNode;
+ parent.rightIsThread = false;
+ }
+ }
+
+ /**
+ * Returns the in-order traversal of the tree as a list of integers.
+ * Traversal is done without recursion or an explicit stack by following threads.
+ *
+ * @return list containing the in-order sequence of node values
+ */
+ public List inorderTraversal() {
+ List result = new ArrayList<>();
+ Node current = root;
+ if (current == null) {
+ return result;
+ }
+
+ // Move to the leftmost node
+ while (current.left != null && !current.leftIsThread) {
+ current = current.left;
+ }
+
+ while (current != null) {
+ result.add(current.value);
+
+ // If right pointer is a thread, follow it
+ if (current.rightIsThread) {
+ current = current.right;
+ } else {
+ // Move to leftmost node in right subtree
+ current = current.right;
+ while (current != null && !current.leftIsThread && current.left != null) {
+ current = current.left;
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Helper: checks whether the tree is empty.
+ *
+ * @return true if tree has no nodes
+ */
+ public boolean isEmpty() {
+ return root == null;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/devutils/nodes/LargeTreeNode.java b/src/main/java/com/thealgorithms/devutils/nodes/LargeTreeNode.java
index 95d53ecb1f7a..d69288f72200 100644
--- a/src/main/java/com/thealgorithms/devutils/nodes/LargeTreeNode.java
+++ b/src/main/java/com/thealgorithms/devutils/nodes/LargeTreeNode.java
@@ -3,7 +3,7 @@
import java.util.Collection;
/**
- * {@link TreeNode} extension that holds a {@link Collection} of refrences to
+ * {@link TreeNode} extension that holds a {@link Collection} of references to
* child Nodes.
*
* @param The type of the data held in the Node.
@@ -18,7 +18,7 @@ public class LargeTreeNode extends TreeNode {
private Collection> childNodes;
/**
- * Empty contructor.
+ * Empty constructor.
*/
public LargeTreeNode() {
super();
diff --git a/src/main/java/com/thealgorithms/devutils/nodes/SimpleNode.java b/src/main/java/com/thealgorithms/devutils/nodes/SimpleNode.java
index 769ffc2a9a96..bf3e795dd74b 100644
--- a/src/main/java/com/thealgorithms/devutils/nodes/SimpleNode.java
+++ b/src/main/java/com/thealgorithms/devutils/nodes/SimpleNode.java
@@ -15,7 +15,7 @@ public class SimpleNode extends Node {
private SimpleNode nextNode;
/**
- * Empty contructor.
+ * Empty constructor.
*/
public SimpleNode() {
super();
diff --git a/src/main/java/com/thealgorithms/devutils/nodes/SimpleTreeNode.java b/src/main/java/com/thealgorithms/devutils/nodes/SimpleTreeNode.java
index 215f01a6ef59..eefffacee8d6 100644
--- a/src/main/java/com/thealgorithms/devutils/nodes/SimpleTreeNode.java
+++ b/src/main/java/com/thealgorithms/devutils/nodes/SimpleTreeNode.java
@@ -11,16 +11,16 @@
public class SimpleTreeNode extends TreeNode {
/**
- * Refrence to the child Node on the left.
+ * Reference to the child Node on the left.
*/
private SimpleTreeNode leftNode;
/**
- * Refrence to the child Node on the right.
+ * Reference to the child Node on the right.
*/
private SimpleTreeNode rightNode;
/**
- * Empty contructor.
+ * Empty constructor.
*/
public SimpleTreeNode() {
super();
diff --git a/src/main/java/com/thealgorithms/devutils/nodes/TreeNode.java b/src/main/java/com/thealgorithms/devutils/nodes/TreeNode.java
index 13c9212306c1..1639bec6e5a0 100644
--- a/src/main/java/com/thealgorithms/devutils/nodes/TreeNode.java
+++ b/src/main/java/com/thealgorithms/devutils/nodes/TreeNode.java
@@ -12,7 +12,7 @@
public abstract class TreeNode extends Node {
/**
- * Refernce to the parent Node.
+ * Reference to the parent Node.
*/
private TreeNode parentNode;
/**
@@ -21,7 +21,7 @@ public abstract class TreeNode extends Node {
private int depth;
/**
- * Empty contructor.
+ * Empty constructor.
*/
public TreeNode() {
super();
diff --git a/src/main/java/com/thealgorithms/divideandconquer/ClosestPair.java b/src/main/java/com/thealgorithms/divideandconquer/ClosestPair.java
index cd26f9213651..4c9c40c83174 100644
--- a/src/main/java/com/thealgorithms/divideandconquer/ClosestPair.java
+++ b/src/main/java/com/thealgorithms/divideandconquer/ClosestPair.java
@@ -182,7 +182,7 @@ public double closestPair(final Location[] a, final int indexNum) {
double minLeftArea; // Minimum length of left array
double minRightArea; // Minimum length of right array
- double minValue; // Minimum lengt
+ double minValue; // Minimum length
minLeftArea = closestPair(leftArray, divideX); // recursive closestPair
minRightArea = closestPair(rightArray, indexNum - divideX);
diff --git a/src/main/java/com/thealgorithms/divideandconquer/SkylineAlgorithm.java b/src/main/java/com/thealgorithms/divideandconquer/SkylineAlgorithm.java
index 610b1b78a36a..0e8d9442138c 100644
--- a/src/main/java/com/thealgorithms/divideandconquer/SkylineAlgorithm.java
+++ b/src/main/java/com/thealgorithms/divideandconquer/SkylineAlgorithm.java
@@ -161,7 +161,7 @@ public int getY() {
* function dominates the argument point.
*
* @param p1 the point that is compared
- * @return true if the point wich calls the function dominates p1 false
+ * @return true if the point which calls the function dominates p1 false
* otherwise.
*/
public boolean dominates(Point p1) {
diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/BoundaryFill.java b/src/main/java/com/thealgorithms/dynamicprogramming/BoundaryFill.java
index 8494492f293f..ccd54ee4349a 100644
--- a/src/main/java/com/thealgorithms/dynamicprogramming/BoundaryFill.java
+++ b/src/main/java/com/thealgorithms/dynamicprogramming/BoundaryFill.java
@@ -12,8 +12,8 @@ private BoundaryFill() {
* Get the color at the given co-odrinates of a 2D image
*
* @param image The image to be filled
- * @param xCoordinate The x co-ordinate of which color is to be obtained
- * @param yCoordinate The y co-ordinate of which color is to be obtained
+ * @param xCoordinate The x coordinate of which color is to be obtained
+ * @param yCoordinate The y coordinate of which color is to be obtained
*/
public static int getPixel(int[][] image, int xCoordinate, int yCoordinate) {
return image[xCoordinate][yCoordinate];
@@ -23,8 +23,8 @@ public static int getPixel(int[][] image, int xCoordinate, int yCoordinate) {
* Put the color at the given co-odrinates of a 2D image
*
* @param image The image to be filed
- * @param xCoordinate The x co-ordinate at which color is to be filled
- * @param yCoordinate The y co-ordinate at which color is to be filled
+ * @param xCoordinate The x coordinate at which color is to be filled
+ * @param yCoordinate The y coordinate at which color is to be filled
*/
public static void putPixel(int[][] image, int xCoordinate, int yCoordinate, int newColor) {
image[xCoordinate][yCoordinate] = newColor;
@@ -34,8 +34,8 @@ public static void putPixel(int[][] image, int xCoordinate, int yCoordinate, int
* Fill the 2D image with new color
*
* @param image The image to be filed
- * @param xCoordinate The x co-ordinate at which color is to be filled
- * @param yCoordinate The y co-ordinate at which color is to be filled
+ * @param xCoordinate The x coordinate at which color is to be filled
+ * @param yCoordinate The y coordinate at which color is to be filled
* @param newColor The new color which to be filled in the image
* @param boundaryColor The old color which is to be replaced in the image
*/
diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/DamerauLevenshteinDistance.java b/src/main/java/com/thealgorithms/dynamicprogramming/DamerauLevenshteinDistance.java
new file mode 100644
index 000000000000..9721d4ab0ad5
--- /dev/null
+++ b/src/main/java/com/thealgorithms/dynamicprogramming/DamerauLevenshteinDistance.java
@@ -0,0 +1,185 @@
+package com.thealgorithms.dynamicprogramming;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Implementation of the full Damerau–Levenshtein distance algorithm.
+ *
+ * This algorithm calculates the minimum number of operations required
+ * to transform one string into another. Supported operations are:
+ * insertion, deletion, substitution, and transposition of adjacent characters.
+ *
+ * Unlike the restricted version (OSA), this implementation allows multiple
+ * edits on the same substring, computing the true edit distance.
+ *
+ * Time Complexity: O(n * m * max(n, m))
+ * Space Complexity: O(n * m)
+ */
+public final class DamerauLevenshteinDistance {
+
+ private DamerauLevenshteinDistance() {
+ // Utility class
+ }
+
+ /**
+ * Computes the full Damerau–Levenshtein distance between two strings.
+ *
+ * @param s1 the first string
+ * @param s2 the second string
+ * @return the minimum edit distance between the two strings
+ * @throws IllegalArgumentException if either input string is null
+ */
+ public static int distance(String s1, String s2) {
+ validateInputs(s1, s2);
+
+ int n = s1.length();
+ int m = s2.length();
+
+ Map charLastPosition = buildCharacterMap(s1, s2);
+ int[][] dp = initializeTable(n, m);
+
+ fillTable(s1, s2, dp, charLastPosition);
+
+ return dp[n + 1][m + 1];
+ }
+
+ /**
+ * Validates that both input strings are not null.
+ *
+ * @param s1 the first string to validate
+ * @param s2 the second string to validate
+ * @throws IllegalArgumentException if either string is null
+ */
+ private static void validateInputs(String s1, String s2) {
+ if (s1 == null || s2 == null) {
+ throw new IllegalArgumentException("Input strings must not be null.");
+ }
+ }
+
+ /**
+ * Builds a character map containing all unique characters from both strings.
+ * Each character is initialized with a position value of 0.
+ *
+ * This map is used to track the last occurrence position of each character
+ * during the distance computation, which is essential for handling transpositions.
+ *
+ * @param s1 the first string
+ * @param s2 the second string
+ * @return a map containing all unique characters from both strings, initialized to 0
+ */
+ private static Map buildCharacterMap(String s1, String s2) {
+ Map charMap = new HashMap<>();
+ for (char c : s1.toCharArray()) {
+ charMap.putIfAbsent(c, 0);
+ }
+ for (char c : s2.toCharArray()) {
+ charMap.putIfAbsent(c, 0);
+ }
+ return charMap;
+ }
+
+ /**
+ * Initializes the dynamic programming table for the algorithm.
+ *
+ * The table has dimensions (n+2) x (m+2) where n and m are the lengths
+ * of the input strings. The extra rows and columns are used to handle
+ * the transposition operation correctly.
+ *
+ * The first row and column are initialized with the maximum possible distance,
+ * while the second row and column represent the base case of transforming
+ * from an empty string.
+ *
+ * @param n the length of the first string
+ * @param m the length of the second string
+ * @return an initialized DP table ready for computation
+ */
+ private static int[][] initializeTable(int n, int m) {
+ int maxDist = n + m;
+ int[][] dp = new int[n + 2][m + 2];
+
+ dp[0][0] = maxDist;
+
+ for (int i = 0; i <= n; i++) {
+ dp[i + 1][0] = maxDist;
+ dp[i + 1][1] = i;
+ }
+
+ for (int j = 0; j <= m; j++) {
+ dp[0][j + 1] = maxDist;
+ dp[1][j + 1] = j;
+ }
+
+ return dp;
+ }
+
+ /**
+ * Fills the dynamic programming table by computing the minimum edit distance
+ * for each substring pair.
+ *
+ * This method implements the core algorithm logic, iterating through both strings
+ * and computing the minimum cost of transforming substrings. It considers all
+ * four operations: insertion, deletion, substitution, and transposition.
+ *
+ * The character position map is updated as we progress through the first string
+ * to enable efficient transposition cost calculation.
+ *
+ * @param s1 the first string
+ * @param s2 the second string
+ * @param dp the dynamic programming table to fill
+ * @param charLastPosition map tracking the last position of each character in s1
+ */
+ private static void fillTable(String s1, String s2, int[][] dp, Map charLastPosition) {
+ int n = s1.length();
+ int m = s2.length();
+
+ for (int i = 1; i <= n; i++) {
+ int lastMatchCol = 0;
+
+ for (int j = 1; j <= m; j++) {
+ char char1 = s1.charAt(i - 1);
+ char char2 = s2.charAt(j - 1);
+
+ int lastMatchRow = charLastPosition.get(char2);
+ int cost = (char1 == char2) ? 0 : 1;
+
+ if (char1 == char2) {
+ lastMatchCol = j;
+ }
+
+ dp[i + 1][j + 1] = computeMinimumCost(dp, i, j, lastMatchRow, lastMatchCol, cost);
+ }
+
+ charLastPosition.put(s1.charAt(i - 1), i);
+ }
+ }
+
+ /**
+ * Computes the minimum cost among all possible operations at the current position.
+ *
+ * This method evaluates four possible operations:
+ * 1. Substitution: replace character at position i with character at position j
+ * 2. Insertion: insert character from s2 at position j
+ * 3. Deletion: delete character from s1 at position i
+ * 4. Transposition: swap characters that have been seen before
+ *
+ * The transposition cost accounts for the gap between the current position
+ * and the last position where matching characters were found.
+ *
+ * @param dp the dynamic programming table
+ * @param i the current position in the first string (1-indexed in the DP table)
+ * @param j the current position in the second string (1-indexed in the DP table)
+ * @param lastMatchRow the row index where the current character of s2 last appeared in s1
+ * @param lastMatchCol the column index where the current character of s1 last matched in s2
+ * @param cost the substitution cost (0 if characters match, 1 otherwise)
+ * @return the minimum cost among all operations
+ */
+ private static int computeMinimumCost(int[][] dp, int i, int j, int lastMatchRow, int lastMatchCol, int cost) {
+ int substitution = dp[i][j] + cost;
+ int insertion = dp[i + 1][j] + 1;
+ int deletion = dp[i][j + 1] + 1;
+ int transposition = dp[lastMatchRow][lastMatchCol] + i - lastMatchRow - 1 + 1 + j - lastMatchCol - 1;
+
+ return Math.min(Math.min(substitution, insertion), Math.min(deletion, transposition));
+ }
+}
diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/Knapsack.java b/src/main/java/com/thealgorithms/dynamicprogramming/Knapsack.java
index 134561766830..0d4c8d501f9f 100644
--- a/src/main/java/com/thealgorithms/dynamicprogramming/Knapsack.java
+++ b/src/main/java/com/thealgorithms/dynamicprogramming/Knapsack.java
@@ -3,53 +3,76 @@
import java.util.Arrays;
/**
- * A Dynamic Programming based solution for the 0-1 Knapsack problem.
- * This class provides a method, `knapSack`, that calculates the maximum value that can be
- * obtained from a given set of items with weights and values, while not exceeding a
- * given weight capacity.
+ * 0/1 Knapsack Problem - Dynamic Programming solution.
*
- * @see 0-1 Knapsack Problem
+ * This algorithm solves the classic optimization problem where we have n items,
+ * each with a weight and a value. The goal is to maximize the total value
+ * without exceeding the knapsack's weight capacity.
+ *
+ * Time Complexity: O(n * W)
+ * Space Complexity: O(W)
+ *
+ * Example:
+ * values = {60, 100, 120}
+ * weights = {10, 20, 30}
+ * W = 50
+ * Output: 220
+ *
+ * @author Arpita
+ * @see Knapsack Problem
*/
public final class Knapsack {
private Knapsack() {
}
+ /**
+ * Validates the input to ensure correct constraints.
+ */
private static void throwIfInvalidInput(final int weightCapacity, final int[] weights, final int[] values) {
if (weightCapacity < 0) {
throw new IllegalArgumentException("Weight capacity should not be negative.");
}
if (weights == null || values == null || weights.length != values.length) {
- throw new IllegalArgumentException("Input arrays must not be null and must have the same length.");
+ throw new IllegalArgumentException("Weights and values must be non-null and of the same length.");
}
if (Arrays.stream(weights).anyMatch(w -> w <= 0)) {
- throw new IllegalArgumentException("Input array should not contain non-positive weight(s).");
+ throw new IllegalArgumentException("Weights must be positive.");
}
}
/**
- * Solves the 0-1 Knapsack problem using Dynamic Programming.
+ * Solves the 0/1 Knapsack problem using Dynamic Programming (bottom-up approach).
*
* @param weightCapacity The maximum weight capacity of the knapsack.
- * @param weights An array of item weights.
- * @param values An array of item values.
- * @return The maximum value that can be obtained without exceeding the weight capacity.
- * @throws IllegalArgumentException If the input arrays are null or have different lengths.
+ * @param weights The array of item weights.
+ * @param values The array of item values.
+ * @return The maximum total value achievable without exceeding capacity.
*/
- public static int knapSack(final int weightCapacity, final int[] weights, final int[] values) throws IllegalArgumentException {
+ public static int knapSack(final int weightCapacity, final int[] weights, final int[] values) {
throwIfInvalidInput(weightCapacity, weights, values);
- // DP table to store the state of the maximum possible return for a given weight capacity.
int[] dp = new int[weightCapacity + 1];
+ // Fill dp[] array iteratively
for (int i = 0; i < values.length; i++) {
- for (int w = weightCapacity; w > 0; w--) {
- if (weights[i] <= w) {
- dp[w] = Math.max(dp[w], dp[w - weights[i]] + values[i]);
- }
+ for (int w = weightCapacity; w >= weights[i]; w--) {
+ dp[w] = Math.max(dp[w], dp[w - weights[i]] + values[i]);
}
}
return dp[weightCapacity];
}
+
+ /*
+ // Example main method for local testing only.
+ public static void main(String[] args) {
+ int[] values = {60, 100, 120};
+ int[] weights = {10, 20, 30};
+ int weightCapacity = 50;
+
+ int maxValue = knapSack(weightCapacity, weights, values);
+ System.out.println("Maximum value = " + maxValue); // Output: 220
+ }
+ */
}
diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/MaximumProductSubarray.java b/src/main/java/com/thealgorithms/dynamicprogramming/MaximumProductSubarray.java
new file mode 100644
index 000000000000..1c16f612e98f
--- /dev/null
+++ b/src/main/java/com/thealgorithms/dynamicprogramming/MaximumProductSubarray.java
@@ -0,0 +1,58 @@
+package com.thealgorithms.dynamicprogramming;
+
+/**
+ * The MaximumProductSubarray class implements the algorithm to find the
+ * maximum product of a contiguous subarray within a given array of integers.
+ *
+ * Given an array of integers (which may contain positive numbers, negative
+ * numbers, and zeros), this algorithm finds the contiguous subarray that has
+ * the largest product. The algorithm handles negative numbers efficiently by
+ * tracking both maximum and minimum products, since a negative number can turn
+ * a minimum product into a maximum product.
+ *
+ * This implementation uses a dynamic programming approach that runs in O(n)
+ * time complexity and O(1) space complexity, making it highly efficient for
+ * large arrays.
+ */
+public final class MaximumProductSubarray {
+
+ private MaximumProductSubarray() {
+ // Prevent instantiation
+ }
+
+ /**
+ * Finds the maximum product of any contiguous subarray in the given array.
+ *
+ * @param nums an array of integers which may contain positive, negative,
+ * and zero values.
+ * @return the maximum product of a contiguous subarray. Returns 0 if the
+ * array is null or empty.
+ */
+ public static int maxProduct(int[] nums) {
+ if (nums == null || nums.length == 0) {
+ return 0;
+ }
+
+ long maxProduct = nums[0];
+ long currentMax = nums[0];
+ long currentMin = nums[0];
+
+ for (int i = 1; i < nums.length; i++) {
+ // Swap currentMax and currentMin if current number is negative
+ if (nums[i] < 0) {
+ long temp = currentMax;
+ currentMax = currentMin;
+ currentMin = temp;
+ }
+
+ // Update currentMax and currentMin
+ currentMax = Math.max(nums[i], currentMax * nums[i]);
+ currentMin = Math.min(nums[i], currentMin * nums[i]);
+
+ // Update global max product
+ maxProduct = Math.max(maxProduct, currentMax);
+ }
+
+ return (int) maxProduct;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/NeedlemanWunsch.java b/src/main/java/com/thealgorithms/dynamicprogramming/NeedlemanWunsch.java
new file mode 100644
index 000000000000..13b640cf0d04
--- /dev/null
+++ b/src/main/java/com/thealgorithms/dynamicprogramming/NeedlemanWunsch.java
@@ -0,0 +1,60 @@
+package com.thealgorithms.dynamicprogramming;
+
+/**
+ * The Needleman–Wunsch algorithm performs global sequence alignment between two strings.
+ * It computes the optimal alignment score using dynamic programming,
+ * given a scoring scheme for matches, mismatches, and gaps.
+ *
+ * Time Complexity: O(n * m)
+ * Space Complexity: O(n * m)
+ */
+public final class NeedlemanWunsch {
+
+ private NeedlemanWunsch() {
+ // Utility Class
+ }
+
+ /**
+ * Computes the Needleman–Wunsch global alignment score between two strings.
+ *
+ * @param s1 the first string
+ * @param s2 the second string
+ * @param matchScore score for a character match
+ * @param mismatchPenalty penalty for a mismatch (should be negative)
+ * @param gapPenalty penalty for inserting a gap (should be negative)
+ * @return the optimal alignment score
+ */
+ public static int align(String s1, String s2, int matchScore, int mismatchPenalty, int gapPenalty) {
+ if (s1 == null || s2 == null) {
+ throw new IllegalArgumentException("Input strings must not be null.");
+ }
+
+ int n = s1.length();
+ int m = s2.length();
+
+ int[][] dp = new int[n + 1][m + 1];
+
+ // Initialize gap penalties for first row and column
+ for (int i = 0; i <= n; i++) {
+ dp[i][0] = i * gapPenalty;
+ }
+ for (int j = 0; j <= m; j++) {
+ dp[0][j] = j * gapPenalty;
+ }
+
+ // Fill the DP matrix
+ for (int i = 1; i <= n; i++) {
+ for (int j = 1; j <= m; j++) {
+ int matchOrMismatch = (s1.charAt(i - 1) == s2.charAt(j - 1)) ? matchScore : mismatchPenalty;
+
+ dp[i][j] = Math.max(Math.max(dp[i - 1][j - 1] + matchOrMismatch, // match/mismatch
+ dp[i - 1][j] + gapPenalty // deletion (gap in s2)
+ ),
+ dp[i][j - 1] + gapPenalty // insertion (gap in s1)
+ );
+ }
+ }
+
+ return dp[n][m];
+ }
+}
diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/PartitionProblem.java b/src/main/java/com/thealgorithms/dynamicprogramming/PartitionProblem.java
index 49c4a0a3a008..8c72fa347f50 100644
--- a/src/main/java/com/thealgorithms/dynamicprogramming/PartitionProblem.java
+++ b/src/main/java/com/thealgorithms/dynamicprogramming/PartitionProblem.java
@@ -1,3 +1,5 @@
+package com.thealgorithms.dynamicprogramming;
+import java.util.Arrays;
/**
* @author Md Asif Joardar
*
@@ -13,11 +15,6 @@
*
* The time complexity of the solution is O(n × sum) and requires O(n × sum) space
*/
-
-package com.thealgorithms.dynamicprogramming;
-
-import java.util.Arrays;
-
public final class PartitionProblem {
private PartitionProblem() {
}
diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/SmithWaterman.java b/src/main/java/com/thealgorithms/dynamicprogramming/SmithWaterman.java
new file mode 100644
index 000000000000..c0d66f68b502
--- /dev/null
+++ b/src/main/java/com/thealgorithms/dynamicprogramming/SmithWaterman.java
@@ -0,0 +1,56 @@
+package com.thealgorithms.dynamicprogramming;
+
+/**
+ * Smith–Waterman algorithm for local sequence alignment.
+ * Finds the highest scoring local alignment between substrings of two sequences.
+ *
+ * Time Complexity: O(n * m)
+ * Space Complexity: O(n * m)
+ */
+public final class SmithWaterman {
+
+ private SmithWaterman() {
+ // Utility Class
+ }
+
+ /**
+ * Computes the Smith–Waterman local alignment score between two strings.
+ *
+ * @param s1 first string
+ * @param s2 second string
+ * @param matchScore score for a match
+ * @param mismatchPenalty penalty for mismatch (negative)
+ * @param gapPenalty penalty for insertion/deletion (negative)
+ * @return the maximum local alignment score
+ */
+ public static int align(String s1, String s2, int matchScore, int mismatchPenalty, int gapPenalty) {
+ if (s1 == null || s2 == null) {
+ throw new IllegalArgumentException("Input strings must not be null.");
+ }
+
+ int n = s1.length();
+ int m = s2.length();
+ int maxScore = 0;
+
+ int[][] dp = new int[n + 1][m + 1];
+
+ for (int i = 1; i <= n; i++) {
+ for (int j = 1; j <= m; j++) {
+ int matchOrMismatch = (s1.charAt(i - 1) == s2.charAt(j - 1)) ? matchScore : mismatchPenalty;
+
+ dp[i][j] = Math.max(0,
+ Math.max(Math.max(dp[i - 1][j - 1] + matchOrMismatch, // match/mismatch
+ dp[i - 1][j] + gapPenalty // deletion
+ ),
+ dp[i][j - 1] + gapPenalty // insertion
+ ));
+
+ if (dp[i][j] > maxScore) {
+ maxScore = dp[i][j];
+ }
+ }
+ }
+
+ return maxScore;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/geometry/BentleyOttmann.java b/src/main/java/com/thealgorithms/geometry/BentleyOttmann.java
new file mode 100644
index 000000000000..a11acb87dd7a
--- /dev/null
+++ b/src/main/java/com/thealgorithms/geometry/BentleyOttmann.java
@@ -0,0 +1,423 @@
+package com.thealgorithms.geometry;
+
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.NavigableSet;
+import java.util.Objects;
+import java.util.PriorityQueue;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+/**
+ * Implementation of the Bentley–Ottmann algorithm for finding all intersection
+ * points among a set of line segments in O((n + k) log n) time.
+ *
+ * Uses a sweep-line approach with an event queue and status structure to
+ * efficiently detect intersections in 2D plane geometry.
+ *
+ * @see
+ * Bentley–Ottmann algorithm
+ */
+public final class BentleyOttmann {
+
+ private BentleyOttmann() {
+ }
+
+ private static final double EPS = 1e-9;
+ private static double currentSweepX;
+
+ /**
+ * Represents a line segment with two endpoints.
+ */
+ public static class Segment {
+ final Point2D.Double p1;
+ final Point2D.Double p2;
+ final int id; // Unique identifier for each segment
+
+ Segment(Point2D.Double p1, Point2D.Double p2) {
+ this.p1 = p1;
+ this.p2 = p2;
+ this.id = segmentCounter++;
+ }
+
+ private static int segmentCounter = 0;
+
+ /**
+ * Computes the y-coordinate of this segment at a given x value.
+ */
+ double getY(double x) {
+ if (Math.abs(p2.x - p1.x) < EPS) {
+ // Vertical segment: return midpoint y
+ return (p1.y + p2.y) / 2.0;
+ }
+ double t = (x - p1.x) / (p2.x - p1.x);
+ return p1.y + t * (p2.y - p1.y);
+ }
+
+ Point2D.Double leftPoint() {
+ return p1.x < p2.x ? p1 : p1.x > p2.x ? p2 : p1.y < p2.y ? p1 : p2;
+ }
+
+ Point2D.Double rightPoint() {
+ return p1.x > p2.x ? p1 : p1.x < p2.x ? p2 : p1.y > p2.y ? p1 : p2;
+ }
+
+ @Override
+ public String toString() {
+ return String.format("S%d[(%.2f, %.2f), (%.2f, %.2f)]", id, p1.x, p1.y, p2.x, p2.y);
+ }
+ }
+
+ /**
+ * Event types for the sweep line algorithm.
+ */
+ private enum EventType { START, END, INTERSECTION }
+
+ /**
+ * Represents an event in the event queue.
+ */
+ private static class Event implements Comparable {
+ final Point2D.Double point;
+ final EventType type;
+ final Set segments; // Segments involved in this event
+
+ Event(Point2D.Double point, EventType type) {
+ this.point = point;
+ this.type = type;
+ this.segments = new HashSet<>();
+ }
+
+ void addSegment(Segment s) {
+ segments.add(s);
+ }
+
+ @Override
+ public int compareTo(Event other) {
+ // Sort by x-coordinate, then by y-coordinate
+ int cmp = Double.compare(this.point.x, other.point.x);
+ if (cmp == 0) {
+ cmp = Double.compare(this.point.y, other.point.y);
+ }
+ if (cmp == 0) {
+ // Process END events before START events at same point
+ cmp = this.type.compareTo(other.type);
+ }
+ return cmp;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (!(o instanceof Event e)) {
+ return false;
+ }
+ return pointsEqual(this.point, e.point);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(Math.round(point.x * 1e6), Math.round(point.y * 1e6));
+ }
+ }
+
+ /**
+ * Comparator for segments in the status structure (sweep line).
+ * Orders segments by their y-coordinate at the current sweep line position.
+ */
+ private static final class StatusComparator implements Comparator {
+ @Override
+ public int compare(Segment s1, Segment s2) {
+ if (s1.id == s2.id) {
+ return 0;
+ }
+
+ double y1 = s1.getY(currentSweepX);
+ double y2 = s2.getY(currentSweepX);
+
+ int cmp = Double.compare(y1, y2);
+ if (Math.abs(y1 - y2) < EPS) {
+ // If y-coordinates are equal, use segment id for consistency
+ return Integer.compare(s1.id, s2.id);
+ }
+ return cmp;
+ }
+ }
+
+ /**
+ * Finds all intersection points among a set of line segments.
+ *
+ * An intersection point is reported when two or more segments cross or touch.
+ * For overlapping segments, only actual crossing/touching points are reported,
+ * not all points along the overlap.
+ *
+ * @param segments list of line segments represented as pairs of points
+ * @return a set of intersection points where segments meet or cross
+ * @throws IllegalArgumentException if the list is null or contains null points
+ */
+ public static Set findIntersections(List segments) {
+ if (segments == null) {
+ throw new IllegalArgumentException("Segment list must not be null");
+ }
+
+ Segment.segmentCounter = 0; // Reset counter
+ Set intersections = new HashSet<>();
+ PriorityQueue eventQueue = new PriorityQueue<>();
+ TreeSet status = new TreeSet<>(new StatusComparator());
+ Map eventMap = new HashMap<>();
+
+ // Initialize event queue with segment start and end points
+ for (Segment s : segments) {
+ Point2D.Double left = s.leftPoint();
+ Point2D.Double right = s.rightPoint();
+
+ Event startEvent = getOrCreateEvent(eventMap, left, EventType.START);
+ startEvent.addSegment(s);
+
+ Event endEvent = getOrCreateEvent(eventMap, right, EventType.END);
+ endEvent.addSegment(s);
+ }
+
+ // Add all unique events to the queue
+ for (Event e : eventMap.values()) {
+ if (!e.segments.isEmpty()) {
+ eventQueue.add(e);
+ }
+ }
+
+ // Process events
+ while (!eventQueue.isEmpty()) {
+ Event event = eventQueue.poll();
+ currentSweepX = event.point.x;
+
+ handleEvent(event, status, eventQueue, eventMap, intersections);
+ }
+
+ return intersections;
+ }
+
+ private static Event getOrCreateEvent(Map eventMap, Point2D.Double point, EventType type) {
+ // Find existing event at this point
+ for (Map.Entry entry : eventMap.entrySet()) {
+ if (pointsEqual(entry.getKey(), point)) {
+ return entry.getValue();
+ }
+ }
+ // Create new event
+ Event event = new Event(point, type);
+ eventMap.put(point, event);
+ return event;
+ }
+
+ private static void handleEvent(Event event, TreeSet status, PriorityQueue eventQueue, Map eventMap, Set intersections) {
+ Point2D.Double p = event.point;
+ Set segmentsAtPoint = new HashSet<>(event.segments);
+
+ // Check segments in status structure (much smaller than allSegments)
+ for (Segment s : status) {
+ if (pointsEqual(s.p1, p) || pointsEqual(s.p2, p) || (onSegment(s, p) && !pointsEqual(s.p1, p) && !pointsEqual(s.p2, p))) {
+ segmentsAtPoint.add(s);
+ }
+ }
+
+ // If 2 or more segments meet at this point, it's an intersection
+ if (segmentsAtPoint.size() >= 2) {
+ intersections.add(p);
+ }
+
+ // Categorize segments
+ Set upperSegs = new HashSet<>(); // Segments starting at p
+ Set lowerSegs = new HashSet<>(); // Segments ending at p
+ Set containingSegs = new HashSet<>(); // Segments containing p in interior
+
+ for (Segment s : segmentsAtPoint) {
+ if (pointsEqual(s.leftPoint(), p)) {
+ upperSegs.add(s);
+ } else if (pointsEqual(s.rightPoint(), p)) {
+ lowerSegs.add(s);
+ } else {
+ containingSegs.add(s);
+ }
+ }
+
+ // Remove ending segments and segments containing p from status
+ status.removeAll(lowerSegs);
+ status.removeAll(containingSegs);
+
+ // Update sweep line position slightly past the event
+ currentSweepX = p.x + EPS;
+
+ // Add starting segments and re-add containing segments
+ status.addAll(upperSegs);
+ status.addAll(containingSegs);
+
+ if (upperSegs.isEmpty() && containingSegs.isEmpty()) {
+ // Find neighbors and check for new intersections
+ Segment sl = getNeighbor(status, lowerSegs, true);
+ Segment sr = getNeighbor(status, lowerSegs, false);
+ if (sl != null && sr != null) {
+ findNewEvent(sl, sr, p, eventQueue, eventMap);
+ }
+ } else {
+ Set unionSegs = new HashSet<>(upperSegs);
+ unionSegs.addAll(containingSegs);
+
+ Segment leftmost = getLeftmost(unionSegs, status);
+ Segment rightmost = getRightmost(unionSegs, status);
+
+ if (leftmost != null) {
+ Segment sl = status.lower(leftmost);
+ if (sl != null) {
+ findNewEvent(sl, leftmost, p, eventQueue, eventMap);
+ }
+ }
+
+ if (rightmost != null) {
+ Segment sr = status.higher(rightmost);
+ if (sr != null) {
+ findNewEvent(rightmost, sr, p, eventQueue, eventMap);
+ }
+ }
+ }
+ }
+
+ private static Segment getNeighbor(NavigableSet status, Set removed, boolean lower) {
+ if (removed.isEmpty()) {
+ return null;
+ }
+ Segment ref = removed.iterator().next();
+ return lower ? status.lower(ref) : status.higher(ref);
+ }
+
+ private static Segment getLeftmost(Set segments, SortedSet status) {
+ Segment leftmost = null;
+ for (Segment s : segments) {
+ if (leftmost == null || Objects.requireNonNull(status.comparator()).compare(s, leftmost) < 0) {
+ leftmost = s;
+ }
+ }
+ return leftmost;
+ }
+
+ private static Segment getRightmost(Set segments, SortedSet status) {
+ Segment rightmost = null;
+ for (Segment s : segments) {
+ if (status.comparator() != null && (rightmost == null || status.comparator().compare(s, rightmost) > 0)) {
+ rightmost = s;
+ }
+ }
+ return rightmost;
+ }
+
+ private static void findNewEvent(Segment s1, Segment s2, Point2D.Double currentPoint, PriorityQueue eventQueue, Map eventMap) {
+ Point2D.Double intersection = getIntersection(s1, s2);
+
+ if (intersection != null && intersection.x > currentPoint.x - EPS && !pointsEqual(intersection, currentPoint)) {
+
+ // Check if event already exists
+ boolean exists = false;
+ for (Map.Entry entry : eventMap.entrySet()) {
+ if (pointsEqual(entry.getKey(), intersection)) {
+ exists = true;
+ Event existingEvent = entry.getValue();
+ existingEvent.addSegment(s1);
+ existingEvent.addSegment(s2);
+ break;
+ }
+ }
+
+ if (!exists) {
+ Event newEvent = new Event(intersection, EventType.INTERSECTION);
+ newEvent.addSegment(s1);
+ newEvent.addSegment(s2);
+ eventMap.put(intersection, newEvent);
+ eventQueue.add(newEvent);
+ }
+ }
+ }
+
+ private static Point2D.Double getIntersection(Segment s1, Segment s2) {
+ double x1 = s1.p1.x;
+ double y1 = s1.p1.y;
+ double x2 = s1.p2.x;
+ double y2 = s1.p2.y;
+ double x3 = s2.p1.x;
+ double y3 = s2.p1.y;
+ double x4 = s2.p2.x;
+ double y4 = s2.p2.y;
+
+ double denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
+
+ if (Math.abs(denom) < EPS) {
+ // Parallel or collinear
+ if (areCollinear(s1, s2)) {
+ // For collinear segments, check if they overlap
+ // Return any overlapping point
+ List overlapPoints = new ArrayList<>();
+
+ if (onSegment(s1, s2.p1)) {
+ overlapPoints.add(s2.p1);
+ }
+ if (onSegment(s1, s2.p2)) {
+ overlapPoints.add(s2.p2);
+ }
+ if (onSegment(s2, s1.p1)) {
+ overlapPoints.add(s1.p1);
+ }
+ if (onSegment(s2, s1.p2)) {
+ overlapPoints.add(s1.p2);
+ }
+
+ // Remove duplicates and return the first point
+ if (!overlapPoints.isEmpty()) {
+ // Find the point that's not an endpoint of both segments
+ for (Point2D.Double pt : overlapPoints) {
+ boolean isS1Endpoint = pointsEqual(pt, s1.p1) || pointsEqual(pt, s1.p2);
+ boolean isS2Endpoint = pointsEqual(pt, s2.p1) || pointsEqual(pt, s2.p2);
+
+ // If it's an endpoint of both, it's a touching point
+ if (isS1Endpoint && isS2Endpoint) {
+ return pt;
+ }
+ }
+ // Return the first overlap point
+ return overlapPoints.getFirst();
+ }
+ }
+ return null;
+ }
+
+ double t = ((x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4)) / denom;
+ double u = -((x1 - x2) * (y1 - y3) - (y1 - y2) * (x1 - x3)) / denom;
+
+ if (t >= -EPS && t <= 1 + EPS && u >= -EPS && u <= 1 + EPS) {
+ double px = x1 + t * (x2 - x1);
+ double py = y1 + t * (y2 - y1);
+ return new Point2D.Double(px, py);
+ }
+
+ return null;
+ }
+
+ private static boolean areCollinear(Segment s1, Segment s2) {
+ double cross1 = crossProduct(s1.p1, s1.p2, s2.p1);
+ double cross2 = crossProduct(s1.p1, s1.p2, s2.p2);
+ return Math.abs(cross1) < EPS && Math.abs(cross2) < EPS;
+ }
+
+ private static double crossProduct(Point2D.Double a, Point2D.Double b, Point2D.Double c) {
+ return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+ }
+
+ private static boolean onSegment(Segment s, Point2D.Double p) {
+ return p.x >= Math.min(s.p1.x, s.p2.x) - EPS && p.x <= Math.max(s.p1.x, s.p2.x) + EPS && p.y >= Math.min(s.p1.y, s.p2.y) - EPS && p.y <= Math.max(s.p1.y, s.p2.y) + EPS && Math.abs(crossProduct(s.p1, s.p2, p)) < EPS;
+ }
+
+ private static boolean pointsEqual(Point2D.Double p1, Point2D.Double p2) {
+ return Math.abs(p1.x - p2.x) < EPS && Math.abs(p1.y - p2.y) < EPS;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/geometry/ConvexHull.java b/src/main/java/com/thealgorithms/geometry/ConvexHull.java
index 17f400854c64..d44d20c68807 100644
--- a/src/main/java/com/thealgorithms/geometry/ConvexHull.java
+++ b/src/main/java/com/thealgorithms/geometry/ConvexHull.java
@@ -61,11 +61,24 @@ public static List convexHullBruteForce(List points) {
return new ArrayList<>(convexSet);
}
+ /**
+ * Computes the convex hull using a recursive divide-and-conquer approach.
+ * Returns points in counter-clockwise order starting from the bottom-most, left-most point.
+ *
+ * @param points the input points
+ * @return the convex hull points in counter-clockwise order
+ */
public static List convexHullRecursive(List points) {
+ if (points.size() < 3) {
+ List result = new ArrayList<>(points);
+ Collections.sort(result);
+ return result;
+ }
+
Collections.sort(points);
Set convexSet = new HashSet<>();
- Point leftMostPoint = points.get(0);
- Point rightMostPoint = points.get(points.size() - 1);
+ Point leftMostPoint = points.getFirst();
+ Point rightMostPoint = points.getLast();
convexSet.add(leftMostPoint);
convexSet.add(rightMostPoint);
@@ -85,9 +98,8 @@ public static List convexHullRecursive(List points) {
constructHull(upperHull, leftMostPoint, rightMostPoint, convexSet);
constructHull(lowerHull, rightMostPoint, leftMostPoint, convexSet);
- List result = new ArrayList<>(convexSet);
- Collections.sort(result);
- return result;
+ // Convert to list and sort in counter-clockwise order
+ return sortCounterClockwise(new ArrayList<>(convexSet));
}
private static void constructHull(Collection points, Point left, Point right, Set convexSet) {
@@ -114,4 +126,82 @@ private static void constructHull(Collection points, Point left, Point ri
}
}
}
+
+ /**
+ * Sorts convex hull points in counter-clockwise order starting from
+ * the bottom-most, left-most point.
+ *
+ * @param hullPoints the unsorted convex hull points
+ * @return the points sorted in counter-clockwise order
+ */
+ private static List sortCounterClockwise(List hullPoints) {
+ if (hullPoints.size() <= 2) {
+ Collections.sort(hullPoints);
+ return hullPoints;
+ }
+
+ // Find the bottom-most, left-most point (pivot)
+ Point pivot = hullPoints.getFirst();
+ for (Point p : hullPoints) {
+ if (p.y() < pivot.y() || (p.y() == pivot.y() && p.x() < pivot.x())) {
+ pivot = p;
+ }
+ }
+
+ // Sort other points by polar angle with respect to pivot
+ final Point finalPivot = pivot;
+ List sorted = new ArrayList<>(hullPoints);
+ sorted.remove(finalPivot);
+
+ sorted.sort((p1, p2) -> {
+ int crossProduct = Point.orientation(finalPivot, p1, p2);
+
+ if (crossProduct == 0) {
+ // Collinear points: sort by distance from pivot (closer first for convex hull)
+ long dist1 = distanceSquared(finalPivot, p1);
+ long dist2 = distanceSquared(finalPivot, p2);
+ return Long.compare(dist1, dist2);
+ }
+
+ // Positive cross product means p2 is counter-clockwise from p1
+ // We want counter-clockwise order, so if p2 is CCW from p1, p1 should come first
+ return -crossProduct;
+ });
+
+ // Build result with pivot first, filtering out intermediate collinear points
+ List result = new ArrayList<>();
+ result.add(finalPivot);
+
+ if (!sorted.isEmpty()) {
+ // This loop iterates through the points sorted by angle.
+ // For points that are collinear with the pivot, we only want the one that is farthest away.
+ // The sort places closer points first.
+ for (int i = 0; i < sorted.size() - 1; i++) {
+ // Check the orientation of the pivot, the current point, and the next point.
+ int orientation = Point.orientation(finalPivot, sorted.get(i), sorted.get(i + 1));
+
+ // If the orientation is not 0, it means the next point (i+1) is at a new angle.
+ // Therefore, the current point (i) must be the farthest point at its angle. We keep it.
+ if (orientation != 0) {
+ result.add(sorted.get(i));
+ }
+ // If the orientation is 0, the points are collinear. We discard the current point (i)
+ // because it is closer to the pivot than the next point (i+1).
+ }
+ // Always add the very last point from the sorted list. It is either the only point
+ // at its angle, or it's the farthest among a set of collinear points.
+ result.add(sorted.getLast());
+ }
+
+ return result;
+ }
+
+ /**
+ * Computes the squared distance between two points to avoid floating point operations.
+ */
+ private static long distanceSquared(Point p1, Point p2) {
+ long dx = (long) p1.x() - p2.x();
+ long dy = (long) p1.y() - p2.y();
+ return dx * dx + dy * dy;
+ }
}
diff --git a/src/main/java/com/thealgorithms/geometry/DDALine.java b/src/main/java/com/thealgorithms/geometry/DDALine.java
new file mode 100644
index 000000000000..cb24951f398a
--- /dev/null
+++ b/src/main/java/com/thealgorithms/geometry/DDALine.java
@@ -0,0 +1,54 @@
+package com.thealgorithms.geometry;
+
+import java.awt.Point;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The {@code DDALine} class implements the Digital Differential Analyzer (DDA)
+ * line drawing algorithm. It computes points along a line between two given
+ * endpoints using floating-point arithmetic.
+ *
+ * The algorithm is straightforward but less efficient compared to
+ * Bresenham’s line algorithm, since it relies on floating-point operations.
+ *
+ * For more information, please visit {@link https://en.wikipedia.org/wiki/Digital_differential_analyzer_(graphics_algorithm)}
+ */
+public final class DDALine {
+
+ private DDALine() {
+ // Prevent instantiation
+ }
+
+ /**
+ * Finds the list of points forming a line between two endpoints using DDA.
+ *
+ * @param x0 the x-coordinate of the starting point
+ * @param y0 the y-coordinate of the starting point
+ * @param x1 the x-coordinate of the ending point
+ * @param y1 the y-coordinate of the ending point
+ * @return an unmodifiable {@code List} containing all points on the line
+ */
+ public static List findLine(int x0, int y0, int x1, int y1) {
+ int dx = x1 - x0;
+ int dy = y1 - y0;
+
+ int steps = Math.max(Math.abs(dx), Math.abs(dy)); // number of steps
+
+ double xIncrement = dx / (double) steps;
+ double yIncrement = dy / (double) steps;
+
+ double x = x0;
+ double y = y0;
+
+ List line = new ArrayList<>(steps + 1);
+
+ for (int i = 0; i <= steps; i++) {
+ line.add(new Point((int) Math.round(x), (int) Math.round(y)));
+ x += xIncrement;
+ y += yIncrement;
+ }
+
+ return line;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/geometry/Haversine.java b/src/main/java/com/thealgorithms/geometry/Haversine.java
new file mode 100644
index 000000000000..fa1799e9f076
--- /dev/null
+++ b/src/main/java/com/thealgorithms/geometry/Haversine.java
@@ -0,0 +1,49 @@
+package com.thealgorithms.geometry;
+/**
+ * This Class implements the Haversine formula to calculate the distance between two points on a sphere (like Earth) from their latitudes and longitudes.
+ *
+ * The Haversine formula is used in navigation and mapping to find the great-circle distance,
+ * which is the shortest distance between two points along the surface of a sphere. It is often
+ * used to calculate the "as the crow flies" distance between two geographical locations.
+ *
+ * The formula is reliable for all distances, including small ones, and avoids issues with
+ * numerical instability that can affect other methods.
+ *
+ * @see "https://en.wikipedia.org/wiki/Haversine_formula" - Wikipedia
+ */
+public final class Haversine {
+
+ // Average radius of Earth in kilometers
+ private static final double EARTH_RADIUS_KM = 6371.0;
+
+ /**
+ * Private constructor to prevent instantiation of this utility class.
+ */
+ private Haversine() {
+ }
+
+ /**
+ * Calculates the great-circle distance between two points on the earth
+ * (specified in decimal degrees).
+ *
+ * @param lat1 Latitude of the first point in decimal degrees.
+ * @param lon1 Longitude of the first point in decimal degrees.
+ * @param lat2 Latitude of the second point in decimal degrees.
+ * @param lon2 Longitude of the second point in decimal degrees.
+ * @return The distance between the two points in kilometers.
+ */
+ public static double haversine(double lat1, double lon1, double lat2, double lon2) {
+ // Convert latitude and longitude from degrees to radians
+ double dLat = Math.toRadians(lat2 - lat1);
+ double dLon = Math.toRadians(lon2 - lon1);
+
+ double lat1Rad = Math.toRadians(lat1);
+ double lat2Rad = Math.toRadians(lat2);
+
+ // Apply the Haversine formula
+ double a = Math.pow(Math.sin(dLat / 2), 2) + Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1Rad) * Math.cos(lat2Rad);
+ double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+ return EARTH_RADIUS_KM * c;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/geometry/WusLine.java b/src/main/java/com/thealgorithms/geometry/WusLine.java
new file mode 100644
index 000000000000..3539daaf6e5a
--- /dev/null
+++ b/src/main/java/com/thealgorithms/geometry/WusLine.java
@@ -0,0 +1,235 @@
+package com.thealgorithms.geometry;
+
+import java.awt.Point;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The {@code WusLine} class implements Xiaolin Wu's line drawing algorithm,
+ * which produces anti-aliased lines by varying pixel brightness
+ * according to the line's proximity to pixel centers.
+ *
+ * This implementation returns the pixel coordinates along with
+ * their associated intensity values (in range [0.0, 1.0]), allowing
+ * rendering systems to blend accordingly.
+ *
+ * The algorithm works by:
+ * - Computing a line's intersection with pixel boundaries
+ * - Assigning intensity values based on distance from pixel centers
+ * - Drawing pairs of pixels perpendicular to the line's direction
+ *
+ * Reference: Xiaolin Wu, "An Efficient Antialiasing Technique",
+ * Computer Graphics (SIGGRAPH '91 Proceedings).
+ *
+ */
+public final class WusLine {
+
+ private WusLine() {
+ // Utility class; prevent instantiation.
+ }
+
+ /**
+ * Represents a pixel and its intensity for anti-aliased rendering.
+ *
+ * The intensity value determines how bright the pixel should be drawn,
+ * with 1.0 being fully opaque and 0.0 being fully transparent.
+ */
+ public static class Pixel {
+ /** The pixel's coordinate on the screen. */
+ public final Point point;
+
+ /** The pixel's intensity value, clamped to the range [0.0, 1.0]. */
+ public final double intensity;
+
+ /**
+ * Constructs a new Pixel with the given coordinates and intensity.
+ *
+ * @param x the x-coordinate of the pixel
+ * @param y the y-coordinate of the pixel
+ * @param intensity the brightness/opacity of the pixel, will be clamped to [0.0, 1.0]
+ */
+ public Pixel(int x, int y, double intensity) {
+ this.point = new Point(x, y);
+ this.intensity = Math.clamp(intensity, 0.0, 1.0);
+ }
+ }
+
+ /**
+ * Internal class to hold processed endpoint data.
+ */
+ private static class EndpointData {
+ final int xPixel;
+ final int yPixel;
+ final double yEnd;
+ final double xGap;
+
+ EndpointData(int xPixel, int yPixel, double yEnd, double xGap) {
+ this.xPixel = xPixel;
+ this.yPixel = yPixel;
+ this.yEnd = yEnd;
+ this.xGap = xGap;
+ }
+ }
+
+ /**
+ * Draws an anti-aliased line using Wu's algorithm.
+ *
+ * The algorithm produces smooth lines by drawing pairs of pixels at each
+ * x-coordinate (or y-coordinate for steep lines), with intensities based on
+ * the line's distance from pixel centers.
+ *
+ * @param x0 the x-coordinate of the line's start point
+ * @param y0 the y-coordinate of the line's start point
+ * @param x1 the x-coordinate of the line's end point
+ * @param y1 the y-coordinate of the line's end point
+ * @return a list of {@link Pixel} objects representing the anti-aliased line,
+ * ordered from start to end
+ */
+ public static List drawLine(int x0, int y0, int x1, int y1) {
+ List pixels = new ArrayList<>();
+
+ // Determine if the line is steep (more vertical than horizontal)
+ boolean steep = Math.abs(y1 - y0) > Math.abs(x1 - x0);
+
+ if (steep) {
+ // For steep lines, swap x and y coordinates to iterate along y-axis
+ int temp = x0;
+ x0 = y0;
+ y0 = temp;
+
+ temp = x1;
+ x1 = y1;
+ y1 = temp;
+ }
+
+ if (x0 > x1) {
+ // Ensure we always draw from left to right
+ int temp = x0;
+ x0 = x1;
+ x1 = temp;
+
+ temp = y0;
+ y0 = y1;
+ y1 = temp;
+ }
+
+ // Calculate the line's slope
+ double deltaX = x1 - (double) x0;
+ double deltaY = y1 - (double) y0;
+ double gradient = (deltaX == 0) ? 1.0 : deltaY / deltaX;
+
+ // Process the first endpoint
+ EndpointData firstEndpoint = processEndpoint(x0, y0, gradient, true);
+ addEndpointPixels(pixels, firstEndpoint, steep);
+
+ // Process the second endpoint
+ EndpointData secondEndpoint = processEndpoint(x1, y1, gradient, false);
+ addEndpointPixels(pixels, secondEndpoint, steep);
+
+ // Draw the main line between endpoints
+ drawMainLine(pixels, firstEndpoint, secondEndpoint, gradient, steep);
+
+ return pixels;
+ }
+
+ /**
+ * Processes a line endpoint to determine its pixel coordinates and intensities.
+ *
+ * @param x the x-coordinate of the endpoint
+ * @param y the y-coordinate of the endpoint
+ * @param gradient the slope of the line
+ * @param isStart true if this is the start endpoint, false if it's the end
+ * @return an {@link EndpointData} object containing processed endpoint information
+ */
+ private static EndpointData processEndpoint(double x, double y, double gradient, boolean isStart) {
+ double xEnd = round(x);
+ double yEnd = y + gradient * (xEnd - x);
+ double xGap = isStart ? rfpart(x + 0.5) : fpart(x + 0.5);
+
+ int xPixel = (int) xEnd;
+ int yPixel = (int) Math.floor(yEnd);
+
+ return new EndpointData(xPixel, yPixel, yEnd, xGap);
+ }
+
+ /**
+ * Adds the two endpoint pixels (one above, one below the line) to the pixel list.
+ *
+ * @param pixels the list to add pixels to
+ * @param endpoint the endpoint data containing coordinates and gaps
+ * @param steep true if the line is steep (coordinates should be swapped)
+ */
+ private static void addEndpointPixels(List pixels, EndpointData endpoint, boolean steep) {
+ double fractionalY = fpart(endpoint.yEnd);
+ double complementFractionalY = rfpart(endpoint.yEnd);
+
+ if (steep) {
+ pixels.add(new Pixel(endpoint.yPixel, endpoint.xPixel, complementFractionalY * endpoint.xGap));
+ pixels.add(new Pixel(endpoint.yPixel + 1, endpoint.xPixel, fractionalY * endpoint.xGap));
+ } else {
+ pixels.add(new Pixel(endpoint.xPixel, endpoint.yPixel, complementFractionalY * endpoint.xGap));
+ pixels.add(new Pixel(endpoint.xPixel, endpoint.yPixel + 1, fractionalY * endpoint.xGap));
+ }
+ }
+
+ /**
+ * Draws the main portion of the line between the two endpoints.
+ *
+ * @param pixels the list to add pixels to
+ * @param firstEndpoint the processed start endpoint
+ * @param secondEndpoint the processed end endpoint
+ * @param gradient the slope of the line
+ * @param steep true if the line is steep (coordinates should be swapped)
+ */
+ private static void drawMainLine(List pixels, EndpointData firstEndpoint, EndpointData secondEndpoint, double gradient, boolean steep) {
+ // Start y-intersection after the first endpoint
+ double intersectionY = firstEndpoint.yEnd + gradient;
+
+ // Iterate through x-coordinates between the endpoints
+ for (int x = firstEndpoint.xPixel + 1; x < secondEndpoint.xPixel; x++) {
+ int yFloor = (int) Math.floor(intersectionY);
+ double fractionalPart = fpart(intersectionY);
+ double complementFractionalPart = rfpart(intersectionY);
+
+ if (steep) {
+ pixels.add(new Pixel(yFloor, x, complementFractionalPart));
+ pixels.add(new Pixel(yFloor + 1, x, fractionalPart));
+ } else {
+ pixels.add(new Pixel(x, yFloor, complementFractionalPart));
+ pixels.add(new Pixel(x, yFloor + 1, fractionalPart));
+ }
+
+ intersectionY += gradient;
+ }
+ }
+
+ /**
+ * Returns the fractional part of a number.
+ *
+ * @param x the input number
+ * @return the fractional part (always in range [0.0, 1.0))
+ */
+ private static double fpart(double x) {
+ return x - Math.floor(x);
+ }
+
+ /**
+ * Returns the reverse fractional part of a number (1 - fractional part).
+ *
+ * @param x the input number
+ * @return 1.0 minus the fractional part (always in range (0.0, 1.0])
+ */
+ private static double rfpart(double x) {
+ return 1.0 - fpart(x);
+ }
+
+ /**
+ * Rounds a number to the nearest integer.
+ *
+ * @param x the input number
+ * @return the nearest integer value as a double
+ */
+ private static double round(double x) {
+ return Math.floor(x + 0.5);
+ }
+}
diff --git a/src/main/java/com/thealgorithms/graph/BronKerbosch.java b/src/main/java/com/thealgorithms/graph/BronKerbosch.java
new file mode 100644
index 000000000000..0510d9bcf494
--- /dev/null
+++ b/src/main/java/com/thealgorithms/graph/BronKerbosch.java
@@ -0,0 +1,114 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Implementation of the Bron–Kerbosch algorithm with pivoting for enumerating all maximal cliques
+ * in an undirected graph.
+ *
+ * The input graph is represented as an adjacency list where {@code adjacency.get(u)} returns the
+ * set of vertices adjacent to {@code u}. The algorithm runs in time proportional to the number of
+ * maximal cliques produced and is widely used for clique enumeration problems.
+ *
+ * @author Wikipedia: Bron–Kerbosch algorithm
+ */
+public final class BronKerbosch {
+
+ private BronKerbosch() {
+ }
+
+ /**
+ * Finds all maximal cliques of the provided graph.
+ *
+ * @param adjacency adjacency list where {@code adjacency.size()} equals the number of vertices
+ * @return a list containing every maximal clique, each represented as a {@link Set} of vertices
+ * @throws IllegalArgumentException if the adjacency list is {@code null}, contains {@code null}
+ * entries, or references invalid vertices
+ */
+ public static List> findMaximalCliques(List> adjacency) {
+ if (adjacency == null) {
+ throw new IllegalArgumentException("Adjacency list must not be null");
+ }
+
+ int n = adjacency.size();
+ List> graph = new ArrayList<>(n);
+ for (int u = 0; u < n; u++) {
+ Set neighbors = adjacency.get(u);
+ if (neighbors == null) {
+ throw new IllegalArgumentException("Adjacency list must not contain null sets");
+ }
+ Set copy = new HashSet<>();
+ for (int v : neighbors) {
+ if (v < 0 || v >= n) {
+ throw new IllegalArgumentException("Neighbor index out of bounds: " + v);
+ }
+ if (v != u) {
+ copy.add(v);
+ }
+ }
+ graph.add(copy);
+ }
+
+ Set r = new HashSet<>();
+ Set p = new HashSet<>();
+ Set x = new HashSet<>();
+ for (int v = 0; v < n; v++) {
+ p.add(v);
+ }
+
+ List> cliques = new ArrayList<>();
+ bronKerboschPivot(r, p, x, graph, cliques);
+ return cliques;
+ }
+
+ private static void bronKerboschPivot(Set r, Set p, Set x, List> graph, List> cliques) {
+ if (p.isEmpty() && x.isEmpty()) {
+ cliques.add(new HashSet<>(r));
+ return;
+ }
+
+ int pivot = choosePivot(p, x, graph);
+ Set candidates = new HashSet<>(p);
+ if (pivot != -1) {
+ candidates.removeAll(graph.get(pivot));
+ }
+
+ for (Integer v : candidates) {
+ r.add(v);
+ Set newP = intersection(p, graph.get(v));
+ Set newX = intersection(x, graph.get(v));
+ bronKerboschPivot(r, newP, newX, graph, cliques);
+ r.remove(v);
+ p.remove(v);
+ x.add(v);
+ }
+ }
+
+ private static int choosePivot(Set p, Set x, List> graph) {
+ int pivot = -1;
+ int maxDegree = -1;
+ Set union = new HashSet<>(p);
+ union.addAll(x);
+ for (Integer v : union) {
+ int degree = graph.get(v).size();
+ if (degree > maxDegree) {
+ maxDegree = degree;
+ pivot = v;
+ }
+ }
+ return pivot;
+ }
+
+ private static Set intersection(Set base, Set neighbors) {
+ Set result = new HashSet<>();
+ for (Integer v : base) {
+ if (neighbors.contains(v)) {
+ result.add(v);
+ }
+ }
+ return result;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/graph/Dinic.java b/src/main/java/com/thealgorithms/graph/Dinic.java
new file mode 100644
index 000000000000..c45bd62ddfbb
--- /dev/null
+++ b/src/main/java/com/thealgorithms/graph/Dinic.java
@@ -0,0 +1,119 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Queue;
+
+/**
+ * Dinic's algorithm for computing maximum flow in a directed graph.
+ *
+ * Time complexity: O(E * V^2) in the worst case, but typically faster in practice
+ * and near O(E * sqrt(V)) for unit networks.
+ *
+ * The graph is represented using a capacity matrix where capacity[u][v] is the
+ * capacity of the directed edge u -> v. Capacities must be non-negative.
+ * The algorithm builds level graphs using BFS and finds blocking flows using DFS
+ * with current-edge optimization.
+ *
+ * This implementation mirrors the API and validation style of
+ * {@link EdmondsKarp#maxFlow(int[][], int, int)} for consistency.
+ *
+ * @see Wikipedia: Dinic's algorithm
+ */
+public final class Dinic {
+ private Dinic() {
+ }
+
+ /**
+ * Computes the maximum flow from source to sink using Dinic's algorithm.
+ *
+ * @param capacity square capacity matrix (n x n); entries must be >= 0
+ * @param source source vertex index in [0, n)
+ * @param sink sink vertex index in [0, n)
+ * @return the maximum flow value
+ * @throws IllegalArgumentException if the input matrix is null/non-square/has negatives or
+ * indices invalid
+ */
+ public static int maxFlow(int[][] capacity, int source, int sink) {
+ if (capacity == null || capacity.length == 0) {
+ throw new IllegalArgumentException("Capacity matrix must not be null or empty");
+ }
+ final int n = capacity.length;
+ for (int i = 0; i < n; i++) {
+ if (capacity[i] == null || capacity[i].length != n) {
+ throw new IllegalArgumentException("Capacity matrix must be square");
+ }
+ for (int j = 0; j < n; j++) {
+ if (capacity[i][j] < 0) {
+ throw new IllegalArgumentException("Capacities must be non-negative");
+ }
+ }
+ }
+ if (source < 0 || sink < 0 || source >= n || sink >= n) {
+ throw new IllegalArgumentException("Source and sink must be valid vertex indices");
+ }
+ if (source == sink) {
+ return 0;
+ }
+
+ // residual capacities
+ int[][] residual = new int[n][n];
+ for (int i = 0; i < n; i++) {
+ residual[i] = Arrays.copyOf(capacity[i], n);
+ }
+
+ int[] level = new int[n];
+ int flow = 0;
+ while (bfsBuildLevelGraph(residual, source, sink, level)) {
+ int[] next = new int[n]; // current-edge optimization
+ int pushed;
+ do {
+ pushed = dfsBlocking(residual, level, next, source, sink, Integer.MAX_VALUE);
+ flow += pushed;
+ } while (pushed > 0);
+ }
+ return flow;
+ }
+
+ private static boolean bfsBuildLevelGraph(int[][] residual, int source, int sink, int[] level) {
+ Arrays.fill(level, -1);
+ level[source] = 0;
+ Queue q = new ArrayDeque<>();
+ q.add(source);
+ while (!q.isEmpty()) {
+ int u = q.poll();
+ for (int v = 0; v < residual.length; v++) {
+ if (residual[u][v] > 0 && level[v] == -1) {
+ level[v] = level[u] + 1;
+ if (v == sink) {
+ return true;
+ }
+ q.add(v);
+ }
+ }
+ }
+ return level[sink] != -1;
+ }
+
+ private static int dfsBlocking(int[][] residual, int[] level, int[] next, int u, int sink, int f) {
+ if (u == sink) {
+ return f;
+ }
+ final int n = residual.length;
+ for (int v = next[u]; v < n; v++, next[u] = v) {
+ if (residual[u][v] <= 0) {
+ continue;
+ }
+ if (level[v] != level[u] + 1) {
+ continue;
+ }
+ int pushed = dfsBlocking(residual, level, next, v, sink, Math.min(f, residual[u][v]));
+ if (pushed > 0) {
+ residual[u][v] -= pushed;
+ residual[v][u] += pushed;
+ return pushed;
+ }
+ }
+ return 0;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/graph/Edmonds.java b/src/main/java/com/thealgorithms/graph/Edmonds.java
new file mode 100644
index 000000000000..4ddb8f9ff544
--- /dev/null
+++ b/src/main/java/com/thealgorithms/graph/Edmonds.java
@@ -0,0 +1,201 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * An implementation of Edmonds's algorithm (also known as the Chu–Liu/Edmonds algorithm)
+ * for finding a Minimum Spanning Arborescence (MSA).
+ *
+ * An MSA is a directed graph equivalent of a Minimum Spanning Tree. It is a tree rooted
+ * at a specific vertex 'r' that reaches all other vertices, such that the sum of the
+ * weights of its edges is minimized.
+ *
+ *
The algorithm works recursively:
+ *
+ * - For each vertex other than the root, select the incoming edge with the minimum weight.
+ * - If the selected edges form a spanning arborescence, it is the MSA.
+ * - If cycles are formed, contract each cycle into a new "supernode".
+ * - Modify the weights of edges entering the new supernode.
+ * - Recursively call the algorithm on the contracted graph.
+ * - The final cost is the sum of the initial edge selections and the result of the recursive call.
+ *
+ *
+ * Time Complexity: O(E * V) where E is the number of edges and V is the number of vertices.
+ *
+ *
References:
+ *
+ */
+public final class Edmonds {
+
+ private Edmonds() {
+ }
+
+ /**
+ * Represents a directed weighted edge in the graph.
+ */
+ public static class Edge {
+ final int from;
+ final int to;
+ final long weight;
+
+ /**
+ * Constructs a directed edge.
+ *
+ * @param from source vertex
+ * @param to destination vertex
+ * @param weight edge weight
+ */
+ public Edge(int from, int to, long weight) {
+ this.from = from;
+ this.to = to;
+ this.weight = weight;
+ }
+ }
+
+ /**
+ * Computes the total weight of the Minimum Spanning Arborescence of a directed,
+ * weighted graph from a given root.
+ *
+ * @param numVertices the number of vertices, labeled {@code 0..numVertices-1}
+ * @param edges list of directed edges in the graph
+ * @param root the root vertex
+ * @return the total weight of the MSA. Returns -1 if not all vertices are reachable
+ * from the root or if a valid arborescence cannot be formed.
+ * @throws IllegalArgumentException if {@code numVertices <= 0} or {@code root} is out of range.
+ */
+ public static long findMinimumSpanningArborescence(int numVertices, List edges, int root) {
+ if (root < 0 || root >= numVertices) {
+ throw new IllegalArgumentException("Invalid number of vertices or root");
+ }
+ if (numVertices == 1) {
+ return 0;
+ }
+
+ return findMSARecursive(numVertices, edges, root);
+ }
+
+ /**
+ * Recursive helper method for finding MSA.
+ */
+ private static long findMSARecursive(int n, List edges, int root) {
+ long[] minWeightEdge = new long[n];
+ int[] predecessor = new int[n];
+ Arrays.fill(minWeightEdge, Long.MAX_VALUE);
+ Arrays.fill(predecessor, -1);
+
+ for (Edge edge : edges) {
+ if (edge.to != root && edge.weight < minWeightEdge[edge.to]) {
+ minWeightEdge[edge.to] = edge.weight;
+ predecessor[edge.to] = edge.from;
+ }
+ }
+ // Check if all non-root nodes are reachable
+ for (int i = 0; i < n; i++) {
+ if (i != root && minWeightEdge[i] == Long.MAX_VALUE) {
+ return -1; // No spanning arborescence exists
+ }
+ }
+ int[] cycleId = new int[n];
+ Arrays.fill(cycleId, -1);
+ boolean[] visited = new boolean[n];
+ int cycleCount = 0;
+
+ for (int i = 0; i < n; i++) {
+ if (visited[i]) {
+ continue;
+ }
+
+ List path = new ArrayList<>();
+ int curr = i;
+
+ // Follow predecessor chain
+ while (curr != -1 && !visited[curr]) {
+ visited[curr] = true;
+ path.add(curr);
+ curr = predecessor[curr];
+ }
+
+ // If we hit a visited node, check if it forms a cycle
+ if (curr != -1) {
+ boolean inCycle = false;
+ for (int node : path) {
+ if (node == curr) {
+ inCycle = true;
+ }
+ if (inCycle) {
+ cycleId[node] = cycleCount;
+ }
+ }
+ if (inCycle) {
+ cycleCount++;
+ }
+ }
+ }
+ if (cycleCount == 0) {
+ long totalWeight = 0;
+ for (int i = 0; i < n; i++) {
+ if (i != root) {
+ totalWeight += minWeightEdge[i];
+ }
+ }
+ return totalWeight;
+ }
+ long cycleWeightSum = 0;
+ for (int i = 0; i < n; i++) {
+ if (cycleId[i] >= 0) {
+ cycleWeightSum += minWeightEdge[i];
+ }
+ }
+
+ // Map old nodes to new nodes (cycles become supernodes)
+ int[] newNodeMap = new int[n];
+ int[] cycleToNewNode = new int[cycleCount];
+ int newN = 0;
+
+ // Assign new node IDs to cycles first
+ for (int i = 0; i < cycleCount; i++) {
+ cycleToNewNode[i] = newN++;
+ }
+
+ // Assign new node IDs to non-cycle nodes
+ for (int i = 0; i < n; i++) {
+ if (cycleId[i] == -1) {
+ newNodeMap[i] = newN++;
+ } else {
+ newNodeMap[i] = cycleToNewNode[cycleId[i]];
+ }
+ }
+
+ int newRoot = newNodeMap[root];
+
+ // Build contracted graph
+ List newEdges = new ArrayList<>();
+ for (Edge edge : edges) {
+ int uCycleId = cycleId[edge.from];
+ int vCycleId = cycleId[edge.to];
+
+ // Skip edges internal to a cycle
+ if (uCycleId >= 0 && uCycleId == vCycleId) {
+ continue;
+ }
+
+ int newU = newNodeMap[edge.from];
+ int newV = newNodeMap[edge.to];
+
+ long newWeight = edge.weight;
+ // Adjust weight for edges entering a cycle
+ if (vCycleId >= 0) {
+ newWeight -= minWeightEdge[edge.to];
+ }
+
+ if (newU != newV) {
+ newEdges.add(new Edge(newU, newV, newWeight));
+ }
+ }
+ return cycleWeightSum + findMSARecursive(newN, newEdges, newRoot);
+ }
+}
diff --git a/src/main/java/com/thealgorithms/graph/EdmondsKarp.java b/src/main/java/com/thealgorithms/graph/EdmondsKarp.java
new file mode 100644
index 000000000000..59e7b09cb49c
--- /dev/null
+++ b/src/main/java/com/thealgorithms/graph/EdmondsKarp.java
@@ -0,0 +1,107 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Queue;
+
+/**
+ * Implementation of the Edmonds–Karp algorithm for computing the maximum flow of a directed graph.
+ *
+ * The algorithm runs in O(V * E^2) time and is a specific implementation of the Ford–Fulkerson
+ * method where the augmenting paths are found using breadth-first search (BFS) to ensure the
+ * shortest augmenting paths (in terms of the number of edges) are used.
+ *
+ *
+ * The graph is represented with a capacity matrix where {@code capacity[u][v]} denotes the
+ * capacity of the edge from {@code u} to {@code v}. Negative capacities are not allowed.
+ *
+ * @author Wikipedia: EdmondsKarp algorithm
+ */
+public final class EdmondsKarp {
+
+ private EdmondsKarp() {
+ }
+
+ /**
+ * Computes the maximum flow from {@code source} to {@code sink} in the provided capacity matrix.
+ *
+ * @param capacity the capacity matrix representing the directed graph; must be square and non-null
+ * @param source the source vertex index
+ * @param sink the sink vertex index
+ * @return the value of the maximum flow between {@code source} and {@code sink}
+ * @throws IllegalArgumentException if the matrix is {@code null}, not square, contains negative
+ * capacities, or if {@code source} / {@code sink} indices are invalid
+ */
+ public static int maxFlow(int[][] capacity, int source, int sink) {
+ if (capacity == null || capacity.length == 0) {
+ throw new IllegalArgumentException("Capacity matrix must not be null or empty");
+ }
+
+ final int n = capacity.length;
+ for (int row = 0; row < n; row++) {
+ if (capacity[row] == null || capacity[row].length != n) {
+ throw new IllegalArgumentException("Capacity matrix must be square");
+ }
+ for (int col = 0; col < n; col++) {
+ if (capacity[row][col] < 0) {
+ throw new IllegalArgumentException("Capacities must be non-negative");
+ }
+ }
+ }
+
+ if (source < 0 || source >= n || sink < 0 || sink >= n) {
+ throw new IllegalArgumentException("Source and sink must be valid vertex indices");
+ }
+ if (source == sink) {
+ return 0;
+ }
+
+ final int[][] residual = new int[n][n];
+ for (int i = 0; i < n; i++) {
+ residual[i] = Arrays.copyOf(capacity[i], n);
+ }
+
+ final int[] parent = new int[n];
+ int maxFlow = 0;
+
+ while (bfs(residual, source, sink, parent)) {
+ int pathFlow = Integer.MAX_VALUE;
+ for (int v = sink; v != source; v = parent[v]) {
+ int u = parent[v];
+ pathFlow = Math.min(pathFlow, residual[u][v]);
+ }
+
+ for (int v = sink; v != source; v = parent[v]) {
+ int u = parent[v];
+ residual[u][v] -= pathFlow;
+ residual[v][u] += pathFlow;
+ }
+
+ maxFlow += pathFlow;
+ }
+
+ return maxFlow;
+ }
+
+ private static boolean bfs(int[][] residual, int source, int sink, int[] parent) {
+ Arrays.fill(parent, -1);
+ parent[source] = source;
+
+ Queue queue = new ArrayDeque<>();
+ queue.add(source);
+
+ while (!queue.isEmpty()) {
+ int u = queue.poll();
+ for (int v = 0; v < residual.length; v++) {
+ if (residual[u][v] > 0 && parent[v] == -1) {
+ parent[v] = u;
+ if (v == sink) {
+ return true;
+ }
+ queue.add(v);
+ }
+ }
+ }
+ return false;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/graph/GomoryHuTree.java b/src/main/java/com/thealgorithms/graph/GomoryHuTree.java
new file mode 100644
index 000000000000..f8c110f25571
--- /dev/null
+++ b/src/main/java/com/thealgorithms/graph/GomoryHuTree.java
@@ -0,0 +1,144 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Queue;
+
+/**
+ * Gomory–Hu tree construction for undirected graphs via n−1 max-flow computations.
+ *
+ * API: {@code buildTree(int[][])} returns {@code {parent, weight}} arrays for the tree.
+ *
+ * @see Wikipedia: Gomory–Hu tree
+ */
+
+public final class GomoryHuTree {
+ private GomoryHuTree() {
+ }
+
+ public static int[][] buildTree(int[][] cap) {
+ validateCapacityMatrix(cap);
+ final int n = cap.length;
+ if (n == 1) {
+ return new int[][] {new int[] {-1}, new int[] {0}};
+ }
+
+ int[] parent = new int[n];
+ int[] weight = new int[n];
+ Arrays.fill(parent, 0);
+ parent[0] = -1;
+ weight[0] = 0;
+
+ for (int s = 1; s < n; s++) {
+ int t = parent[s];
+ MaxFlowResult res = edmondsKarpWithMinCut(cap, s, t);
+ int f = res.flow;
+ weight[s] = f;
+
+ for (int v = 0; v < n; v++) {
+ if (v != s && parent[v] == t && res.reachable[v]) {
+ parent[v] = s;
+ }
+ }
+
+ if (t != 0 && res.reachable[parent[t]]) {
+ parent[s] = parent[t];
+ parent[t] = s;
+ weight[s] = weight[t];
+ weight[t] = f;
+ }
+ }
+ return new int[][] {parent, weight};
+ }
+
+ private static void validateCapacityMatrix(int[][] cap) {
+ if (cap == null || cap.length == 0) {
+ throw new IllegalArgumentException("Capacity matrix must not be null or empty");
+ }
+ final int n = cap.length;
+ for (int i = 0; i < n; i++) {
+ if (cap[i] == null || cap[i].length != n) {
+ throw new IllegalArgumentException("Capacity matrix must be square");
+ }
+ for (int j = 0; j < n; j++) {
+ if (cap[i][j] < 0) {
+ throw new IllegalArgumentException("Capacities must be non-negative");
+ }
+ }
+ }
+ }
+
+ private static final class MaxFlowResult {
+ final int flow;
+ final boolean[] reachable;
+ MaxFlowResult(int flow, boolean[] reachable) {
+ this.flow = flow;
+ this.reachable = reachable;
+ }
+ }
+
+ private static MaxFlowResult edmondsKarpWithMinCut(int[][] capacity, int source, int sink) {
+ final int n = capacity.length;
+ int[][] residual = new int[n][n];
+ for (int i = 0; i < n; i++) {
+ residual[i] = Arrays.copyOf(capacity[i], n);
+ }
+
+ int[] parent = new int[n];
+ int maxFlow = 0;
+
+ while (bfs(residual, source, sink, parent)) {
+ int pathFlow = Integer.MAX_VALUE;
+ for (int v = sink; v != source; v = parent[v]) {
+ int u = parent[v];
+ pathFlow = Math.min(pathFlow, residual[u][v]);
+ }
+ for (int v = sink; v != source; v = parent[v]) {
+ int u = parent[v];
+ residual[u][v] -= pathFlow;
+ residual[v][u] += pathFlow;
+ }
+ maxFlow += pathFlow;
+ }
+
+ boolean[] reachable = new boolean[n];
+ markReachable(residual, source, reachable);
+ return new MaxFlowResult(maxFlow, reachable);
+ }
+
+ private static boolean bfs(int[][] residual, int source, int sink, int[] parent) {
+ Arrays.fill(parent, -1);
+ parent[source] = source;
+ Queue q = new ArrayDeque<>();
+ q.add(source);
+ while (!q.isEmpty()) {
+ int u = q.poll();
+ for (int v = 0; v < residual.length; v++) {
+ if (residual[u][v] > 0 && parent[v] == -1) {
+ parent[v] = u;
+ if (v == sink) {
+ return true;
+ }
+ q.add(v);
+ }
+ }
+ }
+ return false;
+ }
+
+ private static void markReachable(int[][] residual, int source, boolean[] vis) {
+ Arrays.fill(vis, false);
+ Queue q = new ArrayDeque<>();
+ vis[source] = true;
+ q.add(source);
+ while (!q.isEmpty()) {
+ int u = q.poll();
+ for (int v = 0; v < residual.length; v++) {
+ if (!vis[v] && residual[u][v] > 0) {
+ vis[v] = true;
+ q.add(v);
+ }
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/thealgorithms/graph/HierholzerAlgorithm.java b/src/main/java/com/thealgorithms/graph/HierholzerAlgorithm.java
new file mode 100644
index 000000000000..a804f77d7fa6
--- /dev/null
+++ b/src/main/java/com/thealgorithms/graph/HierholzerAlgorithm.java
@@ -0,0 +1,140 @@
+package com.thealgorithms.graph;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Stack;
+
+/**
+ * Implementation of Hierholzer's algorithm to find an Eulerian Circuit in an undirected graph.
+ *
+ * An Eulerian circuit is a trail in a graph that visits every edge exactly once,
+ * starting and ending at the same vertex. This algorithm finds such a circuit if one exists.
+ *
+ *
+ * This implementation is designed for an undirected graph. For a valid Eulerian
+ * circuit to exist, the graph must satisfy two conditions:
+ *
+ * - All vertices with a non-zero degree must be part of a single connected component.
+ * - Every vertex must have an even degree (an even number of edges connected to it).
+ *
+ *
+ *
+ * The algorithm runs in O(E + V) time, where E is the number of edges and V is the number of vertices.
+ * The graph is represented by a Map where keys are vertices and values are a LinkedList of adjacent vertices.
+ *
+ *
+ * @see Wikipedia: Hierholzer's algorithm
+ */
+public final class HierholzerAlgorithm {
+
+ private final Map> graph;
+
+ public HierholzerAlgorithm(Map> graph) {
+ this.graph = (graph == null) ? new HashMap<>() : graph;
+ }
+
+ public boolean hasEulerianCircuit() {
+ if (graph.isEmpty()) {
+ return true;
+ }
+
+ for (List neighbors : graph.values()) {
+ if (neighbors.size() % 2 != 0) {
+ return false;
+ }
+ }
+
+ return isCoherentlyConnected();
+ }
+
+ public List findEulerianCircuit() {
+ if (!hasEulerianCircuit()) {
+ return Collections.emptyList();
+ }
+
+ Map> tempGraph = new HashMap<>();
+ for (Map.Entry> entry : graph.entrySet()) {
+ tempGraph.put(entry.getKey(), new LinkedList<>(entry.getValue()));
+ }
+
+ Stack currentPath = new Stack<>();
+ LinkedList circuit = new LinkedList<>();
+
+ int startVertex = -1;
+ for (Map.Entry> entry : tempGraph.entrySet()) {
+ if (!entry.getValue().isEmpty()) {
+ startVertex = entry.getKey();
+ break;
+ }
+ }
+
+ if (startVertex == -1) {
+ if (graph.isEmpty()) {
+ return Collections.emptyList();
+ }
+ return Collections.singletonList(graph.keySet().iterator().next());
+ }
+
+ currentPath.push(startVertex);
+
+ while (!currentPath.isEmpty()) {
+ int currentVertex = currentPath.peek();
+
+ if (tempGraph.containsKey(currentVertex) && !tempGraph.get(currentVertex).isEmpty()) {
+ int nextVertex = tempGraph.get(currentVertex).pollFirst();
+ tempGraph.get(nextVertex).remove(Integer.valueOf(currentVertex));
+ currentPath.push(nextVertex);
+ } else {
+ circuit.addFirst(currentVertex);
+ currentPath.pop();
+ }
+ }
+
+ return circuit;
+ }
+
+ private boolean isCoherentlyConnected() {
+ if (graph.isEmpty()) {
+ return true;
+ }
+
+ Set visited = new HashSet<>();
+ int startNode = -1;
+
+ for (Map.Entry> entry : graph.entrySet()) {
+ if (!entry.getValue().isEmpty()) {
+ startNode = entry.getKey();
+ break;
+ }
+ }
+
+ if (startNode == -1) {
+ return true;
+ }
+
+ dfs(startNode, visited);
+
+ for (Map.Entry> entry : graph.entrySet()) {
+ if (!entry.getValue().isEmpty() && !visited.contains(entry.getKey())) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private void dfs(int u, Set visited) {
+ visited.add(u);
+ if (graph.containsKey(u)) {
+ for (int v : graph.get(u)) {
+ if (!visited.contains(v)) {
+ dfs(v, visited);
+ }
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/thealgorithms/graph/HierholzerEulerianPath.java b/src/main/java/com/thealgorithms/graph/HierholzerEulerianPath.java
new file mode 100644
index 000000000000..82da5c8163e5
--- /dev/null
+++ b/src/main/java/com/thealgorithms/graph/HierholzerEulerianPath.java
@@ -0,0 +1,303 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.List;
+
+/**
+ * Implementation of Hierholzer's Algorithm for finding an Eulerian Path or Circuit
+ * in a directed graph.
+ *
+ *
+ * An Eulerian Circuit is a path that starts and ends at the same vertex
+ * and visits every edge exactly once.
+ *
+ *
+ *
+ * An Eulerian Path visits every edge exactly once but may start and end
+ * at different vertices.
+ *
+ *
+ *
+ * Algorithm Summary:
+ * 1. Compute indegree and outdegree for all vertices.
+ * 2. Check if the graph satisfies Eulerian path or circuit conditions.
+ * 3. Verify that all vertices with non-zero degree are weakly connected (undirected connectivity).
+ * 4. Use Hierholzer’s algorithm to build the path by exploring unused edges iteratively.
+ *
+ *
+ *
+ * Time Complexity: O(E + V).
+ * Space Complexity: O(V + E).
+ *
+ *
+ * @author Wikipedia: Hierholzer algorithm
+ */
+public class HierholzerEulerianPath {
+
+ /**
+ * Simple directed graph represented by adjacency lists.
+ */
+ public static class Graph {
+ private final List> adjacencyList;
+
+ /**
+ * Constructs a graph with a given number of vertices.
+ *
+ * @param numNodes number of vertices
+ */
+ public Graph(int numNodes) {
+ adjacencyList = new ArrayList<>();
+ for (int i = 0; i < numNodes; i++) {
+ adjacencyList.add(new ArrayList<>());
+ }
+ }
+
+ /**
+ * Adds a directed edge from vertex {@code from} to vertex {@code to}.
+ *
+ * @param from source vertex
+ * @param to destination vertex
+ */
+ public void addEdge(int from, int to) {
+ adjacencyList.get(from).add(to);
+ }
+
+ /**
+ * Returns a list of outgoing edges from the given vertex.
+ *
+ * @param node vertex index
+ * @return list of destination vertices
+ */
+ public List getEdges(int node) {
+ return adjacencyList.get(node);
+ }
+
+ /**
+ * Returns the number of vertices in the graph.
+ *
+ * @return number of vertices
+ */
+ public int getNumNodes() {
+ return adjacencyList.size();
+ }
+ }
+
+ private final Graph graph;
+
+ /**
+ * Creates a Hierholzer solver for the given graph.
+ *
+ * @param graph directed graph
+ */
+ public HierholzerEulerianPath(Graph graph) {
+ this.graph = graph;
+ }
+
+ /**
+ * Finds an Eulerian Path or Circuit using Hierholzer’s Algorithm.
+ *
+ * @return list of vertices representing the Eulerian Path/Circuit,
+ * or an empty list if none exists
+ */
+ public List findEulerianPath() {
+ int n = graph.getNumNodes();
+
+ // empty graph -> no path
+ if (n == 0) {
+ return new ArrayList<>();
+ }
+
+ int[] inDegree = new int[n];
+ int[] outDegree = new int[n];
+ int edgeCount = computeDegrees(inDegree, outDegree);
+
+ // no edges -> single vertex response requested by tests: [0]
+ if (edgeCount == 0) {
+ return Collections.singletonList(0);
+ }
+
+ int startNode = determineStartNode(inDegree, outDegree);
+ if (startNode == -1) {
+ return new ArrayList<>();
+ }
+
+ if (!allNonZeroDegreeVerticesWeaklyConnected(startNode, n, outDegree, inDegree)) {
+ return new ArrayList<>();
+ }
+
+ List path = buildHierholzerPath(startNode, n);
+ if (path.size() != edgeCount + 1) {
+ return new ArrayList<>();
+ }
+
+ return rotateEulerianCircuitIfNeeded(path, outDegree, inDegree);
+ }
+
+ private int computeDegrees(int[] inDegree, int[] outDegree) {
+ int edgeCount = 0;
+ for (int u = 0; u < graph.getNumNodes(); u++) {
+ for (int v : graph.getEdges(u)) {
+ outDegree[u]++;
+ inDegree[v]++;
+ edgeCount++;
+ }
+ }
+ return edgeCount;
+ }
+
+ private int determineStartNode(int[] inDegree, int[] outDegree) {
+ int n = graph.getNumNodes();
+ int startNode = -1;
+ int startCount = 0;
+ int endCount = 0;
+
+ for (int i = 0; i < n; i++) {
+ int diff = outDegree[i] - inDegree[i];
+ if (diff == 1) {
+ startNode = i;
+ startCount++;
+ } else if (diff == -1) {
+ endCount++;
+ } else if (Math.abs(diff) > 1) {
+ return -1;
+ }
+ }
+
+ if (!((startCount == 1 && endCount == 1) || (startCount == 0 && endCount == 0))) {
+ return -1;
+ }
+
+ if (startNode == -1) {
+ for (int i = 0; i < n; i++) {
+ if (outDegree[i] > 0) {
+ startNode = i;
+ break;
+ }
+ }
+ }
+ return startNode;
+ }
+
+ private List buildHierholzerPath(int startNode, int n) {
+ List> tempAdj = new ArrayList<>();
+ for (int i = 0; i < n; i++) {
+ tempAdj.add(new ArrayDeque<>(graph.getEdges(i)));
+ }
+
+ Deque stack = new ArrayDeque<>();
+ List path = new ArrayList<>();
+ stack.push(startNode);
+
+ while (!stack.isEmpty()) {
+ int u = stack.peek();
+ if (!tempAdj.get(u).isEmpty()) {
+ stack.push(tempAdj.get(u).pollFirst());
+ } else {
+ path.add(stack.pop());
+ }
+ }
+
+ Collections.reverse(path);
+ return path;
+ }
+
+ private List rotateEulerianCircuitIfNeeded(List path, int[] outDegree, int[] inDegree) {
+ int startCount = 0;
+ int endCount = 0;
+ for (int i = 0; i < outDegree.length; i++) {
+ int diff = outDegree[i] - inDegree[i];
+ if (diff == 1) {
+ startCount++;
+ } else if (diff == -1) {
+ endCount++;
+ }
+ }
+
+ if (startCount == 0 && endCount == 0 && !path.isEmpty()) {
+ int preferredStart = -1;
+ for (int i = 0; i < outDegree.length; i++) {
+ if (outDegree[i] > 0) {
+ preferredStart = i;
+ break;
+ }
+ }
+
+ if (preferredStart != -1 && path.get(0) != preferredStart) {
+ int idx = 0;
+ for (Integer node : path) { // replaced indexed loop
+ if (node == preferredStart) {
+ break;
+ }
+ idx++;
+ }
+
+ if (idx > 0) {
+ List