 Open in App
Not now

# Find the Rotation Count in Rotated Sorted array

• Difficulty Level : Easy
• Last Updated : 02 Jan, 2023

Given an array arr[] of size N having distinct numbers sorted in increasing order and the array has been right rotated (i.e, the last element will be cyclically shifted to the starting position of the array) k number of times, the task is to find the value of k.

Examples:

Input: arr[] = {15, 18, 2, 3, 6, 12}
Output: 2
Explanation: Initial array must be {2, 3, 6, 12, 15, 18}.
We get the given array after rotating the initial array twice.

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

Input: arr[] = {7, 9, 11, 12, 15};
Output: 0

Recommended Practice

Approach 1 (Using linear search): This problem can be solved using linear search.

If we take a closer look at examples, we can notice that the number of rotations is equal to the index of the minimum element. A simple linear solution is to find the minimum element and returns its index.

Illustration:

Consider the array arr[]={15, 18, 2, 3, 6, 12};
Initially minimum = 15, min_index = 0

At i = 1: min = 15, min_index = 0
At i = 2: min = min(2, 15) = 2, min_index = 2
At i = 3: min = 2, min_index = 2
At i = 4: min = 2, min_index = 2
At i = 5: min = 2, min_index = 2

The array is rotated twice to the right

Follow the steps mentioned below to implement the idea:

• Initialize two variables to store the minimum value and the index of that value.
• Traverse the array from start to the end:
• Find the minimum value and index where the minimum value is stored.
• Return the index of the minimum value.

Below is the code implementation of the above idea.

## C++

 `// C++ program to find number of rotations``// in a sorted and rotated array.``#include ``using` `namespace` `std;` `// Returns count of rotations for an array which``// is first sorted in ascending order, then rotated``int` `countRotations(``int` `arr[], ``int` `n)``{``    ``// We basically find index of minimum``    ``// element``    ``int` `min = arr, min_index = 0;``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(min > arr[i]) {``            ``min = arr[i];``            ``min_index = i;``        ``}``    ``}``    ``return` `min_index;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 15, 18, 2, 3, 6, 12 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << countRotations(arr, n);``    ``return` `0;``}` `// This code is contributed by Adutya Kumar(adityakumar129)`

## C

 `// C program to find number of rotations``// in a sorted and rotated array.``#include ` `// Returns count of rotations for an array which``// is first sorted in ascending order, then rotated``int` `countRotations(``int` `arr[], ``int` `n)``{``    ``// We basically find index of minimum``    ``// element``    ``int` `min = arr, min_index = 0;``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(min > arr[i]) {``            ``min = arr[i];``            ``min_index = i;``        ``}``    ``}``    ``return` `min_index;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 15, 18, 2, 3, 6, 12 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``printf``(``"%d"``, countRotations(arr, n));``    ``return` `0;``}` `// This code is contributed by Adutya Kumar(adityakumar129)`

