auto commit

docs/notes/10.1 斐波那契数列.md

@@ -0,0 +1,67 @@
+# 10.1 斐波那契数列
+
+[NowCoder](https://www.nowcoder.com/practice/c6c7742f5ba7442aada113136ddea0c3?tpId=13&tqId=11160&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+求斐波那契数列的第 n 项，n <= 39。
+
+<!--<div align="center"><img src="https://latex.codecogs.com/gif.latex?f(n)=\left\{\begin{array}{rcl}0&&{n=0}\\1&&{n=1}\\f(n-1)+f(n-2)&&{n>1}\end{array}\right." class="mathjax-pic"/></div> <br> -->
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/45be9587-6069-4ab7-b9ac-840db1a53744.jpg" width="300px">
+
+## 解题思路
+
+如果使用递归求解，会重复计算一些子问题。例如，计算 f(4) 需要计算 f(3) 和 f(2)，计算 f(3) 需要计算 f(2) 和 f(1)，可以看到 f(2) 被重复计算了。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/c13e2a3d-b01c-4a08-a69b-db2c4e821e09.png" width="350px"/>
+
+递归是将一个问题划分成多个子问题求解，动态规划也是如此，但是动态规划会把子问题的解缓存起来，从而避免重复求解子问题。
+
+```java
+public int Fibonacci(int n) {
+    if (n <= 1)
+        return n;
+    int[] fib = new int[n + 1];
+    fib[1] = 1;
+    for (int i = 2; i <= n; i++)
+        fib[i] = fib[i - 1] + fib[i - 2];
+    return fib[n];
+}
+```
+
+考虑到第 i 项只与第 i-1 和第 i-2 项有关，因此只需要存储前两项的值就能求解第 i 项，从而将空间复杂度由 O(N) 降低为 O(1)。
+
+```java
+public int Fibonacci(int n) {
+    if (n <= 1)
+        return n;
+    int pre2 = 0, pre1 = 1;
+    int fib = 0;
+    for (int i = 2; i <= n; i++) {
+        fib = pre2 + pre1;
+        pre2 = pre1;
+        pre1 = fib;
+    }
+    return fib;
+}
+```
+
+由于待求解的 n 小于 40，因此可以将前 40 项的结果先进行计算，之后就能以 O(1) 时间复杂度得到第 n 项的值。
+
+```java
+public class Solution {
+
+    private int[] fib = new int[40];
+
+    public Solution() {
+        fib[1] = 1;
+        for (int i = 2; i < fib.length; i++)
+            fib[i] = fib[i - 1] + fib[i - 2];
+    }
+
+    public int Fibonacci(int n) {
+        return fib[n];
+    }
+}
+```

docs/notes/10.2 矩形覆盖.md

@@ -0,0 +1,40 @@
+# 10.2 矩形覆盖
+
+[NowCoder](https://www.nowcoder.com/practice/72a5a919508a4251859fb2cfb987a0e6?tpId=13&tqId=11163&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+我们可以用 2\*1 的小矩形横着或者竖着去覆盖更大的矩形。请问用 n 个 2\*1 的小矩形无重叠地覆盖一个 2\*n 的大矩形，总共有多少种方法？
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/b903fda8-07d0-46a7-91a7-e803892895cf.gif" width="100px">
+
+## 解题思路
+
+当 n 为 1 时，只有一种覆盖方法：
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/f6e146f1-57ad-411b-beb3-770a142164ef.png" width="100px">
+
+当 n 为 2 时，有两种覆盖方法：
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/fb3b8f7a-4293-4a38-aae1-62284db979a3.png" width="200px">
+
+要覆盖 2\*n 的大矩形，可以先覆盖 2\*1 的矩形，再覆盖 2\*(n-1) 的矩形；或者先覆盖 2\*2 的矩形，再覆盖 2\*(n-2) 的矩形。而覆盖 2\*(n-1) 和 2\*(n-2) 的矩形可以看成子问题。该问题的递推公式如下：
+
+<!-- <div align="center"><img src="https://latex.codecogs.com/gif.latex?f(n)=\left\{\begin{array}{rcl}1&&{n=1}\\2&&{n=2}\\f(n-1)+f(n-2)&&{n>1}\end{array}\right." class="mathjax-pic"/></div> <br> -->
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/508c6e52-9f93-44ed-b6b9-e69050e14807.jpg" width="350px">
+
+```java
+public int RectCover(int n) {
+    if (n <= 2)
+        return n;
+    int pre2 = 1, pre1 = 2;
+    int result = 0;
+    for (int i = 3; i <= n; i++) {
+        result = pre2 + pre1;
+        pre2 = pre1;
+        pre1 = result;
+    }
+    return result;
+}
+```

docs/notes/10.3 跳台阶.md

@@ -0,0 +1,38 @@
+# 10.3 跳台阶
+
+[NowCoder](https://www.nowcoder.com/practice/8c82a5b80378478f9484d87d1c5f12a4?tpId=13&tqId=11161&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9dae7475-934f-42e5-b3b3-12724337170a.png" width="380px">
+
+## 解题思路
+
+当 n = 1 时，只有一种跳法：
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/72aac98a-d5df-4bfa-a71a-4bb16a87474c.png" width="250px">
+
+当 n = 2 时，有两种跳法：
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/1b80288d-1b35-4cd3-aa17-7e27ab9a2389.png" width="300px">
+
+跳 n 阶台阶，可以先跳 1 阶台阶，再跳 n-1 阶台阶；或者先跳 2 阶台阶，再跳 n-2 阶台阶。而 n-1 和 n-2 阶台阶的跳法可以看成子问题，该问题的递推公式为：
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/508c6e52-9f93-44ed-b6b9-e69050e14807.jpg" width="350px">
+
+```java
+public int JumpFloor(int n) {
+    if (n <= 2)
+        return n;
+    int pre2 = 1, pre1 = 2;
+    int result = 0;
+    for (int i = 2; i < n; i++) {
+        result = pre2 + pre1;
+        pre2 = pre1;
+        pre1 = result;
+    }
+    return result;
+}
+```

docs/notes/10.4 变态跳台阶.md

@@ -0,0 +1,58 @@
+# 10.4 变态跳台阶
+
+[NowCoder](https://www.nowcoder.com/practice/22243d016f6b47f2a6928b4313c85387?tpId=13&tqId=11162&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级... 它也可以跳上 n 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/cd411a94-3786-4c94-9e08-f28320e010d5.png" width="380px">
+
+## 解题思路
+
+### 动态规划
+
+```java
+public int JumpFloorII(int target) {
+    int[] dp = new int[target];
+    Arrays.fill(dp, 1);
+    for (int i = 1; i < target; i++)
+        for (int j = 0; j < i; j++)
+            dp[i] += dp[j];
+    return dp[target - 1];
+}
+```
+
+### 数学推导
+
+跳上 n-1 级台阶，可以从 n-2 级跳 1 级上去，也可以从 n-3 级跳 2 级上去...，那么
+
+```
+f(n-1) = f(n-2) + f(n-3) + ... + f(0)
+```
+
+同样，跳上 n 级台阶，可以从 n-1 级跳 1 级上去，也可以从 n-2 级跳 2 级上去... ，那么
+
+```
+f(n) = f(n-1) + f(n-2) + ... + f(0)
+```
+
+综上可得
+
+```
+f(n) - f(n-1) = f(n-1)
+```
+
+即
+
+```
+f(n) = 2*f(n-1)
+```
+
+所以 f(n) 是一个等比数列
+
+```source-java
+public int JumpFloorII(int target) {
+    return (int) Math.pow(2, target - 1);
+}
+```

docs/notes/11. 旋转数组的最小数字.md

@@ -0,0 +1,65 @@
+# 11. 旋转数组的最小数字
+
+[NowCoder](https://www.nowcoder.com/practice/9f3231a991af4f55b95579b44b7a01ba?tpId=13&tqId=11159&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/0038204c-4b8a-42a5-921d-080f6674f989.png" width="210px">
+
+## 解题思路
+
+将旋转数组对半分可以得到一个包含最小元素的新旋转数组，以及一个非递减排序的数组。新的旋转数组的数组元素是原数组的一半，从而将问题规模减少了一半，这种折半性质的算法的时间复杂度为 O(logN)（为了方便，这里将 log<sub>2</sub>N 写为 logN）。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/424f34ab-a9fd-49a6-9969-d76b42251365.png" width="300px">
+
+此时问题的关键在于确定对半分得到的两个数组哪一个是旋转数组，哪一个是非递减数组。我们很容易知道非递减数组的第一个元素一定小于等于最后一个元素。
+
+通过修改二分查找算法进行求解（l 代表 low，m 代表 mid，h 代表 high）：
+
+- 当 nums[m] <= nums[h] 时，表示 [m, h] 区间内的数组是非递减数组，[l, m] 区间内的数组是旋转数组，此时令 h = m；
+- 否则 [m + 1, h] 区间内的数组是旋转数组，令 l = m + 1。
+
+```java
+public int minNumberInRotateArray(int[] nums) {
+    if (nums.length == 0)
+        return 0;
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] <= nums[h])
+            h = m;
+        else
+            l = m + 1;
+    }
+    return nums[l];
+}
+```
+
+如果数组元素允许重复，会出现一个特殊的情况：nums[l] == nums[m] == nums[h]，此时无法确定解在哪个区间，需要切换到顺序查找。例如对于数组 {1,1,1,0,1}，l、m 和 h 指向的数都为 1，此时无法知道最小数字 0 在哪个区间。
+
+```java
+public int minNumberInRotateArray(int[] nums) {
+    if (nums.length == 0)
+        return 0;
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[l] == nums[m] && nums[m] == nums[h])
+            return minNumber(nums, l, h);
+        else if (nums[m] <= nums[h])
+            h = m;
+        else
+            l = m + 1;
+    }
+    return nums[l];
+}
+
+private int minNumber(int[] nums, int l, int h) {
+    for (int i = l; i < h; i++)
+        if (nums[i] > nums[i + 1])
+            return nums[i + 1];
+    return nums[l];
+}
+```

docs/notes/12. 矩阵中的路径.md

@@ -0,0 +1,64 @@
+# 12. 矩阵中的路径
+
+[NowCoder](https://www.nowcoder.com/practice/c61c6999eecb4b8f88a98f66b273a3cc?tpId=13&tqId=11218&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向上下左右移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。
+
+例如下面的矩阵包含了一条 bfce 路径。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/1db1c7ea-0443-478b-8df9-7e33b1336cc4.png" width="200px">
+
+## 解题思路
+
+使用回溯法（backtracking）进行求解，它是一种暴力搜索方法，通过搜索所有可能的结果来求解问题。回溯法在一次搜索结束时需要进行回溯（回退），将这一次搜索过程中设置的状态进行清除，从而开始一次新的搜索过程。例如下图示例中，从 f 开始，下一步有 4 种搜索可能，如果先搜索 b，需要将 b 标记为已经使用，防止重复使用。在这一次搜索结束之后，需要将 b 的已经使用状态清除，并搜索 c。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/dc964b86-7a08-4bde-a3d9-e6ddceb29f98.png" width="200px">
+
+本题的输入是数组而不是矩阵（二维数组），因此需要先将数组转换成矩阵。
+
+```java
+private final static int[][] next = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
+private int rows;
+private int cols;
+
+public boolean hasPath(char[] array, int rows, int cols, char[] str) {
+    if (rows == 0 || cols == 0) return false;
+    this.rows = rows;
+    this.cols = cols;
+    boolean[][] marked = new boolean[rows][cols];
+    char[][] matrix = buildMatrix(array);
+    for (int i = 0; i < rows; i++)
+        for (int j = 0; j < cols; j++)
+            if (backtracking(matrix, str, marked, 0, i, j))
+                return true;
+
+    return false;
+}
+
+private boolean backtracking(char[][] matrix, char[] str,
+                             boolean[][] marked, int pathLen, int r, int c) {
+
+    if (pathLen == str.length) return true;
+    if (r < 0 || r >= rows || c < 0 || c >= cols
+            || matrix[r][c] != str[pathLen] || marked[r][c]) {
+
+        return false;
+    }
+    marked[r][c] = true;
+    for (int[] n : next)
+        if (backtracking(matrix, str, marked, pathLen + 1, r + n[0], c + n[1]))
+            return true;
+    marked[r][c] = false;
+    return false;
+}
+
+private char[][] buildMatrix(char[] array) {
+    char[][] matrix = new char[rows][cols];
+    for (int r = 0, idx = 0; r < rows; r++)
+        for (int c = 0; c < cols; c++)
+            matrix[r][c] = array[idx++];
+    return matrix;
+}
+```

docs/notes/13. 机器人的运动范围.md

@@ -0,0 +1,58 @@
+# 13. 机器人的运动范围
+
+[NowCoder](https://www.nowcoder.com/practice/6e5207314b5241fb83f2329e89fdecc8?tpId=13&tqId=11219&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+地上有一个 m 行和 n 列的方格。一个机器人从坐标 (0, 0) 的格子开始移动，每一次只能向左右上下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于 k 的格子。
+
+例如，当 k 为 18 时，机器人能够进入方格 (35,37)，因为 3+5+3+7=18。但是，它不能进入方格 (35,38)，因为 3+5+3+8=19。请问该机器人能够达到多少个格子？
+
+## 解题思路
+
+使用深度优先搜索（Depth First Search，DFS）方法进行求解。回溯是深度优先搜索的一种特例，它在一次搜索过程中需要设置一些本次搜索过程的局部状态，并在本次搜索结束之后清除状态。而普通的深度优先搜索并不需要使用这些局部状态，虽然还是有可能设置一些全局状态。
+
+```java
+private static final int[][] next = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
+private int cnt = 0;
+private int rows;
+private int cols;
+private int threshold;
+private int[][] digitSum;
+
+public int movingCount(int threshold, int rows, int cols) {
+    this.rows = rows;
+    this.cols = cols;
+    this.threshold = threshold;
+    initDigitSum();
+    boolean[][] marked = new boolean[rows][cols];
+    dfs(marked, 0, 0);
+    return cnt;
+}
+
+private void dfs(boolean[][] marked, int r, int c) {
+    if (r < 0 || r >= rows || c < 0 || c >= cols || marked[r][c])
+        return;
+    marked[r][c] = true;
+    if (this.digitSum[r][c] > this.threshold)
+        return;
+    cnt++;
+    for (int[] n : next)
+        dfs(marked, r + n[0], c + n[1]);
+}
+
+private void initDigitSum() {
+    int[] digitSumOne = new int[Math.max(rows, cols)];
+    for (int i = 0; i < digitSumOne.length; i++) {
+        int n = i;
+        while (n > 0) {
+            digitSumOne[i] += n % 10;
+            n /= 10;
+        }
+    }
+    this.digitSum = new int[rows][cols];
+    for (int i = 0; i < this.rows; i++)
+        for (int j = 0; j < this.cols; j++)
+            this.digitSum[i][j] = digitSumOne[i] + digitSumOne[j];
+}
+```

docs/notes/14. 剪绳子.md

@@ -0,0 +1,52 @@
+# 14. 剪绳子
+
+[Leetcode](https://leetcode.com/problems/integer-break/description/)
+
+## 题目描述
+
+把一根绳子剪成多段，并且使得每段的长度乘积最大。
+
+```html
+n = 2
+return 1 (2 = 1 + 1)
+
+n = 10
+return 36 (10 = 3 + 3 + 4)
+```
+
+## 解题思路
+
+### 贪心
+
+尽可能多剪长度为 3 的绳子，并且不允许有长度为 1 的绳子出现。如果出现了，就从已经切好长度为 3 的绳子中拿出一段与长度为 1 的绳子重新组合，把它们切成两段长度为 2 的绳子。
+
+证明：当 n >= 5 时，3(n - 3) - n = 2n - 9 > 0，且 2(n - 2) - n = n - 4 > 0。因此在 n >= 5 的情况下，将绳子剪成一段为 2 或者 3，得到的乘积会更大。又因为 3(n - 3) - 2(n - 2) = n - 5 >= 0，所以剪成一段长度为 3 比长度为 2 得到的乘积更大。
+
+```java
+public int integerBreak(int n) {
+    if (n < 2)
+        return 0;
+    if (n == 2)
+        return 1;
+    if (n == 3)
+        return 2;
+    int timesOf3 = n / 3;
+    if (n - timesOf3 * 3 == 1)
+        timesOf3--;
+    int timesOf2 = (n - timesOf3 * 3) / 2;
+    return (int) (Math.pow(3, timesOf3)) * (int) (Math.pow(2, timesOf2));
+}
+```
+
+### 动态规划
+
+```java
+public int integerBreak(int n) {
+    int[] dp = new int[n + 1];
+    dp[1] = 1;
+    for (int i = 2; i <= n; i++)
+        for (int j = 1; j < i; j++)
+            dp[i] = Math.max(dp[i], Math.max(j * (i - j), dp[j] * (i - j)));
+    return dp[n];
+}
+```

docs/notes/15. 二进制中 1 的个数.md

@@ -0,0 +1,40 @@
+# 15. 二进制中 1 的个数
+
+[NowCoder](https://www.nowcoder.com/practice/8ee967e43c2c4ec193b040ea7fbb10b8?tpId=13&tqId=11164&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+输入一个整数，输出该数二进制表示中 1 的个数。
+
+### n&(n-1)
+
+该位运算去除 n 的位级表示中最低的那一位。
+
+```
+n       : 10110100
+n-1     : 10110011
+n&(n-1) : 10110000
+```
+
+时间复杂度：O(M)，其中 M 表示 1 的个数。
+
+
+```java
+public int NumberOf1(int n) {
+    int cnt = 0;
+    while (n != 0) {
+        cnt++;
+        n &= (n - 1);
+    }
+    return cnt;
+}
+```
+
+
+### Integer.bitCount()
+
+```java
+public int NumberOf1(int n) {
+    return Integer.bitCount(n);
+}
+```

docs/notes/16. 数值的整数次方.md

@@ -0,0 +1,36 @@
+# 16. 数值的整数次方
+
+[NowCoder](https://www.nowcoder.com/practice/1a834e5e3e1a4b7ba251417554e07c00?tpId=13&tqId=11165&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+给定一个 double 类型的浮点数 base 和 int 类型的整数 exponent，求 base 的 exponent 次方。
+
+## 解题思路
+
+下面的讨论中 x 代表 base，n 代表 exponent。
+
+<!--<div align="center"><img src="https://latex.codecogs.com/gif.latex?x^n=\left\{\begin{array}{rcl}(x*x)^{n/2}&&{n\%2=0}\\x*(x*x)^{n/2}&&{n\%2=1}\end{array}\right." class="mathjax-pic"/></div> <br>-->
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/48b1d459-8832-4e92-938a-728aae730739.jpg" width="330px">
+
+
+因为 (x\*x)<sup>n/2</sup> 可以通过递归求解，并且每次递归 n 都减小一半，因此整个算法的时间复杂度为 O(logN)。
+
+```java
+public double Power(double base, int exponent) {
+    if (exponent == 0)
+        return 1;
+    if (exponent == 1)
+        return base;
+    boolean isNegative = false;
+    if (exponent < 0) {
+        exponent = -exponent;
+        isNegative = true;
+    }
+    double pow = Power(base * base, exponent / 2);
+    if (exponent % 2 != 0)
+        pow = pow * base;
+    return isNegative ? 1 / pow : pow;
+}
+```

docs/notes/17. 打印从 1 到最大的 n 位数.md

@@ -0,0 +1,40 @@
+# 17. 打印从 1 到最大的 n 位数
+
+## 题目描述
+
+输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数即 999。
+
+## 解题思路
+
+由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用 char 数组进行存储。
+
+使用回溯法得到所有的数。
+
+```java
+public void print1ToMaxOfNDigits(int n) {
+    if (n <= 0)
+        return;
+    char[] number = new char[n];
+    print1ToMaxOfNDigits(number, 0);
+}
+
+private void print1ToMaxOfNDigits(char[] number, int digit) {
+    if (digit == number.length) {
+        printNumber(number);
+        return;
+    }
+    for (int i = 0; i < 10; i++) {
+        number[digit] = (char) (i + '0');
+        print1ToMaxOfNDigits(number, digit + 1);
+    }
+}
+
+private void printNumber(char[] number) {
+    int index = 0;
+    while (index < number.length && number[index] == '0')
+        index++;
+    while (index < number.length)
+        System.out.print(number[index++]);
+    System.out.println();
+}
+```

docs/notes/18.1 在 O(1) 时间内删除链表节点.md

@@ -0,0 +1,37 @@
+# 18.1 在 O(1) 时间内删除链表节点
+
+## 解题思路
+
+① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/1176f9e1-3442-4808-a47a-76fbaea1b806.png" width="600"/>
+
+② 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 O(N)。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/4bf8d0ba-36f0-459e-83a0-f15278a5a157.png" width="600"/>
+
+综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个尾节点以 O(N) 的时间复杂度操作节点的总次数。(2N-1)/N \~ 2，因此该算法的平均时间复杂度为 O(1)。
+
+```java
+public ListNode deleteNode(ListNode head, ListNode tobeDelete) {
+    if (head == null || tobeDelete == null)
+        return null;
+    if (tobeDelete.next != null) {
+        // 要删除的节点不是尾节点
+        ListNode next = tobeDelete.next;
+        tobeDelete.val = next.val;
+        tobeDelete.next = next.next;
+    } else {
+        if (head == tobeDelete)
+             // 只有一个节点
+            head = null;
+        else {
+            ListNode cur = head;
+            while (cur.next != tobeDelete)
+                cur = cur.next;
+            cur.next = null;
+        }
+    }
+    return head;
+}
+```

docs/notes/18.2 删除链表中重复的结点.md

@@ -0,0 +1,25 @@
+# 18.2 删除链表中重复的结点
+
+[NowCoder](https://www.nowcoder.com/practice/fc533c45b73a41b0b44ccba763f866ef?tpId=13&tqId=11209&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/17e301df-52e8-4886-b593-841a16d13e44.png" width="450"/>
+
+## 解题描述
+
+```java
+public ListNode deleteDuplication(ListNode pHead) {
+    if (pHead == null || pHead.next == null)
+        return pHead;
+    ListNode next = pHead.next;
+    if (pHead.val == next.val) {
+        while (next != null && pHead.val == next.val)
+            next = next.next;
+        return deleteDuplication(next);
+    } else {
+        pHead.next = deleteDuplication(pHead.next);
+        return pHead;
+    }
+}
+```

docs/notes/19. 正则表达式匹配.md

@@ -0,0 +1,40 @@
+# 19. 正则表达式匹配
+
+[NowCoder](https://www.nowcoder.com/practice/45327ae22b7b413ea21df13ee7d6429c?tpId=13&tqId=11205&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+请实现一个函数用来匹配包括 '.' 和 '\*' 的正则表达式。模式中的字符 '.' 表示任意一个字符，而 '\*' 表示它前面的字符可以出现任意次（包含 0 次）。
+
+在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串 "aaa" 与模式 "a.a" 和 "ab\*ac\*a" 匹配，但是与 "aa.a" 和 "ab\*a" 均不匹配。
+
+## 解题思路
+
+应该注意到，'.' 是用来当做一个任意字符，而 '\*' 是用来重复前面的字符。这两个的作用不同，不能把 '.' 的作用和 '\*' 进行类比，从而把它当成重复前面字符一次。
+
+```java
+public boolean match(char[] str, char[] pattern) {
+
+    int m = str.length, n = pattern.length;
+    boolean[][] dp = new boolean[m + 1][n + 1];
+
+    dp[0][0] = true;
+    for (int i = 1; i <= n; i++)
+        if (pattern[i - 1] == '*')
+            dp[0][i] = dp[0][i - 2];
+
+    for (int i = 1; i <= m; i++)
+        for (int j = 1; j <= n; j++)
+            if (str[i - 1] == pattern[j - 1] || pattern[j - 1] == '.')
+                dp[i][j] = dp[i - 1][j - 1];
+            else if (pattern[j - 1] == '*')
+                if (pattern[j - 2] == str[i - 1] || pattern[j - 2] == '.') {
+                    dp[i][j] |= dp[i][j - 1]; // a* counts as single a
+                    dp[i][j] |= dp[i - 1][j]; // a* counts as multiple a
+                    dp[i][j] |= dp[i][j - 2]; // a* counts as empty
+                } else
+                    dp[i][j] = dp[i][j - 2];   // a* only counts as empty
+
+    return dp[m][n];
+}
+```

docs/notes/20. 表示数值的字符串.md

@@ -0,0 +1,49 @@
+# 20. 表示数值的字符串
+
+[NowCoder](https://www.nowcoder.com/practice/6f8c901d091949a5837e24bb82a731f2?tpId=13&tqId=11206&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+```
+true
+
+"+100"
+"5e2"
+"-123"
+"3.1416"
+"-1E-16"
+```
+
+```
+false
+
+"12e"
+"1a3.14"
+"1.2.3"
+"+-5"
+"12e+4.3"
+```
+
+
+## 解题思路
+
+使用正则表达式进行匹配。
+
+```html
+[]  ： 字符集合
+()  ： 分组
+?   ： 重复 0 ~ 1 次
++   ： 重复 1 ~ n 次
+*   ： 重复 0 ~ n 次
+.   ： 任意字符
+\\. ： 转义后的 .
+\\d ： 数字
+```
+
+```java
+public boolean isNumeric(char[] str) {
+    if (str == null || str.length == 0)
+        return false;
+    return new String(str).matches("[+-]?\\d*(\\.\\d+)?([eE][+-]?\\d+)?");
+}
+```

docs/notes/21. 调整数组顺序使奇数位于偶数前面.md

@@ -0,0 +1,60 @@
+# 21. 调整数组顺序使奇数位于偶数前面
+
+[NowCoder](https://www.nowcoder.com/practice/beb5aa231adc45b2a5dcc5b62c93f593?tpId=13&tqId=11166&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+需要保证奇数和奇数，偶数和偶数之间的相对位置不变，这和书本不太一样。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/d03a2efa-ef19-4c96-97e8-ff61df8061d3.png" width="200px">
+
+## 解题思路
+
+方法一：创建一个新数组，时间复杂度 O(N)，空间复杂度 O(N)。
+
+```java
+public void reOrderArray(int[] nums) {
+    // 奇数个数
+    int oddCnt = 0;
+    for (int x : nums)
+        if (!isEven(x))
+            oddCnt++;
+    int[] copy = nums.clone();
+    int i = 0, j = oddCnt;
+    for (int num : copy) {
+        if (num % 2 == 1)
+            nums[i++] = num;
+        else
+            nums[j++] = num;
+    }
+}
+
+private boolean isEven(int x) {
+    return x % 2 == 0;
+}
+```
+
+方法二：使用冒泡思想，每次都当前偶数上浮到当前最右边。时间复杂度 O(N<sup>2</sup>)，空间复杂度 O(1)，时间换空间。
+
+```java
+public void reOrderArray(int[] nums) {
+    int N = nums.length;
+    for (int i = N - 1; i > 0; i--) {
+        for (int j = 0; j < i; j++) {
+            if (isEven(nums[j]) && !isEven(nums[j + 1])) {
+                swap(nums, j, j + 1);
+            }
+        }
+    }
+}
+
+private boolean isEven(int x) {
+    return x % 2 == 0;
+}
+
+private void swap(int[] nums, int i, int j) {
+    int t = nums[i];
+    nums[i] = nums[j];
+    nums[j] = t;
+}
+```

docs/notes/22. 链表中倒数第 K 个结点.md

@@ -0,0 +1,27 @@
+# 22. 链表中倒数第 K 个结点
+
+[NowCoder](https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId=13&tqId=11167&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 解题思路
+
+设链表的长度为 N。设置两个指针 P1 和 P2，先让 P1 移动 K 个节点，则还有 N - K 个节点可以移动。此时让 P1 和 P2 同时移动，可以知道当 P1 移动到链表结尾时，P2 移动到第 N - K 个节点处，该位置就是倒数第 K 个节点。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/6b504f1f-bf76-4aab-a146-a9c7a58c2029.png" width="500"/>
+
+```java
+public ListNode FindKthToTail(ListNode head, int k) {
+    if (head == null)
+        return null;
+    ListNode P1 = head;
+    while (P1 != null && k-- > 0)
+        P1 = P1.next;
+    if (k > 0)
+        return null;
+    ListNode P2 = head;
+    while (P1 != null) {
+        P1 = P1.next;
+        P2 = P2.next;
+    }
+    return P2;
+}
+```

docs/notes/23. 链表中环的入口结点.md

@@ -0,0 +1,33 @@
+# 23. 链表中环的入口结点
+
+[NowCoder](https://www.nowcoder.com/practice/253d2c59ec3e4bc68da16833f79a38e4?tpId=13&tqId=11208&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+一个链表中包含环，请找出该链表的环的入口结点。要求不能使用额外的空间。
+
+## 解题思路
+
+使用双指针，一个指针 fast 每次移动两个节点，一个指针 slow 每次移动一个节点。因为存在环，所以两个指针必定相遇在环中的某个节点上。假设相遇点在下图的 z1 位置，此时 fast 移动的节点数为 x+2y+z，slow 为 x+y，由于 fast 速度比 slow 快一倍，因此 x+2y+z=2(x+y)，得到 x=z。
+
+在相遇点，slow 要到环的入口点还需要移动 z 个节点，如果让 fast 重新从头开始移动，并且速度变为每次移动一个节点，那么它到环入口点还需要移动 x 个节点。在上面已经推导出 x=z，因此 fast 和 slow 将在环入口点相遇。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/bb7fc182-98c2-4860-8ea3-630e27a5f29f.png" width="500"/>
+
+```java
+public ListNode EntryNodeOfLoop(ListNode pHead) {
+    if (pHead == null || pHead.next == null)
+        return null;
+    ListNode slow = pHead, fast = pHead;
+    do {
+        fast = fast.next.next;
+        slow = slow.next;
+    } while (slow != fast);
+    fast = pHead;
+    while (slow != fast) {
+        slow = slow.next;
+        fast = fast.next;
+    }
+    return slow;
+}
+```

docs/notes/24. 反转链表.md

@@ -0,0 +1,36 @@
+# 24. 反转链表
+
+[NowCoder](https://www.nowcoder.com/practice/75e878df47f24fdc9dc3e400ec6058ca?tpId=13&tqId=11168&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 解题思路
+
+### 递归
+
+```java
+public ListNode ReverseList(ListNode head) {
+    if (head == null || head.next == null)
+        return head;
+    ListNode next = head.next;
+    head.next = null;
+    ListNode newHead = ReverseList(next);
+    next.next = head;
+    return newHead;
+}
+```
+
+### 迭代
+
+使用头插法。
+
+```java
+public ListNode ReverseList(ListNode head) {
+    ListNode newList = new ListNode(-1);
+    while (head != null) {
+        ListNode next = head.next;
+        head.next = newList.next;
+        newList.next = head;
+        head = next;
+    }
+    return newList.next;
+}
+```

docs/notes/25. 合并两个排序的链表.md

@@ -0,0 +1,51 @@
+# 25. 合并两个排序的链表
+
+[NowCoder](https://www.nowcoder.com/practice/d8b6b4358f774294a89de2a6ac4d9337?tpId=13&tqId=11169&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/c094d2bc-ec75-444b-af77-d369dfb6b3b4.png" width="400"/>
+
+## 解题思路
+
+### 递归
+
+```java
+public ListNode Merge(ListNode list1, ListNode list2) {
+    if (list1 == null)
+        return list2;
+    if (list2 == null)
+        return list1;
+    if (list1.val <= list2.val) {
+        list1.next = Merge(list1.next, list2);
+        return list1;
+    } else {
+        list2.next = Merge(list1, list2.next);
+        return list2;
+    }
+}
+```
+
+### 迭代
+
+```java
+public ListNode Merge(ListNode list1, ListNode list2) {
+    ListNode head = new ListNode(-1);
+    ListNode cur = head;
+    while (list1 != null && list2 != null) {
+        if (list1.val <= list2.val) {
+            cur.next = list1;
+            list1 = list1.next;
+        } else {
+            cur.next = list2;
+            list2 = list2.next;
+        }
+        cur = cur.next;
+    }
+    if (list1 != null)
+        cur.next = list1;
+    if (list2 != null)
+        cur.next = list2;
+    return head.next;
+}
+```

docs/notes/26. 树的子结构.md

@@ -0,0 +1,27 @@
+# 26. 树的子结构
+
+[NowCoder](https://www.nowcoder.com/practice/6e196c44c7004d15b1610b9afca8bd88?tpId=13&tqId=11170&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/84a5b15a-86c5-4d8e-9439-d9fd5a4699a1.jpg" width="450"/>
+
+## 解题思路
+
+```java
+public boolean HasSubtree(TreeNode root1, TreeNode root2) {
+    if (root1 == null || root2 == null)
+        return false;
+    return isSubtreeWithRoot(root1, root2) || HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
+}
+
+private boolean isSubtreeWithRoot(TreeNode root1, TreeNode root2) {
+    if (root2 == null)
+        return true;
+    if (root1 == null)
+        return false;
+    if (root1.val != root2.val)
+        return false;
+    return isSubtreeWithRoot(root1.left, root2.left) && isSubtreeWithRoot(root1.right, root2.right);
+}
+```

docs/notes/27. 二叉树的镜像.md

@@ -0,0 +1,25 @@
+# 27. 二叉树的镜像
+
+[NowCoder](https://www.nowcoder.com/practice/564f4c26aa584921bc75623e48ca3011?tpId=13&tqId=11171&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/0c12221f-729e-4c22-b0ba-0dfc909f8adf.jpg" width="300"/>
+
+## 解题思路
+
+```java
+public void Mirror(TreeNode root) {
+    if (root == null)
+        return;
+    swap(root);
+    Mirror(root.left);
+    Mirror(root.right);
+}
+
+private void swap(TreeNode root) {
+    TreeNode t = root.left;
+    root.left = root.right;
+    root.right = t;
+}
+```

docs/notes/28. 对称的二叉树.md

@@ -0,0 +1,27 @@
+# 28. 对称的二叉树
+
+[NowCoder](https://www.nowcoder.com/practice/ff05d44dfdb04e1d83bdbdab320efbcb?tpId=13&tqId=11211&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/0c12221f-729e-4c22-b0ba-0dfc909f8adf.jpg" width="300"/>
+
+## 解题思路
+
+```java
+boolean isSymmetrical(TreeNode pRoot) {
+    if (pRoot == null)
+        return true;
+    return isSymmetrical(pRoot.left, pRoot.right);
+}
+
+boolean isSymmetrical(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 isSymmetrical(t1.left, t2.right) && isSymmetrical(t1.right, t2.left);
+}
+```

docs/notes/29. 顺时针打印矩阵.md

@@ -0,0 +1,32 @@
+# 29. 顺时针打印矩阵
+
+[NowCoder](https://www.nowcoder.com/practice/9b4c81a02cd34f76be2659fa0d54342a?tpId=13&tqId=11172&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+下图的矩阵顺时针打印结果为：1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9, 5, 6, 7, 11, 10
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/48517227-324c-4664-bd26-a2d2cffe2bfe.png" width="200px">
+
+## 解题思路
+
+```java
+public ArrayList<Integer> printMatrix(int[][] matrix) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    int r1 = 0, r2 = matrix.length - 1, c1 = 0, c2 = matrix[0].length - 1;
+    while (r1 <= r2 && c1 <= c2) {
+        for (int i = c1; i <= c2; i++)
+            ret.add(matrix[r1][i]);
+        for (int i = r1 + 1; i <= r2; i++)
+            ret.add(matrix[i][c2]);
+        if (r1 != r2)
+            for (int i = c2 - 1; i >= c1; i--)
+                ret.add(matrix[r2][i]);
+        if (c1 != c2)
+            for (int i = r2 - 1; i > r1; i--)
+                ret.add(matrix[i][c1]);
+        r1++; r2--; c1++; c2--;
+    }
+    return ret;
+}
+```

docs/notes/3. 数组中重复的数字.md

@@ -0,0 +1,49 @@
+# 3. 数组中重复的数字
+
+[NowCoder](https://www.nowcoder.com/practice/623a5ac0ea5b4e5f95552655361ae0a8?tpId=13&tqId=11203&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+在一个长度为 n 的数组里的所有数字都在 0 到 n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的，也不知道每个数字重复几次。请找出数组中任意一个重复的数字。
+
+```html
+Input:
+{2, 3, 1, 0, 2, 5}
+
+Output:
+2
+```
+
+## 解题思路
+
+要求时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。
+
+对于这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素调整到第 i 个位置上进行求解。
+
+以 (2, 3, 1, 0, 2, 5) 为例，遍历到位置 4 时，该位置上的数为 2，但是第 2 个位置上已经有一个 2 的值了，因此可以知道 2 重复：
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/49d2adc1-b28a-44bf-babb-d44993f4a2e3.gif" width="250px">
+
+
+```java
+public boolean duplicate(int[] nums, int length, int[] duplication) {
+    if (nums == null || length <= 0)
+        return false;
+    for (int i = 0; i < length; i++) {
+        while (nums[i] != i) {
+            if (nums[i] == nums[nums[i]]) {
+                duplication[0] = nums[i];
+                return true;
+            }
+            swap(nums, i, nums[i]);
+        }
+    }
+    return false;
+}
+
+private void swap(int[] nums, int i, int j) {
+    int t = nums[i];
+    nums[i] = nums[j];
+    nums[j] = t;
+}
+```

docs/notes/30. 包含 min 函数的栈.md

@@ -0,0 +1,32 @@
+# 30. 包含 min 函数的栈
+
+[NowCoder](https://www.nowcoder.com/practice/4c776177d2c04c2494f2555c9fcc1e49?tpId=13&tqId=11173&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的 min 函数。
+
+## 解题思路
+
+```java
+private Stack<Integer> dataStack = new Stack<>();
+private Stack<Integer> minStack = new Stack<>();
+
+public void push(int node) {
+    dataStack.push(node);
+    minStack.push(minStack.isEmpty() ? node : Math.min(minStack.peek(), node));
+}
+
+public void pop() {
+    dataStack.pop();
+    minStack.pop();
+}
+
+public int top() {
+    return dataStack.peek();
+}
+
+public int min() {
+    return minStack.peek();
+}
+```

docs/notes/31. 栈的压入、弹出序列.md

@@ -0,0 +1,29 @@
+# 31. 栈的压入、弹出序列
+
+[NowCoder](https://www.nowcoder.com/practice/d77d11405cc7470d82554cb392585106?tpId=13&tqId=11174&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。
+
+例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。
+
+## 解题思路
+
+使用一个栈来模拟压入弹出操作。
+
+```java
+public boolean IsPopOrder(int[] pushSequence, int[] popSequence) {
+    int n = pushSequence.length;
+    Stack<Integer> stack = new Stack<>();
+    for (int pushIndex = 0, popIndex = 0; pushIndex < n; pushIndex++) {
+        stack.push(pushSequence[pushIndex]);
+        while (popIndex < n && !stack.isEmpty() 
+                && stack.peek() == popSequence[popIndex]) {
+            stack.pop();
+            popIndex++;
+        }
+    }
+    return stack.isEmpty();
+}
+```

docs/notes/32.1 从上往下打印二叉树.md

@@ -0,0 +1,37 @@
+# 32.1 从上往下打印二叉树
+
+[NowCoder](https://www.nowcoder.com/practice/7fe2212963db4790b57431d9ed259701?tpId=13&tqId=11175&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+从上往下打印出二叉树的每个节点，同层节点从左至右打印。
+
+例如，以下二叉树层次遍历的结果为：1,2,3,4,5,6,7
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/d5e838cf-d8a2-49af-90df-1b2a714ee676.jpg" width="250"/>
+
+## 解题思路
+
+使用队列来进行层次遍历。
+
+不需要使用两个队列分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
+
+```java
+public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
+    Queue<TreeNode> queue = new LinkedList<>();
+    ArrayList<Integer> ret = new ArrayList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+        int cnt = queue.size();
+        while (cnt-- > 0) {
+            TreeNode t = queue.poll();
+            if (t == null)
+                continue;
+            ret.add(t.val);
+            queue.add(t.left);
+            queue.add(t.right);
+        }
+    }
+    return ret;
+}
+```

docs/notes/32.2 把二叉树打印成多行.md

@@ -0,0 +1,32 @@
+# 32.2 把二叉树打印成多行
+
+[NowCoder](https://www.nowcoder.com/practice/445c44d982d04483b04a54f298796288?tpId=13&tqId=11213&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+和上题几乎一样。
+
+## 解题思路
+
+```java
+ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
+    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(pRoot);
+    while (!queue.isEmpty()) {
+        ArrayList<Integer> list = new ArrayList<>();
+        int cnt = queue.size();
+        while (cnt-- > 0) {
+            TreeNode node = queue.poll();
+            if (node == null)
+                continue;
+            list.add(node.val);
+            queue.add(node.left);
+            queue.add(node.right);
+        }
+        if (list.size() != 0)
+            ret.add(list);
+    }
+    return ret;
+}
+```

docs/notes/32.3 按之字形顺序打印二叉树.md

@@ -0,0 +1,36 @@
+# 32.3 按之字形顺序打印二叉树
+
+[NowCoder](https://www.nowcoder.com/practice/91b69814117f4e8097390d107d2efbe0?tpId=13&tqId=11212&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
+
+## 解题思路
+
+```java
+public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
+    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(pRoot);
+    boolean reverse = false;
+    while (!queue.isEmpty()) {
+        ArrayList<Integer> list = new ArrayList<>();
+        int cnt = queue.size();
+        while (cnt-- > 0) {
+            TreeNode node = queue.poll();
+            if (node == null)
+                continue;
+            list.add(node.val);
+            queue.add(node.left);
+            queue.add(node.right);
+        }
+        if (reverse)
+            Collections.reverse(list);
+        reverse = !reverse;
+        if (list.size() != 0)
+            ret.add(list);
+    }
+    return ret;
+}
+```

docs/notes/33. 二叉搜索树的后序遍历序列.md

@@ -0,0 +1,34 @@
+# 33. 二叉搜索树的后序遍历序列
+
+[NowCoder](https://www.nowcoder.com/practice/a861533d45854474ac791d90e447bafd?tpId=13&tqId=11176&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。假设输入的数组的任意两个数字都互不相同。
+
+例如，下图是后序遍历序列 1,3,2 所对应的二叉搜索树。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/13454fa1-23a8-4578-9663-2b13a6af564a.jpg" width="150"/>
+
+## 解题思路
+
+```java
+public boolean VerifySquenceOfBST(int[] sequence) {
+    if (sequence == null || sequence.length == 0)
+        return false;
+    return verify(sequence, 0, sequence.length - 1);
+}
+
+private boolean verify(int[] sequence, int first, int last) {
+    if (last - first <= 1)
+        return true;
+    int rootVal = sequence[last];
+    int cutIndex = first;
+    while (cutIndex < last && sequence[cutIndex] <= rootVal)
+        cutIndex++;
+    for (int i = cutIndex; i < last; i++)
+        if (sequence[i] < rootVal)
+            return false;
+    return verify(sequence, first, cutIndex - 1) && verify(sequence, cutIndex, last - 1);
+}
+```

docs/notes/34. 二叉树中和为某一值的路径.md

@@ -0,0 +1,36 @@
+# 34. 二叉树中和为某一值的路径
+
+[NowCoder](https://www.nowcoder.com/practice/b736e784e3e34731af99065031301bca?tpId=13&tqId=11177&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
+
+下图的二叉树有两条和为 22 的路径：10, 5, 7 和 10, 12
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ed77b0e6-38d9-4a34-844f-724f3ffa2c12.jpg" width="200"/>
+
+## 解题思路
+
+```java
+private ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+
+public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
+    backtracking(root, target, new ArrayList<>());
+    return ret;
+}
+
+private void backtracking(TreeNode node, int target, ArrayList<Integer> path) {
+    if (node == null)
+        return;
+    path.add(node.val);
+    target -= node.val;
+    if (target == 0 && node.left == null && node.right == null) {
+        ret.add(new ArrayList<>(path));
+    } else {
+        backtracking(node.left, target, path);
+        backtracking(node.right, target, path);
+    }
+    path.remove(path.size() - 1);
+}
+```

docs/notes/35. 复杂链表的复制.md

@@ -0,0 +1,67 @@
+# 35. 复杂链表的复制
+
+[NowCoder](https://www.nowcoder.com/practice/f836b2c43afc4b35ad6adc41ec941dba?tpId=13&tqId=11178&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的 head。
+
+```java
+public class RandomListNode {
+    int label;
+    RandomListNode next = null;
+    RandomListNode random = null;
+
+    RandomListNode(int label) {
+        this.label = label;
+    }
+}
+```
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/66a01953-5303-43b1-8646-0c77b825e980.png" width="300"/>
+
+## 解题思路
+
+第一步，在每个节点的后面插入复制的节点。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/dfd5d3f8-673c-486b-8ecf-d2082107b67b.png" width="600"/>
+
+第二步，对复制节点的 random 链接进行赋值。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/cafbfeb8-7dfe-4c0a-a3c9-750eeb824068.png" width="600"/>
+
+第三步，拆分。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/e151b5df-5390-4365-b66e-b130cd253c12.png" width="600"/>
+
+```java
+public RandomListNode Clone(RandomListNode pHead) {
+    if (pHead == null)
+        return null;
+    // 插入新节点
+    RandomListNode cur = pHead;
+    while (cur != null) {
+        RandomListNode clone = new RandomListNode(cur.label);
+        clone.next = cur.next;
+        cur.next = clone;
+        cur = clone.next;
+    }
+    // 建立 random 链接
+    cur = pHead;
+    while (cur != null) {
+        RandomListNode clone = cur.next;
+        if (cur.random != null)
+            clone.random = cur.random.next;
+        cur = clone.next;
+    }
+    // 拆分
+    cur = pHead;
+    RandomListNode pCloneHead = pHead.next;
+    while (cur.next != null) {
+        RandomListNode next = cur.next;
+        cur.next = next.next;
+        cur = next;
+    }
+    return pCloneHead;
+}
+```

docs/notes/36. 二叉搜索树与双向链表.md

@@ -0,0 +1,34 @@
+# 36. 二叉搜索树与双向链表
+
+[NowCoder](https://www.nowcoder.com/practice/947f6eb80d944a84850b0538bf0ec3a5?tpId=13&tqId=11179&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/05a08f2e-9914-4a77-92ef-aebeaecf4f66.jpg" width="400"/>
+
+## 解题思路
+
+```java
+private TreeNode pre = null;
+private TreeNode head = null;
+
+public TreeNode Convert(TreeNode root) {
+    inOrder(root);
+    return head;
+}
+
+private void inOrder(TreeNode node) {
+    if (node == null)
+        return;
+    inOrder(node.left);
+    node.left = pre;
+    if (pre != null)
+        pre.right = node;
+    pre = node;
+    if (head == null)
+        head = node;
+    inOrder(node.right);
+}
+```

docs/notes/37. 序列化二叉树.md

@@ -0,0 +1,39 @@
+# 37. 序列化二叉树
+
+[NowCoder](https://www.nowcoder.com/practice/cf7e25aa97c04cc1a68c8f040e71fb84?tpId=13&tqId=11214&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+请实现两个函数，分别用来序列化和反序列化二叉树。
+
+## 解题思路
+
+```java
+private String deserializeStr;
+
+public String Serialize(TreeNode root) {
+    if (root == null)
+        return "#";
+    return root.val + " " + Serialize(root.left) + " " + Serialize(root.right);
+}
+
+public TreeNode Deserialize(String str) {
+    deserializeStr = str;
+    return Deserialize();
+}
+
+private TreeNode Deserialize() {
+    if (deserializeStr.length() == 0)
+        return null;
+    int index = deserializeStr.indexOf(" ");
+    String node = index == -1 ? deserializeStr : deserializeStr.substring(0, index);
+    deserializeStr = index == -1 ? "" : deserializeStr.substring(index + 1);
+    if (node.equals("#"))
+        return null;
+    int val = Integer.valueOf(node);
+    TreeNode t = new TreeNode(val);
+    t.left = Deserialize();
+    t.right = Deserialize();
+    return t;
+}
+```

docs/notes/38. 字符串的排列.md

@@ -0,0 +1,40 @@
+# 38. 字符串的排列
+
+[NowCoder](https://www.nowcoder.com/practice/fe6b651b66ae47d7acce78ffdd9a96c7?tpId=13&tqId=11180&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+输入一个字符串，按字典序打印出该字符串中字符的所有排列。例如输入字符串 abc，则打印出由字符 a, b, c 所能排列出来的所有字符串 abc, acb, bac, bca, cab 和 cba。
+
+## 解题思路
+
+```java
+private ArrayList<String> ret = new ArrayList<>();
+
+public ArrayList<String> Permutation(String str) {
+    if (str.length() == 0)
+        return ret;
+    char[] chars = str.toCharArray();
+    Arrays.sort(chars);
+    backtracking(chars, new boolean[chars.length], new StringBuilder());
+    return ret;
+}
+
+private void backtracking(char[] chars, boolean[] hasUsed, StringBuilder s) {
+    if (s.length() == chars.length) {
+        ret.add(s.toString());
+        return;
+    }
+    for (int i = 0; i < chars.length; i++) {
+        if (hasUsed[i])
+            continue;
+        if (i != 0 && chars[i] == chars[i - 1] && !hasUsed[i - 1]) /* 保证不重复 */
+            continue;
+        hasUsed[i] = true;
+        s.append(chars[i]);
+        backtracking(chars, hasUsed, s);
+        s.deleteCharAt(s.length() - 1);
+        hasUsed[i] = false;
+    }
+}
+```

docs/notes/39. 数组中出现次数超过一半的数字.md

@@ -0,0 +1,27 @@
+# 39. 数组中出现次数超过一半的数字
+
+[NowCoder](https://www.nowcoder.com/practice/e8a1b01a2df14cb2b228b30ee6a92163?tpId=13&tqId=11181&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 解题思路
+
+多数投票问题，可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。
+
+使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素相等时，令 cnt++，否则令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
+
+```java
+public int MoreThanHalfNum_Solution(int[] nums) {
+    int majority = nums[0];
+    for (int i = 1, cnt = 1; i < nums.length; i++) {
+        cnt = nums[i] == majority ? cnt + 1 : cnt - 1;
+        if (cnt == 0) {
+            majority = nums[i];
+            cnt = 1;
+        }
+    }
+    int cnt = 0;
+    for (int val : nums)
+        if (val == majority)
+            cnt++;
+    return cnt > nums.length / 2 ? majority : 0;
+}
+```

docs/notes/4. 二维数组中的查找.md

@@ -0,0 +1,47 @@
+# 4. 二维数组中的查找
+
+[NowCoder](https://www.nowcoder.com/practice/abc3fe2ce8e146608e868a70efebf62e?tpId=13&tqId=11154&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+给定一个二维数组，其每一行从左到右递增排序，从上到下也是递增排序。给定一个数，判断这个数是否在该二维数组中。
+
+```html
+Consider the following matrix:
+[
+  [1,   4,  7, 11, 15],
+  [2,   5,  8, 12, 19],
+  [3,   6,  9, 16, 22],
+  [10, 13, 14, 17, 24],
+  [18, 21, 23, 26, 30]
+]
+
+Given target = 5, return true.
+Given target = 20, return false.
+```
+
+## 解题思路
+
+要求时间复杂度 O(M + N)，空间复杂度 O(1)。其中 M 为行数，N 为 列数。
+
+该二维数组中的一个数，小于它的数一定在其左边，大于它的数一定在其下边。因此，从右上角开始查找，就可以根据 target 和当前元素的大小关系来缩小查找区间，当前元素的查找区间为左下角的所有元素。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/0ad9f7ba-f408-4999-a77a-9b73562c9088.gif" width="200px">
+
+```java
+public boolean Find(int target, int[][] matrix) {
+    if (matrix == null || matrix.length == 0 || matrix[0].length == 0)
+        return false;
+    int rows = matrix.length, cols = matrix[0].length;
+    int r = 0, c = cols - 1; // 从右上角开始
+    while (r <= rows - 1 && c >= 0) {
+        if (target == matrix[r][c])
+            return true;
+        else if (target > matrix[r][c])
+            r++;
+        else
+            c--;
+    }
+    return false;
+}
+```

docs/notes/40. 最小的 K 个数.md

@@ -0,0 +1,81 @@
+# 40. 最小的 K 个数
+
+[NowCoder](https://www.nowcoder.com/practice/6a296eb82cf844ca8539b57c23e6e9bf?tpId=13&tqId=11182&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 解题思路
+
+### 快速选择
+
+- 复杂度：O(N) + O(1)
+- 只有当允许修改数组元素时才可以使用
+
+快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。可以利用这个特性找出数组的第 K 个元素，这种找第 K 个元素的算法称为快速选择算法。
+
+```java
+public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    if (k > nums.length || k <= 0)
+        return ret;
+    findKthSmallest(nums, k - 1);
+    /* findKthSmallest 会改变数组，使得前 k 个数都是最小的 k 个数 */
+    for (int i = 0; i < k; i++)
+        ret.add(nums[i]);
+    return ret;
+}
+
+public void 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)
+            h = j - 1;
+        else
+            l = j + 1;
+    }
+}
+
+private int partition(int[] nums, int l, int h) {
+    int p = nums[l];     /* 切分元素 */
+    int i = l, j = h + 1;
+    while (true) {
+        while (i != h && nums[++i] < p) ;
+        while (j != l && nums[--j] > p) ;
+        if (i >= j)
+            break;
+        swap(nums, i, j);
+    }
+    swap(nums, l, j);
+    return j;
+}
+
+private void swap(int[] nums, int i, int j) {
+    int t = nums[i];
+    nums[i] = nums[j];
+    nums[j] = t;
+}
+```
+
+### 大小为 K 的最小堆
+
+- 复杂度：O(NlogK) + O(K)
+- 特别适合处理海量数据
+
+应该使用大顶堆来维护最小堆，而不能直接创建一个小顶堆并设置一个大小，企图让小顶堆中的元素都是最小元素。
+
+维护一个大小为 K 的最小堆过程如下：在添加一个元素之后，如果大顶堆的大小大于 K，那么需要将大顶堆的堆顶元素去除。
+
+```java
+public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
+    if (k > nums.length || k <= 0)
+        return new ArrayList<>();
+    PriorityQueue<Integer> maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
+    for (int num : nums) {
+        maxHeap.add(num);
+        if (maxHeap.size() > k)
+            maxHeap.poll();
+    }
+    return new ArrayList<>(maxHeap);
+}
+```

docs/notes/41.1 数据流中的中位数.md

@@ -0,0 +1,40 @@
+# 41.1 数据流中的中位数
+
+[NowCoder](https://www.nowcoder.com/practice/9be0172896bd43948f8a32fb954e1be1?tpId=13&tqId=11216&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
+
+## 解题思路
+
+```java
+/* 大顶堆，存储左半边元素 */
+private PriorityQueue<Integer> left = new PriorityQueue<>((o1, o2) -> o2 - o1);
+/* 小顶堆，存储右半边元素，并且右半边元素都大于左半边 */
+private PriorityQueue<Integer> right = new PriorityQueue<>();
+/* 当前数据流读入的元素个数 */
+private int N = 0;
+
+public void Insert(Integer val) {
+    /* 插入要保证两个堆存于平衡状态 */
+    if (N % 2 == 0) {
+        /* N 为偶数的情况下插入到右半边。
+         * 因为右半边元素都要大于左半边，但是新插入的元素不一定比左半边元素来的大，
+         * 因此需要先将元素插入左半边，然后利用左半边为大顶堆的特点，取出堆顶元素即为最大元素，此时插入右半边 */
+        left.add(val);
+        right.add(left.poll());
+    } else {
+        right.add(val);
+        left.add(right.poll());
+    }
+    N++;
+}
+
+public Double GetMedian() {
+    if (N % 2 == 0)
+        return (left.peek() + right.peek()) / 2.0;
+    else
+        return (double) right.peek();
+}
+```

docs/notes/41.2 字符流中第一个不重复的字符.md

@@ -0,0 +1,25 @@
+# 41.2 字符流中第一个不重复的字符
+
+[NowCoder](https://www.nowcoder.com/practice/00de97733b8e4f97a3fb5c680ee10720?tpId=13&tqId=11207&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符 "go" 时，第一个只出现一次的字符是 "g"。当从该字符流中读出前六个字符“google" 时，第一个只出现一次的字符是 "l"。
+
+## 解题思路
+
+```java
+private int[] cnts = new int[256];
+private Queue<Character> queue = new LinkedList<>();
+
+public void Insert(char ch) {
+    cnts[ch]++;
+    queue.add(ch);
+    while (!queue.isEmpty() && cnts[queue.peek()] > 1)
+        queue.poll();
+}
+
+public char FirstAppearingOnce() {
+    return queue.isEmpty() ? '#' : queue.peek();
+}
+```

docs/notes/42. 连续子数组的最大和.md

@@ -0,0 +1,24 @@
+# 42. 连续子数组的最大和
+
+[NowCoder](https://www.nowcoder.com/practice/459bd355da1549fa8a49e350bf3df484?tpId=13&tqId=11183&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+{6, -3, -2, 7, -15, 1, 2, 2}，连续子数组的最大和为 8（从第 0 个开始，到第 3 个为止）。
+
+## 解题思路
+
+```java
+public int FindGreatestSumOfSubArray(int[] nums) {
+    if (nums == null || nums.length == 0)
+        return 0;
+    int greatestSum = Integer.MIN_VALUE;
+    int sum = 0;
+    for (int val : nums) {
+        sum = sum <= 0 ? val : sum + val;
+        greatestSum = Math.max(greatestSum, sum);
+    }
+    return greatestSum;
+}
+```
+

docs/notes/43. 从 1 到 n 整数中 1 出现的次数.md

@@ -0,0 +1,18 @@
+# 43. 从 1 到 n 整数中 1 出现的次数
+
+[NowCoder](https://www.nowcoder.com/practice/bd7f978302044eee894445e244c7eee6?tpId=13&tqId=11184&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 解题思路
+
+```java
+public int NumberOf1Between1AndN_Solution(int n) {
+    int cnt = 0;
+    for (int m = 1; m <= n; m *= 10) {
+        int a = n / m, b = n % m;
+        cnt += (a + 8) / 10 * m + (a % 10 == 1 ? b + 1 : 0);
+    }
+    return cnt;
+}
+```
+
+> [Leetcode : 233. Number of Digit One](https://leetcode.com/problems/number-of-digit-one/discuss/64381/4+-lines-O(log-n)-C++JavaPython)

docs/notes/44. 数字序列中的某一位数字.md

@@ -0,0 +1,54 @@
+# 44. 数字序列中的某一位数字
+
+## 题目描述
+
+数字以 0123456789101112131415... 的格式序列化到一个字符串中，求这个字符串的第 index 位。
+
+## 解题思路
+
+```java
+public int getDigitAtIndex(int index) {
+    if (index < 0)
+        return -1;
+    int place = 1;  // 1 表示个位，2 表示 十位...
+    while (true) {
+        int amount = getAmountOfPlace(place);
+        int totalAmount = amount * place;
+        if (index < totalAmount)
+            return getDigitAtIndex(index, place);
+        index -= totalAmount;
+        place++;
+    }
+}
+
+/**
+ * place 位数的数字组成的字符串长度
+ * 10, 90, 900, ...
+ */
+private int getAmountOfPlace(int place) {
+    if (place == 1)
+        return 10;
+    return (int) Math.pow(10, place - 1) * 9;
+}
+
+/**
+ * place 位数的起始数字
+ * 0, 10, 100, ...
+ */
+private int getBeginNumberOfPlace(int place) {
+    if (place == 1)
+        return 0;
+    return (int) Math.pow(10, place - 1);
+}
+
+/**
+ * 在 place 位数组成的字符串中，第 index 个数
+ */
+private int getDigitAtIndex(int index, int place) {
+    int beginNumber = getBeginNumberOfPlace(place);
+    int shiftNumber = index / place;
+    String number = (beginNumber + shiftNumber) + "";
+    int count = index % place;
+    return number.charAt(count) - '0';
+}
+```

docs/notes/45. 把数组排成最小的数.md

@@ -0,0 +1,27 @@
+# 45. 把数组排成最小的数
+
+[NowCoder](https://www.nowcoder.com/practice/8fecd3f8ba334add803bf2a06af1b993?tpId=13&tqId=11185&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组 {3，32，321}，则打印出这三个数字能排成的最小数字为 321323。
+
+## 解题思路
+
+可以看成是一个排序问题，在比较两个字符串 S1 和 S2 的大小时，应该比较的是 S1+S2 和 S2+S1 的大小，如果 S1+S2 < S2+S1，那么应该把 S1 排在前面，否则应该把 S2 排在前面。
+
+```java
+public String PrintMinNumber(int[] numbers) {
+    if (numbers == null || numbers.length == 0)
+        return "";
+    int n = numbers.length;
+    String[] nums = new String[n];
+    for (int i = 0; i < n; i++)
+        nums[i] = numbers[i] + "";
+    Arrays.sort(nums, (s1, s2) -> (s1 + s2).compareTo(s2 + s1));
+    String ret = "";
+    for (String str : nums)
+        ret += str;
+    return ret;
+}
+```

docs/notes/46. 把数字翻译成字符串.md

@@ -0,0 +1,31 @@
+# 46. 把数字翻译成字符串
+
+[Leetcode](https://leetcode.com/problems/decode-ways/description/)
+
+## 题目描述
+
+给定一个数字，按照如下规则翻译成字符串：1 翻译成“a”，2 翻译成“b”... 26 翻译成“z”。一个数字有多种翻译可能，例如 12258 一共有 5 种，分别是 abbeh，lbeh，aveh，abyh，lyh。实现一个函数，用来计算一个数字有多少种不同的翻译方法。
+
+## 解题思路
+
+```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];
+}
+```

docs/notes/47. 礼物的最大价值.md

@@ -0,0 +1,35 @@
+# 47. 礼物的最大价值
+
+[NowCoder](https://www.nowcoder.com/questionTerminal/72a99e28381a407991f2c96d8cb238ab)
+
+## 题目描述
+
+在一个 m\*n 的棋盘的每一个格都放有一个礼物，每个礼物都有一定价值（大于 0）。从左上角开始拿礼物，每次向右或向下移动一格，直到右下角结束。给定一个棋盘，求拿到礼物的最大价值。例如，对于如下棋盘
+
+```
+1    10   3    8
+12   2    9    6
+5    7    4    11
+3    7    16   5
+```
+
+礼物的最大价值为 1+12+5+7+7+16+5=53。
+
+## 解题思路
+
+应该用动态规划求解，而不是深度优先搜索，深度优先搜索过于复杂，不是最优解。
+
+```java
+public int getMost(int[][] values) {
+    if (values == null || values.length == 0 || values[0].length == 0)
+        return 0;
+    int n = values[0].length;
+    int[] dp = new int[n];
+    for (int[] value : values) {
+        dp[0] += value[0];
+        for (int i = 1; i < n; i++)
+            dp[i] = Math.max(dp[i], dp[i - 1]) + value[i];
+    }
+    return dp[n - 1];
+}
+```

docs/notes/48. 最长不含重复字符的子字符串.md

@@ -0,0 +1,29 @@
+# 48. 最长不含重复字符的子字符串
+
+## 题目描述
+
+输入一个字符串（只包含 a\~z 的字符），求其最长不含重复字符的子字符串的长度。例如对于 arabcacfr，最长不含重复字符的子字符串为 acfr，长度为 4。
+
+## 解题思路
+
+```java
+public int longestSubStringWithoutDuplication(String str) {
+    int curLen = 0;
+    int maxLen = 0;
+    int[] preIndexs = new int[26];
+    Arrays.fill(preIndexs, -1);
+    for (int curI = 0; curI < str.length(); curI++) {
+        int c = str.charAt(curI) - 'a';
+        int preI = preIndexs[c];
+        if (preI == -1 || curI - preI > curLen) {
+            curLen++;
+        } else {
+            maxLen = Math.max(maxLen, curLen);
+            curLen = curI - preI;
+        }
+        preIndexs[c] = curI;
+    }
+    maxLen = Math.max(maxLen, curLen);
+    return maxLen;
+}
+```

docs/notes/49. 丑数.md

@@ -0,0 +1,30 @@
+# 49. 丑数
+
+[NowCoder](https://www.nowcoder.com/practice/6aa9e04fc3794f68acf8778237ba065b?tpId=13&tqId=11186&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+把只包含因子 2、3 和 5 的数称作丑数（Ugly Number）。例如 6、8 都是丑数，但 14 不是，因为它包含因子 7。习惯上我们把 1 当做是第一个丑数。求按从小到大的顺序的第 N 个丑数。
+
+## 解题思路
+
+```java
+public int GetUglyNumber_Solution(int N) {
+    if (N <= 6)
+        return N;
+    int i2 = 0, i3 = 0, i5 = 0;
+    int[] dp = new int[N];
+    dp[0] = 1;
+    for (int i = 1; i < N; i++) {
+        int next2 = dp[i2] * 2, next3 = dp[i3] * 3, next5 = dp[i5] * 5;
+        dp[i] = Math.min(next2, Math.min(next3, next5));
+        if (dp[i] == next2)
+            i2++;
+        if (dp[i] == next3)
+            i3++;
+        if (dp[i] == next5)
+            i5++;
+    }
+    return dp[N - 1];
+}
+```

docs/notes/5. 替换空格.md

@@ -0,0 +1,48 @@
+# 5. 替换空格
+
+[NowCoder](https://www.nowcoder.com/practice/4060ac7e3e404ad1a894ef3e17650423?tpId=13&tqId=11155&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+
+将一个字符串中的空格替换成 "%20"。
+
+```text
+Input:
+"A B"
+
+Output:
+"A%20B"
+```
+
+## 解题思路
+
+在字符串尾部填充任意字符，使得字符串的长度等于替换之后的长度。因为一个空格要替换成三个字符（%20），因此当遍历到一个空格时，需要在尾部填充两个任意字符。
+
+令 P1 指向字符串原来的末尾位置，P2 指向字符串现在的末尾位置。P1 和 P2 从后向前遍历，当 P1 遍历到一个空格时，就需要令 P2 指向的位置依次填充 02%（注意是逆序的），否则就填充上 P1 指向字符的值。
+
+从后向前遍是为了在改变 P2 所指向的内容时，不会影响到 P1 遍历原来字符串的内容。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/6980aef0-debe-4b4b-8da5-8b1befbc1408.gif" width="230px">
+
+```java
+public String replaceSpace(StringBuffer str) {
+    int P1 = str.length() - 1;
+    for (int i = 0; i <= P1; i++)
+        if (str.charAt(i) == ' ')
+            str.append("  ");
+
+    int P2 = str.length() - 1;
+    while (P1 >= 0 && P2 > P1) {
+        char c = str.charAt(P1--);
+        if (c == ' ') {
+            str.setCharAt(P2--, '0');
+            str.setCharAt(P2--, '2');
+            str.setCharAt(P2--, '%');
+        } else {
+            str.setCharAt(P2--, c);
+        }
+    }
+    return str.toString();
+}
+```

docs/notes/50. 第一个只出现一次的字符位置.md

@@ -0,0 +1,49 @@
+# 50. 第一个只出现一次的字符位置
+
+[NowCoder](https://www.nowcoder.com/practice/1c82e8cf713b4bbeb2a5b31cf5b0417c?tpId=13&tqId=11187&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+在一个字符串中找到第一个只出现一次的字符，并返回它的位置。
+
+```
+Input: abacc
+Output: b
+```
+
+## 解题思路
+
+最直观的解法是使用 HashMap 对出现次数进行统计，但是考虑到要统计的字符范围有限，因此可以使用整型数组代替 HashMap，从而将空间复杂度由 O(N) 降低为 O(1)。
+
+```java
+public int FirstNotRepeatingChar(String str) {
+    int[] cnts = new int[256];
+    for (int i = 0; i < str.length(); i++)
+        cnts[str.charAt(i)]++;
+    for (int i = 0; i < str.length(); i++)
+        if (cnts[str.charAt(i)] == 1)
+            return i;
+    return -1;
+}
+```
+
+以上实现的空间复杂度还不是最优的。考虑到只需要找到只出现一次的字符，那么需要统计的次数信息只有 0,1,更大，使用两个比特位就能存储这些信息。
+
+```java
+public int FirstNotRepeatingChar2(String str) {
+    BitSet bs1 = new BitSet(256);
+    BitSet bs2 = new BitSet(256);
+    for (char c : str.toCharArray()) {
+        if (!bs1.get(c) && !bs2.get(c))
+            bs1.set(c);     // 0 0 -> 0 1
+        else if (bs1.get(c) && !bs2.get(c))
+            bs2.set(c);     // 0 1 -> 1 1
+    }
+    for (int i = 0; i < str.length(); i++) {
+        char c = str.charAt(i);
+        if (bs1.get(c) && !bs2.get(c))  // 0 1
+            return i;
+    }
+    return -1;
+}
+```

docs/notes/51. 数组中的逆序对.md

@@ -0,0 +1,48 @@
+# 51. 数组中的逆序对
+
+[NowCoder](https://www.nowcoder.com/practice/96bd6684e04a44eb80e6a68efc0ec6c5?tpId=13&tqId=11188&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
+
+## 解题思路
+
+```java
+private long cnt = 0;
+private int[] tmp;  // 在这里声明辅助数组，而不是在 merge() 递归函数中声明
+
+public int InversePairs(int[] nums) {
+    tmp = new int[nums.length];
+    mergeSort(nums, 0, nums.length - 1);
+    return (int) (cnt % 1000000007);
+}
+
+private void mergeSort(int[] nums, int l, int h) {
+    if (h - l < 1)
+        return;
+    int m = l + (h - l) / 2;
+    mergeSort(nums, l, m);
+    mergeSort(nums, m + 1, h);
+    merge(nums, l, m, h);
+}
+
+private void merge(int[] nums, int l, int m, int h) {
+    int i = l, j = m + 1, k = l;
+    while (i <= m || j <= h) {
+        if (i > m)
+            tmp[k] = nums[j++];
+        else if (j > h)
+            tmp[k] = nums[i++];
+        else if (nums[i] <= nums[j])
+            tmp[k] = nums[i++];
+        else {
+            tmp[k] = nums[j++];
+            this.cnt += m - i + 1;  // nums[i] > nums[j]，说明 nums[i...mid] 都大于 nums[j]
+        }
+        k++;
+    }
+    for (k = l; k <= h; k++)
+        nums[k] = tmp[k];
+}
+```

docs/notes/52. 两个链表的第一个公共结点.md

@@ -0,0 +1,24 @@
+# 52. 两个链表的第一个公共结点
+
+[NowCoder](https://www.nowcoder.com/practice/6ab1d9a29e88450685099d45c9e31e46?tpId=13&tqId=11189&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/5f1cb999-cb9a-4f6c-a0af-d90377295ab8.png" width="500"/>
+
+## 解题思路
+
+设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
+
+当访问链表 A 的指针访问到链表尾部时，令它从链表 B 的头部重新开始访问链表 B；同样地，当访问链表 B 的指针访问到链表尾部时，令它从链表 A 的头部重新开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
+
+```java
+public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
+    ListNode l1 = pHead1, l2 = pHead2;
+    while (l1 != l2) {
+        l1 = (l1 == null) ? pHead2 : l1.next;
+        l2 = (l2 == null) ? pHead1 : l2.next;
+    }
+    return l1;
+}
+```

docs/notes/53. 数字在排序数组中出现的次数.md

@@ -0,0 +1,36 @@
+# 53. 数字在排序数组中出现的次数
+
+[NowCoder](https://www.nowcoder.com/practice/70610bf967994b22bb1c26f9ae901fa2?tpId=13&tqId=11190&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+```html
+Input:
+nums = 1, 2, 3, 3, 3, 3, 4, 6
+K = 3
+
+Output:
+4
+```
+
+## 解题思路
+
+```java
+public int GetNumberOfK(int[] nums, int K) {
+    int first = binarySearch(nums, K);
+    int last = binarySearch(nums, K + 1);
+    return (first == nums.length || nums[first] != K) ? 0 : last - first;
+}
+
+private int binarySearch(int[] nums, int K) {
+    int l = 0, h = nums.length;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] >= K)
+            h = m;
+        else
+            l = m + 1;
+    }
+    return l;
+}
+```

docs/notes/54. 二叉查找树的第 K 个结点.md

@@ -0,0 +1,27 @@
+# 54. 二叉查找树的第 K 个结点
+
+[NowCoder](https://www.nowcoder.com/practice/ef068f602dde4d28aab2b210e859150a?tpId=13&tqId=11215&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 解题思路
+
+利用二叉查找树中序遍历有序的特点。
+
+```java
+private TreeNode ret;
+private int cnt = 0;
+
+public TreeNode KthNode(TreeNode pRoot, int k) {
+    inOrder(pRoot, k);
+    return ret;
+}
+
+private void inOrder(TreeNode root, int k) {
+    if (root == null || cnt >= k)
+        return;
+    inOrder(root.left, k);
+    cnt++;
+    if (cnt == k)
+        ret = root;
+    inOrder(root.right, k);
+}
+```

docs/notes/55.1 二叉树的深度.md

@@ -0,0 +1,17 @@
+# 55.1 二叉树的深度
+
+[NowCoder](https://www.nowcoder.com/practice/435fb86331474282a3499955f0a41e8b?tpId=13&tqId=11191&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ba355101-4a93-4c71-94fb-1da83639727b.jpg" width="350px"/>
+
+## 解题思路
+
+```java
+public int TreeDepth(TreeNode root) {
+    return root == null ? 0 : 1 + Math.max(TreeDepth(root.left), TreeDepth(root.right));
+}
+```

docs/notes/55.2 平衡二叉树.md

@@ -0,0 +1,30 @@
+# 55.2 平衡二叉树
+
+[NowCoder](https://www.nowcoder.com/practice/8b3b95850edb4115918ecebdf1b4d222?tpId=13&tqId=11192&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+平衡二叉树左右子树高度差不超过 1。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/af1d1166-63af-47b6-9aa3-2bf2bd37bd03.jpg" width="250px"/>
+
+## 解题思路
+
+```java
+private boolean isBalanced = true;
+
+public boolean IsBalanced_Solution(TreeNode root) {
+    height(root);
+    return isBalanced;
+}
+
+private int height(TreeNode root) {
+    if (root == null || !isBalanced)
+        return 0;
+    int left = height(root.left);
+    int right = height(root.right);
+    if (Math.abs(left - right) > 1)
+        isBalanced = false;
+    return 1 + Math.max(left, right);
+}
+```

docs/notes/56. 数组中只出现一次的数字.md

@@ -0,0 +1,28 @@
+# 56. 数组中只出现一次的数字
+
+[NowCoder](https://www.nowcoder.com/practice/e02fdb54d7524710a7d664d082bb7811?tpId=13&tqId=11193&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+一个整型数组里除了两个数字之外，其他的数字都出现了两次，找出这两个数。
+
+## 解题思路
+
+两个不相等的元素在位级表示上必定会有一位存在不同，将数组的所有元素异或得到的结果为不存在重复的两个元素异或的结果。
+
+diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
+
+```java
+public void FindNumsAppearOnce(int[] nums, int num1[], int num2[]) {
+    int diff = 0;
+    for (int num : nums)
+        diff ^= num;
+    diff &= -diff;
+    for (int num : nums) {
+        if ((num & diff) == 0)
+            num1[0] ^= num;
+        else
+            num2[0] ^= num;
+    }
+}
+```

docs/notes/57.1 和为 S 的两个数字.md

@@ -0,0 +1,31 @@
+# 57.1 和为 S 的两个数字
+
+[NowCoder](https://www.nowcoder.com/practice/390da4f7a00f44bea7c2f3d19491311b?tpId=13&tqId=11195&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+输入一个递增排序的数组和一个数字 S，在数组中查找两个数，使得他们的和正好是 S。如果有多对数字的和等于 S，输出两个数的乘积最小的。
+
+## 解题思路
+
+使用双指针，一个指针指向元素较小的值，一个指针指向元素较大的值。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。
+
+- 如果两个指针指向元素的和 sum == target，那么得到要求的结果；
+- 如果 sum > target，移动较大的元素，使 sum 变小一些；
+- 如果 sum < target，移动较小的元素，使 sum 变大一些。
+
+```java
+public ArrayList<Integer> FindNumbersWithSum(int[] array, int sum) {
+    int i = 0, j = array.length - 1;
+    while (i < j) {
+        int cur = array[i] + array[j];
+        if (cur == sum)
+            return new ArrayList<>(Arrays.asList(array[i], array[j]));
+        if (cur < sum)
+            i++;
+        else
+            j--;
+    }
+    return new ArrayList<>();
+}
+```

docs/notes/57.2 和为 S 的连续正数序列.md

@@ -0,0 +1,43 @@
+# 57.2 和为 S 的连续正数序列
+
+[NowCoder](https://www.nowcoder.com/practice/c451a3fd84b64cb19485dad758a55ebe?tpId=13&tqId=11194&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+输出所有和为 S 的连续正数序列。
+
+例如和为 100 的连续序列有：
+
+```
+[9, 10, 11, 12, 13, 14, 15, 16]
+[18, 19, 20, 21, 22]。
+```
+
+## 解题思路
+
+```java
+public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {
+    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+    int start = 1, end = 2;
+    int curSum = 3;
+    while (end < sum) {
+        if (curSum > sum) {
+            curSum -= start;
+            start++;
+        } else if (curSum < sum) {
+            end++;
+            curSum += end;
+        } else {
+            ArrayList<Integer> list = new ArrayList<>();
+            for (int i = start; i <= end; i++)
+                list.add(i);
+            ret.add(list);
+            curSum -= start;
+            start++;
+            end++;
+            curSum += end;
+        }
+    }
+    return ret;
+}
+```

docs/notes/58.1 翻转单词顺序列.md

@@ -0,0 +1,47 @@
+# 58.1 翻转单词顺序列
+
+[NowCoder](https://www.nowcoder.com/practice/3194a4f4cf814f63919d0790578d51f3?tpId=13&tqId=11197&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+```html
+Input:
+"I am a student."
+
+Output:
+"student. a am I"
+```
+
+## 解题思路
+
+题目应该有一个隐含条件，就是不能用额外的空间。虽然 Java 的题目输入参数为 String 类型，需要先创建一个字符数组使得空间复杂度为 O(N)，但是正确的参数类型应该和原书一样，为字符数组，并且只能使用该字符数组的空间。任何使用了额外空间的解法在面试时都会大打折扣，包括递归解法。
+
+正确的解法应该是和书上一样，先旋转每个单词，再旋转整个字符串。
+
+```java
+public String ReverseSentence(String str) {
+    int n = str.length();
+    char[] chars = str.toCharArray();
+    int i = 0, j = 0;
+    while (j <= n) {
+        if (j == n || chars[j] == ' ') {
+            reverse(chars, i, j - 1);
+            i = j + 1;
+        }
+        j++;
+    }
+    reverse(chars, 0, n - 1);
+    return new String(chars);
+}
+
+private void reverse(char[] c, int i, int j) {
+    while (i < j)
+        swap(c, i++, j--);
+}
+
+private void swap(char[] c, int i, int j) {
+    char t = c[i];
+    c[i] = c[j];
+    c[j] = t;
+}
+```

docs/notes/58.2 左旋转字符串.md

@@ -0,0 +1,41 @@
+# 58.2 左旋转字符串
+
+[NowCoder](https://www.nowcoder.com/practice/12d959b108cb42b1ab72cef4d36af5ec?tpId=13&tqId=11196&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+```html
+Input:
+S="abcXYZdef"
+K=3
+
+Output:
+"XYZdefabc"
+```
+
+## 解题思路
+
+先将 "abc" 和 "XYZdef" 分别翻转，得到 "cbafedZYX"，然后再把整个字符串翻转得到 "XYZdefabc"。
+
+```java
+public String LeftRotateString(String str, int n) {
+    if (n >= str.length())
+        return str;
+    char[] chars = str.toCharArray();
+    reverse(chars, 0, n - 1);
+    reverse(chars, n, chars.length - 1);
+    reverse(chars, 0, chars.length - 1);
+    return new String(chars);
+}
+
+private void reverse(char[] chars, int i, int j) {
+    while (i < j)
+        swap(chars, i++, j--);
+}
+
+private void swap(char[] chars, int i, int j) {
+    char t = chars[i];
+    chars[i] = chars[j];
+    chars[j] = t;
+}
+```

docs/notes/59. 滑动窗口的最大值.md

@@ -0,0 +1,29 @@
+# 59. 滑动窗口的最大值
+
+[NowCoder](https://www.nowcoder.com/practice/1624bc35a45c42c0bc17d17fa0cba788?tpId=13&tqId=11217&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。
+
+例如，如果输入数组 {2, 3, 4, 2, 6, 2, 5, 1} 及滑动窗口的大小 3，那么一共存在 6 个滑动窗口，他们的最大值分别为 {4, 4, 6, 6, 6, 5}。
+
+## 解题思路
+
+```java
+public ArrayList<Integer> maxInWindows(int[] num, int size) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    if (size > num.length || size < 1)
+        return ret;
+    PriorityQueue<Integer> heap = new PriorityQueue<>((o1, o2) -> o2 - o1);  /* 大顶堆 */
+    for (int i = 0; i < size; i++)
+        heap.add(num[i]);
+    ret.add(heap.peek());
+    for (int i = 0, j = i + size; j < num.length; i++, j++) {            /* 维护一个大小为 size 的大顶堆 */
+        heap.remove(num[i]);
+        heap.add(num[j]);
+        ret.add(heap.peek());
+    }
+    return ret;
+}
+```

docs/notes/6. 从尾到头打印链表.md

@@ -0,0 +1,78 @@
+# 6. 从尾到头打印链表
+
+[NowCoder](https://www.nowcoder.com/practice/d0267f7f55b3412ba93bd35cfa8e8035?tpId=13&tqId=11156&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+从尾到头反过来打印出每个结点的值。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/f5792051-d9b2-4ca4-a234-a4a2de3d5a57.png" width="280px">
+
+## 解题思路
+
+### 使用递归
+
+要逆序打印链表 1->2->3（3,2,1)，可以先逆序打印链表 2->3(3,2)，最后再打印第一个节点 1。而链表 2->3 可以看成一个新的链表，要逆序打印该链表可以继续使用求解函数，也就是在求解函数中调用自己，这就是递归函数。
+
+```java
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    if (listNode != null) {
+        ret.addAll(printListFromTailToHead(listNode.next));
+        ret.add(listNode.val);
+    }
+    return ret;
+}
+```
+
+### 使用头插法
+
+使用头插法可以得到一个逆序的链表。
+
+头结点和第一个节点的区别：
+
+- 头结点是在头插法中使用的一个额外节点，这个节点不存储值；
+- 第一个节点就是链表的第一个真正存储值的节点。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/0dae7e93-cfd1-4bd3-97e8-325b032b716f.gif" width="370px">
+
+```java
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    // 头插法构建逆序链表
+    ListNode head = new ListNode(-1);
+    while (listNode != null) {
+        ListNode memo = listNode.next;
+        listNode.next = head.next;
+        head.next = listNode;
+        listNode = memo;
+    }
+    // 构建 ArrayList
+    ArrayList<Integer> ret = new ArrayList<>();
+    head = head.next;
+    while (head != null) {
+        ret.add(head.val);
+        head = head.next;
+    }
+    return ret;
+}
+```
+
+### 使用栈
+
+栈具有后进先出的特点，在遍历链表时将值按顺序放入栈中，最后出栈的顺序即为逆序。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9d1deeba-4ae1-41dc-98f4-47d85b9831bc.gif" width="300px">
+
+```java
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    Stack<Integer> stack = new Stack<>();
+    while (listNode != null) {
+        stack.add(listNode.val);
+        listNode = listNode.next;
+    }
+    ArrayList<Integer> ret = new ArrayList<>();
+    while (!stack.isEmpty())
+        ret.add(stack.pop());
+    return ret;
+}
+```

docs/notes/60. n 个骰子的点数.md

@@ -0,0 +1,72 @@
+# 60. n 个骰子的点数
+
+[Lintcode](https://www.lintcode.com/en/problem/dices-sum/)
+
+## 题目描述
+
+把 n 个骰子扔在地上，求点数和为 s 的概率。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/195f8693-5ec4-4987-8560-f25e365879dd.png" width="300px">
+
+## 解题思路
+
+### 动态规划
+
+使用一个二维数组 dp 存储点数出现的次数，其中 dp[i][j] 表示前 i 个骰子产生点数 j 的次数。
+
+空间复杂度：O(N<sup>2</sup>)
+
+```java
+public List<Map.Entry<Integer, Double>> dicesSum(int n) {
+    final int face = 6;
+    final int pointNum = face * n;
+    long[][] dp = new long[n + 1][pointNum + 1];
+
+    for (int i = 1; i <= face; i++)
+        dp[1][i] = 1;
+
+    for (int i = 2; i <= n; i++)
+        for (int j = i; j <= pointNum; j++)     /* 使用 i 个骰子最小点数为 i */
+            for (int k = 1; k <= face && k <= j; k++)
+                dp[i][j] += dp[i - 1][j - k];
+
+    final double totalNum = Math.pow(6, n);
+    List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
+    for (int i = n; i <= pointNum; i++)
+        ret.add(new AbstractMap.SimpleEntry<>(i, dp[n][i] / totalNum));
+
+    return ret;
+}
+```
+
+### 动态规划 + 旋转数组
+
+空间复杂度：O(N)
+
+```java
+public List<Map.Entry<Integer, Double>> dicesSum(int n) {
+    final int face = 6;
+    final int pointNum = face * n;
+    long[][] dp = new long[2][pointNum + 1];
+
+    for (int i = 1; i <= face; i++)
+        dp[0][i] = 1;
+
+    int flag = 1;                                     /* 旋转标记 */
+    for (int i = 2; i <= n; i++, flag = 1 - flag) {
+        for (int j = 0; j <= pointNum; j++)
+            dp[flag][j] = 0;                          /* 旋转数组清零 */
+
+        for (int j = i; j <= pointNum; j++)
+            for (int k = 1; k <= face && k <= j; k++)
+                dp[flag][j] += dp[1 - flag][j - k];
+    }
+
+    final double totalNum = Math.pow(6, n);
+    List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
+    for (int i = n; i <= pointNum; i++)
+        ret.add(new AbstractMap.SimpleEntry<>(i, dp[1 - flag][i] / totalNum));
+
+    return ret;
+}
+```

docs/notes/61. 扑克牌顺子.md

@@ -0,0 +1,37 @@
+# 61. 扑克牌顺子
+
+[NowCoder](https://www.nowcoder.com/practice/762836f4d43d43ca9deb273b3de8e1f4?tpId=13&tqId=11198&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+五张牌，其中大小鬼为癞子，牌面为 0。判断这五张牌是否能组成顺子。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/eaa506b6-0747-4bee-81f8-3cda795d8154.png" width="350px">
+
+
+## 解题思路
+
+```java
+public boolean isContinuous(int[] nums) {
+
+    if (nums.length < 5)
+        return false;
+
+    Arrays.sort(nums);
+
+    // 统计癞子数量
+    int cnt = 0;
+    for (int num : nums)
+        if (num == 0)
+            cnt++;
+
+    // 使用癞子去补全不连续的顺子
+    for (int i = cnt; i < nums.length - 1; i++) {
+        if (nums[i + 1] == nums[i])
+            return false;
+        cnt -= nums[i + 1] - nums[i] - 1;
+    }
+
+    return cnt >= 0;
+}
+```

docs/notes/62. 圆圈中最后剩下的数.md

@@ -0,0 +1,21 @@
+# 62. 圆圈中最后剩下的数
+
+[NowCoder](https://www.nowcoder.com/practice/f78a359491e64a50bce2d89cff857eb6?tpId=13&tqId=11199&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+让小朋友们围成一个大圈。然后，随机指定一个数 m，让编号为 0 的小朋友开始报数。每次喊到 m-1 的那个小朋友要出列唱首歌，然后可以在礼品箱中任意的挑选礼物，并且不再回到圈中，从他的下一个小朋友开始，继续 0...m-1 报数 .... 这样下去 .... 直到剩下最后一个小朋友，可以不用表演。
+
+## 解题思路
+
+约瑟夫环，圆圈长度为 n 的解可以看成长度为 n-1 的解再加上报数的长度 m。因为是圆圈，所以最后需要对 n 取余。
+
+```java
+public int LastRemaining_Solution(int n, int m) {
+    if (n == 0)     /* 特殊输入的处理 */
+        return -1;
+    if (n == 1)     /* 递归返回条件 */
+        return 0;
+    return (LastRemaining_Solution(n - 1, m) + m) % n;
+}
+```

docs/notes/63. 股票的最大利润.md

@@ -0,0 +1,27 @@
+# 63. 股票的最大利润
+
+[Leetcode](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
+
+## 题目描述
+
+可以有一次买入和一次卖出，买入必须在前。求最大收益。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/42661013-750f-420b-b3c1-437e9a11fb65.png" width="220px">
+
+## 解题思路
+
+使用贪心策略，假设第 i 轮进行卖出操作，买入操作价格应该在 i 之前并且价格最低。
+
+```java
+public int maxProfit(int[] prices) {
+    if (prices == null || prices.length == 0)
+        return 0;
+    int soFarMin = prices[0];
+    int maxProfit = 0;
+    for (int i = 1; i < prices.length; i++) {
+        soFarMin = Math.min(soFarMin, prices[i]);
+        maxProfit = Math.max(maxProfit, prices[i] - soFarMin);
+    }
+    return maxProfit;
+}
+```

docs/notes/64. 求 1+2+3+...+n.md

@@ -0,0 +1,23 @@
+# 64. 求 1+2+3+...+n
+
+[NowCoder](https://www.nowcoder.com/practice/7a0da8fc483247ff8800059e12d7caf1?tpId=13&tqId=11200&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句 A ? B : C。
+
+## 解题思路
+
+使用递归解法最重要的是指定返回条件，但是本题无法直接使用 if 语句来指定返回条件。
+
+条件与 && 具有短路原则，即在第一个条件语句为 false 的情况下不会去执行第二个条件语句。利用这一特性，将递归的返回条件取非然后作为 && 的第一个条件语句，递归的主体转换为第二个条件语句，那么当递归的返回条件为 true 的情况下就不会执行递归的主体部分，递归返回。
+
+本题的递归返回条件为 n <= 0，取非后就是 n > 0；递归的主体部分为 sum += Sum_Solution(n - 1)，转换为条件语句后就是 (sum += Sum_Solution(n - 1)) > 0。
+
+```java
+public int Sum_Solution(int n) {
+    int sum = n;
+    boolean b = (n > 0) && ((sum += Sum_Solution(n - 1)) > 0);
+    return sum;
+}
+```

docs/notes/65. 不用加减乘除做加法.md

@@ -0,0 +1,19 @@
+# 65. 不用加减乘除做加法
+
+[NowCoder](https://www.nowcoder.com/practice/59ac416b4b944300b617d4f7f111b215?tpId=13&tqId=11201&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+写一个函数，求两个整数之和，要求不得使用 +、-、\*、/ 四则运算符号。
+
+## 解题思路
+
+a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。
+
+递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
+
+```java
+public int Add(int a, int b) {
+    return b == 0 ? a : Add(a ^ b, (a & b) << 1);
+}
+```

docs/notes/66. 构建乘积数组.md

@@ -0,0 +1,24 @@
+# 66. 构建乘积数组
+
+[NowCoder](https://www.nowcoder.com/practice/94a4d381a68b47b7a8bed86f2975db46?tpId=13&tqId=11204&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+给定一个数组 A[0, 1,..., n-1]，请构建一个数组 B[0, 1,..., n-1]，其中 B 中的元素 B[i]=A[0]\*A[1]\*...\*A[i-1]\*A[i+1]\*...\*A[n-1]。要求不能使用除法。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/4240a69f-4d51-4d16-b797-2dfe110f30bd.png" width="250px">
+
+
+## 解题思路
+
+```java
+public int[] multiply(int[] A) {
+    int n = A.length;
+    int[] B = new int[n];
+    for (int i = 0, product = 1; i < n; product *= A[i], i++)       /* 从左往右累乘 */
+        B[i] = product;
+    for (int i = n - 1, product = 1; i >= 0; product *= A[i], i--)  /* 从右往左累乘 */
+        B[i] *= product;
+    return B;
+}
+```

docs/notes/67. 把字符串转换成整数.md

@@ -0,0 +1,37 @@
+# 67. 把字符串转换成整数
+
+[NowCoder](https://www.nowcoder.com/practice/1277c681251b4372bdef344468e4f26e?tpId=13&tqId=11202&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+将一个字符串转换成一个整数，字符串不是一个合法的数值则返回 0，要求不能使用字符串转换整数的库函数。
+
+```html
+Iuput:
++2147483647
+1a33
+
+Output:
+2147483647
+0
+```
+
+## 解题思路
+
+```java
+public int StrToInt(String str) {
+    if (str == null || str.length() == 0)
+        return 0;
+    boolean isNegative = str.charAt(0) == '-';
+    int ret = 0;
+    for (int i = 0; i < str.length(); i++) {
+        char c = str.charAt(i);
+        if (i == 0 && (c == '+' || c == '-'))  /* 符号判定 */
+            continue;
+        if (c < '0' || c > '9')                /* 非法输入 */
+            return 0;
+        ret = ret * 10 + (c - '0');
+    }
+    return isNegative ? -ret : ret;
+}
+```

docs/notes/68. 树中两个节点的最低公共祖先.md

@@ -0,0 +1,41 @@
+# 68. 树中两个节点的最低公共祖先
+
+## 解题思路
+
+### 二叉查找树
+
+[Leetcode : 235. Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
+
+二叉查找树中，两个节点 p, q 的公共祖先 root 满足 root.val >= p.val && root.val <= q.val。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/047faac4-a368-4565-8331-2b66253080d3.jpg" width="220"/>
+
+```java
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+    if (root == null)
+        return root;
+    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;
+}
+```
+
+### 普通二叉树
+
+[Leetcode : 236. Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
+
+在左右子树中查找是否存在 p 或者 q，如果 p 和 q 分别在两个子树中，那么就说明根节点就是最低公共祖先。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/d27c99f0-7881-4f2d-9675-c75cbdee3acd.jpg" width="250"/>
+
+```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;
+}
+```

docs/notes/7. 重建二叉树.md

@@ -0,0 +1,38 @@
+# 7. 重建二叉树
+
+[NowCoder](https://www.nowcoder.com/practice/8a19cbe657394eeaac2f6ea9b0f6fcf6?tpId=13&tqId=11157&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+根据二叉树的前序遍历和中序遍历的结果，重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
+
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/31d9adce-2af8-4754-8386-0aabb4e500b0.png" width="300"/>
+
+## 解题思路
+
+前序遍历的第一个值为根节点的值，使用这个值将中序遍历结果分成两部分，左部分为树的左子树中序遍历结果，右部分为树的右子树中序遍历的结果。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/c269e362-1128-4212-9cf3-d4c12b363b2f.gif" width="330px">
+
+```java
+// 缓存中序遍历数组每个值对应的索引
+private Map<Integer, Integer> indexForInOrders = new HashMap<>();
+
+public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
+    for (int i = 0; i < in.length; i++)
+        indexForInOrders.put(in[i], i);
+    return reConstructBinaryTree(pre, 0, pre.length - 1, 0);
+}
+
+private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int inL) {
+    if (preL > preR)
+        return null;
+    TreeNode root = new TreeNode(pre[preL]);
+    int inIndex = indexForInOrders.get(root.val);
+    int leftTreeSize = inIndex - inL;
+    root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, inL);
+    root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, inL + leftTreeSize + 1);
+    return root;
+}
+```

docs/notes/8. 二叉树的下一个结点.md

@@ -0,0 +1,50 @@
+# 8. 二叉树的下一个结点
+
+[NowCoder](https://www.nowcoder.com/practice/9023a0c988684a53960365b889ceaf5e?tpId=13&tqId=11210&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
+
+```java
+public class TreeLinkNode {
+
+    int val;
+    TreeLinkNode left = null;
+    TreeLinkNode right = null;
+    TreeLinkNode next = null;
+
+    TreeLinkNode(int val) {
+        this.val = val;
+    }
+}
+```
+
+## 解题思路
+
+① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/b0611f89-1e5f-4494-a795-3544bf65042a.gif" width="220px"/>
+
+② 否则，向上找第一个左链接指向的树包含该节点的祖先节点。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/95080fae-de40-463d-a76e-783a0c677fec.gif" width="200px"/>
+
+```java
+public TreeLinkNode GetNext(TreeLinkNode pNode) {
+    if (pNode.right != null) {
+        TreeLinkNode node = pNode.right;
+        while (node.left != null)
+            node = node.left;
+        return node;
+    } else {
+        while (pNode.next != null) {
+            TreeLinkNode parent = pNode.next;
+            if (parent.left == pNode)
+                return parent;
+            pNode = pNode.next;
+        }
+    }
+    return null;
+}
+```

docs/notes/9. 用两个栈实现队列.md

@@ -0,0 +1,33 @@
+# 9. 用两个栈实现队列
+
+[NowCoder](https://www.nowcoder.com/practice/54275ddae22f475981afa2244dd448c6?tpId=13&tqId=11158&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking&from=cyc_github)
+
+## 题目描述
+
+用两个栈来实现一个队列，完成队列的 Push 和 Pop 操作。
+
+## 解题思路
+
+in 栈用来处理入栈（push）操作，out 栈用来处理出栈（pop）操作。一个元素进入 in 栈之后，出栈的顺序被反转。当元素要出栈时，需要先进入 out 栈，此时元素出栈顺序再一次被反转，因此出栈顺序就和最开始入栈顺序是相同的，先进入的元素先退出，这就是队列的顺序。
+
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/3ea280b5-be7d-471b-ac76-ff020384357c.gif" width="350"/>
+
+```java
+Stack<Integer> in = new Stack<Integer>();
+Stack<Integer> out = new Stack<Integer>();
+
+public void push(int node) {
+    in.push(node);
+}
+
+public int pop() throws Exception {
+    if (out.isEmpty())
+        while (!in.isEmpty())
+            out.push(in.pop());
+
+    if (out.isEmpty())
+        throw new Exception("queue is empty");
+
+    return out.pop();
+}
+```

docs/notes/Docker.md

@@ -1,12 +1,4 @@
-<!-- GFM-TOC -->
-* [一、解决的问题](#一解决的问题)
-* [二、与虚拟机的比较](#二与虚拟机的比较)
-* [三、优势](#三优势)
-* [四、使用场景](#四使用场景)
-* [五、镜像与容器](#五镜像与容器)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 一、解决的问题
 
@@ -14,13 +6,13 @@
 
 Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程进行隔离，被隔离的进程独立于宿主操作系统和其它隔离的进程。使用 Docker 可以不修改应用程序代码，不需要开发人员学习特定环境下的技术，就能够将现有的应用程序部署在其它机器上。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/011f3ef6-d824-4d43-8b2c-36dab8eaaa72-1.png" width="400px"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/011f3ef6-d824-4d43-8b2c-36dab8eaaa72-1.png" width="400px"/>
 
 # 二、与虚拟机的比较
 
 虚拟机也是一种虚拟化技术，它与 Docker 最大的区别在于它是通过模拟硬件，并在硬件上安装操作系统来实现。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/be608a77-7b7f-4f8e-87cc-f2237270bf69.png" width="500"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/be608a77-7b7f-4f8e-87cc-f2237270bf69.png" width="500"/>
 
 ## 启动速度
 
@@ -74,7 +66,7 @@ Docker 轻量级的特点使得它很适合用于部署、维护、组合微服
 
 构建容器时，通过在镜像的基础上添加一个可写层（writable layer），用来保存着容器运行过程中的修改。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/docker-filesystems-busyboxrw.png"/> </div><br>
+![](pics/docker-filesystems-busyboxrw.png)
 
 # 参考资料
 
@@ -87,10 +79,3 @@ Docker 轻量级的特点使得它很适合用于部署、维护、组合微服
 - [What is Docker](https://www.docker.com/what-docker)
 - [持续集成是什么？](http://www.ruanyifeng.com/blog/2015/09/continuous-integration.html)
 
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Git.md

@@ -1,24 +1,10 @@
-<!-- GFM-TOC -->
-* [集中式与分布式](#集中式与分布式)
-* [中心服务器](#中心服务器)
-* [工作流](#工作流)
-* [分支实现](#分支实现)
-* [冲突](#冲突)
-* [Fast forward](#fast-forward)
-* [分支管理策略](#分支管理策略)
-* [储藏（Stashing）](#储藏stashing)
-* [SSH 传输设置](#ssh-传输设置)
-* [.gitignore 文件](#gitignore-文件)
-* [Git 命令一览](#git-命令一览)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 集中式与分布式
 
 Git 属于分布式版本控制系统，而 SVN 属于集中式。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/1fe2dc77-9a2d-4643-90b3-bbf50f649bac.png" width="600px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/1fe2dc77-9a2d-4643-90b3-bbf50f649bac.png" width="600px">
 
 集中式版本控制只有中心服务器拥有一份代码，而分布式版本控制每个人的电脑上就有一份完整的代码。
 
@@ -40,45 +26,45 @@ Github 就是一个中心服务器。
 
 Git 的版本库有一个称为 Stage 的暂存区以及最后的 History 版本库，History 存储所有分支信息，使用一个 HEAD 指针指向当前分支。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/71b97a50-a49f-4f1a-81d1-48c3364d61b3.png" width="700px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/71b97a50-a49f-4f1a-81d1-48c3364d61b3.png" width="700px">
 
 - git add files 把文件的修改添加到暂存区
 - git commit 把暂存区的修改提交到当前分支，提交之后暂存区就被清空了
 - git reset -- files 使用当前分支上的修改覆盖暂存区，用来撤销最后一次 git add files
 - git checkout -- files 使用暂存区的修改覆盖工作目录，用来撤销本地修改
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/72ee7e9a-194d-42e9-b4d7-29c23417ca18.png" width="320px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/72ee7e9a-194d-42e9-b4d7-29c23417ca18.png" width="320px">
 
 可以跳过暂存区域直接从分支中取出修改，或者直接提交修改到分支中。
 
 - git commit -a 直接把所有文件的修改添加到暂存区然后执行提交
 - git checkout HEAD -- files 取出最后一次修改，可以用来进行回滚操作
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/a4a0a6e6-386b-4bfa-b899-ec33d3310f3e.png" width="500px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/a4a0a6e6-386b-4bfa-b899-ec33d3310f3e.png" width="500px">
 
 # 分支实现
 
 使用指针将每个提交连接成一条时间线，HEAD 指针指向当前分支指针。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ec4d7464-7140-46d8-827e-d63634202e1e.png" width="220px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ec4d7464-7140-46d8-827e-d63634202e1e.png" width="220px">
 
 新建分支是新建一个指针指向时间线的最后一个节点，并让 HEAD 指针指向新分支，表示新分支成为当前分支。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/66d00642-ce37-466c-8f7a-143d0bf84cd6.png" width="220px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/66d00642-ce37-466c-8f7a-143d0bf84cd6.png" width="220px">
 
 每次提交只会让当前分支指针向前移动，而其它分支指针不会移动。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/72a01242-e6b4-46c5-a285-24e754d63093.png" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/72a01242-e6b4-46c5-a285-24e754d63093.png" width="300px">
 
 合并分支也只需要改变指针即可。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/94617147-0cbd-4a28-847d-81e52efb1b1e.png" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/94617147-0cbd-4a28-847d-81e52efb1b1e.png" width="300px">
 
 # 冲突
 
 当两个分支都对同一个文件的同一行进行了修改，在分支合并时就会产生冲突。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/32b05e81-41b3-414a-8656-736c9604e3d6.png" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/32b05e81-41b3-414a-8656-736c9604e3d6.png" width="300px">
 
 Git 会使用 <<<<<<< ，======= ，>>>>>>> 标记出不同分支的内容，只需要把不同分支中冲突部分修改成一样就能解决冲突。
 
@@ -100,7 +86,7 @@ Creating a new branch is quick AND simple.
 $ git merge --no-ff -m "merge with no-ff" dev
 ```
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9a519773-84b2-4c81-81cf-4e7dd739a97a.png" width="350px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9a519773-84b2-4c81-81cf-4e7dd739a97a.png" width="350px">
 
 # 分支管理策略
 
