时间复杂度和空间复杂度

时间复杂度：
一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数f(n)，进而分析f(n)随n的变化情况并确定T(n)的数量级。这里用”O”来表示数量级，给出算法的时间复杂度。
T(n)=O(f(n));
它表示随着问题规模的n的增大，算法的执行时间的增长率和f(n)的增长率相同，这称作算法的渐进时间复杂度，简称时间复杂度。而我们一般讨论的是最坏时间复杂度，这样做的原因是：最坏情况下的时间复杂度是算法在任何输入实例上运行时间的上界，分析最坏的情况以估算算法指向时间的一个上界。
常用的时间复杂度有以下七种，算法时间复杂度依次增加：O(1)常数型、O(log2 n)对数型、O(n)线性型、O(nlog2n)二维型、O(n^2)平方型、O(n^3)立方型、O(2^n)指数型.
时间复杂度的分析方法：

1、时间复杂度就是函数中基本操作所执行的次数
2、一般默认的是最坏时间复杂度，即分析最坏情况下所能执行的次数
3、忽略掉常数项及系数，保留对增长因子影响最大的一部分。
4、关注运行时间的增长趋势，关注函数式中增长最快的表达式，忽略系数
5、计算时间复杂度是估算随着n的增长函数执行次数的增长趋势
6、递归算法的时间复杂度为：递归总次数 * 每次递归中基本操作所执行的次数
空间复杂度：
算法的空间复杂度并不是计算实际占用的空间，而是计算整个算法的辅助空间单元的个数，与问题的规模没有关系。算法的空间复杂度S(n)定义为该算法所耗费空间的数量级。
S(n)=O(f(n)) 若算法执行时所需要的辅助空间相对于输入数据量n而言是一个常数，则称这个算法的辅助空间为O(1);

递归算法的空间复杂度：递归深度N*每次递归所要的辅助空间， 如果每次递归所需的辅助空间是常数，则递归的空间复杂度是 O(N).

eg:二分查找(使用递归算法和非递归算法)的时间复杂度和空间复杂度。
//非递归方法

int BinarySearch(int* array, int len, int data)
{
    int left = 0;
    int right = len - 1;

    while (left <= right)
    {
        int middle = (left & right) + ((left ^ right) >> 1);
        if (data > array[middle])
        {
            left = middle + 1;
        }
        else if (data < array[middle])
        {
            right = middle - 1;
        }
        else
        {
            return middle;
        }
    }
    return -1;
}

int main()
{
    int array[] = { 1, 2, 3, 6, 7, 8, 9, 10 };
    int ret = BinarySearch(array, sizeof(array)/sizeof(int), 7);//4
    cout << ret << endl;
    return 0;
}

循环的基本次数是log2 N，所以:
时间复杂度是O(log2 N);
由于辅助空间是常数级别的所以：
空间复杂度是O(1);



递归：

template
T* BinarySearch(T* left,T* right,const T& data)
{
assert(left);
assert(right);
if (right >=left)
{
T* mid =left+(right-left)/2;
if (*mid == data)
return mid;
else
return *mid > data ? BinarySearch(left, mid - 1, data) : BinarySearch(mid + 1, right, data);
}
else
{
return NULL;
}
}

递归的次数和深度都是log2 N,每次所需要的辅助空间都是常数级别的：
时间复杂度:O(log2 N)
空间复杂度：O(log2N )




斐波那契数列的时间和空间复杂度
//递归情况下的斐波那契数列

long long Fib(int n)
{
assert(n >= 0);
return n<2 ? n : Fib(n - 1) + Fib(n-2);
}

“`
递归的时间复杂度是： 递归次数*每次递归中执行基本操作的次数
所以时间复杂度是： O(2^N)
递归的空间复杂度是： 递归的深度*每次递归所需的辅助空间的个数
所以空间复杂度是：O(N)