# Leetcode Find Minimum in Rotated Sorted Array II problem solution

In this Leetcode Find Minimum in Rotated Sorted Array II problem solution Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array nums = [0,1,4,4,5,6,7] might become:

1. [4,5,6,7,0,1,4] if it was rotated 4 times.
2. [0,1,4,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 that may contain duplicates, return the minimum element of this array. You must decrease the overall operation steps as much as possible.

## Problem solution in Python.

```class Solution:
def findMin(self, nums: List[int]) -> int:
i=0
if not nums:return None
while(i<len(nums)-1 and nums[i+1]>=nums[i]):
i+=1
if i==len(nums)-1:i=-1
return nums[i+1]
```

## Problem solution in Java.

```int low = 0, high = nums.length-1;
while(low < high) {
int mid = (low + high) / 2;
if(nums[low] > nums[mid]) {
high = mid;
}else if(nums[mid] > nums[high]) {
low = mid + 1;
}else if(nums[low] < nums[mid]){
return nums[low];
}else if(nums[mid] < nums[high]) {
return nums[mid];
}else {
low++;
}
}

return nums[low];
```

## Problem solution in C++.

```int findMin(vector<int>& nums) {
int left = 0, right = nums.size()-1;
while (left < right) {
int mid = left+(right-left)/2;
if (nums[left] > nums[mid]){
left++;
right=mid;
}
else if (nums[mid] > nums[right]){
left=mid+1;
}
else {
if(nums[left] < nums[right])
return nums[left];
else
right--;
}
}
return nums[left];
}
```

## Problem solution in C.

```int findMin(int* nums, int numsSize) {
if (numsSize == 1 || nums[0] < nums[numsSize-1]) {
return nums[0];
}
for (int i = numsSize - 1; i > 0; i--) {
if (nums[i] < nums[i-1]) {
return nums[i];
}
}
}
```