From 8dfa8ab7d2b3bde5685389e0ccf45efb77481db2 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 25 Jul 2018 23:35:26 +0800
Subject: [PATCH] auto commit

---
 "notes/Java \345\237\272\347\241\200.md"      |   1 -
 "notes/Java \345\271\266\345\217\221.md"      |  20 ++--
 notes/Linux.md                                |  14 ++-
 notes/Redis.md                                |  72 ++++++------
 ...214\207 offer \351\242\230\350\247\243.md" | 111 +++++++++++-------
 ...15\344\275\234\347\263\273\347\273\237.md" |   2 +-
 ...27\346\234\272\347\275\221\347\273\234.md" |  22 ++--
 pics/026d3cb4-67f7-4a83-884d-8032f57ec446.png | Bin 0 -> 12288 bytes
 8 files changed, 138 insertions(+), 104 deletions(-)
 create mode 100644 pics/026d3cb4-67f7-4a83-884d-8032f57ec446.png

diff --git "a/notes/Java \345\237\272\347\241\200.md" "b/notes/Java \345\237\272\347\241\200.md"
index bdd13aff..907eea00 100644
--- "a/notes/Java \345\237\272\347\241\200.md"	
+++ "b/notes/Java \345\237\272\347\241\200.md"	
@@ -1177,7 +1177,6 @@ Java 注解是附加在代码中的一些元信息，用于一些工具在编译
 - Java 支持自动垃圾回收，而 C++ 需要手动回收。
 - Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
 - Java 不支持操作符重载，虽然可以对两个 String 对象支持加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
-- Java 内置了线程的支持，而 C++ 需要依靠第三方库。
 - Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
 - Java 不支持条件编译，C++ 通过 #ifdef #ifndef 等预处理命令从而实现条件编译。
 
