Search in Rotated Sorted Array in DSA Rust - Build from Scratch

Search in Rotated Sorted Array

📖 Scenario: You have a list of numbers that was originally sorted but then rotated at some unknown point. For example, a sorted list like [1, 2, 3, 4, 5] might become [4, 5, 1, 2, 3]. You want to find if a specific number exists in this rotated list.

🎯 Goal: Build a Rust program that searches for a target number in a rotated sorted array and returns its index if found, or -1 if not found.

📋 What You'll Learn

Create a vector called nums with the exact values [4, 5, 6, 7, 0, 1, 2]

Create a variable called target and set it to 0

Implement a function called search_rotated that takes nums and target as parameters and returns the index of target in nums or -1 if not found

Use binary search logic adapted for rotated sorted arrays inside search_rotated

Print the result of calling search_rotated(&nums, target)

💡 Why This Matters

🌍 Real World

Rotated sorted arrays appear in systems where data is shifted or rotated, such as circular buffers or rotated logs. Efficient searching in such arrays is important for fast data retrieval.

💼 Career

Understanding how to search in rotated sorted arrays is a common interview question and helps develop problem-solving skills for software engineering roles.

1

Create the rotated sorted array

Create a vector called nums with the exact values [4, 5, 6, 7, 0, 1, 2]

DSA Rust

# Create the vector nums with the given values
# Your code here

Hint

Use let nums = vec![4, 5, 6, 7, 0, 1, 2]; to create the vector.

2

Set the target value to search

Create a variable called target and set it to 0

DSA Rust

fn main() {
    let nums = vec![4, 5, 6, 7, 0, 1, 2];
    // Create the variable target and set it to 0
    // Your code here
}

Hint

Use let target = 0; to create the target variable.

3

Implement the search function

Implement a function called search_rotated that takes nums: &Vec and target: i32 as parameters and returns an i32. Use binary search logic adapted for rotated sorted arrays inside search_rotated.

DSA Rust

fn main() {
    let nums = vec![4, 5, 6, 7, 0, 1, 2];
    let target = 0;
}

// Implement search_rotated function here
// Your code here

Hint

Use a while loop with left and right pointers. Compare nums[mid] with target and adjust pointers based on rotated sorted array logic.

4

Print the search result

Print the result of calling search_rotated(&nums, target) inside the main function.

DSA Rust

fn main() {
    let nums = vec![4, 5, 6, 7, 0, 1, 2];
    let target = 0;
    // Print the result of search_rotated(&nums, target) here
    // Your code here
}

