详解时间复杂度和空间复杂度

今天的你，学习了吗？敲代码了吗？比昨天有哪些进步？

---

1、算法效率

1.1 、算法的复杂度

算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。

时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

2、时间复杂度

2.1、 时间复杂度的定义

在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。


但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。

一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

即找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。

我们来个代码作为例子看一下：

// 请计算一下Func1中++count语句总共执行了多少次？
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);
}

这里我们可以看出上述代码有一个两层 for 循环(N²)，其次还有一个单层for循环(2*N)，最后是一个while循环，循环次数为M = 10。所以这串代码的数学表达式我们可以写为：F(N) = N ²+2 * N + 10 。

❓那Func1的时间复杂度就是 N ²+2 * N + 10 吗？

回答：当然不是啦！

实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

图解上述代码：

当然在这里就引出了大O的渐进表示法~就让我们一起来看看吧！

2.2 、大O的渐进表示法

大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。

推导大O阶方法：

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

使用大O的渐进表示法以后，上述Func1的时间复杂度为：O(N²)

2.2.1 、O(1) 时间复杂度示例

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

分析：

Func4 这段代码我们可以看到，里面就一层for循环，而且循环次数是常数次，更准确点是100次，但是我们上面说了不需要计算到准确的次数，那么这里的常数次无论是多大，只要是常数，就根据推导大O阶方法 1 知：O(1) 复杂度类型。
而此 “1” 非彼 “1”，这里的 “1” 代表的是常数。

图解分析：

2.2.2、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);
}

分析：

Func2在这里我们不难看出其代码中存在的数学函数表达式为：F(N) = 2 * N + 10，这里根据推导大O阶方法二和三可以得出，Func2的时间复杂度为：O(N)。

图解分析：

2.2.3、M+N时间复杂度示例

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

分析：

Func3可以看出是有两个for循环而循环的次数都是未知数，所以这里时间复杂度为：O(M+N)；当然这里依然存在三种情况考虑一下：当M>>N时，就是O(M)；当M<M/2N，即O(M)/O(N)。

图解分析：

2.2.4、冒泡排序时间复杂度O(N²)

/ 计算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，其时间复杂度是O(N)；最坏情况是执行(N*(N+1)/2次，其时间复杂度是：O(N²)。
所以这里出现多种不同情况，而这里就要记住了，在计算时间复杂度时候需要考虑到最坏的情况。
因此，冒泡排序的时间复杂度为：O(N²)

图解分析：

2.2.5、strstr 函数时间复杂度O(N)

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

分析：

这里是strstr()查找字符串函数，该函数在时间复杂度上也存在考虑情况。
最好情况：查找常数次；平均情况：查找N/2次；最坏情况：查找N次。 所以这里考虑最坏情况，其时间复杂度为：O(N)。

图解分析：

通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。

另外有些算法的时间复杂度存在最好、平均和最坏情况：

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

例如：在一个长度为N数组中搜索一个数据x
最好情况：1次找到
最坏情况：N次找到
平均情况：N/2次找到
在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

2.2.6、二分查找时间复杂度O(log2^N)

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

分析：

二分查找最好情况1次找到即常数次，时间复杂度为：O(1)；最坏情况：若找X次，那么就有X个2相乘，即就有X = log2^N,即时间复杂度为：O( log2^N)。
这里考虑最坏情况，所以二分查找的时间复杂度为：O(log2^N)。

图解分析：

这里将二分查找和暴力查找进行一个比较：

（这里单纯的讨论二分查找这个思想，不考虑二分查找需要有序的数组，有序是二分查找需要付出的代价）

  N     O(N)   log(2)N
 1000   1000    10
 100W    100W    20
 10亿   10亿    30

关于以2为底的时间复杂度的一些拓展知识：

2.2.7、递归时间复杂度

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

分析：

对于递归时间复杂度的计算首先要考虑递归次数，其次在考虑递归程序中是否还存在其他需要计算的条件。
这里在递归了N次，其时间复杂度为：O(N)。

图解分析：

2.2.8、递归里面还包含有其他的时间复杂度

// 计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N)
{
    	if (0 == N)
		return 1;
    	for (int i = 0; i < N; i++)
    	{
    		printf("%d ", i);
    	}
		printf("\n");
		return Fac(N - 1) * N;
}

分析：

这里递归了N次，每一次递归里面有有N次循环，所以其时间复杂度为：O(N²)。

图解分析：

递归时间复杂度计算的总结：

1、如果每次函数调用次数是O(1)，那就看他的递归次数；
2、如果每次函数调用次数不是O(1)，那就看他的递归调用次数中的累加；

2.2.9、斐波那契数列的时间复杂度

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

分析：

这里通过递归实现斐波那契数列，经过计算这里递归了 2^N 次。
因此其时间复杂度为：O(2^N)

图解分析：

3、空间复杂度

3.1、空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度 。

空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。
空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法。
(注意：时间复杂度看次数，空间复杂度看变量的个数）

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

3.1.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;
    }
}

分析：

空间复杂度看变量的个数，而这一段程序中明显可以看出有三个变（end、exchange、i），又因为空间复杂度也用大O渐进表示法来表示，所以其空间复杂度为：O(1)。

图解分析：

3.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;
}

分析：

这里存在malloc动态开辟空间问题，这里动态开辟了(n+1)个空间，本来还有fibArray和 i 这两个变量，所以一共是n+3个空间，所以其空间复杂度为：O(N)。

图解分析：
关于malloc 动态空间开辟问题的空间复杂度：

还有一个和上图第一个malloc动态空间开辟的空间复杂度原理相似的一种情况：就是C99支持的变长数组 int arr[n]; 这个也是O(N)。

3.1.3、阶乘递归Fac的空间复杂度

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

分析：

递归在这里需要考虑到栈开辟问题，每递归一次就会在内存里面开辟一块栈空间。因此这里递归了N次，每次都开辟一块空间，所以空间复杂度为：O(N)。

图解分析：

3.1.4、斐波那契递归Fib的空间复杂度

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

分析：

这里可以看出分两层递归，先F(N)递归到F(2)，然后在回去F(N)，再递归到F(1)，但是这里就存在一个重要的问题了，那就是：时间是累积的，一去不复返，不能重复使用，因此它的时间复杂度是O(2^N)；空间是可以重复利用的的，其空间复杂度是O(N)。

图解分析：

4、常见的复杂度对比

总结

数据结构和算法的学习，第一步就是要知道什么是时间复杂度和空间复杂度，而数据结构和算法又是编程的核心，所以我建议大家还是好好的学学他们兄弟俩，无论是你考试还是以后找工作，这兄弟俩总是形影不离，伴随着你。
如有不足之处希望大家批评指正！如果觉得还行就把赞和评论留下呗~
谢谢观看，再见！