Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Print the Maximum Subarray Sum

  • Difficulty Level : Medium
  • Last Updated : 15 Nov, 2021

Given an array arr[], the task is to find the elements of a contiguous subarray of numbers which has the largest sum.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr = [-2, -3, 4, -1, -2, 1, 5, -3]
Output: [4, -1, -2, 1, 5]
Explanation: 
In the above input the maximum contiguous subarray sum is 7 and the elements of the subarray are [4, -1, -2, 1, 5]



Input: arr = [-2, -5, 6, -2, -3, 1, 5, -6] 
Output: [6, -2, -3, 1, 5] 
Explanation: 
In the above input the maximum contiguous subarray sum is 7 and the elements 
of the subarray are [6, -2, -3, 1, 5]

Naive Approach: The naive approach is to generate all the possible subarray and print that subarray which has maximum sum. 
Time complexity: O(N2
Auxiliary Space: O(1)

Efficient Approach: The idea is to use the Kadane’s Algorithm to find the maximum subarray sum and store the starting and ending index of the subarray having maximum sum and print the subarray from starting index to ending index. Below are the steps:

  1. Initialize 3 variables endIndex to 0, currMax and globalMax to first value of the input array.
  2. For each element in the array starting from index(say i) 1, update currMax to max(nums[i], nums[i] + currMax) and globalMax and endIndex to i only if currMax > globalMax.
  3. To find the start index, iterate from endIndex in the left direction and keep decrementing the value of globalMax until it becomes 0. The point at which it becomes 0 is the start index.
  4. Now print the subarray between [start, end].

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the elements
// of Subarray with maximum sum
void SubarrayWithMaxSum(vector<int>& nums)
{
    // Initialize currMax and globalMax
    // with first value of nums
    int endIndex, currMax = nums[0];
    int globalMax = nums[0];
 
    // Iterate for all the elements
    // of the array
    for (int i = 1; i < nums.size(); ++i) {
 
        // Update currMax
        currMax = max(nums[i],
                      nums[i] + currMax);
 
        // Check if currMax is greater
        // than globalMax
        if (currMax > globalMax) {
            globalMax = currMax;
            endIndex = i;
        }
    }
 
    int startIndex = endIndex;
 
    // Traverse in left direction to
    // find start Index of subarray
    while (startIndex >= 0) {
 
        globalMax -= nums[startIndex];
 
        if (globalMax == 0)
            break;
 
        // Decrement the start index
        startIndex--;
    }
 
    // Printing the elements of
    // subarray with max sum
    for (int i = startIndex;
         i <= endIndex; ++i) {
 
        cout << nums[i] << " ";
    }
}
 
// Driver Code
int main()
{
    // Given array arr[]
    vector<int> arr
        = { -2, -5, 6, -2,
            -3, 1, 5, -6 };
 
    // Function call
    SubarrayWithMaxSum(arr);
    return 0;
}


Java




// Java program for the above approach
import java.util.*;
class GFG{
 
  // Function to print the elements
  // of Subarray with maximum sum
  static void SubarrayWithMaxSum(Vector<Integer> nums)
  {
    // Initialize currMax and globalMax
    // with first value of nums
    int endIndex = 0, currMax = nums.get(0);
    int globalMax = nums.get(0);
 
    // Iterate for all the elements
    // of the array
    for (int i = 1; i < nums.size(); ++i)
    {
 
      // Update currMax
      currMax = Math.max(nums.get(i),
                         nums.get(i) + currMax);
 
      // Check if currMax is greater
      // than globalMax
      if (currMax > globalMax)
      {
        globalMax = currMax;
        endIndex = i;
      }
    }
 
    int startIndex = endIndex;
 
    // Traverse in left direction to
    // find start Index of subarray
    while (startIndex >= 0)
    {
      globalMax -= nums.get(startIndex);
 
      if (globalMax == 0)
        break;
 
      // Decrement the start index
      startIndex--;
    }
 
    // Printing the elements of
    // subarray with max sum
    for(int i = startIndex; i <= endIndex; ++i)
    {
      System.out.print(nums.get(i) + " ");
    }
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    // Given array arr[]
    Vector<Integer> arr = new Vector<Integer>();
    arr.add(-2);
    arr.add(-5);
    arr.add(6);
    arr.add(-2);
    arr.add(-3);
    arr.add(1);
    arr.add(5);
    arr.add(-6);
 
    // Function call
    SubarrayWithMaxSum(arr);
  }
}
 
// This code is contributed by Rajput-Ji


Python3




# Python3 program for the above approach
 
# Function to print the elements
# of Subarray with maximum sum
def SubarrayWithMaxSum(nums):
     
    # Initialize currMax and globalMax
    # with first value of nums
    currMax = nums[0]
    globalMax = nums[0]
 
    # Iterate for all the elements
    # of the array
    for i in range(1, len(nums)):
 
        # Update currMax
        currMax = max(nums[i],
                      nums[i] + currMax)
 
        # Check if currMax is greater
        # than globalMax
        if (currMax > globalMax):
            globalMax = currMax
            endIndex = i
     
    startIndex = endIndex
 
    # Traverse in left direction to
    # find start Index of subarray
    while (startIndex >= 0):
        globalMax -= nums[startIndex]
 
        if (globalMax == 0):
            break
 
        # Decrement the start index
        startIndex -= 1
     
    # Printing the elements of
    # subarray with max sum
    for i in range(startIndex, endIndex + 1):
        print(nums[i], end = " ")
     
# Driver Code
 
# Given array arr[]
arr = [ -2, -5, 6, -2,
        -3, 1, 5, -6 ]
 
# Function call
SubarrayWithMaxSum(arr)
 
# This code is contributed by sanjoy_62


C#




// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
 
  // Function to print the elements
  // of Subarray with maximum sum
  static void SubarrayWithMaxSum(List<int> nums)
  {
    // Initialize currMax and globalMax
    // with first value of nums
    int endIndex = 0, currMax = nums[0];
    int globalMax = nums[0];
 
    // Iterate for all the elements
    // of the array
    for (int i = 1; i < nums.Count; ++i)
    {
 
      // Update currMax
      currMax = Math.Max(nums[i],
                         nums[i] + currMax);
 
      // Check if currMax is greater
      // than globalMax
      if (currMax > globalMax)
      {
        globalMax = currMax;
        endIndex = i;
      }
    }
 
    int startIndex = endIndex;
 
    // Traverse in left direction to
    // find start Index of subarray
    while (startIndex >= 0)
    {
      globalMax -= nums[startIndex];
 
      if (globalMax == 0)
        break;
 
      // Decrement the start index
      startIndex--;
    }
 
    // Printing the elements of
    // subarray with max sum
    for(int i = startIndex; i <= endIndex; ++i)
    {
      Console.Write(nums[i] + " ");
    }
  }
 
  // Driver Code
  public static void Main(String[] args)
  {
    // Given array []arr
    List<int> arr = new List<int>();
    arr.Add(-2);
    arr.Add(-5);
    arr.Add(6);
    arr.Add(-2);
    arr.Add(-3);
    arr.Add(1);
    arr.Add(5);
    arr.Add(-6);
 
    // Function call
    SubarrayWithMaxSum(arr);
  }
}
 
