Merge branch 'master' into master

Author: DenizAltunkapan

.github/workflows/infer.yml

@@ -33,7 +33,7 @@ jobs:
 
       - name: Cache infer build
         id: cache-infer
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: infer
           key: ${{ runner.os }}-infer-${{ env.year_week }}

.gitpod.dockerfile

@@ -1,4 +1,4 @@
-FROM gitpod/workspace-java-21:2025-10-06-13-14-25
+FROM gitpod/workspace-java-21:2025-11-14-10-05-32
 
 ENV LLVM_SCRIPT="tmp_llvm.sh"
 

DIRECTORY.md

@@ -385,6 +385,7 @@
           - 📄 [Dinic](src/main/java/com/thealgorithms/graph/Dinic.java)
           - 📄 [Edmonds](src/main/java/com/thealgorithms/graph/Edmonds.java)
           - 📄 [EdmondsKarp](src/main/java/com/thealgorithms/graph/EdmondsKarp.java)
+          - 📄 [GomoryHuTree](src/main/java/com/thealgorithms/graph/GomoryHuTree.java)
           - 📄 [HierholzerAlgorithm](src/main/java/com/thealgorithms/graph/HierholzerAlgorithm.java)
           - 📄 [HierholzerEulerianPath](src/main/java/com/thealgorithms/graph/HierholzerEulerianPath.java)
           - 📄 [HopcroftKarp](src/main/java/com/thealgorithms/graph/HopcroftKarp.java)

pom.xml

@@ -42,7 +42,7 @@
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>5.20.0</version>
+            <version>5.21.0</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -112,7 +112,7 @@
                     <dependency>
                     <groupId>com.puppycrawl.tools</groupId>
                     <artifactId>checkstyle</artifactId>
-                    <version>12.1.2</version>
+                    <version>12.2.0</version>
                     </dependency>
                 </dependencies>
             </plugin>
@@ -127,7 +127,7 @@
                         <plugin>
                             <groupId>com.mebigfatguy.fb-contrib</groupId>
                             <artifactId>fb-contrib</artifactId>
-                            <version>7.7.0</version>
+                            <version>7.7.2</version>
                         </plugin>
                         <plugin>
                             <groupId>com.h3xstream.findsecbugs</groupId>

src/main/java/com/thealgorithms/backtracking/Combination.java

@@ -7,8 +7,7 @@
 import java.util.TreeSet;
 
 /**
- * Finds all permutations of given array
- * @author Alan Piao (<a href="https://github.com/cpiao3">git-Alan Piao</a>)
+ * Finds all combinations of a given array using backtracking algorithm * @author Alan Piao (<a href="https://github.com/cpiao3">git-Alan Piao</a>)
  */
 public final class Combination {
     private Combination() {

src/main/java/com/thealgorithms/ciphers/OneTimePadCipher.java

@@ -0,0 +1,89 @@
+package com.thealgorithms.ciphers;
+
+import java.security.SecureRandom;
+import java.util.Objects;
+
+/**
+ * One-Time Pad (OTP) cipher implementation.
+ *
+ * <p>The One-Time Pad is information-theoretically secure if:
+ * <ul>
+ *   <li>The key is truly random.</li>
+ *   <li>The key length is at least as long as the plaintext.</li>
+ *   <li>The key is used only once and kept secret.</li>
+ * </ul>
+ *
+ * <p>This implementation is for <b>educational purposes only</b> and should not be
+ * used in production systems.
+ */
+public final class OneTimePadCipher {
+
+    private static final SecureRandom RANDOM = new SecureRandom();
+
+    private OneTimePadCipher() {
+        // utility class
+    }
+
+    /**
+     * Generates a random key of the given length in bytes.
+     *
+     * @param length the length of the key in bytes, must be non-negative
+     * @return a new random key
+     * @throws IllegalArgumentException if length is negative
+     */
+    public static byte[] generateKey(int length) {
+        if (length < 0) {
+            throw new IllegalArgumentException("length must be non-negative");
+        }
+        byte[] key = new byte[length];
+        RANDOM.nextBytes(key);
+        return key;
+    }
+
+    /**
+     * Encrypts the given plaintext bytes using the provided key.
+     * <p>The key length must be exactly the same as the plaintext length.
+     *
+     * @param plaintext the plaintext bytes, must not be {@code null}
+     * @param key the one-time pad key bytes, must not be {@code null}
+     * @return the ciphertext bytes
+     * @throws IllegalArgumentException if the key length does not match plaintext length
+     * @throws NullPointerException if plaintext or key is {@code null}
+     */
+    public static byte[] encrypt(byte[] plaintext, byte[] key) {
+        validateInputs(plaintext, key);
+        return xor(plaintext, key);
+    }
+
+    /**
+     * Decrypts the given ciphertext bytes using the provided key.
+     * <p>For a One-Time Pad, decryption is identical to encryption:
+     * {@code plaintext = ciphertext XOR key}.
+     *
+     * @param ciphertext the ciphertext bytes, must not be {@code null}
+     * @param key the one-time pad key bytes, must not be {@code null}
+     * @return the decrypted plaintext bytes
+     * @throws IllegalArgumentException if the key length does not match ciphertext length
+     * @throws NullPointerException if ciphertext or key is {@code null}
+     */
+    public static byte[] decrypt(byte[] ciphertext, byte[] key) {
+        validateInputs(ciphertext, key);
+        return xor(ciphertext, key);
+    }
+
+    private static void validateInputs(byte[] input, byte[] key) {
+        Objects.requireNonNull(input, "input must not be null");
+        Objects.requireNonNull(key, "key must not be null");
+        if (input.length != key.length) {
+            throw new IllegalArgumentException("Key length must match input length");
+        }
+    }
+
+    private static byte[] xor(byte[] data, byte[] key) {
+        byte[] result = new byte[data.length];
+        for (int i = 0; i < data.length; i++) {
+            result[i] = (byte) (data[i] ^ key[i]);
+        }
+        return result;
+    }
+}

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.
+ *
+ * <p>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 <a href="https://en.wikipedia.org/wiki/Threaded_binary_tree">Wikipedia:
+ * Threaded binary tree</a>
+ */
+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<Integer> inorderTraversal() {
+        List<Integer> 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;
+    }
+}