数据结构之----算法简单介绍

什么是算法？

算法是指在有限的时间内得出想要的结果的一组指令或者是操作步骤。

算法特性：

• 问题是明确的，包含清晰的输入和输出定义。
• 具有可行性，能够在有限步骤、时间和内存空间下完成。
• 各步骤都有确定的含义，相同的输入和运行条件下，输出始终相同。

什么是数据结构？

数据结构是指计算机中组织和存储数据的方式。

数据机构设计目标：

• 空间占用尽量减少，从而节省计算机内存。
• 数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。
• 提供简洁的数据表示和逻辑信息，以便使得算法高效运行。

数据结构设计是一个充满权衡的过程。如果想要在某方面取得提升，往往需要在另一方面作出妥协。
如：

• 链表相较于数组，在数据添加和删除操作上更加便捷，但牺牲了数据访问速度。
• 图相较于链表，提供了更丰富的逻辑信息，但需要占用更大的内存空间。

数据结构与算法的关系？

• 数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及用于操作数据的方法。
• 算法是数据结构发挥作用的舞台。数据结构本身仅存储数据信息，结合算法才能解决特定问题。
• 算法通常可以基于不同的数据结构进行实现，但执行效率可能相差很大，选择合适的数据结构是关键。

如何评判算法的效率？

在算法设计中，我们先后追求以下两个层面的目标。

1. 找到问题解法：算法需要在规定的输入范围内，可靠地求得问题的正确解。
2. 寻求最优解法：同一个问题可能存在多种解法，我们希望找到尽可能高效的算法。

也就是说，在能够解决问题的前提下，算法效率已成为衡量算法优劣的主要评价指标，它包括以下两个维度。

• 时间效率：算法运行速度的快慢。
• 空间效率：算法占用内存空间的大小。

简而言之，我们的目标是设计既快又省的数据结构与算法。而有效地评估算法效率至关重要，因为只有这样我们才能将各种算法进行对比，从而指导算法设计与优化过程。

效率评估方法主要分为两种：实际测试、理论估算。

什么是实际测试？

假设我们现在有算法 A 和算法 B ，它们都能解决同一问题，现在需要对比这两个算法的效率。最直接的方法是找一台计算机，运行这两个算法，并监控记录它们的运行时间和内存占用情况。这种评估方式能够反映真实情况，但也存在较大局限性。

• 一方面，难以排除测试环境的干扰因素。硬件配置会影响算法的性能表现。比如在某台计算机中，算法 A 的运行时间比算法 B 短；但在另一台配置不同的计算机中，我们可能得到相反的测试结果。这意味着我们需要在各种机器上进行测试，统计平均效率，而这是不现实的。
• 另一方面，展开完整测试非常耗费资源。随着输入数据量的变化，算法会表现出不同的效率。例如，在输入数据量较小时，算法 A 的运行时间比算法 B 更少；而输入数据量较大时，测试结果可能恰恰相反。因此，为了得到有说服力的结论，我们需要测试各种规模的输入数据，而这需要耗费大量的计算资源。

什么是理论估算？

由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为「渐近复杂度分析 asymptotic complexity analysis」，简称「复杂度分析」。

复杂度分析体现算法运行所需的时间（空间）资源与输入数据大小之间的关系。它描述了随着输入数据大小的增加，算法执行所需时间和空间的增长趋势。这个定义有些拗口，我们可以将其分为三个重点来理解。

• 时间和空间资源：分别对应「时间复杂度 time complexity」和「空间复杂度 space complexity」。
• 随着输入数据大小的增加：意味着复杂度反映了算法运行效率与输入数据体量之间的关系。
• 时间和空间的增长趋势：表示复杂度分析关注的不是运行时间或占用空间的具体值，而是时间或空间增长的快慢。

复杂度分析克服了实际测试方法的弊端，体现在以下两个方面。

• 它独立于测试环境，分析结果适用于所有运行平台。
• 它可以体现不同数据量下的算法效率，尤其是在大数据量下的算法性能。

什么是算法的时间复杂度？

时间复杂度是指运行时间随着数据量变大时的增长趋势。

什么是时间增长趋势？

这个概念比较抽象，我们通过一个例子来加以理解。假设输入数据大小为 𝑛 ，给定三个算法函数 A、B 和 C ：

