【后端秋招准备笔记——数据结构与算法基础】

数据结构与算法基础

算是先复习一遍之前学过的数据结构与算法课吧，采用的是看课加书结合的方法。
课程选择的是青岛大学-王卓老师的数据结构课，王老师讲解的非常清晰，而且课程规划和节奏也非常好，观看体验极佳。
附课程链接：数据结构与算法基础（青岛大学-王卓）

下面是课程笔记，记得比较随性，等秋招全部结束我再回来慢慢梳理，该打补丁打补丁。

1. 算法和算法分析

1. 事前估计和事后估计
2. 假设每条语句所需的时间均为单位时间
3. 算法的渐进时间复杂度
4. 顺序查找 判断最好情况与最坏情况，分析平均的时间复杂度
5. 1< logn < n < nlogn < n^2< n^3 < 2^n < n!
6. 渐进的空间复杂度
   1. 算法本身占据的空间
   2. 实现的时候需要的辅助空间

2. 线性表的定义

1. 同一个线性表中的元素具有相同特性，元素间为线性关系
2. 线性表P = ((p1,e1),(p2,e2))
3. 顺序存储结构：存储空间的分配不灵活，而且空间复杂度比较高
4. 链式结构相对灵活
5. 线性表中的数据元素的类型可以为简单类型也可以为复杂类型
6. 顺序存储定义：把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构
7. 顺序表与实际的一维数组的序号之间差1，第i个表值实际上是数组的第i-1个数
8. 顺序表的插入和删除算法相对来说会比较难：需要判断插入位置是否合法，需要判断当前的表是否已满
9. 顺序表属于静态的存储形式，数据元素的个数是不能自由扩充的
10. 链表，用物理位置任意的存储单元来存储元素，逻辑顺序与物理顺序不一定相同了
11. 链表单结点包含数据域与指针域，头指针指向第一个元素的地址；单链表，双链表和循环链表
12. 头结点，额外附加的节点，在首元节点之前加入的，这时，头指针指向头节点
13. 头节点不计入链表的长度
14. 顺序表是随机存取，而链表是顺序存取

3. 栈和队列

1. 栈和队列也都是线性表
   1. 栈先进后出 递归
   2. 队列先进先出 排队问题
2. 栈
   1. 只能在表的一端，通常是表尾，进行插入和删除操作的线性表
   2. LIFO 后进先出 stack Top Base
   3. 入栈 PUSH（x） 出栈 POP（y）
3. 队列
   1. FIFO 只能在表尾进行插入，在表头进行删除 先进先出
   2. queue Q（a1, a2, … an）
4. 案例
   1. 进制转换 十进制159转换为八进制数
      1. 使用栈，先进后出
   2. 括号匹配的检验
      1. 圆括号和方括号自己要匹配，不能交叉只能嵌套
      2. 左括号就进栈，右括号就进行匹配，匹配则pop
      3. 匹配不了就不匹配
   3. 表达式求值
      1. 算符优先算法
      2. 操作数 运算符 界限符
   4. 舞伴问题
      1. 依次从男队和女队队头各出一人配成舞伴，先进先出
5. 栈的表示和操作的实现
   1. 为了方便操作，top通常指向真正栈顶元素之上的下标地址
   2. 顺序栈需要有stacksize来表示栈可以使用的最大容量
   3. 空栈 base==top
   4. top - base = stacksize 则栈满
   5. 栈满时的处理方法：报错或分配更大的空间
   6. 上溢和下溢
   7. 顺序栈的操作，实际上就是对数组的初始化和指针的移动
   8. 链栈是运算受限的单链表，只能在链表头部进行操作 LinkStack
   9. 链栈中的指针方向，an为栈顶元素，a1为栈底元素
   10. 存储结构实际上是相当灵活的，如何操作都是根据实际问题进行调整的
   11. 链栈不存在满栈的情况，空栈相当于头指针指向空
   12. 插入和删除操作都在栈顶进行