// This code is contributed by gauravrajput1


Javascript




<script>
 
// Javascript program for the above approach
 
// Function to print the elements
// of Subarray with maximum sum
function SubarrayWithMaxSum(nums)
{
     
    // Initialize currMax and globalMax
    // with first value of nums
    var endIndex, currMax = nums[0];
    var globalMax = nums[0];
 
    // Iterate for all the elements
    // of the array
    for(var i = 1; i < nums.length; ++i)
    {
         
        // Update currMax
        currMax = Math.max(nums[i],
                           nums[i] + currMax);
 
        // Check if currMax is greater
        // than globalMax
        if (currMax > globalMax)
        {
            globalMax = currMax;
            endIndex = i;
        }
    }
 
    var startIndex = endIndex;
 
    // Traverse in left direction to
    // find start Index of subarray
    while (startIndex >= 0)
    {
        globalMax -= nums[startIndex];
 
        if (globalMax == 0)
            break;
 
        // Decrement the start index
        startIndex--;
    }
 
    // Printing the elements of
    // subarray with max sum
    for(var i = startIndex;
            i <= endIndex; ++i)
    {
        document.write(nums[i] + " ");
    }
}
 
// Driver Code
 
// Given array arr[]
var arr = [ -2, -5, 6, -2,
            -3, 1, 5, -6 ];
             
// Function call
SubarrayWithMaxSum(arr);
 
// This code is contributed by rutvik_56
 
</script>


Output

6 -2 -3 1 5 

Time complexity: O(N) 
Auxiliary Space: O(1)
 

Alternate Efficient Approach: This approach eliminates the inner while loop that moves in left direction decrementing global_max in the above mentioned method. Thus this method reduces the time.

  1. Initialize currMax and globalMax to first value of the input array. Initialize endIndex, startIndex, globalMaxStartIndex to 0.  ( endIndex, startIndex store the start and end indices of the max sum sub array ending at i. globalMaxStartIndex stores the startIndex of the globalMax )
  2. For each element in the array starting from index (say i) 1, update currMax and startIndex to i if nums[i] > nums[i] + currMax. Else only update currMax.
  3. Update globalMax if currMax>globalMax. Also update globalMaxStartIndex.
  4. Now print the subarray between [start index, globalMaxStartIndex].

Below is the implementation of the above approach:
 

Java




// Java program for the above approach
import java.util.*;
 
class GFG {
 
