数据结构与算法前置

数据结构绪论学习笔记：

简介

数据结构是一门研究非等值计算的程序设计问题的操作对象,以及他们之间的关系核操作等相关问题的学科。

简而言之数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。

数据

客观描述事务的符号，计算机中可以操作的对象，可以被计算机识别，并输入给计算机处理的符号集合。不仅仅包括整型、实型等数值类型，还包括字符、图像、视频等非数值型。前提为：

1. 可以被输入到计算机。
2. 可以被计算机程序处理。

数据元素

组成数据的有意义的基本单位，通常作为整体被称为记录。通俗来讲是一个类的子集，比如禽类的子集：鸭

数据项

一个数据元素可以由若干个数据项组成，数据详是数据不可分割的最小单位。

数据对象

性质相同的数据元素的集合，是数据的子集。

小结

数据结构是相互之间存在一种或者多种特定关系的数据元素的集合。

划分

逻辑结构

逻数据对象中元素之间的相互关系。

集合结构

元素中的数据元素除了同属于一个集合外，没有其他关系。

线性结构

线性结构中的数据元素之间是一对一的关系

树形结构

树型结构中的数据元素之间存在一种一对多的层次关系

图形数据结构

图形数据结构的元素是多对多的关系

物理结构

数据的逻辑结构在计算机中的存储形式

顺序结构存储:

数据元素存放在地址连续的存储单元内，数据之间的逻辑关系核物理关系是一致的。

链式存储结构

元素存放在任意的存储单元里，存储单元可以连续，也可以不连续。

抽象数据类型

一组性质相同的值的集合及定义在此几何上的一些操作的总称。

原子类型

不可以再分解的基本类型，包括整型、实型、字符型等。

结构类型

由若干个类型组合而成，是可以再分解的，比如整型数组是由若干个整型数据组成的。

算法

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

特性

输入输出

零个或多个输入，至少由一个或者多个输出。

有穷性

算法再执行有限步骤之后，自动结束而不是无限循环，并且每一个步骤要再可接受的时间内完成。

确定性

算法的每一步骤都具有具体的含义，不会出现二义性。即在相同的输入输出只能由相同的结果。

可行性

算法的每一步必须可行，每一步都能通过执行有限次数完成。

设计要求

正确性

算法至少应该具有输入、输出和加工处理无歧义性，能够正确反映问题的需求，能够得到问题的正确答案。

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

可读性

便于阅读理解、和交流。

健壮性

输入数据不合法时，算法能够做出相关处理，而不是产生异常或莫名奇妙的结果。

时间效率高和存储量低

时间效率是指算法执行的时间，对于同一个问题有多种算法解决。执行时间短的算法效率高，执行时间长的效率低。存储量需求是指在执行过程中需要的最大存储空间。设计算法应该要尽量满足时间效率高和存储量低的需求。

算法度量方法

事后统计方法

通过设计好的测试程序和数据，利用计算机计时对不同算法表程序运行的时间进行比较，从而确定算法效率的高低。

缺陷

1. 需要提前编制好程序。
2. 依赖计算机硬件和软件等环境。
3. 算法测试数据设计困难。

事前分析估算方法

计算机程序编制之前，需要统计方法对算法进行估算。

影响因素

高级语言程序编写的程序在计算机上运行时间取决于：

1. 算法采用的策略和方法 (根本)
2. 编译产生的代码质量
3. 问题输入的规模
4. 机器执行指令的熟度，

算法时间复杂度

语句总的执行次数$T(n)$是关于问题规模$n$的函数，进而分析$T(n)$随着$n$的情况变化而确定$T(n)$的规模级。算法的时间复杂度，也就是算法的时间度量，记作：$T(n)$=$O(f(n))$，它表示随着问题规模$n$的增大，算法的执行时间的增长率和$f(n)$的增长率相同，称作算法的逐渐时间复杂度，简称时间复杂度。其中$f(n)$是问题规模$n$的某个函数。

假设每行代码执行的时间都一样，为 unit_time。

1 2 3 4 5 6 7 8