6. 栈与递归
   1. 包含自己 或者反复地调用自己
   2. 必备的三个条件：
      1. 能够将原来的问题转换为一个新的问题，新问题是与原问题解法相同或者类似
      2. 可以通过上述转换使问题简化
      3. 必须有一个明确的递归出口或者递归的边界
   3. 递归工作栈 包含实参 形参 和返回地址
   4. 递归->非递归 降低代码的时间开销
      1. 将尾递归和单向递归转换为循环结构
      2. 自用栈来模拟系统的运行时栈
7. 队列的表示和操作的实现
   1. 顺序队列-真溢出和假溢出 每移动一次，队中元素都要移动
   2. 为了解决这种问题，可以将队的空间设想为一个循环的表，将空间反复地利用 Q.rear = (Q.rear + 1) % MAXQSIZE
   3. 队空队满都是 front == rear
      1. 另外设置一个标志，记录队空队满
      2. 另设一个变量，记录元素个数
      3. 少用一个元素空间*** (Q.rear + 1) % MAXQSIZE == Q.front
   4. 初始化分配空间的时候需要判断空间是否分配成功
   5. 队列的链式表示和实现
      1. 链队是包含头结点的 Q.front指向头结点 Q.rear指向尾结点

4. 串、数组和广义表

1. 串的定义 String
   1. 子串，任意个连续字符组成的子序列
   2. 子串位置，子串中第一个字符在主串中的位置 从1开始
   3. 串相等： 长度相等且个各对应位置上的字符都相同
2. 串的逻辑结构还是线性结构，存储结构还是顺序存储结构和链式存储结构
   1. 串的链式存储结构的存储密度较低，可以通过将多个字符存放在一个结点中，提高存储密度
3. 串的模式匹配算法
   1. BF算法（暴力破解） KMP算法（速度快）
   2. BF简单匹配法，穷举法
   3. KMP算法无需回溯，可以利用已匹配的串进行加速
      1. next[j]，前缀和后缀模式串子串进行比较
      2. nextval【j】，相同则继续回溯，不会相同则为next[j]
4. 数组
   1. 结构是固定的，定义以后维度不再改变
   2. 一般不做插入和删除，只做取元素和修改元素的值
   3. 一般用顺序存储结构来存储
   4. 内存空间的地址是一维的
   5. 二维数组有两种存储方式，以行序为主序或者以列序为主序
   6. 特殊矩阵的压缩存储
5. 广义表
   1. 又称列表Lists，表中的每一个ai或者是原子，或者是一个广义表，递归定义
   2. 表头 广义表中的第一个元素
   3. 表尾 除了表头以外其他元素组成的表
   4. 长度 广义表最外层包含的元素个数
   5. 深度 广义表展开后所含括号的重数

5. 树和二叉树

1. 树的定义
   1. 递归定义，由根和子树组成
   2. 嵌套集合/凹入表示/广义表
2. 树的基本术语
   1. 根结点，非空树中无前驱结点的结点
   2. 结点的度，结点拥有的子树的个数
   3. 树的度，树内各结点度的最大值
   4. 叶子/终端结点 度= 0
   5. 双亲和孩子
   6. 兄弟结点 与 堂兄弟（位于同一层的结点）
   7. 结点的祖先和子孙
   8. 树的深度，树中结点的最大层次
   9. 有序树和无序树
   10. 森林，m棵互不相交的树构成的集合
3. 二叉树的定义
   1. 每个结点最多只有两个分支
   2. 根节点和两棵互不相交的左子树和右子树组成
   3. 二叉树的结点的子树哪怕只有一个孩子，也需要区分左子树还是右子树
