# Minimum distance between the maximum and minimum element of a given Array

• Difficulty Level : Medium
• Last Updated : 14 Jan, 2022

Given an array A[] consisting of N elements, the task is to find the minimum distance between the minimum and the maximum element of the array.
Examples:

Input: arr[] = {3, 2, 1, 2, 1, 4, 5, 8, 6, 7, 8, 2}
Output:
Explanation:
The minimum element(= 1) is present at indices {2, 4}
The maximum element(= 8) is present at indices {7, 10}.
The minimum distance between an occurrence of 1 and 8 is 7 – 4 = 3
Input: arr[] = {1, 3, 69}
Output:
Explanation:
The minimum element(= 1) is present at index 0.
The maximum element(= 69) is present at index 2.
Therefore, the minimum distance between them is 2.

Naive Approach:
The simplest approach to solve this problem is as follows:

• Find the minimum and maximum elements of the array.
• Traverse the array and for every occurrence of the maximum element, calculate its distance from all occurrences of the minimum element in the array and update the minimum distance.
• After complete traversal of the array, print all the minimum distance obtained.

Time Complexity: O(N2
Auxiliary Space: O(1)
Efficient Approach:
Follow the steps below to optimize the above approach:

• Traverse the array to find the minimum and maximum elements.
• Initialize two variables min_index and max_index to store the indices of the minimum and maximum elements of the array respectively. Initialize them with -1.
• Traverse the array. If at any instant, both min_index and max_index is not equal to -1, i.e. both of them have stored a valid index, calculate there a difference.
• Compare this difference with the minimum distance(say, min_dist) and update min_dist accordingly.
• Finally, print the final value of min_dist obtained after the complete traversal of the array.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement the``// above approach``#include ``using` `namespace` `std;` `// Function to find the minimum``// distance between the minimum``// and the maximum element``int` `minDistance(``int` `a[], ``int` `n)``{``    ``// Stores the minimum and maximum``    ``// array element``    ``int` `maximum = -1, minimum = INT_MAX;` `    ``// Stores the most recently traversed``    ``// indices of the minimum and the``    ``// maximum element``    ``int` `min_index = -1, max_index = -1;` `    ``// Stores the minimum distance``    ``// between the minimum and the``    ``// maximum``    ``int` `min_dist = n + 1;` `    ``// Find the maximum and``    ``// the minimum element``    ``// from the given array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(a[i] > maximum)``            ``maximum = a[i];` `        ``if` `(a[i] < minimum)``            ``minimum = a[i];``    ``}` `    ``// Find the minimum distance``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Check if current element``        ``// is equal to minimum``        ``if` `(a[i] == minimum)``            ``min_index = i;` `        ``// Check if current element``        ``// is equal to maximum``        ``if` `(a[i] == maximum)``            ``max_index = i;` `        ``// If both the minimum and the``        ``// maximum element has``        ``// occurred at least once``        ``if` `(min_index != -1``            ``&& max_index != -1)` `            ``// Update the minimum distance``            ``min_dist``                ``= min(min_dist,``                      ``abs``(min_index``                          ``- max_index));``    ``}` `    ``// Return the answer``    ``return` `min_dist;``}` `// Driver Code``int` `main()``{``    ``int` `a[] = { 3, 2, 1, 2, 1, 4,``                ``5, 8, 6, 7, 8, 2 };``    ``int` `n = ``sizeof` `a / ``sizeof` `a[0];``    ``cout << minDistance(a, n);``}`

## Java

 `// Java Program to implement``// the above approach``import` `java.util.*;``class` `GFG {` `    ``// Function to find the minimum``    ``// distance between the minimum``    ``// and the maximum element``    ``public` `static` `int` `minDistance(``int` `a[], ``int` `n)``    ``{` `        ``// Stores the minimum and maximum``        ``// array element``        ``int` `max = -``1``, min = Integer.MAX_VALUE;` `        ``// Stores the most recently traversed``        ``// indices of the minimum and the``        ``// maximum element``        ``int` `min_index = -``1``, max_index = -``1``;` `        ``// Stores the minimum distance``        ``// between the minimum and the``        ``// maximum``        ``int` `min_dist = n + ``1``;` `        ``// Find the maximum and``        ``// the minimum element``        ``// from the given array``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``if` `(a[i] > max)``                ``max = a[i];``            ``if` `(a[i] < min)``                ``min = a[i];``        ``}` `        ``// Find the minimum distance``        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// Check if current element``            ``// is equal to minimum``            ``if` `(a[i] == min)``                ``min_index = i;` `            ``// Check if current element``            ``// is equal to maximum``            ``if` `(a[i] == max)``                ``max_index = i;` `            ``// If both the minimum and the``            ``// maximum element has``            ``// occurred at least once``            ``if` `(min_index != -``1``                ``&& max_index != -``1``)``                ``min_dist``                    ``= Math.min(min_dist,``                               ``Math.abs(min_index``                                        ``- max_index));``        ``}``        ``return` `min_dist;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``12``;``        ``int` `a[] = { ``3``, ``2``, ``1``, ``2``, ``1``, ``4``,``                    ``5``, ``8``, ``6``, ``7``, ``8``, ``2` `};``        ``System.out.println(minDistance(a, n));``    ``}``}`

## Python3

 `# Python3 Program to implement the``# above approach``import` `sys` `# Function to find the minimum``# distance between the minimum``# and the maximum element``def` `minDistance(a, n):` `    ``# Stores the minimum and maximum``    ``# array element``    ``maximum ``=` `-``1``    ``minimum ``=` `sys.maxsize`` ` `    ``# Stores the most recently traversed``    ``# indices of the minimum and the``    ``# maximum element``    ``min_index ``=` `-``1``    ``max_index ``=` `-``1`` ` `    ``# Stores the minimum distance``    ``# between the minimum and the``    ``# maximum``    ``min_dist ``=` `n ``+` `1`` ` `    ``# Find the maximum and``    ``# the minimum element``    ``# from the given array``    ``for` `i ``in` `range` `(n):``        ``if` `(a[i] > maximum):``            ``maximum ``=` `a[i]` `        ``if` `(a[i] < minimum):``            ``minimum ``=` `a[i]`` ` `    ``# Find the minimum distance``    ``for` `i ``in` `range` `(n):`` ` `        ``# Check if current element``        ``# is equal to minimum``        ``if` `(a[i] ``=``=` `minimum):``            ``min_index ``=` `i`` ` `        ``# Check if current element``        ``# is equal to maximum``        ``if` `(a[i] ``=``=` `maximum):``            ``max_index ``=` `i`` ` `        ``# If both the minimum and the``        ``# maximum element has``        ``# occurred at least once``        ``if` `(min_index !``=` `-``1` `and``            ``max_index !``=` `-``1``):`` ` `            ``# Update the minimum distance``            ``min_dist ``=` `(``min``(min_dist,``                        ``abs``(min_index ``-``                            ``max_index)))`` ` `    ``# Return the answer``    ``return` `min_dist`` ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``a ``=` `[``3``, ``2``, ``1``, ``2``, ``1``, ``4``,``         ``5``, ``8``, ``6``, ``7``, ``8``, ``2``]``    ``n ``=` `len``(a)``    ``print` `(minDistance(a, n))` `# This code is contributed by Chitranayal`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{``    ` `// Function to find the minimum``// distance between the minimum``// and the maximum element``static` `int` `minDistance(``int` `[]a, ``int` `n)``{``    ` `    ``// Stores the minimum and maximum``    ``// array element``    ``int` `max = -1, min = Int32.MaxValue;` `    ``// Stores the most recently traversed``    ``// indices of the minimum and the``    ``// maximum element``    ``int` `min_index = -1, max_index = -1;` `    ``// Stores the minimum distance``    ``// between the minimum and the``    ``// maximum``    ``int` `min_dist = n + 1;` `    ``// Find the maximum and``    ``// the minimum element``    ``// from the given array``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``if` `(a[i] > max)``            ``max = a[i];``        ``if` `(a[i] < min)``            ``min = a[i];``    ``}` `    ``// Find the minimum distance``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``// Check if current element``        ``// is equal to minimum``        ``if` `(a[i] == min)``            ``min_index = i;` `        ``// Check if current element``        ``// is equal to maximum``        ``if` `(a[i] == max)``            ``max_index = i;` `        ``// If both the minimum and the``        ``// maximum element has``        ``// occurred at least once``        ``if` `(min_index != -1 && max_index != -1)``            ``min_dist = Math.Min(min_dist,``                                ``Math.Abs(``                                ``min_index -``                                ``max_index));``    ``}``    ``return` `min_dist;``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `n = 12;``    ``int` `[]a = { 3, 2, 1, 2, 1, 4,``                ``5, 8, 6, 7, 8, 2 };``                ` `    ``Console.WriteLine(minDistance(a, n));``}``}` `// This code is contributed by piyush3010`

## Javascript

 ``

Output:

`3`

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

My Personal Notes arrow_drop_up