Merge branch 'master' into LIFOCache

Author: KevinMwita7

DIRECTORY.md

@@ -1,5 +1,7 @@
 # Project Structure
 
+## src
+
 - 📁 **main**
   - 📁 **java**
     - 📁 **com**
@@ -165,12 +167,10 @@
             - 📄 [Kruskal](src/main/java/com/thealgorithms/datastructures/graphs/Kruskal.java)
             - 📄 [MatrixGraphs](src/main/java/com/thealgorithms/datastructures/graphs/MatrixGraphs.java)
             - 📄 [PrimMST](src/main/java/com/thealgorithms/datastructures/graphs/PrimMST.java)
-            - 📄 [README](src/main/java/com/thealgorithms/datastructures/graphs/README.md)
             - 📄 [TarjansAlgorithm](src/main/java/com/thealgorithms/datastructures/graphs/TarjansAlgorithm.java)
             - 📄 [UndirectedAdjacencyListGraph](src/main/java/com/thealgorithms/datastructures/graphs/UndirectedAdjacencyListGraph.java)
             - 📄 [WelshPowell](src/main/java/com/thealgorithms/datastructures/graphs/WelshPowell.java)
           - 📁 **hashmap**
-            - 📄 [Readme](src/main/java/com/thealgorithms/datastructures/hashmap/Readme.md)
             - 📁 **hashing**
               - 📄 [GenericHashMapUsingArray](src/main/java/com/thealgorithms/datastructures/hashmap/hashing/GenericHashMapUsingArray.java)
               - 📄 [GenericHashMapUsingArrayList](src/main/java/com/thealgorithms/datastructures/hashmap/hashing/GenericHashMapUsingArrayList.java)
@@ -194,7 +194,6 @@
             - 📄 [MergeKSortedArrays](src/main/java/com/thealgorithms/datastructures/heaps/MergeKSortedArrays.java)
             - 📄 [MinHeap](src/main/java/com/thealgorithms/datastructures/heaps/MinHeap.java)
             - 📄 [MinPriorityQueue](src/main/java/com/thealgorithms/datastructures/heaps/MinPriorityQueue.java)
-            - 📄 [Readme](src/main/java/com/thealgorithms/datastructures/heaps/Readme.md)
           - 📁 **lists**
             - 📄 [CircleLinkedList](src/main/java/com/thealgorithms/datastructures/lists/CircleLinkedList.java)
             - 📄 [CountSinglyLinkedListRecursion](src/main/java/com/thealgorithms/datastructures/lists/CountSinglyLinkedListRecursion.java)
@@ -205,7 +204,6 @@
             - 📄 [MergeSortedArrayList](src/main/java/com/thealgorithms/datastructures/lists/MergeSortedArrayList.java)
             - 📄 [MergeSortedSinglyLinkedList](src/main/java/com/thealgorithms/datastructures/lists/MergeSortedSinglyLinkedList.java)
             - 📄 [QuickSortLinkedList](src/main/java/com/thealgorithms/datastructures/lists/QuickSortLinkedList.java)
-            - 📄 [README](src/main/java/com/thealgorithms/datastructures/lists/README.md)
             - 📄 [RandomNode](src/main/java/com/thealgorithms/datastructures/lists/RandomNode.java)
             - 📄 [ReverseKGroup](src/main/java/com/thealgorithms/datastructures/lists/ReverseKGroup.java)
             - 📄 [RotateSinglyLinkedLists](src/main/java/com/thealgorithms/datastructures/lists/RotateSinglyLinkedLists.java)
@@ -222,12 +220,10 @@
             - 📄 [PriorityQueues](src/main/java/com/thealgorithms/datastructures/queues/PriorityQueues.java)
             - 📄 [Queue](src/main/java/com/thealgorithms/datastructures/queues/Queue.java)
             - 📄 [QueueByTwoStacks](src/main/java/com/thealgorithms/datastructures/queues/QueueByTwoStacks.java)
-            - 📄 [README](src/main/java/com/thealgorithms/datastructures/queues/README.md)
             - 📄 [SlidingWindowMaximum](src/main/java/com/thealgorithms/datastructures/queues/SlidingWindowMaximum.java)
             - 📄 [TokenBucket](src/main/java/com/thealgorithms/datastructures/queues/TokenBucket.java)
           - 📁 **stacks**
             - 📄 [NodeStack](src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java)
-            - 📄 [README](src/main/java/com/thealgorithms/datastructures/stacks/README.md)
             - 📄 [ReverseStack](src/main/java/com/thealgorithms/datastructures/stacks/ReverseStack.java)
             - 📄 [Stack](src/main/java/com/thealgorithms/datastructures/stacks/Stack.java)
             - 📄 [StackArray](src/main/java/com/thealgorithms/datastructures/stacks/StackArray.java)
