【2021最新版】数据结构＋算法面试题总结（9+20道题含答案解析）

曾经终败给现在 2023-01-18 14:22 6阅读 0赞

### 文章目录 ###

*   *   *  1、栈（stack）
         *  2、队列（queue）
         *  3、链表（Link）
         *  4、散列表（Hash Table）
         *  5、排序二叉树
         *  6、 前缀树
         *  7、红黑树
         *  8、B-TREE
         *  9、位图
     *  算法面试题
     *   *  1、数据里有\{1,2,3,4,5,6,7,8,9\}，请随机打乱顺序，生成一个新的数组（请以代码实现）
         *  2、写出代码判断一个整数是不是2的阶次方（请代码实现，谢绝调用API方法）
         *  3、假设今日是2015年3月1日，星期日，请算出13个月零6天后是星期几，距离现在多少天（请用代码实现，谢绝调用 API方法）
         *  4、有两个篮子，分别为A 和 B，篮子A里装有鸡蛋，篮子B里装有苹果，请用面向对象的思想实现两个篮子里的物品交换（请用代码实现）
         *  5、二分查找
         *  6、冒泡排序算法
         *  7、插入排序算法
         *  8、快速排序算法
         *  9、希尔排序算法
         *  10、归并排序算法
         *  11、桶排序算法
         *  12、基数排序算法
         *  13、剪枝算法
         *  14、回溯算法
         *  15、最短路径算法
         *  16、最小生成树算法
         *  17、AES
         *  18、RSA
         *  19、CRC
         *  20、MD5
 *  总结

> 最近面试的小伙伴很多，对此我整理了一份Java面试题手册：基础知识、JavaOOP、Java集合/泛型面试题、Java异常面试题、Java中的IO与NIO面试题、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、SpringBoot、SpringCloud、RabbitMQ、Dubbo、MyBatis、ZooKeeper、[数据结构、算法、][Link 1]Elasticsearch、Kafka、微服务、Linux等等。可以分享给大家学习。【持续更新中】

完整版Java面试题地址：[【2021最新版】Java面试真题汇总][Link 1]

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>内容</th> 
   <th>地址链接</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>【2021最新版】JavaOOP面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/115288673" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/115288673</a></td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>【2021最新版】Java基础面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/115485109" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/115485109</a></td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>【2021最新版】多线程&amp;并发面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/115489616" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/115489616</a></td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>【2021最新版】JVM面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/115555086" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/115555086</a></td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>【2021最新版】Mysql面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/115561030" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/115561030</a></td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>【2021最新版】Redis面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/115642129" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/115642129</a></td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>【2021最新版】Memcached面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/115664662" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/115664662</a></td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>【2021最新版】MongoDB面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/115672336" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/115672336</a></td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>【2021最新版】Spring面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/115738909" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/115738909</a></td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>【2021最新版】Spring Boot面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/115771307" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/115771307</a></td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>【2021最新版】Spring Cloud面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/115917190" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/115917190</a></td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>【2021最新版】RabbitMQ面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/116064045" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/116064045</a></td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>【2021最新版】Dubbo面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/116237861" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/116237861</a></td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td>【2021最新版】MyBatis面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/116427170" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/116427170</a></td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td>【2021最新版】ZooKeeper面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/116458096" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/116458096</a></td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td>【2021最新版】数据结构面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/116461620" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/116461620</a></td> 
  </tr> 
  <tr> 
   <td>17</td> 
   <td>【2021最新版】算法面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/116461620" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/116461620</a></td> 
  </tr> 
  <tr> 
   <td>18</td> 
   <td>【2021最新版】Elasticsearch面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/116656094" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/116656094</a></td> 
  </tr> 
  <tr> 
   <td>19</td> 
   <td>【2021最新版】Kafka面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/116659584" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/116659584</a></td> 
  </tr> 
  <tr> 
   <td>20</td> 
   <td>【2021最新版】微服务面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/116662109" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/116662109</a></td> 
  </tr> 
  <tr> 
   <td>21</td> 
   <td>【2021最新版】Linux面试题总结</td> 
   <td><a href="https://blog.csdn.net/m0_48795607/article/details/116798880" rel="nofollow">https://blog.csdn.net/m0_48795607/article/details/116798880</a></td> 
  </tr> 
 </tbody> 
</table>

### 1、栈（stack） ###

**答：**