## Java

 `// Java program to find number of``// rotations in a sorted and rotated``// array.``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `LinearSearch {``    ``// Returns count of rotations for an``    ``// array which is first sorted in``    ``// ascending order, then rotated``    ``static` `int` `countRotations(``int` `arr[], ``int` `n)``    ``{``        ``// We basically find index of minimum``        ``// element``        ``int` `min = arr[``0``], min_index = ``0``;``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``if` `(min > arr[i]) {``                ``min = arr[i];``                ``min_index = i;``            ``}``        ``}``        ``return` `min_index;``    ``}` `    ``// Driver program to test above functions``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``15``, ``18``, ``2``, ``3``, ``6``, ``12` `};``        ``int` `n = arr.length;` `        ``System.out.println(countRotations(arr, n));``    ``}``}` `// This code is contributed by Adutya Kumar(adityakumar129)`

## Python3

 `# Python3 program to find number``# of rotations in a sorted and``# rotated array.` `# Returns count of rotations for``# an array which is first sorted``# in ascending order, then rotated``def` `countRotations(arr, n):` `    ``# We basically find index``    ``# of minimum element``    ``min` `=` `arr[``0``]``    ``min_index ``=` `0``    ``for` `i ``in` `range``(``0``, n):``    ` `        ``if` `(``min` `> arr[i]):``        ` `            ``min` `=` `arr[i]``            ``min_index ``=` `i``        ` `    ``return` `min_index;`  `# Driver code``arr ``=` `[``15``, ``18``, ``2``, ``3``, ``6``, ``12``]``n ``=` `len``(arr)``print``(countRotations(arr, n))` `# This code is contributed by Smitha Dinesh Semwal`

## C#

 `// c# program to find number of``// rotations in a sorted and rotated``// array.``using` `System;` `class` `LinearSearch``{``    ``// Returns count of rotations for an``    ``// array which is first sorted in``    ``// ascending order, then rotated``    ``static` `int` `countRotations(``int` `[]arr, ``int` `n)``    ``{``        ``// We basically find index of minimum``        ``// element``        ``int` `min = arr, min_index = 0;``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``if` `(min > arr[i])``            ``{``                ``min = arr[i];``                ``min_index = i;``            ``}``        ``}``        ``return` `min_index;``    ``}` `    ``// Driver program to test above functions``    ``public` `static` `void` `Main ()``    ``{``        ``int` `[]arr = {15, 18, 2, 3, 6, 12};``        ``int` `n = arr.Length;``    ` `    ``Console.WriteLine(countRotations(arr, n));``    ``}``}``// This code is contributed by vt_m.`

## PHP

 ` ``\$arr``[``\$i``])``        ``{``            ``\$min` `= ``\$arr``[``\$i``];``            ``\$min_index` `= ``\$i``;``        ``}``    ``}``    ``return` `\$min_index``;``}` `// Driver code``\$arr` `= ``array``(15, 18, 2,``             ``3, 6, 12);``\$n` `= sizeof(``\$arr``);``echo` `countRotations(``\$arr``, ``\$n``);` `// This code is contributed``// by ajit``?>`

## Javascript

 ``

Output

`2`

Time Complexity: O(N)
Auxiliary Space: O(1)

Another Approach: (Using Linear Search):

The idea is to first check if the array is rotated 0 times, then return the index when the element is greater than the next element.

Follow the steps mentioned below to implement the idea:

• Check if the array is rotated:
• Traverse the array from 0 till N:
• Return index + 1,  when the current element is greater than the next element.
• Else return 0.

Below is the code implementation of the above idea.

## C++

 `#include ``using` `namespace` `std;` `int` `countRotations(``int` `arr[], ``int` `n)``{` `    ``// Check is array is rotated``    ``if` `(arr > arr[n - 1]) {` `        ``// Traverse the array``        ``for` `(``int` `i = 0; i < n; i++) {` `            ``// Index where element is greater``            ``// than the next element``            ``if` `(arr[i] > arr[i + 1])``                ``return` `i + 1;``        ``}``    ``}` `    ``// Array is not rotated``    ``return` `0;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 15, 18, 2, 3, 6, 12 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << countRotations(arr, n);``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;` `class` `GFG {``  ``static` `int` `countRotations(``int` `arr[], ``int` `n)``  ``{` `    ``// Check is array is rotated``    ``if` `(arr[``0``] > arr[n - ``1``]) {` `      ``// Traverse the array``      ``for` `(``int` `i = ``0``; i < n; i++) {` `        ``// Index where element is greater``        ``// than the next element``        ``if` `(arr[i] > arr[i + ``1``])``          ``return` `i + ``1``;``      ``}``    ``}` `    ``// Array is not rotated``    ``return` `0``;``  ``}` `  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `arr[] = { ``15``, ``18``, ``2``, ``3``, ``6``, ``12` `};``    ``int` `n = arr.length;``    ``System.out.println(countRotations(arr, n));``  ``}``}` `// This code is contributed by dhanshriborse561`

## Python3

 `def` `countRotations(arr, n):``    ``# Check is array is rotated``    ``if` `(arr[``0``] > arr[n ``-` `1``]):` `        ``# Traverse the array``        ``for` `i ``in` `range``(``0``, n):` `            ``# Index where element is greater``            ``# than the next element``            ``if` `(arr[i] > arr[i ``+` `1``]):``                ``return` `i ``+` `1` `    ``# Array is not rotated``    ``return` `0` `# Driver code``arr ``=` `[``15``, ``18``, ``2``, ``3``, ``6``, ``12``]``n ``=` `len``(arr)``print``(countRotations(arr, n))` `# This code is contributed by karandeep1234`

## C#

 `// Include namespace system``using` `System;` `public` `class` `GFG``{``  ``public` `static` `int` `countRotations(``int``[] arr, ``int` `n)``  ``{``    ``// Check is array is rotated``    ``if` `(arr > arr[n - 1])``    ``{``      ``// Traverse the array``      ``for` `(``int` `i = 0; i < n; i++)``      ``{``        ``// Index where element is greater``        ``// than the next element``        ``if` `(arr[i] > arr[i + 1])``        ``{``          ``return` `i + 1;``        ``}``      ``}``    ``}``    ``// Array is not rotated``    ``return` `0;``  ``}``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int``[] arr = {15, 18, 2, 3, 6, 12};``    ``var` `n = arr.Length;``    ``Console.WriteLine(GFG.countRotations(arr, n));``  ``}``}` `// This code is contributed by aadityaburujwale.`