@@ -259,7 +255,6 @@
             - 📄 [PreOrderTraversal](src/main/java/com/thealgorithms/datastructures/trees/PreOrderTraversal.java)
             - 📄 [PrintTopViewofTree](src/main/java/com/thealgorithms/datastructures/trees/PrintTopViewofTree.java)
             - 📄 [QuadTree](src/main/java/com/thealgorithms/datastructures/trees/QuadTree.java)
-            - 📄 [README](src/main/java/com/thealgorithms/datastructures/trees/README.md)
             - 📄 [RedBlackBST](src/main/java/com/thealgorithms/datastructures/trees/RedBlackBST.java)
             - 📄 [SameTreesCheck](src/main/java/com/thealgorithms/datastructures/trees/SameTreesCheck.java)
             - 📄 [SegmentTree](src/main/java/com/thealgorithms/datastructures/trees/SegmentTree.java)
@@ -749,7 +744,6 @@
           - 📄 [ValidParentheses](src/main/java/com/thealgorithms/strings/ValidParentheses.java)
           - 📄 [WordLadder](src/main/java/com/thealgorithms/strings/WordLadder.java)
           - 📁 **zigZagPattern**
-            - 📄 [README](src/main/java/com/thealgorithms/strings/zigZagPattern/README.md)
             - 📄 [ZigZagPattern](src/main/java/com/thealgorithms/strings/zigZagPattern/ZigZagPattern.java)
         - 📁 **tree**
           - 📄 [HeavyLightDecomposition](src/main/java/com/thealgorithms/tree/HeavyLightDecomposition.java)
@@ -1048,6 +1042,7 @@
           - 📄 [GrahamScanTest](src/test/java/com/thealgorithms/geometry/GrahamScanTest.java)
           - 📄 [MidpointCircleTest](src/test/java/com/thealgorithms/geometry/MidpointCircleTest.java)
           - 📄 [MidpointEllipseTest](src/test/java/com/thealgorithms/geometry/MidpointEllipseTest.java)
+          - 📄 [PointTest](src/test/java/com/thealgorithms/geometry/PointTest.java)
         - 📁 **graph**
           - 📄 [ConstrainedShortestPathTest](src/test/java/com/thealgorithms/graph/ConstrainedShortestPathTest.java)
           - 📄 [StronglyConnectedComponentOptimizedTest](src/test/java/com/thealgorithms/graph/StronglyConnectedComponentOptimizedTest.java)
@@ -1416,4 +1411,4 @@
           - 📁 **zigZagPattern**
             - 📄 [ZigZagPatternTest](src/test/java/com/thealgorithms/strings/zigZagPattern/ZigZagPatternTest.java)
         - 📁 **tree**
-          - 📄 [HeavyLightDecompositionTest](src/test/java/com/thealgorithms/tree/HeavyLightDecompositionTest.java)
+          - 📄 [HeavyLightDecompositionTest](src/test/java/com/thealgorithms/tree/HeavyLightDecompositionTest.java)

pom.xml

@@ -128,7 +128,7 @@
                         <plugin>
                             <groupId>com.mebigfatguy.fb-contrib</groupId>
                             <artifactId>fb-contrib</artifactId>
-                            <version>7.6.11</version>
+                            <version>7.6.12</version>
                         </plugin>
                         <plugin>
                             <groupId>com.h3xstream.findsecbugs</groupId>

src/main/java/com/thealgorithms/datastructures/hashmap/hashing/Intersection.java

