Open in App
Not now

# Find minimum difference between any two elements (pair) in given array

• Difficulty Level : Basic
• Last Updated : 14 Feb, 2023

Given an unsorted array, find the minimum difference between any pair in the given array.

Examples :

Input: {1, 5, 3, 19, 18, 25}
Output: 1
Explanation: Minimum difference is between 18 and 19

Input: {30, 5, 20, 9}
Output: 4
Explanation: Minimum difference is between 5 and 9

Input: {1, 19, -4, 31, 38, 25, 100}
Output: 5
Explanation: Minimum difference is between 1 and -4

Recommended Practice

Naive Approach: To solve the problem follow the below idea:

A simple solution is to use two loops two generate every pair of elements and compare them to get the minimum difference

Below is the implementation of the above approach:

## C++

 `// C++ implementation of simple method to find` `// minimum difference between any pair` `#include ` `using` `namespace` `std;`   `// Returns minimum difference between any pair` `int` `findMinDiff(``int` `arr[], ``int` `n)` `{` `    ``// Initialize difference as infinite` `    ``int` `diff = INT_MAX;`   `    ``// Find the min diff by comparing difference` `    ``// of all possible pairs in given array` `    ``for` `(``int` `i = 0; i < n - 1; i++)` `        ``for` `(``int` `j = i + 1; j < n; j++)` `            ``if` `(``abs``(arr[i] - arr[j]) < diff)` `                ``diff = ``abs``(arr[i] - arr[j]);`   `    ``// Return min diff` `    ``return` `diff;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 5, 3, 19, 18, 25 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``// Function call` `    ``cout << ``"Minimum difference is "` `<< findMinDiff(arr, n);` `    ``return` `0;` `}`

## Java

 `// Java implementation of simple method to find` `// minimum difference between any pair`   `class` `GFG {` `    ``// Returns minimum difference between any pair` `    ``static` `int` `findMinDiff(``int``[] arr, ``int` `n)` `    ``{` `        ``// Initialize difference as infinite` `        ``int` `diff = Integer.MAX_VALUE;`   `        ``// Find the min diff by comparing difference` `        ``// of all possible pairs in given array` `        ``for` `(``int` `i = ``0``; i < n - ``1``; i++)` `            ``for` `(``int` `j = i + ``1``; j < n; j++)` `                ``if` `(Math.abs((arr[i] - arr[j])) < diff)` `                    ``diff = Math.abs((arr[i] - arr[j]));`   `        ``// Return min diff` `        ``return` `diff;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = ``new` `int``[] { ``1``, ``5``, ``3``, ``19``, ``18``, ``25` `};`   `        ``// Function call` `        ``System.out.println(``"Minimum difference is "` `                           ``+ findMinDiff(arr, arr.length));` `    ``}` `}`

## Python3

 `# Python implementation of simple method to find` `# minimum difference between any pair`   `# Returns minimum difference between any pair`     `def` `findMinDiff(arr, n):` `    ``# Initialize difference as infinite` `    ``diff ``=` `10``*``*``20`   `    ``# Find the min diff by comparing difference` `    ``# of all possible pairs in given array` `    ``for` `i ``in` `range``(n``-``1``):` `        ``for` `j ``in` `range``(i``+``1``, n):` `            ``if` `abs``(arr[i]``-``arr[j]) < diff:` `                ``diff ``=` `abs``(arr[i] ``-` `arr[j])`   `    ``# Return min diff` `    ``return` `diff`     `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``1``, ``5``, ``3``, ``19``, ``18``, ``25``]` `    ``n ``=` `len``(arr)`   `    ``# Function call` `    ``print``(``"Minimum difference is "` `+` `str``(findMinDiff(arr, n)))`   `# This code is contributed by Pratik Chhajer`

## C#

 `// C# implementation of simple method to find` `// minimum difference between any pair` `using` `System;`   `class` `GFG {`   `    ``// Returns minimum difference between any pair` `    ``static` `int` `findMinDiff(``int``[] arr, ``int` `n)` `    ``{`   `        ``// Initialize difference as infinite` `        ``int` `diff = ``int``.MaxValue;`   `        ``// Find the min diff by comparing difference` `        ``// of all possible pairs in given array` `        ``for` `(``int` `i = 0; i < n - 1; i++)` `            ``for` `(``int` `j = i + 1; j < n; j++)` `                ``if` `(Math.Abs((arr[i] - arr[j])) < diff)` `                    ``diff = Math.Abs((arr[i] - arr[j]));`   `        ``// Return min diff` `        ``return` `diff;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] arr = ``new` `int``[] { 1, 5, 3, 19, 18, 25 };`   `        ``// Function call` `        ``Console.Write(``"Minimum difference is "` `                      ``+ findMinDiff(arr, arr.Length));` `    ``}` `}`   `// This code is contributed by nitin mittal.`

