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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
  
#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 found new minimum
        if (arr[i] < min) {
            leftMin = rightMin = i;
            min = arr[i];
        }
  
        // If arr[i] = min then rightmost index
        // for min will change
        else if (arr[i] == min)
            rightMin = i;
  
        // If found new maximum
        if (arr[i] > max) {
            leftMax = rightMax = i;
            max = arr[i];
        }
  
        // If arr[i] = max then rightmost index
        // for max will change
        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";
}
  
// Driver code
int main()
{
    int arr[] = { 2, 1, 1, 2, 1, 5, 6, 5 };
    int n = sizeof(arr)/sizeof(arr[0]);
  
    findIndices(arr, n);
}
  
  
// This code is contributed
// by ihritik

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
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 found new minimum
            if (arr[i] < min) {
                leftMin = rightMin = i;
                min = arr[i];
            }
  
            // If arr[i] = min then rightmost index
            // for min will change
            else if (arr[i] == min)
                rightMin = i;
  
            // If found new maximum
            if (arr[i] > max) {
                leftMax = rightMax = i;
                max = arr[i];
            }
  
            // If arr[i] = max then rightmost index
            // for max will change
            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);
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 2, 1, 1, 2, 1, 5, 6, 5 };
        int n = arr.length;
  
        findIndices(arr, n);
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach 
  
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 found new minimum 
        if (arr[i] < min_element) :
            leftMin = rightMin =
            min_element = arr[i]
      
        # If arr[i] = min then rightmost 
        # index for min will change 
        elif (arr[i] == min_element) :
            rightMin =
  
        # If found new maximum 
        if (arr[i] > max_element) : 
            leftMax = rightMax =
            max_element = arr[i]
          
        # If arr[i] = max then rightmost 
        # index for max will change 
        elif (arr[i] == max_element) : 
            rightMax = i
    print("Minimum left : ", leftMin) 
    print("Minimum right : ", rightMin) 
    print("Maximum left : ", leftMax ) 
    print("Maximum right : ", rightMax)
  
# Driver code 
if __name__ == "__main__" :
  
    arr = [ 2, 1, 1, 2, 1, 5, 6, 5
    n = len(arr)
  
    findIndices(arr, n) 
  
# This code is contributed by Ryuga 

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
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 found new minimum
            if (arr[i] < min) {
                leftMin = rightMin = i;
                min = arr[i];
            }
  
            // If arr[i] = min then rightmost index
            // for min will change
            else if (arr[i] == min)
                rightMin = i;
  
            // If found new maximum
            if (arr[i] > max) {
                leftMax = rightMax = i;
                max = arr[i];
            }
  
            // If arr[i] = max then rightmost index
            // for max will change
            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);
    }
  
    // Driver code
    public static void Main()
    {
        int []arr = { 2, 1, 1, 2, 1, 5, 6, 5 };
        int n = arr.Length;
  
        findIndices(arr, n);
    }
}
// This code is contributed 
// By ihritik

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of the approach
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 found new minimum
        if ($arr[$i] < $min)
        {
            $leftMin = $rightMin = $i;
            $min = $arr[$i];
        }
  
        // If arr[i] = min then rightmost 
        // index for min will change
        else if ($arr[$i] == $min)
            $rightMin = $i;
  
        // If found new maximum
        if ($arr[$i] > $max
        {
            $leftMax = $rightMax = $i;
            $max = $arr[$i];
        }
  
        // If arr[i] = max then rightmost 
        // index for max will change
        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";
}
  
// Driver code
$arr = array( 2, 1, 1, 2, 1, 5, 6, 5 );
$n = sizeof($arr);
  
findIndices($arr, $n);
  
// This code is contributed
// by Sachin
?>

chevron_right


Output:

Minimum left : 1
Minimum right : 4
Maximum left : 6
Maximum right : 6

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of above idea
#include<bits/stdc++.h>
using namespace std;
  
// Function to return the index of the rightmost
// minimum element from the array
int getRightMin(int arr[], int n)
{
  
    // First element is the minimum in a sorted array
    int min = arr[0];
    int rightMin = 0;
    int i = 1;
    while (i < n) {
  
        // While the elements are equal to the minimum
        // update rightMin
        if (arr[i] == min)
            rightMin = i;
  
        i *= 2;
    }
  
    i = rightMin + 1;
  
    // Final check whether there are any elements
    // which are equal to the minimum
    while (i < n && arr[i] == min) {
        rightMin = i;
        i++;
    }
  
    return rightMin;
}
  
