Skip to content
Related Articles

Related Articles

Search for an element in a Mountain Array
  • Last Updated : 28 Jan, 2021

Given a mountain array arr[] and an integer X, the task is to find the smallest index of X in the given array. If no such index found, print -1.

Examples:

Input: arr = {1, 2, 3, 4, 5, 3, 1}, X = 3
Output: 2
Explanation: 
The smallest index of X(= 3) in the array is 2. 
Therefore, the required output is 2.

Input: arr[] = {0, 1, 2, 4, 2, 1}, X = 3
Output: -1
Explanation: Since 3 does not exist in the array, the required output is -1.

Naive Approach: The simplest approach is to traverse the array and check if element at current index is equal to X or not. If found to be true, then print that index. 



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

Efficient Approach: The optimal idea to solve this problem is to use Binary Search. Follow the steps below to solve this problem:

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program for the above approach
#include<bits/stdc++.h>
using namespace std;
 
// Function to find the index of
// the peak element in the array
int findPeak(vector<int> arr)
{
 
  // Stores left most index in which
  // the peak element can be found
  int left = 0;
 
  // Stores right most index in which
  // the peak element can be found
  int right = arr.size() - 1;
  while (left < right)
  {
 
    // Stores mid of left and right
    int mid = left + (right - left) / 2;
 
    // If element at mid is less than
    // element at (mid + 1)
    if (arr[mid] < arr[mid + 1])
    {
 
      // Update left
      left = mid + 1;
    }
    else
    {
 
      // Update right
      right = mid;
    }
  }
  return left;
}
 
// Function to perform binary search in an
// a subarray if elements of the subarray
// are in an ascending order
int BS(int X, int left, int right,
       vector<int> arr)
{
  while (left <= right)
  {
 
    // Stores mid of left and right
    int mid = left + (right - left) / 2;
 
    // If X found at mid
    if (arr[mid] == X)
    {
      return mid;
    }
 
    // If X is greater than mid
    else if (X > arr[mid])
    {
 
      // Update left
      left = mid + 1;
    }
 
    else
    {
 
      // Update right
      right = mid - 1;
    }
  }
  return -1;
}
 
// Function to perform binary search in an
// a subarray if elements of the subarray
// are in an ascending order
int reverseBS(int X, int left, int right, vector<int> arr)
{
  while (left <= right)
  {
 
    // Stores mid of left and right
    int mid = left + (right - left) / 2;
 
    // If X found at mid
    if (arr[mid] == X)
    {
      return mid;
    }
 
    else if (X > arr[mid])
    {
 
      // Update right
      right = mid - 1;
    }
    else
    {
 
      // Update left
      left = mid + 1;
    }
  }
  return -1;
}
 
// Function to find the smallest index of X
void findInMA(int X, vector<int> mountainArr)
{
 
  // Stores index of peak element in array
  int peakIndex = findPeak(mountainArr);
 
  // Stores index of X in the array
  int res = -1;
 
  // If X greater than or equal to first element
  // of array and less than the peak element
  if (X >= mountainArr[0] && X <= mountainArr[peakIndex])
  {
 
    // Update res
    res = BS(X, 0, peakIndex, mountainArr);
  }
 
  // If element not found on
  // left side of peak element
  if (res == -1)
  {
 
    // Update res
    res = reverseBS(X, peakIndex + 1,
                    mountainArr.size() - 1,
                    mountainArr);
  }
 
  // Print res
  cout<<res<<endl;
}
 
// Driver Code
int main()
{
 
  // Given X
  int X = 3;
 
  // Given array
  vector<int> list{1, 2, 3, 4, 5, 3, 1};
 
  // Function Call
  findInMA(X, list);
}
 
// This code is contributed by bgangwar59.

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
 
import java.io.*;
import java.util.*;
 
class GFG {
 
