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

Last Updated : 08 Oct, 2023

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;` `}`

Java

 `import` `java.util.ArrayList;` `import` `java.util.Arrays;` `import` `java.util.List;`   `public` `class` `Main {` `    ``// Function to return all pairs having minimal absolute difference` `    ``public` `static` `List> minAbsDiffPairs(``int``[] arr) {` `        ``// Sort the array in non-decreasing order` `        ``Arrays.sort(arr);`   `        ``// Find the minimum absolute difference between pairs` `        ``int` `minDiff = Integer.MAX_VALUE;` `        ``List> pairs = ``new` `ArrayList<>();`   `        ``for` `(``int` `i = ``0``; i < arr.length - ``1``; i++) {` `            ``int` `diff = Math.abs(arr[i] - arr[i + ``1``]);`   `            ``// If the current difference is smaller than the minimum difference so far` `            ``if` `(diff < minDiff) {` `                ``minDiff = diff;` `                ``pairs.clear();` `                ``pairs.add(Arrays.asList(arr[i], arr[i + ``1``]));` `            ``}` `            ``// If the current difference is equal to the minimum difference so far` `            ``else` `if` `(diff == minDiff) {` `                ``pairs.add(Arrays.asList(arr[i], arr[i + ``1``]));` `            ``}` `        ``}`   `        ``return` `pairs;` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``int``[] arr = { ``4``, ``2``, ``1``, ``3` `};` `        ``List> pairs = minAbsDiffPairs(arr);`   `        ``// Print all pairs` `        ``for` `(List pair : pairs) {` `            ``System.out.println(pair.get(``0``) + ``" "` `+ pair.get(``1``));` `        ``}` `    ``}` `}`

Python

 `def` `min_abs_diff_pairs(arr):` `    ``# Sort the array in non-decreasing order` `    ``arr.sort()`   `    ``# Find the minimum absolute difference between pairs` `    ``min_diff ``=` `float``(``'inf'``)` `    ``pairs ``=` `[]` `    ``for` `i ``in` `range``(``len``(arr)):` `        ``for` `j ``in` `range``(i ``+` `1``, ``len``(arr)):` `            ``diff ``=` `abs``(arr[i] ``-` `arr[j])` `            ``if` `diff < min_diff:` `                ``min_diff ``=` `diff` `                ``pairs ``=` `[[arr[i], arr[j]]]` `            ``elif` `diff ``=``=` `min_diff:` `                ``pairs.append([arr[i], arr[j]])`   `    ``return` `pairs`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``4``, ``2``, ``1``, ``3``]` `    ``pairs ``=` `min_abs_diff_pairs(arr)`   `    ``# Print all pairs` `    ``for` `v ``in` `pairs:` `        ``print``(v[``0``], v[``1``])` `       `

C#

 `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `public` `class` `GFG {` `    ``// Function to return all pairs having minimal absolute` `    ``// difference` `    ``public` `static` `List >` `    ``MinAbsDiffPairs(List<``int``> arr)` `    ``{` `        ``// Sort the array in non-decreasing order` `        ``arr.Sort();`   `        ``// Find the minimum absolute difference between` `        ``// pairs` `        ``int` `min_diff = ``int``.MaxValue;` `        ``List > pairs = ``new` `List >();` `        ``for` `(``int` `i = 0; i < arr.Count; i++) {` `            ``for` `(``int` `j = i + 1; j < arr.Count; j++) {` `                ``int` `diff = Math.Abs(arr[i] - arr[j]);` `                ``if` `(diff < min_diff) {` `                    ``min_diff = diff;` `                    ``pairs.Clear();` `                    ``pairs.Add(` `                        ``new` `List<``int``>{ arr[i], arr[j] });` `                ``}` `                ``else` `if` `(diff == min_diff) {` `                    ``pairs.Add(` `                        ``new` `List<``int``>{ arr[i], arr[j] });` `                ``}` `            ``}` `        ``}`   `        ``return` `pairs;` `    ``}`   `    ``public` `static` `void` `Main()` `    ``{` `        ``List<``int``> arr = ``new` `List<``int``>{ 4, 2, 1, 3 };` `        ``List > pairs = MinAbsDiffPairs(arr);`   `        ``// Print all pairs` `        ``foreach``(``var` `v ``in` `pairs)` `        ``{` `            ``Console.WriteLine(v[0] + ``" "` `+ v[1]);` `        ``}` `    ``}` `}`

Javascript

 `// Function to return all` `// pairs having minimal absolute difference` `function` `minAbsDiffPairs(arr) {` `    ``// Sort the array in non-decreasing order` `    ``arr.sort((a, b) => a - b);`   `    ``// Find the minimum absolute difference between pairs` `    ``let min_diff = Number.MAX_VALUE;` `    ``let pairs=[];` `    ``for` `(let i = 0; i < arr.length; i++) {` `        ``for` `(let j = i+1; j < arr.length; j++) {` `            ``let diff = Math.abs(arr[i] - arr[j]);` `            ``if` `(diff < min_diff) {` `                ``min_diff = diff;` `                ``pairs=[[arr[i], arr[j]]];` `            ``}` `            ``else` `if` `(diff == min_diff) {` `                ``pairs.push([arr[i], arr[j]]);` `            ``}` `        ``}` `    ``}`   `    ``return` `pairs;` `}`   `// Driver Code` `let arr = [ 4, 2, 1, 3 ];` `let pairs = minAbsDiffPairs(arr);`   `// Print all pairs` `for` `(let v of pairs) {` `    ``console.log(v[0]+  ``" "``+  v[1]);` `}`

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.

Article Tags :
Practice Tags :