// Function to return the index of the leftmost
// maximum element from the array
 int getLeftMax(int arr[], int n)
{
  
    // Last element is the maximum in a sorted array
    int max = arr[n - 1];
    int leftMax = n - 1;
    int i = n - 2;
    while (i > 0) {
  
        // While the elements are equal to the maximum
        // update leftMax
        if (arr[i] == max)
            leftMax = i;
  
        i /= 2;
    }
  
    i = leftMax - 1;
  
    // Final check whether there are any elements
    // which are equal to the maximum
    while (i >= 0 && arr[i] == max) {
        leftMax = i;
        i--;
    }
  
    return leftMax;
}
  
// Driver code
int main()
{
    int arr[] = { 0, 0, 1, 2, 5, 5, 6, 8, 8 };
    int n = sizeof(arr)/sizeof(arr[0]);
  
    // First element is the leftmost minimum in a sorted array
    cout << "Minimum left : " << 0 <<"\n";
    cout << "Minimum right : " << getRightMin(arr, n) << "\n";
    cout << "Maximum left : " << getLeftMax(arr, n) <<"\n";
  
    // Last element is the rightmost maximum in a sorted array
    cout << "Maximum right : " << (n - 1);
}
  
// This code is contributed by ihritik

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of above idea
public class GFG {
  
    // Function to return the index of the rightmost
    // minimum element from the array
    public static int getRightMin(int arr[], int n)
    {
  
        // First element is the minimum in a sorted array
        int min = arr[0];
        int rightMin = 0;
        int i = 1;
        while (i < n) {
  
            // While the elements are equal to the minimum
            // update rightMin
            if (arr[i] == min)
                rightMin = i;
  
            i *= 2;
        }
  
        i = rightMin + 1;
  
        // Final check whether there are any elements
        // which are equal to the minimum
        while (i < n && arr[i] == min) {
            rightMin = i;
            i++;
        }
  
        return rightMin;
    }
  
    // Function to return the index of the leftmost
    // maximum element from the array
    public static int getLeftMax(int arr[], int n)
    {
  
        // Last element is the maximum in a sorted array
        int max = arr[n - 1];
        int leftMax = n - 1;
        int i = n - 2;
        while (i > 0) {
  
            // While the elements are equal to the maximum
            // update leftMax
            if (arr[i] == max)
                leftMax = i;
  
            i /= 2;
        }
  
        i = leftMax - 1;
  
        // Final check whether there are any elements
        // which are equal to the maximum
        while (i >= 0 && arr[i] == max) {
            leftMax = i;
            i--;
        }
  
        return leftMax;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 0, 0, 1, 2, 5, 5, 6, 8, 8 };
        int n = arr.length;
  
        // First element is the leftmost minimum in a sorted array
        System.out.println("Minimum left : " + 0);
        System.out.println("Minimum right : " + getRightMin(arr, n));
        System.out.println("Maximum left : " + getLeftMax(arr, n));
  
        // Last element is the rightmost maximum in a sorted array
        System.out.println("Maximum right : " + (n - 1));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 implementation of above idea
  
# Function to return the index of the 
# rightmost minimum element from the array
def getRightMin(arr, n):
      
    # First element is the minimum 
    # in a sorted array
    min = arr[0]
    rightMin = 0
    i = 1
    while (i < n):
          
        # While the elements are equal to 
        # the minimum update rightMin
        if (arr[i] == min):
            rightMin = i
  
        i *= 2
      
    i = rightMin + 1
  
    # Final check whether there are any 
    # elements which are equal to the minimum
    while (i < n and arr[i] == min):
        rightMin = i
        i += 1
      
    return rightMin
  
# Function to return the index of the 
# leftmost maximum element from the array
def getLeftMax(arr, n):
      
    # Last element is the maximum 
    # in a sorted array
    max = arr[n - 1]
    leftMax = n - 1
    i = n - 2
    while (i > 0):
          
        # While the elements are equal to
        # the maximum update leftMax
        if (arr[i] == max):
            leftMax = i
  
        i = int(i / 2)
          
    i = leftMax - 1
  
    # Final check whether there are any 
    # elements which are equal to the maximum
    while (i >= 0 and arr[i] == max):
        leftMax = i
        i -= 1
      
