Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array nums = [0,1,2,4,5,6,7] might become:
Notice that rotating an array [a[0], a[1], a[2], …, a[n-1]] 1 time results in the array [a[n-1], a[0], a[1], a[2], …, a[n-2]].
Given the sorted rotated array nums of unique elements, return the minimum element of this array.
You must write an algorithm that runs in O(log n) time.
Input: nums = [3,4,5,1,2]
Output: 1
Explanation: The original array was [1,2,3,4,5] rotated 3 times.
Input: nums = [4,5,6,7,0,1,2]
Output: 0
Explanation: The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.
Input: nums = [11,13,15,17]
Output: 11
Explanation: The original array was [11,13,15,17] and it was rotated 4 times.
From: LeetCode
Link: 153. Find Minimum in Rotated Sorted Array
1. Binary Search:
The array is sorted but rotated. If we pick the middle element, we can determine which half of the array is strictly increasing and which half contains the rotation point (and hence the minimum).
2. Identifying the Correct Half:
3. Finding the Minimum:
Continue the binary search until the left and right pointers converge, at which point they will point to the minimum element in the array.
4. Time Complexity:
The binary search cuts the search space in half at each step, resulting in an O(logn) time complexity, where n is the size of the array.
5. Implementation:
int findMin(int* nums, int numsSize) {
int left = 0, right = numsSize - 1;
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] > nums[right]) {
// If mid element is greater than the rightmost element,
// the minimum must be in the right part
left = mid + 1;
} else {
// If mid element is less than or equal to the rightmost element,
// the minimum must be in the left part including the mid element
right = mid;
}
}
// When the while loop ends, left == right, pointing to the minimum element
return nums[left];
}