// 算法 A 的时间复杂度：常数阶
void algorithm_A(int n) {
	System.out.println(0);
}
// 算法 B 的时间复杂度：线性阶
void algorithm_B(int n) {
	for (int i = 0; i < n; i++) {
		System.out.println(0);
	}
}
// 算法 C 的时间复杂度：常数阶
void algorithm_C(int n) {
	for (int i = 0; i < 1000000; i++) {
		System.out.println(0);
	}
}

• 算法 A 只有 1 个打印操作，算法运行时间不随着 𝑛 增大而增长。我们称此算法的时间复杂度为常数阶。
• 算法 B 中的打印操作需要循环 𝑛 次，算法运行时间随着 𝑛 增大呈线性增长。此算法的时间复杂度被称为线性阶。
• 算法 C 中的打印操作需要循环 1000000 次，虽然运行时间很长，但它与输入数据大小 𝑛 无关。因此 C的时间复杂度和 A 相同，仍为常数阶。

时间复杂度分析有什么特点？

1. 时间复杂度能够有效评估算法效率。例如，算法 B 的运行时间呈线性增长，在 𝑛 > 1 时比算法 A 更慢，在 𝑛 > 1000000 时比算法 C 更慢。事实上，只要输入数据大小 𝑛 足够大，复杂度为常数阶的算法一定优于线性阶的算法，这正是时间增长趋势所表达的含义。
2. 时间复杂度的推算方法更简便。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的 单位时间 ，从而将 计算操作的运行时间的统计 简化为 计算操作的数量的统计 ，这样一来估算难度就大大降低了。
3. 时间复杂度也存在一定的局限性。例如，尽管算法 A 和 C 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 B 的时间复杂度比 C 高，但在输入数据大小 𝑛 较小时，算法 B 明显优于算法 C 。在这些情况下，我们很难仅凭时间复杂度判断算法效率的高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。

如何计算时间复杂度？

计算时间复杂度分为两步，首先统计操作数量，然后判断函数的渐近上界。

什么是函数的渐近上界？

给定一个输入大小为 𝑛 的函数：

void algorithm(int n) {
	int a = 1; // +1
	a = a + 1; // +1
	a = a * 2; // +1
	// 循环 n 次
	for (int i = 0; i < n; i++) { // +1（每轮都执行 i ++）
		System.out.println(0); // +1
	}
}

设算法的操作数量是一个关于输入数据大小 𝑛 的函数，记为$\mathrm{T}$(𝑛) ，则以上函数的的操作数量为：

$\mathrm{T}$(𝑛) 是一次函数，说明其运行时间的增长趋势是线性的，因此它的时间复杂度是线性阶。

我们将线性阶的时间复杂度记为 $\mathrm{O}$(𝑛) ，这个数学符号称为「大 $\mathrm{O}$ 记号 big‑𝑂 notation」，表示函数 $\mathrm{T}$(𝑛)的「渐近上界 asymptotic upper bound」。

时间复杂度分析本质上是计算 操作数量函数 $\mathrm{T}$(𝑛) 的渐近上界，其具有明确的数学定义。

计算渐近上界就是寻找一个函数 𝑓(𝑛) ，使得当 𝑛 趋向于无穷大时，$\mathrm{T}$(𝑛) 和 𝑓(𝑛) 处于相同的增长级别，仅相差一个常数项 𝑐 的倍数。

如何统计操作数量？

针对代码，逐行从上到下计算即可。然而，由于上述 𝑐 ⋅ 𝑓(𝑛) 中的常数项 𝑐 可以取任意大小，因此操作数量$\mathrm{T}$(𝑛) 中的各种系数、常数项都可以被忽略。

根据此原则，可以总结出以下计数简化技巧：

1. 忽略 $\mathrm{T}$(𝑛) 中的常数项。因为它们都与 𝑛 无关，所以对时间复杂度不产生影响。
2. 省略所有系数。例如，循环 2𝑛 次、5𝑛 + 1 次等，都可以简化记为 𝑛 次，因为 𝑛 前面的系数对时间复杂度没有影响。
3. 循环嵌套时使用乘法。总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用第 1点和第 2点的技巧。

例：