## PHP

 ``

## Javascript

 ``

Output

`Minimum difference is 1`

Time Complexity: O(N2).
Auxiliary Space: O(1)

## Find the minimum difference between any two elements using sorting:

The idea is to use sorting and compare every adjacent pair of the array

Follow the given steps to solve the problem:

• Sort array in ascending order
• Initialize difference as infinite
• Compare all adjacent pairs in a sorted array and keep track of the minimum difference

Below is the implementation of the above approach:

## C++

 `// C++ program to find minimum difference between` `// any pair in an unsorted array` `#include ` `using` `namespace` `std;`   `// Returns minimum difference between any pair` `int` `findMinDiff(``int` `arr[], ``int` `n)` `{` `    ``// Sort array in non-decreasing order` `    ``sort(arr, arr + n);`   `    ``// Initialize difference as infinite` `    ``int` `diff = INT_MAX;`   `    ``// Find the min diff by comparing adjacent` `    ``// pairs in sorted array` `    ``for` `(``int` `i = 0; i < n - 1; i++)` `        ``if` `(arr[i + 1] - arr[i] < diff)` `            ``diff = arr[i + 1] - arr[i];`   `    ``// Return min diff` `    ``return` `diff;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 5, 3, 19, 18, 25 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``// Function call` `    ``cout << ``"Minimum difference is "` `<< findMinDiff(arr, n);` `    ``return` `0;` `}`

## Java

 `// Java program to find minimum difference between` `// any pair in an unsorted array`   `import` `java.util.Arrays;`   `class` `GFG {` `    ``// Returns minimum difference between any pair` `    ``static` `int` `findMinDiff(``int``[] arr, ``int` `n)` `    ``{` `        ``// Sort array in non-decreasing order` `        ``Arrays.sort(arr);`   `        ``// Initialize difference as infinite` `        ``int` `diff = Integer.MAX_VALUE;`   `        ``// Find the min diff by comparing adjacent` `        ``// pairs in sorted array` `        ``for` `(``int` `i = ``0``; i < n - ``1``; i++)` `            ``if` `(arr[i + ``1``] - arr[i] < diff)` `                ``diff = arr[i + ``1``] - arr[i];`   `        ``// Return min diff` `        ``return` `diff;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = ``new` `int``[] { ``1``, ``5``, ``3``, ``19``, ``18``, ``25` `};`   `        ``// Function call` `        ``System.out.println(``"Minimum difference is "` `                           ``+ findMinDiff(arr, arr.length));` `    ``}` `}`

## Python3

 `# Python3 program to find minimum difference between` `# any pair in an unsorted array`   `# Returns minimum difference between any pair`     `def` `findMinDiff(arr, n):`   `    ``# Sort array in non-decreasing order` `    ``arr ``=` `sorted``(arr)`   `    ``# Initialize difference as infinite` `    ``diff ``=` `10``*``*``20`   `    ``# Find the min diff by comparing adjacent` `    ``# pairs in sorted array` `    ``for` `i ``in` `range``(n``-``1``):` `        ``if` `arr[i``+``1``] ``-` `arr[i] < diff:` `            ``diff ``=` `arr[i``+``1``] ``-` `arr[i]`   `    ``# Return min diff` `    ``return` `diff`     `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``1``, ``5``, ``3``, ``19``, ``18``, ``25``]` `    ``n ``=` `len``(arr)`   `    ``# Function call` `    ``print``(``"Minimum difference is "` `+` `str``(findMinDiff(arr, n)))`   `# This code is contributed by Pratik Chhajer`

## C#

 `// C# program to find minimum` `// difference between any pair` `// in an unsorted array` `using` `System;`   `class` `GFG {` `    ``// Returns minimum difference` `    ``// between any pair` `    ``static` `int` `findMinDiff(``int``[] arr, ``int` `n)` `    ``{` `        ``// Sort array in` `        ``// non-decreasing order` `        ``Array.Sort(arr);`   `        ``// Initialize difference` `        ``// as infinite` `        ``int` `diff = ``int``.MaxValue;`   `        ``// Find the min diff by` `        ``// comparing adjacent pairs` `        ``// in sorted array` `        ``for` `(``int` `i = 0; i < n - 1; i++)` `            ``if` `(arr[i + 1] - arr[i] < diff)` `                ``diff = arr[i + 1] - arr[i];`   `        ``// Return min diff` `        ``return` `diff;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] arr = ``new` `int``[] { 1, 5, 3, 19, 18, 25 };`   `        ``// Function call` `        ``Console.WriteLine(``"Minimum difference is "` `                          ``+ findMinDiff(arr, arr.Length));` `    ``}` `}`   `// This code is contributed by anuj_67.`

