Why Three Sum Problem All Unique Triplets in DSA C?

The Big Idea

What if you could find all zero-sum triplets in seconds instead of hours of manual checking?

The Scenario

Imagine you have a list of numbers and you want to find all groups of three numbers that add up to zero. Doing this by hand means checking every possible group of three numbers one by one.

The Problem

Checking every group manually takes a very long time, especially if the list is big. It is easy to miss some groups or count the same group more than once, making the process slow and error-prone.

The Solution

The Three Sum problem solution uses a smart way to sort the list and then use two pointers to find the groups quickly without repeating the same groups. This method saves time and avoids mistakes.

Before vs After

✗ Before

for (int i = 0; i < n-2; i++) {
  for (int j = i+1; j < n-1; j++) {
    for (int k = j+1; k < n; k++) {
      if (arr[i] + arr[j] + arr[k] == 0) {
        print_triplet(arr[i], arr[j], arr[k]);
      }
    }
  }
}

✓ After

sort(arr, arr + n);
for (int i = 0; i < n-2; i++) {
  if (i > 0 && arr[i] == arr[i-1]) continue;
  int left = i + 1, right = n - 1;
  while (left < right) {
    int sum = arr[i] + arr[left] + arr[right];
    if (sum == 0) {
      print_triplet(arr[i], arr[left], arr[right]);
      while (left < right && arr[left] == arr[left+1]) left++;
      while (left < right && arr[right] == arr[right-1]) right--;
      left++; right--;
    } else if (sum < 0) left++;
    else right--;
  }
}

What It Enables

This approach makes it possible to find all unique triplets that sum to zero quickly and correctly, even in large lists.

Real Life Example

Finding three products whose prices add up to zero after applying discounts or credits in a shopping app to offer special deals.

Key Takeaways

Manual checking of all triplets is slow and error-prone.

Sorting and two-pointer technique speeds up the search and avoids duplicates.

Efficiently finds all unique triplets summing to zero in large data sets.