diff --git "a/notes/Java \345\271\266\345\217\221.md" "b/notes/Java \345\271\266\345\217\221.md"
index 800796db..ab3528f2 100644
--- "a/notes/Java \345\271\266\345\217\221.md"	
+++ "b/notes/Java \345\271\266\345\217\221.md"	
@@ -499,7 +499,7 @@ public synchronized static void fun() {
 
 ## ReentrantLock
 
-ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁.
+ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。
 
 ```java
 public class LockExample {
@@ -952,7 +952,7 @@ produce..produce..consume..consume..produce..consume..produce..consume..produce.
 
 ```java
 public class ForkJoinExample extends RecursiveTask<Integer> {
-    private final int threhold = 5;
+    private final int threshold = 5;
     private int first;
     private int last;
 
@@ -964,7 +964,7 @@ public class ForkJoinExample extends RecursiveTask<Integer> {
     @Override
     protected Integer compute() {
         int result = 0;
-        if (last - first <= threhold) {
+        if (last - first <= threshold) {
             // 任务足够小则直接计算
             for (int i = first; i <= last; i++) {
                 result += i;
@@ -1134,7 +1134,7 @@ public static void main(String[] args) throws InterruptedException {
 1000
 ```
 
-除了使用原子类之外，也可以使用 synchronized 互斥锁来保证操作的完整性，它对应的内存间交互操作为：lock 和 unlock，在虚拟机实现上对应的字节码指令为 monitorenter 和 monitorexit。
+除了使用原子类之外，也可以使用 synchronized 互斥锁来保证操作的原子性。它对应的内存间交互操作为：lock 和 unlock，在虚拟机实现上对应的字节码指令为 monitorenter 和 monitorexit。
 
 ```java
 public class AtomicSynchronizedExample {
@@ -1176,9 +1176,13 @@ public static void main(String[] args) throws InterruptedException {
 
 可见性指当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。Java 内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值来实现可见性的。
 
-volatile 可保证可见性。synchronized 也能够保证可见性，对一个变量执行 unlock 操作之前，必须把变量值同步回主内存。final 关键字也能保证可见性：被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 this 逃逸（其它线程可以通过 this 引用访问到初始化了一半的对象），那么其它线程就能看见 final 字段的值。
+主要有有三种实现可见性的方式：
 
-对前面的线程不安全示例中的 cnt 变量用 volatile 修饰，不能解决线程不安全问题，因为 volatile 并不能保证操作的原子性。
+- volatile
+- synchronized，对一个变量执行 unlock 操作之前，必须把变量值同步回主内存。
+- final，被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 this 逃逸（其它线程通过 this 引用访问到初始化了一半的对象），那么其它线程就能看见 final 字段的值。
+
+对前面的线程不安全示例中的 cnt 变量使用 volatile 修饰，不能解决线程不安全问题，因为 volatile 并不能保证操作的原子性。
 
 ### 3. 有序性
 
@@ -1662,9 +1666,9 @@ JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：
 
 - 缩小同步范围，例如对于 synchronized，应该尽量使用同步块而不是同步方法。
 
-- 多用同步类少用 wait() 和 notify()。首先，CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现对复杂控制流的控制。其次，这些类是由最好的企业编写和维护，在后续的 JDK 中它们还会不断优化和完善，使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。
+- 多用同步类少用 wait() 和 notify()。首先，CountDownLatch, CyclicBarrier, Semaphore 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现对复杂的控制流；其次，这些同步类是由最好的企业编写和维护，在后续的 JDK 中还会不断优化和完善，使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。
 
-- 多用并发集合少用同步集合。并发集合比同步集合的可扩展性更好，例如应该使用 ConcurrentHashMap 而不是 Hashtable。
+- 多用并发集合少用同步集合，例如应该使用 ConcurrentHashMap 而不是 Hashtable。
 
 - 使用本地变量和不可变类来保证线程安全。
 
diff --git a/notes/Linux.md b/notes/Linux.md
index 27094e5c..705b9b0d 100644
--- a/notes/Linux.md
+++ b/notes/Linux.md
@@ -871,7 +871,9 @@ $ ls -al /etc | less
 
 ## 提取指令
 
-cut 对数据进行切分，取出想要的部分。切分过程一行一行地进行。
+cut 对数据进行切分，取出想要的部分。
+
+切分过程一行一行地进行。
 
 ```html
 $ cut
@@ -891,7 +893,7 @@ root pts/1 192.168.201.254 Thu Feb 5 22:37 - 23:53 (01:16)
 $ last | cut -d ' ' -f 1
 ```
 
-示例 2：将 export 输出的讯息，取出第 12 字符以后的所有字符串。
+示例 2：将 export 输出的信息，取出第 12 字符以后的所有字符串。
 
 ```html
 $ export
@@ -906,7 +908,7 @@ $ export | cut -c 12
 
 ## 排序指令
 
-**sort**  进行排序。
+**sort**  用于排序。
 
 ```html
 $ sort [-fbMnrtuk] [file or stdin]
@@ -1204,7 +1206,7 @@ pid_t wait(int *status)
 
 如果成功，返回被收集的子进程的进程 ID；如果调用进程没有子进程，调用就会失败，此时返回 -1，同时 errno 被置为 ECHILD。
 
-参数 status 用来保存被收集的子进程退出时的一些状态，如果我们对这个子进程是如何死掉的毫不在意，只想把这个子进程消灭掉，可以设置这个参数为 NULL：
+参数 status 用来保存被收集的子进程退出时的一些状态，如果对这个子进程是如何死掉的毫不在意，只想把这个子进程消灭掉，可以设置这个参数为 NULL：
 
 ```c
 pid = wait(NULL);
@@ -1218,7 +1220,7 @@ pid_t waitpid(pid_t pid, int *status, int options)
 
 作用和 wait() 完全相同，但是多了两个可由用户控制的参数 pid 和 options。
 
-pid 参数指示一个子进程的 ID，表示只关心这个子进程的退出 SIGCHLD 信号。如果 pid=-1 时，那么和 wait() 作用相同，都是关心所有子进程退出的 SIGCHLD 信号。
+pid 参数指示一个子进程的 ID，表示只关心这个子进程退出的 SIGCHLD 信号。如果 pid=-1 时，那么和 wait() 作用相同，都是关心所有子进程退出的 SIGCHLD 信号。
 
 options 参数主要有 WNOHANG 和 WUNTRACED 两个选项，WNOHANG 可以使 waitpid() 调用变成非阻塞的，也就是说它会立即返回，父进程可以继续执行其它任务。
 
@@ -1238,7 +1240,7 @@ options 参数主要有 WNOHANG 和 WUNTRACED 两个选项，WNOHANG 可以使 w
 
 系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程。
 
-要消灭系统中大量的僵尸进程，只需要将其父进程杀死，此时所有的僵尸进程就会变成孤儿进程，从而被 init 所收养，这样 init 就会释放所有的僵死进程所占有的资源，从而结束僵尸进程。
+要消灭系统中大量的僵尸进程，只需要将其父进程杀死，此时僵尸进程就会变成孤儿进程，从而被 init 所收养，这样 init 就会释放所有的僵死进程所占有的资源，从而结束僵尸进程。
 
 # 参考资料
 
diff --git a/notes/Redis.md b/notes/Redis.md
index 8bd8aed0..21840399 100644
--- a/notes/Redis.md
+++ b/notes/Redis.md
@@ -25,7 +25,7 @@
 * [六、键的过期时间](#六键的过期时间)
 * [七、数据淘汰策略](#七数据淘汰策略)
 * [八、持久化](#八持久化)
-    * [快照持久化](#快照持久化)
+    * [RDB 持久化](#rdb-持久化)
     * [AOF 持久化](#aof-持久化)
 * [九、发布与订阅](#九发布与订阅)
 * [十、事务](#十事务)
@@ -210,17 +210,7 @@ OK
 
 ## 字典
 
-以下是 Redis 字典的主要数据结构，从上往下分析，一个 dict 有两个 dictht，一个 dictht 有一个 dictEntry 数组，每个 dictEntry 有 next 指针因此是一个链表结构。从上面的分析可以看出 Redis 的字典是一个基于拉链法解决冲突的哈希表结构。
-
-```c
-typedef struct dict {
-    dictType *type;
-    void *privdata;
-    dictht ht[2];
-    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
-    unsigned long iterators; /* number of iterators currently running */
-} dict;
-```
+dictht 是一个散列表结构，使用拉链法保存哈希冲突的 dictEntry。
 
 ```c
 /* This is our hash table structure. Every dictionary has two of this as we
@@ -246,11 +236,21 @@ typedef struct dictEntry {
 } dictEntry;
 ```
 
-哈希表需要具备扩容能力，在扩容时就需要对每个键值对进行 rehash。dict 有两个 dictht，在 rehash 的时候会将一个 dictht 上的键值对重新插入另一个 dictht 上面，完成之后释放空间并交换两个 dictht 的角色。
+Redis 的字典 dict 中包含两个哈希表 dictht，这是为了方便进行 rehash 操作。在扩容时，将其中一个 dictht 上的键值对 rehash 到另一个 dictht 上面，完成之后释放空间并交换两个 dictht 的角色。
+
+```c
+typedef struct dict {
+    dictType *type;
+    void *privdata;
+    dictht ht[2];
+    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
+    unsigned long iterators; /* number of iterators currently running */
+} dict;
+```
 
 rehash 操作不是一次性完成，而是采用渐进方式，这是为了避免一次性执行过多的 rehash 操作给服务器带来过大的负担。
 
-渐进式 rehash 通过记录 dict 的 rehashidx 完成，它从 0 开始然后每执行一次 rehash 都会递增。例如在一次 rehash 中，要把 dict[0] rehash 到 dict[1]，这一次会把 dict[0] 上 table[rehashidx] 的键值对 rehash 到 dict[1] 上，dict[0] 的 table[rehashidx] 指向 null，并令 rehashidx++。
+渐进式 rehash 通过记录 dict 的 rehashidx 完成，它从 0 开始，然后每执行一次 rehash 都会递增。例如在一次 rehash 中，要把 dict[0] rehash 到 dict[1]，这一次会把 dict[0] 上 table[rehashidx] 的键值对 rehash 到 dict[1] 上，dict[0] 的 table[rehashidx] 指向 null，并令 rehashidx++。
 
 在 rehash 期间，每次对字典执行添加、删除、查找或者更新操作时，都会执行一次渐进式 rehash。
 
@@ -320,13 +320,13 @@ int dictRehash(dict *d, int n) {
 
 <div align="center"> <img src="../pics//beba612e-dc5b-4fc2-869d-0b23408ac90a.png"/> </div><br>
 
-在查找时，从上层指针开始查找，找到对应的区间之后再到下一层去查找。例如下图演示了查找 22 的过程。
+在查找时，从上层指针开始查找，找到对应的区间之后再到下一层去查找。下图演示了查找 22 的过程。
 
 <div align="center"> <img src="../pics//0ea37ee2-c224-4c79-b895-e131c6805c40.png"/> </div><br>
 
 与红黑树等平衡树相比，跳跃表具有以下优点：
 
-- 插入速度非常快速，因为不需要平衡树的旋转操作；
+- 插入速度非常快速，因为不需要进行旋转等操作来维护平衡性；
 - 更容易实现；
 - 支持无锁操作。
 
@@ -336,7 +336,7 @@ int dictRehash(dict *d, int n) {
 
 可以对 String 进行自增自减运算，从而实现计数器功能。
 
-例如对于网站访问量，如果使用 MySQL 数据库进行存储，那么每访问一次网站就要对磁盘进行读写操作。而对 Redis 这种内存型数据库的读写性能非常高，很适合存储这种频繁读写的计数量。
+Redis 这种内存型数据库的读写性能非常高，很适合存储频繁读写的计数量。
 
 ## 缓存
 
@@ -346,7 +346,7 @@ int dictRehash(dict *d, int n) {
 
 例如 DNS 记录就很适合使用 Redis 进行存储。
 
-查找表和缓存类似，也是利用了 Redis 快速的查找特性。但是查找表的内容不能失效，而缓存的内容可以失效。
+查找表和缓存类似，也是利用了 Redis 快速的查找特性。但是查找表的内容不能失效，而缓存的内容可以失效，因为缓存不作为可靠的数据来源。
 
 ## 消息队列
 
@@ -356,27 +356,29 @@ List 是一个双向链表，可以通过 lpop 和 lpush 写入和读取消息
 
 ## 会话缓存
 
-在分布式场景下具有多个应用服务器，可以使用 Redis 来统一存储这些应用服务器的会话信息，使得某个应用服务器宕机时不会丢失会话信息，从而保证高可用。
+在分布式场景下具有多个应用服务器，可以使用 Redis 来统一存储这些应用服务器的会话信息。
+
+当应用服务器不再存储用户的会话信息，也就不再具有状态，一个用户可以请求任意一个应用服务器。
 
 ## 分布式锁实现
 
-在分布式场景下，无法使用单机环境下的锁实现。当多个节点上的进程都需要获取同一个锁时，就需要使用分布式锁来进行同步。
+在分布式场景下，无法使用单机环境下的锁来对多个节点上的进程进行同步。
 
-除了可以使用 Redis 自带的 SETNX 命令实现分布式锁之外，还可以使用官方提供的 RedLock 分布式锁实现。
+可以使用 Reids 自带的 SETNX 命令实现分布式锁，除此之外，还可以使用官方提供的 RedLock 分布式锁实现。
 
 ## 其它
 
-Set 可以实现交集、并集等操作，例如共同好友功能。
+Set 可以实现交集、并集等操作，从而实现共同好友等功能。
 
-ZSet 可以实现有序性操作，例如排行榜功能。
+ZSet 可以实现有序性操作，从而实现排行榜等功能。
 
 # 五、Redis 与 Memcached
 
-两者都是非关系型内存键值数据库。有以下主要不同：
+两者都是非关系型内存键值数据库，主要有以下不同：
 
 ## 数据类型
 
-Memcached 仅支持字符串类型，而 Redis 支持五种不同种类的数据类型，使得它可以更灵活地解决问题。
+Memcached 仅支持字符串类型，而 Redis 支持五种不同的数据类型，可以更灵活地解决问题。
 
 ## 数据持久化
 
@@ -384,15 +386,15 @@ Redis 支持两种持久化策略：RDB 快照和 AOF 日志，而 Memcached 不
 
 ## 分布式
 
-Memcached 不支持分布式，只能通过在客户端使用一致性哈希这样的分布式算法来实现分布式存储，这种方式在存储和查询时都需要先在客户端计算一次数据所在的节点。
+Memcached 不支持分布式，只能通过在客户端使用一致性哈希来实现分布式存储，这种方式在存储和查询时都需要先在客户端计算一次数据所在的节点。
 
 Redis Cluster 实现了分布式的支持。
 
 ## 内存管理机制
 
-在 Redis 中，并不是所有数据都一直存储在内存中，可以将一些很久没用的 value 交换到磁盘。而 Memcached 的数据则会一直在内存中。
+- 在 Redis 中，并不是所有数据都一直存储在内存中，可以将一些很久没用的 value 交换到磁盘，而 Memcached 的数据则会一直在内存中。
 
-Memcached 将内存分割成特定长度的块来存储数据，以完全解决内存碎片的问题，但是这种方式会使得内存的利用率不高，例如块的大小为 128 bytes，只存储 100 bytes 的数据，那么剩下的 28 bytes 就浪费掉了。
+- Memcached 将内存分割成特定长度的块来存储数据，以完全解决内存碎片的问题，但是这种方式会使得内存的利用率不高，例如块的大小为 128 bytes，只存储 100 bytes 的数据，那么剩下的 28 bytes 就浪费掉了。
 
 # 六、键的过期时间
 
@@ -402,7 +404,9 @@ Redis 可以为每个键设置过期时间，当键过期时，会自动删除
 
 # 七、数据淘汰策略
 
-可以设置内存最大使用量，当内存使用量超过时施行淘汰策略，具体有 6 种淘汰策略。
+可以设置内存最大使用量，当内存使用量超出时，会施行数据淘汰策略。
+
+Reids 具体有 6 种淘汰策略：
 
 | 策略 | 描述 |
 | :--: | :--: |
@@ -413,15 +417,15 @@ Redis 可以为每个键设置过期时间，当键过期时，会自动删除
 | allkeys-random | 从所有数据集中任意选择数据进行淘汰 |
 | noeviction | 禁止驱逐数据 |
 
-如果使用 Redis 来缓存数据时，要保证所有数据都是热点数据，可以将内存最大使用量设置为热点数据占用的内存量，然后启用 allkeys-lru 淘汰策略，将最近最少使用的数据淘汰。
+作为内存数据库，出于对性能和内存消耗的考虑，Redis 的淘汰算法实际实现上并非针对所有 key，而是抽样一小部分 key 从中选出被淘汰 key。
 
-作为内存数据库，出于对性能和内存消耗的考虑，Redis 的淘汰算法（LRU、TTL）实际实现上并非针对所有 key，而是抽样一小部分 key 从中选出被淘汰 key。
+使用 Redis 缓存数据时，为了提高缓存命中率，需要保证缓存数据都是热点数据。可以将内存最大使用量设置为热点数据占用的内存量，然后启用 allkeys-lru 淘汰策略，将最近最少使用的数据淘汰。
 
 # 八、持久化
 
 Redis 是内存型数据库，为了保证数据在断电后不会丢失，需要将内存中的数据持久化到硬盘上。
 
-## 快照持久化
+## RDB 持久化
 
 将某个时间点的所有数据都存放到硬盘上。
 
@@ -435,9 +439,7 @@ Redis 是内存型数据库，为了保证数据在断电后不会丢失，需
 
 将写命令添加到 AOF 文件（Append Only File）的末尾。
 
-对硬盘的文件进行写入时，写入的内容首先会被存储到缓冲区，然后由操作系统决定什么时候将该内容同步到硬盘，用户可以调用 file.flush() 方法请求操作系统尽快将缓冲区存储的数据同步到硬盘。可以看出写入文件的数据不会立即同步到硬盘上，在将写命令添加到 AOF 文件时，要根据需求来保证何时同步到硬盘上。
-
-有以下同步选项：
+使用 AOF 持久化需要设置同步选项，从而确保写命令什么时候会同步到磁盘文件上。这是因为对硬盘的文件进行写入并不会马上将内容同步到磁盘文件上，而是先存储到缓冲区，然后由操作系统决定什么时候同步到硬盘。有以下同步选项：
 
 | 选项 | 同步频率 |
 | :--: | :--: |
diff --git "a/notes/\345\211\221\346\214\207 offer \351\242\230\350\247\243.md" "b/notes/\345\211\221\346\214\207 offer \351\242\230\350\247\243.md"
index 7ff73846..a7b6db99 100644
--- "a/notes/\345\211\221\346\214\207 offer \351\242\230\350\247\243.md"	
+++ "b/notes/\345\211\221\346\214\207 offer \351\242\230\350\247\243.md"	
@@ -90,12 +90,20 @@
 
 ## 题目描述
 
-在一个长度为 n 的数组里的所有数字都在 0 到 n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的，也不知道每个数字重复几次。请找出数组中任意一个重复的数字。例如，如果输入长度为 7 的数组 {2, 3, 1, 0, 2, 5}，那么对应的输出是第一个重复的数字 2。
+在一个长度为 n 的数组里的所有数字都在 0 到 n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的，也不知道每个数字重复几次。请找出数组中任意一个重复的数字。
 
-要求复杂度为 O(N) + O(1)，也就是时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。牛客网讨论区这一题的首票答案使用 nums[i] + length 来将元素标记，这么做会有加法溢出问题。
+```html
+Input:
+{2, 3, 1, 0, 2, 5}
+
+Output:
+2
+```
 
 ## 解题思路
 
+要求复杂度为 O(N) + O(1)，也就是时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。牛客网讨论区这一题的首票答案使用 nums[i] + length 来将元素标记，这么做会有加法溢出问题。
+
 这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素放到第 i 个位置上。
 
 以 (2, 3, 1, 0, 2, 5) 为例：
@@ -158,7 +166,11 @@ Given target = 20, return false.
 
 ## 解题思路
 
-从右上角开始查找。因为矩阵中的一个数，它左边的数都比它小，下边的数都比它大。因此，从右上角开始查找，就可以根据 target 和当前元素的大小关系来缩小查找区间。
+从右上角开始查找。矩阵中的一个数，它左边的数都比它小，下边的数都比它大。因此，从右上角开始查找，就可以根据 target 和当前元素的大小关系来缩小查找区间。
+
+当前元素的查找区间为左下角的所有元素，例如元素 12 的查找区间如下：
+
+<div align="center"> <img src="../pics//026d3cb4-67f7-4a83-884d-8032f57ec446.png" width="200"/> </div><br>
 
 复杂度：O(M + N) + O(1)
 
@@ -261,25 +273,14 @@ public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
 }
 ```
 
-### 使用 Collections.reverse()
-
-```java
-public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
-    ArrayList<Integer> ret = new ArrayList<>();
-    while (listNode != null) {
-        ret.add(listNode.val);
-        listNode = listNode.next;
-    }
-    Collections.reverse(ret);
-    return ret;
-}
-```
-
 ### 使用头插法
 
 利用链表头插法为逆序的特点。
 
-头结点和第一个节点的区别：头结点是在头插法中使用的一个额外节点，这个节点不存储值；第一个节点就是链表的第一个真正存储值的节点。
+头结点和第一个节点的区别：
+
+- 头结点是在头插法中使用的一个额外节点，这个节点不存储值；
+- 第一个节点就是链表的第一个真正存储值的节点。
 
 ```java
 public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
@@ -302,6 +303,20 @@ public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
 }
 ```
 
+### 使用 Collections.reverse()
+
+```java
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    while (listNode != null) {
+        ret.add(listNode.val);
+        listNode = listNode.next;
+    }
+    Collections.reverse(ret);
+    return ret;
+}
+```
+
 # 7. 重建二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/8a19cbe657394eeaac2f6ea9b0f6fcf6?tpId=13&tqId=11157&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
@@ -322,22 +337,23 @@ inorder =  [9,3,15,20,7]
 前序遍历的第一个值为根节点的值，使用这个值将中序遍历结果分成两部分，左部分为树的左子树中序遍历结果，右部分为树的右子树中序遍历的结果。
 
 ```java
-private Map<Integer, Integer> inOrderNumsIndexs = new HashMap<>(); // 缓存中序遍历数组的每个值对应的索引
+// 缓存中序遍历数组的每个值对应的索引
+private Map<Integer, Integer> inOrderNumsIndexs = new HashMap<>();
 
 public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
     for (int i = 0; i < in.length; i++)
         inOrderNumsIndexs.put(in[i], i);
-    return reConstructBinaryTree(pre, 0, pre.length - 1, in, 0, in.length - 1);
+    return reConstructBinaryTree(pre, 0, pre.length - 1, 0, in.length - 1);
 }
 
-private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int[] in, int inL, int inR) {
+private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int inL, int inR) {
     if (preL > preR)
         return null;
     TreeNode root = new TreeNode(pre[preL]);
     int inIndex = inOrderNumsIndexs.get(root.val);
     int leftTreeSize = inIndex - inL;
-    root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, in, inL, inL + leftTreeSize - 1);
-    root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, in, inL + leftTreeSize + 1, inR);
+    root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, inL, inL + leftTreeSize - 1);
+    root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, inL + leftTreeSize + 1, inR);
     return root;
 }
 ```
@@ -350,16 +366,6 @@ private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int[] in,
 
 给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
 
-## 解题思路
-
-① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
-
-<div align="center"> <img src="../pics//cb0ed469-27ab-471b-a830-648b279103c8.png" width="250"/> </div><br>
-
-② 否则，向上找第一个左链接指向的树包含该节点的祖先节点。
-
-<div align="center"> <img src="../pics//e143f6da-d114-4ba4-8712-f65299047fa2.png" width="250"/> </div><br>
-
 ```java
 public class TreeLinkNode {
     int val;
@@ -373,6 +379,16 @@ public class TreeLinkNode {
 }
 ```
 
+## 解题思路
+
+① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
+
+<div align="center"> <img src="../pics//cb0ed469-27ab-471b-a830-648b279103c8.png" width="250"/> </div><br>
+
+② 否则，向上找第一个左链接指向的树包含该节点的祖先节点。
+
+<div align="center"> <img src="../pics//e143f6da-d114-4ba4-8712-f65299047fa2.png" width="250"/> </div><br>
+
 ```java
 public TreeLinkNode GetNext(TreeLinkNode pNode) {
     if (pNode.right != null) {
@@ -398,7 +414,7 @@ public TreeLinkNode GetNext(TreeLinkNode pNode) {
 
 ## 题目描述
 
-用两个栈来实现一个队列，完成队列的 Push 和 Pop 操作。队列中的元素为 int 类型。
+用两个栈来实现一个队列，完成队列的 Push 和 Pop 操作。
 
 ## 解题思路
 
@@ -442,7 +458,7 @@ public int pop() throws Exception {
 
 <div align="center"> <img src="../pics//a0df8edc-581b-4977-95c2-d7025795b899.png" width="300"/> </div><br>
 
-递归方法是将一个问题划分成多个子问题求解，动态规划也是如此，但是动态规划会把子问题的解缓存起来，避免重复求解子问题。
+递归是将一个问题划分成多个子问题求解，动态规划也是如此，但是动态规划会把子问题的解缓存起来，从而避免重复求解子问题。
 
 ```java
 public int Fibonacci(int n) {
@@ -521,11 +537,11 @@ public int JumpFloor(int n) {
 
 ```java
 public int JumpFloor(int n) {
-    if (n <= 1)
+    if (n <= 2)
         return n;
-    int pre2 = 0, pre1 = 1;
-    int result = 0;
-    for (int i = 1; i <= n; i++) {
+    int pre2 = 1, pre1 = 2;
+    int result = 1;
+    for (int i = 2; i < n; i++) {
         result = pre2 + pre1;
         pre2 = pre1;
         pre1 = result;
@@ -613,6 +629,8 @@ public int RectCover(int n) {
 
 因为 h 的赋值表达式为 h = m，因此循环体的循环条件应该为 l < h，详细解释请见 [Leetcode 题解](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3.md#%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE) 二分查找部分。
 
+但是如果出现 nums[l] == nums[m] == nums[h]，那么此时无法确定解在哪个区间，因此需要切换到顺序查找。
+
 复杂度：O(logN) + O(1)
 
 ```java
@@ -622,13 +640,22 @@ public int minNumberInRotateArray(int[] nums) {
     int l = 0, h = nums.length - 1;
     while (l < h) {
         int m = l + (h - l) / 2;
-        if (nums[m] <= nums[h])
+        if (nums[l] == nums[m] && nums[m] == nums[h])
+            return minNumber(nums, l, h);
+        else if (nums[m] <= nums[h])
             h = m;
         else
             l = m + 1;
     }
     return nums[l];
 }
+
+private int minNumber(int[] nums, int l, int h) {
+    for (int i = l; i < h; i++)
+        if (nums[i] > nums[i + 1])
+            return nums[i + 1];
+    return nums[l];
+}
 ```
 
 # 12. 矩阵中的路径
@@ -2022,7 +2049,7 @@ public int getDigitAtIndex(int index)
 {
     if (index < 0)
         return -1;
-    int place = 1;  // 位数，1 表示个位，2 表示 十位...
+    int place = 1;  // 1 表示个位，2 表示 十位...
     while (true) {
         int amount = getAmountOfPlace(place);
         int totalAmount = amount * place;
@@ -2640,7 +2667,7 @@ private void swap(char[] c, int i, int j)
 
 ## 解题思路
 
-将 "abcXYZdef" 旋转左移三位，可以先将 "abc" 和 "XYZdef" 分别旋转，得到 "cbafedZYX"，然后再把整个字符串旋转得到 "XYZdefabc"。
+先将 "abc" 和 "XYZdef" 分别翻转，得到 "cbafedZYX"，然后再把整个字符串翻转得到 "XYZdefabc"。
 
 ```java
 public String LeftRotateString(String str, int n)
diff --git "a/notes/\350\256\241\347\256\227\346\234\272\346\223\215\344\275\234\347\263\273\347\273\237.md" "b/notes/\350\256\241\347\256\227\346\234\272\346\223\215\344\275\234\347\263\273\347\273\237.md"
index 4a4077d3..52c74dd7 100644
--- "a/notes/\350\256\241\347\256\227\346\234\272\346\223\215\344\275\234\347\263\273\347\273\237.md"
+++ "b/notes/\350\256\241\347\256\227\346\234\272\346\223\215\344\275\234\347\263\273\347\273\237.md"
@@ -352,7 +352,7 @@ end monitor;
 
 管程引入了  **条件变量**  以及相关的操作：**wait()** 和 **signal()** 来实现同步操作。对条件变量执行 wait() 操作会导致调用进程阻塞，把管程让出来给另一个进程持有。signal() 操作用于唤醒被阻塞的进程。
 
-<font size=3> **使用管程实现生成者-消费者问题** </font><br>
+<font size=3> **使用管程实现生产者-消费者问题** </font><br>
 
 ```pascal
 // 管程
diff --git "a/notes/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md" "b/notes/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
index 8603393c..f1460844 100644
--- "a/notes/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
+++ "b/notes/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234.md"
@@ -139,25 +139,17 @@
 
 -  **物理层** ：考虑的是怎样在传输媒体上传输数据比特流，而不是指具体的传输媒体。物理层的作用是尽可能屏蔽传输媒体和通信手段的差异，使数据链路层感觉不到这些差异。
 
-### 2. 七层协议
+### 2. OSI
 
 其中表示层和会话层用途如下：
 
--  **表示层** ：数据压缩、加密以及数据描述。这使得应用程序不必担心在各台主机中表示/存储的内部格式不同的问题。
+-  **表示层** ：数据压缩、加密以及数据描述，这使得应用程序不必担心在各台主机中数据内部格式不同的问题。
 
 -  **会话层** ：建立及管理会话。
 
 五层协议没有表示层和会话层，而是将这些功能留给应用程序开发者处理。
 
-### 3. 数据在各层之间的传递过程
-
-在向下的过程中，需要添加下层协议所需要的首部或者尾部，而在向上的过程中不断拆开首部和尾部。
-
-路由器只有下面三层协议，因为路由器位于网络核心中，不需要为进程或者应用程序提供服务，因此也就不需要运输层和应用层。
-
-<div align="center"> <img src="../pics//ac106e7e-489a-4082-abd9-dabebe48394c.jpg" width="800"/> </div><br>
-
-### 4. TCP/IP
+### 3. TCP/IP
 
 它只有四层，相当于五层协议中数据链路层和物理层合并为网络接口层。
 
@@ -169,6 +161,14 @@ TCP/IP 协议族是一种沙漏形状，中间小两边大，IP 协议在其中
 
 <div align="center"> <img src="../pics//d4eef1e2-5703-4ca4-82ab-8dda93d6b81f.png" width="500"/> </div><br>
 
+### 4. 数据在各层之间的传递过程
+
+在向下的过程中，需要添加下层协议所需要的首部或者尾部，而在向上的过程中不断拆开首部和尾部。
+
+路由器只有下面三层协议，因为路由器位于网络核心中，不需要为进程或者应用程序提供服务，因此也就不需要运输层和应用层。
+
+<div align="center"> <img src="../pics//ac106e7e-489a-4082-abd9-dabebe48394c.jpg" width="800"/> </div><br>
+
 # 二、物理层
 
 ## 通信方式
diff --git a/pics/026d3cb4-67f7-4a83-884d-8032f57ec446.png b/pics/026d3cb4-67f7-4a83-884d-8032f57ec446.png
new file mode 100644
index 0000000000000000000000000000000000000000..26d62519c21cc9276451c0551b859dad1ec70566
GIT binary patch
literal 12288
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%0DQ^dqcqDx+Mg{ru#<kzUsjU0u)4
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
D?`aRZ

literal 0
HcmV?d00001

-- 
GitLab