[Leetcode] #154 Find Minimum in Rotated Sorted Array II

Discription

Follow up for "Find Minimum in Rotated Sorted Array":
What if duplicates are allowed?Would this affect the run-time complexity? How and why?Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.(i.e., 

0 1 2 4 5 6 7

 might become 

4 5 6 7 0 1 2

).Find the minimum element.The array may contain duplicates.

Solution

int MinInorder(vector<int> &nums, int index1, int index2){
int result = nums[index1];
for (int i = index1 + 1; i <= index2; i++){
if (result > nums[i])
result = nums[i];
}
return result;
}

int findMin(vector<int>& nums) {
int index1 = 0, index2 = nums.size() - 1;
int mid = index1;
while (nums[index1] >= nums[index2]){
if (index2 - index1 == 1){
mid = index2;
break;
}
mid = (index1 + index2) >> 1;
if (nums[index1] == nums[index2] && nums[mid] == nums[index2])
return MinInorder(nums, index1, index2);
if (nums[mid] >= nums[index1])
index1 = mid;
else if (nums[mid] <= nums[index1])
index2 = mid;
}
return nums[mid];
}

int findMin(vector<int> &num) {      //input  [1,3,3]
int start = 0;
int end = num.size() - 1;
int mid = 0;
while (start < end) {
mid = start + (end - start) / 2;

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

int findMin(vector<int> &num) {
int start = 0;
int end = num.size() - 1;
int mid;
while (start<end){
if (num[start]<num[end])    //  1 3 3
break;
mid = start + (end - start) / 2;
if (num[mid]>num[end]){
start = mid + 1;
}
else if (num[mid] == num[end]){
start++;
end--;
}
else
end = mid;
}
return num[start];
}

GitHub-LeetCode: https://github.com/wenwu313/LeetCode