初入数据结构：时间与空间复杂度

本文主要介绍时间复杂度和空间复杂度的概念，辅以实例和一些力扣上面试用的算法题。

一.时间复杂度

在计算机科学中，算法的时间复杂度是一个函数。算法中基本操作的执行次数，为算法的时间复杂度。

// 请计算一下Func1基本操作执行了多少次？
void Func1(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 * N ; ++ k)
{
 ++count;
}
int M = 10;
while (M--)
{
 ++count;
}
printf("%d\n", count);
}

一共执行了N^2+2*N+10次，这里使用大O渐进表示法，那么时间复杂度就是O(N^2)

接下来看几个例子

1.这里其实就是算循环走了多少次，而不是指令。很显然，是O(N)。

// 计算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(M+N)；一般情况下，时间复杂度计算时，未知数都是用N，但是也可以是M,K等等其他的，这里如果加个条件，N远大于M，认为O（N）,若两者差不多大，就是O（N）。

void Func3(int N, int M)
{
int count = 0;
for (int k = 0; k < M; ++ k)
{
 ++count;
}
for (int k = 0; k < N ; ++ k)
{
 ++count;
}
printf("%d\n", count);
}

3.这里跑了100次，其实要用1来替代常数次。也就是运算常数次等于O（1），并不是1次

// 计算Func4的时间复杂度？
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++ k)
{
 ++count;
}
printf("%d\n", count);
}

4.基本操作执行最好1次，最坏N次，时间复杂度一般看最坏，时间复杂度为 O(N)

const char * strchr ( const char * str, int character );

5.行最好N次，最坏执行了(N*(N+1)/2次，通过推导大O阶方法+时间复杂度一般看最 坏，时间复杂度为 O(N^2)

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

6.最好1次，最坏O(logN)次，时间复杂度为 O(logN),logN在算法分析中表示是底 数为2

// 计算BinarySearch的时间复杂度？
int BinarySearch(int* a, int n, int x)
{
assert(a);
int begin = 0;
int end = n-1;
while (begin < end)
{
 int mid = begin + ((end-begin)>>1);
 if (a[mid] < x)
 begin = mid+1;
 else if (a[mid] > x)
 end = mid;
 else
 return mid;
}
return -1;
}

7.递归了N次，时间复杂度为O(N)

// 计算阶乘递归Factorial的时间复杂度？
long long Factorial(size_t N)
{
return N < 2 ? N : Factorial(N-1)*N;
}

8.递归了2^N次，时间复杂度为O(2^N)

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

二.空间复杂度

空间复杂度是对一个算法在运行过程中临时额外占用存储空间大小的量度 。空间复杂度不是程序占用了多少 bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。

空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法。

还是看例子：

1.这里在执行的时候，创建了两个变量。一个end，一个i，在往复循环的过程中，始终操作的就是for和end开辟的空间，所以是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;
 }
}

2.开辟了n+1个数组，也就是n+1块空间，还开辟了变量i，常数块空间，所以空间复杂度是O(N)

// 计算Fibonacci的空间复杂度？
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次，建立了N个栈帧，所以空间复杂度是O(N)

// 计算阶乘递归Factorial的空间复杂度？
long long Factorial(size_t N)
{
 return N < 2 ? N : Factorial(N-1)*N;
}

4.这里不少人觉得是O(2^N)，但其实是O(N)，因为空间是可以反复使用的，跟时间不一样，空间在于深度，首先执行F(N)，再执行F(N-1)，再执行F(N-2)，一直执行到F(1)，这就是N个空间，然后去执行F(N)下面的F(N-2)，会反复利用上面用过的空间，所以就是O(N).

// 计算斐波那契递归Fibonacci的空间复杂度？
long long Fibonacci(size_t N)
{
return N < 2 ? N : Fibonacci(N-1)+Fibonacci(N-2);
}

三. 实例

实例已经放到如下链接了：（本人leetcode刷题专栏，敬请移步）

消失的数字和轮转数字（leetcode简单+中等）_何以过春秋的博客-CSDN博客