栈（ stack）是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫做栈顶（top）。它是后进先出（LIFO）的。对栈的基本操作只有 push（进栈）和 pop（出栈）两种，前者相当于插入，后者相当于删除最后的元素。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70][]

### 2、队列（queue） ###

**答：**

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。  
![在这里插入图片描述][20210510210125238.png]

### 3、链表（Link） ###

**答：**

链表是一种数据结构，和数组同级。比如， Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 1][]

### 4、散列表（Hash Table） ###

**答：**

散列表（Hash table，也叫哈希表）是一种查找算法，与链表、树等算法不同的是，散列表算法在查找时不需要进行一系列和关键字（关键字是数据元素中某个数据项的值，用以标识一个数据元素）的比较操作。

散列表算法希望能尽量做到不经过任何比较，通过一次存取就能得到所查找的数据元素，因而必须要在数据元素的存储位置和它的关键字（可用key表示）之间建立一个确定的对应关系，使每个关键字和散列表中一个唯一的存储位置相对应。因此在查找时，只要根据这个对应关系找到给定关键字在散列表中的位置即可。这种对应关系被称为散列函数(可用h(key)表示)。

**用的构造散列函数的方法有：**

1） 直接定址法： 取关键字或关键字的某个线性函数值为散列地址。

即： h(key) = key或h(key) = a \* key + b， 其中a和b为常数。

（2） 数字分析法

（3） 平方取值法：取关键字平方后的中间几位为散列地址。

（4） 折叠法：将关键字分割成位数相同的几部分，然后取这几部分的叠加和作为散列地址。

（5） 除留余数法：取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址，

即： h(key) = key MOD p p ≤ m

（6） 随机数法：选择一个随机函数，取关键字的随机函数值为它的散列地址，

即： h(key) = random(key)

### 5、排序二叉树 ###

**答：**

首先如果普通二叉树每个节点满足：左子树所有节点值小于它的根节点值，且右子树所有节点值大于它的根节点值，则这样的二叉树就是排序二叉树。

**插入操作**

首先要从根节点开始往下找到自己要插入的位置（即新节点的父节点）；具体流程是：新节点与当前节点比较，如果相同则表示已经存在且不能再重复插入；如果小于当前节点，则到左子树中 寻找，如果左子树为空则当前节点为要找的父节点，新节点插入到当前节点的左子树即可；如果大于当前节点，则到右子树中寻找，如果右子树为空则当前节点为要找的父节点，新节点插入到当前节点的右子树即可。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 2][]  
**删除操作**

删除操作主要分为三种情况， 即要删除的节点无子节点，要删除的节点只有一个子节点，要删除的节点有两个子节点。

5、排序二叉树

1.  对于要删除的节点无子节点可以直接删除，即让其父节点将该子节点置空即可。
2.  对于要删除的节点只有一个子节点，则替换要删除的节点为其子节点。
3.  对于要删除的节点有两个子节点， 则首先找该节点的替换节点（即右子树中最小的节点），接着替换要删除的节点为替换节点，然后删除替换节点。  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 3][]  
    **查询操作**

查找操作的主要流程为：先和根节点比较，如果相同就返回， 如果小于根节点则到左子树中归查找，如果大于根节点则到右子树中递归查找。因此在排序二叉树中可以很容易获取最大（最右最深子节点）和最小（最左最深子节点）值

### 6、 前缀树 ###

**答：**

前缀树(Prefix Trees 或者 Trie)与树类似，用于处理字符串相关的问题时非常高效。它可以实现快速检索，常用于字典中的单词查询，搜索引擎的自动补全甚至 IP 路由。

下图展示了“top”, “thus”和“their”三个单词在前缀树中如何存储的：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 4][]

### 7、红黑树 ###

**答：**

红黑树的特性

（1）每个节点或者是黑色，或者是红色。

（2）根节点是黑色。

（3）每个叶子节点（NIL）是黑色。 \[注意：这里叶子节点，是指为空(NIL 或NULL)的叶子节点！

（4）如果一个节点是红色的，则它的子节点必须是黑色的。

（5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

**左旋**

对 x 进行左旋，意味着，将“x 的右孩子”设为“x 的父亲节点”；即，将 x 变成了一个左节点(x成了为 z 的左孩子)！。 因此，左旋中的“左”，意味着“被旋转的节点将变成一个左节点”。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 5][]

LEFT-ROTATE(T, x) y ← right[x] // 前提：这里假设 x 的右孩子为 y。下面开始正式操作 right[x] ← left[y] // 将 “y 的左孩子” 设为 “x 的右孩子”，即 将β设为 x 的右孩子 p[left[y]] ← x // 将 “x” 设为 “y 的左孩子的父亲”，即 将β的父亲设为 x
    p[y] ← p[x] // 将 “x 的父亲” 设为 “y 的父亲” if p[x] = nil[T] then root[T] ← y // 情况 1：如果 “x 的父亲” 是空节点，则将 y 设为根节点 else if x = left[p[x]] then left[p[x]] ← y // 情况 2：如果 x 是它父节点的左孩子，则将 y 设为“x 的父节点 的左孩子” else right[p[x]] ← y // 情况 3： (x 是它父节点的右孩子) 将 y 设为“x 的父节点的右孩 子” left[y] ← x // 将 “x” 设为 “y 的左孩子” p[x] ← y // 将 “x 的父节点” 设为 “y”

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 6][]  
**右旋**  
对 x 进行右旋，意味着，将“x 的左孩子”设为“x 的父亲节点”；即，将 x 变成了一个右节点(x成了为 y 的右孩子)！ 因此，右旋中的“右”，意味着“被旋转的节点将变成一个右节点”。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 7][]  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 8][]  
**添加**

第一步: 将红黑树当作一颗二叉查找树，将节点插入。

第二步：将插入的节点着色为"红色"。

根据被插入节点的父节点的情况，可以将"当节点 z 被着色为红色节点，并插入二叉树"划分为三种情况来处理。

① 情况说明：被插入的节点是根节点。

处理方法：直接把此节点涂为黑色。

② 情况说明：被插入的节点的父节点是黑色。

处理方法：什么也不需要做。节点被插入后，仍然是红黑树。

③ 情况说明：被插入的节点的父节点是红色。这种情况下，被插入节点是一定存在非空祖父节点的；进一步的讲，被插入节点也一定存在叔叔节点(即使叔叔节点为空，我们也视之为存在，空节点本身就是黑色节点)。理解这点之后，我们依据"叔叔节点的情况"，将这种情况进一步划分为 3种情况(Case)  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 9][]  
第三步: 通过一系列的旋转或着色等操作，使之重新成为一颗红黑树。

**删除**

第一步：将红黑树当作一颗二叉查找树， 将节点删除。

这和"删除常规二叉查找树中删除节点的方法是一样的"。分 3 种情况：

① 被删除节点没有儿子，即为叶节点。那么，直接将该节点删除就 OK 了。

② 被删除节点只有一个儿子。那么，直接删除该节点，并用该节点的唯一子节点顶替它的位置。

③ 被删除节点有两个儿子。那么，先找出它的后继节点；然后把“它的后继节点的内容”复制给“该节点的内容”；之后，删除“它的后继节点”。

第二步：通过"旋转和重新着色"等一系列来修正该树，使之重新成为一棵红黑树。

因为"第一步"中删除节点之后，可能会违背红黑树的特性。所以需要通过"旋转和重新着色"来修正该树，使之重新成为一棵红黑树。

选择重着色 3 种情况。

① 情况说明： x 是“红+黑”节点。

处理方法：直接把 x 设为黑色，结束。此时红黑树性质全部恢复。

② 情况说明： x 是“黑+黑”节点，且 x 是根。

处理方法：什么都不做，结束。此时红黑树性质全部恢复。

③ 情况说明： x 是“黑+黑”节点，且 x 不是根。

处理方法：这种情况又可以划分为 4 种子情况。这 4 种子情况如下表所示：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 10][]  
参考： https://www.jianshu.com/p/038585421b73

代码实现： https://www.cnblogs.com/skywang12345/p/3624343.html

### 8、B-TREE ###

**答：**  
B-tree 又叫平衡多路查找树。一棵 m 阶的 B-tree (m 叉树)的特性如下（其中 ceil(x)是一个取上限的函数） ：

1.  树中每个结点至多有 m 个孩子；
2.  除根结点和叶子结点外，其它每个结点至少有有 ceil(m / 2)个孩子；
3.  若根结点不是叶子结点，则至少有 2 个孩子（特殊情况：没有孩子的根结点，即根结点为叶子结点，整棵树只有一个根节点）；
4.  所有叶子结点都出现在同一层，叶子结点不包含任何关键字信息(可以看做是外部结点或查询失败的结点，实际上这些结点不存在，指向这些结点的指针都为 null)； 5. 每个非终端结点中包含有 n 个关键字信息： (n， P0， K1， P1， K2， P2， …， Kn， Pn)。其中：
5.

