Three Sum Problem All Unique Triplets in DSA Javascript - Time & Space Complexity

Time Complexity: Three Sum Problem All Unique Triplets

O(n²)

Understanding Time Complexity

We want to understand how the time needed to find all unique triplets that sum to zero grows as the input list gets bigger.

How does the number of steps change when the list size increases?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

function threeSum(nums) {
  nums.sort((a, b) => a - b);
  const result = [];
  for (let i = 0; i < nums.length - 2; i++) {
    if (i > 0 && nums[i] === nums[i - 1]) continue;
    let left = i + 1, right = nums.length - 1;
    while (left < right) {
      const sum = nums[i] + nums[left] + nums[right];
      if (sum === 0) {
        result.push([nums[i], nums[left], nums[right]]);
        while (nums[left] === nums[left + 1]) left++;
        while (nums[right] === nums[right - 1]) right--;
        left++;
        right--;
      } else if (sum < 0) {
        left++;
      } else {
        right--;
      }
    }
  }
  return result;
}
    

This code finds all unique triplets in the array that add up to zero by sorting and using a two-pointer approach.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The outer for-loop runs through each element, and inside it, the while-loop moves two pointers to find pairs.
• How many times: The outer loop runs about n times, and the inner while-loop runs up to n times in total for each outer loop step.

How Execution Grows With Input

As the input size grows, the number of operations grows roughly with the square of the input size.

Input Size (n)	Approx. Operations
10	About 100
100	About 10,000
1000	About 1,000,000

Pattern observation: Doubling the input size roughly quadruples the work because of the nested loops.

Final Time Complexity

Time Complexity: O(n²)

This means the time needed grows roughly with the square of the input size, so if the list doubles, the work increases about four times.

Common Mistake

[X] Wrong: "Because there are three numbers, the time complexity must be O(n³)."

[OK] Correct: The sorting and two-pointer method reduce the inner search to linear time, so the total is O(n²), not cubic.

Interview Connect

Understanding this time complexity helps you explain how efficient your solution is and shows you can optimize nested loops with smart techniques.

Self-Check

"What if we used three nested loops instead of sorting and two pointers? How would the time complexity change?"

Practice

1. What is the main goal of the Three Sum Problem in algorithms?

easy

A. Find all unique triplets in an array that sum to zero

B. Sort the array in ascending order

C. Find the maximum sum of any three elements

D. Count the number of pairs that sum to zero

Solution

1. Step 1: Understand the problem statement

   The Three Sum Problem asks to find all unique sets of three numbers in an array whose sum is zero.

2. Step 2: Differentiate from other sum problems

   Unlike sorting or pair sums, this problem specifically targets triplets summing to zero without duplicates.

3. Final Answer:

   Find all unique triplets in an array that sum to zero -> Option A

4. Quick Check:

   Three Sum Problem = Find unique triplets summing to zero [OK]

Hint: Look for three numbers adding to zero without repeats [OK]

Common Mistakes:

• Confusing with pair sum problems
• Thinking it requires sorting only
• Looking for max sum instead of zero sum

2. Which of the following is the correct way to start sorting an array nums in JavaScript before solving the Three Sum Problem?

easy

A. nums.sort()

B. nums.sorted()

C. nums.sort((a, b) => b - a)

D. nums.sort((a, b) => a - b)

Solution

1. Step 1: Understand JavaScript sort behavior

   By default, sort() converts elements to strings and sorts lexicographically, which is incorrect for numbers.

2. Step 2: Use numeric comparator for ascending order

   Using nums.sort((a, b) => a - b) sorts numbers correctly in ascending order, which is needed for the algorithm.

3. Final Answer:

   nums.sort((a, b) => a - b) -> Option D

4. Quick Check:

   Numeric ascending sort = nums.sort((a, b) => a - b) [OK]

Hint: Use comparator (a, b) => a - b for numeric ascending sort [OK]

Common Mistakes:

• Using default sort() without comparator
• Using descending sort when ascending needed
• Using non-existent method sorted()

3. What will be the output of the following code snippet?

