From 2abb5464c8ce9062a60f60a8e59f7ff9f39fd6d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E4=BC=9F?= <18056981502@163.com>
Date: Tue, 14 Aug 2018 01:03:00 +0800
Subject: [PATCH 01/14] =?UTF-8?q?=E8=87=AA=E9=80=89=E9=94=81=20->=20?=
 =?UTF-8?q?=E8=87=AA=E6=97=8B=E9=94=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 notes/Java 并发.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/notes/Java 并发.md b/notes/Java 并发.md
index 89ab7cac..28e69e36 100644
--- a/notes/Java 并发.md	
+++ b/notes/Java 并发.md	
@@ -1594,7 +1594,7 @@ ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因
 
 互斥同步的进入阻塞状态的开销都很大，应该尽量避免。在许多应用中，共享数据的锁定状态只会持续很短的一段时间。自旋锁的思想是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。
 
-自选锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。
+自旋锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。
 
 在 JDK 1.6 中引入了自适应的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。
 

From 7fc6ceac3c621239257bae76eb169593deca5292 Mon Sep 17 00:00:00 2001
From: zhangzhikai <zhangzhikai@corp.netease.com>
Date: Tue, 14 Aug 2018 14:45:21 +0800
Subject: [PATCH 02/14] =?UTF-8?q?=E4=BF=AE=E6=94=B9CyclicBarrier=E9=83=A8?=
 =?UTF-8?q?=E5=88=86=E9=94=99=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 notes/Java 并发.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/notes/Java 并发.md b/notes/Java 并发.md
index ab3528f2..e7d09e1f 100644
--- a/notes/Java 并发.md	
+++ b/notes/Java 并发.md	
@@ -759,7 +759,7 @@ run..run..run..run..run..run..run..run..run..run..end
 
 用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。
 
-和 CountdownLatch 相似，都是通过维护计数器来实现的。但是它的计数器是递增的，每次执行 await() 方法之后，计数器会加 1，直到计数器的值和设置的值相等，等待的所有线程才会继续执行。和 CountdownLatch 的另一个区别是，CyclicBarrier 的计数器可以循环使用，所以它才叫做循环屏障。
+和 CountdownLatch 相似，都是通过维护计数器来实现的。初始化的时候计数器count与构造函数传入的参数parties相同，每次有线程调用await方法时候，计数器count不断减1，知道count减为0时等待的所有线程才会继续执行。和 CountdownLatch 的另一个区别是，CyclicBarrier 可以通过调用reset方法循环使用，所以它才叫做循环屏障。
 
 下图应该从下往上看才正确。
 

From 3056dea7b21034cbd1017dcd7652b7576ddd0be7 Mon Sep 17 00:00:00 2001
From: zhangzhikai <zhangzhikai@corp.netease.com>
Date: Tue, 14 Aug 2018 14:49:12 +0800
Subject: [PATCH 03/14] =?UTF-8?q?=E4=BF=AE=E6=94=B9CyclicBarrier=E9=83=A8?=
 =?UTF-8?q?=E5=88=86=E9=94=99=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 notes/Java 并发.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/notes/Java 并发.md b/notes/Java 并发.md
index e7d09e1f..e59cb9e7 100644
--- a/notes/Java 并发.md	
+++ b/notes/Java 并发.md	
@@ -759,7 +759,7 @@ run..run..run..run..run..run..run..run..run..run..end
 
 用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。
 
-和 CountdownLatch 相似，都是通过维护计数器来实现的。初始化的时候计数器count与构造函数传入的参数parties相同，每次有线程调用await方法时候，计数器count不断减1，知道count减为0时等待的所有线程才会继续执行。和 CountdownLatch 的另一个区别是，CyclicBarrier 可以通过调用reset方法循环使用，所以它才叫做循环屏障。
+和 CountdownLatch 相似，都是通过维护计数器来实现的。初始化的时候计数器count与构造函数传入的参数parties相同，每次有线程调用await方法时候，计数器count不断减1，直到count减为0时等待的所有线程才会继续执行。和 CountdownLatch 的另一个区别是，CyclicBarrier 可以通过调用reset方法循环使用，所以它才叫做循环屏障。
 
 下图应该从下往上看才正确。
 

From 819060dc94049c77cec80eaed2d0f67156128353 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 14 Aug 2018 21:07:46 +0800
Subject: [PATCH 04/14] auto commit

---
 notes/Java 并发.md         | 108 ++++++++++++++++++++---------------
 notes/剑指 offer 题解.md |  41 ++++++++-----
 2 files changed, 89 insertions(+), 60 deletions(-)

