时间复杂度
概念定义
根据定义，时间复杂度指输入数据大小为 N 时，算法运行所需花费的时间。需要注意：（重点在输入数据的大小上，如果跟输入数据无关则不考虑）
统计的是算法的「计算操作数量」，而不是「运行的绝对时间」。计算操作数量和运行绝对时间呈正相关关系，并不相等。算法运行时间受到「编程语言 、计算机处理器速度、运行环境」等多种因素影响。例如，
同样的算法使用 Python 或 C++ 实现、使用 CPU 或 GPU 、使用本地 IDE 或力扣平台提交，运行时间都不同。
体现的是计算操作随数据大小 N 变化时的变化情况。假设算法运行总共需要「 1次操作」、「100 次操作」，此两情况的时间复杂度都为常数级 O(1) ；需要「 N 次操作」、「 100N次操作」的时间复杂度都为O(N)。
常见的时间复杂度的排序：
O(1)<O(logN)<O(N)<O(NlogN)<O(N2)<O(2N)<O(N!)
常数 O(1)：运行次数与 N 大小呈常数关系，即不随输入数据大小 N的变化而变化。
int algorithm(int N) {
int a = 1; int b = 2; int x = a * b + N; return 1; }
运行次数与 N 大小呈常数关系，即不随输入数据大小 N 的变化而变化。
int algorithm(int N) {
int count = 0; int a = 10000; for (int i = 0; i < a; i++) { count++; } return count; }
对于以上代码，无论 a 取多大，都与输入数据大小无关，因此时间复杂度仍为 O(1)。
线性 O(N) ：循环运行次数与 N 大小呈线性关系，时间复杂度为 O(N) 。
对于以下代码，虽然是两层循环，但第二层与 N大小无关，因此整体仍与 N呈线性关系。
int algorithm(int N) {
int count = 0; int a = 10000; for (int i = 0; i < N; i++) { for (int j = 0; j < a; j++) { count++; } } return count; }
平方 O(N^2) ：两层循环相互独立，都与 N呈线性关系，因此总体与 N 呈平方关系，时间复杂度为 O(N^2)。
以冒泡排序为例，其包含了两层相互独立的循环。
1、第一层循环的复杂度为O（N）
2、第二层循环的复杂度为O（N）
因为冒泡排序的总体时间复杂度为O（N2）
int[] bubbleSort(int[] nums) {
int N = nums.length; for (int i = 0; i < N - 1; i++) { for (int j = 0; j < N - 1 - i; j++) { if (nums[j] > nums[j + 1]) { int tmp = nums[j]; nums[j] = nums[j + 1]; nums[j + 1] = tmp; } } } return nums; }
指数 O(2^N) ：
生物学科中的 “细胞分裂” 即是指数级增长。初始状态为 1 个细胞，分裂一轮后为 2 个，分裂两轮后为 4 个，……，分裂 N 轮后有 2^N个细胞。
算法中，指数阶常出现于递归，算法原理图与代码如下所示。
int algorithm(int N) {
if (N <= 0) return 1; int count_1 = algorithm(N - 1); int count_2 = algorithm(N - 1); return count_1 + count_2; }
阶乘 O(N!) ：
阶乘阶对应数学上常见的 “全排列” 。即给定 N 个互不重复的元素，求其所有可能的排列方案，则方案数量为：
N×(N−1)×(N−2)×⋯×2×1=N!
如下图与代码所示，阶乘常使用递归实现，算法原理：第一层分裂出 N 个，第二层分裂出 N - 1 个，…… ，直至到第 N 层时终止并回溯。
int algorithm(int N) {
if (N <= 0) return 1; int count = 0; for (int i = 0; i < N; i++) { count += algorithm(N - 1); } return count; }
对数 O(logN) ：
对数阶与指数阶相反，指数阶为 “每轮分裂出两倍的情况” ，而对数阶是 “每轮排除一半的情况” 。对数阶常出现于「二分法」、「分治」等算法中，体现着 “一分为二” 或 “一分为多” 的算法思想。
设循环次数为 m ，则输入数据大小 N与 2 ^ m呈线性关系，两边同时取 log_2对数，则得到循环次数 m与 log2N 呈线性关系，即时间复杂度为 O(logN) 。
int algorithm(int N) {
int count = 0; float i = N; while (i > 1) { i = i / 2; count++; } return count; }
线性对数 O(NlogN) ：
两层循环相互独立，第一层和第二层时间复杂度分别为O(logN) 和O(N) ，则总体时间复杂度为 O(NlogN) ；
int algorithm(int N) {
int count = 0; float i = N; while (i > 1) { i = i / 2; for (int j = 0; j < N; j++) count++; } return count; }
空间复杂度
概念定义
空间复杂度涉及的空间类型有：
输入空间： 存储输入数据所需的空间大小；
暂存空间： 算法运行过程中，存储所有中间变量和对象等数据所需的空间大小；
输出空间： 算法运行返回时，存储输出数据所需的空间大小；
通常情况下，空间复杂度指在输入数据大小为 NN 时，算法运行所使用的「暂存空间」+「输出空间」的总体大小。
根据来源不同，算法使用的内存空间分为三类：
指令空间：编译后，程序指令使用的内存空间。
数据空间：算法中的各项变量使用的空间，包括：声明的常量、变量、动态数组、动态对象等使用的内存空间。
栈帧空间：程序调用函数是基于栈实现的，函数在调用期间，占用常量大小的栈帧空间，直至返回后释放。如以下代码所示，在循环中调用函数，每轮调用 test() 返回后，栈帧空间已被释放，因此空间复杂度仍为 O(1) 。
符号表示
通常情况下，空间复杂度统计算法在 “最差情况” 下使用的空间大小，以体现算法运行所需预留的空间量，使用符号 O 表示。
最差情况有两层含义，分别为「最差输入数据」、算法运行中的「最差运行点」。例如以下代码：
最差输入数据： 当 N≤10 时，数组 nums 的长度恒定为 10 ，空间复杂度为 O(10) = O(1)=O(1) ；当 N>10 时，数组 nums 长度为 N ，空间复杂度为 O(N) ；因此，空间复杂度应为最差输入数据情况下的 O(N) 。
最差运行点： 在执行 nums = [0] * 10 时，算法仅使用 O(1)大小的空间；而当执行 nums = [0] * N 时，算法使用 O(N) 的空间；因此，空间复杂度应为最差运行点的 O(N) 。
常数O（1）
普通常量、变量、对象、元素数量与输入数据大小 NN 无关的集合，皆使用常数大小的空间。
void algorithm(int N) {
int num = 0; int[] nums = new int[10000]; Node node = new Node(0); Map<Integer, String> dic = new HashMap<>() {{ put(0, "0"); }}; }
如以下代码所示，虽然函数 test() 调用了 N次，但每轮调用后 test() 已返回，无累计栈帧空间使用，因此空间复杂度仍为O(1) 。
void algorithm(int N) {
for (int i = 0; i < N; i++) { test(); } }
线性 O(N) ：
元素数量与 N呈线性关系的任意类型集合（常见于一维数组、链表、哈希表等），皆使用线性大小的空间。
void algorithm(int N) {
int[] nums_1 = new int[N]; int[] nums_2 = new int[N / 2]; List<Node> nodes = new ArrayList<>(); for (int i = 0; i < N; i++) { nodes.add(new Node(i)); } Map<Integer, String> dic = new HashMap<>(); for (int i = 0; i < N; i++) { dic.put(i, String.valueOf(i)); } }
如下图与代码所示，此递归调用期间，会同时存在 N 个未返回的 algorithm() 函数，因此使用O(N) 大小的栈帧空间。
int algorithm(int N) {
if (N <= 1) return 1; return algorithm(N - 1) + 1; }
平方 O(N^2) ：
元素数量与 N 呈平方关系的任意类型集合（常见于矩阵），皆使用平方大小的空间。
void algorithm(int N) {
int num_matrix[][] = new int[N][N]; List<List<Node>> node_matrix = new ArrayList<>(); for (int i = 0; i < N; i++) { List<Node> nodes = new ArrayList<>(); for (int j = 0; j < N; j++) { nodes.add(new Node(j)); } node_matrix.add(nodes); } }
如下图与代码所示，递归调用时同时存在 N个未返回的 algorithm() 函数，使用 O(N) 栈帧空间；每层递归函数中声明了数组，平均长度为N/2 使用 O(N)空间；因此总体空间复杂度为 O(N^2)。
int algorithm(int N) {
if (N <= 0) return 0; int[] nums = new int[N]; return algorithm(N - 1); }
指数 O(2^N)
指数阶常见于二叉树、多叉树。例如，高度为 N 的「满二叉树」的节点数量为 2^N，占用 O(2^N)大小的空间；同理，高度为 N 的「满 m 叉树」的节点数量为 m^N，占用 O(m^N) = O(2^N)=O(2N) 大小的空间。
对数 O(logN) ：
对数阶常出现于分治算法的栈帧空间累计、数据类型转换等，例如：快速排序 ，平均空间复杂度为 Θ(logN) ，最差空间复杂度为 O(N)。拓展知识：通过应用 Tail Call Optimization ，可以将快速排序的最差空间
复杂度限定至 O(N) 。
数字转化为字符串 ，设某正整数为 N ，则字符串的空间复杂度为O(logN) 。推导如下：正整数 N的位数为log10N ，即转化的字符串长度为 log10N ，因此空间复杂度为 O(logN) 。
时空权衡
对于算法的性能，需要从时间和空间的使用情况来综合评价。优良的算法应具备两个特性，即时间和空间复杂度皆较低。而实际上，对于某个算法问题，同时优化时间复杂度和空间复杂度是非常困难的。降低时间复杂度，往往是以提升空间复杂度为代价的，反之亦然。
由于当代计算机的内存充足，通常情况下，算法设计中一般会采取「空间换时间」的做法，即牺牲部分计算机存储空间，来提升算法的运行速度。