Check if an array is sorted and rotated using Binary Search

Pre-requisite: Check if an array is sorted and rotated using Linear Search

Given an array arr[] of N distinct integers, the task is to check if this array is sorted when rotated counter-clockwise. A sorted array is not considered sorted and rotated, i.e., there should at least one rotation.

Examples:

Input: arr[] = { 3, 4, 5, 1, 2 }
Output: true
Explanation:
Sorted array: {1, 2, 3, 4, 5}.
Rotating this sorted array clockwise
by 3 positions, we get: { 3, 4, 5, 1, 2}

Input: arr[] = {7, 9, 11, 12, 5}
Output: true



Input: arr[] = {1, 2, 3}
Output: false

Approach: One approach to solving this problem using Linear Search has already been discussed in this article.

In this article, an approach using Binary Search concept is mentioned.

  1. To apply a binary search, the array needs to follow some order by which at every iteration, one half of the array can be eliminated.
  2. Therefore, the order followed by an array which is sorted and rotated array is that all the elements to the left of the pivot(the point at which the array is rotated) are in descending order and all the elements to the right of the pivot would be in ascending order.

    This can be visualized from the illustration below:

  3. Therefore, the pivot can be found using Binary Search and recursion in the following way:
    • Base Cases: The base case will be either when the pivot has been found or if the pivot cannot be found in the given array. The pivot cannot be found when the right index is less than the left index. -1 is returned in these cases. And when high and low are pointing to the same element, then the element at low is the pivot and that element is returned.
      if (high < low)
           return -1;
      if (high == low)
           return low;

      Apart from this, another base case is when mid((low + high) / 2) is a pivot. The element at mid is considered when that element is less than the next element or greater than the previous element.

      if (mid < high && arr[mid + 1] < arr[mid])
          reutrn mid;
      if (mid > low && arr[mid] < arr[mid - 1])
          return mid - 1;
      
    • Recursive Case: When none of the base cases satisfies, then a decision has to be made whether to ignore the first half or second half. This decision is taken by checking if the element at the first index (low) is greater than the element at the middle index or not. If it is, then the pivot for sure lies in the first half. Else, the pivot lies in the second half.
      if (arr[low] > arr[mid]) 
          return findPivot(arr, low, mid - 1);    
      else 
          return findPivot(arr, mid + 1, high);
      
      
  4. Once the pivot is found, then either traverse to the left of the array from the pivot and check if all the elements are in descending order, or traverse to the right of the array and check if all the elements are in ascending order or not.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

#include <bits/stdc++.h>
  
using namespace std;
  
// Function to return the
// index of the pivot
int findPivot(int arr[], int low, int high)
{
    // Base cases
    if (high < low)
        return -1;
    if (high == low)
        return low;
  
    int mid = (low + high) / 2;
    if (mid < high && arr[mid + 1] < arr[mid]) 
    {
        return mid;
    }
  
    // Check if element at (mid - 1) is pivot
    // Consider the cases like {4, 5, 1, 2, 3}
    if (mid > low && arr[mid] < arr[mid - 1])
    {
        return mid - 1;
    }
  
    // Decide whether we need to go to
    // the left half or the right half
    if (arr[low] > arr[mid])
    {
        return findPivot(arr, low, mid - 1);
    }
    else 
    {
        return findPivot(arr, mid + 1, high);
    }
}
  
// Function to check if a given array
// is sorted rotated or not
bool isRotated(int arr[], int n)
{
    int l = 0;
    int r = n - 1;
    int pivot = -1;
    if (arr[l] > arr[r])
    {
        pivot = findPivot(arr, l, r);
  
        // To check if the elements to the left
        // of the pivot are in descending or not
        if (l < pivot)
        {
            while (pivot > l)
            {
                if (arr[pivot] < arr[pivot - 1])
                {
                    return false;
                }
                pivot--;
            }
        }
  
        // To check if the elements to the right
        // of the pivot are in ascending or not
        else {
            pivot++;
            while (pivot < r) {
                if (arr[pivot] > arr[pivot + 1]) {
                    return false;
                }
                pivot++;
            }
        }
  
        // If any of the above if or else is true
        // Then the array is sorted rotated
        return true;
    }
  
    // Else the array is not sorted rotated
    else {
        return false;
    }
}
  
// Driver code
int main()
{
    int arr[] = { 3, 4, 5, 1, 2 };
    if (isRotated(arr, 5)) cout<<"true";
    else
    cout<<"false";
    return 0;
}
  
// This code is contributed by mohit kumar 29

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the above approach
  
class GFG {
  
    // Function to return the
    // index of the pivot
    static int findPivot(int arr[], int low, int high)
    {
        // Base cases
        if (high < low)
            return -1;
        if (high == low)
            return low;
  
        int mid = (low + high) / 2;
        if (mid < high && arr[mid + 1] < arr[mid]) {
            return mid;
        }
  
        // Check if element at (mid - 1) is pivot
        // Consider the cases like {4, 5, 1, 2, 3}
        if (mid > low && arr[mid] < arr[mid - 1]) {
            return mid - 1;
        }
  
        // Decide whether we need to go to
        // the left half or the right half
        if (arr[low] > arr[mid]) {
            return findPivot(arr, low, mid - 1);
        }
        else {
            return findPivot(arr, mid + 1, high);
        }
    }
  