4. 二叉树的性质
   1. 在二叉树的第i层上至多有2^(i-1)个结点 i>=1
   2. 深度为k的二叉树至多有2^k-1个结点 k>=1，最少有k个结点
   3. 对于任何一棵二叉树T，其叶子数为n0,度为2的结点数为n2，n0 = n2 + 1
      1. B = n-1 = n2 * 2 + n1 * 1 (B为总边数）
      2. n = 2 * n2 + n1 + 1 = n0 + n1 + n2
      3. n0 = n2 + 1
   4. 所有结点都在，达到最大的二叉树——满二叉树
   5. 深度为k，具有n个结点的二叉树，每个结点都与深度为k的满二叉树1~n的结点一一对应时，称为完全二叉树
   6. 在满二叉树中，从最后一个结点开始，连续去掉任意个结点，即是一棵完全二叉树
   7. 具有n个结点的完全二叉树的深度为[log2n] + 1
   8. 具有n个结点的完全二叉树，第i个结点的双亲结点是[i/2]，左孩子是结点2i，右孩子是结点2i+1
5. 二叉树的存储结构
   1. 顺序存储结构，按照满二叉树的结点层次编号，依次存放二叉树中的数据元素
   2. 顺序存储缺点：数据变化较大时，修改代价较大；对于右单支树，浪费的存储空间较大
   3. 顺序存储仅适合存储满二叉树或完全二叉树
   4. 链式存储结构，两个指针域，分别指向左右孩子
   5. 在n个结点的二叉链表中，有n+1个空指针域
6. 遍历二叉树和线索二叉树
   1. 遍历，需要每个结点均访问一次，但不破坏原来的数据结构
   2. 得到所有结点的一个线性序列
   3. 规定先左后右的话，分为先序遍历，中序遍历和后序遍历
   4. 知道先序和中序，或者由中序和后续，是可以还原出原来的二叉树的
      1. 根据中序是可以判断根和左子树，右子树的 根据先序判断谁是根
      2. 后序是左右根，这样最后一个结点一定是根
   5. 通过递归的方式，传递二叉链表
   6. 每个结点都会经过3次，根据第几次经过的时候访问，分为先中后序，但是经过的路径都是完全相同的
   7. 用栈的方法，非递归地进行中序遍历
   8. 二叉树的层次遍历
      1. 用队列来进行，当前结点出队时分别入队左右孩子
   9. 二叉树遍历算法的应用
      1. 根据输入作为先序序列构建二叉树
      2. 复制二叉树
      3. 计算二叉树的深度 return m>n ?(m+1):(n+1)
      4. 计算二叉树结点总数
      5. 计算叶子结点的总数
   10. 线索二叉树 寻找特定序列中某个结点的前驱结点和后续结点
       1. 如果没有左孩子，就指向前驱结点
       2. 如果没有右孩子，就指向后继结点
       3. 对二叉树的每个结点再增设两个标志域Itag rtag
7. 树和森林
   1. 树的存储结构
      1. 双亲表示法：数据域和双亲域，指示本结点的双亲结点在数组中的位置 找双亲容易，找孩子难
      2. 孩子链表： 找孩子容易 找双亲比较难
      3. 孩子兄弟表示法（二叉树表示法）： 一个数据域和两个指针域，分别指向第一个孩子结点和下一个兄弟结点
      4. 树和二叉树的转换，这样就可以通过二叉树的运算来实现对数的操作，通过二叉链表作媒介可以建立一个对应关系
         1. 通过存储结构来唯一对应
         2. 树变二叉树，兄弟相连留长子
         3. 二叉树变回树：左孩右右连双亲 去掉原来右孩线
      5. 森林转换为二叉树
         1. 各棵树分别转换为二叉树
         2. 将每棵树的根结点用线相连
         3. 以第一棵树的根结点为二叉树的根，再以根结点为轴心，顺时针旋转构成二叉树型结构
      6. 二叉树转换为森林
         1. 去掉根结点沿右分支搜索到的所有右孩子间的连线，变成孤立的二叉树
         2. 将孤立二叉树还原为树
      7. 树和森林的遍历
         1. 树的遍历
            1. 先根遍历
            2. 后根遍历
            3. 层次遍历
         2. 森林的遍历
            1. 将森林看为三部分：第一棵树的根结点，第一棵树的子树森林，剩余树构成的森林
            2. 先序遍历、中序遍历
8. 哈夫曼树及其应用——最优二叉树，判别效率最高
   1. 基本概念
      1. 路径，路径长度，两结点间路径上的分支数
      2. 树的路径长度，从根到每一个结点的路径长度之和
      3. 完全二叉树是路径长度最短的二叉树
      4. 权，将树中结点赋给一个有着某种含义的数值
      5. 结点的带权路径长度：从根结点到该结点的路径长度乘该结点的权
      6. 树的带权路径长度，树中所有叶子结点的带权路径长度之和
      7. 哈夫曼树，带权路径长度WPL最短的树
      8. 度相同的树比较才有意义
      9. 权值越大的叶子离根越近
   2. 哈夫曼树的构造算法
      1. 给定n个权值，构造n棵二叉树
      2. 以权值最小的树作为左右子树 新的二叉树根结点的权值为原根结点权值之和
      3. 哈夫曼树一定有2n-1个结点
      4. 哈夫曼树的结点度数为0或者2，没有度为1的结点
      5. 通过顺序存储结构来构造哈夫曼树，weight parent lch rch
      6. 生成的哈夫曼树可以不唯一
   3. 哈夫曼编码
      1. 尽可能用不等长的编码，出现次数较多的字符采用尽可能短的编码，出现次数少的采用长的编码
      2. 长度不等的编码，任意一个字符的编码都不是另外一个字符编码的前缀，不然就会有重码
      3. 前缀码使得电文总长最短
      4. 以每个字符在电文中出现的平均概率作为权值
      5. 从根到每个叶子路径上的标号连接起来，作为该叶子代表的字符的编码，因为都是叶子结点，所以不会有重码
      6. 左0右1
      7. 哈夫曼编码是最优前缀码
   4. 文件的编码和解码
      1. 编码——先统计字母的频次
      2. 构造哈夫曼树
      3. 进行哈夫曼编码
      4. 查HC[i]，得到各字符的哈夫曼编码
      5. 解码——构造哈夫曼树（接收字符频度表W）
      6. 依次读入二进制码
      7. 到达叶子结点时，即可翻译出字符

6. 图

1. 图的定义和术语

   1. G = (V, E)
   2. V为顶点，有穷非空
   3. E为边，有穷集合
   4. 无向图和有向图
   5. 完全图：任意两个点都有边相连
   6. 稀疏图、稠密图、网（边带权重）、邻接、关联、顶点的度（TD（v）），入度和出度
   7. 路径和路径长度、回路、简单路径（除起点和终点可以相同，其他顶点均不相同）
   8. 连通图：任意两个顶点之间都存在路径；强连通图和非强连通图
   9. 权和网
   10. 子图
   11. 连通分量，无向图G的极大连通子图
   12. 极小连通子图，为G的连通子图，再删除一条边就不再是连通的了
   13. 生成树：包含所有顶点的极小连通子图
   14. 生成森林：对非连通图，由各个连通分量的生成树的集合

2. 案例分析

   1. 六度空间理论/小世界理论

3. 图的类型定义

   1. 深度优先遍历和广度优先遍历

4. 图的存储结构

   1. 数组表示法（邻接矩阵）
   2. 链式存储结构 邻接表、邻接多重表、十字链表
   3. 重点邻接矩阵和邻接表
   4. 邻接矩阵
      1. n*n的方阵
      2. 对角线上的元素都为0
      3. 无向图的邻接矩阵是对称矩阵
      4. 顶点i的度，第i行中1的个数
      5. 有向图，可能是非对称
      6. 有向图邻接矩阵，第i行出度边；第i列，入度边
      7. 网的邻接矩阵，对应的元素值为权值，无边为∞
      8. 邻接矩阵的建立
         1. 两个数组分别存储顶点表和邻接矩阵

5. 常见的应用：

   1. 最小生成树：Prim（依次添加结点）K（依次添加边）
   2. 最短路径：Dijistra(依次添加） Floyd（n阶方阵，计算每添加一个结点对其他路径的影响）
   3. 拓扑排序（深度/广度优先）对有向无环图
      1. 先找入度为0的点
      2. 找到以后断开连接，重复1、2直至所有点visited
   4. 关键路径
      1. AOE网
      2. 活动最早开始的时间，和最迟开始的时间

7. 查找

1. 查找的基本概念，同一类型数据元素构成的集合
   1. 根据给定的值，在查找表中找到关键字等于给定值的数据元素
   2. 主关键字、次关键字
   3. 目的：查询、检索各种属性、插入新的数据元素、删除
   4. 评价查找算法：ASL（平均查找长度）
   5. 提高查找的效率：人为加上某些确定的约束关系
2. 线性表的查找：
   1. 顺序查找（线性查找）
      1. 每执行一次循环都要进行两次比较
      2. 改进，将待查关键字key存入表头作为哨兵
      3. time:ASL = (n+1)/2, mem: O(1)
      4. 提高效率，将查找概率比较高的排在前面
      5. 按照查找概率动态地调整记录顺序
   2. 二分查找
      1. mid = (low+high)/2
      2. low = mid - 1
      3. high = mid + 1
      4. while(low<=high)
      5. ASL log2(n+1) - 1
      6. 仅适用于有序表
   3. 分块查找
      1. 需要先建立索引顺序表
      2. 其实相当于是二分+顺序，首先在索引顺序表上进行二分找到块，然后在用顺序查找在块内查找
      3. ASL = Lb + Lw ~ log2(n/s + 1) +s/2
3. 树表的查找：
   1. 动态查找表，在查找过程中动态生成
   2. 二叉排序树和平衡二叉树
   3. 二叉排序树/搜索树/查找树
      1. 左子树所有结点的值小于根结点的值
      2. 右子树所有结点的值大于等于根结点的值
      3. 左子树和右子树又分别为二叉排序树
      4. 中序遍历序列一定是递增有序的
      5. 由于其特殊性质，非常适合用递归算法来进行查找
      6. 最好情况是O（log2n），最差是O（n）
      7. 如何提高不平衡的二叉排序树的查找效率——>平衡二叉树
      8. 二叉排序树的插入和删除
      9. 如果删除的是叶子结点，就直接删除；如果只有左子树或右子树，直接替换；如果既有左子树又有右子树，那么直接用他的前驱结点来代替他，就是左子树的最大结点来代替他
   4. 平衡二叉树
      1. AVL树，首先必须是二叉排序树
      2. 左子树和右子树的高度之差的绝对值小于等于1
      3. 左子树和右子树也是平衡二叉树
      4. BF平衡因子，左子树的高度-右子树的高度
      5. 如果插入新的结点以后造成失衡，就需要调整二叉树
      6. 以最小的失衡子树根结点作为失衡结点 LL LR RL RR
      7. 调整原则： 降低高度 保持二叉排序树的性质
4. 散列表的查找
   1. hash函数，Loc(i) = H(key i)
   2. 冲突：key1 ≠ key2 但是H（key1） = H（key2）
   3. 同义词：具有相同函数值的多个关键字
   4. 构造好的散列函数：尽可能简单+分布均匀分布，避免空间浪费
   5. 制定一个好的解决冲突的方案
   6. 多种方法，直接定址法、除留余数法
      1. 直接定址法
         1. Hash(key) = a*key +b
         2. 空间效率较低，但是不会产生冲突
      2. 除留余数法
         1. Hash(key) = key mod p
         2. 选取合适的p ，p<=m且为质数
         3. di增量序列，有冲突就寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到
         4. 线性探测/二次探测（p为4k+3的质数）/伪随机探测法
      3. 开放地址法
      4. 链地址法（拉链法），用一个数组将m个单链表的表头指针存储起来，形成一个动态的结构
         1. 优点，非同义词不会冲突，无聚集现象
         2. 适用于表长不定的情况
   7. 散列表的查找
      1. ASL取决于三个值：散列函数、处理冲突的方法、散列表的装填因子α（表中填入的记录数/哈希表的长度）

8. 第八章排序

1. 排序的概念
   1. 将一组杂乱无章的数据按一定的顺序顺次排列起来
   2. 排序的应用非常广泛
2. 插入排序
   1. 类似抽扑克牌，将待排序的对象按照关键码的大小，插入到已经排好序的序列中
   2. 顺序法定位插入位置——直接插入排序；二分法定位插入位置——二分插入排序； 缩小增量多遍插入排序——希尔排序
   3. 直接插入排序，从后往前进行顺序查找，直到找到合适的位置进行插入 time:O(n)~O(n^2) mem: O(1) 稳定
   4. 折半插入排序，采用折半查找法 time:O(n^2) mem: O(1) 稳定
   5. 希尔排序
      1. 定义增量序列
      2. 递减
      3. 互质
      4. 最后一个为1
      5. 间隔插入排序
      6. time: O(n^{1.25)~O(1.6*n}1.25）
      7. mem: O(1)
      8. 不稳定
      9. 不适合在链式存储结构上来实现
3. 交换排序
   1. 冒泡排序
      1. 两两比较，前小后大规则交换
      2. 一轮结束比后，序列中最大的数移动到了序列最后
      3. n个记录 n-1轮比较， 第m轮，比较n-m次；
      4. 如果某一趟没有进行交换，就不需要后续了
      5. time: O（n^2） mem O(1) 稳定
   2. 快速排序
      1. 递归思想
      2. 任取一个元素为中心
      3. 比中心小的在左，比中心大的在右，形成左右子表
      4. 分别对左右子表重复2和3
      5. 直到每个子表只有1个元素
      6. time: O(nlogn) mem: O(logn)
      7. 因为用了递归的思想，所以需要栈来存储函数调用的参数和返回值等，最坏情况是O（n），平均是O(logn）
      8. 快速排序是一种不稳定的排序方法
      9. 快速排序不适用于对原本有序或者基本有序的记录序列进行排序
4. 选择排序
   1. 简单选择排序
      1. 依次找最小的树和前面进行交换
      2. time:O(n^2)，mem:O(1)，不稳定的排序
   2. 堆排序
      1. ai<= a2i; ai <= a2i+1为小根堆，反之为大根堆；堆为完全二叉树，且任一非叶子结点值均小于（大于）它的孩子结点
      2. 依次输出堆顶值，再将剩余元素调整成新的堆
      3. 以小根堆为例：
         1. 输出堆顶，以最后一个元素代替之
         2. 根与左右比较，下调
         3. 直至叶子结点，得到新的堆——“筛选”
      4. 无序序列如何变成堆？
         1. 建立初始完全二叉树
         2. 从最后一个非叶子结点来调整，将以钙元素为根的二叉树调整为堆
      5. time: O(nlogn) mem: O(1) 不稳定
5. 归并排序
   1. 2-路归并排序，重复将2个有序序列归并为一个
   2. 使用双指针，合并相邻序列的时候需要新开空间
   3. time: O(nlog2n) mem: O(n) 稳定
6. 基数排序
   1. 不需要比较，又称桶排序或箱排序
   2. 采用先分配再收集的方式，如数字序列，按个十百…依次往e[0]~e[9]分配，再收集回来，结束以后就是有序的了
   3. time: O(k*(n+m))，k:关键字，m：桶的个数
   4. mem: O(m+n)
   5. 稳定

完结撒花~✿✿✿