Open In App

Java Program for Size of The Subarray With Maximum Sum

Improve
Improve
Like Article
Like
Save
Share
Report

An array is given, find the length of the subarray having maximum sum.

Examples: 

Input :  a[] = {1, -2, 1, 1, -2, 1}
Output : Length of the subarray is 2
Explanation: Subarray with consecutive elements 
and maximum sum will be {1, 1}. So length is 2
Input : ar[] = { -2, -3, 4, -1, -2, 1, 5, -3 }
Output : Length of the subarray is 5
Explanation: Subarray with consecutive elements 
and maximum sum will be {4, -1, -2, 1, 5} 

This problem is mainly a variation of the Largest Sum Contiguous Subarray Problem.
The idea is to update starting index whenever the sum ending here becomes less than 0.

Java




// Java program to print length of the largest
// contiguous array sum
 
class GFG {
     
   // Main driver method
    static int maxSubArraySum(int a[], int size)
    {
        int max_so_far = Integer.MIN_VALUE,
       
        max_ending_here = 0,start = 0,
        end = 0, s = 0;
 
        for (int i = 0; i < size; i++)
        {
            max_ending_here += a[i];
 
            if (max_so_far < max_ending_here)
            {
                max_so_far = max_ending_here;
                start = s;
                end = i;
            }
 
            if (max_ending_here < 0)
            {
                max_ending_here = 0;
                s = i + 1;
            }
        }
        return (end - start + 1);
    }
 
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring and initializing integer array
        int a[] = { -2, -3, 4, -1, -2, 1, 5, -3 };
       
        int n = a.length;
         
        // Calling function so as to print
        // largest contiguous sum on console
        System.out.println(maxSubArraySum(a, n));
    }
}


Output : 

5

 

Time Complexity: O(N) where N is size of the input array. This is because a for loop is executed from 1 to size of the array.
Auxiliary Space: O(1) as no extra space has been taken.

Approach#2: Using Kadane’s algorithm

This approach implements Kadane’s algorithm to find the maximum subarray sum and returns the size of the subarray with the maximum sum.

Algorithm:

  1.  Initialize max_sum, current_sum, start, end, max_start, and max_end to the first element of the array.
  2.  Iterate through the array from the second element.
  3.  If the current element is greater than the sum of the current element and current_sum, update start to the current index.
  4.  Update current_sum as the maximum of the current element and the sum of current element and current_sum.
  5.  If current_sum is greater than max_sum, update max_sum, end to the current index, and max_start and max_end to start and end  respectively.
  6.  Return max_end – max_start + 1 as the size of the subarray with maximum sum.

Below is the implementation of the approach:

Java




// Java code for the approach
 
import java.util.*;
 
public class GFG {
 
    // Function to find the maximum subarray sum
    static int maxSubarraySum(List<Integer> a)
    {
 
        int n = a.size();
        int max_sum = a.get(0);
        int current_sum = a.get(0);
        int start = 0;
        int end = 0;
        int max_start = 0;
        int max_end = 0;
 
        // Traverse the list
        for (int i = 1; i < n; i++) {
            // If the current element is greater than the
            // sum so far plus the current element, then
            // update the start index to the current index
            if (a.get(i) > current_sum + a.get(i)) {
                start = i;
            }
 
            // Update the current sum to be either the
            // current element or the sum so far plus the
            // current element
            current_sum = Math.max(a.get(i),
                                   current_sum + a.get(i));
 
            // If the current sum is greater than the
            // maximum sum so far, then update the maximum
            // sum and its start and end indices
            if (current_sum > max_sum) {
                max_sum = current_sum;
                end = i;
                max_start = start;
                max_end = end;
            }
        }
 
        // Return the length of the maximum subarray
        return max_end - max_start + 1;
    }
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Storing as list
        List<Integer> a
            = Arrays.asList(-2, -3, 4, -1, -2, 1, 5, -3);
 
        System.out.println(maxSubarraySum(a));
    }
}


Output

5

Time Complexity: O(n), where n is the length of array
Auxiliary Space: O(1)

Note: The above code assumes that there is at least one positive element in the array. If all the elements are negative, the code needs to be modified to return the maximum element in the array.

Please refer complete article on Size of The Subarray With Maximum Sum for more details!



Last Updated : 10 May, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads