leetcode/apps/docs/content/(01-linear-structures)/binary-search/33-search-in-rotated-sorted-array.mdx

---
title: '33. Search in Rotated Sorted Array'
description: There is an integer array nums sorted in ascending order (with distinct values)
icon: dot
topics:
  - { name: "Array", slug: "array" }
  - { name: "Binary Search", slug: "binary-search" }
video: "U8XENwh8Oy8"
sidebar:
  label: 'Search in Rotated Sorted Array'
  badge: 'Medium'
---

::::warning
You must write an algorithm with O(log n) runtime complexity.
::::

### Example 1:
- Input: `nums = [4,5,6,7,0,1,2], target = 0`
- Output: `4`

### Example 2:
- Input: `nums = [4,5,6,7,0,1,2], target = 3`
- Output: `-1`

### Example 3:
- Input: `nums = [1], target = 0`
- Output: `-1`

### Constraints:

- `1 <= nums.length <= 5000`
- `-10^4 <= nums[i] <= 10^4`
- All values of `nums` are unique.
- `nums` is an ascending array that is possibly rotated.
- `-10^4 <= target <= 10^4`

## Approach

```mermaid
flowchart TD
  S(["search(nums, target)"]) --> I["l = 0, r = n - 1"]
  I --> W{"l <= r?"}
  W -- no --> E(["return -1"])
  W -- yes --> M["mid = floor((l + r) / 2)"]
  M --> F{"nums[mid] == target?"}
  F -- yes --> R(["return mid"])
  F -- no --> H{"nums[l] <= nums[mid]? — left half sorted"}
  H -- yes --> A{"target outside [nums[l], nums[mid]]?"}
  A -- yes --> A1["l = mid + 1 — search the right half"]
  A -- no --> A2["r = mid - 1"]
  H -- no --> B{"target outside [nums[mid], nums[r]]?"}
  B -- yes --> B1["r = mid - 1 — search the left half"]
  B -- no --> B2["l = mid + 1"]
  A1 --> W
  A2 --> W
  B1 --> W
  B2 --> W
```

## Solution

```js
/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
  let l = 0, r = nums.length - 1;   

  while (l <= r){
    let mid = Math.floor((l + r)/2);
    if (target === nums[mid]) {
      return mid
    }

    // Left sorted portion
    if (nums[l] <= nums[mid]){
      if (target > nums[mid] || target < nums[l]){
        l = mid + 1;
      }else{
        r = mid - 1;
      }
    }
    // Right sorted portion
    else{
      if(target < nums[mid] || target > nums[r]){
        r = mid - 1; 
      }else{
        l = mid + 1;
      }
    }
  }
  return -1;
};
```