a) Ki (i=1…n)为关键字，且关键字按顺序排序 K(i-1)< Ki。

b) Pi 为指向子树根的接点，且指针 P(i-1)指向子树种所有结点的关键字均小于 Ki，但都大于 K(i-1)。

c) 关键字的个数 n 必须满足： ceil(m / 2)-1 <= n <= m-1。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 11][]  
一棵 m 阶的 B+tree 和 m 阶的 B-tree 的差异在于：

1.有 n 棵子树的结点中含有 n 个关键字； (B-tree 是 n 棵子树有 n-1 个关键字)

2.所有的叶子结点中包含了全部关键字的信息，及指向含有这些关键字记录的指针，且叶子结点本身依关键字的大小自小而大的顺序链接。 (B-tree 的叶子节点并没有包括全部需要查找的信息)

3.所有的非终端结点可以看成是索引部分，结点中仅含有其子树根结点中最大（或最小）关键字。(B-tree 的非终节点也包含需要查找的有效信息）  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 12][]

### 9、位图 ###

**答：**

位图的原理就是用一个 bit 来标识一个数字是否存在，采用一个 bit 来存储一个数据，所以这样可以大大的节省空间。 bitmap 是很常用的数据结构， 比如用于 Bloom Filter 中；

用于无重复整数的排序等等。 bitmap 通常基于数组来实现，数组中每个元素可以看成是一系列二进制数，所有元素组成更大的二进制集合。

https://www.cnblogs.com/polly333/p/4760275.html

## 算法面试题 ##

### 1、数据里有\{1,2,3,4,5,6,7,8,9\}，请随机打乱顺序，生成一个新的数组（请以代码实现） ###

**答：**

import java.util.Arrays;
    //打乱数组 public class Demo1 { //随机打乱 public static int[] srand(int[] a) { int[] b = new int[a.length]; for(int i = 0; i < a.length;i++) { //随机获取下标 int tmp = (int)(Math.random()*(a.length - i)); //随机数:[ 0 ， a.length - i ) b[i] = a[tmp]; //将此时a[tmp]的下标移动到靠后的位置 int change = a[a.length - i - 1]; a[a.length - i - 1] = a[tmp]; a[tmp] = change; }return b; }public static void main(String[] args) { int[] a = {1,2,3,4,5,6,7,8,9}; System.out.println(Arrays.toString(srand(a))); } }

### 2、写出代码判断一个整数是不是2的阶次方（请代码实现，谢绝调用API方法） ###

**答：**

import java.util.Scanner;
    //判断整数是不是2的阶次方 public class Demo2 { public static boolean check(int sum) { boolean flag = true; //判断标志 while(sum > 1) { if (sum % 2 == 0) { sum = sum/2; } else { flag = false; break; } }return flag; }public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入一个整数:"); int sum = scanner.nextInt(); System.out.println(sum + " 是不是2的阶次方：" + check(sum)); } }

### 3、假设今日是2015年3月1日，星期日，请算出13个月零6天后是星期几，距离现在多少天（请用代码实现，谢绝调用 API方法） ###

**答：**

import java.util.Scanner;
    //算出星期几 public class Demo4 { public static String[] week = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"}; public static int i = 0; public static int[] monthday1 = {0,31,28,31,30,31,30,31,31,30,31,30,31}; public static int[] monthday2 = {0,31,29,31,30,31,30,31,31,30,31,30,31}; //查看距离当前天数的差值 public static String distance(int year,int month,int day,int newMonth,int newDay) { int sum = 0; //设定初始距离天数 if (month + newMonth >= 12) { if (((year + 1) % 4 == 0 && (year + 1) % 100 != 0)||(year + 1) % 400 == 0) { sum += 366 + newDay; for(int i = 0;i < newMonth - 12;i++) { sum += monthday1[month + i]; } } else { sum += 365 + newDay; for(int i = 0;i < newMonth - 12;i++) { sum += monthday1[month + i]; } } }else {for(int i = 0;i < newMonth;i++) { sum += monthday1[month + i]; }sum += newDay; }return week[sum%7]; }public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入当前年份"); int year = scanner.nextInt(); System.out.println("请输入当前月份"); int month = scanner.nextInt(); System.out.println("请输入当前天数"); int day = scanner.nextInt(); System.out.println("请输入当前是星期几：以数字表示，如：星期天 为 0"); int index = scanner.nextInt(); System.out.println("今天是：" + year + "-" + month + "-" + day + " " + week[index]); System.err.println("请输入相隔月份"); int newMonth = scanner.nextInt(); System.out.println("请输入剩余天数"); int newDay = scanner.nextInt(); System.out.println("经过" + newMonth + "月" + newDay + "天后，是" + distance(year,month,day,newMonth,newDay)); } }

