Leftmost and rightmost indices of the maximum and the minimum element of an array
Given an array arr[], the task is to find the leftmost and the rightmost indices of the minimum and the maximum element from the array where arr[] consists of non-distinct elements.
Examples:
Input: arr[] = {2, 1, 1, 2, 1, 5, 6, 5}
Output: Minimum left : 1
Minimum right : 4
Maximum left : 6
Maximum right : 6
Minimum element is 1 which is present at indices 1, 2 and 4.
Maximum element is 6 which is present only at index 6.
Input: arr[] = {0, 1, 0, 2, 7, 5, 6, 7}
Output: Minimum left : 0
Minimum right : 2
Maximum left : 4
Maximum right : 7
Method 1: When the array is unsorted.
- Initialize the variable leftMin = rightMin = leftMax = rightMax = arr[0] and min = max = arr[0].
- Start traversing the array from 1 to n – 1.
- If arr[i] < min then a new minimum is found. Update leftMin = rightMin = i.
- Else arr[i] = min then another copy of the current minimum is found. Update the rightMin = i.
- If arr[i] > max then a new maximum is found. Update leftMax = rightMax = i.
- Else arr[i] = max then another copy of the current maximum is found. Update the rightMax = i.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
void findIndices( int arr[], int n)
{
int leftMin = 0, rightMin = 0;
int leftMax = 0, rightMax = 0;
int min = arr[0], max = arr[0];
for ( int i = 1; i < n; i++) {
if (arr[i] < min) {
leftMin = rightMin = i;
min = arr[i];
}
else if (arr[i] == min)
rightMin = i;
if (arr[i] > max) {
leftMax = rightMax = i;
max = arr[i];
}
else if (arr[i] == max)
rightMax = i;
}
cout << "Minimum left : " << leftMin << "\n" ;
cout << "Minimum right : " << rightMin << "\n" ;
cout << "Maximum left : " << leftMax << "\n" ;
cout << "Maximum right : " << rightMax << "\n" ;
}
int main()
{
int arr[] = { 2, 1, 1, 2, 1, 5, 6, 5 };
int n = sizeof (arr)/ sizeof (arr[0]);
findIndices(arr, n);
}
|
Java
public class GFG {
public static void findIndices( int arr[], int n)
{
int leftMin = 0 , rightMin = 0 ;
int leftMax = 0 , rightMax = 0 ;
int min = arr[ 0 ], max = arr[ 0 ];
for ( int i = 1 ; i < n; i++) {
if (arr[i] < min) {
leftMin = rightMin = i;
min = arr[i];
}
else if (arr[i] == min)
rightMin = i;
if (arr[i] > max) {
leftMax = rightMax = i;
max = arr[i];
}
else if (arr[i] == max)
rightMax = i;
}
System.out.println( "Minimum left : " + leftMin);
System.out.println( "Minimum right : " + rightMin);
System.out.println( "Maximum left : " + leftMax);
System.out.println( "Maximum right : " + rightMax);
}
public static void main(String[] args)
{
int arr[] = { 2 , 1 , 1 , 2 , 1 , 5 , 6 , 5 };
int n = arr.length;
findIndices(arr, n);
}
}
|
Python3
def findIndices(arr, n) :
leftMin, rightMin = 0 , 0
leftMax, rightMax = 0 , 0
min_element = arr[ 0 ]
max_element = arr[ 0 ]
for i in range (n) :
if (arr[i] < min_element) :
leftMin = rightMin = i
min_element = arr[i]
elif (arr[i] = = min_element) :
rightMin = i
if (arr[i] > max_element) :
leftMax = rightMax = i
max_element = arr[i]
elif (arr[i] = = max_element) :
rightMax = i
print ( "Minimum left : " , leftMin)
print ( "Minimum right : " , rightMin)
print ( "Maximum left : " , leftMax )
print ( "Maximum right : " , rightMax)
if __name__ = = "__main__" :
arr = [ 2 , 1 , 1 , 2 , 1 , 5 , 6 , 5 ]
n = len (arr)
findIndices(arr, n)
|
C#
using System;
class GFG {
static void findIndices( int []arr, int n)
{
int leftMin = 0, rightMin = 0;
int leftMax = 0, rightMax = 0;
int min = arr[0], max = arr[0];
for ( int i = 1; i < n; i++) {
if (arr[i] < min) {
leftMin = rightMin = i;
min = arr[i];
}
else if (arr[i] == min)
rightMin = i;
if (arr[i] > max) {
leftMax = rightMax = i;
max = arr[i];
}
else if (arr[i] == max)
rightMax = i;
}
Console.WriteLine( "Minimum left : " + leftMin);
Console.WriteLine( "Minimum right : " + rightMin);
Console.WriteLine( "Maximum left : " + leftMax);
Console.WriteLine( "Maximum right : " + rightMax);
}
public static void Main()
{
int []arr = { 2, 1, 1, 2, 1, 5, 6, 5 };
int n = arr.Length;
findIndices(arr, n);
}
}
|
PHP
<?php
function findIndices( $arr , $n )
{
$leftMin = 0;
$rightMin = 0;
$leftMax = 0;
$rightMax = 0;
$min = $arr [0];
$max = $arr [0];
for ( $i = 1; $i < $n ; $i ++)
{
if ( $arr [ $i ] < $min )
{
$leftMin = $rightMin = $i ;
$min = $arr [ $i ];
}
else if ( $arr [ $i ] == $min )
$rightMin = $i ;
if ( $arr [ $i ] > $max )
{
$leftMax = $rightMax = $i ;
$max = $arr [ $i ];
}
else if ( $arr [ $i ] == $max )
$rightMax = $i ;
}
echo "Minimum left : " , $leftMin , "\n" ;
echo "Minimum right : " , $rightMin , "\n" ;
echo "Maximum left : " , $leftMax , "\n" ;
echo "Maximum right : " , $rightMax , "\n" ;
}
$arr = array ( 2, 1, 1, 2, 1, 5, 6, 5 );
$n = sizeof( $arr );
findIndices( $arr , $n );
?>
|
Javascript
<script>
function findIndices(arr,n)
{
let leftMin = 0, rightMin = 0;
let leftMax = 0, rightMax = 0;
let min = arr[0], max = arr[0];
for (let i = 1; i < n; i++) {
if (arr[i] < min) {
leftMin = rightMin = i;
min = arr[i];
}
else if (arr[i] == min)
rightMin = i;
if (arr[i] > max) {
leftMax = rightMax = i;
max = arr[i];
}
else if (arr[i] == max)
rightMax = i;
}
document.write( "Minimum left : " + leftMin+ "<br>" );
document.write( "Minimum right : " + rightMin+ "<br>" );
document.write( "Maximum left : " + leftMax+ "<br>" );
document.write( "Maximum right : " + rightMax+ "<br>" );
}
let arr=[2, 1, 1, 2, 1, 5, 6, 5 ];
let n = arr.length;
findIndices(arr, n);
</script>
|
Output:
Minimum left : 1
Minimum right : 4
Maximum left : 6
Maximum right : 6
Time Complexity: O(n)
Auxiliary Space: O(1)
Method 2: When the array is sorted.
- When the array is sorted then leftMin = 0 and rightMax = n – 1.
- In order to find the rightMin, apply a modified binary search:
- Set i = 1.
- While arr[i] = min update rightMin = i and i = i * 2.
- Finally do a linear search for the rest of the elements from rightMin + 1 to n – 1 while arr[i] = min.
- Return rightMin in the end.
- Similarly, for leftMax repeat the above steps but in reverse i.e. from n – 1 and update i = i / 2 after every iteration.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
int getRightMin( int arr[], int n)
{
int min = arr[0];
int rightMin = 0;
int i = 1;
while (i < n) {
if (arr[i] == min)
rightMin = i;
i *= 2;
}
i = rightMin + 1;
while (i < n && arr[i] == min) {
rightMin = i;
i++;
}
return rightMin;
}
int getLeftMax( int arr[], int n)
{
int max = arr[n - 1];
int leftMax = n - 1;
int i = n - 2;
while (i > 0) {
if (arr[i] == max)
leftMax = i;
i /= 2;
}
i = leftMax - 1;
while (i >= 0 && arr[i] == max) {
leftMax = i;
i--;
}
return leftMax;
}
int main()
{
int arr[] = { 0, 0, 1, 2, 5, 5, 6, 8, 8 };
int n = sizeof (arr)/ sizeof (arr[0]);
cout << "Minimum left : " << 0 << "\n" ;
cout << "Minimum right : " << getRightMin(arr, n) << "\n" ;
cout << "Maximum left : " << getLeftMax(arr, n) << "\n" ;
cout << "Maximum right : " << (n - 1);
}
|
Java
public class GFG {
public static int getRightMin( int arr[], int n)
{
int min = arr[ 0 ];
int rightMin = 0 ;
int i = 1 ;
while (i < n) {
if (arr[i] == min)
rightMin = i;
i *= 2 ;
}
i = rightMin + 1 ;
while (i < n && arr[i] == min) {
rightMin = i;
i++;
}
return rightMin;
}
public static int getLeftMax( int arr[], int n)
{
int max = arr[n - 1 ];
int leftMax = n - 1 ;
int i = n - 2 ;
while (i > 0 ) {
if (arr[i] == max)
leftMax = i;
i /= 2 ;
}
i = leftMax - 1 ;
while (i >= 0 && arr[i] == max) {
leftMax = i;
i--;
}
return leftMax;
}
public static void main(String[] args)
{
int arr[] = { 0 , 0 , 1 , 2 , 5 , 5 , 6 , 8 , 8 };
int n = arr.length;
System.out.println( "Minimum left : " + 0 );
System.out.println( "Minimum right : " + getRightMin(arr, n));
System.out.println( "Maximum left : " + getLeftMax(arr, n));
System.out.println( "Maximum right : " + (n - 1 ));
}
}
|
Python3
def getRightMin(arr, n):
min = arr[ 0 ]
rightMin = 0
i = 1
while (i < n):
if (arr[i] = = min ):
rightMin = i
i * = 2
i = rightMin + 1
while (i < n and arr[i] = = min ):
rightMin = i
i + = 1
return rightMin
def getLeftMax(arr, n):
max = arr[n - 1 ]
leftMax = n - 1
i = n - 2
while (i > 0 ):
if (arr[i] = = max ):
leftMax = i
i = int (i / 2 )
i = leftMax - 1
while (i > = 0 and arr[i] = = max ):
leftMax = i
i - = 1
return leftMax
if __name__ = = '__main__' :
arr = [ 0 , 0 , 1 , 2 , 5 , 5 , 6 , 8 , 8 ]
n = len (arr)
print ( "Minimum left :" , 0 )
print ( "Minimum right :" , getRightMin(arr, n))
print ( "Maximum left :" , getLeftMax(arr, n))
print ( "Maximum right :" , (n - 1 ))
|
C#
using System;
public class GFG {
public static int getRightMin( int []arr, int n)
{
int min = arr[0];
int rightMin = 0;
int i = 1;
while (i < n) {
if (arr[i] == min)
rightMin = i;
i *= 2;
}
i = rightMin + 1;
while (i < n && arr[i] == min) {
rightMin = i;
i++;
}
return rightMin;
}
public static int getLeftMax( int []arr, int n)
{
int max = arr[n - 1];
int leftMax = n - 1;
int i = n - 2;
while (i > 0) {
if (arr[i] == max)
leftMax = i;
i /= 2;
}
i = leftMax - 1;
while (i >= 0 && arr[i] == max) {
leftMax = i;
i--;
}
return leftMax;
}
public static void Main()
{
int []arr = { 0, 0, 1, 2, 5, 5, 6, 8, 8 };
int n = arr.Length;
Console.WriteLine( "Minimum left : " + 0);
Console.WriteLine( "Minimum right : " + getRightMin(arr, n));
Console.WriteLine( "Maximum left : " + getLeftMax(arr, n));
Console.WriteLine( "Maximum right : " + (n - 1));
}
}
|
PHP
<?php
function getRightMin( $arr , $n )
{
$min = $arr [0];
$rightMin = 0;
$i = 1;
while ( $i < $n )
{
if ( $arr [ $i ] == $min )
$rightMin = $i ;
$i *= 2;
}
$i = $rightMin + 1;
while ( $i < $n && $arr [ $i ] == $min )
{
$rightMin = $i ;
$i ++;
}
return $rightMin ;
}
function getLeftMax( $arr , $n )
{
$max = $arr [ $n - 1];
$leftMax = $n - 1;
$i = $n - 2;
while ( $i > 0)
{
if ( $arr [ $i ] == $max )
$leftMax = $i ;
$i /= 2;
}
$i = $leftMax - 1;
while ( $i >= 0 && $arr [ $i ] == $max )
{
$leftMax = $i ;
$i --;
}
return $leftMax ;
}
$arr = array (0, 0, 1, 2, 5,
5, 6, 8, 8 );
$n = sizeof( $arr );
echo "Minimum left : " , 0, "\n" ;
echo "Minimum right : " ,
getRightMin( $arr , $n ), "\n" ;
echo "Maximum left : " ,
getLeftMax( $arr , $n ), "\n" ;
echo "Maximum right : " , ( $n - 1), "\n" ;
?>
|
Javascript
<script>
function getRightMin(arr, n)
{
let min = arr[0];
let rightMin = 0;
let i = 1;
while (i < n) {
if (arr[i] == min)
rightMin = i;
i *= 2;
}
i = rightMin + 1;
while (i < n && arr[i] == min) {
rightMin = i;
i++;
}
return rightMin;
}
function getLeftMax(arr, n)
{
let max = arr[n - 1];
let leftMax = n - 1;
let i = n - 2;
while (i > 0) {
if (arr[i] == max)
leftMax = i;
i = parseInt(i / 2, 10);
}
i = leftMax - 1;
while (i >= 0 && arr[i] == max) {
leftMax = i;
i--;
}
return leftMax;
}
let arr = [ 0, 0, 1, 2, 5, 5, 6, 8, 8 ];
let n = arr.length;
document.write( "Minimum left : " + 0 + "</br>" );
document.write( "Minimum right : " + getRightMin(arr, n) + "</br>" );
document.write( "Maximum left : " + getLeftMax(arr, n) + "</br>" );
document.write( "Maximum right : " + (n - 1));
</script>
|
Output:
Minimum left : 0
Minimum right : 1
Maximum left : 7
Maximum right : 8
Time Complexity: O(n) As linear search is applied for a set of elements so the worst case time complexity will be O(n).
Auxiliary Space: O(1)
Last Updated :
23 Jun, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...