时间 空间复杂度小结（斐波那契 二分查找举例）

1.时间复杂度

时间复杂度实际就是函数，函数计算执行的基本操作次数 .

进行时间复杂度分析时需注意: 

1)时间复杂度强调的是函数执行的操作次数，这里的函数是指数学里面的函数，而不是C语法里的函数；

2)在实际中我们通常情况考量的是算法的最坏情况；

3)忽略掉常数； 

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

    (比如：F(n)=10*n^2+50n+1000,其时间复杂度为O(n)=n^2)

5)递归算法的时间复杂度计算：递归总次数*每次递归操作次数.

 

2.空间复杂度

空间复杂度，它是对一个算法在运行过程中临时占用存储空间大小的量度。所以它强调的是使用的辅助空间的的大小，而不是指所有的数据所占用的空间(不会像时间那样会一直累加）。

对递归算法的空间复杂度，假如递归深度为N*每次递归的辅助空间大小，如果每次递归的辅助空间是常数，则其空间复杂度为O(N)

 二分查找：

int Binary_Find(int *arr,int len,int data){     //非递归实现
    int left=0;
    int right=len - 1;
    while(left <= right){
        int mid=left + (right-left>>1); 
        if(arr[mid] > data){
            right = mid - 1;
        }
        else if(arr[mid] < data){
            left = mid + 1;
        }
        else
        return mid;
    }
    return -1;
}
//比如查找13的时候，这就是一种最坏的情况，一共要查4次确定13查不到，于是
//当查找次数t较大时， 其差不多查询了2^t大的范围，所以不难得出普通二分查找时间复杂度：O（logN）
// 空间复杂度：O（1）  创建的空间变量是常数个
int BinaryFind_R(int *arr,int lo,int hi,int data){   //递归实现
     
    if(lo > hi){
        return -1;
    }
    int mid=lo + (hi - lo >>1);
    if(arr[mid] > data){
        BinaryFind_R(arr,lo,mid-1,data);
    }
    else if(arr[mid] < data){
        BinaryFind_R(arr,mid+1,hi ,data);
    } 
    else return mid;
}

//递归方式的时间复杂度：函数每次执行的时间复杂度为O（1），执行递归的次数同非递归的二分查找次数，故时间复杂度也是O(logN);  

//空间复杂度：O(logN);  

int main(){
    int arr[]={1,3,4,5,6,7,8,8,9};
    int len = sizeof(arr)/sizeof(arr[0]);
    //测试用例
    printf("位置:%d
",BinaryFind_R(arr,0,len-1,1));
    printf("位置:%d
",BinaryFind_R(arr,0,len-1,3));
    printf("位置:%d
",BinaryFind_R(arr,0,len-1,4));
    printf("位置:%d
",BinaryFind_R(arr,0,len-1,5));
    printf("位置:%d
",BinaryFind_R(arr,0,len-1,6));
    printf("位置:%d
",BinaryFind_R(arr,0,len-1,7));
    printf("位置:%d
",BinaryFind_R(arr,0,len-1,8));
    printf("位置:%d
",BinaryFind_R(arr,0,len-1,9));
    printf("位置:%d
",BinaryFind_R(arr,0,len-1,13));
         
    return 0;
} 

 求斐波那契数

#include<stdio.h>
int Fib(int n){                  //递归实现 
    return    n<2? n: Fib(n-1) + Fib(n-2);
}
//它的每一步计算都被分成计算前两个斐波那契数，以此往下递归。那么这就形成了一颗二叉树，n较大时趋近于一个满二叉树。
//于是不难得出其时间复杂度：O(2^n)   空间复杂度：O（n）

int NonRFib(int n){              //非递归实现 
    int x0=0,x1=1,x2;
    for(int i=2 ;i <= n; ++i){
        x2 = x0 +x1;
        x0 = x1;
        x1 = x2;
    }
    return x2;
}
//时间复杂度：O（n）  空间复杂度：O（1）
int main(){
    int N;
    scanf("%d",&N);
    if(N < 0) printf("数字要大于0");
    else{
        printf("%d
",NonRFib(N));
        printf("%d",Fib(N));
    } 
    return 0;
}