GeeksforGeeks App
Open App
Browser
Continue

# Find all pairs in an Array in sorted order with minimum absolute difference

Given an integer array arr[] of size N, the task is to find all distinct pairs having minimum absolute difference and print them in ascending order.

Examples:

Input: arr[] = {4, 2, 1, 3}
Output: {1, 2}, {2, 3}, {3, 4}
Explanation: The minimum absolute difference between pairs is 1.

Input: arr[] = {1, 3, 8, 10, 15}
Output: {1, 3}, {8, 10}
Explanation: The minimum absolute difference between the pairs {1, 3}, {8, 10} is 2.

Approach (Using Nested Loop):

The basic idea is to compare each pair of elements in the array and find the pair(s) with the minimum absolute difference.

1. Sort the array arr in non-decreasing order.
2. Initialize a variable min_diff to store the minimum absolute difference between pairs. Set min_diff to a very large value (e.g., INT_MAX).
3. Initialize a vector pairs to store all pairs having the minimum absolute difference.
4. Iterate through the array arr using a nested loop. For each pair of elements (arr[i], arr[j]) such that i < j, compute the absolute difference diff = abs(arr[i] – arr[j]). If diff < min_diff, update min_diff with diff and clear the vector pairs. Add the pair (arr[i], arr[j]) to the vector pairs.
5. If diff == min_diff, add the pair (arr[i], arr[j]) to the vector pairs.
6. Return the vector pairs containing all pairs having the minimum absolute difference.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to return all``// pairs having minimal absolute difference``vector> minAbsDiffPairs(vector<``int``>& arr) {``    ``// Sort the array in non-decreasing order``    ``sort(arr.begin(), arr.end());` `    ``// Find the minimum absolute difference between pairs``    ``int` `min_diff = INT_MAX;``    ``vector> pairs;``    ``for` `(``int` `i = 0; i < arr.size(); i++) {``        ``for` `(``int` `j = i+1; j < arr.size(); j++) {``            ``int` `diff = ``abs``(arr[i] - arr[j]);``            ``if` `(diff < min_diff) {``                ``min_diff = diff;``                ``pairs.clear();``                ``pairs.push_back({arr[i], arr[j]});``            ``}``            ``else` `if` `(diff == min_diff) {``                ``pairs.push_back({arr[i], arr[j]});``            ``}``        ``}``    ``}` `    ``return` `pairs;``}` `// Driver Code``int` `main() {``    ``vector<``int``> arr = { 4, 2, 1, 3 };``    ``vector> pairs = minAbsDiffPairs(arr);` `    ``// Print all pairs``    ``for` `(``auto` `v : pairs) {``        ``cout << v[0] << ``" "` `<< v[1] << endl;``    ``}` `    ``return` `0;``}`

Output:

```     1 2
2 3
3 4```

Time Complexity: O(n^2 log n), where n is the size of the input array. This is because we are using a nested loop to compare each pair of elements in the array, and the sorting operation inside the outer loop has a time complexity of O(n log n).

Auxiliary Space: O(k), where k is the number of pairs having the minimum absolute difference.

Approach: The idea is to consider the absolute difference of the adjacent elements of the sorted array. Follow the steps below to solve the problem:

• Sort the given array arr[].
• Compare all adjacent pairs in the sorted array and find the minimum absolute difference between all adjacent pairs.
• Finally, print all the adjacent pairs having differences equal to the minimum absolute difference.

