Check if subarray with 0 sum is exists or not

Given an array of integers, check if array contains a sub-array having 0 sum.

 

For example,


Input:  { 3, 4, -7, 3, 1, 3, 1, -4, -2, -2 }

Output: Subarray with 0 sum exists
 
The sub-arrays with 0 sum are:

{ 3, 4, -7 }
{ 4, -7, 3 }
{ -7, 3, 1, 3 }
{ 3, 1, -4 }
{ 3, 1, 3, 1, -4, -2, -2 }
{ 3, 4, -7, 3, 1, 3, 1, -4, -2, -2 }

 
We can easily solve this problem in linear time by using hashing. The idea is to use set to check if sub-array with zero sum is present in the given array or not. We traverse the given array, and maintain sum of elements seen so far. If sum is seen before (i.e. sum exists in set), we return true as there exists at-least one sub-array with zero sum which ends at current index else we insert the sum into the set.

The time complexity of proposed solution is O(n) and auxiliary space used by the program is O(n).

C++

Download   Run Code


Output:


Subarray exists

Java

Download   Run Code


Output:


Subarray exists


 

 
Also See: Print all sub-arrays with 0 sum

 
Exercise: Extend the solution for non-zero sum of sub-array.

 
1 Star2 Stars3 Stars4 Stars5 Stars (8 votes, average: 5.00 out of 5)

Loading...

Thanks for reading.

Please use our online compiler to post code in comments. To contribute, get in touch with us.
Like us? Please spread the word and help us grow. Happy coding 🙂
 


Leave a Reply

avatar
  Subscribe  
newest oldest most voted
Notify of
H. Guijt
Guest

Instead of arguments (int A[], int n), we can also use (std::initializer_list A). The function call would then be zeroSumSubArray ({4, 2, -3, -1, 0 4});, and the for-loop could use range-based for.

NeelLohit
Guest

Hi, I would like to point out that your method above is predicated upon the condition that the linear addition of the elements in the array will at least once give a sum of zero. So for the array {5,1,-6,4,3} the algorithm works. But for the same elements in a different order e.g {5,1,4,-6,3}, this doesn’t work. That condition is not mentioned in the question. I think we should look for a more generalized solution to this problem and not just concentrate on the time complexity alone.

Sravan
Guest

Instead of checking whether sum visited previously or not,can we check sum value in each iteration and see if sum is zero .If in any iteration sum is zero then there exists sub array whose sum is 0.No?

Yusuf Belim
Guest

Below fails.
int A[] = { 3,6,-6 };

Yusuf Belim
Guest

Please ignore

newbie
Guest

code for the extended exercise we test with the sum so far minus the given sum
code in kotlin

working
Guest

[2, 3, 1, 4, -1, 6], the sum set will contain [0, 2, 5, 6, 10, 9, 15], no repeating.

Zeeshan
Guest

please java code explain

Krishna Chowdary G
Guest

This program is not working with the input
int[] A = { 4, -6, 3, -2, 4, 2, 7 };
and output is Subarray do not exist

Supreeth
Guest

//Solution without set.

public class ZeroSumSubArray {

public static void main(String[] args) {
// TODO Auto-generated method stub

int[] A = { 4,-6,3,-2,2,4,7 };

int sum = 0;
for (int i = 0; i < A.length; i++) {

sum = sum + A[i];
System.out.println(sum);
if (sum == 0) {
System.out.println("ZeroSum Sub Array exit");
return;
}

}
System.out.println("ZeroSum Sub Array doesn't exit");

}

}

Adi
Guest

How is the time complexity O(n)? Set::find() has time complexity log(n). Therefore, time complexity here should be sum(log(i)) = log(n!) = nlogn?

Sridhar
Guest

Confused.
The sum is being considered starting from the first element in the Java code.
How about this situation
{4, 5, 1, -6, 2}
The subarray {5,1,-6} sums to 0, but this would not be found by the Java code.
Am I missing something?

geno
Guest

in JAVA example why you use the code fragment: “set.add(sum)” on line 32 ????

boomShakalaka
Guest

If anyone is having a hard time understanding how the algorithm works. You basically traverse through the array, and keep adding each element to the sum variable, and each time you store the new value of sum in a set.

Here come’s the tricky part.

[this is front part of the array] [sub array with zero sum] [this is back of the array]

now suppose the sum of the front part of the array was sum1, this would have been stored in our set. And you keep on iterating. When you have reached the end of the sub array with 0 sum, Guess what should be the value of the sum variable be? well it should be sum of the front part + sum of the sub array with sum 0. Which is sum of the front part. There sum would be sum1, which is already present in the set. And the function returns true.

Now what if the sub array with 0 sum is in the front.

[sub array with 0 sum] [back part of the array]

We already add 0 to our set before we start iterating. So after iterating over the sub array with contiguous sum the value of sum becomes 0, which is already present in the sub array, so boom shakalaka. You get a true value returned from the function.

Cke
Guest

This won’t work on say [3, -50, 1, -4]

Am I right?

Cke
Guest

Yes I’m. Tested it ou your code!

Cke
Guest

Ok, I see it now, you are working only on continious sub-arrays 😉

sneh
Guest

{2, -3, 3}
the algorithm will return True but there is no subarray with zero sum.

sneh
Guest

apology, {-3, 3}

Reena Somvanshi
Guest

this code fails for [4,2,3,1,0,4], it returns true though there are no zero sum sub arrays. Sum is repeating due to 0 in the array.

Tony
Guest

There is one zero sum subarray which is {0}.

Roshan
Guest

int A[] = { 2, 1, -4, -1, 4 };
fails

Roshan
Guest

by mistake, ign0re