@@ -8,60 +8,66 @@
 
 /**
  * The {@code Intersection} class provides a method to compute the intersection of two integer arrays.
- * The intersection is defined as the set of common elements present in both arrays.
  * <p>
- * This class utilizes a HashMap to efficiently count occurrences of elements in the first array,
- * allowing for an efficient lookup of common elements in the second array.
+ * This intersection includes duplicate values — meaning elements are included in the result
+ * as many times as they appear in both arrays (i.e., multiset intersection).
  * </p>
  *
  * <p>
- * Example:
- * <pre>
+ * The algorithm uses a {@link java.util.HashMap} to count occurrences of elements in the first array,
+ * then iterates through the second array to collect common elements based on these counts.
+ * </p>
+ *
+ * <p>
+ * Example usage:
+ * <pre>{@code
  * int[] array1 = {1, 2, 2, 1};
  * int[] array2 = {2, 2};
- * List<Integer> result = Intersection.intersection(array1, array2); // result will contain [2, 2]
- * </pre>
+ * List<Integer> result = Intersection.intersection(array1, array2); // result: [2, 2]
+ * }</pre>
  * </p>
  *
  * <p>
- * Note: The order of the returned list may vary since it depends on the order of elements
- * in the input arrays.
+ * Note: The order of elements in the returned list depends on the order in the second input array.
  * </p>
  */
 public final class Intersection {
 
+    private Intersection() {
+        // Utility class; prevent instantiation
+    }
+
     /**
-     * Computes the intersection of two integer arrays.
+     * Computes the intersection of two integer arrays, preserving element frequency.
+     * For example, given [1,2,2,3] and [2,2,4], the result will be [2,2].
+     *
      * Steps:
-     * 1. Count the occurrences of each element in the first array using a HashMap.
-     * 2. Iterate over the second array and check if the element is present in the HashMap.
-     * If it is, add it to the result list and decrement the count in the HashMap.
-     * 3. Return the result list containing the intersection of the two arrays.
+     * 1. Count the occurrences of each element in the first array using a map.
+     * 2. Iterate over the second array and collect common elements.
      *
      * @param arr1 the first array of integers
      * @param arr2 the second array of integers
-     * @return a list containing the intersection of the two arrays, or an empty list if either array is null or empty
+     * @return a list containing the intersection of the two arrays (with duplicates),
+     *         or an empty list if either array is null or empty
      */
     public static List<Integer> intersection(int[] arr1, int[] arr2) {
         if (arr1 == null || arr2 == null || arr1.length == 0 || arr2.length == 0) {
             return Collections.emptyList();
         }
 
-        Map<Integer, Integer> cnt = new HashMap<>(16);
-        for (int v : arr1) {
-            cnt.put(v, cnt.getOrDefault(v, 0) + 1);
+        Map<Integer, Integer> countMap = new HashMap<>();
+        for (int num : arr1) {
+            countMap.put(num, countMap.getOrDefault(num, 0) + 1);
         }
 
-        List<Integer> res = new ArrayList<>();
-        for (int v : arr2) {
-            if (cnt.containsKey(v) && cnt.get(v) > 0) {
-                res.add(v);
-                cnt.put(v, cnt.get(v) - 1);
+        List<Integer> result = new ArrayList<>();
+        for (int num : arr2) {
+            if (countMap.getOrDefault(num, 0) > 0) {
+                result.add(num);
+                countMap.computeIfPresent(num, (k, v) -> v - 1);
             }
         }
-        return res;
-    }
 
-    private Intersection() {
+        return result;
     }
 }

src/main/java/com/thealgorithms/datastructures/hashmap/hashing/MajorityElement.java

@@ -1,8 +1,10 @@
 package com.thealgorithms.datastructures.hashmap.hashing;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * This class provides a method to find the majority element(s) in an array of integers.
@@ -18,13 +20,18 @@ private MajorityElement() {
      * Returns a list of majority element(s) from the given array of integers.
      *
      * @param nums an array of integers
-     * @return a list containing the majority element(s); returns an empty list if none exist
+     * @return a list containing the majority element(s); returns an empty list if none exist or input is null/empty
      */
     public static List<Integer> majority(int[] nums) {
-        HashMap<Integer, Integer> numToCount = new HashMap<>();
+        if (nums == null || nums.length == 0) {
+            return Collections.emptyList();
+        }
+
+        Map<Integer, Integer> numToCount = new HashMap<>();
         for (final var num : nums) {
             numToCount.merge(num, 1, Integer::sum);
         }
+
         List<Integer> majorityElements = new ArrayList<>();
         for (final var entry : numToCount.entrySet()) {
             if (entry.getValue() >= nums.length / 2) {

src/main/java/com/thealgorithms/maths/Convolution.java

@@ -23,24 +23,21 @@ public static double[] convolution(double[] a, double[] b) {
         double[] convolved = new double[a.length + b.length - 1];
 
         /*
-    The discrete convolution of two signals A and B is defined as:
-
-          A.length
-    C[i] = Σ (A[k]*B[i-k])
-          k=0
-
-    It's obvious that:  0 <= k <= A.length , 0 <= i <= A.length + B.length - 2  and  0 <= i-k <=
-    B.length - 1 From the last inequality we get that:  i - B.length + 1 <= k <= i and thus we get
-    the conditions below.
+         * Discrete convolution formula:
+         * C[i] = Σ A[k] * B[i - k]
+         * where k ranges over valid indices so that both A[k] and B[i-k] are in bounds.
          */
+
         for (int i = 0; i < convolved.length; i++) {
-            convolved[i] = 0;
-            int k = Math.max(i - b.length + 1, 0);
+            double sum = 0;
+            int kStart = Math.max(0, i - b.length + 1);
+            int kEnd = Math.min(i, a.length - 1);
 
-            while (k < i + 1 && k < a.length) {
-                convolved[i] += a[k] * b[i - k];
-                k++;
+            for (int k = kStart; k <= kEnd; k++) {
+                sum += a[k] * b[i - k];
             }
+
+            convolved[i] = sum;
         }
 
         return convolved;

src/main/java/com/thealgorithms/maths/Median.java

@@ -13,8 +13,13 @@ 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.
      */
     public static double median(int[] values) {
+        if (values == null || values.length == 0) {
+            throw new IllegalArgumentException("Values array cannot be empty or null");
+        }
+
         Arrays.sort(values);
         int length = values.length;
         return length % 2 == 0 ? (values[length / 2] + values[length / 2 - 1]) / 2.0 : values[length / 2];

src/main/java/com/thealgorithms/maths/Mode.java

@@ -3,46 +3,49 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
-/*
- * Find the mode of an array of numbers
- *
- * The mode of an array of numbers is the most frequently occurring number in the array,
- * or the most frequently occurring numbers if there are multiple numbers with the same frequency
+/**
+ * Utility class to calculate the mode(s) of an array of integers.
+ * <p>
+ * The mode of an array is the integer value(s) that occur most frequently.
+ * If multiple values have the same highest frequency, all such values are returned.
+ * </p>
  */
 public final class Mode {
     private Mode() {
     }
 
-    /*
-     * Find the mode of an array of integers
+    /**
+     * Computes the mode(s) of the specified array of integers.
+     * <p>
+     * If the input array is empty, this method returns {@code null}.
+     * If multiple numbers share the highest frequency, all are returned in the result array.
+     * </p>
      *
-     * @param numbers array of integers
-     * @return mode of the array
+     * @param numbers an array of integers to analyze
+     * @return an array containing the mode(s) of the input array, or {@code null} if the input is empty
      */
     public static int[] mode(final int[] numbers) {
         if (numbers.length == 0) {
             return null;
         }
 
-        HashMap<Integer, Integer> count = new HashMap<>();
+        Map<Integer, Integer> count = new HashMap<>();
 
         for (int num : numbers) {
-            if (count.containsKey(num)) {
-                count.put(num, count.get(num) + 1);
-            } else {
-                count.put(num, 1);
-            }
+            count.put(num, count.getOrDefault(num, 0) + 1);
         }
 
         int max = Collections.max(count.values());
-        ArrayList<Integer> modes = new ArrayList<>();
+        List<Integer> modes = new ArrayList<>();
 
         for (final var entry : count.entrySet()) {
             if (entry.getValue() == max) {
                 modes.add(entry.getKey());
             }
         }
-        return modes.stream().mapToInt(n -> n).toArray();
+        return modes.stream().mapToInt(Integer::intValue).toArray();
     }
 }

src/test/java/com/thealgorithms/bitmanipulation/ParityCheckTest.java

@@ -6,10 +6,30 @@
 import org.junit.jupiter.api.Test;
 
 public class ParityCheckTest {
+    @Test
+    public void testIsEvenParity() {
+        assertTrue(ParityCheck.checkParity(0)); // 0 -> 0 ones
+        assertTrue(ParityCheck.checkParity(3)); // 11 -> 2 ones
+        assertTrue(ParityCheck.checkParity(5)); // 101 -> 2 ones
+        assertTrue(ParityCheck.checkParity(10)); // 1010 -> 2 ones
+        assertTrue(ParityCheck.checkParity(15)); // 1111 -> 4 ones
+        assertTrue(ParityCheck.checkParity(1023)); // 10 ones
+    }
+
     @Test
     public void testIsOddParity() {
-        assertTrue(ParityCheck.checkParity(5)); // 101 has 2 ones (even parity)
-        assertFalse(ParityCheck.checkParity(7)); // 111 has 3 ones (odd parity)
-        assertFalse(ParityCheck.checkParity(8)); // 1000 has 1 one (odd parity)
+        assertFalse(ParityCheck.checkParity(1)); // 1 -> 1 one
+        assertFalse(ParityCheck.checkParity(2)); // 10 -> 1 one
+        assertFalse(ParityCheck.checkParity(7)); // 111 -> 3 ones
+        assertFalse(ParityCheck.checkParity(8)); // 1000 -> 1 one
+        assertFalse(ParityCheck.checkParity(11)); // 1011 -> 3 ones
+        assertFalse(ParityCheck.checkParity(31)); // 11111 -> 5 ones
+    }
+
+    @Test
+    public void testLargeNumbers() {
+        assertTrue(ParityCheck.checkParity(0b10101010)); // 4 ones
+        assertFalse(ParityCheck.checkParity(0b100000000)); // 1 one
+        assertTrue(ParityCheck.checkParity(0xAAAAAAAA)); // Alternating bits, 16 ones
     }
 }