Javascript Program to Find all triplets with zero sum

Last Updated : 16 Sep, 2024

Given an array of distinct elements. The task is to find triplets in the array whose sum is zero.

Examples :

Input : arr[] = {0, -1, 2, -3, 1}
Output : (0 -1 1), (2 -3 1)

Explanation : The triplets with zero sum are
0 + -1 + 1 = 0 and 2 + -3 + 1 = 0  

Input : arr[] = {1, -2, 1, 0, 5}
Output : 1 -2  1
Explanation : The triplets with zero sum is
1 + -2 + 1 = 0

Method 1:

This is a simple method that takes O(n³) time to arrive at the result.

Approach:

The naive approach runs three loops and check one by one that sum of three elements is zero or not. If the sum of three elements is zero then print elements otherwise print not found.

Algorithm:

Run three nested loops with loop counter i, j, k
The first loops will run from 0 to n-3 and second loop from i+1 to n-2 and the third loop from j+1 to n-1. The loop counter represents the three elements of the triplet.
Check if the sum of elements at i'th, j'th, k'th is equal to zero or not. If yes print the sum else continue.

Below is the implementation of the above approach:

JavaScript

// A simple Javascript program to find //three elements whose sum is equal to zero arr = [0, -1, 2, -3, 1];  // Prints all triplets in arr[] with 0 sum     function findTriplets(arr) {     let found = false;     for (let i = 0; i < arr.length - 2; i++) {         for (let j = i + 1; j < arr.length - 1; j++) {             for (let k = j + 1; k < arr.length; k++) {                 if (arr[i] + arr[j] + arr[k] === 0) {                     console.log(arr[i] + " " + arr[j] + " " + arr[k]);                     found = true;                 }             }         }         // If no triplet with 0 sum found in array         if (found === false) {             console.log(" not exist ");         }     } } findTriplets(arr);

Output

0 -1 1 2 -3 1

Complexity Analysis:

Time Complexity: O(n³).
As three nested loops are required, so the time complexity is O(n³).
Auxiliary Space: O(1).
Since no extra space is required, so the space complexity is constant.

Method 2:

The second method uses the process of Hashing to arrive at the result and is solved at a lesser time of O(n²).

Approach:

This involves traversing through the array. For every element arr[i], find a pair with sum "-arr[i]". This problem reduces to pair sum and can be solved in O(n) time using hashing.

Algorithm:

Create a hashmap to store a key-value pair.
Run a nested loop with two loops, the outer loop from 0 to n-2 and the inner loop from i+1 to n-1
Check if the sum of ith and jth element multiplied with -1 is present in the hashmap or not
If the element is present in the hashmap, print the triplet else insert the j'th element in the hashmap.

Below is the implementation of the above approach:

JavaScript

// Javascript program to find triplets in a given // array whose sum is zero  // function to print triplets with 0 sum function findTriplets(arr, n) {     let found = false;      for (let i = 0; i < n - 1; i++) {         // Find all pairs with sum equals to         // "-arr[i]"         let s = new Set();         for (let j = i + 1; j < n; j++) {             let x = -(arr[i] + arr[j]);             if (s.has(x)) {                 console.log(x + " " + arr[i] + " " + arr[j]);                 found = true;             }             else                 s.add(arr[j]);         }     }      if (found == false)         console.log(" No Triplet Found"); }  // Driver code let arr = [0, -1, 2, -3, 1]; let n = arr.length; findTriplets(arr, n);

Output

-1 0 1 -3 2 1

Complexity Analysis:

Time Complexity: O(n²).
Since two nested loops are required, so the time complexity is O(n²).
Auxiliary Space: O(n).
Since a hashmap is required, so the space complexity is linear.

Method 3:

This method uses Sorting to arrive at the correct result and is solved in O(n²) time.

Approach:

The above method requires extra space. The idea is based on method 2 of this post. For every element check that there is a pair whose sum is equal to the negative value of that element.

Algorithm:

Sort the array in ascending order.
Traverse the array from start to end.
For every index i, create two variables l = i + 1 and r = n - 1
Run a loop until l is less than r if the sum of array[i], array[l] and array[r] is equal to zero then print the triplet and break the loop
If the sum is less than zero then increment the value of l, by increasing the value of l the sum will increase as the array is sorted, so array[l+1] > array [l]
If the sum is greater than zero then decrement the value of r, by increasing the value of l the sum will decrease as the array is sorted, so array[r-1] < a rray [r].

Below is the implementation of the above approach:

JavaScript

// Javascript program to find triplets in a given // array whose sum is zero  // function to print triplets with 0 sum function findTriplets(arr, n) {     let found = false;      // sort array elements     arr.sort((a, b) => a - b);      for (let i = 0; i < n - 1; i++) {         // initialize left and right         let l = i + 1;         let r = n - 1;         let x = arr[i];         while (l < r) {             if (x + arr[l] + arr[r] == 0) {                 // print elements if it's sum is zero                 console.log(x + " " + arr[l] + " " + arr[r])                 l++;                 r--;                 found = true;             }              // If sum of three elements is less             // than zero then increment in left             else if (x + arr[l] + arr[r] < 0)                 l++;              // if sum is greater than zero than             // decrement in right side             else                 r--;         }     }      if (found == false)         console.log(" No Triplet Found"); }  // Driven source  let arr = [0, -1, 2, -3, 1]; let n = arr.length; findTriplets(arr, n);

Output

-3 1 2 -1 0 1

Complexity Analysis:

Time Complexity : O(n²).
Only two nested loops are required, so the time complexity is O(n²).
Auxiliary Space : O(1), no extra space is required, so the time complexity is constant.

Please refer complete article on Find all triplets with zero sum for more details!.

Javascript Program to Find a triplet such that sum of two equals to third element

kartik

Improve

Article Tags :

Practice Tags :

Javascript Program to Find all triplets with zero sum

Method 1:

Approach:

Algorithm:

Complexity Analysis:

Method 2:

Approach:

Algorithm:

Method 3:

Approach:

Algorithm:

Complexity Analysis:

Similar Reads