Java Program to Find the Minimum Distance Between Array Elements

Finding the minimum distance between two specified elements in an array is a common problem in computer science and data analysis. This task involves calculating the smallest distance between the first occurrences of two distinct elements within a given array. Such a problem is pertinent in applications that involve optimizing search algorithms, analyzing data patterns, and processing data structures efficiently.

Input:

 
int[] arr = {8, 2, 5, 7, 5, 9, 8, 6};
int x = 8, y = 5;   

Output:

 
Minimum distance between 8 and 5 is 3.

1. Brute-Force Method

Iterate through all pairs: For every pair of indices i and j in the array, check if the elements at these indices are equal to x and y.

Calculate distance: When both elements are found, calculate the distance between their indices.

Track minimum distance: Keep track of the minimum distance encountered during the traversal.

File Name: MinimumDistanceBruteForce.java

 
public class MinimumDistanceBruteForce {
    // Function to find the minimum distance between two specified elements in an array
    public static int findMinDistanceBruteForce(int[] arr, int x, int y) {
        int minDistance = Integer.MAX_VALUE; // Initialize minDistance to a large value        
        // Iterate through all pairs of indices
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                // Check if the pair of elements are x and y (or y and x)
                if ((arr[i] == x && arr[j] == y) || (arr[i] == y && arr[j] == x)) {
                    // Calculate the distance between the two indices
                    minDistance = Math.min(minDistance, Math.abs(i - j));
                }
            }
        }        
        // Return -1 if no valid distance was found
        return minDistance == Integer.MAX_VALUE ? -1 : minDistance;
    }
    public static void main(String[] args) {
        int[] arr1 = {10, 5, 3, 2, 5, 3, 7};
        int x1 = 5, y1 = 3;
        System.out.println("Minimum distance between " + x1 + " and " + y1 + " is " + findMinDistanceBruteForce(arr1, x1, y1)); // Output: 1
        int[] arr2 = {8, 2, 5, 7, 5, 9, 8, 6};
        int x2 = 8, y2 = 5;
        System.out.println("Minimum distance between " + x2 + " and " + y2 + " is " + findMinDistanceBruteForce(arr2, x2, y2)); // Output: 2
    }
}   

Output:

 
Minimum distance between 5 and 3 is 1
Minimum distance between 8 and 5 is 2

Time Complexity: O(n²) - It is due to the nested loop, where each element is compared with every other element.

Space Complexity: O(1) - No additional space is required apart from a few variables.

Pros:

Simplicity: This method is straightforward to implement and understand. It involves iterating through all pairs of indices in the array to find the minimum distance.
No additional data structures: It doesn't require any extra data structures, making it easy to code.

Cons:

Inefficiency: With a time complexity of O(n²), this method is highly inefficient for large arrays. It involves nested loops where each element is compared with every other element, leading to quadratic growth in computation time.
Performance limitations: Due to its inefficiency, this method is not suitable for performance-critical applications or large datasets.

2. Single-Pass with Index Tracking

Track indices: Traverse the array once while keeping track of the last seen indices of the two elements x and y.

Calculate distance: Whenever both elements are encountered, compute the distance between their indices.

Update minimum distance: Maintain the minimum distance found during the traversal.

File Name: MinimumDistanceIndexTracking.java

 
public class MinimumDistanceIndexTracking {
    // Function to find the minimum distance between two specified elements in an array
    public static int findMinDistance(int[] arr, int x, int y) {
        int indexX = -1; // Index of the last occurrence of x
        int indexY = -1; // Index of the last occurrence of y
        int minDistance = Integer.MAX_VALUE; // Initialize minDistance to a large value        
        // Traverse the array
        for (int i = 0; i < arr.length; i++) {
            // Update indexX if the current element is x
            if (arr[i] == x) {
                indexX = i;
                // Calculate distance if indexY has been set
                if (indexY != -1) {
                    minDistance = Math.min(minDistance, Math.abs(indexX - indexY));
                }
            }           
            // Update indexY if the current element is y
            if (arr[i] == y) {
                indexY = i;
                // Calculate distance if indexX has been set
                if (indexX != -1) {
                    minDistance = Math.min(minDistance, Math.abs(indexX - indexY));
                }
            }
        }        
        // Return -1 if no valid distance was found
        return minDistance == Integer.MAX_VALUE ? -1 : minDistance;
    }
    public static void main(String[] args) {
        int[] arr1 = {10, 5, 3, 2, 5, 3, 7};
        int x1 = 5, y1 = 3;
        System.out.println("Minimum distance between " + x1 + " and " + y1 + " is " + findMinDistance(arr1, x1, y1)); // Output: 1
        int[] arr2 = {8, 2, 5, 7, 5, 9, 8, 6};
        int x2 = 8, y2 = 5;
        System.out.println("Minimum distance between " + x2 + " and " + y2 + " is " + findMinDistance(arr2, x2, y2)); // Output: 2
    }
}   

