算法的复杂度

算法的时间复杂度和空间复杂度统称为算法复杂度。

一、算法的时间复杂度

• 概念：时间复杂度就是一个函数，该函数计算的是执行基本操作的次数。

• 时间复杂度的—O渐进表示法
  一个算法中语句总的执行次数称为语句的频度或时间频度，记为T（n）;n称为时间规模。一般情况下，算法总的执行次数T（n）是n的一个函数f(n),当n不断变化时，时间频度T（n）也会随之不断变化，当n趋于无穷大时，算法执行次数的增长率和f(n)的增长率相同，记作T（n） = O（f(n)）,称O（f（n）)为算法的时间复杂度。
  一般算法O（f(n)）的计算方法：

• 用常数1取代运行时间中所有的加法常数；

• 在修正后的运行次数函数中，只保留最高项；
• 如果最高项的系数存在且不是1，则去除与这个项相乘的常数

3.复杂度算法—实例
- 常见的时间复杂度
计算1+2+3+……+n

int Sum(int N)
{
    int ret = 0;
    for(int idx=0; idx<=N; ++idx)//时间复杂度为O(N),空间复杂度0(1);
    {
        ret += idx;
    }
    return ret;
}

利用高斯公式计算

int Sum(int N)
{
    int ret = ((N+1)*N)>>1;//高斯公式   时间复杂度O(1) 空间复杂度O(1)
    return ret;
}

在数组中查找值为data的元素

nt Find(int *arr,int data,int N)
{
    for(int idx=0; idx<N; ++idx)//时间复杂度O(N)，空间复杂度O(1)
    {
        if(idx==data)
        {
            return idx;
        }
    }
    return -1;
}

二分查找

int Find(int *arr,int left,int right,int data)//时间复杂度O(log2(N)),空间复杂度O(1)
{
    while(left<= right)
    {
        int mid = (right+left)/2;
        if(arr[mid] > data)
        {
            right = mid-1;
        }
        else if(arr[mid] < data)
        {
            left = mid+1;
        }
        else
        {
            return mid;
        }
    }
    return -1;

}

• 分治算法的时间复杂度（二叉树、二叉搜索树）
  对于饱和的二叉树，高度为h，二叉树总的节点数为2^h-1，则二叉树的高度为h = log2N(N是总的接待你个数)
  最坏的情况下会调用h个节点，所以二叉树的时间复杂度与二分查找相同，O（log2N）;
• 递归的时间复杂度
  递归算法的时间复杂度 = 递归总次数*每次递归的次数

int Sum(int N)
{
    if(N==1)
        return 1;
    return Sum(N-1)+N;//时间复杂度O(N),空间复杂度O(N)
}

void FunTest(int N)
{
    if(N==1)
        return;
    FunTest(N-1);//时间复杂度O(N),空间复杂度O(1*N*2)--->O(N)
    FunTest(N-2);
}

斐波那契函数 时间复杂度O(2^N),空间复杂度O(N)

long long Fibonacc(int n)
{
    return (n<2)?(1):(Fibonacc(n-1)+Fibonacc(n-2));
}

斐波那契函数的优化

long long Fibonacc(int n)//时间复杂度O(n),空间复杂度O(1)
{
    int i = 0;
    int first = 1;
    int second = 1;
    int sum = 0;
    for(i = 3; i<n; ++i)
    {
        sum = first + second;
        first = second;
        second = sum;
    }
    return sum;
}

int Fib(int first,int second,int n)//正向递归
{
    if(n==3)
        return first+second;
    return Fib(second,first+second,n-1);//时间复杂度O(n),空间复杂度O(n)
}

二、空间复杂度

与时间复杂度类似，递归算法的空间复杂度为 = 递归深度*每次递归空间大小