## Javascript

 `// JS code to implement the approach``function` `countRotations(arr, n) {` `    ``// Check is array is rotated``    ``if` `(arr > arr[n - 1]) {` `        ``// Traverse the array``        ``for` `(let i = 0; i < n; i++) {` `            ``// Index where element is greater``            ``// than the next element``            ``if` `(arr[i] > arr[i + 1])``                ``return` `i + 1;``        ``}``    ``}` `    ``// Array is not rotated``    ``return` `0;``}` `// Driver code``let arr = [15, 18, 2, 3, 6, 12];``let n = arr.length;``console.log(countRotations(arr, n));` `// This code is contributed by adityamaharshi21`

Output

`2`

Time Complexity: O(N)
Auxiliary Space: O(1)

Approach 2: (Efficient Using Binary Search)

A better approach would be to perform binary searching, in place of linear search to find the position of the smallest element in the array.

Follow the steps mentioned below to implement the idea:

• The minimum element is the only element whose previous is greater than it. If there is no previous element, then there is no rotation (the first element is minimum).
• Check this condition for the middle element by comparing it with the (mid-1)th and (mid+1)th elements.
• If the minimum element is not at the middle (neither mid nor mid + 1), then
• If the middle element is smaller than the last element, then the minimum element lies in the left half
• Else minimum element lies in the right half.

Illustration:

Let the array be arr[]={15, 18, 2, 3, 6, 12}
low = 0 , high = 5.
=>  mid = 2
=>  arr[mid]=2 , arr[mid-1] > arr[mid] , hence condition is matched
=>  The required index = mid = 2

So the element is  found at index 2.

Below is the implementation of the above approach.

## C++

 `// Binary Search based C++ program to find number``// of rotations in a sorted and rotated array.``#include ``using` `namespace` `std;` `// Returns count of rotations for an array which``// is first sorted in ascending order, then rotated``int` `countRotations(``int` `arr[], ``int` `low, ``int` `high)``{``    ``// This condition is needed to handle the case``    ``// when the array is not rotated at all``    ``if` `(high < low)``        ``return` `0;` `    ``// If there is only one element left``    ``if` `(high == low)``        ``return` `low;` `    ``// Find mid``    ``int` `mid = low + (high - low) / 2; ``/*(low + high)/2;*/` `    ``// Check if element (mid+1) is minimum element.``    ``// Consider the cases like {3, 4, 5, 1, 2}``    ``if` `(mid < high && arr[mid + 1] < arr[mid])``        ``return` `(mid + 1);` `    ``// Check if mid itself is minimum element``    ``if` `(mid > low && arr[mid] < arr[mid - 1])``        ``return` `mid;` `    ``// Decide whether we need to go to left half or``    ``// right half``    ``if` `(arr[high] > arr[mid])``        ``return` `countRotations(arr, low, mid - 1);` `    ``return` `countRotations(arr, mid + 1, high);``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 15, 18, 2, 3, 6, 12 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << countRotations(arr, 0, N - 1);``    ``return` `0;``}`