fn search_rotated(nums: &Vec, target: i32) -> i32 {
    let mut left = 0;
    let mut right = nums.len() as i32 - 1;

    while left <= right {
        let mid = left + (right - left) / 2;
        let mid_val = nums[mid as usize];

        if mid_val == target {
            return mid;
        }

        if nums[left as usize] <= mid_val {
            if nums[left as usize] <= target && target < mid_val {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        } else {
            if mid_val < target && target <= nums[right as usize] {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }

    -1
}

Hint

Use println!("{}", index); to print the index returned by search_rotated.

Practice

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

easy

A. The array size is unknown

B. The array contains duplicate elements

C. The array is sorted in descending order

D. The array is split into two sorted parts, making direct binary search tricky

Solution

1. Step 1: Understand the array structure

   A rotated sorted array is originally sorted but then rotated at some pivot, splitting it into two sorted parts.

2. Step 2: Impact on search

   This split means a normal binary search can't be applied directly because the order is disrupted at the pivot.

3. Final Answer:

   The array is split into two sorted parts, making direct binary search tricky -> Option D

4. Quick Check:

   Rotated array = two sorted parts [OK]

Hint: Look for the pivot splitting the array into two sorted halves [OK]

Common Mistakes:

• Assuming the array is fully sorted without rotation
• Ignoring the pivot point in the array
• Thinking duplicates cause the main challenge
• Confusing descending order with rotation

2. Which Rust code snippet correctly declares a function signature to search a target in a rotated sorted array?

easy

A. fn search(nums: &[i32], target: i32) -> Option<usize>

B. fn search(nums: Vec<i32>, target: i32) -> usize

C. fn search(nums: &Vec<i32>, target: i32) -> bool

D. fn search(nums: &[i32], target: i32) -> i32

Solution

1. Step 1: Analyze parameter types

   Using a slice &[i32] is efficient and idiomatic for read-only array input in Rust.

2. Step 2: Analyze return type

   Returning Option<usize> allows indicating if the target was found (Some(index)) or not (None).

3. Final Answer:

   fn search(nums: &[i32], target: i32) -> Option<usize> -> Option A

4. Quick Check:

   Slice input + Option return = fn search(nums: &[i32], target: i32) -> Option<usize> [OK]

Hint: Use &[i32] for input and Option<usize> for index result [OK]

Common Mistakes:

• Using Vec<i32> unnecessarily copies data
• Returning usize without Option loses 'not found' info
• Returning bool loses index information
• Returning i32 index can be ambiguous

3. Given the Rust function below, what is the output when searching for target 3?

fn search(nums: &[i32], target: i32) -> Option<usize> {
    let mut left = 0;
    let mut right = nums.len() - 1;
    while left <= right {
        let mid = (left + right) / 2;
        if nums[mid] == target {
            return Some(mid);
        }
        if nums[left] <= nums[mid] {
            if nums[left] <= target && target < nums[mid] {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        } else {
            if nums[mid] < target && target <= nums[right] {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }
    None
}

let arr = [4,5,6,7,0,1,2];
println!("{:?}", search(&arr, 3));

medium

A. None

B. Some(2)

C. Some(4)

D. Some(0)

Solution

1. Step 1: Understand the array and target

   The array is [4,5,6,7,0,1,2], target is 3 which is not present in the array.

2. Step 2: Trace the search logic

   The function performs binary search on rotated array but since 3 is missing, the loop ends returning None.

3. Final Answer:

   None -> Option A

4. Quick Check:

   3 not in array = None [OK]

Hint: If target missing, function returns None [OK]

Common Mistakes:

• Assuming target 3 is present and returning wrong index
• Confusing mid calculation causing infinite loop
• Ignoring rotation logic in conditions
• Returning Some with wrong index

4. Identify the bug in the following Rust code for searching a target in a rotated sorted array:

fn search(nums: &[i32], target: i32) -> Option<usize> {
    let mut left = 0;
    let mut right = nums.len() - 1;
    while left < right {
        let mid = (left + right) / 2;
        if nums[mid] == target {
            return Some(mid);
        }
        if nums[left] <= nums[mid] {
            if nums[left] <= target && target < nums[mid] {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        } else {
            if nums[mid] < target && target <= nums[right] {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }
    None
}

medium

A. The function should return bool instead of Option<usize>

B. The mid calculation should use floating division

C. The loop condition should be while left <= right, not while left < right

D. The array should be mutable

Solution

1. Step 1: Analyze loop condition

   The loop uses while left < right, which misses checking when left == right, possibly skipping the last element.

2. Step 2: Correct loop condition

   Changing to while left <= right ensures all elements are checked, including when left equals right.

3. Final Answer:

   The loop condition should be while left <= right, not while left < right -> Option C

4. Quick Check:

   Loop must cover all indices [OK]

Hint: Use while left <= right to cover all elements [OK]

Common Mistakes:

• Using < instead of <= causing missed checks
• Trying floating division for mid index
• Changing return type unnecessarily
• Making array mutable without need

5. You have a rotated sorted array with possible duplicates: [2,2,2,3,4,2]. How would you modify the search algorithm to correctly find target 3?

hard

A. Sort the array before searching

B. Add extra checks to skip duplicates when nums[left] == nums[mid] == nums[right]

C. Use linear search instead of binary search

D. Ignore duplicates and apply normal rotated search

Solution

1. Step 1: Understand duplicates impact

   Duplicates can make it unclear which side is sorted because nums[left], nums[mid], nums[right] may be equal.

2. Step 2: Modify algorithm to skip duplicates

   When nums[left] == nums[mid] == nums[right], increment left and decrement right to skip duplicates and continue search.

3. Step 3: Avoid sorting or linear search

   Sorting changes array order; linear search is inefficient. Proper duplicate handling keeps binary search efficient.

4. Final Answer:

   Add extra checks to skip duplicates when nums[left] == nums[mid] == nums[right] -> Option B

5. Quick Check:

   Skip duplicates to maintain binary search [OK]

Hint: Skip duplicates at edges when equal to mid [OK]

Common Mistakes:

• Sorting array losing rotation info
• Using linear search losing efficiency
• Ignoring duplicates causing wrong results
• Assuming duplicates don't affect logic