Java Program to Find Two Elements Whose Sum is Closest to Zero

A popular issue in computer science, "finding two elements in an array whose sum is closest to zero" is often posed in coding interviews because it may be used to assess a candidate's ability to solve problems, comprehend sorting algorithms, and use the two-pointer technique.

Finding two different entries in an array whose combined value is as near to zero as possible is the goal of this challenge. Sorting and the two-pointer technique can be used to solve this problem efficiently.

The sorting time complexity is O(n logn), and the two-pointer traversal time complexity is O(n), making the total complexity O(n ogn). The approach not only yields the best answer but also shows how several algorithmic techniques can be combined to efficiently solve complicated issues.

Approach

To solve this problem, we can follow these steps:

Sort the Array: First, sort the array. Sorting helps in efficiently finding pairs of numbers using the two-pointer technique.
Initialize Two Pointers: Use two pointers, one starting from the beginning (left) and the other from the end (right) of the array.
Iterate and Find the Pair: Calculate the sum of the elements at these two pointers. If the sum is closer to zero than the previously recorded sum, update the closest sum. Depending on the sum, move the pointers inward to find the closest pair.

Detailed Explanation

Sorting the Array: Sorting the array helps in reducing the problem complexity. A sorted array allows us to use the two-pointer technique effectively.
Using Two Pointers: By using two pointers, we can check the sum of pairs without having to use a nested loop, thus reducing the time complexity from O(n^2) to O(nlogn) due to sorting.
Updating the Closest Sum: Keep track of the closest sum found and the corresponding pair of elements.

File Name: ClosestSumToZero.java

 
import java.util.Arrays;
public class ClosestSumToZero {
    // Function to find the two elements whose sum is closest to zero
    public static void findClosestToZero(int[] arr) {
        if (arr.length < 2) {
            System.out.println("Array should have at least two elements.");
            return;
        }
        // Sort the array
        Arrays.sort(arr);
        // Initialize variables
        int left = 0;
        int right = arr.length - 1;
        int minSum = Integer.MAX_VALUE;
        int closestLeft = left;
        int closestRight = right;
        // Use two pointers to find the closest sum to zero
        while (left < right) {
            int sum = arr[left] + arr[right];
            // Check if the absolute sum is less than the minimum sum found so far
            if (Math.abs(sum) < Math.abs(minSum)) {
                minSum = sum;
                closestLeft = left;
                closestRight = right;
            }
            // Move the pointers based on the sum
            if (sum < 0) {
                left++;
            } else {
                right--;
            }
        }
        // Output the result
        System.out.println("The two elements whose sum is closest to zero are: " + 
                           arr[closestLeft] + " and " + arr[closestRight]);
    }
    // Main method to test the function
    public static void main(String[] args) {
        int[] arr = {1, 60, -10, 70, -80, 85};
        findClosestToZero(arr);
    }
}   

Output:

 
The two elements whose sum is closest to zero are: -80 and 85

Explanation

The code begins by sorting the array using Arrays.sort(arr), which ensures that the elements are in ascending order. This sorting step is crucial because it allows the use of the two-pointer technique.

Once the array is sorted, two pointers, left and right, are initialized at the start and end of the array, respectively. The while loop runs as long as the left pointer is less than the right pointer, continuously calculating the sum of the elements at these two pointers.

If the sum is closer to zero than the previously recorded minimum sum, the code updates the minimum sum and the indices of the pair of elements. Depending on whether the sum is negative or positive, the left pointer is incremented (to increase the sum) or the right pointer is decremented (to decrease the sum), respectively. This pointer adjustment strategy helps in converging towards the pair of elements whose sum is closest to zero.

Conclusion

Using sorting and the two-pointer technique, the above method identifies the pair of elements in an array whose total is closest to zero. This approach is an excellent way to handle the problem because it is simple to comprehend and saves a lot of time.

Next TopicJava-program-to-perform-message-encoding-using-matrix-multiplication

← prev next →