# Find if there is a subarray with 0 sum

• Difficulty Level : Medium
• Last Updated : 11 Feb, 2022

Given an array of positive and negative numbers, find if there is a subarray (of size at-least one) with 0 sum.

Examples :

Input: {4, 2, -3, 1, 6}
Output: true
Explanation:
There is a subarray with zero sum from index 1 to 3.

Input: {4, 2, 0, 1, 6}
Output: true

Explanation

The third element is zero. A single element is also a sub-array.

Input: {-3, 2, 3, 1, 6}
Output: false

A simple solution is to consider all subarrays one by one and check the sum of every subarray. We can run two loops: the outer loop picks a starting point i and the inner loop tries all subarrays starting from i (See this for implementation). The time complexity of this method is O(n2).
We can also use hashing. The idea is to iterate through the array and for every element arr[i], calculate the sum of elements from 0 to i (this can simply be done as sum += arr[i]). If the current sum has been seen before, then there is a zero-sum array. Hashing is used to store the sum values so that we can quickly store sum and find out whether the current sum is seen before or not.
Example :

```arr[] = {1, 4, -2, -2, 5, -4, 3}

If we consider all prefix sums, we can
notice that there is a subarray with 0
sum when :
1) Either a prefix sum repeats or
2) Or prefix sum becomes 0.

Prefix sums for above array are:
1, 5, 3, 1, 6, 2, 5

Since prefix sum 1 repeats, we have a subarray
with 0 sum. ```

Following is implementation of the above approach.