## PHP

 ``

## Javascript

 ``

Output

`Minimum difference is 1`

Time Complexity: O(N log N)
Auxiliary Space: O(1)

## Find the minimum difference between any two elements using Merge Sort:

The merge Helper function always compares two elements between each other. We can do this in O(nlogn) time instead of sorting and then again traversing the sorted array.

• Take a variable minDiff and store the minimum difference and compare with each recursive stack of the merge helper function.

## C++

 `// C++ code` `#include ` `using` `namespace` `std;`   `class` `Solution {`   `public``:` `    ``// Function to find minimum difference between any pair` `    ``// of elements in an array.` `    ``int` `MinimumDifference(``int` `arr[], ``int` `n)` `    ``{` `        ``if` `(n < 2)` `            ``return` `INT_MAX;` `        ``int` `mid = n / 2;` `        ``int` `left[mid];` `        ``int` `right[n - mid];`   `        ``for` `(``int` `i = 0; i < mid; i++) {` `            ``left[i] = arr[i];` `        ``}`   `        ``for` `(``int` `i = mid; i < n; i++) {` `            ``right[i - mid] = arr[i];` `        ``}`   `        ``int` `ls = MinimumDifference(left, mid);` `        ``int` `rs = MinimumDifference(right, n - mid);` `        ``int` `mg` `            ``= mergeHelper(left, right, arr, mid, n - mid);`   `        ``return` `min(mg, min(ls, rs));` `    ``}`   `private``:` `    ``int` `mergeHelper(``int` `left[], ``int` `right[], ``int` `arr[],` `                    ``int` `n1, ``int` `n2)` `    ``{` `        ``int` `i = 0;` `        ``int` `j = 0;` `        ``int` `k = 0;` `        ``int` `minDiff = INT_MAX;`   `        ``while` `(i < n1 && j < n2) {` `            ``if` `(left[i] <= right[j]) {` `                ``minDiff = min(minDiff, right[j] - left[i]);` `                ``arr[k] = left[i];` `                ``i++;` `            ``}` `            ``else` `{` `                ``minDiff = min(minDiff, left[i] - right[j]);` `                ``arr[k] = right[j];` `                ``j++;` `            ``}` `            ``k++;` `        ``}`   `        ``while` `(i < n1) {` `            ``arr[k] = left[i];` `            ``i++;` `            ``k++;` `        ``}` `        ``while` `(j < n2) {` `            ``arr[k] = right[j];` `            ``j++;` `            ``k++;` `        ``}`   `        ``return` `minDiff;` `    ``}` `};`   `int` `main()` `{`   `    ``// Code` `    ``int` `arr[] = { 1, 5, 3, 19, 18, 25 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``// Function call` `    ``Solution sln;` `    ``int` `minDiff = sln.MinimumDifference(arr, n);` `    ``cout << ``"Minimum difference is "` `<< minDiff << endl;` `    ``return` `0;` `}`   `// This code is contributed by Aman Kumar`

