# 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