### 4、有两个篮子，分别为A 和 B，篮子A里装有鸡蛋，篮子B里装有苹果，请用面向对象的思想实现两个篮子里的物品交换（请用代码实现） ###

**答：**

//面向对象思想实现篮子物品交换 public class Demo5 { public static void main(String[] args) { //创建篮子 Basket A = new Basket("A"); Basket B = new Basket("B"); //装载物品 A.load("鸡蛋"); B.load("苹果"); //交换物品 A.change(B); A.show(); B.show(); } }class Basket{ public String name; //篮子名称 private Goods goods; //篮子中所装物品 public Basket(String name) { // TODO Auto-generated constructor stub this.name = name; System.out.println(name + "篮子被创建");
    }
    //装物品函数 public void load(String name) { goods = new Goods(name); System.out.println(this.name + "装载了" + name + "物品"); }public void change(Basket B) { System.out.println(this.name + " 和 " + B.name + "中的物品发生了交换"); String tmp = this.goods.getName(); this.goods.setName(B.goods.getName()); B.goods.setName(tmp); }public void show() { System.out.println(this.name + "中有" + goods.getName() + "物品"); } }class Goods{ private String name; //物品名称 public String getName() { return name; }public void setName(String name) { this.name = name; }public Goods(String name) { // TODO Auto-generated constructor stub this.name = name; } }

### 5、二分查找 ###

**答：**

又叫折半查找，要求待查找的序列有序。每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，如果中间位置的值比待查关键字小，则在后半部分循环这个查找的过程。直到查找到了为止，否则序列中没有待查的关键字。

public static int biSearch(int []array,int a){ 
    	int lo=0;
    	int hi=array.length-1;
    	int mid;
    	while(lo<=hi){ 
    		mid=(lo+hi)/2;
    		//中间位置 if(array[mid]==a){ return mid+1; }else if(array[mid]<a){ //向右查找 lo=mid+1; }else{ //向左查找 hi=mid-1; } }return -1; }

### 6、冒泡排序算法 ###

**答：**  
1）比较前后相邻的二个数据，如果前面数据大于后面的数据，就将这二个数据交换。

2）这样对数组的第 0 个数据到 N-1 个数据进行一次遍历后，最大的一个数据就“沉” 到数组第N-1 个位置。

3） N=N-1，如果 N 不为 0 就重复前面二步，否则排序完成。

public static void bubbleSort1(int [] a, int n){  int i, j; for(i=0; i<n; i++){ //表示 n 次排序过程。 for(j=1; j<n-i; j++){ if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换 //交换 a[j-1]和 a[j] int temp; temp = a[j-1]; a[j-1] = a[j]; a[j]=temp; } 
    } } }

### 7、插入排序算法 ###

**答：**

通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应的位置并插入。插入排序非常类似于整扑克牌。在开始摸牌时，左手是空的，牌面朝下放在桌上。接着， 一次从桌上摸起一张牌，并将它插入到左手一把牌中的正确位置上。 为了找到这张牌的正确位置，要将它与手中已有的牌从右到左地进行比较。无论什么时候，左手中的牌都是排好序的。如果输入数组已经是排好序的话，插入排序出现最佳情况，其运行时间是输入规模的一个线性函数。如果输入数组是逆序排列的，将出现最坏情况。平均  
情况与最坏情况一样，其时间代价是(n2)。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 13][]