## Java

 `// Java Code` `import` `java.io.*;`   `public` `class` `GFG {`   `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``// Code` `        ``int``[] arr = ``new` `int``[] { ``1``, ``5``, ``3``, ``19``, ``18``, ``25` `};`   `        ``// Function call` `        ``var sln = ``new` `Solution();` `        ``var minDiff` `            ``= sln.MinimumDifference(arr, arr.length);` `        ``System.out.println(``"Minimum difference is "` `                           ``+ minDiff);` `    ``}` `}` `class` `Solution {` `    ``// Function to find minimum difference between any pair` `    ``// of elements in an array.` `    ``public` `int` `MinimumDifference(``int``[] arr, ``int` `n)` `    ``{` `        ``// code here` `        ``if` `(arr.length < ``2``)` `            ``return` `Integer.MAX_VALUE;` `        ``int` `mid = arr.length / ``2``;` `        ``int``[] left = ``new` `int``[mid];` `        ``int``[] right = ``new` `int``[arr.length - mid];` `        ``int` `i = ``0``;` `        ``while` `(i < mid) {` `            ``left[i] = arr[i];` `            ``i += ``1``;` `        ``}` `        ``while` `(i < arr.length) {` `            ``right[i - mid] = arr[i];` `            ``i += ``1``;` `        ``}` `        ``var ls = MinimumDifference(left, left.length);` `        ``var rs = MinimumDifference(right, right.length);` `        ``var mg = mergeHelper(left, right, arr);` `        ``return` `Math.min(mg, Math.min(ls, rs));` `    ``}` `    ``private` `int` `mergeHelper(``int``[] left, ``int``[] right,` `                            ``int``[] arr)` `    ``{` `        ``int` `i = ``0``;` `        ``int` `j = ``0``;` `        ``int` `k = ``0``;` `        ``int` `minDiff = Integer.MAX_VALUE;` `        ``while` `(i < left.length && j < right.length) {` `            ``if` `(left[i] <= right[j]) {` `                ``minDiff` `                    ``= Math.min(minDiff, right[j] - left[i]);` `                ``arr[k] = left[i];` `                ``i += ``1``;` `            ``}` `            ``else` `{` `                ``minDiff` `                    ``= Math.min(minDiff, left[i] - right[j]);` `                ``arr[k] = right[j];` `                ``j += ``1``;` `            ``}` `            ``k += ``1``;` `        ``}` `        ``while` `(i < left.length) {` `            ``arr[k] = left[i];` `            ``i += ``1``;` `            ``k += ``1``;` `        ``}` `        ``while` `(j < right.length) {` `            ``arr[k] = right[j];` `            ``j += ``1``;` `            ``k += ``1``;` `        ``}` `        ``return` `minDiff;` `    ``}` `}`   `// This code is contributed by Pushpesh Raj.`

## Python3

 `# Python Code` `class` `Solution:` `        ``# Function to find minimum difference between any pair` `    ``# of elements in an array.` `    ``def` `MinimumDifference(``self``, arr, n):` `        ``if` `n < ``2``:` `            ``return` `float``(``'inf'``)` `        ``mid ``=` `n ``/``/` `2` `        ``left ``=` `arr[:mid]` `        ``right ``=` `arr[mid:]`   `        ``ls ``=` `self``.MinimumDifference(left, ``len``(left))` `        ``rs ``=` `self``.MinimumDifference(right, ``len``(right))` `        ``mg ``=` `self``.mergeHelper(left, right, arr, ``len``(left), ``len``(right))`   `        ``return` `min``(mg, ``min``(ls, rs))`   `    ``def` `mergeHelper(``self``, left, right, arr, n1, n2):` `        ``i, j, k ``=` `0``, ``0``, ``0` `        ``minDiff ``=` `float``(``'inf'``)`   `        ``while` `i < n1 ``and` `j < n2:` `            ``if` `left[i] <``=` `right[j]:` `                ``minDiff ``=` `min``(minDiff, right[j] ``-` `left[i])` `                ``arr[k] ``=` `left[i]` `                ``i ``+``=` `1` `            ``else``:` `                ``minDiff ``=` `min``(minDiff, left[i] ``-` `right[j])` `                ``arr[k] ``=` `right[j]` `                ``j ``+``=` `1` `            ``k ``+``=` `1`   `        ``while` `i < n1:` `            ``arr[k] ``=` `left[i]` `            ``i ``+``=` `1` `            ``k ``+``=` `1` `        ``while` `j < n2:` `            ``arr[k] ``=` `right[j]` `            ``j ``+``=` `1` `            ``k ``+``=` `1`   `        ``return` `minDiff`     `# Driver Code` `arr ``=` `[``1``, ``5``, ``3``, ``19``, ``18``, ``25``]` `n ``=` `len``(arr)` `sln ``=` `Solution()`   `# Function call` `minDiff ``=` `sln.MinimumDifference(arr, n)` `print``(``"Minimum difference is"``, minDiff)`   `# This code is contributed by Prasad Kandekar(prasad264)`

