时间、空间复杂度

时间空间复杂度

该篇为数据结构内容的一第节，来介绍如何判断算法效率，即计算时间复杂度与空间复杂度。

🐸一、时间复杂度

1. 算法的时间复杂度是一个函数，所表达的其实并不是具体时间，而是基本操作的执行次数。
2. 示例：计算++count执行的次数。

void doplus(int N)
{
    int count = 0;
    for (int i = 0; i < N ; ++ i)
    {
        for (int j = 0; j < N ; ++ j)
        {
        ++count;
        }
    }
    
    for(int k = 0; k < 2; ++k)
    {
        ++count;
    }
}

可以计算出++count的执行次数为：F(N) = N²+2，对于该程序，它的基本操作不止执行++count的次数，估计一下总次数可能是X*F(N),X表示类似++count的语句个数。

该算法的时间复杂度是O(N²),原因如下：

3. 在实际使用中，往往不会使用具体基本操作的执行次数的函数，因为这样其实不方便进行比较，例如：F1(x) = x²+2x 与 F2(x) = x³-4进行比较大小的结果是一个分段的。

   斤斤计较显然不太适用于计算机上，因为当x=1或当x=100时其实F1(x)与F2(x) 在电脑上执行时间都不会相差太大，因此对于表示算法优劣的时间复杂度其实是用 大O的渐进表示法 🌟

   *如果基本操作的执行次数的函数是常数表达式，用O(1)表示其时间复杂度。

   *只保留函数的最高阶项，且除去该项的系数 。

4. 练习：计算冒泡排序的时间复杂度

void BubbleSort(int* a, int n)
{
    assert(a);
    for (size_t end = n; end > 0; --end)
    {
        int exchange = 0;
        for (size_t i = 1; i < end; ++i)
    	{   
            if (a[i-1] > a[i])
            {
                int temp = a[i-1];
                a[i-1] = a[i];
                a[i] = temp;
                exchange = 1;
            }
        }
        
        if (exchange == 0)
             break;
    }
}

答案是O(n²)。那么这是为什么呢？可能有的朋友说：因为有两个嵌套循环……

其实计算时间复杂度并不能单看有多少循环，最主要的还是要了解算法思想。

该冒泡排序：第1次遍历数组的n-1个元素，第2次遍历n-2个元素……第n-1次遍历1个元素。如果有一次遍历没有交互数组元素，就直接结束。

可以看出最坏的结果是一个递减数列，则F(n) = (n-1 + 1) * (n-1) / 2 = (n²-n)/2；而最好的结果就是数组本来就排序好的，则F(n) = n。时间复杂看最坏的情况，为O(N²)

🐯二、空间复杂度

1. 许多年前，空间复杂度在内存很少的时候也是衡量一个算法优劣的重要指标，当然在现在它也有它的作用，毕竟万一两个算法的时间复杂度要是一样呢。

   当程序运行的时候，所需的栈空间在编译时就已经确定了，因此空间复杂度主要表示显示的额外空间，即 额外临时占用存储空间大小的量度 。

   空间复杂度也不是表示程序到底占用了多少byte的空间，而是表示变量的个数。用 大O渐进表示法 。

2. 示例: 计算冒泡排序的空间复杂度

 void BubbleSort(int* a, int n)
 {
     assert(a);
     for (size_t end = n; end > 0; --end)
     {
         int exchange = 0;
         for (size_t i = 1; i < end; ++i)
     	{   
             if (a[i-1] > a[i])
             {
                 int temp = a[i-1];
                 a[i-1] = a[i];
                 a[i] = temp;
                 exchange = 1;
             }
         }
         
         if (exchange == 0)
              break;
     }
 }

答案是O(1)，有的朋友可能会问了，不是有两个循环吗，而且在循环里面都有定义的变量呀，怎么会是常数呢？ 其实原因也很简单，不要忘记变量的作用域哦，简单的理解，其实size_t i、int temp等语句确实会执行不止一次，但是它们所使用是空间可能都是同一个。因此该冒泡排序的空间复杂度就是O(1)了。

3. 示例：计算递归n的阶乘的空间复杂度

 long long Fac(size_t N)
 {
     if(N == 0)
     	return 1;
     return Fac(N-1)*N;
 }

答案是O(N)，学习过递归可以知道，该程序会开辟N个这样的空间，只有当最后一个即N=0时，才开始返回结果，然后依次返回，空间才会依次的销毁。因此空间复杂度为O(N)。

待续~