int cal(int n) { int sum = 0; //执行一次 int i = 1; //执行一次 for (; i <= n; ++i) { //执行n次 sum = sum + i; //执行n次 } return sum; //总的时间复杂度为2n+2 }

1 2 3 4 5 6 7 8 9 10 11

int cal(int n) { int sum = 0; //执行一次 int i = 1; //执行一次 int j = 1; //执行一次 for (; i <= n; ++i) { //执行n次 j = 1; //执行n次 for (; j <= n; ++j) { //执行n*n次 sum = sum + i * j; //执行n*n次 } } //总的时间复杂度为2n^2+2n+3 }

注意：当$n$很大的时候，我们通常会忽略掉公式中的低阶、常量、系数三部分并不左右增长趋势，而公式中的低阶、常量、系数三部分并不左右增 长趋势，所以都可以忽略。我们只需要记录一个最大量级就可以了。

技巧

只关注循环执行次数最多的一段代码

1 2 3 4 5 6 7 8

int cal(int n) { int sum = 0; int i = 1; for (; i <= n; ++i) { //n次 sum = sum + i; // n 次 } return sum; } //去掉常数项系数O(n)

加法法则

总复杂度等于量级最大的那段代码的复杂度

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

int cal(int n) { int sum_1 = 0; int p = 1; for (; p < 100; ++p) { //常数 sum_1 = sum_1 + p; } int sum_2 = 0; int q = 1; for (; q < n; ++q) { //n次 sum_2 = sum_2 + q; //n次 } int sum_3 = 0; int i = 1; int j = 1; for (; i <= n; ++i) { //n次 j = 1; for (; j <= n; ++j) { // n^2 sum_3 = sum_3 + i * j; //n^2 } } return sum_1 + sum_2 + sum_3; }

$\mathrm{T} 1(\mathrm{n})=\mathrm{O}(\mathrm{f}(\mathrm{n}))$,$\mathrm{T} 2(\mathrm{n})=\mathrm{O}(\mathrm{g}(\mathrm{n}))$那么$T(n)=T 1(n)+T 2(n)=\max (O(n)), O(g(n)) )=O(\max (f(n)g(n) )$

乘法法则

嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

$\mathrm{T} 1(\mathrm{n})=\mathrm{O}(\mathrm{f}(\mathrm{n})), \quad \mathrm{T} 2(\mathrm{n})=\mathrm{O}(\mathrm{g}(\mathrm{n}))$那么$\mathrm{T}(\mathrm{n})=\mathrm{T} 1(\mathrm{n})^{\star} \mathrm{T} 2(\mathrm{n})=\mathrm{O}(\mathrm{f}(\mathrm{n}))^{\star} \mathrm{O}(\mathrm{g}(\mathrm{n}))=\mathrm{O}\left(\mathrm{f}(\mathrm{n})^{\star} \mathrm{g}(\mathrm{n})\right)$

假设$\mathrm{T} 1(\mathrm{n})=\mathrm{O}(\mathrm{n}), \quad \mathrm{T} 2(\mathrm{n})=\mathrm{O}\left(\mathrm{n}^{2}\right)$，那么$\mathrm{T} 1(\mathrm{n})^{*} \mathrm{T} 2(\mathrm{n})=\mathrm{O}\left(\mathrm{n}^{3}\right)$.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

int cal(int n) { int ret = 0; int i = 1; for (; i < n; ++i) { //n次 ret = ret + f(i); } } int f(int n) { int sum = 0; int i = 1; for (; i < n; ++i) { //n次 sum = sum + i; } return sum; }

常见复杂度

$O(1)$

O(1) 只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。也就是说算法执行的步骤是有限的。

1 2 3

int i = 8; int j = 6; int sum = i + j;

$O(\log n)$O($ nlogn $)

1 2 3 4

i=1; while (i <= n) { i = i * 2; }

这段代码停止的时的时候为i<=n,那么如何求n呢，

$2^02^12^22^32^42^52^62^62^7……..2^x$,通过我们学习的数学知识基本上可以知道$2^n=n$求解的答案，为

$x=\log _{2} n$,也就是说这段代码的时间复杂度为$O(log _{2} n)$

我们把代码改一下呢

1 2 3 4

i=1; while (i <= n) { i = i * 3; }

这段代码的时间复杂度就应该为$O\left(\log _{3} n\right)$，但是$\log _{3} n$=$\log _{3} 2^{} \log _{2} n$，$\mathrm{O}\left(\log _{3} n\right)=\mathrm{O}\left(\mathrm{C}^{}\right.$$\log _{2} n )$,其中$\mathrm{C}=\log _{3} 2$为常量，可忽略，即$O(C(n))=O(f(n))$,所以$\mathrm{O}\left(\log _{2} n\right)$等价于$\mathrm{O}\left(\log _{3} \mathrm{n}\right)$，因此在对数复杂度中，我们可以忽略底的对数，统一标识为$O(logn)$

$O(n \log n)$

一段代码的复杂度为$O(logn)$，我们循环执行n遍就是$O(n \log n)$。

$O(m+n)$

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

int cal(int m, int n) { int sum_1 = 0; int i = 1; for (; i < m; ++i) { sum_1 = sum_1 + i; } int sum_2 = 0; int j = 1; for (; j < n; ++j) { sum_2 = sum_2 + j; } return sum_1 + sum_2; }

m 和 n 是表示两个数据规模。我们无法事先评估 m 和 n 谁的量级大，所以我们在表示复杂度的时候，就不能简单地利用加法法则，省略掉其中一个。所以，上面代码的时间复杂 度就是 O(m+n)。

O(m*n)

$\mathrm{T} 1(\mathrm{m})^{\star} \mathrm{T} 2(\mathrm{n})=\mathrm{O}(\mathrm{f}(\mathrm{m}) * \mathrm{f}(\mathrm{n}))$仍然有效。

空间复杂度分析

空间复杂度全称就是渐进空间复杂度（asymptotic space complexity），表示算法的 存储空间与数据规模之间的增长关系。

1 2 3 4 5 6 7 8 9 10 11

void print(int n) { int i = 0; //空间存储变量 int[] a = new int[n]; //申请大小为n的int类型数组空间量为O(n) for (i; i <n; ++i) { a[i] = i * i; //其余代码未占用更多空间整段代码的空间的空间复杂度为O(n) } for (i = n-1; i >= 0; --i) { print out a[i] } }

复杂度图

$O(1)<O(\log n)<O(n)<O(n \log n)<O\left(n^{2}\right)<O\left(n^{3}\right)<O\left(n^{n}\right)<O\left(n^{n}\right)$

最好、最坏情况时间复杂度

1 2 3 4 5 6 7 8 9

// n 表示数组 array 的长度 int find(int[] array, int n, int x) { int i = 0; int pos = -1; for (; i < n; ++i) { if (array[i] == x) pos = i; } return pos; }

在一个无序的数组（array）中，查找变量 x 出现的 位置。如果没有找到，就返回 -1。按这段代码的复杂度是 $O(n)$，其中，n 为数组的长度。假设我们在中途中找到了 x 我们就可以结束循环了。我们修改一下代码。

1 2 3 4 5 6 7 8 9 10 11 12

// n 表示数组 array 的长度 int find(int[] array, int n, int x) { int i = 0; int pos = -1; for (; i < n; ++i) { if (array[i] == x) { pos = i; break; //找到他的时候跳出 } } return pos; }

如果我们在第一个位置就找到了它，那么它的时间复杂度就应该为$O(1)$,如果我们在最后找到那么它的时间复杂度为$O(n)$

这里我们就引入了三个新的概念： 最好情况时间复杂度、最坏情况时间复杂度和平均情况时间复杂度

因此相对应的是最好情况时间复杂度为$O(1)$，最坏情况时间复杂度为$O(n)$.

平均情况时间复杂度

最好情况时间复杂度和最坏情况时间复杂度对应的都是极端情况下的代码复杂度，发生的概率其实并不大。为了更好地表示平均情况下的复杂度，我们引入另一个概念：平均情况时间复杂度(平均时间复杂度)。

要查找的变量 x 在数组中的位置，有 n+1 种情况：在数组的 0～n-1 位置中和不在数组中。我们把 每种情况下，查找需要遍历的元素个数累加起来，然后再除以 n+1，就可以得到需要遍历的元素个 数的平均值：

$\frac{1+2+3+\cdots+n+n}{n+1}=\frac{n(n+3)}{2(n+1)}$

大 O 标记法中，可以省略掉系数、低阶、常量因此我们得到的平均时间复杂度为$O(n)$

但是我们忽略了一个问题这 n+1 种 情况，出现的概率并不是一样的。因此我们需要引入概率论的一些知识。

要查找的变量 x，要么在数组里，要么就不在数组里。这两种情况对应的概率统计起来很麻烦，我们假设在数组中与不在数组中的概率都为 1/2。另外，要查找的数据 出现在 0～n-1 这 n 个位置的概率也是一样的，为 1/n。所以，根据概率乘法法则，要查找的数据出 现在 0～n-1 中任意位置的概率就是 $=\frac{1}{2 n}$。

因此我们将式子完善一下。

$1 \times \frac{1}{2 n}+2 \times \frac{1}{2 n}+3 \times \frac{1}{2 n}+\dots+n \times \frac{1}{2 n}+n \times \frac{1}{2}=\frac{3 n+1}{4}$

$\frac{3 n+1}{4}$这个值是概率论中的加权平均值，也叫作期望值，所以平均时间复杂度的全称应该叫加权平均时间复杂度或者期望时间复杂度。根据大$O$表示法来表示时间复杂度依然是$O(n)$

均摊时间复杂度

均摊时间复杂度又叫摊还分析（或者叫平摊分析）。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

// array 表示一个长度为 n 的数组 // 代码中的 array.length 就等于 n int[] array = new int[n]; int count = 0; void insert(int val) { if (count == array.length) { int sum = 0; for (int i = 0; i < array.length; ++i) {//for 循环遍历数组 sum = sum + array[i]; //求和 } array[0] = sum; //sum 值放到数组的第一个位 count = 1; } array[count] = val; //清空数组 ++count; }

数组中有空闲空间，我们只需将数据插入到数组下标为 count 的位置就可以 了，最好情况时间复杂度为 O(1)。最坏的情况下，数组中没有空闲空间了，我们需要先做一次 数组的遍历求和，然后再将数据插入，所以最坏情况时间复杂度为O(n)。
用概率论的方法来分析平均时间复杂度。
数组的长度是 n，根据数据插入的位置的不同，我们可以分为 n 种情况，每种情况的时间复杂 度是 O(1)。除此之外，还有一种“额外”的情况，就是在数组没有空闲空间时插入一个数据，这个时 候的时间复杂度是 O(n)。而且，这 n+1 种情况发生的概率一样，都是$\frac{1}{n+1}$。根据加权平均的计算方法，我们求得的平均时间复杂度就是：

$1 \times \frac{1}{n+1}+1 \times \frac{1}{n+1}+\dots+1 \times \frac{1}{n+1}+n \times \frac{1}{n+1}=O(1)$

这里不需要引入概率论的知识也可以：find() 函数在极端情况下，复杂度才为 O(1)。但 insert() 在大部分情况下，时间复杂度都为 O(1)。只有个别情况下，复杂度才比较高，为 O(n)。这是 insert()第一个区别于 find() 的地方。

对于 insert() 函数来说，O(1) 时间复杂度的插入和 O(n) 时间复杂度 的插入，出现的频率是非常有规律的，而且有一定的前后时序关系，一般都是一个 O(n) 插入之后， 紧跟着 n-1 个 O(1) 的插入操作，循环往复。

针对这样一种特殊场景的复杂度分析，我们并不需要像之前讲平均复杂度分析方法那样，找出所有的输入情况及相应的发生概率，然后再计算加权平均值。我们引入了摊还分析法，通过摊还分析得到的时间复杂度我们起了一个名字，叫均摊时间复杂度。

每一次 O(n) 的插入操作，都会跟着 n-1 次 O(1) 的 插入操作，所以把耗时多的那次操作均摊到接下来的 n-1 次耗时少的操作上，均摊下来，这一组连续的操作的均摊时间复杂度就是 O(1)。

参考资料

《数据结构与算法之美》

《大话数据结构》