Maximum element in a sorted and rotated array

Last Updated : 07 Nov, 2024

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

// 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; }

Java

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));     } }

Python

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

JavaScript

// 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));

Output

[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.

C++

#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; }

Java

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));     } }

Python

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));     } }

JavaScript

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));

Output

Type of array and its maximum element

md1844

Improve

Article Tags :

Practice Tags :

Maximum element in a sorted and rotated array

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

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

Similar Reads