    // Function to find the index of
    // the peak element in the array
    public static int findPeak(
        ArrayList<Integer> arr)
    {
 
        // Stores left most index in which
        // the peak element can be found
        int left = 0;
 
        // Stores right most index in which
        // the peak element can be found
        int right = arr.size() - 1;
 
        while (left < right) {
 
            // Stores mid of left and right
            int mid = left + (right - left) / 2;
 
            // If element at mid is less than
            // element at (mid + 1)
            if (arr.get(mid) < arr.get(mid + 1)) {
 
                // Update left
                left = mid + 1;
            }
            else {
 
                // Update right
                right = mid;
            }
        }
 
        return left;
    }
 
    // Function to perform binary search in an
    // a subarray if elements of the subarray
    // are in an ascending order
    static int BS(int X, int left, int right,
                  ArrayList<Integer> arr)
    {
 
        while (left <= right) {
 
            // Stores mid of left and right
            int mid = left + (right - left) / 2;
 
            // If X found at mid
            if (arr.get(mid) == X) {
                return mid;
            }
 
            // If X is greater than mid
            else if (X > arr.get(mid)) {
 
                // Update left
                left = mid + 1;
            }
 
            else {
 
                // Update right
                right = mid - 1;
            }
        }
        return -1;
    }
 
    // Function to perform binary search in an
    // a subarray if elements of the subarray
    // are in an ascending order
    static int reverseBS(int X, int left, int right,
                         ArrayList<Integer> arr)
    {
        while (left <= right) {
 
            // Stores mid of left and right
            int mid = left + (right - left) / 2;
 
            // If X found at mid
            if (arr.get(mid) == X) {
                return mid;
            }
 
            else if (X > arr.get(mid)) {
 
                // Update right
                right = mid - 1;
            }
            else {
 
                // Update left
                left = mid + 1;
            }
        }
        return -1;
    }
 
