Merge branch 'master' into fix-7458-unify-dijkstra-priorityqueue

Author: priyanshuvishwakarma273403

…rithms/tree/HeavyLightDecomposition.java …tures/trees/HeavyLightDecomposition.javasrc/main/java/com/thealgorithms/tree/HeavyLightDecomposition.java renamed to src/main/java/com/thealgorithms/datastructures/trees/HeavyLightDecomposition.java src/main/java/com/thealgorithms/tree/HeavyLightDecomposition.java renamed to src/main/java/com/thealgorithms/datastructures/trees/HeavyLightDecomposition.java

@@ -1,4 +1,4 @@
-package com.thealgorithms.tree;
+package com.thealgorithms.datastructures.trees;
 
 import java.util.ArrayList;
 import java.util.List;

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

@@ -0,0 +1,43 @@
+package com.thealgorithms.maths;
+
+/**
+ * The Padovan Sequence is a sequence of integers defined by the recurrence relation:
+ * P(n) = P(n-2) + P(n-3) with initial values P(0) = P(1) = P(2) = 1.
+ * Example: 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37...
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Padovan_sequence">
+ *     Wikipedia: Padovan Sequence</a>
+ * @author Vraj Prajapati (@Rosander0)
+ */
+public final class PadovanSequence {
+
+    private PadovanSequence() {
+        // Utility class
+    }
+
+    /**
+     * Calculates the nth term of the Padovan Sequence.
+     *
+     * @param n the index of the sequence (must be non-negative)
+     * @return the nth term of the Padovan Sequence
+     */
+    public static long padovan(final int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("Input must be non-negative. Received: " + n);
+        }
+        if (n <= 2) {
+            return 1;
+        }
+        long a = 1;
+        long b = 1;
+        long c = 1;
+        long result = 0;
+        for (int i = 3; i <= n; i++) {
+            result = a + b;
+            a = b;
+            b = c;
+            c = result;
+        }
+        return result;
+    }
+}

src/main/java/com/thealgorithms/searches/InterpolationSearch.java

@@ -36,9 +36,12 @@ public int find(int[] array, int key) {
         // Since array is sorted, an element present
         // in array must be in range defined by corner
         while (start <= end && key >= array[start] && key <= array[end]) {
+            if (array[start] == array[end]) {
+                return start;
+            }
             // Probing the position with keeping
             // uniform distribution in mind.
-            int pos = start + (((end - start) / (array[end] - array[start])) * (key - array[start]));
+            int pos = start + (int) (((long) (end - start) * (key - array[start])) / ((long) array[end] - array[start]));
 
             // Condition of target found
             if (array[pos] == key) {

…ms/tree/HeavyLightDecompositionTest.java …s/trees/HeavyLightDecompositionTest.javasrc/test/java/com/thealgorithms/tree/HeavyLightDecompositionTest.java renamed to src/test/java/com/thealgorithms/datastructures/trees/HeavyLightDecompositionTest.java src/test/java/com/thealgorithms/tree/HeavyLightDecompositionTest.java renamed to src/test/java/com/thealgorithms/datastructures/trees/HeavyLightDecompositionTest.java

@@ -1,4 +1,4 @@
-package com.thealgorithms.tree;
+package com.thealgorithms.datastructures.trees;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;

src/test/java/com/thealgorithms/maths/PadovanSequenceTest.java

@@ -0,0 +1,36 @@
+package com.thealgorithms.maths;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author Vraj Prajapati (@Rosander0)
+ */
+public class PadovanSequenceTest {
+
+    @Test
+    public void testBaseCase() {
+        assertEquals(1, PadovanSequence.padovan(0));
+        assertEquals(1, PadovanSequence.padovan(1));
+        assertEquals(1, PadovanSequence.padovan(2));
+    }
+
+    @Test
+    public void testKnownValues() {
+        assertEquals(2, PadovanSequence.padovan(3));
+        assertEquals(2, PadovanSequence.padovan(4));
+        assertEquals(3, PadovanSequence.padovan(5));
+        assertEquals(4, PadovanSequence.padovan(6));
+        assertEquals(5, PadovanSequence.padovan(7));
+        assertEquals(7, PadovanSequence.padovan(8));
+        assertEquals(9, PadovanSequence.padovan(9));
+        assertEquals(12, PadovanSequence.padovan(10));
+    }
+
+    @Test
+    public void testInvalidInput() {
+        assertThrows(IllegalArgumentException.class, () -> PadovanSequence.padovan(-1));
+    }
+}

src/test/java/com/thealgorithms/searches/InterpolationSearchTest.java

@@ -87,4 +87,15 @@ void testInterpolationSearchLargeNonUniformArray() {
         int key = 21; // Present in the array
         assertEquals(6, interpolationSearch.find(array, key), "The index of the found element should be 6.");
     }
+
+    /**
+     * Test for interpolation search with specific sorted arrays that previously caused division by zero.
+     */
+    @Test
+    void testInterpolationSearchDivisionByZeroEdgeCases() {
+        InterpolationSearch interpolationSearch = new InterpolationSearch();
+        assertEquals(3, interpolationSearch.find(new int[] {0, 0, 0, 2}, 2));
+        assertEquals(0, interpolationSearch.find(new int[] {2, 2, 2, 2}, 2));
+        assertEquals(3, interpolationSearch.find(new int[] {0, 1, 2, 4}, 4));
+    }
 }