Search in Rotated Sorted Array in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a rotated sorted array?

A rotated sorted array is an array that was originally sorted in ascending order but then rotated (shifted) at some pivot point. For example, [4,5,6,7,0,1,2] is a rotated version of [0,1,2,4,5,6,7].

beginner

Why can't we use simple binary search directly on a rotated sorted array?

Because the array is not fully sorted in ascending order due to rotation, simple binary search may fail. The array has two sorted parts separated by the pivot, so we need to identify which part to search in.

intermediate

What is the main idea to search in a rotated sorted array using binary search?

At each step, check which half (left or right) is sorted. Then decide if the target lies in the sorted half or the other half. Narrow down the search accordingly until the target is found or the search space is empty.

beginner

In the C code for searching in a rotated sorted array, what variables are used to track the search range?

Two variables, usually named 'left' and 'right', track the current search range indices. 'mid' is calculated as the middle index between 'left' and 'right'.

beginner

What is the time complexity of searching in a rotated sorted array using binary search?

The time complexity is O(log n) because the search space is halved at each step, similar to normal binary search.

What does the 'pivot' in a rotated sorted array represent?

A The largest element's index

B The smallest element's index where rotation happened

C The middle element of the array

D The first element of the array

The pivot is the index where the smallest element is located, marking the rotation point.

If the left half of the array is sorted, how do we decide to search there?

A If target is between left and mid elements inclusive

B If target is greater than mid element

C If target is less than left element

D Always search left half

We check if the target lies between the left and mid elements to decide if we search the left half.

What happens if the target is not found after the search range is empty?

A Return the last mid index

B Return 0

C Return -1 indicating target not found

D Restart the search

Returning -1 indicates the target is not present in the array.

Which of these arrays is a rotated sorted array?

A [3,4,5,1,2]

B [1,2,3,4,5]

C [5,4,3,2,1]

D [2,3,1,5,4]

Array [3,4,5,1,2] is a rotated sorted array; it was originally sorted and then rotated.

What is the first step in the binary search on a rotated sorted array?

A Return -1 immediately

B Sort the array

C Check if array is empty

D Calculate mid index and check if mid is target

We calculate mid and check if it matches the target before deciding which half to search.

Explain how binary search is adapted to find a target in a rotated sorted array.

Think about how to decide which half to search based on sorted order.

Describe the role of 'left', 'right', and 'mid' pointers in the search algorithm for rotated sorted arrays.

Consider how these pointers help divide the array.

Practice

1. What is the main challenge when searching for an element in a rotated sorted array compared to a normal sorted array?

easy

A. The array is not fully sorted, so normal binary search cannot be directly applied

B. The array contains duplicate elements

C. The array size is unknown

D. The array elements are all negative

Solution

1. Step 1: Understand sorted vs rotated sorted array

   A normal sorted array is fully sorted in ascending order, but a rotated sorted array is a sorted array shifted at some pivot point, breaking the full order.

2. Step 2: Impact on binary search

   Binary search requires a fully sorted array to decide which half to search next. In a rotated array, this condition breaks, so normal binary search cannot be directly applied.

3. Final Answer:

   The array is not fully sorted, so normal binary search cannot be directly applied -> Option A

4. Quick Check:

   Rotated array breaks full sort = normal binary search fails [OK]

Hint: Rotated array breaks order; normal binary search fails [OK]

Common Mistakes:

• Assuming array is fully sorted
• Ignoring the pivot point
• Thinking duplicates cause the main issue

2. Which of the following is the correct way to check if the middle element is in the left sorted portion of a rotated sorted array in C?

easy

A. if (arr[mid] > arr[end])

B. if (arr[mid] >= arr[start])

C. if (arr[mid] <= arr[start])

D. if (arr[mid] < arr[end])

Solution

1. Step 1: Understand left sorted portion condition

   If the middle element is greater than or equal to the start element, it means mid is in the left sorted portion because left side is sorted ascending.

2. Step 2: Translate condition to code

   The condition is written as if (arr[mid] >= arr[start]) in C to check this.

3. Final Answer:

   if (arr[mid] >= arr[start]) -> Option B

4. Quick Check:

   Mid >= start means left sorted [OK]

Hint: Check if mid >= start to find left sorted part [OK]

Common Mistakes:

