在这个斐波那契数列中的数字，就被称为斐波那契数。这个级数与大自然植物的关系极为密切。几乎所有花朵的花瓣数都来自这个级数中的一项数字：菠萝表皮方块形鳞苞形成两组旋向相反的螺线，它们的条数必须是这个级数中紧邻的两个数字（如左旋8行，右旋13行）；还有向日葵花盘……直到最近的1993年，人们才对这个古老而重要的级数给出真正满意的解释：此级数中任何相邻的两个数，次第相除，其比率都最为接近0.618034……这个值，它的极限就是所谓的"黄金分割数"。

 1 //非递归算法
 2 long long fib1(size_t N) {
 3     long long a = 0, b = 1, c = 0;
 4     if (N < 2) {
 5         return N;
 6     }
 7     else {
 8         for (long long i = 2; i <= N; ++i) {
 9             c = a + b;
10             a = b;
11             b = c;
12         }
13     }
14         return c;
15 }
16 int main()
17 {
18     printf("%lld", fib1(10));
19     getchar();
20     return 0;
21 }  //此算法最大的优点是不存在重复计算，故效率比递归算法快的多得多。

 1 //递归算法
 2 long long fib2(size_t N) {
 3     if (N < 2) 
 4         return N;
 5     return fib2(N - 1) + fib2(N - 2);
 6 }
 7 int main()
 8 {
 9     printf("%lld", fib2(10));
10     getchar();
11     return 0;
12 }

 1 template<typename T>  
 2 T* BinarySearch(T* array,int number,const T& data)  
 3 {  
 4        assert(number>=0);  
 5        int left = 0;  
 6        int right = number-1;  
 7        while (right >= left)  
 8        {  
 9               int mid = (left&right) + ((left^right)>>1);  
10               if (array[mid] > data)  
11               {  
12                      right = mid - 1;  
13               }  
14               else if (array[mid] < data)  
15               {  
16                      left = mid + 1;  
17               }  
18               else  
19               {  
20                      return (array + mid);  
21               }  
22        }  
23        return NULL;  
24 }  

 1 template<typename T>  
 2 T* BinarySearch(T* left,T* right,const T& data)  
 3 {  
 4        assert(left);  
 5        assert(right);  
 6        if (right >=left)  
 7        {  
 8               T* mid =left+(right-left)/2;  
 9               if (*mid == data)  
10                      return mid;  
11               else  
12                      return *mid > data ? BinarySearch(left, mid - 1, data) : BinarySearch(mid + 1, right, data);  
13        }  
14        else  
15        {  
16               return NULL;  
17        }  
18 }  

时间复杂度：一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数f(n)，进而分析f(n)随n的变化情况并确定T(n)的数量级。这里用"O"来表示数量级，给出算法的时间复杂度。

      T(n)=O(f(n));                 

  它表示随着问题规模的n的增大，算法的执行时间的增长率和f(n)的增长率相同，这称作算法的渐进时间复杂度，简称时间复杂度。而我们一般讨论的是最坏时间复杂度，这样做的原因是：最坏情况下的时间复杂度是算法在任何输入实例上运行时间的上界，分析最坏的情况以估算算法指向时间的一个上界。

时间复杂度的分析方法：

（1）时间复杂度就是函数中基本操作所执行的次数；

（2）一般默认的是最坏时间复杂度，即分析最坏情况下所能执行的次数；

（3）忽略掉常数项；

（4）关注运行时间的增长趋势，关注函数式中增长最快的表达式，忽略系数；

（5）计算时间复杂度是估算随着n的增长函数执行次数的增长趋势；

（6）递归算法的时间复杂度为：递归总次数 * 每次递归中基本操作所执行的次数；

    常用的时间复杂度有以下七种，算法时间复杂度依次增加：O(1)常数型、O(log2 n)对数型、O(n)线性型、O(nlog2n)二维型、O(n^2)平方型、O(n^3)立方型、O(2^n)指数型。

5. 斐波那契数的时间复杂度与空间复杂度分析

非递归算法空间复杂度分析
此函数内部最多时一共开辟了a, b, c, i四个变量空间复杂度是常数，即为O（1）。 

递归的时间复杂度是：  递归次数*每次递归中执行基本操作的次数，所以时间复杂度是： O(2^N)

分析：

假设最坏情况下，循环X次之后找到，则：2^x=n; x=logn(算法中如果没写，log默认底数为2)

6.2 递归算法复杂度分析

 1 class Temp
 2 {
 3 public:
 4     Temp(){
 5         ++N;
 6         Sum += N;
 7     }
 8     static void Reset(){
 9         N = 0;
10         Sum = 0;
11     }
12     static int GetSum(){
13         return Sum;
14     }
15 private:
16     static int N;
17     static int Sum;
18 };
19 int Temp::N = 0;
20 int Temp::Sum = 0;
21 int solution_Sum(int n){
22     Temp::Reset();
23     Temp *a = new Temp[n];
24     delete[]a;
25     a = 0;
26     return Temp::GetSum();
27 }
28 int main(){
29     cout << solution_Sum(100) << endl;
30     getchar();
31     return 0;
32 
33 }