剑指offer之旋转数组的最小数字&斐波那契数列

面试题：旋转数组的最小数字

题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小数字。例如：数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小数字为1。

背景资料：

旋转数组的特点：

（1）递增排序的数组旋转之后的数组可划分为两个排序的子数组；

（2）前面的子数组的元素都大于或等于后面子数组的元素；

（3）最小的元素刚好是两个子数组的分界线；

（4）旋转数组在一定程度上是有序的；

       在有序的数组中可以用二分查找实现O(logn)的查找，我们也可用二分查找的思想寻找旋转数组的最小数字。

思路：

这道题最直观的解法并不难，从头到尾遍历一次数组，我们就能找出最小的元素。这种思路的时间复杂度是O(n)。但是这种思路并没有利用输入的旋转数组的特性，肯定达不到面试官的要求。

我们注意到旋转之后的数组实际上可以划分为两个排序的子数组，而且前面子数组的元素都大于或等于后面子数组的元素。我们还注意到最小数的元素刚好是这两个子数组的分界线。在排序的数组中我们可以用二分查找法实现O(logn)的查找。    

1. 设置两个指针P1和P2，初始状态第一个指针指向前面子数组的第一个元素，第二个指针指向后面子数组的最后一个元素；

2. 找到两个指针的中间元素；

3. 如果该中间元素位于前面的递增子数组，那么它应该大于或等于第一个指针指向的元素。此时最小的元素应该就是位于该中间元素的后面。移动之后的第一个指针仍位于前面的递增子数组；同样，如果中间元素位于后面的那个子数组，那么它应该小于或等于第二个指针指向的元素。此时最小的元素应该就是位于该中间元素的前面。不管是移动第一个指针还是移动第二个指针，查找的范围都会缩小到原来的一半。接下来我们再用更新之后的两个指针重复做新一轮的查找。

4. 再继续找P1和P2的中间元素如此，便可以缩小搜索范围，提高时间复杂度，最终第一个指针指向前面子数组的最后一个元素，而第二个指针指向后面子数组的第一个元素，它们处于相邻位置，而第二个指针指向的刚好是最小的元素，这是程序循环结束的条件,即就是P2-P1==1。

接下来我们以题目中数组{3,4,5,1,2}为例：

首先把P1指向第0个元素，把P2指向第二个元素，如图：

位于两个指针中间的数字是5，它大于第一个指针指向的数字，所以它肯定位于第一个递增数组中，并且最小的数字肯定位于其后面的某个位置，基于此，我们移动P1让它指向中间元素5，如图：

由图可得，此时位于P1和P2中间的数字是1，它小于第二个指针指向的数字，所以它肯定位于第二个递增数组，并且最小的数字肯定位于它前面的某个位置或者它就是最小的数字，基于此我们移动P2让它指向中间元素1，如图：

此时P1和P2指向两个相邻的元素，程序循环结束，且P2指向的元素就是数组中最小的数字。       

注意：当两个指针指向的数字及它们中间的数字三者相等时，无法判断中间数字位于前面的子数组还是后面的子数组，也就无法移动两个指针来缩小查找的范围，此时只能用顺序查找的方法。

代码实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

#include using namespace std; int Min(int numbers[],int len); int MinInOrder(int numbers[],int index1,int index2); int Min(int numbers[],int len) {     if(numbers==nullptr||len<=0)     {         throw new std :: exception("异常");//抛出异常     }     int index1 = 0;//解决前面的0个元素搬到最后面     int index2 = len-1;     int indexMid = index1;     while(numbers[index1]>=numbers[index2])     {         if(index2-index1 == 1)         {             indexMid = index2;             break;         }         indexMid = (index2+index1)/2;         if(numbers[index1]==numbers[index2]&&numbers[indexMid]==numbers[index1])             return  MinInOrder(numbers,index1,index2);         if(numbers[indexMid]>=numbers[index1])             index1 = indexMid;         else if(numbers[indexMid]<=numbers[index1])             index2 = indexMid;     }     return numbers[indexMid]; } int MinInOrder(int numbers[],int index1,int index2) {     int result =numbers[index1];     for(int i = index1+1;i<=index2;i++)     {         if(result>numbers[i])         result = numbers[i];     }     return result; } int main() {     int numbers1[5] = {3,4,5,1,2};     cout<<Min(numbers1,5)<<endl;     int numbers2[5] = {1,0,1,1,1};     cout<<Min(numbers2,5)<<endl;     return 0; }

 

 

面试题：斐波那契数列

，用程序实现。

这是一道特别简单的题，用递归写的话，几行就搞定，代码如下

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

int fib(int n) {     if(n <= 0)     {         return 0;     }     else if(n == 1)     {         return 1;     }     else     {         return fib(n-1) + fib(n-2);     } }

 

不过当你求得项数不断变大时，你会发现程序运行的越来越慢了，当求第100项时，大概要运行五六分钟才能出来，这样程序的效率就太慢了，就拿求第10项吧，如图：

 

有好多重复的结点，且会发现随着n的增大，重复的结点会越多，程序的效率特别低，这个题可能是递归最失败的应用吧。

用循环就很快啦！

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

int fib(int n) {     int arr[2] = {0,1};          if(n<</span>2)     {         return arr[n];     }     int f1 = 0;     int f2 = 1;     int f3;     for(int i = 2;i<=n;++i)     {         f3 = f1 +f2;         f1 = f2;         f2 = f3;     }     return f3;

时间复杂度为O(n)。