Search in Rotated Sorted Array

Search in Rotated Sorted Array

https://leetcode.com/problems/search-in-rotated-sorted-array/description/

Given the array nums after the possible rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums.

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

Example:

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

My code:

impl Solution {
    pub fn search(nums: Vec<i32>, target: i32) -> i32 {
        search_recursive(&nums, target).map_or(-1, |i| i as i32)
    }
}

fn search_recursive(nums: &[i32], target: i32) -> Option<usize> {
    let n = nums.len();
    if n == 0 {
        return None;
    }
    if nums[0] <= nums[n-1] {
        return nums.binary_search(&target).ok();
    }

    let mid = n / 2;
    search_recursive(&nums[..mid], target).or_else(
        || search_recursive(&nums[mid..], target).map(|i| i + mid)
    )
}

Trae code:

fn search(nums: &[i32], target: i32) -> i32 {
    search_recursive(nums, target, 0, nums.len() as i32 - 1).unwrap_or(-1)
}

fn search_recursive(nums: &[i32], target: i32, left: i32, right: i32) -> Option<i32> {
    if left > right {
        return None;
    }

    let mid = left + (right - left) / 2;
    
    if nums[mid as usize] == target {
        return Some(mid);
    }

    // If left half is sorted
    if nums[left as usize] <= nums[mid as usize] {
        if nums[left as usize] <= target && target < nums[mid as usize] {
            search_recursive(nums, target, left, mid - 1)
        } else {
            search_recursive(nums, target, mid + 1, right)
        }
    } 
    // Else right half must be sorted
    else {
        if nums[mid as usize] < target && target <= nums[right as usize] {
            search_recursive(nums, target, mid + 1, right)
        } else {
            search_recursive(nums, target, left, mid - 1)
        }
    }
}