void algorithm(int n) {
	int a = 1; // +0（技巧 1）
	a = a + n; // +0（技巧 1）
	// +n（技巧 2）
	for (int i = 0; i < 5 * n + 1; i++) {
		System.out.println(0);
	}
	// +n*n（技巧 3）
	for (int i = 0; i < 2 * n; i++) {
		for (int j = 0; j < n + 1; j++) {
			System.out.println(0);
		}
	}
}

得出：

如何判断函数的渐进上界？

时间复杂度由多项式$\mathrm{T}$(𝑛) 中最高阶的项来决定。这是因为在 𝑛 趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。

时间复杂度类型都有哪些？

1.常数阶 $\mathrm{O}$(1)

常数阶的操作数量与输入数据大小 𝑛 无关，即不随着 𝑛 的变化而变化。
在以下函数中，尽管操作数量 size 可能很大，但由于其与输入数据大小 𝑛 无关，因此时间复杂度仍为 $\mathrm{O}$(1)：

/* 常数阶 */
int constant(int n) {
	int count = 0;
	int size = 100000;
	for (int i = 0; i < size; i++){
		count++;
	}
	return count;
}

2.线性阶 $\mathrm{O}$(𝑛)

线性阶的操作数量相对于输入数据大小 𝑛 以线性级别增长。
线性阶通常出现在单层循环中：

/* 线性阶 */
int linear(int n) {
	int count = 0;
	for (int i = 0; i < n; i++){
		count++;
	}
	return count;
}

其中，遍历数组和遍历链表等操作的时间复杂度均为 $\mathrm{O}$(𝑛) ，其中 𝑛 为数组或链表的长度：

/* 线性阶（遍历数组） */
int arrayTraversal(int[] nums) {
	int count = 0;
	// 循环次数与数组长度成正比
	for (int num : nums) {
		count++;
	}
	return count;
}

值得注意的是，输入数据大小 𝑛 需根据输入数据的类型来具体确定。比如在第一个示例中，变量 𝑛 为输入数据大小；在第二个示例中，数组长度 𝑛 为数据大小。

3. 平方阶 $\mathrm{O}$(𝑛²)

平方阶的操作数量相对于输入数据大小 𝑛 以平方级别增长。
平方阶通常出现在嵌套循环中，外层循环和内层循环都为$\mathrm{O}$(𝑛) ，因此总体为$\mathrm{O}$(𝑛²) ：

/* 平方阶 */
int quadratic(int n) {
	int count = 0;
	// 循环次数与数组长度成平方关系
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			count++;
		}
	}
	return count;
}

常数阶、线性阶和平方阶三种时间复杂度的对比：

以冒泡排序为例，外层循环执行 𝑛 − 1 次，内层循环执行 𝑛 − 1、𝑛 − 2、…、2、1 次，平均为 𝑛/2 次，因此时间复杂度为 $\mathrm{O}$((𝑛 − 1)𝑛/2) = $\mathrm{O}$(𝑛²) 。

/* 平方阶（冒泡排序） */
int bubbleSort(int[] nums) {
	int count = 0; // 计数器
	// 外循环：未排序区间为 [0, i]
	for (int i = nums.length - 1; i > 0; i--) {
		// 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
		for (int j = 0; j < i; j++) {
			if (nums[j] > nums[j + 1]) {
				// 交换 nums[j] 与 nums[j + 1]
				int tmp = nums[j];
				nums[j] = nums[j + 1];
				nums[j + 1] = tmp;
				count += 3; // 元素交换包含 3 个单元操作
			}
		}
	}
	return count;
}

4. 指数阶 $\mathrm{O}$(2^𝑛)

生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 1 个细胞，分裂一轮后变为 2 个，分裂 两轮后变为 4 个，以此类推，分裂 𝑛 轮后有 2^𝑛 个细胞。

以下代码模拟了细胞分裂的过程，时间复杂度为 $\mathrm{O}$(2^𝑛):

/* 指数阶（循环实现） */
int exponential(int n) {
	int count = 0, base = 1;
	// 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < base; j++) {
			count++;
		}
		base *= 2;
	}
	// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
	return count;
}

在实际算法中，指数阶常出现于递归函数中。

例如在以下代码中，其递归地一分为二，经过 𝑛 次分裂后停止：

