Check if an array is sorted and rotated

Given an array of N distinct integers. The task is to write a program to check if this array is sorted and rotated counter-clockwise. A sorted array is not considered as sorted and rotated, i.e., there should at least one rotation.

Examples:

Input : arr[] = { 3, 4, 5, 1, 2 }
Output : YES
The above array is sorted and rotated.
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: YES

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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

Find the minimum element in the array.
Now, if the array is sorted and then rotated then all the elements before minimum element will be in increasing order and all elements after the minimum element will also be in increasing order.
Check if all elements before minimum element are in increasing order.
Check if all elements before minimum element are in increasing order.
Check if the last element of the array is smaller than the element just before the minimum element.
If all of the above three condition satisfies then print YES otherwise print NO.

Below is the implementation of the above idea:

C++

// CPP program to check if an array is 
// sorted and rotated clockwise 
#include <climits> 
#include <iostream> 
  
using namespace std; 
  
// Function to check if an array is 
// sorted and rotated clockwise 
void checkIfSortRotated(int arr[], int n) 
{ 
    int minEle = INT_MAX; 
    int maxEle = INT_MIN; 
  
    int minIndex = -1; 
  
    // Find the minimum element 
    // and it's index 
    for (int i = 0; i < n; i++) { 
        if (arr[i] < minEle) { 
            minEle = arr[i]; 
            minIndex = i; 
        } 
    } 
  
    int flag1 = 1; 
  
    // Check if all elements before minIndex 
    // are in increasing order 
    for (int i = 1; i < minIndex; i++) { 
        if (arr[i] < arr[i - 1]) { 
            flag1 = 0; 
            break; 
        } 
    } 
  
    int flag2 = 1; 
  
    // Check if all elements after minIndex 
    // are in increasing order 
    for (int i = minIndex + 1; i < n; i++) { 
        if (arr[i] < arr[i - 1]) { 
            flag2 = 0; 
            break; 
        } 
    } 
  
    // Check if last element of the array 
    // is smaller than the element just 
    // before the element at minIndex 
    if (flag1 && flag2 && (arr[n - 1] < arr[minIndex - 1])) 
        cout << "YES"; 
    else
        cout << "NO"; 
} 
  
