diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..314f02b1
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+*.txt
\ No newline at end of file
diff --git a/README.md b/README.md
index b69e91cf..0493e185 100644
--- a/README.md
+++ b/README.md
@@ -1,18 +1,13 @@
+
+| Ⅰ | Ⅱ | Ⅲ | Ⅳ | Ⅴ | Ⅵ | Ⅶ | Ⅷ | Ⅸ | Ⅹ |
+| :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:|
+|网络[:cloud:](#网络-cloud) |操作系统[:computer:](#操作系统-computer)| 算法[:pencil2:](#数据结构与算法-pencil2)| 面向对象[:couple:](#面向对象-couple) |数据库[:floppy_disk:](#数据库-floppy_disk)| Java [:coffee:](#java-coffee)| 分布式[:sweat_drops:](#分布式-sweat_drops)| 工具[:hammer:](#工具-hammer)| 编码实践[:speak_no_evil:](#编码实践-speak_no_evil)| 后记[:memo:](#后记-memo) |
+
-
+:loudspeaker: 本仓库不参与商业行为，不向读者收取任何费用。
-
-
-
-
-
-
- 
+:loudspeaker: This repository is not engaging in business activities, and does not charge readers any fee.
+
## 网络 :cloud:
@@ -38,7 +33,7 @@
> [算法](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/算法.md)
-整理自《算法 第四版》，主要整理了面试常问的排序和查找算法。
+整理自《算法 第四版》
> [剑指 Offer 题解](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/剑指%20offer%20题解.md)
@@ -46,7 +41,7 @@
> [Leetcode 题解](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Leetcode%20题解.md)
-对题目做了一个分类，并对每种题型的解题思路做了总结。已经整理了 300+ 的题目，基本涵盖所有经典题目。
+对题目做了一个分类，并对每种题型的解题思路做了总结。
## 面向对象 :couple:
@@ -56,7 +51,7 @@
> [面向对象思想](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/面向对象思想.md)
-一些面向对象思想和原则。
+一些面向对象思想和设计原则。
## 数据库 :floppy_disk:
@@ -64,19 +59,23 @@
整理自《数据库系统概论 第四版》
-> [SQL 语法](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/SQL%20语法.md)
+> [SQL](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/SQL.md)
整理自《SQL 必知必会》
> [MySQL](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/MySQL.md)
-整理自《高性能 MySQL》，整理了一些重点内容。
+整理自《高性能 MySQL》
+
+> [Redis](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Redis.md)
+
+整理自《Redis 设计与实现》和《Redis 实战》
## Java :coffee:
-> [JVM](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/JVM.md)
+> [Java 虚拟机](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Java%20虚拟机.md)
-整理自《深入理解 Java 虚拟机》，主要整理了内存模型、垃圾回收以及类加载机制。
+整理自《深入理解 Java 虚拟机》
> [Java 并发](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Java%20并发.md)
@@ -86,15 +85,44 @@
容器的一些总结，包含容器源码的分析。
-> [Java IO](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Java%20IO.md)
+> [Java I/O](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Java%20IO.md)
-File、InputStream OutputStream、Reader Writer、Serializable、Socket、NIO
+File, InputStream OutputStream, Reader Writer, Serializable, Socket, NIO
> [Java 基础](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Java%20基础.md)
整理了一些常见考点。
-## 编码实践 :hammer:
+> [JDK 中的设计模式](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/JDK%20中的设计模式.md)
+
+对每种设计模式做了一个总结，并给出在 JDK 中的使用实例。
+
+## 分布式 :sweat_drops:
+
+> [分布式基础](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/分布式基础.md)
+
+整理自《大规模分布式存储系统》
+
+> [一致性协议](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/一致性协议.md)
+
+两阶段提交、Paxos、Raft、拜占庭将军问题。
+
+> [分布式问题分析](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/分布式问题分析.md)
+
+分布式事务、负载均衡算法与实现、分布式锁、分布式 Session、分库分表的分布式困境与应对之策。
+
+
+## 工具 :hammer:
+
+> [Git](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/Git.md)
+
+整理一些 Git 的使用和概念。
+
+> [正则表达式](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/正则表达式.md)
+
+整理自《正则表达式必知必会》
+
+## 编码实践 :speak_no_evil:
> [重构](https://github.com/CyC2018/InnterviewNotes/blob/master/notes/重构.md)
@@ -108,33 +136,40 @@ File、InputStream OutputStream、Reader Writer、Serializable、Socket、NIO
Google 开源项目的代码风格规范。
-
-
## 后记 :memo:
-网上有很多相关的资料，但是这些资料都比较零散。本仓库的笔记是从经典的书籍和材料中整理而来，在整理出重点的同时会尽可能保证知识的系统性，因此比较适合作为应对面试的学习资料。
+**关于仓库**
-笔记内容按照 [中文文案排版指北](http://mazhuang.org/wiki/chinese-copywriting-guidelines/#%E4%B8%8D%E8%A6%81%E4%BD%BF%E7%94%A8%E4%B8%8D%E5%9C%B0%E9%81%93%E7%9A%84%E7%BC%A9%E5%86%99) 进行排版，以保证内容的可读性。这里提供了本人实现的 Markdown 文档排版工具的下载：[Markdown-Typesetting](https://github.com/CyC2018/Markdown-Typesetting)。
+本仓库是笔者在准备 2018 年春招实习过程中的学习总结，内容以计算机书籍的学习笔记为主，在整理重点知识的同时会尽量保证知识的系统性。
-由于 Github 使用的 GFM 不支持 MathJax 公式，也不支持 TOC 标记，为了把本地的 Markdown 文档转换为 GFM 支持的格式，需要替换 MathJax 公式为 CodeCogs 的云服务和重新生成 TOC 目录。并且为了让图片显示效果更好，笔记内容基本使用了 <center> 标记来让图片居中显示，但是 GFM 却不支持 <center> 标记，因此也需要进行一定的转换。这里提供了本人实现的 GFM 文档转换工具的下载：[GFM-Converter](https://github.com/CyC2018/GFM-Converter)。
+**关于贡献**
-因为大部分内容是一个字一个字打上去的，难免会有一些笔误，如果发现，可以直接在相应的文档上编辑修改。
+因为大部分内容是笔者一个字一个字打上去的，所有难免会有一些笔误。如果发现，可以直接在相应的文档上编辑修改。
-如果觉得内容不够完善或者有写的不好的地方，您可以在 Issues 中发表反馈意见。
+笔者能力有限，很多内容还不够完善。如果您希望和笔者一起完善这个仓库，可以在发表一个 Issue，表明您想要添加的内容，笔者会及时查看。
-笔记内容可供个人随意使用，转载或者引用请注明出处，毕竟写了很长时间没那么轻松~
+因为不打算将这个仓库做成一个大而全的面试宝典，只希望添加一些比较通用的基础知识，或者是与 Java 和分布式相关的内容，但是不添加 Java Web 相关的内容。
-## Donate
+您也可以在 Issues 中发表关于改进本仓库的建议。
-[Alipay](https://github.com/CyC2018/InterviewNotes/blob/master/other/alipay.md)
+**关于上传**
-## License
+笔者在本地使用为知笔记软件进行书写，为了方便将本地笔记内容上传到 Github 上，实现了一整套自动化上传方案，包括文本文件的导出、提取图片、Markdown 文档转换、Git 同步。
- ![]() ` 让图片居中显示，只能使用 `` ，所以只能使用 img 标签来引用图片。
+
+**关于转载**
+
+本仓库内容使用到的资料都会在最后面的参考资料中给出引用链接，希望您在使用本仓库的内容时也能给出相应的引用链接。
+
+**鸣谢**
+
+[TeeKee](https://github.com/linw7)
-本作品采用 知识共享署名-非商业性使用-相同方式共享 3.0 中国大陆许可协议 进行许可。
diff --git a/notes/Git.md b/notes/Git.md
new file mode 100644
index 00000000..1695faad
--- /dev/null
+++ b/notes/Git.md
@@ -0,0 +1,158 @@
+
+* [学习资料](#学习资料)
+* [集中式与分布式](#集中式与分布式)
+* [Git 的中心服务器](#git-的中心服务器)
+* [Git 工作流](#git-工作流)
+* [分支实现](#分支实现)
+* [冲突](#冲突)
+* [Fast forward](#fast-forward)
+* [分支管理策略](#分支管理策略)
+* [储藏（Stashing）](#储藏stashing)
+* [SSH 传输设置](#ssh-传输设置)
+* [.gitignore 文件](#gitignore-文件)
+* [Git 命令一览](#git-命令一览)
+
+
+
+# 学习资料
+
+- [Git - 简明指南](http://rogerdudler.github.io/git-guide/index.zh.html)
+- [图解 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/)
+
+# 集中式与分布式
+
+Git 属于分布式版本控制系统，而 SVN 属于集中式。
+
+集中式版本控制只有中心服务器拥有一份代码，而分布式版本控制每个人的电脑上就有一份完整的代码。
+
+集中式版本控制有安全性问题，当中心服务器挂了所有人都没办法工作了。
+
+集中式版本控制需要连网才能工作，如果网速过慢，那么提交一个文件的会慢的无法让人忍受。而分布式版本控制不需要连网就能工作。
+
+分布式版本控制新建分支、合并分支操作速度非常快，而集中式版本控制新建一个分支相当于复制一份完整代码。
+
+# Git 的中心服务器
+
+Git 的中心服务器用来交换每个用户的修改。没有中心服务器也能工作，但是中心服务器能够 24 小时保持开机状态，这样就能更方便的交换修改。Github 就是一种 Git 中心服务器。
+
+# Git 工作流
+
+New File
+```
+
+## PATCH
+
+> 对资源进行部分修改
+
+PUT 也可以用于修改资源，但是只能完全替代原始资源，PATCH 允许部分修改。
+
+```html
+PATCH /file.txt HTTP/1.1
+Host: www.example.com
+Content-Type: application/example
+If-Match: "e0023aa4e"
+Content-Length: 100
+
+[description of changes]
+```
+
+## DELETE
+
+> 删除文件
与 PUT 功能相反，并且同样不带验证机制。
-## OPTIONS：查询支持的方法
+```html
+DELETE /file.html HTTP/1.1
+```
+
+## OPTIONS
+
+> 查询支持的方法
查询指定的 URL 能够支持的方法。
会返回 Allow: GET, POST, HEAD, OPTIONS 这样的内容。
-## TRACE：追踪路径
+## CONNECT
+
+> 要求用隧道协议连接代理
+
+要求在与代理服务器通信时建立隧道，使用 SSL（Secure Sockets Layer，安全套接层）和 TLS（Transport Layer Security，传输层安全）协议把通信内容加密后经网络隧道传输。
+
+```html
+CONNECT www.example.com:443 HTTP/1.1
+```
+
+
+```
+
+另一个用户浏览了含有这个内容的页面将会跳往 domain.com 并携带了当前作用域的 Cookie。如果这个论坛网站通过 Cookie 管理用户登录状态，那么攻击者就可以通过这个 Cookie 登录被攻击者的账号了。
+
+### 2. 危害
+
+- 伪造虚假的输入表单骗取个人信息
+- 窃取用户的 Cookie 值
+- 显示伪造的文章或者图片
+
+### 3. 防范手段
+
+（一）过滤特殊字符
+
+许多语言都提供了对 HTML 的过滤：
+
+- PHP 的 htmlentities() 或是 htmlspecialchars()。
+- Python 的 cgi.escape()。
+- Java 的 xssprotect (Open Source Library)。
+- Node.js 的 node-validator。
+
+（二）指定 HTTP 的 Content-Type
+
+通过这种方式，可以避免内容被当成 HTML 解析，比如 PHP 语言可以使用以下代码：
+
+```php
+
+```
+
+## 跨站点请求伪造
+
+### 1. 概念
+
+跨站点请求伪造（Cross-site request forgery，CSRF），是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并执行一些操作（如发邮件，发消息，甚至财产操作如转账和购买商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去执行。这利用了 Web 中用户身份验证的一个漏洞：简单的身份验证只能保证请求发自某个用户的浏览器，却不能保证请求本身是用户自愿发出的。
+
+XSS 利用的是用户对指定网站的信任，CSRF 利用的是网站对用户网页浏览器的信任。
+
+假如一家银行用以执行转账操作的 URL 地址如下：
+
+```
+http://www.examplebank.com/withdraw?account=AccoutName&amount=1000&for=PayeeName。
+```
+
+那么，一个恶意攻击者可以在另一个网站上放置如下代码：
+
+```
+ set = new HashSet<>();
+set.add(e1);
+set.add(e2);
+System.out.println(set.size()); // 2
+```
+
+理想的散列函数应当具有均匀性，即不相等的实例应当均匀分不到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来，可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。
+
+一个数与 31 相乘可以转换成移位和减法：31\*x == (x<<5)-x。
+
+```java
+@Override
+public int hashCode() {
+ int result = 17;
+ result = 31 * result + x;
+ result = 31 * result + y;
+ result = 31 * result + z;
+ return result;
+}
+```
+
+## toString()
+
+默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。
+
+```java
+public class ToStringExample {
+ private int number;
+
+ public ToStringExample(int number) {
+ this.number = number;
+ }
+}
+```
+
+```java
+ToStringExample example = new ToStringExample(123);
+System.out.println(example.toString());
+```
+
+```html
+ToStringExample@4554617c
+```
+
+## clone()
+
+**1. cloneable**
+
+clone() 是 Object 的受保护方法，这意味着，如果一个类不显式去覆盖 clone() 就没有这个方法。
+
+```java
+public class CloneExample {
+ private int a;
+ private int b;
+}
+```
+
+```java
+CloneExample e1 = new CloneExample();
+CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'
+```
+
+接下来覆盖 Object 的 clone() 得到以下实现：
+
+```java
+public class CloneExample {
+ private int a;
+ private int b;
+
+ @Override
+ protected CloneExample clone() throws CloneNotSupportedException {
+ return (CloneExample)super.clone();
+ }
+}
+```
+
+```java
+CloneExample e1 = new CloneExample();
+try {
+ CloneExample e2 = e1.clone();
+} catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+}
+```
+
+```html
+java.lang.CloneNotSupportedException: CloneTest
+```
+
+以上抛出了 CloneNotSupportedException，这是因为 CloneTest 没有实现 Cloneable 接口。
+
+```java
+public class CloneExample implements Cloneable {
+ private int a;
+ private int b;
+
+ @Override
+ protected Object clone() throws CloneNotSupportedException {
+ return super.clone();
+ }
+}
+```
+
+应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
+
+**2. 深拷贝与浅拷贝**
+
+- 浅拷贝：拷贝实例和原始实例的引用类型引用同一个对象；
+- 深拷贝：拷贝实例和原始实例的引用类型引用不同对象。
+
+```java
+public class ShallowCloneExample implements Cloneable {
+ private int[] arr;
+
+ public ShallowCloneExample() {
+ arr = new int[10];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
+
+ public void set(int index, int value) {
+ arr[index] = value;
+ }
+
+ public int get(int index) {
+ return arr[index];
+ }
+
+ @Override
+ protected ShallowCloneExample clone() throws CloneNotSupportedException {
+ return (ShallowCloneExample) super.clone();
+ }
+}
+```
+
+```java
+ShallowCloneExample e1 = new ShallowCloneExample();
+ShallowCloneExample e2 = null;
+try {
+ e2 = e1.clone();
+} catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+}
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 222
+```
+
+```java
+public class DeepCloneExample implements Cloneable {
+ private int[] arr;
+
+ public DeepCloneExample() {
+ arr = new int[10];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
+
+ public void set(int index, int value) {
+ arr[index] = value;
+ }
+
+ public int get(int index) {
+ return arr[index];
+ }
+
+ @Override
+ protected DeepCloneExample clone() throws CloneNotSupportedException {
+ DeepCloneExample result = (DeepCloneExample) super.clone();
+ result.arr = new int[arr.length];
+ for (int i = 0; i < arr.length; i++) {
+ result.arr[i] = arr[i];
+ }
+ return result;
+ }
+}
+```
+
+```java
+DeepCloneExample e1 = new DeepCloneExample();
+DeepCloneExample e2 = null;
+try {
+ e2 = e1.clone();
+} catch (CloneNotSupportedException e) {
+ e.printStackTrace();
+}
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 2
+```
+
+使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
+
+```java
+public class CloneConstructorExample {
+ private int[] arr;
+
+ public CloneConstructorExample() {
+ arr = new int[10];
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
+
+ public CloneConstructorExample(CloneConstructorExample original) {
+ arr = new int[original.arr.length];
+ for (int i = 0; i < original.arr.length; i++) {
+ arr[i] = original.arr[i];
+ }
+ }
+
+ public void set(int index, int value) {
+ arr[index] = value;
+ }
+
+ public int get(int index) {
+ return arr[index];
+ }
+}
+```
+
+```java
+CloneConstructorExample e1 = new CloneConstructorExample();
+CloneConstructorExample e2 = new CloneConstructorExample(e1);
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 2
+```
+
+# 四、继承
+
+## 访问权限
Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
-可以对类或类中的成员（字段以及方法）加上访问修饰符。成员可见表示其它类可以用成员所在类的对象访问到该成员；类可见表示其它类可以用这个类创建对象，可以把类当做包中的一个成员，然后包表示一个类，这样就好理解了。
+可以对类或类中的成员（字段以及方法）加上访问修饰符。
-protected 用于修饰成员，表示在继承体系中成员对于子类可见。但是这个访问修饰符对于类没有意义，因为包没有继承体系。
+- 成员可见表示其它类可以用这个类的实例访问到该成员；
+- 类可见表示其它类可以用这个类创建对象。
-更详细的内容：[ 浅析 Java 中的访问权限控制 ](http://www.importnew.com/18097.html)
+protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
-## 2. 抽象类与接口的区别
+设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
-抽象类至少包含一个抽象方法，该抽象方法必须在子类中实现。由于抽象类没有抽象方法的具体实现，因此不能对抽象类进行实例化。
+如果子类的方法覆盖了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里式替换原则。
+
+字段决不能是公有的，因为这么做的话就失去了对这个实例域修改行为的控制，客户端可以对其随意修改。可以使用共有的 getter 和 setter 方法来替换共有字段。
```java
-public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
- // abstract method
- abstract void service(ServletRequest req, ServletResponse res);
-
- void init() {
- // Its implementation
- }
- // other method related to Servlet
+public class AccessExample {
+ public int x;
}
```
-接口定义了一组方法，但是接口都没有方法的实现，也就是说这些方法都是抽象方法。
-
```java
-public interface Externalizable extends Serializable {
+public class AccessExample {
+ private int x;
- void writeExternal(ObjectOutput out) throws IOException;
+ public int getX() {
+ return x;
+ }
- void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
+ public void setX(int x) {
+ this.x = x;
+ }
}
```
-更详细的内容：[Java 抽象类与接口的区别 ](http://www.importnew.com/12399.html)
-
-## 3. super()
-
-用来访问父类的构造函数父类的方法，第二种情况中，子类需要重载父类的方法。
+但是也有例外，如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。
```java
-public class Subclass extends Superclass {
- // overrides printMethod in Superclass
- public void printMethod() {
- super.printMethod();
- System.out.println("Printed in Subclass");
+public class AccessWithInnerClassExample {
+ private class InnerClass {
+ int x;
}
- public static void main(String[] args) {
- Subclass s = new Subclass();
- s.printMethod();
+
+ private InnerClass innerClass;
+
+ public AccessWithInnerClassExample() {
+ innerClass = new InnerClass();
+ }
+
+ public int getValue() {
+ return innerClass.x; // 直接访问
}
}
```
+## 抽象类与接口
+
+**1. 抽象类**
+
+抽象类和抽象方法都使用 abstract 进行声明。抽象类一般会包含抽象方法，抽象方法一定位于抽象类中。
+
+抽象类和普通类最大的区别是，抽象类不能被实例化，需要继承抽象类才能实例化其子类。
+
+```java
+public abstract class AbstractClassExample {
+
+ protected int x;
+ private int y;
+
+ public abstract void func1();
+
+ public void func2() {
+ System.out.println("func2");
+ }
+}
+```
+
+```java
+public class AbstractExtendClassExample extends AbstractClassExample{
+ @Override
+ public void func1() {
+ System.out.println("func1");
+ }
+}
+```
+
+```java
+// AbstractClassExample ac1 = new AbstractClassExample(); // 'AbstractClassExample' is abstract; cannot be instantiated
+AbstractClassExample ac2 = new AbstractExtendClassExample();
+ac2.func1();
+```
+
+**2. 接口**
+
+接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。
+
+从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。
+
+接口也可以包含字段，并且这些字段隐式都是 static 和 final 的。
+
+接口中的方法默认都是 public 的，并且不允许定义为 private 或者 protected。
+
+```java
+public interface InterfaceExample {
+ void func1();
+
+ default void func2(){
+ System.out.println("func2");
+ }
+
+ int x = 123;
+ //int y; // Variable 'y' might not have been initialized
+ public int z = 0; // Modifier 'public' is redundant for interface fields
+ // private int k = 0; // Modifier 'private' not allowed here
+ // protected int l = 0; // Modifier 'protected' not allowed here
+ // private void fun3(); // Modifier 'private' not allowed here
+}
+```
+
+```java
+public class InterfaceImplementExample implements InterfaceExample {
+ @Override
+ public void func1() {
+ System.out.println("func1");
+ }
+}
+```
+
+```java
+// InterfaceExample ie1 = new InterfaceExample(); // 'InterfaceExample' is abstract; cannot be instantiated
+InterfaceExample ie2 = new InterfaceImplementExample();
+ie2.func1();
+System.out.println(InterfaceExample.x);
+```
+
+**3. 比较**
+
+- 从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求子类和父类具有 IS-A 关系；
+- 从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
+- 接口的字段只能是 static 和 final 类型的，而抽象类的域可以有多种访问权限。
+- 接口的方法只能是 public 的，而抽象类的方法可以由多种访问权限。
+
+**4. 使用选择**
+
+使用抽象类：
+
+- 需要在几个相关的类中共享代码；
+- 需要能控制继承来的方法和域的访问权限，而不是都为 public。
+- 需要继承非静态（non-static）和非常量（non-final）字段。
+
+使用接口：
+
+- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
+- 需要使用多重继承。
+
+在很多情况下，接口优先于抽象类，因为接口没有抽象类严格的类层次接口要求，可以灵活地为一个类添加行为。并且从 Java 8 开始，接口也可以有默认的方法实现，使得修改接口的成本也变的很低。
+
+> [深入理解 abstract class 和 interface](https://www.ibm.com/developerworks/cn/java/l-javainterface-abstract/) [When to Use Abstract Class and Interface](https://dzone.com/articles/when-to-use-abstract-class-and-intreface)
+
+## super
+
+- 访问父类的构造函数：可以使用 super() 函数访问父类的构造函数，从而完成一些初始化的工作。
+- 访问父类的成员：如果子类覆盖了父类的中某个方法的实现，可以通过使用 super 关键字来引用父类的方法实现。
+
+```java
+public class SuperExample {
+ protected int x;
+ protected int y;
+
+ public SuperExample(int x, int y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ public void func() {
+ System.out.println("SuperExample.func()");
+ }
+}
+```
+
+```java
+public class SuperExtendExample extends SuperExample {
+ private int z;
+
+ public SuperExtendExample(int x, int y, int z) {
+ super(x, y);
+ this.z = z;
+ }
+
+ @Override
+ public void func() {
+ super.func();
+ System.out.println("SuperExtendExample.func()");
+ }
+}
+```
+
+```java
+SuperExample e = new SuperExtendExample(1, 2, 3);
+e.func();
+```
+
+```html
+SuperExample.func()
+SuperExtendExample.func()
+```
+
> [Using the Keyword super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)
-# String
+## 覆盖与重载
-## 1. String, StringBuffer and StringBuilder
+- 覆盖（Override）存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法；
-**是否可变**
+- 重载（Overload）存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。应该注意的是，返回值不同，其它都相同不算是重载。
-String 不可变，StringBuffer 和 StringBuilder 可变。
+# 五、String
-**是否线程安全**
+## String, StringBuffer and StringBuilder
-String 不可变，因此是线程安全的。
+**1. 是否可变**
-StringBuilder 不是线程安全的；StringBuffer 是线程安全的，使用 synchronized 来同步。
+- String 不可变
+- StringBuffer 和 StringBuilder 可变
+
+**2. 是否线程安全**
+
+- String 不可变，因此是线程安全的
+- StringBuilder 不是线程安全的
+- StringBuffer 是线程安全的，内部使用 synchronized 来同步
> [String, StringBuffer, and StringBuilder](https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder)
-## 2. String 不可变的原因
+## String 不可变的原因
-**可以缓存 hash 值**
+**1. 可以缓存 hash 值**
-因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 等。不可变的特性可以使得 hash 值也不可变，因此就只需要进行一次计算。
+因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
-**String Pool 的需要**
+**2. String Pool 的需要**
-如果 String 已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
+如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
- {
@@ -400,20 +961,23 @@ public class Box {
}
```
-更详细的内容：
+> [Java 泛型详解](https://www.ziwenxie.site/2017/03/01/java-generic/)[10 道 Java 泛型面试题](https://cloud.tencent.com/developer/article/1033693)
-- [Java 泛型详解 ](https://www.ziwenxie.site/2017/03/01/java-generic/)
-- [10 道 Java 泛型面试题 ](https://cloud.tencent.com/developer/article/1033693)
+# 十、注解
-# 特性
+Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。
-## 1. 三大特性
+> [注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
-[ 封装、继承、多态 ](https://github.com/CyC2018/InterviewNotes/blob/master/notes/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E6%80%9D%E6%83%B3.md#%E5%B0%81%E8%A3%85%E7%BB%A7%E6%89%BF%E5%A4%9A%E6%80%81)
+# 十一、特性
-## 2. Java 各版本的新特性
+## 面向对象三大特性
-New highlights in Java SE 8
+> [封装、继承、多态](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E6%80%9D%E6%83%B3.md#%E5%B0%81%E8%A3%85%E7%BB%A7%E6%89%BF%E5%A4%9A%E6%80%81)
+
+## Java 各版本的新特性
+
+**New highlights in Java SE 8**
1. Lambda Expressions
2. Pipelines and Streams
@@ -425,7 +989,7 @@ New highlights in Java SE 8
8. Parallel operations
9. PermGen Error Removed
-New highlights in Java SE 7
+**New highlights in Java SE 7**
1. Strings in Switch Statement
2. Type Inference for Generic Instance Creation
@@ -436,16 +1000,12 @@ New highlights in Java SE 7
7. Binary Literals, Underscore in literals
8. Diamond Syntax
-> [Difference between Java 1.8 and Java 1.7?](http://www.selfgrowth.com/articles/difference-between-java-18-and-java-17)
+> [Difference between Java 1.8 and Java 1.7?](http://www.selfgrowth.com/articles/difference-between-java-18-and-java-17) [Java 8 特性 ](http://www.importnew.com/19345.html)
-更详细的内容：[Java 8 特性 ](http://www.importnew.com/19345.html)
-
-## 3. Java 与 C++ 的区别
+## Java 与 C++ 的区别
Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
-比较详细的内容：
-
| Java | C++ |
| -- | -- |
| Java does not support pointers, templates, unions, operator overloading, structures etc. The Java language promoters initially said "No pointers!", but when many programmers questioned how you can work without pointers, the promoters began saying "Restricted pointers." Java supports what it calls "references". References act a lot like pointers in C++ languages but you cannot perform arithmetic on pointers in Java. References have types, and they're type-safe. These references cannot be interpreted as raw address and unsafe conversion is not allowed. | C++ supports structures, unions, templates, operator overloading, pointers and pointer arithmetic.|
@@ -462,7 +1022,12 @@ Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Obje
> [What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)
-## 4. JRE or JDK
+## JRE or JDK
- JRE is the JVM program, Java application need to run on JRE.
- JDK is a superset of JRE, JRE + tools for developing java programs. e.g, it provides the compiler "javac"
+
+# 参考资料
+
+- Eckel B. Java 编程思想[M]. 机械工业出版社, 2002.
+- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
diff --git a/notes/Java 容器.md b/notes/Java 容器.md
index bc2453b3..1cb19fe6 100644
--- a/notes/Java 容器.md
+++ b/notes/Java 容器.md
@@ -1,139 +1,140 @@
-* [概览](#概览)
- * [1. List](#1-list)
- * [2. Set](#2-set)
- * [3. Queue](#3-queue)
- * [4. Map](#4-map)
- * [5. Java 1.0/1.1 容器](#5-java-1011-容器)
-* [容器中的设计模式](#容器中的设计模式)
- * [1. 迭代器模式](#1-迭代器模式)
- * [2. 适配器模式](#2-适配器模式)
-* [散列](#散列)
-* [源码分析](#源码分析)
- * [1. ArraList](#1-arralist)
- * [2. Vector 与 Stack](#2-vector-与-stack)
- * [3. LinkedList](#3-linkedlist)
- * [4. TreeMap](#4-treemap)
- * [5. HashMap](#5-hashmap)
- * [6. LinkedHashMap](#6-linkedhashmap)
- * [7. ConcurrentHashMap](#7-concurrenthashmap)
+* [一、概览](#一概览)
+ * [Collection](#collection)
+ * [Map](#map)
+* [二、容器中的设计模式](#二容器中的设计模式)
+ * [迭代器模式](#迭代器模式)
+ * [适配器模式](#适配器模式)
+* [三、源码分析](#三源码分析)
+ * [ArrayList](#arraylist)
+ * [Vector](#vector)
+ * [LinkedList](#linkedlist)
+ * [TreeMap](#treemap)
+ * [HashMap](#hashmap)
+ * [LinkedHashMap](#linkedhashmap)
+ * [ConcurrentHashMap - JDK 1.7](#concurrenthashmap---jdk-17)
+ * [ConcurrentHashMap - JDK 1.8](#concurrenthashmap---jdk-18)
* [参考资料](#参考资料)
-# 概览
-
- list = new ArrayList<>();
+list.add("a");
+list.add("b");
+for (String item : list) {
+ System.out.println(item);
+}
+```
-# 容器中的设计模式
-
-## 1. 迭代器模式
-
-从概览图可以看到，每个集合类都有一个 Iterator 对象，可以通过这个迭代器对象来遍历集合中的元素。
-
-[Java 中的迭代器模式 ](https://github.com/CyC2018/InterviewNotes/blob/master/notes/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F.md#92-java-%E5%86%85%E7%BD%AE%E7%9A%84%E8%BF%AD%E4%BB%A3%E5%99%A8)
-
-## 2. 适配器模式
+## 适配器模式
java.util.Arrays#asList() 可以把数组类型转换为 List 类型。
```java
- List list = Arrays.asList(1, 2, 3);
- int[] arr = {1, 2, 3};
- list = Arrays.asList(arr);
+@SafeVarargs
+public static List asList(T... a)
```
-# 散列
+如果要将数组类型转换为 List 类型，应该注意的是 asList() 的参数为泛型的变长参数，因此不能使用基本类型数组作为参数，只能使用相应的包装类型数组。
-使用 hasCode() 来返回散列值，使用的是对象的地址。
+```java
+Integer[] arr = {1, 2, 3};
+List list = Arrays.asList(arr);
+```
-而 equals() 是用来判断两个对象是否相等的，相等的两个对象散列值一定要相同，但是散列值相同的两个对象不一定相等。
+也可以使用以下方式生成 List。
-相等必须满足以下五个性质：
+```java
+List list = Arrays.asList(1,2,3);
+```
-1. 自反性
-2. 对称性
-3. 传递性
-4. 一致性（多次调用 x.equals(y)，结果不变）
-5. 对任何不是 null 的对象 x 调用 x.equals(nul) 结果都为 false
+# 三、源码分析
-# 源码分析
+建议先阅读 [算法-查找](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E7%AE%97%E6%B3%95.md#%E6%9F%A5%E6%89%BE) 部分，对容器类源码的理解有很大帮助。
-建议先阅读 [ 算法 - 查找 ](https://github.com/CyC2018/InterviewNotes/blob/master/notes/%E7%AE%97%E6%B3%95.md#%E7%AC%AC%E4%B8%89%E7%AB%A0-%E6%9F%A5%E6%89%BE) 部分，对集合类源码的理解有很大帮助。
+至于 ConcurrentHashMap 的理解，需要有并发方面的知识，建议先阅读：[Java 并发](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Java%20%E5%B9%B6%E5%8F%91.md)
-源码下载：[OpenJDK 1.7](http://download.java.net/openjdk/jdk7)
+以下源码从 JDK 1.8 提取而来，下载地址：[JDK-Source-Code](https://github.com/CyC2018/JDK-Source-Code)。
-## 1. ArraList
+## ArrayList
[ArraList.java](https://github.com/CyC2018/JDK-Source-Code/tree/master/src/ArrayList.java)
+### 1. 概览
+
实现了 RandomAccess 接口，因此支持随机访问，这是理所当然的，因为 ArrayList 是基于数组实现的。
```java
public class ArrayList extends AbstractList
- implements List, RandomAccess, Cloneable, java.io.Serializable
+ implements List, RandomAccess, Cloneable, java.io.Serializable
```
-基于数组实现，保存元素的数组使用 transient 修饰，这是因为该数组不一定所有位置都占满元素，因此也就没必要全部都进行序列化。需要重写 writeObject() 和 readObject()。
+基于数组实现，保存元素的数组使用 transient 修饰，该关键字声明数组默认不会被序列化。ArrayList 具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。ArrayList 重写了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。
```java
-private transient Object[] elementData;
+transient Object[] elementData; // non-private to simplify nested class access
```
-数组的默认大小为 10
+数组的默认大小为 10。
```java
-public ArrayList(int initialCapacity) {
- super();
- if (initialCapacity < 0)
- throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
- this.elementData = new Object[initialCapacity];
-}
-
-public ArrayList() {
- this(10);
-}
+private static final int DEFAULT_CAPACITY = 10;
```
-删除元素时调用 System.arraycopy() 对元素进行复制，因此删除操作成本很高，最好在创建时就指定大概的容量大小，减少复制操作的执行次数。
+删除元素时需要调用 System.arraycopy() 对元素进行复制，因此删除操作成本很高。
```java
public E remove(int index) {
@@ -145,33 +146,23 @@ public E remove(int index) {
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
- elementData[--size] = null; // Let gc do its work
+ elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
```
-添加元素时使用 ensureCapacity() 方法来保证容量足够，如果不够时，需要进行扩容，使得新容量为旧容量的 1.5 倍。
-
-modCount 用来记录 ArrayList 结构发生变化的次数，因为每次在进行 add() 和 addAll() 时都需要调用 ensureCapacity()，因此直接在 ensureCapacity() 中对 modCount 进行修改。
-
-结构发生变化：添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。
+添加元素时使用 ensureCapacity() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，使得新容量为旧容量的 1.5 倍（oldCapacity + (oldCapacity >> 1))。扩容操作需要把原数组整个复制到新数组中，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。
```java
-public void ensureCapacity(int minCapacity) {
- if (minCapacity > 0)
- ensureCapacityInternal(minCapacity);
-}
-
-private void ensureCapacityInternal(int minCapacity) {
+private void ensureExplicitCapacity(int minCapacity) {
modCount++;
+
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
-private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
-
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
@@ -183,16 +174,12 @@ private void grow(int minCapacity) {
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
-
-private static int hugeCapacity(int minCapacity) {
- if (minCapacity < 0) // overflow
- throw new OutOfMemoryError();
- return (minCapacity > MAX_ARRAY_SIZE) ?
- Integer.MAX_VALUE :
- MAX_ARRAY_SIZE;
-}
```
+### 2. Fail-Fast
+
+modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。
+
在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。
```java
@@ -202,56 +189,146 @@ private void writeObject(java.io.ObjectOutputStream s)
int expectedModCount = modCount;
s.defaultWriteObject();
- // Write out array length
- s.writeInt(elementData.length);
+ // Write out size as capacity for behavioural compatibility with clone()
+ s.writeInt(size);
// Write out all elements in the proper order.
- for (int i=0; i()); 返回一个线程安全的 ArrayList，也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类；
+为了获得线程安全的 ArrayList，可以调用 Collections.synchronizedList(new ArrayList<>()); 返回一个线程安全的 ArrayList，也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类；
-**和 LinkedList 的区别**
+### 4. 和 LinkedList 的区别
-1. ArrayList 基于动态数组实现，LinkedList 基于双向循环链表实现；
-2. ArrayList 支持随机访问，LinkedList 不支持；
-3. LinkedList 在任意位置添加删除元素更快。
+- ArrayList 基于动态数组实现，LinkedList 基于双向循环链表实现；
+- ArrayList 支持随机访问，LinkedList 不支持；
+- LinkedList 在任意位置添加删除元素更快。
-## 2. Vector 与 Stack
+## Vector
[Vector.java](https://github.com/CyC2018/JDK-Source-Code/tree/master/src/Vector.java)
-## 3. LinkedList
+## LinkedList
[LinkedList.java](https://github.com/CyC2018/JDK-Source-Code/tree/master/src/LinkedList.java)
-## 4. TreeMap
+## TreeMap
[TreeMap.java](https://github.com/CyC2018/JDK-Source-Code/tree/master/src/TreeMap.java)
-## 5. HashMap
+## HashMap
[HashMap.java](https://github.com/CyC2018/JDK-Source-Code/tree/master/src/HashMap.java)
-使用拉链法来解决冲突。
+### 1. 存储结构
-默认容量 capacity 为 16，需要注意的是容量必须保证为 2 的次方。容量就是 Entry[] table 数组的长度，size 是数组的实际使用量。
+使用拉链法来解决冲突，内部包含了一个 Entry 类型的数组 table，数组中的每个位置被当成一个桶。
-threshold 规定了一个 size 的临界值，size 必须小于 threshold，如果大于等于，就必须进行扩容操作。
+```java
+transient Entry[] table;
+```
-threshold = capacity * load_factor，其中 load_factor 为 table 数组能够使用的比例，load_factor 过大会导致聚簇的出现，从而影响查询和插入的效率，详见算法笔记。
+其中，Entry 就是存储数据的键值对，它包含了四个字段。从 next 字段我们可以看出 Entry 是一个链表，即每个桶会存放一个链表。
+
+ implements Map.Entry {
+ final int hash;
+ final K key;
+ V value;
+ Node next;
+
+ Node(int hash, K key, V value, Node next) {
+ this.hash = hash;
+ this.key = key;
+ this.value = value;
+ this.next = next;
+ }
+
+ public final K getKey() { return key; }
+ public final V getValue() { return value; }
+ public final String toString() { return key + "=" + value; }
+
+ public final int hashCode() {
+ return Objects.hashCode(key) ^ Objects.hashCode(value);
+ }
+
+ public final V setValue(V newValue) {
+ V oldValue = value;
+ value = newValue;
+ return oldValue;
+ }
+
+ public final boolean equals(Object o) {
+ if (o == this)
+ return true;
+ if (o instanceof Map.Entry) {
+ Map.Entry e = (Map.Entry)o;
+ if (Objects.equals(key, e.getKey()) &&
+ Objects.equals(value, e.getValue()))
+ return true;
+ }
+ return false;
+ }
+}
+```
+
+### 2. 拉链法的工作原理
+
+```java
+HashMap map = new HashMap<>();
+map.put("K1", "V1");
+map.put("K2", "V2");
+map.put("K3", "V3");
+```
+
+- 新建一个 HashMap，默认大小为 16；
+- 插入 <K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3。
+- 插入 <K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6。
+- 插入 <K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 <K2,V2> 后面。
+
+ implements Map.Entry {
- final K key;
- V value;
- Entry next;
- final int hash;
-}
-```
-
-get() 操作需要分成两种情况，key 为 null 和 不为 null，从中可以看出 HashMap 允许插入 null 作为键。
-
-```java
-public V get(Object key) {
- if (key == null)
- return getForNullKey();
- int hash = hash(key.hashCode());
- for (Entry e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
- Object k;
- if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
- return e.value;
+void resize(int newCapacity) {
+ Entry[] oldTable = table;
+ int oldCapacity = oldTable.length;
+ if (oldCapacity == MAXIMUM_CAPACITY) {
+ threshold = Integer.MAX_VALUE;
+ return;
}
- return null;
+
+ Entry[] newTable = new Entry[newCapacity];
+ transfer(newTable);
+ table = newTable;
+ threshold = (int)(newCapacity * loadFactor);
}
-```
-put() 操作也需要根据 key 是否为 null 做不同的处理，需要注意的是如果本来没有 key 为 null 的键值对，新插入一个 key 为 null 的键值对时默认是放在数组的 0 位置，这是因为 null 不能计算 hash 值，也就无法知道应该放在哪个链表上。
-
-```java
-public V put(K key, V value) {
- if (key == null)
- return putForNullKey(value);
- int hash = hash(key.hashCode());
- int i = indexFor(hash, table.length);
- for (Entry e = table[i]; e != null; e = e.next) {
- Object k;
- if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
- V oldValue = e.value;
- e.value = value;
- e.recordAccess(this);
- return oldValue;
+void transfer(Entry[] newTable) {
+ Entry[] src = table;
+ int newCapacity = newTable.length;
+ for (int j = 0; j < src.length; j++) {
+ Entry e = src[j];
+ if (e != null) {
+ src[j] = null;
+ do {
+ Entry next = e.next;
+ int i = indexFor(e.hash, newCapacity);
+ e.next = newTable[i];
+ newTable[i] = e;
+ e = next;
+ } while (e != null);
}
}
-
- modCount++;
- addEntry(hash, key, value, i);
- return null;
}
```
+### 5. 确定桶下标
+
+很多操作都需要先确定一个键值对所在的桶下标，需要分三步进行。
+
+（一）hashCode()
+
+调用 Key 的 hashCode() 方法得到 hashCode。
+
```java
-private V putForNullKey(V value) {
- for (Entry e = table[0]; e != null; e = e.next) {
- if (e.key == null) {
- V oldValue = e.value;
- e.value = value;
- e.recordAccess(this);
- return oldValue;
- }
- }
- modCount++;
- addEntry(0, null, value, 0);
- return null;
+public final int hashCode() {
+ return Objects.hashCode(key) ^ Objects.hashCode(value);
}
```
-## 6. LinkedHashMap
+（二）高位运算
+
+将 hashCode 的高 16 位和低 16 位进行异或操作，使得在数组比较小时，也能保证高低位都参与到了哈希计算中。
+
+```java
+static final int hash(Object key) {
+ int h;
+ return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
+}
+```
+
+（三）除留余数法
+
+令 x = 1<<4，即 x 为 2 的 4 次方，它具有以下性质：
+
+```
+x : 00010000
+x-1 : 00001111
+```
+
+令一个数 y 与 x-1 做与运算，可以去除 y 位级表示的第 4 位及以上数：
+
+```
+y : 10110010
+x-1 : 00001111
+y&(x-1) : 00000010
+```
+
+这个性质和 y 对 x 取模效果是一样的：
+
+```
+x : 00010000
+y : 10110010
+y%x : 00000010
+```
+
+我们知道，位运算的代价比求模运算小的多，因此在进行这种计算时能用位运算的话能带来更高的性能。
+
+拉链法需要使用除留余数法来得到桶下标，也就是需要进行以下计算：hash%capacity，如果能保证 capacity 为 2 的幂次方，那么就可以将这个操作转换位位运算。
+
+以下操作在 Java 8 中没有，但是原理上相同。
+
+```java
+static int indexFor(int h, int length) {
+ return h & (length-1);
+}
+```
+
+### 6. 扩容-重新计算桶下标
+
+在进行扩容时，需要把 Node 重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作。
+
+假设原数组长度 capacity 为 8，扩容之后 new capacity 为 16：
+
+```html
+capacity : 00010000
+new capacity : 00100000
+```
+
+对于一个 Key，它的 hashCode 如果在第 6 位上为 0，那么除留余数得到的结果和之前一样；如果为 1，那么得到的结果为原来的结果 + 8。
+
+### 7. 扩容-计算数组容量
+
+先考虑如何求一个数的补码，对于 10010000，它的掩码为 11111111，可以使用以下方法得到：
+
+```
+mask |= mask >> 1 11011000
+mask |= mask >> 2 11111100
+mask |= mask >> 4 11111111
+```
+
+如果最后令 mask+1，得到就是大于原始数字的最小的 2 次方。
+
+以下是 HashMap 中计算一个大小所需要的数组容量的代码：
+
+```java
+static final int tableSizeFor(int cap) {
+ int n = cap - 1;
+ n |= n >>> 1;
+ n |= n >>> 2;
+ n |= n >>> 4;
+ n |= n >>> 8;
+ n |= n >>> 16;
+ return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
+}
+```
+
+### 7. null 值
+
+HashMap 允许有一个 Node 的 Key 为 null，该 Node 一定会放在第 0 个桶的位置，因为这个 Key 无法计算 hashCode()，因此只能规定一个桶让它存放。
+
+### 8. 与 HashTable 的区别
+
+- HashTable 是同步的，它使用了 synchronized 来进行同步。它也是线程安全的，多个线程可以共享同一个 HashTable。HashMap 不是同步的，但是可以使用 ConcurrentHashMap，它是 HashTable 的替代，而且比 HashTable 可扩展性更好。
+- HashMap 可以插入键为 null 的 Entry。
+- HashMap 的迭代器是 fail-fast 迭代器，而 Hashtable 的 enumerator 迭代器不是 fail-fast 的。
+- 由于 Hashtable 是线程安全的也是 synchronized，所以在单线程环境下它比 HashMap 要慢。
+- HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
+
+## LinkedHashMap
[LinkedHashMap.java](https://github.com/CyC2018/JDK-Source-Code/tree/master/src/HashMap.java)
-## 7. ConcurrentHashMap
+## ConcurrentHashMap - JDK 1.7
-[ConcurrentHashMap.java](https://github.com/CyC2018/JDK-Source-Code/tree/master/src/HashMap.java)
+[ConcurrentHashMap.java](https://github.com/CyC2018/JDK-Source-Code/blob/master/src/1.7/ConcurrentHashMap.java)
-[ 探索 ConcurrentHashMap 高并发性的实现机制 ](https://www.ibm.com/developerworks/cn/java/java-lo-concurrenthashmap/)
+ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了了分段锁，每个分段锁维护着几个桶，多个线程可以同时访问不同分段锁上的桶。
+
+相比于 HashTable 和用同步包装器包装的 HashMap（Collections.synchronizedMap(new HashMap())），ConcurrentHashMap 拥有更高的并发性。在 HashTable 和由同步包装器包装的 HashMap 中，使用一个全局的锁来同步不同线程间的并发访问。同一时间点，只能有一个线程持有锁，也就是说在同一时间点，只能有一个线程能访问容器。这虽然保证多线程间的安全并发访问，但同时也导致对容器的访问变成串行化的了。
+
+### 1. 存储结构
+
+和 HashMap 类似。
+
+```java
+static final class HashEntry {
+ final int hash;
+ final K key;
+ volatile V value;
+ volatile HashEntry next;
+}
+```
+
+继承自 ReentrantLock，每个 Segment 维护着多个 HashEntry。
+
+```java
+static final class Segment extends ReentrantLock implements Serializable {
+
+ private static final long serialVersionUID = 2249069246763182397L;
+
+ static final int MAX_SCAN_RETRIES =
+ Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
+
+ transient volatile HashEntry[] table;
+
+ transient int count;
+
+ transient int modCount;
+
+ transient int threshold;
+
+ final float loadFactor;
+}
+```
+
+```java
+final Segment[] segments;
+```
+
+默认的并发级别为 16，也就是说默认创建 16 个 Segment。
+
+```java
+static final int DEFAULT_CONCURRENCY_LEVEL = 16;
+```
+
+ [] tab = table;
+ int index = (tab.length - 1) & hash;
+ HashEntry e = entryAt(tab, index);
+ HashEntry pred = null;
+ while (e != null) {
+ K k;
+ HashEntry next = e.next;
+ if ((k = e.key) == key ||
+ (e.hash == hash && key.equals(k))) {
+ V v = e.value;
+ if (value == null || value == v || value.equals(v)) {
+ if (pred == null)
+ setEntryAt(tab, index, next);
+ else
+ pred.setNext(next);
+ ++modCount;
+ --count;
+ oldValue = v;
+ }
+ break;
+ }
+ pred = e;
+ e = next;
+ }
+ } finally {
+ unlock();
+ }
+ return oldValue;
+}
+```
+
+在以下链表中删除 C 节点，C 节点之后的所有节点都原样保留，C 节点之前的所有节点都被克隆到新的链表中，并且顺序被反转。可以注意到，在执行 remove 操作时，原始链表并没有被修改，也就是说，读线程不会受到执行 remove 操作的并发写线程的干扰。
+
+ {
+ final int hash;
+ final K key;
+ volatile V value;
+ volatile HashEntry next;
+}
+```
+
+由于内存可见性问题，未正确同步的情况下，写线程写入的值可能并不为后续的读线程可见。
+
+下面以写线程 M 和读线程 N 来说明 ConcurrentHashMap 如何协调读 / 写线程间的内存可见性问题。
+
+ e = getFirst(hash);
+ while(e != null) {
+ if(e.hash == hash && key.equals(e.key)) {
+ V v = e.value;
+ if(v != null)
+ return v;
+ // 如果读到 value 域为 null，说明发生了重排序，加锁后重新读取
+ return readValueUnderLock(e);
+ }
+ e = e.next;
+ }
+ }
+ return null;
+}
+```
+
+在 ConcurrentHashMap 中，所有执行写操作的方法（put, remove, clear），在对链表做结构性修改之后，在退出写方法前都会去写这个 count 变量。所有未加锁的读操作（get, contains, containsKey）在读方法中，都会首先去读取这个 count 变量。
+
+根据 Java 内存模型，对 同一个 volatile 变量的写 / 读操作可以确保：写线程写入的值，能够被之后未加锁的读线程 “看到”。
+
+这个特性和前面介绍的 HashEntry 对象的不变性相结合，使得在 ConcurrentHashMap 中，读线程在读取散列表时，基本不需要加锁就能成功获得需要的值。这两个特性相配合，不仅减少了请求同一个锁的频率（读操作一般不需要加锁就能够成功获得值），也减少了持有同一个锁的时间（只有读到 value 域的值为 null 时 ，读线程才需要加锁后重读）。
+
+### 4. 小结
+
+ConcurrentHashMap 的高并发性主要来自于三个方面：
+
+- 用分离锁实现多个线程间的更深层次的共享访问。
+- 用 HashEntery 对象的不变性来降低执行读操作的线程在遍历链表期间对加锁的需求。
+- 通过对同一个 Volatile 变量的写 / 读访问，协调不同线程间读 / 写操作的内存可见性。
+
+## ConcurrentHashMap - JDK 1.8
+
+[ConcurrentHashMap.java](https://github.com/CyC2018/JDK-Source-Code/blob/master/src/ConcurrentHashMap.java)
+
+JDK 1.7 分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock。
+
+JDK 1.8 的实现不是用了 Segment，Segment 属于重入锁 ReentrantLock。而是使用了内置锁 synchronized，主要是出于以下考虑：
+
+1. synchronized 的锁粒度更低；
+2. synchronized 优化空间更大；
+3. 在大量数据操作的情况下，ReentrantLock 会开销更多的内存。
+
+并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。
# 参考资料
-- Java 编程思想
+- Eckel B. Java 编程思想 [M]. 机械工业出版社, 2002.
+- [Java Collection Framework](https://www.w3resource.com/java-tutorial/java-collections.php)
+- [Iterator 模式](https://openhome.cc/Gossip/DesignPattern/IteratorPattern.htm)
+- [Java 8 系列之重新认识 HashMap](https://tech.meituan.com/java-hashmap.html)
+- [What is difference between HashMap and Hashtable in Java?](http://javarevisited.blogspot.hk/2010/10/difference-between-hashmap-and.html)
+- [Java 集合之 HashMap](http://www.zhangchangle.com/2018/02/07/Java%E9%9B%86%E5%90%88%E4%B9%8BHashMap/)
+- [The principle of ConcurrentHashMap analysis](http://www.programering.com/a/MDO3QDNwATM.html)
+- [探索 ConcurrentHashMap 高并发性的实现机制](https://www.ibm.com/developerworks/cn/java/java-lo-concurrenthashmap/)
+- [HashMap 相关面试题及其解答](https://www.jianshu.com/p/75adf47958a7)
+- [Java 集合细节（二）：asList 的缺陷](http://wiki.jikexueyuan.com/project/java-enhancement/java-thirtysix.html)
+
diff --git a/notes/Java 并发.md b/notes/Java 并发.md
index 7b13cff7..a1131c9c 100644
--- a/notes/Java 并发.md
+++ b/notes/Java 并发.md
@@ -1,451 +1,1658 @@
-* [使用线程](#使用线程)
- * [1. 实现 Runnable 接口](#1-实现-runnable-接口)
- * [2. 实现 Callable 接口](#2-实现-callable-接口)
- * [3. 继承 Tread 类](#3-继承-tread-类)
- * [4. 实现接口 vs 继承 Thread](#4-实现接口-vs-继承-thread)
-* [Executor](#executor)
-* [基础线程机制](#基础线程机制)
- * [1. sleep()](#1-sleep)
- * [2. yield()](#2-yield)
- * [3. join()](#3-join)
- * [4. deamon](#4-deamon)
-* [线程之间的协作](#线程之间的协作)
- * [1. 线程通信](#1-线程通信)
- * [2. 线程同步](#2-线程同步)
- * [2.1 synchronized](#21-synchronized)
- * [2.2 Lock](#22-lock)
- * [2.3 BlockingQueue](#23-blockingqueue)
-* [线程状态](#线程状态)
-* [结束线程](#结束线程)
- * [1. 阻塞](#1-阻塞)
- * [2. 中断](#2-中断)
-* [原子性](#原子性)
-* [volatile](#volatile)
- * [1. 内存可见性](#1-内存可见性)
- * [2. 禁止指令重排](#2-禁止指令重排)
-* [多线程开发良好的实践](#多线程开发良好的实践)
-* [未完待续](#未完待续)
+* [一、线程状态转换](#一线程状态转换)
+ * [新建（New）](#新建new)
+ * [可运行（Runnable）](#可运行runnable)
+ * [阻塞（Blocking）](#阻塞blocking)
+ * [无限期等待（Waiting）](#无限期等待waiting)
+ * [限期等待（Timed Waiting）](#限期等待timed-waiting)
+ * [死亡（Terminated）](#死亡terminated)
+* [二、使用线程](#二使用线程)
+ * [实现 Runnable 接口](#实现-runnable-接口)
+ * [实现 Callable 接口](#实现-callable-接口)
+ * [继承 Thread 类](#继承-thread-类)
+ * [实现接口 VS 继承 Thread](#实现接口-vs-继承-thread)
+* [三、基础线程机制](#三基础线程机制)
+ * [Executor](#executor)
+ * [Daemon](#daemon)
+ * [sleep()](#sleep)
+ * [yield()](#yield)
+* [四、中断](#四中断)
+ * [InterruptedException](#interruptedexception)
+ * [interrupted()](#interrupted)
+ * [Executor 的中断操作](#executor-的中断操作)
+* [五、互斥同步](#五互斥同步)
+ * [synchronized](#synchronized)
+ * [ReentrantLock](#reentrantlock)
+ * [synchronized 和 ReentrantLock 比较](#synchronized-和-reentrantlock-比较)
+* [六、线程之间的协作](#六线程之间的协作)
+ * [join()](#join)
+ * [wait() notify() notifyAll()](#wait-notify-notifyall)
+ * [await() signal() signalAll()](#await-signal-signalall)
+* [七、J.U.C - AQS](#七juc---aqs)
+ * [CountdownLatch](#countdownlatch)
+ * [CyclicBarrier](#cyclicbarrier)
+ * [Semaphore](#semaphore)
+* [八、J.U.C - 其它组件](#八juc---其它组件)
+ * [FutureTask](#futuretask)
+ * [BlockingQueue](#blockingqueue)
+ * [ForkJoin](#forkjoin)
+* [九、线程不安全示例](#九线程不安全示例)
+* [十、Java 内存模型](#十java-内存模型)
+ * [主内存与工作内存](#主内存与工作内存)
+ * [内存间交互操作](#内存间交互操作)
+ * [内存模型三大特性](#内存模型三大特性)
+ * [先行发生原则](#先行发生原则)
+* [十一、线程安全](#十一线程安全)
+ * [线程安全分类](#线程安全分类)
+ * [线程安全的实现方法](#线程安全的实现方法)
+* [十二、锁优化](#十二锁优化)
+ * [自旋锁与自适应自旋](#自旋锁与自适应自旋)
+ * [锁消除](#锁消除)
+ * [锁粗化](#锁粗化)
+ * [轻量级锁](#轻量级锁)
+ * [偏向锁](#偏向锁)
+* [十三、多线程开发良好的实践](#十三多线程开发良好的实践)
* [参考资料](#参考资料)
-# 使用线程
+# 一、线程状态转换
+
+ {
+public class MyCallable implements Callable {
public Integer call() {
- // ...
- }
- public static void main(String[] args) {
- MyCallable mc = new MyCallable();
- FutureTask ft = new FutureTask<>(mc);
- Thread thread = new Thread(ft);
- thread.start();
- System.out.println(ft.get());
+ return 123;
}
}
```
-## 3. 继承 Tread 类
+```java
+public static void main(String[] args) throws ExecutionException, InterruptedException {
+ MyCallable mc = new MyCallable();
+ FutureTask ft = new FutureTask<>(mc);
+ Thread thread = new Thread(ft);
+ thread.start();
+ System.out.println(ft.get());
+}
+```
+
+## 继承 Thread 类
同样也是需要实现 run() 方法，并且最后也是调用 start() 方法来启动线程。
```java
-class MyThread extends Thread {
+public class MyThread extends Thread {
public void run() {
// ...
}
- public static void main(String[] args) {
- MyThread mt = new MyThread();
- mt.start();
- }
}
```
-## 4. 实现接口 vs 继承 Thread
+```java
+public static void main(String[] args) {
+ MyThread mt = new MyThread();
+ mt.start();
+}
+```
+
+## 实现接口 VS 继承 Thread
实现接口会更好一些，因为：
-1. Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口。
-2. 类可能只要求可执行即可，继承整个 Thread 类开销会过大。
+1. Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
+2. 类可能只要求可执行就行，继承整个 Thread 类开销会过大。
-# Executor
+# 三、基础线程机制
+
+## Executor
Executor 管理多个异步任务的执行，而无需程序员显示地管理线程的生命周期。
-主要有三种 Excutor：
+主要有三种 Executor：
1. CachedTreadPool：一个任务创建一个线程；
2. FixedThreadPool：所有任务只能使用固定大小的线程；
3. SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
```java
-ExecutorService exec = Executors.newCachedThreadPool();
-for(int i = 0; i < 5; i++) {
- exec.execute(new MyRunnable());
+public static void main(String[] args) {
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ for (int i = 0; i < 5; i++) {
+ executorService.execute(new MyRunnable());
+ }
+ executorService.shutdown();
}
```
-# 基础线程机制
+## Daemon
-## 1. sleep()
+守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分。
-**Thread.sleep(millisec)** 方法会休眠当前正在执行的线程，millisec 单位为毫秒。也可以使用 TimeUnit.TILLISECONDS.sleep(millisec)。
+当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。
-sleep() 可能会抛出 InterruptedException。因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
+main() 属于非守护线程。
+
+使用 setDaemon() 方法将一个线程设置为守护线程。
+
+```java
+public static void main(String[] args) {
+ Thread thread = new Thread(new MyRunnable());
+ thread.setDaemon(true);
+}
+```
+
+## sleep()
+
+Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
+
+sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
```java
public void run() {
try {
- // ...
- Thread.sleep(1000);
- // ...
- } catch(InterruptedException e) {
- System.err.println(e);
+ Thread.sleep(3000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
}
}
```
-## 2. yield()
+## yield()
-对静态方法 **Thread.yield()** 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。
+对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。
```java
public void run() {
- // ...
Thread.yield();
}
```
-## 3. join()
+# 四、中断
-在线程中调用另一个线程的 **join()** 方法，会将当前线程挂起，直到目标线程结束。
+一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。
-可以加一个超时参数。
+## InterruptedException
-## 4. deamon
+通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
-后台线程（ **deamon** ）是程序运行时在后台提供服务的线程，并不属于程序中不可或缺的部分。
-
-当所有非后台线程结束时，程序也就终止，同时会杀死所有后台线程。
-
-main() 属于非后台线程。
-
-使用 setDaemon() 方法将一个线程设置为后台线程。
-
-# 线程之间的协作
-
-- **线程通信** ：保证线程以一定的顺序执行；
-- **线程同步** ：保证线程对临界资源的互斥访问。
-
-线程通信往往是基于线程同步的基础上完成的，因此很多线程通信问题也是线程同步问题。
-
-## 1. 线程通信
-
-**wait()、notify() 和 notifyAll()** 三者实现了线程之间的通信。
-
-wait() 会在等待时将线程挂起，而不是忙等待，并且只有在 notify() 或者 notifyAll() 到达时才唤醒。
-
-sleep() 和 yield() 并没有释放锁，但是 wait() 会释放锁。实际上，只有在同步控制方法或同步控制块里才能调用 wait() 、notify() 和 notifyAll()。
-
-这几个方法属于基类的一部分，而不属于 Thread。
+对于以下代码，在 Main 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。
```java
-private boolean flag = false;
-
-public synchronized void after() {
- while(flag == false) {
- wait();
- // ...
- }
-}
-
-public synchronized void before() {
- flag = true;
- notifyAll();
-}
-```
-
-**wait() 和 sleep() 的区别**
-
-1. wait() 是 Object 类的方法，而 sleep() 是 Thread 的静态方法；
-2. wait() 会放弃锁，而 sleep() 不会。
-
-## 2. 线程同步
-
-给定一个进程内的所有线程，都共享同一存储空间，这样有好处又有坏处。这些线程就可以共享数据，非常有用。不过，在两个线程同时修改某一资源时，这也会造成一些问题。Java 提供了同步机制，以控制对共享资源的互斥访问。
-
-### 2.1 synchronized
-
-**同步一个方法**
-
-使多个线程不能同时访问该方法。
-
-```java
-public synchronized void func(String name) {
- // ...
-}
-```
-
-**同步一个代码块**
-
-```java
-public void func(String name) {
- synchronized(this) {
- // ...
- }
-}
-```
-
-### 2.2 Lock
-
-若要实现更细粒度的控制，我们可以使用锁（lock）。
-
-```java
-private Lock lock;
-public int func(int value) {
- lock.lock();
- // ...
- lock.unlock();
-}
-```
-
-### 2.3 BlockingQueue
-
-java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
-
-- **FIFO 队列** ：LinkedBlockingQueue、ArrayListBlockingQueue（固定长度）
-- **优先级队列** ：PriorityBlockingQueue
-
-提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将一直阻塞到队列中有内容，如果队列为满 put() 将阻塞到队列有空闲位置。它们响应中断，当收到中断请求的时候会抛出 InterruptedException，从而提前结束阻塞状态。
-
-**使用 BlockingQueue 实现生产者消费者问题**
-
-```java
-// 生产者
-import java.util.concurrent.BlockingQueue;
-
-public class Producer implements Runnable {
- private BlockingQueue queue;
-
- public Producer(BlockingQueue queue) {
- this.queue = queue;
+public class InterruptExample {
+ public static void main(String[] args) throws InterruptedException {
+ Thread thread1 = new MyThread1();
+ thread1.start();
+ thread1.interrupt();
+ System.out.println("Main run");
}
- @Override
- public void run() {
- System.out.println(Thread.currentThread().getName() + " is making product...");
- String product = "made by " + Thread.currentThread().getName();
- try {
- queue.put(product);
- } catch (InterruptedException e) {
- e.printStackTrace();
+ private static class MyThread1 extends Thread {
+ @Override
+ public void run() {
+ try {
+ Thread.sleep(2000);
+ System.out.println("Thread run");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
}
}
}
+
```
-```java
-// 消费者
-import java.util.concurrent.BlockingQueue;
-
-public class Consumer implements Runnable{
- private BlockingQueue queue;
-
- public Consumer(BlockingQueue queue) {
- this.queue = queue;
- }
-
- @Override
- public void run() {
- try {
- String product = queue.take();
- System.out.println(Thread.currentThread().getName() + " is consuming product " + product + "...");
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
-}
+```html
+Main run
+java.lang.InterruptedException: sleep interrupted
+ at java.lang.Thread.sleep(Native Method)
+ at InterruptExample.lambda$main$0(InterruptExample.java:5)
+ at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
+ at java.lang.Thread.run(Thread.java:745)
```
-```java
-// 客户端
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
+## interrupted()
-public class Client {
- public static void main(String[] args) {
- BlockingQueue queue = new LinkedBlockingQueue<>(5);
- for (int i = 0; i < 2; i++) {
- new Thread(new Consumer(queue), "Producer" + i).start();
- }
- for (int i = 0; i < 5; i++) {
- // 只有两个 Product，因此只能消费两个，其它三个消费者被阻塞
- new Thread(new Producer(queue), "Consumer" + i).start();
- }
- for (int i = 2; i < 5; i++) {
- new Thread(new Consumer(queue), "Producer" + i).start();
+如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。
+
+但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
+
+```java
+public class InterruptExample {
+ public static void main(String[] args) throws InterruptedException {
+ Thread thread2 = new MyThread2();
+ thread2.start();
+ thread2.interrupt();
+ }
+
+ private static class MyThread2 extends Thread {
+ @Override
+ public void run() {
+ while (!interrupted()) {
+ // ..
+ }
+ System.out.println("Thread end");
}
}
}
```
```html
-// 运行结果
-Consumer0 is making product...
-Producer0 is consuming product made by Consumer0...
-Consumer1 is making product...
-Producer1 is consuming product made by Consumer1...
-Consumer2 is making product...
-Consumer3 is making product...
-Consumer4 is making product...
-Producer2 is consuming product made by Consumer2...
-Producer3 is consuming product made by Consumer3...
-Producer4 is consuming product made by Consumer4...
+Thread end
```
-# 线程状态
+## Executor 的中断操作
-JDK 从 1.5 开始在 Thread 类中增添了 State 枚举，包含以下六种状态：
+调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。
-1. **NEW** （新建）
-2. **RUNNABLE** （当线程正在运行或者已经就绪正等待 CPU 时间片）
-3. **BLOCKED** （阻塞，线程在等待获取对象同步锁）
-4. **Waiting** （调用不带超时的 wait() 或 join()）
-5. **TIMED_WAITING** （调用 sleep()、带超时的 wait() 或者 join()）
-6. **TERMINATED** （死亡）
-
- 进行封装。FutureTask 实现了 RunnableFuture 接口，该接口继承自 Runnable 和 Future 接口，这使得 FutureTask 既可以当做一个任务执行，也可以有返回值。
+
+```java
+public class FutureTask implements RunnableFuture
+```
+
+```java
+public interface RunnableFuture extends Runnable, Future
+```
+
+当一个计算任务需要执行很长时间，那么就可以用 FutureTask 来封装这个任务，用一个线程去执行该任务，然后其它线程继续执行其它任务。当需要该任务的计算结果时，再通过 FutureTask 的 get() 方法获取。
+
+```java
+public class FutureTaskExample {
+ public static void main(String[] args) throws ExecutionException, InterruptedException {
+ FutureTask futureTask = new FutureTask(new Callable() {
+ @Override
+ public Integer call() throws Exception {
+ int result = 0;
+ for (int i = 0; i < 100; i++) {
+ Thread.sleep(10);
+ result += i;
+ }
+ return result;
+ }
+ });
+
+ Thread computeThread = new Thread(futureTask);
+ computeThread.start();
+
+ Thread otherThread = new Thread(() -> {
+ System.out.println("other task is running...");
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ });
+ otherThread.start();
+ System.out.println(futureTask.get());
+ }
+}
+```
+
+```html
+other task is running...
+4950
+```
+
+## BlockingQueue
+
+java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
+
+- **FIFO 队列** ：LinkedBlockingQueue、ArrayListBlockingQueue（固定长度）
+- **优先级队列** ：PriorityBlockingQueue
+
+提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，指到队列有空闲位置。
+
+**使用 BlockingQueue 实现生产者消费者问题**
+
+```java
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+
+public class ProducerConsumer {
+
+ private static BlockingQueue queue = new ArrayBlockingQueue<>(5);
+
+ private static class Producer extends Thread {
+ @Override
+ public void run() {
+ try {
+ queue.put("product");
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.print("produce..");
+ }
+ }
+
+ private static class Consumer extends Thread {
+
+ @Override
+ public void run() {
+ try {
+ String product = queue.take();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.print("consume..");
+ }
+ }
+
+ public static void main(String[] args) {
+ for (int i = 0; i < 2; i++) {
+ Producer producer = new Producer();
+ producer.start();
+ }
+ for (int i = 0; i < 5; i++) {
+ Consumer consumer = new Consumer();
+ consumer.start();
+ }
+ for (int i = 0; i < 3; i++) {
+ Producer producer = new Producer();
+ producer.start();
+ }
+ }
+}
+```
+
+```html
+produce..produce..consume..consume..produce..consume..produce..consume..produce..consume..
+```
+
+## ForkJoin
+
+主要用于并行计算中，和 MapReduce 原理类似，都是把大的计算任务拆分成多个小任务并行计算。
+
+```java
+public class ForkJoinExample extends RecursiveTask {
+ private final int threhold = 5;
+ private int first;
+ private int last;
+
+ public ForkJoinExample(int first, int last) {
+ this.first = first;
+ this.last = last;
+ }
+
+ @Override
+ protected Integer compute() {
+ int result = 0;
+ if (last - first <= threhold) {
+ // 任务足够小则直接计算
+ for (int i = first; i <= last; i++) {
+ result += i;
+ }
+ } else {
+ // 拆分成小任务
+ int middle = first + (last - first) / 2;
+ ForkJoinExample leftTask = new ForkJoinExample(first, middle);
+ ForkJoinExample rightTask = new ForkJoinExample(middle + 1, last);
+ leftTask.fork();
+ rightTask.fork();
+ result = leftTask.join() + rightTask.join();
+ }
+ return result;
+ }
+}
+```
+
+```java
+public static void main(String[] args) throws ExecutionException, InterruptedException {
+ ForkJoinExample example = new ForkJoinExample(1, 10000);
+ ForkJoinPool forkJoinPool = new ForkJoinPool();
+ Future result = forkJoinPool.submit(example);
+ System.out.println(result.get());
+}
+```
+
+ForkJoin 使用 ForkJoinPool 来启动，它是一个特殊的线程池，线程数量取决于 CPU 核数。
+
+```java
+public class ForkJoinPool extends AbstractExecutorService
+```
+
+ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，Thread2 从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。
+
+ map = new HashMap<>();
+ Map unmodifiableMap = Collections.unmodifiableMap(map);
+ unmodifiableMap.put("a", 1);
+ }
+}
+```
+
+```html
+Exception in thread "main" java.lang.UnsupportedOperationException
+ at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)
+ at ImmutableExample.main(ImmutableExample.java:9)
+```
+
+Collections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都直接抛出异常。
+
+```java
+public V put(K key, V value) {
+ throw new UnsupportedOperationException();
+}
+```
+
+多线程环境下，应当尽量使对象称为不可变，来满足线程安全。
+
+### 2. 绝对线程安全
+
+不管运行时环境如何，调用者都不需要任何额外的同步措施。
+
+### 3. 相对线程安全
+
+相对的线程安全需要保证对这个对象单独的操作是线程安全的，在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。
+
+在 Java 语言中，大部分的线程安全类都属于这种类型，例如 Vector、HashTable、Collections 的 synchronizedCollection() 方法包装的集合等。
+
+对于下面的代码，如果删除元素的线程删除了一个元素，而获取元素的线程试图访问一个已经被删除的元素，那么就会抛出 ArrayIndexOutOfBoundsException。
+
+```java
+public class VectorUnsafeExample {
+ private static Vector vector = new Vector<>();
+
+ public static void main(String[] args) {
+ while (true) {
+ for (int i = 0; i < 100; i++) {
+ vector.add(i);
+ }
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> {
+ for (int i = 0; i < vector.size(); i++) {
+ vector.remove(i);
+ }
+ });
+ executorService.execute(() -> {
+ for (int i = 0; i < vector.size(); i++) {
+ vector.get(i);
+ }
+ });
+ executorService.shutdown();
+ }
+ }
+}
+```
+
+```html
+Exception in thread "Thread-159738" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 3
+ at java.util.Vector.remove(Vector.java:831)
+ at VectorUnsafeExample.lambda$main$0(VectorUnsafeExample.java:14)
+ at VectorUnsafeExample$$Lambda$1/713338599.run(Unknown Source)
+ at java.lang.Thread.run(Thread.java:745)
+```
+
+
+如果要保证上面的代码能正确执行下去，就需要对删除元素和获取元素的代码进行同步。
+
+```java
+executorService.execute(() -> {
+ synchronized (vector) {
+ for (int i = 0; i < vector.size(); i++) {
+ vector.remove(i);
+ }
+ }
+});
+executorService.execute(() -> {
+ synchronized (vector) {
+ for (int i = 0; i < vector.size(); i++) {
+ vector.get(i);
+ }
+ }
+});
+```
+
+### 4. 线程兼容
+
+线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API 中大部分的类都是属于线程兼容的，如与前面的 Vector 和 HashTable 相对应的集合类 ArrayList 和 HashMap 等。
+
+### 5. 线程对立
+
+线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。由于 Java 语言天生就具备多线程特性，线程对立这种排斥多线程的代码是很少出现的，而且通常都是有害的，应当尽量避免。
+
+## 线程安全的实现方法
+
+### 1. 互斥同步
+
+synchronized 和 ReentrantLock。
+
+### 2. 非阻塞同步
+
+互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步（Blocking Synchronization）。
+
+从处理问题的方式上说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施（例如加锁），那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。随着硬件指令集的发展，我们有了另外一个选择：基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采取其他的补偿措施（最常见的补偿措施就是不断地重试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步（Non-Blocking Synchronization）。
+
+乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。
+
+CAS 指令需要有 3 个操作数，分别是内存位置（在 Java 中可以简单理解为变量的内存地址，用 V 表示）、旧的预期值（用 A 表示）和新值（用 B 表示）。CAS 指令执行时，当且仅当 V 符合旧预期值 A 时，处理器用新值 B 更新 V 的值，否则它就不执行更新。但是无论是否更新了 V 的值，都会返回 V 的旧值，上述的处理过程是一个原子操作。
+
+J.U.C 包里面的整数原子类 AtomicInteger，其中的 compareAndSet() 和 getAndIncrement() 等方法都使用了 Unsafe 类的 CAS 操作。
+
+在下面的代码 1 中，使用了 AtomicInteger 执行了自增的操作。代码 2 是 incrementAndGet() 的源码，它调用了 unsafe 的 getAndAddInt() 。代码 3 是 getAndAddInt() 源码，var1 指示内存位置，var2 指示新值，var4 指示操作需要加的数值，这里为 1。在代码 3 的实现中，通过 getIntVolatile(var1, var2) 得到旧的预期值。通过调用 compareAndSwapInt() 来进行 CAS 比较，如果 var2=var5，那么就更新内存地址为 var1 的变量为 var5+var4。可以看到代码 3 是在一个循环中进行，发生冲突的做法是不断的进行重试。
+
+```java
+// 代码 1
+private AtomicInteger cnt = new AtomicInteger();
+
+public void add() {
+ cnt.incrementAndGet();
+}
+```
+
+```java
+// 代码 2
+public final int incrementAndGet() {
+ return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
+}
+```
+
+```java
+// 代码 3
+public final int getAndAddInt(Object var1, long var2, int var4) {
+ int var5;
+ do {
+ var5 = this.getIntVolatile(var1, var2);
+ } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
+
+ return var5;
+}
+```
+
+ABA ：如果一个变量 V 初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。J.U.C 包提供了一个带有标记的原子引用类“AtomicStampedReference”来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
+
+### 3. 无同步方案
+
+要保证线程安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。
+
+**（一）可重入代码（Reentrant Code）**
+
+这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入的代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。
+
+可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。我们可以通过一个简单的原则来判断代码是否具备可重入性：如果一个方法，它的返回结果是可以预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性的要求，当然也就是线程安全的。
+
+**（二）栈封闭**
+
+多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在栈中，属于线程私有的。
+
+```java
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class StackClosedExample {
+ public void add100() {
+ int cnt = 0;
+ for (int i = 0; i < 100; i++) {
+ cnt++;
+ }
+ System.out.println(cnt);
+ }
+
+ public static void main(String[] args) {
+ StackClosedExample example = new StackClosedExample();
+ ExecutorService executorService = Executors.newCachedThreadPool();
+ executorService.execute(() -> example.add100());
+ executorService.execute(() -> example.add100());
+ executorService.shutdown();
+ }
+}
+```
+
+```html
+100
+100
+```
+
+**（三）线程本地存储（Thread Local Storage）**
+
+如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
+
+符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完，其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
+
+可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。
+
+对于以下代码，thread1 中设置 threadLocal 为 1，而 thread2 设置 threadLocal 为 2。过了一段时间之后，thread1 读取 threadLocal 依然是 1，不受 thread2 的影响。
+
+```java
+public class ThreadLocalExample {
+ public static void main(String[] args) {
+ ThreadLocal threadLocal = new ThreadLocal();
+ Thread thread1 = new Thread(() -> {
+ threadLocal.set(1);
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ System.out.println(threadLocal.get());
+ threadLocal.remove();
+ });
+ Thread thread2 = new Thread(() -> {
+ threadLocal.set(2);
+ threadLocal.remove();
+ });
+ thread1.start();
+ thread2.start();
+ }
+}
+```
+
+```html
+1
+```
+
+为了理解 ThreadLocal，先看以下代码：
+
+```java
+public class ThreadLocalExample1 {
+ public static void main(String[] args) {
+ ThreadLocal threadLocal1 = new ThreadLocal();
+ ThreadLocal threadLocal2 = new ThreadLocal();
+ Thread thread1 = new Thread(() -> {
+ threadLocal1.set(1);
+ threadLocal2.set(1);
+ });
+ Thread thread2 = new Thread(() -> {
+ threadLocal1.set(2);
+ threadLocal2.set(2);
+ });
+ thread1.start();
+ thread2.start();
+ }
+}
+```
+
+它所对应的底层结构图为：
+
+ sf = new SoftReference(obj);
-obj = null;
-sf.get();
```
-sf 是对 obj 的一个软引用，通过 sf.get() 方法可以取到这个对象，当然，当这个对象被标记为需要回收的对象时，则返回 null；
-
-软引用主要用来实现类似缓存的功能，在内存足够的情况下直接通过软引用取值，无需从繁忙的真实来源查询数据，提升速度；当内存不足时，自动删除这部分缓存数据，从真正的来源查询这些数据。
-
-
-#### 1.3.3 弱引用
+**（三）弱引用**
只能生存到下一次垃圾收集发生之前，当垃圾收集器工作时，无论当前内存是否足够，都会被回收。
+使用 WeakReference 类来实现弱引用。
+
```java
Object obj = new Object();
WeakReference wf = new WeakReference(obj);
-obj = null;
-wf.get();
-wf.isEnQueued();
```
-#### 1.3.4 虚引用
+**（四）虚引用**
-又称为幽灵引用或者幻影引用，一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用取得一个对象实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。
+又称为幽灵引用或者幻影引用。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用取得一个对象实例。
+
+为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。
+
+使用 PhantomReference 来实现虚引用。
```java
Object obj = new Object();
PhantomReference pf = new PhantomReference(obj);
-obj=null;
-pf.get();
-pf.isEnQueued();
```
-### 1.3 方法区的回收
+### 4. 方法区的回收
-在方法区主要是对常量池的回收和对类的卸载。
+因为方法区主要存放永久代对象，而永久代对象的回收率比新生代差很多，因此在方法区上进行回收性价比不高。
-常量池的回收和堆中对象回收类似。
+主要是对常量池的回收和对类的卸载。
类的卸载条件很多，需要满足以下三个条件，并且满足了也不一定会被卸载：
@@ -215,61 +205,59 @@ pf.isEnQueued();
在大量使用反射、动态代理、CGLib 等 ByteCode 框架、动态生成 JSP 以及 OSGo 这类频繁自定义 ClassLoader 的场景都需要虚拟机具备类卸载功能，以保证不会出现内存溢出。
-### 1.4 finalize()
-
-当一个对象可被回收时，如果该对象有必要执行 finalize() 方法，那么就有可能可能通过在该方法中让对象重新被引用，从而实现自救。
+### 5. finalize()
finalize() 类似 C++ 的析构函数，用来做关闭外部资源等工作。但是 try-finally 等方式可以做的更好，并且该方法运行代价高昂，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。
-## 2. 垃圾收集算法
+当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能通过在该方法中让对象重新被引用，从而实现自救。
-### 2.1 标记-清除算法
+## 垃圾收集算法
- \lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。 启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给引导类加载器，直接使用 null 代替即可。
+- 启动类加载器（Bootstrap ClassLoader）此类加载器负责将存放在 <JAVA_HOME>\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。 启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给启动类加载器，直接使用 null 代替即可。
-- 扩展类加载器（Extension ClassLoader） 这个类加载器是由 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将 /lib/ext 或者被 java.ext.dir 系统变量所指定路径中的所有类库加载到内存中，开发者可以直接使用扩展类加载器。
+- 扩展类加载器（Extension ClassLoader）这个类加载器是由 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将 <JAVA_HOME>/lib/ext 或者被 java.ext.dir 系统变量所指定路径中的所有类库加载到内存中，开发者可以直接使用扩展类加载器。
-- 应用程序类加载器（Application ClassLoader） 这个类加载器是由 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。由于这个类加载器是 ClassLoader 中的 getSystemClassLoader() 方法的返回值，因此一般称为系统类加载器。它负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。
+- 应用程序类加载器（Application ClassLoader）这个类加载器是由 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。由于这个类加载器是 ClassLoader 中的 getSystemClassLoader() 方法的返回值，因此一般称为系统类加载器。它负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。
-### 4.3 双亲委派模型
+### 3. 双亲委派模型
应用程序都是由三种类加载器相互配合进行加载的，如果有必要，还可以加入自己定义的类加载器。下图展示的类加载器之间的层次关系，称为类加载器的双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器，这里类加载器之间的父子关系一般通过组合（Composition）关系来实现，而不是通过继承（Inheritance）的关系实现。
- partitionLabels(String S) {
List ret = new ArrayList<>();
- int[] lastIdxs = new int[26];
- for(int i = 0; i < S.length(); i++) lastIdxs[S.charAt(i) - 'a'] = i;
- int startIdx = 0;
- while(startIdx < S.length()) {
- int endIdx = startIdx;
- for(int i = startIdx; i < S.length() && i <= endIdx; i++) {
- int lastIdx = lastIdxs[S.charAt(i) - 'a'];
- if(lastIdx == i) continue;
- if(lastIdx > endIdx) endIdx = lastIdx;
+ int[] lastIndexs = new int[26];
+ for (int i = 0; i < S.length(); i++) {
+ lastIndexs[S.charAt(i) - 'a'] = i;
+ }
+ int firstIndex = 0;
+ while (firstIndex < S.length()) {
+ int lastIndex = firstIndex;
+ for (int i = firstIndex; i < S.length() && i <= lastIndex; i++) {
+ int index = lastIndexs[S.charAt(i) - 'a'];
+ if (index == i) continue;
+ if (index > lastIndex) lastIndex = index;
}
- ret.add(endIdx - startIdx + 1);
- startIdx = endIdx + 1;
+ ret.add(lastIndex - firstIndex + 1);
+ firstIndex = lastIndex + 1;
}
return ret;
}
@@ -392,23 +393,21 @@ Output:
```java
public int[][] reconstructQueue(int[][] people) {
- if(people == null || people.length == 0 || people[0].length == 0) return new int[0][0];
-
- Arrays.sort(people, new Comparator() {
- public int compare(int[] a, int[] b) {
- if(a[0] == b[0]) return a[1] - b[1];
- return b[0] - a[0];
- }
+ if (people == null || people.length == 0 || people[0].length == 0) return new int[0][0];
+ Arrays.sort(people, (a, b) -> {
+ if (a[0] == b[0]) return a[1] - b[1];
+ return b[0] - a[0];
});
-
- int n = people.length;
+ int N = people.length;
List tmp = new ArrayList<>();
- for(int i = 0; i < n; i++) {
- tmp.add(people[i][1], new int[]{people[i][0], people[i][1]});
+ for (int i = 0; i < N; i++) {
+ int index = people[i][1];
+ int[] p = new int[]{people[i][0], people[i][1]};
+ tmp.add(index, p);
}
- int[][] ret = new int[n][2];
- for(int i = 0; i < n; i++) {
+ int[][] ret = new int[N][2];
+ for (int i = 0; i < N; i++) {
ret[i][0] = tmp.get(i)[0];
ret[i][1] = tmp.get(i)[1];
}
@@ -420,7 +419,7 @@ public int[][] reconstructQueue(int[][] people) {
双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。
-**从一个已经排序的数组中查找出两个数，使它们的和为 0**
+**有序数组的 Tow Sum**
[Leetcode ：167. Two Sum II - Input array is sorted (Easy)](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/description/)
@@ -429,6 +428,8 @@ Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2
```
+题目描述：从一个已经排序的数组中找出两个数，使它们的和为 0。
+
使用双指针，一个指针指向元素较小的值，一个指针指向元素较大的值。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。
如果两个指针指向元素的和 sum == target，那么得到要求的结果；如果 sum > target，移动较大的元素，使 sum 变小一些；如果 sum < target，移动较小的元素，使 sum 变大一些。
@@ -457,22 +458,22 @@ Given s = "leetcode", return "leotcede".
使用双指针，指向待反转的两个元音字符，一个指针从头向尾遍历，一个指针从尾到头遍历。
```java
-private HashSet vowels = new HashSet<>(Arrays.asList('a','e','i','o','u','A','E','I','O','U'));
+private HashSet vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
public String reverseVowels(String s) {
- if(s.length() == 0) return s;
+ if (s.length() == 0) return s;
int i = 0, j = s.length() - 1;
char[] result = new char[s.length()];
- while(i <= j){
+ while (i <= j) {
char ci = s.charAt(i);
char cj = s.charAt(j);
- if(!vowels.contains(ci)){
+ if (!vowels.contains(ci)) {
result[i] = ci;
i++;
- } else if(!vowels.contains(cj)){
+ } else if (!vowels.contains(cj)) {
result[j] = cj;
j--;
- } else{
+ } else {
result[i] = cj;
result[j] = ci;
i++;
@@ -497,12 +498,12 @@ Explanation: 1 * 1 + 2 * 2 = 5
```java
public boolean judgeSquareSum(int c) {
- int left = 0, right = (int) Math.sqrt(c);
- while(left <= right){
- int powSum = left * left + right * right;
- if(powSum == c) return true;
- else if(powSum > c) right--;
- else left++;
+ int i = 0, j = (int) Math.sqrt(c);
+ while (i <= j) {
+ int powSum = i * i + j * j;
+ if (powSum == c) return true;
+ if (powSum > c) j--;
+ else i++;
}
return false;
}
@@ -518,13 +519,13 @@ Output: True
Explanation: You could delete the character 'c'.
```
-题目描述：字符串可以删除一个字符，判断是否能构成回文字符串。
+题目描述：可以删除一个字符，判断是否能构成回文字符串。
```java
public boolean validPalindrome(String s) {
- int i = 0, j = s.length() -1;
- while(i < j){
- if(s.charAt(i) != s.charAt(j)){
+ int i = 0, j = s.length() - 1;
+ while (i < j) {
+ if (s.charAt(i) != s.charAt(j)) {
return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
}
i++;
@@ -533,12 +534,9 @@ public boolean validPalindrome(String s) {
return true;
}
-private boolean isPalindrome(String s, int l, int r){
- while(l < r){
- if(s.charAt(l) != s.charAt(r))
- return false;
- l++;
- r--;
+private boolean isPalindrome(String s, int l, int r) {
+ while (l < r) {
+ if (s.charAt(l++) != s.charAt(r--)) return false;
}
return true;
}
@@ -548,18 +546,18 @@ private boolean isPalindrome(String s, int l, int r){
[Leetcode : 88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)
-题目描述：把归并结果存到第一个数组上
+题目描述：把归并结果存到第一个数组上。
```java
public void merge(int[] nums1, int m, int[] nums2, int n) {
int i = m - 1, j = n - 1; // 需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值
- int idx = m + n - 1;
- while(i >= 0 || j >= 0){
- if(i < 0) nums1[idx] = nums2[j--];
- else if(j < 0) nums1[idx] = nums1[i--];
- else if(nums1[i] > nums2[j]) nums1[idx] = nums1[i--];
- else nums1[idx] = nums2[j--];
- idx--;
+ int index = m + n - 1;
+ while (i >= 0 || j >= 0) {
+ if (i < 0) nums1[index] = nums2[j--];
+ else if (j < 0) nums1[index] = nums1[i--];
+ else if (nums1[i] > nums2[j]) nums1[index] = nums1[i--];
+ else nums1[index] = nums2[j--];
+ index--;
}
}
```
@@ -572,12 +570,12 @@ public void merge(int[] nums1, int m, int[] nums2, int n) {
```java
public boolean hasCycle(ListNode head) {
- if(head == null) return false;
+ if (head == null) return false;
ListNode l1 = head, l2 = head.next;
- while(l1 != null && l2 != null){
- if(l1 == l2) return true;
+ while (l1 != null && l2 != null) {
+ if (l1 == l2) return true;
l1 = l1.next;
- if(l2.next == null) break;
+ if (l2.next == null) break;
l2 = l2.next.next;
}
return false;
@@ -596,7 +594,7 @@ Output:
"apple"
```
-题目描述：可以删除 s 中的一些字符，使得它成为字符串列表 d 中的一个字符串。要求在 d 中找到满足条件的最长字符串。
+题目描述：删除 s 中的一些字符，使得它构成字符串列表 d 中的一个字符串，找出能构成的最长字符串。如果有多个相同长度的结果，返回按字典序排序的最大字符串。
```java
public String findLongestWord(String s, List d) {
@@ -605,8 +603,7 @@ public String findLongestWord(String s, List d) {
for (int i = 0, j = 0; i < s.length() && j < str.length(); i++) {
if (s.charAt(i) == str.charAt(j)) j++;
if (j == str.length()) {
- if (ret.length() < str.length()
- || (ret.length() == str.length() && ret.compareTo(str) > 0)) {
+ if (ret.length() < str.length() || (ret.length() == str.length() && ret.compareTo(str) > 0)) {
ret = str;
}
}
@@ -620,9 +617,9 @@ public String findLongestWord(String s, List d) {
### 快速选择
-一般用于求解 **Kth Element** 问题，可以在 O(n) 时间复杂度，O(1) 空间复杂度完成求解工作。
+一般用于求解 **Kth Element** 问题，可以在 O(N) 时间复杂度，O(1) 空间复杂度完成求解工作。
-与快速排序一样，快速选择一般需要先打乱数组，否则最坏情况下时间复杂度为 O(n2 )。
+与快速排序一样，快速选择一般需要先打乱数组，否则最坏情况下时间复杂度为 O(N2 )。
### 堆排序
@@ -632,24 +629,23 @@ public String findLongestWord(String s, List d) {
[Leetocde : 215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
-**排序** ：时间复杂度 O(nlgn)，空间复杂度 O(1) 解法
+**排序** ：时间复杂度 O(NlogN)，空间复杂度 O(1)
```java
public int findKthLargest(int[] nums, int k) {
- int N = nums.length;
- Arrays.sort(nums);
- return nums[N - k];
+ Arrays.sort(nums);
+ return nums[nums.length - k];
}
```
-**堆排序** ：时间复杂度 O(nlgk)，空间复杂度 O(k)
+**堆排序** ：时间复杂度 O(OlogK)，空间复杂度 O(K)。
```java
public int findKthLargest(int[] nums, int k) {
PriorityQueue pq = new PriorityQueue<>();
- for(int val : nums) {
- pq.offer(val);
- if(pq.size() > k) {
+ for (int val : nums) {
+ pq.add(val);
+ if (pq.size() > k) {
pq.poll();
}
}
@@ -657,56 +653,47 @@ public int findKthLargest(int[] nums, int k) {
}
```
-**快速选择** ：时间复杂度 O(n)，空间复杂度 O(1)
+**快速选择** ：时间复杂度 O(N)，空间复杂度 O(1)
```java
public int findKthLargest(int[] nums, int k) {
- k = nums.length - k;
- int lo = 0;
- int hi = nums.length - 1;
- while (lo < hi) {
- final int j = partition(nums, lo, hi);
- if(j < k) {
- lo = j + 1;
- } else if (j > k) {
- hi = j - 1;
- } else {
- break;
- }
- }
- return nums[k];
+ k = nums.length - k;
+ int l = 0, h = nums.length - 1;
+ while (l < h) {
+ int j = partition(nums, l, h);
+ if (j == k) break;
+ if (j < k) l = j + 1;
+ else h = j - 1;
}
+ return nums[k];
+}
- private int partition(int[] a, int lo, int hi) {
- int i = lo;
- int j = hi + 1;
- while(true) {
- while(i < hi && less(a[++i], a[lo]));
- while(j > lo && less(a[lo], a[--j]));
- if(i >= j) {
- break;
- }
- exch(a, i, j);
- }
- exch(a, lo, j);
- return j;
+private int partition(int[] a, int l, int h) {
+ int i = l, j = h + 1;
+ while (true) {
+ while (i < h && less(a[++i], a[l])) ;
+ while (j > l && less(a[l], a[--j])) ;
+ if (i >= j) break;
+ swap(a, i, j);
}
+ swap(a, l, j);
+ return j;
+}
- private void exch(int[] a, int i, int j) {
- final int tmp = a[i];
- a[i] = a[j];
- a[j] = tmp;
- }
+private void swap(int[] a, int i, int j) {
+ int tmp = a[i];
+ a[i] = a[j];
+ a[j] = tmp;
+}
- private boolean less(int v, int w) {
- return v < w;
- }
+private boolean less(int v, int w) {
+ return v < w;
}
```
### 桶排序
-**找出出现频率最多的 k 个数**
+**出现频率最多的 k 个数**
[Leetcode : 347. Top K Frequent Elements (Medium)](https://leetcode.com/problems/top-k-frequent-elements/description/)
@@ -714,24 +701,26 @@ public int findKthLargest(int[] nums, int k) {
Given [1,1,1,2,2,3] and k = 2, return [1,2].
```
+设置若干个桶，每个桶存储出现频率相同的数，并且桶的下标代表桶中数出现的频率，即第 i 个桶中存储的数出现的频率为 i。把数都放到桶之后，从后向前遍历桶，最先得到的 k 个数就是出现频率最多的的 k 个数。
+
```java
public List topKFrequent(int[] nums, int k) {
List ret = new ArrayList<>();
- Map map = new HashMap<>();
- for(int num : nums) {
- map.put(num, map.getOrDefault(num, 0) + 1);
+ Map frequencyMap = new HashMap<>();
+ for (int num : nums) {
+ frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
}
List[] bucket = new List[nums.length + 1];
- for(int key : map.keySet()) {
- int frequency = map.get(key);
- if(bucket[frequency] == null) {
+ for (int key : frequencyMap.keySet()) {
+ int frequency = frequencyMap.get(key);
+ if (bucket[frequency] == null) {
bucket[frequency] = new ArrayList<>();
}
bucket[frequency].add(key);
}
- for(int i = bucket.length - 1; i >= 0 && ret.size() < k; i--) {
- if(bucket[i] != null) {
+ for (int i = bucket.length - 1; i >= 0 && ret.size() < k; i--) {
+ if (bucket[i] != null) {
ret.addAll(bucket[i]);
}
}
@@ -739,6 +728,51 @@ public List topKFrequent(int[] nums, int k) {
}
```
+**按照字符出现次数对字符串排序**
+
+[Leetcode : 451. Sort Characters By Frequency (Medium)](https://leetcode.com/problems/sort-characters-by-frequency/description/)
+
+```html
+Input:
+"tree"
+
+Output:
+"eert"
+
+Explanation:
+'e' appears twice while 'r' and 't' both appear once.
+So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.
+```
+
+```java
+public String frequencySort(String s) {
+ Map map = new HashMap<>();
+ for (char c : s.toCharArray()) {
+ map.put(c, map.getOrDefault(c, 0) + 1);
+ }
+ List[] frequencyBucket = new List[s.length() + 1];
+ for(char c : map.keySet()){
+ int f = map.get(c);
+ if (frequencyBucket[f] == null) {
+ frequencyBucket[f] = new ArrayList<>();
+ }
+ frequencyBucket[f].add(c);
+ }
+ StringBuilder str = new StringBuilder();
+ for (int i = frequencyBucket.length - 1; i >= 0; i--) {
+ if (frequencyBucket[i] == null) {
+ continue;
+ }
+ for (char c : frequencyBucket[i]) {
+ for (int j = 0; j < i; j++) {
+ str.append(c);
+ }
+ }
+ }
+ return str.toString();
+}
+```
+
## 搜索
深度优先搜索和广度优先搜索广泛运用于树和图中，但是它们的应用远远不止如此。
@@ -747,28 +781,42 @@ public List topKFrequent(int[] nums, int k) {
i 表示第 i 个节点与根节点的路径长度，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di <=dj 。利用这个结论，可以求解最短路径 **最优解** 问题：第一次遍历到目的节点，其所经过的路径为最短路径，如果继续遍历，之后再遍历到目的节点，所经过的路径就不是最短路径。
+第二层：
+
+- 6 -> {4}
+- 2 -> {}
+- 1 -> {}
+- 5 -> {3}
+
+第三层：
+
+- 4 -> {}
+- 3 -> {}
+
+可以看到，每一轮遍历的节点都与根节点路径长度相同。设 di 表示第 i 个节点与根节点的路径长度，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di <=dj 。利用这个结论，可以求解最短路径等 **最优解** 问题：第一次遍历到目的节点，其所经过的路径为最短路径，如果继续遍历，之后再遍历到目的节点，所经过的路径就不是最短路径。
在程序实现 BFS 时需要考虑以下问题：
-- 队列：用来存储每一轮遍历的节点
-- 标记：对于遍历过得节点，应该将它标记，防止重复遍历；
+- 队列：用来存储每一轮遍历的节点；
+- 标记：对于遍历过的节点，应该将它标记，防止重复遍历。
**计算在网格中从原点到特定点的最短路径长度**
```html
[[1,1,0,1],
-[1,0,1,0],
-[1,1,1,1],
-[1,0,1,1]]
+ [1,0,1,0],
+ [1,1,1,1],
+ [1,0,1,1]]
```
+1 表示可以经过某个位置。
+
```java
public int minPathLength(int[][] grids, int tr, int tc) {
int[][] next = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
@@ -803,14 +851,14 @@ private class Position {
ret){
}
```
+**IP 地址划分**
+
+[Leetcode : 93. Restore IP Addresses(Medium)](https://leetcode.com/problems/restore-ip-addresses/description/)
+
+```html
+Given "25525511135",
+return ["255.255.11.135", "255.255.111.35"].
+```
+
+```java
+private List ret;
+
+public List restoreIpAddresses(String s) {
+ ret = new ArrayList<>();
+ doRestore(0, "", s);
+ return ret;
+}
+
+private void doRestore(int k, String path, String s) {
+ if (k == 4 || s.length() == 0) {
+ if (k == 4 && s.length() == 0) {
+ ret.add(path);
+ }
+ return;
+ }
+ for (int i = 0; i < s.length() && i <= 2; i++) {
+ if (i != 0 && s.charAt(0) == '0') break;
+ String part = s.substring(0, i + 1);
+ if (Integer.valueOf(part) <= 255) {
+ doRestore(k + 1, path.length() != 0 ? path + "." + part : part, s.substring(i + 1));
+ }
+ }
+}
+```
+
**填充封闭区域**
[Leetcode : 130. Surrounded Regions (Medium)](https://leetcode.com/problems/surrounded-regions/description/)
@@ -1083,74 +1167,11 @@ private void dfs(int r, int c, boolean[][] canReach) {
}
```
-**N 皇后**
-
-[Leetcode : 51. N-Queens (Hard)](https://leetcode.com/problems/n-queens/description/)
-
- > ret;
-private char[][] nQueens;
-private boolean[] colUsed;
-private boolean[] diagonals45Used;
-private boolean[] diagonals135Used;
-private int n;
-
-public List> solveNQueens(int n) {
- ret = new ArrayList<>();
- nQueens = new char[n][n];
- Arrays.fill(nQueens, '.');
- colUsed = new boolean[n];
- diagonals45Used = new boolean[2 * n - 1];
- diagonals135Used = new boolean[2 * n - 1];
- this.n = n;
- backstracking(0);
- return ret;
-}
-
-private void backstracking(int row) {
- if (row == n) {
- List list = new ArrayList<>();
- for (char[] chars : nQueens) {
- list.add(new String(chars));
- }
- ret.add(list);
- return;
- }
-
- for (int col = 0; col < n; col++) {
- int diagonals45Idx = row + col;
- int diagonals135Idx = n - 1 - (row - col);
- if (colUsed[col] || diagonals45Used[diagonals45Idx] || diagonals135Used[diagonals135Idx]) {
- continue;
- }
- nQueens[row][col] = 'Q';
- colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = true;
- backstracking(row + 1);
- colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = false;
- nQueens[row][col] = '.';
- }
-}
-```
-
### Backtracking
-回溯是 DFS 的一种，它不是用在遍历图的节点上，而是用于求解 **排列组合** 问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串。
+回溯属于 DF，它不是用在遍历图的节点上，而是用于求解 **排列组合** 问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串。
-在程序实现时，回溯需要注意对元素进行标记的问题。使用递归实现的回溯，在访问一个新元素进入新的递归调用，此时需要将新元素标记为已经访问，这样才能在继续递归调用时不用重复访问该元素；但是在递归返回时，需要将该元素标记为未访问，因为只需要保证在一个递归链中不同时访问一个元素，而在不同的递归链是可以访问已经访问过但是不在当前递归链中的元素。
+在程序实现时，回溯需要注意对元素进行标记的问题。使用递归实现的回溯，在访问一个新元素进入新的递归调用时，需要将新元素标记为已经访问，这样才能在继续递归调用时不用重复访问该元素；但是在递归返回时，需要将该元素标记为未访问，因为只需要保证在一个递归链中不同时访问一个元素，可以访问已经访问过但是不在当前递归链中的元素。
**数字键盘组合**
@@ -1168,20 +1189,21 @@ private static final String[] KEYS = {"", "", "abc", "def", "ghi", "jkl", "mno",
public List letterCombinations(String digits) {
List ret = new ArrayList<>();
- if (digits != null && digits.length() != 0) {
- combination("", digits, 0, ret);
- }
+ if (digits == null || digits.length() == 0) return ret;
+ combination(new StringBuilder(), digits, ret);
return ret;
}
-private void combination(String prefix, String digits, int offset, List ret) {
- if (offset == digits.length()) {
- ret.add(prefix);
+private void combination(StringBuilder prefix, String digits, List ret) {
+ if (prefix.length() == digits.length()) {
+ ret.add(prefix.toString());
return;
}
- String letters = KEYS[digits.charAt(offset) - '0'];
+ String letters = KEYS[digits.charAt(prefix.length()) - '0'];
for (char c : letters.toCharArray()) {
- combination(prefix + c, digits, offset + 1, ret);
+ prefix.append(c);
+ combination(prefix, digits, ret);
+ prefix.deleteCharAt(prefix.length() - 1); // 删除
}
}
```
@@ -1227,55 +1249,22 @@ private boolean dfs(char[][] board, String word, int start, int r, int c) {
if (start == word.length()) {
return true;
}
- if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != word.charAt(start) || visited[r][c] ) {
+ if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != word.charAt(start) || visited[r][c]) {
return false;
}
visited[r][c] = true;
for (int i = 0; i < shift.length; i++) {
int nextR = r + shift[i][0];
int nextC = c + shift[i][1];
- if (dfs(board, word, start + 1, nextR, nextC)) return true;
+ if (dfs(board, word, start + 1, nextR, nextC)) {
+ return true;
+ }
}
visited[r][c] = false;
return false;
}
```
-**IP 地址划分**
-
-[Leetcode : 93. Restore IP Addresses(Medium)](https://leetcode.com/problems/restore-ip-addresses/description/)
-
-```html
-Given "25525511135",
-return ["255.255.11.135", "255.255.111.35"].
-```
-
-```java
-private List ret;
-
-public List restoreIpAddresses(String s) {
- ret = new ArrayList<>();
- doRestore(0, "", s);
- return ret;
-}
-
-private void doRestore(int k, String path, String s) {
- if (k == 4 || s.length() == 0) {
- if (k == 4 && s.length() == 0) {
- ret.add(path);
- }
- return;
- }
- for (int i = 0; i < s.length() && i <= 2; i++) {
- if (i != 0 && s.charAt(0) == '0') break;
- String part = s.substring(0, i + 1);
- if (Integer.valueOf(part) <= 255) {
- doRestore(k + 1, path.length() != 0 ? path + "." + part : part, s.substring(i + 1));
- }
- }
-}
-```
-
**排列**
[Leetcode : 46. Permutations (Medium)](https://leetcode.com/problems/permutations/description/)
@@ -1327,7 +1316,7 @@ private void backtracking(List permuteList, boolean[] visited, int[] nu
[[1,1,2], [1,2,1], [2,1,1]]
```
-题目描述：数组元素可能含有相同的元素，进行排列时就有可能出先重复的排列，要求重复的排列只返回一个。
+题目描述：数组元素可能含有相同的元素，进行排列时就有可能出现 重复的排列，要求重复的排列只返回一个。
在实现上，和 Permutations 不同的是要先排序，然后在添加一个元素时，判断这个元素是否等于前一个元素，如果等于，并且前一个元素还未访问，那么就跳过这个元素。
@@ -1343,12 +1332,12 @@ public List> permuteUnique(int[] nums) {
private void backtracking(List permuteList, boolean[] visited, int[] nums, List> ret) {
if (permuteList.size() == nums.length) {
- ret.add(new ArrayList(permuteList));
+ ret.add(new ArrayList(permuteList)); // 重新构造一个 List
return;
}
for (int i = 0; i < visited.length; i++) {
- if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) continue;
+ if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) continue; // 防止重复
if (visited[i]) continue;
visited[i] = true;
permuteList.add(nums[i]);
@@ -1385,12 +1374,11 @@ public List> combine(int n, int k) {
private void backtracking(int start, int n, int k, List combineList, List> ret){
if(k == 0){
- ret.add(new ArrayList(combineList)); // 这里要重新构造一个 List
+ ret.add(new ArrayList(combineList));
return;
}
- for(int i = start; i <= n - k + 1; i++){ // 剪枝
-
+ for(int i = start; i <= n - k + 1; i++) { // 剪枝
combineList.add(i); // 把 i 标记为已访问
backtracking(i + 1, n, k - 1, combineList, ret);
combineList.remove(combineList.size() - 1); // 把 i 标记为未访问
@@ -1475,6 +1463,46 @@ private void doCombination(int[] candidates, int target, int start, List> combinationSum3(int k, int n) {
+ List> ret = new ArrayList<>();
+ List path = new ArrayList<>();
+ for (int i = 1; i <= 9; i++) {
+ path.add(i);
+ backtracking(k - 1, n - i, path, i, ret);
+ path.remove(0);
+ }
+ return ret;
+}
+
+private void backtracking(int k, int n, List path, int start, List> ret) {
+ if (k == 0 && n == 0) {
+ ret.add(new ArrayList<>(path));
+ return;
+ }
+ if (k == 0 || n == 0) return;
+ for (int i = start + 1; i <= 9; i++) { // 只能访问下一个元素，防止遍历的结果重复
+ path.add(i);
+ backtracking(k - 1, n - i, path, i, ret);
+ path.remove(path.size() - 1);
+ }
+}
+```
+
**子集**
[Leetcode : 78. Subsets (Medium)](https://leetcode.com/problems/subsets/description/)
@@ -1488,7 +1516,7 @@ private List subsetList;
public List> subsets(int[] nums) {
ret = new ArrayList<>();
subsetList = new ArrayList<>();
- for (int i = 0; i <= nums.length; i++) {
+ for (int i = 0; i <= nums.length; i++) { // 不同的子集大小
backtracking(0, i, nums);
}
return ret;
@@ -1502,7 +1530,7 @@ private void backtracking(int startIdx, int size, int[] nums) {
for (int i = startIdx; i < nums.length; i++) {
subsetList.add(nums[i]);
- backtracking(i + 1, size, nums); // startIdx 设为下一个元素，使 subset 中的元素都递增排序
+ backtracking(i + 1, size, nums);
subsetList.remove(subsetList.size() - 1);
}
}
@@ -1559,10 +1587,20 @@ private void backtracking(int startIdx, int size, int[] nums) {
}
```
-**分割字符串使得每部分都是回文数**
+**分割字符串使得每个部分都是回文数**
[Leetcode : 131. Palindrome Partitioning (Medium)](https://leetcode.com/problems/palindrome-partitioning/description/)
+```html
+For example, given s = "aab",
+Return
+
+[
+ ["aa","b"],
+ ["a","a","b"]
+]
+```
+
```java
private List> ret;
@@ -1650,6 +1688,69 @@ private int cubeNum(int i, int j) {
}
```
+**N 皇后**
+
+[Leetcode : 51. N-Queens (Hard)](https://leetcode.com/problems/n-queens/description/)
+
+ > ret;
+private char[][] nQueens;
+private boolean[] colUsed;
+private boolean[] diagonals45Used;
+private boolean[] diagonals135Used;
+private int n;
+
+public List> solveNQueens(int n) {
+ ret = new ArrayList<>();
+ nQueens = new char[n][n];
+ Arrays.fill(nQueens, '.');
+ colUsed = new boolean[n];
+ diagonals45Used = new boolean[2 * n - 1];
+ diagonals135Used = new boolean[2 * n - 1];
+ this.n = n;
+ backstracking(0);
+ return ret;
+}
+
+private void backstracking(int row) {
+ if (row == n) {
+ List list = new ArrayList<>();
+ for (char[] chars : nQueens) {
+ list.add(new String(chars));
+ }
+ ret.add(list);
+ return;
+ }
+
+ for (int col = 0; col < n; col++) {
+ int diagonals45Idx = row + col;
+ int diagonals135Idx = n - 1 - (row - col);
+ if (colUsed[col] || diagonals45Used[diagonals45Idx] || diagonals135Used[diagonals135Idx]) {
+ continue;
+ }
+ nQueens[row][col] = 'Q';
+ colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = true;
+ backstracking(row + 1);
+ colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = false;
+ nQueens[row][col] = '.';
+ }
+}
+```
+
## 分治
**给表达式加括号**
@@ -1692,123 +1793,7 @@ public List diffWaysToCompute(String input) {
## 动态规划
-递归和动态规划都是将原问题拆成多个子问题然后求解，他们之间最本质的区别是，动态规划保存了子问题的解。
-
-### 分割整数
-
-**分割整数的最大乘积**
-
-[Leetcode : 343. Integer Break (Medim)](https://leetcode.com/problems/integer-break/description/)
-
-题目描述：For example, given n = 2, return 1 (2 = 1 + 1); given n = 10, return 36 (10 = 3 + 3 + 4).
-
-```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 - 1; j++) {
- dp[i] = Math.max(dp[i], Math.max(j * dp[i - j], j * (i - j)));
- }
- }
- return dp[n];
-}
-```
-
-**按平方数来分割整数**
-
-[Leetcode : 279. Perfect Squares(Medium)](https://leetcode.com/problems/perfect-squares/description/)
-
-题目描述：For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.
-
-```java
-public int numSquares(int n) {
- List squares = new ArrayList<>(); // 存储小于 n 的平方数
- int diff = 3;
- while(square <= n) {
- squares.add(square);
- square += diff;
- diff += 2;
- }
- int[] dp = new int[n + 1];
- for(int i = 1; i <= n; i++) {
- int max = Integer.MAX_VALUE;
- for(int s : squares) {
- if(s > i) break;
- max = Math.min(max, dp[i - s] + 1);
- }
- dp[i] = max;
- }
- return dp[n];
-}
-```
-
-**分割整数构成字母字符串**
-
-[Leetcode : 91. Decode Ways (Medium)](https://leetcode.com/problems/decode-ways/description/)
-
-题目描述：Given encoded message "12", it could be decoded as "AB" (1 2) or "L" (12).
-
-```java
-public int numDecodings(String s) {
- if(s == null || s.length() == 0) return 0;
- int n = s.length();
- int[] dp = new int[n + 1];
- dp[0] = 1;
- dp[1] = s.charAt(0) == '0' ? 0 : 1;
- for(int i = 2; i <= n; i++) {
- int one = Integer.valueOf(s.substring(i - 1, i));
- if(one != 0) dp[i] += dp[i - 1];
- if(s.charAt(i - 2) == '0') continue;
- int two = Integer.valueOf(s.substring(i - 2, i));
- if(two <= 26) dp[i] += dp[i - 2];
- }
- return dp[n];
-}
-```
-
-### 矩阵路径
-
-**矩阵的总路径数**
-
-[Leetcode : 62. Unique Paths (Medium)](https://leetcode.com/problems/unique-paths/description/)
-
-题目描述：统计从矩阵左上角到右下角的路径总数，每次只能向左和向下移动。
-
-```java
-public int uniquePaths(int m, int n) {
- int[] dp = new int[n];
- for (int i = 0; i < m; i++) {
- for (int j = 0; j < n; j++) {
- if(i == 0) dp[j] = 1;
- else if(j != 0) dp[j] = dp[j] + dp[j - 1];
- }
- }
- return dp[n - 1];
-}
-```
-
-**矩阵的最小路径和**
-
-[Leetcode : 64. Minimum Path Sum (Medium)](https://leetcode.com/problems/minimum-path-sum/description/)
-
-题目描述：求从矩阵的左上角到右下角的最小路径和，每次只能向左和向下移动。
-
-```java
-public int minPathSum(int[][] grid) {
- if(grid.length == 0 || grid[0].length == 0) return 0;
- int m = grid.length, n = grid[0].length;
- int[] dp = new int[n];
- for(int i = 0; i < m; i++) {
- for(int j = 0; j < n; j++) {
- if(j == 0) dp[0] = dp[0] + grid[i][0];
- else if(i == 0) dp[j] = dp[j - 1] + grid[0][j];
- else dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];
- }
- }
- return dp[n - 1];
-}
-```
+递归和动态规划都是将原问题拆成多个子问题然后求解，他们之间最本质的区别是，动态规划保存了子问题的解，避免重复计算。
### 斐波那契数列
@@ -1824,13 +1809,12 @@ public int minPathSum(int[][] grid) {
dp[N] 即为所求。
-考虑到 dp[i] 只与 dp[i - 1] 和 dp[i - 2] 有关，因此可以只用两个变量来存储 dp[i - 1] 和 dp[i - 2] 即可，使得原来的 O(n) 空间复杂度优化为 O(1) 复杂度。
+考虑到 dp[i] 只与 dp[i - 1] 和 dp[i - 2] 有关，因此可以只用两个变量来存储 dp[i - 1] 和 dp[i - 2]，使得原来的 O(N) 空间复杂度优化为 O(1) 复杂度。
```java
public int climbStairs(int n) {
if(n == 1) return 1;
if(n == 2) return 2;
- // 前一个楼梯、后一个楼梯
int pre1 = 2, pre2 = 1;
for(int i = 2; i < n; i++){
int cur = pre1 + pre2;
@@ -1904,37 +1888,37 @@ public int rob(int[] nums) {
[Leetcode : 213. House Robber II (Medium)](https://leetcode.com/problems/house-robber-ii/description/)
```java
+private int[] dp;
+
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;
- if(n == 1) return nums[0];
+ if (n == 1) return nums[0];
+ dp = new int[n];
return Math.max(rob(nums, 0, n - 2), rob(nums, 1, n - 1));
}
-private int rob(int[] nums, int s, int e) {
- int n = nums.length;
- if(e - s == 0) return nums[s];
- if(e - s == 1) return Math.max(nums[s], nums[s + 1]);
- int[] dp = new int[n];
- dp[s] = nums[s];
- dp[s + 1] = nums[s + 1];
- dp[s + 2] = nums[s] + nums[s + 2];
- for (int i = s + 3; i <= e; i++) {
+private int rob(int[] nums, int first, int last) {
+ if (last - first == 0) return nums[first];
+ if (last - first == 1) return Math.max(nums[first], nums[first + 1]);
+ dp[first] = nums[first];
+ dp[first + 1] = nums[first + 1];
+ dp[first + 2] = nums[first] + nums[first + 2];
+ for (int i = first + 3; i <= last; i++) {
dp[i] = Math.max(dp[i - 2], dp[i - 3]) + nums[i];
}
- return Math.max(dp[e], dp[e - 1]);
+ return Math.max(dp[last], dp[last - 1]);
}
```
**信件错排**
-题目描述：有 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 和 j 的信后，第 i 个信和信封在正确的位置，其余 i-1 封信有 dp[i-1] 种错误装信方式。由于 j 有 i-1 种取值，因此共有 (n-1)\*dp[i-1] 种错误装信方式。
+- 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 种取值，因此共有 (n-1)\*dp[i-1] 种错误装信方式。
综上所述，错误装信数量方式数量为：
@@ -1952,7 +1936,7 @@ dp[N] 即为所求。
定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 Sn 结尾的序列的最长递增子序列长度。对于一个递增子序列 {Si1 , Si2 ,...,Sim }，如果 im < n 并且 Sim < Sn ，此时 {Si1 , Si2 ,..., Sim , Sn } 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 Sn 就构成了以 Sn 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | Si < Sn && i < n} 。
-因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {Sn } 就构成了递增子序列，因此需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：
+因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {Sn } 就构成了递增子序列，需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：
2 ) ，可以使用二分查找使得时间复杂度降低为 O(nlogn )。定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素，例如对于数组 [4,5,6,3]，有
+以上解法的时间复杂度为 O(n2 ) ，可以使用二分查找使得时间复杂度降低为 O(nlogn)。定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素，例如对于数组 [4,5,6,3]，有
```html
len = 1 : [4], [5], [6], [3] => tails[0] = 3
len = 2 : [4, 5], [5, 6] => tails[1] = 5
-len = 3 : [4, 5, 6] => tails[2] = 6
+len = 3 : [4, 5, 6] => tails[2] = 6
```
-对于一个元素 x，如果它大于 tails 数组所有的值，那么把它添加到 tails 后面；如果 tails[i-1] < x <= tails[i]，那么更新 tails[i] = x 。
+对于一个元素 x，
+
+- 如果它大于 tails 数组所有的值，那么把它添加到 tails 后面，表示最长递增子序列长度加 1；
+- 如果 tails[i-1] < x <= tails[i]，那么更新 tails[i-1] = x。
可以看出 tails 数组保持有序，因此在查找 Si 位于 tails 数组的位置时就可以使用二分查找。
@@ -1998,22 +1985,59 @@ public int lengthOfLIS(int[] nums) {
int n = nums.length;
int[] tails = new int[n];
int size = 0;
- for(int i = 0; i < n; i++){
- int idx = binarySearch(tails, 0, size, nums[i]);
- tails[idx] = nums[i];
- if(idx == size) size++;
+ for (int i = 0; i < n; i++) {
+ int index = binarySearch(tails, 0, size, nums[i]);
+ tails[index] = nums[i];
+ if (index == size) size++;
}
return size;
}
-private int binarySearch(int[] nums, int sIdx, int eIdx, int key){
- while(sIdx < eIdx){
- int mIdx = sIdx + (eIdx - sIdx) / 2;
- if(nums[mIdx] == key) return mIdx;
- else if(nums[mIdx] > key) eIdx = mIdx;
- else sIdx = mIdx + 1;
+private int binarySearch(int[] nums, int first, int last, int key) {
+ while (first < last) {
+ int mid = first + (last - first) / 2;
+ if (nums[mid] == key) return mid;
+ else if (nums[mid] > key) last = mid;
+ else first = mid + 1;
}
- return sIdx;
+ return first;
+}
+```
+
+**一组整数对能够构成的最长链**
+
+[Leetcode : 646. Maximum Length of Pair Chain (Medium)](https://leetcode.com/problems/maximum-length-of-pair-chain/description/)
+
+```html
+Input: [[1,2], [2,3], [3,4]]
+Output: 2
+Explanation: The longest chain is [1,2] -> [3,4]
+```
+
+题目描述：对于 (a, b) 和 (c, d) ，如果 b < c，则它们可以构成一条链。
+
+```java
+public int findLongestChain(int[][] pairs) {
+ if(pairs == null || pairs.length == 0) {
+ return 0;
+ }
+ Arrays.sort(pairs, (a, b) -> (a[0] - b[0]));
+ int n = pairs.length;
+ int[] dp = new int[n];
+ Arrays.fill(dp, 1);
+ for(int i = 0; i < n; i++) {
+ for(int j = 0; j < i; j++) {
+ if(pairs[i][0] > pairs[j][1]){
+ dp[i] = Math.max(dp[i], dp[j] + 1);
+ }
+ }
+ }
+
+ int ret = 0;
+ for(int num : dp) {
+ ret = Math.max(ret, num);
+ }
+ return ret;
}
```
@@ -2021,6 +2045,19 @@ private int binarySearch(int[] nums, int sIdx, int eIdx, int key){
[Leetcode : 376. Wiggle Subsequence (Medium)](https://leetcode.com/problems/wiggle-subsequence/description/)
+```html
+Input: [1,7,4,9,2,5]
+Output: 6
+The entire sequence is a wiggle sequence.
+
+Input: [1,17,5,10,13,15,10,5,16,8]
+Output: 7
+There are several subsequences that achieve this length. One is [1,17,10,13,10,16,8].
+
+Input: [1,2,3,4,5,6,7,8,9]
+Output: 2
+```
+
要求：使用 O(n) 时间复杂度求解。
使用两个状态 up 和 down。
@@ -2038,17 +2075,16 @@ public int wiggleMaxLength(int[] nums) {
}
```
-### 最长公共子系列
+### 最长公共子序列
对于两个子序列 S1 和 S2，找出它们最长的公共子序列。
定义一个二维数组 dp 用来存储最长公共子序列的长度，其中 dp[i][j] 表示 S1 的前 i 个字符与 S2 的前 j 个字符最长公共子序列的长度。考虑 S1i 与 S2j 值是否相等，分为两种情况：
-① 当 S1i ==S2j 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1i 这个值，最长公共子序列长度加 1 ，即 dp[i][j] = dp[i-1][j-1] + 1。
+- 当 S1i ==S2j 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1i 这个值，最长公共子序列长度加 1 ，即 dp[i][j] = dp[i-1][j-1] + 1。
+- 当 S1i != S2j 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，与 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。
-② 当 S1i != S2j 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，与 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。
-
-综上，最长公共子系列的状态转移方程为：
+综上，最长公共子序列的状态转移方程为：
i 为结尾的最长递增子序列长度，子序列必须包含 Si ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1i 和 S2j 。
-③ 由于 2 ，在求最终解时，最长公共子序列中 dp[N][M] 就是最终解，而最长递增子序列中 dp[N] 不是最终解，因为以 SN 为结尾的最长递增子序列不一定是整个序列最长递增子序列，需要遍历一遍 dp 数组找到最大者。
+- 针对的是两个序列，求它们的最长公共子序列。
+- 在最长递增子序列中，dp[i] 表示以 Si 为结尾的最长递增子序列长度，子序列必须包含 Si ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1i 和 S2j 。
+- 由于 2 ，在求最终解时，最长公共子序列中 dp[N][M] 就是最终解，而最长递增子序列中 dp[N] 不是最终解，因为以 SN 为结尾的最长递增子序列不一定是整个序列最长递增子序列，需要遍历一遍 dp 数组找到最大者。
```java
public int lengthOfLCS(int[] nums1, int[] nums2) {
@@ -2080,8 +2116,8 @@ public int lengthOfLCS(int[] nums1, int[] nums2) {
定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示体积不超过 j 的情况下，前 i 件物品能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论：
-① 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最大价值就是总体积不超过 j 的前 i-1 件物品的最大价值，dp[i][j] = dp[i-1][j]。
-② 第 i 件物品添加到背包中，dp[i][j] = dp[i-1][j-w] + v。
+- 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最大价值就是总体积不超过 j 的前 i-1 件物品的最大价值，dp[i][j] = dp[i-1][j]。
+- 第 i 件物品添加到背包中，dp[i][j] = dp[i-1][j-w] + v。
第 i 件物品可添加也可以不添加，取决于哪种情况下最大价值更大。
@@ -2091,19 +2127,18 @@ public int lengthOfLCS(int[] nums1, int[] nums2) {
```java
public int knapsack(int W, int N, int[] weights, int[] values) {
- int[][] dp = new int[N][W];
- for (int i = W - 1; i >= 0; i--) {
- dp[0][i] = i > weights[0] ? values[0] : 0;
- }
- for (int i = 1; i < N; i++) {
- for (int j = W - 1; j >= weights[i]; j--) {
- dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weights[i]] + values[i]);
- }
- for (int j = weights[i - 1] - 1; j >= 0; j--) {
- dp[i][j] = dp[i - 1][j];
+ int[][] dp = new int[N + 1][W + 1];
+ for (int i = 1; i <= N; i++) {
+ int w = weights[i - 1], v = values[i - 1];
+ for (int j = 1; j <= W; j++) {
+ if (j >= w) {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - w] + v);
+ } else {
+ dp[i][j] = dp[i - 1][j];
+ }
}
}
- return dp[N - 1][W - 1];
+ return dp[N][W];
}
```
@@ -2113,7 +2148,22 @@ public int knapsack(int W, int N, int[] weights, int[] values) {
wordDict) {
int n = s.length();
boolean[] dp = new boolean[n + 1];
dp[0] = true;
for (int i = 1; i <= n; i++) {
- for (String word : wordDict) {
- if (word.length() <= i
- && word.equals(s.substring(i - word.length(), i))) {
- dp[i] = dp[i] || dp[i - word.length()];
+ for (String word : wordDict) { // 每个单词可以使用多次
+ int len = word.length();
+ if (len <= i && word.equals(s.substring(i - len, i))) {
+ dp[i] = dp[i] || dp[i - len];
}
}
}
@@ -2213,7 +2267,9 @@ Explanation:
There are 5 ways to assign symbols to make the sum of nums be target 3.
```
-该问题可以转换为 subset sum 问题，从而使用 0-1 背包的方法来求解。可以将这组数看成两部分，P 和 N，其中 P 使用正号，N 使用负号，有以下推导：
+该问题可以转换为 Subset Sum 问题，从而使用 0-1 背包的方法来求解。
+
+可以将这组数看成两部分，P 和 N，其中 P 使用正号，N 使用负号，有以下推导：
```html
sum(P) - sum(N) = target
@@ -2226,26 +2282,34 @@ sum(P) + sum(N) + sum(P) - sum(N) = target + sum(P) + sum(N)
```java
public int findTargetSumWays(int[] nums, int S) {
int sum = 0;
- for (int num : nums) {
- sum += num;
- }
- if (sum < S || (sum + S) % 2 == 1) {
- return 0;
- }
- return subsetSum(nums, (sum + S) >>> 1);
-}
-
-private int subsetSum(int[] nums, int targetSum) {
- Arrays.sort(nums);
- int[] dp = new int[targetSum + 1];
+ for (int num : nums) sum += num;
+ if (sum < S || (sum + S) % 2 == 1) return 0;
+ int W = (sum + S) / 2;
+ int[] dp = new int[W + 1];
dp[0] = 1;
- for (int i = 0; i < nums.length; i++) {
- int num = nums[i];
- for (int j = targetSum; j >= num; j--) {
- dp[j] = dp[j] + dp[j - num];
+ for (int num : nums) {
+ for (int i = W; i >= 0; i--) {
+ if (num <= i) {
+ dp[i] = dp[i] + dp[i - num];
+ }
}
}
- return dp[targetSum];
+ return dp[W];
+}
+```
+
+DFS 解法：
+
+```java
+public int findTargetSumWays(int[] nums, int S) {
+ return findTargetSumWays(nums, 0, S);
+}
+
+private int findTargetSumWays(int[] nums, int start, int S) {
+ if (start == nums.length) {
+ return S == 0 ? 1 : 0;
+ }
+ return findTargetSumWays(nums, start + 1, S + nums[start]) + findTargetSumWays(nums, start + 1, S - nums[start]);
}
```
@@ -2257,7 +2321,7 @@ private int subsetSum(int[] nums, int targetSum) {
Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
Output: 4
-Explanation: This are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are “10,”0001”,”1”,”0”
+Explanation: There are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are "10","0001","1","0"
```
这是一个多维费用的 0-1 背包问题，有两个背包大小，0 的数量和 1 的数量。
@@ -2265,20 +2329,16 @@ Explanation: This are totally 4 strings can be formed by the using of 5 0s and 3
```java
public int findMaxForm(String[] strs, int m, int n) {
if (strs == null || strs.length == 0) return 0;
- int l = strs.length;
int[][] dp = new int[m + 1][n + 1];
- for (int i = 0; i < l; i++) {
- String s = strs[i];
+ for (String s : strs) { // 每个字符串只能用一次
int ones = 0, zeros = 0;
for (char c : s.toCharArray()) {
if (c == '0') zeros++;
- else if (c == '1') ones++;
+ else ones++;
}
- for (int j = m; j >= zeros; j--) {
- for (int k = n; k >= ones; k--) {
- if (zeros <= j && ones <= k) {
- dp[j][k] = Math.max(dp[j][k], dp[j - zeros][k - ones] + 1);
- }
+ for (int i = m; i >= zeros; i--) {
+ for (int j = n; j >= ones; j--) {
+ dp[i][j] = Math.max(dp[i][j], dp[i - zeros][j - ones] + 1);
}
}
}
@@ -2290,19 +2350,30 @@ public int findMaxForm(String[] strs, int m, int n) {
[Leetcode : 322. Coin Change (Medium)](https://leetcode.com/problems/coin-change/description/)
+```html
+Example 1:
+coins = [1, 2, 5], amount = 11
+return 3 (11 = 5 + 5 + 1)
+
+Example 2:
+coins = [2], amount = 3
+return -1.
+```
+
题目描述：给一些面额的硬币，要求用这些硬币来组成给定面额的钱数，并且使得硬币数量最少。硬币可以重复使用。
-这是一个完全背包问题，完全背包问题和 0-1 背包问题在实现上唯一的不同是，第二层循环是从 0 开始的，而不是从尾部开始。
+这是一个完全背包问题。
```java
public int coinChange(int[] coins, int amount) {
+ if (coins == null || coins.length == 0) return 0;
int[] dp = new int[amount + 1];
Arrays.fill(dp, amount + 1);
dp[0] = 0;
for (int i = 1; i <= amount; i++) {
- for (int j = 0; j < coins.length; j++) {
- if (coins[j] <= i) {
- dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
+ for (int c : coins) {
+ if (c <= i) {
+ dp[i] = Math.min(dp[i], dp[i - c] + 1);
}
}
}
@@ -2332,14 +2403,17 @@ Note that different sequences are counted as different combinations.
Therefore the output is 7.
```
+完全背包。
+
```java
public int combinationSum4(int[] nums, int target) {
+ if (nums == null || nums.length == 0) return 0;
int[] dp = new int[target + 1];
dp[0] = 1;
for (int i = 1; i <= target; i++) {
- for (int j = 0; j < nums.length; j++) {
- if(nums[j] <= i) {
- dp[i] += dp[i - nums[j]];
+ for (int num : nums) {
+ if (num <= i) {
+ dp[i] += dp[i - num];
}
}
}
@@ -2347,6 +2421,38 @@ public int combinationSum4(int[] nums, int target) {
}
```
+**只能进行 k 次的股票交易**
+
+[Leetcode : 188. Best Time to Buy and Sell Stock IV (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/)
+
+```html
+dp[i, j] = max(dp[i, j-1], prices[j] - prices[jj] + dp[i-1, jj]) { jj in range of [0, j-1] }
+ = max(dp[i, j-1], prices[j] + max(dp[i-1, jj] - prices[jj]))
+```
+
+```java
+public int maxProfit(int k, int[] prices) {
+ int n = prices.length;
+ if (k >= n/2) { // 这种情况下该问题退化为普通的股票交易问题
+ int maxPro = 0;
+ for (int i = 1; i < n; i++) {
+ if (prices[i] > prices[i-1])
+ maxPro += prices[i] - prices[i-1];
+ }
+ return maxPro;
+ }
+ int[][] dp = new int[k + 1][n];
+ for (int i = 1; i <= k; i++) {
+ int localMax = dp[i - 1][0] - prices[0];
+ for (int j = 1; j < n; j++) {
+ dp[i][j] = Math.max(dp[i][j - 1], prices[j] + localMax);
+ localMax = Math.max(localMax, dp[i - 1][j] - prices[j]);
+ }
+ }
+ return dp[k][n - 1];
+}
+```
+
**只能进行两次的股票交易**
[Leetcode : 123. Best Time to Buy and Sell Stock III (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/)
@@ -2365,58 +2471,35 @@ public int maxProfit(int[] prices) {
}
```
-**只能进行 k 次的股票交易**
-
-[Leetcode : 188. Best Time to Buy and Sell Stock IV (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/)
-
-```html
-dp[i, j] = max(dp[i, j-1], prices[j] - prices[jj] + dp[i-1, jj]) { jj in range of [0, j-1] } = max(dp[i, j-1], prices[j] + max(dp[i-1, jj] - prices[jj]))
-```
-
-```java
-public int maxProfit(int k, int[] prices) {
- int n = prices.length;
- if (k >= n/2) {
- int maxPro = 0;
- for (int i = 1; i < n; i++) {
- if (prices[i] > prices[i-1])
- maxPro += prices[i] - prices[i-1];
- }
- return maxPro;
- }
- int[][] dp = new int[k + 1][n];
- for (int i = 1; i <= k; i++) {
- int localMax = dp[i - 1][0] - prices[0];
- for (int j = 1; j < n; j++) {
- dp[i][j] = Math.max(dp[i][j - 1], prices[j] + localMax);
- localMax = Math.max(localMax, dp[i - 1][j] - prices[j]);
- }
- }
- return dp[k][n - 1];
-}
-```
-
### 数组区间
**数组区间和**
[Leetcode : 303. Range Sum Query - Immutable (Easy)](https://leetcode.com/problems/range-sum-query-immutable/description/)
-求区间 i \~ j 的和，可以转换为 sum[j] - sum[i-1]，其中 sum[i] 为 0 \~ j 的和。
+```html
+Given nums = [-2, 0, 3, -5, 2, -1]
+
+sumRange(0, 2) -> 1
+sumRange(2, 5) -> -1
+sumRange(0, 5) -> -3
+```
+
+求区间 i \~ j 的和，可以转换为 sum[j] - sum[i-1]，其中 sum[i] 为 0 \~ i 的和。
```java
class NumArray {
-
- int[] nums;
+ private int[] sums;
public NumArray(int[] nums) {
- for(int i = 1; i < nums.length; i++)
- nums[i] += nums[i - 1];
- this.nums = nums;
+ sums = new int[nums.length];
+ for (int i = 0; i < nums.length; i++) {
+ sums[i] = i == 0 ? nums[0] : sums[i - 1] + nums[i];
+ }
}
public int sumRange(int i, int j) {
- return i == 0 ? nums[j] : nums[j] - nums[i - 1];
+ return i == 0 ? sums[j] : sums[j] - sums[i - 1];
}
}
```
@@ -2425,33 +2508,21 @@ class NumArray {
[Leetcode : 53. Maximum Subarray (Easy)](https://leetcode.com/problems/maximum-subarray/description/)
-令 sum[i] 为以 num[i] 为结尾的子数组最大的和，可以由 sum[i-1] 得到 sum[i] 的值，如果 sum[i-1] 小于 0，那么以 num[i] 为结尾的子数组不能包含前面的内容，因为加上前面的部分，那么和一定会比 num[i] 还小。
-
-```java
-public int maxSubArray(int[] nums) {
- int n = nums.length;
- int[] sum = new int[n];
- sum[0] = nums[0];
- int max = sum[0];
- for(int i = 1; i < n; i++){
- sum[i] = (sum[i-1] > 0 ? sum[i-1] : 0) + nums[i];
- max = Math.max(max, sum[i]);
- }
- return max;
-}
+```html
+For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
+the contiguous subarray [4,-1,2,1] has the largest sum = 6.
```
-空间复杂度可以优化成 O(1) 空间复杂度
-
```java
public int maxSubArray(int[] nums) {
- int max = nums[0];
- int oldsum = nums[0];
+ if (nums == null || nums.length == 0) return 0;
+ int preSum = nums[0];
+ int maxSum = preSum;
for (int i = 1; i < nums.length; i++) {
- oldsum = (oldsum > 0 ? oldsum: 0) + nums[i];
- max = Math.max(max, oldsum);
+ preSum = preSum > 0 ? preSum + nums[i] : nums[i];
+ maxSum = Math.max(maxSum, preSum);
}
- return max;
+ return maxSum;
}
```
@@ -2461,25 +2532,25 @@ public int maxSubArray(int[] nums) {
```html
A = [1, 2, 3, 4]
-
return: 3, for 3 arithmetic slices in A: [1, 2, 3], [2, 3, 4] and [1, 2, 3, 4] itself.
```
-对于 (1,2,3,4)，它有三种组成递增子区间的方式，而对于 (1,2,3,4,5)，它组成递增子区间的方式除了 (1,2,3,4) 的三种外还多了一种，即 (1,2,3,4,5)，因此 dp[i] = dp[i - 1] + 1。
+dp[i] 表示以 A[i] 为结尾的等差递增子区间的个数。
+
+如果 A[i] - A[i - 1] == A[i - 1] - A[i - 2]，表示 [A[i - 2], A[i - 1], A[i]] 是一个等差递增子区间。如果 [A[i - 3], A[i - 2], A[i - 1]] 是一个等差递增子区间，那么 [A[i - 3], A[i - 2], A[i - 1], A[i]] 也是。因此在这个条件下，dp[i] = dp[i-1] + 1。
```java
public int numberOfArithmeticSlices(int[] A) {
+ if (A == null || A.length == 0) return 0;
int n = A.length;
int[] dp = new int[n];
- for(int i = 2; i < n; i++) {
- if(A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
+ for (int i = 2; i < n; i++) {
+ if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
dp[i] = dp[i - 1] + 1;
}
}
int ret = 0;
- for(int cnt : dp) {
- ret += cnt;
- }
+ for (int cnt : dp) ret += cnt;
return ret;
}
```
@@ -2490,6 +2561,12 @@ public int numberOfArithmeticSlices(int[] A) {
[Leetcode : 583. Delete Operation for Two Strings (Medium)](https://leetcode.com/problems/delete-operation-for-two-strings/description/)
+```html
+Input: "sea", "eat"
+Output: 2
+Explanation: You need one step to make "sea" to "ea" and another step to make "eat" to "ea".
+```
+
可以转换为求两个字符串的最长公共子序列问题。
```java
@@ -2499,18 +2576,189 @@ public int minDistance(String word1, String word2) {
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
if (i == 0 || j == 0) continue;
- dp[i][j] = word1.charAt(i - 1) == word2.charAt(j - 1) ? dp[i - 1][j - 1] + 1
- : Math.max(dp[i][j - 1], dp[i - 1][j]);
+ dp[i][j] = word1.charAt(i - 1) == word2.charAt(j - 1) ?
+ dp[i - 1][j - 1] + 1 : Math.max(dp[i][j - 1], dp[i - 1][j]);
}
}
return m + n - 2 * dp[m][n];
}
```
-**修改一个字符串称为另一个字符串** // TODO
+**修改一个字符串称为另一个字符串**
[Leetcode : 72. Edit Distance (Hard)](https://leetcode.com/problems/edit-distance/description/)
+```java
+public int minDistance(String word1, String word2) {
+ if (word1 == null || word2 == null) {
+ return 0;
+ }
+ int m = word1.length(), n = word2.length();
+ int[][] dp = new int[m + 1][n + 1];
+ for (int i = 1; i <= m; i++) {
+ dp[i][0] = i;
+ }
+ for (int i = 1; i <= n; i++) {
+ dp[0][i] = i;
+ }
+ for (int i = 1; i <= m; i++) {
+ for (int j = 1; j <= n; j++) {
+ if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
+ dp[i][j] = dp[i - 1][j - 1];
+ } else {
+ dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i][j - 1], dp[i - 1][j])) + 1;
+ }
+ }
+ }
+ return dp[m][n];
+}
+```
+
+### 分割整数
+
+**分割整数的最大乘积**
+
+[Leetcode : 343. Integer Break (Medim)](https://leetcode.com/problems/integer-break/description/)
+
+题目描述：For example, given n = 2, return 1 (2 = 1 + 1); given n = 10, return 36 (10 = 3 + 3 + 4).
+
+```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 - 1; j++) {
+ dp[i] = Math.max(dp[i], Math.max(j * dp[i - j], j * (i - j)));
+ }
+ }
+ return dp[n];
+}
+```
+
+**按平方数来分割整数**
+
+[Leetcode : 279. Perfect Squares(Medium)](https://leetcode.com/problems/perfect-squares/description/)
+
+题目描述：For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.
+
+```java
+public int numSquares(int n) {
+ List squareList = generateSquareList(n);
+ int[] dp = new int[n + 1];
+ for (int i = 1; i <= n; i++) {
+ int max = Integer.MAX_VALUE;
+ for (int square : squareList) {
+ if (square > i) break;
+ max = Math.min(max, dp[i - square] + 1);
+ }
+ dp[i] = max;
+ }
+ return dp[n];
+}
+
+private List generateSquareList(int n) {
+ List squareList = new ArrayList<>();
+ int diff = 3;
+ int square = 1;
+ while (square <= n) {
+ squareList.add(square);
+ square += diff;
+ diff += 2;
+ }
+ return squareList;
+}
+```
+
+**分割整数构成字母字符串**
+
+[Leetcode : 91. Decode Ways (Medium)](https://leetcode.com/problems/decode-ways/description/)
+
+题目描述：Given encoded message "12", it could be decoded as "AB" (1 2) or "L" (12).
+
+```java
+public int numDecodings(String s) {
+ if(s == null || s.length() == 0) return 0;
+ int n = s.length();
+ int[] dp = new int[n + 1];
+ dp[0] = 1;
+ dp[1] = s.charAt(0) == '0' ? 0 : 1;
+ for(int i = 2; i <= n; i++) {
+ int one = Integer.valueOf(s.substring(i - 1, i));
+ if(one != 0) dp[i] += dp[i - 1];
+ if(s.charAt(i - 2) == '0') continue;
+ int two = Integer.valueOf(s.substring(i - 2, i));
+ if(two <= 26) dp[i] += dp[i - 2];
+ }
+ return dp[n];
+}
+```
+
+### 矩阵路径
+
+**矩阵的总路径数**
+
+[Leetcode : 62. Unique Paths (Medium)](https://leetcode.com/problems/unique-paths/description/)
+
+题目描述：统计从矩阵左上角到右下角的路径总数，每次只能向右或者向下移动。
+
+ st = new Stack();
public void push(int x) {
Stack temp = new Stack();
- while(!st.isEmpty()){
+ while (!st.isEmpty()) {
temp.push(st.pop());
}
st.push(x);
- while(!temp.isEmpty()){
+ while (!temp.isEmpty()) {
st.push(temp.pop());
}
}
@@ -3070,7 +3349,7 @@ class MyQueue {
两个栈实现：
```java
-class MyQueue {
+class MyQueue {
private Stack in = new Stack();
private Stack out = new Stack();
@@ -3088,9 +3367,9 @@ class MyQueue {
return out.peek();
}
- private void in2out(){
- if(out.isEmpty()){
- while(!in.isEmpty()){
+ private void in2out() {
+ if (out.isEmpty()) {
+ while (!in.isEmpty()) {
out.push(in.pop());
}
}
@@ -3117,8 +3396,9 @@ class MyStack {
public void push(int x) {
queue.add(x);
- for(int i = 1; i < queue.size(); i++){ // 翻转
- queue.add(queue.remove());
+ int cnt = queue.size();
+ while (cnt-- > 1) {
+ queue.add(queue.poll());
}
}
@@ -3157,20 +3437,14 @@ class MinStack {
public void push(int x) {
dataStack.add(x);
- if(x < min) {
- min = x;
- }
+ min = Math.min(min, x);
minStack.add(min);
}
public void pop() {
dataStack.pop();
minStack.pop();
- if(!minStack.isEmpty()) {
- min = minStack.peek();
- } else{
- min = Integer.MAX_VALUE;
- }
+ min = minStack.isEmpty() ? min = Integer.MAX_VALUE : minStack.peek();
}
public int top() {
@@ -3198,17 +3472,15 @@ Output : true
```java
public boolean isValid(String s) {
Stack stack = new Stack<>();
- for(int i = 0; i < s.length(); i++){
- char c = s.charAt(i);
- if(c == '(' || c == '{' || c == '[') stack.push(c);
- else{
- if(stack.isEmpty()) return false;
+ for (char c : s.toCharArray()) {
+ if (c == '(' || c == '{' || c == '[') stack.push(c);
+ else {
+ if (stack.isEmpty()) return false;
char cStack = stack.pop();
- if(c == ')' && cStack != '(' ||
- c == ']' && cStack != '[' ||
- c == '}' && cStack != '{' ) {
- return false;
- }
+ boolean b1 = c == ')' && cStack != '(';
+ boolean b2 = c == ']' && cStack != '[';
+ boolean b3 = c == '}' && cStack != '{';
+ if (b1 || b2 || b3) return false;
}
}
return stack.isEmpty();
@@ -3307,9 +3579,9 @@ HashMap 也可以用来对元素进行计数统计，此时键为元素，值为
[Leetcode : 1. Two Sum (Easy)](https://leetcode.com/problems/two-sum/description/)
-可以先对数组进行排序，然后使用双指针方法或者二分查找方法。这样做的时间复杂度为 O(nlgn )，空间复杂度为 O(1)。
+可以先对数组进行排序，然后使用双指针方法或者二分查找方法。这样做的时间复杂度为 O(NlogN)，空间复杂度为 O(1)。
-用 HashMap 存储数组元素和索引的映射，在访问到 nums[i] 时，判断 HashMap 中是否存在 target - nums[i] ，如果存在说明 target - nums[i] 所在的索引和 i 就是要找的两个数。该方法的时间复杂度为 O(n)，空间复杂度为 O(n)，使用空间来换取时间。
+用 HashMap 存储数组元素和索引的映射，在访问到 nums[i] 时，判断 HashMap 中是否存在 target - nums[i] ，如果存在说明 target - nums[i] 所在的索引和 i 就是要找的两个数。该方法的时间复杂度为 O(N)，空间复杂度为 O(N)，使用空间来换取时间。
```java
public int[] twoSum(int[] nums, int target) {
@@ -3322,6 +3594,18 @@ public int[] twoSum(int[] nums, int target) {
}
```
+**判断数组是否含有相同元素**
+
+[Leetcode : 217. Contains Duplicate (Easy)](https://leetcode.com/problems/contains-duplicate/description/)
+
+```java
+public boolean containsDuplicate(int[] nums) {
+ Set set = new HashSet<>();
+ for (int num : nums) set.add(num);
+ return set.size() < nums.length;
+}
+```
+
**最长和谐序列**
[Leetcode : 594. Longest Harmonious Subsequence (Easy)](https://leetcode.com/problems/longest-harmonious-subsequence/description/)
@@ -3350,6 +3634,45 @@ public int findLHS(int[] nums) {
}
```
+**最长连续序列**
+
+[Leetcode : 128. Longest Consecutive Sequence (Medium)](https://leetcode.com/problems/longest-consecutive-sequence/description/)
+
+```html
+Given [100, 4, 200, 1, 3, 2],
+The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.
+```
+
+```java
+public int longestConsecutive(int[] nums) {
+ Map numCnts = new HashMap<>();
+ for (int num : nums) {
+ numCnts.put(num, 1);
+ }
+ for (int num : nums) {
+ count(numCnts, num);
+ }
+ int max = 0;
+ for (int num : nums) {
+ max = Math.max(max, numCnts.get(num));
+ }
+ return max;
+}
+
+private int count(Map numCnts, int num) {
+ if (!numCnts.containsKey(num)) {
+ return 0;
+ }
+ int cnt = numCnts.get(num);
+ if (cnt > 1) {
+ return cnt;
+ }
+ cnt = count(numCnts, num + 1) + 1;
+ numCnts.put(num, cnt);
+ return cnt;
+}
+```
+
## 字符串
**两个字符串包含的字符是否完全相同**
@@ -3455,7 +3778,7 @@ Output: 6
Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
```
-解决方案是从字符串的某一位开始，尝试着去扩展子字符串。
+从字符串的某一位开始，尝试着去扩展子字符串。
```java
private int cnt = 0;
@@ -3545,18 +3868,229 @@ For example, given nums = [0, 1, 0, 3, 12], after calling your function, nums sh
```java
public void moveZeroes(int[] nums) {
- int n = nums.length;
int idx = 0;
- for(int i = 0; i < n; i++){
- if(nums[i] != 0) nums[idx++] = nums[i];
- }
- while(idx < n){
- nums[idx++] = 0;
- }
+ for (int num : nums) if (num != 0) nums[idx++] = num;
+ while (idx < nums.length) nums[idx++] = 0;
+}
+```
+
+**调整矩阵**
+
+[Leetcode : 566. Reshape the Matrix (Easy)](https://leetcode.com/problems/reshape-the-matrix/description/)
+
+```html
+Input:
+nums =
+[[1,2],
+ [3,4]]
+r = 1, c = 4
+Output:
+[[1,2,3,4]]
+Explanation:
+The row-traversing of nums is [1,2,3,4]. The new reshaped matrix is a 1 * 4 matrix, fill it row by row by using the previous list.
+```
+
+```java
+public int[][] matrixReshape(int[][] nums, int r, int c) {
+ int m = nums.length, n = nums[0].length;
+ if (m * n != r * c) return nums;
+ int[][] ret = new int[r][c];
+ int index = 0;
+ for (int i = 0; i < r; i++) {
+ for (int j = 0; j < c; j++) {
+ ret[i][j] = nums[index / n][index % n];
+ index++;
+ }
+ }
+ return ret;
+}
+```
+
+**找出数组中最长的连续 1**
+
+[Leetcode : 485. Max Consecutive Ones (Easy)](https://leetcode.com/problems/max-consecutive-ones/description/)
+
+```java
+public int findMaxConsecutiveOnes(int[] nums) {
+ int max = 0;
+ int cur = 0;
+ for (int num : nums) {
+ if (num == 0) cur = 0;
+ else {
+ cur++;
+ max = Math.max(max, cur);
+ }
+ }
+ return max;
+}
+```
+
+**数组相邻差值的个数**
+
+[Leetcode : 667. Beautiful Arrangement II (Medium)](https://leetcode.com/problems/beautiful-arrangement-ii/description/)
+
+```html
+Input: n = 3, k = 2
+Output: [1, 3, 2]
+Explanation: The [1, 3, 2] has three different positive integers ranging from 1 to 3, and the [2, 1] has exactly 2 distinct integers: 1 and 2.
+```
+
+题目描述：数组元素为 1\~n 的整数，要求构建数组，使得相邻元素的差值不相同的个数为 k。
+
+让前 k+1 个元素构建出 k 个不相同的差值，序列为：1 k+1 2 k 3 k-1 ... k/2 k/2+1.
+
+```java
+public int[] constructArray(int n, int k) {
+ int[] ret = new int[n];
+ ret[0] = 1;
+ for (int i = 1, interval = k; i <= k; i++, interval--) {
+ ret[i] = i % 2 == 1 ? ret[i - 1] + interval : ret[i - 1] - interval;
+ }
+ for (int i = k + 1; i < n; i++) {
+ ret[i] = i + 1;
+ }
+ return ret;
+}
+```
+
+**数组的度**
+
+[Leetcode : 697. Degree of an Array (Easy)](https://leetcode.com/problems/degree-of-an-array/description/)
+
+```html
+Input: [1,2,2,3,1,4,2]
+Output: 6
+```
+
+题目描述：数组的度定义为元素出现的最高频率，例如上面的数组度为 3。要求找到一个最小的子数组，这个子数组的度和原数组一样。
+
+```java
+public int findShortestSubArray(int[] nums) {
+ Map numsCnt = new HashMap<>();
+ Map numsLastIndex = new HashMap<>();
+ Map numsFirstIndex = new HashMap<>();
+ for (int i = 0; i < nums.length; i++) {
+ int num = nums[i];
+ numsCnt.put(num, numsCnt.getOrDefault(num, 0) + 1);
+ numsLastIndex.put(num, i);
+ if (!numsFirstIndex.containsKey(num)) {
+ numsFirstIndex.put(num, i);
+ }
+ }
+ int maxCnt = 0;
+ for (int num : nums) {
+ maxCnt = Math.max(maxCnt, numsCnt.get(num));
+ }
+ int ret = nums.length;
+ for (int i = 0; i < nums.length; i++) {
+ int num = nums[i];
+ int cnt = numsCnt.get(num);
+ if (cnt != maxCnt) continue;
+ ret = Math.min(ret, numsLastIndex.get(num) - numsFirstIndex.get(num) + 1);
+ }
+ return ret;
+}
+```
+
+**对角元素相等的矩阵**
+
+[Leetcode : 766. Toeplitz Matrix (Easy)](https://leetcode.com/problems/toeplitz-matrix/description/)
+
+```html
+1234
+5123
+9512
+
+In the above grid, the diagonals are "[9]", "[5, 5]", "[1, 1, 1]", "[2, 2, 2]", "[3, 3]", "[4]", and in each diagonal all elements are the same, so the answer is True.
+```
+
+```java
+public boolean isToeplitzMatrix(int[][] matrix) {
+ for (int i = 0; i < matrix[0].length; i++) {
+ if (!check(matrix, matrix[0][i], 0, i)) {
+ return false;
+ }
+ }
+ for (int i = 0; i < matrix.length; i++) {
+ if (!check(matrix, matrix[i][0], i, 0)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+private boolean check(int[][] matrix, int expectValue, int row, int col) {
+ if (row >= matrix.length || col >= matrix[0].length) {
+ return true;
+ }
+ if (matrix[row][col] != expectValue) {
+ return false;
+ }
+ return check(matrix, expectValue, row + 1, col + 1);
+}
+```
+
+**嵌套数组**
+
+[Leetcode : 565. Array Nesting (Medium)](https://leetcode.com/problems/array-nesting/description/)
+
+```html
+Input: A = [5,4,0,3,1,6,2]
+Output: 4
+Explanation:
+A[0] = 5, A[1] = 4, A[2] = 0, A[3] = 3, A[4] = 1, A[5] = 6, A[6] = 2.
+
+One of the longest S[K]:
+S[0] = {A[0], A[5], A[6], A[2]} = {5, 6, 2, 0}
+```
+
+题目描述：S[i] 表示一个集合，集合的第一个元素是 A[i]，第二个元素是 A[A[i]]，如此嵌套下去。求最大的 S[i]。
+
+```java
+public int arrayNesting(int[] nums) {
+ int max = 0;
+ for (int i = 0; i < nums.length; i++) {
+ int cnt = 0;
+ for (int j = i; nums[j] != -1; ) {
+ cnt++;
+ int t = nums[j];
+ nums[j] = -1; // 标记该位置已经被访问
+ j = t;
+
+ }
+ max = Math.max(max, cnt);
+ }
+ return max;
+}
+```
+
+**分隔数组**
+
+[Leetcode : 769. Max Chunks To Make Sorted (Medium)](https://leetcode.com/problems/max-chunks-to-make-sorted/description/)
+
+```html
+Input: arr = [1,0,2,3,4]
+Output: 4
+Explanation:
+We can split into two chunks, such as [1, 0], [2, 3, 4].
+However, splitting into [1, 0], [2], [3], [4] is the highest number of chunks possible.
+```
+
+题目描述：分隔数组，使得对每部分排序后数组就为有序。
+
+```java
+public int maxChunksToSorted(int[] arr) {
+ if (arr == null) return 0;
+ int ret = 0;
+ int right = arr[0];
+ for (int i = 0; i < arr.length; i++) {
+ right = Math.max(right, arr[i]);
+ if (right == i) ret++;
+ }
+ return ret;
}
```
-### 1-n 分布
**一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出丢失的数和重复的数**
@@ -3567,9 +4101,14 @@ Input: nums = [1,2,2,4]
Output: [2,3]
```
-最直接的方法是先对数组进行排序，这种方法时间复杂度为 O(nlogn ).本题可以以 O(n) 的时间复杂度、O(1) 空间复杂度来求解。
+```html
+Input: nums = [1,2,2,4]
+Output: [2,3]
+```
-主要思想是让通过交换数组元素，使得数组上的元素在正确的位置上
+最直接的方法是先对数组进行排序，这种方法时间复杂度为 O(nlogn)。本题可以以 O(n) 的时间复杂度、O(1) 空间复杂度来求解。
+
+主要思想是通过交换数组元素，使得数组上的元素在正确的位置上。
遍历数组，如果第 i 位上的元素不是 i + 1 ，那么就交换第 i 位 和 nums[i] - 1 位上的元素，使得 num[i] - 1 的元素为 nums[i] ，也就是该位的元素是正确的。交换操作需要循环进行，因为一次交换没办法使得第 i 位上的元素是正确的。但是要交换的两个元素可能就是重复元素，那么循环就可能永远进行下去，终止循环的方法是加上 nums[i] != nums[nums[i] - 1 条件。
@@ -3580,32 +4119,29 @@ Output: [2,3]
```java
public int[] findErrorNums(int[] nums) {
- for(int i = 0; i < nums.length; i++){
- while(nums[i] != i + 1 && nums[i] != nums[nums[i] - 1]) {
+ for (int i = 0; i < nums.length; i++) {
+ while (nums[i] != i + 1) {
+ if (nums[i] == nums[nums[i] - 1]) {
+ return new int[]{nums[nums[i] - 1], i + 1};
+ }
swap(nums, i, nums[i] - 1);
}
}
- for(int i = 0; i < nums.length; i++){
- if(i + 1 != nums[i]) {
- return new int[]{nums[i], i + 1};
- }
- }
-
return null;
}
-private void swap(int[] nums, int i, int j){
- int tmp = nums[i];
- nums[i] = nums[j];
- nums[j] = tmp;
+private void swap(int[] nums, int i, int j) {
+ int tmp = nums[i]; nums[i] = nums[j]; nums[j] = tmp;
}
```
-**找出数组中重复的数，数组值在 [0, n-1] 之间**
+**找出数组中重复的数，数组值在 [1, n] 之间**
[Leetcode : 287. Find the Duplicate Number (Medium)](https://leetcode.com/problems/find-the-duplicate-number/description/)
+要求不能修改数组，也不能使用额外的空间。
+
二分查找解法：
```java
@@ -3628,24 +4164,23 @@ public int findDuplicate(int[] nums) {
```java
public int findDuplicate(int[] nums) {
- int slow = nums[0], fast = nums[nums[0]];
- while (slow != fast) {
- slow = nums[slow];
- fast = nums[nums[fast]];
- }
-
- fast = 0;
- while (slow != fast) {
- slow = nums[slow];
- fast = nums[fast];
- }
- return slow;
+ int slow = nums[0], fast = nums[nums[0]];
+ while (slow != fast) {
+ slow = nums[slow];
+ fast = nums[nums[fast]];
+ }
+ fast = 0;
+ while (slow != fast) {
+ slow = nums[slow];
+ fast = nums[fast];
+ }
+ return slow;
}
```
-### 有序矩阵
+**有序矩阵查找**
-有序矩阵指的是行和列分别有序的矩阵。一般可以利用有序性使用二分查找方法。
+[Leetocde : 240. Search a 2D Matrix II (Medium)](https://leetcode.com/problems/search-a-2d-matrix-ii/description/)
```html
[
@@ -3655,10 +4190,6 @@ public int findDuplicate(int[] nums) {
]
```
-**有序矩阵查找**
-
-[Leetocde : 240. Search a 2D Matrix II (Medium)](https://leetcode.com/problems/search-a-2d-matrix-ii/description/)
-
```java
public boolean searchMatrix(int[][] matrix, int target) {
if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
@@ -3741,7 +4272,7 @@ class Tuple implements Comparable {
## 链表
-**判断两个链表的交点**
+**找出两个链表的交点**
[Leetcode : 160. Intersection of Two Linked Lists (Easy)](https://leetcode.com/problems/intersection-of-two-linked-lists/description/)
@@ -3818,6 +4349,11 @@ public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
[Leetcode : 83. Remove Duplicates from Sorted List (Easy)](https://leetcode.com/problems/remove-duplicates-from-sorted-list/description/)
+```html
+Given 1->1->2, return 1->2.
+Given 1->1->2->3->3, return 1->2->3.
+```
+
```java
public ListNode deleteDuplicates(ListNode head) {
if(head == null || head.next == null) return head;
@@ -3826,22 +4362,203 @@ public ListNode deleteDuplicates(ListNode head) {
}
```
+**删除链表的倒数第 n 个节点**
+
+[Leetcode : 19. Remove Nth Node From End of List (Medium)](https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/)
+
+```html
+Given linked list: 1->2->3->4->5, and n = 2.
+After removing the second node from the end, the linked list becomes 1->2->3->5.
+```
+
+```java
+public ListNode removeNthFromEnd(ListNode head, int n) {
+ ListNode newHead = new ListNode(-1);
+ newHead.next = head;
+ ListNode fast = newHead;
+ while (n-- > 0) {
+ fast = fast.next;
+ }
+ ListNode slow = newHead;
+ while (fast.next != null) {
+ fast = fast.next;
+ slow = slow.next;
+ }
+ slow.next = slow.next.next;
+ return newHead.next;
+}
+```
+
+**交换链表中的相邻结点**
+
+[Leetcode : 24. Swap Nodes in Pairs (Medium)](https://leetcode.com/problems/swap-nodes-in-pairs/description/)
+
+```html
+Given 1->2->3->4, you should return the list as 2->1->4->3.
+```
+
+题目要求：不能修改结点的 val 值；O(1) 空间复杂度。
+
+```java
+public ListNode swapPairs(ListNode head) {
+ ListNode newHead = new ListNode(-1);
+ newHead.next = head;
+ ListNode cur = head, pre = newHead;
+ while (cur != null && cur.next != null) {
+ ListNode next = cur.next;
+ pre.next = next;
+ cur.next = next.next;
+ next.next = cur;
+ pre = cur;
+ cur = cur.next;
+ }
+ return newHead.next;
+}
+```
+
+**根据有序链表构造平衡的 BST**
+
+[Leetcode : 109. Convert Sorted List to Binary Search Tree (Medium)](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/description/)
+
+```html
+Given the sorted linked list: [-10,-3,0,5,9],
+
+One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:
+
+ 0
+ / \
+ -3 9
+ / /
+ -10 5
+```
+
+```java
+public TreeNode sortedListToBST(ListNode head) {
+ if (head == null) return null;
+ int size = size(head);
+ if (size == 1) return new TreeNode(head.val);
+ ListNode pre = head, mid = pre.next;
+ int step = 2;
+ while (step <= size / 2) {
+ pre = mid;
+ mid = mid.next;
+ step++;
+ }
+ pre.next = null;
+ TreeNode t = new TreeNode(mid.val);
+ t.left = sortedListToBST(head);
+ t.right = sortedListToBST(mid.next);
+ return t;
+}
+
+private int size(ListNode node) {
+ int size = 0;
+ while (node != null) {
+ size++;
+ node = node.next;
+ }
+ return size;
+}
+```
+
+
+**链表求和**
+
+[Leetcode : 445. Add Two Numbers II (Medium)](https://leetcode.com/problems/add-two-numbers-ii/description/)
+
+```html
+Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
+Output: 7 -> 8 -> 0 -> 7
+```
+
+题目要求：不能修改原始链表。
+
+```java
+public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+ Stack l1Stack = buildStack(l1);
+ Stack l2Stack = buildStack(l2);
+ ListNode head = new ListNode(-1);
+ int carry = 0;
+ while (!l1Stack.isEmpty() || !l2Stack.isEmpty() || carry != 0) {
+ int x = l1Stack.isEmpty() ? 0 : l1Stack.pop();
+ int y = l2Stack.isEmpty() ? 0 : l2Stack.pop();
+ int sum = x + y + carry;
+ ListNode node = new ListNode(sum % 10);
+ node.next = head.next;
+ head.next = node;
+ carry = sum / 10;
+ }
+ return head.next;
+}
+
+private Stack buildStack(ListNode l) {
+ Stack stack = new Stack<>();
+ while (l != null) {
+ stack.push(l.val);
+ l = l.next;
+ }
+ return stack;
+}
+```
+
+**分隔链表**
+
+[Leetcode : 725. Split Linked List in Parts(Medium)](https://leetcode.com/problems/split-linked-list-in-parts/description/)
+
+```html
+Input:
+root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
+Output: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
+Explanation:
+The input has been split into consecutive parts with size difference at most 1, and earlier parts are a larger size than the later parts.
+```
+
+题目描述：把链表分隔成 k 部分，每部分的长度都应该尽可能相同，排在前面的长度应该大于等于后面的。
+
+```java
+public ListNode[] splitListToParts(ListNode root, int k) {
+ int N = 0;
+ ListNode cur = root;
+ while (cur != null) {
+ N++;
+ cur = cur.next;
+ }
+ int mod = N % k;
+ int size = N / k;
+ ListNode[] ret = new ListNode[k];
+ cur = root;
+ for (int i = 0; cur != null && i < k; i++) {
+ ret[i] = cur;
+ int curSize = size + (mod-- > 0 ? 1 : 0);
+ for (int j = 0; j < curSize - 1; j++) {
+ cur = cur.next;
+ }
+ ListNode next = cur.next;
+ cur.next = null;
+ cur = next;
+ }
+ return ret;
+}
+```
+
**回文链表**
[Leetcode : 234. Palindrome Linked List (Easy)](https://leetcode.com/problems/palindrome-linked-list/description/)
+要求以 O(1) 的空间复杂度来求解。
+
切成两半，把后半段反转，然后比较两半是否相等。
```java
public boolean isPalindrome(ListNode head) {
- if(head == null || head.next == null) return true;
+ if (head == null || head.next == null) return true;
ListNode slow = head, fast = head.next;
- while(fast != null && fast.next != null){
+ while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
- if(fast != null){ // 偶数节点，让 slow 指向下一个节点
+ if (fast != null) { // 偶数节点，让 slow 指向下一个节点
slow = slow.next;
}
@@ -3851,14 +4568,14 @@ public boolean isPalindrome(ListNode head) {
return isEqual(l1, l2);
}
-private void cut(ListNode head, ListNode cutNode){
- while( head.next != cutNode ) head = head.next;
+private void cut(ListNode head, ListNode cutNode) {
+ while (head.next != cutNode) head = head.next;
head.next = null;
}
-private ListNode reverse(ListNode head){
+private ListNode reverse(ListNode head) {
ListNode newHead = null;
- while(head != null){
+ while (head != null) {
ListNode nextNode = head.next;
head.next = newHead;
newHead = head;
@@ -3867,9 +4584,9 @@ private ListNode reverse(ListNode head){
return newHead;
}
-private boolean isEqual(ListNode l1, ListNode l2){
- while(l1 != null && l2 != null){
- if(l1.val != l2.val) return false;
+private boolean isEqual(ListNode l1, ListNode l2) {
+ while (l1 != null && l2 != null) {
+ if (l1.val != l2.val) return false;
l1 = l1.next;
l2 = l2.next;
}
@@ -4016,7 +4733,7 @@ Return 3. The paths that sum to 8 are:
3. -3 -> 11
```
-路径不一定以 root 开头并以 leaf 结尾，但是必须连续
+路径不一定以 root 开头，也不一定以 leaf 结尾，但是必须连续。
```java
public int pathSum(TreeNode root, int sum) {
@@ -4123,19 +4840,13 @@ There are two left leaves in the binary tree, with values 9 and 15 respectively.
```java
public int sumOfLeftLeaves(TreeNode root) {
- if(root == null) {
- return 0;
- }
- if(isLeaf(root.left)) {
- return root.left.val + sumOfLeftLeaves(root.right);
- }
+ if(root == null) return 0;
+ if(isLeaf(root.left)) return root.left.val + sumOfLeftLeaves(root.right);
return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
}
private boolean isLeaf(TreeNode node){
- if(node == null) {
- return false;
- }
+ if(node == null) return false;
return node.left == null && node.right == null;
}
```
@@ -4192,7 +4903,7 @@ Given tree s:
/ \
1 2
Given tree t:
- 4
+ 4
/ \
1 2
Return true, because t has the same structure and node values with a subtree of s.
@@ -4235,9 +4946,10 @@ private TreeNode toBST(int[] nums, int sIdx, int eIdx){
**两节点的最长路径**
+[Leetcode : 543. Diameter of Binary Tree (Easy)](https://leetcode.com/problems/diameter-of-binary-tree/description/)
+
```html
Input:
-
1
/ \
2 3
@@ -4247,8 +4959,6 @@ Input:
Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].
```
-[Leetcode : 543. Diameter of Binary Tree (Easy)](https://leetcode.com/problems/diameter-of-binary-tree/description/)
-
```java
private int max = 0;
@@ -4468,11 +5178,11 @@ public int findBottomLeftValue(TreeNode root) {
### 前中后序遍历
```html
- 1
- / \
- 2 3
- / \ \
-4 5 6
+ 1
+ / \
+ 2 3
+ / \ \
+4 5 6
```
层次遍历顺序：[1 2 3 4 5 6]
@@ -4521,14 +5231,14 @@ void dfs(TreeNode root){
```java
public List preorderTraversal(TreeNode root) {
List ret = new ArrayList<>();
- if (root == null) return ret;
Stack stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
+ if (node == null) continue;
ret.add(node.val);
- if (node.right != null) stack.push(node.right);
- if (node.left != null) stack.push(node.left); // 先添加右子树再添加左子树，这样是为了让左子树在栈顶
+ stack.push(node.right); // 先右后左，保证左子树先遍历
+ stack.push(node.left);
}
return ret;
}
@@ -4543,14 +5253,14 @@ public List preorderTraversal(TreeNode root) {
```java
public List postorderTraversal(TreeNode root) {
List ret = new ArrayList<>();
- if (root == null) return ret;
Stack stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
+ if (node == null) continue;
ret.add(node.val);
- if (node.left != null) stack.push(node.left);
- if (node.right != null) stack.push(node.right);
+ stack.push(node.left);
+ stack.push(node.right);
}
Collections.reverse(ret);
return ret;
@@ -4564,11 +5274,12 @@ public List postorderTraversal(TreeNode root) {
```java
public List inorderTraversal(TreeNode root) {
List ret = new ArrayList<>();
+ if (root == null) return ret;
Stack stack = new Stack<>();
TreeNode cur = root;
- while(cur != null || !stack.isEmpty()) {
- while(cur != null) { // 模拟递归栈的不断深入
- stack.add(cur);
+ while (cur != null || !stack.isEmpty()) {
+ while (cur != null) {
+ stack.push(cur);
cur = cur.left;
}
TreeNode node = stack.pop();
@@ -4588,7 +5299,7 @@ public List inorderTraversal(TreeNode root) {
[653. Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/)
```html
-Input:
+Input:
5
/ \
3 6
@@ -4689,17 +5400,11 @@ public TreeNode convertBST(TreeNode root) {
}
private void traver(TreeNode root) {
- if (root == null) {
- return;
- }
- if (root.right != null) {
- traver(root.right);
- }
+ if (root == null) return;
+ if (root.right != null) traver(root.right);
sum += root.val;
root.val = sum;
- if (root.left != null) {
- traver(root.left);
- }
+ if (root.left != null) traver(root.left);
}
```
@@ -4724,31 +5429,31 @@ private List list;
public int[] findMode(TreeNode root) {
list = new ArrayList<>();
- inorder(root);
+ inOrder(root);
int[] ret = new int[list.size()];
int idx = 0;
- for(int num : list){
+ for (int num : list) {
ret[idx++] = num;
}
return ret;
}
-private void inorder(TreeNode node){
- if(node == null) return;
- inorder(node.left);
- if(preNode != null){
- if(preNode.val == node.val) cnt++;
+private void inOrder(TreeNode node) {
+ if (node == null) return;
+ inOrder(node.left);
+ if (preNode != null) {
+ if (preNode.val == node.val) cnt++;
else cnt = 1;
}
- if(cnt > maxCnt){
+ if (cnt > maxCnt) {
maxCnt = cnt;
list.clear();
list.add(node.val);
- } else if(cnt == maxCnt){
+ } else if (cnt == maxCnt) {
list.add(node.val);
}
preNode = node;
- inorder(node.right);
+ inOrder(node.right);
}
```
@@ -4779,19 +5484,19 @@ private int cnt = 0;
private int val;
public int kthSmallest(TreeNode root, int k) {
- inorder(root, k);
+ inOrder(root, k);
return val;
}
-private void inorder(TreeNode node, int k) {
- if(node == null) return;
- inorder(node.left, k);
+private void inOrder(TreeNode node, int k) {
+ if (node == null) return;
+ inOrder(node.left, k);
cnt++;
- if(cnt == k) {
+ if (cnt == k) {
val = node.val;
return;
}
- inorder(node.right, k);
+ inOrder(node.right, k);
}
```
@@ -4808,33 +5513,24 @@ Trie，又称前缀树或字典树，用于判断字符串是否存在或者是
```java
class Trie {
- private class Node{
- Node[] childs = new Node[26];
- boolean isLeaf;
- }
-
private Node root = new Node();
- /** Initialize your data structure here. */
public Trie() {
}
- /** Inserts a word into the trie. */
public void insert(String word) {
- int idx = word.charAt(0) - 'a';
insert(word, root);
}
private void insert(String word, Node node){
int idx = word.charAt(0) - 'a';
- if(node.childs[idx] == null){
- node.childs[idx] = new Node();
+ if(node.child[idx] == null){
+ node.child[idx] = new Node();
}
- if(word.length() == 1) node.childs[idx].isLeaf = true;
- else insert(word.substring(1), node.childs[idx]);
+ if(word.length() == 1) node.child[idx].isLeaf = true;
+ else insert(word.substring(1), node.child[idx]);
}
- /** Returns if the word is in the trie. */
public boolean search(String word) {
return search(word, root);
}
@@ -4842,12 +5538,11 @@ class Trie {
private boolean search(String word, Node node){
if(node == null) return false;
int idx = word.charAt(0) - 'a';
- if(node.childs[idx] == null) return false;
- if(word.length() == 1) return node.childs[idx].isLeaf;
- return search(word.substring(1), node.childs[idx]);
+ if(node.child[idx] == null) return false;
+ if(word.length() == 1) return node.child[idx].isLeaf;
+ return search(word.substring(1), node.child[idx]);
}
- /** Returns if there is any word in the trie that starts with the given prefix. */
public boolean startsWith(String prefix) {
return startWith(prefix, root);
}
@@ -4856,7 +5551,12 @@ class Trie {
if(node == null) return false;
if(prefix.length() == 0) return true;
int idx = prefix.charAt(0) - 'a';
- return startWith(prefix.substring(1), node.childs[idx]);
+ return startWith(prefix.substring(1), node.child[idx]);
+ }
+
+ private class Node{
+ Node[] child = new Node[26];
+ boolean isLeaf;
}
}
```
@@ -4874,51 +5574,50 @@ Input: sum("ap"), Output: 5
```java
class MapSum {
- private class Trie {
- int val;
- Map childs;
- boolean isWord;
- Trie() {
- childs = new HashMap<>();
- }
+ private class Node {
+ Node[] child = new Node[26];
+ int value;
}
- private Trie root;
+ private Node root = new Node();
public MapSum() {
- root = new Trie();
+
}
public void insert(String key, int val) {
- Trie cur = root;
- for(char c : key.toCharArray()) {
- if(!cur.childs.containsKey(c)) {
- Trie next = new Trie();
- cur.childs.put(c, next);
- }
- cur = cur.childs.get(c);
+ insert(key, root, val);
+ }
+
+ private void insert(String key, Node node, int val) {
+ int idx = key.charAt(0) - 'a';
+ if (node.child[idx] == null) {
+ node.child[idx] = new Node();
+ }
+ if (key.length() == 1) {
+ node.child[idx].value = val;
+ } else {
+ insert(key.substring(1), node.child[idx], val);
}
- cur.val = val;
- cur.isWord = true;
}
public int sum(String prefix) {
- Trie cur = root;
- for(char c : prefix.toCharArray()) {
- if(!cur.childs.containsKey(c)) return 0;
- cur = cur.childs.get(c);
- }
- return dfs(cur);
+ return sum(prefix, root);
}
- private int dfs(Trie cur) {
- int sum = 0;
- if(cur.isWord) {
- sum += cur.val;
+ private int sum(String prefix, Node node) {
+ if (node == null) {
+ return 0;
}
- for(Trie next : cur.childs.values()) {
- sum += dfs(next);
+ int sum = node.value;
+ if (prefix.length() == 0) {
+ for (Node next : node.child) {
+ sum += sum(prefix, next);
+ }
+ } else {
+ int idx = prefix.charAt(0) - 'a';
+ sum = sum(prefix.substring(1), node.child[idx]);
}
return sum;
}
@@ -4927,11 +5626,71 @@ class MapSum {
## 图
+**冗余连接**
+
+[Leetcode : 684. Redundant Connection (Medium)](https://leetcode.com/problems/redundant-connection/description/)
+
+```html
+Input: [[1,2], [1,3], [2,3]]
+Output: [2,3]
+Explanation: The given undirected graph will be like this:
+ 1
+ / \
+2 - 3
+```
+
+题目描述：有一系列的边连成的图，找出一条边，移除它之后该图能够成为一棵树。
+
+使用 Union-Find。
+
+```java
+public int[] findRedundantConnection(int[][] edges) {
+ int N = edges.length;
+ UF uf = new UF(N);
+ for (int[] e : edges) {
+ int u = e[0], v = e[1];
+ if (uf.find(u) == uf.find(v)) {
+ return e;
+ }
+ uf.union(u, v);
+ }
+ return new int[]{-1, -1};
+}
+
+private class UF {
+ int[] id;
+
+ UF(int N) {
+ id = new int[N + 1];
+ for (int i = 0; i < id.length; i++) {
+ id[i] = i;
+ }
+ }
+
+ void union(int u, int v) {
+ int uID = find(u);
+ int vID = find(v);
+ if (uID == vID) {
+ return;
+ }
+ for (int i = 0; i < id.length; i++) {
+ if (id[i] == uID) {
+ id[i] = vID;
+ }
+ }
+ }
+
+ int find(int p) {
+ return id[p];
+ }
+}
+```
+
## 位运算
**1. 基本原理**
-0s 表示 一串 0 ，1s 表示一串 1。
+0s 表示一串 0，1s 表示一串 1。
```
x ^ 0s = x x & 0s = 0 x | 0s = x
@@ -4939,9 +5698,9 @@ x ^ 1s = ~x x & 1s = x x | 1s = 1s
x ^ x = 0 x & x = x x | x = x
```
-① 利用 x ^ 1s = \~x 的特点，可以将位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数；
-② 利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask ：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位；
-③ 利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设置操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1 。
+- 利用 x ^ 1s = \~x 的特点，可以将位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数；
+- 利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask ：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位；
+- 利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设值操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1 。
\>\> n 为算术右移，相当于除以 2n ；
\>\>\> n 为无符号右移，左边会补上 0。
@@ -4949,7 +5708,7 @@ x ^ x = 0 x & x = x x | x = x
n&(n-1) 该位运算是去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110 **100** ，减去 1 得到 10110**011**，这两个数相与得到 10110**000**。
-n-n&(\~n+1) 概运算是去除 n 的位级表示中最高的那一位。
+n-n&(\~n+1) 运算是去除 n 的位级表示中最高的那一位。
n&(-n) 该运算得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110 **100** ，-n 得到 01001**100**，相与得到 00000**100**
@@ -4957,7 +5716,7 @@ n&(-n) 该运算得到 n 的位级表示中最低的那一位。-n 得到 n 的
要获取 111111111，将 0 取反即可，\~0。
-要得到只有第 i 位为 1 的 mask，将 1 向左移动 i 位即可，1<<i 。例如 1<<5 得到只有第 5 位为 1 的 mask ：00010000。
+要得到只有第 i 位为 1 的 mask，将 1 向左移动 i-1 位即可，1<<(i-1) 。例如 1<<4 得到只有第 5 位为 1 的 mask ：00010000。
要得到 1 到 i 位为 1 的 mask，1<<(i+1)-1 即可，例如将 1<<(4+1)-1 = 00010000-1 = 00001111。
@@ -5016,16 +5775,16 @@ num & (~((1 << (i+1)) - 1));
**4. Java 中的位操作**
```html
-static int Integer.bitCount() // 统计 1 的数量
-static int Integer.highestOneBit() // 获得最高位
-static String toBinaryString(int i) // 转换位二进制表示的字符串
+static int Integer.bitCount(); // 统计 1 的数量
+static int Integer.highestOneBit(); // 获得最高位
+static String toBinaryString(int i); // 转换为二进制表示的字符串
```
**统计两个数的二进制表示有多少位不同**
[Leetcode : 461. Hamming Distance (Easy)](https://leetcode.com/problems/hamming-distance/)
-对两个数进行异或操作，不同的那一位结果为 1 ，统计有多少个 1 即可。
+对两个数进行异或操作，位级表示不同的那一位为 1，统计有多少个 1 即可。
```java
public int hammingDistance(int x, int y) {
@@ -5047,6 +5806,28 @@ public int hammingDistance(int x, int y) {
}
```
+**找出数组中缺失的那个数**
+
+[Leetcode : 268. Missing Number (Easy)](https://leetcode.com/problems/missing-number/description/)
+
+```html
+Input: [3,0,1]
+Output: 2
+```
+
+题目描述：数组元素在 0-n 之间，但是有一个数是缺失的，要求找到这个缺失的数。
+ `
+
+```java
+public int missingNumber(int[] nums) {
+ int ret = 0;
+ for (int i = 0; i <= nums.length; i++) {
+ ret = i == nums.length ? ret ^ i : ret ^ i ^ nums[i];
+ }
+ return ret;
+}
+```
+
**翻转一个数的比特位**
[Leetcode : 190. Reverse Bits (Easy)](https://leetcode.com/problems/reverse-bits/description/)
@@ -5054,7 +5835,7 @@ public int hammingDistance(int x, int y) {
```java
public int reverseBits(int n) {
int ret = 0;
- for(int i = 0; i < 32; i++){
+ for (int i = 0; i < 32; i++) {
ret <<= 1;
ret |= (n & 1);
n >>>= 1;
@@ -5063,6 +5844,37 @@ public int reverseBits(int n) {
}
```
+如果该函数需要被调用很多次，可以将 int 拆成 4 个 byte，然后缓存 byte 对应的比特位翻转，最后再拼接起来。
+
+```java
+private static Map cache = new HashMap<>();
+
+public int reverseBits(int n) {
+ int ret = 0;
+ for (int i = 0; i < 4; i++) {
+ byte b = (byte) (n & 0b11111111);
+ ret <<= 8;
+ ret |= reverseByte(b);
+ n >>= 8;
+ }
+ return ret;
+
+}
+
+private int reverseByte(byte b) {
+ if (cache.containsKey(b)) return cache.get(b);
+ int ret = 0;
+ byte t = b;
+ for (int i = 0; i < 8; i++) {
+ ret <<= 1;
+ ret |= t & 1;
+ t >>= 1;
+ }
+ cache.put(b, ret);
+ return ret;
+}
+```
+
**不用额外变量交换两个整数**
[程序员代码面试指南 ：P317](#)
@@ -5073,38 +5885,13 @@ b = a ^ b;
a = a ^ b;
```
-将 c = a ^ b，那么 b ^ c = b ^ b ^ a = a，a ^ c = a ^ a ^ b = b。
-
-**判断一个数是不是 4 的 n 次方**
-
-[Leetcode : 342. Power of Four (Easy)](https://leetcode.com/problems/power-of-four/)
-
-该数二进制表示有且只有一个奇数位为 1 ，其余的都为 0 ，例如 16 ： 10000。可以每次把 1 向左移动 2 位，就能构造出这种数字，然后比较构造出来的数与要判断的数是否相同。
-
-```java
-public boolean isPowerOfFour(int num) {
- int i = 1;
- while(i > 0){
- if(i == num) return true;
- i = i << 2;
- }
- return false;
-}
-```
-
-也可以用 Java 的 Integer.toString() 方法将该数转换为 4 进制形式的字符串，然后判断字符串是否以 1 开头。
-
-```java
-public boolean isPowerOfFour(int num) {
- return Integer.toString(num, 4).matches("10*");
-}
-```
+令 c = a ^ b，那么 b ^ c = b ^ b ^ a = a，a ^ c = a ^ a ^ b = b。
**判断一个数是不是 2 的 n 次方**
[Leetcode : 231. Power of Two (Easy)](https://leetcode.com/problems/power-of-two/description/)
-同样可以用 Power of Four 的方法，但是 2 的 n 次方更特殊，它的二进制表示只有一个 1 存在。
+二进制表示只有一个 1 存在。
```java
public boolean isPowerOfTwo(int n) {
@@ -5120,6 +5907,35 @@ public boolean isPowerOfTwo(int n) {
}
```
+**判断一个数是不是 4 的 n 次方**
+
+[Leetcode : 342. Power of Four (Easy)](https://leetcode.com/problems/power-of-four/)
+
+该数二进制表示有且只有一个奇数位为 1 ，其余的都为 0 ，例如 16 ：10000。可以每次把 1 向左移动 2 位，就能构造出这种数字，然后比较构造出来的数与要判断的数是否相同。
+
+```java
+public boolean isPowerOfFour(int num) {
+ int i = 1;
+ while(i > 0){
+ if(i == num) return true;
+ i = i << 2;
+ }
+ return false;
+}
+```
+
+```java
+public boolean isPowerOfFour(int num) {
+ return Integer.toString(num, 4).matches("10*");
+}
+```
+
+```java
+public boolean isPowerOfFour(int num) {
+ return num > 0 && (num & (num - 1)) == 0 && (num & 0b01010101010101010101010101010101) != 0;
+}
+```
+
**数组中唯一一个不重复的元素**
[Leetcode : 136. Single Number (Easy)](https://leetcode.com/problems/single-number/description/)
@@ -5178,7 +5994,13 @@ public boolean hasAlternatingBits(int n) {
[Leetcode : 476. Number Complement (Easy)](https://leetcode.com/problems/number-complement/description/)
-不考虑二进制表示中的首 0 部分
+```html
+Input: 5
+Output: 2
+Explanation: The binary representation of 5 is 101 (no leading zero bits), and its complement is 010. So you need to output 2.
+```
+
+不考虑二进制表示中的首 0 部分。
对于 00000101，要求补码可以将它与 00000111 进行异或操作。那么问题就转换为求掩码 00000111。
@@ -5239,6 +6061,12 @@ public int getSum(int a, int b) {
[Leetcode : 318. Maximum Product of Word Lengths (Medium)](https://leetcode.com/problems/maximum-product-of-word-lengths/description/)
+```html
+Given ["abcw", "baz", "foo", "bar", "xtfn", "abcdef"]
+Return 16
+The two words can be "abcw", "xtfn".
+```
+
题目描述：字符串数组的字符串只含有小写字符。求解字符串数组中两个字符串长度的最大乘积，要求这两个字符串不能含有相同字符。
解题思路：本题主要问题是判断两个字符串是否含相同字符，由于字符串只含有小写字符，总共 26 位，因此可以用一个 32 位的整数来存储每个字符是否出现过。
@@ -5265,6 +6093,22 @@ public int maxProduct(String[] words) {
}
```
+**统计从 0 \~ n 每个数的二进制表示中 1 的个数**
+
+[Leetcode : 338. Counting Bits (Medium)](https://leetcode.com/problems/counting-bits/description/)
+
+对于数字 6(110)，它可以看成是数字 (10) 前面加上一个 1 ，因此 dp[i] = dp[i&(i-1)] + 1;
+
+```java
+public int[] countBits(int num) {
+ int[] ret = new int[num + 1];
+ for(int i = 1; i <= num; i++){
+ ret[i] = ret[i&(i-1)] + 1;
+ }
+ return ret;
+}
+```
+
# 参考资料
- [Leetcode](https://leetcode.com/problemset/algorithms/?status=Todo)
diff --git a/notes/Linux.md b/notes/Linux.md
index 2c072e75..dbeddf16 100644
--- a/notes/Linux.md
+++ b/notes/Linux.md
@@ -1,121 +1,99 @@
-* [常用操作以及概念](#常用操作以及概念)
+* [一、常用操作以及概念](#一常用操作以及概念)
* [求助](#求助)
* [关机](#关机)
- * [查看进程](#查看进程)
- * [查看端口](#查看端口)
* [PATH](#path)
* [运行等级](#运行等级)
* [sudo](#sudo)
* [GNU](#gnu)
* [包管理工具](#包管理工具)
- * [常见发行版本](#常见发行版本)
-* [分区](#分区)
+ * [发行版](#发行版)
+ * [VIM 三个模式](#vim-三个模式)
+* [二、分区](#二分区)
* [磁盘的文件名](#磁盘的文件名)
* [分区表](#分区表)
- * [1. MBR](#1-mbr)
- * [2. GPT](#2-gpt)
* [开机检测程序](#开机检测程序)
- * [1. BIOS](#1-bios)
- * [2. UEFI](#2-uefi)
* [挂载](#挂载)
-* [文件权限与目录配置](#文件权限与目录配置)
+* [三、文件](#三文件)
* [文件权限概念](#文件权限概念)
* [文件属性以及权限的修改](#文件属性以及权限的修改)
- * [1. 修改文件所属群组](#1-修改文件所属群组)
- * [2. 修改文件拥有者](#2-修改文件拥有者)
- * [3. 修改权限](#3-修改权限)
* [目录的权限](#目录的权限)
* [文件默认权限](#文件默认权限)
* [目录配置](#目录配置)
-* [文件与目录](#文件与目录)
* [文件时间](#文件时间)
* [文件与目录的基本操作](#文件与目录的基本操作)
- * [1. ls](#1-ls)
- * [2. cp](#2-cp)
- * [3. rm](#3-rm)
- * [4. mv](#4-mv)
* [获取文件内容](#获取文件内容)
- * [1. cat](#1-cat)
- * [2. tac](#2-tac)
- * [3. more](#3-more)
- * [4. less](#4-less)
- * [5. head](#5-head)
- * [6. tail](#6-tail)
- * [7. od](#7-od)
- * [8. touch](#8-touch)
* [指令与文件搜索](#指令与文件搜索)
- * [1. which](#1-which)
- * [2. whereis](#2-whereis)
- * [3. locate](#3-locate)
- * [4. find](#4-find)
- * [4.1 与时间有关的选项](#41-与时间有关的选项)
- * [4.2 与文件拥有者和所属群组有关的选项](#42-与文件拥有者和所属群组有关的选项)
- * [4.3 与文件权限和名称有关的选项](#43-与文件权限和名称有关的选项)
-* [磁盘与文件系统](#磁盘与文件系统)
+* [四、磁盘与文件系统](#四磁盘与文件系统)
* [文件系统的组成](#文件系统的组成)
* [inode](#inode)
* [目录的 inode 与 block](#目录的-inode-与-block)
* [实体链接与符号链接](#实体链接与符号链接)
- * [1. 实体链接](#1-实体链接)
- * [2. 符号链接](#2-符号链接)
-* [压缩与打包](#压缩与打包)
+* [五、压缩与打包](#五压缩与打包)
* [压缩](#压缩)
- * [1. gzip](#1-gzip)
- * [2. bzip2](#2-bzip2)
- * [3. xz](#3-xz)
* [打包](#打包)
-* [Bash](#bash)
- * [Bash 特性](#bash-特性)
+* [六、Bash](#六bash)
+ * [特性](#特性)
* [变量操作](#变量操作)
* [指令搜索顺序](#指令搜索顺序)
* [数据流重定向](#数据流重定向)
- * [管线指令](#管线指令)
- * [1. 提取指令：cut](#1-提取指令cut)
- * [2. 排序命令：sort、uniq](#2-排序命令sortuniq)
- * [3. 双向输出重定向：tee](#3-双向输出重定向tee)
- * [4. 字符转换指令：tr、col、expand、join、paste](#4-字符转换指令trcolexpandjoinpaste)
- * [5. 分区指令：split](#5-分区指令split)
-* [正规表示法与文件格式化处理](#正规表示法与文件格式化处理)
+* [七、管线指令](#七管线指令)
+ * [提取指令](#提取指令)
+ * [排序指令](#排序指令)
+ * [双向输出重定向](#双向输出重定向)
+ * [字符转换指令](#字符转换指令)
+ * [分区指令](#分区指令)
+* [八、正则表达式](#八正则表达式)
* [grep](#grep)
* [printf](#printf)
* [awk](#awk)
-* [vim 三个模式](#vim-三个模式)
+* [九、进程管理](#九进程管理)
+ * [查看进程](#查看进程)
+ * [进程状态](#进程状态)
+ * [SIGCHILD](#sigchild)
+ * [孤儿进程和僵死进程](#孤儿进程和僵死进程)
+* [十、I/O 复用](#十io-复用)
+ * [概念理解](#概念理解)
+ * [I/O 模型](#io-模型)
+ * [select poll epoll](#select-poll-epoll)
+ * [select 和 poll 比较](#select-和-poll-比较)
+ * [eopll 工作模式](#eopll-工作模式)
+ * [select poll epoll 应用场景](#select-poll-epoll-应用场景)
* [参考资料](#参考资料)
-# 常用操作以及概念
+# 一、常用操作以及概念
## 求助
-**1. --help**
+### 1. --help
指令的基本用法与选项介绍。
-**2. man**
+### 2. man
man 是 manual 的缩写，将指令的具体信息显示出来。
当执行 man date 时，有 DATE(1) 出现，其中的数字代表指令的类型，常用的数字及其类型如下：
| 代号 | 类型 |
-| -- | -- |
+| :--: | -- |
| 1 | 用户在 shell 环境中可以操作的指令或者可执行文件 |
| 5 | 配置文件 |
| 8 | 系统管理员可以使用的管理指令 |
-**3. info**
+### 3. info
info 与 man 类似，但是 info 将文档分成一个个页面，每个页面可以进行跳转。
## 关机
-**1. sync**
+### 1. sync
-为了加快对磁盘上文件的读写速度，位于内存中的文件数据不会立即同步到磁盘上，因此关机之前需要先进行 sync 同步操作。
+为了加快对磁盘文件的读写速度，位于内存中的文件数据不会立即同步到磁盘上，因此关机之前需要先进行 sync 同步操作。
-**2. shutdown**
+### 2. shutdown
```html
# /sbin/shutdown [-krhc] [时间] [警告讯息]
@@ -125,22 +103,10 @@ info 与 man 类似，但是 info 将文档分成一个个页面，每个页面
-c ： 取消已经在进行的 shutdown 指令内容
```
-**3. 其它关机指令**
+### 3. 其它关机指令
reboot、halt、poweroff。
-## 查看进程
-
-```html
-ps aux | grep threadx
-```
-
-## 查看端口
-
-```html
-netstat -anp | grep 80
-```
-
## PATH
可以在环境变量 PATH 中声明可执行文件的路径，路径之间用 : 分隔。
@@ -165,7 +131,7 @@ netstat -anp | grep 80
## GNU
-GNU 计划，又译为革奴计划，它的目标是创建一套完全自由的操作系统，称为 GNU，其内容软件完全以 GPL 方式发布。其中 GPL 全称为 GNU 通用公共许可协议，包含了以下内容：
+GNU 计划，译为革奴计划，它的目标是创建一套完全自由的操作系统，称为 GNU，其内容软件完全以 GPL 方式发布。其中 GPL 全称为 GNU 通用公共许可协议，包含了以下内容：
- 以任何目的运行此程序的自由；
- 再复制的自由；
@@ -177,7 +143,7 @@ RPM 和 DPKG 为最常见的两类软件包管理工具。RPM 全称为 Redhat P
YUM 基于 RPM 包管理工具，具有依赖管理功能，并具有软件升级的功能。
-## 常见发行版本
+## 发行版
Linux 发行版是 Linux 内核及各种应用软件的集成版本。
@@ -186,13 +152,30 @@ Linux 发行版是 Linux 内核及各种应用软件的集成版本。
| DPKG | Ubuntu | Debian |
| RPM | Red Hat | Fedora / CentOS |
-# 分区
+## VIM 三个模式
+
+- 一般指令模式（Command mode）：进入 VIM 的默认模式，可以用于移动游标查看内容；
+- 编辑模式（Insert mode）：按下 "i" 等按键之后进入，可以对文本进行编辑；
+- 指令列模式（Bottom-line mode）：按下 ":" 按键之后进入，用于保存退出等操作。
+
+d N)。一般实际应用中，出度 d 是非常大的数字，通常超过 100，因此 h 非常小（通常不超过 3）。而红黑树这种结构，h 明显要深的多。并且于逻辑上很近的节点（父子）物理上可能很远，无法利用局部性，效率明显比 B-Tree 差很多。
B+Tree 更适合外存索引，原因和内节点出度 d 有关。由于 B+Tree 内节点去掉了 data 域，因此可以拥有更大的出度，拥有更好的性能。
-# 查询性能优化
+# 四、查询性能优化
-## 1. Explain
+### Explain
用来分析 SQL 语句，分析结果中比较重要的字段有：
@@ -318,29 +298,30 @@ B+Tree 更适合外存索引，原因和内节点出度 d 有关。由于 B+Tree
- rows : 扫描的行数
-## 2. 减少返回的列
+### 减少返回的列
慢查询主要是因为访问了过多数据，除了访问过多行之外，也包括访问过多列。
最好不要使用 SELECT * 语句，要根据需要选择查询的列。
-## 3. 减少返回的行
+### 减少返回的行
最好使用 LIMIT 语句来取出想要的那些行。
-还可以建立索引来减少条件语句的全表扫描。例如对于下面的语句，不适用索引的情况下需要进行全表扫描，而使用索引只需要扫描几行记录即可，使用 Explain 语句可以通过观察 rows 字段来看出这种差异。
+还可以建立索引来减少条件语句的全表扫描。例如对于下面的语句，不使用索引的情况下需要进行全表扫描，而使用索引只需要扫描几行记录即可，使用 Explain 语句可以通过观察 rows 字段来看出这种差异。
```sql
SELECT * FROM sakila.film_actor WHERE film_id = 1;
```
-## 4. 拆分大的 DELETE 或 INSERT 语句
+### 拆分大的 DELETE 或 INSERT 语句
如果一次性执行的话，可能一次锁住很多数据、占满整个事务日志、耗尽系统资源、阻塞很多小的但重要的查询。
```sql
DELEFT FROM messages WHERE create < DATE_SUB(NOW(), INTERVAL 3 MONTH);
```
+
```sql
rows_affected = 0
do {
@@ -349,74 +330,64 @@ do {
} while rows_affected > 0
```
-# 分库与分表
+# 五、切分
-**1. 分表与分区的不同**
-
-分表，就是讲一张表分成多个小表，这些小表拥有不同的表名；而分区是将一张表的数据分为多个区块，这些区块可以存储在同一个磁盘上，也可以存储在不同的磁盘上，这种方式下表仍然只有一个。
-
-**2. 使用分库与分表的原因**
随着时间和业务的发展，数据库中的表会越来越多，并且表中的数据量也会越来越大，那么读写操作的开销也会随着增大。
-**3. 垂直切分**
+## 垂直切分
将表按功能模块、关系密切程度划分出来，部署到不同的库上。例如，我们会建立商品数据库 payDB、用户数据库 userDB 等，分别用来存储项目与商品有关的表和与用户有关的表。
-**4. 水平切分**
+## 水平切分
-把表中的数据按照某种规则存储到多个结构相同的表中，例如按 id 的散列值、性别等进行划分，
+把表中的数据按照某种规则存储到多个结构相同的表中，例如按 id 的散列值、性别等进行划分。
-**5. 垂直切分与水平切分的选择**
+## 切分的选择
如果数据库中的表太多，并且项目各项业务逻辑清晰，那么垂直切分是首选。
如果数据库的表不多，但是单表的数据量很大，应该选择水平切分。
-**6. 水平切分的实现方式**
+## 存在的问题
-最简单的是使用 merge 存储引擎。
-
-**7. 分库与分表存在的问题**
-
-(1) 事务问题
+### 1. 事务问题
在执行分库分表之后，由于数据存储到了不同的库上，数据库事务管理出现了困难。如果依赖数据库本身的分布式事务管理功能去执行事务，将付出高昂的性能代价；如果由应用程序去协助控制，形成程序逻辑上的事务，又会造成编程方面的负担。
-(2) 跨库跨表连接问题
+### 2. 跨库跨表连接问题
在执行了分库分表之后，难以避免会将原本逻辑关联性很强的数据划分到不同的表、不同的库上。这时，表的连接操作将受到限制，我们无法连接位于不同分库的表，也无法连接分表粒度不同的表，导致原本只需要一次查询就能够完成的业务需要进行多次才能完成。
-# 故障转移和故障恢复
+### 3. 额外的数据管理负担和数据运算压力
+
+最显而易见的就是数据的定位问题和数据的增删改查的重复执行问题，这些都可以通过应用程序解决，但必然引起额外的逻辑运算。
+
+
+# 六、故障转移和故障恢复
故障转移也叫做切换，当主库出现故障时就切换到备库，使备库成为主库。故障恢复顾名思义就是从故障中恢复过来，并且保证数据的正确性。
-## 1. 故障转移
-
-**1.1 提升备库或切换角色**
+### 提升备库或切换角色
提升一台备库为主库，或者在一个主-主复制结构中调整主动和被动角色。
-**1.2 虚拟 IP 地址和 IP 托管**
+### 虚拟 IP 地址和 IP 托管
为 MySQL 实例指定一个逻辑 IP 地址，当 MySQL 实例失效时，可以将 IP 地址转移到另一台 MySQL 服务器上。
-**1.3 中间件解决方案**
+### 中间件解决方案
通过代理，可以路由流量到可以使用的服务器上。
- scoreMap = new HashMap<>();
```
-```
+```java
// Student' name -> Student's score
Map scoreMap = new HashMap<>();
```
添加测试用例来说明：
-```
+```java
//...
// Example: add(1, 2), return 3
int add(int x, int y) {
@@ -110,7 +111,7 @@ int add(int x, int y) {
在很复杂的函数调用中对每个参数标上名字：
-```
+```java
int a = 1;
int b = 2;
int num = add(\* x = *\ a, \* y = *\ b);
@@ -118,17 +119,18 @@ int num = add(\* x = *\ a, \* y = *\ b);
使用专业名词来缩短概念上的解释，比如用设计模式名来说明代码。
-# 提高控制流的可读性
+# 七、提高控制流的可读性
条件表达式中，左侧是变量，右侧是常数。比如下面第一个语句正确：
-```
+```java
if(len < 10)
if(10 > len)
```
if / else 条件语句，逻辑的处理顺序为：① 正逻辑；② 关键逻辑；③ 简单逻辑。
-```
+
+```java
if(a == b) {
// 正逻辑
} else{
@@ -144,15 +146,15 @@ do / while 的条件放在后面，不够简单明了，并且会有一些迷惑
在嵌套的循环中，用一些 return 语句往往能减少嵌套的层数。
-# 拆分长表达式
+# 八、拆分长表达式
长表达式的可读性很差，可以引入一些解释变量从而拆分表达式：
-```
+```python
if line.split(':')[0].strip() == "root":
...
```
-```
+```python
username = line.split(':')[0].strip()
if username == "root":
...
@@ -160,22 +162,22 @@ if username == "root":
使用摩根定理简化一些逻辑表达式：
-```
+```java
if(!a && !b) {
...
}
```
-```
-if(a || b) {
+```java
+if(!(a || b)) {
...
}
```
-# 变量与可读性
+# 九、变量与可读性
**去除控制流变量** 。在循环中通过使用 break 或者 return 可以减少控制流变量的使用。
-```
+```java
boolean done = false;
while(/* condition */ && !done) {
...
@@ -198,7 +200,7 @@ while(/* condition */) {
JavaScript 可以用闭包减小作用域。以下代码中 submit_form 是函数变量，submitted 变量控制函数不会被提交两次。第一个实现中 submitted 是全局变量，第二个实现把 submitted 放到匿名函数中，从而限制了起作用域范围。
-```
+```js
submitted = false;
var submit_form = function(form_name) {
if(submitted) {
@@ -208,7 +210,7 @@ var submit_form = function(form_name) {
};
```
-```
+```js
var submit_form = (function() {
var submitted = false;
return function(form_name) {
@@ -228,7 +230,7 @@ JavaScript 中没有用 var 声明的变量都是全局变量，而全局变量
在一个网页中有以下文本输入字段：
-```
+```html
n -1]，将该哈希空间看成一个哈希环，将每个节点都配置到哈希环上。每个数据对象通过哈希取模得到哈希值之后，存放到哈希环中顺时针方向第一个大于等于该哈希值的节点上。
+
+ printListFromTailToHead(ListNode listNode) {
- ArrayList ret = new ArrayList<>();
- while (listNode != null) {
- ret.add(listNode.val);
- listNode = listNode.next;
- }
- Collections.reverse(ret);
- return ret;
-}
-```
+输入链表的第一个节点，从尾到头反过来打印出每个结点的值。
-使用 Stack
+ printListFromTailToHead(ListNode listNode) {
@@ -217,7 +238,7 @@ public ArrayList printListFromTailToHead(ListNode listNode) {
}
```
-递归
+### 使用递归
```java
public ArrayList printListFromTailToHead(ListNode listNode) {
@@ -230,18 +251,37 @@ public ArrayList printListFromTailToHead(ListNode listNode) {
}
```
-不使用库函数，并且不使用递归的迭代实现，利用链表的头插法为逆序的特性。
+### 使用 Collections.reverse()
```java
public ArrayList printListFromTailToHead(ListNode listNode) {
- ListNode head = new ListNode(-1); // 头结点
- ListNode cur = listNode;
- while (cur != null) {
- ListNode next = cur.next;
- cur.next = head.next;
- head.next = cur;
- cur = next;
+ ArrayList ret = new ArrayList<>();
+ while (listNode != null) {
+ ret.add(listNode.val);
+ listNode = listNode.next;
}
+ Collections.reverse(ret);
+ return ret;
+}
+```
+
+### 使用头插法
+
+利用链表头插法为逆序的特点。
+
+头结点和第一个节点的区别：头结点是在头插法中使用的一个额外节点，这个节点不存储值；第一个节点就是链表的第一个真正存储值的节点。
+
+```java
+public ArrayList 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 ret = new ArrayList<>();
head = head.next;
while (head != null) {
@@ -252,14 +292,30 @@ public ArrayList printListFromTailToHead(ListNode listNode) {
}
```
-## 7. 重建二叉树
+# 7. 重建二叉树
-**题目描述**
+## 题目描述
-根据二叉树的前序遍历和中序遍历的结果，重建出该二叉树。
+根据二叉树的前序遍历和中序遍历的结果，重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
+
+```html
+preorder = [3,9,20,15,7]
+inorder = [9,3,15,20,7]
+```
+
+ inOrderNumsIdx = new HashMap<>(); // 缓存中序遍历数组的每个值对应的索引
+
public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
+ for (int i = 0; i < in.length; i++) {
+ inOrderNumsIdx.put(in[i], i);
+ }
return reConstructBinaryTree(pre, 0, pre.length - 1, in, 0, in.length - 1);
}
@@ -267,243 +323,387 @@ private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int[] in,
if (preL == preR) return new TreeNode(pre[preL]);
if (preL > preR || inL > inR) return null;
TreeNode root = new TreeNode(pre[preL]);
- int midIdx = inL;
- while (midIdx <= inR && in[midIdx] != root.val) midIdx++;
- int leftTreeSize = midIdx - inL;
+ int inIdx = inOrderNumsIdx.get(root.val);
+ int leftTreeSize = inIdx - inL;
root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, in, inL, inL + leftTreeSize - 1);
root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, in, inL + leftTreeSize + 1, inR);
return root;
}
```
-## 8. 二叉树的下一个结点
+# 8. 二叉树的下一个结点
-**题目描述**
+## 题目描述
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
-**解题思路**
+## 解题思路
-- 如果一个节点有右子树不为空，那么该节点的下一个节点是右子树的最左节点；
-- 否则，向上找第一个左链接指向的树包含该节点的祖先节点。
+① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
- stack1 = new Stack();
-Stack stack2 = new Stack();
+Stack in = new Stack();
+Stack out = new Stack();
public void push(int node) {
- stack1.push(node);
+ in.push(node);
}
-public int pop() {
- if (stack2.isEmpty()) {
- while (!stack1.isEmpty()) {
- stack2.push(stack1.pop());
+public int pop() throws Exception {
+ if (out.isEmpty()) {
+ while (!in.isEmpty()) {
+ out.push(in.pop());
}
}
- return stack2.pop();
+ if (out.isEmpty()) {
+ throw new Exception("queue is empty");
+ }
+ return out.pop();
}
```
-## 10.1 斐波那契数列
+# 10.1 斐波那契数列
+
+## 题目描述
+
+求菲波那契数列的第 n 项。
+
+ n/2 可以通过递归求解，并且每递归一次，n 都减小一半，因此整个算法的时间复杂度为 O(logn)。
```java
public double Power(double base, int exponent) {
@@ -587,11 +824,21 @@ public double Power(double base, int exponent) {
}
double pow = Power(base * base, exponent / 2);
if (exponent % 2 != 0) pow = pow * base;
- return isNegative ? 1 / pow : pow;
+ return isNegative ? (1 / pow) : pow;
}
```
-## 17. 打印从 1 到最大的 n 位数
+# 17. 打印从 1 到最大的 n 位数
+
+## 题目描述
+
+输入数字 n，按顺序打印出从 1 最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数即 999。
+
+## 解题思路
+
+由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用 char 数组进行存储。
+
+使用回溯法得到所有的数。
```java
public void print1ToMaxOfNDigits(int n) {
@@ -600,28 +847,38 @@ public void print1ToMaxOfNDigits(int n) {
print1ToMaxOfNDigits(number, -1);
}
-private void print1ToMaxOfNDigits(char[] number, int idx) {
- if (idx == number.length - 1) {
+private void print1ToMaxOfNDigits(char[] number, int digit) {
+ if (digit == number.length - 1) {
printNumber(number);
return;
}
for (int i = 0; i < 10; i++) {
- number[idx + 1] = (char) (i + '0');
- print1ToMaxOfNDigits(number, idx + 1);
+ number[digit + 1] = (char) (i + '0');
+ print1ToMaxOfNDigits(number, digit + 1);
}
}
private void printNumber(char[] number) {
- boolean isBeginWith0 = true;
- for (char c : number) {
- if (isBeginWith0 && c != '0') isBeginWith0 = false;
- if(!isBeginWith0) System.out.print(c);
- }
+ int index = 0;
+ while (index < number.length && number[index] == '0') index++;
+ while (index < number.length) System.out.print(number[index++]);
System.out.println();
}
```
-## 18.1 在 O(1) 时间内删除链表节点
+# 18.1 在 O(1) 时间内删除链表节点
+
+## 解题思路
+
+① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，令该节点指向下下个节点，然后删除下一个节点，时间复杂度为 O(1)。
+
+2 )
-空间复杂度 : O(1)
+## 解题思路
+
+复杂度：O(N2 ) + O(1)
```java
-public void reOrderArray(int[] array) {
- int n = array.length;
+public void reOrderArray(int[] nums) {
+ int n = nums.length;
for (int i = 0; i < n; i++) {
- if (array[i] % 2 == 0) {
+ if (nums[i] % 2 == 0) {
int nextOddIdx = i + 1;
- while (nextOddIdx < n && array[nextOddIdx] % 2 == 0) nextOddIdx++;
+ while (nextOddIdx < n && nums[nextOddIdx] % 2 == 0) nextOddIdx++;
if (nextOddIdx == n) break;
- int nextOddVal = array[nextOddIdx];
+ int nextOddVal = nums[nextOddIdx];
for (int j = nextOddIdx; j > i; j--) {
- array[j] = array[j - 1];
+ nums[j] = nums[j - 1];
}
- array[i] = nextOddVal;
+ nums[i] = nextOddVal;
}
}
}
```
-时间复杂度 : O(n)
-空间复杂度 : O(n)
+复杂度：O(N) + O(N)
```java
-public void reOrderArray(int[] array) {
+public void reOrderArray(int[] nums) {
int oddCnt = 0;
- for (int num : array) if (num % 2 == 1) oddCnt++;
- int[] copy = array.clone();
+ for (int val : nums) if (val % 2 == 1) oddCnt++;
+ int[] copy = nums.clone();
int i = 0, j = oddCnt;
for (int num : copy) {
- if (num % 2 == 1) array[i++] = num;
- else array[j++] = num;
+ if (num % 2 == 1) nums[i++] = num;
+ else nums[j++] = num;
}
}
```
-## 22. 链表中倒数第 k 个结点
+# 22. 链表中倒数第 K 个结点
+
+## 解题思路
+
+设链表的长度为 N。设两个指针 P1 和 P2，先让 P1 移动 K 个节点，则还有 N - K 个节点可以移动。此时让 P1 和 P2 同时移动，可以知道当 P1 移动到链表结尾时，P2 移动到 N - K 个节点处，该位置就是倒数第 K 个节点。
+
+## 解题思路
+
+ printMatrix(int[][] matrix) {
@@ -902,7 +1250,13 @@ public ArrayList printMatrix(int[][] matrix) {
}
```
-## 30. 包含 min 函数的栈
+# 30. 包含 min 函数的栈
+
+## 题目描述
+
+定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的 min 函数。
+
+## 解题思路
```java
private Stack stack = new Stack<>();
@@ -930,24 +1284,46 @@ public int min() {
}
```
-## 31. 栈的压入、弹出序列
+# 31. 栈的压入、弹出序列
+
+## 题目描述
+
+输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。
+
+## 解题思路
+
+使用一个栈来模拟压入弹出操作。
```java
public boolean IsPopOrder(int[] pushA, int[] popA) {
int n = pushA.length;
Stack stack = new Stack<>();
- for (int i = 0, j = 0; i < n; i++) {
- stack.push(pushA[i]);
- while (j < n && stack.peek() == popA[j]) {
+ for (int pushIndex = 0, popIndex = 0; pushIndex < n; pushIndex++) {
+ stack.push(pushA[pushIndex]);
+ while (popIndex < n && stack.peek() == popA[popIndex]) {
stack.pop();
- j++;
+ popIndex++;
}
}
return stack.isEmpty();
}
```
-## 32.1 从上往下打印二叉树
+# 32.1 从上往下打印二叉树
+
+## 题目描述
+
+从上往下打印出二叉树的每个节点，同层节点从左至右打印。
+
+例如，以下二叉树层次遍历的结果为：1,2,3,4,5,6,7
+
+ PrintFromTopToBottom(TreeNode root) {
@@ -968,7 +1344,13 @@ public ArrayList PrintFromTopToBottom(TreeNode root) {
}
```
-## 32.3 把二叉树打印成多行
+# 32.2 把二叉树打印成多行
+
+## 题目描述
+
+和上题几乎一样。
+
+## 解题思路
```java
ArrayList> Print(TreeNode pRoot) {
@@ -991,7 +1373,13 @@ ArrayList> Print(TreeNode pRoot) {
}
```
-## 32.3 按之字形顺序打印二叉树
+# 32.3 按之字形顺序打印二叉树
+
+## 题目描述
+
+请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
+
+## 解题思路
```java
public ArrayList> Print(TreeNode pRoot) {
@@ -1009,95 +1397,112 @@ public ArrayList> Print(TreeNode pRoot) {
if (node.left != null) queue.add(node.left);
if (node.right != null) queue.add(node.right);
}
- if (reverse) {
- Collections.reverse(list);
- reverse = false;
- } else {
- reverse = true;
- }
+ if (reverse) Collections.reverse(list);
+ reverse = !reverse;
ret.add(list);
}
return ret;
}
```
+# 33. 二叉搜索树的后序遍历序列
-## 33. 二叉搜索树的后序遍历序列
+## 题目描述
+
+输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。假设输入的数组的任意两个数字都互不相同。
+
+例如，下图是后序遍历序列 3,1,2 所对应的二叉搜索树。
+
+ > ret = new ArrayList<>();
public ArrayList> FindPath(TreeNode root, int target) {
- dfs(root, target, 0, new ArrayList<>());
+ dfs(root, target, new ArrayList<>());
return ret;
}
-private void dfs(TreeNode node, int target, int curSum, ArrayList path) {
+private void dfs(TreeNode node, int target, ArrayList path) {
if (node == null) return;
- curSum += node.val;
path.add(node.val);
- if (curSum == target && node.left == null && node.right == null) {
+ target -= node.val;
+ if (target == 0 && node.left == null && node.right == null) {
ret.add(new ArrayList(path));
} else {
- dfs(node.left, target, curSum, path);
- dfs(node.right, target, curSum, path);
+ dfs(node.left, target, path);
+ dfs(node.right, target, path);
}
path.remove(path.size() - 1);
}
```
-## 35. 复杂链表的复制
+# 35. 复杂链表的复制
-**题目描述**
+## 题目描述
-输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的 head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
+输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的 head。
+
+ ret = new ArrayList<>();
public ArrayList Permutation(String str) {
- if (str.length() == 0) return new ArrayList<>();
+ if (str.length() == 0) return ret;
char[] chars = str.toCharArray();
Arrays.sort(chars);
- backtracking(chars, new boolean[chars.length], "");
+ backtracking(chars, new boolean[chars.length], new StringBuffer());
return ret;
}
-private void backtracking(char[] chars, boolean[] used, String s) {
+private void backtracking(char[] chars, boolean[] hasUsed, StringBuffer s) {
if (s.length() == chars.length) {
- ret.add(s);
+ ret.add(s.toString());
return;
}
for (int i = 0; i < chars.length; i++) {
- if (used[i]) continue;
- if (i != 0 && chars[i] == chars[i - 1] && !used[i - 1]) continue; // 保证不重复
- used[i] = true;
- backtracking(chars, used, s + chars[i]);
- used[i] = false;
+ 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;
}
}
```
-# 第五章 优化时间和空间效率
+# 39. 数组中出现次数超过一半的数字
-## 39. 数组中出现次数超过一半的数字
+## 解题思路
+
+多数投票问题，可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。
+
+使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素不相等时，令 cnt--。如果前面查找了 i 个元素，且 cnt == 0 ，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
```java
-public int MoreThanHalfNum_Solution(int[] array) {
- int cnt = 1, num = array[0];
- for (int i = 1; i < array.length; i++) {
- if (array[i] == num) cnt++;
- else cnt--;
+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) {
- num = array[i];
+ majority = nums[i];
cnt = 1;
}
}
- cnt = 0;
- for (int i = 0; i < array.length; i++) {
- if (num == array[i]) cnt++;
- }
- return cnt > array.length / 2 ? num : 0;
+ int cnt = 0;
+ for (int val : nums) if (val == majority) cnt++;
+ return cnt > nums.length / 2 ? majority : 0;
}
```
+# 40. 最小的 K 个数
-## 40. 最小的 K 个数
+## 解题思路
-构建大小为 k 的小顶堆。
+### 快速选择
-时间复杂度：O(nlgk)
-空间复杂度：O(k)
+- 复杂度：O(N) + O(1)
+- 只有当允许修改数组元素时才可以使用
+
+快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。可以利用这个特性找出数组的第 K 个元素，这种找第 K 个元素的算法称为快速选择算法。
+
+找到第 K 个元素之后，就可以再遍历一次数组，所有小于等于该元素的数组元素都是最小的 K 个数。
```java
-public ArrayList GetLeastNumbers_Solution(int[] input, int k) {
- if (k > input.length || k <= 0) return new ArrayList<>();
- PriorityQueue pq = new PriorityQueue<>((o1, o2) -> o2 - o1);
- for (int num : input) {
- pq.add(num);
- if (pq.size() > k) {
- pq.poll();
- }
- }
- ArrayList ret = new ArrayList<>(pq);
- return ret;
-}
-```
-
-利用快速选择
-
-时间复杂度：O(n)
-空间复杂度：O(1)
-
-```java
-public ArrayList GetLeastNumbers_Solution(int[] input, int k) {
- if (k > input.length || k <= 0) return new ArrayList<>();
- int kthSmallest = findKthSmallest(input, k - 1);
+public ArrayList GetLeastNumbers_Solution(int[] nums, int k) {
+ if (k > nums.length || k <= 0) return new ArrayList<>();
+ int kthSmallest = findKthSmallest(nums, k - 1);
ArrayList ret = new ArrayList<>();
- for (int num : input) {
- if(num <= kthSmallest && ret.size() < k) ret.add(num);
+ for (int val : nums) {
+ if (val <= kthSmallest && ret.size() < k) {
+ ret.add(val);
+ }
}
return ret;
}
public int findKthSmallest(int[] nums, int k) {
- int lo = 0;
- int hi = nums.length - 1;
- while (lo < hi) {
- int j = partition(nums, lo, hi);
- if (j < k) {
- lo = j + 1;
- } else if (j > k) {
- hi = j - 1;
- } else {
- break;
- }
+ 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;
}
return nums[k];
}
-private int partition(int[] a, int lo, int hi) {
- int i = lo;
- int j = hi + 1;
+private int partition(int[] nums, int l, int h) {
+ int i = l, j = h + 1;
while (true) {
- while (i < hi && less(a[++i], a[lo])) ;
- while (j > lo && less(a[lo], a[--j])) ;
- if (i >= j) {
- break;
- }
- exch(a, i, j);
+ while (i < h && nums[++i] < nums[l]) ;
+ while (j > l && nums[l] < nums[--j]) ;
+ if (i >= j) break;
+ swap(nums, i, j);
}
- exch(a, lo, j);
+ swap(nums, l, j);
return j;
}
-private void exch(int[] a, int i, int j) {
- final int tmp = a[i];
- a[i] = a[j];
- a[j] = tmp;
-}
-
-private boolean less(int v, int w) {
- return v < w;
+private void swap(int[] nums, int i, int j) {
+ int t = nums[i]; nums[i] = nums[j]; nums[j] = t;
}
```
-## 41.1 数据流中的中位数
+### 大小为 K 的最小堆
+- 复杂度：O(NlogK) + O(K)
+- 特别适合处理海量数据
-**题目描述**
+应该使用大顶堆来维护最小堆，而不能直接创建一个小顶堆并设置一个大小，企图让小顶堆中的元素都是最小元素。
+
+维护一个大小为 K 的最小堆过程如下：在添加一个元素之后，如果大顶堆的大小大于 K，那么需要将大顶堆的堆顶元素去除。
+
+```java
+public ArrayList GetLeastNumbers_Solution(int[] nums, int k) {
+ if (k > nums.length || k <= 0) return new ArrayList<>();
+ PriorityQueue maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
+ for (int num : nums) {
+ maxHeap.add(num);
+ if (maxHeap.size() > k) {
+ maxHeap.poll();
+ }
+ }
+ ArrayList ret = new ArrayList<>(maxHeap);
+ return ret;
+}
+```
+
+# 41.1 数据流中的中位数
+
+## 题目描述
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
+## 解题思路
+
```java
-private PriorityQueue maxHeap = new PriorityQueue<>((o1, o2) -> o2-o1); // 实现左边部分
-private PriorityQueue minHeep = new PriorityQueue<>(); // 实现右边部分，右边部分所有元素大于左边部分
-private int cnt = 0;
+public class Solution {
+ // 大顶堆，存储左半边元素
+ private PriorityQueue left = new PriorityQueue<>((o1, o2) -> o2 - o1);
+ // 小顶堆，存储右半边元素，并且右半边元素都大于左半边
+ private PriorityQueue right = new PriorityQueue<>();
+ // 当前数据流读入的元素个数
+ private int N = 0;
-public void Insert(Integer num) {
- // 插入要保证两个堆存于平衡状态
- if(cnt % 2 == 0) {
- // 为偶数的情况下插入到最小堆，先经过最大堆筛选，这样就能保证最大堆中的元素都小于最小堆中的元素
- maxHeap.add(num);
- minHeep.add(maxHeap.poll());
- } else {
- minHeep.add(num);
- maxHeap.add(minHeep.poll());
+ 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++;
}
- cnt++;
-}
-public Double GetMedian() {
- if(cnt % 2 == 0) {
- return (maxHeap.peek() + minHeep.peek()) / 2.0;
- } else {
- return (double) minHeep.peek();
+ public Double GetMedian() {
+ if (N % 2 == 0) {
+ return (left.peek() + right.peek()) / 2.0;
+ } else {
+ return (double) right.peek();
+ }
}
}
```
-## 41.2 字符流中第一个不重复的字符
+# 41.2 字符流中第一个不重复的字符
-**题目描述**
+## 题目描述
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符 "go" 时，第一个只出现一次的字符是 "g"。当从该字符流中读出前六个字符“google" 时，第一个只出现一次的字符是 "l"。
+## 解题思路
+
```java
-//Insert one char from stringstream
-private int[] cnts = new int[256];
-private Queue queue = new LinkedList<>();
+public class Solution {
+ private int[] cnts = new int[256];
+ private Queue queue = new LinkedList<>();
-public void Insert(char ch) {
- cnts[ch]++;
- queue.add(ch);
- while (!queue.isEmpty() && cnts[queue.peek()] > 1) {
- queue.poll();
+ public void Insert(char ch) {
+ cnts[ch]++;
+ queue.add(ch);
+ while (!queue.isEmpty() && cnts[queue.peek()] > 1) {
+ queue.poll();
+ }
}
-}
-//return the first appearence once char in current stringstream
-public char FirstAppearingOnce() {
- if (queue.isEmpty()) return '#';
- return queue.peek();
+ public char FirstAppearingOnce() {
+ if (queue.isEmpty()) return '#';
+ return queue.peek();
+ }
}
```
+# 42. 连续子数组的最大和
-## 42. 连续子数组的最大和
+## 题目描述
+
+{6,-3,-2,7,-15,1,2,2}，连续子数组的最大和为 8（从第 0 个开始，到第 3 个为止）。
+
+## 解题思路
```java
-public int FindGreatestSumOfSubArray(int[] array) {
- if(array.length == 0) return 0;
+public int FindGreatestSumOfSubArray(int[] nums) {
+ if (nums.length == 0) return 0;
int ret = Integer.MIN_VALUE;
int sum = 0;
- for(int num : array) {
- if(sum <= 0) sum = num;
- else sum += num;
+ for (int val : nums) {
+ if (sum <= 0) sum = val;
+ else sum += val;
ret = Math.max(ret, sum);
}
return ret;
}
```
-## 43. 从 1 到 n 整数中 1 出现的次数
+# 43. 从 1 到 n 整数中 1 出现的次数
-解题参考：[Leetcode : 233. Number of Digit One](https://leetcode.com/problems/number-of-digit-one/discuss/64381/4+-lines-O(log-n)-C++JavaPython)
+## 解题思路
+
+> [Leetcode : 233. Number of Digit One](https://leetcode.com/problems/number-of-digit-one/discuss/64381/4+-lines-O(log-n)-C++JavaPython)
```java
public int NumberOf1Between1AndN_Solution(int n) {
@@ -1406,53 +1841,67 @@ public int NumberOf1Between1AndN_Solution(int n) {
}
```
-## 44. 数字序列中的某一位数字
+# 44. 数字序列中的某一位数字
-**题目描述**
+## 题目描述
数字以 0123456789101112131415... 的格式序列化到一个字符串中，求这个字符串的第 index 位。
+## 解题思路
+
```java
-int digitAtIndex(int index) {
+public int digitAtIndex(int index) {
if (index < 0) return -1;
int digit = 1;
while (true) {
int amount = getAmountOfDigit(digit);
int totalAmount = amount * digit;
- if (index < totalAmount) return digitAtIndex(index, digit);
+ if (index < totalAmount) {
+ return digitAtIndex(index, digit);
+ }
index -= totalAmount;
digit++;
}
}
+/**
+ * digit 位数的数字组成的字符串长度
+ * 例如 digit = 2，return 90
+ */
private int getAmountOfDigit(int digit) {
if (digit == 1) return 10;
- return (int) Math.pow(10, digit - 1);
+ return (int) Math.pow(10, digit - 1) * 9;
}
-private int digitAtIndex(int index, int digits) {
- int number = beginNumber(digits) + index / digits;
- int remain = index % digits;
+/**
+ * 在 digit 位数组成的字符串中，第 index 个数
+ */
+private int digitAtIndex(int index, int digit) {
+ int number = beginNumber(digit) + index / digit;
+ int remain = index % digit;
return (number + "").charAt(remain) - '0';
}
-private int beginNumber(int digits) {
- if (digits == 1) return 0;
- return (int) Math.pow(10, digits - 1);
-}
-
-public static void main(String[] args) {
- Solution solution = new Solution();
- System.out.println(solution.digitAtIndex(1001));
+/**
+ * digit 位数的起始数字
+ * 例如 digit = 2 return 10
+ */
+private int beginNumber(int digit) {
+ if (digit == 1) return 0;
+ return (int) Math.pow(10, digit - 1);
}
```
-## 45. 把数组排成最小的数
+# 45. 把数组排成最小的数
-**题目描述**
+## 题目描述
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组 {3，32，321}，则打印出这三个数字能排成的最小数字为 321323。
+## 解题思路
+
+可以看成是一个排序问题，在比较两个字符串 S1 和 S2 的大小时，应该比较的是 S1+S2 和 S2+S1 的大小，如果 S1+S2 < S2+S1，那么应该把 S1 排在前面，否则应该把 S2 排在前面。
+
```java
public String PrintMinNumber(int[] numbers) {
int n = numbers.length;
@@ -1465,11 +1914,13 @@ public String PrintMinNumber(int[] numbers) {
}
```
-## 46. 把数字翻译成字符串
+# 46. 把数字翻译成字符串
-**题目描述**
+## 题目描述
-给定一个数字，按照如下规则翻译成字符串：0 翻译成“a”，1 翻译成“b”...25 翻译成“z”。一个数字有多种翻译可能，例如 12258 一共有 5 种，分别是 bccfi，bwfi，bczi，mcfi，mzi。实现一个函数，用来计算一个数字有多少种不同的翻译方法。
+给定一个数字，按照如下规则翻译成字符串：0 翻译成“a”，1 翻译成“b”... 25 翻译成“z”。一个数字有多种翻译可能，例如 12258 一共有 5 种，分别是 bccfi，bwfi，bczi，mcfi，mzi。实现一个函数，用来计算一个数字有多少种不同的翻译方法。
+
+## 解题思路
```java
public int getTranslationCount(String number) {
@@ -1487,11 +1938,11 @@ public int getTranslationCount(String number) {
}
```
-## 47. 礼物的最大价值
+# 47. 礼物的最大价值
-**题目描述**
+## 题目描述
-在一个 m * n 的棋盘的每一个格都放有一个礼物，每个礼物都有一定价值（大于 0）。从左上角开始拿礼物，每次向右或向下移动一格，直到右下角结束。给定一个棋盘，求拿到礼物的最大价值。例如，对于如下棋盘
+在一个 m\*n 的棋盘的每一个格都放有一个礼物，每个礼物都有一定价值（大于 0）。从左上角开始拿礼物，每次向右或向下移动一格，直到右下角结束。给定一个棋盘，求拿到礼物的最大价值。例如，对于如下棋盘
```
1 10 3 8
@@ -1502,7 +1953,7 @@ public int getTranslationCount(String number) {
礼物的最大价值为 1+12+5+7+7+16+5=53。
-**解题思路**
+## 解题思路
应该用动态规划求解，而不是深度优先搜索，深度优先搜索过于复杂，不是最优解。
@@ -1522,58 +1973,69 @@ public int getMaxValue(int[][] values) {
}
```
-## 48. 最长不含重复字符的子字符串
+# 48. 最长不含重复字符的子字符串
-**题目描述**
+## 题目描述
输入一个字符串（只包含 a\~z 的字符），求其最长不含重复字符的子字符串的长度。例如对于 arabcacfr，最长不含重复字符的子字符串为 acfr，长度为 4。
+## 解题思路
+
```java
public int longestSubStringWithoutDuplication(String str) {
int curLen = 0;
int maxLen = 0;
- int[] position = new int[26];
+ int[] indexs = new int[26];
+ Arrays.fill(indexs, -1);
for (int i = 0; i < str.length(); i++) {
int c = str.charAt(i) - 'a';
- int preIndex = position[c];
+ int preIndex = indexs[c];
if (preIndex == -1 || i - preIndex > curLen) curLen++;
else {
maxLen = Math.max(maxLen, curLen);
curLen = i - preIndex;
}
- position[c] = i;
+ indexs[c] = i;
}
maxLen = Math.max(maxLen, curLen);
return maxLen;
}
```
-## 49. 丑数
+# 49. 丑数
-**题目描述**
+## 题目描述
把只包含因子 2、3 和 5 的数称作丑数（Ugly Number）。例如 6、8 都是丑数，但 14 不是，因为它包含因子 7。 习惯上我们把 1 当做是第一个丑数。求按从小到大的顺序的第 N 个丑数。
+## 解题思路
+
```java
public int GetUglyNumber_Solution(int index) {
if (index <= 6) return index;
int i2 = 0, i3 = 0, i5 = 0;
- int cnt = 1;
int[] dp = new int[index];
dp[0] = 1;
- while (cnt < index) {
+ for (int i = 1; i < index; i++) {
int n2 = dp[i2] * 2, n3 = dp[i3] * 3, n5 = dp[i5] * 5;
- int tmp = Math.min(n2, Math.min(n3, n5));
- dp[cnt++] = tmp;
- if (tmp == n2) i2++;
- if (tmp == n3) i3++;
- if (tmp == n5) i5++;
+ dp[i] = Math.min(n2, Math.min(n3, n5));
+ if (dp[i] == n2) i2++;
+ if (dp[i] == n3) i3++;
+ if (dp[i] == n5) i5++;
}
return dp[index - 1];
}
```
-## 50. 第一个只出现一次的字符位置
+# 50. 第一个只出现一次的字符位置
+
+## 题目描述
+
+在一个字符串 (1<=字符串长度 <=10000，全部由字母组成) 中找到第一个只出现一次的字符，并返回它的位置。
+
+## 解题思路
+
+最直观的解法是使用 HashMap 对出现次数进行统计，但是考虑到要统计的字符范围有限，因此可以使用整型数组代替 HashMap。
```java
public int FirstNotRepeatingChar(String str) {
@@ -1584,99 +2046,174 @@ public int FirstNotRepeatingChar(String str) {
}
```
-## 51. 数组中的逆序对
+以上实现的空间复杂度还不是最优的。考虑到只需要找到只出现一次的字符，那么我们只需要统计的次数信息只有 0,1,更大，那么使用两个比特位就能存储这些信息。
+
+```java
+public int FirstNotRepeatingChar(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
+ else if (bs1.get(c) && !bs2.get(c)) bs2.set(c); // 0 1
+ }
+ for (int i = 0; i < str.length(); i++) {
+ char c = str.charAt(i);
+ if (bs1.get(c) && !bs2.get(c)) return i;
+ }
+ return -1;
+}
+```
+
+# 51. 数组中的逆序对
+
+## 题目描述
+
+在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数 P。
+
+## 解题思路
```java
private long cnt = 0;
+private int[] tmp; // 在这里创建辅助数组，而不是在 merge() 递归函数中创建
-public int InversePairs(int[] array) {
- mergeSortUp2Down(array, 0, array.length - 1);
+public int InversePairs(int[] nums) {
+ tmp = new int[nums.length];
+ mergeSortUp2Down(nums, 0, nums.length - 1);
return (int) (cnt % 1000000007);
}
-private void mergeSortUp2Down(int[] a, int start, int end) {
- if (end - start < 1) return;
- int mid = start + (end - start) / 2;
- mergeSortUp2Down(a, start, mid);
- mergeSortUp2Down(a, mid + 1, end);
- merge(a, start, mid, end);
+private void mergeSortUp2Down(int[] nums, int first, int last) {
+ if (last - first < 1) return;
+ int mid = first + (last - first) / 2;
+ mergeSortUp2Down(nums, first, mid);
+ mergeSortUp2Down(nums, mid + 1, last);
+ merge(nums, first, mid, last);
}
-private void merge(int[] a, int start, int mid, int end) {
- int[] tmp = new int[end - start + 1];
- int i = start, j = mid + 1, k = 0;
- while (i <= mid || j <= end) {
- if (i > mid) tmp[k] = a[j++];
- else if (j > end) tmp[k] = a[i++];
- else if (a[i] < a[j]) tmp[k] = a[i++];
+private void merge(int[] nums, int first, int mid, int last) {
+ int i = first, j = mid + 1, k = first;
+ while (i <= mid || j <= last) {
+ if (i > mid) tmp[k] = nums[j++];
+ else if (j > last) tmp[k] = nums[i++];
+ else if (nums[i] < nums[j]) tmp[k] = nums[i++];
else {
- tmp[k] = a[j++];
- this.cnt += mid - i + 1; // a[i] > a[j] ，说明 a[i...mid] 都大于 a[j]
+ tmp[k] = nums[j++];
+ this.cnt += mid - i + 1; // nums[i] > nums[j]，说明 nums[i...mid] 都大于 nums[j]
}
k++;
}
-
- for (k = 0; k < tmp.length; k++) {
- a[start + k] = tmp[k];
+ for (k = first; k <= last; k++) {
+ nums[k] = tmp[k];
}
}
```
-## 52. 两个链表的第一个公共结点
+# 52. 两个链表的第一个公共结点
+
+## 题目描述
+
+ FindNumbersWithSum(int[] array, int sum) {
@@ -1731,86 +2302,90 @@ public ArrayList FindNumbersWithSum(int[] array, int sum) {
}
```
-## 57.2 和为 S 的连续正数序列
+# 57.2 和为 S 的连续正数序列
-**题目描述**
+## 题目描述
-和为 100 的连续序列有 18, 19, 20, 21, 22
+和为 100 的连续序列有 18, 19, 20, 21, 22。
+
+## 解题思路
```java
public ArrayList> FindContinuousSequence(int sum) {
ArrayList> ret = new ArrayList<>();
- int start = 1, end = 2;
- int mid = sum / 2;
+ int first = 1, last = 2;
int curSum = 3;
- while (start <= mid && end < sum) {
+ while (first <= sum / 2 && last < sum) {
if (curSum > sum) {
- curSum -= start;
- start++;
+ curSum -= first;
+ first++;
} else if (curSum < sum) {
- end++;
- curSum += end;
+ last++;
+ curSum += last;
} else {
ArrayList list = new ArrayList<>();
- for (int i = start; i <= end; i++) {
+ for (int i = first; i <= last; i++) {
list.add(i);
}
ret.add(list);
- curSum -= start;
- start++;
- end++;
- curSum += end;
+ curSum -= first;
+ first++;
+ last++;
+ curSum += last;
}
}
return ret;
}
```
-## 58.1 翻转单词顺序列
+# 58.1 翻转单词顺序列
-**题目描述**
+## 题目描述
输入："I am a student."
输出："student. a am I"
+## 解题思路
+
+题目应该有一个隐含条件，就是不能用额外的空间。虽然 Java 的题目输入参数为 String 类型，需要先创建一个字符数组使得空间复杂度为 O(n)，但是正确的参数类型应该和原书一样，为字符数组，并且只能使用该字符数组的空间。任何使用了额外空间的解法在面试时都会大打折扣，包括递归解法。正确的解法应该是和书上一样，先旋转每个单词，再旋转整个字符串。
+
```java
public String ReverseSentence(String str) {
if (str.length() == 0) return str;
int n = str.length();
char[] chars = str.toCharArray();
- int start = 0, end = 0;
- while (end <= n) {
- if (end == n || chars[end] == ' ') {
- reverse(chars, start, end - 1);
- start = end + 1;
+ int i = 0, j = 0;
+ while (j <= n) {
+ if (j == n || chars[j] == ' ') {
+ reverse(chars, i, j - 1);
+ i = j + 1;
}
- end++;
+ j++;
}
reverse(chars, 0, n - 1);
return new String(chars);
}
-private void reverse(char[] c, int start, int end) {
- while (start < end) {
- char t = c[start];
- c[start] = c[end];
- c[end] = t;
- start++;
- end--;
+private void reverse(char[] c, int i, int j) {
+ while(i < j) {
+ char t = c[i]; c[i] = c[j]; c[j] = t;
+ i++; j--;
}
}
```
-## 58.2 左旋转字符串
+# 58.2 左旋转字符串
-**题目描述**
+## 题目描述
对于一个给定的字符序列 S，请你把其循环左移 K 位后的序列输出。例如，字符序列 S=”abcXYZdef”, 要求输出循环左移 3 位后的结果，即“XYZdefabc”。
+## 解题思路
+
```java
public String LeftRotateString(String str, int n) {
- if (str.length() == 0) return "";
+ if(str.length() == 0) return "";
char[] c = str.toCharArray();
reverse(c, 0, n - 1);
reverse(c, n, c.length - 1);
@@ -1819,26 +2394,26 @@ public String LeftRotateString(String str, int n) {
}
private void reverse(char[] c, int i, int j) {
- while (i < j) {
- char t = c[i];
- c[i] = c[j];
- c[j] = t;
- i++;
- j--;
+ while(i < j) {
+ char t = c[i]; c[i] = c[j]; c[j] = t;
+ i++; j--;
}
}
```
-## 59. 滑动窗口的最大值
+# 59. 滑动窗口的最大值
-**题目描述**
+## 题目描述
-给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组 {2, 3, 4, 2, 6, 2, 5, 1} 及滑动窗口的大小 3，那么一共存在 6 个滑动窗口，他们的最大值分别为 {4, 4, 6, 6, 6, 5}；
+给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组 {2, 3, 4, 2, 6, 2, 5, 1} 及滑动窗口的大小 3，那么一共存在 6 个滑动窗口，他们的最大值分别为 {4, 4, 6, 6, 6, 5}。
+
+## 解题思路
```java
public ArrayList maxInWindows(int[] num, int size) {
ArrayList ret = new ArrayList<>();
if (size > num.length || size < 1) return ret;
+ // 构建最大堆，即堆顶元素是堆的最大值。
PriorityQueue heap = new PriorityQueue((o1, o2) -> o2 - o1);
for (int i = 0; i < size; i++) heap.add(num[i]);
ret.add(heap.peek());
@@ -1851,13 +2426,17 @@ public ArrayList maxInWindows(int[] num, int size) {
}
```
-## 60. n 个骰子的点数
+# 60. n 个骰子的点数
-**题目描述**
+## 题目描述
把 n 个骰子仍在地上，求点数和为 s 的概率。
-最直观的动态规划解法，O(n2 ) 的空间复杂度。
+## 解题思路
+
+### 动态规划解法
+
+空间复杂度：O(N2 )
```java
private static int face = 6;
@@ -1872,18 +2451,20 @@ public double countProbability(int n, int s) {
for (int i = 1; i < n; i++) {
for (int j = i; j < pointNum; j++) { // 使用 i 个骰子最小点数为 i
for (int k = 1; k <= face; k++) {
- if (j - k < 0) continue;
- dp[i][j] += dp[i - 1][j - k];
+ if (j - k >= 0) {
+ dp[i][j] += dp[i - 1][j - k];
+ }
}
}
}
-
int totalNum = (int) Math.pow(6, n);
return (double) dp[n - 1][s - 1] / totalNum;
}
```
-使用旋转数组将空间复杂度降低为 O(n)
+### 动态规划解法 + 旋转数组
+
+空间复杂度：O(N)
```java
private static int face = 6;
@@ -1899,48 +2480,51 @@ public double countProbability(int n, int s) {
for (int i = 1; i < n; i++) {
for (int j = i; j < pointNum; j++) { // 使用 i 个骰子最小点数为 i
for (int k = 1; k <= face; k++) {
- if (j - k < 0) continue;
- dp[flag][j] += dp[1 - flag][j - k];
+ if (j - k >= 0) {
+ dp[flag][j] += dp[1 - flag][j - k];
+ }
}
}
+ flag = 1 - flag;
}
-
int totalNum = (int) Math.pow(6, n);
- return (double) dp[n - 1][s - 1] / totalNum;
+ return (double) dp[flag][s - 1] / totalNum;
}
```
-## 61. 扑克牌顺子
+# 61. 扑克牌顺子
-**题目描述**
+## 题目描述
五张牌，其中大小鬼为癞子，牌面大小为 0。判断是否能组成顺子。
+## 解题思路
+
```java
-public boolean isContinuous(int[] numbers) {
- if (numbers.length < 5) return false;
- Arrays.sort(numbers);
+public boolean isContinuous(int[] nums) {
+ if (nums.length < 5) return false;
+ Arrays.sort(nums);
int cnt = 0;
- for (int num : numbers) if (num == 0) cnt++;
- for (int i = cnt; i < numbers.length - 1; i++) {
- if (numbers[i + 1] == numbers[i]) return false;
- int cut = numbers[i + 1] - numbers[i] - 1;
- if (cut > cnt) return false;
- cnt -= cut;
+ 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;
+ int interval = nums[i + 1] - nums[i] - 1;
+ if (interval > cnt) return false;
+ cnt -= interval;
}
return true;
}
```
-## 62. 圆圈中最后剩下的数
+# 62. 圆圈中最后剩下的数
-**题目描述**
+## 题目描述
-让小朋友们围成一个大圈。然后 , 他随机指定一个数 m, 让编号为 0 的小朋友开始报数。每次喊到 m-1 的那个小朋友要出列唱首歌 , 然后可以在礼品箱中任意的挑选礼物 , 并且不再回到圈中 , 从他的下一个小朋友开始 , 继续 0...m-1 报数 .... 这样下去 .... 直到剩下最后一个小朋友 , 可以不用表演。
+让小朋友们围成一个大圈。然后，他随机指定一个数 m，让编号为 0 的小朋友开始报数。每次喊到 m-1 的那个小朋友要出列唱首歌，然后可以在礼品箱中任意的挑选礼物，并且不再回到圈中，从他的下一个小朋友开始，继续 0...m-1 报数 .... 这样下去 .... 直到剩下最后一个小朋友，可以不用表演。
-**解题思路**
+## 解题思路
-约瑟夫环
+约瑟夫环，圆圈长度为 n 的解可以看成长度为 n-1 的解再加上报数的长度 m。因为是圆圈，所以最后需要对 n 取余。
```java
public int LastRemaining_Solution(int n, int m) {
@@ -1950,12 +2534,16 @@ public int LastRemaining_Solution(int n, int m) {
}
```
-## 63. 股票的最大利润
+# 63. 股票的最大利润
-**题目描述**
+## 题目描述
可以有一次买入和一次卖出，买入必须在前。求最大收益。
+## 解题思路
+
+使用贪心策略，假设第 i 轮进行卖出操作，买入操作价格应该是 i 之前并且价格最低。
+
```java
public int maxProfit(int[] prices) {
int n = prices.length;
@@ -1970,11 +2558,13 @@ public int maxProfit(int[] prices) {
}
```
-## 64. 求 1+2+3+...+n
+# 64. 求 1+2+3+...+n
-**题目描述**
+## 题目描述
-求 1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句（A?B:C）
+求 1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句（A?B:C）。
+
+## 解题思路
```java
public int Sum_Solution(int n) {
@@ -1984,9 +2574,13 @@ public int Sum_Solution(int n) {
}
```
-## 65. 不用加减乘除做加法
+# 65. 不用加减乘除做加法
-a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
+## 解题思路
+
+a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。
+
+递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
```java
public int Add(int num1, int num2) {
@@ -1995,38 +2589,31 @@ public int Add(int num1, int num2) {
}
```
-## 66. 构建乘积数组
+# 66. 构建乘积数组
-**题目描述**
+## 题目描述
给定一个数组 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]。不能使用除法。
+## 解题思路
+
```java
public int[] multiply(int[] A) {
int n = A.length;
- int[][] dp = new int[n][n];
- for (int i = 0; i < n; i++) {
- dp[i][i] = A[i];
- }
- for (int i = 0; i < n; i++) {
- for (int j = i + 1; j < n; j++) {
- dp[i][j] = dp[i][j - 1] * A[j];
- }
- }
-
int[] B = new int[n];
- Arrays.fill(B, 1);
- for (int i = 0; i < n; i++) {
- if (i != 0) B[i] *= dp[0][i - 1];
- if (i != n - 1) B[i] *= dp[i + 1][n - 1];
+ 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;
}
```
-# 第七章 两个面试案例
+# 67. 把字符串转换成整数
-## 67. 把字符串转换成整数
+## 解题思路
```java
public int StrToInt(String str) {
@@ -2036,16 +2623,22 @@ public int StrToInt(String str) {
int ret = 0;
for (int i = 0; i < chars.length; i++) {
if (i == 0 && (chars[i] == '+' || chars[i] == '-')) continue;
- if (chars[i] < '0' || chars[i] > '9') return 0;
+ if (chars[i] < '0' || chars[i] > '9') return 0; // 非法输入
ret = ret * 10 + (chars[i] - '0');
}
return isNegative ? -ret : ret;
}
```
-## 68. 树中两个节点的最低公共祖先
+# 68. 树中两个节点的最低公共祖先
-树是二叉查找树的最低公共祖先问题：
+## 解题思路
+
+### 二叉查找树
+
+1 和 T2 两个事务同时对一个数据进行修改，T1 先修改，T2 随后修改，T2 的修改覆盖了 T1 的修改。
+## 问题
-## 读脏数据
+### 1. 丢失修改
-T1 做修改后写入数据库，T2 读取这个修改后的数据，但是如果 T1 撤销了这次修改，使得 T2 读取的数据是脏数据。
+T1 和 T2 两个事务都对一个数据进行修改，T1 先修改，T2 随后修改，T2 的修改覆盖了 T1 的修改。
-## 不可重复读
+1 读入某个数据，T2 对该数据做了修改，如果 T1 再读这个数据，该数据已经改变，和最开始读入的是不一样的。
+### 2. 读脏数据
-# 隔离级别
+T1 修改一个数据，T2 随后读取这个数据。如果 T1 撤销了这次修改，那么 T2 读取的数据是脏数据。
-数据库管理系统需要防止数据出现不一致，并且有多种级别可以实现，这些级别称为隔离级别。
+2 读取一个数据，T1 对该数据做了修改。如果 T2 再次读取这个数据，此时读取的结果和和第一次读取的结果不同。
-## 提交读（READ COMMITTED）
+1 读取某个范围的数据，T2 在这个范围内插入新的数据，T1 再次读取这个范围的数据，此时读取的结果和和第一次读取的结果不同。
-保证在同一个事务中多次读取同样的记录结果是一致的。但是会出现幻读的问题，所谓幻读，指的是某个事务在读取某个范围内的记录时，其它事务会在范围内插入数据，产生幻行。
+1 | T1 |
+| :--: | :--: |
+| lock-x(A) | |
+| read A=20 | |
+| | lock-x(A) |
+| | wait |
+| write A=19 | |
+| commit | |
+| unlock-x(A) | |
+| | obtain |
+| | read A=19 |
+| | write A=21 |
+| | commit |
+| | unlock-x(A)|
+
+**二级封锁协议**
+
+在一级的基础上，要求读取数据 A 时必须加 S 锁，读取完马上释放 S 锁。
可以解决读脏数据问题，因为如果一个事务在对数据 A 进行修改，根据 1 级封锁协议，会加 X 锁，那么就不能再加 S 锁了，也就是不会读入数据。
-**3 级封锁协议**
+| T1 | T1 |
+| :--: | :--: |
+| lock-x(A) | |
+| read A=20 | |
+| write A=19 | |
+| | lock-s(A) |
+| | wait |
+| rollback | |
+| A=20 | |
+| unlock-x(A) | |
+| | obtain |
+| | read A=20 |
+| | commit |
+| | unlock-s(A)|
-在 2 级的基础上，要求读取数据 A 时必须加 S 锁，直到事务结束了才能释放 S 锁。
+**三级封锁协议**
+
+在二级的基础上，要求读取数据 A 时必须加 S 锁，直到事务结束了才能释放 S 锁。
可以解决不可重复读的问题，因为读 A 时，其它事务不能对 A 加 X 锁，从而避免了在读的期间数据发生改变。
-## 两段锁协议
+| T1 | T1 |
+| :--: | :--: |
+| lock-s(A) | |
+| read A=20 | |
+| |lock-x(A) |
+| | wait |
+| read A=20| |
+| commit | |
+| unlock-s(A) | |
+| | obtain |
+| | read A=20 |
+| | write A=19|
+| | commit |
+| | unlock-X(A)|
-加锁和解锁分为两个阶段进行。两段锁是并行事务可串行化的充分条件，但不是必要条件。
+### 2. 两段锁协议
+
+加锁和解锁分为两个阶段进行，事务 T 对数据 A 进行读或者写操作之前，必须先获得对 A 的封锁，并且在释放一个封锁之后，T 不能再获得任何的其它锁。
+
+事务遵循两段锁协议是保证并发操作可串行化调度的充分条件。例如以下操作满足两段锁协议，它是可串行化调度。
```html
lock-x(A)...lock-s(B)...lock-s(c)...unlock(A)...unlock(C)...unlock(B)
```
-# 乐观锁和悲观锁
+但不是必要条件，例如以下操作不满足两段锁协议，但是它还是可串行化调度。
-## 悲观锁
+```html
+lock-x(A)...unlock(A)...lock-s(B)...unlock(B)...lock-s(c)...unlock(C)...
+```
-假定会发生并发冲突，屏蔽一切可能违反数据完整性的操作。
+# 四、隔离级别
-Java synchronized 就属于悲观锁的一种实现，每次线程要修改数据时都先获得锁，保证同一时刻只有一个线程能操作数据，其他线程则会被阻塞。
+ **1. 未提交读（READ UNCOMMITTED）**
-## 乐观锁
+事务中的修改，即使没有提交，对其它事务也是可见的。
-假设不会发生并发冲突，只在提交操作时检查是否违反数据完整性。
+ **2. 提交读（READ COMMITTED）**
-Java JUC 中的 Atomic 包就是乐观锁的一种实现，AtomicInteger 通过 CAS（Compare And Set）操作实现线程安全的自增操作。
+一个事务只能读取已经提交的事务所做的修改。换句话说，一个事务所做的修改在提交之前对其它事务是不可见的。
-乐观锁有两种实现方式，数据版本和时间戳。它们都需要在数据库表中增加一个字段，使用这个字段来判断数据是否过期。例如，数据版本实现方式中，需要在数据库表中增加一个数字类型的 version 字段，当读取数据时，将 version 字段的值一同读出。随后数据每更新一次，对此 version 值加 1。当提交更新的时候，判断读出的 version 和数据库表中的 version 是否一致，如果一致，则予以更新；否则认为是过期数据。
+ **3. 可重复读（REPEATABLE READ）**
-## MySQL 隐式和显示锁定
+保证在同一个事务中多次读取同样数据的结果是一样的。
-MySQL InnoDB 采用的是两阶段锁协议。在事务执行过程中，随时都可以执行锁定，锁只有在执行 COMMIT 或者 ROLLBACK 的时候才会释放，并且所有的锁是在同一时刻被释放。前面描述的锁定都是隐式锁定，InnoDB 会根据事务隔离级别在需要的时候自动加锁。
+ **4. 可串行化（SERIALIXABLE）**
-另外，InnoDB 也支持通过特定的语句进行显示锁定，这些语句不属于 SQL 规范：
+强制事务串行执行。
-- SELECT ... LOCK IN SHARE MODE
-- SELECT ... FOR UPDATE
+ **四个隔离级别的对比**
-# 范式
+| 隔离级别 | 脏读 | 不可重复读 | 幻影读 |
+| :---: | :---: | :---:| :---: |
+| 未提交读 | YES | YES | YES |
+| 提交读 | NO | YES | YES |
+| 可重复读 | NO | NO | YES |
+| 可串行化 | NO | NO | NO |
-记 A->B 表示 A 函数决定于 B，也可以说 B 函数依赖于 A。
+# 五、多版本并发控制
+
+（Multi-Version Concurrency Control, MVCC）是 MySQL 的 InnoDB 存储引擎实现隔离级别的一种具体方式，用于实现提交读和可重复读这两种隔离级别。而未提交读隔离级别总是读取最新的数据行，无需使用 MVCC；可串行化隔离级别需要对所有读取的行都加锁，单纯使用 MVCC 无法实现。
+
+## 版本号
+
+- 系统版本号：是一个递增的数字，每开始一个新的事务，系统版本号就会自动递增。
+- 事务版本号：事务开始时的系统版本号。
+
+InooDB 的 MVCC 在每行记录后面都保存着两个隐藏的列，用来存储两个版本号：
+
+- 创建版本号：指示创建一个数据行的快照时的系统版本号；
+- 删除版本号：如果该快照的删除版本号大于当前事务版本号表示该快照有效，否则表示该快照已经被删除了。
+
+## Undo 日志
+
+InnoDB 的 MVCC 使用到的快照存储在 Undo 日志中，该日志通过回滚指针把一个数据行（Record）的所有快照连接起来。
+
+ **分解前** **分解后** @ qq.com**
+
+为了可读性，常常把转义的字符放到字符集合 [ ] 中，但是含义是相同的。
+
+```
+[\w.]+@\w+\.\w+
+[\w.]+@[\w]+\.[\w]+
+```
+
+**{n}** 匹配 n 个字符，**{m, n}** 匹配 m\~n 个字符，**{m,}** 至少匹配 m 个字符；
+
+\* 和 + 都是贪婪型元字符，会匹配最多的内容，在元字符后面加 ? 可以转换为懒惰型元字符，例如 \*?、+? 和 {m, n}? 。
+
+**正则表达式**
+
+```
+a.+c
+```
+
+由于 + 是贪婪型的，因此 .+ 会匹配更可能多的内容，所以会把整个 abcabcabc 文本都匹配，而不是只匹配前面的 abc 文本。用懒惰型可以实现匹配前面的。
+
+**匹配结果**
+
+**abcabcabc**
+
+# 六、位置匹配
+
+## 单词边界
+
+**\b** 可以匹配一个单词的边界，边界是指位于 \w 和 \W 之间的位置；**\B** 匹配一个不是单词边界的位置。
+
+\b 只匹配位置，不匹配字符，因此 \babc\b 匹配出来的结果为 3 个字符。
+
+## 字符串边界
+
+**^** 匹配整个字符串的开头，**$** 匹配结尾。
+
+^ 元字符在字符集合中用作求非，在字符集合外用作匹配字符串的开头。
+
+使用 (?m) 来打开分行匹配模式，在该模式下，换行被当做字符串的边界。
+
+**应用**
+
+匹配代码中以 // 开始的注释行
+
+**正则表达式**
+
+```
+(?m)^\s*//.*$
+```
+
+如果没用 (?m)，则只会匹配 // 注释 1 以及之后的所有内容。用了分行匹配模式之后，换行符被当成是字符串分隔符，因此能正确匹配出两个注释内容。
+
+**匹配结果**
+
+1. public void fun() {
+2. **// 注释 1**
+3. int a = 1;
+4. int b = 2;
+5. **// 注释 2**
+6. int c = a + b;
+7. }
+
+# 七、使用子表达式
+
+使用 **( )** 定义一个子表达式。子表达式的内容可以当成一个独立元素，即可以将它看成一个字符，并且使用 * 等元字符。
+
+子表达式可以嵌套，但是嵌套层次过深会变得很难理解。
+
+**正则表达式**
+
+```
+(ab) {2,}
+```
+
+**匹配结果**
+
+**ababab**
+
+**|** 是或元字符，它把左边和右边所有的部分都看成单独的两个部分，两个部分只要有一个匹配就行。
+
+**正则表达式**
+
+```
+(19|20)\d{2}
+```
+
+**匹配结果**
+
+1. **1900**
+2. **2010**
+3. 1020
+
+**应用**
+
+匹配 IP 地址。IP 地址中每部分都是 0-255 的数字，用正则表达式匹配时以下情况是合法的：
+
+1. 一位或者两位的数字
+2. 1 开头的三位数
+3. 2 开头，第 2 位是 0-4 的三位数
+4. 25 开头，第 3 位是 0-5 的三位数
+
+**正则表达式**
+
+```
+(((\d{1,2})|(1\d{2})|(2[0-4]\d)|(25[0-5]))\.) {3}(((\d{1,2})|(1\d{2})|(2[0-4]\d)|(25[0-5])))
+```
+
+**匹配结果**
+
+1. **192.168.0.1**
+2. 555.555.555.555
+
+# 八、回溯引用
+
+回溯引用使用 **\n** 来引用某个子表达式，其中 n 代表的是子表达式的序号，从 1 开始。它和子表达式匹配的内容一致，比如子表达式匹配到 abc，那么回溯引用部分也需要匹配 abc 。
+
+**应用**
+
+匹配 HTML 中合法的标题元素。
+
+**正则表达式**
+
+\1 将回溯引用子表达式 (h[1-6]) 匹配的内容，也就是说必须和子表达式匹配的内容一致。
+
+```
+<(h[1-6])>\w*?
+```
+
+**匹配结果**
+
+1. **<h1>x</h1>**
+2. **<h2>x</h2>**
+3. <h3>x</h1>
+
+## 替换
+
+需要用到两个正则表达式。
+
+**应用**
+
+修改电话号码格式。
+
+**文本**
+
+313-555-1234
+
+**查找正则表达式**
+
+```
+(\d{3})(-)(\d{3})(-)(\d{4})
+```
+
+**替换正则表达式**
+
+在第一个子表达式查找的结果加上 () ，然后加一个空格，在第三个和第五个字表达式查找的结果中间加上 - 进行分隔。
+
+```
+($1) $3-$5
+```
+
+**结果**
+
+(313) 555-1234
+
+## 大小写转换
+
+| 元字符 | 说明 |
+| :---: | :---: |
+| \l | 把下个字符转换为小写 |
+| \u| 把下个字符转换为大写 |
+| \L | 把\L 和\E 之间的字符全部转换为小写 |
+| \U | 把\U 和\E 之间的字符全部转换为大写 |
+| \E | 结束\L 或者\U |
+
+**应用**
+
+把文本的第二个和第三个字符转换为大写。
+
+**文本**
+
+abcd
+
+**查找**
+
+```
+(\w)(\w{2})(\w)
+```
+
+**替换**
+
+```
+$1\U$2\E$3
+```
+
+**结果**
+
+aBCd
+
+# 九、前后查找
+
+前后查找规定了匹配的内容首尾应该匹配的内容，但是又不包含首尾匹配的内容。向前查找用 **?=** 来定义，它规定了尾部匹配的内容，这个匹配的内容在 ?= 之后定义。所谓向前查找，就是规定了一个匹配的内容，然后以这个内容为尾部向前面查找需要匹配的内容。向后匹配用 ?<= 定义。
+
+**应用**
+
+查找出邮件地址 @ 字符前面的部分。
+
+**正则表达式**
+
+```
+\w+(?=@)
+```
+
+**结果**
+
+**abc** @qq.com
+
+对向前和向后查找取非，只要把 = 替换成 ! 即可，比如 (?=) 替换成 (?!) 。取非操作使得匹配那些首尾不符合要求的内容。
+
+# 十、嵌入条件
+
+## 回溯引用条件
+
+条件判断为某个子表达式是否匹配，如果匹配则需要继续匹配条件表达式后面的内容。
+
+**正则表达式**
+
+子表达式 (\\() 匹配一个左括号，其后的 ? 表示匹配 0 个或者 1 个。 ?(1) 为条件，当子表达式 1 匹配时条件成立，需要执行 \) 匹配，也就是匹配右括号。
+
+```
+(\()?abc(?(1)\))
+```
+
+**结果**
+
+1. **(abc)**
+2. **abc**
+3. (abc
+
+## 前后查找条件
+
+条件为定义的首尾是否匹配，如果匹配，则继续执行后面的匹配。注意，首尾不包含在匹配的内容中。
+
+**正则表达式**
+
+ ?(?=-) 为前向查找条件，只有在以 - 为前向查找的结尾能匹配 \d{5} ，才继续匹配 -\d{4} 。
+
+```
+\d{5}(?(?=-)-\d{4})
+```
+
+**结果**
+
+1. **11111**
+2. 22222-
+3. **33333-4444**
+
+# 参考资料
+
+- BenForta. 正则表达式必知必会 [M]. 人民邮电出版社, 2007.
diff --git a/notes/算法.md b/notes/算法.md
index f6fcf43e..997dc245 100644
--- a/notes/算法.md
+++ b/notes/算法.md
@@ -1,128 +1,70 @@
-* [算法分析](#算法分析)
- * [1. 函数转换](#1-函数转换)
- * [2. 数学模型](#2-数学模型)
- * [3. ThreeSum](#3-threesum)
- * [4. 倍率实验](#4-倍率实验)
- * [5. 注意事项](#5-注意事项)
-* [排序](#排序)
- * [1. 初级排序算法](#1-初级排序算法)
- * [1.1 约定](#11-约定)
- * [1.2 选择排序](#12-选择排序)
- * [1.3 插入排序](#13-插入排序)
- * [1.4 选择排序和插入排序的比较](#14-选择排序和插入排序的比较)
- * [1.5 希尔排序](#15-希尔排序)
- * [2 归并排序](#2-归并排序)
- * [2.1 归并方法](#21-归并方法)
- * [2.2 自顶向下归并排序](#22-自顶向下归并排序)
- * [2.3 自底向上归并排序](#23-自底向上归并排序)
- * [3. 快速排序](#3-快速排序)
- * [3.1 基本算法](#31-基本算法)
- * [3.2 切分](#32-切分)
- * [3.3 性能分析](#33-性能分析)
- * [3.4 算法改进](#34-算法改进)
- * [3.4.1 切换到插入排序](#341-切换到插入排序)
- * [3.4.2 三取样](#342-三取样)
- * [3.4.3 三向切分](#343-三向切分)
- * [4. 优先队列](#4-优先队列)
- * [4.1 堆](#41-堆)
- * [4.2 上浮和下沉](#42-上浮和下沉)
- * [4.3 插入元素](#43-插入元素)
- * [4.4 删除最大元素](#44-删除最大元素)
- * [4.5 堆排序](#45-堆排序)
- * [4.6 分析](#46-分析)
- * [5. 应用](#5-应用)
- * [5.1 排序算法的比较](#51-排序算法的比较)
- * [5.2 Java 的排序算法实现](#52-java-的排序算法实现)
- * [5.3 基于切分的快速选择算法](#53-基于切分的快速选择算法)
-* [查找](#查找)
- * [1. 符号表](#1-符号表)
- * [1.1 无序符号表](#11-无序符号表)
- * [1.2 有序符号表](#12-有序符号表)
- * [1.3 二分查找实现有序符号表](#13-二分查找实现有序符号表)
- * [2. 二叉查找树](#2-二叉查找树)
- * [2.1 get()](#21-get)
- * [2.2 put()](#22-put)
- * [2.3 分析](#23-分析)
- * [2.4 floor()](#24-floor)
- * [2.5 rank()](#25-rank)
- * [2.6 min()](#26-min)
- * [2.7 deleteMin()](#27-deletemin)
- * [2.8 delete()](#28-delete)
- * [2.9 keys()](#29-keys)
- * [2.10 性能分析](#210-性能分析)
- * [3. 平衡查找树](#3-平衡查找树)
- * [3.1 2-3 查找树](#31-2-3-查找树)
- * [3.1.1 插入操作](#311-插入操作)
- * [3.1.2 性质](#312-性质)
- * [3.2 红黑二叉查找树](#32-红黑二叉查找树)
- * [3.2.1 左旋转](#321-左旋转)
- * [3.2.2 右旋转](#322-右旋转)
- * [3.2.3 颜色转换](#323-颜色转换)
- * [3.2.4 插入](#324-插入)
- * [3.2.5 删除最小键](#325-删除最小键)
- * [3.2.6 分析](#326-分析)
- * [4. 散列表](#4-散列表)
- * [4.1 散列函数](#41-散列函数)
- * [4.2 基于拉链法的散列表](#42-基于拉链法的散列表)
- * [4.3 基于线性探测法的散列表](#43-基于线性探测法的散列表)
- * [4.3.1 查找](#431-查找)
- * [4.3.2 插入](#432-插入)
- * [4.3.3 删除](#433-删除)
- * [4.3.4 调整数组大小](#434-调整数组大小)
- * [5. 应用](#5-应用)
- * [5.1 各种符号表实现的比较](#51-各种符号表实现的比较)
- * [5.2 Java 的符号表实现](#52-java-的符号表实现)
- * [5.3 集合类型](#53-集合类型)
- * [5.4 稀疏向量乘法](#54-稀疏向量乘法)
+* [一、算法分析](#一算法分析)
+ * [数学模型](#数学模型)
+ * [ThreeSum](#threesum)
+ * [倍率实验](#倍率实验)
+ * [注意事项](#注意事项)
+* [二、栈和队列](#二栈和队列)
+ * [栈](#栈)
+ * [队列](#队列)
+* [三、union-find](#三union-find)
+ * [quick-find](#quick-find)
+ * [quick-union](#quick-union)
+ * [加权 quick-union](#加权-quick-union)
+ * [路径压缩的加权 quick-union](#路径压缩的加权-quick-union)
+ * [各种 union-find 算法的比较](#各种-union-find-算法的比较)
+* [四、排序](#四排序)
+ * [选择排序](#选择排序)
+ * [插入排序](#插入排序)
+ * [希尔排序](#希尔排序)
+ * [归并排序](#归并排序)
+ * [快速排序](#快速排序)
+ * [优先队列](#优先队列)
+ * [应用](#应用)
+* [五、查找](#五查找)
+ * [二分查找实现有序符号表](#二分查找实现有序符号表)
+ * [二叉查找树](#二叉查找树)
+ * [2-3 查找树](#2-3-查找树)
+ * [红黑二叉查找树](#红黑二叉查找树)
+ * [散列表](#散列表)
+ * [应用](#应用)
+* [参考资料](#参考资料)
-# 算法分析
+# 一、算法分析
-## 1. 函数转换
+## 数学模型
-指数函数可以转换为线性函数，从而在函数图像上显示的更直观。
+### 1. 近似
-T(N)=aN3 转换为 lg(T(N))=3lgN+lga
+N3 /6-N2 /2+N/3 \~ N3 /6。使用 \~f(N) 来表示所有随着 N 的增大除以 f(N) 的结果趋近于 1 的函数。
-3 /6-N2 /2+N/3 的增长数量级为 O(N3 )。增长数量级将算法与它的实现隔离开来，一个算法的增长数量级为 O(N3 ) 与它是否用 Java 实现，是否运行于特定计算机上无关。
-**近似**
-
-使用 \~f(N) 来表示所有随着 N 的增大除以 f(N) 的结果趋近于 1 的函数 , 例如 N3 /6-N2 /2+N/3 \~ N3 /6。
-
-3 与它是否用 Java 实现，是否运行于特定计算机上无关。
-
-3 /6-N2 /2+N/3，因此它的近似执行次数为 \~N3 /6，增长数量级为 N3 。
+该算法的内循环为 if(a[i]+a[j]+a[k]==0) 语句，总共执行的次数为 N(N-1)(N-2) = N3 /6-N2 /2+N/3，因此它的近似执行次数为 \~N3 /6，增长数量级为 O(N3 )。
-**改进**
+ **改进**
通过将数组先排序，对两个元素求和，并用二分查找方法查找是否存在该和的相反数，如果存在，就说明存在三元组的和为 0。
-该方法可以将 ThreeSum 算法增长数量级降低为 N2 logN。
+该方法可以将 ThreeSum 算法增长数量级降低为 O(N2 logN)。
```java
public class ThreeSumFast {
- public static int count(int[] a) {
- Arrays.sort(a);
- int N = a.length;
+ public int count(int[] nums) {
+ Arrays.sort(nums);
+ int N = nums.length;
int cnt = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
- for (int k = j + 1; k < N; k++) {
- // rank() 方法返回元素在数组中的下标，如果元素不存在，这里会返回 -1。应该注意这里的下标必须大于 j，这样就不会重复统计了。
- if (BinarySearch.rank(-a[i] - a[j], a) > j) {
- cnt++;
- }
+ // 应该注意这里的下标必须大于 j，否则会重复统计。
+ if (binarySearch(nums, -nums[i] - nums[j]) > j) {
+ cnt++;
}
}
}
return cnt;
}
+
+ private int binarySearch(int[] nums, int target) {
+ int l = 0, h = nums.length - 1;
+ while (l <= h) {
+ int m = l + (h - l) / 2;
+ if (target == nums[m]) return m;
+ else if (target > nums[m]) l = m + 1;
+ else h = m - 1;
+ }
+ return -1;
+ }
}
```
-## 4. 倍率实验
+## 倍率实验
-如果 T(N) \~ aNb lgN，那么 T(2N)/T(N) \~ 2b ，例如对于暴力方法的 ThreeSum 算法，近似时间为 \~N3 /6，对它进行倍率实验得到如下结果：
+如果 T(N) \~ aNb logN，那么 T(2N)/T(N) \~ 2b 。
-3 /6。进行如下实验：多次运行该算法，每次取的 N 值为前一次的两倍，统计每次执行的时间，并统计本次运行时间与前一次运行时间的比值，得到如下结果：
-可见 T(2N)/T(N)\~23 ，也就是 b 为 3。
+| N | Time | Ratio |
+| :---: | :---: | :---: |
+| 250 | 0.0 | 2.7 |
+| 500 | 0.0 | 4.8 |
+| 1000 | 0.1 | 6.9 |
+| 2000 | 0.8 | 7.7 |
+| 4000 | 6.4 | 8.0 |
+| 8000 | 51.1 | 8.0 |
-## 5. 注意事项
+可以看到，T(2N)/T(N) \~ 23 ，因此可以确定 T(N) \~ aN3 logN。
-**大常数**
+## 注意事项
+
+### 1. 大常数
在求近似时，如果低级项的常数系数很大，那么近似的结果就是错误的。
-**缓存**
+### 2. 缓存
计算机系统会使用缓存技术来组织内存，访问数组相邻的元素会比访问不相邻的元素快很多。
-**对最坏情况下的性能的保证**
+### 3. 对最坏情况下的性能的保证
在核反应堆、心脏起搏器或者刹车控制器中的软件，最坏情况下的性能是十分重要的。
-**随机化算法**
+### 4. 随机化算法
通过打乱输入，去除算法对输入的依赖。
-**均摊分析**
+### 5. 均摊分析
-将所有操作的总成本所以操作总数来将成本均摊。例如对一个空栈进行 N 次连续的 push() 调用需要访问数组的元素为 N+4+8+16+...+2N=5N-4（N 是向数组写入元素，其余的都是调整数组大小时进行复制需要的访问数组操作），均摊后每次操作访问数组的平均次数为常数。
+将所有操作的总成本除于操作总数来将成本均摊。例如对一个空栈进行 N 次连续的 push() 调用需要访问数组的元素为 N+4+8+16+...+2N=5N-4（N 是向数组写入元素，其余的都是调整数组大小时进行复制需要的访问数组操作），均摊后每次操作访问数组的平均次数为常数。
+
+# 二、栈和队列
+
+## 栈
+
+> First-In-Last-Out
+
+ **1. 数组实现**
+
+```java
+public class ResizeArrayStack- implements Iterable
- {
+ private Item[] a = (Item[]) new Object[1];
+ private int N = 0;
+
+ public void push(Item item) {
+ if (N >= a.length) {
+ resize(2 * a.length);
+ }
+ a[N++] = item;
+ }
+
+ public Item pop() {
+ Item item = a[--N];
+ if (N <= a.length / 4) {
+ resize(a.length / 2);
+ }
+ return item;
+ }
+
+ // 调整数组大小，使得栈具有伸缩性
+ private void resize(int size) {
+ Item[] tmp = (Item[]) new Object[size];
+ for (int i = 0; i < N; i++) {
+ tmp[i] = a[i];
+ }
+ a = tmp;
+ }
+
+ public boolean isEmpty() {
+ return N == 0;
+ }
+
+ public int size() {
+ return N;
+ }
+
+ @Override
+ public Iterator
- iterator() {
+ // 需要返回逆序遍历的迭代器
+ return new ReverseArrayIterator();
+ }
+
+ private class ReverseArrayIterator implements Iterator
- {
+ private int i = N;
+
+ @Override
+ public boolean hasNext() {
+ return i > 0;
+ }
+
+ @Override
+ public Item next() {
+ return a[--i];
+ }
+ }
+}
+```
+
+
**2. 链表实现**
+
+需要使用链表的头插法来实现，因为头插法中最后压入栈的元素在链表的开头，它的 next 指针指向前一个压入栈的元素，在弹出元素使就可以通过 next 指针遍历到前一个压入栈的元素从而让这个元素称为新的栈顶元素。
+
+```java
+public class Stack- {
+
+ private Node top = null;
+ private int N = 0;
+
+ private class Node {
+ Item item;
+ Node next;
+ }
+
+ public boolean isEmpty() {
+ return N == 0;
+ }
+
+ public int size() {
+ return N;
+ }
+
+ public void push(Item item) {
+ Node newTop = new Node();
+ newTop.item = item;
+ newTop.next = top;
+ top = newTop;
+ N++;
+ }
+
+ public Item pop() {
+ Item item = top.item;
+ top = top.next;
+ N--;
+ return item;
+ }
+}
+```
+
+## 队列
+
+> First-In-First-Out
+
+下面是队列的链表实现，需要维护 first 和 last 节点指针，分别指向队首和队尾。
+
+这里需要考虑 first 和 last 指针哪个作为链表的开头。因为出队列操作需要让队首元素的下一个元素成为队首，所以需要容易获取下一个元素，而链表的头部节点的 next 指针指向下一个元素，因此可以让 first 指针链表的开头。
+
+```java
+public class Queue
- {
+ private Node first;
+ private Node last;
+ int N = 0;
+ private class Node{
+ Item item;
+ Node next;
+ }
+
+ public boolean isEmpty(){
+ return N == 0;
+ }
+
+ public int size(){
+ return N;
+ }
+
+ // 入队列
+ public void enqueue(Item item){
+ Node newNode = new Node();
+ newNode.item = item;
+ newNode.next = null;
+ if(isEmpty()){
+ last = newNode;
+ first = newNode;
+ } else{
+ last.next = newNode;
+ last = newNode;
+ }
+ N++;
+ }
+
+ // 出队列
+ public Item dequeue() {
+ if (isEmpty()) return null;
+ Node node = first;
+ first = first.next;
+ N--;
+ if (isEmpty()) last = null;
+ return node.item;
+ }
+}
+```
+
+# 三、union-find
-# 排序
+用于解决动态连通性问题，能动态连接两个点，并且判断两个点是否连通。
-## 1. 初级排序算法
+
2 /2 次比较和 \~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。
-### 1.3 插入排序
+## 插入排序
-将一个元素插入到已排序的数组中，使得插入之后的数组也是有序的。插入排序从左到右插入每个元素，每次插入之后左部的子数组是有序的。
+插入排序从左到右进行，每次都将当前元素插入到左部已经排序的数组中，使得插入之后左部数组依然有序。
-2 /4 比较以及 \~N2 /4 次交换，最坏的情况下需要 \~N2 /2 比较以及 \~N2 /2 次交换，最坏的情况是数组是逆序的；而最好的情况下需要 N-1 次比较和 0 次交换，最好的情况就是数组已经有序了。
+插入排序的复杂度取决于数组的初始顺序，如果数组已经部分有序了，那么插入排序会很快。
+
+- 平均情况下插入排序需要 \~N2 /4 比较以及 \~N2 /4 次交换；
+- 最坏的情况下需要 \~N2 /2 比较以及 \~N2 /2 次交换，最坏的情况是数组是逆序的；
+- 最好的情况下需要 N-1 次比较和 0 次交换，最好的情况就是数组已经有序了。
插入排序对于部分有序数组和小规模数组特别高效。
-### 1.4 选择排序和插入排序的比较
-
-对于随机排序的无重复主键的数组，插入排序和选择排序的运行时间是平方级别的，两者之比是一个较小的常数。
-
-### 1.5 希尔排序
+## 希尔排序
对于大规模的数组，插入排序很慢，因为它只能交换相邻的元素，如果要把元素从一端移到另一端，就需要很多次操作。
@@ -275,15 +533,15 @@ public class Insertion {
希尔排序使用插入排序对间隔 h 的序列进行排序，如果 h 很大，那么元素就能很快的移到很远的地方。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。
-N )。
-
-因为小数组的递归操作会过于频繁，因此使用插入排序来处理小数组将会获得更高的性能。
-
-### 2.3 自底向上归并排序
+### 3. 自底向上归并排序
先归并那些微型数组，然后成对归并得到的子数组。
- list = Arrays.asList(array);
+ Collections.shuffle(list);
+ list.toArray(array);
+ }
}
```
-### 3.2 切分
+### 2. 切分
-取 a[lo] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于等于它的元素，交换这两个元素，并不断继续这个过程，就可以保证左指针的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[lo] 和左子数组最右侧的元素 a[j] 交换然后返回 j 即可。
+取 a[lo] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于等于它的元素，交换这两个元素，并不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[lo] 和 a[j] 交换位置。
-N =2CN/2 +N，也就是复杂度为 O(NlgN )。
+快速排序最好的情况下是每次都正好能将数组对半分，这样递归调用次数才是最少的。这种情况下比较次数为 CN =2CN/2 +N，复杂度为 O(NlogN)。
最坏的情况下，第一次从最小的元素切分，第二次从第二小的元素切分，如此这般。因此最坏的情况下需要比较 N2 /2。为了防止数组最开始就是有序的，在进行快速排序时需要随机打乱数组。
-### 3.4 算法改进
+### 4. 算法改进
-#### 3.4.1 切换到插入排序
+（一）切换到插入排序
因为快速排序在小数组中也会调用自己，对于小数组，插入排序比快速排序的性能更好，因此在小数组中可以切换到插入排序。
-#### 3.4.2 三取样
+（二）三取样
最好的情况下是每次都能取数组的中位数作为切分元素，但是计算中位数的代价很高。人们发现取 3 个元素并将大小居中的元素作为切分元素的效果最好。
-#### 3.4.3 三向切分
+（三）三向切分
对于有大量重复元素的数组，可以将数组切分为三部分，分别对应小于、等于和大于切分元素。
三向切分快速排序对于只有若干不同主键的随机数组可以在线性时间内完成排序。
- {
@@ -501,10 +764,12 @@ public class MaxPQ {
}
```
-### 4.2 上浮和下沉
+### 2. 上浮和下沉
在堆中，当一个节点比父节点大，那么需要交换这个两个节点。交换后还可能比它新的父节点大，因此需要不断地进行比较和交换操作。把这种操作称为上浮。
+2 | 1 | |
+| 插入排序 | yes | yes | N \~ N2 | 1 | 时间复杂度和初始顺序有关 |
+| 希尔排序 | no | yes | N 的若干倍乘于递增序列的长度 | 1 | |
+| 快速排序 | no | yes | NlogN | logN | |
+| 三向切分快速排序 | no | yes | N \~ NlogN | logN | 适用于有大量重复主键|
+| 归并排序 | yes | no | NlogN | N | |
+| 堆排序 | no | yes | NlogN | 1 | | |
-快速排序时最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间增长数量级为 \~cNlgN，这里的 c 比其他线性对数级别的排序算法都要小。使用三向切分之后，实际应用中可能出现的某些分布的输入能够达到线性级别，而其它排序算法仍然需要线性对数时间。
+快速排序是最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间近似为 \~cNlogN，这里的 c 比其他线性对数级别的排序算法都要小。使用三向切分之后，实际应用中可能出现的某些分布的输入能够达到线性级别，而其它排序算法仍然需要线性对数时间。
-### 5.2 Java 的排序算法实现
+### 2. Java 的排序算法实现
Java 系统库中的主要排序方法为 java.util.Arrays.sort()，对于原始数据类型使用三向切分的快速排序，对于引用类型使用归并排序。
-### 5.3 基于切分的快速选择算法
+### 3. 基于切分的快速选择算法
-快速排序的 partition() 方法，会将数组的 a[lo] 至 a[hi] 重新排序并返回一个整数 j 使得 a[lo..j-1] 小于等于 a[j]，且 a[j+1..hi] 大于等于 a[j]。那么如果 j=k，a[j] 就是第 k 个数。
+快速排序的 partition() 方法，会返回一个整数 j 使得 a[lo..j-1] 小于等于 a[j]，且 a[j+1..hi] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。
-该算法是线性级别的，因为每次正好将数组二分，那么比较的总次数为 (N+N/2+N/4+..)，直到找到第 k 个元素，这个和显然小于 2N。
+可以利用这个特性找出数组的第 k 个元素。
```java
public static Comparable select(Comparable[] a, int k) {
@@ -617,33 +900,23 @@ public static Comparable select(Comparable[] a, int k) {
}
```
-# 查找
+该算法是线性级别的，因为每次正好将数组二分，那么比较的总次数为 (N+N/2+N/4+..)，直到找到第 k 个元素，这个和显然小于 2N。
-本章使用三种经典的数据结构来实现高效的符号表：二叉查找树、红黑树和散列表。
+# 五、查找
-## 1. 符号表
+符号表是一种存储键值对的数据结构，主要支持两种操作：插入一个新的键值对、根据给定键得到值。
-### 1.1 无序符号表
-
- , Value> {
@@ -702,15 +975,21 @@ public class BinarySearchST, Value> {
}
```
-## 2. 二叉查找树
+## 二叉查找树
-**二叉树** 定义为一个空链接，或者是一个有左右两个链接的节点，每个链接都指向一颗子二叉树。
+**二叉树** 是一个空链接，或者是一个有左右两个链接的节点，每个链接都指向一颗子二叉树。
-**二叉查找树** （BST）是一颗二叉树，并且每个节点的键都大于其左子树中的任意节点的键而小于右子树的任意节点的键。
+ , Value> {
@@ -741,9 +1020,13 @@ public class BST, Value> {
}
```
-### 2.1 get()
+（为了方便绘图，二叉树的空链接不画出来。）
-如果树是空的，则查找未命中；如果被查找的键和根节点的键相等，查找命中，否则递归地在子树中查找：如果被查找的键较小就在左子树中查找，较大就在右子树中查找。
+### 1. get()
+
+- 如果树是空的，则查找未命中；
+- 如果被查找的键和根节点的键相等，查找命中；
+- 否则递归地在子树中查找：如果被查找的键较小就在左子树中查找，较大就在右子树中查找。
```java
public Value get(Key key) {
@@ -758,10 +1041,12 @@ private Value get(Node x, Key key) {
}
```
-### 2.2 put()
+### 2. put()
当插入的键不存在于树中，需要创建一个新节点，并且更新上层节点的链接使得该节点正确链接到树中。
+ keys(Key lo, Key hi) {
@@ -899,35 +1199,41 @@ private void keys(Node x, Queue queue, Key lo, Key hi) {
}
```
-### 2.10 性能分析
+### 10. 性能分析
复杂度：二叉查找树所有操作在最坏的情况下所需要的时间都和树的高度成正比。
-## 3. 平衡查找树
+## 2-3 查找树
-### 3.1 2-3 查找树
+ queue, Key lo, Key hi) {
画红黑树时可以将红链接画平。
- , Value> {
@@ -966,13 +1272,11 @@ public class RedBlackBST, Value> {
}
```
-#### 3.2.1 左旋转
+### 1. 左旋转
因为合法的红链接都为左链接，如果出现右链接为红链接，那么就需要进行左旋转操作。
- {
@@ -1184,7 +1470,7 @@ public class LinearProbingHashST {
}
```
-#### 4.3.1 查找
+**（一）查找**
```java
public Value get(Key key) {
@@ -1197,7 +1483,7 @@ public Value get(Key key) {
}
```
-#### 4.3.2 插入
+**（二）插入**
```java
public void put(Key key, Value val) {
@@ -1215,9 +1501,9 @@ public void put(Key key, Value val) {
}
```
-#### 4.3.3 删除
+**（三）删除**
-删除操作应当将右侧所有相邻的键值重新插入散列表中。
+删除操作应当将右侧所有相邻的键值对重新插入散列表中。
```java
public void delete(Key key) {
@@ -1243,14 +1529,14 @@ public void delete(Key key) {
}
```
-#### 4.3.4 调整数组大小
+**（四）调整数组大小**
-线性探测法的成本取决于连续条目的长度，连续条目也叫聚簇。当聚簇很长时，在查找和插入时也需要进行很多次探测。
+线性探测法的成本取决于连续条目的长度，连续条目也叫聚簇。当聚簇很长时，在查找和插入时也需要进行很多次探测。例如下图中 2\~5 位置就是一个聚簇。
+
+ hashMap;
@@ -1324,3 +1611,8 @@ public class SparseVector {
}
}
```
+
+# 参考资料
+
+- Sedgewick, Robert, and Kevin Wayne. _Algorithms_. Addison-Wesley Professional, 2011.
+
diff --git a/notes/计算机操作系统.md b/notes/计算机操作系统.md
index 4108d7a6..e992bd63 100644
--- a/notes/计算机操作系统.md
+++ b/notes/计算机操作系统.md
@@ -1,89 +1,37 @@
-* [第一章 概述](#第一章-概述)
+* [一、 概述](#一-概述)
* [操作系统基本特征](#操作系统基本特征)
- * [1. 并发](#1-并发)
- * [2. 共享](#2-共享)
- * [3. 虚拟](#3-虚拟)
- * [4. 异步](#4-异步)
+ * [操作系统基本功能](#操作系统基本功能)
* [系统调用](#系统调用)
- * [中断分类](#中断分类)
- * [1. 外中断](#1-外中断)
- * [2. 异常](#2-异常)
- * [3. 陷入](#3-陷入)
* [大内核和微内核](#大内核和微内核)
- * [1. 大内核](#1-大内核)
- * [2. 微内核](#2-微内核)
-* [第二章 进程管理](#第二章-进程管理)
+ * [中断分类](#中断分类)
+* [二、进程管理](#二进程管理)
* [进程与线程](#进程与线程)
- * [1. 进程](#1-进程)
- * [2. 线程](#2-线程)
- * [3. 区别](#3-区别)
* [进程状态的切换](#进程状态的切换)
* [调度算法](#调度算法)
- * [1. 批处理系统中的调度](#1-批处理系统中的调度)
- * [1.1 先来先服务](#11-先来先服务)
- * [1.2 短作业优先](#12-短作业优先)
- * [1.3 最短剩余时间优先](#13-最短剩余时间优先)
- * [2. 交互式系统中的调度](#2-交互式系统中的调度)
- * [2.1 优先权优先](#21-优先权优先)
- * [2.2 时间片轮转](#22-时间片轮转)
- * [2.3 多级反馈队列](#23-多级反馈队列)
- * [2.4 短进程优先](#24-短进程优先)
- * [3. 实时系统中的调度](#3-实时系统中的调度)
* [进程同步](#进程同步)
- * [1. 临界区](#1-临界区)
- * [2. 同步与互斥](#2-同步与互斥)
- * [3. 信号量](#3-信号量)
- * [4. 管程](#4-管程)
- * [进程通信](#进程通信)
- * [1. 管道](#1-管道)
- * [2. 信号量](#2-信号量)
- * [3. 消息队列](#3-消息队列)
- * [4. 信号](#4-信号)
- * [5. 共享内存](#5-共享内存)
- * [6. 套接字](#6-套接字)
* [经典同步问题](#经典同步问题)
- * [1. 读者-写者问题](#1-读者-写者问题)
- * [2. 哲学家进餐问题](#2-哲学家进餐问题)
-* [第三章 死锁](#第三章-死锁)
+ * [进程通信](#进程通信)
+* [三、死锁](#三死锁)
* [死锁的必要条件](#死锁的必要条件)
* [死锁的处理方法](#死锁的处理方法)
- * [1. 鸵鸟策略](#1-鸵鸟策略)
- * [2. 死锁预防](#2-死锁预防)
- * [2.1 破坏互斥条件](#21-破坏互斥条件)
- * [2.2 破坏占有和等待条件](#22-破坏占有和等待条件)
- * [2.3 破坏不可抢占条件](#23-破坏不可抢占条件)
- * [2.4 破坏环路等待](#24-破坏环路等待)
- * [3. 死锁避免](#3-死锁避免)
- * [3.1 安全状态](#31-安全状态)
- * [3.2 单个资源的银行家算法](#32-单个资源的银行家算法)
- * [3.3 多个资源的银行家算法](#33-多个资源的银行家算法)
- * [4. 死锁检测与死锁恢复](#4-死锁检测与死锁恢复)
- * [4.1 死锁检测算法](#41-死锁检测算法)
- * [4.2 死锁恢复](#42-死锁恢复)
-* [第四章 存储器管理](#第四章-存储器管理)
+* [四、内存管理](#四内存管理)
* [虚拟内存](#虚拟内存)
* [分页与分段](#分页与分段)
- * [1. 分页](#1-分页)
- * [2. 分段](#2-分段)
- * [3. 段页式](#3-段页式)
- * [4. 分页与分段区别](#4-分页与分段区别)
+ * [分页系统地址映射](#分页系统地址映射)
* [页面置换算法](#页面置换算法)
- * [1. 最佳（Optimal）](#1-最佳optimal)
- * [2. 先进先出（FIFO）](#2-先进先出fifo)
- * [3. 最近最久未使用（LRU, Least Recently Used）](#3-最近最久未使用lru,-least-recently-used)
- * [4. 时钟（Clock）](#4-时钟clock)
-* [第五章 设备管理](#第五章-设备管理)
+* [五、设备管理](#五设备管理)
* [磁盘调度算法](#磁盘调度算法)
- * [1. 先来先服务（FCFS, First Come First Serverd）](#1-先来先服务fcfs,-first-come-first-serverd)
- * [2. 最短寻道时间优先（SSTF, Shortest Seek Time First）](#2-最短寻道时间优先sstf,-shortest-seek-time-first)
- * [3. 扫描算法（SCAN）](#3-扫描算法scan)
- * [4. 循环扫描算法（CSCAN）](#4-循环扫描算法cscan)
+* [六、链接](#六链接)
+ * [编译系统](#编译系统)
+ * [目标文件](#目标文件)
+ * [静态链接](#静态链接)
+ * [动态链接](#动态链接)
* [参考资料](#参考资料)
-# 第一章 概述
+# 一、 概述
## 操作系统基本特征
@@ -111,13 +59,60 @@
### 4. 异步
-异步是指进程不是一次性执行完毕，而是走走停停，以不可知的速度向前推进。
+异步指进程不是一次性执行完毕，而是走走停停，以不可知的速度向前推进。
+
+## 操作系统基本功能
+
+### 1. 进程管理
+
+进程控制、进程同步、进程通信、死锁处理、处理机调度等。
+
+### 2. 内存管理
+
+内存分配、地址映射、内存保护与共享和内存扩充等功能。
+
+### 3. 文件管理
+
+文件存储空间的管理、目录管理及文件读写管理和保护等。
+
+### 4. 设备管理
+
+完成用户的 I/O 请求，方便用户使用各种设备，并提高设备的利用率，主要包括缓冲管理、设备分配、设备处理和虛拟设备等功能。
## 系统调用
-如果一个进程在用户态需要用到操作系统的一些功能，就需要使用系统调用从而陷入内核，由操作系统代为完成。
+如果一个进程在用户态需要使用内核态的功能，就进行系统调用从而陷入内核，由操作系统代为完成。
-可以由系统调用请求的功能有设备管理、文件管理、进程管理、进程通信、存储器管理等。
+ **使用信号量实现生产者-消费者问题**
-使用一个缓冲区来保存物品，只有缓冲区没有满，生产者才可以放入物品；只有缓冲区不为空，消费者才可以拿走物品。
+问题描述：使用一个缓冲区来保存物品，只有缓冲区没有满，生产者才可以放入物品；只有缓冲区不为空，消费者才可以拿走物品。
-需要使用一个互斥量 mutex 来对缓冲区这个临界资源进行互斥访问。
+因为缓冲区属于临界资源，因此需要使用一个互斥量 mutex 来控制对缓冲区的互斥访问。
-为了控制生产者和消费者的行为，需要记录缓冲区中物品的数量。数量可以使用信号量来进行统计，这里需要使用两个信号量：empty 记录空缓冲区的数量，full 记录满缓冲区的数量。其中，empty 信号量是在生产者进程中使用，当 empty 不为 0 时，生产者才可以放入物品；full 信号量是在消费者进行中使用，当 full 信号量不为 0 时，消费者才可以取走物品。
+为了同步生产者和消费者的行为，需要记录缓冲区中物品的数量。数量可以使用信号量来进行统计，这里需要使用两个信号量：empty 记录空缓冲区的数量，full 记录满缓冲区的数量。其中，empty 信号量是在生产者进程中使用，当 empty 不为 0 时，生产者才可以放入物品；full 信号量是在消费者进程中使用，当 full 信号量不为 0 时，消费者才可以取走物品。
-注意，不能先对缓冲区进行加锁，再测试信号量。也就是说，不能先执行 down(mutex) 再执行 down(empty)。如果这么做了，那么可能会出现这种情况：生产者对缓冲区加锁后，执行 down(empty) 操作，发现 empty=0，此时生成者睡眠。消费者此时不能进入临界区，因为生产者对缓冲区加锁了，也就无法执行 up(empty) 操作，那么生产者和消费者就会一直等待下去。
+注意，不能先对缓冲区进行加锁，再测试信号量。也就是说，不能先执行 down(mutex) 再执行 down(empty)。如果这么做了，那么可能会出现这种情况：生产者对缓冲区加锁后，执行 down(empty) 操作，发现 empty = 0，此时生产者睡眠。消费者不能进入临界区，因为生产者对缓冲区加锁了，也就无法执行 up(empty) 操作，empty 永远都为 0，那么生产者和消费者就会一直等待下去，造成死锁。
```c
#define N 100
@@ -310,22 +296,22 @@ semaphore full = 0;
void producer() {
while(TRUE){
- int item = produce_item;
- down(empty);
- down(mutex);
+ int item = produce_item();
+ down(&empty);
+ down(&mutex);
insert_item(item);
- up(mutex);
- up(full);
+ up(&mutex);
+ up(&full);
}
}
void consumer() {
while(TRUE){
- down(full);
- down(mutex);
- int item = remove_item(item);
- up(mutex);
- up(empty);
+ down(&full);
+ down(&mutex);
+ int item = remove_item();
+ up(&mutex);
+ up(&empty);
consume_item(item);
}
}
@@ -335,7 +321,7 @@ void consumer() {
使用信号量机制实现的生产者消费者问题需要客户端代码做很多控制，而管程把控制的代码独立出来，不仅不容易出错，也使得客户端代码调用更容易。
-c 语言不支持管程，下面的示例代码使用了类 Pascal 语言来描述管程。示例代码中的管程提供了 insert() 和 remove() 方法，客户端代码通过调用这两个方法来解决生产者-消费者问题。
+c 语言不支持管程，下面的示例代码使用了类 Pascal 语言来描述管程。示例代码的管程提供了 insert() 和 remove() 方法，客户端代码通过调用这两个方法来解决生产者-消费者问题。
```pascal
monitor ProducerConsumer
@@ -356,11 +342,12 @@ end monitor;
管程有一个重要特性：在一个时刻只能有一个进程使用管程。进程在无法继续执行的时候不能一直占用管程，否者其它进程永远不能使用管程。
-管程引入了 **条件变量** 以及相关的操作：**wait()** 和 **signal()** 来实现同步操作。对条件变量执行 wait() 操作会导致调用进程阻塞，把管程让出来让另一个进程持有。signal() 操作用于唤醒被阻塞的进程。
+管程引入了 **条件变量** 以及相关的操作：**wait()** 和 **signal()** 来实现同步操作。对条件变量执行 wait() 操作会导致调用进程阻塞，把管程让出来给另一个进程持有。signal() 操作用于唤醒被阻塞的进程。
-**使用管程实现生成者-消费者问题**
+ **使用管程实现生成者-消费者问题** **（一）管道**
+
+写进程在管道的尾端写入数据，读进程在管道的首端读出数据。管道提供了简单的流控制机制，进程试图读空管道时，在有数据写入管道前，进程将一直阻塞。同样地，管道已经满时，进程再试图写管道，在其它进程从管道中移走数据之前，写进程将一直阻塞。
+
+Linux 中管道通过空文件实现。
+
+管道有三种：
+
+1. 普通管道：有两个限制，一是只能单向传输；二是只能在父子进程之间使用；
+2. 流管道：去除第一个限制，支持双向传输；
+3. 命名管道：去除第二个限制，可以在不相关进程之间进行通信。
+
+ **（二）消息队列**
+
+消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
+
+ **（三）套接字**
+
+套接字也是一种进程间通信机制，与其它通信机制不同的是，它可用于不同机器间的进程通信。
+
+1 和 P2 所请求的资源都得不到满足，只有进程 P3 可以，让 P3 执行，之后释放 P3 拥有的资源，此时 A = (2 2 2 0)。P2 可以执行，执行后释放 P2 拥有的资源，A = (4 2 2 1) 。P1 也可以执行。所有进程都可以顺利执行，没有死锁。
+
+算法总结如下：
+
+每个进程最开始时都不被标记，执行过程有可能被标记。当算法结束时，任何没有被标记的进程都是死锁进程。
+
+1. 寻找一个没有标记的进程 Pi ，它所请求的资源小于等于 A。
+2. 如果找到了这样一个进程，那么将 C 矩阵的第 i 行向量加到 A 中，标记该进程，并转回 1。
+3. 如果没有这样一个进程，算法终止。
+
+**（三）死锁恢复**
+
+- 利用抢占恢复
+- 利用回滚恢复
+- 通过杀死进程恢复
+
+### 3. 死锁预防
在程序运行之前预防发生死锁。
-#### 2.1 破坏互斥条件
+**（一）破坏互斥条件**
例如假脱机打印机技术允许若干个进程同时输出，唯一真正请求物理打印机的进程是打印机守护进程。
-#### 2.2 破坏占有和等待条件
+**（二）破坏占有和等待条件**
一种实现方式是规定所有进程在开始执行前请求所需要的全部资源。
-#### 2.3 破坏不可抢占条件
+**（三）破坏不可抢占条件**
-#### 2.4 破坏环路等待
+**（四）破坏环路等待**
给资源统一编号，进程只能按编号顺序来请求资源。
-### 3. 死锁避免
+### 4. 死锁避免
在程序运行时避免发生死锁。
-#### 3.1 安全状态
+**（一）安全状态**
1 和 P2 所请求的资源都得不到满足，只有进程 P3 可以，让 P3 执行，之后释放 P3 拥有的资源，此时 A = (2 2 2 0)。P1 可以执行，执行后释放 P1 拥有的资源，A = (4 2 2 2) ，P2 也可以执行。所有进程都可以顺利执行，没有死锁。
-
-算法总结如下：
-
-每个进程最开始时都不被标记，执行过程有可能被标记。当算法结束时，任何没有被标记的进程都是死锁进程。
-
-1. 寻找一个没有标记的进程 Pi ，它所请求的资源小于等于 A。
-2. 如果找到了这样一个进程，那么将 C 矩阵的第 i 行向量加到 A 中，标记该进程，并转回 1。
-3. 如果有没有这样一个进程，算法终止。
-
-可以看到，死锁检测和银行家算法中判断是否为安全状态的方法类似。
-
-#### 4.2 死锁恢复
-
-- 利用抢占恢复
-- 杀死进程
-
-# 第四章 存储器管理
+# 四、内存管理
## 虚拟内存
-每个程序拥有自己的地址空间，这个地址空间被分割成多个块，每一块称为一页。这些页被映射到物理内存，但不需要映射到连续的物理内存，也不需要所有页都必须在物理内存中。
-
-当程序引用到一部分在物理内存中的地址空间时，由硬件执行必要的映射，将缺失的部分装入物理内存并重新执行失败的指令。
+每个程序拥有自己的地址空间，这个地址空间被分割成多个块，每一块称为一页。这些页被映射到物理内存，但不需要映射到连续的物理内存，也不需要所有页都必须在物理内存中。当程序引用到一部分不在物理内存中的地址空间时，由硬件执行必要的映射，将缺失的部分装入物理内存并重新执行失败的指令。
## 分页与分段
### 1. 分页
-用户程序的地址空间被划分为若干固定大小的区域，称为“页”。相应地，内存空间分成若干个物理块，页和块的大小相等。可将用户程序的任一页放在内存的任一块中，实现了离散分配，由一个页表来维护它们之间的映射关系。
+大部分虚拟内存系统都使用分页技术。把由程序产生的地址称为虚拟地址，它们构成了一个虚拟地址空间。例如有一台计算机可以产生 16 位地址，它的虚拟地址空间为 0\~64K，然而计算机只有 32KB 的物理内存，因此虽然可以编写 64KB 的程序，但它们不能被完全调入内存运行。
+
+
+
+int main()
+{
+ printf("hello, world\n");
+ return 0;
+}
+```
+
+在 Unix 系统上，由编译器把源文件转换为目标文件。
+
+```bash
+gcc -o hello hello.c
+```
+
+这个过程大致如下：
+
+k -1)} 中随机取出一个数，记作 r，然后取 r 倍的争用期作为重传等待时间。
-## 集线器
+## 扩展局域网*
-从表面上看，使用集线器的局域网在物理上是一个星型网。但是集线器使用电子器件来模拟实际缆线的工作，逻辑上仍是一个总线网，整个系统仍像一个传统以太网那样运行。
+### 1. 在物理层进行扩展
-d 为偏差，它与新的 RRT 和 RRTs 有关。
+其中 RTTd 为偏差。
## TCP 流量控制
流量控制是为了控制发送方发送速率，保证接收方来得及接收。
-接收方发送的确认报文中的窗口字段可以用来控制发送方窗口大小，从而影响发送方的发送速率。例如将窗口字段设置为 0，则发送方不能发送数据。
+接收方发送的确认报文中的窗口字段可以用来控制发送方窗口大小，从而影响发送方的发送速率。将窗口字段设置为 0，则发送方不能发送数据。
## TCP 拥塞控制
如果网络出现拥塞，分组将会丢失，此时发送方会继续重传，从而导致网络拥塞程度更高。因此当出现拥塞时，应当控制发送方的速率。这一点和流量控制很像，但是出发点不同。流量控制是为了让接收方能来得及接受，而拥塞控制是为了降低整个网络的拥塞程度。
-1 和 M2 ，此时收到 M4 ，应当发送对 M2 的确认。
在发送方，如果收到三个重复确认，那么可以确认下一个报文段丢失，例如收到三个 M2 ，则 M3 丢失。此时执行快重传，立即重传下一个报文段。
-在这种情况下，只是丢失个别报文段，而不是网络拥塞，因此执行快恢复，令 ssthresh = cwnd / 2 ，cwnd = ssthresh，注意到此时直接进入拥塞避免。
+在这种情况下，只是丢失个别报文段，而不是网络拥塞，因此执行快恢复，令 ssthresh = cwnd/2 ，cwnd = ssthresh，注意到此时直接进入拥塞避免。
- observers;
- private float temperature;
- private float humidity;
- private float pressure;
-
- public WeatherData() {
- observers = new ArrayList<>();
- }
-
- @Override
- public void resisterObserver(Observer o) {
- observers.add(o);
- }
-
- @Override
- public void removeObserver(Observer o) {
- int i = observers.indexOf(o);
- if (i >= 0) {
- observers.remove(i);
- }
- }
-
- @Override
- public void notifyObserver() {
- for (Observer o : observers) {
- o.update(temperature, humidity, pressure);
- }
- }
-
- public void setMeasurements(float temperature, float humidity, float pressure) {
- this.temperature = temperature;
- this.humidity = humidity;
- this.pressure = pressure;
- notifyObserver();
- }
-}
-```
-```java
-public interface Observer {
- public void update(float temp, float humidity, float pressure);
-}
-```
-```java
-public class CurrentConditionsDisplay implements Observer {
- private Subject weatherData;
-
- public CurrentConditionsDisplay(Subject weatherData) {
- this.weatherData = weatherData;
- weatherData.resisterObserver(this);
- }
-
- @Override
- public void update(float temp, float humidity, float pressure) {
- System.out.println("CurrentConditionsDisplay.update:" + temp + " " + humidity + " " + pressure);
- }
-}
-```
-```java
-public class StatisticsDisplay implements Observer {
- private Subject weatherData;
-
- public StatisticsDisplay(Subject weatherData) {
- this.weatherData = weatherData;
- weatherData.resisterObserver(this);
- }
-
- @Override
- public void update(float temp, float humidity, float pressure) {
- System.out.println("StatisticsDisplay.update:" + temp + " " + humidity + " " + pressure);
- }
-}
-```
-```java
-public class WeatherStation {
- public static void main(String[] args) {
- WeatherData weatherData = new WeatherData();
- CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(weatherData);
- StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
-
- weatherData.setMeasurements(0, 0, 0);
- weatherData.setMeasurements(1, 1, 1);
- }
-}
-```
-执行结果
-```html
-CurrentConditionsDisplay.update:0.0 0.0 0.0
-StatisticsDisplay.update:0.0 0.0 0.0
-CurrentConditionsDisplay.update:1.0 1.0 1.0
-StatisticsDisplay.update:1.0 1.0 1.0
-```
-
-# 第三章 装饰模式
-
-**1. 问题描述**
-
-设计不同种类的饮料，并且每种饮料可以动态添加新的材料，比如可以添加牛奶。计算一种饮料的价格。
-
-**2. 模式定义**
-
-动态地将责任附加到对象上。在扩展功能上，装饰者提供了比继承更有弹性的替代方案。
-
-下图中 DarkRoast 对象被 Mocha 包裹，Mocha 对象又被 Whip 包裹，并且他们都继承自相同父类，都有 cost() 方法，但是外层对象的 cost() 方法实现调用了内层对象的 cost() 方法。因此，如果要在 DarkRoast 上添加 Mocha，那么只需要用 Mocha 包裹 DarkRoast，如果还需要 Whip ，就用 Whip 包裹 Mocha，最后调用 cost() 方法能把三种对象的价格都包含进去。
-
- {
-
- private int[] items;
-
- public Aggregate() {
- items = new int[10];
- for (int i = 0; i < items.length; i++) {
- items[i] = i;
- }
- }
-
- @Override
- public Iterator iterator() {
- return new ConcreteIterator(items);
- }
-}
-```
-```java
-import java.util.Iterator;
-
-public class ConcreteIterator implements Iterator {
-
- private int[] items;
- private int position = 0;
-
- public ConcreteIterator(int[] items) {
- this.items = items;
- }
-
- @Override
- public boolean hasNext() {
- return position < items.length;
- }
-
- @Override
- public Integer next() {
- return items[position++];
- }
-}
-```
-```java
-public class Client {
- public static void main(String[] args) {
- Aggregate aggregate = new Aggregate();
- for (int item : aggregate) {
- System.out.println(item);
- }
- }
-}
-```
-
-## 3. 组合模式
-
-**1. 设计原则**
-
-一个类应该只有一个引起改变的原因。
-
-**2. 模式定义**
-
-允许将对象组合成树形结构来表现“整体/部分”层次结构。
-
-组合能让客户以一致的方式处理个别对象以及组合对象。
-
-**3. 模式类图**
-
-组件（Component）类是组合类（Composite）和叶子类（Leaf）的父类，可以把组合类看成是树的中间节点。
-
-组合类拥有一个组件对象，因此组合类的操作可以委托给组件对象去处理，而组件对象可以是另一个组合类或者叶子类。
-
- childs;
-
- public Composite(String name) {
- super(name);
- childs = new ArrayList<>();
- }
-
- @Override
- public void addChild(Component component) {
- childs.add(component);
- }
-
- @Override
- protected void print(int level) {
- for (int i = 0; i < level; i++) {
- System.out.print("--");
- }
- System.out.println("Composite:" + name);
- for (Component component : childs) {
- component.print(level + 1);
- }
- }
-}
-```
+如果存在下面这种代码，就需要使用简单工厂将对象实例化的部分放到简单工厂中。
```java
public class Client {
public static void main(String[] args) {
- Composite root = new Composite("root");
- Component node1 = new Leaf("1");
- Component node2 = new Composite("2");
- Component node3 = new Leaf("3");
- root.addChild(node1);
- root.addChild(node2);
- root.addChild(node3);
- Component node21 = new Leaf("21");
- Component node22 = new Composite("22");
- node2.addChild(node21);
- node2.addChild(node22);
- Component node221 = new Leaf("221");
- node22.addChild(node221);
- root.print();
- }
-}
-```
-运行结果
-
-```html
-Composite:root
---left:1
---Composite:2
-----left:21
-----Composite:22
-------left:221
---left:3
-```
-
-# 第十章 状态模式
-
-**1. 模式定义**
-
-允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它所属的类。
-
-**2. 模式类图**
-
-Context 的 request() 方法委托给 State 对象去处理。当 Context 组合的 State 对象发生改变时，它的行为也就发生了改变。
-
-
-
-
