Find Minimum in Rotated Sorted Array
You are given an array of length n which was originally sorted in ascending order. It has now been rotated between 1 and n times. For example, the array nums = [1,2,3,4,5,6] might become:
[3,4,5,6,1,2] if it was rotated 4 times.
[1,2,3,4,5,6] if it was rotated 6 times.
Notice that rotating the array 4 times moves the last four elements of the array to the beginning. Rotating the array 6 times produces the original array.
Assuming all elements in the rotated sorted array nums are unique, return the minimum element of this array.
A solution that runs in O(n) time is trivial, can you write an algorithm that runs in O(log n) time?
Example 1:
Input: nums = [3,4,5,6,1,2]
Output: 1
Example 2:
Input: nums = [4,5,0,1,2,3]
Output: 0
Example 3:
Input: nums = [4,5,6,7]
Output: 4
Constraints:
1 <= nums.length <= 1000
-1000 <= nums[i] <= 1000
Solution
Referring to Find Target in Rotated Sorted Array, we can use the same method. However, this problem can be seen as a simplified version that we only need to judge whether nums[mid] > nums[ri]
to see where the minimum is.
Code
Just simplify the binary search function in Find Target in Rotated Sorted Array
class Solution:
def findMin(self, nums: List[int]) -> int:
le = 0
ri = len(nums)-1
ans = nums[0]
while le <= ri:
mid = (le+ri)//2
print(le, mid, ri)
if nums[le] <= nums[mid]:
if nums[le] > nums[ri]:
ans = min(ans, nums[ri])
le = mid+1
else:
ans = min(ans, nums[le])
ri = mid-1
else:
ans = min(ans, nums[mid])
ri = mid-1
return ans
Most simplified:
class Solution:
def findMin(self, nums: List[int]) -> int:
start , end = 0, len(nums) - 1
curr_min = float("inf")
while start < end :
mid = start + (end - start ) // 2
curr_min = min(curr_min,nums[mid])
# right has the min
if nums[mid] > nums[end]:
start = mid + 1
# left has the min
else:
end = mid - 1
return min(curr_min,nums[start])