## C++

 `// A C++ program to find if ` `// there is a zero sum subarray` `#include ` `using` `namespace` `std;`   `bool` `subArrayExists(``int` `arr[], ``int` `n)` `{` `    ``unordered_set<``int``> sumSet;`   `    ``// Traverse through array ` `    ``// and store prefix sums` `    ``int` `sum = 0;` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{` `        ``sum += arr[i];`   `        ``// If prefix sum is 0 or ` `        ``// it is already present` `        ``if` `(sum == 0 ` `            ``|| sumSet.find(sum) ` `            ``!= sumSet.end())` `            ``return` `true``;`   `        ``sumSet.insert(sum);` `    ``}` `    ``return` `false``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { -3, 2, 3, 1, 6 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``if` `(subArrayExists(arr, n))` `        ``cout << ``"Found a subarray with 0 sum"``;` `    ``else` `        ``cout << ``"No Such Sub Array Exists!"``;` `    ``return` `0;` `}`

## Java

 `// A Java program to find ` `// if there is a zero sum subarray` `import` `java.util.HashSet;` `import` `java.util.Set;`   `class` `ZeroSumSubarray ` `{` `    ``// Returns true if arr[] ` `    ``// has a subarray with sero sum` `    ``static` `Boolean subArrayExists(``int` `arr[])` `    ``{` `        ``// Creates an empty hashset hs` `        ``Set hs = ``new` `HashSet();`   `        ``// Initialize sum of elements` `        ``int` `sum = ``0``;`   `        ``// Traverse through the given array` `        ``for` `(``int` `i = ``0``; i < arr.length; i++) ` `        ``{` `            ``// Add current element to sum` `            ``sum += arr[i];`   `            ``// Return true in following cases` `            ``// a) Current element is 0` `            ``// b) sum of elements from 0 to i is 0` `            ``// c) sum is already present in hash set` `            ``if` `(arr[i] == ``0` `                ``|| sum == ``0` `                ``|| hs.contains(sum))` `                ``return` `true``;`   `            ``// Add sum to hash set` `            ``hs.add(sum);` `        ``}`   `        ``// We reach here only when there is` `        ``// no subarray with 0 sum` `        ``return` `false``;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String arg[])` `    ``{` `        ``int` `arr[] = { -``3``, ``2``, ``3``, ``1``, ``6` `};` `        ``if` `(subArrayExists(arr))` `            ``System.out.println(` `                ``"Found a subarray with 0 sum"``);` `        ``else` `            ``System.out.println(``"No Such Sub Array Exists!"``);` `    ``}` `}`

## Python3

 `# A python program to find if` `# there is a zero sum subarray`     `def` `subArrayExists(arr, n):` `    ``# traverse through array` `    ``# and store prefix sums` `    ``n_sum ``=` `0` `    ``s ``=` `set``()`   `    ``for` `i ``in` `range``(n):` `        ``n_sum ``+``=` `arr[i]`   `        ``# If prefix sum is 0 or` `        ``# it is already present` `        ``if` `n_sum ``=``=` `0` `or` `n_sum ``in` `s:` `            ``return` `True` `        ``s.add(n_sum)`   `    ``return` `False`     `# Driver code` `arr ``=` `[``-``3``, ``2``, ``3``, ``1``, ``6``]` `n ``=` `len``(arr)` `if` `subArrayExists(arr, n) ``=``=` `True``:` `    ``print``(``"Found a sunbarray with 0 sum"``)` `else``:` `    ``print``(``"No Such sub array exits!"``)`   `# This code is contributed by Shrikant13`

## C#

 `// A C# program to find if there` `// is a zero sum subarray` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG {` `    ``// Returns true if arr[] has` `    ``// a subarray with sero sum` `    ``static` `bool` `SubArrayExists(``int``[] arr)` `    ``{` `        ``// Creates an empty HashSet hM` `        ``HashSet<``int``> hs = ``new` `HashSet<``int``>();` `        ``// Initialize sum of elements` `        ``int` `sum = 0;`   `        ``// Traverse through the given array` `        ``for` `(``int` `i = 0; i < arr.Length; i++) ` `        ``{` `            ``// Add current element to sum` `            ``sum += arr[i];`   `            ``// Return true in following cases` `            ``// a) Current element is 0` `            ``// b) sum of elements from 0 to i is 0` `            ``// c) sum is already present in hash set` `            ``if` `(arr[i] == 0 ` `                ``|| sum == 0 ` `                ``|| hs.Contains(sum))` `                ``return` `true``;`   `            ``// Add sum to hash set` `            ``hs.Add(sum);` `        ``}`   `        ``// We reach here only when there is` `        ``// no subarray with 0 sum` `        ``return` `false``;` `    ``}`   `    ``// Main Method` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] arr = { -3, 2, 3, 1, 6 };` `        ``if` `(SubArrayExists(arr))` `            ``Console.WriteLine(` `                ``"Found a subarray with 0 sum"``);` `        ``else` `            ``Console.WriteLine(``"No Such Sub Array Exists!"``);` `    ``}` `}`

## Javascript

 `// A Javascript program to` `//  find if there is a zero sum subarray`   `const subArrayExists = (arr) => {` `    ``const sumSet = ``new` `Set();`   `    ``// Traverse through array ` `    ``// and store prefix sums` `    ``let sum = 0;` `    ``for` `(let i = 0 ; i < arr.length ; i++)` `    ``{` `        ``sum += arr[i];`   `        ``// If prefix sum is 0 ` `        ``// or it is already present` `        ``if` `(sum === 0 || sumSet.has(sum))` `            ``return` `true``;`   `        ``sumSet.add(sum);` `    ``}` `    ``return` `false``;` `}`   `// Driver code`   `const arr =  [-3, 2, 3, 1, 6];` `if` `(subArrayExists(arr))` `    ``console.log(``"Found a subarray with 0 sum"``);` `else` `    ``console.log(``"No Such Sub Array Exists!"``);`

Output

`No Such Sub Array Exists!`

Time Complexity of this solution can be considered as O(n) under the assumption that we have good hashing function that allows insertion and retrieval operations in O(1) time.
Space Complexity: O(n) .Here we required extra space for unordered_set to insert array elements.

Exercise:
Extend the above program to print starting and ending indexes of all subarrays with 0 sum.