 Open in App
Not now

# C++ Program to Find if there is a subarray with 0 sum

• Last Updated : 26 Dec, 2021

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:
There is a subarray with zero sum from index 2 to 2.

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; ` `}`

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.

Please refer complete article on Find if there is a subarray with 0 sum for more details!

My Personal Notes arrow_drop_up
Related Articles