/* 指数阶（递归实现） */
int expRecur(int n) {
	if (n == 1){
		return 1;
	}
	return expRecur(n - 1) + expRecur(n - 1) + 1;
}

指数阶增长非常迅速，在穷举法（暴力搜索、回溯等）中比较常见。对于数据规模较大的问题，指数阶是不可接受的，通常需要使用动态规划或贪心等算法来解决。

5.对数阶 $\mathrm{O}$($\log$ 𝑛)

与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 𝑛 ，由于每轮缩减到一半，因此循环次数是 $\log$ 2𝑛 ，即 2𝑛 的反函数。

以下代码模拟了每轮缩减到一半的过程，时间复杂度为 $\mathrm{O}$($\log$ 2𝑛) ，简记为 $\mathrm{O}$($\log$ 𝑛)。

/* 对数阶（循环实现） */
int logarithmic(float n) {
	int count = 0;
	while (n > 1) {
		n = n / 2;
		count++;
	}
	return count;
}

与指数阶类似，对数阶也常出现于递归函数中。以下代码形成了一个高度为 $\log$ 2𝑛 的递归树：

/* 对数阶（递归实现） */
int logRecur(float n) {
	if (n <= 1){
		return 0;
	}
	return logRecur(n / 2) + 1;
}

对数阶常出现于基于分治策略的算法中，体现了 一分为多 和 化繁为简 的算法思想。它增长缓慢，是
仅次于常数阶的理想的时间复杂度。

$\mathrm{O}$($\log$ 𝑛) 的底数是多少？
准确来说，“一分为 𝑚” 对应的时间复杂度是 $\mathrm{O}$(${\log }_m$ 𝑛) 。而通过对数换底公式，我们可以得到具有不同底数的、相等的时间复杂度：

也就是说，底数 𝑚 可以在不影响复杂度的前提下转换。因此我们通常会省略底数 𝑚 ，将对数阶直接记为$\mathrm{O}$($\log$ 𝑛) 。

6.线性对数阶 $\mathrm{O}$(𝑛 $\log$ 𝑛)

线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为$\mathrm{O}$($\log$ 𝑛) 和 $\mathrm{O}$( 𝑛) 。相关代码如下：

/* 线性对数阶 */
int linearLogRecur(float n) {
	if (n <= 1){
		return 1;
	}
	int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
	for (int i = 0; i < n; i++) {
		count++;
	}
	return count;
}

下图展示了线性对数阶的生成方式。二叉树的每一层的操作总数都为 𝑛 ，树共有${\log }_2$𝑛 + 1 层，因此时间复杂度为 $\mathrm{O}$(𝑛 $\log$ 𝑛)。

主流排序算法的时间复杂度通常为$\mathrm{O}$(𝑛 $\log$ 𝑛)，例如快速排序、归并排序、堆排序等。

7.阶乘阶 $\mathrm{O}$(𝑛!)

阶乘阶对应数学上的“全排列”问题。给定 𝑛 个互不重复的元素，求其所有可能的排列方案，方案数量为：

阶乘通常使用递归实现。如图与代码所示，第一层分裂出 𝑛 个，第二层分裂出 𝑛 − 1 个，以此类推，直至第 𝑛 层时停止分裂：

/* 阶乘阶（递归实现） */
int factorialRecur(int n) {
	if (n == 0){
	return 1;
	}
	int count = 0;
	// 从 1 个分裂出 n 个
	for (int i = 0; i < n; i++) {
		count += factorialRecur(n - 1);
	}
	return count;
}

注意，因为当 𝑛 ≥ 4 时恒有 𝑛! > 2𝑛 ，所以阶乘阶比指数阶增长得更快，在 𝑛 较大时也是不可接的。

什么是最差、最佳、平均时间复杂度?

算法的时间效率往往不是固定的，而是与输入数据的分布有关。假设输入一个长度为 𝑛 的数组nums ，其中nums 由从 1 至 𝑛 的数字组成，每个数字只出现一次；但元素顺序是随机打乱的，任务目标是返回元素 1 的索引。我们可以得出以下结论。

• 当 nums = [?, ?, …, 1] ，即当末尾元素是 1 时，需要完整遍历数组，达到最差时间复杂度 $\mathrm{O}$(𝑛) 。
• 当 nums = [1, ?, ?, …] ，即当首个元素为 1 时，无论数组多长都不需要继续遍历，达到最佳时间复杂度$\Omega$(1) 。

