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/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/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 0245372fe012..2c94224ddeb4 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/BSTRecursiveGeneric.java
+++ b/src/main/java/com/thealgorithms/datastructures/trees/BSTRecursiveGeneric.java
@@ -30,7 +30,7 @@ public BSTRecursiveGeneric() {
}
/**
- * Displays the tree is a structed format
+ * Displays the tree is a structured format
*/
public void prettyDisplay() {
prettyDisplay(root, 0);
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/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/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/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/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 rotated = new ArrayList<>();
+ int currentIndex = 0;
+ for (Integer node : path) { // replaced indexed loop
+ if (currentIndex >= idx) {
+ rotated.add(node);
+ }
+ currentIndex++;
+ }
+ currentIndex = 0;
+ for (Integer node : path) { // replaced indexed loop
+ if (currentIndex < idx) {
+ rotated.add(node);
+ }
+ currentIndex++;
+ }
+ path = rotated;
+ }
+ }
+ }
+ return path;
+ }
+
+ /**
+ * Checks weak connectivity (undirected) among vertices that have non-zero degree.
+ *
+ * @param startNode node to start DFS from (must be a vertex with non-zero degree)
+ * @param n number of vertices
+ * @param outDegree out-degree array
+ * @param inDegree in-degree array
+ * @return true if all vertices having non-zero degree belong to a single weak component
+ */
+ private boolean allNonZeroDegreeVerticesWeaklyConnected(int startNode, int n, int[] outDegree, int[] inDegree) {
+ boolean[] visited = new boolean[n];
+ Deque stack = new ArrayDeque<>();
+ stack.push(startNode);
+ visited[startNode] = true;
+
+ while (!stack.isEmpty()) {
+ int u = stack.pop();
+ for (int v : graph.getEdges(u)) {
+ if (!visited[v]) {
+ visited[v] = true;
+ stack.push(v);
+ }
+ }
+ for (int x = 0; x < n; x++) {
+ if (!visited[x]) {
+ for (int y : graph.getEdges(x)) {
+ if (y == u) {
+ visited[x] = true;
+ stack.push(x);
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ for (int i = 0; i < n; i++) {
+ if (outDegree[i] + inDegree[i] > 0 && !visited[i]) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/graph/HungarianAlgorithm.java b/src/main/java/com/thealgorithms/graph/HungarianAlgorithm.java
new file mode 100644
index 000000000000..84f5671c4f9d
--- /dev/null
+++ b/src/main/java/com/thealgorithms/graph/HungarianAlgorithm.java
@@ -0,0 +1,150 @@
+package com.thealgorithms.graph;
+
+import java.util.Arrays;
+
+/**
+ * Hungarian algorithm (a.k.a. Kuhn–Munkres) for the Assignment Problem.
+ *
+ * Given an n x m cost matrix (n tasks, m workers), finds a minimum-cost
+ * one-to-one assignment. If the matrix is rectangular, the algorithm pads to a
+ * square internally. Costs must be finite non-negative integers.
+ *
+ *
Time complexity: O(n^3) with n = max(rows, cols).
+ *
+ *
API returns the assignment as an array where {@code assignment[i]} is the
+ * column chosen for row i (or -1 if unassigned when rows != cols), and a total
+ * minimal cost.
+ *
+ * @see Wikipedia: Hungarian algorithm
+ */
+public final class HungarianAlgorithm {
+
+ private HungarianAlgorithm() {
+ }
+
+ /** Result holder for the Hungarian algorithm. */
+ public static final class Result {
+ public final int[] assignment; // assignment[row] = col or -1
+ public final int minCost;
+
+ public Result(int[] assignment, int minCost) {
+ this.assignment = assignment;
+ this.minCost = minCost;
+ }
+ }
+
+ /**
+ * Solves the assignment problem for a non-negative cost matrix.
+ *
+ * @param cost an r x c matrix of non-negative costs
+ * @return Result with row-to-column assignment and minimal total cost
+ * @throws IllegalArgumentException for null/empty or negative costs
+ */
+ public static Result solve(int[][] cost) {
+ validate(cost);
+ int rows = cost.length;
+ int cols = cost[0].length;
+ int n = Math.max(rows, cols);
+
+ // Build square matrix with padding 0 for missing cells
+ int[][] a = new int[n][n];
+ for (int i = 0; i < n; i++) {
+ if (i < rows) {
+ for (int j = 0; j < n; j++) {
+ a[i][j] = (j < cols) ? cost[i][j] : 0;
+ }
+ } else {
+ Arrays.fill(a[i], 0);
+ }
+ }
+
+ // Potentials and matching arrays
+ int[] u = new int[n + 1];
+ int[] v = new int[n + 1];
+ int[] p = new int[n + 1];
+ int[] way = new int[n + 1];
+
+ for (int i = 1; i <= n; i++) {
+ p[0] = i;
+ int j0 = 0;
+ int[] minv = new int[n + 1];
+ boolean[] used = new boolean[n + 1];
+ Arrays.fill(minv, Integer.MAX_VALUE);
+ Arrays.fill(used, false);
+ do {
+ used[j0] = true;
+ int i0 = p[j0];
+ int delta = Integer.MAX_VALUE;
+ int j1 = 0;
+ for (int j = 1; j <= n; j++) {
+ if (!used[j]) {
+ int cur = a[i0 - 1][j - 1] - u[i0] - v[j];
+ if (cur < minv[j]) {
+ minv[j] = cur;
+ way[j] = j0;
+ }
+ if (minv[j] < delta) {
+ delta = minv[j];
+ j1 = j;
+ }
+ }
+ }
+ for (int j = 0; j <= n; j++) {
+ if (used[j]) {
+ u[p[j]] += delta;
+ v[j] -= delta;
+ } else {
+ minv[j] -= delta;
+ }
+ }
+ j0 = j1;
+ } while (p[j0] != 0);
+ do {
+ int j1 = way[j0];
+ p[j0] = p[j1];
+ j0 = j1;
+ } while (j0 != 0);
+ }
+
+ int[] matchColForRow = new int[n];
+ Arrays.fill(matchColForRow, -1);
+ for (int j = 1; j <= n; j++) {
+ if (p[j] != 0) {
+ matchColForRow[p[j] - 1] = j - 1;
+ }
+ }
+
+ // Build assignment for original rows only, ignore padded rows
+ int[] assignment = new int[rows];
+ Arrays.fill(assignment, -1);
+ int total = 0;
+ for (int i = 0; i < rows; i++) {
+ int j = matchColForRow[i];
+ if (j >= 0 && j < cols) {
+ assignment[i] = j;
+ total += cost[i][j];
+ }
+ }
+ return new Result(assignment, total);
+ }
+
+ private static void validate(int[][] cost) {
+ if (cost == null || cost.length == 0) {
+ throw new IllegalArgumentException("Cost matrix must not be null or empty");
+ }
+ int c = cost[0].length;
+ if (c == 0) {
+ throw new IllegalArgumentException("Cost matrix must have at least 1 column");
+ }
+ for (int i = 0; i < cost.length; i++) {
+ if (cost[i] == null || cost[i].length != c) {
+ throw new IllegalArgumentException("Cost matrix must be rectangular with equal row lengths");
+ }
+ for (int j = 0; j < c; j++) {
+ if (cost[i][j] < 0) {
+ throw new IllegalArgumentException("Costs must be non-negative");
+ }
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/thealgorithms/graph/PushRelabel.java b/src/main/java/com/thealgorithms/graph/PushRelabel.java
new file mode 100644
index 000000000000..1bfb5ceacce0
--- /dev/null
+++ b/src/main/java/com/thealgorithms/graph/PushRelabel.java
@@ -0,0 +1,162 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Queue;
+
+/**
+ * Push–Relabel (Relabel-to-Front variant simplified to array scanning) for maximum flow.
+ *
+ *
Input graph is a capacity matrix where {@code capacity[u][v]} is the capacity of the edge
+ * {@code u -> v}. Capacities must be non-negative. Vertices are indexed in {@code [0, n)}.
+ *
+ *
Time complexity: O(V^3) in the worst case for the array-based variant; typically fast in
+ * practice. This implementation uses a residual network over an adjacency-matrix representation.
+ *
+ *
The API mirrors {@link EdmondsKarp#maxFlow(int[][], int, int)} and {@link Dinic#maxFlow(int[][], int, int)}.
+ *
+ * @see Wikipedia: Push–Relabel maximum flow algorithm
+ */
+public final class PushRelabel {
+
+ private PushRelabel() {
+ }
+
+ /**
+ * Computes the maximum flow from {@code source} to {@code sink} using Push–Relabel.
+ *
+ * @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 inputs are invalid
+ */
+ public static int maxFlow(int[][] capacity, int source, int sink) {
+ validate(capacity, source, sink);
+ final int n = capacity.length;
+ if (source == sink) {
+ return 0;
+ }
+
+ int[][] residual = new int[n][n];
+ for (int i = 0; i < n; i++) {
+ residual[i] = Arrays.copyOf(capacity[i], n);
+ }
+
+ int[] height = new int[n];
+ int[] excess = new int[n];
+ int[] nextNeighbor = new int[n];
+
+ // Preflow initialization
+ height[source] = n;
+ for (int v = 0; v < n; v++) {
+ int cap = residual[source][v];
+ if (cap > 0) {
+ residual[source][v] -= cap;
+ residual[v][source] += cap;
+ excess[v] += cap;
+ excess[source] -= cap;
+ }
+ }
+
+ // Active queue contains vertices (except source/sink) with positive excess
+ Queue active = new ArrayDeque<>();
+ for (int v = 0; v < n; v++) {
+ if (v != source && v != sink && excess[v] > 0) {
+ active.add(v);
+ }
+ }
+
+ State state = new State(residual, height, excess, nextNeighbor, source, sink, active);
+
+ while (!active.isEmpty()) {
+ int u = active.poll();
+ discharge(u, state);
+ if (excess[u] > 0) {
+ // still active after discharge; push to back
+ active.add(u);
+ }
+ }
+
+ // Total flow equals excess at sink
+ return excess[sink];
+ }
+
+ private static void discharge(int u, State s) {
+ final int n = s.residual.length;
+ while (s.excess[u] > 0) {
+ if (s.nextNeighbor[u] >= n) {
+ relabel(u, s.residual, s.height);
+ s.nextNeighbor[u] = 0;
+ continue;
+ }
+ int v = s.nextNeighbor[u];
+ if (s.residual[u][v] > 0 && s.height[u] == s.height[v] + 1) {
+ int delta = Math.min(s.excess[u], s.residual[u][v]);
+ s.residual[u][v] -= delta;
+ s.residual[v][u] += delta;
+ s.excess[u] -= delta;
+ int prevExcessV = s.excess[v];
+ s.excess[v] += delta;
+ if (v != s.source && v != s.sink && prevExcessV == 0) {
+ s.active.add(v);
+ }
+ } else {
+ s.nextNeighbor[u]++;
+ }
+ }
+ }
+
+ private static final class State {
+ final int[][] residual;
+ final int[] height;
+ final int[] excess;
+ final int[] nextNeighbor;
+ final int source;
+ final int sink;
+ final Queue active;
+
+ State(int[][] residual, int[] height, int[] excess, int[] nextNeighbor, int source, int sink, Queue active) {
+ this.residual = residual;
+ this.height = height;
+ this.excess = excess;
+ this.nextNeighbor = nextNeighbor;
+ this.source = source;
+ this.sink = sink;
+ this.active = active;
+ }
+ }
+
+ private static void relabel(int u, int[][] residual, int[] height) {
+ final int n = residual.length;
+ int minHeight = Integer.MAX_VALUE;
+ for (int v = 0; v < n; v++) {
+ if (residual[u][v] > 0) {
+ minHeight = Math.min(minHeight, height[v]);
+ }
+ }
+ if (minHeight < Integer.MAX_VALUE) {
+ height[u] = minHeight + 1;
+ }
+ }
+
+ private static void validate(int[][] capacity, int source, int sink) {
+ if (capacity == null || capacity.length == 0) {
+ throw new IllegalArgumentException("Capacity matrix must not be null or empty");
+ }
+ 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");
+ }
+ }
+}
diff --git a/src/main/java/com/thealgorithms/graph/StoerWagner.java b/src/main/java/com/thealgorithms/graph/StoerWagner.java
new file mode 100644
index 000000000000..b204834c431a
--- /dev/null
+++ b/src/main/java/com/thealgorithms/graph/StoerWagner.java
@@ -0,0 +1,78 @@
+package com.thealgorithms.graph;
+
+/**
+ * An implementation of the Stoer-Wagner algorithm to find the global minimum cut of an undirected, weighted graph.
+ * A minimum cut is a partition of the graph's vertices into two disjoint sets with the minimum possible edge weight
+ * sum connecting the two sets.
+ *
+ * Wikipedia: https://en.wikipedia.org/wiki/Stoer%E2%80%93Wagner_algorithm
+ * Time Complexity: O(V^3) where V is the number of vertices.
+ */
+public class StoerWagner {
+
+ /**
+ * Finds the minimum cut in the given undirected, weighted graph.
+ *
+ * @param graph An adjacency matrix representing the graph. graph[i][j] is the weight of the edge between i and j.
+ * @return The weight of the minimum cut.
+ */
+ public int findMinCut(int[][] graph) {
+ int n = graph.length;
+ if (n < 2) {
+ return 0;
+ }
+
+ int[][] currentGraph = new int[n][n];
+ for (int i = 0; i < n; i++) {
+ System.arraycopy(graph[i], 0, currentGraph[i], 0, n);
+ }
+
+ int minCut = Integer.MAX_VALUE;
+ boolean[] merged = new boolean[n];
+
+ for (int phase = 0; phase < n - 1; phase++) {
+ boolean[] inSetA = new boolean[n];
+ int[] weights = new int[n];
+ int prev = -1;
+ int last = -1;
+
+ for (int i = 0; i < n - phase; i++) {
+ int maxWeight = -1;
+ int currentVertex = -1;
+
+ for (int j = 0; j < n; j++) {
+ if (!merged[j] && !inSetA[j] && weights[j] > maxWeight) {
+ maxWeight = weights[j];
+ currentVertex = j;
+ }
+ }
+
+ if (currentVertex == -1) {
+ // This can happen if the graph is disconnected.
+ return 0;
+ }
+
+ prev = last;
+ last = currentVertex;
+ inSetA[last] = true;
+
+ for (int j = 0; j < n; j++) {
+ if (!merged[j] && !inSetA[j]) {
+ weights[j] += currentGraph[last][j];
+ }
+ }
+ }
+
+ minCut = Math.min(minCut, weights[last]);
+
+ // Merge 'last' vertex into 'prev' vertex
+ for (int i = 0; i < n; i++) {
+ currentGraph[prev][i] += currentGraph[last][i];
+ currentGraph[i][prev] = currentGraph[prev][i];
+ }
+ merged[last] = true;
+ }
+
+ return minCut;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/graph/YensKShortestPaths.java b/src/main/java/com/thealgorithms/graph/YensKShortestPaths.java
new file mode 100644
index 000000000000..dfc8386de6ce
--- /dev/null
+++ b/src/main/java/com/thealgorithms/graph/YensKShortestPaths.java
@@ -0,0 +1,263 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.PriorityQueue;
+import java.util.Set;
+
+/**
+ * Yen's algorithm for finding K loopless shortest paths in a directed graph with non-negative edge weights.
+ *
+ * Input is an adjacency matrix of edge weights. A value of -1 indicates no edge.
+ * All existing edge weights must be non-negative. Zero-weight edges are allowed.
+ *
+ * References:
+ * - Wikipedia: Yen's algorithm (https://en.wikipedia.org/wiki/Yen%27s_algorithm)
+ * - Dijkstra's algorithm for the base shortest path computation.
+ */
+public final class YensKShortestPaths {
+
+ private YensKShortestPaths() {
+ }
+
+ private static final int NO_EDGE = -1;
+ private static final long INF_COST = Long.MAX_VALUE / 4;
+
+ /**
+ * Compute up to k loopless shortest paths from src to dst using Yen's algorithm.
+ *
+ * @param weights adjacency matrix; weights[u][v] = -1 means no edge; otherwise non-negative edge weight
+ * @param src source vertex index
+ * @param dst destination vertex index
+ * @param k maximum number of paths to return (k >= 1)
+ * @return list of paths, each path is a list of vertex indices in order from src to dst
+ * @throws IllegalArgumentException on invalid inputs (null, non-square, negatives on existing edges, bad indices, k < 1)
+ */
+ public static List> kShortestPaths(int[][] weights, int src, int dst, int k) {
+ validate(weights, src, dst, k);
+ final int n = weights.length;
+ // Make a defensive copy to avoid mutating caller's matrix
+ int[][] weightsCopy = new int[n][n];
+ for (int i = 0; i < n; i++) {
+ weightsCopy[i] = Arrays.copyOf(weights[i], n);
+ }
+
+ List shortestPaths = new ArrayList<>();
+ PriorityQueue candidates = new PriorityQueue<>(); // min-heap by cost then lexicographic nodes
+ Set seen = new HashSet<>(); // deduplicate candidate paths by node sequence key
+
+ Path first = dijkstra(weightsCopy, src, dst, new boolean[n]);
+ if (first == null) {
+ return List.of();
+ }
+ shortestPaths.add(first);
+
+ for (int kIdx = 1; kIdx < k; kIdx++) {
+ Path lastPath = shortestPaths.get(kIdx - 1);
+ List lastNodes = lastPath.nodes;
+ for (int i = 0; i < lastNodes.size() - 1; i++) {
+ int spurNode = lastNodes.get(i);
+ List rootPath = lastNodes.subList(0, i + 1);
+
+ // Build modified graph: remove edges that would recreate same root + next edge as any A path
+ int[][] modifiedWeights = cloneMatrix(weightsCopy);
+
+ for (Path p : shortestPaths) {
+ if (startsWith(p.nodes, rootPath) && p.nodes.size() > i + 1) {
+ int u = p.nodes.get(i);
+ int v = p.nodes.get(i + 1);
+ modifiedWeights[u][v] = NO_EDGE; // remove edge
+ }
+ }
+ // Prevent revisiting nodes in rootPath (loopless constraint), except spurNode itself
+ boolean[] blocked = new boolean[n];
+ for (int j = 0; j < rootPath.size() - 1; j++) {
+ blocked[rootPath.get(j)] = true;
+ }
+
+ Path spurPath = dijkstra(modifiedWeights, spurNode, dst, blocked);
+ if (spurPath != null) {
+ // concatenate rootPath (excluding spurNode at end) + spurPath
+ List totalNodes = new ArrayList<>(rootPath);
+ // spurPath.nodes starts with spurNode; avoid duplication
+ for (int idx = 1; idx < spurPath.nodes.size(); idx++) {
+ totalNodes.add(spurPath.nodes.get(idx));
+ }
+ long rootCost = pathCost(weightsCopy, rootPath);
+ long totalCost = rootCost + spurPath.cost; // spurPath.cost covers from spurNode to dst
+ Path candidate = new Path(totalNodes, totalCost);
+ String key = candidate.key();
+ if (seen.add(key)) {
+ candidates.add(candidate);
+ }
+ }
+ }
+ if (candidates.isEmpty()) {
+ break;
+ }
+ shortestPaths.add(candidates.poll());
+ }
+
+ // Map to list of node indices for output
+ List> result = new ArrayList<>(shortestPaths.size());
+ for (Path p : shortestPaths) {
+ result.add(new ArrayList<>(p.nodes));
+ }
+ return result;
+ }
+
+ private static void validate(int[][] weights, int src, int dst, int k) {
+ if (weights == null || weights.length == 0) {
+ throw new IllegalArgumentException("Weights matrix must not be null or empty");
+ }
+ int n = weights.length;
+ for (int i = 0; i < n; i++) {
+ if (weights[i] == null || weights[i].length != n) {
+ throw new IllegalArgumentException("Weights matrix must be square");
+ }
+ for (int j = 0; j < n; j++) {
+ int val = weights[i][j];
+ if (val < NO_EDGE) {
+ throw new IllegalArgumentException("Weights must be -1 (no edge) or >= 0");
+ }
+ }
+ }
+ if (src < 0 || dst < 0 || src >= n || dst >= n) {
+ throw new IllegalArgumentException("Invalid src/dst indices");
+ }
+ if (k < 1) {
+ throw new IllegalArgumentException("k must be >= 1");
+ }
+ }
+
+ private static boolean startsWith(List list, List prefix) {
+ if (prefix.size() > list.size()) {
+ return false;
+ }
+ for (int i = 0; i < prefix.size(); i++) {
+ if (!Objects.equals(list.get(i), prefix.get(i))) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private static int[][] cloneMatrix(int[][] a) {
+ int n = a.length;
+ int[][] b = new int[n][n];
+ for (int i = 0; i < n; i++) {
+ b[i] = Arrays.copyOf(a[i], n);
+ }
+ return b;
+ }
+
+ private static long pathCost(int[][] weights, List nodes) {
+ long cost = 0;
+ for (int i = 0; i + 1 < nodes.size(); i++) {
+ int u = nodes.get(i);
+ int v = nodes.get(i + 1);
+ int edgeCost = weights[u][v];
+ if (edgeCost < 0) {
+ return INF_COST; // invalid
+ }
+ cost += edgeCost;
+ }
+ return cost;
+ }
+
+ private static Path dijkstra(int[][] weights, int src, int dst, boolean[] blocked) {
+ int n = weights.length;
+ final long inf = INF_COST;
+ long[] dist = new long[n];
+ int[] parent = new int[n];
+ Arrays.fill(dist, inf);
+ Arrays.fill(parent, -1);
+ PriorityQueue queue = new PriorityQueue<>();
+ if (blocked[src]) {
+ return null;
+ }
+ dist[src] = 0;
+ queue.add(new Node(src, 0));
+ while (!queue.isEmpty()) {
+ Node current = queue.poll();
+ if (current.dist != dist[current.u]) {
+ continue;
+ }
+ if (current.u == dst) {
+ break;
+ }
+ for (int v = 0; v < n; v++) {
+ int edgeWeight = weights[current.u][v];
+ if (edgeWeight >= 0 && !blocked[v]) {
+ long newDist = current.dist + edgeWeight;
+ if (newDist < dist[v]) {
+ dist[v] = newDist;
+ parent[v] = current.u;
+ queue.add(new Node(v, newDist));
+ }
+ }
+ }
+ }
+ if (dist[dst] >= inf) {
+ // If src==dst and not blocked, the path is trivial with cost 0
+ if (src == dst) {
+ List nodes = new ArrayList<>();
+ nodes.add(src);
+ return new Path(nodes, 0);
+ }
+ return null;
+ }
+ // Reconstruct path
+ List nodes = new ArrayList<>();
+ int cur = dst;
+ while (cur != -1) {
+ nodes.add(0, cur);
+ cur = parent[cur];
+ }
+ return new Path(nodes, dist[dst]);
+ }
+
+ private static final class Node implements Comparable {
+ final int u;
+ final long dist;
+ Node(int u, long dist) {
+ this.u = u;
+ this.dist = dist;
+ }
+ public int compareTo(Node o) {
+ return Long.compare(this.dist, o.dist);
+ }
+ }
+
+ private static final class Path implements Comparable {
+ final List nodes;
+ final long cost;
+ Path(List nodes, long cost) {
+ this.nodes = nodes;
+ this.cost = cost;
+ }
+ String key() {
+ return nodes.toString();
+ }
+ @Override
+ public int compareTo(Path o) {
+ int costCmp = Long.compare(this.cost, o.cost);
+ if (costCmp != 0) {
+ return costCmp;
+ }
+ // tie-break lexicographically on nodes
+ int minLength = Math.min(this.nodes.size(), o.nodes.size());
+ for (int i = 0; i < minLength; i++) {
+ int aNode = this.nodes.get(i);
+ int bNode = o.nodes.get(i);
+ if (aNode != bNode) {
+ return Integer.compare(aNode, bNode);
+ }
+ }
+ return Integer.compare(this.nodes.size(), o.nodes.size());
+ }
+ }
+}
diff --git a/src/main/java/com/thealgorithms/maths/AbundantNumber.java b/src/main/java/com/thealgorithms/maths/AbundantNumber.java
new file mode 100644
index 000000000000..804ac4d71477
--- /dev/null
+++ b/src/main/java/com/thealgorithms/maths/AbundantNumber.java
@@ -0,0 +1,58 @@
+package com.thealgorithms.maths;
+
+/**
+ * In number theory, an abundant number or excessive number is a positive integer for which
+ * the sum of its proper divisors is greater than the number.
+ * Equivalently, it is a number for which the sum of proper divisors (or aliquot sum) is greater than n.
+ *
+ * The integer 12 is the first abundant number. Its proper divisors are 1, 2, 3, 4 and 6 for a total of 16.
+ *
+ * Wiki: https://en.wikipedia.org/wiki/Abundant_number
+ */
+public final class AbundantNumber {
+
+ private AbundantNumber() {
+ }
+
+ // Function to calculate sum of all divisors including n
+ private static int sumOfDivisors(int n) {
+ int sum = 1 + n; // 1 and n are always divisors
+ for (int i = 2; i <= n / 2; i++) {
+ if (n % i == 0) {
+ sum += i; // adding divisor to sum
+ }
+ }
+ return sum;
+ }
+
+ // Common validation method
+ private static void validatePositiveNumber(int number) {
+ if (number <= 0) {
+ throw new IllegalArgumentException("Number must be positive.");
+ }
+ }
+
+ /**
+ * Check if {@code number} is an Abundant number or not by checking sum of divisors > 2n
+ *
+ * @param number the number
+ * @return {@code true} if {@code number} is an Abundant number, otherwise false
+ */
+ public static boolean isAbundant(int number) {
+ validatePositiveNumber(number);
+
+ return sumOfDivisors(number) > 2 * number;
+ }
+
+ /**
+ * Check if {@code number} is an Abundant number or not by checking Aliquot Sum > n
+ *
+ * @param number the number
+ * @return {@code true} if {@code number} is a Abundant number, otherwise false
+ */
+ public static boolean isAbundantNumber(int number) {
+ validatePositiveNumber(number);
+
+ return AliquotSum.getAliquotSum(number) > number;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/maths/Area.java b/src/main/java/com/thealgorithms/maths/Area.java
index 7a06fd5e5fa0..1eba6666dde3 100644
--- a/src/main/java/com/thealgorithms/maths/Area.java
+++ b/src/main/java/com/thealgorithms/maths/Area.java
@@ -48,6 +48,25 @@ public static double surfaceAreaSphere(final double radius) {
return 4 * Math.PI * radius * radius;
}
+ /**
+ * Calculate the surface area of a pyramid with a square base.
+ *
+ * @param sideLength side length of the square base
+ * @param slantHeight slant height of the pyramid
+ * @return surface area of the given pyramid
+ */
+ public static double surfaceAreaPyramid(final double sideLength, final double slantHeight) {
+ if (sideLength <= 0) {
+ throw new IllegalArgumentException("Must be a positive sideLength");
+ }
+ if (slantHeight <= 0) {
+ throw new IllegalArgumentException("Must be a positive slantHeight");
+ }
+ double baseArea = sideLength * sideLength;
+ double lateralSurfaceArea = 2 * sideLength * slantHeight;
+ return baseArea + lateralSurfaceArea;
+ }
+
/**
* Calculate the area of a rectangle.
*
@@ -77,7 +96,7 @@ public static double surfaceAreaCylinder(final double radius, final double heigh
throw new IllegalArgumentException(POSITIVE_RADIUS);
}
if (height <= 0) {
- throw new IllegalArgumentException(POSITIVE_RADIUS);
+ throw new IllegalArgumentException(POSITIVE_HEIGHT);
}
return 2 * (Math.PI * radius * radius + Math.PI * radius * height);
}
diff --git a/src/main/java/com/thealgorithms/maths/BinomialCoefficient.java b/src/main/java/com/thealgorithms/maths/BinomialCoefficient.java
index faec049b08a7..1de39adbc18a 100644
--- a/src/main/java/com/thealgorithms/maths/BinomialCoefficient.java
+++ b/src/main/java/com/thealgorithms/maths/BinomialCoefficient.java
@@ -1,8 +1,8 @@
package com.thealgorithms.maths;
/*
- * Java program for Binomial Cofficients
- * Binomial Cofficients: A binomial cofficient C(n,k) gives number ways
+ * Java program for Binomial Coefficients
+ * Binomial Coefficients: A binomial coefficient C(n,k) gives number ways
* in which k objects can be chosen from n objects.
* Wikipedia: https://en.wikipedia.org/wiki/Binomial_coefficient
*
diff --git a/src/main/java/com/thealgorithms/maths/ChebyshevIteration.java b/src/main/java/com/thealgorithms/maths/ChebyshevIteration.java
new file mode 100644
index 000000000000..bc30f1ba6e7e
--- /dev/null
+++ b/src/main/java/com/thealgorithms/maths/ChebyshevIteration.java
@@ -0,0 +1,181 @@
+package com.thealgorithms.maths;
+
+/**
+ * In numerical analysis, Chebyshev iteration is an iterative method for solving
+ * systems of linear equations Ax = b. It is designed for systems where the
+ * matrix A is symmetric positive-definite (SPD).
+ *
+ *
+ * This method is a "polynomial acceleration" method, meaning it finds the
+ * optimal polynomial to apply to the residual to accelerate convergence.
+ *
+ *
+ * It requires knowledge of the bounds of the eigenvalues of the matrix A:
+ * m(A) (smallest eigenvalue) and M(A) (largest eigenvalue).
+ *
+ *
+ * Wikipedia: https://en.wikipedia.org/wiki/Chebyshev_iteration
+ *
+ * @author Mitrajit Ghorui(KeyKyrios)
+ */
+public final class ChebyshevIteration {
+
+ private ChebyshevIteration() {
+ }
+
+ /**
+ * Solves the linear system Ax = b using the Chebyshev iteration method.
+ *
+ *
+ * NOTE: The matrix A *must* be symmetric positive-definite (SPD) for this
+ * algorithm to converge.
+ *
+ * @param a The matrix A (must be square, SPD).
+ * @param b The vector b.
+ * @param x0 The initial guess vector.
+ * @param minEigenvalue The smallest eigenvalue of A (m(A)).
+ * @param maxEigenvalue The largest eigenvalue of A (M(A)).
+ * @param maxIterations The maximum number of iterations to perform.
+ * @param tolerance The desired tolerance for the residual norm.
+ * @return The solution vector x.
+ * @throws IllegalArgumentException if matrix/vector dimensions are
+ * incompatible,
+ * if maxIterations <= 0, or if eigenvalues are invalid (e.g., minEigenvalue
+ * <= 0, maxEigenvalue <= minEigenvalue).
+ */
+ public static double[] solve(double[][] a, double[] b, double[] x0, double minEigenvalue, double maxEigenvalue, int maxIterations, double tolerance) {
+ validateInputs(a, b, x0, minEigenvalue, maxEigenvalue, maxIterations, tolerance);
+
+ int n = b.length;
+ double[] x = x0.clone();
+ double[] r = vectorSubtract(b, matrixVectorMultiply(a, x));
+ double[] p = new double[n];
+
+ double d = (maxEigenvalue + minEigenvalue) / 2.0;
+ double c = (maxEigenvalue - minEigenvalue) / 2.0;
+
+ double alpha = 0.0;
+ double alphaPrev = 0.0;
+
+ for (int k = 0; k < maxIterations; k++) {
+ double residualNorm = vectorNorm(r);
+ if (residualNorm < tolerance) {
+ return x; // Solution converged
+ }
+
+ if (k == 0) {
+ alpha = 1.0 / d;
+ System.arraycopy(r, 0, p, 0, n); // p = r
+ } else {
+ double beta = c * alphaPrev / 2.0 * (c * alphaPrev / 2.0);
+ alpha = 1.0 / (d - beta / alphaPrev);
+ double[] pUpdate = scalarMultiply(beta / alphaPrev, p);
+ p = vectorAdd(r, pUpdate); // p = r + (beta / alphaPrev) * p
+ }
+
+ double[] xUpdate = scalarMultiply(alpha, p);
+ x = vectorAdd(x, xUpdate); // x = x + alpha * p
+
+ // Recompute residual for accuracy
+ r = vectorSubtract(b, matrixVectorMultiply(a, x));
+ alphaPrev = alpha;
+ }
+
+ return x; // Return best guess after maxIterations
+ }
+
+ /**
+ * Validates the inputs for the Chebyshev solver.
+ */
+ private static void validateInputs(double[][] a, double[] b, double[] x0, double minEigenvalue, double maxEigenvalue, int maxIterations, double tolerance) {
+ int n = a.length;
+ if (n == 0) {
+ throw new IllegalArgumentException("Matrix A cannot be empty.");
+ }
+ if (n != a[0].length) {
+ throw new IllegalArgumentException("Matrix A must be square.");
+ }
+ if (n != b.length) {
+ throw new IllegalArgumentException("Matrix A and vector b dimensions do not match.");
+ }
+ if (n != x0.length) {
+ throw new IllegalArgumentException("Matrix A and vector x0 dimensions do not match.");
+ }
+ if (minEigenvalue <= 0) {
+ throw new IllegalArgumentException("Smallest eigenvalue must be positive (matrix must be positive-definite).");
+ }
+ if (maxEigenvalue <= minEigenvalue) {
+ throw new IllegalArgumentException("Max eigenvalue must be strictly greater than min eigenvalue.");
+ }
+ if (maxIterations <= 0) {
+ throw new IllegalArgumentException("Max iterations must be positive.");
+ }
+ if (tolerance <= 0) {
+ throw new IllegalArgumentException("Tolerance must be positive.");
+ }
+ }
+
+ // --- Vector/Matrix Helper Methods ---
+ /**
+ * Computes the product of a matrix A and a vector v (Av).
+ */
+ private static double[] matrixVectorMultiply(double[][] a, double[] v) {
+ int n = a.length;
+ double[] result = new double[n];
+ for (int i = 0; i < n; i++) {
+ double sum = 0;
+ for (int j = 0; j < n; j++) {
+ sum += a[i][j] * v[j];
+ }
+ result[i] = sum;
+ }
+ return result;
+ }
+
+ /**
+ * Computes the subtraction of two vectors (v1 - v2).
+ */
+ private static double[] vectorSubtract(double[] v1, double[] v2) {
+ int n = v1.length;
+ double[] result = new double[n];
+ for (int i = 0; i < n; i++) {
+ result[i] = v1[i] - v2[i];
+ }
+ return result;
+ }
+
+ /**
+ * Computes the addition of two vectors (v1 + v2).
+ */
+ private static double[] vectorAdd(double[] v1, double[] v2) {
+ int n = v1.length;
+ double[] result = new double[n];
+ for (int i = 0; i < n; i++) {
+ result[i] = v1[i] + v2[i];
+ }
+ return result;
+ }
+
+ /**
+ * Computes the product of a scalar and a vector (s * v).
+ */
+ private static double[] scalarMultiply(double scalar, double[] v) {
+ int n = v.length;
+ double[] result = new double[n];
+ for (int i = 0; i < n; i++) {
+ result[i] = scalar * v[i];
+ }
+ return result;
+ }
+
+ /**
+ * Computes the L2 norm (Euclidean norm) of a vector.
+ */
+ private static double vectorNorm(double[] v) {
+ double sumOfSquares = 0;
+ for (double val : v) {
+ sumOfSquares += val * val;
+ }
+ return Math.sqrt(sumOfSquares);
+ }
+}
diff --git a/src/main/java/com/thealgorithms/maths/EvilNumber.java b/src/main/java/com/thealgorithms/maths/EvilNumber.java
new file mode 100644
index 000000000000..419133702fd4
--- /dev/null
+++ b/src/main/java/com/thealgorithms/maths/EvilNumber.java
@@ -0,0 +1,39 @@
+package com.thealgorithms.maths;
+
+/**
+ * In number theory, an evil number is a non-negative integer that has an even number of 1s in its binary expansion.
+ * Non-negative integers that are not evil are called odious numbers.
+ *
+ * Evil Number Wiki: https://en.wikipedia.org/wiki/Evil_number
+ * Odious Number Wiki: https://en.wikipedia.org/wiki/Odious_number
+ */
+public final class EvilNumber {
+
+ private EvilNumber() {
+ }
+
+ // Function to count number of one bits in a number using bitwise operators
+ private static int countOneBits(int number) {
+ int oneBitCounter = 0;
+ while (number > 0) {
+ oneBitCounter += number & 1; // increment count if last bit is 1
+ number >>= 1; // right shift to next bit
+ }
+ return oneBitCounter;
+ }
+
+ /**
+ * Check either {@code number} is an Evil number or Odious number
+ *
+ * @param number the number
+ * @return {@code true} if {@code number} is an Evil number, otherwise false (in case of of Odious number)
+ */
+ public static boolean isEvilNumber(int number) {
+ if (number < 0) {
+ throw new IllegalArgumentException("Negative numbers are not allowed.");
+ }
+
+ int noOfOneBits = countOneBits(number);
+ return noOfOneBits % 2 == 0;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/maths/ExtendedEuclideanAlgorithm.java b/src/main/java/com/thealgorithms/maths/ExtendedEuclideanAlgorithm.java
new file mode 100644
index 000000000000..4934d4493bf2
--- /dev/null
+++ b/src/main/java/com/thealgorithms/maths/ExtendedEuclideanAlgorithm.java
@@ -0,0 +1,48 @@
+package com.thealgorithms.maths;
+
+/**
+ * In mathematics, the extended Euclidean algorithm is an extension to the
+ * Euclidean algorithm, and computes, in addition to the greatest common divisor
+ * (gcd) of integers a and b, also the coefficients of Bézout's identity, which
+ * are integers x and y such that ax + by = gcd(a, b).
+ *
+ *
+ * For more details, see
+ * https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
+ */
+public final class ExtendedEuclideanAlgorithm {
+
+ private ExtendedEuclideanAlgorithm() {
+ }
+
+ /**
+ * This method implements the extended Euclidean algorithm.
+ *
+ * @param a The first number.
+ * @param b The second number.
+ * @return An array of three integers:
+ *
+ * - Index 0: The greatest common divisor (gcd) of a and b.
+ * - Index 1: The value of x in the equation ax + by = gcd(a, b).
+ * - Index 2: The value of y in the equation ax + by = gcd(a, b).
+ *
+ */
+ public static long[] extendedGCD(long a, long b) {
+ if (b == 0) {
+ // Base case: gcd(a, 0) = a. The equation is a*1 + 0*0 = a.
+ return new long[] {a, 1, 0};
+ }
+
+ // Recursive call
+ long[] result = extendedGCD(b, a % b);
+ long gcd = result[0];
+ long x1 = result[1];
+ long y1 = result[2];
+
+ // Update coefficients using the results from the recursive call
+ long x = y1;
+ long y = x1 - a / b * y1;
+
+ return new long[] {gcd, x, y};
+ }
+}
diff --git a/src/main/java/com/thealgorithms/maths/HarshadNumber.java b/src/main/java/com/thealgorithms/maths/HarshadNumber.java
index 5792e925a8aa..abe21cb045ae 100644
--- a/src/main/java/com/thealgorithms/maths/HarshadNumber.java
+++ b/src/main/java/com/thealgorithms/maths/HarshadNumber.java
@@ -1,49 +1,78 @@
package com.thealgorithms.maths;
-// Wikipedia for Harshad Number : https://en.wikipedia.org/wiki/Harshad_number
-
+/**
+ * A Harshad number (or Niven number) in a given number base is an integer that
+ * is divisible by the sum of its digits.
+ * For example, 18 is a Harshad number because 18 is divisible by (1 + 8) = 9.
+ * The name "Harshad" comes from the Sanskrit words "harṣa" (joy) and "da"
+ * (give), meaning "joy-giver".
+ *
+ * @author Hardvan
+ * @see Harshad Number -
+ * Wikipedia
+ */
public final class HarshadNumber {
private HarshadNumber() {
}
/**
- * A function to check if a number is Harshad number or not
+ * Checks if a number is a Harshad number.
+ * A Harshad number is a positive integer that is divisible by the sum of its
+ * digits.
*
- * @param n The number to be checked
- * @return {@code true} if {@code a} is Harshad number, otherwise
+ * @param n the number to be checked (must be positive)
+ * @return {@code true} if {@code n} is a Harshad number, otherwise
* {@code false}
+ * @throws IllegalArgumentException if {@code n} is less than or equal to 0
*/
public static boolean isHarshad(long n) {
if (n <= 0) {
- return false;
+ throw new IllegalArgumentException("Input must be a positive integer. Received: " + n);
}
- long t = n;
+ long temp = n;
long sumOfDigits = 0;
- while (t > 0) {
- sumOfDigits += t % 10;
- t /= 10;
+ while (temp > 0) {
+ sumOfDigits += temp % 10;
+ temp /= 10;
}
return n % sumOfDigits == 0;
}
/**
- * A function to check if a number is Harshad number or not
+ * Checks if a number represented as a string is a Harshad number.
+ * A Harshad number is a positive integer that is divisible by the sum of its
+ * digits.
*
- * @param s The number in String to be checked
- * @return {@code true} if {@code a} is Harshad number, otherwise
+ * @param s the string representation of the number to be checked
+ * @return {@code true} if the number is a Harshad number, otherwise
* {@code false}
+ * @throws IllegalArgumentException if {@code s} is null, empty, or represents a
+ * non-positive integer
+ * @throws NumberFormatException if {@code s} cannot be parsed as a long
*/
public static boolean isHarshad(String s) {
- final Long n = Long.valueOf(s);
+ if (s == null || s.isEmpty()) {
+ throw new IllegalArgumentException("Input string cannot be null or empty");
+ }
+
+ final long n;
+ try {
+ n = Long.parseLong(s);
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException("Input string must be a valid integer: " + s, e);
+ }
+
if (n <= 0) {
- return false;
+ throw new IllegalArgumentException("Input must be a positive integer. Received: " + n);
}
int sumOfDigits = 0;
for (char ch : s.toCharArray()) {
- sumOfDigits += ch - '0';
+ if (Character.isDigit(ch)) {
+ sumOfDigits += ch - '0';
+ }
}
return n % sumOfDigits == 0;
diff --git a/src/main/java/com/thealgorithms/maths/HeronsFormula.java b/src/main/java/com/thealgorithms/maths/HeronsFormula.java
index 5baee715d1ec..10438e2888b9 100644
--- a/src/main/java/com/thealgorithms/maths/HeronsFormula.java
+++ b/src/main/java/com/thealgorithms/maths/HeronsFormula.java
@@ -1,33 +1,76 @@
package com.thealgorithms.maths;
/**
- * Wikipedia for HeronsFormula => https://en.wikipedia.org/wiki/Heron%27s_formula
- * Find the area of a triangle using only side lengths
+ * Heron's Formula implementation for calculating the area of a triangle given
+ * its three side lengths.
+ *
+ * Heron's Formula states that the area of a triangle whose sides have lengths
+ * a, b, and c is:
+ * Area = √(s(s - a)(s - b)(s - c))
+ * where s is the semi-perimeter of the triangle: s = (a + b + c) / 2
+ *
+ *
+ * @see Heron's
+ * Formula - Wikipedia
+ * @author satyabarghav
*/
-
public final class HeronsFormula {
- /*
- * A function to get the Area of a Triangle using Heron's Formula
- * @param s1,s2,s3 => the three sides of the Triangle
- * @return area using the formula (√(s(s – s1)(s – s2)(s – s3)))
- * here s is called semi-perimeter and it is the half of the perimeter (i.e; s = (s1+s2+s3)/2)
- * @author satyabarghav
+ /**
+ * Private constructor to prevent instantiation of this utility class.
*/
private HeronsFormula() {
}
+ /**
+ * Checks if all three side lengths are positive.
+ *
+ * @param a the length of the first side
+ * @param b the length of the second side
+ * @param c the length of the third side
+ * @return true if all sides are positive, false otherwise
+ */
private static boolean areAllSidesPositive(final double a, final double b, final double c) {
return a > 0 && b > 0 && c > 0;
}
+ /**
+ * Checks if the given side lengths satisfy the triangle inequality theorem.
+ *
+ * The triangle inequality theorem states that the sum of any two sides
+ * of a triangle must be greater than the third side.
+ *
+ *
+ * @param a the length of the first side
+ * @param b the length of the second side
+ * @param c the length of the third side
+ * @return true if the sides can form a valid triangle, false otherwise
+ */
private static boolean canFormTriangle(final double a, final double b, final double c) {
return a + b > c && b + c > a && c + a > b;
}
+ /**
+ * Calculates the area of a triangle using Heron's Formula.
+ *
+ * Given three side lengths a, b, and c, the area is computed as:
+ * Area = √(s(s - a)(s - b)(s - c))
+ * where s is the semi-perimeter: s = (a + b + c) / 2
+ *
+ *
+ * @param a the length of the first side (must be positive)
+ * @param b the length of the second side (must be positive)
+ * @param c the length of the third side (must be positive)
+ * @return the area of the triangle
+ * @throws IllegalArgumentException if any side length is non-positive or if the
+ * sides cannot form a valid triangle
+ */
public static double herons(final double a, final double b, final double c) {
- if (!areAllSidesPositive(a, b, c) || !canFormTriangle(a, b, c)) {
- throw new IllegalArgumentException("Triangle can't be formed with the given side lengths");
+ if (!areAllSidesPositive(a, b, c)) {
+ throw new IllegalArgumentException("All side lengths must be positive");
+ }
+ if (!canFormTriangle(a, b, c)) {
+ throw new IllegalArgumentException("Triangle cannot be formed with the given side lengths (violates triangle inequality)");
}
final double s = (a + b + c) / 2.0;
return Math.sqrt((s) * (s - a) * (s - b) * (s - c));
diff --git a/src/main/java/com/thealgorithms/maths/JugglerSequence.java b/src/main/java/com/thealgorithms/maths/JugglerSequence.java
index 702310a1f295..a459b4b6d4bb 100644
--- a/src/main/java/com/thealgorithms/maths/JugglerSequence.java
+++ b/src/main/java/com/thealgorithms/maths/JugglerSequence.java
@@ -43,7 +43,7 @@ public static void jugglerSequence(int inputNumber) {
seq.add(n + "");
}
String res = String.join(",", seq);
- System.out.println(res);
+ System.out.print(res + "\n");
}
// Driver code
diff --git a/src/main/java/com/thealgorithms/maths/KaprekarNumbers.java b/src/main/java/com/thealgorithms/maths/KaprekarNumbers.java
index eb9750f9ce08..99842e2f4f5e 100644
--- a/src/main/java/com/thealgorithms/maths/KaprekarNumbers.java
+++ b/src/main/java/com/thealgorithms/maths/KaprekarNumbers.java
@@ -4,23 +4,51 @@
import java.util.ArrayList;
import java.util.List;
+/**
+ * Utility class for identifying and working with Kaprekar Numbers.
+ *
+ * A Kaprekar number is a positive integer with the following property:
+ * If you square it, then split the resulting number into two parts (right part
+ * has same number of
+ * digits as the original number, left part has the remaining digits), and
+ * finally add the two
+ * parts together, you get the original number.
+ *
+ * For example:
+ *
+ * - 9: 9² = 81 → 8 + 1 = 9 (Kaprekar number)
+ * - 45: 45² = 2025 → 20 + 25 = 45 (Kaprekar number)
+ * - 297: 297² = 88209 → 88 + 209 = 297 (Kaprekar number)
+ *
+ *
+ * Note: The right part can have leading zeros, but must not be all zeros.
+ *
+ * @see Kaprekar Number
+ * - Wikipedia
+ * @author TheAlgorithms (https://github.com/TheAlgorithms)
+ */
public final class KaprekarNumbers {
private KaprekarNumbers() {
}
- /* This program demonstrates if a given number is Kaprekar Number or not.
- Kaprekar Number: A Kaprekar number is an n-digit number which its square can be split into
- two parts where the right part has n digits and sum of these parts is equal to the original
- number. */
-
- // Provides a list of kaprekarNumber in a range
- public static List kaprekarNumberInRange(long start, long end) throws Exception {
- long n = end - start;
- if (n < 0) {
- throw new Exception("Invalid range");
+ /**
+ * Finds all Kaprekar numbers within a given range (inclusive).
+ *
+ * @param start the starting number of the range (inclusive)
+ * @param end the ending number of the range (inclusive)
+ * @return a list of all Kaprekar numbers in the specified range
+ * @throws IllegalArgumentException if start is greater than end or if start is
+ * negative
+ */
+ public static List kaprekarNumberInRange(long start, long end) {
+ if (start > end) {
+ throw new IllegalArgumentException("Start must be less than or equal to end. Given start: " + start + ", end: " + end);
+ }
+ if (start < 0) {
+ throw new IllegalArgumentException("Start must be non-negative. Given start: " + start);
}
- ArrayList list = new ArrayList<>();
+ ArrayList list = new ArrayList<>();
for (long i = start; i <= end; i++) {
if (isKaprekarNumber(i)) {
list.add(i);
@@ -30,24 +58,60 @@ public static List kaprekarNumberInRange(long start, long end) throws Exce
return list;
}
- // Checks whether a given number is Kaprekar Number or not
+ /**
+ * Checks whether a given number is a Kaprekar number.
+ *
+ * The algorithm works as follows:
+ *
+ * - Square the number
+ * - Split the squared number into two parts: left and right
+ * - The right part has the same number of digits as the original number
+ * - Add the left and right parts
+ * - If the sum equals the original number, it's a Kaprekar number
+ *
+ *
+ * Special handling is required for numbers whose squares contain zeros.
+ *
+ * @param num the number to check
+ * @return true if the number is a Kaprekar number, false otherwise
+ * @throws IllegalArgumentException if num is negative
+ */
public static boolean isKaprekarNumber(long num) {
+ if (num < 0) {
+ throw new IllegalArgumentException("Number must be non-negative. Given: " + num);
+ }
+
+ if (num == 0 || num == 1) {
+ return true;
+ }
+
String number = Long.toString(num);
BigInteger originalNumber = BigInteger.valueOf(num);
BigInteger numberSquared = originalNumber.multiply(originalNumber);
- if (number.length() == numberSquared.toString().length()) {
- return number.equals(numberSquared.toString());
- } else {
- BigInteger leftDigits1 = BigInteger.ZERO;
- BigInteger leftDigits2;
- if (numberSquared.toString().contains("0")) {
- leftDigits1 = new BigInteger(numberSquared.toString().substring(0, numberSquared.toString().indexOf("0")));
- }
- leftDigits2 = new BigInteger(numberSquared.toString().substring(0, (numberSquared.toString().length() - number.length())));
- BigInteger rightDigits = new BigInteger(numberSquared.toString().substring(numberSquared.toString().length() - number.length()));
- String x = leftDigits1.add(rightDigits).toString();
- String y = leftDigits2.add(rightDigits).toString();
- return (number.equals(x)) || (number.equals(y));
+ String squaredStr = numberSquared.toString();
+
+ // Special case: if the squared number has the same length as the original
+ if (number.length() == squaredStr.length()) {
+ return number.equals(squaredStr);
+ }
+
+ // Calculate the split position
+ int splitPos = squaredStr.length() - number.length();
+
+ // Split the squared number into left and right parts
+ String leftPart = squaredStr.substring(0, splitPos);
+ String rightPart = squaredStr.substring(splitPos);
+
+ // Parse the parts as BigInteger (handles empty left part as zero)
+ BigInteger leftNum = leftPart.isEmpty() ? BigInteger.ZERO : new BigInteger(leftPart);
+ BigInteger rightNum = new BigInteger(rightPart);
+
+ // Check if right part is all zeros (invalid for Kaprekar numbers except 1)
+ if (rightNum.equals(BigInteger.ZERO)) {
+ return false;
}
+
+ // Check if the sum equals the original number
+ return leftNum.add(rightNum).equals(originalNumber);
}
}
diff --git a/src/main/java/com/thealgorithms/maths/KeithNumber.java b/src/main/java/com/thealgorithms/maths/KeithNumber.java
index 1756cfbae91b..eb7f800d378f 100644
--- a/src/main/java/com/thealgorithms/maths/KeithNumber.java
+++ b/src/main/java/com/thealgorithms/maths/KeithNumber.java
@@ -4,57 +4,98 @@
import java.util.Collections;
import java.util.Scanner;
-final class KeithNumber {
+/**
+ * A Keith number is an n-digit positive integer where the sequence formed by
+ * starting with its digits and repeatedly adding the previous n terms,
+ * eventually reaches the number itself.
+ *
+ *
+ * For example:
+ *
+ * - 14 is a Keith number: 1, 4, 5, 9, 14
+ * - 19 is a Keith number: 1, 9, 10, 19
+ * - 28 is a Keith number: 2, 8, 10, 18, 28
+ * - 197 is a Keith number: 1, 9, 7, 17, 33, 57, 107, 197
+ *
+ *
+ * @see Keith Number -
+ * Wikipedia
+ * @see Keith Number -
+ * MathWorld
+ */
+public final class KeithNumber {
private KeithNumber() {
}
- // user-defined function that checks if the given number is Keith or not
- static boolean isKeith(int x) {
- // List stores all the digits of the X
+ /**
+ * Checks if a given number is a Keith number.
+ *
+ *
+ * The algorithm works as follows:
+ *
+ * - Extract all digits of the number and store them in a list
+ * - Generate subsequent terms by summing the last n digits
+ * - Continue until a term equals or exceeds the original number
+ * - If a term equals the number, it is a Keith number
+ *
+ *
+ * @param number the number to check (must be positive)
+ * @return {@code true} if the number is a Keith number, {@code false} otherwise
+ * @throws IllegalArgumentException if the number is not positive
+ */
+ public static boolean isKeith(int number) {
+ if (number <= 0) {
+ throw new IllegalArgumentException("Number must be positive");
+ }
+
+ // Extract digits and store them in the list
ArrayList terms = new ArrayList<>();
- // n denotes the number of digits
- int temp = x;
- int n = 0;
- // executes until the condition becomes false
+ int temp = number;
+ int digitCount = 0;
+
while (temp > 0) {
- // determines the last digit of the number and add it to the List
terms.add(temp % 10);
- // removes the last digit
temp = temp / 10;
- // increments the number of digits (n) by 1
- n++;
+ digitCount++;
}
- // reverse the List
+
+ // Reverse the list to get digits in correct order
Collections.reverse(terms);
+
+ // Generate subsequent terms in the sequence
int nextTerm = 0;
- int i = n;
- // finds next term for the series
- // loop executes until the condition returns true
- while (nextTerm < x) {
+ int currentIndex = digitCount;
+
+ while (nextTerm < number) {
nextTerm = 0;
- // next term is the sum of previous n terms (it depends on number of digits the number
- // has)
- for (int j = 1; j <= n; j++) {
- nextTerm = nextTerm + terms.get(i - j);
+ // Sum the last 'digitCount' terms
+ for (int j = 1; j <= digitCount; j++) {
+ nextTerm = nextTerm + terms.get(currentIndex - j);
}
terms.add(nextTerm);
- i++;
+ currentIndex++;
}
- // when the control comes out of the while loop, there will be two conditions:
- // either nextTerm will be equal to x or greater than x
- // if equal, the given number is Keith, else not
- return (nextTerm == x);
+
+ // Check if the generated term equals the original number
+ return (nextTerm == number);
}
- // driver code
+ /**
+ * Main method for demonstrating Keith number detection.
+ * Reads a number from standard input and checks if it is a Keith number.
+ *
+ * @param args command line arguments (not used)
+ */
public static void main(String[] args) {
- Scanner in = new Scanner(System.in);
- int n = in.nextInt();
- if (isKeith(n)) {
- System.out.println("Yes, the given number is a Keith number.");
+ Scanner scanner = new Scanner(System.in);
+ System.out.print("Enter a positive integer: ");
+ int number = scanner.nextInt();
+
+ if (isKeith(number)) {
+ System.out.println("Yes, " + number + " is a Keith number.");
} else {
- System.out.println("No, the given number is not a Keith number.");
+ System.out.println("No, " + number + " is not a Keith number.");
}
- in.close();
+ scanner.close();
}
}
diff --git a/src/main/java/com/thealgorithms/maths/KrishnamurthyNumber.java b/src/main/java/com/thealgorithms/maths/KrishnamurthyNumber.java
index 03f18aca786f..a00ef7e3b15d 100644
--- a/src/main/java/com/thealgorithms/maths/KrishnamurthyNumber.java
+++ b/src/main/java/com/thealgorithms/maths/KrishnamurthyNumber.java
@@ -3,10 +3,25 @@
/**
* Utility class for checking if a number is a Krishnamurthy number.
*
- * A Krishnamurthy number (also known as a Strong number) is a number whose sum of the factorials of its digits is equal to the number itself.
+ *
+ * A Krishnamurthy number (also known as a Strong number or Factorion) is a
+ * number
+ * whose sum of the factorials of its digits is equal to the number itself.
+ *
*
- * For example, 145 is a Krishnamurthy number because 1! + 4! + 5! = 1 + 24 + 120 = 145.
+ *
+ * For example, 145 is a Krishnamurthy number because 1! + 4! + 5! = 1 + 24 +
+ * 120 = 145.
+ *
+ *
+ *
+ * The only Krishnamurthy numbers in base 10 are: 1, 2, 145, and 40585.
+ *
+ *
+ *
* Example usage:
+ *
+ *
*
* boolean isKrishnamurthy = KrishnamurthyNumber.isKrishnamurthy(145);
* System.out.println(isKrishnamurthy); // Output: true
@@ -14,40 +29,43 @@
* isKrishnamurthy = KrishnamurthyNumber.isKrishnamurthy(123);
* System.out.println(isKrishnamurthy); // Output: false
*
+ *
+ * @see Factorion
+ * (Wikipedia)
*/
public final class KrishnamurthyNumber {
+ // Pre-computed factorials for digits 0-9 to improve performance
+ private static final int[] FACTORIALS = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
+
private KrishnamurthyNumber() {
}
/**
* Checks if a number is a Krishnamurthy number.
*
- * @param n The number to check
+ *
+ * A number is a Krishnamurthy number if the sum of the factorials of its digits
+ * equals the number itself.
+ *
+ *
+ * @param n the number to check
* @return true if the number is a Krishnamurthy number, false otherwise
*/
public static boolean isKrishnamurthy(int n) {
- int tmp = n;
- int s = 0;
-
if (n <= 0) {
return false;
- } else {
- while (n != 0) {
- // initialising the variable fact that will store the factorials of the digits
- int fact = 1;
- // computing factorial of each digit
- for (int i = 1; i <= n % 10; i++) {
- fact = fact * i;
- }
- // computing the sum of the factorials
- s = s + fact;
- // discarding the digit for which factorial has been calculated
- n = n / 10;
- }
+ }
- // evaluating if sum of the factorials of the digits equals the number itself
- return tmp == s;
+ int original = n;
+ int sum = 0;
+
+ while (n != 0) {
+ int digit = n % 10;
+ sum = sum + FACTORIALS[digit];
+ n = n / 10;
}
+
+ return sum == original;
}
}
diff --git a/src/main/java/com/thealgorithms/maths/LeonardoNumber.java b/src/main/java/com/thealgorithms/maths/LeonardoNumber.java
index bbeec052777f..9ac3691a6285 100644
--- a/src/main/java/com/thealgorithms/maths/LeonardoNumber.java
+++ b/src/main/java/com/thealgorithms/maths/LeonardoNumber.java
@@ -1,25 +1,79 @@
package com.thealgorithms.maths;
/**
- * https://en.wikipedia.org/wiki/Leonardo_number
+ * Utility class for calculating Leonardo Numbers.
+ *
+ * Leonardo numbers are a sequence of numbers defined by the recurrence:
+ * L(n) = L(n-1) + L(n-2) + 1, with L(0) = 1 and L(1) = 1
+ *
+ * The sequence begins: 1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, ...
+ *
+ * This class provides both a recursive implementation and an optimized
+ * iterative
+ * implementation for calculating Leonardo numbers.
+ *
+ * @see Leonardo Number
+ * - Wikipedia
+ * @see OEIS A001595
*/
public final class LeonardoNumber {
private LeonardoNumber() {
}
/**
- * Calculate nth Leonardo Number (1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, ...)
+ * Calculates the nth Leonardo Number using recursion.
+ *
+ * Time Complexity: O(2^n) - exponential due to repeated calculations
+ * Space Complexity: O(n) - due to recursion stack
+ *
+ * Note: This method is not recommended for large values of n due to exponential
+ * time complexity.
+ * Consider using {@link #leonardoNumberIterative(int)} for better performance.
*
- * @param n the index of Leonardo Number to calculate
- * @return nth number of Leonardo sequences
+ * @param n the index of the Leonardo Number to calculate (must be non-negative)
+ * @return the nth Leonardo Number
+ * @throws IllegalArgumentException if n is negative
*/
public static int leonardoNumber(int n) {
if (n < 0) {
- throw new ArithmeticException();
+ throw new IllegalArgumentException("Input must be non-negative. Received: " + n);
}
if (n == 0 || n == 1) {
return 1;
}
- return (leonardoNumber(n - 1) + leonardoNumber(n - 2) + 1);
+ return leonardoNumber(n - 1) + leonardoNumber(n - 2) + 1;
+ }
+
+ /**
+ * Calculates the nth Leonardo Number using an iterative approach.
+ *
+ * This method provides better performance than the recursive version for large
+ * values of n.
+ *
+ * Time Complexity: O(n)
+ * Space Complexity: O(1)
+ *
+ * @param n the index of the Leonardo Number to calculate (must be non-negative)
+ * @return the nth Leonardo Number
+ * @throws IllegalArgumentException if n is negative
+ */
+ public static int leonardoNumberIterative(int n) {
+ if (n < 0) {
+ throw new IllegalArgumentException("Input must be non-negative. Received: " + n);
+ }
+ if (n == 0 || n == 1) {
+ return 1;
+ }
+
+ int previous = 1;
+ int current = 1;
+
+ for (int i = 2; i <= n; i++) {
+ int next = current + previous + 1;
+ previous = current;
+ current = next;
+ }
+
+ return current;
}
}
diff --git a/src/main/java/com/thealgorithms/maths/LinearDiophantineEquationsSolver.java b/src/main/java/com/thealgorithms/maths/LinearDiophantineEquationsSolver.java
index a50cfb218283..a95e7053e210 100644
--- a/src/main/java/com/thealgorithms/maths/LinearDiophantineEquationsSolver.java
+++ b/src/main/java/com/thealgorithms/maths/LinearDiophantineEquationsSolver.java
@@ -2,20 +2,77 @@
import java.util.Objects;
+/**
+ * A solver for linear Diophantine equations of the form ax + by = c.
+ *
+ * A linear Diophantine equation is an equation in which only integer solutions
+ * are allowed.
+ * This solver uses the Extended Euclidean Algorithm to find integer solutions
+ * (x, y)
+ * for equations of the form ax + by = c, where a, b, and c are integers.
+ *
+ *
+ * The equation has solutions if and only if gcd(a, b) divides c.
+ * If solutions exist, this solver finds one particular solution.
+ *
+ *
+ * @see Diophantine
+ * Equation
+ * @see Extended
+ * Euclidean Algorithm
+ */
public final class LinearDiophantineEquationsSolver {
private LinearDiophantineEquationsSolver() {
}
+ /**
+ * Demonstrates the solver with a sample equation: 3x + 4y = 7.
+ *
+ * @param args command line arguments (not used)
+ */
public static void main(String[] args) {
// 3x + 4y = 7
final var toSolve = new Equation(3, 4, 7);
System.out.println(findAnySolution(toSolve));
}
+ /**
+ * Finds any integer solution to the linear Diophantine equation ax + by = c.
+ *
+ * The method returns one of three types of solutions:
+ *
+ * - A specific solution (x, y) if solutions exist
+ * - {@link Solution#NO_SOLUTION} if no integer solutions exist
+ * - {@link Solution#INFINITE_SOLUTIONS} if the equation is 0x + 0y = 0
+ *
+ *
+ *
+ * @param equation the linear Diophantine equation to solve
+ * @return a Solution object containing the result
+ * @throws NullPointerException if equation is null
+ */
public static Solution findAnySolution(final Equation equation) {
if (equation.a() == 0 && equation.b() == 0 && equation.c() == 0) {
return Solution.INFINITE_SOLUTIONS;
}
+ if (equation.a() == 0 && equation.b() == 0) {
+ return Solution.NO_SOLUTION;
+ }
+ if (equation.a() == 0) {
+ if (equation.c() % equation.b() == 0) {
+ return new Solution(0, equation.c() / equation.b());
+ } else {
+ return Solution.NO_SOLUTION;
+ }
+ }
+ if (equation.b() == 0) {
+ if (equation.c() % equation.a() == 0) {
+ return new Solution(equation.c() / equation.a(), 0);
+ } else {
+ return Solution.NO_SOLUTION;
+ }
+ }
final var stub = new GcdSolutionWrapper(0, new Solution(0, 0));
final var gcdSolution = gcd(equation.a(), equation.b(), stub);
if (equation.c() % gcdSolution.getGcd() != 0) {
@@ -29,43 +86,100 @@ public static Solution findAnySolution(final Equation equation) {
return toReturn;
}
+ /**
+ * Computes the GCD of two integers using the Extended Euclidean Algorithm.
+ *
+ * This method also finds coefficients x and y such that ax + by = gcd(a, b).
+ * The coefficients are stored in the 'previous' wrapper object.
+ *
+ *
+ * @param a the first integer
+ * @param b the second integer
+ * @param previous a wrapper to store the solution coefficients
+ * @return a GcdSolutionWrapper containing the GCD and coefficients
+ */
private static GcdSolutionWrapper gcd(final int a, final int b, final GcdSolutionWrapper previous) {
if (b == 0) {
return new GcdSolutionWrapper(a, new Solution(1, 0));
}
// stub wrapper becomes the `previous` of the next recursive call
final var stubWrapper = new GcdSolutionWrapper(0, new Solution(0, 0));
- final var next = /* recursive call */ gcd(b, a % b, stubWrapper);
+ final var next = gcd(b, a % b, stubWrapper);
previous.getSolution().setX(next.getSolution().getY());
previous.getSolution().setY(next.getSolution().getX() - (a / b) * (next.getSolution().getY()));
previous.setGcd(next.getGcd());
return new GcdSolutionWrapper(next.getGcd(), previous.getSolution());
}
+ /**
+ * Represents a solution (x, y) to a linear Diophantine equation.
+ *
+ * Special instances:
+ *
+ * - {@link #NO_SOLUTION} - indicates no integer solutions exist
+ * - {@link #INFINITE_SOLUTIONS} - indicates infinitely many solutions
+ * exist
+ *
+ *
+ */
public static final class Solution {
+ /**
+ * Singleton instance representing the case where no solution exists.
+ */
public static final Solution NO_SOLUTION = new Solution(Integer.MAX_VALUE, Integer.MAX_VALUE);
+
+ /**
+ * Singleton instance representing the case where infinite solutions exist.
+ */
public static final Solution INFINITE_SOLUTIONS = new Solution(Integer.MIN_VALUE, Integer.MIN_VALUE);
+
private int x;
private int y;
+ /**
+ * Constructs a solution with the given x and y values.
+ *
+ * @param x the x coordinate of the solution
+ * @param y the y coordinate of the solution
+ */
public Solution(int x, int y) {
this.x = x;
this.y = y;
}
+ /**
+ * Gets the x value of this solution.
+ *
+ * @return the x value
+ */
public int getX() {
return x;
}
+ /**
+ * Gets the y value of this solution.
+ *
+ * @return the y value
+ */
public int getY() {
return y;
}
+ /**
+ * Sets the x value of this solution.
+ *
+ * @param x the new x value
+ */
public void setX(int x) {
this.x = x;
}
+ /**
+ * Sets the y value of this solution.
+ *
+ * @param y the new y value
+ */
public void setY(int y) {
this.y = y;
}
@@ -95,14 +209,35 @@ public String toString() {
}
}
+ /**
+ * Represents a linear Diophantine equation of the form ax + by = c.
+ *
+ * @param a the coefficient of x
+ * @param b the coefficient of y
+ * @param c the constant term
+ */
public record Equation(int a, int b, int c) {
}
+ /**
+ * A wrapper class that holds both the GCD and the solution coefficients
+ * from the Extended Euclidean Algorithm.
+ *
+ * This class is used internally to pass results between recursive calls
+ * of the GCD computation.
+ *
+ */
public static final class GcdSolutionWrapper {
private int gcd;
private Solution solution;
+ /**
+ * Constructs a GcdSolutionWrapper with the given GCD and solution.
+ *
+ * @param gcd the greatest common divisor
+ * @param solution the solution coefficients
+ */
public GcdSolutionWrapper(int gcd, Solution solution) {
this.gcd = gcd;
this.solution = solution;
@@ -120,18 +255,38 @@ public boolean equals(Object obj) {
return (this.gcd == that.gcd && Objects.equals(this.solution, that.solution));
}
+ /**
+ * Gets the GCD value.
+ *
+ * @return the GCD
+ */
public int getGcd() {
return gcd;
}
+ /**
+ * Sets the GCD value.
+ *
+ * @param gcd the new GCD value
+ */
public void setGcd(int gcd) {
this.gcd = gcd;
}
+ /**
+ * Gets the solution coefficients.
+ *
+ * @return the solution
+ */
public Solution getSolution() {
return solution;
}
+ /**
+ * Sets the solution coefficients.
+ *
+ * @param solution the new solution
+ */
public void setSolution(Solution solution) {
this.solution = solution;
}
diff --git a/src/main/java/com/thealgorithms/maths/LucasSeries.java b/src/main/java/com/thealgorithms/maths/LucasSeries.java
index e277c511f317..90a35f0d6259 100644
--- a/src/main/java/com/thealgorithms/maths/LucasSeries.java
+++ b/src/main/java/com/thealgorithms/maths/LucasSeries.java
@@ -1,38 +1,69 @@
package com.thealgorithms.maths;
/**
- * https://en.wikipedia.org/wiki/Lucas_number
+ * Utility class for calculating Lucas numbers.
+ * The Lucas sequence is similar to the Fibonacci sequence but starts with 2 and
+ * 1.
+ * The sequence follows: L(n) = L(n-1) + L(n-2)
+ * Starting values: L(1) = 2, L(2) = 1
+ * Sequence: 2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, ...
+ *
+ * @see Lucas Number
+ * @author TheAlgorithms Contributors
*/
public final class LucasSeries {
private LucasSeries() {
}
/**
- * Calculate nth number of Lucas Series(2, 1, 3, 4, 7, 11, 18, 29, 47, 76,
- * 123, ....) using recursion
+ * Calculate the nth Lucas number using recursion.
+ * Time Complexity: O(2^n) - exponential due to recursive calls
+ * Space Complexity: O(n) - recursion depth
*
- * @param n nth
- * @return nth number of Lucas Series
+ * @param n the position in the Lucas sequence (1-indexed, must be positive)
+ * @return the nth Lucas number
+ * @throws IllegalArgumentException if n is less than 1
*/
public static int lucasSeries(int n) {
- return n == 1 ? 2 : n == 2 ? 1 : lucasSeries(n - 1) + lucasSeries(n - 2);
+ if (n < 1) {
+ throw new IllegalArgumentException("Input must be a positive integer. Provided: " + n);
+ }
+ if (n == 1) {
+ return 2;
+ }
+ if (n == 2) {
+ return 1;
+ }
+ return lucasSeries(n - 1) + lucasSeries(n - 2);
}
/**
- * Calculate nth number of Lucas Series(2, 1, 3, 4, 7, 11, 18, 29, 47, 76,
- * 123, ....) using iteration
+ * Calculate the nth Lucas number using iteration.
+ * Time Complexity: O(n) - single loop through n iterations
+ * Space Complexity: O(1) - constant space usage
*
- * @param n nth
- * @return nth number of lucas series
+ * @param n the position in the Lucas sequence (1-indexed, must be positive)
+ * @return the nth Lucas number
+ * @throws IllegalArgumentException if n is less than 1
*/
public static int lucasSeriesIteration(int n) {
+ if (n < 1) {
+ throw new IllegalArgumentException("Input must be a positive integer. Provided: " + n);
+ }
+ if (n == 1) {
+ return 2;
+ }
+ if (n == 2) {
+ return 1;
+ }
+
int previous = 2;
int current = 1;
- for (int i = 1; i < n; i++) {
+ for (int i = 2; i < n; i++) {
int next = previous + current;
previous = current;
current = next;
}
- return previous;
+ return current;
}
}
diff --git a/src/main/java/com/thealgorithms/maths/LuckyNumber.java b/src/main/java/com/thealgorithms/maths/LuckyNumber.java
new file mode 100644
index 000000000000..70308e1e0edd
--- /dev/null
+++ b/src/main/java/com/thealgorithms/maths/LuckyNumber.java
@@ -0,0 +1,78 @@
+package com.thealgorithms.maths;
+
+/**
+ * In number theory, a lucky number is a natural number in a set which is generated by a certain "sieve".
+ * This sieve is similar to the sieve of Eratosthenes that generates the primes,
+ * but it eliminates numbers based on their position in the remaining set,
+ * instead of their value (or position in the initial set of natural numbers).
+ *
+ * Wiki: https://en.wikipedia.org/wiki/Lucky_number
+ */
+public final class LuckyNumber {
+
+ private LuckyNumber() {
+ }
+
+ // Common validation method
+ private static void validatePositiveNumber(int number) {
+ if (number <= 0) {
+ throw new IllegalArgumentException("Number must be positive.");
+ }
+ }
+
+ // Function to check recursively for Lucky Number
+ private static boolean isLuckyRecursiveApproach(int n, int counter) {
+ // Base case: If counter exceeds n, number is lucky
+ if (counter > n) {
+ return true;
+ }
+
+ // If number is eliminated in this step, it's not lucky
+ if (n % counter == 0) {
+ return false;
+ }
+
+ // Calculate new position after removing every counter-th number
+ int newNumber = n - (n / counter);
+
+ // Recursive call for next round
+ return isLuckyRecursiveApproach(newNumber, counter + 1);
+ }
+
+ /**
+ * Check if {@code number} is a Lucky number or not using recursive approach
+ *
+ * @param number the number
+ * @return {@code true} if {@code number} is a Lucky number, otherwise false
+ */
+ public static boolean isLuckyNumber(int number) {
+ validatePositiveNumber(number);
+ int counterStarting = 2;
+ return isLuckyRecursiveApproach(number, counterStarting);
+ }
+
+ /**
+ * Check if {@code number} is a Lucky number or not using iterative approach
+ *
+ * @param number the number
+ * @return {@code true} if {@code number} is a Lucky number, otherwise false
+ */
+ public static boolean isLucky(int number) {
+ validatePositiveNumber(number);
+
+ int counter = 2; // Position starts from 2 (since first elimination happens at 2)
+ int position = number; // The position of the number in the sequence
+
+ while (counter <= position) {
+ if (position % counter == 0) {
+ return false;
+ } // Number is eliminated
+
+ // Update the position of n after removing every counter-th number
+ position = position - (position / counter);
+ counter++;
+ }
+
+ return true; // Survives all eliminations → Lucky Number
+ }
+}
diff --git a/src/main/java/com/thealgorithms/maths/Means.java b/src/main/java/com/thealgorithms/maths/Means.java
index dccc820b172e..5445a3caebc7 100644
--- a/src/main/java/com/thealgorithms/maths/Means.java
+++ b/src/main/java/com/thealgorithms/maths/Means.java
@@ -4,9 +4,27 @@
import org.apache.commons.collections4.IterableUtils;
/**
- * https://en.wikipedia.org/wiki/Mean
+ * Utility class for computing various types of statistical means.
*
- * by: Punit Patel
+ * This class provides static methods to calculate different types of means
+ * (averages)
+ * from a collection of numbers. All methods accept any {@link Iterable}
+ * collection of
+ * {@link Double} values and return the computed mean as a {@link Double}.
+ *
+ *
+ *
+ * Supported means:
+ *
+ * - Arithmetic Mean: The sum of all values divided by the count
+ * - Geometric Mean: The nth root of the product of n values
+ * - Harmonic Mean: The reciprocal of the arithmetic mean of
+ * reciprocals
+ *
+ *
+ *
+ * @see Mean (Wikipedia)
+ * @author Punit Patel
*/
public final class Means {
@@ -14,41 +32,90 @@ private Means() {
}
/**
- * @brief computes the [Arithmetic Mean](https://en.wikipedia.org/wiki/Arithmetic_mean) of the input
- * @param numbers the input numbers
- * @throws IllegalArgumentException empty input
+ * Computes the arithmetic mean (average) of the given numbers.
+ *
+ * The arithmetic mean is calculated as: (x₁ + x₂ + ... + xₙ) / n
+ *
+ *
+ * Example: For numbers [2, 4, 6], the arithmetic mean is (2+4+6)/3 = 4.0
+ *
+ *
+ * @param numbers the input numbers (must not be empty)
* @return the arithmetic mean of the input numbers
+ * @throws IllegalArgumentException if the input is empty
+ * @see Arithmetic
+ * Mean
*/
public static Double arithmetic(final Iterable numbers) {
checkIfNotEmpty(numbers);
- return StreamSupport.stream(numbers.spliterator(), false).reduce((x, y) -> x + y).get() / IterableUtils.size(numbers);
+ double sum = StreamSupport.stream(numbers.spliterator(), false).reduce(0d, (x, y) -> x + y);
+ int size = IterableUtils.size(numbers);
+ return sum / size;
}
/**
- * @brief computes the [Geometric Mean](https://en.wikipedia.org/wiki/Geometric_mean) of the input
- * @param numbers the input numbers
- * @throws IllegalArgumentException empty input
+ * Computes the geometric mean of the given numbers.
+ *
+ * The geometric mean is calculated as: ⁿ√(x₁ × x₂ × ... × xₙ)
+ *
+ *
+ * Example: For numbers [2, 8], the geometric mean is √(2×8) = √16 = 4.0
+ *
+ *
+ * Note: This method may produce unexpected results for negative numbers,
+ * as it computes the real-valued nth root which may not exist for negative
+ * products.
+ *
+ *
+ * @param numbers the input numbers (must not be empty)
* @return the geometric mean of the input numbers
+ * @throws IllegalArgumentException if the input is empty
+ * @see Geometric
+ * Mean
*/
public static Double geometric(final Iterable numbers) {
checkIfNotEmpty(numbers);
- return Math.pow(StreamSupport.stream(numbers.spliterator(), false).reduce((x, y) -> x * y).get(), 1d / IterableUtils.size(numbers));
+ double product = StreamSupport.stream(numbers.spliterator(), false).reduce(1d, (x, y) -> x * y);
+ int size = IterableUtils.size(numbers);
+ return Math.pow(product, 1.0 / size);
}
/**
- * @brief computes the [Harmonic Mean](https://en.wikipedia.org/wiki/Harmonic_mean) of the input
- * @param numbers the input numbers
- * @throws IllegalArgumentException empty input
+ * Computes the harmonic mean of the given numbers.
+ *
+ * The harmonic mean is calculated as: n / (1/x₁ + 1/x₂ + ... + 1/xₙ)
+ *
+ *
+ * Example: For numbers [1, 2, 4], the harmonic mean is 3/(1/1 + 1/2 + 1/4) =
+ * 3/1.75 ≈ 1.714
+ *
+ *
+ * Note: This method will produce unexpected results if any input number is
+ * zero,
+ * as it involves computing reciprocals.
+ *
+ *
+ * @param numbers the input numbers (must not be empty)
* @return the harmonic mean of the input numbers
+ * @throws IllegalArgumentException if the input is empty
+ * @see Harmonic Mean
*/
public static Double harmonic(final Iterable numbers) {
checkIfNotEmpty(numbers);
- return IterableUtils.size(numbers) / StreamSupport.stream(numbers.spliterator(), false).reduce(0d, (x, y) -> x + 1d / y);
+ double sumOfReciprocals = StreamSupport.stream(numbers.spliterator(), false).reduce(0d, (x, y) -> x + 1d / y);
+ int size = IterableUtils.size(numbers);
+ return size / sumOfReciprocals;
}
+ /**
+ * Validates that the input iterable is not empty.
+ *
+ * @param numbers the input numbers to validate
+ * @throws IllegalArgumentException if the input is empty
+ */
private static void checkIfNotEmpty(final Iterable numbers) {
if (!numbers.iterator().hasNext()) {
- throw new IllegalArgumentException("Emtpy list given for Mean computation.");
+ throw new IllegalArgumentException("Empty list given for Mean computation.");
}
}
}
diff --git a/src/main/java/com/thealgorithms/maths/Median.java b/src/main/java/com/thealgorithms/maths/Median.java
index fd2aab84e4e9..5e1a4bc3a8d9 100644
--- a/src/main/java/com/thealgorithms/maths/Median.java
+++ b/src/main/java/com/thealgorithms/maths/Median.java
@@ -3,17 +3,35 @@
import java.util.Arrays;
/**
- * Wikipedia: https://en.wikipedia.org/wiki/Median
+ * Utility class for calculating the median of an array of integers.
+ * The median is the middle value in a sorted list of numbers. If the list has
+ * an even number
+ * of elements, the median is the average of the two middle values.
+ *
+ *
+ * Time Complexity: O(n log n) due to sorting
+ *
+ * Space Complexity: O(1) if sorting is done in-place
+ *
+ * @see Median (Wikipedia)
+ * @see Mean,
+ * Median, and Mode Review
*/
public final class Median {
private Median() {
}
/**
- * Calculate average median
- * @param values sorted numbers to find median of
- * @return median of given {@code values}
- * @throws IllegalArgumentException If the input array is empty or null.
+ * Calculates the median of an array of integers.
+ * The array is sorted internally, so the original order is not preserved.
+ * For arrays with an odd number of elements, returns the middle element.
+ * For arrays with an even number of elements, returns the average of the two
+ * middle elements.
+ *
+ * @param values the array of integers to find the median of (can be unsorted)
+ * @return the median value as a double
+ * @throws IllegalArgumentException if the input array is empty or null
*/
public static double median(int[] values) {
if (values == null || values.length == 0) {
@@ -22,6 +40,10 @@ public static double median(int[] values) {
Arrays.sort(values);
int length = values.length;
- return length % 2 == 0 ? (values[length / 2] + values[length / 2 - 1]) / 2.0 : values[length / 2];
+ if (length % 2 == 0) {
+ return (values[length / 2] + values[length / 2 - 1]) / 2.0;
+ } else {
+ return values[length / 2];
+ }
}
}
diff --git a/src/main/java/com/thealgorithms/maths/Neville.java b/src/main/java/com/thealgorithms/maths/Neville.java
new file mode 100644
index 000000000000..ca45f2e8a042
--- /dev/null
+++ b/src/main/java/com/thealgorithms/maths/Neville.java
@@ -0,0 +1,61 @@
+package com.thealgorithms.maths;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * In numerical analysis, Neville's algorithm is an algorithm used for
+ * polynomial interpolation. Given n+1 points, there is a unique polynomial of
+ * degree at most n that passes through all the points. Neville's algorithm
+ * computes the value of this polynomial at a given point.
+ *
+ *
+ * Wikipedia: https://en.wikipedia.org/wiki/Neville%27s_algorithm
+ *
+ * @author Mitrajit Ghorui(KeyKyrios)
+ */
+public final class Neville {
+
+ private Neville() {
+ }
+
+ /**
+ * Evaluates the polynomial that passes through the given points at a
+ * specific x-coordinate.
+ *
+ * @param x The x-coordinates of the points. Must be the same length as y.
+ * @param y The y-coordinates of the points. Must be the same length as x.
+ * @param target The x-coordinate at which to evaluate the polynomial.
+ * @return The interpolated y-value at the target x-coordinate.
+ * @throws IllegalArgumentException if the lengths of x and y arrays are
+ * different, if the arrays are empty, or if x-coordinates are not unique.
+ */
+ public static double interpolate(double[] x, double[] y, double target) {
+ if (x.length != y.length) {
+ throw new IllegalArgumentException("x and y arrays must have the same length.");
+ }
+ if (x.length == 0) {
+ throw new IllegalArgumentException("Input arrays cannot be empty.");
+ }
+
+ // Check for duplicate x-coordinates to prevent division by zero
+ Set seenX = new HashSet<>();
+ for (double val : x) {
+ if (!seenX.add(val)) {
+ throw new IllegalArgumentException("Input x-coordinates must be unique.");
+ }
+ }
+
+ int n = x.length;
+ double[] p = new double[n];
+ System.arraycopy(y, 0, p, 0, n); // Initialize p with y values
+
+ for (int k = 1; k < n; k++) {
+ for (int i = 0; i < n - k; i++) {
+ p[i] = ((target - x[i + k]) * p[i] + (x[i] - target) * p[i + 1]) / (x[i] - x[i + k]);
+ }
+ }
+
+ return p[0];
+ }
+}
diff --git a/src/main/java/com/thealgorithms/maths/Perimeter.java b/src/main/java/com/thealgorithms/maths/Perimeter.java
index f8aa1876d388..670851eb346b 100644
--- a/src/main/java/com/thealgorithms/maths/Perimeter.java
+++ b/src/main/java/com/thealgorithms/maths/Perimeter.java
@@ -27,7 +27,7 @@ public static float perimeterRegularPolygon(int n, float side) {
* @param side2 for length of side 2
* @param side3 for length of side 3
* @param sides for length of remaining sides
- * @return Perimeter of given trapezoid.
+ * @return Perimeter of given irregular polygon.
*/
public static float perimeterIrregularPolygon(float side1, float side2, float side3, float... sides) {
float perimeter = side1 + side2 + side3;
diff --git a/src/main/java/com/thealgorithms/maths/PowerOfFour.java b/src/main/java/com/thealgorithms/maths/PowerOfFour.java
new file mode 100644
index 000000000000..e5fe6255821b
--- /dev/null
+++ b/src/main/java/com/thealgorithms/maths/PowerOfFour.java
@@ -0,0 +1,36 @@
+package com.thealgorithms.maths;
+
+/**
+ * Utility class for checking if a number is a power of four.
+ * A power of four is a number that can be expressed as 4^n where n is a non-negative integer.
+ * This class provides a method to determine if a given integer is a power of four using bit manipulation.
+ *
+ * @author krishna-medapati (https://github.com/krishna-medapati)
+ */
+public final class PowerOfFour {
+ private PowerOfFour() {
+ }
+
+ /**
+ * Checks if the given integer is a power of four.
+ *
+ * A number is considered a power of four if:
+ * 1. It is greater than zero
+ * 2. It has exactly one '1' bit in its binary representation (power of two)
+ * 3. The '1' bit is at an even position (0, 2, 4, 6, ...)
+ *
+ * The method uses the mask 0x55555555 (binary: 01010101010101010101010101010101)
+ * to check if the set bit is at an even position.
+ *
+ * @param number the integer to check
+ * @return true if the number is a power of four, false otherwise
+ */
+ public static boolean isPowerOfFour(int number) {
+ if (number <= 0) {
+ return false;
+ }
+ boolean isPowerOfTwo = (number & (number - 1)) == 0;
+ boolean hasEvenBitPosition = (number & 0x55555555) != 0;
+ return isPowerOfTwo && hasEvenBitPosition;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/maths/SieveOfAtkin.java b/src/main/java/com/thealgorithms/maths/SieveOfAtkin.java
index ee59d0784ec4..780dd81dac7c 100644
--- a/src/main/java/com/thealgorithms/maths/SieveOfAtkin.java
+++ b/src/main/java/com/thealgorithms/maths/SieveOfAtkin.java
@@ -14,7 +14,7 @@
public final class SieveOfAtkin {
private SieveOfAtkin() {
- // Utlity class; prevent instantiation
+ // Utility class; prevent instantiation
}
/**
diff --git a/src/main/java/com/thealgorithms/maths/SieveOfEratosthenes.java b/src/main/java/com/thealgorithms/maths/SieveOfEratosthenes.java
index f22d22e8c6af..5a15c4201a15 100644
--- a/src/main/java/com/thealgorithms/maths/SieveOfEratosthenes.java
+++ b/src/main/java/com/thealgorithms/maths/SieveOfEratosthenes.java
@@ -1,66 +1,82 @@
package com.thealgorithms.maths;
-import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
/**
- * @brief utility class implementing Sieve of Eratosthenes
+ * Sieve of Eratosthenes Algorithm
+ * An efficient algorithm to find all prime numbers up to a given limit.
+ *
+ * Algorithm:
+ * 1. Create a boolean array of size n+1, initially all true
+ * 2. Mark 0 and 1 as not prime
+ * 3. For each number i from 2 to sqrt(n):
+ * - If i is still marked as prime
+ * - Mark all multiples of i (starting from i²) as not prime
+ * 4. Collect all numbers still marked as prime
+ *
+ * Time Complexity: O(n log log n)
+ * Space Complexity: O(n)
+ *
+ * @author Navadeep0007
+ * @see Sieve of Eratosthenes
*/
public final class SieveOfEratosthenes {
+
private SieveOfEratosthenes() {
+ // Utility class, prevent instantiation
}
- private static void checkInput(int n) {
- if (n <= 0) {
- throw new IllegalArgumentException("n must be positive.");
+ /**
+ * Finds all prime numbers up to n using the Sieve of Eratosthenes algorithm
+ *
+ * @param n the upper limit (inclusive)
+ * @return a list of all prime numbers from 2 to n
+ * @throws IllegalArgumentException if n is negative
+ */
+ public static List findPrimes(int n) {
+ if (n < 0) {
+ throw new IllegalArgumentException("Input must be non-negative");
}
- }
- private static Type[] sievePrimesTill(int n) {
- checkInput(n);
- Type[] isPrimeArray = new Type[n + 1];
- Arrays.fill(isPrimeArray, Type.PRIME);
- isPrimeArray[0] = Type.NOT_PRIME;
- isPrimeArray[1] = Type.NOT_PRIME;
+ if (n < 2) {
+ return new ArrayList<>();
+ }
+
+ // Create boolean array, initially all true
+ boolean[] isPrime = new boolean[n + 1];
+ for (int i = 2; i <= n; i++) {
+ isPrime[i] = true;
+ }
- double cap = Math.sqrt(n);
- for (int i = 2; i <= cap; i++) {
- if (isPrimeArray[i] == Type.PRIME) {
- for (int j = 2; i * j <= n; j++) {
- isPrimeArray[i * j] = Type.NOT_PRIME;
+ // Sieve process
+ for (int i = 2; i * i <= n; i++) {
+ if (isPrime[i]) {
+ // Mark all multiples of i as not prime
+ for (int j = i * i; j <= n; j += i) {
+ isPrime[j] = false;
}
}
}
- return isPrimeArray;
- }
-
- private static int countPrimes(Type[] isPrimeArray) {
- return (int) Arrays.stream(isPrimeArray).filter(element -> element == Type.PRIME).count();
- }
- private static int[] extractPrimes(Type[] isPrimeArray) {
- int numberOfPrimes = countPrimes(isPrimeArray);
- int[] primes = new int[numberOfPrimes];
- int primeIndex = 0;
- for (int curNumber = 0; curNumber < isPrimeArray.length; ++curNumber) {
- if (isPrimeArray[curNumber] == Type.PRIME) {
- primes[primeIndex++] = curNumber;
+ // Collect all prime numbers
+ List primes = new ArrayList<>();
+ for (int i = 2; i <= n; i++) {
+ if (isPrime[i]) {
+ primes.add(i);
}
}
+
return primes;
}
/**
- * @brief finds all of the prime numbers up to the given upper (inclusive) limit
- * @param n upper (inclusive) limit
- * @exception IllegalArgumentException n is non-positive
- * @return the array of all primes up to the given number (inclusive)
+ * Counts the number of prime numbers up to n
+ *
+ * @param n the upper limit (inclusive)
+ * @return count of prime numbers from 2 to n
*/
- public static int[] findPrimesTill(int n) {
- return extractPrimes(sievePrimesTill(n));
- }
-
- private enum Type {
- PRIME,
- NOT_PRIME,
+ public static int countPrimes(int n) {
+ return findPrimes(n).size();
}
}
diff --git a/src/main/java/com/thealgorithms/maths/SmithNumber.java b/src/main/java/com/thealgorithms/maths/SmithNumber.java
new file mode 100644
index 000000000000..c06e0023d9bb
--- /dev/null
+++ b/src/main/java/com/thealgorithms/maths/SmithNumber.java
@@ -0,0 +1,52 @@
+package com.thealgorithms.maths;
+
+import com.thealgorithms.maths.Prime.PrimeCheck;
+
+/**
+ * In number theory, a smith number is a composite number for which, in a given number base,
+ * the sum of its digits is equal to the sum of the digits in its prime factorization in the same base.
+ *
+ * For example, in base 10, 378 = 21 X 33 X 71 is a Smith number since 3 + 7 + 8 = 2 X 1 + 3 X 3 + 7 X 1,
+ * and 22 = 21 X 111 is a Smith number, because 2 + 2 = 2 X 1 + (1 + 1) X 1.
+ *
+ * Wiki: https://en.wikipedia.org/wiki/Smith_number
+ */
+public final class SmithNumber {
+
+ private SmithNumber() {
+ }
+
+ private static int primeFactorDigitSum(int n) {
+ int sum = 0;
+ int num = n;
+
+ // Factorize the number using trial division
+ for (int i = 2; i * i <= num; i++) {
+ while (n % i == 0) { // while i divides n
+ sum += SumOfDigits.sumOfDigits(i); // add sum of digits of factor
+ n /= i; // divide n by the factor
+ }
+ }
+
+ // If n is still > 1, it itself is a prime factor
+ if (n > 1) {
+ sum += SumOfDigits.sumOfDigits(n);
+ }
+
+ return sum;
+ }
+
+ /**
+ * Check if {@code number} is Smith number or not
+ *
+ * @param number the number
+ * @return {@code true} if {@code number} is a Smith number, otherwise false
+ */
+ public static boolean isSmithNumber(int number) {
+ if (PrimeCheck.isPrime(number)) {
+ return false; // Smith numbers must be composite
+ }
+
+ return SumOfDigits.sumOfDigits(number) == primeFactorDigitSum(number);
+ }
+}
diff --git a/src/main/java/com/thealgorithms/matrix/LUDecomposition.java b/src/main/java/com/thealgorithms/matrix/LUDecomposition.java
new file mode 100644
index 000000000000..e41aaa201338
--- /dev/null
+++ b/src/main/java/com/thealgorithms/matrix/LUDecomposition.java
@@ -0,0 +1,88 @@
+package com.thealgorithms.matrix;
+
+/**
+ * LU Decomposition algorithm
+ * --------------------------
+ * Decomposes a square matrix a into a product of two matrices:
+ * a = l * u
+ * where:
+ * - l is a lower triangular matrix with 1s on its diagonal
+ * - u is an upper triangular matrix
+ *
+ * Reference:
+ * https://en.wikipedia.org/wiki/lu_decomposition
+ */
+public final class LUDecomposition {
+
+ private LUDecomposition() {
+ }
+
+ /**
+ * A helper class to store both l and u matrices
+ */
+ public static class LU {
+ double[][] l;
+ double[][] u;
+
+ LU(double[][] l, double[][] u) {
+ this.l = l;
+ this.u = u;
+ }
+ }
+
+ /**
+ * Performs LU Decomposition on a square matrix a
+ *
+ * @param a input square matrix
+ * @return LU object containing l and u matrices
+ */
+ public static LU decompose(double[][] a) {
+ int n = a.length;
+ double[][] l = new double[n][n];
+ double[][] u = new double[n][n];
+
+ for (int i = 0; i < n; i++) {
+ // upper triangular matrix
+ for (int k = i; k < n; k++) {
+ double sum = 0;
+ for (int j = 0; j < i; j++) {
+ sum += l[i][j] * u[j][k];
+ }
+ u[i][k] = a[i][k] - sum;
+ }
+
+ // lower triangular matrix
+ for (int k = i; k < n; k++) {
+ if (i == k) {
+ l[i][i] = 1; // diagonal as 1
+ } else {
+ double sum = 0;
+ for (int j = 0; j < i; j++) {
+ sum += l[k][j] * u[j][i];
+ }
+ l[k][i] = (a[k][i] - sum) / u[i][i];
+ }
+ }
+ }
+
+ return new LU(l, u);
+ }
+
+ /**
+ * Utility function to print a matrix
+ *
+ * @param m matrix to print
+ */
+ public static void printMatrix(double[][] m) {
+ for (double[] row : m) {
+ System.out.print("[");
+ for (int j = 0; j < row.length; j++) {
+ System.out.printf("%7.3f", row[j]);
+ if (j < row.length - 1) {
+ System.out.print(", ");
+ }
+ }
+ System.out.println("]");
+ }
+ }
+}
diff --git a/src/main/java/com/thealgorithms/matrix/PrintAMatrixInSpiralOrder.java b/src/main/java/com/thealgorithms/matrix/PrintAMatrixInSpiralOrder.java
index 2757da1f9023..4ae5970a9574 100644
--- a/src/main/java/com/thealgorithms/matrix/PrintAMatrixInSpiralOrder.java
+++ b/src/main/java/com/thealgorithms/matrix/PrintAMatrixInSpiralOrder.java
@@ -3,17 +3,41 @@
import java.util.ArrayList;
import java.util.List;
+/**
+ * Utility class to print a matrix in spiral order.
+ *
+ * Given a 2D array (matrix), this class provides a method to return the
+ * elements
+ * of the matrix in spiral order, starting from the top-left corner and moving
+ * clockwise.
+ *
+ *
+ * @author Sadiul Hakim (https://github.com/sadiul-hakim)
+ */
public class PrintAMatrixInSpiralOrder {
+
/**
- * Search a key in row and column wise sorted matrix
+ * Returns the elements of the given matrix in spiral order.
+ *
+ * @param matrix the 2D array to traverse in spiral order
+ * @param row the number of rows in the matrix
+ * @param col the number of columns in the matrix
+ * @return a list containing the elements of the matrix in spiral order
*
- * @param matrix matrix to be searched
- * @param row number of rows matrix has
- * @param col number of columns matrix has
- * @author Sadiul Hakim : https://github.com/sadiul-hakim
+ *
+ * Example:
+ *
+ *
+ * int[][] matrix = {
+ * {1, 2, 3},
+ * {4, 5, 6},
+ * {7, 8, 9}
+ * };
+ * print(matrix, 3, 3) returns [1, 2, 3, 6, 9, 8, 7, 4, 5]
+ *
+ *
*/
public List print(int[][] matrix, int row, int col) {
-
// r traverses matrix row wise from first
int r = 0;
// c traverses matrix column wise from first
diff --git a/src/main/java/com/thealgorithms/matrix/RotateMatrixBy90Degrees.java b/src/main/java/com/thealgorithms/matrix/RotateMatrixBy90Degrees.java
index 9a7f255282ac..7ee8a1a9f0ed 100644
--- a/src/main/java/com/thealgorithms/matrix/RotateMatrixBy90Degrees.java
+++ b/src/main/java/com/thealgorithms/matrix/RotateMatrixBy90Degrees.java
@@ -40,7 +40,7 @@ static void printMatrix(int[][] arr) {
}
/**
- * Class containing the algo to roate matrix by 90 degree
+ * Class containing the algo to rotate matrix by 90 degree
*/
final class Rotate {
private Rotate() {
diff --git a/src/main/java/com/thealgorithms/matrix/StochasticMatrix.java b/src/main/java/com/thealgorithms/matrix/StochasticMatrix.java
new file mode 100644
index 000000000000..8b071113f9cc
--- /dev/null
+++ b/src/main/java/com/thealgorithms/matrix/StochasticMatrix.java
@@ -0,0 +1,74 @@
+package com.thealgorithms.matrix;
+
+/**
+ * Utility class to check whether a matrix is stochastic.
+ * A matrix is stochastic if all its elements are non-negative
+ * and the sum of each row or column is equal to 1.
+ *Reference: https://en.wikipedia.org/wiki/Stochastic_matrix
+ */
+public final class StochasticMatrix {
+
+ private static final double TOLERANCE = 1e-9;
+
+ private StochasticMatrix() {
+ // Utility class
+ }
+ /**
+ * Checks if a matrix is row-stochastic.
+ *
+ * @param matrix the matrix to check
+ * @return true if the matrix is row-stochastic
+ * @throws IllegalArgumentException if matrix is null or empty
+ */
+ public static boolean isRowStochastic(double[][] matrix) {
+ validateMatrix(matrix);
+
+ for (double[] row : matrix) {
+ double sum = 0.0;
+ for (double value : row) {
+ if (value < 0) {
+ return false;
+ }
+ sum += value;
+ }
+ if (Math.abs(sum - 1.0) > TOLERANCE) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Checks if a matrix is column-stochastic.
+ *
+ * @param matrix the matrix to check
+ * @return true if the matrix is column-stochastic
+ * @throws IllegalArgumentException if matrix is null or empty
+ */
+ public static boolean isColumnStochastic(double[][] matrix) {
+ validateMatrix(matrix);
+
+ int rows = matrix.length;
+ int cols = matrix[0].length;
+
+ for (int j = 0; j < cols; j++) {
+ double sum = 0.0;
+ for (int i = 0; i < rows; i++) {
+ if (matrix[i][j] < 0) {
+ return false;
+ }
+ sum += matrix[i][j];
+ }
+ if (Math.abs(sum - 1.0) > TOLERANCE) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private static void validateMatrix(double[][] matrix) {
+ if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
+ throw new IllegalArgumentException("Matrix must not be null or empty");
+ }
+ }
+}
diff --git a/src/main/java/com/thealgorithms/others/BankersAlgorithm.java b/src/main/java/com/thealgorithms/others/BankersAlgorithm.java
index 836526529374..5abf633a1c12 100644
--- a/src/main/java/com/thealgorithms/others/BankersAlgorithm.java
+++ b/src/main/java/com/thealgorithms/others/BankersAlgorithm.java
@@ -3,7 +3,7 @@
import java.util.Scanner;
/**
- * This file contains an implementation of BANKER'S ALGORITM Wikipedia:
+ * This file contains an implementation of BANKER'S ALGORITHM Wikipedia:
* https://en.wikipedia.org/wiki/Banker%27s_algorithm
*
* The algorithm for finding out whether or not a system is in a safe state can
diff --git a/src/main/java/com/thealgorithms/others/CRCAlgorithm.java b/src/main/java/com/thealgorithms/others/CRCAlgorithm.java
index 00ddc86be820..2d0be15e0a7b 100644
--- a/src/main/java/com/thealgorithms/others/CRCAlgorithm.java
+++ b/src/main/java/com/thealgorithms/others/CRCAlgorithm.java
@@ -95,7 +95,7 @@ public int getCorrectMess() {
/**
* Resets some of the object's values, used on the main function, so that it
- * can be re-used, in order not to waste too much memory and time, by
+ * can be reused, in order not to waste too much memory and time, by
* creating new objects.
*/
public void refactor() {
@@ -171,7 +171,7 @@ public void divideMessageWithP(boolean check) {
* Once the message is transmitted, some of it's elements, is possible to
* change from 1 to 0, or from 0 to 1, because of the Bit Error Rate (ber).
* For every element of the message, a random double number is created. If
- * that number is smaller than ber, then the spesific element changes. On
+ * that number is smaller than ber, then the specific element changes. On
* the other hand, if it's bigger than ber, it does not. Based on these
* changes. the boolean variable messageChanged, gets the value: true, or
* false.
diff --git a/src/main/java/com/thealgorithms/others/GaussLegendre.java b/src/main/java/com/thealgorithms/others/GaussLegendre.java
index b56b51f158fb..acf76ae3b192 100644
--- a/src/main/java/com/thealgorithms/others/GaussLegendre.java
+++ b/src/main/java/com/thealgorithms/others/GaussLegendre.java
@@ -1,7 +1,7 @@
package com.thealgorithms.others;
/**
- * Guass Legendre Algorithm ref
+ * Gauss Legendre Algorithm ref
* https://en.wikipedia.org/wiki/Gauss–Legendre_algorithm
*
* @author AKS1996
diff --git a/src/main/java/com/thealgorithms/others/Huffman.java b/src/main/java/com/thealgorithms/others/Huffman.java
index 4fdee5d5e70e..22e75da502b5 100644
--- a/src/main/java/com/thealgorithms/others/Huffman.java
+++ b/src/main/java/com/thealgorithms/others/Huffman.java
@@ -1,125 +1,211 @@
package com.thealgorithms.others;
import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
import java.util.PriorityQueue;
-import java.util.Scanner;
-// node class is the basic structure
-// of each node present in the Huffman - tree.
+/**
+ * Node class representing a node in the Huffman tree.
+ * Each node contains a character, its frequency, and references to left and
+ * right children.
+ */
class HuffmanNode {
-
int data;
char c;
-
HuffmanNode left;
HuffmanNode right;
-}
-// comparator class helps to compare the node
-// on the basis of one of its attribute.
-// Here we will be compared
-// on the basis of data values of the nodes.
-class MyComparator implements Comparator {
+ /**
+ * Constructor for HuffmanNode.
+ *
+ * @param c the character stored in this node
+ * @param data the frequency of the character
+ */
+ HuffmanNode(char c, int data) {
+ this.c = c;
+ this.data = data;
+ this.left = null;
+ this.right = null;
+ }
+
+ /**
+ * Default constructor for HuffmanNode.
+ */
+ HuffmanNode() {
+ this.left = null;
+ this.right = null;
+ }
+}
+/**
+ * Comparator class for comparing HuffmanNode objects based on their frequency
+ * data.
+ * Used to maintain min-heap property in the priority queue.
+ */
+class HuffmanComparator implements Comparator {
+ @Override
public int compare(HuffmanNode x, HuffmanNode y) {
- return x.data - y.data;
+ return Integer.compare(x.data, y.data);
}
}
+/**
+ * Implementation of Huffman Coding algorithm for data compression.
+ * Huffman Coding is a greedy algorithm that assigns variable-length codes to
+ * characters
+ * based on their frequency of occurrence. Characters with higher frequency get
+ * shorter codes.
+ *
+ *
+ * Time Complexity: O(n log n) where n is the number of unique characters
+ * Space Complexity: O(n)
+ *
+ * @see Huffman
+ * Coding
+ */
public final class Huffman {
private Huffman() {
}
- // recursive function to print the
- // huffman-code through the tree traversal.
- // Here s is the huffman - code generated.
- public static void printCode(HuffmanNode root, String s) {
- // base case; if the left and right are null
- // then its a leaf node and we print
- // the code s generated by traversing the tree.
- if (root.left == null && root.right == null && Character.isLetter(root.c)) {
- // c is the character in the node
- System.out.println(root.c + ":" + s);
-
- return;
+ /**
+ * Builds a Huffman tree from the given character array and their frequencies.
+ *
+ * @param charArray array of characters
+ * @param charFreq array of frequencies corresponding to the characters
+ * @return root node of the Huffman tree
+ * @throws IllegalArgumentException if arrays are null, empty, or have different
+ * lengths
+ */
+ public static HuffmanNode buildHuffmanTree(char[] charArray, int[] charFreq) {
+ if (charArray == null || charFreq == null) {
+ throw new IllegalArgumentException("Character array and frequency array cannot be null");
+ }
+ if (charArray.length == 0 || charFreq.length == 0) {
+ throw new IllegalArgumentException("Character array and frequency array cannot be empty");
+ }
+ if (charArray.length != charFreq.length) {
+ throw new IllegalArgumentException("Character array and frequency array must have the same length");
}
- // if we go to left then add "0" to the code.
- // if we go to the right add"1" to the code.
- // recursive calls for left and
- // right sub-tree of the generated tree.
- printCode(root.left, s + "0");
- printCode(root.right, s + "1");
- }
+ int n = charArray.length;
+ PriorityQueue priorityQueue = new PriorityQueue<>(n, new HuffmanComparator());
- // main function
- public static void main(String[] args) {
- Scanner s = new Scanner(System.in);
+ // Create leaf nodes and add to priority queue
+ for (int i = 0; i < n; i++) {
+ if (charFreq[i] < 0) {
+ throw new IllegalArgumentException("Frequencies must be non-negative");
+ }
+ HuffmanNode node = new HuffmanNode(charArray[i], charFreq[i]);
+ priorityQueue.add(node);
+ }
- // number of characters.
- int n = 6;
- char[] charArray = {'a', 'b', 'c', 'd', 'e', 'f'};
- int[] charfreq = {5, 9, 12, 13, 16, 45};
+ // Build the Huffman tree
+ while (priorityQueue.size() > 1) {
+ HuffmanNode left = priorityQueue.poll();
+ HuffmanNode right = priorityQueue.poll();
- // creating a priority queue q.
- // makes a min-priority queue(min-heap).
- PriorityQueue q = new PriorityQueue(n, new MyComparator());
+ HuffmanNode parent = new HuffmanNode();
+ parent.data = left.data + right.data;
+ parent.c = '-';
+ parent.left = left;
+ parent.right = right;
- for (int i = 0; i < n; i++) {
- // creating a Huffman node object
- // and add it to the priority queue.
- HuffmanNode hn = new HuffmanNode();
+ priorityQueue.add(parent);
+ }
- hn.c = charArray[i];
- hn.data = charfreq[i];
+ return priorityQueue.poll();
+ }
- hn.left = null;
- hn.right = null;
+ /**
+ * Generates Huffman codes for all characters in the tree.
+ *
+ * @param root root node of the Huffman tree
+ * @return map of characters to their Huffman codes
+ */
+ public static Map generateCodes(HuffmanNode root) {
+ Map huffmanCodes = new HashMap<>();
+ if (root != null) {
+ generateCodesHelper(root, "", huffmanCodes);
+ }
+ return huffmanCodes;
+ }
- // add functions adds
- // the huffman node to the queue.
- q.add(hn);
+ /**
+ * Helper method to recursively generate Huffman codes by traversing the tree.
+ *
+ * @param node current node in the tree
+ * @param code current code being built
+ * @param huffmanCodes map to store character-to-code mappings
+ */
+ private static void generateCodesHelper(HuffmanNode node, String code, Map huffmanCodes) {
+ if (node == null) {
+ return;
}
- // create a root node
- HuffmanNode root = null;
+ // If it's a leaf node, store the code
+ if (node.left == null && node.right == null && Character.isLetter(node.c)) {
+ huffmanCodes.put(node.c, code.isEmpty() ? "0" : code);
+ return;
+ }
- // Here we will extract the two minimum value
- // from the heap each time until
- // its size reduces to 1, extract until
- // all the nodes are extracted.
- while (q.size() > 1) {
- // first min extract.
- HuffmanNode x = q.peek();
- q.poll();
+ // Traverse left with '0' and right with '1'
+ if (node.left != null) {
+ generateCodesHelper(node.left, code + "0", huffmanCodes);
+ }
+ if (node.right != null) {
+ generateCodesHelper(node.right, code + "1", huffmanCodes);
+ }
+ }
- // second min extarct.
- HuffmanNode y = q.peek();
- q.poll();
+ /**
+ * Prints Huffman codes for all characters in the tree.
+ * This method is kept for backward compatibility and demonstration purposes.
+ *
+ * @param root root node of the Huffman tree
+ * @param code current code being built (initially empty string)
+ */
+ public static void printCode(HuffmanNode root, String code) {
+ if (root == null) {
+ return;
+ }
- // new node f which is equal
- HuffmanNode f = new HuffmanNode();
+ // If it's a leaf node, print the code
+ if (root.left == null && root.right == null && Character.isLetter(root.c)) {
+ System.out.println(root.c + ":" + code);
+ return;
+ }
- // to the sum of the frequency of the two nodes
- // assigning values to the f node.
- f.data = x.data + y.data;
- f.c = '-';
+ // Traverse left with '0' and right with '1'
+ if (root.left != null) {
+ printCode(root.left, code + "0");
+ }
+ if (root.right != null) {
+ printCode(root.right, code + "1");
+ }
+ }
- // first extracted node as left child.
- f.left = x;
+ /**
+ * Demonstrates the Huffman coding algorithm with sample data.
+ *
+ * @param args command line arguments (not used)
+ */
+ public static void main(String[] args) {
+ // Sample characters and their frequencies
+ char[] charArray = {'a', 'b', 'c', 'd', 'e', 'f'};
+ int[] charFreq = {5, 9, 12, 13, 16, 45};
- // second extracted node as the right child.
- f.right = y;
+ System.out.println("Characters: a, b, c, d, e, f");
+ System.out.println("Frequencies: 5, 9, 12, 13, 16, 45");
+ System.out.println("\nHuffman Codes:");
- // marking the f node as the root node.
- root = f;
+ // Build Huffman tree
+ HuffmanNode root = buildHuffmanTree(charArray, charFreq);
- // add this node to the priority-queue.
- q.add(f);
+ // Generate and print Huffman codes
+ Map codes = generateCodes(root);
+ for (Map.Entry entry : codes.entrySet()) {
+ System.out.println(entry.getKey() + ": " + entry.getValue());
}
-
- // print the codes by traversing the tree
- printCode(root, "");
- s.close();
}
}
diff --git a/src/main/java/com/thealgorithms/others/Implementing_auto_completing_features_using_trie.java b/src/main/java/com/thealgorithms/others/Implementing_auto_completing_features_using_trie.java
index bb88c7e3ae2f..7a1a7aadd805 100644
--- a/src/main/java/com/thealgorithms/others/Implementing_auto_completing_features_using_trie.java
+++ b/src/main/java/com/thealgorithms/others/Implementing_auto_completing_features_using_trie.java
@@ -97,7 +97,7 @@ static void suggestionsRec(TrieNode root, String currPrefix) {
}
}
- // Fucntion to print suggestions for
+ // Function to print suggestions for
// given query prefix.
static int printAutoSuggestions(TrieNode root, final String query) {
TrieNode pCrawl = root;
diff --git a/src/main/java/com/thealgorithms/others/InsertDeleteInArray.java b/src/main/java/com/thealgorithms/others/InsertDeleteInArray.java
index 15093549871b..06a2539ee8b7 100644
--- a/src/main/java/com/thealgorithms/others/InsertDeleteInArray.java
+++ b/src/main/java/com/thealgorithms/others/InsertDeleteInArray.java
@@ -1,51 +1,172 @@
package com.thealgorithms.others;
+import java.util.Arrays;
import java.util.Scanner;
+/**
+ * Utility class for performing insert and delete operations on arrays.
+ *
+ * This class demonstrates how to insert an element at a specific position and
+ * delete an element from a specific position in an integer array. Since arrays
+ * in Java have fixed size, insertion creates a new array with increased size,
+ * and deletion shifts elements to fill the gap.
+ *
+ *
+ *
+ * Time Complexity:
+ *
+ *
+ * - Insert: O(n) - requires copying elements to new array
+ * - Delete: O(n) - requires shifting elements
+ *
+ *
+ *
+ * Space Complexity:
+ *
+ *
+ * - Insert: O(n) - new array of size n+1
+ * - Delete: O(1) - in-place modification (excluding result array)
+ *
+ *
+ * @author TheAlgorithms community
+ * @see Array
+ * Data Structure
+ */
public final class InsertDeleteInArray {
private InsertDeleteInArray() {
}
+ /**
+ * Inserts an element at the specified position in the array.
+ *
+ * Creates a new array with size = original array size + 1.
+ * Elements at positions <= insertPos retain their positions,
+ * while elements at positions > insertPos are shifted right by one position.
+ *
+ *
+ * @param array the original array
+ * @param element the element to be inserted
+ * @param position the index at which the element should be inserted (0-based)
+ * @return a new array with the element inserted at the specified position
+ * @throws IllegalArgumentException if position is negative or greater than
+ * array length
+ * @throws IllegalArgumentException if array is null
+ */
+ public static int[] insertElement(int[] array, int element, int position) {
+ if (array == null) {
+ throw new IllegalArgumentException("Array cannot be null");
+ }
+ if (position < 0 || position > array.length) {
+ throw new IllegalArgumentException("Position must be between 0 and " + array.length);
+ }
+
+ int[] newArray = new int[array.length + 1];
+
+ // Copy elements before insertion position
+ System.arraycopy(array, 0, newArray, 0, position);
+
+ // Insert the new element
+ newArray[position] = element;
+
+ // Copy remaining elements after insertion position
+ System.arraycopy(array, position, newArray, position + 1, array.length - position);
+
+ return newArray;
+ }
+
+ /**
+ * Deletes an element at the specified position from the array.
+ *
+ * Creates a new array with size = original array size - 1.
+ * Elements after the deletion position are shifted left by one position.
+ *
+ *
+ * @param array the original array
+ * @param position the index of the element to be deleted (0-based)
+ * @return a new array with the element at the specified position removed
+ * @throws IllegalArgumentException if position is negative or greater than or
+ * equal to array length
+ * @throws IllegalArgumentException if array is null or empty
+ */
+ public static int[] deleteElement(int[] array, int position) {
+ if (array == null) {
+ throw new IllegalArgumentException("Array cannot be null");
+ }
+ if (array.length == 0) {
+ throw new IllegalArgumentException("Array is empty");
+ }
+ if (position < 0 || position >= array.length) {
+ throw new IllegalArgumentException("Position must be between 0 and " + (array.length - 1));
+ }
+
+ int[] newArray = new int[array.length - 1];
+
+ // Copy elements before deletion position
+ System.arraycopy(array, 0, newArray, 0, position);
+
+ // Copy elements after deletion position
+ System.arraycopy(array, position + 1, newArray, position, array.length - position - 1);
+
+ return newArray;
+ }
+
+ /**
+ * Main method demonstrating insert and delete operations on an array.
+ *
+ * This method interactively:
+ *
+ * - Takes array size and elements as input
+ * - Inserts a new element at a specified position
+ * - Deletes an element from a specified position
+ * - Displays the array after each operation
+ *
+ *
+ *
+ * @param args command line arguments (not used)
+ */
public static void main(String[] args) {
- try (Scanner s = new Scanner(System.in)) {
- System.out.println("Enter the size of the array");
- int size = s.nextInt();
- int[] a = new int[size];
- int i;
-
- // To enter the initial elements
- for (i = 0; i < size; i++) {
- System.out.println("Enter the element");
- a[i] = s.nextInt();
- }
+ try (Scanner scanner = new Scanner(System.in)) {
+ // Input: array size and elements
+ System.out.println("Enter the size of the array:");
+ int size = scanner.nextInt();
- // To insert a new element(we are creating a new array)
- System.out.println("Enter the index at which the element should be inserted");
- int insertPos = s.nextInt();
- System.out.println("Enter the element to be inserted");
- int ins = s.nextInt();
- int size2 = size + 1;
- int[] b = new int[size2];
- for (i = 0; i < size2; i++) {
- if (i <= insertPos) {
- b[i] = a[i];
- } else {
- b[i] = a[i - 1];
- }
+ if (size <= 0) {
+ System.out.println("Array size must be positive");
+ return;
}
- b[insertPos] = ins;
- for (i = 0; i < size2; i++) {
- System.out.println(b[i]);
+
+ int[] array = new int[size];
+
+ System.out.println("Enter " + size + " elements:");
+ for (int i = 0; i < size; i++) {
+ array[i] = scanner.nextInt();
}
- // To delete an element given the index
- System.out.println("Enter the index at which element is to be deleted");
- int delPos = s.nextInt();
- for (i = delPos; i < size2 - 1; i++) {
- b[i] = b[i + 1];
+ System.out.println("Original array: " + Arrays.toString(array));
+
+ // Insert operation
+ System.out.println("\nEnter the index at which the element should be inserted (0-" + size + "):");
+ int insertPos = scanner.nextInt();
+ System.out.println("Enter the element to be inserted:");
+ int elementToInsert = scanner.nextInt();
+
+ try {
+ array = insertElement(array, elementToInsert, insertPos);
+ System.out.println("Array after insertion: " + Arrays.toString(array));
+ } catch (IllegalArgumentException e) {
+ System.out.println("Error during insertion: " + e.getMessage());
+ return;
}
- for (i = 0; i < size2 - 1; i++) {
- System.out.println(b[i]);
+
+ // Delete operation
+ System.out.println("\nEnter the index at which element is to be deleted (0-" + (array.length - 1) + "):");
+ int deletePos = scanner.nextInt();
+
+ try {
+ array = deleteElement(array, deletePos);
+ System.out.println("Array after deletion: " + Arrays.toString(array));
+ } catch (IllegalArgumentException e) {
+ System.out.println("Error during deletion: " + e.getMessage());
}
}
}
diff --git a/src/main/java/com/thealgorithms/others/IterativeFloodFill.java b/src/main/java/com/thealgorithms/others/IterativeFloodFill.java
index 3ef90369bd52..3f685f418a3d 100644
--- a/src/main/java/com/thealgorithms/others/IterativeFloodFill.java
+++ b/src/main/java/com/thealgorithms/others/IterativeFloodFill.java
@@ -32,8 +32,8 @@ private IterativeFloodFill() {
* Iteratively fill the 2D image with new color
*
* @param image The image to be filled
- * @param x The x co-ordinate at which color is to be filled
- * @param y The y co-ordinate at which color is to be filled
+ * @param x The x coordinate at which color is to be filled
+ * @param y The y coordinate at which color is to be filled
* @param newColor The new color which to be filled in the image
* @param oldColor The old color which is to be replaced in the image
* @see FloodFill BFS
@@ -86,8 +86,8 @@ private static class Point {
* Checks if a pixel should be skipped during flood fill operation.
*
* @param image The image to get boundaries
- * @param x The x co-ordinate of pixel to check
- * @param y The y co-ordinate of pixel to check
+ * @param x The x coordinate of pixel to check
+ * @param y The y coordinate of pixel to check
* @param oldColor The old color which is to be replaced in the image
* @return {@code true} if pixel should be skipped, else {@code false}
*/
diff --git a/src/main/java/com/thealgorithms/others/Krishnamurthy.java b/src/main/java/com/thealgorithms/others/Krishnamurthy.java
deleted file mode 100644
index 8e5ba7c6f1c7..000000000000
--- a/src/main/java/com/thealgorithms/others/Krishnamurthy.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package com.thealgorithms.others;
-
-import java.util.Scanner;
-
-final class Krishnamurthy {
- private Krishnamurthy() {
- }
-
- static int fact(int n) {
- int i;
- int p = 1;
- for (i = n; i >= 1; i--) {
- p = p * i;
- }
- return p;
- }
-
- public static void main(String[] args) {
- Scanner sc = new Scanner(System.in);
- int a;
- int b;
- int s = 0;
- System.out.print("Enter the number : ");
- a = sc.nextInt();
- int n = a;
- while (a > 0) {
- b = a % 10;
- s = s + fact(b);
- a = a / 10;
- }
- if (s == n) {
- System.out.print(n + " is a krishnamurthy number");
- } else {
- System.out.print(n + " is not a krishnamurthy number");
- }
- sc.close();
- }
-}
diff --git a/src/main/java/com/thealgorithms/others/LowestBasePalindrome.java b/src/main/java/com/thealgorithms/others/LowestBasePalindrome.java
index 76d1ed4aba1d..a3ca8d6f6db8 100644
--- a/src/main/java/com/thealgorithms/others/LowestBasePalindrome.java
+++ b/src/main/java/com/thealgorithms/others/LowestBasePalindrome.java
@@ -4,8 +4,26 @@
import java.util.List;
/**
- * @brief Class for finding the lowest base in which a given integer is a palindrome.
- cf. https://oeis.org/A016026
+ * Utility class for finding the lowest base in which a given integer is a
+ * palindrome.
+ *
+ * A number is a palindrome in a given base if its representation in that base
+ * reads the same
+ * forwards and backwards. For example, 15 in base 2 is 1111, which is
+ * palindromic.
+ * This class provides methods to check palindromic properties and find the
+ * smallest base
+ * where a number becomes palindromic.
+ *
+ *
+ * Example: The number 15 in base 2 is represented as [1,1,1,1], which is
+ * palindromic.
+ * The number 10 in base 3 is represented as [1,0,1], which is also palindromic.
+ *
+ *
+ * @see OEIS A016026 - Smallest base in which
+ * n is palindromic
+ * @author TheAlgorithms Contributors
*/
public final class LowestBasePalindrome {
private LowestBasePalindrome() {
@@ -37,12 +55,18 @@ private static void checkNumber(int number) {
/**
* Computes the digits of a given number in a specified base.
+ *
+ * The digits are returned in reverse order (least significant digit first).
+ * For example, the number 13 in base 2 produces [1,0,1,1] representing 1101 in
+ * binary.
+ *
*
- * @param number the number to be converted
- * @param base the base to be used for the conversion
- * @return a list of digits representing the number in the given base, with the most
- * significant digit at the end of the list
- * @throws IllegalArgumentException if the number is negative or the base is less than 2
+ * @param number the number to be converted (must be non-negative)
+ * @param base the base to be used for the conversion (must be greater than 1)
+ * @return a list of digits representing the number in the given base, with the
+ * least significant digit at the beginning of the list
+ * @throws IllegalArgumentException if the number is negative or the base is
+ * less than 2
*/
public static List computeDigitsInBase(int number, int base) {
checkNumber(number);
@@ -58,6 +82,10 @@ public static List computeDigitsInBase(int number, int base) {
/**
* Checks if a list of integers is palindromic.
+ *
+ * A list is palindromic if it reads the same forwards and backwards.
+ * For example, [1,2,1] is palindromic, but [1,2,3] is not.
+ *
*
* @param list the list of integers to be checked
* @return {@code true} if the list is a palindrome, {@code false} otherwise
@@ -73,12 +101,29 @@ public static boolean isPalindromic(List list) {
}
/**
- * Checks if the representation of a given number in a specified base is palindromic.
+ * Checks if the representation of a given number in a specified base is
+ * palindromic.
+ *
+ * This method first validates the input, then applies optimization: if the
+ * number
+ * ends with 0 in the given base (i.e., divisible by the base), it cannot be
+ * palindromic
+ * as palindromes cannot start with 0.
+ *
+ *
+ * Examples:
+ * - 101 in base 10 is palindromic (101)
+ * - 15 in base 2 is palindromic (1111)
+ * - 10 in base 3 is palindromic (101)
+ *
*
- * @param number the number to be checked
- * @param base the base in which the number will be represented
- * @return {@code true} if the number is palindromic in the specified base, {@code false} otherwise
- * @throws IllegalArgumentException if the number is negative or the base is less than 2
+ * @param number the number to be checked (must be non-negative)
+ * @param base the base in which the number will be represented (must be
+ * greater than 1)
+ * @return {@code true} if the number is palindromic in the specified base,
+ * {@code false} otherwise
+ * @throws IllegalArgumentException if the number is negative or the base is
+ * less than 2
*/
public static boolean isPalindromicInBase(int number, int base) {
checkNumber(number);
@@ -89,7 +134,8 @@ public static boolean isPalindromicInBase(int number, int base) {
}
if (number % base == 0) {
- // If the last digit of the number in the given base is 0, it can't be palindromic
+ // If the last digit of the number in the given base is 0, it can't be
+ // palindromic
return false;
}
@@ -97,10 +143,29 @@ public static boolean isPalindromicInBase(int number, int base) {
}
/**
- * Finds the smallest base in which the representation of a given number is palindromic.
+ * Finds the smallest base in which the representation of a given number is
+ * palindromic.
+ *
+ * This method iteratively checks bases starting from 2 until it finds one where
+ * the number is palindromic. For any number n ≥ 2, the number is always
+ * palindromic
+ * in base n-1 (represented as [1, 1]), so this algorithm is guaranteed to
+ * terminate.
+ *
+ *
+ * Time Complexity: O(n * log(n)) in the worst case, where we check each base
+ * and
+ * convert the number to that base.
+ *
+ *
+ * Examples:
+ * - lowestBasePalindrome(15) returns 2 (15 in base 2 is 1111)
+ * - lowestBasePalindrome(10) returns 3 (10 in base 3 is 101)
+ * - lowestBasePalindrome(11) returns 10 (11 in base 10 is 11)
+ *
*
- * @param number the number to be checked
- * @return the smallest base in which the number is a palindrome
+ * @param number the number to be checked (must be non-negative)
+ * @return the smallest base in which the number is a palindrome (base ≥ 2)
* @throws IllegalArgumentException if the number is negative
*/
public static int lowestBasePalindrome(int number) {
diff --git a/src/main/java/com/thealgorithms/others/MaximumSumOfDistinctSubarraysWithLengthK.java b/src/main/java/com/thealgorithms/others/MaximumSumOfDistinctSubarraysWithLengthK.java
index c05f1af4e327..dec813dd3213 100644
--- a/src/main/java/com/thealgorithms/others/MaximumSumOfDistinctSubarraysWithLengthK.java
+++ b/src/main/java/com/thealgorithms/others/MaximumSumOfDistinctSubarraysWithLengthK.java
@@ -1,14 +1,26 @@
package com.thealgorithms.others;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.HashMap;
+import java.util.Map;
/**
- * References: https://en.wikipedia.org/wiki/Streaming_algorithm
+ * Algorithm to find the maximum sum of a subarray of size K with all distinct
+ * elements.
*
- * This model involves computing the maximum sum of subarrays of a fixed size \( K \) from a stream of integers.
- * As the stream progresses, elements from the end of the window are removed, and new elements from the stream are added.
+ * This implementation uses a sliding window approach with a hash map to
+ * efficiently
+ * track element frequencies within the current window. The algorithm maintains
+ * a window
+ * of size K and slides it across the array, ensuring all elements in the window
+ * are distinct.
*
+ * Time Complexity: O(n) where n is the length of the input array
+ * Space Complexity: O(k) for storing elements in the hash map
+ *
+ * @see Streaming
+ * Algorithm
+ * @see Sliding
+ * Window
* @author Swarga-codes (https://github.com/Swarga-codes)
*/
public final class MaximumSumOfDistinctSubarraysWithLengthK {
@@ -16,54 +28,62 @@ private MaximumSumOfDistinctSubarraysWithLengthK() {
}
/**
- * Finds the maximum sum of a subarray of size K consisting of distinct elements.
+ * Finds the maximum sum of a subarray of size K consisting of distinct
+ * elements.
*
- * @param k The size of the subarray.
- * @param nums The array from which subarrays will be considered.
+ * The algorithm uses a sliding window technique with a frequency map to track
+ * the count of each element in the current window. A window is valid only if
+ * all K elements are distinct (frequency map size equals K).
*
- * @return The maximum sum of any distinct-element subarray of size K. If no such subarray exists, returns 0.
+ * @param k The size of the subarray. Must be non-negative.
+ * @param nums The array from which subarrays will be considered.
+ * @return The maximum sum of any distinct-element subarray of size K.
+ * Returns 0 if no such subarray exists or if k is 0 or negative.
+ * @throws IllegalArgumentException if k is negative
*/
public static long maximumSubarraySum(int k, int... nums) {
- if (nums.length < k) {
+ if (k <= 0 || nums == null || nums.length < k) {
return 0;
}
- long masSum = 0; // Variable to store the maximum sum of distinct subarrays
- long currentSum = 0; // Variable to store the sum of the current subarray
- Set currentSet = new HashSet<>(); // Set to track distinct elements in the current subarray
- // Initialize the first window
+ long maxSum = 0;
+ long currentSum = 0;
+ Map frequencyMap = new HashMap<>();
+
+ // Initialize the first window of size k
for (int i = 0; i < k; i++) {
currentSum += nums[i];
- currentSet.add(nums[i]);
+ frequencyMap.put(nums[i], frequencyMap.getOrDefault(nums[i], 0) + 1);
}
- // If the first window contains distinct elements, update maxSum
- if (currentSet.size() == k) {
- masSum = currentSum;
+
+ // Check if the first window has all distinct elements
+ if (frequencyMap.size() == k) {
+ maxSum = currentSum;
}
+
// Slide the window across the array
- for (int i = 1; i < nums.length - k + 1; i++) {
- // Update the sum by removing the element that is sliding out and adding the new element
- currentSum = currentSum - nums[i - 1];
- currentSum = currentSum + nums[i + k - 1];
- int j = i;
- boolean flag = false; // flag value which says that the subarray contains distinct elements
- while (j < i + k && currentSet.size() < k) {
- if (nums[i - 1] == nums[j]) {
- flag = true;
- break;
- } else {
- j++;
- }
- }
- if (!flag) {
- currentSet.remove(nums[i - 1]);
+ for (int i = k; i < nums.length; i++) {
+ // Remove the leftmost element from the window
+ int leftElement = nums[i - k];
+ currentSum -= leftElement;
+ int leftFrequency = frequencyMap.get(leftElement);
+ if (leftFrequency == 1) {
+ frequencyMap.remove(leftElement);
+ } else {
+ frequencyMap.put(leftElement, leftFrequency - 1);
}
- currentSet.add(nums[i + k - 1]);
- // If the current window has distinct elements, compare and possibly update maxSum
- if (currentSet.size() == k && masSum < currentSum) {
- masSum = currentSum;
+
+ // Add the new rightmost element to the window
+ int rightElement = nums[i];
+ currentSum += rightElement;
+ frequencyMap.put(rightElement, frequencyMap.getOrDefault(rightElement, 0) + 1);
+
+ // If all elements in the window are distinct, update maxSum if needed
+ if (frequencyMap.size() == k && currentSum > maxSum) {
+ maxSum = currentSum;
}
}
- return masSum; // the final maximum sum
+
+ return maxSum;
}
}
diff --git a/src/main/java/com/thealgorithms/others/MemoryManagementAlgorithms.java b/src/main/java/com/thealgorithms/others/MemoryManagementAlgorithms.java
index 0924b8569942..40a5f6a7a767 100644
--- a/src/main/java/com/thealgorithms/others/MemoryManagementAlgorithms.java
+++ b/src/main/java/com/thealgorithms/others/MemoryManagementAlgorithms.java
@@ -16,7 +16,7 @@ public abstract class MemoryManagementAlgorithms {
* blocks available.
* @param sizeOfProcesses: an int array that contains the sizes of the
* processes we need memory blocks for.
- * @return the ArrayList filled with Integers repressenting the memory
+ * @return the ArrayList filled with Integers representing the memory
* allocation that took place.
*/
public abstract ArrayList fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses);
@@ -91,7 +91,7 @@ private static int findBestFit(int[] blockSizes, int processSize) {
* blocks available.
* @param sizeOfProcesses: an int array that contains the sizes of the
* processes we need memory blocks for.
- * @return the ArrayList filled with Integers repressenting the memory
+ * @return the ArrayList filled with Integers representing the memory
* allocation that took place.
*/
public ArrayList fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) {
@@ -149,7 +149,7 @@ private static int findWorstFit(int[] blockSizes, int processSize) {
* blocks available.
* @param sizeOfProcesses: an int array that contains the sizes of the
* processes we need memory blocks for.
- * @return the ArrayList filled with Integers repressenting the memory
+ * @return the ArrayList filled with Integers representing the memory
* allocation that took place.
*/
public ArrayList fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) {
@@ -201,7 +201,7 @@ private static int findFirstFit(int[] blockSizes, int processSize) {
* blocks available.
* @param sizeOfProcesses: an int array that contains the sizes of the
* processes we need memory blocks for.
- * @return the ArrayList filled with Integers repressenting the memory
+ * @return the ArrayList filled with Integers representing the memory
* allocation that took place.
*/
public ArrayList fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) {
@@ -262,7 +262,7 @@ private int findNextFit(int[] blockSizes, int processSize) {
* blocks available.
* @param sizeOfProcesses: an int array that contains the sizes of the
* processes we need memory blocks for.
- * @return the ArrayList filled with Integers repressenting the memory
+ * @return the ArrayList filled with Integers representing the memory
* allocation that took place.
*/
public ArrayList fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) {
diff --git a/src/main/java/com/thealgorithms/others/MiniMaxAlgorithm.java b/src/main/java/com/thealgorithms/others/MiniMaxAlgorithm.java
index e0b96570a4fe..28dc980034f3 100644
--- a/src/main/java/com/thealgorithms/others/MiniMaxAlgorithm.java
+++ b/src/main/java/com/thealgorithms/others/MiniMaxAlgorithm.java
@@ -4,54 +4,99 @@
import java.util.Random;
/**
- * MiniMax is an algorithm used int artificial intelligence and game theory for
- * minimizing the possible loss for the worst case scenario.
+ * MiniMax is an algorithm used in artificial intelligence and game theory for
+ * minimizing the possible loss for the worst case scenario. It is commonly used
+ * in two-player turn-based games such as Tic-Tac-Toe, Chess, and Checkers.
*
- * See more (https://en.wikipedia.org/wiki/Minimax,
- * https://www.geeksforgeeks.org/minimax-algorithm-in-game-theory-set-1-introduction/).
+ *
+ * The algorithm simulates all possible moves in a game tree and chooses the
+ * move that minimizes the maximum possible loss. The algorithm assumes both
+ * players play optimally.
+ *
+ *
+ * Time Complexity: O(b^d) where b is the branching factor and d is the depth
+ *
+ * Space Complexity: O(d) for the recursive call stack
+ *
+ *
+ * See more:
+ *
*
* @author aitofi (https://github.com/aitorfi)
*/
-public class MiniMaxAlgorithm {
+public final class MiniMaxAlgorithm {
+
+ private static final Random RANDOM = new Random();
/**
* Game tree represented as an int array containing scores. Each array
- * element is a leaf node.
+ * element is a leaf node. The array length must be a power of 2.
*/
private int[] scores;
+
+ /**
+ * The height of the game tree, calculated as log2(scores.length).
+ */
private int height;
/**
- * Initializes the scores with 8 random leaf nodes
+ * Initializes the MiniMaxAlgorithm with 8 random leaf nodes (2^3 = 8).
+ * Each score is a random integer between 1 and 99 inclusive.
*/
public MiniMaxAlgorithm() {
- scores = getRandomScores(3, 99);
- height = log2(scores.length);
+ this(getRandomScores(3, 99));
+ }
+
+ /**
+ * Initializes the MiniMaxAlgorithm with the provided scores.
+ *
+ * @param scores An array of scores representing leaf nodes. The length must be
+ * a power of 2.
+ * @throws IllegalArgumentException if the scores array length is not a power of
+ * 2
+ */
+ public MiniMaxAlgorithm(int[] scores) {
+ if (!isPowerOfTwo(scores.length)) {
+ throw new IllegalArgumentException("The number of scores must be a power of 2.");
+ }
+ this.scores = Arrays.copyOf(scores, scores.length);
+ this.height = log2(scores.length);
}
+ /**
+ * Demonstrates the MiniMax algorithm with a random game tree.
+ *
+ * @param args Command line arguments (not used)
+ */
public static void main(String[] args) {
- MiniMaxAlgorithm miniMaxAlgorith = new MiniMaxAlgorithm();
+ MiniMaxAlgorithm miniMaxAlgorithm = new MiniMaxAlgorithm();
boolean isMaximizer = true; // Specifies the player that goes first.
- boolean verbose = true; // True to show each players choices.
int bestScore;
- bestScore = miniMaxAlgorith.miniMax(0, isMaximizer, 0, verbose);
+ bestScore = miniMaxAlgorithm.miniMax(0, isMaximizer, 0, true);
- if (verbose) {
- System.out.println();
- }
-
- System.out.println(Arrays.toString(miniMaxAlgorith.getScores()));
+ System.out.println();
+ System.out.println(Arrays.toString(miniMaxAlgorithm.getScores()));
System.out.println("The best score for " + (isMaximizer ? "Maximizer" : "Minimizer") + " is " + bestScore);
}
/**
* Returns the optimal score assuming that both players play their best.
*
- * @param depth Indicates how deep we are into the game tree.
- * @param isMaximizer True if it is maximizers turn; otherwise false.
- * @param index Index of the leaf node that is being evaluated.
- * @param verbose True to show each players choices.
+ *
+ * This method recursively evaluates the game tree using the minimax algorithm.
+ * At each level, the maximizer tries to maximize the score while the minimizer
+ * tries to minimize it.
+ *
+ * @param depth The current depth in the game tree (0 at root).
+ * @param isMaximizer True if it is the maximizer's turn; false for minimizer.
+ * @param index Index of the current node in the game tree.
+ * @param verbose True to print each player's choice during evaluation.
* @return The optimal score for the player that made the first move.
*/
public int miniMax(int depth, boolean isMaximizer, int index, boolean verbose) {
@@ -75,7 +120,7 @@ public int miniMax(int depth, boolean isMaximizer, int index, boolean verbose) {
}
// Leaf nodes can be sequentially inspected by
- // recurssively multiplying (0 * 2) and ((0 * 2) + 1):
+ // recursively multiplying (0 * 2) and ((0 * 2) + 1):
// (0 x 2) = 0; ((0 x 2) + 1) = 1
// (1 x 2) = 2; ((1 x 2) + 1) = 3
// (2 x 2) = 4; ((2 x 2) + 1) = 5 ...
@@ -87,46 +132,73 @@ public int miniMax(int depth, boolean isMaximizer, int index, boolean verbose) {
}
/**
- * Returns an array of random numbers which lenght is a power of 2.
+ * Returns an array of random numbers whose length is a power of 2.
*
- * @param size The power of 2 that will determine the lenght of the array.
- * @param maxScore The maximum possible score.
- * @return An array of random numbers.
+ * @param size The power of 2 that will determine the length of the array
+ * (array length = 2^size).
+ * @param maxScore The maximum possible score (scores will be between 1 and
+ * maxScore inclusive).
+ * @return An array of random numbers with length 2^size.
*/
public static int[] getRandomScores(int size, int maxScore) {
int[] randomScores = new int[(int) Math.pow(2, size)];
- Random rand = new Random();
for (int i = 0; i < randomScores.length; i++) {
- randomScores[i] = rand.nextInt(maxScore) + 1;
+ randomScores[i] = RANDOM.nextInt(maxScore) + 1;
}
return randomScores;
}
- // A utility function to find Log n in base 2
+ /**
+ * Calculates the logarithm base 2 of a number.
+ *
+ * @param n The number to calculate log2 for (must be a power of 2).
+ * @return The log2 of n.
+ */
private int log2(int n) {
return (n == 1) ? 0 : log2(n / 2) + 1;
}
- // A utility function to check if a number is a power of 2
+ /**
+ * Checks if a number is a power of 2.
+ *
+ * @param n The number to check.
+ * @return True if n is a power of 2, false otherwise.
+ */
private boolean isPowerOfTwo(int n) {
return n > 0 && (n & (n - 1)) == 0;
}
+ /**
+ * Sets the scores array for the game tree.
+ *
+ * @param scores The array of scores. Length must be a power of 2.
+ * @throws IllegalArgumentException if the scores array length is not a power of
+ * 2
+ */
public void setScores(int[] scores) {
if (!isPowerOfTwo(scores.length)) {
- System.out.println("The number of scores must be a power of 2.");
- return;
+ throw new IllegalArgumentException("The number of scores must be a power of 2.");
}
- this.scores = scores;
+ this.scores = Arrays.copyOf(scores, scores.length);
height = log2(this.scores.length);
}
+ /**
+ * Returns a copy of the scores array.
+ *
+ * @return A copy of the scores array.
+ */
public int[] getScores() {
- return scores;
+ return Arrays.copyOf(scores, scores.length);
}
+ /**
+ * Returns the height of the game tree.
+ *
+ * @return The height of the game tree (log2 of the number of leaf nodes).
+ */
public int getHeight() {
return height;
}
diff --git a/src/main/java/com/thealgorithms/others/PageRank.java b/src/main/java/com/thealgorithms/others/PageRank.java
index c7be7a9882bc..2899b80bcee8 100644
--- a/src/main/java/com/thealgorithms/others/PageRank.java
+++ b/src/main/java/com/thealgorithms/others/PageRank.java
@@ -2,94 +2,306 @@
import java.util.Scanner;
-class PageRank {
+/**
+ * PageRank Algorithm Implementation
+ *
+ *
+ * The PageRank algorithm is used by Google Search to rank web pages in their
+ * search engine
+ * results. It was named after Larry Page, one of the founders of Google.
+ * PageRank is a way of
+ * measuring the importance of website pages.
+ *
+ *
+ * Algorithm: 1. Initialize PageRank values for all pages to 1/N (where N is the
+ * total number
+ * of pages) 2. For each iteration: - For each page, calculate the new PageRank
+ * by summing the
+ * contributions from all incoming links - Apply the damping factor: PR(page) =
+ * (1-d) + d *
+ * sum(PR(incoming_page) / outgoing_links(incoming_page)) 3. Repeat until
+ * convergence
+ *
+ * @see PageRank Algorithm
+ */
+public final class PageRank {
+ private static final int MAX_NODES = 10;
+ private static final double DEFAULT_DAMPING_FACTOR = 0.85;
+ private static final int DEFAULT_ITERATIONS = 2;
+
+ private int[][] adjacencyMatrix;
+ private double[] pageRankValues;
+ private int nodeCount;
+
+ /**
+ * Constructor to initialize PageRank with specified number of nodes
+ *
+ * @param numberOfNodes the number of nodes/pages in the graph
+ * @throws IllegalArgumentException if numberOfNodes is less than 1 or greater
+ * than MAX_NODES
+ */
+ public PageRank(int numberOfNodes) {
+ if (numberOfNodes < 1 || numberOfNodes > MAX_NODES) {
+ throw new IllegalArgumentException("Number of nodes must be between 1 and " + MAX_NODES);
+ }
+ this.nodeCount = numberOfNodes;
+ this.adjacencyMatrix = new int[MAX_NODES][MAX_NODES];
+ this.pageRankValues = new double[MAX_NODES];
+ }
+
+ /**
+ * Default constructor for interactive mode
+ */
+ public PageRank() {
+ this.adjacencyMatrix = new int[MAX_NODES][MAX_NODES];
+ this.pageRankValues = new double[MAX_NODES];
+ }
+
+ /**
+ * Main method for interactive PageRank calculation
+ *
+ * @param args command line arguments (not used)
+ */
public static void main(String[] args) {
- int nodes;
- int i;
- int j;
- Scanner in = new Scanner(System.in);
- System.out.print("Enter the Number of WebPages: ");
- nodes = in.nextInt();
- PageRank p = new PageRank();
- System.out.println("Enter the Adjacency Matrix with 1->PATH & 0->NO PATH Between two WebPages: ");
- for (i = 1; i <= nodes; i++) {
- for (j = 1; j <= nodes; j++) {
- p.path[i][j] = in.nextInt();
- if (j == i) {
- p.path[i][j] = 0;
+ try (Scanner scanner = new Scanner(System.in)) {
+ System.out.print("Enter the Number of WebPages: ");
+ int nodes = scanner.nextInt();
+
+ PageRank pageRank = new PageRank(nodes);
+ System.out.println("Enter the Adjacency Matrix with 1->PATH & 0->NO PATH Between two WebPages: ");
+
+ for (int i = 1; i <= nodes; i++) {
+ for (int j = 1; j <= nodes; j++) {
+ int value = scanner.nextInt();
+ pageRank.setEdge(i, j, value);
}
}
+
+ pageRank.calculatePageRank(nodes, DEFAULT_DAMPING_FACTOR, DEFAULT_ITERATIONS, true);
}
- p.calc(nodes);
}
- public int[][] path = new int[10][10];
- public double[] pagerank = new double[10];
+ /**
+ * Sets an edge in the adjacency matrix
+ *
+ * @param from source node (1-indexed)
+ * @param to destination node (1-indexed)
+ * @param value 1 if edge exists, 0 otherwise
+ */
+ public void setEdge(int from, int to, int value) {
+ if (from == to) {
+ adjacencyMatrix[from][to] = 0; // No self-loops
+ } else {
+ adjacencyMatrix[from][to] = value;
+ }
+ }
- public void calc(double totalNodes) {
- double initialPageRank;
- double outgoingLinks = 0;
- double dampingFactor = 0.85;
- double[] tempPageRank = new double[10];
- int externalNodeNumber;
- int internalNodeNumber;
- int k = 1; // For Traversing
- int iterationStep = 1;
- initialPageRank = 1 / totalNodes;
- System.out.printf(" Total Number of Nodes :" + totalNodes + "\t Initial PageRank of All Nodes :" + initialPageRank + "\n");
+ /**
+ * Sets the adjacency matrix for the graph
+ *
+ * @param matrix the adjacency matrix (1-indexed)
+ */
+ public void setAdjacencyMatrix(int[][] matrix) {
+ for (int i = 1; i <= nodeCount; i++) {
+ for (int j = 1; j <= nodeCount; j++) {
+ setEdge(i, j, matrix[i][j]);
+ }
+ }
+ }
- // 0th ITERATION _ OR _ INITIALIZATION PHASE //
- for (k = 1; k <= totalNodes; k++) {
- this.pagerank[k] = initialPageRank;
+ /**
+ * Gets the PageRank value for a specific node
+ *
+ * @param node the node index (1-indexed)
+ * @return the PageRank value
+ */
+ public double getPageRank(int node) {
+ if (node < 1 || node > nodeCount) {
+ throw new IllegalArgumentException("Node index out of bounds");
}
- System.out.print("\n Initial PageRank Values , 0th Step \n");
+ return pageRankValues[node];
+ }
+
+ /**
+ * Gets all PageRank values
+ *
+ * @return array of PageRank values (1-indexed)
+ */
+ public double[] getAllPageRanks() {
+ return pageRankValues.clone();
+ }
+
+ /**
+ * Calculates PageRank using the default damping factor and iterations
+ *
+ * @param totalNodes the total number of nodes
+ * @return array of PageRank values
+ */
+ public double[] calculatePageRank(int totalNodes) {
+ return calculatePageRank(totalNodes, DEFAULT_DAMPING_FACTOR, DEFAULT_ITERATIONS, false);
+ }
+
+ /**
+ * Calculates PageRank with custom parameters
+ *
+ * @param totalNodes the total number of nodes
+ * @param dampingFactor the damping factor (typically 0.85)
+ * @param iterations number of iterations to perform
+ * @param verbose whether to print detailed output
+ * @return array of PageRank values
+ */
+ public double[] calculatePageRank(int totalNodes, double dampingFactor, int iterations, boolean verbose) {
+ validateInputParameters(totalNodes, dampingFactor, iterations);
- for (k = 1; k <= totalNodes; k++) {
- System.out.printf(" Page Rank of " + k + " is :\t" + this.pagerank[k] + "\n");
+ this.nodeCount = totalNodes;
+ double initialPageRank = 1.0 / totalNodes;
+
+ if (verbose) {
+ System.out.printf("Total Number of Nodes: %d\tInitial PageRank of All Nodes: %.6f%n", totalNodes, initialPageRank);
}
- while (iterationStep <= 2) { // Iterations
- // Store the PageRank for All Nodes in Temporary Array
- for (k = 1; k <= totalNodes; k++) {
- tempPageRank[k] = this.pagerank[k];
- this.pagerank[k] = 0;
- }
+ initializePageRanks(totalNodes, initialPageRank, verbose);
+ performIterations(totalNodes, dampingFactor, iterations, verbose);
- for (internalNodeNumber = 1; internalNodeNumber <= totalNodes; internalNodeNumber++) {
- for (externalNodeNumber = 1; externalNodeNumber <= totalNodes; externalNodeNumber++) {
- if (this.path[externalNodeNumber][internalNodeNumber] == 1) {
- k = 1;
- outgoingLinks = 0; // Count the Number of Outgoing Links for each externalNodeNumber
- while (k <= totalNodes) {
- if (this.path[externalNodeNumber][k] == 1) {
- outgoingLinks = outgoingLinks + 1; // Counter for Outgoing Links
- }
- k = k + 1;
- }
- // Calculate PageRank
- this.pagerank[internalNodeNumber] += tempPageRank[externalNodeNumber] * (1 / outgoingLinks);
- }
- }
- System.out.printf("\n After " + iterationStep + "th Step \n");
+ if (verbose) {
+ System.out.println("\nFinal PageRank:");
+ printPageRanks(totalNodes);
+ }
- for (k = 1; k <= totalNodes; k++) {
- System.out.printf(" Page Rank of " + k + " is :\t" + this.pagerank[k] + "\n");
- }
+ return pageRankValues.clone();
+ }
+
+ /**
+ * Validates input parameters for PageRank calculation
+ *
+ * @param totalNodes the total number of nodes
+ * @param dampingFactor the damping factor
+ * @param iterations number of iterations
+ * @throws IllegalArgumentException if parameters are invalid
+ */
+ private void validateInputParameters(int totalNodes, double dampingFactor, int iterations) {
+ if (totalNodes < 1 || totalNodes > MAX_NODES) {
+ throw new IllegalArgumentException("Total nodes must be between 1 and " + MAX_NODES);
+ }
+ if (dampingFactor < 0 || dampingFactor > 1) {
+ throw new IllegalArgumentException("Damping factor must be between 0 and 1");
+ }
+ if (iterations < 1) {
+ throw new IllegalArgumentException("Iterations must be at least 1");
+ }
+ }
+
+ /**
+ * Initializes PageRank values for all nodes
+ *
+ * @param totalNodes the total number of nodes
+ * @param initialPageRank the initial PageRank value
+ * @param verbose whether to print output
+ */
+ private void initializePageRanks(int totalNodes, double initialPageRank, boolean verbose) {
+ for (int i = 1; i <= totalNodes; i++) {
+ pageRankValues[i] = initialPageRank;
+ }
+
+ if (verbose) {
+ System.out.println("\nInitial PageRank Values, 0th Step");
+ printPageRanks(totalNodes);
+ }
+ }
- iterationStep = iterationStep + 1;
+ /**
+ * Performs the iterative PageRank calculation
+ *
+ * @param totalNodes the total number of nodes
+ * @param dampingFactor the damping factor
+ * @param iterations number of iterations
+ * @param verbose whether to print output
+ */
+ private void performIterations(int totalNodes, double dampingFactor, int iterations, boolean verbose) {
+ for (int iteration = 1; iteration <= iterations; iteration++) {
+ double[] tempPageRank = storeCurrentPageRanks(totalNodes);
+ calculateNewPageRanks(totalNodes, tempPageRank);
+ applyDampingFactor(totalNodes, dampingFactor);
+
+ if (verbose) {
+ System.out.printf("%nAfter %d iteration(s)%n", iteration);
+ printPageRanks(totalNodes);
}
+ }
+ }
- // Add the Damping Factor to PageRank
- for (k = 1; k <= totalNodes; k++) {
- this.pagerank[k] = (1 - dampingFactor) + dampingFactor * this.pagerank[k];
+ /**
+ * Stores current PageRank values in a temporary array
+ *
+ * @param totalNodes the total number of nodes
+ * @return temporary array with current PageRank values
+ */
+ private double[] storeCurrentPageRanks(int totalNodes) {
+ double[] tempPageRank = new double[MAX_NODES];
+ for (int i = 1; i <= totalNodes; i++) {
+ tempPageRank[i] = pageRankValues[i];
+ pageRankValues[i] = 0;
+ }
+ return tempPageRank;
+ }
+
+ /**
+ * Calculates new PageRank values based on incoming links
+ *
+ * @param totalNodes the total number of nodes
+ * @param tempPageRank temporary array with previous PageRank values
+ */
+ private void calculateNewPageRanks(int totalNodes, double[] tempPageRank) {
+ for (int targetNode = 1; targetNode <= totalNodes; targetNode++) {
+ for (int sourceNode = 1; sourceNode <= totalNodes; sourceNode++) {
+ if (adjacencyMatrix[sourceNode][targetNode] == 1) {
+ int outgoingLinks = countOutgoingLinks(sourceNode, totalNodes);
+ if (outgoingLinks > 0) {
+ pageRankValues[targetNode] += tempPageRank[sourceNode] / outgoingLinks;
+ }
+ }
}
+ }
+ }
- // Display PageRank
- System.out.print("\n Final Page Rank : \n");
- for (k = 1; k <= totalNodes; k++) {
- System.out.printf(" Page Rank of " + k + " is :\t" + this.pagerank[k] + "\n");
+ /**
+ * Applies the damping factor to all PageRank values
+ *
+ * @param totalNodes the total number of nodes
+ * @param dampingFactor the damping factor
+ */
+ private void applyDampingFactor(int totalNodes, double dampingFactor) {
+ for (int i = 1; i <= totalNodes; i++) {
+ pageRankValues[i] = (1 - dampingFactor) + dampingFactor * pageRankValues[i];
+ }
+ }
+
+ /**
+ * Counts the number of outgoing links from a node
+ *
+ * @param node the source node (1-indexed)
+ * @param totalNodes total number of nodes
+ * @return the count of outgoing links
+ */
+ private int countOutgoingLinks(int node, int totalNodes) {
+ int count = 0;
+ for (int i = 1; i <= totalNodes; i++) {
+ if (adjacencyMatrix[node][i] == 1) {
+ count++;
}
}
+ return count;
+ }
+
+ /**
+ * Prints the PageRank values for all nodes
+ *
+ * @param totalNodes the total number of nodes
+ */
+ private void printPageRanks(int totalNodes) {
+ for (int i = 1; i <= totalNodes; i++) {
+ System.out.printf("PageRank of %d: %.6f%n", i, pageRankValues[i]);
+ }
}
}
diff --git a/src/main/java/com/thealgorithms/others/PrintAMatrixInSpiralOrder.java b/src/main/java/com/thealgorithms/others/PrintAMatrixInSpiralOrder.java
deleted file mode 100644
index abfdd006879e..000000000000
--- a/src/main/java/com/thealgorithms/others/PrintAMatrixInSpiralOrder.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package com.thealgorithms.others;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class PrintAMatrixInSpiralOrder {
- /**
- * Search a key in row and column wise sorted matrix
- *
- * @param matrix matrix to be searched
- * @param row number of rows matrix has
- * @param col number of columns matrix has
- * @author Sadiul Hakim : https://github.com/sadiul-hakim
- */
- public List print(int[][] matrix, int row, int col) {
- // r traverses matrix row wise from first
- int r = 0;
- // c traverses matrix column wise from first
- int c = 0;
- int i;
- List result = new ArrayList<>();
- while (r < row && c < col) {
- // print first row of matrix
- for (i = c; i < col; i++) {
- result.add(matrix[r][i]);
- }
- // increase r by one because first row printed
- r++;
- // print last column
- for (i = r; i < row; i++) {
- result.add(matrix[i][col - 1]);
- }
- // decrease col by one because last column has been printed
- col--;
- // print rows from last except printed elements
- if (r < row) {
- for (i = col - 1; i >= c; i--) {
- result.add(matrix[row - 1][i]);
- }
- row--;
- }
- // print columns from first except printed elements
- if (c < col) {
- for (i = row - 1; i >= r; i--) {
- result.add(matrix[i][c]);
- }
- c++;
- }
- }
- return result;
- }
-}
diff --git a/src/main/java/com/thealgorithms/physics/CoulombsLaw.java b/src/main/java/com/thealgorithms/physics/CoulombsLaw.java
new file mode 100644
index 000000000000..3a3ad3e0d223
--- /dev/null
+++ b/src/main/java/com/thealgorithms/physics/CoulombsLaw.java
@@ -0,0 +1,80 @@
+package com.thealgorithms.physics;
+
+/**
+ * Implements Coulomb's Law for electrostatics.
+ * Provides simple static methods to calculate electrostatic force and circular orbit velocity.
+ *
+ * @author [Priyanshu Singh](https://github.com/Priyanshu1303d)
+ * @see Wikipedia
+ */
+public final class CoulombsLaw {
+
+ /** Coulomb's constant in N·m²/C² */
+ public static final double COULOMBS_CONSTANT = 8.9875517923e9;
+
+ /**
+ * Private constructor to prevent instantiation of this utility class.
+ */
+ private CoulombsLaw() {
+ }
+
+ /**
+ * Calculates the electrostatic force vector exerted by one charge on another.
+ * The returned vector is the force *on* the second charge (q2).
+ *
+ * @param q1 Charge of the first particle (in Coulombs).
+ * @param x1 X-position of the first particle (m).
+ * @param y1 Y-position of the first particle (m).
+ * @param q2 Charge of the second particle (in Coulombs).
+ * @param x2 X-position of the second particle (m).
+ * @param y2 Y-position of the second particle (m).
+ * @return A double array `[fx, fy]` representing the force vector on the second charge.
+ */
+ public static double[] calculateForceVector(double q1, double x1, double y1, double q2, double x2, double y2) {
+ // Vector from 1 to 2
+ double dx = x2 - x1;
+ double dy = y2 - y1;
+ double distanceSq = dx * dx + dy * dy;
+
+ // If particles are at the same position, force is zero to avoid division by zero.
+ if (distanceSq == 0) {
+ return new double[] {0, 0};
+ }
+
+ double distance = Math.sqrt(distanceSq);
+ // Force magnitude: k * (q1 * q2) / r^2
+ // A positive result is repulsive (pushes q2 away from q1).
+ // A negative result is attractive (pulls q2 toward q1).
+ double forceMagnitude = COULOMBS_CONSTANT * q1 * q2 / distanceSq;
+
+ // Calculate the components of the force vector
+ // (dx / distance) is the unit vector pointing from 1 to 2.
+ double fx = forceMagnitude * (dx / distance);
+ double fy = forceMagnitude * (dy / distance);
+
+ return new double[] {fx, fy};
+ }
+
+ /**
+ * Calculates the speed required for a stable circular orbit of a charged particle
+ * around a central charge (e.g., an electron orbiting a nucleus).
+ *
+ * @param centralCharge The charge of the central body (in Coulombs).
+ * @param orbitingCharge The charge of the orbiting body (in Coulombs).
+ * @param orbitingMass The mass of the orbiting body (in kg).
+ * @param radius The radius of the orbit (in m).
+ * @return The orbital speed (in m/s).
+ * @throws IllegalArgumentException if mass or radius are not positive.
+ */
+ public static double calculateCircularOrbitVelocity(double centralCharge, double orbitingCharge, double orbitingMass, double radius) {
+ if (orbitingMass <= 0 || radius <= 0) {
+ throw new IllegalArgumentException("Orbiting mass and radius must be positive.");
+ }
+
+ // We only need the magnitude of the force, which is always positive.
+ double forceMagnitude = Math.abs(COULOMBS_CONSTANT * centralCharge * orbitingCharge) / (radius * radius);
+
+ // F_c = m * v^2 / r => v = sqrt(F_c * r / m)
+ return Math.sqrt(forceMagnitude * radius / orbitingMass);
+ }
+}
diff --git a/src/main/java/com/thealgorithms/physics/DampedOscillator.java b/src/main/java/com/thealgorithms/physics/DampedOscillator.java
new file mode 100644
index 000000000000..84028b628e77
--- /dev/null
+++ b/src/main/java/com/thealgorithms/physics/DampedOscillator.java
@@ -0,0 +1,109 @@
+package com.thealgorithms.physics;
+
+/**
+ * Models a damped harmonic oscillator, capturing the behavior of a mass-spring-damper system.
+ *
+ * The system is defined by the second-order differential equation:
+ * x'' + 2 * gamma * x' + omega₀² * x = 0
+ * where:
+ *
+ * - omega₀ is the natural (undamped) angular frequency in radians per second.
+ * - gamma is the damping coefficient in inverse seconds.
+ *
+ *
+ * This implementation provides:
+ *
+ * - An analytical solution for the underdamped case (γ < ω₀).
+ * - A numerical integrator based on the explicit Euler method for simulation purposes.
+ *
+ *
+ * Usage Example:
+ *
{@code
+ * DampedOscillator oscillator = new DampedOscillator(10.0, 0.5);
+ * double displacement = oscillator.displacementAnalytical(1.0, 0.0, 0.1);
+ * double[] nextState = oscillator.stepEuler(new double[]{1.0, 0.0}, 0.001);
+ * }
+ *
+ * @author [Yash Rajput](https://github.com/the-yash-rajput)
+ */
+public final class DampedOscillator {
+
+ /** Natural (undamped) angular frequency (rad/s). */
+ private final double omega0;
+
+ /** Damping coefficient (s⁻¹). */
+ private final double gamma;
+
+ private DampedOscillator() {
+ throw new AssertionError("No instances.");
+ }
+
+ /**
+ * Constructs a damped oscillator model.
+ *
+ * @param omega0 the natural frequency (rad/s), must be positive
+ * @param gamma the damping coefficient (s⁻¹), must be non-negative
+ * @throws IllegalArgumentException if parameters are invalid
+ */
+ public DampedOscillator(double omega0, double gamma) {
+ if (omega0 <= 0) {
+ throw new IllegalArgumentException("Natural frequency must be positive.");
+ }
+ if (gamma < 0) {
+ throw new IllegalArgumentException("Damping coefficient must be non-negative.");
+ }
+ this.omega0 = omega0;
+ this.gamma = gamma;
+ }
+
+ /**
+ * Computes the analytical displacement of an underdamped oscillator.
+ * Formula: x(t) = A * exp(-γt) * cos(ω_d t + φ)
+ *
+ * @param amplitude the initial amplitude A
+ * @param phase the initial phase φ (radians)
+ * @param time the time t (seconds)
+ * @return the displacement x(t)
+ */
+ public double displacementAnalytical(double amplitude, double phase, double time) {
+ double omegaD = Math.sqrt(Math.max(0.0, omega0 * omega0 - gamma * gamma));
+ return amplitude * Math.exp(-gamma * time) * Math.cos(omegaD * time + phase);
+ }
+
+ /**
+ * Performs a single integration step using the explicit Euler method.
+ * State vector format: [x, v], where v = dx/dt.
+ *
+ * @param state the current state [x, v]
+ * @param dt the time step (seconds)
+ * @return the next state [x_next, v_next]
+ * @throws IllegalArgumentException if the state array is invalid or dt is non-positive
+ */
+ public double[] stepEuler(double[] state, double dt) {
+ if (state == null || state.length != 2) {
+ throw new IllegalArgumentException("State must be a non-null array of length 2.");
+ }
+ if (dt <= 0) {
+ throw new IllegalArgumentException("Time step must be positive.");
+ }
+
+ double x = state[0];
+ double v = state[1];
+ double acceleration = -2.0 * gamma * v - omega0 * omega0 * x;
+
+ double xNext = x + dt * v;
+ double vNext = v + dt * acceleration;
+
+ return new double[] {xNext, vNext};
+ }
+
+ /** @return the natural (undamped) angular frequency (rad/s). */
+ public double getOmega0() {
+ return omega0;
+ }
+
+ /** @return the damping coefficient (s⁻¹). */
+ public double getGamma() {
+ return gamma;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/physics/ElasticCollision2D.java b/src/main/java/com/thealgorithms/physics/ElasticCollision2D.java
new file mode 100644
index 000000000000..399c3f1e041f
--- /dev/null
+++ b/src/main/java/com/thealgorithms/physics/ElasticCollision2D.java
@@ -0,0 +1,73 @@
+package com.thealgorithms.physics;
+
+/**
+ * 2D Elastic collision between two circular bodies
+ * Based on principles of conservation of momentum and kinetic energy.
+ *
+ * @author [Yash Rajput](https://github.com/the-yash-rajput)
+ */
+public final class ElasticCollision2D {
+
+ private ElasticCollision2D() {
+ throw new AssertionError("No instances. Utility class");
+ }
+
+ public static class Body {
+ public double x;
+ public double y;
+ public double vx;
+ public double vy;
+ public double mass;
+ public double radius;
+
+ public Body(double x, double y, double vx, double vy, double mass, double radius) {
+ this.x = x;
+ this.y = y;
+ this.vx = vx;
+ this.vy = vy;
+ this.mass = mass;
+ this.radius = radius;
+ }
+ }
+
+ /**
+ * Resolve instantaneous elastic collision between two circular bodies.
+ *
+ * @param a first body
+ * @param b second body
+ */
+ public static void resolveCollision(Body a, Body b) {
+ double dx = b.x - a.x;
+ double dy = b.y - a.y;
+ double dist = Math.hypot(dx, dy);
+
+ if (dist == 0) {
+ return; // overlapping
+ }
+
+ double nx = dx / dist;
+ double ny = dy / dist;
+
+ // relative velocity along normal
+ double rv = (b.vx - a.vx) * nx + (b.vy - a.vy) * ny;
+
+ if (rv > 0) {
+ return; // moving apart
+ }
+
+ // impulse with masses
+ double m1 = a.mass;
+ double m2 = b.mass;
+
+ double j = -(1 + 1.0) * rv / (1.0 / m1 + 1.0 / m2);
+
+ // impulse vector
+ double impulseX = j * nx;
+ double impulseY = j * ny;
+
+ a.vx -= impulseX / m1;
+ a.vy -= impulseY / m1;
+ b.vx += impulseX / m2;
+ b.vy += impulseY / m2;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/physics/Gravitation.java b/src/main/java/com/thealgorithms/physics/Gravitation.java
new file mode 100644
index 000000000000..292fdc195f85
--- /dev/null
+++ b/src/main/java/com/thealgorithms/physics/Gravitation.java
@@ -0,0 +1,66 @@
+package com.thealgorithms.physics;
+
+/**
+ * Implements Newton's Law of Universal Gravitation.
+ * Provides simple static methods to calculate gravitational force and circular orbit velocity.
+ *
+ * @author [Priyanshu Kumar Singh](https://github.com/Priyanshu1303d)
+ * @see Wikipedia
+ */
+public final class Gravitation {
+
+ /** Gravitational constant in m^3 kg^-1 s^-2 */
+ public static final double GRAVITATIONAL_CONSTANT = 6.67430e-11;
+
+ /**
+ * Private constructor to prevent instantiation of this utility class.
+ */
+ private Gravitation() {
+ }
+
+ /**
+ * Calculates the gravitational force vector exerted by one body on another.
+ *
+ * @param m1 Mass of the first body (kg).
+ * @param x1 X-position of the first body (m).
+ * @param y1 Y-position of the first body (m).
+ * @param m2 Mass of the second body (kg).
+ * @param x2 X-position of the second body (m).
+ * @param y2 Y-position of the second body (m).
+ * @return A double array `[fx, fy]` representing the force vector on the second body.
+ */
+ public static double[] calculateGravitationalForce(double m1, double x1, double y1, double m2, double x2, double y2) {
+ double dx = x1 - x2;
+ double dy = y1 - y2;
+ double distanceSq = dx * dx + dy * dy;
+
+ // If bodies are at the same position, force is zero to avoid division by zero.
+ if (distanceSq == 0) {
+ return new double[] {0, 0};
+ }
+
+ double distance = Math.sqrt(distanceSq);
+ double forceMagnitude = GRAVITATIONAL_CONSTANT * m1 * m2 / distanceSq;
+
+ // Calculate the components of the force vector
+ double fx = forceMagnitude * (dx / distance);
+ double fy = forceMagnitude * (dy / distance);
+
+ return new double[] {fx, fy};
+ }
+
+ /**
+ * Calculates the speed required for a stable circular orbit.
+ *
+ * @param centralMass The mass of the central body (kg).
+ * @param radius The radius of the orbit (m).
+ * @return The orbital speed (m/s).
+ * @throws IllegalArgumentException if mass or radius are not positive.
+ */
+ public static double calculateCircularOrbitVelocity(double centralMass, double radius) {
+ if (centralMass <= 0 || radius <= 0) {
+ throw new IllegalArgumentException("Mass and radius must be positive.");
+ }
+ return Math.sqrt(GRAVITATIONAL_CONSTANT * centralMass / radius);
+ }
+}
diff --git a/src/main/java/com/thealgorithms/physics/Kinematics.java b/src/main/java/com/thealgorithms/physics/Kinematics.java
new file mode 100644
index 000000000000..d017fe787afd
--- /dev/null
+++ b/src/main/java/com/thealgorithms/physics/Kinematics.java
@@ -0,0 +1,69 @@
+package com.thealgorithms.physics;
+/**
+ * Implements the fundamental "SUVAT" equations for motion
+ * under constant acceleration.
+ *
+ * @author [Priyanshu Kumar Singh](https://github.com/Priyanshu1303d)
+ * @see Wikipedia
+ */
+public final class Kinematics {
+ private Kinematics() {
+ }
+
+ /**
+ * Calculates the final velocity (v) of an object.
+ * Formula: v = u + at
+ *
+ * @param u Initial velocity (m/s).
+ * @param a Constant acceleration (m/s^2).
+ * @param t Time elapsed (s).
+ * @return The final velocity (m/s).
+ */
+
+ public static double calculateFinalVelocity(double u, double a, double t) {
+ return u + a * t;
+ }
+
+ /**
+ * Calculates the displacement (s) of an object.
+ * Formula: s = ut + 0.5 * a * t^2
+ *
+ * @param u Initial velocity (m/s).
+ * @param a Constant acceleration (m/s^2).
+ * @param t Time elapsed (s).
+ * @return The displacement (m).
+ */
+
+ public static double calculateDisplacement(double u, double a, double t) {
+ return u * t + 0.5 * a * t * t;
+ }
+
+ /**
+ * Calculates the displacement (s) of an object.
+ * Formula: v^2 = u^2 + 2 * a * s
+ *
+ * @param u Initial velocity (m/s).
+ * @param a Constant acceleration (m/s^2).
+ * @param s Displacement (m).
+ * @return The final velocity squared (m/s)^2.
+ */
+
+ public static double calculateFinalVelocitySquared(double u, double a, double s) {
+ return u * u + 2 * a * s;
+ }
+
+ /**
+ * Calculates the displacement (s) using the average velocity.
+ * Formula: s = (u + v) / 2 * t
+ *
+ * @param u Initial velocity (m/s).
+ * @param v Final velocity (m/s).
+ * @param t Time elapsed (s).
+ * @return The displacement (m).
+ */
+
+ public static double calculateDisplacementFromVelocities(double u, double v, double t) {
+ double velocitySum = u + v;
+ return velocitySum / 2 * t;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/physics/ProjectileMotion.java b/src/main/java/com/thealgorithms/physics/ProjectileMotion.java
new file mode 100644
index 000000000000..cfc79547922c
--- /dev/null
+++ b/src/main/java/com/thealgorithms/physics/ProjectileMotion.java
@@ -0,0 +1,96 @@
+package com.thealgorithms.physics;
+
+/**
+ *
+ * This implementation calculates the flight path of a projectile launched from any INITIAL HEIGHT.
+ * It is a more flexible version of the ground-to-ground model.
+ *
+ * @see Wikipedia - Projectile Motion
+ * @author [Priyanshu Kumar Singh](https://github.com/Priyanshu1303d)
+ */
+public final class ProjectileMotion {
+
+ private ProjectileMotion() {
+ }
+
+ /** Standard Earth gravity constant*/
+ private static final double GRAVITY = 9.80665;
+
+ /**
+ * A simple container for the results of a projectile motion calculation.
+ */
+ public static final class Result {
+ private final double timeOfFlight;
+ private final double horizontalRange;
+ private final double maxHeight;
+
+ public Result(double timeOfFlight, double horizontalRange, double maxHeight) {
+ this.timeOfFlight = timeOfFlight;
+ this.horizontalRange = horizontalRange;
+ this.maxHeight = maxHeight;
+ }
+
+ /** @return The total time the projectile is in the air (seconds). */
+ public double getTimeOfFlight() {
+ return timeOfFlight;
+ }
+
+ /** @return The total horizontal distance traveled (meters). */
+ public double getHorizontalRange() {
+ return horizontalRange;
+ }
+
+ /** @return The maximum vertical height from the ground (meters). */
+ public double getMaxHeight() {
+ return maxHeight;
+ }
+ }
+
+ /**
+ * Calculates projectile trajectory using standard Earth gravity.
+ *
+ * @param initialVelocity Initial speed of the projectile (m/s).
+ * @param launchAngleDegrees Launch angle from the horizontal (degrees).
+ * @param initialHeight Starting height of the projectile (m).
+ * @return A {@link Result} object with the trajectory data.
+ */
+ public static Result calculateTrajectory(double initialVelocity, double launchAngleDegrees, double initialHeight) {
+ return calculateTrajectory(initialVelocity, launchAngleDegrees, initialHeight, GRAVITY);
+ }
+
+ /**
+ * Calculates projectile trajectory with a custom gravity value.
+ *
+ * @param initialVelocity Initial speed (m/s). Must be non-negative.
+ * @param launchAngleDegrees Launch angle (degrees).
+ * @param initialHeight Starting height (m). Must be non-negative.
+ * @param gravity Acceleration due to gravity (m/s^2). Must be positive.
+ * @return A {@link Result} object with the trajectory data.
+ */
+ public static Result calculateTrajectory(double initialVelocity, double launchAngleDegrees, double initialHeight, double gravity) {
+ if (initialVelocity < 0 || initialHeight < 0 || gravity <= 0) {
+ throw new IllegalArgumentException("Velocity, height, and gravity must be non-negative, and gravity must be positive.");
+ }
+
+ double launchAngleRadians = Math.toRadians(launchAngleDegrees);
+ double initialVerticalVelocity = initialVelocity * Math.sin(launchAngleRadians); // Initial vertical velocity
+ double initialHorizontalVelocity = initialVelocity * Math.cos(launchAngleRadians); // Initial horizontal velocity
+
+ // Correctly calculate total time of flight using the quadratic formula for vertical motion.
+ // y(t) = y0 + initialVerticalVelocity*t - 0.5*g*t^2. We solve for t when y(t) = 0.
+ double totalTimeOfFlight = (initialVerticalVelocity + Math.sqrt(initialVerticalVelocity * initialVerticalVelocity + 2 * gravity * initialHeight)) / gravity;
+
+ // Calculate max height. If launched downwards, max height is the initial height.
+ double maxHeight;
+ if (initialVerticalVelocity > 0) {
+ double heightGained = initialVerticalVelocity * initialVerticalVelocity / (2 * gravity);
+ maxHeight = initialHeight + heightGained;
+ } else {
+ maxHeight = initialHeight;
+ }
+
+ double horizontalRange = initialHorizontalVelocity * totalTimeOfFlight;
+
+ return new Result(totalTimeOfFlight, horizontalRange, maxHeight);
+ }
+}
diff --git a/src/main/java/com/thealgorithms/physics/SimplePendulumRK4.java b/src/main/java/com/thealgorithms/physics/SimplePendulumRK4.java
new file mode 100644
index 000000000000..6de69c103b5a
--- /dev/null
+++ b/src/main/java/com/thealgorithms/physics/SimplePendulumRK4.java
@@ -0,0 +1,126 @@
+package com.thealgorithms.physics;
+
+/**
+ * Simulates a simple pendulum using the Runge-Kutta 4th order method.
+ * The pendulum is modeled with the nonlinear differential equation.
+ *
+ * @author [Yash Rajput](https://github.com/the-yash-rajput)
+ */
+public final class SimplePendulumRK4 {
+
+ private SimplePendulumRK4() {
+ throw new AssertionError("No instances.");
+ }
+
+ private final double length; // meters
+ private final double g; // acceleration due to gravity (m/s^2)
+
+ /**
+ * Constructs a simple pendulum simulator.
+ *
+ * @param length the length of the pendulum in meters
+ * @param g the acceleration due to gravity in m/s^2
+ */
+ public SimplePendulumRK4(double length, double g) {
+ if (length <= 0) {
+ throw new IllegalArgumentException("Length must be positive");
+ }
+ if (g <= 0) {
+ throw new IllegalArgumentException("Gravity must be positive");
+ }
+ this.length = length;
+ this.g = g;
+ }
+
+ /**
+ * Computes the derivatives of the state vector.
+ * State: [theta, omega] where theta is angle and omega is angular velocity.
+ *
+ * @param state the current state [theta, omega]
+ * @return the derivatives [dtheta/dt, domega/dt]
+ */
+ private double[] derivatives(double[] state) {
+ double theta = state[0];
+ double omega = state[1];
+ double dtheta = omega;
+ double domega = -(g / length) * Math.sin(theta);
+ return new double[] {dtheta, domega};
+ }
+
+ /**
+ * Performs one time step using the RK4 method.
+ *
+ * @param state the current state [theta, omega]
+ * @param dt the time step size
+ * @return the new state after time dt
+ */
+ public double[] stepRK4(double[] state, double dt) {
+ if (state == null || state.length != 2) {
+ throw new IllegalArgumentException("State must be array of length 2");
+ }
+ if (dt <= 0) {
+ throw new IllegalArgumentException("Time step must be positive");
+ }
+
+ double[] k1 = derivatives(state);
+ double[] s2 = new double[] {state[0] + 0.5 * dt * k1[0], state[1] + 0.5 * dt * k1[1]};
+
+ double[] k2 = derivatives(s2);
+ double[] s3 = new double[] {state[0] + 0.5 * dt * k2[0], state[1] + 0.5 * dt * k2[1]};
+
+ double[] k3 = derivatives(s3);
+ double[] s4 = new double[] {state[0] + dt * k3[0], state[1] + dt * k3[1]};
+
+ double[] k4 = derivatives(s4);
+
+ double thetaNext = state[0] + dt / 6.0 * (k1[0] + 2 * k2[0] + 2 * k3[0] + k4[0]);
+ double omegaNext = state[1] + dt / 6.0 * (k1[1] + 2 * k2[1] + 2 * k3[1] + k4[1]);
+
+ return new double[] {thetaNext, omegaNext};
+ }
+
+ /**
+ * Simulates the pendulum for a given duration.
+ *
+ * @param initialState the initial state [theta, omega]
+ * @param dt the time step size
+ * @param steps the number of steps to simulate
+ * @return array of states at each step
+ */
+ public double[][] simulate(double[] initialState, double dt, int steps) {
+ double[][] trajectory = new double[steps + 1][2];
+ trajectory[0] = initialState.clone();
+
+ double[] currentState = initialState.clone();
+ for (int i = 1; i <= steps; i++) {
+ currentState = stepRK4(currentState, dt);
+ trajectory[i] = currentState.clone();
+ }
+
+ return trajectory;
+ }
+
+ /**
+ * Calculates the total energy of the pendulum.
+ * E = (1/2) * m * L^2 * omega^2 + m * g * L * (1 - cos(theta))
+ * We use m = 1 for simplicity.
+ *
+ * @param state the current state [theta, omega]
+ * @return the total energy
+ */
+ public double calculateEnergy(double[] state) {
+ double theta = state[0];
+ double omega = state[1];
+ double kineticEnergy = 0.5 * length * length * omega * omega;
+ double potentialEnergy = g * length * (1 - Math.cos(theta));
+ return kineticEnergy + potentialEnergy;
+ }
+
+ public double getLength() {
+ return length;
+ }
+
+ public double getGravity() {
+ return g;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/physics/SnellLaw.java b/src/main/java/com/thealgorithms/physics/SnellLaw.java
new file mode 100644
index 000000000000..2736984814fd
--- /dev/null
+++ b/src/main/java/com/thealgorithms/physics/SnellLaw.java
@@ -0,0 +1,33 @@
+package com.thealgorithms.physics;
+
+/**
+ * Calculates refraction angle using Snell's Law:
+ * n1 * sin(theta1) = n2 * sin(theta2)
+ * @see Snell's Law
+ */
+public final class SnellLaw {
+
+ private SnellLaw() {
+ throw new AssertionError("No instances.");
+ }
+
+ /**
+ * Computes the refracted angle (theta2) in radians.
+ *
+ * @param n1 index of refraction of medium 1
+ * @param n2 index of refraction of medium 2
+ * @param theta1 incident angle in radians
+ * @return refracted angle (theta2) in radians
+ * @throws IllegalArgumentException if total internal reflection occurs
+ */
+ public static double refractedAngle(double n1, double n2, double theta1) {
+ double ratio = n1 / n2;
+ double sinTheta2 = ratio * Math.sin(theta1);
+
+ if (Math.abs(sinTheta2) > 1.0) {
+ throw new IllegalArgumentException("Total internal reflection: no refraction possible.");
+ }
+
+ return Math.asin(sinTheta2);
+ }
+}
diff --git a/src/main/java/com/thealgorithms/physics/ThinLens.java b/src/main/java/com/thealgorithms/physics/ThinLens.java
new file mode 100644
index 000000000000..5fb29d8c41e4
--- /dev/null
+++ b/src/main/java/com/thealgorithms/physics/ThinLens.java
@@ -0,0 +1,74 @@
+package com.thealgorithms.physics;
+
+/**
+ * Implements the Thin Lens Formula used in ray optics:
+ *
+ *
+ * 1/f = 1/v + 1/u
+ *
+ *
+ * where:
+ *
+ * - f = focal length
+ * - u = object distance
+ * - v = image distance
+ *
+ *
+ * Uses the Cartesian sign convention.
+ *
+ * @see Thin Lens
+ */
+public final class ThinLens {
+
+ private ThinLens() {
+ throw new AssertionError("No instances.");
+ }
+
+ /**
+ * Computes the image distance using the thin lens formula.
+ *
+ * @param focalLength focal length of the lens (f)
+ * @param objectDistance object distance (u)
+ * @return image distance (v)
+ * @throws IllegalArgumentException if focal length or object distance is zero
+ */
+ public static double imageDistance(double focalLength, double objectDistance) {
+
+ if (focalLength == 0 || objectDistance == 0) {
+ throw new IllegalArgumentException("Focal length and object distance must be non-zero.");
+ }
+
+ return 1.0 / ((1.0 / focalLength) - (1.0 / objectDistance));
+ }
+
+ /**
+ * Computes magnification of the image.
+ *
+ *
+ * m = v / u
+ *
+ *
+ * @param imageDistance image distance (v)
+ * @param objectDistance object distance (u)
+ * @return magnification
+ * @throws IllegalArgumentException if object distance is zero
+ */
+ public static double magnification(double imageDistance, double objectDistance) {
+
+ if (objectDistance == 0) {
+ throw new IllegalArgumentException("Object distance must be non-zero.");
+ }
+
+ return imageDistance / objectDistance;
+ }
+
+ /**
+ * Determines whether the image formed is real or virtual.
+ *
+ * @param imageDistance image distance (v)
+ * @return {@code true} if image is real, {@code false} if virtual
+ */
+ public static boolean isRealImage(double imageDistance) {
+ return imageDistance > 0;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/puzzlesandgames/Sudoku.java b/src/main/java/com/thealgorithms/puzzlesandgames/Sudoku.java
deleted file mode 100644
index fce665c4de00..000000000000
--- a/src/main/java/com/thealgorithms/puzzlesandgames/Sudoku.java
+++ /dev/null
@@ -1,169 +0,0 @@
-package com.thealgorithms.puzzlesandgames;
-
-/**
- * A class that provides methods to solve Sudoku puzzles of any n x n size
- * using a backtracking approach, where n must be a perfect square.
- * The algorithm checks for safe number placements in rows, columns,
- * and subgrids (which are sqrt(n) x sqrt(n) in size) and recursively solves the puzzle.
- * Though commonly used for 9x9 grids, it is adaptable to other valid Sudoku dimensions.
- */
-final class Sudoku {
-
- private Sudoku() {
- }
-
- /**
- * Checks if placing a number in a specific position on the Sudoku board is safe.
- * The number is considered safe if it does not violate any of the Sudoku rules:
- * - It should not be present in the same row.
- * - It should not be present in the same column.
- * - It should not be present in the corresponding 3x3 subgrid.
- * - It should not be present in the corresponding subgrid, which is sqrt(n) x sqrt(n) in size (e.g., for a 9x9 grid, the subgrid will be 3x3).
- *
- * @param board The current state of the Sudoku board.
- * @param row The row index where the number is to be placed.
- * @param col The column index where the number is to be placed.
- * @param num The number to be placed on the board.
- * @return True if the placement is safe, otherwise false.
- */
- public static boolean isSafe(int[][] board, int row, int col, int num) {
- // Check the row for duplicates
- for (int d = 0; d < board.length; d++) {
- if (board[row][d] == num) {
- return false;
- }
- }
-
- // Check the column for duplicates
- for (int r = 0; r < board.length; r++) {
- if (board[r][col] == num) {
- return false;
- }
- }
-
- // Check the corresponding 3x3 subgrid for duplicates
- int sqrt = (int) Math.sqrt(board.length);
- int boxRowStart = row - row % sqrt;
- int boxColStart = col - col % sqrt;
-
- for (int r = boxRowStart; r < boxRowStart + sqrt; r++) {
- for (int d = boxColStart; d < boxColStart + sqrt; d++) {
- if (board[r][d] == num) {
- return false;
- }
- }
- }
-
- return true;
- }
-
- /**
- * Solves the Sudoku puzzle using backtracking.
- * The algorithm finds an empty cell and tries placing numbers
- * from 1 to n, where n is the size of the board
- * (for example, from 1 to 9 in a standard 9x9 Sudoku).
- * The algorithm finds an empty cell and tries placing numbers from 1 to 9.
- * The standard version of Sudoku uses numbers from 1 to 9, so the algorithm can be
- * easily modified for other variations of the game.
- * If a number placement is valid (checked via `isSafe`), the number is
- * placed and the function recursively attempts to solve the rest of the puzzle.
- * If no solution is possible, the number is removed (backtracked),
- * and the process is repeated.
- *
- * @param board The current state of the Sudoku board.
- * @param n The size of the Sudoku board (typically 9 for a standard puzzle).
- * @return True if the Sudoku puzzle is solvable, false otherwise.
- */
- public static boolean solveSudoku(int[][] board, int n) {
- int row = -1;
- int col = -1;
- boolean isEmpty = true;
-
- // Find the next empty cell
- for (int i = 0; i < n; i++) {
- for (int j = 0; j < n; j++) {
- if (board[i][j] == 0) {
- row = i;
- col = j;
- isEmpty = false;
- break;
- }
- }
- if (!isEmpty) {
- break;
- }
- }
-
- // No empty space left
- if (isEmpty) {
- return true;
- }
-
- // Try placing numbers 1 to n in the empty cell (n should be a perfect square)
- // Eg: n=9 for a standard 9x9 Sudoku puzzle, n=16 for a 16x16 puzzle, etc.
- for (int num = 1; num <= n; num++) {
- if (isSafe(board, row, col, num)) {
- board[row][col] = num;
- if (solveSudoku(board, n)) {
- return true;
- } else {
- // replace it
- board[row][col] = 0;
- }
- }
- }
- return false;
- }
-
- /**
- * Prints the current state of the Sudoku board in a readable format.
- * Each row is printed on a new line, with numbers separated by spaces.
- *
- * @param board The current state of the Sudoku board.
- * @param n The size of the Sudoku board (typically 9 for a standard puzzle).
- */
- public static void print(int[][] board, int n) {
- // Print the board in a nxn grid format
- // if n=9, print the board in a 9x9 grid format
- // if n=16, print the board in a 16x16 grid format
- for (int r = 0; r < n; r++) {
- for (int d = 0; d < n; d++) {
- System.out.print(board[r][d]);
- System.out.print(" ");
- }
- System.out.print("\n");
-
- if ((r + 1) % (int) Math.sqrt(n) == 0) {
- System.out.print("");
- }
- }
- }
-
- /**
- * The driver method to demonstrate solving a Sudoku puzzle.
- * A sample 9x9 Sudoku puzzle is provided, and the program attempts to solve it
- * using the `solveSudoku` method. If a solution is found, it is printed to the console.
- *
- * @param args Command-line arguments (not used in this program).
- */
- public static void main(String[] args) {
- int[][] board = new int[][] {
- {3, 0, 6, 5, 0, 8, 4, 0, 0},
- {5, 2, 0, 0, 0, 0, 0, 0, 0},
- {0, 8, 7, 0, 0, 0, 0, 3, 1},
- {0, 0, 3, 0, 1, 0, 0, 8, 0},
- {9, 0, 0, 8, 6, 3, 0, 0, 5},
- {0, 5, 0, 0, 9, 0, 6, 0, 0},
- {1, 3, 0, 0, 0, 0, 2, 5, 0},
- {0, 0, 0, 0, 0, 0, 0, 7, 4},
- {0, 0, 5, 2, 0, 6, 3, 0, 0},
- };
- int n = board.length;
-
- if (solveSudoku(board, n)) {
- print(board, n);
- } else {
- System.out.println("No solution");
- }
- }
-}
diff --git a/src/main/java/com/thealgorithms/randomized/MonteCarloIntegration.java b/src/main/java/com/thealgorithms/randomized/MonteCarloIntegration.java
index 05d7abbbcd6c..06101295e880 100644
--- a/src/main/java/com/thealgorithms/randomized/MonteCarloIntegration.java
+++ b/src/main/java/com/thealgorithms/randomized/MonteCarloIntegration.java
@@ -64,13 +64,21 @@ private static double doApproximate(Function fx, double a, doubl
if (!validate(fx, a, b, n)) {
throw new IllegalArgumentException("Invalid input parameters");
}
- double totalArea = 0.0;
+ double total = 0.0;
double interval = b - a;
- for (int i = 0; i < n; i++) {
+ int pairs = n / 2;
+ for (int i = 0; i < pairs; i++) {
+ double u = generator.nextDouble();
+ double x1 = a + u * interval;
+ double x2 = a + (1.0 - u) * interval;
+ total += fx.apply(x1);
+ total += fx.apply(x2);
+ }
+ if ((n & 1) == 1) {
double x = a + generator.nextDouble() * interval;
- totalArea += fx.apply(x);
+ total += fx.apply(x);
}
- return interval * totalArea / n;
+ return interval * total / n;
}
private static boolean validate(Function fx, double a, double b, int n) {
diff --git a/src/main/java/com/thealgorithms/maths/FactorialRecursion.java b/src/main/java/com/thealgorithms/recursion/FactorialRecursion.java
similarity index 92%
rename from src/main/java/com/thealgorithms/maths/FactorialRecursion.java
rename to src/main/java/com/thealgorithms/recursion/FactorialRecursion.java
index d9bafd1e39e9..673f216bdc9a 100644
--- a/src/main/java/com/thealgorithms/maths/FactorialRecursion.java
+++ b/src/main/java/com/thealgorithms/recursion/FactorialRecursion.java
@@ -1,4 +1,4 @@
-package com.thealgorithms.maths;
+package com.thealgorithms.recursion;
public final class FactorialRecursion {
private FactorialRecursion() {
diff --git a/src/main/java/com/thealgorithms/recursion/FibonacciSeries.java b/src/main/java/com/thealgorithms/recursion/FibonacciSeries.java
index e5f474085367..9bc6da2f7443 100644
--- a/src/main/java/com/thealgorithms/recursion/FibonacciSeries.java
+++ b/src/main/java/com/thealgorithms/recursion/FibonacciSeries.java
@@ -12,10 +12,12 @@ private FibonacciSeries() {
throw new UnsupportedOperationException("Utility class");
}
public static int fibonacci(int n) {
+ if (n < 0) {
+ throw new IllegalArgumentException("n must be a non-negative integer");
+ }
if (n <= 1) {
return n;
- } else {
- return fibonacci(n - 1) + fibonacci(n - 2);
}
+ return fibonacci(n - 1) + fibonacci(n - 2);
}
}
diff --git a/src/main/java/com/thealgorithms/searches/ExponentalSearch.java b/src/main/java/com/thealgorithms/searches/ExponentialSearch.java
similarity index 100%
rename from src/main/java/com/thealgorithms/searches/ExponentalSearch.java
rename to src/main/java/com/thealgorithms/searches/ExponentialSearch.java
diff --git a/src/main/java/com/thealgorithms/searches/RowColumnWiseSorted2dArrayBinarySearch.java b/src/main/java/com/thealgorithms/searches/RowColumnWiseSorted2dArrayBinarySearch.java
index b40c7554d84b..ecdcd36adf21 100644
--- a/src/main/java/com/thealgorithms/searches/RowColumnWiseSorted2dArrayBinarySearch.java
+++ b/src/main/java/com/thealgorithms/searches/RowColumnWiseSorted2dArrayBinarySearch.java
@@ -13,7 +13,7 @@
* In this two pointers are taken, the first points to the 0th row and the second one points to end
* column, and then the element corresponding to the pointers placed in the array is compared with
* the target that either its equal, greater or smaller than the target. If the element is equal to
- * the target, the co-ordinates of that element is returned i.e. an array of the two pointers will
+ * the target, the coordinates of that element is returned i.e. an array of the two pointers will
* be returned, else if the target is greater than corresponding element then the pointer pointing
* to the 0th row will be incremented by 1, else if the target is lesser than the corresponding
* element then the pointer pointing to the end column will be decremented by 1. And if the element
diff --git a/src/main/java/com/thealgorithms/searches/SentinelLinearSearch.java b/src/main/java/com/thealgorithms/searches/SentinelLinearSearch.java
new file mode 100644
index 000000000000..1a5903a5d134
--- /dev/null
+++ b/src/main/java/com/thealgorithms/searches/SentinelLinearSearch.java
@@ -0,0 +1,99 @@
+package com.thealgorithms.searches;
+
+import com.thealgorithms.devutils.searches.SearchAlgorithm;
+
+/**
+ * Sentinel Linear Search is a variation of linear search that eliminates the
+ * need to check the array bounds in each iteration by placing the search key
+ * at the end of the array as a sentinel value.
+ *
+ *
+ * The algorithm works by:
+ * 1. Storing the last element of the array
+ * 2. Placing the search key at the last position (sentinel)
+ * 3. Searching from the beginning without bound checking
+ * 4. If found before the last position, return the index
+ * 5. If found at the last position, check if it was originally there
+ *
+ *
+ * Time Complexity:
+ * - Best case: O(1) - when the element is at the first position
+ * - Average case: O(n) - when the element is in the middle
+ * - Worst case: O(n) - when the element is not present
+ *
+ *
+ * Space Complexity: O(1) - only uses constant extra space
+ *
+ *
+ * Advantages over regular linear search:
+ * - Reduces the number of comparisons by eliminating bound checking
+ * - Slightly more efficient in practice due to fewer conditional checks
+ *
+ * @author TheAlgorithms Contributors
+ * @see LinearSearch
+ * @see SearchAlgorithm
+ */
+public class SentinelLinearSearch implements SearchAlgorithm {
+ /**
+ * Performs sentinel linear search on the given array.
+ *
+ * @param array the array to search in
+ * @param key the element to search for
+ * @param the type of elements in the array, must be Comparable
+ * @return the index of the first occurrence of the key, or -1 if not found
+ * @throws IllegalArgumentException if the array is null
+ */
+ @Override
+ public > int find(T[] array, T key) {
+ if (array == null) {
+ throw new IllegalArgumentException("Array cannot be null");
+ }
+
+ if (array.length == 0) {
+ return -1;
+ }
+
+ if (key == null) {
+ return findNull(array);
+ }
+
+ // Store the last element
+ T lastElement = array[array.length - 1];
+
+ // Place the sentinel (search key) at the end
+ array[array.length - 1] = key;
+
+ int i = 0;
+ // Search without bound checking since sentinel guarantees we'll find the key
+ while (array[i].compareTo(key) != 0) {
+ i++;
+ }
+
+ // Restore the original last element
+ array[array.length - 1] = lastElement;
+
+ // Check if we found the key before the sentinel position
+ // or if the original last element was the key we were looking for
+ if (i < array.length - 1 || (lastElement != null && lastElement.compareTo(key) == 0)) {
+ return i;
+ }
+
+ return -1; // Key not found
+ }
+
+ /**
+ * Helper method to find null values in the array.
+ *
+ * @param array the array to search in
+ * @param the type of elements in the array
+ * @return the index of the first null element, or -1 if not found
+ */
+ private > int findNull(T[] array) {
+ for (int i = 0; i < array.length; i++) {
+ if (array[i] == null) {
+ return i;
+ }
+ }
+ return -1;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/slidingwindow/CountNiceSubarrays.java b/src/main/java/com/thealgorithms/slidingwindow/CountNiceSubarrays.java
new file mode 100644
index 000000000000..46f8deeb58dd
--- /dev/null
+++ b/src/main/java/com/thealgorithms/slidingwindow/CountNiceSubarrays.java
@@ -0,0 +1,99 @@
+package com.thealgorithms.slidingwindow;
+
+/**
+ * Counts the number of "nice subarrays".
+ * A nice subarray is a contiguous subarray that contains exactly k odd numbers.
+ *
+ * This implementation uses the sliding window technique.
+ *
+ * Reference:
+ * https://leetcode.com/problems/count-number-of-nice-subarrays/
+ *
+ * Time Complexity: O(n)
+ * Space Complexity: O(n)
+ */
+public final class CountNiceSubarrays {
+
+ // Private constructor to prevent instantiation
+ private CountNiceSubarrays() {
+ }
+
+ /**
+ * Returns the count of subarrays containing exactly k odd numbers.
+ *
+ * @param nums input array of integers
+ * @param k number of odd elements required in the subarray
+ * @return number of nice subarrays
+ */
+ public static int countNiceSubarrays(int[] nums, int k) {
+
+ int n = nums.length;
+
+ // Left pointer of the sliding window
+ int left = 0;
+
+ // Tracks number of odd elements in the current window
+ int oddCount = 0;
+
+ // Final answer: total number of nice subarrays
+ int result = 0;
+
+ /*
+ * memo[i] stores how many valid starting positions exist
+ * when the left pointer is at index i.
+ *
+ * This avoids recomputing the same values again.
+ */
+ int[] memo = new int[n];
+
+ // Right pointer moves forward to expand the window
+ for (int right = 0; right < n; right++) {
+
+ // If current element is odd, increment odd count
+ if ((nums[right] & 1) == 1) {
+ oddCount++;
+ }
+
+ /*
+ * If oddCount exceeds k, shrink the window from the left
+ * until oddCount becomes valid again.
+ */
+ if (oddCount > k) {
+ left += memo[left];
+ oddCount--;
+ }
+
+ /*
+ * When the window contains exactly k odd numbers,
+ * count all possible valid subarrays starting at `left`.
+ */
+ if (oddCount == k) {
+
+ /*
+ * If this left index hasn't been processed before,
+ * count how many consecutive even numbers follow it.
+ */
+ if (memo[left] == 0) {
+ int count = 0;
+ int temp = left;
+
+ // Count consecutive even numbers
+ while ((nums[temp] & 1) == 0) {
+ count++;
+ temp++;
+ }
+
+ /*
+ * Number of valid subarrays starting at `left`
+ * is (count of even numbers + 1)
+ */
+ memo[left] = count + 1;
+ }
+
+ // Add number of valid subarrays for this left position
+ result += memo[left];
+ }
+ }
+ return result;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/sorts/BubbleSort.java b/src/main/java/com/thealgorithms/sorts/BubbleSort.java
index 6823c68d0a74..d2eca3506c2d 100644
--- a/src/main/java/com/thealgorithms/sorts/BubbleSort.java
+++ b/src/main/java/com/thealgorithms/sorts/BubbleSort.java
@@ -10,6 +10,13 @@ class BubbleSort implements SortAlgorithm {
/**
* Implements generic bubble sort algorithm.
*
+ * Time Complexity:
+ * - Best case: O(n) – array is already sorted.
+ * - Average case: O(n^2)
+ * - Worst case: O(n^2)
+ *
+ * Space Complexity: O(1) – in-place sorting.
+ *
* @param array the array to be sorted.
* @param the type of elements in the array.
* @return the sorted array.
diff --git a/src/main/java/com/thealgorithms/sorts/HeapSort.java b/src/main/java/com/thealgorithms/sorts/HeapSort.java
index e798fb91b925..5e3b20f43e10 100644
--- a/src/main/java/com/thealgorithms/sorts/HeapSort.java
+++ b/src/main/java/com/thealgorithms/sorts/HeapSort.java
@@ -1,9 +1,20 @@
package com.thealgorithms.sorts;
/**
- * Heap Sort Algorithm Implementation
+ * Heap Sort algorithm implementation.
+ *
+ * Heap sort converts the array into a max-heap and repeatedly extracts the maximum
+ * element to sort the array in increasing order.
+ *
+ * Time Complexity:
+ * - Best case: O(n log n)
+ * - Average case: O(n log n)
+ * - Worst case: O(n log n)
+ *
+ * Space Complexity: O(1) – in-place sorting
*
* @see Heap Sort Algorithm
+ * @see SortAlgorithm
*/
public class HeapSort implements SortAlgorithm {
diff --git a/src/main/java/com/thealgorithms/sorts/InsertionSort.java b/src/main/java/com/thealgorithms/sorts/InsertionSort.java
index 21ebf3827b5f..fdbfd9cd1cfa 100644
--- a/src/main/java/com/thealgorithms/sorts/InsertionSort.java
+++ b/src/main/java/com/thealgorithms/sorts/InsertionSort.java
@@ -1,5 +1,23 @@
package com.thealgorithms.sorts;
+/**
+ * Generic Insertion Sort algorithm.
+ *
+ * Standard insertion sort iterates through the array and inserts each element into its
+ * correct position in the sorted portion of the array.
+ *
+ * Sentinel sort is a variation that first places the minimum element at index 0 to
+ * avoid redundant comparisons in subsequent passes.
+ *
+ * Time Complexity:
+ * - Best case: O(n) – array is already sorted (sentinel sort can improve slightly)
+ * - Average case: O(n^2)
+ * - Worst case: O(n^2) – array is reverse sorted
+ *
+ * Space Complexity: O(1) – in-place sorting
+ *
+ * @see SortAlgorithm
+ */
class InsertionSort implements SortAlgorithm {
/**
diff --git a/src/main/java/com/thealgorithms/sorts/LinkListSort.java b/src/main/java/com/thealgorithms/sorts/LinkListSort.java
index 800d78f36549..d8fd76a86236 100644
--- a/src/main/java/com/thealgorithms/sorts/LinkListSort.java
+++ b/src/main/java/com/thealgorithms/sorts/LinkListSort.java
@@ -106,7 +106,7 @@ public static boolean isSorted(int[] p, int option) {
// The given array and the expected array is checked if both are same then true
// is displayed else false is displayed
default:
- // default is used incase user puts a unauthorized value
+ // default is used in case user puts a unauthorized value
System.out.println("Wrong choice");
}
// Switch case is used to call the classes as per the user requirement
diff --git a/src/main/java/com/thealgorithms/sorts/MergeSort.java b/src/main/java/com/thealgorithms/sorts/MergeSort.java
index 86a184f67b26..f7a7c8da004d 100644
--- a/src/main/java/com/thealgorithms/sorts/MergeSort.java
+++ b/src/main/java/com/thealgorithms/sorts/MergeSort.java
@@ -13,11 +13,16 @@ class MergeSort implements SortAlgorithm {
private Comparable[] aux;
/**
- * Generic merge sort algorithm implements.
+ * Generic merge sort algorithm.
*
- * @param unsorted the array which should be sorted.
- * @param Comparable class.
- * @return sorted array.
+ * Time Complexity:
+ * - Best case: O(n log n)
+ * - Average case: O(n log n)
+ * - Worst case: O(n log n)
+ *
+ * Space Complexity: O(n) – requires auxiliary array for merging.
+ *
+ * @see SortAlgorithm
*/
@Override
public > T[] sort(T[] unsorted) {
diff --git a/src/main/java/com/thealgorithms/sorts/QuickSort.java b/src/main/java/com/thealgorithms/sorts/QuickSort.java
index 3abb1aae2306..b0ca8b9f159d 100644
--- a/src/main/java/com/thealgorithms/sorts/QuickSort.java
+++ b/src/main/java/com/thealgorithms/sorts/QuickSort.java
@@ -1,17 +1,36 @@
package com.thealgorithms.sorts;
/**
- * @author Varun Upadhyay (https://github.com/varunu28)
- * @author Podshivalov Nikita (https://github.com/nikitap492)
+ * QuickSort is a divide-and-conquer sorting algorithm.
+ *
+ * The algorithm selects a pivot element and partitions the array into two
+ * subarrays such that:
+ *
+ * - Elements smaller than the pivot are placed on the left
+ * - Elements greater than the pivot are placed on the right
+ *
+ *
+ * The subarrays are then recursively sorted until the entire array is ordered.
+ *
+ *
This implementation uses randomization to reduce the probability of
+ * encountering worst-case performance on already sorted inputs.
+ *
+ *
Time Complexity:
+ *
+ * - Best Case: O(n log n)
+ * - Average Case: O(n log n)
+ * - Worst Case: O(n^2)
+ *
+ *
+ * Space Complexity: O(log n) due to recursion stack (in-place sorting).
+ *
+ * @author Varun Upadhyay
+ * @author Podshivalov Nikita
* @see SortAlgorithm
*/
+
class QuickSort implements SortAlgorithm {
- /**
- * This method implements the Generic Quick Sort
- *
- * @param array The array to be sorted Sorts the array in increasing order
- */
@Override
public > T[] sort(T[] array) {
doSort(array, 0, array.length - 1);
@@ -21,27 +40,33 @@ public > T[] sort(T[] array) {
/**
* The sorting process
*
- * @param left The first index of an array
- * @param right The last index of an array
* @param array The array to be sorted
+ * @param left The first index of an array
+ * @param right The last index of an array
*/
private static > void doSort(T[] array, final int left, final int right) {
+ // Continue sorting only if the subarray has more than one element
if (left < right) {
+ // Randomly choose a pivot and partition the array
final int pivot = randomPartition(array, left, right);
+ // Recursively sort elements before the pivot
doSort(array, left, pivot - 1);
+ // Recursively sort elements after the pivot
doSort(array, pivot, right);
}
}
/**
- * Randomize the array to avoid the basically ordered sequences
+ * Randomizes the array to avoid already ordered or nearly ordered sequences
*
* @param array The array to be sorted
- * @param left The first index of an array
+ * @param left The first index of an array
* @param right The last index of an array
* @return the partition index of the array
*/
private static > int randomPartition(T[] array, final int left, final int right) {
+ // Randomizing the pivot helps avoid worst-case performance
+ // for already sorted or nearly sorted arrays
final int randomIndex = left + (int) (Math.random() * (right - left + 1));
SortUtils.swap(array, randomIndex, right);
return partition(array, left, right);
@@ -51,21 +76,26 @@ private static > int randomPartition(T[] array, final in
* This method finds the partition index for an array
*
* @param array The array to be sorted
- * @param left The first index of an array
- * @param right The last index of an array Finds the partition index of an
- * array
+ * @param left The first index of an array
+ * @param right The last index of an array
*/
private static > int partition(T[] array, int left, int right) {
final int mid = (left + right) >>> 1;
+ // Choose the middle element as the pivot
final T pivot = array[mid];
-
+ // Move the left and right pointers towards each other
while (left <= right) {
+ // Move left pointer until an element >= pivot is found
while (SortUtils.less(array[left], pivot)) {
++left;
}
+
+ // Move right pointer until an element <= pivot is found
while (SortUtils.less(pivot, array[right])) {
--right;
}
+
+ // Swap elements that are on the wrong side of the pivot
if (left <= right) {
SortUtils.swap(array, left, right);
++left;
diff --git a/src/main/java/com/thealgorithms/sorts/SelectionSort.java b/src/main/java/com/thealgorithms/sorts/SelectionSort.java
index db7732d7e218..2d1814441701 100644
--- a/src/main/java/com/thealgorithms/sorts/SelectionSort.java
+++ b/src/main/java/com/thealgorithms/sorts/SelectionSort.java
@@ -2,11 +2,16 @@
public class SelectionSort implements SortAlgorithm {
/**
- * Sorts an array of comparable elements in increasing order using the selection sort algorithm.
+ * Generic Selection Sort algorithm.
*
- * @param array the array to be sorted
- * @param the class of array elements
- * @return the sorted array
+ * Time Complexity:
+ * - Best case: O(n^2)
+ * - Average case: O(n^2)
+ * - Worst case: O(n^2)
+ *
+ * Space Complexity: O(1) – in-place sorting.
+ *
+ * @see SortAlgorithm
*/
@Override
public > T[] sort(T[] array) {
diff --git a/src/main/java/com/thealgorithms/sorts/SmoothSort.java b/src/main/java/com/thealgorithms/sorts/SmoothSort.java
new file mode 100644
index 000000000000..c45d6f1f02b2
--- /dev/null
+++ b/src/main/java/com/thealgorithms/sorts/SmoothSort.java
@@ -0,0 +1,168 @@
+package com.thealgorithms.sorts;
+
+/**
+ * Smooth Sort is an in-place, comparison-based sorting algorithm proposed by Edsger W. Dijkstra (1981).
+ *
+ * It can be viewed as a variant of heapsort that maintains a forest of heap-ordered Leonardo trees
+ * (trees whose sizes are Leonardo numbers). The algorithm is adaptive: when the input is already
+ * sorted or nearly sorted, the heap invariants are often satisfied and the expensive rebalancing
+ * operations do little work, yielding near-linear behavior.
+ *
+ *
Time Complexity:
+ *
+ * - Best case: O(n) for already sorted input
+ * - Average case: O(n log n)
+ * - Worst case: O(n log n)
+ *
+ *
+ * Space Complexity: O(1) auxiliary space (in-place).
+ *
+ * @see Smoothsort
+ * @see Leonardo numbers
+ * @see SortAlgorithm
+ */
+public class SmoothSort implements SortAlgorithm {
+
+ /**
+ * Leonardo numbers (L(0) = L(1) = 1, L(k+2) = L(k+1) + L(k) + 1) up to the largest value that
+ * fits into a signed 32-bit integer.
+ */
+ private static final int[] LEONARDO = {1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, 287, 465, 753, 1219, 1973, 3193, 5167, 8361, 13529, 21891, 35421, 57313, 92735, 150049, 242785, 392835, 635621, 1028457, 1664079, 2692537, 4356617, 7049155, 11405773, 18454929, 29860703, 48315633, 78176337,
+ 126491971, 204668309, 331160281, 535828591, 866988873, 1402817465};
+
+ /**
+ * Sorts the given array in ascending order using Smooth Sort.
+ *
+ * @param array the array to sort
+ * @param the element type
+ * @return the sorted array
+ */
+ @Override
+ public > T[] sort(final T[] array) {
+ if (array.length < 2) {
+ return array;
+ }
+
+ final int last = array.length - 1;
+
+ // The forest shape is encoded as (p, pshift): p is a bit-vector of present tree orders,
+ // shifted right by pshift. pshift is the order of the rightmost (current) Leonardo tree.
+ long p = 1L;
+ int pshift = 1;
+
+ int head = 0;
+ while (head < last) {
+ if ((p & 3L) == 3L) {
+ sift(array, pshift, head);
+ p >>>= 2;
+ pshift += 2;
+ } else {
+ // Add a new singleton tree; if it will not be merged anymore, we must fully trinkle.
+ if (LEONARDO[pshift - 1] >= last - head) {
+ trinkle(array, p, pshift, head, false);
+ } else {
+ // This tree will be merged later, so it is enough to restore its internal heap property.
+ sift(array, pshift, head);
+ }
+
+ if (pshift == 1) {
+ // If L(1) is used, the new singleton is L(0).
+ p <<= 1;
+ pshift = 0;
+ } else {
+ // Otherwise, shift to order 1 and append a singleton of order 1.
+ p <<= (pshift - 1);
+ pshift = 1;
+ }
+ }
+
+ p |= 1L;
+ head++;
+ }
+
+ trinkle(array, p, pshift, head, false);
+
+ // Repeatedly remove the maximum (always at head) by shrinking the heap region.
+ while (pshift != 1 || p != 1L) {
+ if (pshift <= 1) {
+ // Rightmost tree is a singleton (order 0 or 1). Move to the previous tree root.
+ final long mask = p & ~1L;
+ final int shift = Long.numberOfTrailingZeros(mask);
+ p >>>= shift;
+ pshift += shift;
+ } else {
+ // Split a tree of order (pshift) into two children trees of orders (pshift-1) and (pshift-2).
+ p <<= 2;
+ p ^= 7L;
+ pshift -= 2;
+
+ trinkle(array, p >>> 1, pshift + 1, head - LEONARDO[pshift] - 1, true);
+ trinkle(array, p, pshift, head - 1, true);
+ }
+
+ head--;
+ }
+
+ return array;
+ }
+
+ private static > void sift(final T[] array, int order, int root) {
+ final T value = array[root];
+
+ while (order > 1) {
+ final int right = root - 1;
+ final int left = root - 1 - LEONARDO[order - 2];
+
+ if (!SortUtils.less(value, array[left]) && !SortUtils.less(value, array[right])) {
+ break;
+ }
+
+ if (!SortUtils.less(array[left], array[right])) {
+ array[root] = array[left];
+ root = left;
+ order -= 1;
+ } else {
+ array[root] = array[right];
+ root = right;
+ order -= 2;
+ }
+ }
+
+ array[root] = value;
+ }
+
+ private static > void trinkle(final T[] array, long p, int order, int root, boolean trusty) {
+ final T value = array[root];
+
+ while (p != 1L) {
+ final int stepson = root - LEONARDO[order];
+
+ if (!SortUtils.less(value, array[stepson])) {
+ break;
+ }
+
+ if (!trusty && order > 1) {
+ final int right = root - 1;
+ final int left = root - 1 - LEONARDO[order - 2];
+
+ if (!SortUtils.less(array[right], array[stepson]) || !SortUtils.less(array[left], array[stepson])) {
+ break;
+ }
+ }
+
+ array[root] = array[stepson];
+ root = stepson;
+
+ final long mask = p & ~1L;
+ final int shift = Long.numberOfTrailingZeros(mask);
+ p >>>= shift;
+ order += shift;
+ trusty = false;
+ }
+
+ if (!trusty) {
+ array[root] = value;
+ sift(array, order, root);
+ }
+ }
+}
diff --git a/src/main/java/com/thealgorithms/sorts/TopologicalSort.java b/src/main/java/com/thealgorithms/sorts/TopologicalSort.java
index e4ed240a9947..382ddde9a6f2 100644
--- a/src/main/java/com/thealgorithms/sorts/TopologicalSort.java
+++ b/src/main/java/com/thealgorithms/sorts/TopologicalSort.java
@@ -11,9 +11,16 @@
* a linked list. A Directed Graph is proven to be acyclic when a DFS or Depth First Search is
* performed, yielding no back-edges.
*
- * https://en.wikipedia.org/wiki/Topological_sorting
+ * Time Complexity: O(V + E)
+ * - V: number of vertices
+ * - E: number of edges
*
- * @author Jonathan Taylor (https://github.com/Jtmonument)
+ * Space Complexity: O(V + E)
+ * - adjacency list and recursion stack in DFS
+ *
+ * Reference: https://en.wikipedia.org/wiki/Topological_sorting
+ *
+ * Author: Jonathan Taylor (https://github.com/Jtmonument)
* Based on Introduction to Algorithms 3rd Edition
*/
public final class TopologicalSort {
diff --git a/src/main/java/com/thealgorithms/stacks/TrappingRainwater.java b/src/main/java/com/thealgorithms/stacks/TrappingRainwater.java
new file mode 100644
index 000000000000..072665061b8e
--- /dev/null
+++ b/src/main/java/com/thealgorithms/stacks/TrappingRainwater.java
@@ -0,0 +1,48 @@
+package com.thealgorithms.stacks;
+/**
+ * Trapping Rainwater Problem
+ * Given an array of non-negative integers representing the height of bars,
+ * compute how much water it can trap after raining.
+ *
+ * Example:
+ * Input: [4,2,0,3,2,5]
+ * Output: 9
+ *
+ * Time Complexity: O(n)
+ * Space Complexity: O(1)
+ *
+ * Reference: https://en.wikipedia.org/wiki/Trapping_rain_water
+ */
+public final class TrappingRainwater {
+
+ private TrappingRainwater() {
+ throw new UnsupportedOperationException("Utility class");
+ }
+
+ public static int trap(int[] height) {
+ int left = 0;
+ int right = height.length - 1;
+ int leftMax = 0;
+ int rightMax = 0;
+ int result = 0;
+
+ while (left < right) {
+ if (height[left] < height[right]) {
+ if (height[left] >= leftMax) {
+ leftMax = height[left];
+ } else {
+ result += leftMax - height[left];
+ }
+ left++;
+ } else {
+ if (height[right] >= rightMax) {
+ rightMax = height[right];
+ } else {
+ result += rightMax - height[right];
+ }
+ right--;
+ }
+ }
+ return result;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/stacks/ValidParentheses.java b/src/main/java/com/thealgorithms/stacks/ValidParentheses.java
new file mode 100644
index 000000000000..2cc616a38826
--- /dev/null
+++ b/src/main/java/com/thealgorithms/stacks/ValidParentheses.java
@@ -0,0 +1,74 @@
+package com.thealgorithms.stacks;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
+
+/**
+ * Valid Parentheses Problem
+ *
+ * Given a string containing just the characters '(', ')', '{', '}', '[' and ']',
+ * determine if the input string is valid.
+ *
+ * An input string is valid if:
+ * 1. Open brackets must be closed by the same type of brackets.
+ * 2. Open brackets must be closed in the correct order.
+ * 3. Every close bracket has a corresponding open bracket of the same type.
+ *
+ * Examples:
+ * Input: "()"
+ * Output: true
+ *
+ * Input: "()[]{}"
+ * Output: true
+ *
+ * Input: "(]"
+ * Output: false
+ *
+ * Input: "([)]"
+ * Output: false
+ *
+ * @author Gokul45-45
+ */
+public final class ValidParentheses {
+ private ValidParentheses() {
+ }
+
+ /**
+ * Checks if the given string has valid parentheses
+ *
+ * @param s the input string containing parentheses
+ * @return true if valid, false otherwise
+ */
+ public static boolean isValid(String s) {
+ if (s == null || s.length() % 2 != 0) {
+ return false;
+ }
+
+ Map parenthesesMap = new HashMap<>();
+ parenthesesMap.put('(', ')');
+ parenthesesMap.put('{', '}');
+ parenthesesMap.put('[', ']');
+
+ Stack stack = new Stack<>();
+
+ for (char c : s.toCharArray()) {
+ if (parenthesesMap.containsKey(c)) {
+ // Opening bracket - push to stack
+ stack.push(c);
+ } else {
+ // Closing bracket - check if it matches
+ if (stack.isEmpty()) {
+ return false;
+ }
+ char openBracket = stack.pop();
+ if (parenthesesMap.get(openBracket) != c) {
+ return false;
+ }
+ }
+ }
+
+ // Stack should be empty if all brackets are matched
+ return stack.isEmpty();
+ }
+}
diff --git a/src/main/java/com/thealgorithms/strings/LengthOfLastWord.java b/src/main/java/com/thealgorithms/strings/LengthOfLastWord.java
new file mode 100644
index 000000000000..7eed59a5ef99
--- /dev/null
+++ b/src/main/java/com/thealgorithms/strings/LengthOfLastWord.java
@@ -0,0 +1,51 @@
+package com.thealgorithms.strings;
+
+/**
+ * The {@code LengthOfLastWord} class provides a utility method to determine
+ * the length of the last word in a given string.
+ *
+ * A "word" is defined as a maximal substring consisting of non-space
+ * characters only. Trailing spaces at the end of the string are ignored.
+ *
+ *
Example:
+ *
{@code
+ * LengthOfLastWord obj = new LengthOfLastWord();
+ * System.out.println(obj.lengthOfLastWord("Hello World")); // Output: 5
+ * System.out.println(obj.lengthOfLastWord(" fly me to the moon ")); // Output: 4
+ * System.out.println(obj.lengthOfLastWord("luffy is still joyboy")); // Output: 6
+ * }
+ *
+ * This implementation runs in O(n) time complexity, where n is the length
+ * of the input string, and uses O(1) additional space.
+ */
+public class LengthOfLastWord {
+
+ /**
+ * Returns the length of the last word in the specified string.
+ *
+ *
The method iterates from the end of the string, skipping trailing
+ * spaces first, and then counts the number of consecutive non-space characters
+ * characters until another space (or the beginning of the string) is reached.
+ *
+ * @param s the input string to analyze
+ * @return the length of the last word in {@code s}; returns 0 if there is no word
+ * @throws NullPointerException if {@code s} is {@code null}
+ */
+ public int lengthOfLastWord(String s) {
+ int sizeOfString = s.length() - 1;
+ int lastWordLength = 0;
+
+ // Skip trailing spaces from the end of the string
+ while (sizeOfString >= 0 && s.charAt(sizeOfString) == ' ') {
+ sizeOfString--;
+ }
+
+ // Count the characters of the last word
+ while (sizeOfString >= 0 && s.charAt(sizeOfString) != ' ') {
+ lastWordLength++;
+ sizeOfString--;
+ }
+
+ return lastWordLength;
+ }
+}
diff --git a/src/main/java/com/thealgorithms/strings/Pangram.java b/src/main/java/com/thealgorithms/strings/Pangram.java
index 01307b28f6c6..a92c282d7e52 100644
--- a/src/main/java/com/thealgorithms/strings/Pangram.java
+++ b/src/main/java/com/thealgorithms/strings/Pangram.java
@@ -60,7 +60,7 @@ public static boolean isPangram(String s) {
}
/**
- * Checks if a String is Pangram or not by checking if each alhpabet is present or not
+ * Checks if a String is Pangram or not by checking if each alphabet is present or not
*
* @param s The String to check
* @return {@code true} if s is a Pangram, otherwise {@code false}
diff --git a/src/main/java/com/thealgorithms/strings/Upper.java b/src/main/java/com/thealgorithms/strings/Upper.java
index 5e248cb6ee39..85db7d41e1aa 100644
--- a/src/main/java/com/thealgorithms/strings/Upper.java
+++ b/src/main/java/com/thealgorithms/strings/Upper.java
@@ -15,23 +15,27 @@ public static void main(String[] args) {
}
/**
- * Converts all the characters in this {@code String} to upper case
+ * Converts all the characters in this {@code String} to upper case.
*
* @param s the string to convert
* @return the {@code String}, converted to uppercase.
*/
public static String toUpperCase(String s) {
if (s == null) {
- throw new IllegalArgumentException("Input string connot be null");
+ throw new IllegalArgumentException("Input string cannot be null");
}
if (s.isEmpty()) {
return s;
}
- StringBuilder result = new StringBuilder(s);
- for (int i = 0; i < result.length(); ++i) {
- char currentChar = result.charAt(i);
- if (Character.isLetter(currentChar) && Character.isLowerCase(currentChar)) {
- result.setCharAt(i, Character.toUpperCase(currentChar));
+
+ StringBuilder result = new StringBuilder(s.length());
+
+ for (int i = 0; i < s.length(); ++i) {
+ char currentChar = s.charAt(i);
+ if (Character.isLowerCase(currentChar)) {
+ result.append(Character.toUpperCase(currentChar));
+ } else {
+ result.append(currentChar);
}
}
return result.toString();
diff --git a/src/main/java/com/thealgorithms/strings/ZAlgorithm.java b/src/main/java/com/thealgorithms/strings/ZAlgorithm.java
new file mode 100644
index 000000000000..dc029b751f45
--- /dev/null
+++ b/src/main/java/com/thealgorithms/strings/ZAlgorithm.java
@@ -0,0 +1,48 @@
+/*
+ * https://en.wikipedia.org/wiki/Z-algorithm
+ */
+package com.thealgorithms.strings;
+
+public final class ZAlgorithm {
+
+ private ZAlgorithm() {
+ throw new UnsupportedOperationException("Utility class");
+ }
+
+ public static int[] zFunction(String s) {
+ int n = s.length();
+ int[] z = new int[n];
+ int l = 0;
+ int r = 0;
+
+ for (int i = 1; i < n; i++) {
+ if (i <= r) {
+ z[i] = Math.min(r - i + 1, z[i - l]);
+ }
+
+ while (i + z[i] < n && s.charAt(z[i]) == s.charAt(i + z[i])) {
+ z[i]++;
+ }
+
+ if (i + z[i] - 1 > r) {
+ l = i;
+ r = i + z[i] - 1;
+ }
+ }
+
+ return z;
+ }
+
+ public static int search(String text, String pattern) {
+ String s = pattern + "$" + text;
+ int[] z = zFunction(s);
+ int p = pattern.length();
+
+ for (int i = 0; i < z.length; i++) {
+ if (z[i] == p) {
+ return i - p - 1;
+ }
+ }
+ return -1;
+ }
+}
diff --git a/src/test/java/com/thealgorithms/backtracking/CombinationSumTest.java b/src/test/java/com/thealgorithms/backtracking/CombinationSumTest.java
new file mode 100644
index 000000000000..986c71acebe8
--- /dev/null
+++ b/src/test/java/com/thealgorithms/backtracking/CombinationSumTest.java
@@ -0,0 +1,29 @@
+package com.thealgorithms.backtracking;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class CombinationSumTest {
+ private static List> norm(Iterable> x) {
+ List> y = new ArrayList<>();
+ for (var p : x) {
+ var q = new ArrayList<>(p);
+ q.sort(Integer::compare);
+ y.add(q);
+ }
+ y.sort(Comparator.>comparingInt(List::size).thenComparing(Object::toString));
+ return y;
+ }
+
+ @Test
+ void sample() {
+ int[] candidates = {2, 3, 6, 7};
+ int target = 7;
+ var expected = List.of(List.of(2, 2, 3), List.of(7));
+ assertEquals(norm(expected), norm(CombinationSum.combinationSum(candidates, target)));
+ }
+}
diff --git a/src/test/java/com/thealgorithms/backtracking/SudokuSolverTest.java b/src/test/java/com/thealgorithms/backtracking/SudokuSolverTest.java
new file mode 100644
index 000000000000..75d3eae08629
--- /dev/null
+++ b/src/test/java/com/thealgorithms/backtracking/SudokuSolverTest.java
@@ -0,0 +1,53 @@
+package com.thealgorithms.backtracking;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+class SudokuSolverTest {
+
+ @Test
+ void testSolveSudokuEasyPuzzle() {
+ int[][] board = {{5, 3, 0, 0, 7, 0, 0, 0, 0}, {6, 0, 0, 1, 9, 5, 0, 0, 0}, {0, 9, 8, 0, 0, 0, 0, 6, 0}, {8, 0, 0, 0, 6, 0, 0, 0, 3}, {4, 0, 0, 8, 0, 3, 0, 0, 1}, {7, 0, 0, 0, 2, 0, 0, 0, 6}, {0, 6, 0, 0, 0, 0, 2, 8, 0}, {0, 0, 0, 4, 1, 9, 0, 0, 5}, {0, 0, 0, 0, 8, 0, 0, 7, 9}};
+
+ assertTrue(SudokuSolver.solveSudoku(board));
+
+ int[][] expected = {{5, 3, 4, 6, 7, 8, 9, 1, 2}, {6, 7, 2, 1, 9, 5, 3, 4, 8}, {1, 9, 8, 3, 4, 2, 5, 6, 7}, {8, 5, 9, 7, 6, 1, 4, 2, 3}, {4, 2, 6, 8, 5, 3, 7, 9, 1}, {7, 1, 3, 9, 2, 4, 8, 5, 6}, {9, 6, 1, 5, 3, 7, 2, 8, 4}, {2, 8, 7, 4, 1, 9, 6, 3, 5}, {3, 4, 5, 2, 8, 6, 1, 7, 9}};
+
+ assertArrayEquals(expected, board);
+ }
+
+ @Test
+ void testSolveSudokuHardPuzzle() {
+ int[][] board = {{0, 0, 0, 0, 0, 0, 6, 8, 0}, {0, 0, 0, 0, 7, 3, 0, 0, 9}, {3, 0, 9, 0, 0, 0, 0, 4, 5}, {4, 9, 0, 0, 0, 0, 0, 0, 0}, {8, 0, 3, 0, 5, 0, 9, 0, 2}, {0, 0, 0, 0, 0, 0, 0, 3, 6}, {9, 6, 0, 0, 0, 0, 3, 0, 8}, {7, 0, 0, 6, 8, 0, 0, 0, 0}, {0, 2, 8, 0, 0, 0, 0, 0, 0}};
+
+ assertTrue(SudokuSolver.solveSudoku(board));
+ }
+
+ @Test
+ void testSolveSudokuAlreadySolved() {
+ int[][] board = {{5, 3, 4, 6, 7, 8, 9, 1, 2}, {6, 7, 2, 1, 9, 5, 3, 4, 8}, {1, 9, 8, 3, 4, 2, 5, 6, 7}, {8, 5, 9, 7, 6, 1, 4, 2, 3}, {4, 2, 6, 8, 5, 3, 7, 9, 1}, {7, 1, 3, 9, 2, 4, 8, 5, 6}, {9, 6, 1, 5, 3, 7, 2, 8, 4}, {2, 8, 7, 4, 1, 9, 6, 3, 5}, {3, 4, 5, 2, 8, 6, 1, 7, 9}};
+
+ assertTrue(SudokuSolver.solveSudoku(board));
+ }
+
+ @Test
+ void testSolveSudokuInvalidSize() {
+ int[][] board = {{1, 2, 3}, {4, 5, 6}};
+ assertFalse(SudokuSolver.solveSudoku(board));
+ }
+
+ @Test
+ void testSolveSudokuNullBoard() {
+ assertFalse(SudokuSolver.solveSudoku(null));
+ }
+
+ @Test
+ void testSolveSudokuEmptyBoard() {
+ int[][] board = {{0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0}};
+
+ assertTrue(SudokuSolver.solveSudoku(board));
+ }
+}
diff --git a/src/test/java/com/thealgorithms/backtracking/UniquePermutationTest.java b/src/test/java/com/thealgorithms/backtracking/UniquePermutationTest.java
new file mode 100644
index 000000000000..c8e7cd0af0dd
--- /dev/null
+++ b/src/test/java/com/thealgorithms/backtracking/UniquePermutationTest.java
@@ -0,0 +1,31 @@
+package com.thealgorithms.backtracking;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+public class UniquePermutationTest {
+
+ @Test
+ void testUniquePermutationsAab() {
+ List expected = Arrays.asList("AAB", "ABA", "BAA");
+ List result = UniquePermutation.generateUniquePermutations("AAB");
+ assertEquals(expected, result);
+ }
+
+ @Test
+ void testUniquePermutationsAbc() {
+ List expected = Arrays.asList("ABC", "ACB", "BAC", "BCA", "CAB", "CBA");
+ List result = UniquePermutation.generateUniquePermutations("ABC");
+ assertEquals(expected, result);
+ }
+
+ @Test
+ void testEmptyString() {
+ List expected = Arrays.asList("");
+ List result = UniquePermutation.generateUniquePermutations("");
+ assertEquals(expected, result);
+ }
+}
diff --git a/src/test/java/com/thealgorithms/bitmanipulation/BitRotateTest.java b/src/test/java/com/thealgorithms/bitmanipulation/BitRotateTest.java
new file mode 100644
index 000000000000..0595ae5a73e1
--- /dev/null
+++ b/src/test/java/com/thealgorithms/bitmanipulation/BitRotateTest.java
@@ -0,0 +1,205 @@
+package com.thealgorithms.bitmanipulation;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for BitRotate class covering typical, boundary, and edge cases.
+ * Tests verify correct behavior for 32-bit circular bit rotations.
+ *
+ * @author Yajunesh
+ */
+public class BitRotateTest {
+
+ // ===== rotateLeft Tests =====
+
+ @Test
+ public void testRotateLeftBasic() {
+ // Basic left rotation
+ assertEquals(0b00000000_00000000_00000000_00000010, BitRotate.rotateLeft(1, 1));
+ assertEquals(0b00000000_00000000_00000000_00000100, BitRotate.rotateLeft(1, 2));
+ assertEquals(0b00000000_00000000_00000000_00001000, BitRotate.rotateLeft(1, 3));
+ }
+
+ @Test
+ public void testRotateLeftWithCarry() {
+ // Test bits carrying from left to right
+ // Binary: 10000000_00000000_00000000_00000001
+ int value = 0x80000001;
+ // After left rotate by 1: 00000000_00000000_00000000_00000011
+ assertEquals(3, BitRotate.rotateLeft(value, 1));
+
+ // Binary: 11000000_00000000_00000000_00000000
+ value = 0xC0000000;
+ // After left rotate by 1: 10000000_00000000_00000000_00000001
+ assertEquals(0x80000001, BitRotate.rotateLeft(value, 1));
+ }
+
+ @Test
+ public void testRotateLeftShift32() {
+ // Shift of 32 should be same as shift of 0 (modulo behavior)
+ int value = 0x12345678;
+ assertEquals(value, BitRotate.rotateLeft(value, 32));
+ assertEquals(value, BitRotate.rotateLeft(value, 64));
+ assertEquals(value, BitRotate.rotateLeft(value, 96));
+ }
+
+ @Test
+ public void testRotateLeftShiftNormalization() {
+ // Test that shifts > 32 are properly normalized
+ int value = 1;
+ assertEquals(BitRotate.rotateLeft(value, 1), BitRotate.rotateLeft(value, 33));
+ assertEquals(BitRotate.rotateLeft(value, 5), BitRotate.rotateLeft(value, 37));
+ }
+
+ @Test
+ public void testRotateLeftZeroShift() {
+ // Zero shift should return original value
+ int value = 0xABCD1234;
+ assertEquals(value, BitRotate.rotateLeft(value, 0));
+ }
+
+ // ===== rotateRight Tests =====
+
+ @Test
+ public void testRotateRightBasic() {
+ // Basic right rotation
+ assertEquals(0b10000000_00000000_00000000_00000000, BitRotate.rotateRight(1, 1));
+ assertEquals(0b01000000_00000000_00000000_00000000, BitRotate.rotateRight(1, 2));
+ assertEquals(0b00100000_00000000_00000000_00000000, BitRotate.rotateRight(1, 3));
+ }
+
+ @Test
+ public void testRotateRightWithCarry() {
+ // Test bits carrying from right to left
+ // Binary: 00000000_00000000_00000000_00000011
+ int value = 3;
+ // After right rotate by 1: 10000000_00000000_00000000_00000001
+ assertEquals(0x80000001, BitRotate.rotateRight(value, 1));
+
+ // Binary: 00000000_00000000_00000000_00000001
+ value = 1;
+ // After right rotate by 1: 10000000_00000000_00000000_00000000
+ assertEquals(0x80000000, BitRotate.rotateRight(value, 1));
+ }
+
+ @Test
+ public void testRotateRightShift32() {
+ // Shift of 32 should be same as shift of 0 (modulo behavior)
+ int value = 0x9ABCDEF0;
+ assertEquals(value, BitRotate.rotateRight(value, 32));
+ assertEquals(value, BitRotate.rotateRight(value, 64));
+ assertEquals(value, BitRotate.rotateRight(value, 96));
+ }
+
+ @Test
+ public void testRotateRightShiftNormalization() {
+ // Test that shifts > 32 are properly normalized
+ int value = 1;
+ assertEquals(BitRotate.rotateRight(value, 1), BitRotate.rotateRight(value, 33));
+ assertEquals(BitRotate.rotateRight(value, 7), BitRotate.rotateRight(value, 39));
+ }
+
+ @Test
+ public void testRotateRightZeroShift() {
+ // Zero shift should return original value
+ int value = 0xDEADBEEF;
+ assertEquals(value, BitRotate.rotateRight(value, 0));
+ }
+
+ // ===== Edge Case Tests =====
+
+ @Test
+ public void testRotateLeftMaxValue() {
+ // Test with maximum integer value
+ int value = Integer.MAX_VALUE; // 0x7FFFFFFF
+ int rotated = BitRotate.rotateLeft(value, 1);
+ // MAX_VALUE << 1 should become 0xFFFFFFFE, but with rotation it becomes different
+ assertEquals(0xFFFFFFFE, rotated);
+ }
+
+ @Test
+ public void testRotateRightMinValue() {
+ // Test with minimum integer value (treated as unsigned)
+ int value = Integer.MIN_VALUE; // 0x80000000
+ int rotated = BitRotate.rotateRight(value, 1);
+ // MIN_VALUE >>> 1 should become 0x40000000, but with rotation from left
+ assertEquals(0x40000000, rotated);
+ }
+
+ @Test
+ public void testRotateAllOnes() {
+ // Test with all bits set
+ int value = 0xFFFFFFFF; // All ones
+ assertEquals(value, BitRotate.rotateLeft(value, 13));
+ assertEquals(value, BitRotate.rotateRight(value, 27));
+ }
+
+ @Test
+ public void testRotateAllZeros() {
+ // Test with all bits zero
+ int value = 0x00000000;
+ assertEquals(value, BitRotate.rotateLeft(value, 15));
+ assertEquals(value, BitRotate.rotateRight(value, 19));
+ }
+
+ // ===== Exception Tests =====
+
+ @Test
+ public void testRotateLeftNegativeShift() {
+ // Negative shifts should throw IllegalArgumentException
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> BitRotate.rotateLeft(42, -1));
+ assertTrue(exception.getMessage().contains("negative"));
+ }
+
+ @Test
+ public void testRotateRightNegativeShift() {
+ // Negative shifts should throw IllegalArgumentException
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> BitRotate.rotateRight(42, -5));
+ assertTrue(exception.getMessage().contains("negative"));
+ }
+
+ // ===== Complementary Operations Test =====
+
+ @Test
+ public void testRotateLeftRightComposition() {
+ // Rotating left then right by same amount should return original value
+ int original = 0x12345678;
+ int shift = 7;
+
+ int leftRotated = BitRotate.rotateLeft(original, shift);
+ int restored = BitRotate.rotateRight(leftRotated, shift);
+
+ assertEquals(original, restored);
+ }
+
+ @Test
+ public void testRotateRightLeftComposition() {
+ // Rotating right then left by same amount should return original value
+ int original = 0x9ABCDEF0;
+ int shift = 13;
+
+ int rightRotated = BitRotate.rotateRight(original, shift);
+ int restored = BitRotate.rotateLeft(rightRotated, shift);
+
+ assertEquals(original, restored);
+ }
+
+ @Test
+ public void testRotateLeft31IsSameAsRotateRight1() {
+ // Rotating left by 31 should be same as rotating right by 1
+ int value = 0x55555555;
+ assertEquals(BitRotate.rotateLeft(value, 31), BitRotate.rotateRight(value, 1));
+ }
+
+ @Test
+ public void testTraversals() {
+ // Test that methods don't throw exceptions
+ assertDoesNotThrow(() -> BitRotate.rotateLeft(1, 1));
+ assertDoesNotThrow(() -> BitRotate.rotateRight(1, 1));
+ }
+}
diff --git a/src/test/java/com/thealgorithms/bitmanipulation/CountSetBitsTest.java b/src/test/java/com/thealgorithms/bitmanipulation/CountSetBitsTest.java
index 61e0757f9c12..757c6edc0151 100644
--- a/src/test/java/com/thealgorithms/bitmanipulation/CountSetBitsTest.java
+++ b/src/test/java/com/thealgorithms/bitmanipulation/CountSetBitsTest.java
@@ -1,26 +1,56 @@
package com.thealgorithms.bitmanipulation;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
-public class CountSetBitsTest {
+class CountSetBitsTest {
@Test
- void testSetBits() {
- CountSetBits csb = new CountSetBits();
- assertEquals(1L, csb.countSetBits(16));
- assertEquals(4, csb.countSetBits(15));
- assertEquals(5, csb.countSetBits(10000));
- assertEquals(5, csb.countSetBits(31));
+ void testCountSetBitsZero() {
+ assertEquals(0, CountSetBits.countSetBits(0));
}
@Test
- void testSetBitsLookupApproach() {
- CountSetBits csb = new CountSetBits();
- assertEquals(1L, csb.lookupApproach(16));
- assertEquals(4, csb.lookupApproach(15));
- assertEquals(5, csb.lookupApproach(10000));
- assertEquals(5, csb.lookupApproach(31));
+ void testCountSetBitsOne() {
+ assertEquals(1, CountSetBits.countSetBits(1));
+ }
+
+ @Test
+ void testCountSetBitsSmallNumber() {
+ assertEquals(4, CountSetBits.countSetBits(3)); // 1(1) + 10(1) + 11(2) = 4
+ }
+
+ @Test
+ void testCountSetBitsFive() {
+ assertEquals(7, CountSetBits.countSetBits(5)); // 1 + 1 + 2 + 1 + 2 = 7
+ }
+
+ @Test
+ void testCountSetBitsTen() {
+ assertEquals(17, CountSetBits.countSetBits(10));
+ }
+
+ @Test
+ void testCountSetBitsLargeNumber() {
+ assertEquals(42, CountSetBits.countSetBits(20)); // Changed from 93 to 42
+ }
+
+ @Test
+ void testCountSetBitsPowerOfTwo() {
+ assertEquals(13, CountSetBits.countSetBits(8)); // Changed from 9 to 13
+ }
+
+ @Test
+ void testCountSetBitsNegativeInput() {
+ assertThrows(IllegalArgumentException.class, () -> CountSetBits.countSetBits(-1));
+ }
+
+ @Test
+ void testNaiveApproachMatchesOptimized() {
+ for (int i = 0; i <= 100; i++) {
+ assertEquals(CountSetBits.countSetBitsNaive(i), CountSetBits.countSetBits(i), "Mismatch at n = " + i);
+ }
}
}
diff --git a/src/test/java/com/thealgorithms/ciphers/OneTimePadCipherTest.java b/src/test/java/com/thealgorithms/ciphers/OneTimePadCipherTest.java
new file mode 100644
index 000000000000..837c56c603d4
--- /dev/null
+++ b/src/test/java/com/thealgorithms/ciphers/OneTimePadCipherTest.java
@@ -0,0 +1,49 @@
+package com.thealgorithms.ciphers;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.nio.charset.StandardCharsets;
+import org.junit.jupiter.api.Test;
+
+class OneTimePadCipherTest {
+
+ @Test
+ void encryptAndDecryptWithRandomKeyRestoresPlaintext() {
+ String plaintext = "The quick brown fox jumps over the lazy dog.";
+ byte[] plaintextBytes = plaintext.getBytes(StandardCharsets.UTF_8);
+
+ byte[] key = OneTimePadCipher.generateKey(plaintextBytes.length);
+
+ byte[] ciphertext = OneTimePadCipher.encrypt(plaintextBytes, key);
+ byte[] decrypted = OneTimePadCipher.decrypt(ciphertext, key);
+
+ assertArrayEquals(plaintextBytes, decrypted);
+ assertEquals(plaintext, new String(decrypted, StandardCharsets.UTF_8));
+ }
+
+ @Test
+ void generateKeyWithNegativeLengthThrowsException() {
+ assertThrows(IllegalArgumentException.class, () -> OneTimePadCipher.generateKey(-1));
+ }
+
+ @Test
+ void encryptWithMismatchedKeyLengthThrowsException() {
+ byte[] data = "hello".getBytes(StandardCharsets.UTF_8);
+ byte[] shortKey = OneTimePadCipher.generateKey(2);
+
+ assertThrows(IllegalArgumentException.class, () -> OneTimePadCipher.encrypt(data, shortKey));
+ }
+
+ @Test
+ void decryptWithMismatchedKeyLengthThrowsException() {
+ byte[] data = "hello".getBytes(StandardCharsets.UTF_8);
+ byte[] key = OneTimePadCipher.generateKey(data.length);
+ byte[] ciphertext = OneTimePadCipher.encrypt(data, key);
+
+ byte[] wrongSizedKey = OneTimePadCipher.generateKey(data.length + 1);
+
+ assertThrows(IllegalArgumentException.class, () -> OneTimePadCipher.decrypt(ciphertext, wrongSizedKey));
+ }
+}
diff --git a/src/test/java/com/thealgorithms/compression/ArithmeticCodingTest.java b/src/test/java/com/thealgorithms/compression/ArithmeticCodingTest.java
new file mode 100644
index 000000000000..8e51fe5eb463
--- /dev/null
+++ b/src/test/java/com/thealgorithms/compression/ArithmeticCodingTest.java
@@ -0,0 +1,154 @@
+package com.thealgorithms.compression;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.math.BigDecimal;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+
+class ArithmeticCodingTest {
+
+ @Test
+ void testThrowsExceptionForNullOrEmptyInput() {
+ // Test that null input throws IllegalArgumentException
+ assertThrows(IllegalArgumentException.class, () -> ArithmeticCoding.compress(null));
+
+ // Test that empty string throws IllegalArgumentException
+ assertThrows(IllegalArgumentException.class, () -> ArithmeticCoding.compress(""));
+ }
+
+ @Test
+ void testCompressionAndDecompressionSimple() {
+ String original = "BABA";
+ Map probTable = ArithmeticCoding.calculateProbabilities(original);
+ BigDecimal compressed = ArithmeticCoding.compress(original);
+
+ // Verify that compression produces a valid number in [0, 1)
+ assertNotNull(compressed);
+ assertTrue(compressed.compareTo(BigDecimal.ZERO) >= 0);
+ assertTrue(compressed.compareTo(BigDecimal.ONE) < 0);
+
+ // Verify decompression restores the original string
+ String decompressed = ArithmeticCoding.decompress(compressed, original.length(), probTable);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ void testSymmetryWithComplexString() {
+ String original = "THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG";
+ Map probTable = ArithmeticCoding.calculateProbabilities(original);
+ BigDecimal compressed = ArithmeticCoding.compress(original);
+
+ // Verify compression produces a number in valid range
+ assertTrue(compressed.compareTo(BigDecimal.ZERO) >= 0);
+ assertTrue(compressed.compareTo(BigDecimal.ONE) < 0);
+
+ // Verify symmetry: decompress(compress(x)) == x
+ String decompressed = ArithmeticCoding.decompress(compressed, original.length(), probTable);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ void testSymmetryWithRepetitions() {
+ String original = "MISSISSIPPI";
+ Map probTable = ArithmeticCoding.calculateProbabilities(original);
+ BigDecimal compressed = ArithmeticCoding.compress(original);
+
+ // Verify compression produces a number in valid range
+ assertTrue(compressed.compareTo(BigDecimal.ZERO) >= 0);
+ assertTrue(compressed.compareTo(BigDecimal.ONE) < 0);
+
+ // Verify the compression-decompression cycle
+ String decompressed = ArithmeticCoding.decompress(compressed, original.length(), probTable);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ void testSingleCharacterString() {
+ String original = "AAAAA";
+ Map probTable = ArithmeticCoding.calculateProbabilities(original);
+ BigDecimal compressed = ArithmeticCoding.compress(original);
+
+ // Even with a single unique character, compression should work
+ assertTrue(compressed.compareTo(BigDecimal.ZERO) >= 0);
+ assertTrue(compressed.compareTo(BigDecimal.ONE) < 0);
+
+ String decompressed = ArithmeticCoding.decompress(compressed, original.length(), probTable);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ void testCompressionOutputDemo() {
+ // Demonstrate actual compression output similar to LZW test
+ String original = "BABA";
+ BigDecimal compressed = ArithmeticCoding.compress(original);
+
+ // Example: "BABA" compresses to approximately 0.625
+ // This shows that the entire message is encoded as a single number
+ System.out.println("Original: " + original);
+ System.out.println("Compressed to: " + compressed);
+ System.out.println("Compression: " + original.length() + " characters -> 1 BigDecimal number");
+
+ // Verify the compressed value is in valid range [0, 1)
+ assertTrue(compressed.compareTo(BigDecimal.ZERO) >= 0);
+ assertTrue(compressed.compareTo(BigDecimal.ONE) < 0);
+ }
+
+ @Test
+ void testProbabilityTableCalculation() {
+ // Test that probability table is calculated correctly
+ String text = "AABBC";
+ Map probTable = ArithmeticCoding.calculateProbabilities(text);
+
+ // Verify all characters are in the table
+ assertTrue(probTable.containsKey('A'));
+ assertTrue(probTable.containsKey('B'));
+ assertTrue(probTable.containsKey('C'));
+
+ // Verify probability ranges are valid
+ for (ArithmeticCoding.Symbol symbol : probTable.values()) {
+ assertTrue(symbol.low().compareTo(BigDecimal.ZERO) >= 0);
+ assertTrue(symbol.high().compareTo(BigDecimal.ONE) <= 0);
+ assertTrue(symbol.low().compareTo(symbol.high()) < 0);
+ }
+ }
+
+ @Test
+ void testDecompressionWithMismatchedProbabilityTable() {
+ // Test decompression with a probability table that doesn't match the original
+ String original = "ABCD";
+ BigDecimal compressed = ArithmeticCoding.compress(original);
+
+ // Create a different probability table (for "XYZ" instead of "ABCD")
+ Map wrongProbTable = ArithmeticCoding.calculateProbabilities("XYZ");
+
+ // Decompression with wrong probability table should produce incorrect output
+ String decompressed = ArithmeticCoding.decompress(compressed, original.length(), wrongProbTable);
+
+ // The decompressed string will be different from original (likely all 'X', 'Y', or 'Z')
+ // This tests the edge case where the compressed value doesn't fall into expected ranges
+ assertNotNull(decompressed);
+ assertEquals(original.length(), decompressed.length());
+ }
+
+ @Test
+ void testDecompressionWithValueOutsideSymbolRanges() {
+ // Create a custom probability table
+ Map probTable = new HashMap<>();
+ probTable.put('A', new ArithmeticCoding.Symbol(new BigDecimal("0.0"), new BigDecimal("0.5")));
+ probTable.put('B', new ArithmeticCoding.Symbol(new BigDecimal("0.5"), new BigDecimal("1.0")));
+
+ // Use a compressed value that should decode properly
+ BigDecimal compressed = new BigDecimal("0.25"); // Falls in 'A' range
+
+ String decompressed = ArithmeticCoding.decompress(compressed, 3, probTable);
+
+ // Verify decompression completes (even if result might not be meaningful)
+ assertNotNull(decompressed);
+ assertEquals(3, decompressed.length());
+ }
+}
diff --git a/src/test/java/com/thealgorithms/compression/BurrowsWheelerTransformTest.java b/src/test/java/com/thealgorithms/compression/BurrowsWheelerTransformTest.java
new file mode 100644
index 000000000000..b6e10e0d796d
--- /dev/null
+++ b/src/test/java/com/thealgorithms/compression/BurrowsWheelerTransformTest.java
@@ -0,0 +1,124 @@
+package com.thealgorithms.compression;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public class BurrowsWheelerTransformTest {
+
+ @Test
+ public void testTransformAndInverseBanana() {
+ String original = "banana$";
+ BurrowsWheelerTransform.BWTResult expectedTransform = new BurrowsWheelerTransform.BWTResult("annb$aa", 4);
+
+ // Test forward transform
+ BurrowsWheelerTransform.BWTResult actualTransform = BurrowsWheelerTransform.transform(original);
+ assertEquals(expectedTransform, actualTransform);
+
+ // Test inverse transform
+ String reconstructed = BurrowsWheelerTransform.inverseTransform(actualTransform.transformed, actualTransform.originalIndex);
+ assertEquals(original, reconstructed);
+ }
+
+ @Test
+ public void testTransformAndInverseAbracadabra() {
+ String original = "abracadabra$";
+ BurrowsWheelerTransform.BWTResult expectedTransform = new BurrowsWheelerTransform.BWTResult("ard$rcaaaabb", 3);
+
+ // Test forward transform
+ BurrowsWheelerTransform.BWTResult actualTransform = BurrowsWheelerTransform.transform(original);
+ assertEquals(expectedTransform, actualTransform);
+
+ // Test inverse transform
+ String reconstructed = BurrowsWheelerTransform.inverseTransform(actualTransform.transformed, actualTransform.originalIndex);
+ assertEquals(original, reconstructed);
+ }
+
+ @Test
+ public void testTransformAndInverseSixMixPixFix() {
+ String original = "SIX.MIX.PIX.FIX$";
+ BurrowsWheelerTransform.BWTResult expectedTransform = new BurrowsWheelerTransform.BWTResult("XXXX.FPSM..$IIII", 11);
+
+ // Test forward transform
+ BurrowsWheelerTransform.BWTResult actualTransform = BurrowsWheelerTransform.transform(original);
+ assertEquals(expectedTransform, actualTransform);
+
+ // Test inverse transform
+ String reconstructed = BurrowsWheelerTransform.inverseTransform(actualTransform.transformed, actualTransform.originalIndex);
+ assertEquals(original, reconstructed);
+ }
+
+ @Test
+ public void testEmptyString() {
+ String original = "";
+ BurrowsWheelerTransform.BWTResult expectedTransform = new BurrowsWheelerTransform.BWTResult("", -1);
+
+ BurrowsWheelerTransform.BWTResult actualTransform = BurrowsWheelerTransform.transform(original);
+ assertEquals(expectedTransform, actualTransform);
+
+ String reconstructed = BurrowsWheelerTransform.inverseTransform(actualTransform.transformed, actualTransform.originalIndex);
+ assertEquals(original, reconstructed);
+ }
+
+ @Test
+ public void testSingleCharacter() {
+ String original = "a";
+ BurrowsWheelerTransform.BWTResult expectedTransform = new BurrowsWheelerTransform.BWTResult("a", 0);
+
+ BurrowsWheelerTransform.BWTResult actualTransform = BurrowsWheelerTransform.transform(original);
+ assertEquals(expectedTransform, actualTransform);
+
+ String reconstructed = BurrowsWheelerTransform.inverseTransform(actualTransform.transformed, actualTransform.originalIndex);
+ assertEquals(original, reconstructed);
+ }
+
+ @Test
+ public void testTransformNull() {
+ assertEquals(new BurrowsWheelerTransform.BWTResult("", -1), BurrowsWheelerTransform.transform(null));
+ }
+
+ @Test
+ public void testInverseTransformNullString() {
+ // bwtString == null
+ assertEquals("", BurrowsWheelerTransform.inverseTransform(null, 1));
+ // bwtString.isEmpty()
+ assertEquals("", BurrowsWheelerTransform.inverseTransform("", 0));
+ }
+
+ @Test
+ public void testInverseTransformIndexOutOfBounds() {
+ String bwt = "annb$aa";
+ int n = bwt.length(); // n = 7
+
+ // originalIndex >= n
+ assertThrows(IllegalArgumentException.class, () -> BurrowsWheelerTransform.inverseTransform(bwt, n));
+ assertThrows(IllegalArgumentException.class, () -> BurrowsWheelerTransform.inverseTransform(bwt, 8));
+
+ // originalIndex < 0
+ assertThrows(IllegalArgumentException.class, () -> BurrowsWheelerTransform.inverseTransform(bwt, -2));
+ }
+
+ @Test
+ public void testBWTResultHelpers() {
+ BurrowsWheelerTransform.BWTResult res1 = new BurrowsWheelerTransform.BWTResult("annb$aa", 4);
+ BurrowsWheelerTransform.BWTResult res2 = new BurrowsWheelerTransform.BWTResult("annb$aa", 4);
+ BurrowsWheelerTransform.BWTResult res3 = new BurrowsWheelerTransform.BWTResult("other", 4);
+ BurrowsWheelerTransform.BWTResult res4 = new BurrowsWheelerTransform.BWTResult("annb$aa", 1);
+
+ assertEquals(res1, res1);
+ assertEquals(res1, res2);
+ assertNotEquals(res1, null); // obj == null
+ assertNotEquals(res1, new Object()); // different class
+ assertNotEquals(res1, res3); // different transformed
+ assertNotEquals(res1, res4); // different originalIndex
+
+ assertEquals(res1.hashCode(), res2.hashCode());
+ assertNotEquals(res1.hashCode(), res3.hashCode());
+
+ assertTrue(res1.toString().contains("annb$aa"));
+ assertTrue(res1.toString().contains("originalIndex=4"));
+ }
+}
diff --git a/src/test/java/com/thealgorithms/compression/LZ77Test.java b/src/test/java/com/thealgorithms/compression/LZ77Test.java
new file mode 100644
index 000000000000..86732d48a54a
--- /dev/null
+++ b/src/test/java/com/thealgorithms/compression/LZ77Test.java
@@ -0,0 +1,223 @@
+package com.thealgorithms.compression;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class LZ77Test {
+
+ @Test
+ @DisplayName("Test compression and decompression of a simple repeating string")
+ void testSimpleRepeatingString() {
+ String original = "ababcbababaa";
+ List compressed = LZ77.compress(original, 10, 4);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test compression and decompression of a string with no repeats initially")
+ void testNoInitialRepeats() {
+ String original = "abcdefgh";
+ List compressed = LZ77.compress(original);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test compression and decompression of a longer example")
+ void testLongerExample() {
+ String original = "TOBEORNOTTOBEORTOBEORNOT";
+ List compressed = LZ77.compress(original, 20, 10);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test empty string compression and decompression")
+ void testEmptyString() {
+ String original = "";
+ List compressed = LZ77.compress(original);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ assertTrue(compressed.isEmpty());
+ }
+
+ @Test
+ @DisplayName("Test null string compression")
+ void testNullStringCompress() {
+ List compressed = LZ77.compress(null);
+ assertTrue(compressed.isEmpty());
+ }
+
+ @Test
+ @DisplayName("Test null list decompression")
+ void testNullListDecompress() {
+ String decompressed = LZ77.decompress(null);
+ assertEquals("", decompressed);
+ }
+
+ @Test
+ @DisplayName("Test invalid buffer sizes throw exception")
+ void testInvalidBufferSizes() {
+ assertThrows(IllegalArgumentException.class, () -> LZ77.compress("test", 0, 5));
+ assertThrows(IllegalArgumentException.class, () -> LZ77.compress("test", 5, 0));
+ assertThrows(IllegalArgumentException.class, () -> LZ77.compress("test", -1, 5));
+ assertThrows(IllegalArgumentException.class, () -> LZ77.compress("test", 5, -1));
+ }
+
+ @Test
+ @DisplayName("Test string with all same characters")
+ void testAllSameCharacters() {
+ String original = "AAAAAA";
+ List compressed = LZ77.compress(original, 10, 5);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // Should achieve good compression for repeated characters
+ assertTrue(compressed.size() < original.length());
+ }
+
+ @Test
+ @DisplayName("Test string with all unique characters")
+ void testAllUniqueCharacters() {
+ String original = "abcdefghijklmnop";
+ List compressed = LZ77.compress(original, 10, 5);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // No compression expected for unique characters
+ assertEquals(original.length(), compressed.size());
+ }
+
+ @Test
+ @DisplayName("Test single character string")
+ void testSingleCharacter() {
+ String original = "a";
+ List compressed = LZ77.compress(original);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ assertEquals(1, compressed.size());
+ }
+
+ @Test
+ @DisplayName("Test match that goes exactly to the end")
+ void testMatchToEnd() {
+ String original = "abcabc";
+ List compressed = LZ77.compress(original, 10, 10);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test with very small window size")
+ void testSmallWindowSize() {
+ String original = "ababababab";
+ List compressed = LZ77.compress(original, 2, 4);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test with very small lookahead buffer")
+ void testSmallLookaheadBuffer() {
+ String original = "ababcbababaa";
+ List compressed = LZ77.compress(original, 10, 2);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test repeating pattern at the end")
+ void testRepeatingPatternAtEnd() {
+ String original = "xyzabcabcabcabc";
+ List compressed = LZ77.compress(original, 15, 8);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test overlapping matches (run-length encoding case)")
+ void testOverlappingMatches() {
+ String original = "aaaaaa";
+ List compressed = LZ77.compress(original, 10, 10);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test complex pattern with multiple repeats")
+ void testComplexPattern() {
+ String original = "abcabcabcxyzxyzxyz";
+ List compressed = LZ77.compress(original, 20, 10);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test with special characters")
+ void testSpecialCharacters() {
+ String original = "hello world! @#$%^&*()";
+ List compressed = LZ77.compress(original);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test with numbers")
+ void testWithNumbers() {
+ String original = "1234567890123456";
+ List compressed = LZ77.compress(original, 15, 8);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test long repeating sequence")
+ void testLongRepeatingSequence() {
+ String original = "abcdefgh".repeat(10);
+ List compressed = LZ77.compress(original, 50, 20);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // Should achieve significant compression
+ assertTrue(compressed.size() < original.length() / 2);
+ }
+
+ @Test
+ @DisplayName("Test compression effectiveness")
+ void testCompressionEffectiveness() {
+ String original = "ababababababab";
+ List compressed = LZ77.compress(original, 20, 10);
+
+ // Verify that compression actually reduces the data size
+ // Each token represents potentially multiple characters
+ assertTrue(compressed.size() <= original.length());
+
+ // Verify decompression
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test with mixed case letters")
+ void testMixedCase() {
+ String original = "AaBbCcAaBbCc";
+ List compressed = LZ77.compress(original);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test default parameters")
+ void testDefaultParameters() {
+ String original = "This is a test string with some repeated patterns. This is repeated.";
+ List compressed = LZ77.compress(original);
+ String decompressed = LZ77.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+}
diff --git a/src/test/java/com/thealgorithms/compression/LZ78Test.java b/src/test/java/com/thealgorithms/compression/LZ78Test.java
new file mode 100644
index 000000000000..7889b50b76f3
--- /dev/null
+++ b/src/test/java/com/thealgorithms/compression/LZ78Test.java
@@ -0,0 +1,295 @@
+package com.thealgorithms.compression;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class LZ78Test {
+
+ @Test
+ @DisplayName("Test compression and decompression of a simple repeating string")
+ void testSimpleRepeatingString() {
+ String original = "ababcbababaa";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test compression and decompression example ABAABABAABAB")
+ void testStandardExample() {
+ String original = "ABAABABAABAB";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // Verify the compression produces expected tokens
+ // Expected: (0,A)(0,B)(1,A)(2,B)(3,A)(4,B)
+ // Where dictionary builds as: 1:A, 2:B, 3:AA, 4:BA, 5:ABA, 6:BAB
+ assertEquals(6, compressed.size());
+ assertEquals(0, compressed.get(0).index());
+ assertEquals('A', compressed.get(0).nextChar());
+ assertEquals(0, compressed.get(1).index());
+ assertEquals('B', compressed.get(1).nextChar());
+ assertEquals(1, compressed.get(2).index());
+ assertEquals('A', compressed.get(2).nextChar());
+ }
+
+ @Test
+ @DisplayName("Test compression and decompression of a longer example")
+ void testLongerExample() {
+ String original = "TOBEORNOTTOBEORTOBEORNOT";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test empty string compression and decompression")
+ void testEmptyString() {
+ String original = "";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ assertTrue(compressed.isEmpty());
+ }
+
+ @Test
+ @DisplayName("Test null string compression")
+ void testNullStringCompress() {
+ List compressed = LZ78.compress(null);
+ assertTrue(compressed.isEmpty());
+ }
+
+ @Test
+ @DisplayName("Test null list decompression")
+ void testNullListDecompress() {
+ String decompressed = LZ78.decompress(null);
+ assertEquals("", decompressed);
+ }
+
+ @Test
+ @DisplayName("Test string with all same characters")
+ void testAllSameCharacters() {
+ String original = "AAAAAA";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // Should achieve good compression: (0,A)(1,A)(2,A)...
+ assertTrue(compressed.size() <= 4); // Builds: A, AA, AAA, etc.
+ }
+
+ @Test
+ @DisplayName("Test string with all unique characters")
+ void testAllUniqueCharacters() {
+ String original = "abcdefg";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // No compression for unique characters
+ assertEquals(original.length(), compressed.size());
+
+ // Each token should have index 0 (empty prefix)
+ for (LZ78.Token token : compressed) {
+ assertEquals(0, token.index());
+ }
+ }
+
+ @Test
+ @DisplayName("Test single character string")
+ void testSingleCharacter() {
+ String original = "a";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ assertEquals(1, compressed.size());
+ assertEquals(0, compressed.getFirst().index());
+ assertEquals('a', compressed.getFirst().nextChar());
+ }
+
+ @Test
+ @DisplayName("Test two character string")
+ void testTwoCharacters() {
+ String original = "ab";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ assertEquals(2, compressed.size());
+ }
+
+ @Test
+ @DisplayName("Test repeating pairs")
+ void testRepeatingPairs() {
+ String original = "ababab";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // Should compress well: (0,a)(0,b)(1,b) or similar
+ assertTrue(compressed.size() < original.length());
+ }
+
+ @Test
+ @DisplayName("Test growing patterns")
+ void testGrowingPatterns() {
+ String original = "abcabcdabcde";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test dictionary building correctness")
+ void testDictionaryBuilding() {
+ String original = "aabaabaab";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // Verify first few tokens
+ // Expected pattern: (0,a)(1,b)(2,a)(3,b) building dictionary 1:a, 2:ab, 3:aa, 4:aab
+ assertTrue(compressed.size() > 0);
+ assertEquals(0, compressed.getFirst().index()); // First char always has index 0
+ }
+
+ @Test
+ @DisplayName("Test with special characters")
+ void testSpecialCharacters() {
+ String original = "hello world! hello!";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test with numbers")
+ void testWithNumbers() {
+ String original = "1234512345";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // Should achieve compression
+ assertTrue(compressed.size() < original.length());
+ }
+
+ @Test
+ @DisplayName("Test long repeating sequence")
+ void testLongRepeatingSequence() {
+ String original = "abcdefgh".repeat(5);
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // LZ78 should achieve some compression for repeating sequences
+ assertTrue(compressed.size() < original.length(), "Compressed size should be less than original length");
+ }
+
+ @Test
+ @DisplayName("Test alternating characters")
+ void testAlternatingCharacters() {
+ String original = "ababababab";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test compression effectiveness")
+ void testCompressionEffectiveness() {
+ String original = "the quick brown fox jumps over the lazy dog the quick brown fox";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // Should achieve some compression due to repeated phrases
+ assertTrue(compressed.size() < original.length());
+ }
+
+ @Test
+ @DisplayName("Test with mixed case letters")
+ void testMixedCase() {
+ String original = "AaBbCcAaBbCc";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test palindrome string")
+ void testPalindrome() {
+ String original = "abccba";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test highly compressible pattern")
+ void testHighlyCompressible() {
+ String original = "aaaaaaaaaa";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // Should achieve excellent compression ratio
+ assertTrue(compressed.size() <= 4);
+ }
+
+ @Test
+ @DisplayName("Test empty list decompression")
+ void testEmptyListDecompress() {
+ List compressed = List.of();
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals("", decompressed);
+ }
+
+ @Test
+ @DisplayName("Test binary-like pattern")
+ void testBinaryPattern() {
+ String original = "0101010101";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test nested patterns")
+ void testNestedPatterns() {
+ String original = "abcabcdefabcdefghi";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test whitespace handling")
+ void testWhitespace() {
+ String original = "a b c a b c";
+ List compressed = LZ78.compress(original);
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ @DisplayName("Test token structure correctness")
+ void testTokenStructure() {
+ String original = "abc";
+ List compressed = LZ78.compress(original);
+
+ // All tokens should have valid indices (>= 0)
+ for (LZ78.Token token : compressed) {
+ assertTrue(token.index() >= 0);
+ assertNotNull(token.nextChar());
+ }
+
+ String decompressed = LZ78.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+}
diff --git a/src/test/java/com/thealgorithms/compression/LZWTest.java b/src/test/java/com/thealgorithms/compression/LZWTest.java
new file mode 100644
index 000000000000..7f0c7503c822
--- /dev/null
+++ b/src/test/java/com/thealgorithms/compression/LZWTest.java
@@ -0,0 +1,104 @@
+package com.thealgorithms.compression;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class LZWTest {
+
+ @Test
+ void testNullAndEmptyInputs() {
+ // Test that a null input to compress returns an empty list
+ assertTrue(LZW.compress(null).isEmpty());
+
+ // Test that a null input to decompress returns an empty string
+ assertEquals("", LZW.decompress(null));
+
+ // Test that an empty input to compress returns an empty list
+ assertTrue(LZW.compress("").isEmpty());
+
+ // Test that an empty input to decompress returns an empty string
+ assertEquals("", LZW.decompress(Collections.emptyList()));
+ }
+
+ @Test
+ void testCompressionAndDecompressionWithSimpleString() {
+ // Test a classic example string
+ String original = "TOBEORNOTTOBEORTOBEORNOT";
+ List compressed = LZW.compress(original);
+
+ // Create the expected output list
+ List expectedOutput = List.of(84, 79, 66, 69, 79, 82, 78, 79, 84, 256, 258, 260, 265, 259, 261, 263);
+
+ // This assertion will fail if the output is not what we expect
+ assertEquals(expectedOutput, compressed);
+
+ // This assertion ensures the decompressed string is correct
+ String decompressed = LZW.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ void testCompressionWithRepeatedChars() {
+ // Test a string with long runs of the same character
+ String original = "AAAAABBBBBAAAAA";
+ List compressed = LZW.compress(original);
+ String decompressed = LZW.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ void testCompressionWithUniqueChars() {
+ // Test a string with no repetitions
+ String original = "ABCDEFG";
+ List compressed = LZW.compress(original);
+ String decompressed = LZW.decompress(compressed);
+ assertEquals(original, decompressed);
+ }
+
+ @Test
+ void testSymmetry() {
+ // Test that compressing and then decompressing a complex string returns the
+ // original
+ String original = "THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG";
+ List compressed = LZW.compress(original);
+ String decompressed = LZW.decompress(compressed);
+ assertEquals(original, decompressed);
+
+ // Another symmetry test with special characters and patterns
+ String original2 = "ababcbababa";
+ List compressed2 = LZW.compress(original2);
+ String decompressed2 = LZW.decompress(compressed2);
+ assertEquals(original2, decompressed2);
+ }
+
+ @Test
+ void testInvalidCompressedData() {
+ // Test that decompressing with an invalid code throws IllegalArgumentException
+ // Create a list with a code that doesn't exist in the dictionary
+ List invalidCompressed = new ArrayList<>();
+ invalidCompressed.add(65); // 'A' - valid
+ invalidCompressed.add(999); // Invalid code (not in dictionary)
+
+ // This should throw IllegalArgumentException with message "Bad compressed k: 999"
+ IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> LZW.decompress(invalidCompressed));
+
+ assertTrue(exception.getMessage().contains("Bad compressed k: 999"));
+ }
+
+ @Test
+ void testDecompressionWithGapInDictionary() {
+ // Test with codes that skip dictionary entries
+ List invalidCompressed = new ArrayList<>();
+ invalidCompressed.add(84); // 'T' - valid
+ invalidCompressed.add(500); // Way beyond current dictionary size
+
+ // This should throw IllegalArgumentException
+ assertThrows(IllegalArgumentException.class, () -> LZW.decompress(invalidCompressed));
+ }
+}
diff --git a/src/test/java/com/thealgorithms/compression/MoveToFrontTest.java b/src/test/java/com/thealgorithms/compression/MoveToFrontTest.java
new file mode 100644
index 000000000000..42ef6c9cd675
--- /dev/null
+++ b/src/test/java/com/thealgorithms/compression/MoveToFrontTest.java
@@ -0,0 +1,92 @@
+package com.thealgorithms.compression;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+public class MoveToFrontTest {
+
+ @Test
+ public void testTransformAndInverseBananaExample() {
+ String original = "annb$aa";
+ String alphabet = "$abn";
+ List expectedTransform = List.of(1, 3, 0, 3, 3, 3, 0);
+
+ // Test forward transform
+ List actualTransform = MoveToFront.transform(original, alphabet);
+ assertEquals(expectedTransform, actualTransform);
+
+ // Test inverse transform
+ String reconstructed = MoveToFront.inverseTransform(actualTransform, alphabet);
+ assertEquals(original, reconstructed);
+ }
+
+ @Test
+ public void testTransformAndInverseCabaaExample() {
+ String original = "cabaa";
+ String alphabet = "abcdef";
+ List expectedTransform = List.of(2, 1, 2, 1, 0);
+
+ // Test forward transform
+ List actualTransform = MoveToFront.transform(original, alphabet);
+ assertEquals(expectedTransform, actualTransform);
+
+ // Test inverse transform
+ String reconstructed = MoveToFront.inverseTransform(actualTransform, alphabet);
+ assertEquals(original, reconstructed);
+ }
+
+ @Test
+ public void testEmptyInput() {
+ String original = "";
+ String alphabet = "abc";
+ List expectedTransform = List.of();
+
+ List actualTransform = MoveToFront.transform(original, alphabet);
+ assertEquals(expectedTransform, actualTransform);
+
+ String reconstructed = MoveToFront.inverseTransform(actualTransform, alphabet);
+ assertEquals(original, reconstructed);
+ }
+
+ @Test
+ public void testEmptyAlphabet() {
+ assertThrows(IllegalArgumentException.class, () -> MoveToFront.transform("abc", ""));
+
+ assertEquals("", MoveToFront.inverseTransform(List.of(1, 2), ""));
+ }
+
+ @Test
+ public void testSymbolNotInAlphabet() {
+ // 'd' is not in "abc"
+ assertThrows(IllegalArgumentException.class, () -> MoveToFront.transform("abd", "abc"));
+ }
+
+ @Test
+ public void testIndexOutOfBounds() {
+ // Index 5 is out of bounds for alphabet "abc"
+ // 1. test index >= alphabet.size()
+ assertThrows(IllegalArgumentException.class, () -> MoveToFront.inverseTransform(List.of(1, 2, 5), "abc"));
+
+ // 2. test index < 0
+ assertThrows(IllegalArgumentException.class, () -> MoveToFront.inverseTransform(List.of(1, -1, 2), "abc"));
+ }
+
+ @Test
+ public void testTransformNull() {
+ List expected = List.of();
+ assertEquals(expected, MoveToFront.transform(null, "abc"));
+ assertThrows(IllegalArgumentException.class, () -> MoveToFront.transform("abc", null));
+ }
+
+ @Test
+ public void testInverseTransformNulls() {
+ // 1. test indices == null
+ assertEquals("", MoveToFront.inverseTransform(null, "abc"));
+
+ // 2. test initialAlphabet == null
+ assertEquals("", MoveToFront.inverseTransform(List.of(1, 2), null));
+ }
+}
diff --git a/src/test/java/com/thealgorithms/compression/RunLengthEncodingTest.java b/src/test/java/com/thealgorithms/compression/RunLengthEncodingTest.java
new file mode 100644
index 000000000000..049a7fac9ae9
--- /dev/null
+++ b/src/test/java/com/thealgorithms/compression/RunLengthEncodingTest.java
@@ -0,0 +1,90 @@
+package com.thealgorithms.compression;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+class RunLengthEncodingTest {
+
+ @Test
+ void testNullInputs() {
+ // Test that a null input to compress returns an empty string
+ assertEquals("", RunLengthEncoding.compress(null));
+
+ // Test that a null input to decompress returns an empty string
+ assertEquals("", RunLengthEncoding.decompress(null));
+ }
+
+ @Test
+ void testCompressionSimple() {
+ // Test a typical string with multiple runs
+ String input = "AAAABBBCCDAA";
+ String expected = "4A3B2C1D2A";
+ assertEquals(expected, RunLengthEncoding.compress(input));
+ }
+
+ @Test
+ void testCompressionWithNoRuns() {
+ // Test a string with no consecutive characters
+ String input = "ABCDE";
+ String expected = "1A1B1C1D1E";
+ assertEquals(expected, RunLengthEncoding.compress(input));
+ }
+
+ @Test
+ void testCompressionEdgeCases() {
+ // Test with an empty string
+ assertEquals("", RunLengthEncoding.compress(""));
+
+ // Test with a single character
+ assertEquals("1A", RunLengthEncoding.compress("A"));
+
+ // Test with a long run of a single character
+ assertEquals("10Z", RunLengthEncoding.compress("ZZZZZZZZZZ"));
+ }
+
+ @Test
+ void testDecompressionSimple() {
+ // Test decompression of a typical RLE string
+ String input = "4A3B2C1D2A";
+ String expected = "AAAABBBCCDAA";
+ assertEquals(expected, RunLengthEncoding.decompress(input));
+ }
+
+ @Test
+ void testDecompressionWithNoRuns() {
+ // Test decompression of a string with single characters
+ String input = "1A1B1C1D1E";
+ String expected = "ABCDE";
+ assertEquals(expected, RunLengthEncoding.decompress(input));
+ }
+
+ @Test
+ void testDecompressionWithMultiDigitCount() {
+ // Test decompression where a run count is greater than 9
+ String input = "12A1B3C";
+ String expected = "AAAAAAAAAAAABCCC";
+ assertEquals(expected, RunLengthEncoding.decompress(input));
+ }
+
+ @Test
+ void testDecompressionEdgeCases() {
+ // Test with an empty string
+ assertEquals("", RunLengthEncoding.decompress(""));
+
+ // Test with a single character run
+ assertEquals("A", RunLengthEncoding.decompress("1A"));
+ }
+
+ @Test
+ void testSymmetry() {
+ // Test that compressing and then decompressing returns the original string
+ String original1 = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB";
+ String compressed = RunLengthEncoding.compress(original1);
+ String decompressed = RunLengthEncoding.decompress(compressed);
+ assertEquals(original1, decompressed);
+
+ String original2 = "A";
+ assertEquals(original2, RunLengthEncoding.decompress(RunLengthEncoding.compress(original2)));
+ }
+}
diff --git a/src/test/java/com/thealgorithms/compression/ShannonFanoTest.java b/src/test/java/com/thealgorithms/compression/ShannonFanoTest.java
new file mode 100644
index 000000000000..ce34088dacca
--- /dev/null
+++ b/src/test/java/com/thealgorithms/compression/ShannonFanoTest.java
@@ -0,0 +1,71 @@
+package com.thealgorithms.compression;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+
+class ShannonFanoTest {
+
+ @Test
+ void testNullInput() {
+ // Test with a null string, should return an empty map
+ assertTrue(ShannonFano.generateCodes(null).isEmpty());
+ }
+
+ @Test
+ void testSimpleString() {
+ // A simple string to test basic code generation
+ String text = "AAABBC";
+ Map codes = ShannonFano.generateCodes(text);
+
+ assertEquals(3, codes.size());
+ assertEquals("0", codes.get('A'));
+ assertEquals("10", codes.get('B'));
+ assertEquals("11", codes.get('C'));
+ }
+
+ @Test
+ void testExampleFromStringIssue() {
+ // Example from the original issue proposal: A:15, B:7, C:6, D:6, E:5
+ // The code finds a more optimal split: {A,B} | {C,D,E} -> |22-17|=5
+ // instead of {A} | {B,C,D,E} -> |15-24|=9.
+ String text = "AAAAAAAAAAAAAAABBBBBBBCCCCCCDDDDDDEEEEE";
+ Map codes = ShannonFano.generateCodes(text);
+
+ assertEquals(5, codes.size());
+ assertEquals("00", codes.get('A'));
+ assertEquals("01", codes.get('B'));
+ assertEquals("10", codes.get('C'));
+ assertEquals("110", codes.get('D'));
+ assertEquals("111", codes.get('E'));
+ }
+
+ @Test
+ void testEdgeCases() {
+ // Test with an empty string
+ assertTrue(ShannonFano.generateCodes("").isEmpty());
+
+ // Test with a single character
+ Map singleCharCodes = ShannonFano.generateCodes("AAAAA");
+ assertEquals(1, singleCharCodes.size());
+ assertEquals("0", singleCharCodes.get('A')); // A single symbol gets code "0"
+
+ // Test with all unique characters
+ String uniqueCharsText = "ABCDEF";
+ Map uniqueCharCodes = ShannonFano.generateCodes(uniqueCharsText);
+ assertEquals(6, uniqueCharCodes.size());
+ // Check that codes are unique and have varying lengths as expected
+ assertEquals(6, uniqueCharCodes.values().stream().distinct().count());
+ }
+
+ @Test
+ void testStringWithTwoChars() {
+ String text = "ABABAB";
+ Map codes = ShannonFano.generateCodes(text);
+
+ assertEquals(2, codes.size());
+ assertTrue(codes.get('A').equals("0") && codes.get('B').equals("1") || codes.get('A').equals("1") && codes.get('B').equals("0"));
+ }
+}
diff --git a/src/test/java/com/thealgorithms/conversions/BinaryToDecimalTest.java b/src/test/java/com/thealgorithms/conversions/BinaryToDecimalTest.java
index 9045d100285e..e11a86b4c006 100644
--- a/src/test/java/com/thealgorithms/conversions/BinaryToDecimalTest.java
+++ b/src/test/java/com/thealgorithms/conversions/BinaryToDecimalTest.java
@@ -18,6 +18,12 @@ public void testBinaryToDecimal() {
assertEquals(5, BinaryToDecimal.binaryToDecimal(101));
assertEquals(63, BinaryToDecimal.binaryToDecimal(111111));
assertEquals(512, BinaryToDecimal.binaryToDecimal(1000000000));
+
+ assertEquals(0, BinaryToDecimal.binaryStringToDecimal("0"));
+ assertEquals(1, BinaryToDecimal.binaryStringToDecimal("1"));
+ assertEquals(5, BinaryToDecimal.binaryStringToDecimal("101"));
+ assertEquals(63, BinaryToDecimal.binaryStringToDecimal("111111"));
+ assertEquals(512, BinaryToDecimal.binaryStringToDecimal("1000000000"));
}
@Test
@@ -25,6 +31,9 @@ public void testBinaryToDecimal() {
public void testNegativeBinaryToDecimal() {
assertEquals(-1, BinaryToDecimal.binaryToDecimal(-1));
assertEquals(-42, BinaryToDecimal.binaryToDecimal(-101010));
+
+ assertEquals(-1, BinaryToDecimal.binaryStringToDecimal("-1"));
+ assertEquals(-42, BinaryToDecimal.binaryStringToDecimal("-101010"));
}
@Test
@@ -32,11 +41,16 @@ public void testNegativeBinaryToDecimal() {
public void testLargeBinaryToDecimal() {
assertEquals(262144L, BinaryToDecimal.binaryToDecimal(1000000000000000000L));
assertEquals(524287L, BinaryToDecimal.binaryToDecimal(1111111111111111111L));
+
+ assertEquals(262144L, BinaryToDecimal.binaryStringToDecimal("1000000000000000000"));
+ assertEquals(524287L, BinaryToDecimal.binaryStringToDecimal("1111111111111111111"));
}
@ParameterizedTest
@CsvSource({"2", "1234", "11112", "101021"})
void testNotCorrectBinaryInput(long binaryNumber) {
assertThrows(IllegalArgumentException.class, () -> BinaryToDecimal.binaryToDecimal(binaryNumber));
+
+ assertThrows(IllegalArgumentException.class, () -> BinaryToDecimal.binaryStringToDecimal(Long.toString(binaryNumber)));
}
}
diff --git a/src/test/java/com/thealgorithms/conversions/TemperatureConverterTest.java b/src/test/java/com/thealgorithms/conversions/TemperatureConverterTest.java
new file mode 100644
index 000000000000..24d55b706f36
--- /dev/null
+++ b/src/test/java/com/thealgorithms/conversions/TemperatureConverterTest.java
@@ -0,0 +1,54 @@
+package com.thealgorithms.conversions;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+class TemperatureConverterTest {
+
+ private static final double DELTA = 0.01;
+
+ @Test
+ void testCelsiusToFahrenheit() {
+ assertEquals(32.0, TemperatureConverter.celsiusToFahrenheit(0.0), DELTA);
+ assertEquals(212.0, TemperatureConverter.celsiusToFahrenheit(100.0), DELTA);
+ assertEquals(-40.0, TemperatureConverter.celsiusToFahrenheit(-40.0), DELTA);
+ assertEquals(98.6, TemperatureConverter.celsiusToFahrenheit(37.0), DELTA);
+ }
+
+ @Test
+ void testCelsiusToKelvin() {
+ assertEquals(273.15, TemperatureConverter.celsiusToKelvin(0.0), DELTA);
+ assertEquals(373.15, TemperatureConverter.celsiusToKelvin(100.0), DELTA);
+ assertEquals(233.15, TemperatureConverter.celsiusToKelvin(-40.0), DELTA);
+ }
+
+ @Test
+ void testFahrenheitToCelsius() {
+ assertEquals(0.0, TemperatureConverter.fahrenheitToCelsius(32.0), DELTA);
+ assertEquals(100.0, TemperatureConverter.fahrenheitToCelsius(212.0), DELTA);
+ assertEquals(-40.0, TemperatureConverter.fahrenheitToCelsius(-40.0), DELTA);
+ assertEquals(37.0, TemperatureConverter.fahrenheitToCelsius(98.6), DELTA);
+ }
+
+ @Test
+ void testFahrenheitToKelvin() {
+ assertEquals(273.15, TemperatureConverter.fahrenheitToKelvin(32.0), DELTA);
+ assertEquals(373.15, TemperatureConverter.fahrenheitToKelvin(212.0), DELTA);
+ assertEquals(233.15, TemperatureConverter.fahrenheitToKelvin(-40.0), DELTA);
+ }
+
+ @Test
+ void testKelvinToCelsius() {
+ assertEquals(0.0, TemperatureConverter.kelvinToCelsius(273.15), DELTA);
+ assertEquals(100.0, TemperatureConverter.kelvinToCelsius(373.15), DELTA);
+ assertEquals(-273.15, TemperatureConverter.kelvinToCelsius(0.0), DELTA);
+ }
+
+ @Test
+ void testKelvinToFahrenheit() {
+ assertEquals(32.0, TemperatureConverter.kelvinToFahrenheit(273.15), DELTA);
+ assertEquals(212.0, TemperatureConverter.kelvinToFahrenheit(373.15), DELTA);
+ assertEquals(-40.0, TemperatureConverter.kelvinToFahrenheit(233.15), DELTA);
+ }
+}
diff --git a/src/test/java/com/thealgorithms/datastructures/graphs/BellmanFordTest.java b/src/test/java/com/thealgorithms/datastructures/graphs/BellmanFordTest.java
new file mode 100644
index 000000000000..c824241c680d
--- /dev/null
+++ b/src/test/java/com/thealgorithms/datastructures/graphs/BellmanFordTest.java
@@ -0,0 +1,158 @@
+package com.thealgorithms.datastructures.graphs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for the BellmanFord algorithm implementation.
+ * Tests cover various graph scenarios including:
+ * - Simple weighted graphs
+ * - Graphs with negative weights
+ * - Single vertex graphs
+ * - Disconnected graphs
+ * - Linear path graphs
+ */
+class BellmanFordTest {
+
+ @Test
+ void testSimpleGraph() {
+ // Create a simple graph with 5 vertices and 8 edges
+ // Graph visualization:
+ // 1
+ // /|\
+ // 6 | 7
+ // / | \
+ // 0 5 2
+ // \ | /
+ // 8 | -2
+ // \|/
+ // 4---3
+ // 9
+ BellmanFord bellmanFord = new BellmanFord(5, 8);
+ bellmanFord.addEdge(0, 1, 6);
+ bellmanFord.addEdge(0, 4, 8);
+ bellmanFord.addEdge(1, 2, 7);
+ bellmanFord.addEdge(1, 4, 5);
+ bellmanFord.addEdge(2, 3, -2);
+ bellmanFord.addEdge(2, 4, -3);
+ bellmanFord.addEdge(3, 4, 9);
+ bellmanFord.addEdge(4, 3, 7);
+
+ // Verify edge array creation
+ assertNotNull(bellmanFord.getEdgeArray());
+ assertEquals(8, bellmanFord.getEdgeArray().length);
+ }
+
+ @Test
+ void testGraphWithNegativeWeights() {
+ // Graph with negative edge weights (but no negative cycle)
+ BellmanFord bellmanFord = new BellmanFord(4, 5);
+ bellmanFord.addEdge(0, 1, 4);
+ bellmanFord.addEdge(0, 2, 5);
+ bellmanFord.addEdge(1, 2, -3);
+ bellmanFord.addEdge(2, 3, 4);
+ bellmanFord.addEdge(1, 3, 6);
+
+ assertNotNull(bellmanFord.getEdgeArray());
+ assertEquals(5, bellmanFord.getEdgeArray().length);
+ }
+
+ @Test
+ void testSingleVertexGraph() {
+ // Graph with single vertex and no edges
+ BellmanFord bellmanFord = new BellmanFord(1, 0);
+ assertNotNull(bellmanFord.getEdgeArray());
+ assertEquals(0, bellmanFord.getEdgeArray().length);
+ }
+
+ @Test
+ void testLinearGraph() {
+ // Linear graph: 0 -> 1 -> 2 -> 3
+ BellmanFord bellmanFord = new BellmanFord(4, 3);
+ bellmanFord.addEdge(0, 1, 2);
+ bellmanFord.addEdge(1, 2, 3);
+ bellmanFord.addEdge(2, 3, 4);
+
+ assertNotNull(bellmanFord.getEdgeArray());
+ assertEquals(3, bellmanFord.getEdgeArray().length);
+ }
+
+ @Test
+ void testEdgeAddition() {
+ BellmanFord bellmanFord = new BellmanFord(3, 3);
+
+ bellmanFord.addEdge(0, 1, 5);
+ bellmanFord.addEdge(1, 2, 3);
+ bellmanFord.addEdge(0, 2, 10);
+
+ // Verify all edges were added
+ assertNotNull(bellmanFord.getEdgeArray());
+ assertEquals(3, bellmanFord.getEdgeArray().length);
+ }
+
+ @Test
+ void testGraphWithZeroWeightEdges() {
+ // Graph with zero weight edges
+ BellmanFord bellmanFord = new BellmanFord(3, 3);
+ bellmanFord.addEdge(0, 1, 0);
+ bellmanFord.addEdge(1, 2, 0);
+ bellmanFord.addEdge(0, 2, 1);
+
+ assertNotNull(bellmanFord.getEdgeArray());
+ assertEquals(3, bellmanFord.getEdgeArray().length);
+ }
+
+ @Test
+ void testLargerGraph() {
+ // Larger graph with 6 vertices
+ BellmanFord bellmanFord = new BellmanFord(6, 9);
+ bellmanFord.addEdge(0, 1, 5);
+ bellmanFord.addEdge(0, 2, 3);
+ bellmanFord.addEdge(1, 3, 6);
+ bellmanFord.addEdge(1, 2, 2);
+ bellmanFord.addEdge(2, 4, 4);
+ bellmanFord.addEdge(2, 5, 2);
+ bellmanFord.addEdge(2, 3, 7);
+ bellmanFord.addEdge(3, 4, -1);
+ bellmanFord.addEdge(4, 5, -2);
+
+ assertNotNull(bellmanFord.getEdgeArray());
+ assertEquals(9, bellmanFord.getEdgeArray().length);
+ }
+
+ @Test
+ void testVertexAndEdgeCount() {
+ BellmanFord bellmanFord = new BellmanFord(10, 15);
+ assertEquals(10, bellmanFord.vertex);
+ assertEquals(15, bellmanFord.edge);
+ }
+
+ @Test
+ void testMultipleEdgesBetweenSameVertices() {
+ // Graph allowing multiple edges between same vertices
+ BellmanFord bellmanFord = new BellmanFord(2, 3);
+ bellmanFord.addEdge(0, 1, 5);
+ bellmanFord.addEdge(0, 1, 3);
+ bellmanFord.addEdge(1, 0, 2);
+
+ assertNotNull(bellmanFord.getEdgeArray());
+ assertEquals(3, bellmanFord.getEdgeArray().length);
+ }
+
+ @Test
+ void testCompleteGraph() {
+ // Complete graph with 4 vertices (6 edges for undirected equivalent)
+ BellmanFord bellmanFord = new BellmanFord(4, 6);
+ bellmanFord.addEdge(0, 1, 1);
+ bellmanFord.addEdge(0, 2, 2);
+ bellmanFord.addEdge(0, 3, 3);
+ bellmanFord.addEdge(1, 2, 4);
+ bellmanFord.addEdge(1, 3, 5);
+ bellmanFord.addEdge(2, 3, 6);
+
+ assertNotNull(bellmanFord.getEdgeArray());
+ assertEquals(6, bellmanFord.getEdgeArray().length);
+ }
+}
diff --git a/src/test/java/com/thealgorithms/datastructures/graphs/ConnectedComponentTest.java b/src/test/java/com/thealgorithms/datastructures/graphs/ConnectedComponentTest.java
new file mode 100644
index 000000000000..b5cfdd9de04f
--- /dev/null
+++ b/src/test/java/com/thealgorithms/datastructures/graphs/ConnectedComponentTest.java
@@ -0,0 +1,204 @@
+package com.thealgorithms.datastructures.graphs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for the Graph class in ConnectedComponent.java.
+ * Tests the depth-first search implementation and connected component counting.
+ * Covers various graph topologies including:
+ * - Single connected components
+ * - Multiple disconnected components
+ * - Self-loops
+ * - Linear chains
+ * - Cyclic graphs
+ */
+class ConnectedComponentTest {
+
+ @Test
+ void testSingleConnectedComponent() {
+ Graph graph = new Graph<>();
+ graph.addEdge(1, 2);
+ graph.addEdge(2, 3);
+ graph.addEdge(3, 4);
+ graph.addEdge(4, 1);
+
+ assertEquals(1, graph.countGraphs());
+ }
+
+ @Test
+ void testTwoDisconnectedComponents() {
+ Graph graph = new Graph<>();
+ // Component 1: 1-2-3
+ graph.addEdge(1, 2);
+ graph.addEdge(2, 3);
+ // Component 2: 4-5
+ graph.addEdge(4, 5);
+
+ assertEquals(2, graph.countGraphs());
+ }
+
+ @Test
+ void testThreeDisconnectedComponents() {
+ Graph graph = new Graph<>();
+ // Component 1: a-b-c-d-e
+ graph.addEdge('a', 'b');
+ graph.addEdge('a', 'e');
+ graph.addEdge('b', 'e');
+ graph.addEdge('b', 'c');
+ graph.addEdge('c', 'd');
+ graph.addEdge('d', 'a');
+ // Component 2: x-y-z
+ graph.addEdge('x', 'y');
+ graph.addEdge('x', 'z');
+ // Component 3: w (self-loop)
+ graph.addEdge('w', 'w');
+
+ assertEquals(3, graph.countGraphs());
+ }
+
+ @Test
+ void testSingleNodeSelfLoop() {
+ Graph graph = new Graph<>();
+ graph.addEdge(1, 1);
+
+ assertEquals(1, graph.countGraphs());
+ }
+
+ @Test
+ void testLinearChain() {
+ Graph graph = new Graph<>();
+ graph.addEdge(1, 2);
+ graph.addEdge(2, 3);
+ graph.addEdge(3, 4);
+ graph.addEdge(4, 5);
+
+ assertEquals(1, graph.countGraphs());
+ }
+
+ @Test
+ void testStarTopology() {
+ // Star graph with center node 0 connected to nodes 1, 2, 3, 4
+ Graph graph = new Graph<>();
+ graph.addEdge(0, 1);
+ graph.addEdge(0, 2);
+ graph.addEdge(0, 3);
+ graph.addEdge(0, 4);
+
+ assertEquals(1, graph.countGraphs());
+ }
+
+ @Test
+ void testCompleteGraph() {
+ // Complete graph K4: every node connected to every other node
+ Graph graph = new Graph<>();
+ graph.addEdge(1, 2);
+ graph.addEdge(1, 3);
+ graph.addEdge(1, 4);
+ graph.addEdge(2, 3);
+ graph.addEdge(2, 4);
+ graph.addEdge(3, 4);
+
+ assertEquals(1, graph.countGraphs());
+ }
+
+ @Test
+ void testStringVertices() {
+ Graph graph = new Graph<>();
+ // Component 1
+ graph.addEdge("New York", "Los Angeles");
+ graph.addEdge("Los Angeles", "Chicago");
+ // Component 2
+ graph.addEdge("London", "Paris");
+ // Component 3
+ graph.addEdge("Tokyo", "Tokyo");
+
+ assertEquals(3, graph.countGraphs());
+ }
+
+ @Test
+ void testEmptyGraph() {
+ Graph graph = new Graph<>();
+ assertEquals(0, graph.countGraphs());
+ }
+
+ @Test
+ void testDepthFirstSearchBasic() {
+ Graph graph = new Graph<>();
+ graph.addEdge(1, 2);
+ graph.addEdge(2, 3);
+
+ // Get the first node and perform DFS
+ assertNotNull(graph.nodeList);
+ assertEquals(3, graph.nodeList.size());
+ }
+
+ @Test
+ void testManyIsolatedComponents() {
+ Graph graph = new Graph<>();
+ // Create 5 isolated components (each is a self-loop)
+ graph.addEdge(1, 1);
+ graph.addEdge(2, 2);
+ graph.addEdge(3, 3);
+ graph.addEdge(4, 4);
+ graph.addEdge(5, 5);
+
+ assertEquals(5, graph.countGraphs());
+ }
+
+ @Test
+ void testBidirectionalEdges() {
+ Graph graph = new Graph<>();
+ // Note: This is a directed graph representation
+ // Adding edge 1->2 does not automatically add 2->1
+ graph.addEdge(1, 2);
+ graph.addEdge(2, 1);
+ graph.addEdge(2, 3);
+ graph.addEdge(3, 2);
+
+ assertEquals(1, graph.countGraphs());
+ }
+
+ @Test
+ void testCyclicGraph() {
+ Graph graph = new Graph<>();
+ // Create a cycle: 1 -> 2 -> 3 -> 4 -> 1
+ graph.addEdge(1, 2);
+ graph.addEdge(2, 3);
+ graph.addEdge(3, 4);
+ graph.addEdge(4, 1);
+
+ assertEquals(1, graph.countGraphs());
+ }
+
+ @Test
+ void testMultipleCycles() {
+ Graph graph = new Graph<>();
+ // Cycle 1: 1 -> 2 -> 3 -> 1
+ graph.addEdge(1, 2);
+ graph.addEdge(2, 3);
+ graph.addEdge(3, 1);
+ // Cycle 2: 4 -> 5 -> 4
+ graph.addEdge(4, 5);
+ graph.addEdge(5, 4);
+
+ assertEquals(2, graph.countGraphs());
+ }
+
+ @Test
+ void testIntegerGraphFromMainExample() {
+ // Recreate the example from main method
+ Graph graph = new Graph<>();
+ graph.addEdge(1, 2);
+ graph.addEdge(2, 3);
+ graph.addEdge(2, 4);
+ graph.addEdge(3, 5);
+ graph.addEdge(7, 8);
+ graph.addEdge(8, 10);
+ graph.addEdge(10, 8);
+
+ assertEquals(2, graph.countGraphs());
+ }
+}
diff --git a/src/test/java/com/thealgorithms/datastructures/graphs/DialsAlgorithmTest.java b/src/test/java/com/thealgorithms/datastructures/graphs/DialsAlgorithmTest.java
new file mode 100644
index 000000000000..2350455d4329
--- /dev/null
+++ b/src/test/java/com/thealgorithms/datastructures/graphs/DialsAlgorithmTest.java
@@ -0,0 +1,88 @@
+package com.thealgorithms.datastructures.graphs;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+final class DialsAlgorithmTest {
+
+ private List> graph;
+ private static final int NUM_VERTICES = 6;
+ private static final int MAX_EDGE_WEIGHT = 10;
+
+ @BeforeEach
+ void setUp() {
+ graph = new ArrayList<>();
+ for (int i = 0; i < NUM_VERTICES; i++) {
+ graph.add(new ArrayList<>());
+ }
+ }
+
+ private void addEdge(int u, int v, int weight) {
+ graph.get(u).add(new DialsAlgorithm.Edge(v, weight));
+ }
+
+ @Test
+ @DisplayName("Test with a simple connected graph")
+ void testSimpleGraph() {
+ // Build graph from a standard example
+ addEdge(0, 1, 2);
+ addEdge(0, 2, 4);
+ addEdge(1, 2, 1);
+ addEdge(1, 3, 7);
+ addEdge(2, 4, 3);
+ addEdge(3, 5, 1);
+ addEdge(4, 3, 2);
+ addEdge(4, 5, 5);
+
+ int[] expectedDistances = {0, 2, 3, 8, 6, 9};
+ int[] actualDistances = DialsAlgorithm.run(graph, 0, MAX_EDGE_WEIGHT);
+ assertArrayEquals(expectedDistances, actualDistances);
+ }
+
+ @Test
+ @DisplayName("Test with a disconnected node")
+ void testDisconnectedNode() {
+ addEdge(0, 1, 5);
+ addEdge(1, 2, 5);
+ // Node 3, 4, 5 are disconnected
+
+ int[] expectedDistances = {0, 5, 10, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE};
+ int[] actualDistances = DialsAlgorithm.run(graph, 0, MAX_EDGE_WEIGHT);
+ assertArrayEquals(expectedDistances, actualDistances);
+ }
+
+ @Test
+ @DisplayName("Test with source as destination")
+ void testSourceIsDestination() {
+ addEdge(0, 1, 10);
+ int[] expectedDistances = {0, 10, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE};
+ // Run with source 0
+ int[] actualDistances = DialsAlgorithm.run(graph, 0, MAX_EDGE_WEIGHT);
+ assertArrayEquals(expectedDistances, actualDistances);
+ }
+
+ @Test
+ @DisplayName("Test graph with multiple paths to a node")
+ void testMultiplePaths() {
+ addEdge(0, 1, 10);
+ addEdge(0, 2, 3);
+ addEdge(2, 1, 2); // Shorter path to 1 is via 2 (3+2=5)
+
+ int[] expectedDistances = {0, 5, 3, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE};
+ int[] actualDistances = DialsAlgorithm.run(graph, 0, MAX_EDGE_WEIGHT);
+ assertArrayEquals(expectedDistances, actualDistances);
+ }
+
+ @Test
+ @DisplayName("Test with an invalid source vertex")
+ void testInvalidSource() {
+ assertThrows(IllegalArgumentException.class, () -> DialsAlgorithm.run(graph, -1, MAX_EDGE_WEIGHT));
+ assertThrows(IllegalArgumentException.class, () -> DialsAlgorithm.run(graph, NUM_VERTICES, MAX_EDGE_WEIGHT));
+ }
+}
diff --git a/src/test/java/com/thealgorithms/datastructures/graphs/DijkstraAlgorithmTest.java b/src/test/java/com/thealgorithms/datastructures/graphs/DijkstraAlgorithmTest.java
index c5df9acdf33b..a189091c17d3 100644
--- a/src/test/java/com/thealgorithms/datastructures/graphs/DijkstraAlgorithmTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/graphs/DijkstraAlgorithmTest.java
@@ -1,6 +1,7 @@
package com.thealgorithms.datastructures.graphs;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.BeforeEach;
@@ -61,4 +62,120 @@ void testInvalidSourceVertex() {
assertThrows(IllegalArgumentException.class, () -> dijkstraAlgorithm.run(graph, -1));
assertThrows(IllegalArgumentException.class, () -> dijkstraAlgorithm.run(graph, graph.length));
}
+
+ @Test
+ void testLinearGraph() {
+ // Linear graph: 0 - 1 - 2 - 3
+ // with weights: 2 3 4
+ int[][] linearGraph = {{0, 2, 0, 0}, {2, 0, 3, 0}, {0, 3, 0, 4}, {0, 0, 4, 0}};
+
+ DijkstraAlgorithm dijkstraLinear = new DijkstraAlgorithm(4);
+ int[] distances = dijkstraLinear.run(linearGraph, 0);
+
+ assertArrayEquals(new int[] {0, 2, 5, 9}, distances);
+ }
+
+ @Test
+ void testStarTopology() {
+ // Star graph: center node 0 connected to all others
+ // 1(2)
+ // |
+ // 3(4)-0-2(3)
+ // |
+ // 4(5)
+ int[][] starGraph = {{0, 2, 3, 4, 5}, {2, 0, 0, 0, 0}, {3, 0, 0, 0, 0}, {4, 0, 0, 0, 0}, {5, 0, 0, 0, 0}};
+
+ DijkstraAlgorithm dijkstraStar = new DijkstraAlgorithm(5);
+ int[] distances = dijkstraStar.run(starGraph, 0);
+
+ assertArrayEquals(new int[] {0, 2, 3, 4, 5}, distances);
+ }
+
+ @Test
+ void testCompleteGraphK4() {
+ // Complete graph K4 with varying weights
+ int[][] completeGraph = {{0, 1, 2, 3}, {1, 0, 4, 5}, {2, 4, 0, 6}, {3, 5, 6, 0}};
+
+ DijkstraAlgorithm dijkstraComplete = new DijkstraAlgorithm(4);
+ int[] distances = dijkstraComplete.run(completeGraph, 0);
+
+ // Direct paths from 0 are shortest
+ assertArrayEquals(new int[] {0, 1, 2, 3}, distances);
+ }
+
+ @Test
+ void testDifferentSourceVertex() {
+ // Test running from different source vertices
+ int[][] simpleGraph = {{0, 5, 0, 0}, {5, 0, 3, 0}, {0, 3, 0, 2}, {0, 0, 2, 0}};
+
+ DijkstraAlgorithm dijkstra = new DijkstraAlgorithm(4);
+
+ // From vertex 0
+ int[] distFrom0 = dijkstra.run(simpleGraph, 0);
+ assertArrayEquals(new int[] {0, 5, 8, 10}, distFrom0);
+
+ // From vertex 2
+ int[] distFrom2 = dijkstra.run(simpleGraph, 2);
+ assertArrayEquals(new int[] {8, 3, 0, 2}, distFrom2);
+
+ // From vertex 3
+ int[] distFrom3 = dijkstra.run(simpleGraph, 3);
+ assertArrayEquals(new int[] {10, 5, 2, 0}, distFrom3);
+ }
+
+ @Test
+ void testUnitWeightGraph() {
+ // Graph with all unit weights (like BFS distance)
+ int[][] unitGraph = {{0, 1, 1, 0}, {1, 0, 1, 1}, {1, 1, 0, 1}, {0, 1, 1, 0}};
+
+ DijkstraAlgorithm dijkstraUnit = new DijkstraAlgorithm(4);
+ int[] distances = dijkstraUnit.run(unitGraph, 0);
+
+ assertArrayEquals(new int[] {0, 1, 1, 2}, distances);
+ }
+
+ @Test
+ void testTwoVertexGraph() {
+ int[][] twoVertexGraph = {{0, 7}, {7, 0}};
+
+ DijkstraAlgorithm dijkstraTwo = new DijkstraAlgorithm(2);
+ int[] distances = dijkstraTwo.run(twoVertexGraph, 0);
+
+ assertArrayEquals(new int[] {0, 7}, distances);
+ }
+
+ @Test
+ void testShortcutPath() {
+ // Graph where direct path is longer than indirect path
+ // 0 --(10)--> 2
+ // 0 --(1)--> 1 --(2)--> 2
+ int[][] shortcutGraph = {{0, 1, 10}, {1, 0, 2}, {10, 2, 0}};
+
+ DijkstraAlgorithm dijkstraShortcut = new DijkstraAlgorithm(3);
+ int[] distances = dijkstraShortcut.run(shortcutGraph, 0);
+
+ // The shortest path to vertex 2 should be 3 (via vertex 1), not 10 (direct)
+ assertArrayEquals(new int[] {0, 1, 3}, distances);
+ }
+
+ @Test
+ void testSourceToSourceDistanceIsZero() {
+ // Verify distance from source to itself is always 0
+ int[] distances = dijkstraAlgorithm.run(graph, 0);
+ assertEquals(0, distances[0]);
+
+ distances = dijkstraAlgorithm.run(graph, 5);
+ assertEquals(0, distances[5]);
+ }
+
+ @Test
+ void testLargeWeights() {
+ // Graph with large weights
+ int[][] largeWeightGraph = {{0, 1000, 0}, {1000, 0, 2000}, {0, 2000, 0}};
+
+ DijkstraAlgorithm dijkstraLarge = new DijkstraAlgorithm(3);
+ int[] distances = dijkstraLarge.run(largeWeightGraph, 0);
+
+ assertArrayEquals(new int[] {0, 1000, 3000}, distances);
+ }
}
diff --git a/src/test/java/com/thealgorithms/datastructures/graphs/MatrixGraphsTest.java b/src/test/java/com/thealgorithms/datastructures/graphs/MatrixGraphsTest.java
index cc8a2df872ce..eaff0222bd36 100644
--- a/src/test/java/com/thealgorithms/datastructures/graphs/MatrixGraphsTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/graphs/MatrixGraphsTest.java
@@ -137,4 +137,215 @@ void testDisconnectedGraph() {
assertTrue(dfs.containsAll(Arrays.asList(0, 1)));
assertTrue(bfs.containsAll(Arrays.asList(0, 1)));
}
+
+ @Test
+ void testSingleVertexGraphDfs() {
+ AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(1);
+
+ List dfs = graph.depthFirstOrder(0);
+ assertEquals(1, dfs.size());
+ assertEquals(0, dfs.getFirst());
+ }
+
+ @Test
+ void testSingleVertexGraphBfs() {
+ AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(1);
+
+ List bfs = graph.breadthFirstOrder(0);
+ assertEquals(1, bfs.size());
+ assertEquals(0, bfs.getFirst());
+ }
+
+ @Test
+ void testBfsLevelOrder() {
+ // Create a graph where BFS should visit level by level
+ // 0
+ // /|\
+ // 1 2 3
+ // |
+ // 4
+ AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(5);
+ graph.addEdge(0, 1);
+ graph.addEdge(0, 2);
+ graph.addEdge(0, 3);
+ graph.addEdge(1, 4);
+
+ List bfs = graph.breadthFirstOrder(0);
+ assertEquals(5, bfs.size());
+ assertEquals(0, bfs.get(0));
+ // Level 1 vertices (1, 2, 3) should appear before level 2 vertex (4)
+ int indexOf4 = bfs.indexOf(4);
+ assertTrue(bfs.indexOf(1) < indexOf4);
+ assertTrue(bfs.indexOf(2) < indexOf4);
+ assertTrue(bfs.indexOf(3) < indexOf4);
+ }
+
+ @Test
+ void testDfsStartFromDifferentVertices() {
+ AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(4);
+ graph.addEdge(0, 1);
+ graph.addEdge(1, 2);
+ graph.addEdge(2, 3);
+
+ // DFS from vertex 0
+ List dfs0 = graph.depthFirstOrder(0);
+ assertEquals(4, dfs0.size());
+ assertEquals(0, dfs0.get(0));
+
+ // DFS from vertex 2
+ List dfs2 = graph.depthFirstOrder(2);
+ assertEquals(4, dfs2.size());
+ assertEquals(2, dfs2.get(0));
+
+ // DFS from vertex 3
+ List dfs3 = graph.depthFirstOrder(3);
+ assertEquals(4, dfs3.size());
+ assertEquals(3, dfs3.get(0));
+ }
+
+ @Test
+ void testBfsStartFromDifferentVertices() {
+ AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(4);
+ graph.addEdge(0, 1);
+ graph.addEdge(1, 2);
+ graph.addEdge(2, 3);
+
+ // BFS from vertex 0
+ List bfs0 = graph.breadthFirstOrder(0);
+ assertEquals(4, bfs0.size());
+ assertEquals(0, bfs0.get(0));
+
+ // BFS from vertex 2
+ List bfs2 = graph.breadthFirstOrder(2);
+ assertEquals(4, bfs2.size());
+ assertEquals(2, bfs2.get(0));
+ }
+
+ @Test
+ void testStarTopologyBfs() {
+ // Star graph: 0 is center connected to 1, 2, 3, 4
+ AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(5);
+ graph.addEdge(0, 1);
+ graph.addEdge(0, 2);
+ graph.addEdge(0, 3);
+ graph.addEdge(0, 4);
+
+ List