【数据结构】算法、时间复杂度和空间复杂度详解 ------ 算法篇

文章目录

📋前言
一. ⛳️算法的定义
二. ⛳️算法的特性
- 2.1 输入输出
- 2.2 输入输出
- 2.3 有穷性
- 2.4 确定性
- 2.5 可行性
三. ⛳️算法设计要求
- 3.1 正确性
- 3.2 可读性
- 3.2 健壮性
- 3.3 时间效率高和存储量低
四. ⛳️算法效率的度量方法
- 4.1 事后统计方法
- 4.2 事前分析估算方法
五. ⛳️算法的复杂度
- 5.1 算法的复杂度的简单介绍
- 5.2 算法复杂度在面试中考察
六. ⛳️算法的时间复杂度（重点）
- 6.1 算法的时间复杂度定义
- 6.2 大O的渐进表示法
- 6.3 常见的时间复杂度
- 6.4 最好情况、最坏情况与平均情况
- 6.5 常见时间复杂度计算举例
七. ⛳️算法的空间复杂度
- 7.1 算法空间复杂度的定义
- 7.2 常见空间复杂度计算举例
八. ⛳️总结

📋前言

🏠 个人主页：@聆风吟的个人主页

🔥系列专栏：本期文章收录在《数据结构初阶》，大家有兴趣可以浏览和关注，后面将会有更多精彩内容！

📝作者留言：文章创作不易，可能会有些地方出现错误，还希望广大读者们能够帮忙指出，让我们大家一起共同进步。
⏰寄语：少年有梦不应止于心动，更要付诸行动。
☀️欢迎大家关注🔍点赞👍收藏⭐️留言📝

一. ⛳️算法的定义

算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。

二. ⛳️算法的特性

算法具有五个基本特性：输入、输出、有穷性、确定性和可行性。

2.1 输入输出

算法具有零个或多个输入，尽管对于大多数算法来说，输入参数都是有必要的，但对于个别情况，如打印"hello world!"这样的代码，不需要任何输入参数，因此算法的输入可以是零个。

2.2 输入输出

算法至少有一个或多个输出，算法是一定需要输出的，不需要输出，你用这个算法干嘛呢？输出的形式可以打印输出，也可以是返回一个或多个值等。

2.3 有穷性

有穷性：是指算法在执行有限的步骤之后，自动结束而不会出现无限循环，并且每一个步骤都在可接受的时间内完成。

2.4 确定性

确定性：算法的每一步骤都具有确定的含义，不会出现二义性。算法在一定条件下，只有一条执行的路径，相同的输入只能有唯一的输出结果。算法的每一步骤都被精确定义而无歧义。

2.5 可行性

可行性：算法的每一步都必须是可行的，也就是说，每一步都能够通过执行有限次数完成。

三. ⛳️算法设计要求

算法不是唯一的。也就是说，解决同一个问题，可以有多种解决问题的算法。通常为了设计一个 “好” 的算法应考虑达到一下目标：
在这里插入图片描述

3.1 正确性

正确性：算法的正确性是指算法至少应该具有输入、输出和加工处理无歧义性，能够得到问题的正确答案。但是算法的 “ 正确 ” 一词在用法上通常有很大差别，大体分为一下四个层次：

算法程序没有语法错误；
算法程序对于合法的输入数据能够产生满足要求的输入结果；
算法程序对于非法的输入数据能够得出满足规格说明的结果；
算法程序对于精心选择的，甚至刁难的测试数据都有满足要求的输出结果。

对于这四层含义，层次 1的要求最低，但仅仅没有语法错误实在谈不上是好算法。这就是如同仅仅解决温饱，不算是生活幸福一样。而层次 4是最难实现的，我们几乎不可能逐一验证所有的输入都得到正确的结果。所以一般情况下，我们通常把层次 3作为衡量一个算法算法是否合格的标准。

3.2 可读性