最差时间复杂度对应函数渐近上界，使用 $\mathrm{O}$表示。相应地，最佳时间复杂度对应函数渐近下界，用 $\Omega$ 表示：

/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
int[] randomNumbers(int n) {
	Integer[] nums = new Integer[n];
	// 生成数组 nums = { 1, 2, 3, ..., n }
	for (int i = 0; i < n; i++) {
		nums[i] = i + 1;
	}
	// 随机打乱数组元素
	Collections.shuffle(Arrays.asList(nums));
	// Integer[] -> int[]
	int[] res = new int[n];
	for (int i = 0; i < n; i++) {
		res[i] = nums[i];
	}
	return res;
}


/* 查找数组 nums 中数字 1 所在索引 */
int findOne(int[] nums) {
	for (int i = 0; i < nums.length; i++) {
		// 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
		// 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
		if (nums[i] == 1){
			return i;
		}
	}
	return -1;
}

值得说明的是，我们在实际中很少使用最佳时间复杂度，因为通常只有在很小概率下才能达到，可能会带来一定的误导性。而最差时间复杂度更为实用，因为它给出了一个效率安全值，让我们可以放心地使用算法。

从上述示例可以看出，最差或最佳时间复杂度只出现于 特殊的数据分布 ，这些情况的出现概率可能很小，并不能真实地反映算法运行效率。相比之下，平均时间复杂度可以体现算法在随机输入数据下的运行效率，用 $\Theta$ 记号来表示。

对于部分算法，我们可以简单地推算出随机数据分布下的平均情况。比如上述示例，由于输入数组是被打乱的，因此元素 1 出现在任意索引的概率都是相等的，那么算法的平均循环次数就是数组长度的一半 𝑛/2 ，平均时间复杂度为 $\Theta$ (𝑛/2) =$\Theta$ (𝑛) 。

但对于较为复杂的算法，计算平均时间复杂度往往是比较困难的，因为很难分析出在数据分布下的整体数学期望。在这种情况下，我们通常使用最差时间复杂度作为算法效率的评判标准。

什么是算法的空间复杂度？

「空间复杂度 space complexity」用于衡量算法占用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似，只需将 运行时间 替换为 占用内存空间 。

什么是算法相关空间？

算法在运行过程中使用的内存空间主要包括以下几种：

• 输入空间：用于存储算法的输入数据。
• 暂存空间：用于存储算法在运行过程中的变量、对象、函数上下文等数据。
• 输出空间：用于存储算法的输出数据。

一般情况下，空间复杂度的统计范围是 暂存空间 加上 输出空间 。

暂存空间可以进一步划分为三个部分：

• 暂存数据：用于保存算法运行过程中的各种常量、变量、对象等。
• 栈帧空间：用于保存调用函数的上下文数据。系统在每次调用函数时都会在栈顶部创建一个栈帧，函数返回后，栈帧空间会被释放。
• 指令空间：用于保存编译后的程序指令，在实际统计中通常忽略不计。

在分析一段程序的空间复杂度时，我们通常统计暂存数据、栈帧空间和输出数据三部分。

/* 类 */
class Node {
	int val;
	Node next;
	Node(int x) { 
		val = x; 
	}
}
/* 函数 */
int function() {
	// 执行某些操作...
	return 0;
}

int algorithm(int n) { // 输入数据
	final int a = 0; // 暂存数据（常量）
	int b = 0; // 暂存数据（变量）
	Node node = new Node(0); // 暂存数据（对象）
	int c = function(); // 栈帧空间（调用函数）
	return a + b + c; // 输出数据
}

空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从操作数量转为 使用空间大小 。

而与时间复杂度不同的是，我们通常只关注最差空间复杂度。这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。

最差空间复杂度中的 最差 有两层含义：

1. 以最差输入数据为准：当 𝑛 < 10 时，空间复杂度为 $\mathrm{O}$(1) ；但当 𝑛 > 10 时，初始化的数组 nums 占用 $\mathrm{O}$(𝑛) 空间；因此最差空间复杂度为 $\mathrm{O}$(𝑛) 。
2. 以算法运行中的峰值内存为准：例如，程序在执行最后一行之前，占用 $\mathrm{O}$(1) 空间；当初始化数组 nums时，程序占用 $\mathrm{O}$(𝑛) 空间；因此最差空间复杂度为 $\mathrm{O}$(𝑛) 。

void algorithm(int n) {
	int a = 0; // O(1)
	int[] b = new int[10000]; // O(1)
	if (n > 10){
		int[] nums = new int[n]; // O(n)
	}
}

在递归函数中，需要注意统计栈帧空间。例如在以下代码中：

• 函数 loop() 在循环中调用了 𝑛 次 function() ，每轮中的 function() 都返回并释放了栈帧空间，因此空间复杂度仍为 𝑂(1) 。
• 递归函数 recur() 在运行过程中会同时存在 𝑛 个未返回的 recur() ，从而占用 𝑂(𝑛) 的栈帧空间。

int function() {
	// 执行某些操作
	return 0;
}

/* 循环 O(1) */
void loop(int n) {
	for (int i = 0; i < n; i++) {
		function();
	}
}

/* 递归 O(n) */
void recur(int n) {
	if (n == 1) return;
	return recur(n - 1);
}

空间复杂度类型都有哪些？

1.常数阶 $\mathrm{O}$(1)

常数阶常见于数量与输入数据大小 𝑛 无关的常量、变量、对象。

需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，因此不会累积占用空间，空间复杂度仍为 𝑂(1) ：

/* 函数 */
int function() {
	// 执行某些操作
	return 0;
}

/* 常数阶 */
void constant(int n) {
	// 常量、变量、对象占用 O(1) 空间
	final int a = 0;
	int b = 0;
	int[] nums = new int[10000];
	ListNode node = new ListNode(0);
	// 循环中的变量占用 O(1) 空间
	for (int i = 0; i < n; i++) {
		int c = 0;
	}
	// 循环中的函数占用 O(1) 空间
	for (int i = 0; i < n; i++) {
		function();
	}
}

2.线性阶 $\mathrm{O}$(𝑛)

线性阶常见于元素数量与 𝑛 成正比的数组、链表、栈、队列等：

/* 线性阶 */
void linear(int n) {
	// 长度为 n 的数组占用 O(n) 空间
	int[] nums = new int[n];
	// 长度为 n 的列表占用 O(n) 空间
	List<ListNode> nodes = new ArrayList<>();
	for (int i = 0; i < n; i++) {
		nodes.add(new ListNode(i));
	}
	// 长度为 n 的哈希表占用 O(n) 空间
	Map<Integer, String> map = new HashMap<>();
	for (int i = 0; i < n; i++) {
		map.put(i, String.valueOf(i));
	}
}

此函数的递归深度为 𝑛 ，即同时存在 𝑛 个未返回的 linear_recur() 函数，使用 $\mathrm{O}$(𝑛) 大小
的栈帧空间：

/* 线性阶（递归实现） */
void linearRecur(int n) {
	System.out.println(" 递归 n = " + n);
	if (n == 1) return;
	linearRecur(n - 1);
}

3. 平方阶 $\mathrm{O}$(𝑛²)

平方阶常见于矩阵和图，元素数量与 𝑛 成平方关系：

/* 平方阶 */
void quadratic(int n) {
	// 矩阵占用 O(n^2) 空间
	int[][] numMatrix = new int[n][n];
	// 二维列表占用 O(n^2) 空间
	List<List<Integer>> numList = new ArrayList<>();
	for (int i = 0; i < n; i++) {
		List<Integer> tmp = new ArrayList<>();
		for (int j = 0; j < n; j++) {
			tmp.add(0);
		}
		numList.add(tmp);
	}
}

该函数的递归深度为 𝑛 ，在每个递归函数中都初始化了一个数组，长度分别为 𝑛、𝑛 − 1、…、2、1 ，平均长度为 𝑛/2 ，因此总体占用$\mathrm{O}$(𝑛²) 空间：

/* 平方阶（递归实现） */
int quadraticRecur(int n) {
	if (n <= 0) return 0;
	// 数组 nums 长度为 n, n-1, ..., 2, 1
	int[] nums = new int[n];
	System.out.println(" 递归 n = " + n + " 中的 nums 长度 = " + nums.length);
	return quadraticRecur(n - 1);
}

