【数据结构手札】时间复杂度详解：概念 | 大O渐进表示法

🌈个人主页：聆风吟
🔥系列专栏：数据结构手札
🔖少年有梦不应止于心动，更要付诸行动。

文章目录

📚专栏订阅推荐
📋往期回顾：复杂度的概念
[一. ⛳️算法的时间复杂度（重点）](#一. ⛳️算法的时间复杂度（重点）)
- [1.1 🔔算法的时间复杂度定义](#1.1 🔔算法的时间复杂度定义)
- [1.2 🔔大O的渐进表示法](#1.2 🔔大O的渐进表示法)
- [1.3 🔔常见的时间复杂度](#1.3 🔔常见的时间复杂度)
- [1.4 🔔最好情况、最坏情况与平均情况](#1.4 🔔最好情况、最坏情况与平均情况)
[二. ⛳️常见时间复杂度计算举例](#二. ⛳️常见时间复杂度计算举例)
📝全文总结

📚专栏订阅推荐

专栏名称	专栏简介
C++藏宝阁	本专栏聚焦学习阶段核心知识点，深耕基础与实战，干货笔记持续更新，和大家共学共进，夯实编程功底。
数据结构手札	本专栏主要是我的数据结构入门学习手札，记录个人从基础到进阶的学习总结。
数据结构手札・刷题篇	本专栏是《数据结构手札》配套习题讲解，通过练习相关题目加深对算法理解。

📋往期回顾：复杂度的概念

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

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

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

1.1 🔔算法的时间复杂度定义

在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间 。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度 。
即：找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。

🎯时间复杂度是衡量程序的时间效率，那么为什么不去计算程序的运行时间呢？

因为程序运行时间与编译的环境和运行机器的配置都有关系，比如同一个算法程序，用一个老编译器进行编译和新编译器进行编译，在同样的机器下运行时间不同；

同一个算法程序，用一个老低配置机器和新高配置机器，运行时间不同；

时间只能程序写好后测试，不能写程序前通过理论思想计算评估。

示例：请计算一下Func1中++count语句总共执行了多少次？

cpp 复制代码

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的渐进表示法是什么，它又是如何推导的呢？且听我慢慢道来，让我们继续接着向下面学习。

1.2 🔔大O的渐进表示法

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

推导大O阶方法：

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

结合上面示例： 使用大O的渐进表示法以后，Func1的时间复杂度为：

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

1.3 🔔常见的时间复杂度

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

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

O(1) < O(logn) < O(n) < O(nlogn) < O(n²) < O(n³) < O(2ⁿ) < O(n!)

1.4 🔔最好情况、最坏情况与平均情况

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

最坏情况：任意输入规模的最大运行次数(上界)

平均情况：任意输入规模的期望运行次数

最好情况：任意输入规模的最小运行次数(下界)

例如：在一个长度为N数组中搜索一个数据x

最好情况：1次找到

最坏情况：N次找到

平均情况：N/2次找到

在实际中 一般在没有特殊说明的情况下，关注的都是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)。

二. ⛳️常见时间复杂度计算举例

1️⃣实例一

cpp 复制代码

// 计算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️⃣实例二

cpp 复制代码

// 计算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️⃣实例三

cpp 复制代码

// 计算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️⃣实例四

cpp 复制代码

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

解析：首先我们先来介绍一下库函数strchr作用：在str指向的字符数组中查找是否包含字符characte。因此实例4的基本操作执行最好1次，最坏N次。根据时间复杂度一般看最坏，strchr的时间复杂度为O(N)。

5️⃣实例五

cpp 复制代码

// 计算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️⃣实例六

cpp 复制代码

// 计算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️⃣实例七

cpp 复制代码

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

	return Fac(N - 1) * N;
}

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

🎯递归算法的时间复杂度 = 单次递归的时间复杂度 * 递归次数

8️⃣实例八

cpp 复制代码

// 计算斐波那契递归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)。

📝全文总结

本文系统性地讲解了算法时间复杂度的核心知识，旨在帮助读者建立一套分析算法效率的完整框架。

核心概念 ：时间复杂度是一个函数，它定量描述了算法随数据规模增长带来的执行时间增长趋势 。其本质是计算算法中基本操作的执行次数，而非精确的运行时间。
表示方法 ：采用 大O渐进表示法，其核心在于抓大放小，简化分析。牢牢掌握其三大推导法则：
- 用1取代所有加法常数
- 只保留最高阶项
- 去除最高阶项的系数
分析方法 ：通过分析循环、递归等核心代码结构，建立执行次数与问题规模N之间的数学关系，并最终用大O表示法化简。
常见复杂度 ：必须熟悉并理解其增长趋势，牢记其效率排序：
O(1) < O(logn) < O(n) < O(nlogn) < O(n²) < O(n³) < O(2ⁿ) < O(n!)
实战关键 ：在实际分析和面试中，没有特别说明时，时间复杂度一律按最坏情况来考量 ，这为我们提供了性能保障的底线。

今天的干货分享到这里就结束啦！如果觉得文章还可以的话，希望能给个三连支持一下，聆风吟的主页还有很多有趣的文章，欢迎小伙伴们前去点评，您的支持就是作者前进的最大动力！

【数据结构手札】时间复杂度详解：概念 | 大O渐进表示法 | 习题

文章目录

📚专栏订阅推荐

📋往期回顾：复杂度的概念

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

1.1 🔔算法的时间复杂度定义

1.2 🔔大O的渐进表示法

1.3 🔔常见的时间复杂度

1.4 🔔最好情况、最坏情况与平均情况

二. ⛳️常见时间复杂度计算举例

1️⃣实例一

2️⃣实例二

3️⃣实例三

4️⃣实例四

5️⃣实例五

6️⃣实例六

7️⃣实例七

8️⃣实例八

📝全文总结