可读性：算法的另一个目的是为了便于阅读，来理解和交流。可读性高有助于人们理解算法，晦涩难懂的算法往往隐含错误，不易被发现，并且难以调试和修改。

3.2 健壮性

健壮性：当输入数据不合法时，算法也能做出相关处理而不是产生异常或莫名其妙的结果。

3.3 时间效率高和存储量低

时间效率指的是算法的执行时间。对于同一个问题，如果有多个算法能够解决，执行时间短的算法效率高，执行时间长的效率低。存储量需求指的是算法在执行过程中需要的最大空间，主要指算法程序运行时所占用的内存或外部硬盘存储空间。因此，设计算法时应尽量满足时间效率高和存储量低的需求。

四. ⛳️算法效率的度量方法

刚才我们提到了设计算法要提高效率。这里的效率大都指算法的执行时间。算法的执行时间需要依据该算法编制的程序在计算机上运行时所消耗的时间来度量的。而度量一个程序的执行时间通常有有两种方法 —— 事后统计方法和事前分析估算方法。

4.1 事后统计方法

事后统计方法：这种方法主要是通过设计好的测试程序和数据，利用计算机计时器对不同的算法编制的程序的运行时间进行比较，从而确定算法效率的高低。但是这种方法明显是有很大的缺陷：

必须要依据算法事先编制好程序，这通常要需要花费大量时间和精力。如果编制出来发现它根本就是一团很糟糕的算法，那不就是竹篮打水一场空了吗？
时间的比较依赖计算机硬件和软件等环境因素的影响，有时会掩盖算法本身的优劣。
算法的测试数据设计困难，并且程序的运行时间往往还与测试数据的规模有很大关系，效率高的算法在小的测试数据面前往往得不到体现。

基于事后统计方法有这样那样的缺陷，我们一般不予以采纳，而是采用另一种事前分析估算方法。

4.2 事前分析估算方法

事前分析估算方法：在计算机程序编制前，依据统计方法对算法进行估算。经过分析我们可以发现，一个用高级语言程序语言编写的程序在计算机上运行时所消耗的时间取决于一下因素：
在这里插入图片描述
解析：
第（1）条是一个好算法的根本，第（2）条要有软件来支持，第（4）条要看硬件性能。因此，抛开这些与计算机硬件、软件有关的因素，一个程序的运行时间，依赖于算法的好坏和问题的输入规模。所谓问题输入规模是指输入量的多少。

五. ⛳️算法的复杂度

5.1 算法的复杂度的简单介绍

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

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

5.2 算法复杂度在面试中考察

在这里插入图片描述

由此可以看出算法复杂度的重要性，所以说同学们下面的内容一定要好好学哦。言归正传接下来让我们开始具体讲解时间复杂度和空间复杂度。

六. ⛳️算法的时间复杂度（重点）

6.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;//执行 N*N 次
		}
	}

	for (int k = 0; k < 2 * N; ++k)
	{
		++count;//执行 2*N 次
	}

	int M = 10;
	while (M--)
	{
		++count;//执行 10次
	}

	printf("%d\n", count);
}

在这里插入图片描述

实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么我们就可以使用大O的渐进表示法。看到这估计有同学该问了大O的渐进表示法是什么，它又是如何推导的呢？且听我慢慢道来，让我们继续接着向下面学习。

6.2 大O的渐进表示法

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

推导大O阶方法：

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

结合上面示例： 使用大O的渐进表示法以后，Func1的时间复杂度为：
在这里插入图片描述

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

6.3 常见的时间复杂度

常见的时间复杂度如下表所示：
在这里插入图片描述
注：对数在文本中不好表示，以 2 为底的对数通常简写为(logn) 。

常用的时间复杂度所耗费的时间从小到大依次是：

O(1) < O(logn) < O(n) < O(nlogn) < O(2n) < O(n3) < O(2n) < O(n!)

6.4 最好情况、最坏情况与平均情况

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

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

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

6.5 常见时间复杂度计算举例