// Driver code 
int main() 
{ 
    int arr[] = { 3, 4, 5, 1, 2 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 
    checkIfSortRotated(arr, n); 
    return 0; 
} 

Java

// Java program to check if an  
// array is sorted and rotated  
// clockwise  
import java.io.*; 
  
class GFG 
{ 
  
// Function to check if an array is  
// sorted and rotated clockwise  
static void checkIfSortRotated(int arr[],  
                               int n)  
{  
    int minEle = Integer.MAX_VALUE; 
    int maxEle = Integer.MIN_VALUE; 
  
    int minIndex = -1;  
  
    // Find the minimum element  
    // and it's index  
    for (int i = 0; i < n; i++)  
    {  
        if (arr[i] < minEle)  
        {  
            minEle = arr[i];  
            minIndex = i;  
        }  
    }  
  
    boolean flag1 = true;  
  
    // Check if all elements before  
    // minIndex are in increasing order  
    for (int i = 1; i < minIndex; i++)  
    {  
        if (arr[i] < arr[i - 1])  
        {  
            flag1 = false;  
            break;  
        }  
    }  
  
    boolean flag2 = true;  
  
    // Check if all elements after  
    // minIndex are in increasing order  
    for (int i = minIndex + 1; i < n; i++) 
    {  
        if (arr[i] < arr[i - 1])  
        {  
            flag2 = false;  
            break;  
        }  
    }  
  
      
    //check if the minIndex is 0, i.e the first element is the smallest , which is the case when array is sorted but not rotated. 
    if(minIndex == 0) 
      { 
          System.out.print("NO"); 
          return; 
      } 
    // Check if last element of the array  
    // is smaller than the element just  
    // before the element at minIndex  
    if (flag1 && flag2 && (arr[n - 1] < 
                           arr[minIndex - 1]))  
        System.out.println("YES");  
    else
        System.out.print("NO");  
}  
  
// Driver code  
public static void main (String[] args) 
{ 
    int arr[] = { 3, 4, 5, 1, 2 };  
      
    int n = arr.length; 
      
    checkIfSortRotated(arr, n);  
} 
} 
  
// This code is contributed  
// by inder_verma. 

Python3

# Python3 program to check if an  
# array is sorted and rotated clockwise 
import sys 
  
# Function to check if an array is 
# sorted and rotated clockwise 
def checkIfSortRotated(arr, n): 
    minEle = sys.maxsize 
    maxEle = -sys.maxsize - 1
    minIndex = -1
  
    # Find the minimum element 
    # and it's index 
    for i in range(n): 
        if arr[i]< minEle: 
            minEle = arr[i] 
            minIndex = i 
    flag1 = 1
  
    # Check if all elements before  
    # minIndex are in increasing order 
    for i in range(1, minIndex): 
        if arr[i] < arr[i - 1]: 
            flag1 = 0
            break
    flag2 = 2
  
    # Check if all elements after  
    # minIndex are in increasing order 
    for i in range(minIndex + 1, n) : 
        if arr[i] < arr[i - 1]: 
            flag2 = 0
            break
  
    # Check if last element of the array 
    # is smaller than the element just 
    # before the element at minIndex 
    if (flag1 and flag2 and 
        arr[n - 1] < arr[minIndex - 1]): 
        print("YES") 
    else: 
        print("NO") 
  
# Driver code 
arr = [3, 4, 5, 1, 2 ] 
n = len(arr) 
checkIfSortRotated(arr, n) 
  
# This code is contributed  
# by Shrikant13 

C#

// C# program to check if an  
// array is sorted and rotated  
// clockwise  
using System; 
  
class GFG 
{ 
  
// Function to check if an array is  
// sorted and rotated clockwise  
static void checkIfSortRotated(int []arr,  
                               int n)  
{  
    int minEle = int.MaxValue; 
    //int maxEle = int.MinValue; 
  
    int minIndex = -1;  
  
    // Find the minimum element  
    // and it's index  
    for (int i = 0; i < n; i++)  
    {  
        if (arr[i] < minEle)  
        {  
            minEle = arr[i];  
            minIndex = i;  
        }  
    }  
  
    bool flag1 = true;  
  
    // Check if all elements before  
    // minIndex are in increasing order  
    for (int i = 1; i < minIndex; i++)  
    {  
        if (arr[i] < arr[i - 1])  
        {  
            flag1 = false;  
            break;  
        }  
    }  
  
    bool flag2 = true;  
  
    // Check if all elements after  
    // minIndex are in increasing order  
    for (int i = minIndex + 1; i < n; i++) 
    {  
        if (arr[i] < arr[i - 1])  
        {  
            flag2 = false;  
            break;  
        }  
    }  
  
    // Check if last element of the array  
    // is smaller than the element just  
    // before the element at minIndex  
    if (flag1 && flag2 && (arr[n - 1] < 
                           arr[minIndex - 1]))  
        Console.WriteLine("YES");  
    else
        Console.WriteLine("NO");  
}  
  
// Driver code  
public static void Main () 
{ 
    int []arr = { 3, 4, 5, 1, 2 };  
      
    int n = arr.Length; 
      
    checkIfSortRotated(arr, n);  
} 
} 
  
// This code is contributed  
// by inder_verma. 

PHP

<?php 
// PHP program to check if an  
// array is sorted and rotated 
// clockwise 
  
// Function to check if an array 
// is sorted and rotated clockwise 
function checkIfSortRotated($arr, $n) 
{ 
    $minEle = PHP_INT_MAX; 
    $maxEle = PHP_INT_MIN; 
  
    $minIndex = -1; 
  
    // Find the minimum element 
    // and it's index 
    for ($i = 0; $i <$n; $i++)  
    { 
        if ($arr[$i] < $minEle)  
        { 
            $minEle = $arr[$i]; 
            $minIndex = $i; 
        } 
    } 
  
    $flag1 = 1; 
  
    // Check if all elements before  
    // minIndex are in increasing order 
    for ( $i = 1; $i <$minIndex; $i++)  
    { 
        if ($arr[$i] < $arr[$i - 1])  
        { 
            $flag1 = 0; 
            break; 
        } 
    } 
  
    $flag2 = 1; 
  
    // Check if all elements after  
    // minIndex are in increasing order 
    for ($i = $minIndex + 1; $i <$n; $i++)  
    { 
        if ($arr[$i] < $arr[$i - 1])  
        { 
            $flag2 = 0; 
            break; 
        } 
    } 
  
    // Check if last element of the array 
    // is smaller than the element just 
    // before the element at minIndex 
    if ($flag1 && $flag2 &&  
       ($arr[$n - 1] < $arr[$minIndex - 1])) 
        echo( "YES"); 
    else
        echo( "NO"); 
} 
  
// Driver code 
$arr = array(3, 4, 5, 1, 2); 
  
$n = count($arr); 
  
checkIfSortRotated($arr, $n); 
  
// This code is contributed 
// by inder_verma. 
?> 

Output:

YES

My Personal Notes

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

C++

Java

Python3

C#

PHP

Recommended Posts: