在旋转数组中找到最小值

     1 2 3 4 5 => sorted
     3 4 5 1 2 => Rotated => Find the min in this in O(log n)

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int bs(vector<int> a)
{
    int l =0, r = a.size()-1;
    while(l<=r)
    {
        int mid = l + (r-l)/2; // Mid guaranteed to be in range
        if(a[mid-1]>a[mid]) return a[mid];
        if(a[mid]>a[l])
        {
            l=mid+1 ; continue;
        }
        else
        {
            r = mid-1 ; //Mid has been checked
        }
    }
}
int main()
{
  vector<int> a = {1,2,3,5,6,7,8,9,10};
  rotate(a.begin(),a.begin()+4,a.end()); //  Make 6 the head 
  for(auto x:a) cout<<x<<endl;
  cout <<"Min is " <<bs(a) <<endl;
  return 0;
}

6
7
8
9
10
1
2
3
5
Min is 3

您有正确的策略，但是没有清楚地考虑不变量。

我将假设元素是不同的。没有这个，它不可能在O(log n)时间内完成。(考虑除单个1外所有元素都为0的情况。)

如果a[0] < a[size-1]，则没有有效旋转，因此a[0]为最小值。

否则有两个递增的运行a[0]<a[1]<...<a[k-1]和a[k]<a[k+1]<...<a[size-1]，其中我们也知道a[k-1]>a[k]。

我们想求出k

开始-像你一样-用括号[0,size-1]猜测。

不变量是这个大括号必须总是包含k。当然对于初始大括号也是如此!

为了确保终止，我们必须在每次迭代中使其更小。当区间只有一个元素时，即lo == hi，我们就得到了答案。

计算一个新的猜测，如你所示，

int mid = (lo + hi) / 2;

现在，有哪些可能性?Mid在[0,k -1]或[k, size-1]中。

如果是前者，则可知mid <= k-1。我们可以使括号[mid+1, hi]保持不变。注意，这总是使括号变小，以确保终止。

如果是后者，我们知道mid>= k，所以可以使用[lo, mid]。注意我们不能说[lo, mid-1]因为mid 可能等于k，打破了不变式。

这引起了另一个问题。如果mid的计算产生mid == hi，则新括号与旧括号相同。我们就没有进展，只有一个无限循环。幸运的是，这从来没有发生过，因为(lo + hi) / 2 < hi每当lo < hi .

最后一块拼图是如何判断mid在哪个运行。这很简单。如果是a[mid] >= a[0]，我们知道它在第一次运行中。

用代码把这些都括起来:

if (a[0] < a[size - 1]) return 0;
int lo = 0, hi = size - 1;
while (lo < hi) {
  int mid = (lo + hi) / 2;
  if (a[mid] >= a[0])
    lo = mid + 1;
  else
    hi = mid;
}
return lo;

使用

查找旋转点

auto sorted_end = is_sorted_until(a.begin(), a.end());

描述来自cppreference:

检查范围[first, last)，并找到从第一个开始且元素按升序排序的最大范围。

使用

获得两种旋转方式的最小值

min(a.front(), *is_sorted_until(a.begin(), a.end()))

小于O(n)但不小于O(log n)。

EDIT既然你链接了SO线程，我正在翻译C++中的答案

int findMin(vector<int> & arr) {
    int low = 0;
    int high = arr.size() - 1;
    while (arr[low] > arr[high]) {
        int mid = (low + high) >> 1;
        if (arr[mid] > arr[high])
            low = mid + 1;
        else
            high = mid;
    }
    return arr[low];
}

这有赋值的味道，所以没有标准库。

我的切割是通过寻找不连续来找到枢轴点:

int findpivot(vector<int> a)
{
    int left = 0;
    int right = a.size() - 1;
    while (a[left] > a[right])
    {
        int mid = (right + left) / 2;
        if (a[mid] > a[right])
        { 
            left = mid + 1;
        }
        else
        {
            right = mid;
        }
    }
    return left;
}

然后，我将查看主元两侧的第一个值以寻找最低值。运行该函数发现(事后看来，"呸!")它总是返回最低值的索引，因为我在枢轴处查找不连续的方式。

最终结果与Java解决方案相同，只是我返回枢轴点，而Java解决方案返回枢轴点处的值。

关于第二个问题，为什么OP被否决了?OP没有被否决。OP的问题是。

好吧，为什么OP的问题被否决了?

我能想出的最好的答案就是这个问题是重复的。OP发现了副本，但没有正确执行。这就限制了这个问题对以后的提问者的有用性。

试试这个:

#include <iostream>
#include <vector>
#include <stdio.h>
#include <algorithm>
#include <math.h>
using namespace std;
int findMinInRotatedSortedVec(vector<int>v, int start, int end)
{
    if (start == end) return v[start];
    int mid = (end-start)/2+start;
    if (v[start] == v[mid]) {
        if (v[mid] == v[end]) {
            int min1 = findMinInRotatedSortedVec(v, start, mid);
            int min2 = findMinInRotatedSortedVec(v, mid+1, end);
            return (min1 > min2) ? min2 : min1;
        }
        if (v[mid] < v[end]) return v[start];
    }
    if ((v[start] < v[mid]) && (v[mid] <= v[end])) return v[start];
    if (v[start] > v[mid]) return findMinInRotatedSortedVec(v, start, mid);
    return findMinInRotatedSortedVec(v, mid+1, end);
}
int main() {
    vector<int> v (70);
    std::iota(v.begin(), v.end(), 31);
    rotate(v.begin(),v.begin()+43,v.end());
    cout <<"Min is " << findMinInRotatedSortedVec(v,0,v.size()-1) <<endl;
  return 0;
}

<algorithm>提供了查找最小元素的内置方法min_element(除了max和minmax)。

你可以这样使用:

std::vector<int>::iterator result = std::min_element(std::begin(a), std::end(a));
std::cout << "Min is " << std::distance(std::begin(a), result);

，而不必使用bs()方法