1️⃣实例一：

// 计算Func1的时间复杂度？
void Func1(int N)
{
	int count = 0;
	for (int k = 0; k < 2 * N; ++k)
	{
		++count;
	}

	int M = 10;
	while (M--)
	{
		++count;
	}
	printf("%d\n", count);
}

解析：实例1基本操作执行了2N+10次，根据大O阶的推导方法很容易得出：Func1的时间复杂度为O(N)。

2️⃣实例二：

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

解析：实例二基本操作执行了M+N次，根据大O阶的推导方法得出：

如果题目没有表明 M 和 N 的大小，Func2的时间复杂度为O(M + N)；
如果题目明确表明 M 远大于 N ，则 N 的变化对时间复杂度的影响不大，Func2的时间复杂度为O(M)；
如果题目明确表明 N 远大于 M ，则 M 的变化对时间复杂度的影响不大，Func2的时间复杂度为O(N)。
如果题目明确表明 M 和 N 一样大，则O(M + N)等价于O(2M)或O(2N)，Func2的时间复杂度为O(M) 或 O(N) ；

3️⃣实例三：

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

解析：实例3基本操作执行了100次，根据大O阶的推导方法很容易得出：Func3的时间复杂度为O(1)。

4️⃣实例四：

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

解析：首先我们先来介绍一下库函数strchr作用：在str指向的字符数组中查找是否包含字符characte。因此实例4的基本操作执行最好1次，最坏N次。根据时间复杂度一般看最坏，strchr的时间复杂度为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-2 次交换，将将一个元素排好序…依次类推。排好所有元素需要执行 n-1 次，每趟交换的次数分别为(n - 1)，(n-2)，(n-3)，… ，(2)，(1)。由此可知，实例5基本操作执行最好n-1次（即数组已经排好序，只需要执行一趟排序判断数组是否已经有序），最坏执行了( n*(n-1) )/2次（即将所有趟交换的次数相加，可以直接使用等差数列求和），通过推导大O阶方法+时间复杂度一般看最坏，BubbleSort的时间复杂度为O(N^2)。

6️⃣实例六：

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

解析：本题是二分查找函数，每次查找将会将范围缩放一半。因此实例6基本操作执行最好1次，最坏O(logN)次。根据时间复杂度一般看最坏，BinarySearch时间复杂度为 O(logN) 。
在这里插入图片描述

7️⃣实例七：

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

	return Fac(N - 1) * N;
}

解析：本题是一个简单的递归调用，实例7通过计算分析发现基本操作递归了N次，时间复杂度为O(N)。
在这里插入图片描述

8️⃣实例八：

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

	return Fib(N - 1) + Fib(N - 2);
}

解析：本题是一个双递归。实例8通过计算分析发现基本操作递归了2ⁿ，Fib的时间复杂度为O(2^n)。
在这里插入图片描述

七. ⛳️算法的空间复杂度

7.1 算法空间复杂度的定义

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

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

7.2 常见空间复杂度计算举例

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

解析：实例1使用了常数个额外空间，分别是[ end，exchange，i ]。根据大O阶的推导方法很容易得出，BubbleSort空间复杂度为 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动态开辟了N+1个空间，根据大O阶的推导方法很容易得出，Fibonacci空间复杂度为 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)。
在这里插入图片描述

八. ⛳️总结

本文主要讲解：

算法的定义：算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。
算法的特性：有穷性、确定性、可行性、输入、输出。
算法的设计要求：正确性、可读性、健壮性、高效率和低存储量需求。
算法的度量方法：事后统计方法、事前分析估算方法。
推导大O阶
时间复杂度
空间复杂度

今天的内容就到这里了，你对今天的内容是否有所掌握？如果还有疑问的话请在评论区里多多提问，大家可以一起帮你解决，让我们共同进步。创作不易，如果对你有用的的话点个赞支持下作者，你们的支持是作者创作最大的动力。关注我不迷路。