@@ -108,7 +94,7 @@ master 分支应该是非常稳定的，只用来发布新版本；
 
 日常开发在开发分支 dev 上进行。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/245fd2fb-209c-4ad5-bc5e-eb5664966a0e.jpg" width=""> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/245fd2fb-209c-4ad5-bc5e-eb5664966a0e.jpg" width="">
 
 # 储藏（Stashing）
 
@@ -148,7 +134,7 @@ $ ssh-keygen -t rsa -C "youremail@example.com"
 
 # Git 命令一览
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/7a29acce-f243-4914-9f00-f2988c528412.jpg" width=""> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/7a29acce-f243-4914-9f00-f2988c528412.jpg" width="">
 
 比较详细的地址：http://www.cheat-sheets.org/saved-copy/git-cheat-sheet.pdf
 
@@ -158,10 +144,3 @@ $ ssh-keygen -t rsa -C "youremail@example.com"
 - [图解 Git](http://marklodato.github.io/visual-git-guide/index-zh-cn.html)
 - [廖雪峰 : Git 教程](https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000)
 - [Learn Git Branching](https://learngitbranching.js.org/)
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/HTTP.md

@@ -1,60 +1,4 @@
-<!-- GFM-TOC -->
-* [一 、基础概念](#一-基础概念)
-    * [URI](#uri)
-    * [请求和响应报文](#请求和响应报文)
-* [二、HTTP 方法](#二http-方法)
-    * [GET](#get)
-    * [HEAD](#head)
-    * [POST](#post)
-    * [PUT](#put)
-    * [PATCH](#patch)
-    * [DELETE](#delete)
-    * [OPTIONS](#options)
-    * [CONNECT](#connect)
-    * [TRACE](#trace)
-* [三、HTTP 状态码](#三http-状态码)
-    * [1XX 信息](#1xx-信息)
-    * [2XX 成功](#2xx-成功)
-    * [3XX 重定向](#3xx-重定向)
-    * [4XX 客户端错误](#4xx-客户端错误)
-    * [5XX 服务器错误](#5xx-服务器错误)
-* [四、HTTP 首部](#四http-首部)
-    * [通用首部字段](#通用首部字段)
-    * [请求首部字段](#请求首部字段)
-    * [响应首部字段](#响应首部字段)
-    * [实体首部字段](#实体首部字段)
-* [五、具体应用](#五具体应用)
-    * [连接管理](#连接管理)
-    * [Cookie](#cookie)
-    * [缓存](#缓存)
-    * [内容协商](#内容协商)
-    * [内容编码](#内容编码)
-    * [范围请求](#范围请求)
-    * [分块传输编码](#分块传输编码)
-    * [多部分对象集合](#多部分对象集合)
-    * [虚拟主机](#虚拟主机)
-    * [通信数据转发](#通信数据转发)
-* [六、HTTPS](#六https)
-    * [加密](#加密)
-    * [认证](#认证)
-    * [完整性保护](#完整性保护)
-    * [HTTPS 的缺点](#https-的缺点)
-* [七、HTTP/2.0](#七http20)
-    * [HTTP/1.x 缺陷](#http1x-缺陷)
-    * [二进制分帧层](#二进制分帧层)
-    * [服务端推送](#服务端推送)
-    * [首部压缩](#首部压缩)
-* [八、HTTP/1.1 新特性](#八http11-新特性)
-* [九、GET 和 POST 比较](#九get-和-post-比较)
-    * [作用](#作用)
-    * [参数](#参数)
-    * [安全](#安全)
-    * [幂等性](#幂等性)
-    * [可缓存](#可缓存)
-    * [XMLHttpRequest](#xmlhttprequest)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 一 、基础概念
 
@@ -62,17 +6,17 @@
 
 URI 包含 URL 和 URN。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/8441b2c4-dca7-4d6b-8efb-f22efccaf331.png" width="500px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/8441b2c4-dca7-4d6b-8efb-f22efccaf331.png" width="500px">
 
 ## 请求和响应报文
 
 ### 1. 请求报文
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/HTTP_RequestMessageExample.png" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/HTTP_RequestMessageExample.png" width=""/>
 
 ### 2. 响应报文
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/HTTP_ResponseMessageExample.png" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/HTTP_ResponseMessageExample.png" width=""/>
 
 # 二、HTTP 方法
 
@@ -159,7 +103,7 @@ DELETE /file.html HTTP/1.1
 CONNECT www.example.com:443 HTTP/1.1
 ```
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/dc00f70e-c5c8-4d20-baf1-2d70014a97e3.jpg" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/dc00f70e-c5c8-4d20-baf1-2d70014a97e3.jpg" width=""/>
 
 ## TRACE
 
@@ -302,7 +246,7 @@ CONNECT www.example.com:443 HTTP/1.1
 
 ## 连接管理
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/HTTP1_x_Connections.png" width="800"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/HTTP1_x_Connections.png" width="800"/>
 
 ### 1. 短连接与长连接
 
@@ -631,11 +575,11 @@ HTTP/1.1 使用虚拟主机技术，使得一台服务器拥有多个域名，
 
 - 用户察觉得到正向代理的存在。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/a314bb79-5b18-4e63-a976-3448bffa6f1b.png" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/a314bb79-5b18-4e63-a976-3448bffa6f1b.png" width=""/>
 
 - 而反向代理一般位于内部网络中，用户察觉不到。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/2d09a847-b854-439c-9198-b29c65810944.png" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/2d09a847-b854-439c-9198-b29c65810944.png" width=""/>
 
 ### 2. 网关
 
@@ -657,7 +601,7 @@ HTTPS 并不是新协议，而是让 HTTP 先和 SSL（Secure Sockets Layer）
 
 通过使用 SSL，HTTPS 具有了加密（防窃听）、认证（防伪装）和完整性保护（防篡改）。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ssl-offloading.jpg" width="700"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ssl-offloading.jpg" width="700"/>
 
 ## 加密
 
@@ -668,7 +612,7 @@ HTTPS 并不是新协议，而是让 HTTP 先和 SSL（Secure Sockets Layer）
 - 优点：运算速度快；
 - 缺点：无法安全地将密钥传输给通信方。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/7fffa4b8-b36d-471f-ad0c-a88ee763bb76.png" width="600"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/7fffa4b8-b36d-471f-ad0c-a88ee763bb76.png" width="600"/>
 
 ### 2.非对称密钥加密
 
@@ -681,13 +625,13 @@ HTTPS 并不是新协议，而是让 HTTP 先和 SSL（Secure Sockets Layer）
 - 优点：可以更安全地将公开密钥传输给通信发送方；
 - 缺点：运算速度慢。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/39ccb299-ee99-4dd1-b8b4-2f9ec9495cb4.png" width="600"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/39ccb299-ee99-4dd1-b8b4-2f9ec9495cb4.png" width="600"/>
 
 ### 3. HTTPS 采用的加密方式
 
 HTTPS 采用混合的加密机制，使用非对称密钥加密用于传输对称密钥来保证传输过程的安全性，之后使用对称密钥加密进行通信来保证通信过程的效率。（下图中的 Session Key 就是对称密钥）
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/How-HTTPS-Works.png" width="600"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/How-HTTPS-Works.png" width="600"/>
 
 ## 认证
 
@@ -699,7 +643,7 @@ HTTPS 采用混合的加密机制，使用非对称密钥加密用于传输对
 
 进行 HTTPS 通信时，服务器会把证书发送给客户端。客户端取得其中的公开密钥之后，先使用数字签名进行验证，如果验证通过，就可以开始通信了。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/2017-06-11-ca.png" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/2017-06-11-ca.png" width=""/>
 
 ## 完整性保护
 
@@ -728,7 +672,7 @@ HTTP/1.x 实现简单是以牺牲性能为代价的：
 
 HTTP/2.0 将报文分成 HEADERS 帧和 DATA 帧，它们都是二进制格式的。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/86e6a91d-a285-447a-9345-c5484b8d0c47.png" width="400"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/86e6a91d-a285-447a-9345-c5484b8d0c47.png" width="400"/>
 
 在通信过程中，只会有一个 TCP 连接存在，它承载了任意数量的双向数据流（Stream）。
 
@@ -736,13 +680,13 @@ HTTP/2.0 将报文分成 HEADERS 帧和 DATA 帧，它们都是二进制格式
 - 消息（Message）是与逻辑请求或响应对应的完整的一系列帧。
 - 帧（Frame）是最小的通信单位，来自不同数据流的帧可以交错发送，然后再根据每个帧头的数据流标识符重新组装。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/af198da1-2480-4043-b07f-a3b91a88b815.png" width="600"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/af198da1-2480-4043-b07f-a3b91a88b815.png" width="600"/>
 
 ## 服务端推送
 
 HTTP/2.0 在客户端请求一个资源时，会把相关的资源一起发送给客户端，客户端就不需要再次发起请求了。例如客户端请求 page.html 页面，服务端就把 script.js 和 style.css 等与之相关的资源一起发给客户端。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/e3f1657c-80fc-4dfa-9643-bf51abd201c6.png" width="800"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/e3f1657c-80fc-4dfa-9643-bf51abd201c6.png" width="800"/>
 
 ## 首部压缩
 
@@ -752,7 +696,7 @@ HTTP/2.0 要求客户端和服务器同时维护和更新一个包含之前见
 
 不仅如此，HTTP/2.0 也使用 Huffman 编码对首部字段进行压缩。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/_u4E0B_u8F7D.png" width="600"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/_u4E0B_u8F7D.png" width="600"/>
 
 # 八、HTTP/1.1 新特性
 
@@ -877,10 +821,3 @@ DELETE /idX/delete HTTP/1.1   -> Returns 404
 - [Symmetric vs. Asymmetric Encryption – What are differences?](https://www.ssl2buy.com/wiki/symmetric-vs-asymmetric-encryption-what-are-differences)
 - [Web 性能优化与 HTTP/2](https://www.kancloud.cn/digest/web-performance-http2)
 - [HTTP/2 简介](https://developers.google.com/web/fundamentals/performance/http2/?hl=zh-cn)
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Java IO.md

@@ -1,35 +1,4 @@
-<!-- GFM-TOC -->
-* [一、概览](#一概览)
-* [二、磁盘操作](#二磁盘操作)
-* [三、字节操作](#三字节操作)
-    * [实现文件复制](#实现文件复制)
-    * [装饰者模式](#装饰者模式)
-* [四、字符操作](#四字符操作)
-    * [编码与解码](#编码与解码)
-    * [String 的编码方式](#string-的编码方式)
-    * [Reader 与 Writer](#reader-与-writer)
-    * [实现逐行输出文本文件的内容](#实现逐行输出文本文件的内容)
-* [五、对象操作](#五对象操作)
-    * [序列化](#序列化)
-    * [Serializable](#serializable)
-    * [transient](#transient)
-* [六、网络操作](#六网络操作)
-    * [InetAddress](#inetaddress)
-    * [URL](#url)
-    * [Sockets](#sockets)
-    * [Datagram](#datagram)
-* [七、NIO](#七nio)
-    * [流与块](#流与块)
-    * [通道与缓冲区](#通道与缓冲区)
-    * [缓冲区状态变量](#缓冲区状态变量)
-    * [文件 NIO 实例](#文件-nio-实例)
-    * [选择器](#选择器)
-    * [套接字 NIO 实例](#套接字-nio-实例)
-    * [内存映射文件](#内存映射文件)
-    * [对比](#对比)
-* [八、参考资料](#八参考资料)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 一、概览
 
@@ -97,7 +66,7 @@ Java I/O 使用了装饰者模式来实现。以 InputStream 为例，
 - FileInputStream 是 InputStream 的子类，属于具体组件，提供了字节流的输入操作；
 - FilterInputStream 属于抽象装饰者，装饰者用于装饰组件，为组件提供额外的功能。例如 BufferedInputStream 为 FileInputStream 提供缓存的功能。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9709694b-db05-4cce-8d2f-1c8b09f4d921.png" width="650px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9709694b-db05-4cce-8d2f-1c8b09f4d921.png" width="650px">
 
 实例化一个具有缓存功能的字节流对象时，只需要在 FileInputStream 对象上再套一层 BufferedInputStream 对象即可。
 
@@ -277,7 +246,7 @@ public static void main(String[] args) throws IOException {
 - Socket：客户端类
 - 服务器和客户端通过 InputStream 和 OutputStream 进行输入输出。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/1e6affc4-18e5-4596-96ef-fb84c63bf88a.png" width="550px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/1e6affc4-18e5-4596-96ef-fb84c63bf88a.png" width="550px">
 
 ## Datagram
 
@@ -339,23 +308,23 @@ I/O 包和 NIO 已经很好地集成了，java.io.\* 已经以 NIO 为基础重
 
 ① 新建一个大小为 8 个字节的缓冲区，此时 position 为 0，而 limit = capacity = 8。capacity 变量不会改变，下面的讨论会忽略它。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/1bea398f-17a7-4f67-a90b-9e2d243eaa9a.png"/> </div><br>
+![](pics/1bea398f-17a7-4f67-a90b-9e2d243eaa9a.png)
 
 ② 从输入通道中读取 5 个字节数据写入缓冲区中，此时 position 为 5，limit 保持不变。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/80804f52-8815-4096-b506-48eef3eed5c6.png"/> </div><br>
+![](pics/80804f52-8815-4096-b506-48eef3eed5c6.png)
 
 ③ 在将缓冲区的数据写到输出通道之前，需要先调用 flip() 方法，这个方法将 limit 设置为当前 position，并将 position 设置为 0。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/952e06bd-5a65-4cab-82e4-dd1536462f38.png"/> </div><br>
+![](pics/952e06bd-5a65-4cab-82e4-dd1536462f38.png)
 
 ④ 从缓冲区中取 4 个字节到输出缓冲中，此时 position 设为 4。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/b5bdcbe2-b958-4aef-9151-6ad963cb28b4.png"/> </div><br>
+![](pics/b5bdcbe2-b958-4aef-9151-6ad963cb28b4.png)
 
 ⑤ 最后需要调用 clear() 方法来清空缓冲区，此时 position 和 limit 都被设置为最初位置。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/67bf5487-c45d-49b6-b9c0-a058d8c68902.png"/> </div><br>
+![](pics/67bf5487-c45d-49b6-b9c0-a058d8c68902.png)
 
 ## 文件 NIO 实例
 
@@ -413,7 +382,7 @@ NIO 实现了 IO 多路复用中的 Reactor 模型，一个线程 Thread 使用
 
 应该注意的是，只有套接字 Channel 才能配置为非阻塞，而 FileChannel 不能，为 FileChannel 配置非阻塞也没有意义。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/093f9e57-429c-413a-83ee-c689ba596cef.png" width="350px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/093f9e57-429c-413a-83ee-c689ba596cef.png" width="350px">
 
 ### 1. 创建选择器
 
@@ -618,10 +587,3 @@ NIO 与普通 I/O 的区别主要有以下两点：
 - [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)
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Java 基础.md

@@ -1,44 +1,4 @@
-<!-- GFM-TOC -->
-* [一、数据类型](#一数据类型)
-    * [基本类型](#基本类型)
-    * [包装类型](#包装类型)
-    * [缓存池](#缓存池)
-* [二、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)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 一、数据类型
 
@@ -193,7 +153,7 @@ value 数组被声明为 final，这意味着 value 数组初始化之后就不
 
 如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9112288f-23f5-4e53-b222-a46fdbca1603.png" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9112288f-23f5-4e53-b222-a46fdbca1603.png" width="300px">
 
 **3. 安全性** 
 
@@ -1356,7 +1316,7 @@ Throwable 可以用来表示任何可以作为异常抛出的类，分为两种
 -  **受检异常** ：需要用 try...catch... 语句捕获并进行处理，并且可以从异常中恢复；
 -  **非受检异常** ：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序崩溃并且无法恢复。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/PPjwP.png" width="600"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/PPjwP.png" width="600"/>
 
 - [Java 入门之异常处理](https://www.tianmaying.com/tutorial/Java-Exception)
 - [Java 异常的面试问题及答案 -Part 1](http://www.importnew.com/7383.html)
@@ -1432,10 +1392,3 @@ Java 注解是附加在代码中的一些元信息，用于一些工具在编译
 
 - Eckel B. Java 编程思想[M]. 机械工业出版社, 2002.
 - Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Java 容器.md

@@ -1,22 +1,4 @@
-<!-- GFM-TOC -->
-* [一、概览](#一概览)
-    * [Collection](#collection)
-    * [Map](#map)
-* [二、容器中的设计模式](#二容器中的设计模式)
-    * [迭代器模式](#迭代器模式)
-    * [适配器模式](#适配器模式)
-* [三、源码分析](#三源码分析)
-    * [ArrayList](#arraylist)
-    * [Vector](#vector)
-    * [CopyOnWriteArrayList](#copyonwritearraylist)
-    * [LinkedList](#linkedlist)
-    * [HashMap](#hashmap)
-    * [ConcurrentHashMap](#concurrenthashmap)
-    * [LinkedHashMap](#linkedhashmap)
-    * [WeakHashMap](#weakhashmap)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 一、概览
 
@@ -24,7 +6,7 @@
 
 ## Collection
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/73403d84-d921-49f1-93a9-d8fe050f3497.png" width="800px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/73403d84-d921-49f1-93a9-d8fe050f3497.png" width="800px">
 
 ### 1. Set
 
@@ -50,7 +32,7 @@
 
 ## Map
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/774d756b-902a-41a3-a3fd-81ca3ef688dc.png" width="500px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/774d756b-902a-41a3-a3fd-81ca3ef688dc.png" width="500px">
 
 - TreeMap：基于红黑树实现。
 
@@ -65,7 +47,7 @@
 
 ## 迭代器模式
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/93fb1d38-83f9-464a-a733-67b2e6bfddda.png" width="600px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/93fb1d38-83f9-464a-a733-67b2e6bfddda.png" width="600px">
 
 Collection 继承了 Iterable 接口，其中的 iterator() 方法能够产生一个 Iterator 对象，通过这个对象就可以迭代遍历 Collection 中的元素。
 
@@ -126,7 +108,7 @@ public class ArrayList<E> extends AbstractList<E>
 private static final int DEFAULT_CAPACITY = 10;
 ```
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/52a7744f-5bce-4ff3-a6f0-8449334d9f3d.png" width="400px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/52a7744f-5bce-4ff3-a6f0-8449334d9f3d.png" width="400px">
 
 ### 2. 扩容
 
@@ -430,7 +412,7 @@ transient Node<E> first;
 transient Node<E> last;
 ```
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/c8563120-cb00-4dd6-9213-9d9b337a7f7c.png" width="500px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/c8563120-cb00-4dd6-9213-9d9b337a7f7c.png" width="500px">
 
 ### 2. 与 ArrayList 的比较
 
@@ -452,7 +434,7 @@ transient Entry[] table;
 
 Entry 存储着键值对。它包含了四个字段，从 next 字段我们可以看出 Entry 是一个链表。即数组中的每个位置被当成一个桶，一个桶存放一个链表。HashMap 使用拉链法来解决冲突，同一个链表中存放哈希值和散列桶取模运算结果相同的 Entry。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9420a703-1f9d-42ce-808e-bcb82b56483d.png" width="550px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9420a703-1f9d-42ce-808e-bcb82b56483d.png" width="550px">
 
 ```java
 static class Entry<K,V> implements Map.Entry<K,V> {
@@ -528,7 +510,7 @@ map.put("K3", "V3");
 - 计算键值对所在的桶；
 - 在链表上顺序查找，时间复杂度显然和链表的长度成正比。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/e0870f80-b79e-4542-ae39-7420d4b0d8fe.png" width="550px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/e0870f80-b79e-4542-ae39-7420d4b0d8fe.png" width="550px">
 
 ### 3. put 操作
 
@@ -864,7 +846,7 @@ final Segment<K,V>[] segments;
 static final int DEFAULT_CONCURRENCY_LEVEL = 16;
 ```
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/db808eff-31d7-4229-a4ad-b8ae71870a3a.png" width="550px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/db808eff-31d7-4229-a4ad-b8ae71870a3a.png" width="550px">
 
 ### 2. size 操作
 
@@ -1150,10 +1132,3 @@ public final class ConcurrentCache<K, V> {
 - [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/)
 
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Java 并发.md

@@ -1,67 +1,8 @@
-<!-- GFM-TOC -->
-* [一、线程状态转换](#一线程状态转换)
-    * [新建（New）](#新建new)
-    * [可运行（Runnable）](#可运行runnable)
-    * [阻塞（Blocked）](#阻塞blocked)
-    * [无限期等待（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-内存模型)
-    * [主内存与工作内存](#主内存与工作内存)
-    * [内存间交互操作](#内存间交互操作)
-    * [内存模型三大特性](#内存模型三大特性)
-    * [先行发生原则](#先行发生原则)
-* [十一、线程安全](#十一线程安全)
-    * [不可变](#不可变)
-    * [互斥同步](#互斥同步)
-    * [非阻塞同步](#非阻塞同步)
-    * [无同步方案](#无同步方案)
-* [十二、锁优化](#十二锁优化)
-    * [自旋锁](#自旋锁)
-    * [锁消除](#锁消除)
-    * [锁粗化](#锁粗化)
-    * [轻量级锁](#轻量级锁)
-    * [偏向锁](#偏向锁)
-* [十三、多线程开发良好的实践](#十三多线程开发良好的实践)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 一、线程状态转换
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/adfb427d-3b21-40d7-a142-757f4ed73079.png" width="600px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/adfb427d-3b21-40d7-a142-757f4ed73079.png" width="600px">
 
 ## 新建（New）
 
@@ -736,7 +677,7 @@ java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.
 
 维护了一个计数器 cnt，每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await() 方法而在等待的线程就会被唤醒。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ba078291-791e-4378-b6d1-ece76c2f0b14.png" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ba078291-791e-4378-b6d1-ece76c2f0b14.png" width="300px">
 
 ```java
 public class CountdownLatchExample {
@@ -785,7 +726,7 @@ public CyclicBarrier(int parties) {
 }
 ```
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/f71af66b-0d54-4399-a44b-f47b58321984.png" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/f71af66b-0d54-4399-a44b-f47b58321984.png" width="300px">
 
 ```java
 public class CyclicBarrierExample {
@@ -1022,7 +963,7 @@ public class ForkJoinPool extends AbstractExecutorService
 
 ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，Thread2 从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/e42f188f-f4a9-4e6f-88fc-45f4682072fb.png" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/e42f188f-f4a9-4e6f-88fc-45f4682072fb.png" width="300px">
 
 # 九、线程不安全示例
 
@@ -1077,19 +1018,19 @@ Java 内存模型试图屏蔽各种硬件和操作系统的内存访问差异，
 
 加入高速缓存带来了一个新的问题：缓存一致性。如果多个缓存共享同一块主内存区域，那么多个缓存的数据可能会不一致，需要一些协议来解决这个问题。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/942ca0d2-9d5c-45a4-89cb-5fd89b61913f.png" width="600px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/942ca0d2-9d5c-45a4-89cb-5fd89b61913f.png" width="600px">
 
 所有的变量都存储在主内存中，每个线程还有自己的工作内存，工作内存存储在高速缓存或者寄存器中，保存了该线程使用的变量的主内存副本拷贝。
 
 线程只能直接操作工作内存中的变量，不同线程之间的变量值传递需要通过主内存来完成。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/15851555-5abc-497d-ad34-efed10f43a6b.png" width="600px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/15851555-5abc-497d-ad34-efed10f43a6b.png" width="600px">
 
 ## 内存间交互操作
 
 Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/8b7ebbad-9604-4375-84e3-f412099d170c.png" width="450px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/8b7ebbad-9604-4375-84e3-f412099d170c.png" width="450px">
 
 - read：把一个变量的值从主内存传输到工作内存中
 - load：在 read 之后执行，把 read 得到的值放入工作内存的变量副本中
@@ -1112,11 +1053,11 @@ Java 内存模型保证了 read、load、use、assign、store、write、lock 和
 
 下图演示了两个线程同时对 cnt 进行操作，load、assign、store 这一系列操作整体上看不具备原子性，那么在 T1 修改 cnt 并且还没有将修改后的值写入主内存，T2 依然可以读入旧值。可以看出，这两个线程虽然执行了两次自增运算，但是主内存中 cnt 的值最后为 1 而不是 2。因此对 int 类型读写操作满足原子性只是说明 load、assign、store 这些单个操作具备原子性。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/2797a609-68db-4d7b-8701-41ac9a34b14f.jpg" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/2797a609-68db-4d7b-8701-41ac9a34b14f.jpg" width="300px">
 
 AtomicInteger 能保证多个线程修改的原子性。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/dd563037-fcaa-4bd8-83b6-b39d93a12c77.jpg" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/dd563037-fcaa-4bd8-83b6-b39d93a12c77.jpg" width="300px">
 
 使用 AtomicInteger 重写之前线程不安全的代码之后得到以下线程安全实现：
 
@@ -1224,7 +1165,7 @@ volatile 关键字通过添加内存屏障的方式来禁止指令重排，即
 
 在一个线程内，在程序前面的操作先行发生于后面的操作。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/874b3ff7-7c5c-4e7a-b8ab-a82a3e038d20.png" width="180px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/874b3ff7-7c5c-4e7a-b8ab-a82a3e038d20.png" width="180px">
 
 ### 2. 管程锁定规则
 
@@ -1232,7 +1173,7 @@ volatile 关键字通过添加内存屏障的方式来禁止指令重排，即
 
 一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/8996a537-7c4a-4ec8-a3b7-7ef1798eae26.png" width="350px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/8996a537-7c4a-4ec8-a3b7-7ef1798eae26.png" width="350px">
 
 ### 3. volatile 变量规则
 
@@ -1240,7 +1181,7 @@ volatile 关键字通过添加内存屏障的方式来禁止指令重排，即
 
 对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/942f33c9-8ad9-4987-836f-007de4c21de0.png" width="400px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/942f33c9-8ad9-4987-836f-007de4c21de0.png" width="400px">
 
 ### 4. 线程启动规则
 
@@ -1248,7 +1189,7 @@ volatile 关键字通过添加内存屏障的方式来禁止指令重排，即
 
 Thread 对象的 start() 方法调用先行发生于此线程的每一个动作。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/6270c216-7ec0-4db7-94de-0003bce37cd2.png" width="380px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/6270c216-7ec0-4db7-94de-0003bce37cd2.png" width="380px">
 
 ### 5. 线程加入规则
 
@@ -1256,7 +1197,7 @@ Thread 对象的 start() 方法调用先行发生于此线程的每一个动作
 
 Thread 对象的结束先行发生于 join() 方法返回。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/233f8d89-31d7-413f-9c02-042f19c46ba1.png" width="400px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/233f8d89-31d7-413f-9c02-042f19c46ba1.png" width="400px">
 
 ### 6. 线程中断规则
 
@@ -1474,7 +1415,7 @@ public class ThreadLocalExample1 {
 
 它所对应的底层结构图为：
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/6782674c-1bfe-4879-af39-e9d722a95d39.png" width="500px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/6782674c-1bfe-4879-af39-e9d722a95d39.png" width="500px">
 
 每个 Thread 都有一个 ThreadLocal.ThreadLocalMap 对象。
 
@@ -1577,17 +1518,17 @@ JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：
 
 以下是 HotSpot 虚拟机对象头的内存布局，这些数据被称为 Mark Word。其中 tag bits 对应了五个状态，这些状态在右侧的 state 表格中给出。除了 marked for gc 状态，其它四个状态已经在前面介绍过了。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png" width="500"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png" width="500"/>
 
 下图左侧是一个线程的虚拟机栈，其中有一部分称为 Lock Record 的区域，这是在轻量级锁运行过程创建的，用于存放锁对象的 Mark Word。而右侧就是一个锁对象，包含了 Mark Word 和其它信息。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/051e436c-0e46-4c59-8f67-52d89d656182.png" width="500"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/051e436c-0e46-4c59-8f67-52d89d656182.png" width="500"/>
 
 轻量级锁是相对于传统的重量级锁而言，它使用 CAS 操作来避免重量级锁使用互斥量的开销。对于绝大部分的锁，在整个同步周期内都是不存在竞争的，因此也就不需要都使用互斥量进行同步，可以先采用 CAS 操作进行同步，如果 CAS 失败了再改用互斥量进行同步。
 
 当尝试获取一个锁对象时，如果锁对象标记为 0 01，说明锁对象的锁未锁定（unlocked）状态。此时虚拟机在当前线程的虚拟机栈中创建 Lock Record，然后使用 CAS 操作将对象的 Mark Word 更新为 Lock Record 指针。如果 CAS 操作成功了，那么线程就获取了该对象上的锁，并且对象的 Mark Word 的锁标记变为 00，表示该对象处于轻量级锁状态。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/baaa681f-7c52-4198-a5ae-303b9386cf47.png" width="400"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/baaa681f-7c52-4198-a5ae-303b9386cf47.png" width="400"/>
 
 如果 CAS 操作失败了，虚拟机首先会检查对象的 Mark Word 是否指向当前线程的虚拟机栈，如果是的话说明当前线程已经拥有了这个锁对象，那就可以直接进入同步块继续执行，否则说明这个锁对象已经被其他线程线程抢占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁。
 
@@ -1599,7 +1540,7 @@ JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：
 
 当有另外一个线程去尝试获取这个锁对象时，偏向状态就宣告结束，此时撤销偏向（Revoke Bias）后恢复到未锁定状态或者轻量级锁状态。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/390c913b-5f31-444f-bbdb-2b88b688e7ce.jpg" width="600"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/390c913b-5f31-444f-bbdb-2b88b688e7ce.jpg" width="600"/>
 
 # 十三、多线程开发良好的实践
 
@@ -1634,10 +1575,3 @@ JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：
 - [JAVA FORK JOIN EXAMPLE](http://www.javacreed.com/java-fork-join-example/ "Java Fork Join Example")
 - [聊聊并发（八）——Fork/Join 框架介绍](http://ifeve.com/talk-concurrency-forkjoin/)
 - [Eliminating SynchronizationRelated Atomic Operations with Biased Locking and Bulk Rebiasing](http://www.oracle.com/technetwork/java/javase/tech/biasedlocking-oopsla2006-preso-150106.pdf)
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Java 虚拟机.md

@@ -1,38 +1,10 @@
-<!-- GFM-TOC -->
-* [一、运行时数据区域](#一运行时数据区域)
-    * [程序计数器](#程序计数器)
-    * [Java 虚拟机栈](#java-虚拟机栈)
-    * [本地方法栈](#本地方法栈)
-    * [堆](#堆)
-    * [方法区](#方法区)
-    * [运行时常量池](#运行时常量池)
-    * [直接内存](#直接内存)
-* [二、垃圾收集](#二垃圾收集)
-    * [判断一个对象是否可被回收](#判断一个对象是否可被回收)
-    * [引用类型](#引用类型)
-    * [垃圾收集算法](#垃圾收集算法)
-    * [垃圾收集器](#垃圾收集器)
-* [三、内存分配与回收策略](#三内存分配与回收策略)
-    * [Minor GC 和 Full GC](#minor-gc-和-full-gc)
-    * [内存分配策略](#内存分配策略)
-    * [Full GC 的触发条件](#full-gc-的触发条件)
-* [四、类加载机制](#四类加载机制)
-    * [类的生命周期](#类的生命周期)
-    * [类加载过程](#类加载过程)
-    * [类初始化时机](#类初始化时机)
-    * [类与类加载器](#类与类加载器)
-    * [类加载器分类](#类加载器分类)
-    * [双亲委派模型](#双亲委派模型)
-    * [自定义类加载器实现](#自定义类加载器实现)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
+[TOC]
 
 本文大部分内容参考  **周志明《深入理解 Java 虚拟机》** ，想要深入学习的话请看原书。
 
 # 一、运行时数据区域
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/5778d113-8e13-4c53-b5bf-801e58080b97.png" width="400px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/5778d113-8e13-4c53-b5bf-801e58080b97.png" width="400px">
 
 ## 程序计数器
 
@@ -42,7 +14,7 @@
 
 每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/8442519f-0b4d-48f4-8229-56f984363c69.png" width="400px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/8442519f-0b4d-48f4-8229-56f984363c69.png" width="400px">
 
 可以通过 -Xss 这个虚拟机参数来指定每个线程的 Java 虚拟机栈内存大小，在 JDK 1.4 中默认为 256K，而在 JDK 1.5+ 默认为 1M：
 
@@ -61,7 +33,7 @@ java -Xss2M HackTheJava
 
 本地方法一般是用其它语言（C、C++ 或汇编语言等）编写的，并且被编译为基于本机硬件和操作系统的程序，对待这些方法需要特别处理。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/66a6899d-c6b0-4a47-8569-9d08f0baf86c.png" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/66a6899d-c6b0-4a47-8569-9d08f0baf86c.png" width="300px">
 
 ## 堆
 
@@ -146,7 +118,7 @@ Java 虚拟机使用该算法来判断对象是否可被回收，GC Roots 一般
 - 方法区中类静态属性引用的对象
 - 方法区中的常量引用的对象
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/83d909d2-3858-4fe1-8ff4-16471db0b180.png" width="350px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/83d909d2-3858-4fe1-8ff4-16471db0b180.png" width="350px">
 
 
 ### 3. 方法区的回收
@@ -227,7 +199,7 @@ obj = null;
 
 ### 1. 标记 - 清除
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/005b481b-502b-4e3f-985d-d043c2b330aa.png" width="400px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/005b481b-502b-4e3f-985d-d043c2b330aa.png" width="400px">
 
 在标记阶段，程序会检查每个对象是否为活动对象，如果是活动对象，则程序会在对象头部打上标记。
 
@@ -242,7 +214,7 @@ obj = null;
 
 ### 2. 标记 - 整理
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ccd773a5-ad38-4022-895c-7ac318f31437.png" width="400px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ccd773a5-ad38-4022-895c-7ac318f31437.png" width="400px">
 
 让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。
 
@@ -256,7 +228,7 @@ obj = null;
 
 ### 3. 复制
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/b2b77b9e-958c-4016-8ae5-9c6edd83871e.png" width="400px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/b2b77b9e-958c-4016-8ae5-9c6edd83871e.png" width="400px">
 
 将内存划分为大小相等的两块，每次只使用其中一块，当这一块内存用完了就将还存活的对象复制到另一块上面，然后再把使用过的内存空间进行一次清理。
 
@@ -277,7 +249,7 @@ HotSpot 虚拟机的 Eden 和 Survivor 大小比例默认为 8:1，保证了内
 
 ## 垃圾收集器
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/c625baa0-dde6-449e-93df-c3a67f2f430f.jpg" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/c625baa0-dde6-449e-93df-c3a67f2f430f.jpg" width=""/>
 
 以上是 HotSpot 虚拟机中的 7 个垃圾收集器，连线表示垃圾收集器可以配合使用。
 
@@ -286,7 +258,7 @@ HotSpot 虚拟机的 Eden 和 Survivor 大小比例默认为 8:1，保证了内
 
 ### 1. Serial 收集器
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg" width=""/>
 
 Serial 翻译为串行，也就是说它以串行的方式执行。
 
@@ -298,7 +270,7 @@ Serial 翻译为串行，也就是说它以串行的方式执行。
 
 ### 2. ParNew 收集器
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg" width=""/>
 
 它是 Serial 收集器的多线程版本。
 
@@ -318,7 +290,7 @@ Serial 翻译为串行，也就是说它以串行的方式执行。
 
 ### 4. Serial Old 收集器
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg" width=""/>
 
 是 Serial 收集器的老年代版本，也是给 Client 场景下的虚拟机使用。如果用在 Server 场景下，它有两大用途：
 
@@ -327,7 +299,7 @@ Serial 翻译为串行，也就是说它以串行的方式执行。
 
 ### 5. Parallel Old 收集器
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/278fe431-af88-4a95-a895-9c3b80117de3.jpg" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/278fe431-af88-4a95-a895-9c3b80117de3.jpg" width=""/>
 
 是 Parallel Scavenge 收集器的老年代版本。
 
@@ -335,7 +307,7 @@ Serial 翻译为串行，也就是说它以串行的方式执行。
 
 ### 6. CMS 收集器
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/62e77997-6957-4b68-8d12-bfd609bb2c68.jpg" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/62e77997-6957-4b68-8d12-bfd609bb2c68.jpg" width=""/>
 
 CMS（Concurrent Mark Sweep），Mark Sweep 指的是标记 - 清除算法。
 
@@ -360,17 +332,17 @@ G1（Garbage-First），它是一款面向服务端应用的垃圾收集器，
 
 堆被分为新生代和老年代，其它收集器进行收集的范围都是整个新生代或者老年代，而 G1 可以直接对新生代和老年代一起回收。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/4cf711a8-7ab2-4152-b85c-d5c226733807.png" width="600"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/4cf711a8-7ab2-4152-b85c-d5c226733807.png" width="600"/>
 
 G1 把堆划分成多个大小相等的独立区域（Region），新生代和老年代不再物理隔离。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png" width="600"/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png" width="600"/>
 
 通过引入 Region 的概念，从而将原来的一整块内存空间划分成多个的小空间，使得每个小空间可以单独进行垃圾回收。这种划分方法带来了很大的灵活性，使得可预测的停顿时间模型成为可能。通过记录每个 Region 垃圾回收时间以及回收所获得的空间（这两个值是通过过去回收的经验获得），并维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的 Region。
 
 每个 Region 都有一个 Remembered Set，用来记录该 Region 对象的引用对象所在的 Region。通过使用 Remembered Set，在做可达性分析的时候就可以避免全堆扫描。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/f99ee771-c56f-47fb-9148-c0036695b5fe.jpg" width=""/> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/f99ee771-c56f-47fb-9148-c0036695b5fe.jpg" width=""/>
 
 如果不计算维护 Remembered Set 的操作，G1 收集器的运作大致可划分为以下几个步骤：
 
@@ -458,7 +430,7 @@ G1 把堆划分成多个大小相等的独立区域（Region），新生代和
 
 ## 类的生命周期
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/335fe19c-4a76-45ab-9320-88c90d6a0d7e.png" width="600px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/335fe19c-4a76-45ab-9320-88c90d6a0d7e.png" width="600px">
 
 包括以下 7 个阶段：
 
@@ -521,11 +493,9 @@ public static final int value = 123;
 其中解析过程在某些情况下可以在初始化阶段之后再开始，这是为了支持 Java 的动态绑定。
 
 <div data="补充为什么可以支持动态绑定 --> <--"></div>
-
 ### 5. 初始化
 
 <div data="modify -->"></div>
-
 初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段是虚拟机执行类构造器 &lt;clinit>() 方法的过程。在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
 
 &lt;clinit>() 是由编译器自动收集类中所有类变量的赋值动作和静态语句块中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定。特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码：
@@ -624,14 +594,13 @@ System.out.println(ConstClass.HELLOWORLD);
 - 应用程序类加载器（Application ClassLoader）这个类加载器是由 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。由于这个类加载器是 ClassLoader 中的 getSystemClassLoader() 方法的返回值，因此一般称为系统类加载器。它负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。
 
 <div data="modify <--"></div>
-
 ## 双亲委派模型
 
 应用程序是由三种类加载器互相配合从而实现类加载，除此之外还可以加入自己定义的类加载器。
 
 下图展示了类加载器之间的层次关系，称为双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其它的类加载器都要有自己的父类加载器。这里的父子关系一般通过组合关系（Composition）来实现，而不是继承关系（Inheritance）。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/0dd2d40a-5b2b-4d45-b176-e75a4cd4bdbf.png" width="500px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/0dd2d40a-5b2b-4d45-b176-e75a4cd4bdbf.png" width="500px">
 
 ### 1. 工作过程
 
@@ -756,10 +725,3 @@ public class FileSystemClassLoader extends ClassLoader {
 - [深入探讨 Java 类加载器](https://www.ibm.com/developerworks/cn/java/j-lo-classloader/index.html#code6)
 - [Guide to WeakHashMap in Java](http://www.baeldung.com/java-weakhashmap)
 - [Tomcat example source code file (ConcurrentCache.java)](https://alvinalexander.com/java/jwarehouse/apache-tomcat-6.0.16/java/org/apache/el/util/ConcurrentCache.java.shtml)
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 二分查找.md

@@ -1,14 +1,6 @@
-<!-- GFM-TOC -->
-* [1. 求开方](#1-求开方)
-* [2. 大于给定元素的最小元素](#2-大于给定元素的最小元素)
-* [3. 有序数组的 Single Element](#3-有序数组的-single-element)
-* [4. 第一个错误的版本](#4-第一个错误的版本)
-* [5. 旋转数组的最小数字](#5-旋转数组的最小数字)
-* [6. 查找区间](#6-查找区间)
-<!-- GFM-TOC -->
+[TOC]
 
-
-**正常实现** 
+正常实现** 
 
 ```text
 Input : [1,2,3,4,5]
@@ -301,10 +293,3 @@ private int binarySearch(int[] nums, int target) {
 }
 ```
 
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 位运算.md

@@ -1,19 +1,4 @@
-<!-- GFM-TOC -->
-* [1. 统计两个数的二进制表示有多少位不同](#1-统计两个数的二进制表示有多少位不同)
-* [2. 数组中唯一一个不重复的元素](#2-数组中唯一一个不重复的元素)
-* [3. 找出数组中缺失的那个数](#3-找出数组中缺失的那个数)
-* [4. 数组中不重复的两个元素](#4-数组中不重复的两个元素)
-* [5. 翻转一个数的比特位](#5-翻转一个数的比特位)
-* [6. 不用额外变量交换两个整数](#6-不用额外变量交换两个整数)
-* [7. 判断一个数是不是 2 的 n 次方](#7-判断一个数是不是-2-的-n-次方)
-* [8.  判断一个数是不是 4 的 n 次方](#8--判断一个数是不是-4-的-n-次方)
-* [9. 判断一个数的位级表示是否不会出现连续的 0 和 1](#9-判断一个数的位级表示是否不会出现连续的-0-和-1)
-* [10. 求一个数的补码](#10-求一个数的补码)
-* [11. 实现整数的加法](#11-实现整数的加法)
-* [12. 字符串数组最大乘积](#12-字符串数组最大乘积)
-* [13. 统计从 0 \~ n 每个数的二进制表示中 1 的个数](#13-统计从-0-\~-n-每个数的二进制表示中-1-的个数)
-<!-- GFM-TOC -->
-
+[TOC]
 
 **基本原理** 
 
@@ -440,10 +425,3 @@ public int[] countBits(int num) {
 }
 ```
 
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 分治.md

@@ -1,8 +1,4 @@
-<!-- GFM-TOC -->
-* [1. 给表达式加括号](#1-给表达式加括号)
-* [2. 不同的二叉搜索树](#2-不同的二叉搜索树)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 1. 给表达式加括号
 
@@ -108,10 +104,3 @@ private List<TreeNode> generateSubtrees(int s, int e) {
     return res;
 }
 ```
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 动态规划.md

@@ -1,43 +1,5 @@
-<!-- GFM-TOC -->
-* [斐波那契数列](#斐波那契数列)
-    * [1. 爬楼梯](#1-爬楼梯)
-    * [2. 强盗抢劫](#2-强盗抢劫)
-    * [3. 强盗在环形街区抢劫](#3-强盗在环形街区抢劫)
-    * [4. 信件错排](#4-信件错排)
-    * [5. 母牛生产](#5-母牛生产)
-* [矩阵路径](#矩阵路径)
-    * [1. 矩阵的最小路径和](#1-矩阵的最小路径和)
-    * [2. 矩阵的总路径数](#2-矩阵的总路径数)
-* [数组区间](#数组区间)
-    * [1. 数组区间和](#1-数组区间和)
-    * [2. 数组中等差递增子区间的个数](#2-数组中等差递增子区间的个数)
-* [分割整数](#分割整数)
-    * [1. 分割整数的最大乘积](#1-分割整数的最大乘积)
-    * [2. 按平方数来分割整数](#2-按平方数来分割整数)
-    * [3. 分割整数构成字母字符串](#3-分割整数构成字母字符串)
-* [最长递增子序列](#最长递增子序列)
-    * [1. 最长递增子序列](#1-最长递增子序列)
-    * [2. 一组整数对能够构成的最长链](#2-一组整数对能够构成的最长链)
-    * [3. 最长摆动子序列](#3-最长摆动子序列)
-* [最长公共子序列](#最长公共子序列)
-* [0-1 背包](#0-1-背包)
-    * [1. 划分数组为和相等的两部分](#1-划分数组为和相等的两部分)
-    * [2. 改变一组数的正负号使得它们的和为一给定数](#2-改变一组数的正负号使得它们的和为一给定数)
-    * [3. 01 字符构成最多的字符串](#3-01-字符构成最多的字符串)
-    * [4. 找零钱的最少硬币数](#4-找零钱的最少硬币数)
-    * [5. 找零钱的硬币数组合](#5-找零钱的硬币数组合)
-    * [6. 字符串按单词列表分割](#6-字符串按单词列表分割)
-    * [7. 组合总和](#7-组合总和)
-* [股票交易](#股票交易)
-    * [1. 需要冷却期的股票交易](#1-需要冷却期的股票交易)
-    * [2. 需要交易费用的股票交易](#2-需要交易费用的股票交易)
-    * [3. 只能进行两次的股票交易](#3-只能进行两次的股票交易)
-    * [4. 只能进行 k 次的股票交易](#4-只能进行-k-次的股票交易)
-* [字符串编辑](#字符串编辑)
-    * [1. 删除两个字符串的字符使它们相等](#1-删除两个字符串的字符使它们相等)
-    * [2. 编辑距离](#2-编辑距离)
-    * [3. 复制粘贴字符](#3-复制粘贴字符)
-<!-- GFM-TOC -->
+[TOC]
+
 
 
 递归和动态规划都是将原问题拆成多个子问题然后求解，他们之间最本质的区别是，动态规划保存了子问题的解，避免重复计算。
@@ -58,7 +20,7 @@
 
 <!--<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=dp[i-1]+dp[i-2]" class="mathjax-pic"/></div> <br>-->
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/14fe1e71-8518-458f-a220-116003061a83.png" width="200px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/14fe1e71-8518-458f-a220-116003061a83.png" width="200px">
 
 考虑到 dp[i] 只与 dp[i - 1] 和 dp[i - 2] 有关，因此可以只用两个变量来存储 dp[i - 1] 和 dp[i - 2]，使得原来的 O(N) 空间复杂度优化为 O(1) 复杂度。
 
@@ -91,7 +53,7 @@ public int climbStairs(int n) {
 
 <!--<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=max(dp[i-2]+nums[i],dp[i-1])" class="mathjax-pic"/></div> <br>-->
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/2de794ca-aa7b-48f3-a556-a0e2708cb976.jpg" width="350px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/2de794ca-aa7b-48f3-a556-a0e2708cb976.jpg" width="350px">
 
 ```java
 public int rob(int[] nums) {
@@ -147,7 +109,7 @@ private int rob(int[] nums, int first, int last) {
 
 <!--<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=(i-1)*dp[i-2]+(i-1)*dp[i-1]" class="mathjax-pic"/></div> <br>-->
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/da1f96b9-fd4d-44ca-8925-fb14c5733388.png" width="350px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/da1f96b9-fd4d-44ca-8925-fb14c5733388.png" width="350px">
 
 ## 5. 母牛生产
 
@@ -159,7 +121,7 @@ private int rob(int[] nums, int first, int last) {
 
 <!--<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=dp[i-1]+dp[i-3]" class="mathjax-pic"/></div> <br>-->
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/879814ee-48b5-4bcb-86f5-dcc400cb81ad.png" width="250px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/879814ee-48b5-4bcb-86f5-dcc400cb81ad.png" width="250px">
 
 # 矩阵路径
 
@@ -209,7 +171,7 @@ public int minPathSum(int[][] grid) {
 
 题目描述：统计从矩阵左上角到右下角的路径总数，每次只能向右或者向下移动。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/dc82f0f3-c1d4-4ac8-90ac-d5b32a9bd75a.jpg" width=""> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/dc82f0f3-c1d4-4ac8-90ac-d5b32a9bd75a.jpg" width="">
 
 ```java
 public int uniquePaths(int m, int n) {
@@ -440,7 +402,7 @@ public int numDecodings(String s) {
 
 <!--<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[n]=max\{1,dp[i]+1|S_i<S_n\&\&i<n\}" class="mathjax-pic"/></div> <br>-->
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ee994da4-0fc7-443d-ac56-c08caf00a204.jpg" width="350px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ee994da4-0fc7-443d-ac56-c08caf00a204.jpg" width="350px">
 
 对于一个长度为 N 的序列，最长递增子序列并不一定会以 S<sub>N</sub> 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，max{ dp[i] | 1 <= i <= N} 即为所求。
 
@@ -613,7 +575,7 @@ public int wiggleMaxLength(int[] nums) {
 
 <!--<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i][j]=\left\{\begin{array}{rcl}dp[i-1][j-1]&&{S1_i==S2_j}\\max(dp[i-1][j],dp[i][j-1])&&{S1_i<>S2_j}\end{array}\right." class="mathjax-pic"/></div> <br>-->
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ecd89a22-c075-4716-8423-e0ba89230e9a.jpg" width="450px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ecd89a22-c075-4716-8423-e0ba89230e9a.jpg" width="450px">
 
 对于长度为 N 的序列 S<sub>1</sub> 和长度为 M 的序列 S<sub>2</sub>，dp[N][M] 就是序列 S<sub>1</sub> 和序列 S<sub>2</sub> 的最长公共子序列长度。
 
@@ -653,7 +615,7 @@ public int lengthOfLCS(int[] nums1, int[] nums2) {
 
 <!--<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i][j]=max(dp[i-1][j],dp[i-1][j-w]+v)" class="mathjax-pic"/></div> <br>-->
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/8cb2be66-3d47-41ba-b55b-319fc68940d4.png" width="400px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/8cb2be66-3d47-41ba-b55b-319fc68940d4.png" width="400px">
 
 ```java
 // W 为背包总体积
@@ -682,7 +644,7 @@ public int knapsack(int W, int N, int[] weights, int[] values) {
 
 <!--<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[j]=max(dp[j],dp[j-w]+v)" class="mathjax-pic"/></div> <br>-->
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9ae89f16-7905-4a6f-88a2-874b4cac91f4.jpg" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9ae89f16-7905-4a6f-88a2-874b4cac91f4.jpg" width="300px">
 
 因为 dp[j-w] 表示 dp[i-1][j-w]，因此不能先求 dp[i][j-w]，防止将 dp[i-1][j-w] 覆盖。也就是说要先计算 dp[i][j] 再计算 dp[i][j-w]，在程序实现时需要按倒序来循环求解。
 
@@ -1046,7 +1008,7 @@ public int combinationSum4(int[] nums, int target) {
 
 题目描述：交易之后需要有一天的冷却时间。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ffd96b99-8009-487c-8e98-11c9d44ef14f.png" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ffd96b99-8009-487c-8e98-11c9d44ef14f.png" width="300px">
 
 ```java
 public int maxProfit(int[] prices) {
@@ -1089,7 +1051,7 @@ The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
 
 题目描述：每交易一次，都要支付一定的费用。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/1e2c588c-72b7-445e-aacb-d55dc8a88c29.png" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/1e2c588c-72b7-445e-aacb-d55dc8a88c29.png" width="300px">
 
 ```java
 public int maxProfit(int[] prices, int fee) {
@@ -1301,10 +1263,3 @@ public int minSteps(int n) {
     return dp[n];
 }
 ```
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 双指针.md

@@ -1,13 +1,4 @@
-<!-- GFM-TOC -->
-* [1. 有序数组的 Two Sum](#1-有序数组的-two-sum)
-* [2. 两数平方和](#2-两数平方和)
-* [3. 反转字符串中的元音字符](#3-反转字符串中的元音字符)
-* [4. 回文字符串](#4-回文字符串)
-* [5. 归并两个有序数组](#5-归并两个有序数组)
-* [6. 判断链表是否存在环](#6-判断链表是否存在环)
-* [7. 最长子序列](#7-最长子序列)
-<!-- GFM-TOC -->
-
+[TOC]
 
 双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。
 
@@ -32,7 +23,7 @@ Output: index1=1, index2=2
 
 数组中的元素最多遍历一次，时间复杂度为 O(N)。只使用了两个额外变量，空间复杂度为  O(1)。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/437cb54c-5970-4ba9-b2ef-2541f7d6c81e.gif" width="200px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/437cb54c-5970-4ba9-b2ef-2541f7d6c81e.gif" width="200px">
 
 ```java
 public int[] twoSum(int[] numbers, int target) {
@@ -102,7 +93,7 @@ Explanation: 1 * 1 + 2 * 2 = 5
 Given s = "leetcode", return "leotcede".
 ```
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/a7cb8423-895d-4975-8ef8-662a0029c772.png" width="400px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/a7cb8423-895d-4975-8ef8-662a0029c772.png" width="400px">
 
 使用双指针，一个指针从头向尾遍历，一个指针从尾到头遍历，当两个指针都遍历到元音字符时，交换这两个元音字符。
 
@@ -111,7 +102,7 @@ Given s = "leetcode", return "leotcede".
 - 时间复杂度为 O(N)：只需要遍历所有元素一次
 - 空间复杂度 O(1)：只需要使用两个额外变量
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ef25ff7c-0f63-420d-8b30-eafbeea35d11.gif" width="400px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ef25ff7c-0f63-420d-8b30-eafbeea35d11.gif" width="400px">
 
 ```java
 private final static HashSet<Character> vowels = new HashSet<>(
@@ -155,7 +146,7 @@ Explanation: You could delete the character 'c'.
 
 使用双指针可以很容易判断一个字符串是否是回文字符串：令一个指针从左到右遍历，一个指针从右到左遍历，这两个指针同时移动一个位置，每次都判断两个指针指向的字符是否相同，如果都相同，字符串才是具有左右对称性质的回文字符串。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/fcc941ec-134b-4dcd-bc86-1702fd305300.gif" width="250px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/fcc941ec-134b-4dcd-bc86-1702fd305300.gif" width="250px">
 
 本题的关键是处理删除一个字符。在使用双指针遍历字符串时，如果出现两个指针指向的字符不相等的情况，我们就试着删除一个字符，再判断删除完之后的字符串是否是回文字符串。
 
@@ -163,7 +154,7 @@ Explanation: You could delete the character 'c'.
 
 在试着删除字符时，我们既可以删除左指针指向的字符，也可以删除右指针指向的字符。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/db5f30a7-8bfa-4ecc-ab5d-747c77818964.gif" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/db5f30a7-8bfa-4ecc-ab5d-747c77818964.gif" width="300px">
 
 ```java
 public boolean validPalindrome(String s) {
@@ -290,10 +281,3 @@ private boolean isSubstr(String s, String target) {
     return j == target.length();
 }
 ```
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 哈希表.md

@@ -1,10 +1,4 @@
-<!-- GFM-TOC -->
-* [1. 数组中两个数的和为给定值](#1-数组中两个数的和为给定值)
-* [2. 判断数组是否含有重复元素](#2-判断数组是否含有重复元素)
-* [3. 最长和谐序列](#3-最长和谐序列)
-* [4. 最长连续序列](#4-最长连续序列)
-<!-- GFM-TOC -->
-
+[TOC]
 
 哈希表使用 O(N) 空间复杂度存储数据，并且以 O(1) 时间复杂度求解问题。
 
@@ -131,10 +125,3 @@ private int maxCount(Map<Integer, Integer> countForNum) {
     return max;
 }
 ```
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 图.md

@@ -1,13 +1,4 @@
-<!-- GFM-TOC -->
-* [二分图](#二分图)
-    * [1. 判断是否为二分图](#1-判断是否为二分图)
-* [拓扑排序](#拓扑排序)
-    * [1. 课程安排的合法性](#1-课程安排的合法性)
-    * [2. 课程安排的顺序](#2-课程安排的顺序)
-* [并查集](#并查集)
-    * [1. 冗余连接](#1-冗余连接)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 二分图
 
@@ -263,10 +254,3 @@ private class UF {
     }
 }
 ```
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 字符串.md

@@ -1,15 +1,4 @@
-<!-- GFM-TOC -->
-* [1. 字符串循环移位包含](#1-字符串循环移位包含)
-* [2. 字符串循环移位](#2-字符串循环移位)
-* [3. 字符串中单词的翻转](#3-字符串中单词的翻转)
-* [4. 两个字符串包含的字符是否完全相同](#4-两个字符串包含的字符是否完全相同)
-* [5. 计算一组字符集合可以组成的回文字符串的最大长度](#5-计算一组字符集合可以组成的回文字符串的最大长度)
-* [6. 字符串同构](#6-字符串同构)
-* [7. 回文子字符串个数](#7-回文子字符串个数)
-* [8. 判断一个整数是否是回文数](#8-判断一个整数是否是回文数)
-* [9. 统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数](#9-统计二进制字符串中连续-1-和连续-0-数量相同的子字符串个数)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 1. 字符串循环移位包含
 
@@ -235,10 +224,3 @@ public int countBinarySubstrings(String s) {
     return count;
 }
 ```
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 排序.md

@@ -1,14 +1,4 @@
-<!-- GFM-TOC -->
-* [快速选择](#快速选择)
-* [堆](#堆)
-    * [1. Kth Element](#1-kth-element)
-* [桶排序](#桶排序)
-    * [1. 出现频率最多的 k 个元素](#1-出现频率最多的-k-个元素)
-    * [2. 按照字符出现次数对字符串排序](#2-按照字符出现次数对字符串排序)
-* [荷兰国旗问题](#荷兰国旗问题)
-    * [1. 按颜色进行排序](#1-按颜色进行排序)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 快速选择
 
@@ -200,7 +190,7 @@ public String frequencySort(String s) {
 
 有三种颜色的球，算法的目标是将这三种球按颜色顺序正确地排列。它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/7a3215ec-6fb7-4935-8b0d-cb408208f7cb.png"/> </div><br>
+![](pics/7a3215ec-6fb7-4935-8b0d-cb408208f7cb.png)
 
 
 ## 1. 按颜色进行排序
@@ -236,10 +226,3 @@ private void swap(int[] nums, int i, int j) {
     nums[j] = t;
 }
 ```
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 搜索.md

@@ -1,38 +1,10 @@
-<!-- GFM-TOC -->
-* [BFS](#bfs)
-    * [1. 计算在网格中从原点到特定点的最短路径长度](#1-计算在网格中从原点到特定点的最短路径长度)
-    * [2. 组成整数的最小平方数数量](#2-组成整数的最小平方数数量)
-    * [3. 最短单词路径](#3-最短单词路径)
-* [DFS](#dfs)
-    * [1. 查找最大的连通面积](#1-查找最大的连通面积)
-    * [2. 矩阵中的连通分量数目](#2-矩阵中的连通分量数目)
-    * [3. 好友关系的连通分量数目](#3-好友关系的连通分量数目)
-    * [4. 填充封闭区域](#4-填充封闭区域)
-    * [5. 能到达的太平洋和大西洋的区域](#5-能到达的太平洋和大西洋的区域)
-* [Backtracking](#backtracking)
-    * [1. 数字键盘组合](#1-数字键盘组合)
-    * [2. IP 地址划分](#2-ip-地址划分)
-    * [3. 在矩阵中寻找字符串](#3-在矩阵中寻找字符串)
-    * [4. 输出二叉树中所有从根到叶子的路径](#4-输出二叉树中所有从根到叶子的路径)
-    * [5. 排列](#5-排列)
-    * [6. 含有相同元素求排列](#6-含有相同元素求排列)
-    * [7. 组合](#7-组合)
-    * [8. 组合求和](#8-组合求和)
-    * [9. 含有相同元素的组合求和](#9-含有相同元素的组合求和)
-    * [10. 1-9 数字的组合求和](#10-1-9-数字的组合求和)
-    * [11. 子集](#11-子集)
-    * [12. 含有相同元素求子集](#12-含有相同元素求子集)
-    * [13. 分割字符串使得每个部分都是回文数](#13-分割字符串使得每个部分都是回文数)
-    * [14. 数独](#14-数独)
-    * [15. N 皇后](#15-n-皇后)
-<!-- GFM-TOC -->
-
+[TOC]
 
 深度优先搜索和广度优先搜索广泛运用于树和图中，但是它们的应用远远不止如此。
 
 # BFS
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/95903878-725b-4ed9-bded-bc4aae0792a9.jpg"/> </div><br>
+![](pics/95903878-725b-4ed9-bded-bc4aae0792a9.jpg)
 
 广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。
 
@@ -269,7 +241,7 @@ private int getShortestPath(List<Integer>[] graphic, int start, int end) {
 
 # DFS
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/74dc31eb-6baa-47ea-ab1c-d27a0ca35093.png"/> </div><br>
+![](pics/74dc31eb-6baa-47ea-ab1c-d27a0ca35093.png)
 
 广度优先搜索一层一层遍历，每一层得到的所有新节点，要用队列存储起来以备下一层遍历的时候再遍历。
 
@@ -591,7 +563,7 @@ Backtracking（回溯）属于 DFS。
 
 [Leetcode](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/) / [力扣](https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/description/)
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9823768c-212b-4b1a-b69a-b3f59e07b977.jpg"/> </div><br>
+![](pics/9823768c-212b-4b1a-b69a-b3f59e07b977.jpg)
 
 ```html
 Input:Digit string "23"
@@ -1194,7 +1166,7 @@ private boolean isPalindrome(String s, int begin, int end) {
 
 [Leetcode](https://leetcode.com/problems/sudoku-solver/description/) / [力扣](https://leetcode-cn.com/problems/sudoku-solver/description/)
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/0e8fdc96-83c1-4798-9abe-45fc91d70b9d.png"/> </div><br>
+![](pics/0e8fdc96-83c1-4798-9abe-45fc91d70b9d.png)
 
 ```java
 private boolean[][] rowsUsed = new boolean[9][10];
@@ -1253,7 +1225,7 @@ private int cubeNum(int i, int j) {
 
 [Leetcode](https://leetcode.com/problems/n-queens/description/) / [力扣](https://leetcode-cn.com/problems/n-queens/description/)
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/067b310c-6877-40fe-9dcf-10654e737485.jpg"/> </div><br>
+![](pics/067b310c-6877-40fe-9dcf-10654e737485.jpg)
 
 在 n\*n 的矩阵中摆放 n 个皇后，并且每个皇后不能在同一行，同一列，同一对角线上，求所有的 n 皇后的解。
 
@@ -1261,12 +1233,12 @@ private int cubeNum(int i, int j) {
 
 45 度对角线标记数组的长度为 2 \* n - 1，通过下图可以明确 (r, c) 的位置所在的数组下标为 r + c。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9c422923-1447-4a3b-a4e1-97e663738187.jpg" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9c422923-1447-4a3b-a4e1-97e663738187.jpg" width="300px">
 
 
 135 度对角线标记数组的长度也是 2 \* n - 1，(r, c) 的位置所在的数组下标为 n - 1 - (r - c)。
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/7a85e285-e152-4116-b6dc-3fab27ba9437.jpg" width="300px"> </div><br>
+<img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/7a85e285-e152-4116-b6dc-3fab27ba9437.jpg" width="300px">
 
 ```java
 private List<List<String>> solutions;
@@ -1314,10 +1286,3 @@ private void backtracking(int row) {
     }
 }
 ```
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 数学.md

@@ -1,30 +1,4 @@
-<!-- GFM-TOC -->
-* [素数分解](#素数分解)
-* [整除](#整除)
-* [最大公约数最小公倍数](#最大公约数最小公倍数)
-    * [1. 生成素数序列](#1-生成素数序列)
-    * [2. 最大公约数](#2-最大公约数)
-    * [3. 使用位操作和减法求解最大公约数](#3-使用位操作和减法求解最大公约数)
-* [进制转换](#进制转换)
-    * [1. 7 进制](#1-7-进制)
-    * [2. 16 进制](#2-16-进制)
-    * [3. 26 进制](#3-26-进制)
-* [阶乘](#阶乘)
-    * [1. 统计阶乘尾部有多少个 0](#1-统计阶乘尾部有多少个-0)
-* [字符串加法减法](#字符串加法减法)
-    * [1. 二进制加法](#1-二进制加法)
-    * [2. 字符串加法](#2-字符串加法)
-* [相遇问题](#相遇问题)
-    * [1. 改变数组元素使所有的数组元素都相等](#1-改变数组元素使所有的数组元素都相等)
-* [多数投票问题](#多数投票问题)
-    * [1. 数组中出现次数多于 n / 2 的元素](#1-数组中出现次数多于-n--2-的元素)
-* [其它](#其它)
-    * [1. 平方数](#1-平方数)
-    * [2. 3 的 n 次方](#2-3-的-n-次方)
-    * [3. 乘积数组](#3-乘积数组)
-    * [4. 找出数组中的乘积最大的三个数](#4-找出数组中的乘积最大的三个数)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 素数分解
 
@@ -531,10 +505,3 @@ public int maximumProduct(int[] nums) {
     return Math.max(max1*max2*max3, max1*min1*min2);
 }
 ```
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 数组与矩阵.md

@@ -1,18 +1,4 @@
-<!-- GFM-TOC -->
-* [1. 把数组中的 0 移到末尾](#1-把数组中的-0-移到末尾)
-* [2. 改变矩阵维度](#2-改变矩阵维度)
-* [3. 找出数组中最长的连续 1](#3-找出数组中最长的连续-1)
-* [4. 有序矩阵查找](#4-有序矩阵查找)
-* [5. 有序矩阵的 Kth Element](#5-有序矩阵的-kth-element)
-* [6. 一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出重复的数和丢失的数](#6-一个数组元素在-[1,-n]-之间，其中一个数被替换为另一个数，找出重复的数和丢失的数)
-* [7. 找出数组中重复的数，数组值在 [1, n] 之间](#7-找出数组中重复的数，数组值在-[1,-n]-之间)
-* [8. 数组相邻差值的个数](#8-数组相邻差值的个数)
-* [9. 数组的度](#9-数组的度)
-* [10. 对角元素相等的矩阵](#10-对角元素相等的矩阵)
-* [11. 嵌套数组](#11-嵌套数组)
-* [12. 分隔数组](#12-分隔数组)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 1. 把数组中的 0 移到末尾
 
@@ -461,10 +447,3 @@ public int maxChunksToSorted(int[] arr) {
     return ret;
 }
 ```
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 栈和队列.md

@@ -1,12 +1,4 @@
-<!-- GFM-TOC -->
-* [1. 用栈实现队列](#1-用栈实现队列)
-* [2. 用队列实现栈](#2-用队列实现栈)
-* [3. 最小值栈](#3-最小值栈)
-* [4. 用栈实现括号匹配](#4-用栈实现括号匹配)
-* [5. 数组中元素与下一个比它大的元素之间的距离](#5-数组中元素与下一个比它大的元素之间的距离)
-* [6. 循环数组中比当前元素大的下一个元素](#6-循环数组中比当前元素大的下一个元素)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 1. 用栈实现队列
 
@@ -230,10 +222,3 @@ public int[] nextGreaterElements(int[] nums) {
     return next;
 }
 ```
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 树.md

@@ -1,42 +1,4 @@
-<!-- GFM-TOC -->
-* [递归](#递归)
-    * [1. 树的高度](#1-树的高度)
-    * [2. 平衡树](#2-平衡树)
-    * [3. 两节点的最长路径](#3-两节点的最长路径)
-    * [4. 翻转树](#4-翻转树)
-    * [5. 归并两棵树](#5-归并两棵树)
-    * [6. 判断路径和是否等于一个数](#6-判断路径和是否等于一个数)
-    * [7. 统计路径和等于一个数的路径数量](#7-统计路径和等于一个数的路径数量)
-    * [8. 子树](#8-子树)
-    * [9. 树的对称](#9-树的对称)
-    * [10. 最小路径](#10-最小路径)
-    * [11. 统计左叶子节点的和](#11-统计左叶子节点的和)
-    * [12. 相同节点值的最大路径长度](#12-相同节点值的最大路径长度)
-    * [13. 间隔遍历](#13-间隔遍历)
-    * [14. 找出二叉树中第二小的节点](#14-找出二叉树中第二小的节点)
-* [层次遍历](#层次遍历)
-    * [1. 一棵树每层节点的平均数](#1-一棵树每层节点的平均数)
-    * [2. 得到左下角的节点](#2-得到左下角的节点)
-* [前中后序遍历](#前中后序遍历)
-    * [1. 非递归实现二叉树的前序遍历](#1-非递归实现二叉树的前序遍历)
-    * [2. 非递归实现二叉树的后序遍历](#2-非递归实现二叉树的后序遍历)
-    * [3. 非递归实现二叉树的中序遍历](#3-非递归实现二叉树的中序遍历)
-* [BST](#bst)
-    * [1. 修剪二叉查找树](#1-修剪二叉查找树)
-    * [2. 寻找二叉查找树的第 k 个元素](#2-寻找二叉查找树的第-k-个元素)
-    * [3. 把二叉查找树每个节点的值都加上比它大的节点的值](#3-把二叉查找树每个节点的值都加上比它大的节点的值)
-    * [4. 二叉查找树的最近公共祖先](#4-二叉查找树的最近公共祖先)
-    * [5. 二叉树的最近公共祖先](#5-二叉树的最近公共祖先)
-    * [6. 从有序数组中构造二叉查找树](#6-从有序数组中构造二叉查找树)
-    * [7. 根据有序链表构造平衡的二叉查找树](#7-根据有序链表构造平衡的二叉查找树)
-    * [8. 在二叉查找树中寻找两个节点，使它们的和为一个给定值](#8-在二叉查找树中寻找两个节点，使它们的和为一个给定值)
-    * [9. 在二叉查找树中查找两个节点之差的最小绝对值](#9-在二叉查找树中查找两个节点之差的最小绝对值)
-    * [10. 寻找二叉查找树中出现次数最多的值](#10-寻找二叉查找树中出现次数最多的值)
-* [Trie](#trie)
-    * [1. 实现一个 Trie](#1-实现一个-trie)
-    * [2. 实现一个 Trie，用来求前缀和](#2-实现一个-trie，用来求前缀和)
-<!-- GFM-TOC -->
-
+[TOC]
 
 # 递归
 
@@ -1045,7 +1007,7 @@ private void inOrder(TreeNode node, List<Integer> nums) {
 
 # Trie
 
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/5c638d59-d4ae-4ba4-ad44-80bdc30f38dd.jpg"/> </div><br>
+![](pics/5c638d59-d4ae-4ba4-ad44-80bdc30f38dd.jpg)
 
 Trie，又称前缀树或字典树，用于判断字符串是否存在或者是否具有某种字符串前缀。
 
@@ -1180,10 +1142,3 @@ class MapSum {
 }
 ```
 
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 目录.md

@@ -1,5 +1,3 @@
-
-
 本文从 Leetcode 中精选大概 200 左右的题目，去除了某些繁杂但是没有多少算法思想的题目，同时保留了面试中经常被问到的经典题目。
 
 # 算法思想
@@ -33,10 +31,3 @@
 - 何海涛, 软件工程师. 剑指 Offer: 名企面试官精讲典型编程题[M]. 电子工业出版社, 2014.
 - 《编程之美》小组. 编程之美[M]. 电子工业出版社, 2008.
 - 左程云. 程序员代码面试指南[M]. 电子工业出版社, 2015.
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>

docs/notes/Leetcode 题解 - 目录1.md

@@ -1,5 +1,3 @@
-
-
 本文从 Leetcode 中精选大概 200 左右的题目，去除了某些繁杂但是没有多少算法思想的题目，同时保留了面试中经常被问到的经典题目。
 
 # 算法思想
@@ -33,10 +31,3 @@
 - 何海涛, 软件工程师. 剑指 Offer: 名企面试官精讲典型编程题[M]. 电子工业出版社, 2014.
 - 《编程之美》小组. 编程之美[M]. 电子工业出版社, 2008.
 - 左程云. 程序员代码面试指南[M]. 电子工业出版社, 2015.
-
-
-
-
-
-
-<div align="center"><img width="320px" src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/githubio/公众号二维码-1.png"></img></div>