    return leftMax
  
# Driver code
if __name__ == '__main__':
    arr = [0, 0, 1, 2, 5, 5, 6, 8, 8
    n = len(arr)
  
    # First element is the leftmost 
    # minimum in a sorted array
    print("Minimum left :", 0)
    print("Minimum right :", getRightMin(arr, n))
    print("Maximum left :", getLeftMax(arr, n))
  
    # Last element is the rightmost maximum 
    # in a sorted array
    print("Maximum right :", (n - 1))
  
# This code is contributed by
# Surendra_Gangwar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of above idea
  
using System;
public class GFG {
  
    // Function to return the index of the rightmost
    // minimum element from the array
    public static int getRightMin(int []arr, int n)
    {
  
        // First element is the minimum in a sorted array
        int min = arr[0];
        int rightMin = 0;
        int i = 1;
        while (i < n) {
  
            // While the elements are equal to the minimum
            // update rightMin
            if (arr[i] == min)
                rightMin = i;
  
            i *= 2;
        }
  
        i = rightMin + 1;
  
        // Final check whether there are any elements
        // which are equal to the minimum
        while (i < n && arr[i] == min) {
            rightMin = i;
            i++;
        }
  
        return rightMin;
    }
  
    // Function to return the index of the leftmost
    // maximum element from the array
    public static int getLeftMax(int []arr, int n)
    {
  
        // Last element is the maximum in a sorted array
        int max = arr[n - 1];
        int leftMax = n - 1;
        int i = n - 2;
        while (i > 0) {
  
            // While the elements are equal to the maximum
            // update leftMax
            if (arr[i] == max)
                leftMax = i;
  
            i /= 2;
        }
  
        i = leftMax - 1;
  
        // Final check whether there are any elements
        // which are equal to the maximum
        while (i >= 0 && arr[i] == max) {
            leftMax = i;
            i--;
        }
  
        return leftMax;
    }
  
    // Driver code
    public static void Main()
    {
        int []arr = { 0, 0, 1, 2, 5, 5, 6, 8, 8 };
        int n = arr.Length;
  
        // First element is the leftmost minimum in a sorted array
        Console.WriteLine("Minimum left : " + 0);
        Console.WriteLine("Minimum right : " + getRightMin(arr, n));
        Console.WriteLine("Maximum left : " + getLeftMax(arr, n));
  
        // Last element is the rightmost maximum in a sorted array
        Console.WriteLine("Maximum right : " + (n - 1));
    }
}
  
// This code is contributed by ihritik

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of above idea
  
// Function to return the index of the 
// rightmost minimum element from the array
function getRightMin($arr, $n)
{
  
    // First element is the minimum 
    // in a sorted array
    $min = $arr[0];
    $rightMin = 0;
    $i = 1;
    while ($i < $n
    {
  
        // While the elements are equal to 
        // the minimum update rightMin
        if ($arr[$i] == $min)
            $rightMin = $i;
  
        $i *= 2;
    }
  
    $i = $rightMin + 1;
  
    // Final check whether there are any 
    // elements which are equal to the minimum
    while ($i < $n && $arr[$i] == $min
    {
        $rightMin = $i;
        $i++;
    }
  
    return $rightMin;
}
  
// Function to return the index of the 
// leftmost maximum element from the array
function getLeftMax($arr, $n)
{
  
    // Last element is the maximum in 
    // a sorted array
    $max = $arr[$n - 1];
    $leftMax = $n - 1;
    $i = $n - 2;
    while ($i > 0)
    {
  
        // While the elements are equal to 
        // the maximum update leftMax
        if ($arr[$i] == $max)
            $leftMax = $i;
  
        $i /= 2;
    }
  
    $i = $leftMax - 1;
  
    // Final check whether there are any 
    // elements which are equal to the maximum
    while ($i >= 0 && $arr[$i] == $max
    {
        $leftMax = $i;
        $i--;
    }
  
    return $leftMax;
}
  
// Driver code
$arr = array(0, 0, 1, 2, 5, 
                5, 6, 8, 8 );
$n = sizeof($arr);
  
// First element is the leftmost
// minimum in a sorted array
echo "Minimum left : ", 0, "\n";
echo "Minimum right : ",
      getRightMin($arr, $n), "\n";
echo "Maximum left : "
      getLeftMax($arr, $n), "\n";
  
// Last element is the rightmost 
// maximum in a sorted array
echo "Maximum right : ", ($n - 1), "\n";
  
// This code is Contributed 
// by Mukul singh
?>

chevron_right


Output:

Minimum left : 0
Minimum right : 1
Maximum left : 7
Maximum right : 8

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.