• Using <= instead of > or >=
• Comparing mid with end incorrectly
• Confusing left and right sorted parts

3. What will be the output of the following C code snippet?

int arr[] = {6,7,8,1,2,3,4,5};
int n = 8;
int target = 3;
int start = 0, end = n - 1;
int mid;
while (start <= end) {
    mid = (start + end) / 2;
    if (arr[mid] == target) {
        printf("%d", mid);
        break;
    }
    if (arr[start] <= arr[mid]) {
        if (target >= arr[start] && target < arr[mid])
            end = mid - 1;
        else
            start = mid + 1;
    } else {
        if (target > arr[mid] && target <= arr[end])
            start = mid + 1;
        else
            end = mid - 1;
    }
}

medium

A. 6

B. 3

C. 2

D. 5

Solution

1. Step 1: Trace the binary search on rotated array

   Initial array: [6,7,8,1,2,3,4,5], target=3. Start=0, end=7. - mid=(0+7)/2=3, arr[3]=1, not target. - arr[start]=6 > arr[mid]=1, so right half is sorted. - target=3 > arr[mid]=1 and target <= arr[end]=5, so start=mid+1=4. - Now start=4, end=7. - mid=(4+7)/2=5, arr[5]=3 matches target.

2. Step 2: Output the index

   Index 5 is printed as the target is found at arr[5].

3. Final Answer:

   5 -> Option D

4. Quick Check:

   Target 3 found at index 5 [OK]

Hint: Trace mid and adjust start/end carefully [OK]

Common Mistakes:

• Not updating start/end correctly
• Confusing which half is sorted
• Wrong mid calculation

4. Identify the bug in the following C code snippet that searches for a target in a rotated sorted array:

int search(int arr[], int n, int target) {
    int start = 0, end = n - 1;
    while (start < end) {
        int mid = (start + end) / 2;
        if (arr[mid] == target) return mid;
        if (arr[start] <= arr[mid]) {
            if (target >= arr[start] && target < arr[mid])
                end = mid - 1;
            else
                start = mid + 1;
        } else {
            if (target > arr[mid] && target <= arr[end])
                start = mid + 1;
            else
                end = mid - 1;
        }
    }
    return -1;
}

medium

A. The target comparison should use > instead of >=

B. The mid calculation should be mid = start + (end - start) / 2

C. The loop condition should be start <= end instead of start < end

D. The function should return start instead of -1 when not found

Solution

1. Step 1: Analyze loop condition impact

   The loop uses while (start < end), which misses the case when start == end. This can skip checking the last element, causing incorrect -1 return even if target is present.

2. Step 2: Correct loop condition

   Changing to while (start <= end) ensures the last element is checked, preventing missed targets.

3. Final Answer:

   The loop condition should be start <= end instead of start < end -> Option C

4. Quick Check:

   Loop must include start == end to check all elements [OK]

Hint: Use start <= end to cover all elements [OK]

Common Mistakes:

• Ignoring last element check
• Thinking mid calculation causes bug
• Returning wrong index on failure

5. Given a rotated sorted array with possible duplicates, which modification is necessary to correctly search for a target element?

hard

A. Add extra checks to skip duplicates when arr[start] == arr[mid] == arr[end]

B. Use linear search instead of binary search

C. Ignore duplicates and apply normal rotated array search

D. Sort the array before searching

Solution

1. Step 1: Understand duplicates impact on rotated search

   Duplicates can cause ambiguity in deciding which half is sorted because arr[start], arr[mid], and arr[end] can be equal, breaking the binary search logic.

2. Step 2: Modify search to handle duplicates

   When arr[start] == arr[mid] == arr[end], increment start and decrement end to skip duplicates and continue search safely.

3. Step 3: Avoid linear search or sorting

   Linear search is inefficient; sorting changes array and is not allowed. Proper duplicate handling preserves binary search efficiency.

4. Final Answer:

   Add extra checks to skip duplicates when arr[start] == arr[mid] == arr[end] -> Option A

5. Quick Check:

   Skip duplicates when start=mid=end to continue search [OK]

Hint: Skip duplicates when start, mid, end equal [OK]

Common Mistakes:

• Ignoring duplicates cause wrong half detection
• Switching to linear search unnecessarily
• Sorting array before search