Search in Rotated Sorted Array

The problem of searching in a rotated sorted array is a fascinating and common question in computer science, particularly in the realm of algorithms and data structures. To understand this problem thoroughly, we will break it down using first principles.

Understanding the Problem

First, let's define what a "rotated sorted array" is:

  1. Sorted Array: A sorted array is an array where the elements are in a specific order (usually ascending or descending). For example, [1, 2, 3, 4, 5] is a sorted array in ascending order.

  2. Rotated Array: Imagine taking an array and "rotating" it. This means taking some elements from the beginning and moving them to the end while keeping the order of the elements intact. For example, if we take [1, 2, 3, 4, 5] and rotate it at the third position, we get [4, 5, 1, 2, 3].

The Search Problem

Now, the problem is to find a specific element in this rotated sorted array. The challenge comes from the fact that the array is no longer fully sorted in the traditional sense due to the rotation, which disrupts the order.

Approach to the Solution

To solve this, we can use a modified version of binary search. Binary search is a highly efficient algorithm used to find an element in a sorted array, working on the principle of dividing the search interval in half with each step. However, in a rotated array, we need to determine which part of the array to apply binary search to, as one part of the array remains sorted after rotation.

Here's a step-by-step approach:

  1. Find the Pivot: The "pivot" is the point where the array was rotated. In our example [4, 5, 1, 2, 3], the pivot is the number 1. The elements to the left and right of the pivot are sorted in ascending order.

  2. Determine the Search Interval:

    • Check if the target element is within the sorted half of the array.
    • If the target is greater than the first element of the array, it lies in the left (higher) side of the pivot.
    • If the target is less, it's on the right (lower) side of the pivot.
  3. Apply Binary Search:

    • Perform binary search in the determined half of the array.
    • If the element is found, return its index.
    • If not, return an indication that the element is not present (like -1).


  • Time Complexity: O(log n), where n is the number of elements in the array. This is because the binary search halves the search space with each step.
  • Space Complexity: O(1), as the search is performed in place without using additional storage.


Let's consider an example to clarify:

  • Array: [6, 7, 8, 1, 2, 3, 4, 5]
  • Target: 3
  1. The pivot here is 1. The array is rotated at this point.
  2. 3 is less than 6 (first element), so it lies in the right half of the pivot.
  3. Apply binary search in the interval [1, 2, 3, 4, 5].
  4. Find and return the index of 3.

In summary, searching in a rotated sorted array requires modifying the traditional binary search to accommodate the effect of rotation. This involves identifying the pivot and determining the correct half of the array to apply binary search, making it an interesting problem that tests one's understanding of binary search and array manipulation.