    // Function to check if a given array
    // is sorted rotated or not
    public static boolean isRotated(int arr[], int n)
    {
        int l = 0;
        int r = n - 1;
        int pivot = -1;
        if (arr[l] > arr[r]) {
            pivot = findPivot(arr, l, r);
  
            // To check if the elements to the left
            // of the pivot are in descending or not
            if (l < pivot) {
                while (pivot > l) {
                    if (arr[pivot] < arr[pivot - 1]) {
                        return false;
                    }
                    pivot--;
                }
            }
  
            // To check if the elements to the right
            // of the pivot are in ascending or not
            else {
                pivot++;
                while (pivot < r) {
                    if (arr[pivot] > arr[pivot + 1]) {
                        return false;
                    }
                    pivot++;
                }
            }
  
            // If any of the above if or else is true
            // Then the array is sorted rotated
            return true;
        }
  
        // Else the array is not sorted rotated
        else {
            return false;
        }
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 3, 4, 5, 1, 2 };
        System.out.println(isRotated(arr, 5));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the above approach
  
# Function to return the 
# index of the pivot 
def findPivot(arr, low, high) :
  
    # Base cases 
    if (high < low) :
        return -1
          
    if (high == low) :
        return low; 
  
    mid = (low + high) // 2
    if (mid < high and arr[mid + 1] < arr[mid]) :
      
        return mid; 
  
    # Check if element at (mid - 1) is pivot 
    # Consider the cases like {4, 5, 1, 2, 3} 
    if (mid > low and arr[mid] < arr[mid - 1]) :
      
        return mid - 1
      
    # Decide whether we need to go to 
    # the left half or the right half 
    if (arr[low] > arr[mid]) :
      
        return findPivot(arr, low, mid - 1); 
      
    else :
      
        return findPivot(arr, mid + 1, high); 
      
# Function to check if a given array 
# is sorted rotated or not 
def isRotated(arr, n) : 
  
    l = 0
    r = n - 1
    pivot = -1
    if (arr[l] > arr[r]) :
      
        pivot = findPivot(arr, l, r); 
  
        # To check if the elements to the left 
        # of the pivot are in descending or not 
        if (l < pivot) :
          
            while (pivot > l) :
              
                if (arr[pivot] < arr[pivot - 1]) :
                  
                    return False
                  
                pivot -= 1
  
        # To check if the elements to the right 
        # of the pivot are in ascending or not 
        else :
            pivot += 1
            while (pivot < r) :
                if (arr[pivot] > arr[pivot + 1]) :
                    return False
                  
                pivot ++ 1
      
        # If any of the above if or else is true 
        # Then the array is sorted rotated 
        return True
  
    # Else the array is not sorted rotated 
    else :
        return False
  
  
# Driver code 
if __name__ == "__main__"
  
    arr = [ 3, 4, 5, 1, 2 ]; 
    if (isRotated(arr, 5)) :
        print("True"); 
    else :
        print("False"); 
  
# This code is contributed by Yash_R

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the above approach
using System;
  
class GFG {
   
    // Function to return the
    // index of the pivot
    static int findPivot(int []arr, int low, int high)
    {
        // Base cases
        if (high < low)
            return -1;
        if (high == low)
            return low;
   
        int mid = (low + high) / 2;
        if (mid < high && arr[mid + 1] < arr[mid]) {
            return mid;
        }
   
        // Check if element at (mid - 1) is pivot
        // Consider the cases like {4, 5, 1, 2, 3}
        if (mid > low && arr[mid] < arr[mid - 1]) {
            return mid - 1;
        }
   
        // Decide whether we need to go to
        // the left half or the right half
        if (arr[low] > arr[mid]) {
            return findPivot(arr, low, mid - 1);
        }
        else {
            return findPivot(arr, mid + 1, high);
        }
    }
   
    // Function to check if a given array
    // is sorted rotated or not
    public static bool isRotated(int []arr, int n)
    {
        int l = 0;
        int r = n - 1;
        int pivot = -1;
        if (arr[l] > arr[r]) {
            pivot = findPivot(arr, l, r);
   
            // To check if the elements to the left
            // of the pivot are in descending or not
            if (l < pivot) {
                while (pivot > l) {
                    if (arr[pivot] < arr[pivot - 1]) {
                        return false;
                    }
                    pivot--;
                }
            }
   
            // To check if the elements to the right
            // of the pivot are in ascending or not
            else {
                pivot++;
                while (pivot < r) {
                    if (arr[pivot] > arr[pivot + 1]) {
                        return false;
                    }
                    pivot++;
                }
            }
   
            // If any of the above if or else is true
            // Then the array is sorted rotated
            return true;
        }
   
        // Else the array is not sorted rotated
        else {
            return false;
        }
    }
   
    // Driver code
    public static void Main(String[] args)
    {
        int []arr = { 3, 4, 5, 1, 2 };
        Console.WriteLine(isRotated(arr, 5));
    }
}
  
// This code contributed by Rajput-Ji

chevron_right


Output:

true

Time Complexity: O(N) as:

  • The pivot element is being found using Binary Search in O(log N)
  • But in order to check if the left part or right part is in descending or ascending order, O(N) time is needed in worst case scenario.
  • Therefore the overall time complexity is O(N)

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.




My Personal Notes arrow_drop_up

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.