时间复杂度（补充）和 空间复杂度

大家好啊，我今天来给大家分享有关空间复杂度的知识。感谢大家对我的支持，我会继续加油更新博客，努力提高博客质量的。

我们在这里先补充时间复杂度的一些实例：

补充实例1：

// 计算BinarySearch的时间复杂度？
int BinarySearch(int* a, int n, int x)
{
assert(a);
int begin = 0;
int end = n-1;
// [begin, end]：begin和end是左闭右闭区间，因此有=号
while (begin <= end)
{
int mid = begin + ((end-begin)>>1);
if (a[mid] < x)
begin = mid+1;
else if (a[mid] > x)
end = mid-1;
else
return mid;
}
return -1;
}

这里用的是二分查找法，查找一次就减去一半的变量，二分查找法：https://editor.csdn.net/md/?articleId=132244421 我们假设我们一直找到最后我们要找到的数的时候的次数为x次，那么2的x次方就会等于N，我们得到执行次数就是以2为底N的对数，所以我们的时间复杂度就是logN，我们默认以2为底的对数可以写成log的形式。但是我们的二分法的使用的前提是数字必须是有序的。

补充实例2：

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

我们要注意递归使用的时候每次函数调用的时间复杂度为O(1)，就看它的递归次数，如果每次调用的时间复杂度不是O(1)，我们就看递归调用中次数的累加。

补充实例3：

// 计算斐波那契递归Fib的时间复杂度？
long long Fib(size_t N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}

我们做这个递归的题得先画出示意图：

我们每次递归调用的次数是符合一个等比数列的，我们从fib（N）调用到fib（1）和fib（2）就结束，因为这两个就返回1了，不会在发生调用了，我们将这些调用次数全部加起来，得到的时间复杂度就是O(2^N)。

接下来就是我们今天的重点了：

空间复杂度：

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

接下来让我们通过实例来计算下空间复杂度：

实例1：

// 计算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;
}
}

我们这里申请的额外空间为exchange和i还有end，所以我们这里的空间复杂度为O(1)。

实例2：

// 计算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;
}

实例2我们利用了malloc函数给它开辟了n+1个空间，所以我们的额外开辟的空间就为n+1个，我们的空间复杂度就为O(N)。

实例3：

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

实例3递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)。但是我们要注意递归容易栈溢出（递归的深度），栈空间不大。

这一节的分享就到这里了，感谢大家的支持。