4. 指数阶 $\mathrm{O}$(2^𝑛)

指数阶常见于二叉树。观察图得，高度为 𝑛 的“满二叉树”的节点数量为 2𝑛 − 1 ，占用 $\mathrm{O}$(2^𝑛)空间：

/* 指数阶（建立满二叉树） */
TreeNode buildTree(int n) {
	if (n == 0) return null;
	TreeNode root = new TreeNode(0);
	root.left = buildTree(n - 1);
	root.right = buildTree(n - 1);
	return root;
}

5.对数阶 $\mathrm{O}$($\log$ 𝑛)

对数阶常见于分治算法。例如归并排序，输入长度为 𝑛 的数组，每轮递归将数组从中点划分为两半，形成高度为 $\log$ 的递归树，使用 $\mathrm{O}$($\log$ 𝑛)栈帧空间。

再例如将数字转化为字符串，输入一个正整数 𝑛 ，它的位数为 ${\log }_{10}$ 𝑛+1 ，即对应字符串长度为${\log }_{10}$ 𝑛+1，因此空间复杂度为$\mathrm{O}$(${\log }_{10}$ 𝑛) = $\mathrm{O}$($\log$ 𝑛) 。

怎么权衡时间与空间？

理想情况下，我们希望算法的时间复杂度和空间复杂度都能达到最优。然而在实际情况中，同时优化时间复杂度和空间复杂度通常是非常困难的。

降低时间复杂度通常需要以提升空间复杂度为代价，反之亦然。我们将牺牲内存空间来提升算法运行速度的思路称为以空间换时间；反之，则称为以时间换空间。

选择哪种思路取决于我们更看重哪个方面。在大多数情况下，时间比空间更宝贵，因此以空间换时间通常是更常用的策略。当然，在数据量很大的情况下，控制空间复杂度也是非常重要的。

总结

算法效率评估

• 时间效率和空间效率是衡量算法优劣的两个主要评价指标。
• 我们可以通过实际测试来评估算法效率，但难以消除测试环境的影响，且会耗费大量计算资源。
• 复杂度分析可以克服实际测试的弊端，分析结果适用于所有运行平台，并且能够揭示算法在不同数据规模下的效率。

时间复杂度

• 时间复杂度用于衡量算法运行时间随数据量增长的趋势，可以有效评估算法效率，但在某些情况下可能失效，如在输入的数据量较小或时间复杂度相同时，无法精确对比算法效率的优劣。
• 最差时间复杂度使用大 𝑂 符号表示，对应函数渐近上界，反映当 𝑛 趋向正无穷时，操作数量 𝑇(𝑛) 的增长级别。
• 推算时间复杂度分为两步，首先统计操作数量，然后判断渐近上界。
• 常见时间复杂度从小到大排列有 𝑂(1)、𝑂(log 𝑛)、𝑂(𝑛)、𝑂(𝑛 log 𝑛)、𝑂(𝑛2)、𝑂(2𝑛) 和 𝑂(𝑛!) 等。
• 某些算法的时间复杂度非固定，而是与输入数据的分布有关。时间复杂度分为最差、最佳、平均时间复杂度，最佳时间复杂度几乎不用，因为输入数据一般需要满足严格条件才能达到最佳情况。
• 平均时间复杂度反映算法在随机数据输入下的运行效率，最接近实际应用中的算法性能。计算平均时间复杂度需要统计输入数据分布以及综合后的数学期望。

空间复杂度

• 空间复杂度的作用类似于时间复杂度，用于衡量算法占用空间随数据量增长的趋势。
• 算法运行过程中的相关内存空间可分为输入空间、暂存空间、输出空间。通常情况下，输入空间不计入空间复杂度计算。暂存空间可分为指令空间、数据空间、栈帧空间，其中栈帧空间通常仅在递归函数中影响空间复杂度。
• 我们通常只关注最差空间复杂度，即统计算法在最差输入数据和最差运行时间点下的空间复杂度。
• 常见空间复杂度从小到大排列有 𝑂(1)、𝑂(log 𝑛)、𝑂(𝑛)、𝑂(𝑛2) 和 𝑂(2𝑛) 等。