Maximum element in a sorted and rotated array

Given a sorted array arr[] (may contain duplicates) of size n that is rotated at some unknown point, the task is to find the maximum element in it. 

Examples: 

Input: arr[] = {5, 6, 1, 2, 3, 4}
Output: 6
Explanation: 6 is the maximum element present in the array.

Input: arr[] = {3, 2, 2, 2}
Output: 3
Explanation: 3 is the maximum element present in the array.

[Naive Approach] Linear Search - O(n) Time and O(1) Space

A simple solution is to use linear search to traverse the complete array and find a maximum. 

// C++ program to find maximum element in a 
// sorted rotated array using linear search
#include <iostream>
#include <vector>
using namespace std;

// Function to find the maximum value
int findMax(vector<int>& arr) {
  
    int res = arr[0];

    // Traverse over arr[] to find maximum element
    for (int i = 1; i < arr.size(); i++) 
        res = max(res, arr[i]);

    return res;
}

int main() {
    vector<int> arr = {5, 6, 1, 2, 3, 4};

    cout << findMax(arr) << endl;
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// Function to find the maximum value
int findMax(int arr[], int size) {
    int res = arr[0];

    // Traverse over arr[] to find maximum element
    for (int i = 1; i < size; i++)
        res = (res > arr[i]) ? res : arr[i];

    return res;
}

int main() {
    int arr[] = {5, 6, 1, 2, 3, 4};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("%d\n", findMax(arr, size));
    return 0;
}

import java.util.Arrays;

public class GfG {
  
    // Function to find the maximum value
    public static int findMax(int[] arr) {
        int res = arr[0];

        // Traverse over arr[] to find maximum element
        for (int i = 1; i < arr.length; i++)
            res = Math.max(res, arr[i]);

        return res;
    }

    public static void main(String[] args) {
        int[] arr = {5, 6, 1, 2, 3, 4};

        System.out.println(findMax(arr));
    }
}

# Function to find the maximum value
def findMax(arr):
    res = arr[0]

    # Traverse over arr[] to find maximum element
    for i in range(1, len(arr)):
        res = max(res, arr[i])

    return res

if __name__ == '__main__':
    arr = [5, 6, 1, 2, 3, 4]
    print(findMax(arr))

// Function to find the maximum value
function findMax(arr) {
    let res = arr[0];

    // Traverse over arr to find maximum element
    for (let i = 1; i < arr.length; i++) 
        res = Math.max(res, arr[i]);

    return res;
}

const arr = [5, 6, 1, 2, 3, 4];

console.log(findMax(arr));

6

[Expected Approach] Binary Search - O(log n) Time and O(1) Space

In Binary Search, we find the mid element and then decide whether to stop or to go to left half or right half. How do we decide in this case. Let us take few examples.

{4, 5, 6, 9, 10, 1, 2}, mid = (0 + 7) / 2 = 3. arr[3] is 9. How to find out that we need to go to the right half (Note that the largest element is in right half)? We can say if arr[mid] > arr[lo], then we go the right half. So we change low = mid. Please note that arr[mid] can also be the largest element.

{50, 10, 20, 30, 40}, mid = (0 + 4)/2 = 2. arr[2] is 20. If arr[mid] is smaller than or equal to arr[lo], then we go to the left half.

How do we terminate the search? One way could be to check if the mid is smaller than both of its adjacent, then we return mid. This would require a lot of condition checks like if adjacent indexes are valid or not and then comparing mid with both. We use an interesting fact here. If arr[lo] <= arr[hi], then the current subarray must be sorted, So we return arr[hi]. This optimizes the code drastically as we do not have to explicitly check the whole sorted array.

#include <bits/stdc++.h>
using namespace std;

int findMax(vector<int> &arr)
{
    int lo = 0, hi = arr.size() - 1;

    while (lo < hi)
    {
        // If the current subarray is already sorted,
        // the maximum is at the hi index
        if (arr[lo] <= arr[hi])
            return arr[hi];
        
        int mid = (lo + hi) / 2;

        // The left half is sorted, the maximum must 
        // be either arr[mid] or in the right half.
        if (arr[mid] > arr[lo])
            lo = mid;
        else
            hi = mid - 1;
    }

    return arr[lo]; 
}

int main()
{
    vector<int> arr = {7, 8, 9, 10, 1, 2, 3, 4, 5};
    cout << findMax(arr);
    return 0;
}

#include <stdio.h>

int findMax(int arr[], int n) {
    int lo = 0, hi = n - 1;

    while (lo < hi) {
      
        // If the current subarray is already sorted,
        // the maximum is at the hi index
        if (arr[lo] <= arr[hi])
            return arr[hi];
        
        int mid = (lo + hi) / 2;

        // The left half is sorted, the maximum must 
        // be either arr[mid] or in the right half.
        if (arr[mid] > arr[lo])
            lo = mid;
        else
            hi = mid - 1;
    }

    return arr[lo]; 
}

int main() {
    int arr[] = {7, 8, 9, 10, 1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d", findMax(arr, n));
    return 0;
}

import java.util.Arrays;

public class Main {
    public static int findMax(int[] arr) {
        int lo = 0, hi = arr.length - 1;

        while (lo < hi) {
          
            // If the current subarray is already sorted,
            // the maximum is at the hi index
            if (arr[lo] <= arr[hi])
                return arr[hi];
            
            int mid = (lo + hi) / 2;

            // The left half is sorted, the maximum must 
            // be either arr[mid] or in the right half.
            if (arr[mid] > arr[lo])
                lo = mid;
            else
                hi = mid - 1;
        }

        return arr[lo]; 
    }

    public static void main(String[] args) {
        int[] arr = {7, 8, 9, 10, 1, 2, 3, 4, 5};
        System.out.println(findMax(arr));
    }
}

def find_max(arr):
    lo, hi = 0, len(arr) - 1

    while lo < hi:
      
        # If the current subarray is already sorted,
        # the maximum is at the hi index
        if arr[lo] <= arr[hi]:
            return arr[hi]
        
        mid = (lo + hi) // 2

        # The left half is sorted, the maximum must 
        # be either arr[mid] or in the right half.
        if arr[mid] > arr[lo]:
            lo = mid
        else:
            hi = mid - 1

    return arr[lo]

arr = [7, 8, 9, 10, 1, 2, 3, 4, 5]
print(find_max(arr))

using System;

class Program {
    static int FindMax(int[] arr) {
        int lo = 0, hi = arr.Length - 1;

        while (lo < hi) {
          
            // If the current subarray is already sorted,
            // the maximum is at the hi index
            if (arr[lo] <= arr[hi])
                return arr[hi];
            
            int mid = (lo + hi) / 2;

            // The left half is sorted, the maximum must 
            // be either arr[mid] or in the right half.
            if (arr[mid] > arr[lo])
                lo = mid;
            else
                hi = mid - 1;
        }

        return arr[lo]; 
    }

    static void Main() {
        int[] arr = {7, 8, 9, 10, 1, 2, 3, 4, 5};
        Console.WriteLine(FindMax(arr));
    }
}

function findMax(arr) {
    let lo = 0, hi = arr.length - 1;

    while (lo < hi) {
    
        // If the current subarray is already sorted,
        // the maximum is at the hi index
        if (arr[lo] <= arr[hi])
            return arr[hi];
        
        let mid = Math.floor((lo + hi) / 2);

        // The left half is sorted, the maximum must 
        // be either arr[mid] or in the right half.
        if (arr[mid] > arr[lo])
            lo = mid;
        else
            hi = mid - 1;
    }

    return arr[lo]; 
}

const arr = [7, 8, 9, 10, 1, 2, 3, 4, 5];
console.log(findMax(arr));

10