一个有序的无重复数字的整型数组，从某处断开，前后互调。例如
[ 0 1 2 | 4 5 6 7 ] 从 2 和 4 中间断开，前后互调得 [ 4 5 6 7 0 1 2 ]。
现在给你一个这样的数组（原本有序，后被前后互调），要求你快速的找到数组中的最小值。
例如给你 [ 4 5 6 7 0 1 2 ]，你应该返回 0
例如给你 [ 1 2 ]，你应该返回 1

提示：使用二分法以提高效率

遍历啊遍历  我只会遍历

以 [ 4 5 6 7 0 1 2 ] 为例，左边4，右边2，正中间7，于是可以断定最小数应该在这个数组的后一半中，一下子排除掉了一半，就是二分法

要是数据量特别大 还可以   否则，以楼主的例子而言  我用肉眼就能判断出最小数是0  根本就不需要电脑去遍历 去二分

回头还是说这个例子：

arry[0]=4 arr[max]=2  arr[mid]=7  可以判断4-7是有序 7--2 是乱序（那能判断min在7--2中  那么下一步判断呢  数列就是偶数个了 不存在arr[mid]了

#include<stdio.h>
int main ()
{ 
    int data[]={4 ,5, 6 ,7 ,12 ,0 ,2 };
    int data01[]={1,2,3};
    int f(int data[],int n);
    printf("%d\n",f(data,7));
    printf("%d\n",f(data01,3));
    return 0;

}
int f(int data[],int n)
{
  int low,hig,cet,key;
  key=data[0];
  if(key<data[n-1]) return key;
  low=0;
  hig=n-1;
  while(hig-low>1)
  {
    cet=low+(hig-low)/2;
    if(data[cet]>key) low=cet;
    else hig=cet;
  }
  return data[hig];
}

#include <stdio.h>

int search(int *array, int size)
{
    int low = 0, high = size, mid1, mid2, mid3;
    if (size == 1)
        return array[0];
    else if (size == 2)
        return array[0] < array[1] ? array[0] : array[1];
    while (low < high)
    {
        mid1 = (low + high)/2;
        if (array[mid1-1] > array[mid1])
            break;
        mid2 = (low + mid1)/2;
        mid3 = (mid1 + 1 + high)/2;
        array[mid2] > array[mid3] ? low = mid1 + 1 : high = mid1;
    }
    return array[mid1];
}

int main(void)
{
    int a[] = { 4, 5, 6, 7, 0, 1, 2 };
    int b[] = { 1, 2 };
    printf("%d\n", search(a, sizeof a/sizeof(int)));
    printf("%d\n", search(b, sizeof b/sizeof(int)));
    return 0;
}