    // Function to find the smallest index of X
    static void findInMA(int X,
                         ArrayList<Integer> mountainArr)
    {
 
        // Stores index of peak element in array
        int peakIndex = findPeak(mountainArr);
 
        // Stores index of X in the array
        int res = -1;
 
        // If X greater than or equal to first element
        // of array and less than the peak element
        if (X >= mountainArr.get(0)
            && X <= mountainArr.get(peakIndex)) {
 
            // Update res
            res = BS(X, 0, peakIndex, mountainArr);
        }
 
        // If element not found on
        // left side of peak element
        if (res == -1) {
 
            // Update res
            res = reverseBS(X, peakIndex + 1,
                            mountainArr.size() - 1,
                            mountainArr);
        }
 
        // Print res
        System.out.println(res);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // Given X
        int X = 3;
 
        // Given array
        ArrayList<Integer> list = new ArrayList<>(
            Arrays.asList(1, 2, 3, 4, 5, 3, 1));
 
        // Function Call
        findInMA(X, list);
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
 
# Function to find the index of
# the peak element in the array
def findPeak(arr):
     
    # Stores left most index in which
    # the peak element can be found
    left = 0
 
    # Stores right most index in which
    # the peak element can be found
    right = len(arr) - 1
 
    while (left < right):
 
        # Stores mid of left and right
        mid = left + (right - left) // 2
 
        # If element at mid is less than
        # element at(mid + 1)
        if (arr[mid] < arr[(mid + 1)]):
 
            # Update left
            left = mid + 1
 
        else:
 
            # Update right
            right = mid
 
    return left
 
# Function to perform binary search in an
# a subarray if elements of the subarray
# are in an ascending order
def BS(X, left, right, arr):
     
    while (left <= right):
 
        # Stores mid of left and right
        mid = left + (right - left) // 2
 
        # If X found at mid
        if (arr[mid] == X):
            return mid
 
        # If X is greater than mid
        elif (X > arr[mid]):
 
            # Update left
            left = mid + 1
 
        else:
 
            # Update right
            right = mid - 1
 
    return -1
 
# Function to perform binary search in an
# a subarray if elements of the subarray
# are in an ascending order
def reverseBS(X, left, right, arr):
     
    while (left <= right):
 
        # Stores mid of left and right
        mid = left + (right - left) // 2
 
        # If X found at mid
        if (arr[mid] == X):
            return mid
 
        elif (X > arr[mid]):
 
            # Update right
            right = mid - 1
 
        else:
             
            # Update left
            left = mid + 1
             
    return -1
 
# Function to find the smallest index of X
def findInMA(X, mountainArr):
     
    # Stores index of peak element in array
    peakIndex = findPeak(mountainArr)
 
    # Stores index of X in the array
    res = -1
 
    # If X greater than or equal to first element
    # of array and less than the peak element
    if (X >= mountainArr[0] and
        X <= mountainArr[peakIndex]):
 
        # Update res
        res = BS(X, 0, peakIndex, mountainArr)
 
    # If element not found on
    # left side of peak element
    if (res == -1):
 
        # Update res
        res = reverseBS(X, peakIndex + 1,
                        mountainArr.size() - 1,
                        mountainArr)
 
    # Print res
    print(res)
 
# Driver Code
if __name__ == "__main__":
 
    # Given X
    X = 3
 
    # Given array
    arr = [ 1, 2, 3, 4, 5, 3, 1 ]
 
    # Function Call
    findInMA(X, arr)
 
# This code is contributed by chitranayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
using System.Collections.Generic;
using System.Linq;
class GFG
{
 
    // Function to find the index of
    // the peak element in the array
    public static int findPeak(List<int> arr)
    {
 
        // Stores left most index in which
        // the peak element can be found
        int left = 0;
 
        // Stores right most index in which
        // the peak element can be found
        int right = arr.Count - 1;
 
        while (left < right)
        {
 
            // Stores mid of left and right
            int mid = left + (right - left) / 2;
 
            // If element at mid is less than
            // element at (mid + 1)
            if (arr[mid] < arr[(mid + 1)])
            {
 
                // Update left
                left = mid + 1;
            }
            else
            {
 
                // Update right
                right = mid;
            }
        }
 
        return left;
    }
 
    // Function to perform binary search in an
    // a subarray if elements of the subarray
    // are in an ascending order
    static int BS(int X, int left, int right,
                List<int> arr)
    {
 
        while (left <= right)
        {
 
            // Stores mid of left and right
            int mid = left + (right - left) / 2;
 
            // If X found at mid
            if (arr[(mid)] == X)
            {
                return mid;
            }
 
            // If X is greater than mid
            else if (X > arr[mid])
            {
 
                // Update left
                left = mid + 1;
            }
 
            else
            {
 
                // Update right
                right = mid - 1;
            }
        }
        return -1;
    }
 
    // Function to perform binary search in an
    // a subarray if elements of the subarray
    // are in an ascending order
    static int reverseBS(int X, int left, int right,
                         List<int> arr)
    {
        while (left <= right)
        {
 
            // Stores mid of left and right
            int mid = left + (right - left) / 2;
 
            // If X found at mid
            if (arr[mid] == X)
            {
                return mid;
            }
 
            else if (X > arr[mid])
            {
 
                // Update right
                right = mid - 1;
            }
            else
            {
 
                // Update left
                left = mid + 1;
            }
        }
        return -1;
    }
 
    // Function to find the smallest index of X
    static void findInMA(int X,
                         List<int> mountainArr)
    {
 
        // Stores index of peak element in array
        int peakIndex = findPeak(mountainArr);
 
        // Stores index of X in the array
        int res = -1;
 
        // If X greater than or equal to first element
        // of array and less than the peak element
        if (X >= mountainArr[0]
            && X <= mountainArr[peakIndex])
        {
 
            // Update res
            res = BS(X, 0, peakIndex, mountainArr);
        }
 
        // If element not found on
        // left side of peak element
        if (res == -1)
        {
 
            // Update res
            res = reverseBS(X, peakIndex + 1,
                            mountainArr.Count - 1,
                            mountainArr);
        }
 
        // Print res
        Console.WriteLine(res);
    }
 
    // Driver Code
    public static void Main( )
    {
 
        // Given X
        int X = 3;
 
        // Given array
        List<int> list =  new List<int>(){1, 2, 3, 4, 5, 3, 1};
 
        // Function Call
        findInMA(X, list);
    }
}
 
// This code is contributed by code_hunt.

chevron_right


Output: 

2

 

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

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 Articles
Page :