    // Function to print the elements
    // of Subarray with maximum sum
    static void SubarrayWithMaxSum(Vector<Integer> nums)
    {
        // Initialize currMax and globalMax
        // with first value of nums
        int currMax = nums.get(0), globalMax = nums.get(0);
        // Initialize endIndex startIndex,globalStartIndex
        int endIndex = 0;
        int startIndex = 0, globalMaxStartIndex = 0;
 
        // Iterate for all the elements of the array
        for (int i = 1; i < nums.size(); ++i) {
 
            // Update currMax and startIndex
            if (nums.get(i) > nums.get(i) + currMax) {
                currMax = nums.get(i);
                startIndex = i; // update the new startIndex
            }
 
            // Update currMax
            else if (nums.get(i) < nums.get(i) + currMax) {
                currMax = nums.get(i) + currMax;
            }
 
            // Update globalMax anf globalMaxStartIndex
            if (currMax > globalMax) {
                globalMax = currMax;
                endIndex = i;
                globalMaxStartIndex = startIndex;
            }
        }
 
        // Printing the elements of subarray with max sum
        for (int i = globalMaxStartIndex; i <= endIndex;
             ++i) {
            System.out.print(nums.get(i) + " ");
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Given array arr[]
        Vector<Integer> arr = new Vector<Integer>();
        arr.add(-2);
        arr.add(-5);
        arr.add(6);
        arr.add(-2);
        arr.add(-3);
        arr.add(1);
        arr.add(5);
        arr.add(-6);
        // Function call
        SubarrayWithMaxSum(arr);
    }
}
 
// This code is contributed by Amritha Basavaraj Patil


C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
public class GFG{
    // Function to print the elements
    // of Subarray with maximum sum
    static void SubarrayWithMaxSum(List<int> nums)
    {
        // Initialize currMax and globalMax
        // with first value of nums
        int currMax = nums[0], globalMax = nums[0];
       
        // Initialize endIndex startIndex,globalStartIndex
        int endIndex = 0;
        int startIndex = 0, globalMaxStartIndex = 0;
  
        // Iterate for all the elements of the array
        for (int i = 1; i < nums.Count; ++i) {
  
            // Update currMax and startIndex
            if (nums[i] > nums[i] + currMax) {
                currMax = nums[i];
                startIndex = i; // update the new startIndex
            }
  
            // Update currMax
            else if (nums[i] < nums[i] + currMax) {
                currMax = nums[i] + currMax;
            }
  
            // Update globalMax anf globalMaxStartIndex
            if (currMax > globalMax) {
                globalMax = currMax;
                endIndex = i;
                globalMaxStartIndex = startIndex;
            }
        }
  
        // Printing the elements of subarray with max sum
        for (int i = globalMaxStartIndex; i <= endIndex;
             ++i) {
            Console.Write(nums[i] + " ");
        }
    }
  
    // Driver Code
    static public void Main (){
         
        // Given array arr[]
        List<int> arr = new List<int>();
        arr.Add(-2);
        arr.Add(-5);
        arr.Add(6);
        arr.Add(-2);
        arr.Add(-3);
        arr.Add(1);
        arr.Add(5);
        arr.Add(-6);
        // Function call
        SubarrayWithMaxSum(arr);
         
    }
}
 
// This code is contributed by rag2127.


Javascript




<script>
 
// JavaScript program for the above approach
 
// Function to print the elements
    // of Subarray with maximum sum
function SubarrayWithMaxSum(nums)
{
    // Initialize currMax and globalMax
        // with first value of nums
        let currMax = nums[0], globalMax = nums[0];
        // Initialize endIndex startIndex,globalStartIndex
        let endIndex = 0;
        let startIndex = 0, globalMaxStartIndex = 0;
  
        // Iterate for all the elements of the array
        for (let i = 1; i < nums.length; ++i) {
  
            // Update currMax and startIndex
            if (nums[i] > nums[i] + currMax) {
                currMax = nums[i];
                startIndex = i; // update the new startIndex
            }
  
            // Update currMax
            else if (nums[i] < nums[i] + currMax) {
                currMax = nums[i] + currMax;
            }
  
            // Update globalMax anf globalMaxStartIndex
            if (currMax > globalMax) {
                globalMax = currMax;
                endIndex = i;
                globalMaxStartIndex = startIndex;
            }
        }
  
        // Printing the elements of subarray with max sum
        for (let i = globalMaxStartIndex; i <= endIndex;
             ++i) {
            document.write(nums[i] + " ");
        }
}
 
// Driver Code
 
let arr = [];
arr.push(-2);
arr.push(-5);
arr.push(6);
arr.push(-2);
arr.push(-3);
arr.push(1);
arr.push(5);
arr.push(-6);
// Function call
SubarrayWithMaxSum(arr);
 
// This code is contributed by unknown2108
 
</script>


Output

6 -2 -3 1 5 

Time complexity: O(N) 
Auxiliary Space: O(1)
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!