304 North Cardinal St.
Dorchester Center, MA 02124

# Find Minimum in Rotated Sorted Array LeetCode Solution

## Problem – Find Minimum in Rotated Sorted Array

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:

• `[4,5,6,7,0,1,2]` if it was rotated `4` times.
• `[0,1,2,4,5,6,7]` if it was rotated `7` times.

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.`

Example 1:

``````Input: nums = [3,4,5,1,2]
Output: 1
Explanation: The original array was [1,2,3,4,5] rotated 3 times.``````

Example 2:

``````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.``````

Example 3:

``````Input: nums = [11,13,15,17]
Output: 11
Explanation: The original array was [11,13,15,17] and it was rotated 4 times.``````

Constraints:

• `n == nums.length`
• `1 <= n <= 5000`
• `-5000 <= nums[i] <= 5000`
• All the integers of `nums` are unique.
• `nums` is sorted and rotated between `1` and `n` times.

### Find Minimum in Rotated Sorted Array LeetCode Solution in C++

``````int findMin(vector<int> &num) {
int start=0,end=num.size()-1;

while (start<end) {
if (num[start]<num[end])
return num[start];

int mid = (start+end)/2;

if (num[mid]>=num[start]) {
start = mid+1;
} else {
end = mid;
}
}

return num[start];
}
``````

### Find Minimum in Rotated Sorted Array LeetCode Solution in Java

``````public class Solution {
public int findMin(int[] num) {
if (num == null || num.length == 0) {
return 0;
}
if (num.length == 1) {
return num[0];
}
int start = 0, end = num.length - 1;
while (start < end) {
int mid = (start + end) / 2;
if (mid > 0 && num[mid] < num[mid - 1]) {
return num[mid];
}
if (num[start] <= num[mid] && num[mid] > num[end]) {
start = mid + 1;
} else {
end = mid - 1;
}
}
return num[start];
}
}
``````

### Find Minimum in Rotated Sorted Array LeetCode Solution in Python

``````class Solution:
def findMin(self, nums: List[int]) -> int:
if len(nums) == 1 or nums[0] < nums[-1]:
return nums[0]

left, right = 0, len(nums) - 1
while left <= right:
mid = left + (right - left) // 2
if mid > 0 and nums[mid - 1] > nums[mid]:  # The nums[mid] is the minimum number
return nums[mid]
if nums[mid] > nums[right]:  # search on the right side, because smaller elements are in the right side
left = mid + 1
else:
right = mid - 1  # search the minimum in the left side
``````
##### Find Minimum in Rotated Sorted Array LeetCode Solution Review:

In our experience, we suggest you solve this Find Minimum in Rotated Sorted Array LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the Find Minimum in Rotated Sorted Array LeetCode Solution

Find on LeetCode

##### Conclusion:

I hope this Find Minimum in Rotated Sorted Array LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

More Coding Solutions >>

LeetCode Solutions

Hacker Rank Solutions

CodeChef Solutions