## Java

 `// Java program to find number of``// rotations in a sorted and rotated``// array.``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `BinarySearch {``    ``// Returns count of rotations for an array``    ``// which is first sorted in ascending order,``    ``// then rotated``    ``static` `int` `countRotations(``int` `arr[], ``int` `low, ``int` `high)``    ``{``        ``// This condition is needed to handle``        ``// the case when array is not rotated``        ``// at all``        ``if` `(high < low)``            ``return` `0``;` `        ``// If there is only one element left``        ``if` `(high == low)``            ``return` `low;` `        ``// Find mid``        ``// /*(low + high)/2;*/``        ``int` `mid = low + (high - low) / ``2``;` `        ``// Check if element (mid+1) is minimum``        ``// element. Consider the cases like``        ``// {3, 4, 5, 1, 2}``        ``if` `(mid < high && arr[mid + ``1``] < arr[mid])``            ``return` `(mid + ``1``);` `        ``// Check if mid itself is minimum element``        ``if` `(mid > low && arr[mid] < arr[mid - ``1``])``            ``return` `mid;` `        ``// Decide whether we need to go to left``        ``// half or right half``        ``if` `(arr[high] > arr[mid])``            ``return` `countRotations(arr, low, mid - ``1``);` `        ``return` `countRotations(arr, mid + ``1``, high);``    ``}` `    ``// Driver program to test above functions``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``15``, ``18``, ``2``, ``3``, ``6``, ``12` `};``        ``int` `N = arr.length;` `        ``System.out.println(countRotations(arr, ``0``, N - ``1``));``    ``}``}``// This code is contributed by Chhavi`

## Python3

 `# Binary Search based Python3``# program to find number of``# rotations in a sorted and``# rotated array.` `# Returns count of rotations for``# an array which is first sorted``# in ascending order, then rotated` `def` `countRotations(arr, n):``    ``start ``=` `0``    ``end ``=` `n``-``1` `    ``# Finding the index of minimum of the array``    ``# index of min would be equal to number to rotation``    ``while` `start<``=``end:``        ``mid ``=` `start``+``(end``-``start)``/``/``2``        ` `        ``# Calculating the previous(prev)``        ``# and next(nex) index of mid``        ``prev ``=` `(mid``-``1``+``n)``%``n``        ``nex ``=` `(mid``+``1``)``%``n` `        ``# Checking if mid is minimum``        ``if` `arr[mid]arr[end]: start ``=` `mid``+``1``        ``else``: ``return` `0` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``15``, ``18``, ``2``, ``3``, ``6``, ``12``]``    ``N ``=` `len``(arr)``    ``print``(countRotations(arr, N))` `# This code is contributed by Smitha Dinesh Semwal`

## C#

 `// C# program to find number of``// rotations in a sorted and rotated``// array.``using` `System;` `class` `BinarySearch {``    ``// Returns count of rotations for an array``    ``// which is first sorted in ascending order,``    ``// then rotated``    ``static` `int` `countRotations(``int``[] arr, ``int` `low, ``int` `high)``    ``{``        ``// This condition is needed to handle``        ``// the case when array is not rotated``        ``// at all``        ``if` `(high < low)``            ``return` `0;` `        ``// If there is only one element left``        ``if` `(high == low)``            ``return` `low;` `        ``// Find mid``        ``// /*(low + high)/2;*/``        ``int` `mid = low + (high - low) / 2;` `        ``// Check if element (mid+1) is minimum``        ``// element. Consider the cases like``        ``// {3, 4, 5, 1, 2}``        ``if` `(mid < high && arr[mid + 1] < arr[mid])``            ``return` `(mid + 1);` `        ``// Check if mid itself is minimum element``        ``if` `(mid > low && arr[mid] < arr[mid - 1])``            ``return` `mid;` `        ``// Decide whether we need to go to left``        ``// half or right half``        ``if` `(arr[high] > arr[mid])``            ``return` `countRotations(arr, low, mid - 1);` `        ``return` `countRotations(arr, mid + 1, high);``    ``}` `    ``// Driver program to test above functions``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 15, 18, 2, 3, 6, 12 };``        ``int` `N = arr.Length;` `        ``Console.WriteLine(countRotations(arr, 0, N - 1));``    ``}``}``// This code is contributed by vt_m.`

## PHP

 ` ``\$low` `&&``        ``\$arr``[``\$mid``] < ``\$arr``[``\$mid` `- 1])``    ``return` `(int)(``\$mid``);` `    ``// Decide whether we need``    ``// to go to left half or``    ``// right half``    ``if` `(``\$arr``[``\$high``] > ``\$arr``[``\$mid``])``    ``return` `countRotations(``\$arr``, ``\$low``,``                          ``\$mid` `- 1);` `    ``return` `countRotations(``\$arr``,``                          ``\$mid` `+ 1,``                          ``\$high``);``}` `// Driver code``\$arr` `= ``array``(15, 18, 2, 3, 6, 12);``\$N` `= sizeof(``\$arr``);``echo` `countRotations(``\$arr``, 0, ``\$N` `- 1);` `// This code is contributed bu ajit``?>`

## Javascript

 ``

Output

`2`

Time Complexity: O(log N)
Auxiliary Space: O(log N)  [this is the space of recursion stack]

Iterative Code (Binary Search):

