Related Articles

# Find if there is a subarray with 0 sum

• Difficulty Level : Medium
• Last Updated : 08 Feb, 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;``}`

## 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 map``            ``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.