diff --git a/docs.rar b/docs.rar
new file mode 100644
index 00000000..4e6d7fb5
Binary files /dev/null and b/docs.rar differ
diff --git a/docs/notes/Docker.md b/docs/notes/Docker.md
index 1b61a7fe..da6e2bf4 100644
--- a/docs/notes/Docker.md
+++ b/docs/notes/Docker.md
@@ -8,7 +8,7 @@
- first;
transient Node last;
```
- implements Map.Entry {
@@ -485,7 +485,7 @@ map.put("K3", "V3");
- 计算键值对所在的桶；
- 在链表上顺序查找，时间复杂度显然和链表的长度成正比。
- [] segments;
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
```
- diffWaysToCompute(String input) {
### BFS
- [] graphic, int start, int end) {
### DFS
- > solutions;
@@ -2571,7 +2571,7 @@ public int minPathSum(int[][] grid) {
题目描述：统计从矩阵左上角到右下角的路径总数，每次只能向右或者向下移动。
- nums) {
### Trie
-33 TB = 8 ZB。
-33 TB
BIOS（Basic Input/Output System，基本输入输出系统），它是一个固件（嵌入在硬件中的软件），BIOS 程序存放在断电后内容不会丢失的只读内存中。
-i 和 keyi+1 ，且不为 null，则该指针指向节点的所有 key 大于等于 keyi 且小于等于 keyi+1 。
- in = new Stack();
@@ -474,7 +474,7 @@ public int pop() throws Exception {
如果使用递归求解，会重复计算一些子问题。例如，计算 f(10) 需要计算 f(9) 和 f(8)，计算 f(9) 需要计算 f(8) 和 f(7)，可以看到 f(8) 被重复计算了。
- > Print(TreeNode pRoot) {
例如，下图是后序遍历序列 1,3,2 所对应的二叉搜索树。
-1 和 T2 两个事务都对一个数据进行修改，T1 先修改，T2 随后修改，T2 的修改覆盖了 T1 的修改。
-1 修改一个数据，T2 随后读取这个数据。如果 T1 撤销了这次修改，那么 T2 读取的数据是脏数据。
-2 读取一个数据，T1 对该数据做了修改。如果 T2 再次读取这个数据，此时读取的结果和第一次读取的结果不同。
-1 读取某个范围的数据，T2 在这个范围内插入新的数据，T1 再次读取这个范围的数据，此时读取的结果和和第一次读取的结果不同。
- > {
选择排序需要 \~N2 /2 次比较和 \~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。
- > extends Sort {
@@ -322,7 +322,7 @@ public class Selection> extends Sort {
以下演示了在一轮循环中，将最大的元素 5 上浮到最右侧。
- > extends Sort {
@@ -358,7 +358,7 @@ public class Bubble> extends Sort {
以下演示了在一轮循环中，将元素 2 插入到左侧已经排序的数组中。
- > extends Sort {
@@ -383,7 +383,7 @@ public class Insertion> extends Sort {
希尔排序使用插入排序对间隔 h 的序列进行排序。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。
- > extends Sort {
@@ -417,7 +417,7 @@ public class Shell> extends Sort {
归并排序的思想是将数组分成两部分，分别进行排序，然后归并起来。
- > extends MergeSort {
- 归并排序将数组分为两个子数组分别排序，并将有序的子数组归并使得整个数组排序；
- 快速排序通过一个切分元素将数组分为两个子数组，左子数组小于等于切分元素，右子数组大于等于切分元素，将这两个子数组排序也就将整个数组排序了。
- > extends Sort {
@@ -543,7 +543,7 @@ public class QuickSort> extends Sort {
取 a[l] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于它的元素，交换这两个元素。不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[l] 和 a[j] 交换位置。
- > {
@@ -683,7 +683,7 @@ public class Heap> {
在堆中，当一个节点比父节点大，那么需要交换这个两个节点。交换后还可能比它新的父节点大，因此需要不断地进行比较和交换操作，把这种操作称为上浮。
- > extends Sort {
@@ -825,7 +825,7 @@ Java 主要排序方法为 java.util.Arrays.sort()，对于原始数据类型使
用于解决动态连通性问题，能动态连接两个点，并且判断两个点是否连通。
- , Value> implement
**二叉树** 是一个空链接，或者是一个有左右两个链接的节点，每个链接都指向一颗子二叉树。
- keys(Node x, Key l, Key h) {
2-3 查找树引入了 2- 节点和 3- 节点，目的是为了让树平衡。一颗完美平衡的 2-3 查找树的所有空链接到根节点的距离应该是相同的。
- keys(Node x, Key l, Key h) {
- 如果插入到 2- 节点上，那么直接将新节点和原来的节点组成 3- 节点即可。
- keys(Node x, Key l, Key h) {
红黑树是 2-3 查找树，但它不需要分别定义 2- 节点和 3- 节点，而是在普通的二叉查找树之上，为节点添加颜色。指向一个节点的链接颜色如果为红色，那么这个节点和上层节点表示的是一个 3- 节点，而黑色则是普通链接。
- keys(Node x, Key l, Key h) {
画红黑树时可以将红链接画平。
- , Value> extends BST {
@@ -1866,7 +1866,7 @@ public class RedBlackBST, Value> extends BST implements UnorderedST {
@@ -2155,7 +2155,7 @@ public void delete(Key key) {
线性探测法的成本取决于连续条目的长度，连续条目也叫聚簇。当聚簇很长时，在查找和插入时也需要进行很多次探测。例如下图中 2\~5 位置就是一个聚簇。
-n -1] 看成一个哈希环，每个服务器节点都配置到哈希环上。每个数据对象通过哈希取模得到哈希值之后，存放到哈希环中顺时针方向第一个大于等于该哈希值的节点上。
-k -1)} 中随机取出一个数，记作 r，然后取 r 倍的争用期作为重传等待时间。
- ![]() ` 让图片居中显示，只能使用 `` 达到居中的效果。
+
+笔者将自己实现的文档排版功能提取出来，放在 Github Page 中，无需下载安装即可免费使用：[Text-Typesetting](https://github.com/CyC2018/Markdown-Typesetting)。
+
+#### Uploading
+
+笔者在本地使用为知笔记软件进行书写，为了方便将本地笔记内容上传到 Github 上，实现了一整套自动化上传方案，包括文本文件的导出、提取图片、Markdown 文档转换、Git 同步。
+
+进行 Markdown 文档转换是因为 Github 使用的 GFM 不支持 MathJax 公式和 TOC 标记，所以需要替换 MathJax 公式为 CodeCogs 的云服务和重新生成 TOC 目录。
+
+笔者将自己实现文档转换功能提取出来，方便大家在需要将本地 Markdown 上传到 Github，或者制作项目 README 文档时生成目录时使用：[GFM-Converter](https://github.com/CyC2018/GFM-Converter)。
+
+#### Logo
+
+Power by [logomakr](https://logomakr.com/).
+
+#### Statement
+
+本仓库不参与商业行为，不向读者收取任何费用。(This repository is not engaging in business activities, and does not charge readers any fee.)
+
+#### Acknowledgements
+
+感谢以下人员对本仓库做出的贡献，当然不仅仅只有这些贡献者，这里就不一一列举了。如果你希望被添加到这个名单中，并且提交过 Issue 或者 PR，请与笔者联系。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#### License
+
+在对本作品进行演绎时，请署名并以相同方式共享。
+
+Document
+
+ Github
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs1/docs/notes/Docker.md b/docs1/docs/notes/Docker.md
new file mode 100644
index 00000000..1b61a7fe
--- /dev/null
+++ b/docs1/docs/notes/Docker.md
@@ -0,0 +1,91 @@
+
+* [一、解决的问题](#一解决的问题)
+* [二、与虚拟机的比较](#二与虚拟机的比较)
+* [三、优势](#三优势)
+* [四、使用场景](#四使用场景)
+* [五、镜像与容器](#五镜像与容器)
+* [参考资料](#参考资料)
+
+
+
+New File
+```
+
+## PATCH
+
+> 对资源进行部分修改
+
+PUT 也可以用于修改资源，但是只能完全替代原始资源，PATCH 允许部分修改。
+
+```html
+PATCH /file.txt HTTP/1.1
+Host: www.example.com
+Content-Type: application/example
+If-Match: "e0023aa4e"
+Content-Length: 100
+
+[description of changes]
+```
+
+## DELETE
+
+> 删除文件
+
+与 PUT 功能相反，并且同样不带验证机制。
+
+```html
+DELETE /file.html HTTP/1.1
+```
+
+## OPTIONS
+
+> 查询支持的方法
+
+查询指定的 URL 能够支持的方法。
+
+会返回 Allow: GET, POST, HEAD, OPTIONS 这样的内容。
+
+## CONNECT
+
+> 要求在与代理服务器通信时建立隧道
+
+使用 SSL（Secure Sockets Layer，安全套接层）和 TLS（Transport Layer Security，传输层安全）协议把通信内容加密后经网络隧道传输。
+
+```html
+CONNECT www.example.com:443 HTTP/1.1
+```
+
+ keys = selector.selectedKeys();
+Iterator keyIterator = keys.iterator();
+while (keyIterator.hasNext()) {
+ SelectionKey key = keyIterator.next();
+ if (key.isAcceptable()) {
+ // ...
+ } else if (key.isReadable()) {
+ // ...
+ }
+ keyIterator.remove();
+}
+```
+
+### 5. 事件循环
+
+因为一次 select() 调用不能处理完所有的事件，并且服务器端有可能需要一直监听事件，因此服务器端处理事件的代码一般会放在一个死循环内。
+
+```java
+while (true) {
+ int num = selector.select();
+ Set keys = selector.selectedKeys();
+ Iterator keyIterator = keys.iterator();
+ while (keyIterator.hasNext()) {
+ SelectionKey key = keyIterator.next();
+ if (key.isAcceptable()) {
+ // ...
+ } else if (key.isReadable()) {
+ // ...
+ }
+ keyIterator.remove();
+ }
+}
+```
+
+## 套接字 NIO 实例
+
+```java
+public class NIOServer {
+
+ public static void main(String[] args) throws IOException {
+
+ Selector selector = Selector.open();
+
+ ServerSocketChannel ssChannel = ServerSocketChannel.open();
+ ssChannel.configureBlocking(false);
+ ssChannel.register(selector, SelectionKey.OP_ACCEPT);
+
+ ServerSocket serverSocket = ssChannel.socket();
+ InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8888);
+ serverSocket.bind(address);
+
+ while (true) {
+
+ selector.select();
+ Set keys = selector.selectedKeys();
+ Iterator keyIterator = keys.iterator();
+
+ while (keyIterator.hasNext()) {
+
+ SelectionKey key = keyIterator.next();
+
+ if (key.isAcceptable()) {
+
+ ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();
+
+ // 服务器会为每个新连接创建一个 SocketChannel
+ SocketChannel sChannel = ssChannel1.accept();
+ sChannel.configureBlocking(false);
+
+ // 这个新连接主要用于从客户端读取数据
+ sChannel.register(selector, SelectionKey.OP_READ);
+
+ } else if (key.isReadable()) {
+
+ SocketChannel sChannel = (SocketChannel) key.channel();
+ System.out.println(readDataFromSocketChannel(sChannel));
+ sChannel.close();
+ }
+
+ keyIterator.remove();
+ }
+ }
+ }
+
+ private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
+
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+ StringBuilder data = new StringBuilder();
+
+ while (true) {
+
+ buffer.clear();
+ int n = sChannel.read(buffer);
+ if (n == -1) {
+ break;
+ }
+ buffer.flip();
+ int limit = buffer.limit();
+ char[] dst = new char[limit];
+ for (int i = 0; i < limit; i++) {
+ dst[i] = (char) buffer.get(i);
+ }
+ data.append(dst);
+ buffer.clear();
+ }
+ return data.toString();
+ }
+}
+```
+
+```java
+public class NIOClient {
+
+ public static void main(String[] args) throws IOException {
+ Socket socket = new Socket("127.0.0.1", 8888);
+ OutputStream out = socket.getOutputStream();
+ String s = "hello world";
+ out.write(s.getBytes());
+ out.close();
+ }
+}
+```
+
+## 内存映射文件
+
+内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。
+
+向内存映射文件写入可能是危险的，只是改变数组的单个元素这样的简单操作，就可能会直接修改磁盘上的文件。修改数据与将数据保存到磁盘是没有分开的。
+
+下面代码行将文件的前 1024 个字节映射到内存中，map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。
+
+```java
+MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
+```
+
+## 对比
+
+NIO 与普通 I/O 的区别主要有以下两点：
+
+- NIO 是非阻塞的；
+- NIO 面向块，I/O 面向流。
+
+# 八、参考资料
+
+- Eckel B, 埃克尔, 昊鹏, 等. Java 编程思想 [M]. 机械工业出版社, 2002.
+- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
+- [Java NIO Tutorial](http://tutorials.jenkov.com/java-nio/index.html)
+- [Java NIO 浅析](https://tech.meituan.com/nio.html)
+- [IBM: 深入分析 Java I/O 的工作机制](https://www.ibm.com/developerworks/cn/java/j-lo-javaio/index.html)
+- [IBM: 深入分析 Java 中的中文编码问题](https://www.ibm.com/developerworks/cn/java/j-lo-chinesecoding/index.html)
+- [IBM: Java 序列化的高级认识](https://www.ibm.com/developerworks/cn/java/j-lo-serial/index.html)
+- [NIO 与传统 IO 的区别](http://blog.csdn.net/shimiso/article/details/24990499)
+- [Decorator Design Pattern](http://stg-tud.github.io/sedc/Lecture/ws13-14/5.3-Decorator.html#mode=document)
+- [Socket Multicast](http://labojava.blogspot.com/2012/12/socket-multicast.html)
diff --git a/docs1/docs/notes/Java 基础.md b/docs1/docs/notes/Java 基础.md
new file mode 100644
index 00000000..6707cc28
--- /dev/null
+++ b/docs1/docs/notes/Java 基础.md
@@ -0,0 +1,1315 @@
+
+* [一、数据类型](#一数据类型)
+ * [包装类型](#包装类型)
+ * [缓存池](#缓存池)
+* [二、String](#二string)
+ * [概览](#概览)
+ * [不可变的好处](#不可变的好处)
+ * [String, StringBuffer and StringBuilder](#string,-stringbuffer-and-stringbuilder)
+ * [String Pool](#string-pool)
+ * [new String("abc")](#new-string"abc")
+* [三、运算](#三运算)
+ * [参数传递](#参数传递)
+ * [float 与 double](#float-与-double)
+ * [隐式类型转换](#隐式类型转换)
+ * [switch](#switch)
+* [四、继承](#四继承)
+ * [访问权限](#访问权限)
+ * [抽象类与接口](#抽象类与接口)
+ * [super](#super)
+ * [重写与重载](#重写与重载)
+* [五、Object 通用方法](#五object-通用方法)
+ * [概览](#概览)
+ * [equals()](#equals)
+ * [hashCode()](#hashcode)
+ * [toString()](#tostring)
+ * [clone()](#clone)
+* [六、关键字](#六关键字)
+ * [final](#final)
+ * [static](#static)
+* [七、反射](#七反射)
+* [八、异常](#八异常)
+* [九、泛型](#九泛型)
+* [十、注解](#十注解)
+* [十一、特性](#十一特性)
+ * [Java 各版本的新特性](#java-各版本的新特性)
+ * [Java 与 C++ 的区别](#java-与-c-的区别)
+ * [JRE or JDK](#jre-or-jdk)
+* [参考资料](#参考资料)
+
+
+
+# 一、数据类型
+
+## 包装类型
+
+八个基本类型：
+
+- boolean/1
+- byte/8
+- char/16
+- short/16
+- int/32
+- float/32
+- long/64
+- double/64
+
+基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。
+
+```java
+Integer x = 2; // 装箱
+int y = x; // 拆箱
+```
+
+## 缓存池
+
+new Integer(123) 与 Integer.valueOf(123) 的区别在于：
+
+- new Integer(123) 每次都会新建一个对象；
+- Integer.valueOf(123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。
+
+```java
+Integer x = new Integer(123);
+Integer y = new Integer(123);
+System.out.println(x == y); // false
+Integer z = Integer.valueOf(123);
+Integer k = Integer.valueOf(123);
+System.out.println(z == k); // true
+```
+
+valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。
+
+```java
+public static Integer valueOf(int i) {
+ if (i >= IntegerCache.low && i <= IntegerCache.high)
+ return IntegerCache.cache[i + (-IntegerCache.low)];
+ return new Integer(i);
+}
+```
+
+在 Java 8 中，Integer 缓存池的大小默认为 -128\~127。
+
+```java
+static final int low = -128;
+static final int high;
+static final Integer cache[];
+
+static {
+ // high value may be configured by property
+ int h = 127;
+ String integerCacheHighPropValue =
+ sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
+ if (integerCacheHighPropValue != null) {
+ try {
+ int i = parseInt(integerCacheHighPropValue);
+ i = Math.max(i, 127);
+ // Maximum array size is Integer.MAX_VALUE
+ h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
+ } catch( NumberFormatException nfe) {
+ // If the property cannot be parsed into an int, ignore it.
+ }
+ }
+ high = h;
+
+ cache = new Integer[(high - low) + 1];
+ int j = low;
+ for(int k = 0; k < cache.length; k++)
+ cache[k] = new Integer(j++);
+
+ // range [-128, 127] must be interned (JLS7 5.1.7)
+ assert IntegerCache.high >= 127;
+}
+```
+
+编译器会在自动装箱过程调用 valueOf() 方法，因此多个 Integer 实例使用自动装箱来创建并且值相同，那么就会引用相同的对象。
+
+```java
+Integer m = 123;
+Integer n = 123;
+System.out.println(m == n); // true
+```
+
+基本类型对应的缓冲池如下：
+
+- boolean values true and false
+- all byte values
+- short values between -128 and 127
+- int values between -128 and 127
+- char in the range \u0000 to \u007F
+
+在使用这些基本类型对应的包装类型时，就可以直接使用缓冲池中的对象。
+
+[StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123
+](https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123)
+
+# 二、String
+
+## 概览
+
+String 被声明为 final，因此它不可被继承。
+
+内部使用 char 数组存储数据，该数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。
+
+```java
+public final class String
+ implements java.io.Serializable, Comparable, CharSequence {
+ /** The value is used for character storage. */
+ private final char value[];
+```
+
+## 不可变的好处
+
+**1. 可以缓存 hash 值**
+
+因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
+
+**2. String Pool 的需要**
+
+如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
+
+ ":(Ljava/lang/String;)V
+ 9: astore_1
+// ...
+```
+
+在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
+
+以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
+
+```java
+public String(String original) {
+ this.value = original.value;
+ this.hash = original.hash;
+}
+```
+
+# 三、运算
+
+## 参数传递
+
+Java 的参数是以值传递的形式传入方法中，而不是引用传递。
+
+以下代码中 Dog dog 的 dog 是一个指针，存储的是对象的地址。在将一个参数传入一个方法时，本质上是将对象的地址以值的方式传递到形参中。因此在方法中使指针引用其它对象，那么这两个指针此时指向的是完全不同的对象，在一方改变其所指向对象的内容时对另一方没有影响。
+
+```java
+public class Dog {
+
+ String name;
+
+ Dog(String name) {
+ this.name = name;
+ }
+
+ String getName() {
+ return this.name;
+ }
+
+ void setName(String name) {
+ this.name = name;
+ }
+
+ String getObjectAddress() {
+ return super.toString();
+ }
+}
+```
+
+```java
+public class PassByValueExample {
+ public static void main(String[] args) {
+ Dog dog = new Dog("A");
+ System.out.println(dog.getObjectAddress()); // Dog@4554617c
+ func(dog);
+ System.out.println(dog.getObjectAddress()); // Dog@4554617c
+ System.out.println(dog.getName()); // A
+ }
+
+ private static void func(Dog dog) {
+ System.out.println(dog.getObjectAddress()); // Dog@4554617c
+ dog = new Dog("B");
+ System.out.println(dog.getObjectAddress()); // Dog@74a14482
+ System.out.println(dog.getName()); // B
+ }
+}
+```
+
+如果在方法中改变对象的字段值会改变原对象该字段值，因为改变的是同一个地址指向的内容。
+
+```java
+class PassByValueExample {
+ public static void main(String[] args) {
+ Dog dog = new Dog("A");
+ func(dog);
+ System.out.println(dog.getName()); // B
+ }
+
+ private static void func(Dog dog) {
+ dog.setName("B");
+ }
+}
+```
+
+[StackOverflow: Is Java “pass-by-reference” or “pass-by-value”?](https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value)
+
+## float 与 double
+
+Java 不能隐式执行向下转型，因为这会使得精度降低。
+
+1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。
+
+```java
+// float f = 1.1;
+```
+
+1.1f 字面量才是 float 类型。
+
+```java
+float f = 1.1f;
+```
+
+## 隐式类型转换
+
+因为字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型下转型为 short 类型。
+
+```java
+short s1 = 1;
+// s1 = s1 + 1;
+```
+
+但是使用 += 或者 ++ 运算符可以执行隐式类型转换。
+
+```java
+s1 += 1;
+// s1++;
+```
+
+上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：
+
+```java
+s1 = (short) (s1 + 1);
+```
+
+[StackOverflow : Why don't Java's +=, -=, *=, /= compound assignment operators require casting?](https://stackoverflow.com/questions/8710619/why-dont-javas-compound-assignment-operators-require-casting)
+
+## switch
+
+从 Java 7 开始，可以在 switch 条件判断语句中使用 String 对象。
+
+```java
+String s = "a";
+switch (s) {
+ case "a":
+ System.out.println("aaa");
+ break;
+ case "b":
+ System.out.println("bbb");
+ break;
+}
+```
+
+switch 不支持 long，是因为 switch 的设计初衷是对那些只有少数的几个值进行等值判断，如果值过于复杂，那么还是用 if 比较合适。
+
+```java
+// long x = 111;
+// switch (x) { // Incompatible types. Found: 'long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
+// case 111:
+// System.out.println(111);
+// break;
+// case 222:
+// System.out.println(222);
+// break;
+// }
+```
+
+[StackOverflow : Why can't your switch statement data type be long, Java?](https://stackoverflow.com/questions/2676210/why-cant-your-switch-statement-data-type-be-long-java)
+
+# 四、继承
+
+## 访问权限
+
+Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
+
+可以对类或类中的成员（字段以及方法）加上访问修饰符。
+
+- 类可见表示其它类可以用这个类创建实例对象。
+- 成员可见表示其它类可以用这个类的实例对象访问到该成员；
+
+protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
+
+设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
+
+如果子类的方法重写了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。
+
+字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。例如下面的例子中，AccessExample 拥有 id 公有字段，如果在某个时刻，我们想要使用 int 存储 id 字段，那么就需要修改所有的客户端代码。
+
+```java
+public class AccessExample {
+ public String id;
+}
+```
+
+可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。
+
+
+```java
+public class AccessExample {
+
+ private int id;
+
+ public String getId() {
+ return id + "";
+ }
+
+ public void setId(String id) {
+ this.id = Integer.valueOf(id);
+ }
+}
+```
+
+但是也有例外，如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。
+
+```java
+public class AccessWithInnerClassExample {
+
+ private class InnerClass {
+ int x;
+ }
+
+ private InnerClass innerClass;
+
+ public AccessWithInnerClassExample() {
+ innerClass = new InnerClass();
+ }
+
+ public int getValue() {
+ return innerClass.x; // 直接访问
+ }
+}
+```
+
+## 抽象类与接口
+
+**1. 抽象类**
+
+抽象类和抽象方法都使用 abstract 关键字进行声明。抽象类一般会包含抽象方法，抽象方法一定位于抽象类中。
+
+抽象类和普通类最大的区别是，抽象类不能被实例化，需要继承抽象类才能实例化其子类。
+
+```java
+public abstract class AbstractClassExample {
+
+ protected int x;
+ private int y;
+
+ public abstract void func1();
+
+ public void func2() {
+ System.out.println("func2");
+ }
+}
+```
+
+```java
+public class AbstractExtendClassExample extends AbstractClassExample {
+ @Override
+ public void func1() {
+ System.out.println("func1");
+ }
+}
+```
+
+```java
+// AbstractClassExample ac1 = new AbstractClassExample(); // 'AbstractClassExample' is abstract; cannot be instantiated
+AbstractClassExample ac2 = new AbstractExtendClassExample();
+ac2.func1();
+```
+
+**2. 接口**
+
+接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。
+
+从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。
+
+接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。
+
+接口的字段默认都是 static 和 final 的。
+
+```java
+public interface InterfaceExample {
+
+ void func1();
+
+ default void func2(){
+ System.out.println("func2");
+ }
+
+ int x = 123;
+ // int y; // Variable 'y' might not have been initialized
+ public int z = 0; // Modifier 'public' is redundant for interface fields
+ // private int k = 0; // Modifier 'private' not allowed here
+ // protected int l = 0; // Modifier 'protected' not allowed here
+ // private void fun3(); // Modifier 'private' not allowed here
+}
+```
+
+```java
+public class InterfaceImplementExample implements InterfaceExample {
+ @Override
+ public void func1() {
+ System.out.println("func1");
+ }
+}
+```
+
+```java
+// InterfaceExample ie1 = new InterfaceExample(); // 'InterfaceExample' is abstract; cannot be instantiated
+InterfaceExample ie2 = new InterfaceImplementExample();
+ie2.func1();
+System.out.println(InterfaceExample.x);
+```
+
+**3. 比较**
+
+- 从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
+- 从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
+- 接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。
+- 接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。
+
+**4. 使用选择**
+
+使用接口：
+
+- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
+- 需要使用多重继承。
+
+使用抽象类：
+
+- 需要在几个相关的类中共享代码。
+- 需要能控制继承来的成员的访问权限，而不是都为 public。
+- 需要继承非静态和非常量字段。
+
+在很多情况下，接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 Java 8 开始，接口也可以有默认的方法实现，使得修改接口的成本也变的很低。
+
+- [深入理解 abstract class 和 interface](https://www.ibm.com/developerworks/cn/java/l-javainterface-abstract/)
+- [When to Use Abstract Class and Interface](https://dzone.com/articles/when-to-use-abstract-class-and-intreface)
+
+## super
+
+- 访问父类的构造函数：可以使用 super() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。
+- 访问父类的成员：如果子类重写了父类的某个方法，可以通过使用 super 关键字来引用父类的方法实现。
+
+```java
+public class SuperExample {
+
+ protected int x;
+ protected int y;
+
+ public SuperExample(int x, int y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ public void func() {
+ System.out.println("SuperExample.func()");
+ }
+}
+```
+
+```java
+public class SuperExtendExample extends SuperExample {
+
+ private int z;
+
+ public SuperExtendExample(int x, int y, int z) {
+ super(x, y);
+ this.z = z;
+ }
+
+ @Override
+ public void func() {
+ super.func();
+ System.out.println("SuperExtendExample.func()");
+ }
+}
+```
+
+```java
+SuperExample e = new SuperExtendExample(1, 2, 3);
+e.func();
+```
+
+```html
+SuperExample.func()
+SuperExtendExample.func()
+```
+
+[Using the Keyword super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)
+
+## 重写与重载
+
+**1. 重写（Override）**
+
+存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。
+
+为了满足里式替换原则，重写有有以下两个限制：
+
+- 子类方法的访问权限必须大于等于父类方法；
+- 子类方法的返回类型必须是父类方法返回类型或为其子类型。
+
+使用 @Override 注解，可以让编译器帮忙检查是否满足上面的两个限制条件。
+
+**2. 重载（Overload）**
+
+存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
+
+应该注意的是，返回值不同，其它都相同不算是重载。
+
+# 五、Object 通用方法
+
+## 概览
+
+```java
+
+public native int hashCode()
+
+public boolean equals(Object obj)
+
+protected native Object clone() throws CloneNotSupportedException
+
+public String toString()
+
+public final native Class getClass()
+
+protected void finalize() throws Throwable {}
+
+public final native void notify()
+
+public final native void notifyAll()
+
+public final native void wait(long timeout) throws InterruptedException
+
+public final void wait(long timeout, int nanos) throws InterruptedException
+
+public final void wait() throws InterruptedException
+```
+
+## equals()
+
+**1. 等价关系**
+
+Ⅰ 自反性
+
+```java
+x.equals(x); // true
+```
+
+Ⅱ 对称性
+
+```java
+x.equals(y) == y.equals(x); // true
+```
+
+Ⅲ 传递性
+
+```java
+if (x.equals(y) && y.equals(z))
+ x.equals(z); // true;
+```
+
+Ⅳ 一致性
+
+多次调用 equals() 方法结果不变
+
+```java
+x.equals(y) == x.equals(y); // true
+```
+
+Ⅴ 与 null 的比较
+
+对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
+
+```java
+x.equals(null); // false;
+```
+
+**2. 等价与相等**
+
+- 对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
+- 对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。
+
+```java
+Integer x = new Integer(1);
+Integer y = new Integer(1);
+System.out.println(x.equals(y)); // true
+System.out.println(x == y); // false
+```
+
+**3. 实现**
+
+- 检查是否为同一个对象的引用，如果是直接返回 true；
+- 检查是否是同一个类型，如果不是，直接返回 false；
+- 将 Object 对象进行转型；
+- 判断每个关键域是否相等。
+
+```java
+public class EqualExample {
+
+ private int x;
+ private int y;
+ private int z;
+
+ public EqualExample(int x, int y, int z) {
+ this.x = x;
+ this.y = y;
+ this.z = z;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+
+ EqualExample that = (EqualExample) o;
+
+ if (x != that.x) return false;
+ if (y != that.y) return false;
+ return z == that.z;
+ }
+}
+```
+
+## hashCode()
+
+hashCode() 返回散列值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。
+
+在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象散列值也相等。
+
+下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。我们希望将这两个对象当成一样的，只在集合中添加一个对象，但是因为 EqualExample 没有实现 hasCode() 方法，因此这两个对象的散列值是不同的，最终导致集合添加了两个等价的对象。
+
+```java
+EqualExample e1 = new EqualExample(1, 1, 1);
+EqualExample e2 = new EqualExample(1, 1, 1);
+System.out.println(e1.equals(e2)); // true
+HashSet set = new HashSet<>();
+set.add(e1);
+set.add(e2);
+System.out.println(set.size()); // 2
+```
+
+理想的散列函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来。可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。
+
+一个数与 31 相乘可以转换成移位和减法：`31*x == (x<<5)-x`，编译器会自动进行这个优化。
+
+```java
+@Override
+public int hashCode() {
+ int result = 17;
+ result = 31 * result + x;
+ result = 31 * result + y;
+ result = 31 * result + z;
+ return result;
+}
+```
+
+## toString()
+
+默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。
+
+```java
+public class ToStringExample {
+
+ private int number;
+
+ public ToStringExample(int number) {
+ this.number = number;
+ }
+}
+```
+
+```java
+ToStringExample example = new ToStringExample(123);
+System.out.println(example.toString());
+```
+
+```html
+ToStringExample@4554617c
+```
+
+## clone()
+
+**1. cloneable**
+
+clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。
+
+```java
+public class CloneExample {
+ private int a;
+ private int b;
+}
+```
+
+```java
+CloneExample e1 = new CloneExample();
+// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'
+```
+
+重写 clone() 得到以下实现：
+
+```java
+public class CloneExample {
+ private int a;
+ private int b;
+
+ @Override
+ public CloneExample clone() throws CloneNotSupportedException {
+ return (CloneExample)super.clone();
+ }
+}
+```
+
+```java
+CloneExample e1 = new CloneExample();
+try {
+ CloneExample e2 = e1.clone();
+} catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+}
+```
+
+```html
+java.lang.CloneNotSupportedException: CloneExample
+```
+
+以上抛出了 CloneNotSupportedException，这是因为 CloneExample 没有实现 Cloneable 接口。
+
+应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
+
+```java
+public class CloneExample implements Cloneable {
+ private int a;
+ private int b;
+
+ @Override
+ public Object clone() throws CloneNotSupportedException {
+ return super.clone();
+ }
+}
+```
+
+**2. 浅拷贝**
+
+拷贝对象和原始对象的引用类型引用同一个对象。
+
+```java
+public class ShallowCloneExample implements Cloneable {
+
+ private int[] arr;
+
+ public ShallowCloneExample() {
+ arr = new int[10];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
+
+ public void set(int index, int value) {
+ arr[index] = value;
+ }
+
+ public int get(int index) {
+ return arr[index];
+ }
+
+ @Override
+ protected ShallowCloneExample clone() throws CloneNotSupportedException {
+ return (ShallowCloneExample) super.clone();
+ }
+}
+```
+
+```java
+ShallowCloneExample e1 = new ShallowCloneExample();
+ShallowCloneExample e2 = null;
+try {
+ e2 = e1.clone();
+} catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+}
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 222
+```
+
+**3. 深拷贝**
+
+拷贝对象和原始对象的引用类型引用不同对象。
+
+```java
+public class DeepCloneExample implements Cloneable {
+
+ private int[] arr;
+
+ public DeepCloneExample() {
+ arr = new int[10];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
+
+ public void set(int index, int value) {
+ arr[index] = value;
+ }
+
+ public int get(int index) {
+ return arr[index];
+ }
+
+ @Override
+ protected DeepCloneExample clone() throws CloneNotSupportedException {
+ DeepCloneExample result = (DeepCloneExample) super.clone();
+ result.arr = new int[arr.length];
+ for (int i = 0; i < arr.length; i++) {
+ result.arr[i] = arr[i];
+ }
+ return result;
+ }
+}
+```
+
+```java
+DeepCloneExample e1 = new DeepCloneExample();
+DeepCloneExample e2 = null;
+try {
+ e2 = e1.clone();
+} catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+}
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 2
+```
+
+**4. clone() 的替代方案**
+
+使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
+
+```java
+public class CloneConstructorExample {
+
+ private int[] arr;
+
+ public CloneConstructorExample() {
+ arr = new int[10];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
+
+ public CloneConstructorExample(CloneConstructorExample original) {
+ arr = new int[original.arr.length];
+ for (int i = 0; i < original.arr.length; i++) {
+ arr[i] = original.arr[i];
+ }
+ }
+
+ public void set(int index, int value) {
+ arr[index] = value;
+ }
+
+ public int get(int index) {
+ return arr[index];
+ }
+}
+```
+
+```java
+CloneConstructorExample e1 = new CloneConstructorExample();
+CloneConstructorExample e2 = new CloneConstructorExample(e1);
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 2
+```
+
+# 六、关键字
+
+## final
+
+**1. 数据**
+
+声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。
+
+- 对于基本类型，final 使数值不变；
+- 对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。
+
+```java
+final int x = 1;
+// x = 2; // cannot assign value to final variable 'x'
+final A y = new A();
+y.a = 1;
+```
+
+**2. 方法**
+
+声明方法不能被子类重写。
+
+private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法。
+
+**3. 类**
+
+声明类不允许被继承。
+
+## static
+
+**1. 静态变量**
+
+- 静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。
+- 实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。
+
+```java
+public class A {
+
+ private int x; // 实例变量
+ private static int y; // 静态变量
+
+ public static void main(String[] args) {
+ // int x = A.x; // Non-static field 'x' cannot be referenced from a static context
+ A a = new A();
+ int x = a.x;
+ int y = A.y;
+ }
+}
+```
+
+**2. 静态方法**
+
+静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。
+
+```java
+public abstract class A {
+ public static void func1(){
+ }
+ // public abstract static void func2(); // Illegal combination of modifiers: 'abstract' and 'static'
+}
+```
+
+只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字。
+
+```java
+public class A {
+
+ private static int x;
+ private int y;
+
+ public static void func1(){
+ int a = x;
+ // int b = y; // Non-static field 'y' cannot be referenced from a static context
+ // int b = this.y; // 'A.this' cannot be referenced from a static context
+ }
+}
+```
+
+**3. 静态语句块**
+
+静态语句块在类初始化时运行一次。
+
+```java
+public class A {
+ static {
+ System.out.println("123");
+ }
+
+ public static void main(String[] args) {
+ A a1 = new A();
+ A a2 = new A();
+ }
+}
+```
+
+```html
+123
+```
+
+**4. 静态内部类**
+
+非静态内部类依赖于外部类的实例，而静态内部类不需要。
+
+```java
+public class OuterClass {
+
+ class InnerClass {
+ }
+
+ static class StaticInnerClass {
+ }
+
+ public static void main(String[] args) {
+ // InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
+ OuterClass outerClass = new OuterClass();
+ InnerClass innerClass = outerClass.new InnerClass();
+ StaticInnerClass staticInnerClass = new StaticInnerClass();
+ }
+}
+```
+
+静态内部类不能访问外部类的非静态的变量和方法。
+
+**5. 静态导包**
+
+在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。
+
+```java
+import static com.xxx.ClassName.*
+```
+
+**6. 初始化顺序**
+
+静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺序。
+
+```java
+public static String staticField = "静态变量";
+```
+
+```java
+static {
+ System.out.println("静态语句块");
+}
+```
+
+```java
+public String field = "实例变量";
+```
+
+```java
+{
+ System.out.println("普通语句块");
+}
+```
+
+最后才是构造函数的初始化。
+
+```java
+public InitialOrderTest() {
+ System.out.println("构造函数");
+}
+```
+
+存在继承的情况下，初始化顺序为：
+
+- 父类（静态变量、静态语句块）
+- 子类（静态变量、静态语句块）
+- 父类（实例变量、普通语句块）
+- 父类（构造函数）
+- 子类（实例变量、普通语句块）
+- 子类（构造函数）
+
+
+# 七、反射
+
+每个类都有一个 **Class** 对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。
+
+类加载相当于 Class 对象的加载，类在第一次使用时才动态加载到 JVM 中。也可以使用 `Class.forName("com.mysql.jdbc.Driver")` 这种方式来控制类的加载，该方法会返回一个 Class 对象。
+
+反射可以提供运行时的类信息，并且这个类可以在运行时才加载进来，甚至在编译时期该类的 .class 不存在也可以加载进来。
+
+Class 和 java.lang.reflect 一起对反射提供了支持，java.lang.reflect 类库主要包含了以下三个类：
+
+- **Field** ：可以使用 get() 和 set() 方法读取和修改 Field 对象关联的字段；
+- **Method** ：可以使用 invoke() 方法调用与 Method 对象关联的方法；
+- **Constructor** ：可以用 Constructor 创建新的对象。
+
+**反射的优点：**
+
+* **可扩展性** ：应用程序可以利用全限定名创建可扩展对象的实例，来使用来自外部的用户自定义类。
+* **类浏览器和可视化开发环境** ：一个类浏览器需要可以枚举类的成员。可视化开发环境（如 IDE）可以从利用反射中可用的类型信息中受益，以帮助程序员编写正确的代码。
+* **调试器和测试工具** ： 调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义，以确保一组测试中有较高的代码覆盖率。
+
+**反射的缺点：**
+
+尽管反射非常强大，但也不能滥用。如果一个功能可以不用反射完成，那么最好就不用。在我们使用反射技术时，下面几条内容应该牢记于心。
+
+* **性能开销** ：反射涉及了动态类型的解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
+
+* **安全限制** ：使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。
+
+* **内部暴露** ：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用，这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。
+
+
+- [Trail: The Reflection API](https://docs.oracle.com/javase/tutorial/reflect/index.html)
+- [深入解析 Java 反射（1）- 基础](http://www.sczyh30.com/posts/Java/java-reflection-1/)
+
+# 八、异常
+
+Throwable 可以用来表示任何可以作为异常抛出的类，分为两种： **Error** 和 **Exception**。其中 Error 用来表示 JVM 无法处理的错误，Exception 分为两种：
+
+- **受检异常** ：需要用 try...catch... 语句捕获并进行处理，并且可以从异常中恢复；
+- **非受检异常** ：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序崩溃并且无法恢复。
+
+ {
+ // T stands for "Type"
+ private T t;
+ public void set(T t) { this.t = t; }
+ public T get() { return t; }
+}
+```
+
+- [Java 泛型详解](http://www.importnew.com/24029.html)
+- [10 道 Java 泛型面试题](https://cloud.tencent.com/developer/article/1033693)
+
+# 十、注解
+
+Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。
+
+[注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
+
+# 十一、特性
+
+## Java 各版本的新特性
+
+**New highlights in Java SE 8**
+
+1. Lambda Expressions
+2. Pipelines and Streams
+3. Date and Time API
+4. Default Methods
+5. Type Annotations
+6. Nashhorn JavaScript Engine
+7. Concurrent Accumulators
+8. Parallel operations
+9. PermGen Error Removed
+
+**New highlights in Java SE 7**
+
+1. Strings in Switch Statement
+2. Type Inference for Generic Instance Creation
+3. Multiple Exception Handling
+4. Support for Dynamic Languages
+5. Try with Resources
+6. Java nio Package
+7. Binary Literals, Underscore in literals
+8. Diamond Syntax
+
+- [Difference between Java 1.8 and Java 1.7?](http://www.selfgrowth.com/articles/difference-between-java-18-and-java-17)
+- [Java 8 特性](http://www.importnew.com/19345.html)
+
+## Java 与 C++ 的区别
+
+- Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
+- Java 通过虚拟机从而实现跨平台特性，但是 C++ 依赖于特定的平台。
+- Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
+- Java 支持自动垃圾回收，而 C++ 需要手动回收。
+- Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
+- Java 不支持操作符重载，虽然可以对两个 String 对象执行加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
+- Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
+- Java 不支持条件编译，C++ 通过 #ifdef #ifndef 等预处理命令从而实现条件编译。
+
+[What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)
+
+## JRE or JDK
+
+- JRE is the JVM program, Java application need to run on JRE.
+- JDK is a superset of JRE, JRE + tools for developing java programs. e.g, it provides the compiler "javac"
+
+# 参考资料
+
+- Eckel B. Java 编程思想[M]. 机械工业出版社, 2002.
+- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
diff --git a/docs1/docs/notes/Java 容器.md b/docs1/docs/notes/Java 容器.md
new file mode 100644
index 00000000..dbd41edc
--- /dev/null
+++ b/docs1/docs/notes/Java 容器.md
@@ -0,0 +1,1193 @@
+
+* [一、概览](#一概览)
+ * [Collection](#collection)
+ * [Map](#map)
+* [二、容器中的设计模式](#二容器中的设计模式)
+ * [迭代器模式](#迭代器模式)
+ * [适配器模式](#适配器模式)
+* [三、源码分析](#三源码分析)
+ * [ArrayList](#arraylist)
+ * [Vector](#vector)
+ * [CopyOnWriteArrayList](#copyonwritearraylist)
+ * [LinkedList](#linkedlist)
+ * [HashMap](#hashmap)
+ * [ConcurrentHashMap](#concurrenthashmap)
+ * [LinkedHashMap](#linkedhashmap)
+ * [WeakHashMap](#weakhashmap)
+* [附录](#附录)
+* [参考资料](#参考资料)
+
+
+
+# 一、概览
+
+容器主要包括 Collection 和 Map 两种，Collection 存储着对象的集合，而 Map 存储着键值对（两个对象）的映射表。
+
+## Collection
+
+ list = new ArrayList<>();
+list.add("a");
+list.add("b");
+for (String item : list) {
+ System.out.println(item);
+}
+```
+
+## 适配器模式
+
+java.util.Arrays#asList() 可以把数组类型转换为 List 类型。
+
+```java
+@SafeVarargs
+public static List asList(T... a)
+```
+
+应该注意的是 asList() 的参数为泛型的变长参数，不能使用基本类型数组作为参数，只能使用相应的包装类型数组。
+
+```java
+Integer[] arr = {1, 2, 3};
+List list = Arrays.asList(arr);
+```
+
+也可以使用以下方式调用 asList()：
+
+```java
+List list = Arrays.asList(1, 2, 3);
+```
+
+# 三、源码分析
+
+如果没有特别说明，以下源码分析基于 JDK 1.8。
+
+在 IDEA 中 double shift 调出 Search EveryWhere，查找源码文件，找到之后就可以阅读源码。
+
+## ArrayList
+
+### 1. 概览
+
+实现了 RandomAccess 接口，因此支持随机访问。这是理所当然的，因为 ArrayList 是基于数组实现的。
+
+```java
+public class ArrayList extends AbstractList
+ implements List, RandomAccess, Cloneable, java.io.Serializable
+```
+
+数组的默认大小为 10。
+
+```java
+private static final int DEFAULT_CAPACITY = 10;
+```
+
+### 2. 扩容
+
+添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 `oldCapacity + (oldCapacity >> 1)`，也就是旧容量的 1.5 倍。
+
+扩容操作需要调用 `Arrays.copyOf()` 把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。
+
+```java
+public boolean add(E e) {
+ ensureCapacityInternal(size + 1); // Increments modCount!!
+ elementData[size++] = e;
+ return true;
+}
+
+private void ensureCapacityInternal(int minCapacity) {
+ if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
+ minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
+ }
+ ensureExplicitCapacity(minCapacity);
+}
+
+private void ensureExplicitCapacity(int minCapacity) {
+ modCount++;
+ // overflow-conscious code
+ if (minCapacity - elementData.length > 0)
+ grow(minCapacity);
+}
+
+private void grow(int minCapacity) {
+ // overflow-conscious code
+ int oldCapacity = elementData.length;
+ int newCapacity = oldCapacity + (oldCapacity >> 1);
+ if (newCapacity - minCapacity < 0)
+ newCapacity = minCapacity;
+ if (newCapacity - MAX_ARRAY_SIZE > 0)
+ newCapacity = hugeCapacity(minCapacity);
+ // minCapacity is usually close to size, so this is a win:
+ elementData = Arrays.copyOf(elementData, newCapacity);
+}
+```
+
+### 3. 删除元素
+
+需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，该操作的时间复杂度为 O(N)，可以看出 ArrayList 删除元素的代价是非常高的。
+
+```java
+public E remove(int index) {
+ rangeCheck(index);
+ modCount++;
+ E oldValue = elementData(index);
+ int numMoved = size - index - 1;
+ if (numMoved > 0)
+ System.arraycopy(elementData, index+1, elementData, index, numMoved);
+ elementData[--size] = null; // clear to let GC do its work
+ return oldValue;
+}
+```
+
+### 4. Fail-Fast
+
+modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。
+
+在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。
+
+```java
+private void writeObject(java.io.ObjectOutputStream s)
+ throws java.io.IOException{
+ // Write out element count, and any hidden stuff
+ int expectedModCount = modCount;
+ s.defaultWriteObject();
+
+ // Write out size as capacity for behavioural compatibility with clone()
+ s.writeInt(size);
+
+ // Write out all elements in the proper order.
+ for (int i=0; i 0) {
+ // be like clone(), allocate array based upon size not capacity
+ ensureCapacityInternal(size);
+
+ Object[] a = elementData;
+ // Read in all elements in the proper order.
+ for (int i=0; i= elementCount)
+ throw new ArrayIndexOutOfBoundsException(index);
+
+ return elementData(index);
+}
+```
+
+### 2. 与 ArrayList 的比较
+
+- Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
+- Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
+
+### 3. 替代方案
+
+可以使用 `Collections.synchronizedList();` 得到一个线程安全的 ArrayList。
+
+```java
+List list = new ArrayList<>();
+List synList = Collections.synchronizedList(list);
+```
+
+也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。
+
+```java
+List list = new CopyOnWriteArrayList<>();
+```
+
+## CopyOnWriteArrayList
+
+### 读写分离
+
+写操作在一个复制的数组上进行，读操作还是在原始数组中进行，读写分离，互不影响。
+
+写操作需要加锁，防止并发写入时导致写入数据丢失。
+
+写操作结束之后需要把原始数组指向新的复制数组。
+
+```java
+public boolean add(E e) {
+ final ReentrantLock lock = this.lock;
+ lock.lock();
+ try {
+ Object[] elements = getArray();
+ int len = elements.length;
+ Object[] newElements = Arrays.copyOf(elements, len + 1);
+ newElements[len] = e;
+ setArray(newElements);
+ return true;
+ } finally {
+ lock.unlock();
+ }
+}
+
+final void setArray(Object[] a) {
+ array = a;
+}
+```
+
+```java
+@SuppressWarnings("unchecked")
+private E get(Object[] a, int index) {
+ return (E) a[index];
+}
+```
+
+### 适用场景
+
+CopyOnWriteArrayList 在写操作的同时允许读操作，大大提高了读操作的性能，因此很适合读多写少的应用场景。
+
+但是 CopyOnWriteArrayList 有其缺陷：
+
+- 内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
+- 数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中。
+
+所以 CopyOnWriteArrayList 不适合内存敏感以及对实时性要求很高的场景。
+
+## LinkedList
+
+### 1. 概览
+
+基于双向链表实现，使用 Node 存储链表节点信息。
+
+```java
+private static class Node {
+ E item;
+ Node next;
+ Node prev;
+}
+```
+
+每个链表存储了 first 和 last 指针：
+
+```java
+transient Node first;
+transient Node last;
+```
+
+ implements Map.Entry {
+ final K key;
+ V value;
+ Entry next;
+ int hash;
+
+ Entry(int h, K k, V v, Entry n) {
+ value = v;
+ next = n;
+ key = k;
+ hash = h;
+ }
+
+ public final K getKey() {
+ return key;
+ }
+
+ public final V getValue() {
+ return value;
+ }
+
+ public final V setValue(V newValue) {
+ V oldValue = value;
+ value = newValue;
+ return oldValue;
+ }
+
+ public final boolean equals(Object o) {
+ if (!(o instanceof Map.Entry))
+ return false;
+ Map.Entry e = (Map.Entry)o;
+ Object k1 = getKey();
+ Object k2 = e.getKey();
+ if (k1 == k2 || (k1 != null && k1.equals(k2))) {
+ Object v1 = getValue();
+ Object v2 = e.getValue();
+ if (v1 == v2 || (v1 != null && v1.equals(v2)))
+ return true;
+ }
+ return false;
+ }
+
+ public final int hashCode() {
+ return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
+ }
+
+ public final String toString() {
+ return getKey() + "=" + getValue();
+ }
+}
+```
+
+### 2. 拉链法的工作原理
+
+```java
+HashMap map = new HashMap<>();
+map.put("K1", "V1");
+map.put("K2", "V2");
+map.put("K3", "V3");
+```
+
+- 新建一个 HashMap，默认大小为 16；
+- 插入 <K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3。
+- 插入 <K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6。
+- 插入 <K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 <K2,V2> 前面。
+
+应该注意到链表的插入是以头插法方式进行的，例如上面的 <K3,V3> 不是插在 <K2,V2> 后面，而是插入在链表头部。
+
+查找需要分成两步进行：
+
+- 计算键值对所在的桶；
+- 在链表上顺序查找，时间复杂度显然和链表的长度成正比。
+
+ e = table[i]; e != null; e = e.next) {
+ Object k;
+ if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
+ V oldValue = e.value;
+ e.value = value;
+ e.recordAccess(this);
+ return oldValue;
+ }
+ }
+
+ modCount++;
+ // 插入新键值对
+ addEntry(hash, key, value, i);
+ return null;
+}
+```
+
+HashMap 允许插入键为 null 的键值对。但是因为无法调用 null 的 hashCode() 方法，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。
+
+```java
+private V putForNullKey(V value) {
+ for (Entry e = table[0]; e != null; e = e.next) {
+ if (e.key == null) {
+ V oldValue = e.value;
+ e.value = value;
+ e.recordAccess(this);
+ return oldValue;
+ }
+ }
+ modCount++;
+ addEntry(0, null, value, 0);
+ return null;
+}
+```
+
+使用链表的头插法，也就是新的键值对插在链表的头部，而不是链表的尾部。
+
+```java
+void addEntry(int hash, K key, V value, int bucketIndex) {
+ if ((size >= threshold) && (null != table[bucketIndex])) {
+ resize(2 * table.length);
+ hash = (null != key) ? hash(key) : 0;
+ bucketIndex = indexFor(hash, table.length);
+ }
+
+ createEntry(hash, key, value, bucketIndex);
+}
+
+void createEntry(int hash, K key, V value, int bucketIndex) {
+ Entry e = table[bucketIndex];
+ // 头插法，链表头部指向新的键值对
+ table[bucketIndex] = new Entry<>(hash, key, value, e);
+ size++;
+}
+```
+
+```java
+Entry(int h, K k, V v, Entry n) {
+ value = v;
+ next = n;
+ key = k;
+ hash = h;
+}
+```
+
+### 4. 确定桶下标
+
+很多操作都需要先确定一个键值对所在的桶下标。
+
+```java
+int hash = hash(key);
+int i = indexFor(hash, table.length);
+```
+
+**4.1 计算 hash 值**
+
+```java
+final int hash(Object k) {
+ int h = hashSeed;
+ if (0 != h && k instanceof String) {
+ return sun.misc.Hashing.stringHash32((String) k);
+ }
+
+ h ^= k.hashCode();
+
+ // This function ensures that hashCodes that differ only by
+ // constant multiples at each bit position have a bounded
+ // number of collisions (approximately 8 at default load factor).
+ h ^= (h >>> 20) ^ (h >>> 12);
+ return h ^ (h >>> 7) ^ (h >>> 4);
+}
+```
+
+```java
+public final int hashCode() {
+ return Objects.hashCode(key) ^ Objects.hashCode(value);
+}
+```
+
+**4.2 取模**
+
+令 x = 1<<4，即 x 为 2 的 4 次方，它具有以下性质：
+
+```
+x : 00010000
+x-1 : 00001111
+```
+
+令一个数 y 与 x-1 做与运算，可以去除 y 位级表示的第 4 位以上数：
+
+```
+y : 10110010
+x-1 : 00001111
+y&(x-1) : 00000010
+```
+
+这个性质和 y 对 x 取模效果是一样的：
+
+```
+y : 10110010
+x : 00010000
+y%x : 00000010
+```
+
+我们知道，位运算的代价比求模运算小的多，因此在进行这种计算时用位运算的话能带来更高的性能。
+
+确定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，如果能保证 capacity 为 2 的 n 次方，那么就可以将这个操作转换为位运算。
+
+```java
+static int indexFor(int h, int length) {
+ return h & (length-1);
+}
+```
+
+### 5. 扩容-基本原理
+
+设 HashMap 的 table 长度为 M，需要存储的键值对数量为 N，如果哈希函数满足均匀性的要求，那么每条链表的长度大约为 N/M，因此平均查找次数的复杂度为 O(N/M)。
+
+为了让查找的成本降低，应该尽可能使得 N/M 尽可能小，因此需要保证 M 尽可能大，也就是说 table 要尽可能大。HashMap 采用动态扩容来根据当前的 N 值来调整 M 值，使得空间效率和时间效率都能得到保证。
+
+和扩容相关的参数主要有：capacity、size、threshold 和 load_factor。
+
+| 参数 | 含义 |
+| :--: | :-- |
+| capacity | table 的容量大小，默认为 16。需要注意的是 capacity 必须保证为 2 的 n 次方。|
+| size | 键值对数量。 |
+| threshold | size 的临界值，当 size 大于等于 threshold 就必须进行扩容操作。 |
+| loadFactor | 装载因子，table 能够使用的比例，threshold = capacity * loadFactor。|
+
+```java
+static final int DEFAULT_INITIAL_CAPACITY = 16;
+
+static final int MAXIMUM_CAPACITY = 1 << 30;
+
+static final float DEFAULT_LOAD_FACTOR = 0.75f;
+
+transient Entry[] table;
+
+transient int size;
+
+int threshold;
+
+final float loadFactor;
+
+transient int modCount;
+```
+
+从下面的添加元素代码中可以看出，当需要扩容时，令 capacity 为原来的两倍。
+
+```java
+void addEntry(int hash, K key, V value, int bucketIndex) {
+ Entry e = table[bucketIndex];
+ table[bucketIndex] = new Entry<>(hash, key, value, e);
+ if (size++ >= threshold)
+ resize(2 * table.length);
+}
+```
+
+扩容使用 resize() 实现，需要注意的是，扩容操作同样需要把 oldTable 的所有键值对重新插入 newTable 中，因此这一步是很费时的。
+
+```java
+void resize(int newCapacity) {
+ Entry[] oldTable = table;
+ int oldCapacity = oldTable.length;
+ if (oldCapacity == MAXIMUM_CAPACITY) {
+ threshold = Integer.MAX_VALUE;
+ return;
+ }
+ Entry[] newTable = new Entry[newCapacity];
+ transfer(newTable);
+ table = newTable;
+ threshold = (int)(newCapacity * loadFactor);
+}
+
+void transfer(Entry[] newTable) {
+ Entry[] src = table;
+ int newCapacity = newTable.length;
+ for (int j = 0; j < src.length; j++) {
+ Entry e = src[j];
+ if (e != null) {
+ src[j] = null;
+ do {
+ Entry next = e.next;
+ int i = indexFor(e.hash, newCapacity);
+ e.next = newTable[i];
+ newTable[i] = e;
+ e = next;
+ } while (e != null);
+ }
+ }
+}
+```
+
+### 6. 扩容-重新计算桶下标
+
+在进行扩容时，需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作。
+
+假设原数组长度 capacity 为 16，扩容之后 new capacity 为 32：
+
+```html
+capacity : 00010000
+new capacity : 00100000
+```
+
+对于一个 Key，
+
+- 它的哈希值如果在第 5 位上为 0，那么取模得到的结果和之前一样；
+- 如果为 1，那么得到的结果为原来的结果 +16。
+
+### 7. 计算数组容量
+
+HashMap 构造函数允许用户传入的容量不是 2 的 n 次方，因为它可以自动地将传入的容量转换为 2 的 n 次方。
+
+先考虑如何求一个数的掩码，对于 10010000，它的掩码为 11111111，可以使用以下方法得到：
+
+```
+mask |= mask >> 1 11011000
+mask |= mask >> 2 11111110
+mask |= mask >> 4 11111111
+```
+
+mask+1 是大于原始数字的最小的 2 的 n 次方。
+
+```
+num 10010000
+mask+1 100000000
+```
+
+以下是 HashMap 中计算数组容量的代码：
+
+```java
+static final int tableSizeFor(int cap) {
+ int n = cap - 1;
+ n |= n >>> 1;
+ n |= n >>> 2;
+ n |= n >>> 4;
+ n |= n >>> 8;
+ n |= n >>> 16;
+ return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
+}
+```
+
+### 8. 链表转红黑树
+
+从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树。
+
+### 9. 与 HashTable 的比较
+
+- HashTable 使用 synchronized 来进行同步。
+- HashMap 可以插入键为 null 的 Entry。
+- HashMap 的迭代器是 fail-fast 迭代器。
+- HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
+
+## ConcurrentHashMap
+
+### 1. 存储结构
+
+```java
+static final class HashEntry {
+ final int hash;
+ final K key;
+ volatile V value;
+ volatile HashEntry next;
+}
+```
+
+ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。
+
+Segment 继承自 ReentrantLock。
+
+```java
+static final class Segment extends ReentrantLock implements Serializable {
+
+ private static final long serialVersionUID = 2249069246763182397L;
+
+ static final int MAX_SCAN_RETRIES =
+ Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
+
+ transient volatile HashEntry[] table;
+
+ transient int count;
+
+ transient int modCount;
+
+ transient int threshold;
+
+ final float loadFactor;
+}
+```
+
+```java
+final Segment[] segments;
+```
+
+默认的并发级别为 16，也就是说默认创建 16 个 Segment。
+
+```java
+static final int DEFAULT_CONCURRENCY_LEVEL = 16;
+```
+
+ [] segments = this.segments;
+ int size;
+ boolean overflow; // true if size overflows 32 bits
+ long sum; // sum of modCounts
+ long last = 0L; // previous sum
+ int retries = -1; // first iteration isn't retry
+ try {
+ for (;;) {
+ // 超过尝试次数，则对每个 Segment 加锁
+ if (retries++ == RETRIES_BEFORE_LOCK) {
+ for (int j = 0; j < segments.length; ++j)
+ ensureSegment(j).lock(); // force creation
+ }
+ sum = 0L;
+ size = 0;
+ overflow = false;
+ for (int j = 0; j < segments.length; ++j) {
+ Segment seg = segmentAt(segments, j);
+ if (seg != null) {
+ sum += seg.modCount;
+ int c = seg.count;
+ if (c < 0 || (size += c) < 0)
+ overflow = true;
+ }
+ }
+ // 连续两次得到的结果一致，则认为这个结果是正确的
+ if (sum == last)
+ break;
+ last = sum;
+ }
+ } finally {
+ if (retries > RETRIES_BEFORE_LOCK) {
+ for (int j = 0; j < segments.length; ++j)
+ segmentAt(segments, j).unlock();
+ }
+ }
+ return overflow ? Integer.MAX_VALUE : size;
+}
+```
+
+### 3. JDK 1.8 的改动
+
+JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发度与 Segment 数量相等。
+
+JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。
+
+并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。
+
+## LinkedHashMap
+
+### 存储结构
+
+继承自 HashMap，因此具有和 HashMap 一样的快速查找特性。
+
+```java
+public class LinkedHashMap extends HashMap implements Map
+```
+
+内部维护了一个双向链表，用来维护插入顺序或者 LRU 顺序。
+
+```java
+/**
+ * The head (eldest) of the doubly linked list.
+ */
+transient LinkedHashMap.Entry head;
+
+/**
+ * The tail (youngest) of the doubly linked list.
+ */
+transient LinkedHashMap.Entry tail;
+```
+
+accessOrder 决定了顺序，默认为 false，此时维护的是插入顺序。
+
+```java
+final boolean accessOrder;
+```
+
+LinkedHashMap 最重要的是以下用于维护顺序的函数，它们会在 put、get 等方法中调用。
+
+```java
+void afterNodeAccess(Node p) { }
+void afterNodeInsertion(boolean evict) { }
+```
+
+### afterNodeAccess()
+
+当一个节点被访问时，如果 accessOrder 为 true，则会将该节点移到链表尾部。也就是说指定为 LRU 顺序之后，在每次访问一个节点时，会将这个节点移到链表尾部，保证链表尾部是最近访问的节点，那么链表首部就是最近最久未使用的节点。
+
+```java
+void afterNodeAccess(Node e) { // move node to last
+ LinkedHashMap.Entry last;
+ if (accessOrder && (last = tail) != e) {
+ LinkedHashMap.Entry p =
+ (LinkedHashMap.Entry)e, b = p.before, a = p.after;
+ p.after = null;
+ if (b == null)
+ head = a;
+ else
+ b.after = a;
+ if (a != null)
+ a.before = b;
+ else
+ last = b;
+ if (last == null)
+ head = p;
+ else {
+ p.before = last;
+ last.after = p;
+ }
+ tail = p;
+ ++modCount;
+ }
+}
+```
+
+### afterNodeInsertion()
+
+在 put 等操作之后执行，当 removeEldestEntry() 方法返回 true 时会移除最晚的节点，也就是链表首部节点 first。
+
+evict 只有在构建 Map 的时候才为 false，在这里为 true。
+
+```java
+void afterNodeInsertion(boolean evict) { // possibly remove eldest
+ LinkedHashMap.Entry first;
+ if (evict && (first = head) != null && removeEldestEntry(first)) {
+ K key = first.key;
+ removeNode(hash(key), key, null, false, true);
+ }
+}
+```
+
+removeEldestEntry() 默认为 false，如果需要让它为 true，需要继承 LinkedHashMap 并且覆盖这个方法的实现，这在实现 LRU 的缓存中特别有用，通过移除最近最久未使用的节点，从而保证缓存空间足够，并且缓存的数据都是热点数据。
+
+```java
+protected boolean removeEldestEntry(Map.Entry eldest) {
+ return false;
+}
+```
+
+### LRU 缓存
+
+以下是使用 LinkedHashMap 实现的一个 LRU 缓存：
+
+- 设定最大缓存空间 MAX_ENTRIES 为 3；
+- 使用 LinkedHashMap 的构造函数将 accessOrder 设置为 true，开启 LRU 顺序；
+- 覆盖 removeEldestEntry() 方法实现，在节点多于 MAX_ENTRIES 就会将最近最久未使用的数据移除。
+
+```java
+class LRUCache extends LinkedHashMap {
+ private static final int MAX_ENTRIES = 3;
+
+ protected boolean removeEldestEntry(Map.Entry eldest) {
+ return size() > MAX_ENTRIES;
+ }
+
+ LRUCache() {
+ super(MAX_ENTRIES, 0.75f, true);
+ }
+}
+```
+
+```java
+public static void main(String[] args) {
+ LRUCache cache = new LRUCache<>();
+ cache.put(1, "a");
+ cache.put(2, "b");
+ cache.put(3, "c");
+ cache.get(1);
+ cache.put(4, "d");
+ System.out.println(cache.keySet());
+}
+```
+
+```html
+[3, 1, 4]
+```
+
+## WeakHashMap
+
+### 存储结构
+
+WeakHashMap 的 Entry 继承自 WeakReference，被 WeakReference 关联的对象在下一次垃圾回收时会被回收。
+
+WeakHashMap 主要用来实现缓存，通过使用 WeakHashMap 来引用缓存对象，由 JVM 对这部分缓存进行回收。
+
+```java
+private static class Entry extends WeakReference implements Map.Entry
+```
+
+### ConcurrentCache
+
+Tomcat 中的 ConcurrentCache 使用了 WeakHashMap 来实现缓存功能。
+
+ConcurrentCache 采取的是分代缓存：
+
+- 经常使用的对象放入 eden 中，eden 使用 ConcurrentHashMap 实现，不用担心会被回收（伊甸园）；
+- 不常用的对象放入 longterm，longterm 使用 WeakHashMap 实现，这些老对象会被垃圾收集器回收。
+- 当调用 get() 方法时，会先从 eden 区获取，如果没有找到的话再到 longterm 获取，当从 longterm 获取到就把对象放入 eden 中，从而保证经常被访问的节点不容易被回收。
+- 当调用 put() 方法时，如果 eden 的大小超过了 size，那么就将 eden 中的所有对象都放入 longterm 中，利用虚拟机回收掉一部分不经常使用的对象。
+
+```java
+public final class ConcurrentCache {
+
+ private final int size;
+
+ private final Map eden;
+
+ private final Map longterm;
+
+ public ConcurrentCache(int size) {
+ this.size = size;
+ this.eden = new ConcurrentHashMap<>(size);
+ this.longterm = new WeakHashMap<>(size);
+ }
+
+ public V get(K k) {
+ V v = this.eden.get(k);
+ if (v == null) {
+ v = this.longterm.get(k);
+ if (v != null)
+ this.eden.put(k, v);
+ }
+ return v;
+ }
+
+ public void put(K k, V v) {
+ if (this.eden.size() >= size) {
+ this.longterm.putAll(this.eden);
+ this.eden.clear();
+ }
+ this.eden.put(k, v);
+ }
+}
+```
+
+# 附录
+
+Collection 绘图源码：
+
+```
+@startuml
+
+interface Collection
+interface Set
+interface List
+interface Queue
+interface SortSet
+
+class HashSet
+class LinkedHashSet
+class TreeSet
+class ArrayList
+class Vector
+class LinkedList
+class PriorityQueue
+
+
+Collection <|-- Set
+Collection <|-- List
+Collection <|-- Queue
+Set <|-- SortSet
+
+Set <|.. HashSet
+Set <|.. LinkedHashSet
+SortSet <|.. TreeSet
+List <|.. ArrayList
+List <|.. Vector
+List <|.. LinkedList
+Queue <|.. LinkedList
+Queue <|.. PriorityQueue
+
+@enduml
+```
+
+Map 绘图源码
+
+```
+@startuml
+
+interface Map
+interface SortMap
+
+class HashTable
+class LinkedHashMap
+class HashMap
+class TreeMap
+
+Map <|.. HashTable
+Map <|.. LinkedHashMap
+Map <|.. HashMap
+Map <|-- SortMap
+SortMap <|.. TreeMap
+
+@enduml
+```
+
+迭代器类图
+
+```
+@startuml
+
+interface Iterable
+interface Collection
+interface List
+interface Set
+interface Queue
+interface Iterator
+interface ListIterator
+
+Iterable <|-- Collection
+Collection <|.. List
+Collection <|.. Set
+Collection <|-- Queue
+Iterator <-- Iterable
+Iterator <|.. ListIterator
+ListIterator <-- List
+
+@enduml
+```
+
+# 参考资料
+
+- Eckel B. Java 编程思想 [M]. 机械工业出版社, 2002.
+- [Java Collection Framework](https://www.w3resource.com/java-tutorial/java-collections.php)
+- [Iterator 模式](https://openhome.cc/Gossip/DesignPattern/IteratorPattern.htm)
+- [Java 8 系列之重新认识 HashMap](https://tech.meituan.com/java_hashmap.html)
+- [What is difference between HashMap and Hashtable in Java?](http://javarevisited.blogspot.hk/2010/10/difference-between-hashmap-and.html)
+- [Java 集合之 HashMap](http://www.zhangchangle.com/2018/02/07/Java%E9%9B%86%E5%90%88%E4%B9%8BHashMap/)
+- [The principle of ConcurrentHashMap analysis](http://www.programering.com/a/MDO3QDNwATM.html)
+- [探索 ConcurrentHashMap 高并发性的实现机制](https://www.ibm.com/developerworks/cn/java/java-lo-concurrenthashmap/)
+- [HashMap 相关面试题及其解答](https://www.jianshu.com/p/75adf47958a7)
+- [Java 集合细节（二）：asList 的缺陷](http://wiki.jikexueyuan.com/project/java-enhancement/java-thirtysix.html)
+- [Java Collection Framework – The LinkedList Class](http://javaconceptoftheday.com/java-collection-framework-linkedlist-class/)
+
diff --git a/docs1/docs/notes/Java 并发.md b/docs1/docs/notes/Java 并发.md
new file mode 100644
index 00000000..024f6636
--- /dev/null
+++ b/docs1/docs/notes/Java 并发.md
@@ -0,0 +1,1638 @@
+
+* [一、线程状态转换](#一线程状态转换)
+ * [新建（New）](#新建new)
+ * [可运行（Runnable）](#可运行runnable)
+ * [阻塞（Blocking）](#阻塞blocking)
+ * [无限期等待（Waiting）](#无限期等待waiting)
+ * [限期等待（Timed Waiting）](#限期等待timed-waiting)
+ * [死亡（Terminated）](#死亡terminated)
+* [二、使用线程](#二使用线程)
+ * [实现 Runnable 接口](#实现-runnable-接口)
+ * [实现 Callable 接口](#实现-callable-接口)
+ * [继承 Thread 类](#继承-thread-类)
+ * [实现接口 VS 继承 Thread](#实现接口-vs-继承-thread)
+* [三、基础线程机制](#三基础线程机制)
+ * [Executor](#executor)
+ * [Daemon](#daemon)
+ * [sleep()](#sleep)
+ * [yield()](#yield)
+* [四、中断](#四中断)
+ * [InterruptedException](#interruptedexception)
+ * [interrupted()](#interrupted)
+ * [Executor 的中断操作](#executor-的中断操作)
+* [五、互斥同步](#五互斥同步)
+ * [synchronized](#synchronized)
+ * [ReentrantLock](#reentrantlock)
+ * [比较](#比较)
+ * [使用选择](#使用选择)
+* [六、线程之间的协作](#六线程之间的协作)
+ * [join()](#join)
+ * [wait() notify() notifyAll()](#wait-notify-notifyall)
+ * [await() signal() signalAll()](#await-signal-signalall)
+* [七、J.U.C - AQS](#七juc---aqs)
+ * [CountdownLatch](#countdownlatch)
+ * [CyclicBarrier](#cyclicbarrier)
+ * [Semaphore](#semaphore)
+* [八、J.U.C - 其它组件](#八juc---其它组件)
+ * [FutureTask](#futuretask)
+ * [BlockingQueue](#blockingqueue)
+ * [ForkJoin](#forkjoin)
+* [九、线程不安全示例](#九线程不安全示例)
+* [十、Java 内存模型](#十java-内存模型)
+ * [主内存与工作内存](#主内存与工作内存)
+ * [内存间交互操作](#内存间交互操作)
+ * [内存模型三大特性](#内存模型三大特性)
+ * [先行发生原则](#先行发生原则)
+* [十一、线程安全](#十一线程安全)
+ * [不可变](#不可变)
+ * [互斥同步](#互斥同步)
+ * [非阻塞同步](#非阻塞同步)
+ * [无同步方案](#无同步方案)
+* [十二、锁优化](#十二锁优化)
+ * [自旋锁](#自旋锁)
+ * [锁消除](#锁消除)
+ * [锁粗化](#锁粗化)
+ * [轻量级锁](#轻量级锁)
+ * [偏向锁](#偏向锁)
+* [十三、多线程开发良好的实践](#十三多线程开发良好的实践)
+* [参考资料](#参考资料)
+
+
+
+# 一、线程状态转换
+
+ {
+ public Integer call() {
+ return 123;
+ }
+}
+```
+
+```java
+public static void main(String[] args) throws ExecutionException, InterruptedException {
+ MyCallable mc = new MyCallable();
+ FutureTask ft = new FutureTask<>(mc);
+ Thread thread = new Thread(ft);
+ thread.start();
+ System.out.println(ft.get());
+}
+```
+
+## 继承 Thread 类
+
+同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。
+
+当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。
+
+```java
+public class MyThread extends Thread {
+ public void run() {
+ // ...
+ }
+}
+```
+
+```java
+public static void main(String[] args) {
+ MyThread mt = new MyThread();
+ mt.start();
+}
+```
+
+## 实现接口 VS 继承 Thread
+
+实现接口会更好一些，因为：
+
+- Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
+- 类可能只要求可执行就行，继承整个 Thread 类开销过大。
+
+# 三、基础线程机制
+
+## Executor
+
+Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。
+
+主要有三种 Executor：
+
+- CachedThreadPool：一个任务创建一个线程；
+- FixedThreadPool：所有任务只能使用固定大小的线程；
+- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
+
+```java
+public static void main(String[] args) {
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ for (int i = 0; i < 5; i++) {
+ executorService.execute(new MyRunnable());
+ }
+ executorService.shutdown();
+}
+```
+
+## Daemon
+
+守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分。
+
+当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。
+
+main() 属于非守护线程。
+
+使用 setDaemon() 方法将一个线程设置为守护线程。
+
+```java
+public static void main(String[] args) {
+ Thread thread = new Thread(new MyRunnable());
+ thread.setDaemon(true);
+}
+```
+
+## sleep()
+
+Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
+
+sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
+
+```java
+public void run() {
+ try {
+ Thread.sleep(3000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+}
+```
+
+## yield()
+
+对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。
+
+```java
+public void run() {
+ Thread.yield();
+}
+```
+
+# 四、中断
+
+一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。
+
+## InterruptedException
+
+通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
+
+对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。
+
+```java
+public class InterruptExample {
+
+ private static class MyThread1 extends Thread {
+ @Override
+ public void run() {
+ try {
+ Thread.sleep(2000);
+ System.out.println("Thread run");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+}
+```
+
+```java
+public static void main(String[] args) throws InterruptedException {
+ Thread thread1 = new MyThread1();
+ thread1.start();
+ thread1.interrupt();
+ System.out.println("Main run");
+}
+```
+
+```html
+Main run
+java.lang.InterruptedException: sleep interrupted
+ at java.lang.Thread.sleep(Native Method)
+ at InterruptExample.lambda$main$0(InterruptExample.java:5)
+ at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
+ at java.lang.Thread.run(Thread.java:745)
+```
+
+## interrupted()
+
+如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。
+
+但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
+
+```java
+public class InterruptExample {
+
+ private static class MyThread2 extends Thread {
+ @Override
+ public void run() {
+ while (!interrupted()) {
+ // ..
+ }
+ System.out.println("Thread end");
+ }
+ }
+}
+```
+
+```java
+public static void main(String[] args) throws InterruptedException {
+ Thread thread2 = new MyThread2();
+ thread2.start();
+ thread2.interrupt();
+}
+```
+
+```html
+Thread end
+```
+
+## Executor 的中断操作
+
+调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。
+
+以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。
+
+```java
+public static void main(String[] args) {
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> {
+ try {
+ Thread.sleep(2000);
+ System.out.println("Thread run");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ });
+ executorService.shutdownNow();
+ System.out.println("Main run");
+}
+```
+
+```html
+Main run
+java.lang.InterruptedException: sleep interrupted
+ at java.lang.Thread.sleep(Native Method)
+ at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
+ at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
+ at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
+ at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
+ at java.lang.Thread.run(Thread.java:745)
+```
+
+如果只想中断 Executor 中的一个线程，可以通过使用 submit() 方法来提交一个线程，它会返回一个 Future 对象，通过调用该对象的 cancel(true) 方法就可以中断线程。
+
+```java
+Future future = executorService.submit(() -> {
+ // ..
+});
+future.cancel(true);
+```
+
+# 五、互斥同步
+
+Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。
+
+## synchronized
+
+**1. 同步一个代码块**
+
+```java
+public void func() {
+ synchronized (this) {
+ // ...
+ }
+}
+```
+
+它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。
+
+对于以下代码，使用 ExecutorService 执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。
+
+```java
+public class SynchronizedExample {
+
+ public void func1() {
+ synchronized (this) {
+ for (int i = 0; i < 10; i++) {
+ System.out.print(i + " ");
+ }
+ }
+ }
+}
+```
+
+```java
+public static void main(String[] args) {
+ SynchronizedExample e1 = new SynchronizedExample();
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> e1.func1());
+ executorService.execute(() -> e1.func1());
+}
+```
+
+```html
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+```
+
+对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。
+
+```java
+public static void main(String[] args) {
+ SynchronizedExample e1 = new SynchronizedExample();
+ SynchronizedExample e2 = new SynchronizedExample();
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> e1.func1());
+ executorService.execute(() -> e2.func1());
+}
+```
+
+```html
+0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
+```
+
+
+**2. 同步一个方法**
+
+```java
+public synchronized void func () {
+ // ...
+}
+```
+
+它和同步代码块一样，作用于同一个对象。
+
+**3. 同步一个类**
+
+```java
+public void func() {
+ synchronized (SynchronizedExample.class) {
+ // ...
+ }
+}
+```
+
+作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。
+
+```java
+public class SynchronizedExample {
+
+ public void func2() {
+ synchronized (SynchronizedExample.class) {
+ for (int i = 0; i < 10; i++) {
+ System.out.print(i + " ");
+ }
+ }
+ }
+}
+```
+
+```java
+public static void main(String[] args) {
+ SynchronizedExample e1 = new SynchronizedExample();
+ SynchronizedExample e2 = new SynchronizedExample();
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> e1.func2());
+ executorService.execute(() -> e2.func2());
+}
+```
+
+```html
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+```
+
+**4. 同步一个静态方法**
+
+```java
+public synchronized static void fun() {
+ // ...
+}
+```
+
+作用于整个类。
+
+## ReentrantLock
+
+ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。
+
+```java
+public class LockExample {
+
+ private Lock lock = new ReentrantLock();
+
+ public void func() {
+ lock.lock();
+ try {
+ for (int i = 0; i < 10; i++) {
+ System.out.print(i + " ");
+ }
+ } finally {
+ lock.unlock(); // 确保释放锁，从而避免发生死锁。
+ }
+ }
+}
+```
+
+```java
+public static void main(String[] args) {
+ LockExample lockExample = new LockExample();
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> lockExample.func());
+ executorService.execute(() -> lockExample.func());
+}
+```
+
+```html
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+```
+
+
+## 比较
+
+**1. 锁的实现**
+
+synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
+
+**2. 性能**
+
+新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
+
+**3. 等待可中断**
+
+当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
+
+ReentrantLock 可中断，而 synchronized 不行。
+
+**4. 公平锁**
+
+公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
+
+synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
+
+**5. 锁绑定多个条件**
+
+一个 ReentrantLock 可以同时绑定多个 Condition 对象。
+
+## 使用选择
+
+除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。
+
+# 六、线程之间的协作
+
+当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。
+
+## join()
+
+在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。
+
+对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。
+
+```java
+public class JoinExample {
+
+ private class A extends Thread {
+ @Override
+ public void run() {
+ System.out.println("A");
+ }
+ }
+
+ private class B extends Thread {
+
+ private A a;
+
+ B(A a) {
+ this.a = a;
+ }
+
+ @Override
+ public void run() {
+ try {
+ a.join();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.println("B");
+ }
+ }
+
+ public void test() {
+ A a = new A();
+ B b = new B(a);
+ b.start();
+ a.start();
+ }
+}
+```
+
+```java
+public static void main(String[] args) {
+ JoinExample example = new JoinExample();
+ example.test();
+}
+```
+
+```
+A
+B
+```
+
+## wait() notify() notifyAll()
+
+调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。
+
+它们都属于 Object 的一部分，而不属于 Thread。
+
+只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateException。
+
+使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。
+
+```java
+public class WaitNotifyExample {
+
+ public synchronized void before() {
+ System.out.println("before");
+ notifyAll();
+ }
+
+ public synchronized void after() {
+ try {
+ wait();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.println("after");
+ }
+}
+```
+
+```java
+public static void main(String[] args) {
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ WaitNotifyExample example = new WaitNotifyExample();
+ executorService.execute(() -> example.after());
+ executorService.execute(() -> example.before());
+}
+```
+
+```html
+before
+after
+```
+
+**wait() 和 sleep() 的区别**
+
+- wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
+- wait() 会释放锁，sleep() 不会。
+
+## await() signal() signalAll()
+
+java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。
+
+相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。
+
+使用 Lock 来获取一个 Condition 对象。
+
+```java
+public class AwaitSignalExample {
+
+ private Lock lock = new ReentrantLock();
+ private Condition condition = lock.newCondition();
+
+ public void before() {
+ lock.lock();
+ try {
+ System.out.println("before");
+ condition.signalAll();
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ public void after() {
+ lock.lock();
+ try {
+ condition.await();
+ System.out.println("after");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ } finally {
+ lock.unlock();
+ }
+ }
+}
+```
+
+```java
+public static void main(String[] args) {
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ AwaitSignalExample example = new AwaitSignalExample();
+ executorService.execute(() -> example.after());
+ executorService.execute(() -> example.before());
+}
+```
+
+```html
+before
+after
+```
+
+# 七、J.U.C - AQS
+
+java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.U.C 的核心。
+
+## CountdownLatch
+
+用来控制一个线程等待多个线程。
+
+维护了一个计数器 cnt，每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await() 方法而在等待的线程就会被唤醒。
+
+ 进行封装。FutureTask 实现了 RunnableFuture 接口，该接口继承自 Runnable 和 Future 接口，这使得 FutureTask 既可以当做一个任务执行，也可以有返回值。
+
+```java
+public class FutureTask implements RunnableFuture
+```
+
+```java
+public interface RunnableFuture extends Runnable, Future
+```
+
+FutureTask 可用于异步获取执行结果或取消执行任务的场景。当一个计算任务需要执行很长时间，那么就可以用 FutureTask 来封装这个任务，主线程在完成自己的任务之后再去获取结果。
+
+```java
+public class FutureTaskExample {
+
+ public static void main(String[] args) throws ExecutionException, InterruptedException {
+ FutureTask futureTask = new FutureTask(new Callable() {
+ @Override
+ public Integer call() throws Exception {
+ int result = 0;
+ for (int i = 0; i < 100; i++) {
+ Thread.sleep(10);
+ result += i;
+ }
+ return result;
+ }
+ });
+
+ Thread computeThread = new Thread(futureTask);
+ computeThread.start();
+
+ Thread otherThread = new Thread(() -> {
+ System.out.println("other task is running...");
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ });
+ otherThread.start();
+ System.out.println(futureTask.get());
+ }
+}
+```
+
+```html
+other task is running...
+4950
+```
+
+## BlockingQueue
+
+java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
+
+- **FIFO 队列** ：LinkedBlockingQueue、ArrayBlockingQueue（固定长度）
+- **优先级队列** ：PriorityBlockingQueue
+
+提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，直到队列有空闲位置。
+
+**使用 BlockingQueue 实现生产者消费者问题**
+
+```java
+public class ProducerConsumer {
+
+ private static BlockingQueue queue = new ArrayBlockingQueue<>(5);
+
+ private static class Producer extends Thread {
+ @Override
+ public void run() {
+ try {
+ queue.put("product");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.print("produce..");
+ }
+ }
+
+ private static class Consumer extends Thread {
+
+ @Override
+ public void run() {
+ try {
+ String product = queue.take();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.print("consume..");
+ }
+ }
+}
+```
+
+```java
+public static void main(String[] args) {
+ for (int i = 0; i < 2; i++) {
+ Producer producer = new Producer();
+ producer.start();
+ }
+ for (int i = 0; i < 5; i++) {
+ Consumer consumer = new Consumer();
+ consumer.start();
+ }
+ for (int i = 0; i < 3; i++) {
+ Producer producer = new Producer();
+ producer.start();
+ }
+}
+```
+
+```html
+produce..produce..consume..consume..produce..consume..produce..consume..produce..consume..
+```
+
+## ForkJoin
+
+主要用于并行计算中，和 MapReduce 原理类似，都是把大的计算任务拆分成多个小任务并行计算。
+
+```java
+public class ForkJoinExample extends RecursiveTask {
+
+ private final int threshold = 5;
+ private int first;
+ private int last;
+
+ public ForkJoinExample(int first, int last) {
+ this.first = first;
+ this.last = last;
+ }
+
+ @Override
+ protected Integer compute() {
+ int result = 0;
+ if (last - first <= threshold) {
+ // 任务足够小则直接计算
+ for (int i = first; i <= last; i++) {
+ result += i;
+ }
+ } else {
+ // 拆分成小任务
+ int middle = first + (last - first) / 2;
+ ForkJoinExample leftTask = new ForkJoinExample(first, middle);
+ ForkJoinExample rightTask = new ForkJoinExample(middle + 1, last);
+ leftTask.fork();
+ rightTask.fork();
+ result = leftTask.join() + rightTask.join();
+ }
+ return result;
+ }
+}
+```
+
+```java
+public static void main(String[] args) throws ExecutionException, InterruptedException {
+ ForkJoinExample example = new ForkJoinExample(1, 10000);
+ ForkJoinPool forkJoinPool = new ForkJoinPool();
+ Future result = forkJoinPool.submit(example);
+ System.out.println(result.get());
+}
+```
+
+ForkJoin 使用 ForkJoinPool 来启动，它是一个特殊的线程池，线程数量取决于 CPU 核数。
+
+```java
+public class ForkJoinPool extends AbstractExecutorService
+```
+
+ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，Thread2 从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。
+
+ map = new HashMap<>();
+ Map unmodifiableMap = Collections.unmodifiableMap(map);
+ unmodifiableMap.put("a", 1);
+ }
+}
+```
+
+```html
+Exception in thread "main" java.lang.UnsupportedOperationException
+ at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)
+ at ImmutableExample.main(ImmutableExample.java:9)
+```
+
+Collections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都直接抛出异常。
+
+```java
+public V put(K key, V value) {
+ throw new UnsupportedOperationException();
+}
+```
+
+## 互斥同步
+
+synchronized 和 ReentrantLock。
+
+## 非阻塞同步
+
+互斥同步最主要的问题就是线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。
+
+互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
+
+### 1. CAS
+
+随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要将线程阻塞，因此这种同步操作称为非阻塞同步。
+
+乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
+
+### 2. AtomicInteger
+
+J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。
+
+以下代码使用了 AtomicInteger 执行了自增的操作。
+
+```java
+private AtomicInteger cnt = new AtomicInteger();
+
+public void add() {
+ cnt.incrementAndGet();
+}
+```
+
+以下代码是 incrementAndGet() 的源码，它调用了 Unsafe 的 getAndAddInt() 。
+
+```java
+public final int incrementAndGet() {
+ return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
+}
+```
+
+以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
+
+可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。
+
+```java
+public final int getAndAddInt(Object var1, long var2, int var4) {
+ int var5;
+ do {
+ var5 = this.getIntVolatile(var1, var2);
+ } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
+
+ return var5;
+}
+```
+
+### 3. ABA
+
+如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
+
+J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
+
+## 无同步方案
+
+要保证线程安全，并不是一定就要进行同步。如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性。
+
+### 1. 栈封闭
+
+多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的。
+
+```java
+public class StackClosedExample {
+ public void add100() {
+ int cnt = 0;
+ for (int i = 0; i < 100; i++) {
+ cnt++;
+ }
+ System.out.println(cnt);
+ }
+}
+```
+
+```java
+public static void main(String[] args) {
+ StackClosedExample example = new StackClosedExample();
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> example.add100());
+ executorService.execute(() -> example.add100());
+ executorService.shutdown();
+}
+```
+
+```html
+100
+100
+```
+
+### 2. 线程本地存储（Thread Local Storage）
+
+如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
+
+符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完。其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
+
+可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。
+
+对于以下代码，thread1 中设置 threadLocal 为 1，而 thread2 设置 threadLocal 为 2。过了一段时间之后，thread1 读取 threadLocal 依然是 1，不受 thread2 的影响。
+
+```java
+public class ThreadLocalExample {
+ public static void main(String[] args) {
+ ThreadLocal threadLocal = new ThreadLocal();
+ Thread thread1 = new Thread(() -> {
+ threadLocal.set(1);
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.println(threadLocal.get());
+ threadLocal.remove();
+ });
+ Thread thread2 = new Thread(() -> {
+ threadLocal.set(2);
+ threadLocal.remove();
+ });
+ thread1.start();
+ thread2.start();
+ }
+}
+```
+
+```html
+1
+```
+
+为了理解 ThreadLocal，先看以下代码：
+
+```java
+public class ThreadLocalExample1 {
+ public static void main(String[] args) {
+ ThreadLocal threadLocal1 = new ThreadLocal();
+ ThreadLocal threadLocal2 = new ThreadLocal();
+ Thread thread1 = new Thread(() -> {
+ threadLocal1.set(1);
+ threadLocal2.set(1);
+ });
+ Thread thread2 = new Thread(() -> {
+ threadLocal1.set(2);
+ threadLocal2.set(2);
+ });
+ thread1.start();
+ thread2.start();
+ }
+}
+```
+
+它所对应的底层结构图为：
+
+ sf = new SoftReference(obj);
+obj = null; // 使对象只被软引用关联
+```
+
+### 3. 弱引用
+
+被弱引用关联的对象一定会被回收，也就是说它只能存活到下一次垃圾回收发生之前。
+
+使用 WeakReference 类来实现弱引用。
+
+```java
+Object obj = new Object();
+WeakReference wf = new WeakReference(obj);
+obj = null;
+```
+
+### 4. 虚引用
+
+又称为幽灵引用或者幻影引用。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用取得一个对象。
+
+为一个对象设置虚引用关联的唯一目的就是能在这个对象被回收时收到一个系统通知。
+
+使用 PhantomReference 来实现虚引用。
+
+```java
+Object obj = new Object();
+PhantomReference pf = new PhantomReference(obj);
+obj = null;
+```
+
+## 垃圾收集算法
+
+### 1. 标记 - 清除
+
+ vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
+
+public String reverseVowels(String s) {
+ int i = 0, j = s.length() - 1;
+ char[] result = new char[s.length()];
+ while (i <= j) {
+ char ci = s.charAt(i);
+ char cj = s.charAt(j);
+ if (!vowels.contains(ci)) {
+ result[i++] = ci;
+ } else if (!vowels.contains(cj)) {
+ result[j--] = cj;
+ } else {
+ result[i++] = cj;
+ result[j--] = ci;
+ }
+ }
+ return new String(result);
+}
+```
+
+**回文字符串**
+
+[680. Valid Palindrome II (Easy)](https://leetcode.com/problems/valid-palindrome-ii/description/)
+
+```html
+Input: "abca"
+Output: True
+Explanation: You could delete the character 'c'.
+```
+
+题目描述：可以删除一个字符，判断是否能构成回文字符串。
+
+```java
+public boolean validPalindrome(String s) {
+ int i = -1, j = s.length();
+ while (++i < --j) {
+ if (s.charAt(i) != s.charAt(j)) {
+ return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
+ }
+ }
+ return true;
+}
+
+private boolean isPalindrome(String s, int i, int j) {
+ while (i < j) {
+ if (s.charAt(i++) != s.charAt(j--)) {
+ return false;
+ }
+ }
+ return true;
+}
+```
+
+**归并两个有序数组**
+
+[88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)
+
+```html
+Input:
+nums1 = [1,2,3,0,0,0], m = 3
+nums2 = [2,5,6], n = 3
+
+Output: [1,2,2,3,5,6]
+```
+
+题目描述：把归并结果存到第一个数组上。
+
+需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值。
+
+```java
+public void merge(int[] nums1, int m, int[] nums2, int n) {
+ int index1 = m - 1, index2 = n - 1;
+ int indexMerge = m + n - 1;
+ while (index1 >= 0 || index2 >= 0) {
+ if (index1 < 0) {
+ nums1[indexMerge--] = nums2[index2--];
+ } else if (index2 < 0) {
+ nums1[indexMerge--] = nums1[index1--];
+ } else if (nums1[index1] > nums2[index2]) {
+ nums1[indexMerge--] = nums1[index1--];
+ } else {
+ nums1[indexMerge--] = nums2[index2--];
+ }
+ }
+}
+```
+
+**判断链表是否存在环**
+
+[141. Linked List Cycle (Easy)](https://leetcode.com/problems/linked-list-cycle/description/)
+
+使用双指针，一个指针每次移动一个节点，一个指针每次移动两个节点，如果存在环，那么这两个指针一定会相遇。
+
+```java
+public boolean hasCycle(ListNode head) {
+ if (head == null) {
+ return false;
+ }
+ ListNode l1 = head, l2 = head.next;
+ while (l1 != null && l2 != null && l2.next != null) {
+ if (l1 == l2) {
+ return true;
+ }
+ l1 = l1.next;
+ l2 = l2.next.next;
+ }
+ return false;
+}
+```
+
+**最长子序列**
+
+[524. Longest Word in Dictionary through Deleting (Medium)](https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/description/)
+
+```
+Input:
+s = "abpcplea", d = ["ale","apple","monkey","plea"]
+
+Output:
+"apple"
+```
+
+题目描述：删除 s 中的一些字符，使得它构成字符串列表 d 中的一个字符串，找出能构成的最长字符串。如果有多个相同长度的结果，返回字典序的最大字符串。
+
+```java
+public String findLongestWord(String s, List d) {
+ String longestWord = "";
+ for (String target : d) {
+ int l1 = longestWord.length(), l2 = target.length();
+ if (l1 > l2 || (l1 == l2 && longestWord.compareTo(target) < 0)) {
+ continue;
+ }
+ if (isValid(s, target)) {
+ longestWord = target;
+ }
+ }
+ return longestWord;
+}
+
+private boolean isValid(String s, String target) {
+ int i = 0, j = 0;
+ while (i < s.length() && j < target.length()) {
+ if (s.charAt(i) == target.charAt(j)) {
+ j++;
+ }
+ i++;
+ }
+ return j == target.length();
+}
+```
+
+## 排序
+
+### 快速选择
+
+用于求解 **Kth Element** 问题，使用快速排序的 partition() 进行实现。
+
+需要先打乱数组，否则最坏情况下时间复杂度为 O(N2 )。
+
+### 堆排序
+
+用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。
+
+堆排序也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。
+
+快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。
+
+可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
+
+**Kth Element**
+
+[215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
+
+题目描述：找到第 k 大的元素。
+
+**排序** ：时间复杂度 O(NlogN)，空间复杂度 O(1)
+
+```java
+public int findKthLargest(int[] nums, int k) {
+ Arrays.sort(nums);
+ return nums[nums.length - k];
+}
+```
+
+**堆排序** ：时间复杂度 O(NlogK)，空间复杂度 O(K)。
+
+```java
+public int findKthLargest(int[] nums, int k) {
+ PriorityQueue pq = new PriorityQueue<>(); // 小顶堆
+ for (int val : nums) {
+ pq.add(val);
+ if (pq.size() > k) // 维护堆的大小为 K
+ pq.poll();
+ }
+ return pq.peek();
+}
+```
+
+**快速选择** ：时间复杂度 O(N)，空间复杂度 O(1)
+
+```java
+public int findKthLargest(int[] nums, int k) {
+ k = nums.length - k;
+ int l = 0, h = nums.length - 1;
+ while (l < h) {
+ int j = partition(nums, l, h);
+ if (j == k) {
+ break;
+ } else if (j < k) {
+ l = j + 1;
+ } else {
+ h = j - 1;
+ }
+ }
+ return nums[k];
+}
+
+private int partition(int[] a, int l, int h) {
+ int i = l, j = h + 1;
+ while (true) {
+ while (a[++i] < a[l] && i < h) ;
+ while (a[--j] > a[l] && j > l) ;
+ if (i >= j) {
+ break;
+ }
+ swap(a, i, j);
+ }
+ swap(a, l, j);
+ return j;
+}
+
+private void swap(int[] a, int i, int j) {
+ int t = a[i];
+ a[i] = a[j];
+ a[j] = t;
+}
+```
+
+### 桶排序
+
+**出现频率最多的 k 个数**
+
+[347. Top K Frequent Elements (Medium)](https://leetcode.com/problems/top-k-frequent-elements/description/)
+
+```html
+Given [1,1,1,2,2,3] and k = 2, return [1,2].
+```
+
+设置若干个桶，每个桶存储出现频率相同的数，并且桶的下标代表桶中数出现的频率，即第 i 个桶中存储的数出现的频率为 i。
+
+把数都放到桶之后，从后向前遍历桶，最先得到的 k 个数就是出现频率最多的的 k 个数。
+
+```java
+public List topKFrequent(int[] nums, int k) {
+ Map frequencyForNum = new HashMap<>();
+ for (int num : nums) {
+ frequencyForNum.put(num, frequencyForNum.getOrDefault(num, 0) + 1);
+ }
+ List[] buckets = new ArrayList[nums.length + 1];
+ for (int key : frequencyForNum.keySet()) {
+ int frequency = frequencyForNum.get(key);
+ if (buckets[frequency] == null) {
+ buckets[frequency] = new ArrayList<>();
+ }
+ buckets[frequency].add(key);
+ }
+ List topK = new ArrayList<>();
+ for (int i = buckets.length - 1; i >= 0 && topK.size() < k; i--) {
+ if (buckets[i] != null) {
+ topK.addAll(buckets[i]);
+ }
+ }
+ return topK;
+}
+```
+
+**按照字符出现次数对字符串排序**
+
+[451. Sort Characters By Frequency (Medium)](https://leetcode.com/problems/sort-characters-by-frequency/description/)
+
+```html
+Input:
+"tree"
+
+Output:
+"eert"
+
+Explanation:
+'e' appears twice while 'r' and 't' both appear once.
+So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.
+```
+
+```java
+public String frequencySort(String s) {
+ Map frequencyForNum = new HashMap<>();
+ for (char c : s.toCharArray())
+ frequencyForNum.put(c, frequencyForNum.getOrDefault(c, 0) + 1);
+
+ List[] frequencyBucket = new ArrayList[s.length() + 1];
+ for (char c : frequencyForNum.keySet()) {
+ int f = frequencyForNum.get(c);
+ if (frequencyBucket[f] == null) {
+ frequencyBucket[f] = new ArrayList<>();
+ }
+ frequencyBucket[f].add(c);
+ }
+ StringBuilder str = new StringBuilder();
+ for (int i = frequencyBucket.length - 1; i >= 0; i--) {
+ if (frequencyBucket[i] == null) {
+ continue;
+ }
+ for (char c : frequencyBucket[i]) {
+ for (int j = 0; j < i; j++) {
+ str.append(c);
+ }
+ }
+ }
+ return str.toString();
+}
+```
+
+### 荷兰国旗问题
+
+荷兰国旗包含三种颜色：红、白、蓝。
+
+有三种颜色的球，算法的目标是将这三种球按颜色顺序正确地排列。
+
+它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。
+
+ () {
+ @Override
+ public int compare(Interval o1, Interval o2) {
+ return o1.end - o2.end;
+ }
+});
+```
+
+**投飞镖刺破气球**
+
+[452. Minimum Number of Arrows to Burst Balloons (Medium)](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
+
+```
+Input:
+[[10,16], [2,8], [1,6], [7,12]]
+
+Output:
+2
+```
+
+题目描述：气球在一个水平数轴上摆放，可以重叠，飞镖垂直投向坐标轴，使得路径上的气球都会刺破。求解最小的投飞镖次数使所有气球都被刺破。
+
+也是计算不重叠的区间个数，不过和 Non-overlapping Intervals 的区别在于，[1, 2] 和 [2, 3] 在本题中算是重叠区间。
+
+```java
+public int findMinArrowShots(int[][] points) {
+ if (points.length == 0) {
+ return 0;
+ }
+ Arrays.sort(points, Comparator.comparingInt(o -> o[1]));
+ int cnt = 1, end = points[0][1];
+ for (int i = 1; i < points.length; i++) {
+ if (points[i][0] <= end) {
+ continue;
+ }
+ cnt++;
+ end = points[i][1];
+ }
+ return cnt;
+}
+```
+
+**根据身高和序号重组队列**
+
+[406. Queue Reconstruction by Height(Medium)](https://leetcode.com/problems/queue-reconstruction-by-height/description/)
+
+```html
+Input:
+[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
+
+Output:
+[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
+```
+
+题目描述：一个学生用两个分量 (h, k) 描述，h 表示身高，k 表示排在前面的有 k 个学生的身高比他高或者和他一样高。
+
+为了使插入操作不影响后续的操作，身高较高的学生应该先做插入操作，否则身高较小的学生原先正确插入的第 k 个位置可能会变成第 k+1 个位置。
+
+身高降序、k 值升序，然后按排好序的顺序插入队列的第 k 个位置中。
+
+```java
+public int[][] reconstructQueue(int[][] people) {
+ if (people == null || people.length == 0 || people[0].length == 0) {
+ return new int[0][0];
+ }
+ Arrays.sort(people, (a, b) -> (a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]));
+ List queue = new ArrayList<>();
+ for (int[] p : people) {
+ queue.add(p[1], p);
+ }
+ return queue.toArray(new int[queue.size()][]);
+}
+```
+
+**分隔字符串使同种字符出现在一起**
+
+[763. Partition Labels (Medium)](https://leetcode.com/problems/partition-labels/description/)
+
+```html
+Input: S = "ababcbacadefegdehijhklij"
+Output: [9,7,8]
+Explanation:
+The partition is "ababcbaca", "defegde", "hijhklij".
+This is a partition so that each letter appears in at most one part.
+A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.
+```
+
+```java
+public List partitionLabels(String S) {
+ int[] lastIndexsOfChar = new int[26];
+ for (int i = 0; i < S.length(); i++) {
+ lastIndexsOfChar[char2Index(S.charAt(i))] = i;
+ }
+ List partitions = new ArrayList<>();
+ int firstIndex = 0;
+ while (firstIndex < S.length()) {
+ int lastIndex = firstIndex;
+ for (int i = firstIndex; i < S.length() && i <= lastIndex; i++) {
+ int index = lastIndexsOfChar[char2Index(S.charAt(i))];
+ if (index > lastIndex) {
+ lastIndex = index;
+ }
+ }
+ partitions.add(lastIndex - firstIndex + 1);
+ firstIndex = lastIndex + 1;
+ }
+ return partitions;
+}
+
+private int char2Index(char c) {
+ return c - 'a';
+}
+```
+
+
+**种植花朵**
+
+[605. Can Place Flowers (Easy)](https://leetcode.com/problems/can-place-flowers/description/)
+
+```html
+Input: flowerbed = [1,0,0,0,1], n = 1
+Output: True
+```
+
+题目描述：花朵之间至少需要一个单位的间隔，求解是否能种下 n 朵花。
+
+```java
+public boolean canPlaceFlowers(int[] flowerbed, int n) {
+ int len = flowerbed.length;
+ int cnt = 0;
+ for (int i = 0; i < len && cnt < n; i++) {
+ if (flowerbed[i] == 1) {
+ continue;
+ }
+ int pre = i == 0 ? 0 : flowerbed[i - 1];
+ int next = i == len - 1 ? 0 : flowerbed[i + 1];
+ if (pre == 0 && next == 0) {
+ cnt++;
+ flowerbed[i] = 1;
+ }
+ }
+ return cnt >= n;
+}
+```
+
+**判断是否为子序列**
+
+[392. Is Subsequence (Medium)](https://leetcode.com/problems/is-subsequence/description/)
+
+```html
+s = "abc", t = "ahbgdc"
+Return true.
+```
+
+```java
+public boolean isSubsequence(String s, String t) {
+ int index = -1;
+ for (char c : s.toCharArray()) {
+ index = t.indexOf(c, index + 1);
+ if (index == -1) {
+ return false;
+ }
+ }
+ return true;
+}
+```
+
+**修改一个数成为非递减数组**
+
+[665. Non-decreasing Array (Easy)](https://leetcode.com/problems/non-decreasing-array/description/)
+
+```html
+Input: [4,2,3]
+Output: True
+Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
+```
+
+题目描述：判断一个数组能不能只修改一个数就成为非递减数组。
+
+在出现 nums[i] < nums[i - 1] 时，需要考虑的是应该修改数组的哪个数，使得本次修改能使 i 之前的数组成为非递减数组，并且 **不影响后续的操作** 。优先考虑令 nums[i - 1] = nums[i]，因为如果修改 nums[i] = nums[i - 1] 的话，那么 nums[i] 这个数会变大，就有可能比 nums[i + 1] 大，从而影响了后续操作。还有一个比较特别的情况就是 nums[i] < nums[i - 2]，只修改 nums[i - 1] = nums[i] 不能使数组成为非递减数组，只能修改 nums[i] = nums[i - 1]。
+
+```java
+public boolean checkPossibility(int[] nums) {
+ int cnt = 0;
+ for (int i = 1; i < nums.length && cnt < 2; i++) {
+ if (nums[i] >= nums[i - 1]) {
+ continue;
+ }
+ cnt++;
+ if (i - 2 >= 0 && nums[i - 2] > nums[i]) {
+ nums[i] = nums[i - 1];
+ } else {
+ nums[i - 1] = nums[i];
+ }
+ }
+ return cnt <= 1;
+}
+```
+
+**股票的最大收益**
+
+[122. Best Time to Buy and Sell Stock II (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
+
+题目描述：一次股票交易包含买入和卖出，多个交易之间不能交叉进行。
+
+对于 [a, b, c, d]，如果有 a <= b <= c <= d ，那么最大收益为 d - a。而 d - a = (d - c) + (c - b) + (b - a) ，因此当访问到一个 prices[i] 且 prices[i] - prices[i-1] > 0，那么就把 prices[i] - prices[i-1] 添加到收益中，从而在局部最优的情况下也保证全局最优。
+
+```java
+public int maxProfit(int[] prices) {
+ int profit = 0;
+ for (int i = 1; i < prices.length; i++) {
+ if (prices[i] > prices[i - 1]) {
+ profit += (prices[i] - prices[i - 1]);
+ }
+ }
+ return profit;
+}
+```
+
+**子数组最大的和**
+
+[53. Maximum Subarray (Easy)](https://leetcode.com/problems/maximum-subarray/description/)
+
+```html
+For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
+the contiguous subarray [4,-1,2,1] has the largest sum = 6.
+```
+
+```java
+public int maxSubArray(int[] nums) {
+ if (nums == null || nums.length == 0) {
+ return 0;
+ }
+ int preSum = nums[0];
+ int maxSum = preSum;
+ for (int i = 1; i < nums.length; i++) {
+ preSum = preSum > 0 ? preSum + nums[i] : nums[i];
+ maxSum = Math.max(maxSum, preSum);
+ }
+ return maxSum;
+}
+```
+
+**买入和售出股票最大的收益**
+
+[121. Best Time to Buy and Sell Stock (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
+
+题目描述：只进行一次交易。
+
+只要记录前面的最小价格，将这个最小价格作为买入价格，然后将当前的价格作为售出价格，查看当前收益是不是最大收益。
+
+```java
+public int maxProfit(int[] prices) {
+ int n = prices.length;
+ if (n == 0) return 0;
+ int soFarMin = prices[0];
+ int max = 0;
+ for (int i = 1; i < n; i++) {
+ if (soFarMin > prices[i]) soFarMin = prices[i];
+ else max = Math.max(max, prices[i] - soFarMin);
+ }
+ return max;
+}
+```
+
+## 二分查找
+
+**正常实现**
+
+```java
+public int binarySearch(int[] nums, int key) {
+ int l = 0, h = nums.length - 1;
+ while (l <= h) {
+ int m = l + (h - l) / 2;
+ if (nums[m] == key) {
+ return m;
+ } else if (nums[m] > key) {
+ h = m - 1;
+ } else {
+ l = m + 1;
+ }
+ }
+ return -1;
+}
+```
+
+**时间复杂度**
+
+二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度为 O(logN)。
+
+**m 计算**
+
+有两种计算中值 m 的方式：
+
+- m = (l + h) / 2
+- m = l + (h - l) / 2
+
+l + h 可能出现加法溢出，最好使用第二种方式。
+
+**返回值**
+
+循环退出时如果仍然没有查找到 key，那么表示查找失败。可以有两种返回值：
+
+- -1：以一个错误码表示没有查找到 key
+- l：将 key 插入到 nums 中的正确位置
+
+**变种**
+
+二分查找可以有很多变种，变种实现要注意边界值的判断。例如在一个有重复元素的数组中查找 key 的最左位置的实现如下：
+
+```java
+public int binarySearch(int[] nums, int key) {
+ int l = 0, h = nums.length - 1;
+ while (l < h) {
+ int m = l + (h - l) / 2;
+ if (nums[m] >= key) {
+ h = m;
+ } else {
+ l = m + 1;
+ }
+ }
+ return l;
+}
+```
+
+该实现和正常实现有以下不同：
+
+- 循环条件为 l < h
+- h 的赋值表达式为 h = m
+- 最后返回 l 而不是 -1
+
+在 nums[m] >= key 的情况下，可以推导出最左 key 位于 [l, m] 区间中，这是一个闭区间。h 的赋值表达式为 h = m，因为 m 位置也可能是解。
+
+在 h 的赋值表达式为 h = mid 的情况下，如果循环条件为 l <= h，那么会出现循环无法退出的情况，因此循环条件只能是 l < h。以下演示了循环条件为 l <= h 时循环无法退出的情况：
+
+```text
+nums = {0, 1, 2}, key = 1
+l m h
+0 1 2 nums[m] >= key
+0 0 1 nums[m] < key
+1 1 1 nums[m] >= key
+1 1 1 nums[m] >= key
+...
+```
+
+当循环体退出时，不表示没有查找到 key，因此最后返回的结果不应该为 -1。为了验证有没有查找到，需要在调用端判断一下返回位置上的值和 key 是否相等。
+
+**求开方**
+
+[69. Sqrt(x) (Easy)](https://leetcode.com/problems/sqrtx/description/)
+
+```html
+Input: 4
+Output: 2
+
+Input: 8
+Output: 2
+Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.
+```
+
+一个数 x 的开方 sqrt 一定在 0 \~ x 之间，并且满足 sqrt == x / sqrt。可以利用二分查找在 0 \~ x 之间查找 sqrt。
+
+对于 x = 8，它的开方是 2.82842...，最后应该返回 2 而不是 3。在循环条件为 l <= h 并且循环退出时，h 总是比 l 小 1，也就是说 h = 2，l = 3，因此最后的返回值应该为 h 而不是 l。
+
+```java
+public int mySqrt(int x) {
+ if (x <= 1) {
+ return x;
+ }
+ int l = 1, h = x;
+ while (l <= h) {
+ int mid = l + (h - l) / 2;
+ int sqrt = x / mid;
+ if (sqrt == mid) {
+ return mid;
+ } else if (mid > sqrt) {
+ h = mid - 1;
+ } else {
+ l = mid + 1;
+ }
+ }
+ return h;
+}
+```
+
+**大于给定元素的最小元素**
+
+[744. Find Smallest Letter Greater Than Target (Easy)](https://leetcode.com/problems/find-smallest-letter-greater-than-target/description/)
+
+```html
+Input:
+letters = ["c", "f", "j"]
+target = "d"
+Output: "f"
+
+Input:
+letters = ["c", "f", "j"]
+target = "k"
+Output: "c"
+```
+
+题目描述：给定一个有序的字符数组 letters 和一个字符 target，要求找出 letters 中大于 target 的最小字符，如果找不到就返回第 1 个字符。
+
+```java
+public char nextGreatestLetter(char[] letters, char target) {
+ int n = letters.length;
+ int l = 0, h = n - 1;
+ while (l <= h) {
+ int m = l + (h - l) / 2;
+ if (letters[m] <= target) {
+ l = m + 1;
+ } else {
+ h = m - 1;
+ }
+ }
+ return l < n ? letters[l] : letters[0];
+}
+```
+
+**有序数组的 Single Element**
+
+[540. Single Element in a Sorted Array (Medium)](https://leetcode.com/problems/single-element-in-a-sorted-array/description/)
+
+```html
+Input: [1, 1, 2, 3, 3, 4, 4, 8, 8]
+Output: 2
+```
+
+题目描述：一个有序数组只有一个数不出现两次，找出这个数。要求以 O(logN) 时间复杂度进行求解。
+
+令 index 为 Single Element 在数组中的位置。如果 m 为偶数，并且 m + 1 < index，那么 nums[m] == nums[m + 1]；m + 1 >= index，那么 nums[m] != nums[m + 1]。
+
+从上面的规律可以知道，如果 nums[m] == nums[m + 1]，那么 index 所在的数组位置为 [m + 2, h]，此时令 l = m + 2；如果 nums[m] != nums[m + 1]，那么 index 所在的数组位置为 [l, m]，此时令 h = m。
+
+因为 h 的赋值表达式为 h = m，那么循环条件也就只能使用 l < h 这种形式。
+
+```java
+public int singleNonDuplicate(int[] nums) {
+ int l = 0, h = nums.length - 1;
+ while (l < h) {
+ int m = l + (h - l) / 2;
+ if (m % 2 == 1) {
+ m--; // 保证 l/h/m 都在偶数位，使得查找区间大小一直都是奇数
+ }
+ if (nums[m] == nums[m + 1]) {
+ l = m + 2;
+ } else {
+ h = m;
+ }
+ }
+ return nums[l];
+}
+```
+
+**第一个错误的版本**
+
+[278. First Bad Version (Easy)](https://leetcode.com/problems/first-bad-version/description/)
+
+题目描述：给定一个元素 n 代表有 [1, 2, ..., n] 版本，可以调用 isBadVersion(int x) 知道某个版本是否错误，要求找到第一个错误的版本。
+
+如果第 m 个版本出错，则表示第一个错误的版本在 [l, m] 之间，令 h = m；否则第一个错误的版本在 [m + 1, h] 之间，令 l = m + 1。
+
+因为 h 的赋值表达式为 h = m，因此循环条件为 l < h。
+
+```java
+public int firstBadVersion(int n) {
+ int l = 1, h = n;
+ while (l < h) {
+ int mid = l + (h - l) / 2;
+ if (isBadVersion(mid)) {
+ h = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ return l;
+}
+```
+
+**旋转数组的最小数字**
+
+[153. Find Minimum in Rotated Sorted Array (Medium)](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/)
+
+```html
+Input: [3,4,5,1,2],
+Output: 1
+```
+
+```java
+public int findMin(int[] nums) {
+ 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];
+}
+```
+
+**查找区间**
+
+[34. Search for a Range (Medium)](https://leetcode.com/problems/search-for-a-range/description/)
+
+```html
+Input: nums = [5,7,7,8,8,10], target = 8
+Output: [3,4]
+
+Input: nums = [5,7,7,8,8,10], target = 6
+Output: [-1,-1]
+```
+
+```java
+public int[] searchRange(int[] nums, int target) {
+ int first = binarySearch(nums, target);
+ int last = binarySearch(nums, target + 1) - 1;
+ if (first == nums.length || nums[first] != target) {
+ return new int[]{-1, -1};
+ } else {
+ return new int[]{first, Math.max(first, last)};
+ }
+}
+
+private int binarySearch(int[] nums, int target) {
+ int l = 0, h = nums.length; // 注意 h 的初始值
+ while (l < h) {
+ int m = l + (h - l) / 2;
+ if (nums[m] >= target) {
+ h = m;
+ } else {
+ l = m + 1;
+ }
+ }
+ return l;
+}
+```
+
+## 分治
+
+**给表达式加括号**
+
+[241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
+
+```html
+Input: "2-1-1".
+
+((2-1)-1) = 0
+(2-(1-1)) = 2
+
+Output : [0, 2]
+```
+
+```java
+public List diffWaysToCompute(String input) {
+ List ways = new ArrayList<>();
+ for (int i = 0; i < input.length(); i++) {
+ char c = input.charAt(i);
+ if (c == '+' || c == '-' || c == '*') {
+ List left = diffWaysToCompute(input.substring(0, i));
+ List right = diffWaysToCompute(input.substring(i + 1));
+ for (int l : left) {
+ for (int r : right) {
+ switch (c) {
+ case '+':
+ ways.add(l + r);
+ break;
+ case '-':
+ ways.add(l - r);
+ break;
+ case '*':
+ ways.add(l * r);
+ break;
+ }
+ }
+ }
+ }
+ }
+ if (ways.size() == 0) {
+ ways.add(Integer.valueOf(input));
+ }
+ return ways;
+}
+```
+
+## 搜索
+
+深度优先搜索和广度优先搜索广泛运用于树和图中，但是它们的应用远远不止如此。
+
+### BFS
+
+i 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di <= dj 。利用这个结论，可以求解最短路径等 **最优解** 问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径。
+
+在程序实现 BFS 时需要考虑以下问题：
+
+- 队列：用来存储每一轮遍历得到的节点；
+- 标记：对于遍历过的节点，应该将它标记，防止重复遍历。
+
+**计算在网格中从原点到特定点的最短路径长度**
+
+```html
+[[1,1,0,1],
+ [1,0,1,0],
+ [1,1,1,1],
+ [1,0,1,1]]
+```
+
+1 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。
+
+```java
+public int minPathLength(int[][] grids, int tr, int tc) {
+ final int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+ final int m = grids.length, n = grids[0].length;
+ Queue> queue = new LinkedList<>();
+ queue.add(new Pair<>(0, 0));
+ int pathLength = 0;
+ while (!queue.isEmpty()) {
+ int size = queue.size();
+ pathLength++;
+ while (size-- > 0) {
+ Pair cur = queue.poll();
+ int cr = cur.getKey(), cc = cur.getValue();
+ grids[cr][cc] = 0; // 标记
+ for (int[] d : direction) {
+ int nr = cr + d[0], nc = cc + d[1];
+ if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 0) {
+ continue;
+ }
+ if (nr == tr && nc == tc) {
+ return pathLength;
+ }
+ queue.add(new Pair<>(nr, nc));
+ }
+ }
+ }
+ return -1;
+}
+```
+
+**组成整数的最小平方数数量**
+
+[279. Perfect Squares (Medium)](https://leetcode.com/problems/perfect-squares/description/)
+
+```html
+For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.
+```
+
+可以将每个整数看成图中的一个节点，如果两个整数之差为一个平方数，那么这两个整数所在的节点就有一条边。
+
+要求解最小的平方数数量，就是求解从节点 n 到节点 0 的最短路径。
+
+本题也可以用动态规划求解，在之后动态规划部分中会再次出现。
+
+```java
+public int numSquares(int n) {
+ List squares = generateSquares(n);
+ Queue queue = new LinkedList<>();
+ boolean[] marked = new boolean[n + 1];
+ queue.add(n);
+ marked[n] = true;
+ int level = 0;
+ while (!queue.isEmpty()) {
+ int size = queue.size();
+ level++;
+ while (size-- > 0) {
+ int cur = queue.poll();
+ for (int s : squares) {
+ int next = cur - s;
+ if (next < 0) {
+ break;
+ }
+ if (next == 0) {
+ return level;
+ }
+ if (marked[next]) {
+ continue;
+ }
+ marked[next] = true;
+ queue.add(next);
+ }
+ }
+ }
+ return n;
+}
+
+/**
+ * 生成小于 n 的平方数序列
+ * @return 1,4,9,...
+ */
+private List generateSquares(int n) {
+ List squares = new ArrayList<>();
+ int square = 1;
+ int diff = 3;
+ while (square <= n) {
+ squares.add(square);
+ square += diff;
+ diff += 2;
+ }
+ return squares;
+}
+```
+
+**最短单词路径**
+
+[127. Word Ladder (Medium)](https://leetcode.com/problems/word-ladder/description/)
+
+```html
+Input:
+beginWord = "hit",
+endWord = "cog",
+wordList = ["hot","dot","dog","lot","log","cog"]
+
+Output: 5
+
+Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
+return its length 5.
+```
+
+```html
+Input:
+beginWord = "hit"
+endWord = "cog"
+wordList = ["hot","dot","dog","lot","log"]
+
+Output: 0
+
+Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
+```
+
+题目描述：找出一条从 beginWord 到 endWord 的最短路径，每次移动规定为改变一个字符，并且改变之后的字符串必须在 wordList 中。
+
+```java
+public int ladderLength(String beginWord, String endWord, List wordList) {
+ wordList.add(beginWord);
+ int N = wordList.size();
+ int start = N - 1;
+ int end = 0;
+ while (end < N && !wordList.get(end).equals(endWord)) {
+ end++;
+ }
+ if (end == N) {
+ return 0;
+ }
+ List[] graphic = buildGraphic(wordList);
+ return getShortestPath(graphic, start, end);
+}
+
+private List[] buildGraphic(List wordList) {
+ int N = wordList.size();
+ List[] graphic = new List[N];
+ for (int i = 0; i < N; i++) {
+ graphic[i] = new ArrayList<>();
+ for (int j = 0; j < N; j++) {
+ if (isConnect(wordList.get(i), wordList.get(j))) {
+ graphic[i].add(j);
+ }
+ }
+ }
+ return graphic;
+}
+
+private boolean isConnect(String s1, String s2) {
+ int diffCnt = 0;
+ for (int i = 0; i < s1.length() && diffCnt <= 1; i++) {
+ if (s1.charAt(i) != s2.charAt(i)) {
+ diffCnt++;
+ }
+ }
+ return diffCnt == 1;
+}
+
+private int getShortestPath(List[] graphic, int start, int end) {
+ Queue queue = new LinkedList<>();
+ boolean[] marked = new boolean[graphic.length];
+ queue.add(start);
+ marked[start] = true;
+ int path = 1;
+ while (!queue.isEmpty()) {
+ int size = queue.size();
+ path++;
+ while (size-- > 0) {
+ int cur = queue.poll();
+ for (int next : graphic[cur]) {
+ if (next == end) {
+ return path;
+ }
+ if (marked[next]) {
+ continue;
+ }
+ marked[next] = true;
+ queue.add(next);
+ }
+ }
+ }
+ return 0;
+}
+```
+
+### DFS
+
+ pacificAtlantic(int[][] matrix) {
+ List ret = new ArrayList<>();
+ if (matrix == null || matrix.length == 0) {
+ return ret;
+ }
+
+ m = matrix.length;
+ n = matrix[0].length;
+ this.matrix = matrix;
+ boolean[][] canReachP = new boolean[m][n];
+ boolean[][] canReachA = new boolean[m][n];
+
+ for (int i = 0; i < m; i++) {
+ dfs(i, 0, canReachP);
+ dfs(i, n - 1, canReachA);
+ }
+ for (int i = 0; i < n; i++) {
+ dfs(0, i, canReachP);
+ dfs(m - 1, i, canReachA);
+ }
+
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ if (canReachP[i][j] && canReachA[i][j]) {
+ ret.add(new int[]{i, j});
+ }
+ }
+ }
+
+ return ret;
+}
+
+private void dfs(int r, int c, boolean[][] canReach) {
+ if (canReach[r][c]) {
+ return;
+ }
+ canReach[r][c] = true;
+ for (int[] d : direction) {
+ int nextR = d[0] + r;
+ int nextC = d[1] + c;
+ if (nextR < 0 || nextR >= m || nextC < 0 || nextC >= n
+ || matrix[r][c] > matrix[nextR][nextC]) {
+
+ continue;
+ }
+ dfs(nextR, nextC, canReach);
+ }
+}
+```
+
+### Backtracking
+
+Backtracking（回溯）属于 DFS。
+
+- 普通 DFS 主要用在 **可达性问题** ，这种问题只需要执行到特点的位置然后返回即可。
+- 而 Backtracking 主要用于求解 **排列组合** 问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串，这种问题在执行到特定的位置返回之后还会继续执行求解过程。
+
+因为 Backtracking 不是立即就返回，而要继续求解，因此在程序实现时，需要注意对元素的标记问题：
+
+- 在访问一个新元素进入新的递归调用时，需要将新元素标记为已经访问，这样才能在继续递归调用时不用重复访问该元素；
+- 但是在递归返回时，需要将元素标记为未访问，因为只需要保证在一个递归链中不同时访问一个元素，可以访问已经访问过但是不在当前递归链中的元素。
+
+**数字键盘组合**
+
+[17. Letter Combinations of a Phone Number (Medium)](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/)
+
+ letterCombinations(String digits) {
+ List combinations = new ArrayList<>();
+ if (digits == null || digits.length() == 0) {
+ return combinations;
+ }
+ doCombination(new StringBuilder(), combinations, digits);
+ return combinations;
+}
+
+private void doCombination(StringBuilder prefix, List combinations, final String digits) {
+ if (prefix.length() == digits.length()) {
+ combinations.add(prefix.toString());
+ return;
+ }
+ int curDigits = digits.charAt(prefix.length()) - '0';
+ String letters = KEYS[curDigits];
+ for (char c : letters.toCharArray()) {
+ prefix.append(c); // 添加
+ doCombination(prefix, combinations, digits);
+ prefix.deleteCharAt(prefix.length() - 1); // 删除
+ }
+}
+```
+
+**IP 地址划分**
+
+[93. Restore IP Addresses(Medium)](https://leetcode.com/problems/restore-ip-addresses/description/)
+
+```html
+Given "25525511135",
+return ["255.255.11.135", "255.255.111.35"].
+```
+
+```java
+public List restoreIpAddresses(String s) {
+ List addresses = new ArrayList<>();
+ StringBuilder tempAddress = new StringBuilder();
+ doRestore(0, tempAddress, addresses, s);
+ return addresses;
+}
+
+private void doRestore(int k, StringBuilder tempAddress, List addresses, String s) {
+ if (k == 4 || s.length() == 0) {
+ if (k == 4 && s.length() == 0) {
+ addresses.add(tempAddress.toString());
+ }
+ return;
+ }
+ for (int i = 0; i < s.length() && i <= 2; i++) {
+ if (i != 0 && s.charAt(0) == '0') {
+ break;
+ }
+ String part = s.substring(0, i + 1);
+ if (Integer.valueOf(part) <= 255) {
+ if (tempAddress.length() != 0) {
+ part = "." + part;
+ }
+ tempAddress.append(part);
+ doRestore(k + 1, tempAddress, addresses, s.substring(i + 1));
+ tempAddress.delete(tempAddress.length() - part.length(), tempAddress.length());
+ }
+ }
+}
+```
+
+**在矩阵中寻找字符串**
+
+[79. Word Search (Medium)](https://leetcode.com/problems/word-search/description/)
+
+```html
+For example,
+Given board =
+[
+ ['A','B','C','E'],
+ ['S','F','C','S'],
+ ['A','D','E','E']
+]
+word = "ABCCED", -> returns true,
+word = "SEE", -> returns true,
+word = "ABCB", -> returns false.
+```
+
+```java
+private final static int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+private int m;
+private int n;
+
+public boolean exist(char[][] board, String word) {
+ if (word == null || word.length() == 0) {
+ return true;
+ }
+ if (board == null || board.length == 0 || board[0].length == 0) {
+ return false;
+ }
+
+ m = board.length;
+ n = board[0].length;
+ boolean[][] hasVisited = new boolean[m][n];
+
+ for (int r = 0; r < m; r++) {
+ for (int c = 0; c < n; c++) {
+ if (backtracking(0, r, c, hasVisited, board, word)) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+private boolean backtracking(int curLen, int r, int c, boolean[][] visited, final char[][] board, final String word) {
+ if (curLen == word.length()) {
+ return true;
+ }
+ if (r < 0 || r >= m || c < 0 || c >= n
+ || board[r][c] != word.charAt(curLen) || visited[r][c]) {
+
+ return false;
+ }
+
+ visited[r][c] = true;
+
+ for (int[] d : direction) {
+ if (backtracking(curLen + 1, r + d[0], c + d[1], visited, board, word)) {
+ return true;
+ }
+ }
+
+ visited[r][c] = false;
+
+ return false;
+}
+```
+
+**输出二叉树中所有从根到叶子的路径**
+
+[257. Binary Tree Paths (Easy)](https://leetcode.com/problems/binary-tree-paths/description/)
+
+```html
+ 1
+ / \
+2 3
+ \
+ 5
+```
+
+```html
+["1->2->5", "1->3"]
+```
+
+```java
+
+public List binaryTreePaths(TreeNode root) {
+ List paths = new ArrayList<>();
+ if (root == null) {
+ return paths;
+ }
+ List values = new ArrayList<>();
+ backtracking(root, values, paths);
+ return paths;
+}
+
+private void backtracking(TreeNode node, List values, List paths) {
+ if (node == null) {
+ return;
+ }
+ values.add(node.val);
+ if (isLeaf(node)) {
+ paths.add(buildPath(values));
+ } else {
+ backtracking(node.left, values, paths);
+ backtracking(node.right, values, paths);
+ }
+ values.remove(values.size() - 1);
+}
+
+private boolean isLeaf(TreeNode node) {
+ return node.left == null && node.right == null;
+}
+
+private String buildPath(List values) {
+ StringBuilder str = new StringBuilder();
+ for (int i = 0; i < values.size(); i++) {
+ str.append(values.get(i));
+ if (i != values.size() - 1) {
+ str.append("->");
+ }
+ }
+ return str.toString();
+}
+```
+
+**排列**
+
+[46. Permutations (Medium)](https://leetcode.com/problems/permutations/description/)
+
+```html
+[1,2,3] have the following permutations:
+[
+ [1,2,3],
+ [1,3,2],
+ [2,1,3],
+ [2,3,1],
+ [3,1,2],
+ [3,2,1]
+]
+```
+
+```java
+public List> permute(int[] nums) {
+ List> permutes = new ArrayList<>();
+ List permuteList = new ArrayList<>();
+ boolean[] hasVisited = new boolean[nums.length];
+ backtracking(permuteList, permutes, hasVisited, nums);
+ return permutes;
+}
+
+private void backtracking(List permuteList, List> permutes, boolean[] visited, final int[] nums) {
+ if (permuteList.size() == nums.length) {
+ permutes.add(new ArrayList<>(permuteList)); // 重新构造一个 List
+ return;
+ }
+ for (int i = 0; i < visited.length; i++) {
+ if (visited[i]) {
+ continue;
+ }
+ visited[i] = true;
+ permuteList.add(nums[i]);
+ backtracking(permuteList, permutes, visited, nums);
+ permuteList.remove(permuteList.size() - 1);
+ visited[i] = false;
+ }
+}
+```
+
+**含有相同元素求排列**
+
+[47. Permutations II (Medium)](https://leetcode.com/problems/permutations-ii/description/)
+
+```html
+[1,1,2] have the following unique permutations:
+[[1,1,2], [1,2,1], [2,1,1]]
+```
+
+数组元素可能含有相同的元素，进行排列时就有可能出现重复的排列，要求重复的排列只返回一个。
+
+在实现上，和 Permutations 不同的是要先排序，然后在添加一个元素时，判断这个元素是否等于前一个元素，如果等于，并且前一个元素还未访问，那么就跳过这个元素。
+
+```java
+public List> permuteUnique(int[] nums) {
+ List> permutes = new ArrayList<>();
+ List permuteList = new ArrayList<>();
+ Arrays.sort(nums); // 排序
+ boolean[] hasVisited = new boolean[nums.length];
+ backtracking(permuteList, permutes, hasVisited, nums);
+ return permutes;
+}
+
+private void backtracking(List permuteList, List> permutes, boolean[] visited, final int[] nums) {
+ if (permuteList.size() == nums.length) {
+ permutes.add(new ArrayList<>(permuteList));
+ return;
+ }
+
+ for (int i = 0; i < visited.length; i++) {
+ if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
+ continue; // 防止重复
+ }
+ if (visited[i]){
+ continue;
+ }
+ visited[i] = true;
+ permuteList.add(nums[i]);
+ backtracking(permuteList, permutes, visited, nums);
+ permuteList.remove(permuteList.size() - 1);
+ visited[i] = false;
+ }
+}
+```
+
+**组合**
+
+[77. Combinations (Medium)](https://leetcode.com/problems/combinations/description/)
+
+```html
+If n = 4 and k = 2, a solution is:
+[
+ [2,4],
+ [3,4],
+ [2,3],
+ [1,2],
+ [1,3],
+ [1,4],
+]
+```
+
+```java
+public List> combine(int n, int k) {
+ List> combinations = new ArrayList<>();
+ List combineList = new ArrayList<>();
+ backtracking(combineList, combinations, 1, k, n);
+ return combinations;
+}
+
+private void backtracking(List combineList, List> combinations, int start, int k, final int n) {
+ if (k == 0) {
+ combinations.add(new ArrayList<>(combineList));
+ return;
+ }
+ for (int i = start; i <= n - k + 1; i++) { // 剪枝
+ combineList.add(i);
+ backtracking(combineList, combinations, i + 1, k - 1, n);
+ combineList.remove(combineList.size() - 1);
+ }
+}
+```
+
+**组合求和**
+
+[39. Combination Sum (Medium)](https://leetcode.com/problems/combination-sum/description/)
+
+```html
+given candidate set [2, 3, 6, 7] and target 7,
+A solution set is:
+[[7],[2, 2, 3]]
+```
+
+```java
+public List> combinationSum(int[] candidates, int target) {
+ List> combinations = new ArrayList<>();
+ backtracking(new ArrayList<>(), combinations, 0, target, candidates);
+ return combinations;
+}
+
+private void backtracking(List tempCombination, List> combinations,
+ int start, int target, final int[] candidates) {
+
+ if (target == 0) {
+ combinations.add(new ArrayList<>(tempCombination));
+ return;
+ }
+ for (int i = start; i < candidates.length; i++) {
+ if (candidates[i] <= target) {
+ tempCombination.add(candidates[i]);
+ backtracking(tempCombination, combinations, i, target - candidates[i], candidates);
+ tempCombination.remove(tempCombination.size() - 1);
+ }
+ }
+}
+```
+
+**含有相同元素的求组合求和**
+
+[40. Combination Sum II (Medium)](https://leetcode.com/problems/combination-sum-ii/description/)
+
+```html
+For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
+A solution set is:
+[
+ [1, 7],
+ [1, 2, 5],
+ [2, 6],
+ [1, 1, 6]
+]
+```
+
+```java
+public List> combinationSum2(int[] candidates, int target) {
+ List> combinations = new ArrayList<>();
+ Arrays.sort(candidates);
+ backtracking(new ArrayList<>(), combinations, new boolean[candidates.length], 0, target, candidates);
+ return combinations;
+}
+
+private void backtracking(List tempCombination, List> combinations,
+ boolean[] hasVisited, int start, int target, final int[] candidates) {
+
+ if (target == 0) {
+ combinations.add(new ArrayList<>(tempCombination));
+ return;
+ }
+ for (int i = start; i < candidates.length; i++) {
+ if (i != 0 && candidates[i] == candidates[i - 1] && !hasVisited[i - 1]) {
+ continue;
+ }
+ if (candidates[i] <= target) {
+ tempCombination.add(candidates[i]);
+ hasVisited[i] = true;
+ backtracking(tempCombination, combinations, hasVisited, i + 1, target - candidates[i], candidates);
+ hasVisited[i] = false;
+ tempCombination.remove(tempCombination.size() - 1);
+ }
+ }
+}
+```
+
+**1-9 数字的组合求和**
+
+[216. Combination Sum III (Medium)](https://leetcode.com/problems/combination-sum-iii/description/)
+
+```html
+Input: k = 3, n = 9
+
+Output:
+
+[[1,2,6], [1,3,5], [2,3,4]]
+```
+
+从 1-9 数字中选出 k 个数不重复的数，使得它们的和为 n。
+
+```java
+public List> combinationSum3(int k, int n) {
+ List> combinations = new ArrayList<>();
+ List path = new ArrayList<>();
+ backtracking(k, n, 1, path, combinations);
+ return combinations;
+}
+
+private void backtracking(int k, int n, int start,
+ List tempCombination, List> combinations) {
+
+ if (k == 0 && n == 0) {
+ combinations.add(new ArrayList<>(tempCombination));
+ return;
+ }
+ if (k == 0 || n == 0) {
+ return;
+ }
+ for (int i = start; i <= 9; i++) {
+ tempCombination.add(i);
+ backtracking(k - 1, n - i, i + 1, tempCombination, combinations);
+ tempCombination.remove(tempCombination.size() - 1);
+ }
+}
+```
+
+**子集**
+
+[78. Subsets (Medium)](https://leetcode.com/problems/subsets/description/)
+
+找出集合的所有子集，子集不能重复，[1, 2] 和 [2, 1] 这种子集算重复
+
+```java
+public List> subsets(int[] nums) {
+ List> subsets = new ArrayList<>();
+ List tempSubset = new ArrayList<>();
+ for (int size = 0; size <= nums.length; size++) {
+ backtracking(0, tempSubset, subsets, size, nums); // 不同的子集大小
+ }
+ return subsets;
+}
+
+private void backtracking(int start, List tempSubset, List> subsets,
+ final int size, final int[] nums) {
+
+ if (tempSubset.size() == size) {
+ subsets.add(new ArrayList<>(tempSubset));
+ return;
+ }
+ for (int i = start; i < nums.length; i++) {
+ tempSubset.add(nums[i]);
+ backtracking(i + 1, tempSubset, subsets, size, nums);
+ tempSubset.remove(tempSubset.size() - 1);
+ }
+}
+```
+
+**含有相同元素求子集**
+
+[90. Subsets II (Medium)](https://leetcode.com/problems/subsets-ii/description/)
+
+```html
+For example,
+If nums = [1,2,2], a solution is:
+
+[
+ [2],
+ [1],
+ [1,2,2],
+ [2,2],
+ [1,2],
+ []
+]
+```
+
+```java
+public List> subsetsWithDup(int[] nums) {
+ Arrays.sort(nums);
+ List> subsets = new ArrayList<>();
+ List tempSubset = new ArrayList<>();
+ boolean[] hasVisited = new boolean[nums.length];
+ for (int size = 0; size <= nums.length; size++) {
+ backtracking(0, tempSubset, subsets, hasVisited, size, nums); // 不同的子集大小
+ }
+ return subsets;
+}
+
+private void backtracking(int start, List tempSubset, List> subsets, boolean[] hasVisited,
+ final int size, final int[] nums) {
+
+ if (tempSubset.size() == size) {
+ subsets.add(new ArrayList<>(tempSubset));
+ return;
+ }
+ for (int i = start; i < nums.length; i++) {
+ if (i != 0 && nums[i] == nums[i - 1] && !hasVisited[i - 1]) {
+ continue;
+ }
+ tempSubset.add(nums[i]);
+ hasVisited[i] = true;
+ backtracking(i + 1, tempSubset, subsets, hasVisited, size, nums);
+ hasVisited[i] = false;
+ tempSubset.remove(tempSubset.size() - 1);
+ }
+}
+```
+
+**分割字符串使得每个部分都是回文数**
+
+[131. Palindrome Partitioning (Medium)](https://leetcode.com/problems/palindrome-partitioning/description/)
+
+```html
+For example, given s = "aab",
+Return
+
+[
+ ["aa","b"],
+ ["a","a","b"]
+]
+```
+
+```java
+public List> partition(String s) {
+ List> partitions = new ArrayList<>();
+ List tempPartition = new ArrayList<>();
+ doPartition(s, partitions, tempPartition);
+ return partitions;
+}
+
+private void doPartition(String s, List> partitions, List tempPartition) {
+ if (s.length() == 0) {
+ partitions.add(new ArrayList<>(tempPartition));
+ return;
+ }
+ for (int i = 0; i < s.length(); i++) {
+ if (isPalindrome(s, 0, i)) {
+ tempPartition.add(s.substring(0, i + 1));
+ doPartition(s.substring(i + 1), partitions, tempPartition);
+ tempPartition.remove(tempPartition.size() - 1);
+ }
+ }
+}
+
+private boolean isPalindrome(String s, int begin, int end) {
+ while (begin < end) {
+ if (s.charAt(begin++) != s.charAt(end--)) {
+ return false;
+ }
+ }
+ return true;
+}
+```
+
+**数独**
+
+[37. Sudoku Solver (Hard)](https://leetcode.com/problems/sudoku-solver/description/)
+
+ > solutions;
+private char[][] nQueens;
+private boolean[] colUsed;
+private boolean[] diagonals45Used;
+private boolean[] diagonals135Used;
+private int n;
+
+public List> solveNQueens(int n) {
+ solutions = new ArrayList<>();
+ nQueens = new char[n][n];
+ for (int i = 0; i < n; i++) {
+ Arrays.fill(nQueens[i], '.');
+ }
+ colUsed = new boolean[n];
+ diagonals45Used = new boolean[2 * n - 1];
+ diagonals135Used = new boolean[2 * n - 1];
+ this.n = n;
+ backtracking(0);
+ return solutions;
+}
+
+private void backtracking(int row) {
+ if (row == n) {
+ List list = new ArrayList<>();
+ for (char[] chars : nQueens) {
+ list.add(new String(chars));
+ }
+ solutions.add(list);
+ return;
+ }
+
+ for (int col = 0; col < n; col++) {
+ int diagonals45Idx = row + col;
+ int diagonals135Idx = n - 1 - (row - col);
+ if (colUsed[col] || diagonals45Used[diagonals45Idx] || diagonals135Used[diagonals135Idx]) {
+ continue;
+ }
+ nQueens[row][col] = 'Q';
+ colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = true;
+ backtracking(row + 1);
+ colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = false;
+ nQueens[row][col] = '.';
+ }
+}
+```
+
+## 动态规划
+
+递归和动态规划都是将原问题拆成多个子问题然后求解，他们之间最本质的区别是，动态规划保存了子问题的解，避免重复计算。
+
+### 斐波那契数列
+
+**爬楼梯**
+
+[70. Climbing Stairs (Easy)](https://leetcode.com/problems/climbing-stairs/description/)
+
+题目描述：有 N 阶楼梯，每次可以上一阶或者两阶，求有多少种上楼梯的方法。
+
+定义一个数组 dp 存储上楼梯的方法数（为了方便讨论，数组下标从 1 开始），dp[i] 表示走到第 i 个楼梯的方法数目。
+
+第 i 个楼梯可以从第 i-1 和 i-2 个楼梯再走一步到达，走到第 i 个楼梯的方法数为走到第 i-1 和第 i-2 个楼梯的方法数之和。
+
+ squareList = generateSquareList(n);
+ int[] dp = new int[n + 1];
+ for (int i = 1; i <= n; i++) {
+ int min = Integer.MAX_VALUE;
+ for (int square : squareList) {
+ if (square > i) {
+ break;
+ }
+ min = Math.min(min, dp[i - square] + 1);
+ }
+ dp[i] = min;
+ }
+ return dp[n];
+}
+
+private List generateSquareList(int n) {
+ List squareList = new ArrayList<>();
+ int diff = 3;
+ int square = 1;
+ while (square <= n) {
+ squareList.add(square);
+ square += diff;
+ diff += 2;
+ }
+ return squareList;
+}
+```
+
+**分割整数构成字母字符串**
+
+[91. Decode Ways (Medium)](https://leetcode.com/problems/decode-ways/description/)
+
+题目描述：Given encoded message "12", it could be decoded as "AB" (1 2) or "L" (12).
+
+```java
+public int numDecodings(String s) {
+ if (s == null || s.length() == 0) {
+ return 0;
+ }
+ int n = s.length();
+ int[] dp = new int[n + 1];
+ dp[0] = 1;
+ dp[1] = s.charAt(0) == '0' ? 0 : 1;
+ for (int i = 2; i <= n; i++) {
+ int one = Integer.valueOf(s.substring(i - 1, i));
+ if (one != 0) {
+ dp[i] += dp[i - 1];
+ }
+ if (s.charAt(i - 2) == '0') {
+ continue;
+ }
+ int two = Integer.valueOf(s.substring(i - 2, i));
+ if (two <= 26) {
+ dp[i] += dp[i - 2];
+ }
+ }
+ return dp[n];
+}
+```
+
+### 最长递增子序列
+
+已知一个序列 {S1 , S2 ,...,Sn }，取出若干数组成新的序列 {Si1 , Si2 ,..., Sim }，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个 **子序列** 。
+
+如果在子序列中，当下标 ix > iy 时，Six > Siy ，称子序列为原序列的一个 **递增子序列** 。
+
+定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 Sn 结尾的序列的最长递增子序列长度。对于一个递增子序列 {Si1 , Si2 ,...,Sim }，如果 im < n 并且 Sim < Sn ，此时 {Si1 , Si2 ,..., Sim , Sn } 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 Sn 就构成了以 Sn 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | Si < Sn && i < n} 。
+
+因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {Sn } 就构成了递增子序列，需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：
+
+ N 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，max{ dp[i] | 1 <= i <= N} 即为所求。
+
+**最长递增子序列**
+
+[300. Longest Increasing Subsequence (Medium)](https://leetcode.com/problems/longest-increasing-subsequence/description/)
+
+```java
+public int lengthOfLIS(int[] nums) {
+ int n = nums.length;
+ int[] dp = new int[n];
+ for (int i = 0; i < n; i++) {
+ int max = 1;
+ for (int j = 0; j < i; j++) {
+ if (nums[i] > nums[j]) {
+ max = Math.max(max, dp[j] + 1);
+ }
+ }
+ dp[i] = max;
+ }
+ return Arrays.stream(dp).max().orElse(0);
+}
+```
+
+使用 Stream 求最大值会导致运行时间过长，可以改成以下形式：
+
+```java
+int ret = 0;
+for (int i = 0; i < n; i++) {
+ ret = Math.max(ret, dp[i]);
+}
+return ret;
+```
+
+以上解法的时间复杂度为 O(N2 )，可以使用二分查找将时间复杂度降低为 O(NlogN)。
+
+定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素。对于一个元素 x，
+
+- 如果它大于 tails 数组所有的值，那么把它添加到 tails 后面，表示最长递增子序列长度加 1；
+- 如果 tails[i-1] < x <= tails[i]，那么更新 tails[i] = x。
+
+例如对于数组 [4,3,6,5]，有：
+
+```html
+tails len num
+[] 0 4
+[4] 1 3
+[3] 1 6
+[3,6] 2 5
+[3,5] 2 null
+```
+
+可以看出 tails 数组保持有序，因此在查找 Si 位于 tails 数组的位置时就可以使用二分查找。
+
+```java
+public int lengthOfLIS(int[] nums) {
+ int n = nums.length;
+ int[] tails = new int[n];
+ int len = 0;
+ for (int num : nums) {
+ int index = binarySearch(tails, len, num);
+ tails[index] = num;
+ if (index == len) {
+ len++;
+ }
+ }
+ return len;
+}
+
+private int binarySearch(int[] tails, int len, int key) {
+ int l = 0, h = len;
+ while (l < h) {
+ int mid = l + (h - l) / 2;
+ if (tails[mid] == key) {
+ return mid;
+ } else if (tails[mid] > key) {
+ h = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ return l;
+}
+```
+
+**一组整数对能够构成的最长链**
+
+[646. Maximum Length of Pair Chain (Medium)](https://leetcode.com/problems/maximum-length-of-pair-chain/description/)
+
+```html
+Input: [[1,2], [2,3], [3,4]]
+Output: 2
+Explanation: The longest chain is [1,2] -> [3,4]
+```
+
+题目描述：对于 (a, b) 和 (c, d) ，如果 b < c，则它们可以构成一条链。
+
+```java
+public int findLongestChain(int[][] pairs) {
+ if (pairs == null || pairs.length == 0) {
+ return 0;
+ }
+ Arrays.sort(pairs, (a, b) -> (a[0] - b[0]));
+ int n = pairs.length;
+ int[] dp = new int[n];
+ Arrays.fill(dp, 1);
+ for (int i = 1; i < n; i++) {
+ for (int j = 0; j < i; j++) {
+ if (pairs[j][1] < pairs[i][0]) {
+ dp[i] = Math.max(dp[i], dp[j] + 1);
+ }
+ }
+ }
+ return Arrays.stream(dp).max().orElse(0);
+}
+```
+
+**最长摆动子序列**
+
+[376. Wiggle Subsequence (Medium)](https://leetcode.com/problems/wiggle-subsequence/description/)
+
+```html
+Input: [1,7,4,9,2,5]
+Output: 6
+The entire sequence is a wiggle sequence.
+
+Input: [1,17,5,10,13,15,10,5,16,8]
+Output: 7
+There are several subsequences that achieve this length. One is [1,17,10,13,10,16,8].
+
+Input: [1,2,3,4,5,6,7,8,9]
+Output: 2
+```
+
+要求：使用 O(N) 时间复杂度求解。
+
+```java
+public int wiggleMaxLength(int[] nums) {
+ if (nums == null || nums.length == 0) {
+ return 0;
+ }
+ int up = 1, down = 1;
+ for (int i = 1; i < nums.length; i++) {
+ if (nums[i] > nums[i - 1]) {
+ up = down + 1;
+ } else if (nums[i] < nums[i - 1]) {
+ down = up + 1;
+ }
+ }
+ return Math.max(up, down);
+}
+```
+
+### 最长公共子序列
+
+对于两个子序列 S1 和 S2，找出它们最长的公共子序列。
+
+定义一个二维数组 dp 用来存储最长公共子序列的长度，其中 dp[i][j] 表示 S1 的前 i 个字符与 S2 的前 j 个字符最长公共子序列的长度。考虑 S1i 与 S2j 值是否相等，分为两种情况：
+
+- 当 S1i ==S2j 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1i 这个值，最长公共子序列长度加 1，即 dp[i][j] = dp[i-1][j-1] + 1。
+- 当 S1i != S2j 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，或者 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，取它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。
+
+综上，最长公共子序列的状态转移方程为：
+
+ 1 和长度为 M 的序列 S2 ，dp[N][M] 就是序列 S1 和序列 S2 的最长公共子序列长度。
+
+与最长递增子序列相比，最长公共子序列有以下不同点：
+
+- 针对的是两个序列，求它们的最长公共子序列。
+- 在最长递增子序列中，dp[i] 表示以 Si 为结尾的最长递增子序列长度，子序列必须包含 Si ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1i 和 S2j 。
+- 在求最终解时，最长公共子序列中 dp[N][M] 就是最终解，而最长递增子序列中 dp[N] 不是最终解，因为以 SN 为结尾的最长递增子序列不一定是整个序列最长递增子序列，需要遍历一遍 dp 数组找到最大者。
+
+```java
+public int lengthOfLCS(int[] nums1, int[] nums2) {
+ int n1 = nums1.length, n2 = nums2.length;
+ int[][] dp = new int[n1 + 1][n2 + 1];
+ for (int i = 1; i <= n1; i++) {
+ for (int j = 1; j <= n2; j++) {
+ if (nums1[i - 1] == nums2[j - 1]) {
+ dp[i][j] = dp[i - 1][j - 1] + 1;
+ } else {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+ }
+ }
+ }
+ return dp[n1][n2];
+}
+```
+
+### 0-1 背包
+
+有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w 和价值 v。
+
+定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示前 i 件物品体积不超过 j 的情况下能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论：
+
+- 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最大价值就是总体积不超过 j 的前 i-1 件物品的最大价值，dp[i][j] = dp[i-1][j]。
+- 第 i 件物品添加到背包中，dp[i][j] = dp[i-1][j-w] + v。
+
+第 i 件物品可添加也可以不添加，取决于哪种情况下最大价值更大。因此，0-1 背包的状态转移方程为：
+
+ wordDict) {
+ int n = s.length();
+ boolean[] dp = new boolean[n + 1];
+ dp[0] = true;
+ for (int i = 1; i <= n; i++) {
+ for (String word : wordDict) { // 完全一个物品可以使用多次
+ int len = word.length();
+ if (len <= i && word.equals(s.substring(i - len, i))) {
+ dp[i] = dp[i] || dp[i - len];
+ }
+ }
+ }
+ return dp[n];
+}
+```
+
+**01 字符构成最多的字符串**
+
+[474. Ones and Zeroes (Medium)](https://leetcode.com/problems/ones-and-zeroes/description/)
+
+```html
+Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
+Output: 4
+
+Explanation: There are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are "10","0001","1","0"
+```
+
+这是一个多维费用的 0-1 背包问题，有两个背包大小，0 的数量和 1 的数量。
+
+```java
+public int findMaxForm(String[] strs, int m, int n) {
+ if (strs == null || strs.length == 0) {
+ return 0;
+ }
+ int[][] dp = new int[m + 1][n + 1];
+ for (String s : strs) { // 每个字符串只能用一次
+ int ones = 0, zeros = 0;
+ for (char c : s.toCharArray()) {
+ if (c == '0') {
+ zeros++;
+ } else {
+ ones++;
+ }
+ }
+ for (int i = m; i >= zeros; i--) {
+ for (int j = n; j >= ones; j--) {
+ dp[i][j] = Math.max(dp[i][j], dp[i - zeros][j - ones] + 1);
+ }
+ }
+ }
+ return dp[m][n];
+}
+```
+
+**找零钱的最少硬币数**
+
+[322. Coin Change (Medium)](https://leetcode.com/problems/coin-change/description/)
+
+```html
+Example 1:
+coins = [1, 2, 5], amount = 11
+return 3 (11 = 5 + 5 + 1)
+
+Example 2:
+coins = [2], amount = 3
+return -1.
+```
+
+题目描述：给一些面额的硬币，要求用这些硬币来组成给定面额的钱数，并且使得硬币数量最少。硬币可以重复使用。
+
+- 物品：硬币
+- 物品大小：面额
+- 物品价值：数量
+
+因为硬币可以重复使用，因此这是一个完全背包问题。
+
+```java
+public int coinChange(int[] coins, int amount) {
+ if (coins == null || coins.length == 0) {
+ return 0;
+ }
+ int[] minimum = new int[amount + 1];
+ Arrays.fill(minimum, amount + 1);
+ minimum[0] = 0;
+ Arrays.sort(coins);
+ for (int i = 1; i <= amount; i++) {
+ for (int j = 0; j < coins.length && coins[j] <= i; j++) {
+ minimum[i] = Math.min(minimum[i], minimum[i - coins[j]] + 1);
+ }
+ }
+ return minimum[amount] > amount ? -1 : minimum[amount];
+}
+```
+
+**组合总和**
+
+[377. Combination Sum IV (Medium)](https://leetcode.com/problems/combination-sum-iv/description/)
+
+```html
+nums = [1, 2, 3]
+target = 4
+
+The possible combination ways are:
+(1, 1, 1, 1)
+(1, 1, 2)
+(1, 2, 1)
+(1, 3)
+(2, 1, 1)
+(2, 2)
+(3, 1)
+
+Note that different sequences are counted as different combinations.
+
+Therefore the output is 7.
+```
+
+完全背包。
+
+```java
+public int combinationSum4(int[] nums, int target) {
+ if (nums == null || nums.length == 0) {
+ return 0;
+ }
+ int[] maximum = new int[target + 1];
+ maximum[0] = 1;
+ Arrays.sort(nums);
+ for (int i = 1; i <= target; i++) {
+ for (int j = 0; j < nums.length && nums[j] <= i; j++) {
+ maximum[i] += maximum[i - nums[j]];
+ }
+ }
+ return maximum[target];
+}
+```
+
+### 股票交易
+
+**需要冷却期的股票交易**
+
+[309. Best Time to Buy and Sell Stock with Cooldown(Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/)
+
+题目描述：交易之后需要有一天的冷却时间。
+
+2 \* 31 \* 50 \* 71 \* 110 \* 130 \* 170 \* …
+
+**整除**
+
+令 x = 2m0 \* 3m1 \* 5m2 \* 7m3 \* 11m4 \* …
+
+令 y = 2n0 \* 3n1 \* 5n2 \* 7n3 \* 11n4 \* …
+
+如果 x 整除 y（y mod x == 0），则对于所有 i，mi <= ni。
+
+**最大公约数最小公倍数**
+
+x 和 y 的最大公约数为：gcd(x,y) = 2min(m0,n0) \* 3min(m1,n1) \* 5min(m2,n2) \* ...
+
+x 和 y 的最小公倍数为：lcm(x,y) = 2max(m0,n0) \* 3max(m1,n1) \* 5max(m2,n2) \* ...
+
+**生成素数序列**
+
+[204. Count Primes (Easy)](https://leetcode.com/problems/count-primes/description/)
+
+埃拉托斯特尼筛法在每次找到一个素数时，将能被素数整除的数排除掉。
+
+```java
+public int countPrimes(int n) {
+ boolean[] notPrimes = new boolean[n + 1];
+ int count = 0;
+ for (int i = 2; i < n; i++) {
+ if (notPrimes[i]) {
+ continue;
+ }
+ count++;
+ // 从 i * i 开始，因为如果 k < i，那么 k * i 在之前就已经被去除过了
+ for (long j = (long) (i) * i; j < n; j += i) {
+ notPrimes[(int) j] = true;
+ }
+ }
+ return count;
+}
+```
+
+### 最大公约数
+
+```java
+int gcd(int a, int b) {
+ return b == 0 ? a : gcd(b, a % b);
+}
+```
+
+最小公倍数为两数的乘积除以最大公约数。
+
+```java
+int lcm(int a, int b) {
+ return a * b / gcd(a, b);
+}
+```
+
+**使用位操作和减法求解最大公约数**
+
+[编程之美：2.7](#)
+
+对于 a 和 b 的最大公约数 f(a, b)，有：
+
+- 如果 a 和 b 均为偶数，f(a, b) = 2\*f(a/2, b/2);
+- 如果 a 是偶数 b 是奇数，f(a, b) = f(a/2, b);
+- 如果 b 是偶数 a 是奇数，f(a, b) = f(a, b/2);
+- 如果 a 和 b 均为奇数，f(a, b) = f(b, a-b);
+
+乘 2 和除 2 都可以转换为移位操作。
+
+```java
+public int gcd(int a, int b) {
+ if (a < b) {
+ return gcd(b, a);
+ }
+ if (b == 0) {
+ return a;
+ }
+ boolean isAEven = isEven(a), isBEven = isEven(b);
+ if (isAEven && isBEven) {
+ return 2 * gcd(a >> 1, b >> 1);
+ } else if (isAEven && !isBEven) {
+ return gcd(a >> 1, b);
+ } else if (!isAEven && isBEven) {
+ return gcd(a, b >> 1);
+ } else {
+ return gcd(b, a - b);
+ }
+}
+```
+
+### 进制转换
+
+**7 进制**
+
+[504. Base 7 (Easy)](https://leetcode.com/problems/base-7/description/)
+
+```java
+public String convertToBase7(int num) {
+ if (num == 0) {
+ return "0";
+ }
+ StringBuilder sb = new StringBuilder();
+ boolean isNegative = num < 0;
+ if (isNegative) {
+ num = -num;
+ }
+ while (num > 0) {
+ sb.append(num % 7);
+ num /= 7;
+ }
+ String ret = sb.reverse().toString();
+ return isNegative ? "-" + ret : ret;
+}
+```
+
+Java 中 static String toString(int num, int radix) 可以将一个整数转换为 radix 进制表示的字符串。
+
+```java
+public String convertToBase7(int num) {
+ return Integer.toString(num, 7);
+}
+```
+
+**16 进制**
+
+[405. Convert a Number to Hexadecimal (Easy)](https://leetcode.com/problems/convert-a-number-to-hexadecimal/description/)
+
+```html
+Input:
+26
+
+Output:
+"1a"
+
+Input:
+-1
+
+Output:
+"ffffffff"
+```
+
+负数要用它的补码形式。
+
+```java
+public String toHex(int num) {
+ char[] map = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+ if (num == 0) return "0";
+ StringBuilder sb = new StringBuilder();
+ while (num != 0) {
+ sb.append(map[num & 0b1111]);
+ num >>>= 4; // 因为考虑的是补码形式，因此符号位就不能有特殊的意义，需要使用无符号右移，左边填 0
+ }
+ return sb.reverse().toString();
+}
+```
+
+**26 进制**
+
+[168. Excel Sheet Column Title (Easy)](https://leetcode.com/problems/excel-sheet-column-title/description/)
+
+```html
+1 -> A
+2 -> B
+3 -> C
+...
+26 -> Z
+27 -> AA
+28 -> AB
+```
+
+因为是从 1 开始计算的，而不是从 0 开始，因此需要对 n 执行 -1 操作。
+
+```java
+public String convertToTitle(int n) {
+ if (n == 0) {
+ return "";
+ }
+ n--;
+ return convertToTitle(n / 26) + (char) (n % 26 + 'A');
+}
+```
+
+### 阶乘
+
+**统计阶乘尾部有多少个 0**
+
+[172. Factorial Trailing Zeroes (Easy)](https://leetcode.com/problems/factorial-trailing-zeroes/description/)
+
+尾部的 0 由 2 * 5 得来，2 的数量明显多于 5 的数量，因此只要统计有多少个 5 即可。
+
+对于一个数 N，它所包含 5 的个数为：N/5 + N/52 + N/53 + ...，其中 N/5 表示不大于 N 的数中 5 的倍数贡献一个 5，N/52 表示不大于 N 的数中 52 的倍数再贡献一个 5 ...。
+
+```java
+public int trailingZeroes(int n) {
+ return n == 0 ? 0 : n / 5 + trailingZeroes(n / 5);
+}
+```
+
+如果统计的是 N! 的二进制表示中最低位 1 的位置，只要统计有多少个 2 即可，该题目出自 [编程之美：2.2](#) 。和求解有多少个 5 一样，2 的个数为 N/2 + N/22 + N/23 + ...
+
+### 字符串加法减法
+
+**二进制加法**
+
+[67. Add Binary (Easy)](https://leetcode.com/problems/add-binary/description/)
+
+```html
+a = "11"
+b = "1"
+Return "100".
+```
+
+```java
+public String addBinary(String a, String b) {
+ int i = a.length() - 1, j = b.length() - 1, carry = 0;
+ StringBuilder str = new StringBuilder();
+ while (carry == 1 || i >= 0 || j >= 0) {
+ if (i >= 0 && a.charAt(i--) == '1') {
+ carry++;
+ }
+ if (j >= 0 && b.charAt(j--) == '1') {
+ carry++;
+ }
+ str.append(carry % 2);
+ carry /= 2;
+ }
+ return str.reverse().toString();
+}
+```
+
+**字符串加法**
+
+[415. Add Strings (Easy)](https://leetcode.com/problems/add-strings/description/)
+
+字符串的值为非负整数。
+
+```java
+public String addStrings(String num1, String num2) {
+ StringBuilder str = new StringBuilder();
+ int carry = 0, i = num1.length() - 1, j = num2.length() - 1;
+ while (carry == 1 || i >= 0 || j >= 0) {
+ int x = i < 0 ? 0 : num1.charAt(i--) - '0';
+ int y = j < 0 ? 0 : num2.charAt(j--) - '0';
+ str.append((x + y + carry) % 10);
+ carry = (x + y + carry) / 10;
+ }
+ return str.reverse().toString();
+}
+```
+
+### 相遇问题
+
+**改变数组元素使所有的数组元素都相等**
+
+[462. Minimum Moves to Equal Array Elements II (Medium)](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/description/)
+
+```html
+Input:
+[1,2,3]
+
+Output:
+2
+
+Explanation:
+Only two moves are needed (remember each move increments or decrements one element):
+
+[1,2,3] => [2,2,3] => [2,2,2]
+```
+
+每次可以对一个数组元素加一或者减一，求最小的改变次数。
+
+这是个典型的相遇问题，移动距离最小的方式是所有元素都移动到中位数。理由如下：
+
+设 m 为中位数。a 和 b 是 m 两边的两个元素，且 b > a。要使 a 和 b 相等，它们总共移动的次数为 b - a，这个值等于 (b - m) + (m - a)，也就是把这两个数移动到中位数的移动次数。
+
+设数组长度为 N，则可以找到 N/2 对 a 和 b 的组合，使它们都移动到 m 的位置。
+
+**解法 1**
+
+先排序，时间复杂度：O(NlogN)
+
+```java
+public int minMoves2(int[] nums) {
+ Arrays.sort(nums);
+ int move = 0;
+ int l = 0, h = nums.length - 1;
+ while (l <= h) {
+ move += nums[h] - nums[l];
+ l++;
+ h--;
+ }
+ return move;
+}
+```
+
+**解法 2**
+
+使用快速选择找到中位数，时间复杂度 O(N)
+
+```java
+public int minMoves2(int[] nums) {
+ int move = 0;
+ int median = findKthSmallest(nums, nums.length / 2);
+ for (int num : nums) {
+ move += Math.abs(num - median);
+ }
+ return move;
+}
+
+private int findKthSmallest(int[] nums, int k) {
+ int l = 0, h = nums.length - 1;
+ while (l < h) {
+ int j = partition(nums, l, h);
+ if (j == k) {
+ break;
+ }
+ if (j < k) {
+ l = j + 1;
+ } else {
+ h = j - 1;
+ }
+ }
+ return nums[k];
+}
+
+private int partition(int[] nums, int l, int h) {
+ int i = l, j = h + 1;
+ while (true) {
+ while (nums[++i] < nums[l] && i < h) ;
+ while (nums[--j] > nums[l] && j > l) ;
+ if (i >= j) {
+ break;
+ }
+ swap(nums, i, j);
+ }
+ swap(nums, l, j);
+ return j;
+}
+
+private void swap(int[] nums, int i, int j) {
+ int tmp = nums[i];
+ nums[i] = nums[j];
+ nums[j] = tmp;
+}
+```
+
+### 多数投票问题
+
+**数组中出现次数多于 n / 2 的元素**
+
+[169. Majority Element (Easy)](https://leetcode.com/problems/majority-element/description/)
+
+先对数组排序，最中间那个数出现次数一定多于 n / 2。
+
+```java
+public int majorityElement(int[] nums) {
+ Arrays.sort(nums);
+ return nums[nums.length / 2];
+}
+```
+
+可以利用 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。
+
+```java
+public int majorityElement(int[] nums) {
+ int cnt = 0, majority = nums[0];
+ for (int num : nums) {
+ majority = (cnt == 0) ? num : majority;
+ cnt = (majority == num) ? cnt + 1 : cnt - 1;
+ }
+ return majority;
+}
+```
+
+### 其它
+
+**平方数**
+
+[367. Valid Perfect Square (Easy)](https://leetcode.com/problems/valid-perfect-square/description/)
+
+```html
+Input: 16
+Returns: True
+```
+
+平方序列：1,4,9,16,..
+
+间隔：3,5,7,...
+
+间隔为等差数列，使用这个特性可以得到从 1 开始的平方序列。
+
+```java
+public boolean isPerfectSquare(int num) {
+ int subNum = 1;
+ while (num > 0) {
+ num -= subNum;
+ subNum += 2;
+ }
+ return num == 0;
+}
+```
+
+**3 的 n 次方**
+
+[326. Power of Three (Easy)](https://leetcode.com/problems/power-of-three/description/)
+
+```java
+public boolean isPowerOfThree(int n) {
+ return n > 0 && (1162261467 % n == 0);
+}
+```
+
+**乘积数组**
+
+[238. Product of Array Except Self (Medium)](https://leetcode.com/problems/product-of-array-except-self/description/)
+
+```html
+For example, given [1,2,3,4], return [24,12,8,6].
+```
+
+给定一个数组，创建一个新数组，新数组的每个元素为原始数组中除了该位置上的元素之外所有元素的乘积。
+
+要求时间复杂度为 O(N)，并且不能使用除法。
+
+```java
+public int[] productExceptSelf(int[] nums) {
+ int n = nums.length;
+ int[] products = new int[n];
+ Arrays.fill(products, 1);
+ int left = 1;
+ for (int i = 1; i < n; i++) {
+ left *= nums[i - 1];
+ products[i] *= left;
+ }
+ int right = 1;
+ for (int i = n - 2; i >= 0; i--) {
+ right *= nums[i + 1];
+ products[i] *= right;
+ }
+ return products;
+}
+```
+
+**找出数组中的乘积最大的三个数**
+
+[628. Maximum Product of Three Numbers (Easy)](https://leetcode.com/problems/maximum-product-of-three-numbers/description/)
+
+```html
+Input: [1,2,3,4]
+Output: 24
+```
+
+```java
+public int maximumProduct(int[] nums) {
+ int max1 = Integer.MIN_VALUE, max2 = Integer.MIN_VALUE, max3 = Integer.MIN_VALUE, min1 = Integer.MAX_VALUE, min2 = Integer.MAX_VALUE;
+ for (int n : nums) {
+ if (n > max1) {
+ max3 = max2;
+ max2 = max1;
+ max1 = n;
+ } else if (n > max2) {
+ max3 = max2;
+ max2 = n;
+ } else if (n > max3) {
+ max3 = n;
+ }
+
+ if (n < min1) {
+ min2 = min1;
+ min1 = n;
+ } else if (n < min2) {
+ min2 = n;
+ }
+ }
+ return Math.max(max1*max2*max3, max1*min1*min2);
+}
+```
+
+# 数据结构相关
+
+## 链表
+
+链表是空节点，或者有一个值和一个指向下一个链表的指针，因此很多链表问题可以用递归来处理。
+
+**找出两个链表的交点**
+
+[160. Intersection of Two Linked Lists (Easy)](https://leetcode.com/problems/intersection-of-two-linked-lists/description/)
+
+```html
+A: a1 → a2
+ ↘
+ c1 → c2 → c3
+ ↗
+B: b1 → b2 → b3
+```
+
+要求：时间复杂度为 O(N)，空间复杂度为 O(1)
+
+设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
+
+当访问 A 链表的指针访问到链表尾部时，令它从链表 B 的头部开始访问链表 B；同样地，当访问 B 链表的指针访问到链表尾部时，令它从链表 A 的头部开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
+
+```java
+public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+ ListNode l1 = headA, l2 = headB;
+ while (l1 != l2) {
+ l1 = (l1 == null) ? headB : l1.next;
+ l2 = (l2 == null) ? headA : l2.next;
+ }
+ return l1;
+}
+```
+
+如果只是判断是否存在交点，那么就是另一个问题，即 [编程之美 3.6]() 的问题。有两种解法：
+
+- 把第一个链表的结尾连接到第二个链表的开头，看第二个链表是否存在环；
+- 或者直接比较两个链表的最后一个节点是否相同。
+
+**链表反转**
+
+[206. Reverse Linked List (Easy)](https://leetcode.com/problems/reverse-linked-list/description/)
+
+递归
+
+```java
+public ListNode reverseList(ListNode head) {
+ if (head == null || head.next == null) {
+ return head;
+ }
+ ListNode next = head.next;
+ ListNode newHead = reverseList(next);
+ next.next = head;
+ head.next = null;
+ return newHead;
+}
+```
+
+头插法
+
+```java
+public ListNode reverseList(ListNode head) {
+ ListNode newHead = new ListNode(-1);
+ while (head != null) {
+ ListNode next = head.next;
+ head.next = newHead.next;
+ newHead.next = head;
+ head = next;
+ }
+ return newHead.next;
+}
+```
+
+**归并两个有序的链表**
+
+[21. Merge Two Sorted Lists (Easy)](https://leetcode.com/problems/merge-two-sorted-lists/description/)
+
+```java
+public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+ if (l1 == null) return l2;
+ if (l2 == null) return l1;
+ if (l1.val < l2.val) {
+ l1.next = mergeTwoLists(l1.next, l2);
+ return l1;
+ } else {
+ l2.next = mergeTwoLists(l1, l2.next);
+ return l2;
+ }
+}
+```
+
+**从有序链表中删除重复节点**
+
+[83. Remove Duplicates from Sorted List (Easy)](https://leetcode.com/problems/remove-duplicates-from-sorted-list/description/)
+
+```html
+Given 1->1->2, return 1->2.
+Given 1->1->2->3->3, return 1->2->3.
+```
+
+```java
+public ListNode deleteDuplicates(ListNode head) {
+ if (head == null || head.next == null) return head;
+ head.next = deleteDuplicates(head.next);
+ return head.val == head.next.val ? head.next : head;
+}
+```
+
+**删除链表的倒数第 n 个节点**
+
+[19. Remove Nth Node From End of List (Medium)](https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/)
+
+```html
+Given linked list: 1->2->3->4->5, and n = 2.
+After removing the second node from the end, the linked list becomes 1->2->3->5.
+```
+
+```java
+public ListNode removeNthFromEnd(ListNode head, int n) {
+ ListNode fast = head;
+ while (n-- > 0) {
+ fast = fast.next;
+ }
+ if (fast == null) return head.next;
+ ListNode slow = head;
+ while (fast.next != null) {
+ fast = fast.next;
+ slow = slow.next;
+ }
+ slow.next = slow.next.next;
+ return head;
+}
+```
+
+**交换链表中的相邻结点**
+
+[24. Swap Nodes in Pairs (Medium)](https://leetcode.com/problems/swap-nodes-in-pairs/description/)
+
+```html
+Given 1->2->3->4, you should return the list as 2->1->4->3.
+```
+
+题目要求：不能修改结点的 val 值，O(1) 空间复杂度。
+
+```java
+public ListNode swapPairs(ListNode head) {
+ ListNode node = new ListNode(-1);
+ node.next = head;
+ ListNode pre = node;
+ while (pre.next != null && pre.next.next != null) {
+ ListNode l1 = pre.next, l2 = pre.next.next;
+ ListNode next = l2.next;
+ l1.next = next;
+ l2.next = l1;
+ pre.next = l2;
+
+ pre = l1;
+ }
+ return node.next;
+}
+```
+
+**链表求和**
+
+[445. Add Two Numbers II (Medium)](https://leetcode.com/problems/add-two-numbers-ii/description/)
+
+```html
+Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
+Output: 7 -> 8 -> 0 -> 7
+```
+
+题目要求：不能修改原始链表。
+
+```java
+public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+ Stack l1Stack = buildStack(l1);
+ Stack l2Stack = buildStack(l2);
+ ListNode head = new ListNode(-1);
+ int carry = 0;
+ while (!l1Stack.isEmpty() || !l2Stack.isEmpty() || carry != 0) {
+ int x = l1Stack.isEmpty() ? 0 : l1Stack.pop();
+ int y = l2Stack.isEmpty() ? 0 : l2Stack.pop();
+ int sum = x + y + carry;
+ ListNode node = new ListNode(sum % 10);
+ node.next = head.next;
+ head.next = node;
+ carry = sum / 10;
+ }
+ return head.next;
+}
+
+private Stack buildStack(ListNode l) {
+ Stack stack = new Stack<>();
+ while (l != null) {
+ stack.push(l.val);
+ l = l.next;
+ }
+ return stack;
+}
+```
+
+**回文链表**
+
+[234. Palindrome Linked List (Easy)](https://leetcode.com/problems/palindrome-linked-list/description/)
+
+题目要求：以 O(1) 的空间复杂度来求解。
+
+切成两半，把后半段反转，然后比较两半是否相等。
+
+```java
+public boolean isPalindrome(ListNode head) {
+ if (head == null || head.next == null) return true;
+ ListNode slow = head, fast = head.next;
+ while (fast != null && fast.next != null) {
+ slow = slow.next;
+ fast = fast.next.next;
+ }
+ if (fast != null) slow = slow.next; // 偶数节点，让 slow 指向下一个节点
+ cut(head, slow); // 切成两个链表
+ return isEqual(head, reverse(slow));
+}
+
+private void cut(ListNode head, ListNode cutNode) {
+ while (head.next != cutNode) {
+ head = head.next;
+ }
+ head.next = null;
+}
+
+private ListNode reverse(ListNode head) {
+ ListNode newHead = null;
+ while (head != null) {
+ ListNode nextNode = head.next;
+ head.next = newHead;
+ newHead = head;
+ head = nextNode;
+ }
+ return newHead;
+}
+
+private boolean isEqual(ListNode l1, ListNode l2) {
+ while (l1 != null && l2 != null) {
+ if (l1.val != l2.val) return false;
+ l1 = l1.next;
+ l2 = l2.next;
+ }
+ return true;
+}
+```
+
+**分隔链表**
+
+[725. Split Linked List in Parts(Medium)](https://leetcode.com/problems/split-linked-list-in-parts/description/)
+
+```html
+Input:
+root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
+Output: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
+Explanation:
+The input has been split into consecutive parts with size difference at most 1, and earlier parts are a larger size than the later parts.
+```
+
+题目描述：把链表分隔成 k 部分，每部分的长度都应该尽可能相同，排在前面的长度应该大于等于后面的。
+
+```java
+public ListNode[] splitListToParts(ListNode root, int k) {
+ int N = 0;
+ ListNode cur = root;
+ while (cur != null) {
+ N++;
+ cur = cur.next;
+ }
+ int mod = N % k;
+ int size = N / k;
+ ListNode[] ret = new ListNode[k];
+ cur = root;
+ for (int i = 0; cur != null && i < k; i++) {
+ ret[i] = cur;
+ int curSize = size + (mod-- > 0 ? 1 : 0);
+ for (int j = 0; j < curSize - 1; j++) {
+ cur = cur.next;
+ }
+ ListNode next = cur.next;
+ cur.next = null;
+ cur = next;
+ }
+ return ret;
+}
+```
+
+**链表元素按奇偶聚集**
+
+[328. Odd Even Linked List (Medium)](https://leetcode.com/problems/odd-even-linked-list/description/)
+
+```html
+Example:
+Given 1->2->3->4->5->NULL,
+return 1->3->5->2->4->NULL.
+```
+
+```java
+public ListNode oddEvenList(ListNode head) {
+ if (head == null) {
+ return head;
+ }
+ ListNode odd = head, even = head.next, evenHead = even;
+ while (even != null && even.next != null) {
+ odd.next = odd.next.next;
+ odd = odd.next;
+ even.next = even.next.next;
+ even = even.next;
+ }
+ odd.next = evenHead;
+ return head;
+}
+```
+
+## 树
+
+### 递归
+
+一棵树要么是空树，要么有两个指针，每个指针指向一棵树。树是一种递归结构，很多树的问题可以使用递归来处理。
+
+**树的高度**
+
+[104. Maximum Depth of Binary Tree (Easy)](https://leetcode.com/problems/maximum-depth-of-binary-tree/description/)
+
+```java
+public int maxDepth(TreeNode root) {
+ if (root == null) return 0;
+ return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
+}
+```
+
+**平衡树**
+
+[110. Balanced Binary Tree (Easy)](https://leetcode.com/problems/balanced-binary-tree/description/)
+
+```html
+ 3
+ / \
+ 9 20
+ / \
+ 15 7
+```
+
+平衡树左右子树高度差都小于等于 1
+
+```java
+private boolean result = true;
+
+public boolean isBalanced(TreeNode root) {
+ maxDepth(root);
+ return result;
+}
+
+public int maxDepth(TreeNode root) {
+ if (root == null) return 0;
+ int l = maxDepth(root.left);
+ int r = maxDepth(root.right);
+ if (Math.abs(l - r) > 1) result = false;
+ return 1 + Math.max(l, r);
+}
+```
+
+**两节点的最长路径**
+
+[543. Diameter of Binary Tree (Easy)](https://leetcode.com/problems/diameter-of-binary-tree/description/)
+
+```html
+Input:
+
+ 1
+ / \
+ 2 3
+ / \
+ 4 5
+
+Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].
+```
+
+```java
+private int max = 0;
+
+public int diameterOfBinaryTree(TreeNode root) {
+ depth(root);
+ return max;
+}
+
+private int depth(TreeNode root) {
+ if (root == null) return 0;
+ int leftDepth = depth(root.left);
+ int rightDepth = depth(root.right);
+ max = Math.max(max, leftDepth + rightDepth);
+ return Math.max(leftDepth, rightDepth) + 1;
+}
+```
+
+**翻转树**
+
+[226. Invert Binary Tree (Easy)](https://leetcode.com/problems/invert-binary-tree/description/)
+
+```java
+public TreeNode invertTree(TreeNode root) {
+ if (root == null) return null;
+ TreeNode left = root.left; // 后面的操作会改变 left 指针，因此先保存下来
+ root.left = invertTree(root.right);
+ root.right = invertTree(left);
+ return root;
+}
+```
+
+**归并两棵树**
+
+[617. Merge Two Binary Trees (Easy)](https://leetcode.com/problems/merge-two-binary-trees/description/)
+
+```html
+Input:
+ Tree 1 Tree 2
+ 1 2
+ / \ / \
+ 3 2 1 3
+ / \ \
+ 5 4 7
+
+Output:
+ 3
+ / \
+ 4 5
+ / \ \
+ 5 4 7
+```
+
+```java
+public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
+ if (t1 == null && t2 == null) return null;
+ if (t1 == null) return t2;
+ if (t2 == null) return t1;
+ TreeNode root = new TreeNode(t1.val + t2.val);
+ root.left = mergeTrees(t1.left, t2.left);
+ root.right = mergeTrees(t1.right, t2.right);
+ return root;
+}
+```
+
+**判断路径和是否等于一个数**
+
+[Leetcdoe : 112. Path Sum (Easy)](https://leetcode.com/problems/path-sum/description/)
+
+```html
+Given the below binary tree and sum = 22,
+
+ 5
+ / \
+ 4 8
+ / / \
+ 11 13 4
+ / \ \
+ 7 2 1
+
+return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
+```
+
+路径和定义为从 root 到 leaf 的所有节点的和。
+
+```java
+public boolean hasPathSum(TreeNode root, int sum) {
+ if (root == null) return false;
+ if (root.left == null && root.right == null && root.val == sum) return true;
+ return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
+}
+```
+
+**统计路径和等于一个数的路径数量**
+
+[437. Path Sum III (Easy)](https://leetcode.com/problems/path-sum-iii/description/)
+
+```html
+root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
+
+ 10
+ / \
+ 5 -3
+ / \ \
+ 3 2 11
+ / \ \
+3 -2 1
+
+Return 3. The paths that sum to 8 are:
+
+1. 5 -> 3
+2. 5 -> 2 -> 1
+3. -3 -> 11
+```
+
+路径不一定以 root 开头，也不一定以 leaf 结尾，但是必须连续。
+
+```java
+public int pathSum(TreeNode root, int sum) {
+ if (root == null) return 0;
+ int ret = pathSumStartWithRoot(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum);
+ return ret;
+}
+
+private int pathSumStartWithRoot(TreeNode root, int sum) {
+ if (root == null) return 0;
+ int ret = 0;
+ if (root.val == sum) ret++;
+ ret += pathSumStartWithRoot(root.left, sum - root.val) + pathSumStartWithRoot(root.right, sum - root.val);
+ return ret;
+}
+```
+
+**子树**
+
+[572. Subtree of Another Tree (Easy)](https://leetcode.com/problems/subtree-of-another-tree/description/)
+
+```html
+Given tree s:
+ 3
+ / \
+ 4 5
+ / \
+ 1 2
+
+Given tree t:
+ 4
+ / \
+ 1 2
+
+Return true, because t has the same structure and node values with a subtree of s.
+
+Given tree s:
+
+ 3
+ / \
+ 4 5
+ / \
+ 1 2
+ /
+ 0
+
+Given tree t:
+ 4
+ / \
+ 1 2
+
+Return false.
+```
+
+```java
+public boolean isSubtree(TreeNode s, TreeNode t) {
+ if (s == null) return false;
+ return isSubtreeWithRoot(s, t) || isSubtree(s.left, t) || isSubtree(s.right, t);
+}
+
+private boolean isSubtreeWithRoot(TreeNode s, TreeNode t) {
+ if (t == null && s == null) return true;
+ if (t == null || s == null) return false;
+ if (t.val != s.val) return false;
+ return isSubtreeWithRoot(s.left, t.left) && isSubtreeWithRoot(s.right, t.right);
+}
+```
+
+**树的对称**
+
+[101. Symmetric Tree (Easy)](https://leetcode.com/problems/symmetric-tree/description/)
+
+```html
+ 1
+ / \
+ 2 2
+ / \ / \
+3 4 4 3
+```
+
+```java
+public boolean isSymmetric(TreeNode root) {
+ if (root == null) return true;
+ return isSymmetric(root.left, root.right);
+}
+
+private boolean isSymmetric(TreeNode t1, TreeNode t2) {
+ if (t1 == null && t2 == null) return true;
+ if (t1 == null || t2 == null) return false;
+ if (t1.val != t2.val) return false;
+ return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
+}
+```
+
+**最小路径**
+
+[111. Minimum Depth of Binary Tree (Easy)](https://leetcode.com/problems/minimum-depth-of-binary-tree/description/)
+
+树的根节点到叶子节点的最小路径长度
+
+```java
+public int minDepth(TreeNode root) {
+ if (root == null) return 0;
+ int left = minDepth(root.left);
+ int right = minDepth(root.right);
+ if (left == 0 || right == 0) return left + right + 1;
+ return Math.min(left, right) + 1;
+}
+```
+
+**统计左叶子节点的和**
+
+[404. Sum of Left Leaves (Easy)](https://leetcode.com/problems/sum-of-left-leaves/description/)
+
+```html
+ 3
+ / \
+ 9 20
+ / \
+ 15 7
+
+There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24.
+```
+
+```java
+public int sumOfLeftLeaves(TreeNode root) {
+ if (root == null) return 0;
+ if (isLeaf(root.left)) return root.left.val + sumOfLeftLeaves(root.right);
+ return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
+}
+
+private boolean isLeaf(TreeNode node){
+ if (node == null) return false;
+ return node.left == null && node.right == null;
+}
+```
+
+**相同节点值的最大路径长度**
+
+[687. Longest Univalue Path (Easy)](https://leetcode.com/problems/longest-univalue-path/)
+
+```html
+ 1
+ / \
+ 4 5
+ / \ \
+ 4 4 5
+
+Output : 2
+```
+
+```java
+private int path = 0;
+
+public int longestUnivaluePath(TreeNode root) {
+ dfs(root);
+ return path;
+}
+
+private int dfs(TreeNode root){
+ if (root == null) return 0;
+ int left = dfs(root.left);
+ int right = dfs(root.right);
+ int leftPath = root.left != null && root.left.val == root.val ? left + 1 : 0;
+ int rightPath = root.right != null && root.right.val == root.val ? right + 1 : 0;
+ path = Math.max(path, leftPath + rightPath);
+ return Math.max(leftPath, rightPath);
+}
+```
+
+**间隔遍历**
+
+[337. House Robber III (Medium)](https://leetcode.com/problems/house-robber-iii/description/)
+
+```html
+ 3
+ / \
+ 2 3
+ \ \
+ 3 1
+Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
+```
+
+```java
+public int rob(TreeNode root) {
+ if (root == null) return 0;
+ int val1 = root.val;
+ if (root.left != null) val1 += rob(root.left.left) + rob(root.left.right);
+ if (root.right != null) val1 += rob(root.right.left) + rob(root.right.right);
+ int val2 = rob(root.left) + rob(root.right);
+ return Math.max(val1, val2);
+}
+```
+
+**找出二叉树中第二小的节点**
+
+[671. Second Minimum Node In a Binary Tree (Easy)](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/description/)
+
+```html
+Input:
+ 2
+ / \
+ 2 5
+ / \
+ 5 7
+
+Output: 5
+```
+
+一个节点要么具有 0 个或 2 个子节点，如果有子节点，那么根节点是最小的节点。
+
+```java
+public int findSecondMinimumValue(TreeNode root) {
+ if (root == null) return -1;
+ if (root.left == null && root.right == null) return -1;
+ int leftVal = root.left.val;
+ int rightVal = root.right.val;
+ if (leftVal == root.val) leftVal = findSecondMinimumValue(root.left);
+ if (rightVal == root.val) rightVal = findSecondMinimumValue(root.right);
+ if (leftVal != -1 && rightVal != -1) return Math.min(leftVal, rightVal);
+ if (leftVal != -1) return leftVal;
+ return rightVal;
+}
+```
+
+### 层次遍历
+
+使用 BFS 进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
+
+**一棵树每层节点的平均数**
+
+[637. Average of Levels in Binary Tree (Easy)](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)
+
+```java
+public List averageOfLevels(TreeNode root) {
+ List ret = new ArrayList<>();
+ if (root == null) return ret;
+ Queue queue = new LinkedList<>();
+ queue.add(root);
+ while (!queue.isEmpty()) {
+ int cnt = queue.size();
+ double sum = 0;
+ for (int i = 0; i < cnt; i++) {
+ TreeNode node = queue.poll();
+ sum += node.val;
+ if (node.left != null) queue.add(node.left);
+ if (node.right != null) queue.add(node.right);
+ }
+ ret.add(sum / cnt);
+ }
+ return ret;
+}
+```
+
+**得到左下角的节点**
+
+[513. Find Bottom Left Tree Value (Easy)](https://leetcode.com/problems/find-bottom-left-tree-value/description/)
+
+```html
+Input:
+
+ 1
+ / \
+ 2 3
+ / / \
+ 4 5 6
+ /
+ 7
+
+Output:
+7
+```
+
+```java
+public int findBottomLeftValue(TreeNode root) {
+ Queue queue = new LinkedList<>();
+ queue.add(root);
+ while (!queue.isEmpty()) {
+ root = queue.poll();
+ if (root.right != null) queue.add(root.right);
+ if (root.left != null) queue.add(root.left);
+ }
+ return root.val;
+}
+```
+
+### 前中后序遍历
+
+```html
+ 1
+ / \
+ 2 3
+ / \ \
+4 5 6
+```
+
+- 层次遍历顺序：[1 2 3 4 5 6]
+- 前序遍历顺序：[1 2 4 5 3 6]
+- 中序遍历顺序：[4 2 5 1 3 6]
+- 后序遍历顺序：[4 5 2 6 3 1]
+
+层次遍历使用 BFS 实现，利用的就是 BFS 一层一层遍历的特性；而前序、中序、后序遍历利用了 DFS 实现。
+
+前序、中序、后序遍只是在对节点访问的顺序有一点不同，其它都相同。
+
+① 前序
+
+```java
+void dfs(TreeNode root) {
+ visit(root);
+ dfs(root.left);
+ dfs(root.right);
+}
+```
+
+② 中序
+
+```java
+void dfs(TreeNode root) {
+ dfs(root.left);
+ visit(root);
+ dfs(root.right);
+}
+```
+
+③ 后序
+
+```java
+void dfs(TreeNode root) {
+ dfs(root.left);
+ dfs(root.right);
+ visit(root);
+}
+```
+
+**非递归实现二叉树的前序遍历**
+
+[144. Binary Tree Preorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-preorder-traversal/description/)
+
+```java
+public List preorderTraversal(TreeNode root) {
+ List ret = new ArrayList<>();
+ Stack stack = new Stack<>();
+ stack.push(root);
+ while (!stack.isEmpty()) {
+ TreeNode node = stack.pop();
+ if (node == null) continue;
+ ret.add(node.val);
+ stack.push(node.right); // 先右后左，保证左子树先遍历
+ stack.push(node.left);
+ }
+ return ret;
+}
+```
+
+**非递归实现二叉树的后序遍历**
+
+[145. Binary Tree Postorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-postorder-traversal/description/)
+
+前序遍历为 root -> left -> right，后序遍历为 left -> right -> root。可以修改前序遍历成为 root -> right -> left，那么这个顺序就和后序遍历正好相反。
+
+```java
+public List postorderTraversal(TreeNode root) {
+ List ret = new ArrayList<>();
+ Stack stack = new Stack<>();
+ stack.push(root);
+ while (!stack.isEmpty()) {
+ TreeNode node = stack.pop();
+ if (node == null) continue;
+ ret.add(node.val);
+ stack.push(node.left);
+ stack.push(node.right);
+ }
+ Collections.reverse(ret);
+ return ret;
+}
+```
+
+**非递归实现二叉树的中序遍历**
+
+[94. Binary Tree Inorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-inorder-traversal/description/)
+
+```java
+public List inorderTraversal(TreeNode root) {
+ List ret = new ArrayList<>();
+ if (root == null) return ret;
+ Stack stack = new Stack<>();
+ TreeNode cur = root;
+ while (cur != null || !stack.isEmpty()) {
+ while (cur != null) {
+ stack.push(cur);
+ cur = cur.left;
+ }
+ TreeNode node = stack.pop();
+ ret.add(node.val);
+ cur = node.right;
+ }
+ return ret;
+}
+```
+
+### BST
+
+二叉查找树（BST）：根节点大于等于左子树所有节点，小于等于右子树所有节点。
+
+二叉查找树中序遍历有序。
+
+**修剪二叉查找树**
+
+[669. Trim a Binary Search Tree (Easy)](https://leetcode.com/problems/trim-a-binary-search-tree/description/)
+
+```html
+Input:
+
+ 3
+ / \
+ 0 4
+ \
+ 2
+ /
+ 1
+
+ L = 1
+ R = 3
+
+Output:
+
+ 3
+ /
+ 2
+ /
+ 1
+```
+
+题目描述：只保留值在 L \~ R 之间的节点
+
+```java
+public TreeNode trimBST(TreeNode root, int L, int R) {
+ if (root == null) return null;
+ if (root.val > R) return trimBST(root.left, L, R);
+ if (root.val < L) return trimBST(root.right, L, R);
+ root.left = trimBST(root.left, L, R);
+ root.right = trimBST(root.right, L, R);
+ return root;
+}
+```
+
+**寻找二叉查找树的第 k 个元素**
+
+[230. Kth Smallest Element in a BST (Medium)](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/)
+
+
+中序遍历解法：
+
+```java
+private int cnt = 0;
+private int val;
+
+public int kthSmallest(TreeNode root, int k) {
+ inOrder(root, k);
+ return val;
+}
+
+private void inOrder(TreeNode node, int k) {
+ if (node == null) return;
+ inOrder(node.left, k);
+ cnt++;
+ if (cnt == k) {
+ val = node.val;
+ return;
+ }
+ inOrder(node.right, k);
+}
+```
+
+递归解法：
+
+```java
+public int kthSmallest(TreeNode root, int k) {
+ int leftCnt = count(root.left);
+ if (leftCnt == k - 1) return root.val;
+ if (leftCnt > k - 1) return kthSmallest(root.left, k);
+ return kthSmallest(root.right, k - leftCnt - 1);
+}
+
+private int count(TreeNode node) {
+ if (node == null) return 0;
+ return 1 + count(node.left) + count(node.right);
+}
+```
+
+**把二叉查找树每个节点的值都加上比它大的节点的值**
+
+[Convert BST to Greater Tree (Easy)](https://leetcode.com/problems/convert-bst-to-greater-tree/description/)
+
+```html
+Input: The root of a Binary Search Tree like this:
+
+ 5
+ / \
+ 2 13
+
+Output: The root of a Greater Tree like this:
+
+ 18
+ / \
+ 20 13
+```
+
+先遍历右子树。
+
+```java
+private int sum = 0;
+
+public TreeNode convertBST(TreeNode root) {
+ traver(root);
+ return root;
+}
+
+private void traver(TreeNode node) {
+ if (node == null) return;
+ traver(node.right);
+ sum += node.val;
+ node.val = sum;
+ traver(node.left);
+}
+```
+
+**二叉查找树的最近公共祖先**
+
+[235. Lowest Common Ancestor of a Binary Search Tree (Easy)](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
+
+```html
+ _______6______
+ / \
+ ___2__ ___8__
+ / \ / \
+0 4 7 9
+ / \
+ 3 5
+
+For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
+```
+
+```java
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+ if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
+ if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
+ return root;
+}
+```
+
+**二叉树的最近公共祖先**
+
+[236. Lowest Common Ancestor of a Binary Tree (Medium) ](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
+
+```html
+ _______3______
+ / \
+ ___5__ ___1__
+ / \ / \
+6 2 0 8
+ / \
+ 7 4
+
+For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
+```
+
+```java
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+ if (root == null || root == p || root == q) return root;
+ TreeNode left = lowestCommonAncestor(root.left, p, q);
+ TreeNode right = lowestCommonAncestor(root.right, p, q);
+ return left == null ? right : right == null ? left : root;
+}
+```
+
+**从有序数组中构造二叉查找树**
+
+[108. Convert Sorted Array to Binary Search Tree (Easy)](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/)
+
+```java
+public TreeNode sortedArrayToBST(int[] nums) {
+ return toBST(nums, 0, nums.length - 1);
+}
+
+private TreeNode toBST(int[] nums, int sIdx, int eIdx){
+ if (sIdx > eIdx) return null;
+ int mIdx = (sIdx + eIdx) / 2;
+ TreeNode root = new TreeNode(nums[mIdx]);
+ root.left = toBST(nums, sIdx, mIdx - 1);
+ root.right = toBST(nums, mIdx + 1, eIdx);
+ return root;
+}
+```
+
+**根据有序链表构造平衡的二叉查找树**
+
+[109. Convert Sorted List to Binary Search Tree (Medium)](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/description/)
+
+```html
+Given the sorted linked list: [-10,-3,0,5,9],
+
+One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:
+
+ 0
+ / \
+ -3 9
+ / /
+ -10 5
+```
+
+```java
+public TreeNode sortedListToBST(ListNode head) {
+ if (head == null) return null;
+ if (head.next == null) return new TreeNode(head.val);
+ ListNode preMid = preMid(head);
+ ListNode mid = preMid.next;
+ preMid.next = null; // 断开链表
+ TreeNode t = new TreeNode(mid.val);
+ t.left = sortedListToBST(head);
+ t.right = sortedListToBST(mid.next);
+ return t;
+}
+
+private ListNode preMid(ListNode head) {
+ ListNode slow = head, fast = head.next;
+ ListNode pre = head;
+ while (fast != null && fast.next != null) {
+ pre = slow;
+ slow = slow.next;
+ fast = fast.next.next;
+ }
+ return pre;
+}
+```
+
+**在二叉查找树中寻找两个节点，使它们的和为一个给定值**
+
+[653. Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/)
+
+```html
+Input:
+
+ 5
+ / \
+ 3 6
+ / \ \
+2 4 7
+
+Target = 9
+
+Output: True
+```
+
+使用中序遍历得到有序数组之后，再利用双指针对数组进行查找。
+
+应该注意到，这一题不能用分别在左右子树两部分来处理这种思想，因为两个待求的节点可能分别在左右子树中。
+
+```java
+public boolean findTarget(TreeNode root, int k) {
+ List nums = new ArrayList<>();
+ inOrder(root, nums);
+ int i = 0, j = nums.size() - 1;
+ while (i < j) {
+ int sum = nums.get(i) + nums.get(j);
+ if (sum == k) return true;
+ if (sum < k) i++;
+ else j--;
+ }
+ return false;
+}
+
+private void inOrder(TreeNode root, List nums) {
+ if (root == null) return;
+ inOrder(root.left, nums);
+ nums.add(root.val);
+ inOrder(root.right, nums);
+}
+```
+
+**在二叉查找树中查找两个节点之差的最小绝对值**
+
+[530. Minimum Absolute Difference in BST (Easy)](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)
+
+```html
+Input:
+
+ 1
+ \
+ 3
+ /
+ 2
+
+Output:
+
+1
+```
+
+利用二叉查找树的中序遍历为有序的性质，计算中序遍历中临近的两个节点之差的绝对值，取最小值。
+
+```java
+private int minDiff = Integer.MAX_VALUE;
+private TreeNode preNode = null;
+
+public int getMinimumDifference(TreeNode root) {
+ inOrder(root);
+ return minDiff;
+}
+
+private void inOrder(TreeNode node) {
+ if (node == null) return;
+ inOrder(node.left);
+ if (preNode != null) minDiff = Math.min(minDiff, node.val - preNode.val);
+ preNode = node;
+ inOrder(node.right);
+}
+```
+
+**寻找二叉查找树中出现次数最多的值**
+
+[501. Find Mode in Binary Search Tree (Easy)](https://leetcode.com/problems/find-mode-in-binary-search-tree/description/)
+
+```html
+ 1
+ \
+ 2
+ /
+ 2
+
+return [2].
+```
+
+答案可能不止一个，也就是有多个值出现的次数一样多。
+
+```java
+private int curCnt = 1;
+private int maxCnt = 1;
+private TreeNode preNode = null;
+
+public int[] findMode(TreeNode root) {
+ List maxCntNums = new ArrayList<>();
+ inOrder(root, maxCntNums);
+ int[] ret = new int[maxCntNums.size()];
+ int idx = 0;
+ for (int num : maxCntNums) {
+ ret[idx++] = num;
+ }
+ return ret;
+}
+
+private void inOrder(TreeNode node, List nums) {
+ if (node == null) return;
+ inOrder(node.left, nums);
+ if (preNode != null) {
+ if (preNode.val == node.val) curCnt++;
+ else curCnt = 1;
+ }
+ if (curCnt > maxCnt) {
+ maxCnt = curCnt;
+ nums.clear();
+ nums.add(node.val);
+ } else if (curCnt == maxCnt) {
+ nums.add(node.val);
+ }
+ preNode = node;
+ inOrder(node.right, nums);
+}
+```
+
+### Trie
+
+ in = new Stack<>();
+ private Stack 
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+
+#### License
+
+在对本作品进行演绎时，请署名并以相同方式共享。
+
+
\ No newline at end of file
diff --git a/docs1/docs/_coverpage.md b/docs1/docs/_coverpage.md
new file mode 100644
index 00000000..32719dd9
--- /dev/null
+++ b/docs1/docs/_coverpage.md
@@ -0,0 +1,15 @@
+
+
+# CS-Notes
+
+> Computer Sicence Learning Notes.
+
+- Algorithm
+- Computer Networks
+- Operating System
+- ...
+
+[GitHub](https://github.com/CyC2018/CS-Notes)
+
+
+
diff --git a/docs1/docs/_media/LogoMakr_1J56bI.png b/docs1/docs/_media/LogoMakr_1J56bI.png
new file mode 100644
index 00000000..8fdee22a
Binary files /dev/null and b/docs1/docs/_media/LogoMakr_1J56bI.png differ
diff --git a/docs1/docs/_media/logomakr-3sxxzw-128x128.png b/docs1/docs/_media/logomakr-3sxxzw-128x128.png
new file mode 100644
index 00000000..80092a94
Binary files /dev/null and b/docs1/docs/_media/logomakr-3sxxzw-128x128.png differ
diff --git a/docs1/docs/_navbar.md b/docs1/docs/_navbar.md
new file mode 100644
index 00000000..47a2356a
--- /dev/null
+++ b/docs1/docs/_navbar.md
@@ -0,0 +1,6 @@
+- Translations
+ - [:uk: English](/)
+ - [:cn: 中文](/zh-cn/)
+ - [:de: Deutsch](/de-de/)
+ - [:es: Spanish](/es/)
+ - [:ru: Russian](/ru/)
diff --git a/docs1/docs/_sidebar.md b/docs1/docs/_sidebar.md
new file mode 100644
index 00000000..a0fd729a
--- /dev/null
+++ b/docs1/docs/_sidebar.md
@@ -0,0 +1,53 @@
+- :pencil2: 算法
+
+ - [剑指 Offer 题解](notes/剑指%20offer%20题解.md)
+ - [Leetcode 题解](notes/Leetcode%20题解)
+ - [算法](notes/算法.md)
+
+- :computer: 操作系统
+
+ - [计算机操作系统](notes/计算机操作系统.md)
+ - [Linux](notes/Linux.md)
+
+- :cloud: 网络
+
+ - [计算机网络](notes/计算机网络.md)
+ - [HTTP](notes/HTTP.md)
+ - [Sockets](notes/Sockets.md)
+
+- :couple: 面向对象
+
+ - [设计模式](notes/设计模式.md)
+ - [面向对象思想](notes/面向对象思想.md)
+
+- :floppy_disk: 数据库
+
+ - [数据库系统原理](notes/数据库系统原理.md)
+ - [SQL](notes/SQL.md)
+ - [Leetcode-Database 题解](notes/Leetcode-Database%20题解.md)
+ - [MySQL](notes/MySQL.md)
+ - [Redis](notes/Redis.md)
+
+- :coffee: Java
+
+ - [Java 基础](notes/Java%20基础.md)
+ - [Java 容器](notes/Java%20容器.md)
+ - [Java 并发](notes/Java%20并发.md)
+ - [Java 虚拟机](notes/Java%20虚拟机.md)
+ - [Java I/O](notes/Java%20IO.md)
+
+- :bulb: 系统设计
+
+ - [系统设计基础](notes/系统设计基础.md)
+ - [分布式](notes/分布式.md)
+ - [集群](notes/集群.md)
+ - [攻击技术](notes/攻击技术.md)
+ - [缓存](notes/缓存.md)
+ - [消息队列](notes/消息队列.md)
+
+- :hammer:工具
+
+ - [Git](notes/Git.md)
+ - [Docker](notes/Docker.md)
+ - [正则表达式](notes/正则表达式.md)
+ - [构建工具](notes/构建工具.md)
diff --git a/docs1/docs/guide.md b/docs1/docs/guide.md
new file mode 100644
index 00000000..1fa6a742
--- /dev/null
+++ b/docs1/docs/guide.md
@@ -0,0 +1 @@
+# test
\ No newline at end of file
diff --git a/docs1/docs/index.html b/docs1/docs/index.html
new file mode 100644
index 00000000..e875a412
--- /dev/null
+++ b/docs1/docs/index.html
@@ -0,0 +1,43 @@
+
+
+
+
+
+