Output:

 
Minimum distance between 5 and 3 is 1
Minimum distance between 8 and 5 is 2

Time Complexity: O(n) - Single pass through the array.

Space Complexity: O(1) - Only a few variables are used for tracking indices and distance.

Pros:

Efficiency: This method has a linear time complexity of O(n) because it only requires a single pass through the array. It is much more efficient than the brute-force approach.
Constant space complexity: It uses only a few extra variables to keep track of the indices, resulting in O(1) space complexity.

Cons:

Intuitiveness: While efficient, this method may not be as intuitive or easy to understand at first glance compared to the brute-force method.

3. Using HashMap

Store indices in a HashMap: Traverse the array and store the indices of occurrences of both elements in a HashMap.

Calculate distance: Once both elements have been encountered, calculate the distance using the stored indices.

Track minimum distance: Update the minimum distance if the current distance is smaller.

File Name: MinimumDistanceHashMap.java

 
import java.util.HashMap;
public class MinimumDistanceHashMap {
    // Function to find the minimum distance between two specified elements in an array
    public static int findMinDistanceUsingHashMap(int[] arr, int x, int y) {
        HashMap<Integer, Integer> indexMap = new HashMap<>(); // HashMap to store indices
        int minDistance = Integer.MAX_VALUE; // Initialize minDistance to a large value        
        // Traverse the array
        for (int i = 0; i < arr.length; i++) {
            // Update the HashMap and calculate distances
            if (arr[i] == x) {
                indexMap.put(x, i);
                if (indexMap.containsKey(y)) {
                    minDistance = Math.min(minDistance, Math.abs(i - indexMap.get(y)));
                }
            }           
            if (arr[i] == y) {
                indexMap.put(y, i);
                if (indexMap.containsKey(x)) {
                    minDistance = Math.min(minDistance, Math.abs(i - indexMap.get(x)));
                }
            }
        }        
        // Return -1 if no valid distance was found
        return minDistance == Integer.MAX_VALUE ? -1 : minDistance;
    }
    public static void main(String[] args) {
        int[] arr1 = {10, 5, 3, 2, 5, 3, 7};
        int x1 = 5, y1 = 3;
        System.out.println("Minimum distance between " + x1 + " and " + y1 + " is " + findMinDistanceUsingHashMap(arr1, x1, y1)); // Output: 1
        int[] arr2 = {8, 2, 5, 7, 5, 9, 8, 6};
        int x2 = 8, y2 = 5;
        System.out.println("Minimum distance between " + x2 + " and " + y2 + " is " + findMinDistanceUsingHashMap(arr2, x2, y2)); // Output: 2
    }
}   

Output:

 
Minimum distance between 5 and 3 is 1
Minimum distance between 8 and 5 is 2

Time Complexity: O(n) - Single traversal of the array.

Space Complexity: O(n) - HashMap requires additional space proportional to the number of elements.

Pros:

Efficiency: Like the single-pass method, this approach also has a linear time complexity of O(n). It is effective in finding the minimum distance between elements.
Handling multiple occurrences: This method handles cases with numerous occurrences of the specified elements gracefully by using a hash map to store indices.

Cons:

Space complexity: The use of a hash map requires additional space proportional to the number of elements in the array, leading to O(n) space complexity.
Complexity in implementation: Managing a hash map adds some complexity to the implementation.

Conclusion

When solving the problem of finding the minimum distance between two specified elements in an array, there are three standard methods: the brute-force method, the single-pass method with index tracking, and the method using hash maps. Each has its own pros and cons, making them suitable for different scenarios based on performance and memory considerations.

The choice of method depends on the specific requirements and constraints of the problem. For small arrays or simple applications, the brute-force method may suffice. However, for large datasets or performance-critical applications, the single-pass method with index tracking or the hash map method is more suitable due to their efficiency. Consider the available memory and the need for simplicity versus performance when selecting the best approach.

Next TopicJava-program-to-find-the-smallest-positive-number-missing-from-an-unsorted-array

← prev next →