function threeSum(nums) {
  nums.sort((a, b) => a - b);
  const result = [];
  for (let i = 0; i < nums.length - 2; i++) {
    if (i > 0 && nums[i] === nums[i - 1]) continue;
    let left = i + 1, right = nums.length - 1;
    while (left < right) {
      const sum = nums[i] + nums[left] + nums[right];
      if (sum === 0) {
        result.push([nums[i], nums[left], nums[right]]);
        while (nums[left] === nums[left + 1]) left++;
        while (nums[right] === nums[right - 1]) right--;
        left++;
        right--;
      } else if (sum < 0) {
        left++;
      } else {
        right--;
      }
    }
  }
  return result;
}

console.log(threeSum([-1,0,1,2,-1,-4]));

medium

A. [[-1, 0, 1], [0, 1, 2]]

B. [[-1, -1, 2], [-1, 0, 1]]

C. [[-4, 2, 2], [-1, 0, 1]]

D. [[0, 0, 0]]

Solution

1. Step 1: Sort the array

   Sorted array is [-4, -1, -1, 0, 1, 2].

2. Step 2: Find unique triplets summing to zero

   Triplets found are [-1, -1, 2] and [-1, 0, 1]. These are pushed to result.

3. Final Answer:

   [[-1, -1, 2], [-1, 0, 1]] -> Option B

4. Quick Check:

   Unique triplets summing zero = [[-1,-1,2],[-1,0,1]] [OK]

Hint: Sort array, use two pointers to find zero sum triplets [OK]

Common Mistakes:

• Not sorting before two-pointer approach
• Including duplicate triplets
• Incorrect pointer movement logic

4. Identify the bug in this Three Sum implementation snippet:

function threeSum(nums) {
  nums.sort((a, b) => a - b);
  const result = [];
  for (let i = 0; i < nums.length - 2; i++) {
    if (nums[i] === nums[i - 1]) continue;
    let left = i + 1, right = nums.length - 1;
    while (left < right) {
      const sum = nums[i] + nums[left] + nums[right];
      if (sum === 0) {
        result.push([nums[i], nums[left], nums[right]]);
        while (nums[left] === nums[left + 1]) left++;
        while (nums[right] === nums[right - 1]) right--;
        left++;
        right--;
      } else if (sum < 0) {
        left++;
      } else {
        right--;
      }
    }
  }
  return result;
}

medium

A. The duplicate check for nums[i] should skip when i > 0

B. The sorting comparator is incorrect

C. The pointers left and right are not updated

D. The result array is not initialized

Solution

1. Step 1: Check duplicate skipping condition

   The condition if (nums[i] === nums[i - 1]) continue; runs even when i = 0, causing incorrect skipping.

2. Step 2: Correct condition to skip duplicates only if i > 0

   It should be if (i > 0 && nums[i] === nums[i - 1]) continue; to avoid skipping first element.

3. Final Answer:

   The duplicate check for nums[i] should skip when i > 0 -> Option A

4. Quick Check:

   Duplicate skip needs i > 0 check [OK]

Hint: Check index bounds when skipping duplicates [OK]

Common Mistakes:

• Skipping duplicates without index check
• Wrong sorting comparator
• Forgetting to update pointers

5. Given the array nums = [3, 0, -2, -1, 1, 2], which of the following is the correct set of unique triplets that sum to zero?

hard

A. [[-2, 2, 3], [-1, 0, 1]]

B. [[-2, -1, 3], [-1, 1, 2]]

C. [[-2, -1, 3], [-2, 0, 2], [-1, 0, 1]]

D. [[0, 0, 0], [-1, 1, 0]]

Solution

1. Step 1: Sort the array

   Sorted array is [-2, -1, 0, 1, 2, 3].

2. Step 2: Find all unique triplets summing to zero

   Triplets are [-2, -1, 3], [-2, 0, 2], and [-1, 0, 1].

3. Final Answer:

   [[-2, -1, 3], [-2, 0, 2], [-1, 0, 1]] -> Option C

4. Quick Check:

   Sorted + two pointers find unique zero sum triplets [OK]

Hint: Sort and use two pointers to find all zero sum triplets [OK]

Common Mistakes:

• Missing some triplets
• Including duplicates
• Incorrect triplet sums