C语言数据结构：时间复杂度2和空间复杂度

1.时间复杂度补充（递归）

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

通过计算分析发现基本操作调用了N+1次，那么时间复杂度为O(N)
那如果将其中间加入一个循环呢？

long long Fac(size_t N)
 {
    if(0 == N)
        return 1;
    for (int i =0 ;i<n;i++)
    {
        ...
    }
    
    return Fac(N-1)*N;

随着N的慢慢变小，我们可以算出这个循环在这个递归中的时间复杂度是O(N^2)
那么总体的时间复杂度也是O(N^2)

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

通过画图我们可以算出他的调用次数：F(N) = 2^(N-1)-1 ==> O(2 ^N)
我们也就知道这个算法并不是很好，因为一旦次数变多，那么消耗的时间也就会多很多

2.空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度 。
空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。
空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。

注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因
此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

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

1. 使用了常数个额外空间，所以空间复杂度为 O(1)

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. 动态开辟了N个空间，空间复杂度为 O(N)

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

3. 递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)

3.轮转数组解法补充

之前介绍过两种写法：点击跳转
我们来写第三种解法：
这个解法我们采用的是用空间换时间的方式来解答的，适合用在对空间没有限制的题目上

void _rotate(int* nums, int n, int k, int* tmp) {
    k %= n;
    memcpy(tmp, nums + n - k, sizeof(int) * k);
    memcpy(tmp + k, nums, sizeof(int) * (n - k));
    memcpy(nums, tmp, sizeof(int) * n);
}

void rotate(int* nums, int numsSize, int k) {
    int tmp[numsSize];
    _rotate(nums, numsSize, k, tmp);
}

这里需要注意数组之间的关系即可