## C++

 `#include ``using` `namespace` `std;` `// Returns count of rotations``// for an array which is first sorted``// in ascending order, then rotated` `// Observation: We have to return``// index of the smallest element``int` `countRotations(``int` `arr[], ``int` `n)``{``    ``int` `low = 0, high = n - 1;``    ``if` `(arr[low] <= arr[high])``        ``return` `0;``    ``/*returns 0 if array is already sorted*/``    ``while` `(low <= high) {` `        ``// if first element is mid or``        ``// last element is mid``        ``// then simply use modulo so it``        ``// never goes out of bound.``        ``int` `mid = low + (high - low) / 2;``        ``int` `prev = (mid - 1 + n) % n;``        ``int` `next = (mid + 1) % n;` `        ``if` `(arr[mid] <= arr[prev] && arr[mid] <= arr[next])``            ``return` `mid;``        ``else` `if` `(arr[mid] <= arr[high])``            ``high = mid - 1;``        ``else` `if` `(arr[mid] >= arr)``            ``low = mid + 1;``    ``}``    ``return` `0;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 15, 18, 2, 3, 6, 12 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << countRotations(arr, n);``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;` `class` `GFG {``    ``// Returns count of rotations``    ``// for an array which is first sorted``    ``// in ascending order, then rotated` `    ``// Observation: We have to return``    ``// index of the smallest element``    ``static` `int` `countRotations(``int``[] arr, ``int` `n)``    ``{``        ``int` `low = ``0``, high = n - ``1``;``        ``while` `(low <= high) {` `            ``// if first element is mid or``            ``// last element is mid``            ``// then simply use modulo so it``            ``// never goes out of bound.``            ``int` `mid = low + (high - low) / ``2``;``            ``int` `prev = (mid - ``1` `+ n) % n;``            ``int` `next = (mid + ``1``) % n;` `            ``if` `(arr[mid] <= arr[prev]``                ``&& arr[mid] <= arr[next])``                ``return` `mid;``            ``else` `if` `(arr[mid] <= arr[high])``                ``high = mid - ``1``;``            ``else` `if` `(arr[mid] >= arr[low])``                ``low = mid + ``1``;``        ``}``        ``return` `0``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{` `        ``int``[] arr = { ``15``, ``18``, ``2``, ``3``, ``6``, ``12` `};``        ``int` `n = arr.length;``        ``System.out.println(countRotations(arr, n));``    ``}``}` `// This code is contributed by shinjanpatra`

## Python3

 `# Returns count of rotations for an array which``# is first sorted in ascending order, then rotated` `# Observation: We have to return index of the smallest element`  `def` `countRotations(arr, n):` `    ``low ``=` `0``    ``high ``=` `n ``-` `1``    ``while``(low <``=` `high):` `        ``# if first element is mid or``        ``# last element is mid``        ``# then simply use modulo``        ``# so it never goes out of bound.``        ``mid ``=` `low ``+` `((high ``-` `low) ``/``/` `2``)``        ``prev ``=` `(mid ``-` `1` `+` `n) ``%` `n``        ``next` `=` `(mid ``+` `1``) ``%` `n` `        ``if``(arr[mid] <``=` `arr[prev]``           ``and` `arr[mid] <``=` `arr[``next``]):``            ``return` `mid``        ``elif` `(arr[mid] <``=` `arr[high]):``            ``high ``=` `mid ``-` `1``        ``elif` `(arr[mid] >``=` `arr[low]):``            ``low ``=` `mid ``+` `1``    ``return` `0` `# Driver code`  `arr ``=` `[``15``, ``18``, ``2``, ``3``, ``6``, ``12``]``n ``=` `len``(arr)``print``(countRotations(arr, n))` `# This code is contributed by shinjanpatra.`

## C#

 `// C# program for the above approach` `using` `System;` `class` `GFG {``    ``// Returns count of rotations``    ``// for an array which is first sorted``    ``// in ascending order, then rotated` `    ``// Observation: We have to return``    ``// index of the smallest element``    ``static` `int` `countRotations(``int``[] arr, ``int` `n)``    ``{``        ``int` `low = 0, high = n - 1;``        ``while` `(low <= high) {` `            ``// if first element is mid or``            ``// last element is mid``            ``// then simply use modulo so it``            ``// never goes out of bound.``            ``int` `mid = low + (high - low) / 2;``            ``int` `prev = (mid - 1 + n) % n;``            ``int` `next = (mid + 1) % n;` `            ``if` `(arr[mid] <= arr[prev]``                ``&& arr[mid] <= arr[next])``                ``return` `mid;``            ``else` `if` `(arr[mid] <= arr[high])``                ``high = mid - 1;``            ``else` `if` `(arr[mid] >= arr[low])``                ``low = mid + 1;``        ``}``        ``return` `0;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{` `        ``int``[] arr = { 15, 18, 2, 3, 6, 12 };``        ``int` `n = arr.Length;``        ``Console.Write(countRotations(arr, n));``    ``}``}` `// This code is contributed by saurabh_jaiswal.`

## Javascript

 ``

Output

`2`

Time Complexity: O(log N)
Auxiliary Space: O(1), since no extra space has been taken.

This article is contributed by Rakesh Kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.