diff --git a/DIRECTORY.md b/DIRECTORY.md index 94f5890bb157..2b595e7a6652 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -792,6 +792,7 @@ * [EditDistanceTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/EditDistanceTest.java) * [EggDroppingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/EggDroppingTest.java) * [FibonacciTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/FibonacciTest.java) + * [KadaneAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/KadaneAlgorithmTest.java) * [KnapsackMemoizationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/KnapsackMemoizationTest.java) * [KnapsackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/KnapsackTest.java) * [LevenshteinDistanceTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LevenshteinDistanceTests.java) diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/KadaneAlgorithm.java b/src/main/java/com/thealgorithms/dynamicprogramming/KadaneAlgorithm.java index 905815d10a29..7a0a3da94c1e 100644 --- a/src/main/java/com/thealgorithms/dynamicprogramming/KadaneAlgorithm.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/KadaneAlgorithm.java @@ -1,36 +1,52 @@ package com.thealgorithms.dynamicprogramming; /** - * @author Siddhant Swarup Mallick - * Program description - To find the maximum subarray sum + * This class implements Kadane's Algorithm to find the maximum subarray sum + * within a given array of integers. The algorithm efficiently computes the maximum + * sum of a contiguous subarray in linear time. + * + * Author: Siddhant Swarup Mallick */ public final class KadaneAlgorithm { private KadaneAlgorithm() { } /** - * OUTPUT : - * Input - {89,56,98,123,26,75,12,40,39,68,91} - * Output: it returns either true or false - * 1st approach Time Complexity : O(n) - * Auxiliary Space Complexity : O(1) + * Computes the maximum subarray sum using Kadane's Algorithm and checks + * if it matches a predicted answer. + * + * @param a The input array of integers for which the maximum + * subarray sum is to be calculated. + * @param predictedAnswer The expected maximum subarray sum to be verified + * against the computed sum. + * @return true if the computed maximum subarray sum equals the predicted + * answer, false otherwise. + * + *

Example:

+ * 
+     * Input: {89, 56, 98, 123, 26, 75, 12, 40, 39, 68, 91}
+     * Output: true if the maximum subarray sum is equal to the
+     *         predicted answer.
+     *
+ * + *

Algorithmic Complexity:

+ * */ public static boolean maxSum(int[] a, int predictedAnswer) { int sum = a[0]; int runningSum = 0; + for (int k : a) { - runningSum = runningSum + k; - // running sum of all the indexs are stored + runningSum += k; sum = Math.max(sum, runningSum); - // the max is stored inorder to the get the maximum sum if (runningSum < 0) { runningSum = 0; } - // if running sum is negative then it is initialized to zero } - // for-each loop is used to iterate over the array and find the maximum subarray sum + return sum == predictedAnswer; - // It returns true if sum and predicted answer matches - // The predicted answer is the answer itself. So it always return true } } diff --git a/src/test/java/com/thealgorithms/dynamicprogramming/KadaneAlgorithmTest.java b/src/test/java/com/thealgorithms/dynamicprogramming/KadaneAlgorithmTest.java new file mode 100644 index 000000000000..e26606ef98a9 --- /dev/null +++ b/src/test/java/com/thealgorithms/dynamicprogramming/KadaneAlgorithmTest.java @@ -0,0 +1,61 @@ +package com.thealgorithms.dynamicprogramming; + +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +public class KadaneAlgorithmTest { + + @Test + void testMaxSumWithPositiveValues() { + // Test with all positive numbers + int[] input = {89, 56, 98, 123, 26, 75, 12, 40, 39, 68, 91}; + int expectedMaxSum = 89 + 56 + 98 + 123 + 26 + 75 + 12 + 40 + 39 + 68 + 91; // sum of all elements + assertTrue(KadaneAlgorithm.maxSum(input, expectedMaxSum)); + } + + @Test + void testMaxSumWithMixedValues() { + // Test with mixed positive and negative numbers + int[] input = {1, -2, 3, 4, -1, 2, 1, -5, 4}; + int expectedMaxSum = 3 + 4 + -1 + 2 + 1; // max subarray is [3, 4, -1, 2, 1] + assertTrue(KadaneAlgorithm.maxSum(input, expectedMaxSum)); + } + + @Test + void testMaxSumWithAllNegativeValues() { + // Test with all negative numbers + int[] input = {-2, -3, -1, -4}; + int expectedMaxSum = -1; // max subarray is the least negative number + assertTrue(KadaneAlgorithm.maxSum(input, expectedMaxSum)); + } + + @Test + void testMaxSumWithSingleElement() { + // Test with a single positive element + int[] input = {10}; + int expectedMaxSum = 10; // max subarray is the single element + assertTrue(KadaneAlgorithm.maxSum(input, expectedMaxSum)); + + // Test with a single negative element + input = new int[] {-10}; + expectedMaxSum = -10; // max subarray is the single element + assertTrue(KadaneAlgorithm.maxSum(input, expectedMaxSum)); + } + + @Test + void testMaxSumWithZero() { + // Test with zeros in the array + int[] input = {0, -1, 2, -2, 0, 3}; + int expectedMaxSum = 3; // max subarray is [2, -2, 0, 3] + assertTrue(KadaneAlgorithm.maxSum(input, expectedMaxSum)); + } + + @Test + void testMaxSumWithEmptyArray() { + // Test with an empty array; should ideally throw an exception or return false + int[] input = {}; + assertThrows(ArrayIndexOutOfBoundsException.class, () -> { KadaneAlgorithm.maxSum(input, 0); }); + } +}