class Solution {
public:
int findMin(vector<int> &num) {
int len = num.size();
if (len == 1)
return num[0];
int left = 0;
int right = len  1;
int mx = numeric_limits<int>::max();
while (left <= right)
{
int mid = left + (rightleft)/2;
if (num[left] < num[mid])
{
mx = min(num[left], mx);
left = mid + 1;
}
else if (num[left] > num[mid])
{
mx = min(num[mid], mx);
right = mid  1;
} else if (num[left] == num[mid])
{
left++;
mx = min(num[mid], mx);
}
}
return mx;
}
};
Here is my solution  Is there better to handle duplicated elements?


I also submitted my answer and it was accepted. I am also not satisfied with my code. it is not compact.
Any insight will be appreciated. I found the way better answer in submission answer. It is just third of my code. hopefully i will do better with rest of the submissionpublic class DuplicateCircularSortedArray { public int findMin(int[] num) { int length=num.length; if(length==1)return num[0]; int index=findMin(0,length1,num); return num[index]; } private int findMin(int low, int high,int[] num){ int index=1; if(num[low]<num[high])return low; int mid=(low+high)/2; if(low==high)return high; if(low==mid && mid+1==high){ return high; }else if(num[low]>num[mid]  num[high]<num[mid]){ low=low+1; }else if(num[mid+1]<num[high]){ high=mid+1; }else if(num[low]==num[high] && low!=high){ low=low+1; high=high1; } index=findMin(low,high,num); return index; }

Here is my answer. I solved it in recursive aloghtrim which is also the answer to the problem of the first step. I don't think you need to deal with the duplicate elements, If a'r] == a[n], it is the same as a[r] > a[n].
int findMin(int * array, size_t size)
{
if(size == 1)
return array[0];
if(array[0] < array[size1])
return array[0];
if(size == 2)
return array[1];size_t middleIndex = size/2; int minOfFormerVector = findMin(array, middleIndex); int minOfLastVector = findMin(array+middleIndex, sizemiddleIndex); if(minOfFormerVector < minOfLastVector) return minOfFormerVector; else return minOfLastVector;
}
int findMin(vector<int> &num) {
int * array = new int[num.size()];
for(size_t n = 0; n < num.size(); ++n)
array[n] = num[n];return findMin(array, num.size()); }