public void sort(int arr[]){  for(int i =1; i<arr.length;i++) {  //插入的数 int insertVal = arr[i]; //被插入的位置(准备和前一个数比较) int index = i-1; //如果插入的数比被插入的数小 while(index>=0&&insertVal<arr[index]) { //将把 arr[index] 向后移动 arr[index+1]=arr[index]; //让 index 向前移动 index--; }//把插入的数放入合适位置 arr[index+1]=insertVal; } 
    }

### 8、快速排序算法 ###

**答：**

快速排序的原理：选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的）。 一般选择序列的第一个元素。

一次循环： 从后往前比较，用基准值和最后一个值比较，如果比基准值小的交换位置，如果没有继续比较下一个，直到找到第一个比基准值小的值才交换。 找到这个值之后，又从前往后开始比较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的值才交换。直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值来说，左右两边就是有序的了。

public void sort(int[] a,int low,int high){ 
    	int start = low;
    	int end = high;
    	int key = a[low];
    	while(end>start){ 
    		//从后往前比较 while(end>start&&a[end]>=key) //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较 end--; if(a[end]<=key){ int temp = a[end]; a[end] = a[start]; a[start] = temp; }//从前往后比较 while(end>start&&a[start]<=key){ //如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置 start++; if(a[start]>=key){ int temp = a[start]; a[start] = a[end]; a[end] = temp; }//此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用 }//递归 if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1 if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1 到最后一个
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 14][]

### 9、希尔排序算法 ###

**答：**

基本思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序” 时，再对全体记录进行依次直接插入排序。

1.  操作方法：选择一个增量序列t1， t2， …， tk，其中 ti>tj， tk=1； 2. 按增量序列个数k，对序列进行k趟排序；
2.  每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m的子序列，分别对各子表进行直接插入排序。仅增量因子为1时，整个序列作为一个表来处理，表长度即为整个序列的长度。  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 15][]

private void shellSort(int[] a) { 
    	int dk = a.length/2;
    	while( dk >= 1 ){ 
    		ShellInsertSort(a, dk);
    		dk = dk/2;
    	}
    }
    private void ShellInsertSort(int[] a, int dk) { 
    	//类似插入排序，只是插入排序增量是 1，这里增量是 dk,把 1 换成 dk 就可以了 for(int i=dk;i<a.length;i++){ if(a[i]<a[i-dk]){ int j; int x=a[i];//x 为待插入元素 a[i]=a[i-dk]; for(j=i-dk; j>=0 && x<a[j];j=j-dk){ //通过循环，逐个后移一位找到要插入的位置。 a[j+dk]=a[j]; }a[j+dk]=x;//插入 } } }

### 10、归并排序算法 ###

**答：**

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 16][]

public class MergeSortTest { 
    	public static void main(String[] args) { 
    		int[] data = new int[] {  5, 3, 6, 2, 1, 9, 4, 8, 7 };
    		print(data);
    		mergeSort(data);
    		System.out.println("排序后的数组： ");
    		print(data);
    	}
    	public static void mergeSort(int[] data) { 
    		sort(data, 0, data.length - 1);
    	}
    	public static void sort(int[] data, int left, int right) { 
    		if (left >= right) return;
    		// 找出中间索引 int center = (left + right) / 2; // 对左边数组进行递归 sort(data, left, center); // 对右边数组进行递归 sort(data, center + 1, right); // 合并 merge(data, left, center, right); print(data); }/** * 将两个数组进行归并，归并前面 2 个数组已有序，归并后依然有序 ** @param data * 数组对象 * @param left * 左数组的第一个元素的索引 * @param center * 左数组的最后一个元素的索引， center+1 是右数组第一个元素的索引 * @param right * 右数组最后一个元素的索引 */public static void merge(int[] data, int left, int center, int right) { // 临时数组 int[] tmpArr = new int[data.length]; // 右数组第一个元素索引 int mid = center + 1; // third 记录临时数组的索引 int third = left; // 缓存左数组第一个元素的索引
    		int tmp = left;
    		while (left <= center && mid <= right) { 
    			// 从两个数组中取出最小的放入临时数组 if (data[left] <= data[mid]) { tmpArr[third++] = data[left++]; } else { tmpArr[third++] = data[mid++]; } }// 剩余部分依次放入临时数组（实际上两个 while 只会执行其中一个） while (mid <= right) { tmpArr[third++] = data[mid++]; }while (left <= center) { tmpArr[third++] = data[left++]; }// 将临时数组中的内容拷贝回原数组中 // （原 left-right 范围的内容被复制回原数组） while (tmp <= right) { data[tmp] = tmpArr[tmp++]; } }public static void print(int[] data) { for (int i = 0; i < data.length; i++) { System.out.print(data[i] + "t"); }System.out.println(); } }

### 11、桶排序算法 ###

**答：**

桶排序的基本思想是： 把数组 arr 划分为 n 个大小相同子区间（桶），每个子区间各自排序，最后合并 。计数排序是桶排序的一种特殊情况，可以把计数排序当成每个桶里只有一个元素的情况。

1.找出待排序数组中的最大值 max、最小值 min

2.我们使用 动态数组 ArrayList 作为桶，桶里放的元素也用 ArrayList 存储。桶的数量为(maxmin)/arr.length+1

3.遍历数组 arr，计算每个元素 arr\[i\] 放的桶

4.每个桶各自排序

public static void bucketSort(int[] arr){ 
    	int max = Integer.MIN_VALUE;
    	int min = Integer.MAX_VALUE;
    	for (int i = 0; i < arr.length; i++){ 
    		max = Math.max(max, arr[i]);
    		min = Math.min(min, arr[i]);
    	}
    	//创建桶 int bucketNum = (max - min) / arr.length + 1; ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum); for(int i = 0; i < bucketNum; i++){ bucketArr.add(new ArrayList<Integer>()); }//将每个元素放入桶 for(int i = 0; i < arr.length; i++){ int num = (arr[i] - min) / (arr.length); bucketArr.get(num).add(arr[i]); }//对每个桶进行排序 for(int i = 0; i < bucketArr.size(); i++){ Collections.sort(bucketArr.get(i)); } }

### 12、基数排序算法 ###

**答：**

将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

public class radixSort { 
    	int a[]={ 49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,2 5,53,51};
    	public radixSort(){ 
    		sort(a);
    		for (inti=0;i<a.length;i++){ 
    			System.out.println(a[i]);
    		}
    	}
    	public void sort(int[] array){ 
    		//首先确定排序的趟数; int max=array[0]; for(inti=1;i<array.length;i++){ 
    		if(array[i]>max){ 
    			max=array[i];
    		}
    	}
    	int time=0;
    	//判断位数; while(max>0){ max/=10; time++; }//建立 10 个队列; List<ArrayList> queue=newArrayList<ArrayList>(); for(int i=0;i<10;i++){ ArrayList<Integer>queue1=new ArrayList<Integer>(); queue.add(queue1); }//进行 time 次分配和收集; for(int i=0;i<time;i++){ //分配数组元素; for(intj=0;j<array.length;j++){ //得到数字的第 time+1 位数; int x=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i); ArrayList<Integer>queue2=queue.get(x); queue2.add(array[j]); queue.set(x, queue2); }int count=0;//元素计数器; //收集队列元素; for(int k=0;k<10;k++){ while(queue.get(k).size()>0){ ArrayList<Integer>queue3=queue.get(k); array[count]=queue3.get(0); queue3.remove(0); count++; } } } } }

### 13、剪枝算法 ###

**答：**

在搜索算法中优化中，剪枝，就是通过某种判断，避免一些不必要的遍历过程，形象的说，就是剪去了搜索树中的某些“枝条”，故称剪枝。应用剪枝优化的核心问题是设计剪枝判断方法，即确定哪些枝条应当舍弃，哪些枝条应当保留的方法。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 17][]

### 14、回溯算法 ###

**答：**

回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。

### 15、最短路径算法 ###

**答：**

从某顶点出发，沿图的边到达另一顶点所经过的路径中，各边上权值之和最小的一条路径叫做最短路径。解决最短路的问题有以下算法，Dijkstra算法，Bellman-Ford算法，Floyd算法和SPFA算法等

### 16、最小生成树算法 ###

**答：**

现在假设有一个很实际的问题：我们要在n个城市中建立一个通信网络，则连通这n个城市需要布置n-1一条通信线路，这个时候我们需要考虑如何在成本最低的情况下建立这个通信网？

于是我们就可以引入连通图来解决我们遇到的问题，n个城市就是图上的n个顶点，然后，边表示两个城市的通信线路，每条边上的权重就是我们搭建这条线路所需要的成本，所以现在我们有n个顶点的连通网可以建立不同的生成树，每一颗生成树都可以作为一个通信网，当我们构造这个连通网所花的成本最小时，搭建该连通网的生成树，就称为最小生成树。

构造最小生成树有很多算法，但是他们都是利用了最小生成树的同一种性质：MST性质（假设N=(V,\{E\})是一个连通网， U 是顶点集V的一个非空子集，如果（u，v）是一条具有最小权值的边，其中u属于U， v属于V-U，则必定存在一颗包含边（u， v）的最小生成树），下面就介绍两种使用MST性质生成最小生成树的算法：普里姆算法和克鲁斯卡尔算法。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 18][]

### 17、AES ###

**答：**

高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 19][]

### 18、RSA ###

**答：**

RSA加密算法是一种典型的非对称加密算法，它基于大数的因式分解数学难题，它也是应用最广泛的非对称加密算法。  
非对称加密是通过两个密钥（公钥-私钥）来实现对数据的加密和解密的。公钥用于加密，私钥用于解密。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 20][]  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 21][]

### 19、CRC ###

**答：**

循环冗余校验(Cyclic Redundancy Check, CRC)是一种根据网络数据包或电脑文件等数据产生简短固定位数校验码的一种散列函数，主要用来检测或校验数据传输或者保存后可能出现的错误。它是利用除法及余数的原理来作错误侦测的。

### 20、MD5 ###

**答：**

MD5常常作为文件的签名出现，我们在下载文件的时候，常常会看到文件页面上附带一个扩展名为MD5的文本或者一行字符，这行字符就是就是把整个文件当作原数据通过MD5计算后的值，我们下载文件后，可以用检查文件MD5信息的软件对下载到的文件在进行一次计算。两次结果对比就可以确保下载到文件的准确性。 另一种常见用途就是网站敏感信息加密，比如用户名密码，支付签名等等。

随着https技术的普及，现在的网站广泛采用前台明文传输到后台，MD5加密（使用偏移量）的方式保护敏感数据保护站点和数据安全。

# 总结 #

> 该面试题答案解析完整文档获取方式：[数据结构＋算法面试题总结][Link 2]

[Link 1]: https://mp.weixin.qq.com/s?__biz=Mzg2ODUzMDg1OQ==&mid=2247484196&idx=1&sn=a49343247b50371531c0969261cbc9d8&chksm=ceabace0f9dc25f66c7886e3077f1d581ebbe6a37bddda06515b6963f455212fa6883cad9fdc&token=1038357268&lang=zh_CN#rd
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70]: /images/20221021/f3036d16f6824e9491d02a6120d474c4.png
[20210510210125238.png]: /images/20221021/6af2a2671b424d41810d7d72479cb2e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 1]: /images/20221021/d4c5f8e78074450db68fbc49261c9f2e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 2]: /images/20221021/70c81e9e5c8748649cae2590efa533be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 3]: /images/20221021/c08ad263a6d2413383fd9fb9934fd36e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 4]: /images/20221021/a4df40779a3a4bb2846e2ef4c259e037.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 5]: /images/20221021/5600287a474d4d92ac7c10adb25dc853.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 6]: /images/20221021/8abd8ccc24d04713859e15df291a3726.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 7]: /images/20221021/15266b3c70b34dcb90bcd2f5168977be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 8]: /images/20221021/728eff587eac432ba3bb0cffdeb7c336.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 9]: /images/20221021/5b8e0401d168452e960c9e6a0e526eed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 10]: /images/20221021/3d934eb524b0470fbdbe6d22f4a69bbb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 11]: /images/20221021/2262c65192ef42eb9cacdd6692f6f8a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 12]: /images/20221021/b95e8d29aad24e009bad4663a0295f7c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 13]: /images/20221021/0bafaacfc29e4e1ba7f5f8b03af9b7d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 14]: /images/20221021/a700f28d19c04356b94284db12bdef31.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 15]: /images/20221021/af17387ff458400bb13a7dfe5fe261aa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 16]: /images/20221021/0f692e11ed804ce090f061772da4626a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 17]: /images/20221021/ed4db2d21d2348ec968910b5fa0c86d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 18]: /images/20221021/4413e864bc8f4e2aa487d6ec75e75ee4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 19]: /images/20221021/3fa2d38342eb4104a0b4f0ca20dabbd6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 20]: /images/20221021/22eae6e7b40847d5bb320baac32a51d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ4Nzk1NjA3_size_16_color_FFFFFF_t_70 21]: /images/20221021/5fc9f82db3074184b833a5add3fc946e.png
[Link 2]: https://mp.weixin.qq.com/s?__biz=Mzg2ODUzMDg1OQ==&mid=2247484196&idx=1&sn=a49343247b50371531c0969261cbc9d8&chksm=ceabace0f9dc25f66c7886e3077f1d581ebbe6a37bddda06515b6963f455212fa6883cad9fdc&token=1335914352&lang=zh_CN#rd