Below is the implementation of the above code:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to return all``// pairs having minimal absolute difference``vector > minAbsDiffPairs(vector<``int``>& arr)``{` `    ``vector > ans;``    ``int` `n = arr.size();` `    ``// Sort the array``    ``sort(arr.begin(), arr.end());` `    ``// Stores the minimal absolute difference``    ``int` `minDiff = INT_MAX;` `    ``for` `(``int` `i = 0; i < n - 1; i++)``        ``minDiff = min(minDiff, ``abs``(arr[i] - arr[i + 1]));` `    ``for` `(``int` `i = 0; i < n - 1; i++) {``        ``vector<``int``> pair;``        ``if` `(``abs``(arr[i] - arr[i + 1]) == minDiff) {``            ``pair.push_back(min(arr[i], arr[i + 1]));``            ``pair.push_back(max(arr[i], arr[i + 1]));``            ``ans.push_back(pair);``        ``}``    ``}` `    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``vector<``int``> arr = { 4, 2, 1, 3 };``    ``int` `N = (``sizeof` `arr) / (``sizeof` `arr[0]);` `    ``vector > pairs = minAbsDiffPairs(arr);` `    ``// Print all pairs``    ``for` `(``auto` `v : pairs)``        ``cout << v[0] << ``" "` `<< v[1] << endl;``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.ArrayList;``import` `java.util.Collections;` `class` `GFG``{``  ` `    ``// Function to return all``    ``// pairs having minimal absolute difference``    ``static` `ArrayList> minAbsDiffPairs(ArrayList arr) {` `        ``ArrayList> ans = ``new` `ArrayList>();``        ``int` `n = arr.size();` `        ``// Sort the array``        ``Collections.sort(arr);` `        ``// Stores the minimal absolute difference``        ``int` `minDiff = Integer.MAX_VALUE;` `        ``for` `(``int` `i = ``0``; i < n - ``1``; i++)``            ``minDiff = Math.min(minDiff, Math.abs(arr.get(i) - arr.get(i + ``1``)));` `        ``for` `(``int` `i = ``0``; i < n - ``1``; i++) {``            ``ArrayList pair = ``new` `ArrayList();``            ``if` `(Math.abs(arr.get(i) - arr.get(i + ``1``)) == minDiff) {``                ``pair.add(Math.min(arr.get(i), arr.get(i + ``1``)));``                ``pair.add(Math.max(arr.get(i), arr.get(i + ``1``)));``                ``ans.add(pair);``            ``}``        ``}` `        ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[]) {``        ``ArrayList arr = ``new` `ArrayList();``        ``arr.add(``4``);``        ``arr.add(``2``);``        ``arr.add(``1``);``        ``arr.add(``3``);` `        ``ArrayList> pairs = minAbsDiffPairs(arr);` `        ``// Print all pairs``        ``// System.out.println(pairs);``        ``for` `(ArrayList v : pairs) {``            ``for` `(``int` `w : v)``                ``System.out.print(w + ``" "``);``            ``System.out.println(``""``);``        ``}``    ``}``}` `// This code is contributed by saurabh_jaiswal.`

## Python3

 `# Python3 program for the above approach``import` `math as Math` `# Function to return all pairs having``# minimal absolute difference``def` `minAbsDiffPairs(arr):` `    ``ans ``=` `[]``    ``n ``=` `len``(arr)` `    ``# Sort the array``    ``arr.sort()` `    ``# Stores the minimal absolute difference``    ``minDiff ``=` `10` `*``*` `9` `    ``for` `i ``in` `range``(n ``-` `1``):``        ``minDiff ``=` `min``(minDiff, Math.fabs(arr[i] ``-``                                         ``arr[i ``+` `1``]))` `    ``for` `i ``in` `range``(n ``-` `1``):``        ``pair ``=` `[]``        ``if` `(Math.fabs(arr[i] ``-` `arr[i ``+` `1``]) ``=``=` `minDiff):``            ``pair.append(``min``(arr[i], arr[i ``+` `1``]))``            ``pair.append(``max``(arr[i], arr[i ``+` `1``]))``            ``ans.append(pair)``            ` `    ``return` `ans` `# Driver Code``arr ``=` `[ ``4``, ``2``, ``1``, ``3` `]``N ``=` `len``(arr)` `pairs ``=` `minAbsDiffPairs(arr)` `# Print all pairs``for` `v ``in` `pairs:``    ``print``(f``"{v[0]} {v[1]}"``)` `# This code is contributed by gfgking`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `  ``// Function to return all``  ``// pairs having minimal Absolute difference``  ``static` `List> minAbsDiffPairs(List<``int``> arr) {` `    ``List> ans = ``new` `List>();``    ``int` `n = arr.Count;` `    ``// Sort the array``    ``arr.Sort();` `    ``// Stores the minimal Absolute difference``    ``int` `minDiff = ``int``.MaxValue;` `    ``for` `(``int` `i = 0; i < n - 1; i++)``      ``minDiff = Math.Min(minDiff, Math.Abs(arr[i] - arr[i + 1]));` `    ``for` `(``int` `i = 0; i < n - 1; i++) {``      ``List<``int``> pair = ``new` `List<``int``>();``      ``if` `(Math.Abs(arr[i] - arr[i + 1]) == minDiff) {``        ``pair.Add(Math.Min(arr[i], arr[i + 1]));``        ``pair.Add(Math.Max(arr[i], arr[i + 1]));``        ``ans.Add(pair);``      ``}``    ``}` `    ``return` `ans;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{``    ``List<``int``> arr = ``new` `List<``int``>();``    ``arr.Add(4);``    ``arr.Add(2);``    ``arr.Add(1);``    ``arr.Add(3);` `    ``List> pairs = minAbsDiffPairs(arr);` `    ``// Print all pairs``    ``// System.out.println(pairs);``    ``foreach` `(List<``int``> v ``in` `pairs)``    ``{``      ``foreach` `(``int` `w ``in` `v)``        ``Console.Write(w + ``" "``);``      ``Console.WriteLine(``""``);``    ``}``  ``}``}` `// This code is contributed by saurabh_jaiswal.`

## Javascript

 ``

Output

```1 2
2 3
3 4```

Time Complexity: O(NlogN)
Auxiliary Space: O(N), since N extra space has been taken.

My Personal Notes arrow_drop_up