diff --git a/notes/Java 并发.md b/notes/Java 并发.md
index 89ab7cac..9cd5955b 100644
--- a/notes/Java 并发.md	
+++ b/notes/Java 并发.md	
@@ -733,7 +733,6 @@ java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.
 
 ```java
 public class CountdownLatchExample {
-
     public static void main(String[] args) throws InterruptedException {
         final int totalThread = 10;
         CountDownLatch countDownLatch = new CountDownLatch(totalThread);
@@ -759,15 +758,30 @@ run..run..run..run..run..run..run..run..run..run..end
 
 用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。
 
-和 CountdownLatch 相似，都是通过维护计数器来实现的。但是它的计数器是递增的，每次执行 await() 方法之后，计数器会加 1，直到计数器的值和设置的值相等，等待的所有线程才会继续执行。和 CountdownLatch 的另一个区别是，CyclicBarrier 的计数器可以循环使用，所以它才叫做循环屏障。
+和 CountdownLatch 相似，都是通过维护计数器来实现的。线程执行 await() 方法之后计数器会减 1，并进行等待，直到计数器为 0，所有调用 awati() 方法而在等待的线程才能继续执行。
 
-下图应该从下往上看才正确。
+CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset() 方法可以循环使用，所以它才叫做循环屏障。
+
+CyclicBarrier 有两个构造函数，其中 parties 指示计数器的初始值，barrierAction 在所有线程都到达屏障的时候会执行一次。
+
+```java
+public CyclicBarrier(int parties, Runnable barrierAction) {
+    if (parties <= 0) throw new IllegalArgumentException();
+    this.parties = parties;
+    this.count = parties;
+    this.barrierCommand = barrierAction;
+}
+
+public CyclicBarrier(int parties) {
+    this(parties, null);
+}
+```
 
 <div align="center"> <img src="../pics//CyclicBarrier.png" width=""/> </div><br>
 
 ```java
 public class CyclicBarrierExample {
-    public static void main(String[] args) throws InterruptedException {
+    public static void main(String[] args) {
         final int totalThread = 10;
         CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
         ExecutorService executorService = Executors.newCachedThreadPool();
@@ -776,9 +790,7 @@ public class CyclicBarrierExample {
                 System.out.print("before..");
                 try {
                     cyclicBarrier.await();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                } catch (BrokenBarrierException e) {
+                } catch (InterruptedException | BrokenBarrierException e) {
                     e.printStackTrace();
                 }
                 System.out.print("after..");
@@ -1198,8 +1210,6 @@ volatile 关键字通过添加内存屏障的方式来禁止指令重排，即
 
 上面提到了可以用 volatile 和 synchronized 来保证有序性。除此之外，JVM 还规定了先行发生原则，让一个操作无需控制就能先于另一个操作完成。
 
-主要有以下这些原则：
-
 ### 1. 单一线程原则
 
 > Single Thread rule
@@ -1270,14 +1280,16 @@ Thread 对象的结束先行发生于 join() 方法返回。
 
 ### 1. 不可变
 
-不可变（Immutable）的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采取任何的线程安全保障措施，只要一个不可变的对象被正确地构建出来，那其外部的可见状态永远也不会改变，永远也不会看到它在多个线程之中处于不一致的状态。
+不可变（Immutable）的对象一定是线程安全的，不需要再采取任何的线程安全保障措施。只要一个不可变的对象被正确地构建出来，永远也不会看到它在多个线程之中处于不一致的状态。
+
+多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
 
 不可变的类型：
 
-- final 关键字修饰的基本数据类型；
+- final 关键字修饰的基本数据类型
 - String
 - 枚举类型
-- Number 部分子类，如 Long 和 Double 等数值包装类型，BigInteger 和 BigDecimal 等大数据类型。但同为 Number 的子类型的原子类 AtomicInteger 和 AtomicLong 则并非不可变的。
+- Number 部分子类，如 Long 和 Double 等数值包装类型，BigInteger 和 BigDecimal 等大数据类型。但同为 Number 的原子类 AtomicInteger 和 AtomicLong 则是可变的。
 
 对于集合类型，可以使用 Collections.unmodifiableXXX() 方法来获取一个不可变的集合。
 
@@ -1305,21 +1317,19 @@ public V put(K key, V value) {
 }
 ```
 
-多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
-
 ### 2. 绝对线程安全
 
 不管运行时环境如何，调用者都不需要任何额外的同步措施。
 
 ### 3. 相对线程安全
 
-相对的线程安全需要保证对这个对象单独的操作是线程安全的，在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。
+相对线程安全需要保证对这个对象单独的操作是线程安全的，在调用的时候不需要做额外的保障措施。但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。
 
 在 Java 语言中，大部分的线程安全类都属于这种类型，例如 Vector、HashTable、Collections 的 synchronizedCollection() 方法包装的集合等。
 
-对于下面的代码，如果删除元素的线程删除了一个元素，而获取元素的线程试图访问一个已经被删除的元素，那么就会抛出 ArrayIndexOutOfBoundsException。
+对于下面的代码，如果删除元素的线程删除了 Vector 的一个元素，而获取元素的线程试图访问一个已经被删除的元素，那么就会抛出 ArrayIndexOutOfBoundsException。
 
-```java
+```Java
 public class VectorUnsafeExample {
     private static Vector<Integer> vector = new Vector<>();
 
@@ -1389,15 +1399,17 @@ synchronized 和 ReentrantLock。
 
 ### 2. 非阻塞同步
 
-互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。
+互斥同步最主要的问题就是线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。
 
-互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
+互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
 
-随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步。
+**（一）CAS** 
 
-乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。
+随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要将线程阻塞，因此这种同步操作称为非阻塞同步。
 
-硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
+乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
+
+**（二）AtomicInteger** 
 
 J.U.C 包里面的整数原子类 AtomicInteger，其中的 compareAndSet() 和 getAndIncrement() 等方法都使用了 Unsafe 类的 CAS 操作。
 
@@ -1419,7 +1431,7 @@ public final int incrementAndGet() {
 }
 ```
 
-以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值 ==var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
+以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
 
 可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。
 
@@ -1434,23 +1446,19 @@ public final int getAndAddInt(Object var1, long var2, int var4) {
 }
 ```
 
-ABA ：如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
+**（三）ABA** 
+
+如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
 
 J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
 
 ### 3. 无同步方案
 
-要保证线程安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。
+要保证线程安全，并不是一定就要进行同步。如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性。
 
-**（一）可重入代码（Reentrant Code）** 
+**（一）栈封闭** 
 
-这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。
-
-可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。
-
-**（二）栈封闭** 
-
-多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在栈中，属于线程私有的。
+多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的。
 
 ```java
 import java.util.concurrent.ExecutorService;
@@ -1482,11 +1490,11 @@ public static void main(String[] args) {
 100
 ```
 
-**（三）线程本地存储（Thread Local Storage）** 
+**（二）线程本地存储（Thread Local Storage）** 
 
 如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
 
-符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完，其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
+符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完。其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
 
 可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。
 
@@ -1584,17 +1592,25 @@ public T get() {
 }
 ```
 
-ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，尽可能在每次使用 ThreadLocal 后手动调用 remove()，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
+ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。
+
+在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，应该尽可能在每次使用 ThreadLocal 后手动调用 remove()，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
+
+**（三）可重入代码（Reentrant Code）** 
+
+这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。
+
+可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。
 
 # 十二、锁优化
 
-这里的锁优化主要是指虚拟机对 synchronized 的优化。
+这里的锁优化主要是指 JVM 对 synchronized 的优化。
 
 ## 自旋锁
 
-互斥同步的进入阻塞状态的开销都很大，应该尽量避免。在许多应用中，共享数据的锁定状态只会持续很短的一段时间。自旋锁的思想是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。
+互斥同步进入阻塞状态的开销都很大，应该尽量避免。在许多应用中，共享数据的锁定状态只会持续很短的一段时间。自旋锁的思想是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。
 
-自选锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。
+自旋锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。
 
 在 JDK 1.6 中引入了自适应的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。
 
@@ -1624,7 +1640,7 @@ public static String concatString(String s1, String s2, String s3) {
 }
 ```
 
-每个 append() 方法中都有一个同步块。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 concatString() 方法内部。也就是说，sb 的所有引用永远不会“逃逸”到 concatString() 方法之外，其他线程无法访问到它，因此可以进行消除。
+每个 append() 方法中都有一个同步块。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 concatString() 方法内部。也就是说，sb 的所有引用永远不会逃逸到 concatString() 方法之外，其他线程无法访问到它，因此可以进行消除。
 
 ## 锁粗化
 
@@ -1636,9 +1652,9 @@ public static String concatString(String s1, String s2, String s3) {
 
 JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：无锁状态（unlocked）、偏向锁状态（biasble）、轻量级锁状态（lightweight locked）和重量级锁状态（inflated）。
 
-以下是 HotSpot 虚拟机对象头的内存布局，这些数据被称为 mark word。其中 tag bits 对应了五个状态，这些状态在右侧的 state 表格中给出，应该注意的是 state 表格不是存储在对象头中的。除了 marked for gc 状态，其它四个状态已经在前面介绍过了。
+以下是 HotSpot 虚拟机对象头的内存布局，这些数据被称为 Mark Word。其中 tag bits 对应了五个状态，这些状态在右侧的 state 表格中给出。除了 marked for gc 状态，其它四个状态已经在前面介绍过了。
 
-<div align="center"> <img src="../pics//bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png" width="600"/> </div><br>
+<div align="center"> <img src="../pics//bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png" width="500"/> </div><br>
 
 下图左侧是一个线程的虚拟机栈，其中有一部分称为 Lock Record 的区域，这是在轻量级锁运行过程创建的，用于存放锁对象的 Mark Word。而右侧就是一个锁对象，包含了 Mark Word 和其它信息。
 
@@ -1646,9 +1662,9 @@ JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：
 
 轻量级锁是相对于传统的重量级锁而言，它使用 CAS 操作来避免重量级锁使用互斥量的开销。对于绝大部分的锁，在整个同步周期内都是不存在竞争的，因此也就不需要都使用互斥量进行同步，可以先采用 CAS 操作进行同步，如果 CAS 失败了再改用互斥量进行同步。
 
-当尝试获取一个锁对象时，如果锁对象标记为 0 01，说明锁对象的锁未锁定（unlocked）状态。此时虚拟机在当前线程栈中创建 Lock Record，然后使用 CAS 操作将对象的 Mark Word 更新为 Lock Record 指针。如果 CAS 操作成功了，那么线程就获取了该对象上的锁，并且对象的 Mark Word 的锁标记变为 00，表示该对象处于轻量级锁状态。
+当尝试获取一个锁对象时，如果锁对象标记为 0 01，说明锁对象的锁未锁定（unlocked）状态。此时虚拟机在当前线程的虚拟机栈中创建 Lock Record，然后使用 CAS 操作将对象的 Mark Word 更新为 Lock Record 指针。如果 CAS 操作成功了，那么线程就获取了该对象上的锁，并且对象的 Mark Word 的锁标记变为 00，表示该对象处于轻量级锁状态。
 
-<div align="center"> <img src="../pics//baaa681f-7c52-4198-a5ae-303b9386cf47.png" width="500"/> </div><br>
+<div align="center"> <img src="../pics//baaa681f-7c52-4198-a5ae-303b9386cf47.png" width="400"/> </div><br>
 
 如果 CAS 操作失败了，虚拟机首先会检查对象的 Mark Word 是否指向当前线程的虚拟机栈，如果是的话说明当前线程已经拥有了这个锁对象，那就可以直接进入同步块继续执行，否则说明这个锁对象已经被其他线程线程抢占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁。
 
@@ -1666,9 +1682,9 @@ JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：
 
 - 给线程起个有意义的名字，这样可以方便找 Bug。
 
-- 缩小同步范围，例如对于 synchronized，应该尽量使用同步块而不是同步方法。
+- 缩小同步范围，从而减少锁争用。例如对于 synchronized，应该尽量使用同步块而不是同步方法。
 
-- 多用同步类少用 wait() 和 notify()。首先，CountDownLatch, CyclicBarrier, Semaphore 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现对复杂的控制流；其次，这些同步类是由最好的企业编写和维护，在后续的 JDK 中还会不断优化和完善，使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。
+- 多用同步工具少用 wait() 和 notify()。首先，CountDownLatch, CyclicBarrier, Semaphore 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现复杂控制流；其次，这些同步类是由最好的企业编写和维护，在后续的 JDK 中还会不断优化和完善，使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。
 
 - 多用并发集合少用同步集合，例如应该使用 ConcurrentHashMap 而不是 Hashtable。
 
diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md
index 0c9bd1f9..4fcc45dc 100644
--- a/notes/剑指 offer 题解.md	
+++ b/notes/剑指 offer 题解.md	
@@ -2520,7 +2520,7 @@ public void FindNumsAppearOnce(int[] nums, int num1[], int num2[]) {
 
 ## 题目描述
 
-输入一个递增排序的数组和一个数字 S，在数组中查找两个数，使得他们的和正好是 S，如果有多对数字的和等于 S，输出两个数的乘积最小的。
+输入一个递增排序的数组和一个数字 S，在数组中查找两个数，使得他们的和正好是 S。如果有多对数字的和等于 S，输出两个数的乘积最小的。
 
 ## 解题思路
 
@@ -2596,9 +2596,13 @@ public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {
 
 ## 题目描述
 
-输入："I am a student."
+```html
+Input:
+"I am a student."
 
-输出："student. a am I"
+Output:
+"student. a am I"
+```
 
 ## 解题思路
 
@@ -2640,7 +2644,14 @@ private void swap(char[] c, int i, int j) {
 
 ## 题目描述
 
-对于一个给定的字符序列 S，请你把其循环左移 K 位后的序列输出。例如，字符序列 S=”abcXYZdef”, 要求输出循环左移 3 位后的结果，即“XYZdefabc”。
+```html
+Input:
+S="abcXYZdef"
+K=3
+
+Output:
+"XYZdefabc"
+```
 
 ## 解题思路
 
@@ -2675,7 +2686,9 @@ private void swap(char[] chars, int i, int j) {
 
 ## 题目描述
 
-给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组 {2, 3, 4, 2, 6, 2, 5, 1} 及滑动窗口的大小 3，那么一共存在 6 个滑动窗口，他们的最大值分别为 {4, 4, 6, 6, 6, 5}。
+给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。
+
+例如，如果输入数组 {2, 3, 4, 2, 6, 2, 5, 1} 及滑动窗口的大小 3，那么一共存在 6 个滑动窗口，他们的最大值分别为 {4, 4, 6, 6, 6, 5}。
 
 ## 解题思路
 
@@ -2774,7 +2787,7 @@ public List<Map.Entry<Integer, Double>> dicesSum(int n) {
 
 ## 题目描述
 
-五张牌，其中大小鬼为癞子，牌面大小为 0。判断是否能组成顺子。
+五张牌，其中大小鬼为癞子，牌面大小为 0。判断这五张牌是否能组成顺子。
 
 ## 解题思路
 
@@ -2803,7 +2816,7 @@ public boolean isContinuous(int[] nums) {
 
 ## 题目描述
 
-让小朋友们围成一个大圈。然后，他随机指定一个数 m，让编号为 0 的小朋友开始报数。每次喊到 m-1 的那个小朋友要出列唱首歌，然后可以在礼品箱中任意的挑选礼物，并且不再回到圈中，从他的下一个小朋友开始，继续 0...m-1 报数 .... 这样下去 .... 直到剩下最后一个小朋友，可以不用表演。
+让小朋友们围成一个大圈。然后，随机指定一个数 m，让编号为 0 的小朋友开始报数。每次喊到 m-1 的那个小朋友要出列唱首歌，然后可以在礼品箱中任意的挑选礼物，并且不再回到圈中，从他的下一个小朋友开始，继续 0...m-1 报数 .... 这样下去 .... 直到剩下最后一个小朋友，可以不用表演。
 
 ## 解题思路
 
@@ -2813,7 +2826,7 @@ public boolean isContinuous(int[] nums) {
 public int LastRemaining_Solution(int n, int m) {
     if (n == 0)     /* 特殊输入的处理 */
         return -1;
-    if (n == 1)     /* 返回条件 */
+    if (n == 1)     /* 递归返回条件 */
         return 0;
     return (LastRemaining_Solution(n - 1, m) + m) % n;
 }
@@ -2851,7 +2864,7 @@ public int maxProfit(int[] prices) {
 
 ## 题目描述
 
-求 1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句（A?B:C）。
+要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句 A ? B : C。
 
 ## 解题思路
 
@@ -2859,7 +2872,7 @@ public int maxProfit(int[] prices) {
 
 条件与 && 具有短路原则，即在第一个条件语句为 false 的情况下不会去执行第二个条件语句。利用这一特性，将递归的返回条件取非然后作为 && 的第一个条件语句，递归的主体转换为第二个条件语句，那么当递归的返回条件为 true 的情况下就不会执行递归的主体部分，递归返回。
 
-以下实现中，递归的返回条件为 n <= 0，取非后就是 n > 0，递归的主体部分为 sum += Sum_Solution(n - 1)，转换为条件语句后就是 (sum += Sum_Solution(n - 1)) > 0。
+本题的递归返回条件为 n <= 0，取非后就是 n > 0；递归的主体部分为 sum += Sum_Solution(n - 1)，转换为条件语句后就是 (sum += Sum_Solution(n - 1)) > 0。
 
 ```java
 public int Sum_Solution(int n) {
@@ -2875,7 +2888,7 @@ public int Sum_Solution(int n) {
 
 ## 题目描述
 
-写一个函数，求两个整数之和，要求在函数体内不得使用 +、-、\*、/ 四则运算符号。
+写一个函数，求两个整数之和，要求不得使用 +、-、\*、/ 四则运算符号。
 
 ## 解题思路
 
@@ -2895,7 +2908,7 @@ public int Add(int a, int b) {
 
 ## 题目描述
 
-给定一个数组 A[0, 1,..., n-1], 请构建一个数组 B[0, 1,..., n-1], 其中 B 中的元素 B[i]=A[0]\*A[1]\*...\*A[i-1]\*A[i+1]\*...\*A[n-1]。不能使用除法。
+给定一个数组 A[0, 1,..., n-1]，请构建一个数组 B[0, 1,..., n-1]，其中 B 中的元素 B[i]=A[0]\*A[1]\*...\*A[i-1]\*A[i+1]\*...\*A[n-1]。要求不能使用除法。
 
 ## 解题思路
 
@@ -2917,7 +2930,7 @@ public int[] multiply(int[] A) {
 
 ## 题目描述
 
-将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为 0 或者字符串不是一个合法的数值则返回 0。
+将一个字符串转换成一个整数，字符串不是一个合法的数值则返回 0，要求不能使用字符串转换整数的库函数。
 
 ```html
 Iuput:
@@ -2979,7 +2992,7 @@ public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
 
 [Leetcode : 236. Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
 
-在左右子树中查找是否存在 p 或者 q，如果 p 和 q 分别在两个子树中，那么就说明根节点就是 LCA。
+在左右子树中查找是否存在 p 或者 q，如果 p 和 q 分别在两个子树中，那么就说明根节点就是最低公共祖先。
 
 ```java
 public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {

From adda52204350ab9fe571da04383c931f21bfe3d4 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 14 Aug 2018 21:10:49 +0800
Subject: [PATCH 05/14] auto commit

---
 notes/Java 并发.md | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/notes/Java 并发.md b/notes/Java 并发.md
index ed60676b..9cd5955b 100644
--- a/notes/Java 并发.md	
+++ b/notes/Java 并发.md	
@@ -758,7 +758,6 @@ run..run..run..run..run..run..run..run..run..run..end
 
 用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。
 
-<<<<<<< HEAD
 和 CountdownLatch 相似，都是通过维护计数器来实现的。线程执行 await() 方法之后计数器会减 1，并进行等待，直到计数器为 0，所有调用 awati() 方法而在等待的线程才能继续执行。
 
 CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset() 方法可以循环使用，所以它才叫做循环屏障。
@@ -772,9 +771,6 @@ public CyclicBarrier(int parties, Runnable barrierAction) {
     this.count = parties;
     this.barrierCommand = barrierAction;
 }
-=======
-和 CountdownLatch 相似，都是通过维护计数器来实现的。初始化的时候计数器count与构造函数传入的参数parties相同，每次有线程调用await方法时候，计数器count不断减1，直到count减为0时等待的所有线程才会继续执行。和 CountdownLatch 的另一个区别是，CyclicBarrier 可以通过调用reset方法循环使用，所以它才叫做循环屏障。
->>>>>>> 8fffe40cb7afc5159cb5751b8906ac9cea7cc563
 
 public CyclicBarrier(int parties) {
     this(parties, null);

From f7c5303cab250ec41998b3ffbcdafa70a76d752a Mon Sep 17 00:00:00 2001
From: Rui Li <mmssddss@gmail.com>
Date: Tue, 14 Aug 2018 22:36:08 +0800
Subject: [PATCH 06/14]  fixed typo

---
 notes/MySQL.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/notes/MySQL.md b/notes/MySQL.md
index 690425db..7ac9685f 100644
--- a/notes/MySQL.md
+++ b/notes/MySQL.md
@@ -129,7 +129,7 @@ MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提
 
 ### 1. 数据结构
 
-B Tree 指的是 Balance Tree，也就是平衡树。平衡树时一颗查找树，并且所有叶子节点位于同一层。
+B Tree 指的是 Balance Tree，也就是平衡树。平衡树是一颗查找树，并且所有叶子节点位于同一层。
 
 B+ Tree 是基于 B Tree 和叶子节点顺序访问指针进行实现，它具有 B Tree 的平衡性，并且通过顺序访问指针来提高区间查询的性能。
 

From 7f1134e6725ed7c670d9fa864d52f7ba48824169 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 14 Aug 2018 23:09:22 +0800
Subject: [PATCH 07/14] auto commit

---
 notes/MySQL.md               |  2 +-
 notes/剑指 offer 题解.md | 76 ++++++++++++++++++++----------------
 2 files changed, 44 insertions(+), 34 deletions(-)

diff --git a/notes/MySQL.md b/notes/MySQL.md
index 690425db..7ac9685f 100644
--- a/notes/MySQL.md
+++ b/notes/MySQL.md
@@ -129,7 +129,7 @@ MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提
 
 ### 1. 数据结构
 
-B Tree 指的是 Balance Tree，也就是平衡树。平衡树时一颗查找树，并且所有叶子节点位于同一层。
+B Tree 指的是 Balance Tree，也就是平衡树。平衡树是一颗查找树，并且所有叶子节点位于同一层。
 
 B+ Tree 是基于 B Tree 和叶子节点顺序访问指针进行实现，它具有 B Tree 的平衡性，并且通过顺序访问指针来提高区间查询的性能。
 
diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md
index 4fcc45dc..0ac7d7e4 100644
--- a/notes/剑指 offer 题解.md	
+++ b/notes/剑指 offer 题解.md	
@@ -58,8 +58,8 @@
 * [50. 第一个只出现一次的字符位置](#50-第一个只出现一次的字符位置)
 * [51. 数组中的逆序对](#51-数组中的逆序对)
 * [52. 两个链表的第一个公共结点](#52-两个链表的第一个公共结点)
-* [53 数字在排序数组中出现的次数](#53-数字在排序数组中出现的次数)
-* [54. 二叉搜索树的第 K 个结点](#54-二叉搜索树的第-k-个结点)
+* [53. 数字在排序数组中出现的次数](#53-数字在排序数组中出现的次数)
+* [54. 二叉查找树的第 K 个结点](#54-二叉查找树的第-k-个结点)
 * [55.1 二叉树的深度](#551-二叉树的深度)
 * [55.2 平衡二叉树](#552-平衡二叉树)
 * [56. 数组中只出现一次的数字](#56-数组中只出现一次的数字)
@@ -112,11 +112,11 @@ Output:
 
 要求复杂度为 O(N) + O(1)，也就是时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。牛客网讨论区这一题的首票答案使用 nums[i] + length 来将元素标记，这么做会有加法溢出问题。
 
-这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素放到第 i 个位置上。
+这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素调整到第 i 个位置上。
 
 以 (2, 3, 1, 0, 2, 5) 为例：
 
-```text-html-basic
+```text
 position-0 : (2,3,1,0,2,5) // 2 <-> 1
              (1,3,2,0,2,5) // 1 <-> 3
              (3,1,2,0,2,5) // 3 <-> 0
@@ -146,7 +146,9 @@ public boolean duplicate(int[] nums, int length, int[] duplication) {
 }
 
 private void swap(int[] nums, int i, int j) {
-    int t = nums[i]; nums[i] = nums[j]; nums[j] = t;
+    int t = nums[i];
+    nums[i] = nums[j];
+    nums[j] = t;
 }
 ```
 
@@ -176,12 +178,12 @@ Given target = 20, return false.
 
 从右上角开始查找。矩阵中的一个数，它左边的数都比它小，下边的数都比它大。因此，从右上角开始查找，就可以根据 target 和当前元素的大小关系来缩小查找区间。
 
+复杂度：O(M + N) + O(1)
+
 当前元素的查找区间为左下角的所有元素，例如元素 12 的查找区间如下：
 
 <div align="center"> <img src="../pics//f94389e9-55b1-4f49-9d37-00ed05900ae0.png" width="250"/> </div><br>
 
-复杂度：O(M + N) + O(1)
-
 ```java
 public boolean Find(int target, int[][] matrix) {
     if (matrix == null || matrix.length == 0 || matrix[0].length == 0)
@@ -193,7 +195,7 @@ public boolean Find(int target, int[][] matrix) {
             return true;
         else if (target > matrix[r][c])
             r++;
-        else 
+        else
             c--;
     }
     return false;
@@ -206,26 +208,33 @@ public boolean Find(int target, int[][] matrix) {
 
 ## 题目描述
 
-请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为 We Are Happy. 则经过替换之后的字符串为 We%20Are%20Happy。
+
+将一个字符串中的空格替换成 "%20"。
+
+```text
+Input:
+"We Are Happy"
+
+Output:
+"We%20Are%20Happy"
+```
 
 ## 解题思路
 
-在字符串尾部填充任意字符，使得字符串的长度等于字符串替换之后的长度。因为一个空格要替换成三个字符（%20），因此当遍历到一个空格时，需要在尾部填充两个任意字符。
+在字符串尾部填充任意字符，使得字符串的长度等于替换之后的长度。因为一个空格要替换成三个字符（%20），因此当遍历到一个空格时，需要在尾部填充两个任意字符。
 
 令 P1 指向字符串原来的末尾位置，P2 指向字符串现在的末尾位置。P1 和 P2从后向前遍历，当 P1 遍历到一个空格时，就需要令 P2 指向的位置依次填充 02%（注意是逆序的），否则就填充上 P1 指向字符的值。
 
 从后向前遍是为了在改变 P2 所指向的内容时，不会影响到 P1 遍历原来字符串的内容。
 
-复杂度：O(N) + O(1)
-
 ```java
 public String replaceSpace(StringBuffer str) {
-    int oldLen = str.length();
-    for (int i = 0; i < oldLen; i++)
+    int P1 = str.length() - 1;
+    for (int i = 0; i < str.length(); i++)
         if (str.charAt(i) == ' ')
             str.append("  ");
 
-    int P1 = oldLen - 1, P2 = str.length() - 1;
+    int P2 = str.length() - 1;
     while (P1 >= 0 && P2 > P1) {
         char c = str.charAt(P1--);
         if (c == ' ') {
@@ -345,23 +354,23 @@ inorder =  [9,3,15,20,7]
 前序遍历的第一个值为根节点的值，使用这个值将中序遍历结果分成两部分，左部分为树的左子树中序遍历结果，右部分为树的右子树中序遍历的结果。
 
 ```java
-// 缓存中序遍历数组的每个值对应的索引
-private Map<Integer, Integer> inOrderNumsIndexs = new HashMap<>();
+// 缓存中序遍历数组每个值对应的索引
+private Map<Integer, Integer> indexForInOrders = 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, 0, in.length - 1);
+        indexForInOrders.put(in[i], i);
+    return reConstructBinaryTree(pre, 0, pre.length - 1, 0);
 }
 
-private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int inL, int inR) {
+private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int inL) {
     if (preL > preR)
         return null;
     TreeNode root = new TreeNode(pre[preL]);
-    int inIndex = inOrderNumsIndexs.get(root.val);
+    int inIndex = indexForInOrders.get(root.val);
     int leftTreeSize = inIndex - inL;
-    root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, inL, inL + leftTreeSize - 1);
-    root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, inL + leftTreeSize + 1, inR);
+    root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, inL);
+    root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, inL + leftTreeSize + 1);
     return root;
 }
 ```
@@ -2259,7 +2268,7 @@ public int GetUglyNumber_Solution(int N) {
 
 ## 题目描述
 
-在一个字符串 (1 <= 字符串长度 <= 10000，全部由字母组成) 中找到第一个只出现一次的字符，并返回它的位置。
+在一个字符串 中找到第一个只出现一次的字符，并返回它的位置。
 
 ## 解题思路
 
@@ -2277,7 +2286,7 @@ public int FirstNotRepeatingChar(String str) {
 }
 ```
 
-以上实现的空间复杂度还不是最优的。考虑到只需要找到只出现一次的字符，那么我们只需要统计的次数信息只有 0,1,更大，使用两个比特位就能存储这些信息。
+以上实现的空间复杂度还不是最优的。考虑到只需要找到只出现一次的字符，那么需要统计的次数信息只有 0,1,更大，使用两个比特位就能存储这些信息。
 
 ```java
 public int FirstNotRepeatingChar2(String str) {
@@ -2304,13 +2313,13 @@ public int FirstNotRepeatingChar2(String str) {
 
 ## 题目描述
 
-在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数 P。
+在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
 
 ## 解题思路
 
 ```java
 private long cnt = 0;
-private int[] tmp;  // 在这里创建辅助数组，而不是在 merge() 递归函数中创建
+private int[] tmp;  // 在这里声明辅助数组，而不是在 merge() 递归函数中声明
 
 public int InversePairs(int[] nums) {
     tmp = new int[nums.length];
@@ -2359,7 +2368,7 @@ private void merge(int[] nums, int l, int m, int h) {
 
 设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
 
-当访问 A 链表的指针访问到链表尾部时，令它从链表 B 的头部重新开始访问链表 B；同样地，当访问 B 链表的指针访问到链表尾部时，令它从链表 A 的头部重新开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
+当访问链表 A 的指针访问到链表尾部时，令它从链表 B 的头部重新开始访问链表 B；同样地，当访问链表 B 的指针访问到链表尾部时，令它从链表 A 的头部重新开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
 
 ```java
 public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
@@ -2372,7 +2381,7 @@ public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
 }
 ```
 
-# 53 数字在排序数组中出现的次数
+# 53. 数字在排序数组中出现的次数
 
 [NowCoder](https://www.nowcoder.com/practice/70610bf967994b22bb1c26f9ae901fa2?tpId=13&tqId=11190&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
@@ -2380,8 +2389,9 @@ public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
 
 ```html
 Input:
-1, 2, 3, 3, 3, 3, 4, 6
-3
+nums = 1, 2, 3, 3, 3, 3, 4, 6
+K = 3
+
 Output:
 4
 ```
@@ -2408,13 +2418,13 @@ private int binarySearch(int[] nums, int K) {
 }
 ```
 
-# 54. 二叉搜索树的第 K 个结点
+# 54. 二叉查找树的第 K 个结点
 
 [NowCoder](https://www.nowcoder.com/practice/ef068f602dde4d28aab2b210e859150a?tpId=13&tqId=11215&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
 ## 解题思路
 
-利用二叉搜索数中序遍历有序的特点。
+利用二叉查找树中序遍历有序的特点。
 
 ```java
 private TreeNode ret;

From 6c0eb1e9efcbb783e75c2322590a82c73a83d3aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E6=B0=B8=E5=B7=9D?= <1029579233@qq.com>
Date: Wed, 15 Aug 2018 13:42:58 +0800
Subject: [PATCH 08/14] Update README.md

---
 README.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 42788e54..f35ee455 100644
--- a/README.md
+++ b/README.md
@@ -179,12 +179,6 @@
 
 欢迎在 Issue 中提交对本仓库的改进建议~
 
-### Authorization
-
-虽然没有加开源协议，但是允许非商业性使用。
-
-转载使用请注明出处，谢谢！
-
 ### Typesetting
 
 笔记内容按照 [中文文案排版指北](http://mazhuang.org/wiki/chinese-copywriting-guidelines/) 进行排版，以保证内容的可读性。
@@ -201,6 +195,12 @@
 
 笔者将自己实现文档转换功能提取出来，方便大家在需要将本地 Markdown 上传到 Github，或者制作项目 README 文档时生成目录时使用：[GFM-Converter](https://github.com/CyC2018/GFM-Converter)。
 
+### License
+
+在对本作品进行演绎时，请署名并以相同方式共享。
+
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="知识共享许可协议" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a>
+
 ### Statement
 
 本仓库不参与商业行为，不向读者收取任何费用。(This repository is not engaging in business activities, and does not charge readers any fee.)

From 9e1c1c51c301c95c2cda81bfbe23289cc883281a Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 15 Aug 2018 19:39:49 +0800
Subject: [PATCH 09/14] auto commit

---
 notes/剑指 offer 题解.md | 212 ++++++++++++++++-------------------
 1 file changed, 94 insertions(+), 118 deletions(-)

diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md
index 0ac7d7e4..1bac6bbb 100644
--- a/notes/剑指 offer 题解.md	
+++ b/notes/剑指 offer 题解.md	
@@ -10,8 +10,8 @@
 * [9. 用两个栈实现队列](#9-用两个栈实现队列)
 * [10.1 斐波那契数列](#101-斐波那契数列)
 * [10.2 跳台阶](#102-跳台阶)
-* [10.3 变态跳台阶](#103-变态跳台阶)
-* [10.4 矩形覆盖](#104-矩形覆盖)
+* [10.3 矩形覆盖](#103-矩形覆盖)
+* [10.4 变态跳台阶](#104-变态跳台阶)
 * [11. 旋转数组的最小数字](#11-旋转数组的最小数字)
 * [12. 矩阵中的路径](#12-矩阵中的路径)
 * [13. 机器人的运动范围](#13-机器人的运动范围)
@@ -465,7 +465,7 @@ public int pop() throws Exception {
 
 ## 题目描述
 
-求菲波那契数列的第 n 项，n <= 39。
+求斐波那契数列的第 n 项，n <= 39。
 
 <div align="center"><img src="https://latex.codecogs.com/gif.latex?f(n)=\left\{\begin{array}{rcl}0&&{n=0}\\1&&{n=1}\\f(n-1)+f(n-2)&&{n>1}\end{array}\right."/></div> <br>
 
@@ -535,23 +535,6 @@ public class Solution {
 
 ## 解题思路
 
-复杂度：O(N) + O(N)
-
-```java
-public int JumpFloor(int n) {
-    if (n == 1)
-        return 1;
-    int[] dp = new int[n];
-    dp[0] = 1;
-    dp[1] = 2;
-    for (int i = 2; i < n; i++)
-        dp[i] = dp[i - 1] + dp[i - 2];
-    return dp[n - 1];
-}
-```
-
-复杂度：O(N) + O(1)
-
 ```java
 public int JumpFloor(int n) {
     if (n <= 2)
@@ -567,7 +550,32 @@ public int JumpFloor(int n) {
 }
 ```
 
-# 10.3 变态跳台阶
+# 10.3 矩形覆盖
+
+[NowCoder](https://www.nowcoder.com/practice/72a5a919508a4251859fb2cfb987a0e6?tpId=13&tqId=11163&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
+
+## 题目描述
+
+我们可以用 2\*1 的小矩形横着或者竖着去覆盖更大的矩形。请问用 n 个 2\*1 的小矩形无重叠地覆盖一个 2\*n 的大矩形，总共有多少种方法？
+
+## 解题思路
+
+```java
+public int RectCover(int n) {
+    if (n <= 2)
+        return n;
+    int pre2 = 1, pre1 = 2;
+    int result = 0;
+    for (int i = 3; i <= n; i++) {
+        result = pre2 + pre1;
+        pre2 = pre1;
+        pre1 = result;
+    }
+    return result;
+}
+```
+
+# 10.4 变态跳台阶
 
 [NowCoder](https://www.nowcoder.com/practice/22243d016f6b47f2a6928b4313c85387?tpId=13&tqId=11162&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
@@ -588,47 +596,6 @@ public int JumpFloorII(int target) {
 }
 ```
 
-# 10.4 矩形覆盖
-
-[NowCoder](https://www.nowcoder.com/practice/72a5a919508a4251859fb2cfb987a0e6?tpId=13&tqId=11163&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
-
-## 题目描述
-
-我们可以用 2\*1 的小矩形横着或者竖着去覆盖更大的矩形。请问用 n 个 2\*1 的小矩形无重叠地覆盖一个 2\*n 的大矩形，总共有多少种方法？
-
-## 解题思路
-
-复杂度：O(N) + O(N)
-
-```java
-public int RectCover(int n) {
-    if (n <= 2)
-        return n;
-    int[] dp = new int[n];
-    dp[0] = 1;
-    dp[1] = 2;
-    for (int i = 2; i < n; i++)
-        dp[i] = dp[i - 1] + dp[i - 2];
-    return dp[n - 1];
-}
-```
-
-复杂度：O(N) + O(1)
-
-```java
-public int RectCover(int n) {
-    if (n <= 2)
-        return n;
-    int pre2 = 1, pre1 = 2;
-    int result = 0;
-    for (int i = 3; i <= n; i++) {
-        result = pre2 + pre1;
-        pre2 = pre1;
-        pre1 = result;
-    }
-    return result;
-}
-```
 
 # 11. 旋转数组的最小数字
 
@@ -638,18 +605,34 @@ public int RectCover(int n) {
 
 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
 
-例如数组 {3, 4, 5, 1, 2} 为 {1, 2, 3, 4, 5} 的一个旋转，该数组的最小值为 1。NOTE：给出的所有元素都大于 0，若数组大小为 0，请返回 0。
+例如数组 {3, 4, 5, 1, 2} 为 {1, 2, 3, 4, 5} 的一个旋转，该数组的最小值为 1。
 
 ## 解题思路
 
+在一个有序数组中查找一个元素可以用二分查找，二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度都为 O(logN)。
+
+本题可以修改二分查找算法进行求解：
+
 - 当 nums[m] <= nums[h] 的情况下，说明解在 [l, m] 之间，此时令 h = m；
 - 否则解在 [m + 1, h] 之间，令 l = m + 1。
 
-因为 h 的赋值表达式为 h = m，因此循环体的循环条件应该为 l < h，详细解释请见 [Leetcode 题解](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3.md) 二分查找部分。
+```java
+public int minNumberInRotateArray(int[] nums) {
+    if (nums.length == 0)
+        return 0;
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] <= nums[h])
+            h = m;
+        else
+            l = m + 1;
+    }
+    return nums[l];
+}
+```
 
-但是如果出现 nums[l] == nums[m] == nums[h]，那么此时无法确定解在哪个区间，需要切换到顺序查找。
-
-复杂度：O(logN) + O(1)
+如果数组元素允许重复的话，那么就会出现一个特殊的情况：nums[l] == nums[m] == nums[h]，那么此时无法确定解在哪个区间，需要切换到顺序查找。例如对于数组 {1,1,1,0,1}，l、m 和 h 指向的数都为 1，此时无法知道最小数字 0 在哪个区间。
 
 ```java
 public int minNumberInRotateArray(int[] nums) {
@@ -737,7 +720,9 @@ private char[][] buildMatrix(char[] array) {
 
 ## 题目描述
 
-地上有一个 m 行和 n 列的方格。一个机器人从坐标 (0, 0) 的格子开始移动，每一次只能向左右上下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于 k 的格子。例如，当 k 为 18 时，机器人能够进入方格（35, 37），因为 3+5+3+7=18。但是，它不能进入方格（35, 38），因为 3+5+3+8=19。请问该机器人能够达到多少个格子？
+地上有一个 m 行和 n 列的方格。一个机器人从坐标 (0, 0) 的格子开始移动，每一次只能向左右上下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于 k 的格子。
+
+例如，当 k 为 18 时，机器人能够进入方格 (35,37)，因为 3+5+3+7=18。但是，它不能进入方格 (35,37)，因为 3+5+3+8=19。请问该机器人能够达到多少个格子？
 
 ## 解题思路
 
@@ -806,7 +791,7 @@ return 36 (10 = 3 + 3 + 4)
 
 ### 贪心
 
-尽可能多剪长度为 3 的绳子，并且不允许有长度为 1 的绳子出现，如果出现了，就从已经切好长度为 3 的绳子中拿出一段与长度为 1 的绳子重新组合，把它们切成两段长度为 2 的绳子。
+尽可能多剪长度为 3 的绳子，并且不允许有长度为 1 的绳子出现。如果出现了，就从已经切好长度为 3 的绳子中拿出一段与长度为 1 的绳子重新组合，把它们切成两段长度为 2 的绳子。
 
 证明：当 n >= 5 时，3(n - 3) - 2(n - 2) = n - 5 >= 0。因此把长度大于 5 的绳子切成两段，令其中一段长度为 3 可以使得两段的乘积最大。
 
@@ -847,19 +832,9 @@ public int integerBreak(int n) {
 
 输入一个整数，输出该数二进制表示中 1 的个数。
 
-### Integer.bitCount()
-
-```java
-public int NumberOf1(int n) {
-    return Integer.bitCount(n);
-}
-```
-
 ### n&(n-1)
 
-O(M) 时间复杂度解法，其中 M 表示 1 的个数。
-
-该位运算是去除 n 的位级表示中最低的那一位。
+该位运算去除 n 的位级表示中最低的那一位。
 
 ```
 n       : 10110100
@@ -867,6 +842,9 @@ n-1     : 10110011
 n&(n-1) : 10110000
 ```
 
+时间复杂度：O(M)，其中 M 表示 1 的个数。
+
+
 ```java
 public int NumberOf1(int n) {
     int cnt = 0;
@@ -878,13 +856,22 @@ public int NumberOf1(int n) {
 }
 ```
 
+
+### Integer.bitCount()
+
+```java
+public int NumberOf1(int n) {
+    return Integer.bitCount(n);
+}
+```
+
 # 16. 数值的整数次方
 
 [NowCoder](https://www.nowcoder.com/practice/1a834e5e3e1a4b7ba251417554e07c00?tpId=13&tqId=11165&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
 ## 题目描述
 
-给定一个 double 类型的浮点数 base 和 int 类型的整数 exponent。求 base 的 exponent 次方。
+给定一个 double 类型的浮点数 base 和 int 类型的整数 exponent，求 base 的 exponent 次方。
 
 ## 解题思路
 
@@ -892,7 +879,7 @@ public int NumberOf1(int n) {
 
 <div align="center"><img src="https://latex.codecogs.com/gif.latex?x^n=\left\{\begin{array}{rcl}(x*x)^{n/2}&&{n\%2=0}\\x*(x*x)^{n/2}&&{n\%2=1}\end{array}\right."/></div> <br>
 
-因为 (x\*x)<sup>n/2</sup> 可以通过递归求解，并且每递归一次，n 都减小一半，因此整个算法的时间复杂度为 O(logN)。
+因为 (x\*x)<sup>n/2</sup> 可以通过递归求解，并且每次递归 n 都减小一半，因此整个算法的时间复杂度为 O(logN)。
 
 ```java
 public double Power(double base, int exponent) {
@@ -1028,6 +1015,7 @@ public ListNode deleteDuplication(ListNode pHead) {
 
 ```java
 public boolean match(char[] str, char[] pattern) {
+
     int m = str.length, n = pattern.length;
     boolean[][] dp = new boolean[m + 1][n + 1];
 
@@ -1058,9 +1046,24 @@ public boolean match(char[] str, char[] pattern) {
 
 ## 题目描述
 
-请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。
+```html
+true
+
+"+100"
+"5e2"
+"-123"
+"3.1416"
+"-1E-16"
+
+false
+
+"12e"
+"1a3.14"
+"1.2.3"
+"+-5"
+"12e+4.3"
+```
 
-例如，字符串 "+100","5e2","-123","3.1416" 和 "-1E-16" 都表示数值。但是 "12e","1a3.14","1.2.3","+-5" 和 "12e+4.3" 都不是。
 
 ## 解题思路
 
@@ -1124,8 +1127,7 @@ public void reOrderArray(int[] nums) {
 <div align="center"> <img src="../pics//ea2304ce-268b-4238-9486-4d8f8aea8ca4.png" width="500"/> </div><br>
 
 ```java
-public ListNode FindKthToTail(ListNode head, int k)
-{
+public ListNode FindKthToTail(ListNode head, int k) {
     if (head == null)
         return null;
     ListNode P1 = head;
@@ -1148,9 +1150,7 @@ public ListNode FindKthToTail(ListNode head, int k)
 
 ## 题目描述
 
-一个链表中包含环，请找出该链表的环的入口结点。
-
-要求不能使用额外的空间。
+一个链表中包含环，请找出该链表的环的入口结点。要求不能使用额外的空间。
 
 ## 解题思路
 
@@ -1161,8 +1161,7 @@ public ListNode FindKthToTail(ListNode head, int k)
 <div align="center"> <img src="../pics//2858f8ad-aedb-45a5-a706-e98c96d690fa.jpg" width="600"/> </div><br>
 
 ```java
-public ListNode EntryNodeOfLoop(ListNode pHead)
-{
+public ListNode EntryNodeOfLoop(ListNode pHead) {
     if (pHead == null || pHead.next == null)
         return null;
     ListNode slow = pHead, fast = pHead;
@@ -1304,8 +1303,6 @@ private boolean isSubtreeWithRoot(TreeNode root1, TreeNode root2) {
 
 ## 解题思路
 
-### 递归
-
 ```java
 public void Mirror(TreeNode root) {
     if (root == null)
@@ -1322,29 +1319,6 @@ private void swap(TreeNode root) {
 }
 ```
 
-### 迭代
-
-```java
-public void Mirror(TreeNode root) {
-    Stack<TreeNode> stack = new Stack<>();
-    stack.push(root);
-    while (!stack.isEmpty()) {
-        TreeNode node = stack.pop();
-        if (node == null)
-            continue;
-        swap(node);
-        stack.push(node.left);
-        stack.push(node.right);
-    }
-}
-
-private void swap(TreeNode node) {
-    TreeNode t = node.left;
-    node.left = node.right;
-    node.right = t;
-}
-```
-
 # 28 对称的二叉树
 
 [NowCder](https://www.nowcoder.com/practice/ff05d44dfdb04e1d83bdbdab320efbcb?tpId=13&tqId=11211&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
@@ -1445,7 +1419,9 @@ public int min() {
 
 ## 题目描述
 
-输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。
+输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。
+
+例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。
 
 ## 解题思路
 
@@ -1838,7 +1814,7 @@ private void backtracking(char[] chars, boolean[] hasUsed, StringBuilder s) {
 
 多数投票问题，可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。
 
-使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素不相等时，令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
+使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素相等时，令 cnt++，否则令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
 
 ```java
 public int MoreThanHalfNum_Solution(int[] nums) {

From 0fb30502e019f03667dc240d110fe8b869c8b1a4 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 15 Aug 2018 21:44:50 +0800
Subject: [PATCH 10/14] auto commit

---
 notes/算法.md                               | 1073 +++++++++--------
 pics/1a2f2998-d0da-41c8-8222-1fd95083a66b.png |  Bin 0 -> 8192 bytes
 pics/2a8e1442-2381-4439-a83f-0312c8678b1f.png |  Bin 0 -> 5120 bytes
 pics/37e79a32-95a9-4503-bdb1-159527e628b8.png |  Bin 0 -> 8192 bytes
 4 files changed, 598 insertions(+), 475 deletions(-)
 create mode 100644 pics/1a2f2998-d0da-41c8-8222-1fd95083a66b.png
 create mode 100644 pics/2a8e1442-2381-4439-a83f-0312c8678b1f.png
 create mode 100644 pics/37e79a32-95a9-4503-bdb1-159527e628b8.png

diff --git a/notes/算法.md b/notes/算法.md
index cb5d4dbe..e404a3c8 100644
--- a/notes/算法.md
+++ b/notes/算法.md
@@ -2,19 +2,10 @@
 * [一、前言](#一前言)
 * [二、算法分析](#二算法分析)
     * [数学模型](#数学模型)
+    * [注意事项](#注意事项)
     * [ThreeSum](#threesum)
     * [倍率实验](#倍率实验)
-    * [注意事项](#注意事项)
-* [三、栈和队列](#三栈和队列)
-    * [栈](#栈)
-    * [队列](#队列)
-* [四、并查集](#四并查集)
-    * [quick-find](#quick-find)
-    * [quick-union](#quick-union)
-    * [加权 quick-union](#加权-quick-union)
-    * [路径压缩的加权 quick-union](#路径压缩的加权-quick-union)
-    * [各种 union-find 算法的比较](#各种-union-find-算法的比较)
-* [五、排序](#五排序)
+* [三、排序](#三排序)
     * [选择排序](#选择排序)
     * [冒泡排序](#冒泡排序)
     * [插入排序](#插入排序)
@@ -23,6 +14,15 @@
     * [快速排序](#快速排序)
     * [堆排序](#堆排序)
     * [小结](#小结)
+* [四、并查集](#四并查集)
+    * [Quick Find](#quick-find)
+    * [Quick Union](#quick-union)
+    * [加权 Quick Union](#加权-quick-union)
+    * [路径压缩的加权 Quick Union](#路径压缩的加权-quick-union)
+    * [比较](#比较)
+* [五、栈和队列](#五栈和队列)
+    * [栈](#栈)
+    * [队列](#队列)
 * [六、查找](#六查找)
     * [初级实现](#初级实现)
     * [二叉查找树](#二叉查找树)
@@ -39,7 +39,8 @@
 
 # 一、前言
 
-本文实现代码以及测试代码放在 [Algorithm](https://github.com/CyC2018/Algorithm)
+- 实现代码：[Algorithm](https://github.com/CyC2018/Algorithm)
+- 绘图文件：[ProcessOn](https://www.processon.com/view/link/5a3e4c1ee4b0ce9ffea8c727)
 
 # 二、算法分析
 
@@ -61,6 +62,28 @@ N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 的增长数量级为 O(N<sup>3</sup>)。增
 
 使用成本模型来评估算法，例如数组的访问次数就是一种成本模型。
 
+## 注意事项
+
+### 1. 大常数
+
+在求近似时，如果低级项的常数系数很大，那么近似的结果就是错误的。
+
+### 2. 缓存
+
+计算机系统会使用缓存技术来组织内存，访问数组相邻的元素会比访问不相邻的元素快很多。
+
+### 3. 对最坏情况下的性能的保证
+
+在核反应堆、心脏起搏器或者刹车控制器中的软件，最坏情况下的性能是十分重要的。
+
+### 4. 随机化算法
+
+通过打乱输入，去除算法对输入的依赖。
+
+### 5. 均摊分析
+
+将所有操作的总成本除于操作总数来将成本均摊。例如对一个空栈进行 N 次连续的 push() 调用需要访问数组的元素为 N+4+8+16+...+2N=5N-4（N 是向数组写入元素，其余的都是调整数组大小时进行复制需要的访问数组操作），均摊后每次操作访问数组的平均次数为常数。
+
 ## ThreeSum
 
 ThreeSum 用于统计一个数组中和为 0 的三元组数量。
@@ -71,6 +94,10 @@ public interface ThreeSum {
 }
 ```
 
+### 1. ThreeSumSlow
+
+该算法的内循环为 `if (nums[i] + nums[j] + nums[k] == 0)` 语句，总共执行的次数为 N(N-1)(N-2) = N<sup>3</sup>/6-N<sup>2</sup>/2+N/3，因此它的近似执行次数为 \~N<sup>3</sup>/6，增长数量级为 O(N<sup>3</sup>)。
+
 ```java
 public class ThreeSumSlow implements ThreeSum {
     @Override
@@ -87,9 +114,7 @@ public class ThreeSumSlow implements ThreeSum {
 }
 ```
 
-该算法的内循环为 `if (nums[i] + nums[j] + nums[k] == 0)` 语句，总共执行的次数为 N(N-1)(N-2) = N<sup>3</sup>/6-N<sup>2</sup>/2+N/3，因此它的近似执行次数为 \~N<sup>3</sup>/6，增长数量级为 O(N<sup>3</sup>)。
-
-<font size=4> **改进** </font></br>
+### 2. ThreeSumFast
 
 通过将数组先排序，对两个元素求和，并用二分查找方法查找是否存在该和的相反数，如果存在，就说明存在三元组的和为 0。
 
@@ -153,21 +178,31 @@ public class BinarySearch {
 
 ```java
 public class RatioTest {
+
     public static void main(String[] args) {
+
         int N = 500;
         int loopTimes = 7;
         double preTime = -1;
+
         while (loopTimes-- > 0) {
+
             int[] nums = new int[N];
+
             StopWatch.start();
+
             ThreeSum threeSum = new ThreeSumSlow();
+
             int cnt = threeSum.count(nums);
             System.out.println(cnt);
+
             double elapsedTime = StopWatch.elapsedTime();
             double ratio = preTime == -1 ? 0 : elapsedTime / preTime;
             System.out.println(N + "  " + elapsedTime + "  " + ratio);
+
             preTime = elapsedTime;
             N *= 2;
+
         }
     }
 }
@@ -175,12 +210,15 @@ public class RatioTest {
 
 ```java
 public class StopWatch {
+
     private static long start;
-    
-    public static void start(){
+
+
+    public static void start() {
         start = System.currentTimeMillis();
     }
-    
+
+
     public static double elapsedTime() {
         long now = System.currentTimeMillis();
         return (now - start) / 1000.0;
@@ -188,438 +226,7 @@ public class StopWatch {
 }
 ```
 
-## 注意事项
-
-### 1. 大常数
-
-在求近似时，如果低级项的常数系数很大，那么近似的结果就是错误的。
-
-### 2. 缓存
-
-计算机系统会使用缓存技术来组织内存，访问数组相邻的元素会比访问不相邻的元素快很多。
-
-### 3. 对最坏情况下的性能的保证
-
-在核反应堆、心脏起搏器或者刹车控制器中的软件，最坏情况下的性能是十分重要的。
-
-### 4. 随机化算法
-
-通过打乱输入，去除算法对输入的依赖。
-
-### 5. 均摊分析
-
-将所有操作的总成本除于操作总数来将成本均摊。例如对一个空栈进行 N 次连续的 push() 调用需要访问数组的元素为 N+4+8+16+...+2N=5N-4（N 是向数组写入元素，其余的都是调整数组大小时进行复制需要的访问数组操作），均摊后每次操作访问数组的平均次数为常数。
-
-# 三、栈和队列
-
-## 栈
-
-First-In-Last-Out
-
-```java
-public interface MyStack<Item> extends Iterable<Item> {
-    MyStack<Item> push(Item item);
-
-    Item pop() throws Exception;
-
-    boolean isEmpty();
-
-    int size();
-}
-```
-
-### 1. 数组实现
-
-```java
-public class ArrayStack<Item> implements MyStack<Item> {
-    // 栈元素数组，只能通过转型来创建泛型数组
-    private Item[] a = (Item[]) new Object[1];
-    // 元素数量
-    private int N = 0;
-
-    @Override
-    public MyStack<Item> push(Item item) {
-        check();
-        a[N++] = item;
-        return this;
-    }
-
-    @Override
-    public Item pop() throws Exception {
-        if (isEmpty())
-            throw new Exception("stack is empty");
-
-        Item item = a[--N];
-        check();
-        a[N] = null; // 避免对象游离
-        return item;
-    }
-
-    private void check() {
-        if (N >= a.length)
-            resize(2 * a.length);
-        else if (N > 0 && N <= a.length / 4)
-            resize(a.length / 2);
-    }
-
-    /**
-     * 调整数组大小，使得栈具有伸缩性
-     */
-    private void resize(int size) {
-        Item[] tmp = (Item[]) new Object[size];
-        for (int i = 0; i < N; i++)
-            tmp[i] = a[i];
-        a = tmp;
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return N == 0;
-    }
-
-    @Override
-    public int size() {
-        return N;
-    }
-
-    @Override
-    public Iterator<Item> iterator() {
-        // 返回逆序遍历的迭代器
-        return new Iterator<Item>() {
-            private int i = N;
-
-            @Override
-            public boolean hasNext() {
-                return i > 0;
-            }
-
-            @Override
-            public Item next() {
-                return a[--i];
-            }
-        };
-    }
-}
-```
-
-### 2. 链表实现
-
-需要使用链表的头插法来实现，因为头插法中最后压入栈的元素在链表的开头，它的 next 指针指向前一个压入栈的元素，在弹出元素时就可以通过 next 指针遍历到前一个压入栈的元素从而让这个元素称为新的栈顶元素。
-
-```java
-public class ListStack<Item> implements MyStack<Item> {
-    private Node top = null;
-    private int N = 0;
-
-    private class Node {
-        Item item;
-        Node next;
-    }
-
-    @Override
-    public MyStack<Item> push(Item item) {
-        Node newTop = new Node();
-        newTop.item = item;
-        newTop.next = top;
-        top = newTop;
-        N++;
-        return this;
-    }
-
-    @Override
-    public Item pop() throws Exception {
-        if (isEmpty())
-            throw new Exception("stack is empty");
-        Item item = top.item;
-        top = top.next;
-        N--;
-        return item;
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return N == 0;
-    }
-
-    @Override
-    public int size() {
-        return N;
-    }
-
-    @Override
-    public Iterator<Item> iterator() {
-        return new Iterator<Item>() {
-            private Node cur = top;
-
-            @Override
-            public boolean hasNext() {
-                return cur != null;
-            }
-
-            @Override
-            public Item next() {
-                Item item = cur.item;
-                cur = cur.next;
-                return item;
-            }
-        };
-    }
-}
-```
-
-## 队列
-
-First-In-First-Out
-
-下面是队列的链表实现，需要维护 first 和 last 节点指针，分别指向队首和队尾。
-
-这里需要考虑 first 和 last 指针哪个作为链表的开头。因为出队列操作需要让队首元素的下一个元素成为队首，所以需要容易获取下一个元素，而链表的头部节点的 next 指针指向下一个元素，因此可以让 first 指针链表的开头。
-
-```java
-public interface MyQueue<Item> extends Iterable<Item> {
-    int size();
-
-    boolean isEmpty();
-
-    MyQueue<Item> add(Item item);
-
-    Item remove() throws Exception;
-}
-```
-
-```java
-public class ListQueue<Item> implements MyQueue<Item> {
-    private Node first;
-    private Node last;
-    int N = 0;
-
-    private class Node {
-        Item item;
-        Node next;
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return N == 0;
-    }
-
-    @Override
-    public int size() {
-        return N;
-    }
-
-    @Override
-    public MyQueue<Item> add(Item item) {
-        Node newNode = new Node();
-        newNode.item = item;
-        newNode.next = null;
-        if (isEmpty()) {
-            last = newNode;
-            first = newNode;
-        } else {
-            last.next = newNode;
-            last = newNode;
-        }
-        N++;
-        return this;
-    }
-
-    @Override
-    public Item remove() throws Exception {
-        if (isEmpty())
-            throw new Exception("queue is empty");
-        Node node = first;
-        first = first.next;
-        N--;
-        if (isEmpty())
-            last = null;
-        return node.item;
-    }
-
-    @Override
-    public Iterator<Item> iterator() {
-        return new Iterator<Item>() {
-            Node cur = first;
-
-            @Override
-            public boolean hasNext() {
-                return cur != null;
-            }
-
-            @Override
-            public Item next() {
-                Item item = cur.item;
-                cur = cur.next;
-                return item;
-            }
-        };
-    }
-}
-```
-
-# 四、并查集
-
-用于解决动态连通性问题，能动态连接两个点，并且判断两个点是否连通。
-
-<div align="center"> <img src="../pics//9d0a637c-6a8f-4f5a-99b9-fdcfa26793ff.png" width="400"/> </div><br>
-
-| 方法 | 描述 |
-| :---: | :---: |
-| UF(int N) | 构造一个大小为 N 的并查集 |
-| void union(int p, int q) | 连接 p 和 q 节点 |
-| int find(int p) | 查找 p 所在的连通分量 |
-| boolean connected(int p, int q) | 判断 p 和 q 节点是否连通 |
-
-```java
-public abstract class UF {
-    protected int[] id;
-
-    public UF(int N) {
-        id = new int[N];
-        for (int i = 0; i < N; i++)
-            id[i] = i;
-    }
-
-    public boolean connected(int p, int q) {
-        return find(p) == find(q);
-    }
-
-    public abstract int find(int p);
-
-    public abstract void union(int p, int q);
-}
-```
-
-## quick-find
-
-可以快速进行 find 操作，即可以快速判断两个节点是否连通。
-
-同一连通分量的所有节点的 id 值相等。
-
-但是 union 操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。
-
-<div align="center"> <img src="../pics//8f0cc500-5994-4c7a-91a9-62885d658662.png" width="350"/> </div><br>
-
-```java
-public class QuickFindUF extends UF {
-    public QuickFindUF(int N) {
-        super(N);
-    }
-
-    @Override
-    public int find(int p) {
-        return id[p];
-    }
-
-    @Override
-    public void union(int p, int q) {
-        int pID = find(p);
-        int qID = find(q);
-
-        if (pID == qID)
-            return;
-
-        for (int i = 0; i < id.length; i++)
-            if (id[i] == pID)
-                id[i] = qID;
-    }
-}
-
-```
-
-## quick-union
-
-可以快速进行 union 操作，只需要修改一个节点的 id 值即可。
-
-但是 find 操作开销很大，因为同一个连通分量的节点 id 值不同，id 值只是用来指向另一个节点。因此需要一直向上查找操作，直到找到最上层的节点。
-
-<div align="center"> <img src="../pics//5d4a5181-65fb-4bf2-a9c6-899cab534b44.png" width="350"/> </div><br>
-
-```java
-public class QuickUnionUF extends UF {
-    public QuickUnionUF(int N) {
-        super(N);
-    }
-
-    @Override
-    public int find(int p) {
-        while (p != id[p])
-            p = id[p];
-        return p;
-    }
-
-    @Override
-    public void union(int p, int q) {
-        int pRoot = find(p);
-        int qRoot = find(q);
-        if (pRoot != qRoot)
-            id[pRoot] = qRoot;
-    }
-}
-```
-
-这种方法可以快速进行 union 操作，但是 find 操作和树高成正比，最坏的情况下树的高度为触点的数目。
-
-<div align="center"> <img src="../pics//bfbb11e2-d208-4efa-b97b-24cd40467cd8.png" width="150"/> </div><br>
-
-## 加权 quick-union
-
-为了解决 quick-union 的树通常会很高的问题，加权 quick-union 在 union 操作时会让较小的树连接较大的树上面。
-
-理论研究证明，加权 quick-union 算法构造的树深度最多不超过 logN。
-
-<div align="center"> <img src="../pics//a4c17d43-fa5e-4935-b74e-147e7f7e782c.png" width="200"/> </div><br>
-
-```java
-public class WeightedQuickUnionUF extends UF {
-
-    // 保存节点的数量信息
-    private int[] sz;
-
-    public WeightedQuickUnionUF(int N) {
-        super(N);
-        this.sz = new int[N];
-        for (int i = 0; i < N; i++)
-            this.sz[i] = 1;
-    }
-
-    @Override
-    public int find(int p) {
-        while (p != id[p])
-            p = id[p];
-        return p;
-    }
-
-    @Override
-    public void union(int p, int q) {
-        int i = find(p);
-        int j = find(q);
-        if (i == j) return;
-        if (sz[i] < sz[j]) {
-            id[i] = j;
-            sz[j] += sz[i];
-        } else {
-            id[j] = i;
-            sz[i] += sz[j];
-        }
-    }
-}
-```
-
-## 路径压缩的加权 quick-union
-
-在检查节点的同时将它们直接链接到根节点，只需要在 find 中添加一个循环即可。
-
-## 各种 union-find 算法的比较
-
-| 算法 | union | find |
-| :---: | :---: | :---: |
-| quick-find | N | 1 |
-| quick-union | 树高 | 树高 |
-| 加权 quick-union | logN | logN |
-| 路径压缩的加权 quick-union | 非常接近 1 | 非常接近 1 |
-
-# 五、排序
+# 三、排序
 
 待排序的元素需要实现 Java 的 Comparable 接口，该接口有 compareTo() 方法，可以用它来判断两个元素的大小关系。
 
@@ -648,41 +255,49 @@ public abstract class Sort<T extends Comparable<T>> {
 
 选择出数组中的最小元素，将它与数组的第一个元素交换位置。再从剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。
 
-<div align="center"> <img src="../pics//ed7b96ac-6428-4bd5-9986-674c54c2a959.png" width="250"/> </div><br>
+选择排序需要 \~N<sup>2</sup>/2 次比较和 \~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。
+
+<div align="center"> <img src="../pics//37e79a32-95a9-4503-bdb1-159527e628b8.png" width="250"/> </div><br>
 
 ```java
 public class Selection<T extends Comparable<T>> extends Sort<T> {
+
     @Override
     public void sort(T[] nums) {
         int N = nums.length;
         for (int i = 0; i < N; i++) {
             int min = i;
-            for (int j = i + 1; j < N; j++)
-                if (less(nums[j], nums[min]))
+            for (int j = i + 1; j < N; j++) {
+                if (less(nums[j], nums[min])) {
                     min = j;
+                }
+            }
             swap(nums, i, min);
         }
     }
 }
 ```
 
-选择排序需要 \~N<sup>2</sup>/2 次比较和 \~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。
-
 ## 冒泡排序
 
-通过从左到右不断交换相邻逆序的相邻元素，在一轮的交换之后，可以让未排序的元素上浮到右侧。
+从左到右不断交换相邻逆序的元素，在一轮的循环之后，可以让未排序的最大元素上浮到右侧。
 
 在一轮循环中，如果没有发生交换，就说明数组已经是有序的，此时可以直接退出。
 
+以下演示了在一轮循环中，将最大的元素 5 上浮到最右侧。
+
+<div align="center"> <img src="../pics//1a2f2998-d0da-41c8-8222-1fd95083a66b.png" width="250"/> </div><br>
+
 ```java
 public class Bubble<T extends Comparable<T>> extends Sort<T> {
+
     @Override
     public void sort(T[] nums) {
         int N = nums.length;
         boolean hasSorted = false;
-        for (int i = 0; i < N && !hasSorted; i++) {
+        for (int i = N - 1; i > 0 && !hasSorted; i--) {
             hasSorted = true;
-            for (int j = 0; j < N - i - 1; j++) {
+            for (int j = 0; j < i; j++) {
                 if (less(nums[j + 1], nums[j])) {
                     hasSorted = false;
                     swap(nums, j, j + 1);
@@ -695,23 +310,7 @@ public class Bubble<T extends Comparable<T>> extends Sort<T> {
 
 ## 插入排序
 
-插入排序从左到右进行，每次都将当前元素插入到左侧已经排序的数组中，使得插入之后左部数组依然有序。
-
-第 j 元素是通过不断向左比较并交换来实现插入过程：当第 j 元素小于第 j - 1 元素，就将它们的位置交换，然后令 j 指针向左移动一个位置，不断进行以上操作。
-
-<div align="center"> <img src="../pics//c9a1de44-b1c0-4d13-a654-827d4ef8a723.png" width="250"/> </div><br>
-
-```java
-public class Insertion<T extends Comparable<T>> extends Sort<T> {
-    @Override
-    public void sort(T[] nums) {
-        int N = nums.length;
-        for (int i = 1; i < N; i++)
-            for (int j = i; j > 0 && less(nums[j], nums[j - 1]); j--)
-                swap(nums, j, j - 1);
-    }
-}
-```
+每次都将当前元素插入到左侧已经排序的数组中，使得插入之后左侧数组依然有序。
 
 对于数组 {3, 5, 2, 4, 1}，它具有以下逆序：(3, 2), (3, 1), (5, 2), (5, 4), (5, 1), (2, 1), (4, 1)，插入排序每次只能交换相邻元素，令逆序数量减少 1，因此插入排序需要交换的次数为逆序数量。
 
@@ -721,6 +320,25 @@ public class Insertion<T extends Comparable<T>> extends Sort<T> {
 - 最坏的情况下需要 \~N<sup>2</sup>/2 比较以及 \~N<sup>2</sup>/2 次交换，最坏的情况是数组是倒序的；
 - 最好的情况下需要 N-1 次比较和 0 次交换，最好的情况就是数组已经有序了。
 
+以下演示了在一轮循环中，将元素 2 插入到左侧已经排序的数组中。
+
+<div align="center"> <img src="../pics//2a8e1442-2381-4439-a83f-0312c8678b1f.png" width="250"/> </div><br>
+
+```java
+public class Insertion<T extends Comparable<T>> extends Sort<T> {
+
+    @Override
+    public void sort(T[] nums) {
+        int N = nums.length;
+        for (int i = 1; i < N; i++) {
+            for (int j = i; j > 0 && less(nums[j], nums[j - 1]); j--) {
+                swap(nums, j, j - 1);
+            }
+        }
+    }
+}
+```
+
 ## 希尔排序
 
 对于大规模的数组，插入排序很慢，因为它只能交换相邻的元素，每次只能将逆序数量减少 1。
@@ -1137,6 +755,511 @@ public class HeapSort<T extends Comparable<T>> extends Sort<T> {
 
 Java 主要排序方法为 java.util.Arrays.sort()，对于原始数据类型使用三向切分的快速排序，对于引用类型使用归并排序。
 
+# 四、并查集
+
+用于解决动态连通性问题，能动态连接两个点，并且判断两个点是否连通。
+
+<div align="center"> <img src="../pics//9d0a637c-6a8f-4f5a-99b9-fdcfa26793ff.png" width="400"/> </div><br>
+
+| 方法 | 描述 |
+| :---: | :---: |
+| UF(int N) | 构造一个大小为 N 的并查集 |
+| void union(int p, int q) | 连接 p 和 q 节点 |
+| int find(int p) | 查找 p 所在的连通分量 |
+| boolean connected(int p, int q) | 判断 p 和 q 节点是否连通 |
+
+```java
+public abstract class UF {
+
+    protected int[] id;
+
+    public UF(int N) {
+        id = new int[N];
+        for (int i = 0; i < N; i++) {
+            id[i] = i;
+        }
+    }
+
+    public boolean connected(int p, int q) {
+        return find(p) == find(q);
+    }
+
+    public abstract int find(int p);
+
+    public abstract void union(int p, int q);
+}
+```
+
+## Quick Find
+
+可以快速进行 find 操作，即可以快速判断两个节点是否连通。
+
+需要保证同一连通分量的所有节点的 id 值相等。
+
+但是 union 操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。
+
+<div align="center"> <img src="../pics//8f0cc500-5994-4c7a-91a9-62885d658662.png" width="350"/> </div><br>
+
+```java
+public class QuickFindUF extends UF {
+
+    public QuickFindUF(int N) {
+        super(N);
+    }
+
+
+    @Override
+    public int find(int p) {
+        return id[p];
+    }
+
+
+    @Override
+    public void union(int p, int q) {
+
+        int pID = find(p);
+        int qID = find(q);
+
+        if (pID == qID) {
+            return;
+        }
+
+        for (int i = 0; i < id.length; i++) {
+            if (id[i] == pID) {
+                id[i] = qID;
+            }
+        }
+    }
+}
+```
+
+## Quick Union
+
+可以快速进行 union 操作，只需要修改一个节点的 id 值即可。
+
+但是 find 操作开销很大，因为同一个连通分量的节点 id 值不同，id 值只是用来指向另一个节点。因此需要一直向上查找操作，直到找到最上层的节点。
+
+<div align="center"> <img src="../pics//5d4a5181-65fb-4bf2-a9c6-899cab534b44.png" width="350"/> </div><br>
+
+```java
+public class QuickUnionUF extends UF {
+
+    public QuickUnionUF(int N) {
+        super(N);
+    }
+
+
+    @Override
+    public int find(int p) {
+
+        while (p != id[p]) {
+            p = id[p];
+        }
+        return p;
+    }
+
+
+    @Override
+    public void union(int p, int q) {
+
+        int pRoot = find(p);
+        int qRoot = find(q);
+
+        if (pRoot != qRoot) {
+            id[pRoot] = qRoot;
+        }
+    }
+}
+```
+
+这种方法可以快速进行 union 操作，但是 find 操作和树高成正比，最坏的情况下树的高度为触点的数目。
+
+<div align="center"> <img src="../pics//bfbb11e2-d208-4efa-b97b-24cd40467cd8.png" width="150"/> </div><br>
+
+## 加权 Quick Union
+
+为了解决 quick-union 的树通常会很高的问题，加权 quick-union 在 union 操作时会让较小的树连接较大的树上面。
+
+理论研究证明，加权 quick-union 算法构造的树深度最多不超过 logN。
+
+<div align="center"> <img src="../pics//a4c17d43-fa5e-4935-b74e-147e7f7e782c.png" width="200"/> </div><br>
+
+```java
+public class WeightedQuickUnionUF extends UF {
+
+    // 保存节点的数量信息
+    private int[] sz;
+
+
+    public WeightedQuickUnionUF(int N) {
+        super(N);
+        this.sz = new int[N];
+        for (int i = 0; i < N; i++) {
+            this.sz[i] = 1;
+        }
+    }
+
+
+    @Override
+    public int find(int p) {
+        while (p != id[p]) {
+            p = id[p];
+        }
+        return p;
+    }
+
+
+    @Override
+    public void union(int p, int q) {
+
+        int i = find(p);
+        int j = find(q);
+
+        if (i == j) return;
+
+        if (sz[i] < sz[j]) {
+            id[i] = j;
+            sz[j] += sz[i];
+        } else {
+            id[j] = i;
+            sz[i] += sz[j];
+        }
+    }
+}
+```
+
+## 路径压缩的加权 Quick Union
+
+在检查节点的同时将它们直接链接到根节点，只需要在 find 中添加一个循环即可。
+
+## 比较
+
+| 算法 | union | find |
+| :---: | :---: | :---: |
+| Quick Find | N | 1 |
+| Quick Union | 树高 | 树高 |
+| 加权 Quick Union | logN | logN |
+| 路径压缩的加权 Quick Union | 非常接近 1 | 非常接近 1 |
+
+# 五、栈和队列
+
+## 栈
+
+```java
+public interface MyStack<Item> extends Iterable<Item> {
+
+    MyStack<Item> push(Item item);
+
+    Item pop() throws Exception;
+
+    boolean isEmpty();
+
+    int size();
+
+}
+```
+
+### 1. 数组实现
+
+```java
+public class ArrayStack<Item> implements MyStack<Item> {
+
+    // 栈元素数组，只能通过转型来创建泛型数组
+    private Item[] a = (Item[]) new Object[1];
+
+    // 元素数量
+    private int N = 0;
+
+
+    @Override
+    public MyStack<Item> push(Item item) {
+        check();
+        a[N++] = item;
+        return this;
+    }
+
+
+    @Override
+    public Item pop() throws Exception {
+
+        if (isEmpty()) {
+            throw new Exception("stack is empty");
+        }
+
+        Item item = a[--N];
+
+        check();
+
+        // 避免对象游离
+        a[N] = null;
+
+        return item;
+    }
+
+
+    private void check() {
+
+        if (N >= a.length) {
+            resize(2 * a.length);
+
+        } else if (N > 0 && N <= a.length / 4) {
+            resize(a.length / 2);
+        }
+    }
+
+
+    /**
+     * 调整数组大小，使得栈具有伸缩性
+     */
+    private void resize(int size) {
+
+        Item[] tmp = (Item[]) new Object[size];
+
+        for (int i = 0; i < N; i++) {
+            tmp[i] = a[i];
+        }
+
+        a = tmp;
+    }
+
+
+    @Override
+    public boolean isEmpty() {
+        return N == 0;
+    }
+
+
+    @Override
+    public int size() {
+        return N;
+    }
+
+
+    @Override
+    public Iterator<Item> iterator() {
+
+        // 返回逆序遍历的迭代器
+        return new Iterator<Item>() {
+
+            private int i = N;
+
+            @Override
+            public boolean hasNext() {
+                return i > 0;
+            }
+
+            @Override
+            public Item next() {
+                return a[--i];
+            }
+        };
+
+    }
+}
+```
+
+### 2. 链表实现
+
+需要使用链表的头插法来实现，因为头插法中最后压入栈的元素在链表的开头，它的 next 指针指向前一个压入栈的元素，在弹出元素时就可以通过 next 指针遍历到前一个压入栈的元素从而让这个元素称为新的栈顶元素。
+
+```java
+public class ListStack<Item> implements MyStack<Item> {
+
+    private Node top = null;
+    private int N = 0;
+
+
+    private class Node {
+        Item item;
+        Node next;
+    }
+
+
+    @Override
+    public MyStack<Item> push(Item item) {
+
+        Node newTop = new Node();
+
+        newTop.item = item;
+        newTop.next = top;
+
+        top = newTop;
+
+        N++;
+
+        return this;
+    }
+
+
+    @Override
+    public Item pop() throws Exception {
+
+        if (isEmpty()) {
+            throw new Exception("stack is empty");
+        }
+
+        Item item = top.item;
+
+        top = top.next;
+        N--;
+
+        return item;
+    }
+
+
+    @Override
+    public boolean isEmpty() {
+        return N == 0;
+    }
+
+
+    @Override
+    public int size() {
+        return N;
+    }
+
+
+    @Override
+    public Iterator<Item> iterator() {
+
+        return new Iterator<Item>() {
+
+            private Node cur = top;
+
+
+            @Override
+            public boolean hasNext() {
+                return cur != null;
+            }
+
+
+            @Override
+            public Item next() {
+                Item item = cur.item;
+                cur = cur.next;
+                return item;
+            }
+        };
+
+    }
+}
+```
+
+## 队列
+
+First-In-First-Out
+
+下面是队列的链表实现，需要维护 first 和 last 节点指针，分别指向队首和队尾。
+
+这里需要考虑 first 和 last 指针哪个作为链表的开头。因为出队列操作需要让队首元素的下一个元素成为队首，所以需要容易获取下一个元素，而链表的头部节点的 next 指针指向下一个元素，因此可以让 first 指针链表的开头。
+
+```java
+public interface MyQueue<Item> extends Iterable<Item> {
+
+    int size();
+
+    boolean isEmpty();
+
+    MyQueue<Item> add(Item item);
+
+    Item remove() throws Exception;
+}
+```
+
+```java
+public class ListQueue<Item> implements MyQueue<Item> {
+
+    private Node first;
+    private Node last;
+    int N = 0;
+
+
+    private class Node {
+        Item item;
+        Node next;
+    }
+
+
+    @Override
+    public boolean isEmpty() {
+        return N == 0;
+    }
+
+
+    @Override
+    public int size() {
+        return N;
+    }
+
+
+    @Override
+    public MyQueue<Item> add(Item item) {
+
+        Node newNode = new Node();
+        newNode.item = item;
+        newNode.next = null;
+
+        if (isEmpty()) {
+            last = newNode;
+            first = newNode;
+        } else {
+            last.next = newNode;
+            last = newNode;
+        }
+
+        N++;
+        return this;
+    }
+
+
+    @Override
+    public Item remove() throws Exception {
+
+        if (isEmpty()) {
+            throw new Exception("queue is empty");
+        }
+
+        Node node = first;
+        first = first.next;
+        N--;
+
+        if (isEmpty()) {
+            last = null;
+        }
+
+        return node.item;
+    }
+
+
+    @Override
+    public Iterator<Item> iterator() {
+
+        return new Iterator<Item>() {
+
+            Node cur = first;
+
+
+            @Override
+            public boolean hasNext() {
+                return cur != null;
+            }
+
+
+            @Override
+            public Item next() {
+                Item item = cur.item;
+                cur = cur.next;
+                return item;
+            }
+        };
+    }
+}
+```
+
+
+
+
+
 # 六、查找
 
 符号表（Symbol Table）是一种存储键值对的数据结构，可以支持快速查找操作。
diff --git a/pics/1a2f2998-d0da-41c8-8222-1fd95083a66b.png b/pics/1a2f2998-d0da-41c8-8222-1fd95083a66b.png
new file mode 100644
index 0000000000000000000000000000000000000000..c459230500a25dbeaa7389a7cc4b92f985833f45
GIT binary patch
literal 8192
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
A^#A|>

literal 0
HcmV?d00001

diff --git a/pics/2a8e1442-2381-4439-a83f-0312c8678b1f.png b/pics/2a8e1442-2381-4439-a83f-0312c8678b1f.png
new file mode 100644
index 0000000000000000000000000000000000000000..a97e49a6b73574b2e583e3bde10f56bec9afda1f
GIT binary patch
literal 5120
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
R2ZAH8+@Pap{~PQ7e*xc4lfeK0

literal 0
HcmV?d00001

diff --git a/pics/37e79a32-95a9-4503-bdb1-159527e628b8.png b/pics/37e79a32-95a9-4503-bdb1-159527e628b8.png
new file mode 100644
index 0000000000000000000000000000000000000000..3b05b25b963303548a15d6917283fccdf667e32d
GIT binary patch
literal 8192
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

literal 0
HcmV?d00001


From 6478389db1ccb3cbab94c5478d3955ad6e4e7898 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 15 Aug 2018 22:16:30 +0800
Subject: [PATCH 11/14] auto commit

---
 notes/算法.md                               |  92 ++++++++++++------
 pics/0157d362-98dd-4e51-ac26-00ecb76beb3e.png | Bin 0 -> 14336 bytes
 pics/220790c6-4377-4a2e-8686-58398afc8a18.png | Bin 0 -> 6144 bytes
 pics/864bfa7d-1149-420c-a752-f9b3d4e782ec.png | Bin 0 -> 16384 bytes
 pics/f8047846-efd4-42be-b6b7-27a7c4998b51.png | Bin 0 -> 12288 bytes
 5 files changed, 61 insertions(+), 31 deletions(-)
 create mode 100644 pics/0157d362-98dd-4e51-ac26-00ecb76beb3e.png
 create mode 100644 pics/220790c6-4377-4a2e-8686-58398afc8a18.png
 create mode 100644 pics/864bfa7d-1149-420c-a752-f9b3d4e782ec.png
 create mode 100644 pics/f8047846-efd4-42be-b6b7-27a7c4998b51.png

diff --git a/notes/算法.md b/notes/算法.md
index e404a3c8..f0e889db 100644
--- a/notes/算法.md
+++ b/notes/算法.md
@@ -347,25 +347,32 @@ public class Insertion<T extends Comparable<T>> extends Sort<T> {
 
 希尔排序使用插入排序对间隔 h 的序列进行排序。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。
 
-<div align="center"> <img src="../pics//cdbe1d12-5ad9-4acb-a717-bbc822c2acf3.png" width="500"/> </div><br>
+<div align="center"> <img src="../pics//0157d362-98dd-4e51-ac26-00ecb76beb3e.png" width="500"/> </div><br>
 
 ```java
 public class Shell<T extends Comparable<T>> extends Sort<T> {
+
     @Override
     public void sort(T[] nums) {
+
         int N = nums.length;
         int h = 1;
-        while (h < N / 3)
-            h = 3 * h + 1;  // 1, 4, 13, 40, ...
+
+        while (h < N / 3) {
+            h = 3 * h + 1; // 1, 4, 13, 40, ...
+        }
 
         while (h >= 1) {
-            for (int i = h; i < N; i++)
-                for (int j = i; j >= h && less(nums[j], nums[j - h]); j -= h)
+            for (int i = h; i < N; i++) {
+                for (int j = i; j >= h && less(nums[j], nums[j - h]); j -= h) {
                     swap(nums, j, j - h);
+                }
+            }
             h = h / 3;
         }
     }
 }
+
 ```
 
 希尔排序的运行时间达不到平方级别，使用递增序列 1, 4, 13, 40, ...  的希尔排序所需要的比较次数不会超过 N 的若干倍乘于递增序列的长度。后面介绍的高级排序算法只会比希尔排序快两倍左右。
@@ -374,7 +381,7 @@ public class Shell<T extends Comparable<T>> extends Sort<T> {
 
 归并排序的思想是将数组分成两部分，分别进行排序，然后归并起来。
 
-<div align="center"> <img src="../pics//8dfb4cc9-26da-45e7-b820-4576fa1cbb0e.png" width="350"/> </div><br>
+<div align="center"> <img src="../pics//220790c6-4377-4a2e-8686-58398afc8a18.png" width="350"/> </div><br>
 
 ### 1. 归并方法
 
@@ -385,21 +392,28 @@ public abstract class MergeSort<T extends Comparable<T>> extends Sort<T> {
 
     protected T[] aux;
 
+
     protected void merge(T[] nums, int l, int m, int h) {
+
         int i = l, j = m + 1;
 
-        for (int k = l; k <= h; k++)
-            aux[k] = nums[k];        // 将数据复制到辅助数组
+        for (int k = l; k <= h; k++) {
+            aux[k] = nums[k]; // 将数据复制到辅助数组
+        }
 
         for (int k = l; k <= h; k++) {
-            if (i > m)
+            if (i > m) {
                 nums[k] = aux[j++];
-            else if (j > h)
+
+            } else if (j > h) {
                 nums[k] = aux[i++];
-            else if (aux[i].compareTo(nums[j]) <= 0)
-                nums[k] = aux[i++];  // 先进行这一步，保证稳定性
-            else
+
+            } else if (aux[i].compareTo(nums[j]) <= 0) {
+                nums[k] = aux[i++]; // 先进行这一步，保证稳定性
+
+            } else {
                 nums[k] = aux[j++];
+            }
         }
     }
 }
@@ -407,10 +421,13 @@ public abstract class MergeSort<T extends Comparable<T>> extends Sort<T> {
 
 ### 2. 自顶向下归并排序
 
-<div align="center"> <img src="../pics//0c55e11c-d3ce-4cd8-b139-028aea6f40e3.png" width="450"/> </div><br>
+将一个大数组分成两个小数组去求解。
+
+因为每次都将问题对半分成两个子问题，而这种对半分的算法复杂度一般为 O(NlogN)，因此该归并排序方法的时间复杂度也为 O(NlogN)。
 
 ```java
 public class Up2DownMergeSort<T extends Comparable<T>> extends MergeSort<T> {
+
     @Override
     public void sort(T[] nums) {
         aux = (T[]) new Comparable[nums.length];
@@ -418,8 +435,9 @@ public class Up2DownMergeSort<T extends Comparable<T>> extends MergeSort<T> {
     }
 
     private void sort(T[] nums, int l, int h) {
-        if (h <= l)
+        if (h <= l) {
             return;
+        }
         int mid = l + (h - l) / 2;
         sort(nums, l, mid);
         sort(nums, mid + 1, h);
@@ -428,23 +446,27 @@ public class Up2DownMergeSort<T extends Comparable<T>> extends MergeSort<T> {
 }
 ```
 
-因为每次都将问题对半分成两个子问题，而这种对半分的算法复杂度一般为 O(NlogN)，因此该归并排序方法的时间复杂度也为 O(NlogN)。
-
 ### 3. 自底向上归并排序
 
 先归并那些微型数组，然后成对归并得到的微型数组。
 
 ```java
 public class Down2UpMergeSort<T extends Comparable<T>> extends MergeSort<T> {
+
     @Override
     public void sort(T[] nums) {
+
         int N = nums.length;
         aux = (T[]) new Comparable[N];
-        for (int sz = 1; sz < N; sz += sz)
-            for (int lo = 0; lo < N - sz; lo += sz + sz)
+
+        for (int sz = 1; sz < N; sz += sz) {
+            for (int lo = 0; lo < N - sz; lo += sz + sz) {
                 merge(nums, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N - 1));
+            }
+        }
     }
 }
+
 ```
 
 ## 快速排序
@@ -454,10 +476,11 @@ public class Down2UpMergeSort<T extends Comparable<T>> extends MergeSort<T> {
 - 归并排序将数组分为两个子数组分别排序，并将有序的子数组归并使得整个数组排序；
 - 快速排序通过一个切分元素将数组分为两个子数组，左子数组小于等于切分元素，右子数组大于等于切分元素，将这两个子数组排序也就将整个数组排序了。
 
-<div align="center"> <img src="../pics//ab77240d-7338-4547-9183-00215e7220ec.png" width="500"/> </div><br>
+<div align="center"> <img src="../pics//f8047846-efd4-42be-b6b7-27a7c4998b51.png" width="500"/> </div><br>
 
 ```java
 public class QuickSort<T extends Comparable<T>> extends Sort<T> {
+
     @Override
     public void sort(T[] nums) {
         shuffle(nums);
@@ -482,9 +505,9 @@ public class QuickSort<T extends Comparable<T>> extends Sort<T> {
 
 ### 2. 切分
 
-取 a[lo] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于等于它的元素，交换这两个元素，并不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[lo] 和 a[j] 交换位置。
+取 a[l] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于等于它的元素，交换这两个元素。不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[l] 和 a[j] 交换位置。
 
-<div align="center"> <img src="../pics//5aac64d3-2c7b-4f32-9e9a-1df2186f588b.png" width="300"/> </div><br>
+<div align="center"> <img src="../pics//864bfa7d-1149-420c-a752-f9b3d4e782ec.png" width="400"/> </div><br>
 
 ```java
 private int partition(T[] nums, int l, int h) {
@@ -528,20 +551,23 @@ private int partition(T[] nums, int l, int h) {
 
 ```java
 public class ThreeWayQuickSort<T extends Comparable<T>> extends QuickSort<T> {
+
     @Override
     protected void sort(T[] nums, int l, int h) {
-        if (h <= l)
+        if (h <= l) {
             return;
+        }
         int lt = l, i = l + 1, gt = h;
         T v = nums[l];
         while (i <= gt) {
             int cmp = nums[i].compareTo(v);
-            if (cmp < 0)
+            if (cmp < 0) {
                 swap(nums, lt++, i++);
-            else if (cmp > 0)
+            } else if (cmp > 0) {
                 swap(nums, i, gt--);
-            else
+            } else {
                 i++;
+            }
         }
         sort(nums, l, lt - 1);
         sort(nums, gt + 1, h);
@@ -555,24 +581,28 @@ public class ThreeWayQuickSort<T extends Comparable<T>> extends QuickSort<T> {
 
 可以利用这个特性找出数组的第 k 个元素。
 
+该算法是线性级别的，因为每次能将数组二分，那么比较的总次数为 (N+N/2+N/4+..)，直到找到第 k 个元素，这个和显然小于 2N。
+
 ```java
 public T select(T[] nums, int k) {
     int l = 0, h = nums.length - 1;
     while (h > l) {
         int j = partition(nums, l, h);
-        if (j == k)
+
+        if (j == k) {
             return nums[k];
-        else if (j > k)
+
+        } else if (j > k) {
             h = j - 1;
-        else
+
+        } else {
             l = j + 1;
+        }
     }
     return nums[k];
 }
 ```
 
-该算法是线性级别的。因为每次能将数组二分，那么比较的总次数为 (N+N/2+N/4+..)，直到找到第 k 个元素，这个和显然小于 2N。
-
 ## 堆排序
 
 ### 1. 堆
diff --git a/pics/0157d362-98dd-4e51-ac26-00ecb76beb3e.png b/pics/0157d362-98dd-4e51-ac26-00ecb76beb3e.png
new file mode 100644
index 0000000000000000000000000000000000000000..fc0999f997288999ff38615db17d5ecc916d2d42
GIT binary patch
literal 14336
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
MmF_+N|6=_AFI7~~0{{R3

literal 0
HcmV?d00001

diff --git a/pics/220790c6-4377-4a2e-8686-58398afc8a18.png b/pics/220790c6-4377-4a2e-8686-58398afc8a18.png
new file mode 100644
index 0000000000000000000000000000000000000000..7910525710e724735de28351f6ac0c346eed7f96
GIT binary patch
literal 6144
zcmeI0dpJ~U-^ZuDRZ7YsQ%*^Ra>&l1DMBWb$oYJ>J1}w#V=&B2F%h%T4%tpkLyp5p
z3?e-3l9a>D4in=PF=H4L1{uS=OV{;0SJ(Ugy`SfOuj~C|4(qqpy6^A0f4}?we(sfG
zXJanDS8gu|1QNHnV&(t>?cf3bUyAMmzSAqcOn{#qkq+ii5V==j7B~=rn_8QKK(!fS
zf@?d0<2|>pxJQCOQi$!(jxm3w7!U}2*TT%yDaMCWIM*lcI^IcWe<wz}^75kD@%@sM
zcDQn>0jW32!w&Y7)GU?-MdlbZJ8N%+V}+R_TcTgNH_O#>(n%z2Fq8Ym$1pNvZYWwi
z4pT?3VlG>>-QvDjeOkBL9ftO=cCX_K!vO_$u@VL#(8ZsQ0ut_sTx4yFx<lOo=m8Ob
z27yk1pu0h!D<Ir{5a<C&R1pL^y5oP<4O)lz_(R$wQ=J)^?=sbF6Bwk28*AK_xU~hp
z*sl|&Uv-@=2Kr#eeFPJsE#+Y6haBxhVRdEcd#0gpv~x{snJr;gqpN;praCQxXcGU8
zI@*RdOc89ZjlbeN6^y)yRBLKYwNE?PV<Hqt3&NcBqq$?^p=#5YAt#6&=QQ?H%cH!X
z5~)*rpke!<YG6}V^-kiU!?+{15~v#z2DPHlFfGy6e;nn-Bv9oOsVOiCRFEla=PqKW
zG;ZuL&PFqV>L~`*{zcU2@loE}qloL0xG@h2)Lm27q6iVPiztmh${S3eitU4DsEM|o
z5iN8RAvS_>KEFz!E|{{?Oj&P^iMCSy{SqF1xrdn>)M|`m+R#a^+VncOZS=RVpC_29
z_p_-r-Yqi?!9$a!Hihh62aXi@@p-eMbh5Ym26W?1)@Vy~O9%eY?mGV-x#+34X%m>9
zH&9mo*^s>r%1ZcECu>%jO<{yDX1zrIe8f#;HJdOVzns<*F>U#E8TM3@$YnIvAjugD
z=cNQz!S+hTHYhrYYto<NrqEtOt?_MNXb2r;t6KeGHym}3%1FtkhK;?<O^KiXR7<{;
zyx+Z29YJ~Bs7y##G;Fpt+0+XP3TStGj#^<)ENTGtgLJL&5nrHNY2u8rTY_KZmudrS
zvvF;qqs{Zp`_K?JE<@1}JW?~1rOX4$u6c2)lRjJwoH<?U)r{z}&Ock-6Z`A}MuT{D
zSl7Q>w4vCy9kW0sUV62eCk_o$14CVtE7K`kZ(QA3#pW4E`Ln^d8I57lzSvF5++elm
zVClkWOH1PJ1H0DnDh57^K{=<rN1m7_1{RC>EsVSv+GiHf?tfjGH~k@}@jQ}XjOO=~
zYyCbvk}(c)P$ACER6Ca0EWAEo((SM3QtdIlYu{nJ4Gf}9EA-+A3H~r8h%r+2<}?D`
zCkEDhm+suDRU1@li@s0(xVf>mdo4)S1q#STbK->GrZPrTq}4{&#<5(3=!Jrik1PIX
zJ|+X>NufrWbGVfxb%cz+j}$-J`W9d8!fJX)MsW4zDPq>jK5ypbx)Xup|G4{e-RumN
znP-uWBX?@Rdkb#WaeyE>h)y1gek$*nhFHdG9~*?yyAv)aw9RCFnhWiFY^48rR?<{f
zH`WEZhQ2c1hStpu@@yk0>D;_;2;@U!Lth>@W}}HC8&VVvkxf9t{FjywU2?v6Bvomp
z@>lHU3Vi~8Jw><$?|bZRSyq&#g6Oi`mXj)@u~(^3!&wS-vhw`E<F?{!uajPg9Xc&y
z0_6JM>F@vq$vzY_qwP;5_3FtNP4!o~ZCXEauEMni(2A<G@;K+wd_;rwrl31lw~ixM
z@7)%^p8e09*4SD?>9Cd%##wqxG`Gr{9q?XmrOigKki7Gp!JtK^s^3R+YH#8_LHv7(
zX7Frxp1wv<zF(Pp6fr1|ZtG0?x#15vic~Y%UJJo<9Q4R4L7qG#<_)oKj{Pf~ec6Lv
zdPMeClG(?vof%387U;oMI5PZ8Tc2msZK7e^Y89g?{Ko2GTN>zey>Fc<iz7l5wv;b_
zRZRH{sIcJS(TIC+$u3*`0KC84o-$ik<d{TVTNurcQVsm@K3gM^aO#*d7}a)sFxpSW
zRD(Dd6E%_-O0SP=+kXShrxlymLE;bvz|5&G{8>q3kH;SGbxz~>bA63<WB_tL#}{)(
zUg0PYnLrhKv+t34+;J26YR_~;ep=``z0?)4cf103d}+LV)nk&Un30KrEBqD(<ylcg
zjk0FvtvGVzK4Z4lnf@7GKu+yB_a%=HzpGJ)_L<Dsm0IOK?8(yfZmvg48~Ats@h4r^
zZI3r;h1s3!m_OUq8S(2KDq{~+7){eF0i#c{y^;<nJ*IR;^xu%tQds_Y*F&>}NhS8_
zO9v6>dVUhlj|5IP*bd;x`HI$Dey=ON+y`Fwa#7QRmG^w`_%Vv9<HFV_(n((U)Z2kK
zh1dqNds~t3+H(oi){J|IgRpFQu~P}#&zCf^eCC#ace`h7>lfGkIWIm{m4AbwQ(>I}
zS_rIw{k7U~Reg^)o#^7U5lM2FB}L<wPkFFn!y&0rgr#QMeP@k7qkdxxm#`m%r_E?|
z@;&Nu#(|lheEQ5=Y9lPF9HP0jAp_WejRb#A1-qLJgM+ydp0J&>;~5l>lCV>VG^E}!
z>f+q`mlu)D1cHV-P}7(l1(%z^#ie!<C`Q0y71ld?@=Z#};BdgOH-n@D?OTglfv9;L
zX7+Ue9Weye_rGUM-n=hIA6-GX#fvVLN?mZ;yjS&8^|<yU)_|!Ib4@XI_{k|<-zTUo
zKiaJ4-q!h{-z!Cp+CfWckg<2*z5GVGc)irW4h9AY{jXC_l8s|&o_*bV@@S!f&8Xg-
zImRgt<@DvyyID0SypL0mGNRg#>UqMz-@0~V97T<c8m$Uw88{HEyj?o-Wi<707#{f^
z)ya!`*xo|U7_jv0aA5H}ei`4jDdoY^g_Wv9>HPhh|1jTDpm(x&UzFgJXe96EYrR;Z
zu?q#Rj2OND&2@LwyoVEMjkY;y+`&$clt38*9$DOR`|2ajTXi~KG~r;StxO28-WN&o
zJ;PcDW<JS8>7m3`>TM-!rJ4<L1oKy93k{$`t|{wt`PNt*w>58{j8^$TUmIVx{n!m<
z1gx`i97N4GYEw)-B7bESTxYx&Sk(PQTdUlRFVRQKN=pZ1*#u`#kuo^S0NF9APvN_1
zr)uarOQJL!A5lqizF3qOTscBXgUFm>6k({(wYD4hZtLIO9<UXi#O>nRMv4ENz5fRY
z<F5!}d(7gWMi{}llnb#-Cz@K-Uton8mj~|wH%uT@SXN?AFU4*N*0Gf(=X~1YWw&9>
z*?4@tnS|mPq4|1Et(EqLPAQMX07eDn?fyRjuYV&?-#K}2Yko*~ZQ@npiKVZfUr(&6
z&j73WD~@vyz{-gX(jQr5-9Xi`r~OA_RrQMwHt*%Hau^n0dJ7GKYr0$G)&P{w1MCdI
z<1?qc;r&)GEh_xK<n~`=y(LDbLPU*v?Q|CbkQIkQ_7^(7G-ZV+<)r}OP>JSnR>7n=
zG(#7-2M8xp(=IU&hDo3bi2mDQd0eQ1L0Jp{&HMDFf$+#t#1!>>hdk~GygYY1yo)HG
z+<R*5DDT{*o;N@kB072wVYA(rEFkzOugUapmoOtNp@xk%Pa_vbW&t*wMy<}z?pHEa
z5O_(}vJ3imDXu+KxjORf+UpTud`AtrFQ?81f0`iswjUWO8*+=XfrO29_jb+?)zu+S
zN~>Dk_G}E*55haRFzds{jT>VYCpFE}74~3Chupm320qyNm320$W(1(R#EoskA|a8S
z;ptLaf=|mBK+%B_p_+j+0C|KCJ@<PR`7i?(R~2}f`30b}=tyR7b)od;20)^T1Z`k9
zaH0yg&~XMi??xwHO4f9iX*OG6*b$<~(ey$StZ|dCF0j<KVGEP(JONYvO!j&q_1|%J
zPMi0_|3*~dY|JwAI6?VR(jQ*%N6>b}>_dRkJ)RkXnQx2y<p!=AgE_V3vR(0<VG0@G
z&YF5t1`mQ(tq;>RWvN_K=8;@$n!7U9+9O^$IkT3TebJ-MQIUlBr4+_<Km5idUVHf9
z`Zj?8k9?IFguFIT=^VPT%5mQjv}(p-eX1?qSZ5M|v-vtWaznZJ)=OY-(A<C+VY}_#
zuiz$cbV^#y265=LmngvNRl`N{{GDRpezHc2H|L{%nIv~>b7Q+{eBOEF{2y@}oJK~0
zm>>0tDfw#7Y4;8O%3KcmbUjuVcmzc_cdWH;YB0FC_cg%Zb#vAX{u-BSQ*cglq%rp>
z@8L6W^JObczmqdDjM1PaAM&Mfz1KDOd}L`$_|)b6c8I(NQMf|)bzfqf4IA?c`oJC_
z0WMqaCg!b}ZQwG#za$V!kFJ?&kV{LxKJdsWZnX)RW^fKIt6oHj@AZ3aWv-oG$3jQb
z^^U!n_SLYSFYvo(Lr2^g3pGX^MWGTX3pY{k2uAIVWW(5{n@D01jwDu62|b|Vdl;n}
z0}THJ(+A>*v{}#3jQ{<R>{a62E{Ee6(?phaF9G=vy`%LwC;2)J+~wJKa{!!nb49^`
z_oB$rrKcPnIn&)WT=qMs!m%uY5Ofx-UrcKvbU2J|a4O?M=7uRG!`l-V^U<lIQ0+Zp
zM7o+jaZVK$Jsp_&95MUX1OWH4g_&mMry$m?6^g}|(;@)u7RNLU0iedb-jk<Kx#g|3
zu*?J=-?u)%9yxN{JiXh%)7q94Nl_T}sE1|j66lw7<Vf+Craz3bXvKB6Vn`jXetXbB
zJ}9$Dd}oL;AW2_G?hfmd`EQ3mrynuO(|WMX{1A9{Cox9^8iv)|m=N>$80zd^J69a}
z!1w1T4Vqp}RI8cPY^q9#VmmfHmvFu!kBTnrHxH?cnW=KChdul{r<1f_(IY=^mA396
zes48I)lbwrEa5wrC$G#WI`^=WJ~S#TRfjx7ef-{!aE%sl8>n9W+&RJ=y#^ACaVe!{
zA2CAR#J{h)oCq$=G;mDQSxP9cq^`8ig``r8G+-RTa-T`!##w26L%*-DW2se_zk*)o
zG(!)VcJtLZ>Q)U<*N>G7v8zLHRSNfpy>8oqkH>tmnD}~583ChnOBxt++!nV87OsTm
z*>fgcJx}Z-B{a+zoH#IA67)H{6tP(Zv-Z5oCZhAKX@!~T*uS1y44nyjKT1ee&!El~
z2icGq=(wf63;0wDwKGlLRl1REC=B+7JV@TJi1Hivzplj-ECMeyMino_{POKZ5wNjT
z!hBOE$-<6DRBzJs1TSNkpCf1eVGu1MI)Bf1J>!|!g{N2U42q%O9}f9eV2mCXKm5y+
z!L#_C?yzW^ZOrY^cYQ?779_y%5DCrUBKl*%Sn?I?0!@UF4+H&!`k6J-T5bJuSyX1K
zB~AZ$>;}e4_u{&F@Ou6))zj~|u4X{J1202p@3h-NHr%2^twlyzI`_!GH~VBeY}B87
zJBfzlwoqMS)Jbs>d;=?q+Q$z_QWoBT<ss>->gm)?%iA53GnK|Ly46<HB;WP;GUS?4
z{8!V@HJ^|19$sXnMFKnN;A<J_zJ(7So7`FnH}-hu#H)jodS@A7?LDRaf<^X>8ALNL
z!BJjotin~Z^uVPGc2-Mi30AP!Ioy*KdP2X1#GDPpgCDsIVp0ZrQe3ceO)IDQrPld@
zoJFxOyvWxup*pdI>a6WiTXUlkMIn7x^ZVUi{Fo>$*1m0Hp(VKGdToT#_bM(BIQ0u<
z@Usw7Zx;b?*FOX{3S0vCFO#5BVY_K?_t*^;gf)|`|IRLM34a*>TM0F)c-og!Ngy|*
z!g|WvmctZzvmZNK*Jtu6!s?D3aE7$x_c64vX7Rh|0`@J~pE2ClH7jACtORN*0JpWZ
z!EHRRor+0yY<CJ!j_j~xrDEJH>Dh!$`|WL1Pk?)Urvpoh=+Ej;(s@kKaM3R|s4>yz
zzqq#PmOhZS7pk42gY$9GG%S05W9WQ^?h0u{27hXmpQXanxgJ|+ad7Kp)?!e&U;l5z
z#8p;l2m7sAZB?$zn`VEfHNTY|fJ<%T0DuwyB8%@yKldXj0M&m4{v%1K+y#)~2h{ji
zBmZO(U`5E#{gD)aY=<ZPfD%4Zz@<O3#?_wysQ3{^fXe&#i<lg$gD<>F+-+fY$T}cS
zW*JxsCsr$G080l@%*v833viM{V8(?^Is3iabUVEJ?|Uh$o)IY&JL0Am`Sp?NBG4De
T0%l`IhW?uH|MUNU&j0@c$L*Xz

literal 0
HcmV?d00001

diff --git a/pics/864bfa7d-1149-420c-a752-f9b3d4e782ec.png b/pics/864bfa7d-1149-420c-a752-f9b3d4e782ec.png
new file mode 100644
index 0000000000000000000000000000000000000000..72cc988f12ebb575ffabf9fee836aa7d23aad0ca
GIT binary patch
literal 16384
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

literal 0
HcmV?d00001

diff --git a/pics/f8047846-efd4-42be-b6b7-27a7c4998b51.png b/pics/f8047846-efd4-42be-b6b7-27a7c4998b51.png
new file mode 100644
index 0000000000000000000000000000000000000000..86e2294f478af16f2bc278d3e30012bb4a7205b3
GIT binary patch
literal 12288
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
Xh1GdMIc$b{rk6@DUi-)Y`uYDahPHTa

literal 0
HcmV?d00001


From d655c65eff7d1914e961d0e414edf7df735b979c Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 15 Aug 2018 22:23:46 +0800
Subject: [PATCH 12/14] auto commit

---
 notes/算法.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/notes/算法.md b/notes/算法.md
index f0e889db..8ce9682d 100644
--- a/notes/算法.md
+++ b/notes/算法.md
@@ -770,14 +770,14 @@ public class HeapSort<T extends Comparable<T>> extends Sort<T> {
 
 | 算法 | 稳定 | 时间复杂度 | 空间复杂度 | 备注 |
 | :---: | :---: |:---: | :---: | :---: |
-| 选择排序 | no | N<sup>2</sup> | 1 | |
-| 冒泡排序 | yes |  N<sup>2</sup> | 1 | |
-| 插入排序 | yes |  N \~ N<sup>2</sup> | 1 | 时间复杂度和初始顺序有关 |
-| 希尔排序 | no |  N 的若干倍乘于递增序列的长度 | 1 | |
-| 快速排序 | no | NlogN | logN | |
-| 三向切分快速排序 | no |  N \~ NlogN | logN | 适用于有大量重复主键|
-| 归并排序 | yes |  NlogN | N | |
-| 堆排序 | no |  NlogN | 1 | | |
+| 选择排序 | :heavy_check_mark:| N<sup>2</sup> | 1 | |
+| 冒泡排序 | :heavy_check_mark: |  N<sup>2</sup> | 1 | |
+| 插入排序 | :heavy_check_mark: |  N \~ N<sup>2</sup> | 1 | 时间复杂度和初始顺序有关 |
+| 希尔排序 | :heavy_multiplication_x:  |  N 的若干倍乘于递增序列的长度 | 1 | |
+| 快速排序 | :heavy_multiplication_x:  | NlogN | logN | |
+| 三向切分快速排序 | :heavy_multiplication_x:  |  N \~ NlogN | logN | 适用于有大量重复主键|
+| 归并排序 | :heavy_check_mark: |  NlogN | N | |
+| 堆排序 | :heavy_multiplication_x:  |  NlogN | 1 | | |
 
 快速排序是最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间近似为 \~cNlogN，这里的 c 比其他线性对数级别的排序算法都要小。使用三向切分快速排序，实际应用中可能出现的某些分布的输入能够达到线性级别，而其它排序算法仍然需要线性对数时间。
 

From a14c6fd5fdf082be7b9307013b7b1ec7b9958003 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 15 Aug 2018 22:27:28 +0800
Subject: [PATCH 13/14] auto commit

---
 notes/算法.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/notes/算法.md b/notes/算法.md
index 8ce9682d..30467b42 100644
--- a/notes/算法.md
+++ b/notes/算法.md
@@ -770,14 +770,14 @@ public class HeapSort<T extends Comparable<T>> extends Sort<T> {
 
 | 算法 | 稳定 | 时间复杂度 | 空间复杂度 | 备注 |
 | :---: | :---: |:---: | :---: | :---: |
-| 选择排序 | :heavy_check_mark:| N<sup>2</sup> | 1 | |
-| 冒泡排序 | :heavy_check_mark: |  N<sup>2</sup> | 1 | |
-| 插入排序 | :heavy_check_mark: |  N \~ N<sup>2</sup> | 1 | 时间复杂度和初始顺序有关 |
-| 希尔排序 | :heavy_multiplication_x:  |  N 的若干倍乘于递增序列的长度 | 1 | |
-| 快速排序 | :heavy_multiplication_x:  | NlogN | logN | |
-| 三向切分快速排序 | :heavy_multiplication_x:  |  N \~ NlogN | logN | 适用于有大量重复主键|
-| 归并排序 | :heavy_check_mark: |  NlogN | N | |
-| 堆排序 | :heavy_multiplication_x:  |  NlogN | 1 | | |
+| 选择排序 | √| N<sup>2</sup> | 1 | |
+| 冒泡排序 | √ |  N<sup>2</sup> | 1 | |
+| 插入排序 | √ |  N \~ N<sup>2</sup> | 1 | 时间复杂度和初始顺序有关 |
+| 希尔排序 | ×  |  N 的若干倍乘于递增序列的长度 | 1 | |
+| 快速排序 | ×  | NlogN | logN | |
+| 三向切分快速排序 | ×  |  N \~ NlogN | logN | 适用于有大量重复主键|
+| 归并排序 | √ |  NlogN | N | |
+| 堆排序 | ×  |  NlogN | 1 | | |
 
 快速排序是最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间近似为 \~cNlogN，这里的 c 比其他线性对数级别的排序算法都要小。使用三向切分快速排序，实际应用中可能出现的某些分布的输入能够达到线性级别，而其它排序算法仍然需要线性对数时间。
 

From aa4dfe2ea77394aacbd002eaffb55c03cf2575f8 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 15 Aug 2018 22:38:23 +0800
Subject: [PATCH 14/14] auto commit

---
 notes/Java 虚拟机.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/notes/Java 虚拟机.md b/notes/Java 虚拟机.md
index 891211da..a4a4ba12 100644
--- a/notes/Java 虚拟机.md	
+++ b/notes/Java 虚拟机.md	
@@ -45,7 +45,7 @@
 可以通过 -Xss 这个虚拟机参数来指定每个线程的 Java 虚拟机栈内存大小：
 
 ```java
-java -Xss=512M HackTheJava
+java -Xss512M HackTheJava
 ```
 
 该区域可能抛出以下异常：
@@ -81,7 +81,7 @@ java -Xss=512M HackTheJava
 可以通过 -Xms 和 -Xmx 两个虚拟机参数来指定一个程序的堆内存大小，第一个参数设置初始值，第二个参数设置最大值。
 
 ```java
-java -Xms=1M -Xmx=2M HackTheJava
+java -Xms1M -Xmx2M HackTheJava
 ```
 
 ## 方法区