## C#

 `using` `System;`   `public` `class` `GFG {`   `    ``static` `public` `void` `Main()` `    ``{`   `        ``// Code` `        ``int``[] arr = ``new` `int``[] { 1, 5, 3, 19, 18, 25 };`   `        ``// Function call` `        ``var` `sln = ``new` `Solution();` `        ``var` `minDiff` `            ``= sln.MinimumDifference(arr, arr.Length);` `        ``Console.WriteLine(``"Minimum difference is "` `                          ``+ minDiff);` `    ``}` `}` `class` `Solution {` `    ``// Function to find minimum difference between any pair` `    ``// of elements in an array.` `    ``public` `int` `MinimumDifference(``int``[] arr, ``int` `n)` `    ``{` `        ``// code here` `        ``if` `(arr.Length < 2)` `            ``return` `int``.MaxValue;` `        ``int` `mid = arr.Length / 2;` `        ``int``[] left = ``new` `int``[mid];` `        ``int``[] right = ``new` `int``[arr.Length - mid];` `        ``int` `i = 0;` `        ``while` `(i < mid) {` `            ``left[i] = arr[i];` `            ``i += 1;` `        ``}` `        ``while` `(i < arr.Length) {` `            ``right[i - mid] = arr[i];` `            ``i += 1;` `        ``}` `        ``var` `ls = MinimumDifference(left, left.Length);` `        ``var` `rs = MinimumDifference(right, right.Length);` `        ``var` `mg = mergeHelper(left, right, arr);` `        ``return` `Math.Min(mg, Math.Min(ls, rs));` `    ``}` `    ``private` `int` `mergeHelper(``int``[] left, ``int``[] right,` `                            ``int``[] arr)` `    ``{` `        ``int` `i = 0;` `        ``int` `j = 0;` `        ``int` `k = 0;` `        ``int` `minDiff = ``int``.MaxValue;` `        ``while` `(i < left.Length && j < right.Length) {` `            ``if` `(left[i] <= right[j]) {` `                ``minDiff` `                    ``= Math.Min(minDiff, right[j] - left[i]);` `                ``arr[k] = left[i];` `                ``i += 1;` `            ``}` `            ``else` `{` `                ``minDiff` `                    ``= Math.Min(minDiff, left[i] - right[j]);` `                ``arr[k] = right[j];` `                ``j += 1;` `            ``}` `            ``k += 1;` `        ``}` `        ``while` `(i < left.Length) {` `            ``arr[k] = left[i];` `            ``i += 1;` `            ``k += 1;` `        ``}` `        ``while` `(j < right.Length) {` `            ``arr[k] = right[j];` `            ``j += 1;` `            ``k += 1;` `        ``}` `        ``return` `minDiff;` `    ``}` `}`

## Javascript

 `// JavaScript code` `class Solution {` `    ``// Function to find minimum difference between any pair` `    ``// of elements in an array.` `    ``MinimumDifference(arr, n) {` `        ``if` `(n < 2)` `              ``return` `Number.MAX_SAFE_INTEGER;` `        ``var` `mid = Math.floor(n / 2);` `        ``var` `left = arr.slice(0, mid);` `        ``var` `right = arr.slice(mid);`   `        ``var` `ls = ``this``.MinimumDifference(left, mid);` `        ``var` `rs = ``this``.MinimumDifference(right, n - mid);` `        ``var` `mg = ``this``.mergeHelper(left, right, arr, mid, n - mid);`   `        ``return` `Math.min(mg, Math.min(ls, rs));` `      ``}`   `    ``// Helper function for merge sort` `    ``mergeHelper(left, right, arr, n1, n2) {` `          ``var` `i = 0;` `          ``var` `j = 0;` `          ``var` `k = 0;` `          ``var` `minDiff = Number.MAX_SAFE_INTEGER;`   `        ``while` `(i < n1 && j < n2) {` `              ``if` `(left[i] <= right[j]) {` `                ``minDiff = Math.min(minDiff, right[j] - left[i]);` `                ``arr[k] = left[i];` `                ``i++;` `              ``}` `            ``else` `{` `                ``minDiff = Math.min(minDiff, left[i] - right[j]);` `                ``arr[k] = right[j];` `                ``j++;` `              ``}` `              ``k++;` `        ``}`   `        ``while` `(i < n1) {` `              ``arr[k] = left[i];` `              ``i++;` `              ``k++;` `        ``}` `        ``while` `(j < n2) {` `              ``arr[k] = right[j];` `              ``j++;` `              ``k++;` `        ``}` `        `  `        ``return` `minDiff;` `      ``}` `}`   `// Code` `var` `arr = [1, 5, 3, 19, 18, 25];` `var` `n = arr.length;`   `// Function call` `var` `sln = ``new` `Solution();` `var` `minDiff = sln.MinimumDifference(arr, n);` `console.log(``"Minimum difference is "` `+ minDiff);`   `// This code is contributed by Prasad Kandekar(prasad264)`

Output

`Minimum difference is 1`

Time Complexity: O(N * log N)  Merge sort algorithm uses (n * log n) complexity.
Auxiliary Space: O(N) In merge sort algorithm all elements are copied into an auxiliary array.