Related Articles

# Search for an element in a Mountain Array

• Last Updated : 31 May, 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 is 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 the element in the 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++

 `// CPP program for the above approach``#include``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 && 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< list{1, 2, 3, 4, 5, 3, 1};` `  ``// Function Call``  ``findInMA(X, list);``}` `// This code is contributed by bgangwar59.`

## Java

 `// 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 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 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 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 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 list = ``new` `ArrayList<>(``            ``Arrays.asList(``1``, ``2``, ``3``, ``4``, ``5``, ``3``, ``1``));` `        ``// Function Call``        ``findInMA(X, list);``    ``}``}`

## Python3

 `# 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`

## C#

 `// 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``            ``&& 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.`

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up