# LeetCode – 3Sum Closest (Java)

Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.

```For example, given array S = {-1 2 1 -4}, and target = 1.
The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
```

Analysis

This problem is similar to 2 Sum. This kind of problem can be solved by using a similar approach, i.e., two pointers from both left and right.

Java Solution

```public int threeSumClosest(int[] nums, int target) { int min = Integer.MAX_VALUE; int result = 0;   Arrays.sort(nums);   for (int i = 0; i < nums.length; i++) { int j = i + 1; int k = nums.length - 1; while (j < k) { int sum = nums[i] + nums[j] + nums[k]; int diff = Math.abs(sum - target);   if(diff == 0) return sum;   if (diff < min) { min = diff; result = sum; } if (sum <= target) { j++; } else { k--; } } }   return result; }```

Time Complexity is O(n^2).

### 18 thoughts on “LeetCode – 3Sum Closest (Java)”

1. sort the array. I think you forgot that step

2. Do we need to have “=” (sum <= target) here ?? since if its equal the diff will be zero and we will be returning sum.

3. Looks so. Can You proof that? Thanks.

4. Wouldn’t it be sufficient if the main loop is iterated only till nums.length-2. Thanks.

5. Your solution assumes the 3 values must be next to each other, which is not true. E.g. {1,3,5,7} tgt = 13

6. This doesn’t work for

Input:[1,1,1,0]
Target:100

Output:
2

Expected:3

7. fixed.

8. Can be converted to a binary search problem after sorting.

The runtime is NlogN(sorting)+logN(binary search)=NlogN

9. public int threeSumCloset(int[]numbers, int target){
if (numbers == null || numbers.length < 3){
return Integer.MAX_VALUE;
}
int min = Integer.MAX_VALUE / 2;
int result = Integer.MAX_VALUE / 2;
Arrays.sort(numbers);
int length = numbers.length;
for (int i = 0; i numbers[i – 1]){
int start = i + 1;
int end = length – 1;
while (start Math.abs(sum – target)){
min = Math.abs(sum – target);
result = sum;
}

start++;
end–;

while (start < end && numbers[start] == numbers[start – 1]){
start++;
}
while (start < end && numbers[end] == numbers[end + 1]){
end–;
}
}
}
}

return result;
}
}

10. if(diff == 0) return 0; is wrong, you should return sum instead.

11. Shouldn’t it be
if(diff == 0) return target;

12. Can this be done using c++ implementation, I’m not able to do it …

13. you should return target if diff equals 0

14. Not necessarily. Because different combinations can still have the same sum value. An extreme case: given array {1, 1, 1, 1, 1} and target value 1.

16. “You may assume that each input would have exactly one solution” Does this mean no duplicates in array?

17. Hi, good code!

But I think add this line of code:

if (diff == 0) return sum;

behind the code:

int diff = Math.abs(sum – target);

maybe makes the run time shorter?

18. Like your code. Always short and clean, plus easy to understand following a logic. Thumbs up!