StarMirror/CS-Notes
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

auto commit

Browse Source
This commit is contained in:
CyC2018 2018-06-12 11:02:23 +08:00
parent e027c81f04
commit fb619c7a20
3 changed files with 91 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
notes/Java 并发.md
View File

@ -569,7 +569,7 @@ ReentrantLock 多了一些高级功能。
在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待， 直到目标线程结束。 在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待， 直到目标线程结束。
对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，因此 b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先与 b 线程的输出。 对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，因此 b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。
```java ```java
public class JoinExample { public class JoinExample {
@ -887,7 +887,7 @@ java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
- **FIFO 队列** ：LinkedBlockingQueue、ArrayListBlockingQueue（固定长度） - **FIFO 队列** ：LinkedBlockingQueue、ArrayListBlockingQueue（固定长度）
- **优先级队列** ：PriorityBlockingQueue - **优先级队列** ：PriorityBlockingQueue
提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，指到队列有空闲位置。 提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，直到队列有空闲位置。
**使用 BlockingQueue 实现生产者消费者问题** **使用 BlockingQueue 实现生产者消费者问题**

153
notes/Leetcode 题解.md
View File

@ -2381,7 +2381,9 @@ dp[N] 即为所求。
```java ```java
public int climbStairs(int n) { public int climbStairs(int n) {
if (n <= 2) return n; if (n <= 2) {
return n;
}
int pre2 = 1, pre1 = 2; int pre2 = 1, pre1 = 2;
for (int i = 2; i < n; i++) { for (int i = 2; i < n; i++) {
int cur = pre1 + pre2; int cur = pre1 + pre2;
@ -2392,55 +2394,27 @@ public int climbStairs(int n) {
} }
``` ```
**母牛生产**
[程序员代码面试指南-P181](#)
题目描述：假设农场中成熟的母牛每年都会生 1 头小母牛，并且永远不会死。第一年有 1 只小母牛，从第二年开始，母牛开始生小母牛。每只小母牛 3 年之后成熟又可以生小母牛。给定整数 N，求 N 年后牛的数量。
第 i 年成熟的牛的数量为：
<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=dp[i-1]+dp[i-3]"/></div> <br>
**强盗抢劫** **强盗抢劫**
[198. House Robber (Easy)](https://leetcode.com/problems/house-robber/description/) [198. House Robber (Easy)](https://leetcode.com/problems/house-robber/description/)
题目描述：抢劫一排住户，但是不能抢邻近的住户，求最大抢劫量。 题目描述：抢劫一排住户，但是不能抢邻近的住户，求最大抢劫量。
定义 dp 数组用来存储最大的抢劫量，其中 dp[i] 表示抢到第 i 个住户时的最大抢劫量。由于不能抢劫邻近住户，因此如果抢劫了第 i 个住户那么只能抢劫 i - 2 和 i - 3 的住户，所以 定义 dp 数组用来存储最大的抢劫量，其中 dp[i] 表示抢到第 i 个住户时的最大抢劫量。由于不能抢劫邻近住户，因此如果抢劫了第 i 个住户那么只能抢劫 i - 2 或者 i - 3 的住户，所以
<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=max(dp[i-2],dp[i-3])+nums[i]"/></div> <br> <div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=max(dp[i-2],dp[i-3])+nums[i]"/></div> <br>
O(n) 空间复杂度实现方法：
```java ```java
public int rob(int[] nums) { public int rob(int[] nums) {
int n = nums.length; int n = nums.length;
if(n == 0) return 0; if (n == 0) {
if(n == 1) return nums[0]; return 0;
if(n == 2) return Math.max(nums[0], nums[1]);
int[] dp = new int[n];
dp[0] = nums[0];
dp[1] = nums[1];
dp[2] = nums[0] + nums[2];
for(int i = 3; i < n; i++){
dp[i] = Math.max(dp[i -2], dp[i - 3]) + nums[i];
} }
return Math.max(dp[n - 1], dp[n - 2]); if (n == 1) {
} return nums[0];
``` }
int pre3 = 0, pre2 = 0, pre1 = 0;
O(1) 空间复杂度实现方法： for (int i = 0; i < n; i++) {
```java
public int rob(int[] nums) {
int n = nums.length;
if(n == 0) return 0;
if(n == 1) return nums[0];
if(n == 2) return Math.max(nums[0], nums[1]);
int pre3 = nums[0], pre2 = nums[1], pre1 = nums[2] + nums[0];
for(int i = 3; i < n; i++){
int cur = Math.max(pre2, pre3) + nums[i]; int cur = Math.max(pre2, pre3) + nums[i];
pre3 = pre2; pre3 = pre2;
pre2 = pre1; pre2 = pre1;
@ -2455,34 +2429,44 @@ public int rob(int[] nums) {
[213. House Robber II (Medium)](https://leetcode.com/problems/house-robber-ii/description/) [213. House Robber II (Medium)](https://leetcode.com/problems/house-robber-ii/description/)
```java ```java
private int[] dp;
public int rob(int[] nums) { public int rob(int[] nums) {
if (nums == null || nums.length == 0) return 0; if (nums == null || nums.length == 0) {
return 0;
}
int n = nums.length; int n = nums.length;
if (n == 1) return nums[0]; if (n == 1) {
dp = new int[n]; return nums[0];
}
return Math.max(rob(nums, 0, n - 2), rob(nums, 1, n - 1)); return Math.max(rob(nums, 0, n - 2), rob(nums, 1, n - 1));
} }
private int rob(int[] nums, int first, int last) { private int rob(int[] nums, int first, int last) {
if (last - first == 0) return nums[first]; int pre3 = 0, pre2 = 0, pre1 = 0;
if (last - first == 1) return Math.max(nums[first], nums[first + 1]); for (int i = first; i <= last; i++) {
dp[first] = nums[first]; int cur = Math.max(pre3, pre2) + nums[i];
dp[first + 1] = nums[first + 1]; pre3 = pre2;
dp[first + 2] = nums[first] + nums[first + 2]; pre2 = pre1;
for (int i = first + 3; i <= last; i++) { pre1 = cur;
dp[i] = Math.max(dp[i - 2], dp[i - 3]) + nums[i];
} }
return Math.max(dp[last], dp[last - 1]); return Math.max(pre2, pre1);
} }
``` ```
**母牛生产**
[程序员代码面试指南-P181](#)
题目描述：假设农场中成熟的母牛每年都会生 1 头小母牛，并且永远不会死。第一年有 1 只小母牛，从第二年开始，母牛开始生小母牛。每只小母牛 3 年之后成熟又可以生小母牛。给定整数 N，求 N 年后牛的数量。
第 i 年成熟的牛的数量为：
<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=dp[i-1]+dp[i-3]"/></div> <br>
**信件错排** **信件错排**
题目描述：有 N 个 信 和 信封，它们被打乱，求错误装信方式的数量。 题目描述：有 N 个 信 和 信封，它们被打乱，求错误装信方式的数量。
定义一个数组 dp 存储错误方式数量，dp[i] 表示 i 个信和信封的错误方式数量。假设第 i 个信装到第 j 个信封里面，而第 j 个信装到第 k 个信封里面。根据 i 和 k 是否相等，有两种情况： 定义一个数组 dp 存储错误方式数量，dp[i] 表示前 i 个信和信封的错误方式数量。假设第 i 个信装到第 j 个信封里面，而第 j 个信装到第 k 个信封里面。根据 i 和 k 是否相等，有两种情况：
- i==k，交换 i 和 k 的信后，它们的信和信封在正确的位置，但是其余 i-2 封信有 dp[i-2] 种错误装信的方式。由于 j 有 i-1 种取值，因此共有 (i-1)\*dp[i-2] 种错误装信方式。 - i==k，交换 i 和 k 的信后，它们的信和信封在正确的位置，但是其余 i-2 封信有 dp[i-2] 种错误装信的方式。由于 j 有 i-1 种取值，因此共有 (i-1)\*dp[i-2] 种错误装信方式。
- i != k，交换 i 和 j 的信后，第 i 个信和信封在正确的位置，其余 i-1 封信有 dp[i-1] 种错误装信方式。由于 j 有 i-1 种取值，因此共有 (i-1)\*dp[i-1] 种错误装信方式。 - i != k，交换 i 和 j 的信后，第 i 个信和信封在正确的位置，其余 i-1 封信有 dp[i-1] 种错误装信方式。由于 j 有 i-1 种取值，因此共有 (i-1)\*dp[i-1] 种错误装信方式。
@ -2493,8 +2477,6 @@ private int rob(int[] nums, int first, int last) {
dp[N] 即为所求。 dp[N] 即为所求。
和上楼梯问题一样，dp[i] 只与 dp[i-1] 和 dp[i-2] 有关，因此也可以只用两个变量来存储 dp[i-1] 和 dp[i-2]。
### 最长递增子序列 ### 最长递增子序列
已知一个序列 {S<sub>1</sub>, S<sub>2</sub>,...,S<sub>n</sub>} ，取出若干数组成新的序列 {S<sub>i1</sub>, S<sub>i2</sub>,..., S<sub>im</sub>}，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个 **子序列** 。 已知一个序列 {S<sub>1</sub>, S<sub>2</sub>,...,S<sub>n</sub>} ，取出若干数组成新的序列 {S<sub>i1</sub>, S<sub>i2</sub>,..., S<sub>im</sub>}，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个 **子序列** 。
@ -2526,51 +2508,68 @@ public int lengthOfLIS(int[] nums) {
} }
dp[i] = max; dp[i] = max;
} }
int ret = 0; return Arrays.stream(dp).max().orElse(0);
for (int i = 0; i < n; i++) {
ret = Math.max(ret, dp[i]);
}
return ret;
} }
``` ```
以上解法的时间复杂度为 O(N<sup>2</sup>) ，可以使用二分查找将时间复杂度降低为 O(NlogN)。定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素。如果有多个长度相等的最长递增子序列，那么 tails[i] 就取最小值。例如对于数组 [4,5,6,3]，有 使用 Stream 求最大值会导致运行时间过长，可以改成以下形式：
```html ```java
len = 1 : [4], [5], [6], [3] => tails[0] = 3 int ret = 0;
len = 2 : [4, 5], [5, 6] => tails[1] = 5 for (int i = 0; i < n; i++) {
len = 3 : [4, 5, 6] => tails[2] = 6 ret = Math.max(ret, dp[i]);
}
return ret;
``` ```
以上解法的时间复杂度为 O(N<sup>2</sup>) ，可以使用二分查找将时间复杂度降低为 O(NlogN)。
对于一个元素 x， 定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素。对于一个元素 x，
- 如果它大于 tails 数组所有的值，那么把它添加到 tails 后面，表示最长递增子序列长度加 1； - 如果它大于 tails 数组所有的值，那么把它添加到 tails 后面，表示最长递增子序列长度加 1；
- 如果 tails[i-1] < x <= tails[i]，那么更新 tails[i-1] = x。 - 如果 tails[i-1] < x <= tails[i]，那么更新 tails[i-1] = x。
例如对于数组 [4,3,6,5]，有：
```html
tails len num
[] 0 4
[4] 1 3
[3] 1 6
[3,6] 2 5
[3,5] 2 null
```
可以看出 tails 数组保持有序，因此在查找 S<sub>i</sub> 位于 tails 数组的位置时就可以使用二分查找。 可以看出 tails 数组保持有序，因此在查找 S<sub>i</sub> 位于 tails 数组的位置时就可以使用二分查找。
```java ```java
public int lengthOfLIS(int[] nums) { public int lengthOfLIS(int[] nums) {
int n = nums.length; int n = nums.length;
int[] tails = new int[n]; int[] tails = new int[n];
int size = 0; int len = 0;
for (int i = 0; i < n; i++) { for (int num : nums) {
int index = binarySearch(tails, 0, size, nums[i]); int index = binarySearch(tails, len, num);
tails[index] = nums[i]; tails[index] = num;
if (index == size) size++; if (index == len) {
len++;
}
} }
return size; return len;
} }
private int binarySearch(int[] nums, int first, int last, int key) { private int binarySearch(int[] tails, int len, int key) {
while (first < last) { int l = 0, h = len;
int mid = first + (last - first) / 2; while (l < h) {
if (nums[mid] == key) return mid; int mid = l + (h - l) / 2;
else if (nums[mid] > key) last = mid; if (tails[mid] == key) {
else first = mid + 1; return mid;
} else if (tails[mid] > key) {
h = mid;
} else {
l = mid + 1;
}
} }
return first; return l;
} }
``` ```

24
notes/MySQL.md
View File

@ -32,13 +32,13 @@
InnoDB 是 MySQL 默认的事务型存储引擎，只有在需要 InnoDB 不支持的特性时，才考虑使用其它存储引擎。 InnoDB 是 MySQL 默认的事务型存储引擎，只有在需要 InnoDB 不支持的特性时，才考虑使用其它存储引擎。
采用 MVCC 来支持高并发，并且实现了四个标准的隔离级别，默认级别是可重复读（REPEATABLE READ），并且通过间隙锁（next-key locking）策略防止幻读的出现。间隙锁使得 InnoDB 不仅仅锁定查询涉及的行，还会对索引中的间隙进行锁定，以防止幻影行的插入。 采用 MVCC 来支持高并发，并且实现了四个标准的隔离级别，默认级别是可重复读（REPEATABLE READ），并且通过间隙锁（next-key locking）策略防止幻影读。间隙锁使得 InnoDB 不仅仅锁定查询涉及的行，还会对索引中的间隙进行锁定，以防止幻影行的插入。
表是基于聚簇索引建立的，它对主键的查询性能有很大的提升。 表是基于聚簇索引建立的，它对主键的查询性能有很大的提升。
内部做了很多优化，包括从磁盘读取数据时采用的可预测性读、能够自动在内存中创建哈希索引以加速读操作的自适应哈希索引、能够加速插入操作的插入缓冲区等。 内部做了很多优化，包括从磁盘读取数据时采用的可预测性读、能够自动在内存中创建哈希索引以加速读操作的自适应哈希索引、能够加速插入操作的插入缓冲区等。
通过一些机制和工具支持真正的热备份。其它存储引擎不支持热备份，要获取一致性视图需要停止对所有表的写入，而在读写混合场景中，停止写入可能也意味着停止读取。 通过一些机制和工具支持真正的在线热备份。其它存储引擎不支持在线热备份，要获取一致性视图需要停止对所有表的写入，而在读写混合场景中，停止写入可能也意味着停止读取。
## MyISAM ## MyISAM
@ -56,14 +56,16 @@ MyISAM 设计简单，数据以紧密格式存储。对于只读数据，或者
## 比较 ## 比较
- 事务：InnoDB 是事务型的。 - 事务：InnoDB 是事务型的，可以使用 Commit 和 Rollback 语句。
- 并发：MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。
- 外键：InnoDB 支持外键。
- 备份：InnoDB 支持在线热备份。 - 备份：InnoDB 支持在线热备份。
- 崩溃恢复：MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。 - 崩溃恢复：MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。
- 并发：MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。
- 其它特性：MyISAM 支持压缩表和空间数据索引。 - 其它特性：MyISAM 支持压缩表和空间数据索引。
# 二、数据类型 # 二、数据类型
@ -168,7 +170,7 @@ B+Tree 相比于 B-Tree 更适合外存索引，因为 B+Tree 内节点去掉了
为了减少磁盘 I/O，磁盘往往不是严格按需读取，而是每次都会预读。这样做的理论依据是计算机科学中著名的局部性原理：当一个数据被用到时，其附近的数据也通常会马上被使用。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，因此速度会非常快。 为了减少磁盘 I/O，磁盘往往不是严格按需读取，而是每次都会预读。这样做的理论依据是计算机科学中著名的局部性原理：当一个数据被用到时，其附近的数据也通常会马上被使用。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，因此速度会非常快。
操作系统一般将内存和磁盘分割成固态大小的块，每一块称为一页，内存与磁盘以页为单位交换数据。数据库系统将索引的一个节点的大小设置为页的大小，使得一次 I/O 就能完全载入一个节点，并且可以利用预读特性，临近的节点也能够被预先载入。 操作系统一般将内存和磁盘分割成固态大小的块，每一块称为一页，内存与磁盘以页为单位交换数据。数据库系统将索引的一个节点的大小设置为页的大小，使得一次 I/O 就能完全载入一个节点，并且可以利用预读特性，相邻的节点也能够被预先载入。
更多内容请参考：[MySQL 索引背后的数据结构及算法原理](http://blog.codinglabs.org/articles/theory-of-mysql-index.html) 更多内容请参考：[MySQL 索引背后的数据结构及算法原理](http://blog.codinglabs.org/articles/theory-of-mysql-index.html)
@ -211,13 +213,13 @@ MyISAM 存储引擎支持空间数据索引，可以用于地理数据存储。
### 4. 全文索引 ### 4. 全文索引
MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而不是直接比值是否相等。查找条件使用 MATCH AGAINST，而不是普通的 WHERE。 MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而不是直接比较是否相等。查找条件使用 MATCH AGAINST，而不是普通的 WHERE。
InnoDB 存储引擎在 MySQL 5.6.4 版本中也开始支持全文索引。 InnoDB 存储引擎在 MySQL 5.6.4 版本中也开始支持全文索引。
## 索引的优点 ## 索引的优点
- 大大减少了服务器需要扫描的数据量； - 大大减少了服务器需要扫描的数据行数。
- 帮助服务器避免进行排序和创建临时表（B+Tree 索引是有序的，可以用来做 ORDER BY 和 GROUP BY 操作）； - 帮助服务器避免进行排序和创建临时表（B+Tree 索引是有序的，可以用来做 ORDER BY 和 GROUP BY 操作）；
@ -291,7 +293,7 @@ customer_id_selectivity: 0.0373
**优点** **优点**
- 可以把相关数据保存在一起，减少 I/O 操作。例如电子邮件表可以根据用户 ID 来聚集数据，这样只需要从磁盘读取少数的数据也就能获取某个用户的全部邮件，如果没有使用聚聚簇索引，则每封邮件都可能导致一次磁盘 I/O。 - 可以把相关数据保存在一起，减少 I/O 操作。例如电子邮件表可以根据用户 ID 来聚集数据，这样只需要从磁盘读取少数的数据也就能获取某个用户的全部邮件，如果没有使用聚簇索引，则每封邮件都可能导致一次磁盘 I/O。
- 数据访问更快。 - 数据访问更快。
**缺点** **缺点**
@ -306,7 +308,7 @@ customer_id_selectivity: 0.0373
## 使用 Explain 进行分析 ## 使用 Explain 进行分析
Explain 用来分析 SELECT 查询语句，开发人员可以通过分析结果来优化查询语句。 Explain 用来分析 SELECT 查询语句，开发人员可以通过分析 Explain 结果来优化查询语句。
比较重要的字段有： 比较重要的字段有：
@ -405,7 +407,7 @@ SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904);
### 1. 事务问题 ### 1. 事务问题
使用分布式事务。 使用分布式事务，比如 XA 接口。
### 2. JOIN ### 2. JOIN