时间复杂度和空间复杂度

时间复杂度

概念

在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

大O表示法

我们采用大O的渐进表示法来表示算法的时间复杂度，一个程序在运行时，根据算法、测试用例的不同，大概分为最好、平均和最坏等三种情况，而我们时间复杂度则计算的是它的最坏的情况，大O符号。即是用于描述函数渐进行为的一个数学符号，实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法即可对其进行估算。

最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)

推导大O阶方法

1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

举个例子，若某个程序的执行次数为F(N) = N² + 2*N，则其时间复杂度为O(N²)

• N = 10，F(N) = 120，O = 100
• N = 100，F(N) = 10200，O = 10000
• N = 1000，F(N) = 1002000，O = 1000000

由此可见，随着N的增大，对程序执行次数影响最大的是N²，因此大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。

习题

练习1

// 计算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*N+10，则时间复杂度为O(N)。

练习2

// 计算Func3的时间复杂度？
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);
}

分析：
它有两个for循环，每个for循环中都执行相应的次数，因此它的执行次数为N+M，因此时间复杂度为O(N+M)。
注：这两个循环是分开的，单独计算的，如果嵌套在一起，就是O(N*M)。

练习3

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

分析：
该函数虽然有一个for循环，但是执行的次数却是常数次，因此时间复杂度为O(1)。

练习4

// 计算strchr的时间复杂度？
const char * strchr ( const char * str, int character );

分析：
strchr函数实现了在一个字符串中查找指定字符，具体的实现就是用一个for循环分别遍历该字符串，直到找到指定的字符，因此时间复杂度为O(n)。

练习5

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

分析：
冒泡排序，第一次执行的次数为 n，第二次执行的次数为 n - 1，…，不难算出它的总的执行次数是一个等差数列，即 (n*(n+1)) / 2 ，因此，时间复杂度为O(n²)。

练习6

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

分析：
二分查找，要寻找N，在每次运行的时候，都要折半查找一次，直到找到为止，即N*(1/2)*(1/2) * …(1/2) = 1，化简即为2^m = N，其中m为执行的次数，m = log₂N，因此时间复杂度为O(log₂N)。

练习7

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

分析：
它每次递归调用执行一次，时间复杂度看的是该函数的执行次数，求N的值就是调用了N次该函数，因此，时间复杂度为O(N)。

练习8

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

分析：

如图，第一次执行需要查1次，第二次执行需要查2次，……，不难发现它是一个等比数列，则他的时间复杂度为O(2ⁿ)。

注：

空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟实践复杂度类似，也使用大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;
 }
}

分析：
这个函数中定义了3个变量，因此它的空间复杂度为O(1)。

练习2

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

分析：
在这个函数中，由于它申请了 n + 1 个大小为long long的空间，因此他的空间复杂度为O(n)

练习3

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

分析：
该函数每次自己递归的调用自己，每次调用都是在重新开辟一个栈帧，调用了N次，则就开辟了N个栈帧，那么它的空间复杂度为O(N)。