数据结构之“算法的时间复杂度和空间复杂度”

算法在编写成可执行程序后，运行时需要耗费时间资源和空间 ( 内存 ) 资源。因此 衡量一个算法的好坏，一般
是从时间和空间两个维度来衡量的 ，即时间复杂度和空间复杂度。
时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间 。在计算
机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计
算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

1.2复杂度的重要性

出现在面试题就大抵可以知道复杂度在这里的重要性了。

最容易想到的思路：先给数组排序，然后判断前一个数+1是否等于后一个值。不等于则返回前一个数+1。排序的复杂度是qsort O（N*logN）显然不符合。

解决思路1：我们通过等差数列的求和公式得到总值，然后依次减去数组中的每个值。就可以找到消失的数字。但是有风险，N的值可能过大导致溢出

cpp 复制代码

//f法1   Nt太大可能会溢出
int missingNumber(int* nums, int numsSize)
{
int N=numsSize;
int sum=(0+N)*(N+1)/2;
for(int i=0;i<N;i++)
{
    sum-=nums[i];
}
return sum;
}

解决思路2：这题和我们做的单身狗问题很像，那我们应该怎么转换成单身狗问题呢？

单身狗是找只出现一次的数，所以我们就可以添加一组没有缺失数字的数组。然后就变成和单身狗一样的问题了。这里不需要考虑顺序异或的问题，排不排序结果都一样。

帮大家回顾一下异或：相同数字的异或为0，不同的为1。还有任何二进制数与0异或为二进制数本身，A ^ 0 = A 。

cpp 复制代码

//法2     转成单身狗来做 
int missingNumber(int* nums, int numsSize)
{
int N=numsSize;
int ret=0;
for(int i=0;i<N;i++)
{
    ret^=nums[i];
}
for(int j=0;j<=N;j++)
{
    ret^=j;
}
return ret;
}

二、时间复杂度

2.1时间复杂度的概念

时间复杂度的定义：在计算机科学中， 算法的时间复杂度是一个函数 ，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法 的时间复杂度。
即：找到某条基本语句与问题规模 N 之间的数学表达式，就是算出了该算法的时间复杂度。

2.2大O的渐进表示法

大 O 符号（ Big O notation ）：是用于描述函数渐进行为的数学符号。
推导大 O 阶方法：
1 、用常数 1 取代运行时间中的所有加法常数。
2 、在修改后的运行次数函数中，只保留最高阶项。
3 、如果最高阶项存在且不是 1 ，则去除与这个项目相乘的常数。得到的结果就是大 O 阶。

解释一下为什么只保留最高项呢，我们假设时间复杂度的函数是Fun（N）=N^2+3N+1，当N=1000时，Fun=1000000+3000+1=1003001几乎可以看作1000000。那就会有人说了，N的值很小时，那这样每个算法的执行时间都差不多的。所以我们只考虑N为很大的值时。

2.3常见的时间复杂度例题计算

例题1

看来前面时间复杂度的概念就知道了，其实就是看循环次数。第一个for循环里面应该是2 * N次

（因为是[0,2 * N - 1]这里用闭区间表示），再来数while循环里面的次数（M--）M次。

O(2 * N + 10)最后时间复杂度化简为O(2 * N)。

cpp 复制代码

// 计算Func2的时间复杂度？
void Func2(int N)
{
 int count = 0;
 for (int k = 0; k < 2 * N ; ++ k)
 {
 ++count;
 }
 int M = 10;
 while (M--)
 {
 ++count;
 }
 printf("%d\n", count);
}

例题2

这里是冒泡排序的时间复杂度计算，冒泡排序本质就是相邻的两个数比较谁大谁放后面（这里默认是升序）。我们这里分两种情况讨论，最好和最坏情况。

最好情况：当数组已经排好序了，就只需要走一遍最外面的循环。所以时间复杂度为O(N)。

最坏情况：数组没有顺序时，第二层for循环也要走，一共N个数两两比较。最多要比较N-1次。

因为第二层的比较次数会随着第一层改变而改变。也就是N-1+N-2+.........+1根据最坏情况可知一共有N-1项，所以就可以使用等差数列求和公式来计算。（N -1）* (N-1+1)/2时间复杂度为O(N^2)

cpp 复制代码

// 计算BubbleSort的时间复杂度？
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])
 {
 Swap(&a[i-1], &a[i]);
 exchange = 1;
 }
 }
 if (exchange == 0)
 break;
 }
}

例题3

这里是递归的时间复杂度计算，先给上结论递归的时间复杂度计算是把每次递归里面循环次数相加。因为里面没有任何其他的循环语句所以就是一次，一共递归N次所以就是N个1相加。时间复杂度为O(N)。

cpp 复制代码

// 计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N)
{
 if(0 == N)
 return 1;
 
 return Fac(N-1)*N;
}

三、空间复杂度

3.1空间复杂度的概念

空间复杂度也是一个数学表达式，是对一个算法在运行过程中 临时占用存储空间大小的量度 。
空间复杂度不是程序占用了多少 bytes 的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。
空间复杂度计算规则基本跟实践复杂度类似，也使用大 O 渐进表示法 。
注意： 函数运行时所需要的栈空间 ( 存储参数、局部变量、一些寄存器信息等 ) 在编译期间已经确定好了，因
此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

3.2大O的渐进表示法

与时间复杂度的大O表示法大致一样。

3.3常见的空间复杂度例题计算

其实空间复杂度就是额外开辟空间的大小。

例题1

我们在函数里面找额外开辟的变量，发现有end、i、exchange三个额外变量。所以我们这里的空间复杂度是常数个，所以为O(1)。

cpp 复制代码

// 计算BubbleSort的空间复杂度？
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])
 {
 Swap(&a[i-1], &a[i]);
 exchange = 1;
 }
 }
 if (exchange == 0)
 break;
 }
}

例题2

这里我们发下先他新创建了一个指针（等价于数组），我们默认新创建的数组复杂度为N，还有一共变量i，O(N+1)空间复杂度化简为O(N)。

cpp 复制代码

// 计算Fibonacci的空间复杂度？
// 返回斐波那契数列的前n项
long long* Fibonacci(size_t n)
{
 if(n==0)
 return NULL;
 
 long long * fibArray = (long long *)malloc((n+1) * sizeof(long long));
 fibArray[0] = 0;
 fibArray[1] = 1;
 for (int i = 2; i <= n ; ++i)
 {
 fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
 }
 return fibArray;
}

例题3

这里是递归的空间复杂度计算，还是和时间复杂度计算一样的。把每次调用相加起来，我们调用函数都会开辟一个新的栈帧，我们一共要调用N次所以空间复杂度为O(N)。

cpp 复制代码

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

总结

学习复杂度是为了让我们在解决一些问题会有多种想法，通过计算复杂度来选择最优的思路。复杂度分析对于设计和评估算法的效率非常重要。通常我们希望设计出时间复杂度和空间复杂度都尽可能低的算法,以提高算法的性能和适用性。复杂度分析是算法设计和分析的核心内容之一。