斐波那契查找（超详解）

    // 斐波那契查找.cpp    

    #include  <iostream>

    #include <string.h>

    using namespace std;  

      

    const int max_size=20;//斐波那契数组的长度  

      

    /*构造一个斐波那契数组*/   

void Fibonacci(int * F)  

{  

        F[0]=0;  

        F[1]=1;  

        for(int i=2;i<max_size;++i)  

            F[i]=F[i-1]+F[i-2];  

}  

      

    /*定义斐波那契查找法*/    

 int Fibonacci_Search(int *a, int n, int key)  //a为要查找的数组,n为要查找的数组长度,key为要查找的关键字  

 {  

      int low=0;  

      int high=n-1;  

        

      int F[max_size];  

      Fibonacci(F);//构造一个斐波那契数组F   

      

      int k=0;  

      while(n>F[k]-1)//计算n位于斐波那契数列的位置  

          ++k;  

      

      int  * temp;//将数组a扩展到F[k]-1的长度  

      temp=new int [F[k]-1];  

      memcpy(temp,a,n*sizeof(int));  

/*

      strcpy和memcpy主要有以下3方面的区别。

    1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。

    2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\0"才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。

    3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy

    4、包含在<string.h>中

    5、函数原型：void *memcpy(void *dest, const void *src, size_t n);

       功能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中

*/

      for(int i=n;i<F[k]-1;++i)  

         temp[i]=a[n-1];  

/*

    首先要明确：如果一个有序表的元素个数为n,并且n正好是（某个斐波那契数 - 1），即n=F[k]-1时，才能用斐波那契查找法。

    如果有序表的元素个n不等于（某个斐波那契数 - 1），即n≠F[k]-1，这时必须要将有序表的元素扩展到大于n的那个斐波那契数 - 1才行，

    上面for循环这段代码：便是这个作用。

 */      

      while(low<=high)  

      {  

        int mid=low+F[k-1]-1;  

        if(key<temp[mid])  

        {  

          high=mid-1;  

          k-=1;  

        }  

        else if(key>temp[mid])  

        {  

         low=mid+1;  

         k-=2;  

        }  

        else  

        {  

           if(mid<n)  

               return mid; //若mid<n则说明mid即为查找到的位置  

           else  

               return n-1; //若mid>=n则说明是扩展的数值,返回n-1  

        }  

      }    

/*

      斐波那契查找方法的核心代码就是上面一段

      原理：

        1）当key=a[mid]时，查找成功；

        2）当key<a[mid]时，新的查找范围是第low个到第mid-1个，此时范围个数为F[k-1] - 1个，即数组左边的长度，

           所以要在[low, F[k - 1] - 1]范围内查找；

        3）当key>a[mid]时，新的查找范围是第mid+1个到第high个，此时范围个数为F[k-2] - 1个，即数组右边的长度，

           所以要在[F[k - 2] - 1]范围内查找。

        4)    对于二分查找，分割是从mid= (low+high)/2开始；而对于斐波那契查找，分割是从mid = low + F[k-1] - 1开始的；

            通过上面知道了，数组a现在的元素个数为F[k]-1个，即数组长为F[k]-1，mid把数组分成了左右两部分，

            左边的长度为：F[k-1] - 1， 那么右边的长度就为（数组长-左边的长度-1），

            即：（F[k]-1） - （F[k-1] - 1） = F[k] - F[k-1] - 1 = F[k-2] - 1。  

*/

      delete [] temp;  //释放new出来的内存，因为是数组，所以才去delete [] temp的方式而不是delete temp.

      return -1;  

 }  

      

int main()  

{  

        //int a[] = {0,10,24,35,47,59,62,73,88,99};

        int a[]= {05,13,19,21,37,56,64,75,80,88,92};

        int key=21;  

        int index=Fibonacci_Search(a,sizeof(a)/sizeof(int),key);  

        /*

        这里插入讨论一下数组的长度问题：

        1、char a[]=""类型的字符串，编译器会在结尾自动添加\0，用sizeof计算会算上'\0'

        2、存在的C语言方法，如strlen(s)，计算字符串的长度，其中s指针。strlen要计算字符串长度，

           必须知道哪里是结尾，因此使用\0表示结尾。只有字符数组才有\0的概念，其它类型(int)的数组没有这个概念。

           如int a[]={} 知道数组长度使用sizeof(a)/sizeof(int);

        3、那么问题来了char a[]={}这种类型的字符串，用用sizeof计算会不会算上'\0'？

            答案是不会的。

        */

        cout<<key<<" is located at:"<<index<<endl;  

        system("PAUSE");  

        return 0;  

}  

/*

        1、这里我首先建立了一个11个元素的数组a[]，n=11，那么n就位于8和13，即F[6]和F[7]之间，所以 k=7，

            此时数组a的元素个数要被扩充，为：F[7] - 1 = 12个

            （这里如果问我为什么要扩充为F[k]-1而不是F[k],先留个问号，可以参考http://www.360doc.com/content/14/0528/10/14505022_381653345.shtml）

        2、然后根据核心代码开始找数：我们要找值为13的元素

           斐波那契数列前几位：0、1、1、2、3、5、8、13

           1）mid=low+F[k-1]-1  则mid=7;

           2）比较得key<temp[mid],则high=mid-1;  k-=1;  即有high=6,k=6

           3)入循环，mid=0+5-1=4;

           4）比较得key<temp[mid],则high=mid-1;  k-=1;,则有high=3,k=5

           3)入循环，mid=0+3-1=2;

           4)比较得key<temp[mid],则high=mid-1;  k-=1;,则有high=1,k=4

           5)入循环，mid=0+2-1=1;

           6)知道mid<n,得到位置为1

          3、最重要的是理解斐波那契查找的理念，让mid保持在数组的黄金分割点处，像一开始时，mid前面长度为F[K-1]-1，后面长度为F[K-2]-1，数组总长度为F[K]-1，mid       在黄金分割点。

*/  

/*
    与二分查找比较：

①斐波那契查找的平均性能比折半查找好，②但最坏情况下性能却比折半查找差，③它还有一个优点就是分割时只需进行加减运算。"

    与二分查找相比，斐波那契查找算法的明显优点在于它只涉及加法和减法运算，而不用除法。

    因为除法比加减法要占去更多的机时，因此，斐波那契查找的平均性能要比折半查找好。  

*/

4000