Add unit test and format code in MaximumSumOfNonAdjacentElements and its test class

Author: Guhapriya01

src/main/java/com/thealgorithms/dynamicprogramming/MaximumSumOfNonAdjacentElements.java

@@ -8,79 +8,88 @@
  */
 final class MaximumSumOfNonAdjacentElements {
 
-  private MaximumSumOfNonAdjacentElements() { }
-
-  /**
-   * Approach 1: Uses a dynamic programming array to store the maximum sum at
-   * each index. Time Complexity: O(n) - where n is the length of the input
-   * array. Space Complexity: O(n) - due to the additional dp array.
-   * @param arr The input array of integers.
-   * @return The maximum sum of non-adjacent elements.
-   */
-  public static int getMaxSumApproach1(int[] arr) {
-    int n = arr.length;
-    int[] dp = new int[n];
-
-    // Base case: Maximum sum if only one element is present.
-    dp[0] = arr[0];
-
-    for (int ind = 1; ind < n; ind++) {
-
-      // Case 1: Do not take the current element, carry forward the previous max
-      // sum.
-      int notTake = dp[ind - 1];
-
-      // Case 2: Take the current element, add it to the max sum up to two
-      // indices before.
-      int take = arr[ind];
-      if (ind > 1) {
-        take += dp[ind - 2];
-      }
-
-      // Store the maximum of both choices in the dp array.
-      dp[ind] = Math.max(take, notTake);
+    private MaximumSumOfNonAdjacentElements() {
     }
 
-    return dp[n - 1];
-  }
-
-  /**
-   * Approach 2: Optimized space complexity approach using two variables instead
-   * of an array. Time Complexity: O(n) - where n is the length of the input
-   * array. Space Complexity: O(1) - as it only uses constant space for two
-   * variables.
-   * @param arr The input array of integers.
-   * @return The maximum sum of non-adjacent elements.
-   */
-  public static int getMaxSumApproach2(int[] arr) {
-    int n = arr.length;
-
-    // Two variables to keep track of previous two results:
-    // prev1 = max sum up to the last element (n-1)
-    // prev2 = max sum up to the element before last (n-2)
-
-    int prev1 = arr[0]; // Base case: Maximum sum for the first element.
-    int prev2 = 0;
-
-    for (int ind = 1; ind < n; ind++) {
-      // Case 1: Do not take the current element, keep the last max sum.
-      int notTake = prev1;
-
-      // Case 2: Take the current element and add it to the result from two
-      // steps back.
-      int take = arr[ind];
-      if (ind > 1) {
-        take += prev2;
-      }
-
-      // Calculate the current maximum sum and update previous values.
-      int current = Math.max(take, notTake);
-
-      // Shift prev1 and prev2 for the next iteration.
-      prev2 = prev1;
-      prev1 = current;
+    /**
+     * Approach 1: Uses a dynamic programming array to store the maximum sum at
+     * each index. Time Complexity: O(n) - where n is the length of the input
+     * array. Space Complexity: O(n) - due to the additional dp array.
+     * @param arr The input array of integers.
+     * @return The maximum sum of non-adjacent elements.
+     */
+    public static int getMaxSumApproach1(int[] arr) {
+        if (arr.length == 0) {
+            return 0; // Check for empty array
+        }
+
+        int n = arr.length;
+        int[] dp = new int[n];
+
+        // Base case: Maximum sum if only one element is present.
+        dp[0] = arr[0];
+
+        for (int ind = 1; ind < n; ind++) {
+
+            // Case 1: Do not take the current element, carry forward the previous max
+            // sum.
+            int notTake = dp[ind - 1];
+
+            // Case 2: Take the current element, add it to the max sum up to two
+            // indices before.
+            int take = arr[ind];
+            if (ind > 1) {
+                take += dp[ind - 2];
+            }
+
+            // Store the maximum of both choices in the dp array.
+            dp[ind] = Math.max(take, notTake);
+        }
+
+        return dp[n - 1];
     }
 
-    return prev1;
-  }
+    /**
+     * Approach 2: Optimized space complexity approach using two variables instead
+     * of an array. Time Complexity: O(n) - where n is the length of the input
+     * array. Space Complexity: O(1) - as it only uses constant space for two
+     * variables.
+     * @param arr The input array of integers.
+     * @return The maximum sum of non-adjacent elements.
+     */
+    public static int getMaxSumApproach2(int[] arr) {
+        if (arr.length == 0) {
+            return 0; // Check for empty array
+        }
+
+        int n = arr.length;
+
+        // Two variables to keep track of previous two results:
+        // prev1 = max sum up to the last element (n-1)
+        // prev2 = max sum up to the element before last (n-2)
+
+        int prev1 = arr[0]; // Base case: Maximum sum for the first element.
+        int prev2 = 0;
+
+        for (int ind = 1; ind < n; ind++) {
+            // Case 1: Do not take the current element, keep the last max sum.
+            int notTake = prev1;
+
+            // Case 2: Take the current element and add it to the result from two
+            // steps back.
+            int take = arr[ind];
+            if (ind > 1) {
+                take += prev2;
+            }
+
+            // Calculate the current maximum sum and update previous values.
+            int current = Math.max(take, notTake);
+
+            // Shift prev1 and prev2 for the next iteration.
+            prev2 = prev1;
+            prev1 = current;
+        }
+
+        return prev1;
+    }
 }

src/test/java/com/thealgorithms/dynamicprogramming/MaximumSumOfNonAdjacentElementsTest.java

@@ -0,0 +1,30 @@
+package com.thealgorithms.dynamicprogramming;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class MaximumSumOfNonAdjacentElementsTest {
+
+    @Test
+    public void testGetMaxSumApproach1() {
+        // Test with various cases
+        assertEquals(15, MaximumSumOfNonAdjacentElements.getMaxSumApproach1(new int[] {3, 2, 5, 10, 7})); // 3 + 7 + 5
+        assertEquals(10, MaximumSumOfNonAdjacentElements.getMaxSumApproach1(new int[] {5, 1, 1, 5})); // 5 + 5
+        assertEquals(0, MaximumSumOfNonAdjacentElements.getMaxSumApproach1(new int[] {})); // Empty array
+        assertEquals(1, MaximumSumOfNonAdjacentElements.getMaxSumApproach1(new int[] {1})); // Single element
+        assertEquals(2, MaximumSumOfNonAdjacentElements.getMaxSumApproach1(new int[] {1, 2})); // Take max of both
+        assertEquals(3, MaximumSumOfNonAdjacentElements.getMaxSumApproach1(new int[] {3, 2})); // Take 3
+    }
+
+    @Test
+    public void testGetMaxSumApproach2() {
+        // Test with various cases
+        assertEquals(15, MaximumSumOfNonAdjacentElements.getMaxSumApproach2(new int[] {3, 2, 5, 10, 7})); // 3 + 7 + 5
+        assertEquals(10, MaximumSumOfNonAdjacentElements.getMaxSumApproach2(new int[] {5, 1, 1, 5})); // 5 + 5
+        assertEquals(0, MaximumSumOfNonAdjacentElements.getMaxSumApproach2(new int[] {})); // Empty array
+        assertEquals(1, MaximumSumOfNonAdjacentElements.getMaxSumApproach2(new int[] {1})); // Single element
+        assertEquals(2, MaximumSumOfNonAdjacentElements.getMaxSumApproach2(new int[] {1, 2})); // Take max of both
+        assertEquals(3, MaximumSumOfNonAdjacentElements.getMaxSumApproach2(new int[] {3, 2})); // Take 3
+    }
+}