stack = new Stack<>();
+ while (l != null) {
+ stack.push(l.val);
+ l = l.next;
+ }
+ return stack;
+}
+```
+
+# 回文链表
+
+[234. Palindrome Linked List (Easy)](https://leetcode.com/problems/palindrome-linked-list/description/)
+
+题目要求：以 O(1) 的空间复杂度来求解。
+
+切成两半，把后半段反转，然后比较两半是否相等。
+
+```java
+public boolean isPalindrome(ListNode head) {
+ if (head == null || head.next == null) return true;
+ ListNode slow = head, fast = head.next;
+ while (fast != null && fast.next != null) {
+ slow = slow.next;
+ fast = fast.next.next;
+ }
+ if (fast != null) slow = slow.next; // 偶数节点，让 slow 指向下一个节点
+ cut(head, slow); // 切成两个链表
+ return isEqual(head, reverse(slow));
+}
+
+private void cut(ListNode head, ListNode cutNode) {
+ while (head.next != cutNode) {
+ head = head.next;
+ }
+ head.next = null;
+}
+
+private ListNode reverse(ListNode head) {
+ ListNode newHead = null;
+ while (head != null) {
+ ListNode nextNode = head.next;
+ head.next = newHead;
+ newHead = head;
+ head = nextNode;
+ }
+ return newHead;
+}
+
+private boolean isEqual(ListNode l1, ListNode l2) {
+ while (l1 != null && l2 != null) {
+ if (l1.val != l2.val) return false;
+ l1 = l1.next;
+ l2 = l2.next;
+ }
+ return true;
+}
+```
+
+# 分隔链表
+
+[725. Split Linked List in Parts(Medium)](https://leetcode.com/problems/split-linked-list-in-parts/description/)
+
+```html
+Input:
+root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
+Output: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
+Explanation:
+The input has been split into consecutive parts with size difference at most 1, and earlier parts are a larger size than the later parts.
+```
+
+题目描述：把链表分隔成 k 部分，每部分的长度都应该尽可能相同，排在前面的长度应该大于等于后面的。
+
+```java
+public ListNode[] splitListToParts(ListNode root, int k) {
+ int N = 0;
+ ListNode cur = root;
+ while (cur != null) {
+ N++;
+ cur = cur.next;
+ }
+ int mod = N % k;
+ int size = N / k;
+ ListNode[] ret = new ListNode[k];
+ cur = root;
+ for (int i = 0; cur != null && i < k; i++) {
+ ret[i] = cur;
+ int curSize = size + (mod-- > 0 ? 1 : 0);
+ for (int j = 0; j < curSize - 1; j++) {
+ cur = cur.next;
+ }
+ ListNode next = cur.next;
+ cur.next = null;
+ cur = next;
+ }
+ return ret;
+}
+```
+
+# 链表元素按奇偶聚集
+
+[328. Odd Even Linked List (Medium)](https://leetcode.com/problems/odd-even-linked-list/description/)
+
+```html
+Example:
+Given 1->2->3->4->5->NULL,
+return 1->3->5->2->4->NULL.
+```
+
+```java
+public ListNode oddEvenList(ListNode head) {
+ if (head == null) {
+ return head;
+ }
+ ListNode odd = head, even = head.next, evenHead = even;
+ while (even != null && even.next != null) {
+ odd.next = odd.next.next;
+ odd = odd.next;
+ even.next = even.next.next;
+ even = even.next;
+ }
+ odd.next = evenHead;
+ return head;
+}
+```
+
+
+
+
+🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/notes/Leetcode-Database 题解.md b/notes/Leetcode-Database 题解.md
new file mode 100644
index 00000000..8f318f32
--- /dev/null
+++ b/notes/Leetcode-Database 题解.md
@@ -0,0 +1,956 @@
+
+* [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)
+
+
+
+# 595. Big Countries
+
+https://leetcode.com/problems/big-countries/description/
+
+## Description
+
+```html
++-----------------+------------+------------+--------------+---------------+
+| 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 |
++-----------------+------------+------------+--------------+---------------+
+```
+
+查找面积超过 3,000,000 或者人口数超过 25,000,000 的国家。
+
+```html
++--------------+-------------+--------------+
+| name | population | area |
++--------------+-------------+--------------+
+| Afghanistan | 25500100 | 652230 |
+| Algeria | 37100000 | 2381741 |
++--------------+-------------+--------------+
+```
+
+## SQL Schema
+
+```sql
+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 )
+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' );
+```
+
+## Solution
+
+```sql
+SELECT name,
+ population,
+ area
+FROM
+ World
+WHERE
+ area > 3000000
+ OR population > 25000000;
+```
+
+# 627. Swap Salary
+
+https://leetcode.com/problems/swap-salary/description/
+
+## Description
+
+```html
+| id | name | sex | salary |
+|----|------|-----|--------|
+| 1 | A | m | 2500 |
+| 2 | B | f | 1500 |
+| 3 | C | m | 5500 |
+| 4 | D | f | 500 |
+```
+
+只用一个 SQL 查询，将 sex 字段反转。
+
+```html
+| id | name | sex | salary |
+|----|------|-----|--------|
+| 1 | A | f | 2500 |
+| 2 | B | m | 1500 |
+| 3 | C | f | 5500 |
+| 4 | D | m | 500 |
+```
+
+## SQL Schema
+
+```sql
+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 )
+VALUES
+ ( '1', 'A', 'm', '2500' ),
+ ( '2', 'B', 'f', '1500' ),
+ ( '3', 'C', 'm', '5500' ),
+ ( '4', 'D', 'f', '500' );
+```
+
+## Solution
+
+```sql
+UPDATE salary
+SET sex = CHAR ( ASCII(sex) ^ ASCII( 'm' ) ^ ASCII( 'f' ) );
+```
+
+# 620. Not Boring Movies
+
+https://leetcode.com/problems/not-boring-movies/description/
+
+## Description
+
+
+```html
++---------+-----------+--------------+-----------+
+| 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 |
++---------+-----------+--------------+-----------+
+```
+
+查找 id 为奇数，并且 description 不是 boring 的电影，按 rating 降序。
+
+```html
++---------+-----------+--------------+-----------+
+| id | movie | description | rating |
++---------+-----------+--------------+-----------+
+| 5 | House card| Interesting| 9.1 |
+| 1 | War | great 3D | 8.9 |
++---------+-----------+--------------+-----------+
+```
+
+## SQL Schema
+
+```sql
+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 )
+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 );
+```
+
+## Solution
+
+```sql
+SELECT
+ *
+FROM
+ cinema
+WHERE
+ id % 2 = 1
+ AND description != 'boring'
+ORDER BY
+ rating DESC;
+```
+
+# 596. Classes More Than 5 Students
+
+https://leetcode.com/problems/classes-more-than-5-students/description/
+
+## Description
+
+```html
++---------+------------+
+| student | class |
++---------+------------+
+| A | Math |
+| B | English |
+| C | Math |
+| D | Biology |
+| E | Math |
+| F | Computer |
+| G | Math |
+| H | Math |
+| I | Math |
++---------+------------+
+```
+
+查找有五名及以上 student 的 class。
+
+```html
++---------+
+| class |
++---------+
+| Math |
++---------+
+```
+
+## SQL Schema
+
+```sql
+DROP TABLE
+IF
+ 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' );
+```
+
+## Solution
+
+```sql
+SELECT
+ class
+FROM
+ courses
+GROUP BY
+ class
+HAVING
+ count( DISTINCT student ) >= 5;
+```
+
+# 182. Duplicate Emails
+
+https://leetcode.com/problems/duplicate-emails/description/
+
+## Description
+
+邮件地址表：
+
+```html
++----+---------+
+| Id | Email |
++----+---------+
+| 1 | a@b.com |
+| 2 | c@d.com |
+| 3 | a@b.com |
++----+---------+
+```
+
+查找重复的邮件地址：
+
+```html
++---------+
+| Email |
++---------+
+| a@b.com |
++---------+
+```
+
+## SQL Schema
+
+```sql
+DROP TABLE
+IF
+ 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' );
+```
+
+## Solution
+
+```sql
+SELECT
+ Email
+FROM
+ Person
+GROUP BY
+ Email
+HAVING
+ COUNT( * ) >= 2;
+```
+
+# 196. Delete Duplicate Emails
+
+https://leetcode.com/problems/delete-duplicate-emails/description/
+
+## Description
+
+邮件地址表：
+
+```html
++----+---------+
+| Id | Email |
++----+---------+
+| 1 | a@b.com |
+| 2 | c@d.com |
+| 3 | a@b.com |
++----+---------+
+```
+
+删除重复的邮件地址：
+
+```html
++----+------------------+
+| Id | Email |
++----+------------------+
+| 1 | john@example.com |
+| 2 | bob@example.com |
++----+------------------+
+```
+
+## SQL Schema
+
+与 182 相同。
+
+## Solution
+
+连接：
+
+```sql
+DELETE p1
+FROM
+ Person p1,
+ Person p2
+WHERE
+ p1.Email = p2.Email
+ AND p1.Id > p2.Id
+```
+
+子查询：
+
+```sql
+DELETE
+FROM
+ Person
+WHERE
+ 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。以下演示了这种错误解法。
+
+```sql
+DELETE
+FROM
+ Person
+WHERE
+ 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)
+
+# 175. Combine Two Tables
+
+https://leetcode.com/problems/combine-two-tables/description/
+
+## Description
+
+Person 表：
+
+```html
++-------------+---------+
+| Column Name | Type |
++-------------+---------+
+| PersonId | int |
+| FirstName | varchar |
+| LastName | varchar |
++-------------+---------+
+PersonId is the primary key column for this table.
+```
+
+Address 表：
+
+```html
++-------------+---------+
+| Column Name | Type |
++-------------+---------+
+| AddressId | int |
+| PersonId | int |
+| City | varchar |
+| State | varchar |
++-------------+---------+
+AddressId is the primary key column for this table.
+```
+
+查找 FirstName, LastName, City, State 数据，而不管一个用户有没有填地址信息。
+
+## SQL Schema
+
+```sql
+DROP TABLE
+IF
+ 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 )
+VALUES
+ ( 1, 'Wang', 'Allen' );
+INSERT INTO Address ( AddressId, PersonId, City, State )
+VALUES
+ ( 1, 2, 'New York City', 'New York' );
+```
+
+## Solution
+
+使用左外连接。
+
+```sql
+SELECT
+ FirstName,
+ LastName,
+ City,
+ State
+FROM
+ Person P
+ LEFT JOIN Address A
+ ON P.PersonId = A.PersonId;
+```
+
+# 181. Employees Earning More Than Their Managers
+
+https://leetcode.com/problems/employees-earning-more-than-their-managers/description/
+
+## Description
+
+Employee 表：
+
+```html
++----+-------+--------+-----------+
+| Id | Name | Salary | ManagerId |
++----+-------+--------+-----------+
+| 1 | Joe | 70000 | 3 |
+| 2 | Henry | 80000 | 4 |
+| 3 | Sam | 60000 | NULL |
+| 4 | Max | 90000 | NULL |
++----+-------+--------+-----------+
+```
+
+查找薪资大于其经理薪资的员工信息。
+
+## SQL Schema
+
+```sql
+DROP TABLE
+IF
+ 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 );
+```
+
+## Solution
+
+```sql
+SELECT
+ E1.NAME AS Employee
+FROM
+ Employee E1
+ INNER JOIN Employee E2
+ ON E1.ManagerId = E2.Id
+ AND E1.Salary > E2.Salary;
+```
+
+# 183. Customers Who Never Order
+
+https://leetcode.com/problems/customers-who-never-order/description/
+
+## Description
+
+Customers 表：
+
+```html
++----+-------+
+| Id | Name |
++----+-------+
+| 1 | Joe |
+| 2 | Henry |
+| 3 | Sam |
+| 4 | Max |
++----+-------+
+```
+
+Orders 表：
+
+```html
++----+------------+
+| Id | CustomerId |
++----+------------+
+| 1 | 3 |
+| 2 | 1 |
++----+------------+
+```
+
+查找没有订单的顾客信息：
+
+```html
++-----------+
+| Customers |
++-----------+
+| Henry |
+| Max |
++-----------+
+```
+
+## SQL Schema
+
+```sql
+DROP TABLE
+IF
+ 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 )
+VALUES
+ ( 1, 'Joe' ),
+ ( 2, 'Henry' ),
+ ( 3, 'Sam' ),
+ ( 4, 'Max' );
+INSERT INTO Orders ( Id, CustomerId )
+VALUES
+ ( 1, 3 ),
+ ( 2, 1 );
+```
+
+## Solution
+
+左外链接
+
+```sql
+SELECT
+ C.Name AS Customers
+FROM
+ Customers C
+ LEFT JOIN Orders O
+ ON C.Id = O.CustomerId
+WHERE
+ O.CustomerId IS NULL;
+```
+
+子查询
+
+```sql
+SELECT
+ Name AS Customers
+FROM
+ Customers
+WHERE
+ Id NOT IN ( SELECT CustomerId FROM Orders );
+```
+
+# 184. Department Highest Salary
+
+https://leetcode.com/problems/department-highest-salary/description/
+
+## Description
+
+Employee 表：
+
+```html
++----+-------+--------+--------------+
+| Id | Name | Salary | DepartmentId |
++----+-------+--------+--------------+
+| 1 | Joe | 70000 | 1 |
+| 2 | Henry | 80000 | 2 |
+| 3 | Sam | 60000 | 2 |
+| 4 | Max | 90000 | 1 |
++----+-------+--------+--------------+
+```
+
+Department 表：
+
+```html
++----+----------+
+| Id | Name |
++----+----------+
+| 1 | IT |
+| 2 | Sales |
++----+----------+
+```
+
+查找一个 Department 中收入最高者的信息：
+
+```html
++------------+----------+--------+
+| Department | Employee | Salary |
++------------+----------+--------+
+| IT | Max | 90000 |
+| Sales | Henry | 80000 |
++------------+----------+--------+
+```
+
+## 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 )
+VALUES
+ ( 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' );
+```
+
+## Solution
+
+创建一个临时表，包含了部门员工的最大薪资。可以对部门进行分组，然后使用 MAX() 汇总函数取得最大薪资。
+
+之后使用连接找到一个部门中薪资等于临时表中最大薪资的员工。
+
+```sql
+SELECT
+ D.NAME Department,
+ E.NAME Employee,
+ E.Salary
+FROM
+ 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;
+```
+
+# 176. Second Highest Salary
+
+https://leetcode.com/problems/second-highest-salary/description/
+
+## Description
+
+```html
++----+--------+
+| Id | Salary |
++----+--------+
+| 1 | 100 |
+| 2 | 200 |
+| 3 | 300 |
++----+--------+
+```
+
+查找工资第二高的员工。
+
+```html
++---------------------+
+| SecondHighestSalary |
++---------------------+
+| 200 |
++---------------------+
+```
+
+没有找到返回 null 而不是不返回数据。
+
+## SQL Schema
+
+```sql
+DROP TABLE
+IF
+ EXISTS Employee;
+CREATE TABLE Employee ( Id INT, Salary INT );
+INSERT INTO Employee ( Id, Salary )
+VALUES
+ ( 1, 100 ),
+ ( 2, 200 ),
+ ( 3, 300 );
+```
+
+## Solution
+
+为了在没有查找到数据时返回 null，需要在查询结果外面再套一层 SELECT。
+
+```sql
+SELECT
+ ( SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT 1, 1 ) SecondHighestSalary;
+```
+
+# 177. Nth Highest Salary
+
+## Description
+
+查找工资第 N 高的员工。
+
+## SQL Schema
+
+同 176。
+
+## Solution
+
+```sql
+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 ) );
+
+END
+```
+
+# 178. Rank Scores
+
+https://leetcode.com/problems/rank-scores/description/
+
+## Description
+
+得分表：
+
+```html
++----+-------+
+| Id | Score |
++----+-------+
+| 1 | 3.50 |
+| 2 | 3.65 |
+| 3 | 4.00 |
+| 4 | 3.85 |
+| 5 | 4.00 |
+| 6 | 3.65 |
++----+-------+
+```
+
+将得分排序，并统计排名。
+
+```html
++-------+------+
+| Score | Rank |
++-------+------+
+| 4.00 | 1 |
+| 4.00 | 1 |
+| 3.85 | 2 |
+| 3.65 | 3 |
+| 3.65 | 3 |
+| 3.50 | 4 |
++-------+------+
+```
+
+## SQL Schema
+
+```sql
+DROP TABLE
+IF
+ 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 );
+```
+
+## Solution
+
+```sql
+SELECT
+ 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;
+```
+
+# 180. Consecutive Numbers
+
+https://leetcode.com/problems/consecutive-numbers/description/
+
+## Description
+
+数字表：
+
+```html
++----+-----+
+| Id | Num |
++----+-----+
+| 1 | 1 |
+| 2 | 1 |
+| 3 | 1 |
+| 4 | 2 |
+| 5 | 1 |
+| 6 | 2 |
+| 7 | 2 |
++----+-----+
+```
+
+查找连续出现三次的数字。
+
+```html
++-----------------+
+| ConsecutiveNums |
++-----------------+
+| 1 |
++-----------------+
+```
+
+## SQL Schema
+
+```sql
+DROP TABLE
+IF
+ 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 );
+```
+
+## Solution
+
+```sql
+SELECT
+ 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;
+```
+
+# 626. Exchange Seats
+
+https://leetcode.com/problems/exchange-seats/description/
+
+## Description
+
+seat 表存储着座位对应的学生。
+
+```html
++---------+---------+
+| id | student |
++---------+---------+
+| 1 | Abbot |
+| 2 | Doris |
+| 3 | Emerson |
+| 4 | Green |
+| 5 | Jeames |
++---------+---------+
+```
+
+要求交换相邻座位的两个学生，如果最后一个座位是奇数，那么不交换这个座位上的学生。
+
+```html
++---------+---------+
+| id | student |
++---------+---------+
+| 1 | Doris |
+| 2 | Abbot |
+| 3 | Green |
+| 4 | Emerson |
+| 5 | Jeames |
++---------+---------+
+```
+
+## SQL Schema
+
+```sql
+DROP TABLE
+IF
+ 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' );
+```
+
+## Solution
+
+使用多个 union。
+
+```sql
+SELECT
+ s1.id - 1 AS id,
+ s1.student
+FROM
+ seat s1
+WHERE
+ s1.id MOD 2 = 0 UNION
+SELECT
+ s2.id + 1 AS id,
+ s2.student
+FROM
+ seat s2
+WHERE
+ s2.id MOD 2 = 1
+ AND s2.id != ( SELECT max( s3.id ) FROM seat s3 ) UNION
+SELECT
+ s4.id AS id,
+ s4.student
+FROM
+ seat s4
+WHERE
+ s4.id MOD 2 = 1
+ AND s4.id = ( SELECT max( s5.id ) FROM seat s5 )
+ORDER BY
+ id;
+```
+
+
+
+
+🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/notes/Linux.md b/notes/Linux.md
new file mode 100644
index 00000000..fe1f217f
--- /dev/null
+++ b/notes/Linux.md
@@ -0,0 +1,1253 @@
+
+* [一、常用操作以及概念](#一常用操作以及概念)
+ * [快捷键](#快捷键)
+ * [求助](#求助)
+ * [关机](#关机)
+ * [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)
+ * [孤儿进程](#孤儿进程)
+ * [僵尸进程](#僵尸进程)
+* [参考资料](#参考资料)
+
+
+
+# 一、常用操作以及概念
+
+## 快捷键
+
+- Tab：命令和文件名补全；
+- Ctrl+C：中断正在运行的程序；
+- Ctrl+D：结束键盘输入（End Of File，EOF）
+
+## 求助
+
+### 1. --help
+
+指令的基本用法与选项介绍。
+
+### 2. man
+
+man 是 manual 的缩写，将指令的具体信息显示出来。
+
+当执行 `man date` 时，有 DATE(1) 出现，其中的数字代表指令的类型，常用的数字及其类型如下：
+
+| 代号 | 类型 |
+| :--: | -- |
+| 1 | 用户在 shell 环境中可以操作的指令或者可执行文件 |
+| 5 | 配置文件 |
+| 8 | 系统管理员可以使用的管理指令 |
+
+### 3. info
+
+info 与 man 类似，但是 info 将文档分成一个个页面，每个页面可以进行跳转。
+
+### 4. doc
+
+/usr/share/doc 存放着软件的一整套说明文件。
+
+## 关机
+
+### 1. who
+
+在关机前需要先使用 who 命令查看有没有其它用户在线。
+
+### 2. sync
+
+为了加快对磁盘文件的读写速度，位于内存中的文件数据不会立即同步到磁盘上，因此关机之前需要先进行 sync 同步操作。
+
+### 3. shutdown
+
+```html
+# shutdown [-krhc] 时间 [信息]
+-k ： 不会关机，只是发送警告信息，通知所有在线的用户
+-r ： 将系统的服务停掉后就重新启动
+-h ： 将系统的服务停掉后就立即关机
+-c ： 取消已经在进行的 shutdown 指令内容
+```
+
+## PATH
+
+可以在环境变量 PATH 中声明可执行文件的路径，路径之间用 : 分隔。
+
+```html
+/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/dmtsai/.local/bin:/home/dmtsai/bin
+```
+
+## sudo
+
+sudo 允许一般用户使用 root 可执行的命令，不过只有在 /etc/sudoers 配置文件中添加的用户才能使用该指令。
+
+## 包管理工具
+
+RPM 和 DPKG 为最常见的两类软件包管理工具：
+
+- RPM 全称为 Redhat Package Manager，最早由 Red Hat 公司制定实施，随后被 GNU 开源操作系统接受并成为很多 Linux 系统 (RHEL) 的既定软件标准。
+- 与 RPM 竞争的是基于 Debian 操作系统 (Ubuntu) 的 DEB 软件包管理工具 DPKG，全称为 Debian Package，功能方面与 RPM 相似。
+
+YUM 基于 RPM，具有依赖管理和软件升级功能。
+
+## 发行版
+
+Linux 发行版是 Linux 内核及各种应用软件的集成版本。
+
+| 基于的包管理工具 | 商业发行版 | 社区发行版 |
+| :--: | :--: | :--: |
+| RPM | Red Hat | Fedora / CentOS |
+| DPKG | Ubuntu | Debian |
+
+## VIM 三个模式
+
+- 一般指令模式（Command mode）：VIM 的默认模式，可以用于移动游标查看内容；
+- 编辑模式（Insert mode）：按下 "i" 等按键之后进入，可以对文本进行编辑；
+- 指令列模式（Bottom-line mode）：按下 ":" 按键之后进入，用于保存退出等操作。
+
+
+
+在指令列模式下，有以下命令用于离开或者保存文件。
+
+| 命令 | 作用 |
+| :--: | :--: |
+| :w | 写入磁盘|
+| :w! | 当文件为只读时，强制写入磁盘。到底能不能写入，与用户对该文件的权限有关 |
+| :q | 离开 |
+| :q! | 强制离开不保存 |
+| :wq | 写入磁盘后离开 |
+| :wq!| 强制写入磁盘后离开 |
+
+## 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)
+
+# 二、磁盘
+
+## 磁盘接口
+
+### 1. IDE
+
+IDE（ATA）全称 Advanced Technology Attachment，接口速度最大为 133MB/s，因为并口线的抗干扰性太差，且排线占用空间较大，不利电脑内部散热，已逐渐被 SATA 所取代。
+
+
+
+### 2. SATA
+
+SATA 全称 Serial ATA，也就是使用串口的 ATA 接口，抗干扰性强，且对数据线的长度要求比 ATA 低很多，支持热插拔等功能。SATA-II 的接口速度为 300MiB/s，而新的 SATA-III 标准可达到 600MiB/s 的传输速度。SATA 的数据线也比 ATA 的细得多，有利于机箱内的空气流通，整理线材也比较方便。
+
+
+
+### 3. SCSI
+
+SCSI 全称是 Small Computer System Interface（小型机系统接口），经历多代的发展，从早期的 SCSI-II 到目前的 Ultra320 SCSI 以及 Fiber-Channel（光纤通道），接口型式也多种多样。SCSI 硬盘广为工作站以及个人电脑以及服务器所使用，因此会使用较为先进的技术，如碟片转速 15000rpm 的高转速，且传输时 CPU 占用率较低，但是单价也比相同容量的 ATA 及 SATA 硬盘更加昂贵。
+
+
+
+### 4. SAS
+
+SAS（Serial Attached SCSI）是新一代的 SCSI 技术，和 SATA 硬盘相同，都是采取序列式技术以获得更高的传输速度，可达到 6Gb/s。此外也通过缩小连接线改善系统内部空间等。
+
+
+
+## 磁盘的文件名
+
+Linux 中每个硬件都被当做一个文件，包括磁盘。磁盘以磁盘接口类型进行命名，常见磁盘的文件名如下：
+
+- IDE 磁盘：/dev/hd[a-d]
+- SATA/SCSI/SAS 磁盘：/dev/sd[a-p]
+
+其中文件名后面的序号的确定与系统检测到磁盘的顺序有关，而与磁盘所插入的插槽位置无关。
+
+# 三、分区
+
+## 分区表
+
+磁盘分区表主要有两种格式，一种是限制较多的 MBR 分区表，一种是较新且限制较少的 GPT 分区表。
+
+### 1. MBR
+
+MBR 中，第一个扇区最重要，里面有主要开机记录（Master boot record, MBR）及分区表（partition table），其中主要开机记录占 446 bytes，分区表占 64 bytes。
+
+分区表只有 64 bytes，最多只能存储 4 个分区，这 4 个分区为主分区（Primary）和扩展分区（Extended）。其中扩展分区只有一个，它使用其它扇区来记录额外的分区表，因此通过扩展分区可以分出更多分区，这些分区称为逻辑分区。
+
+Linux 也把分区当成文件，分区文件的命名方式为：磁盘文件名 + 编号，例如 /dev/sda1。注意，逻辑分区的编号从 5 开始。
+
+### 2. GPT
+
+不同的磁盘有不同的扇区大小，例如 512 bytes 和最新磁盘的 4 k。GPT 为了兼容所有磁盘，在定义扇区上使用逻辑区块地址（Logical Block Address, LBA），LBA 默认大小为 512 bytes。
+
+GPT 第 1 个区块记录了主要开机记录（MBR），紧接着是 33 个区块记录分区信息，并把最后的 33 个区块用于对分区信息进行备份。这 33 个区块第一个为 GPT 表头纪录，这个部份纪录了分区表本身的位置与大小和备份分区的位置，同时放置了分区表的校验码 (CRC32)，操作系统可以根据这个校验码来判断 GPT 是否正确。若有错误，可以使用备份分区进行恢复。
+
+GPT 没有扩展分区概念，都是主分区，每个 LBA 可以分 4 个分区，因此总共可以分 4 * 32 = 128 个分区。
+
+MBR 不支持 2.2 TB 以上的硬盘，GPT 则最多支持到 233 TB = 8 ZB。
+
+
+
+## 开机检测程序
+
+### 1. BIOS
+
+BIOS（Basic Input/Output System，基本输入输出系统），它是一个固件（嵌入在硬件中的软件），BIOS 程序存放在断电后内容不会丢失的只读内存中。
+
+
+
+BIOS 是开机的时候计算机执行的第一个程序，这个程序知道可以开机的磁盘，并读取磁盘第一个扇区的主要开机记录（MBR），由主要开机记录（MBR）执行其中的开机管理程序，这个开机管理程序会加载操作系统的核心文件。
+
+主要开机记录（MBR）中的开机管理程序提供以下功能：选单、载入核心文件以及转交其它开机管理程序。转交这个功能可以用来实现多重引导，只需要将另一个操作系统的开机管理程序安装在其它分区的启动扇区上，在启动开机管理程序时，就可以通过选单选择启动当前的操作系统或者转交给其它开机管理程序从而启动另一个操作系统。
+
+下图中，第一扇区的主要开机记录（MBR）中的开机管理程序提供了两个选单：M1、M2，M1 指向了 Windows 操作系统，而 M2 指向其它分区的启动扇区，里面包含了另外一个开机管理程序，提供了一个指向 Linux 的选单。
+
+
+
+安装多重引导，最好先安装 Windows 再安装 Linux。因为安装 Windows 时会覆盖掉主要开机记录（MBR），而 Linux 可以选择将开机管理程序安装在主要开机记录（MBR）或者其它分区的启动扇区，并且可以设置开机管理程序的选单。
+
+### 2. UEFI
+
+BIOS 不可以读取 GPT 分区表，而 UEFI 可以。
+
+# 四、文件系统
+
+## 分区与文件系统
+
+对分区进行格式化是为了在分区上建立文件系统。一个分区通常只能格式化为一个文件系统，但是磁盘阵列等技术可以将一个分区格式化为多个文件系统。
+
+## 组成
+
+最主要的几个组成部分如下：
+
+- inode：一个文件占用一个 inode，记录文件的属性，同时记录此文件的内容所在的 block 编号；
+- block：记录文件的内容，文件太大时，会占用多个 block。
+
+除此之外还包括：
+
+- superblock：记录文件系统的整体信息，包括 inode 和 block 的总量、使用量、剩余量，以及文件系统的格式与相关信息等；
+- block bitmap：记录 block 是否被使用的位域。
+
+
+
+## 文件读取
+
+对于 Ext2 文件系统，当要读取一个文件的内容时，先在 inode 中去查找文件内容所在的所有 block，然后把所有 block 的内容读出来。
+
+
+
+而对于 FAT 文件系统，它没有 inode，每个 block 中存储着下一个 block 的编号。
+
+
+
+## 磁盘碎片
+
+指一个文件内容所在的 block 过于分散，导致磁盘磁头移动距离过大，从而降低磁盘读写性能。
+
+## block
+
+在 Ext2 文件系统中所支持的 block 大小有 1K，2K 及 4K 三种，不同的大小限制了单个文件和文件系统的最大大小。
+
+| 大小 | 1KB | 2KB | 4KB |
+| :---: | :---: | :---: | :---: |
+| 最大单一文件 | 16GB | 256GB | 2TB |
+| 最大文件系统 | 2TB | 8TB | 16TB |
+
+一个 block 只能被一个文件所使用，未使用的部分直接浪费了。因此如果需要存储大量的小文件，那么最好选用比较小的 block。
+
+## inode
+
+inode 具体包含以下信息：
+
+- 权限 (read/write/excute)；
+- 拥有者与群组 (owner/group)；
+- 容量；
+- 建立或状态改变的时间 (ctime)；
+- 最近一次的读取时间 (atime)；
+- 最近修改的时间 (mtime)；
+- 定义文件特性的旗标 (flag)，如 SetUID...；
+- 该文件真正内容的指向 (pointer)。
+
+inode 具有以下特点：
+
+- 每个 inode 大小均固定为 128 bytes (新的 ext4 与 xfs 可设定到 256 bytes)；
+- 每个文件都仅会占用一个 inode。
+
+inode 中记录了文件内容所在的 block 编号，但是每个 block 非常小，一个大文件随便都需要几十万的 block。而一个 inode 大小有限，无法直接引用这么多 block 编号。因此引入了间接、双间接、三间接引用。间接引用是指，让 inode 记录的引用 block 块记录引用信息。
+
+
+
+## 目录
+
+建立一个目录时，会分配一个 inode 与至少一个 block。block 记录的内容是目录下所有文件的 inode 编号以及文件名。
+
+可以看出文件的 inode 本身不记录文件名，文件名记录在目录中，因此新增文件、删除文件、更改文件名这些操作与目录的 w 权限有关。
+
+## 日志
+
+如果突然断电，那么文件系统会发生错误，例如断电前只修改了 block bitmap，而还没有将数据真正写入 block 中。
+
+ext3/ext4 文件系统引入了日志功能，可以利用日志来修复文件系统。
+
+## 挂载
+
+挂载利用目录作为文件系统的进入点，也就是说，进入目录之后就可以读取文件系统的数据。
+
+## 目录配置
+
+为了使不同 Linux 发行版本的目录结构保持一致性，Filesystem Hierarchy Standard (FHS) 规定了 Linux 的目录结构。最基础的三个目录如下：
+
+- / (root, 根目录)
+- /usr (unix software resource)：所有系统默认软件都会安装到这个目录；
+- /var (variable)：存放系统或程序运行过程中的数据文件。
+
+
+
+# 五、文件
+
+## 文件属性
+
+用户分为三种：文件拥有者、群组以及其它人，对不同的用户有不同的文件权限。
+
+使用 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：文件名
+
+常见的文件类型及其含义有：
+
+- d：目录
+- -：文件
+- l：链接文件
+
+9 位的文件权限字段中，每 3 个为一组，共 3 组，每一组分别代表对文件拥有者、所属群组以及其它人的文件权限。一组权限中的 3 位分别为 r、w、x 权限，表示可读、可写、可执行。
+
+文件时间有以下三种：
+
+- modification time (mtime)：文件的内容更新就会更新；
+- status time (ctime)：文件的状态（权限、属性）更新就会更新；
+- access time (atime)：读取文件时就会更新。
+
+## 文件与目录的基本操作
+
+### 1. ls
+
+列出文件或者目录的信息，目录的信息就是其中包含的文件。
+
+```html
+# ls [-aAdfFhilnrRSt] file|dir
+-a ：列出全部的文件
+-d ：仅列出目录本身
+-l ：以长数据串行列出，包含文件的属性与权限等等数据
+```
+
+### 2. cd
+
+更换当前目录。
+
+```
+cd [相对路径或绝对路径]
+```
+
+### 3. mkdir
+
+创建目录。
+
+```
+# mkdir [-mp] 目录名称
+-m ：配置目录权限
+-p ：递归创建目录
+```
+
+### 4. rmdir
+
+删除目录，目录必须为空。
+
+```html
+rmdir [-p] 目录名称
+-p ：递归删除目录
+```
+
+### 5. touch
+
+更新文件时间或者建立新文件。
+
+```html
+# touch [-acdmt] filename
+-a ： 更新 atime
+-c ： 更新 ctime，若该文件不存在则不建立新文件
+-m ： 更新 mtime
+-d ： 后面可以接更新日期而不使用当前日期，也可以使用 --date="日期或时间"
+-t ： 后面可以接更新时间而不使用当前时间，格式为[YYYYMMDDhhmm]
+```
+
+### 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 等也复制了
+```
+
+### 7. rm
+
+删除文件。
+
+```html
+# rm [-fir] 文件或目录
+-r ：递归删除
+```
+
+### 8. mv
+
+移动文件。
+
+```html
+# mv [-fiu] source destination
+# mv [options] source1 source2 source3 .... directory
+-f ： force 强制的意思，如果目标文件已经存在，不会询问而直接覆盖
+```
+
+## 修改权限
+
+可以将一组权限用数字来表示，此时一组权限的 3 个位当做二进制数字的位，从左到右每个位的权值为 4、2、1，即每个权限对应的数字权值为 r : 4、w : 2、x : 1。
+
+```html
+# chmod [-R] xyz dirname/filename
+```
+
+示例：将 .bashrc 文件的权限修改为 -rwxr-xr--。
+
+```html
+# chmod 754 .bashrc
+```
+
+也可以使用符号来设定权限。
+
+```html
+# chmod [ugoa] [+-=] [rwx] dirname/filename
+- u：拥有者
+- g：所属群组
+- o：其他人
+- a：所有人
+- +：添加权限
+- -：移除权限
+- =：设定权限
+```
+
+示例：为 .bashrc 文件的所有用户添加写权限。
+
+```html
+# chmod a+w .bashrc
+```
+
+## 文件默认权限
+
+- 文件默认权限：文件默认没有可执行权限，因此为 666，也就是 -rw-rw-rw- 。
+- 目录默认权限：目录必须要能够进入，也就是必须拥有可执行权限，因此为 777 ，也就是 drwxrwxrwx。
+
+可以通过 umask 设置或者查看文件的默认权限，通常以掩码的形式来表示，例如 002 表示其它用户的权限去除了一个 2 的权限，也就是写权限，因此建立新文件时默认的权限为 -rw-rw-r--。
+
+## 目录的权限
+
+文件名不是存储在一个文件的内容中，而是存储在一个文件所在的目录中。因此，拥有文件的 w 权限并不能对文件名进行修改。
+
+目录存储文件列表，一个目录的权限也就是对其文件列表的权限。因此，目录的 r 权限表示可以读取文件列表；w 权限表示可以修改文件列表，具体来说，就是添加删除文件，对文件名进行修改；x 权限可以让该目录成为工作目录，x 权限是 r 和 w 权限的基础，如果不能使一个目录成为工作目录，也就没办法读取文件列表以及对文件列表进行修改了。
+
+## 链接
+
+```html
+# ln [-sf] source_filename dist_filename
+-s ：默认是 hard link，加 -s 为 symbolic link
+-f ：如果目标文件存在时，先删除目标文件
+```
+
+
+
+### 1. 实体链接
+
+在目录下创建一个条目，记录着文件名与 inode 编号，这个 inode 就是源文件的 inode。
+
+删除任意一个条目，文件还是存在，只要引用数量不为 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
+```
+
+### 2. 符号链接
+
+符号链接文件保存着源文件所在的绝对路径，在读取时会定位到源文件上，可以理解为 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
+```
+
+## 获取文件内容
+
+### 1. cat
+
+取得文件内容。
+
+```html
+# cat [-AbEnTv] filename
+-n ：打印出行号，连同空白行也会有行号，-b 不会
+```
+
+### 2. tac
+
+是 cat 的反向操作，从最后一行开始打印。
+
+### 3. more
+
+和 cat 不同的是它可以一页一页查看文件内容，比较适合大文件的查看。
+
+### 4. less
+
+和 more 类似，但是多了一个向前翻页的功能。
+
+### 5. head
+
+取得文件前几行。
+
+```html
+# head [-n number] filename
+-n ：后面接数字，代表显示几行的意思
+```
+
+### 6. tail
+
+是 head 的反向操作，只是取得是后几行。
+
+### 7. od
+
+以字符或者十六进制的形式显示二进制文件。
+
+## 指令与文件搜索
+
+### 1. which
+
+指令搜索。
+
+```html
+# which [-a] command
+-a ：将所有指令列出，而不是只列第一个
+```
+
+### 2. whereis
+
+文件搜索。速度比较快，因为它只搜索几个特定的目录。
+
+```html
+# whereis [-bmsu] dirname/filename
+```
+
+### 3. locate
+
+文件搜索。可以用关键字或者正则表达式进行搜索。
+
+locate 使用 /var/lib/mlocate/ 这个数据库来进行搜索，它存储在内存中，并且每天更新一次，所以无法用 locate 搜索新建的文件。可以使用 updatedb 来立即更新数据库。
+
+```html
+# locate [-ir] keyword
+-r：正则表达式
+```
+
+### 4. find
+
+文件搜索。可以使用文件的属性和权限进行搜索。
+
+```html
+# find [basedir] [option]
+example: find . -name "shadow*"
+```
+
+**① 与时间有关的选项**
+
+```html
+-mtime n ：列出在 n 天前的那一天修改过内容的文件
+-mtime +n ：列出在 n 天之前 (不含 n 天本身) 修改过内容的文件
+-mtime -n ：列出在 n 天之内 (含 n 天本身) 修改过内容的文件
+-newer file ： 列出比 file 更新的文件
+```
+
++4、4 和 -4 的指示的时间范围如下：
+
+
+
+**② 与文件拥有者和所属群组有关的选项**
+
+```html
+-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 的文件
+```
+
+# 六、压缩与打包
+
+## 压缩文件名
+
+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 的压缩 |
+
+## 压缩指令
+
+### 1. gzip
+
+gzip 是 Linux 使用最广的压缩指令，可以解开 compress、zip 与 gzip 所压缩的文件。
+
+经过 gzip 压缩过，源文件就不存在了。
+
+有 9 个不同的压缩等级可以使用。
+
+可以使用 zcat、zmore、zless 来读取压缩文件的内容。
+
+```html
+$ gzip [-cdtv#] filename
+-c ：将压缩的数据输出到屏幕上
+-d ：解压缩
+-t ：检验压缩文件是否出错
+-v ：显示压缩比等信息
+-# ： # 为数字的意思，代表压缩等级，数字越大压缩比越高，默认为 6
+```
+
+### 2. bzip2
+
+提供比 gzip 更高的压缩比。
+
+查看命令：bzcat、bzmore、bzless、bzgrep。
+
+```html
+$ bzip2 [-cdkzv#] filename
+-k ：保留源文件
+```
+
+### 3. xz
+
+提供比 bzip2 更佳的压缩比。
+
+可以看到，gzip、bzip2、xz 的压缩比不断优化。不过要注意的是，压缩比越高，压缩的时间也越长。
+
+查看命令：xzcat、xzmore、xzless、xzgrep。
+
+```html
+$ xz [-dtlkc#] filename
+```
+
+## 打包
+
+压缩指令只能对一个文件进行压缩，而打包能够将多个文件打包成一个大文件。tar 不仅可以用于打包，也可以使用 gzip、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 -jcv -f filename.tar.bz2 要被压缩的文件或目录名称 |
+| 查 看 | tar -jtv -f filename.tar.bz2 |
+| 解压缩 | tar -jxv -f filename.tar.bz2 -C 要解压缩的目录 |
+
+# 七、Bash
+
+可以通过 Shell 请求内核提供服务，Bash 正是 Shell 的一种。
+
+## 特性
+
+- 命令历史：记录使用过的命令
+- 命令与文件补全：快捷键：tab
+- 命名别名：例如 lm 是 ls -al 的别名
+- shell scripts
+- 通配符：例如 ls -l /usr/bin/X\* 列出 /usr/bin 下面所有以 X 开头的文件
+
+## 变量操作
+
+对一个变量赋值直接使用 =。
+
+对变量取用需要在变量前加上 \$ ，也可以用 \${} 的形式；
+
+输出变量使用 echo 命令。
+
+```bash
+$ 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。
+
+可以使用 \`指令\` 或者 \$(指令) 的方式将指令的执行结果赋值给变量。例如 version=\$(uname -r)，则 version 的值为 4.15.0-22-generic。
+
+可以使用 export 命令将自定义变量转成环境变量，环境变量可以在子程序中使用，所谓子程序就是由当前 Bash 而产生的子 Bash。
+
+Bash 的变量可以声明为数组和整数数字。注意数字类型没有浮点数。如果不进行声明，默认是字符串类型。变量的声明使用 declare 命令：
+
+```html
+$ declare [-aixr] variable
+-a ： 定义为数组类型
+-i ： 定义为整数类型
+-x ： 定义为环境变量
+-r ： 定义为 readonly 类型
+```
+
+使用 [ ] 来对数组进行索引操作：
+
+```bash
+$ array[1]=a
+$ array[2]=b
+$ echo ${array[1]}
+```
+
+## 指令搜索顺序
+
+- 以绝对或相对路径来执行指令，例如 /bin/ls 或者 ./ls ；
+- 由别名找到该指令来执行；
+- 由 Bash 内置的指令来执行；
+- 按 \$PATH 变量指定的搜索路径的顺序找到第一个指令来执行。
+
+## 数据流重定向
+
+重定向指的是使用文件代替标准输入、标准输出和标准错误输出。
+
+| 1 | 代码 | 运算符 |
+| :---: | :---: | :---:|
+| 标准输入 (stdin) | 0 | < 或 << |
+| 标准输出 (stdout) | 1 | > 或 >> |
+| 标准错误输出 (stderr) | 2 | 2> 或 2>> |
+
+其中，有一个箭头的表示以覆盖的方式重定向，而有两个箭头的表示以追加的方式重定向。
+
+可以将不需要的标准输出以及标准错误输出重定向到 /dev/null，相当于扔进垃圾箱。
+
+如果需要将标准输出以及标准错误输出同时重定向到一个文件，需要将某个输出转换为另一个输出，例如 2>&1 表示将标准错误输出转换为标准输出。
+
+```bash
+$ find /home -name .bashrc > list 2>&1
+```
+
+# 八、管道指令
+
+管道是将一个命令的标准输出作为另一个命令的标准输入，在数据需要经过多个步骤的处理之后才能得到我们想要的内容时就可以使用管道。
+
+在命令之间使用 | 分隔各个管道命令。
+
+```bash
+$ ls -al /etc | less
+```
+
+## 提取指令
+
+cut 对数据进行切分，取出想要的部分。
+
+切分过程一行一行地进行。
+
+```html
+$ cut
+-d ：分隔符
+-f ：经过 -d 分隔后，使用 -f n 取出第 n 个区间
+-c ：以字符为单位取出区间
+```
+
+示例 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 | cut -d ' ' -f 1
+```
+
+示例 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 | cut -c 12-
+```
+
+## 排序指令
+
+**sort** 用于排序。
+
+```html
+$ sort [-fbMnrtuk] [file or stdin]
+-f ：忽略大小写
+-b ：忽略最前面的空格
+-M ：以月份的名字来排序，例如 JAN，DEC
+-n ：使用数字
+-r ：反向排序
+-u ：相当于 unique，重复的内容只出现一次
+-t ：分隔符，默认为 tab
+-k ：指定排序的区间
+```
+
+示例：/etc/passwd 文件内容以 : 来分隔，要求以第三列进行排序。
+
+```html
+$ 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** 可以将重复的数据只取一个。
+
+```html
+$ uniq [-ic]
+-i ：忽略大小写
+-c ：进行计数
+```
+
+示例：取得每个人的登录总次数
+
+```html
+$ last | cut -d ' ' -f 1 | sort | uniq -c
+1
+6 (unknown
+47 dmtsai
+4 reboot
+7 root
+1 wtmp
+```
+
+## 双向输出重定向
+
+输出重定向会将输出内容重定向到文件中，而 **tee** 不仅能够完成这个功能，还能保留屏幕上的输出。也就是说，使用 tee 指令，一个输出会同时传送到文件和屏幕上。
+
+```html
+$ tee [-a] file
+```
+
+## 字符转换指令
+
+**tr** 用来删除一行中的字符，或者对字符进行替换。
+
+```html
+$ tr [-ds] SET1 ...
+-d ： 删除行中 SET1 这个字符串
+```
+
+示例，将 last 输出的信息所有小写转换为大写。
+
+```html
+$ last | tr '[a-z]' '[A-Z]'
+```
+
+ **col** 将 tab 字符转为空格字符。
+
+```html
+$ col [-xb]
+-x ： 将 tab 键转换成对等的空格键
+```
+
+**expand** 将 tab 转换一定数量的空格，默认是 8 个。
+
+```html
+$ expand [-t] file
+-t ：tab 转为空格的数量
+```
+
+**join** 将有相同数据的那一行合并在一起。
+
+```html
+$ join [-ti12] file1 file2
+-t ：分隔符，默认为空格
+-i ：忽略大小写的差异
+-1 ：第一个文件所用的比较字段
+-2 ：第二个文件所用的比较字段
+```
+
+**paste** 直接将两行粘贴在一起。
+
+```html
+$ paste [-d] file1 file2
+-d ：分隔符，默认为 tab
+```
+
+## 分区指令
+
+**split** 将一个文件划分成多个文件。
+
+```html
+$ split [-bl] file PREFIX
+-b ：以大小来进行分区，可加单位，例如 b, k, m 等
+-l ：以行数来进行分区。
+- PREFIX ：分区文件的前导名称
+```
+
+# 九、正则表达式
+
+## grep
+
+g/re/p（globally search a regular expression and print)，使用正则表示式进行全局查找并打印。
+
+```html
+$ grep [-acinv] [--color=auto] 搜寻字符串 filename
+-c ： 统计个数
+-i ： 忽略大小写
+-n ： 输出行号
+-v ： 反向选择，也就是显示出没有 搜寻字符串 内容的那一行
+--color=auto ：找到的关键字加颜色显示
+```
+
+示例：把含有 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
+```
+
+因为 { 和 } 在 shell 是有特殊意义的，因此必须要使用转义字符进行转义。
+
+```html
+$ grep -n 'go\{2,5\}g' regular_express.txt
+```
+
+## 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
+```
+
+## awk
+
+是由 Alfred Aho，Peter Weinberger, 和 Brian Kernighan 创造，awk 这个名字就是这三个创始人名字的首字母。
+
+awk 每次处理一行，处理的最小单位是字段，每个字段的命名方式为：\$n，n 为字段号，从 1 开始，\$0 表示一整行。
+
+示例：取出最近五个登录用户的用户名和 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)
+```
+
+```html
+$ last -n 5 | awk '{print $1 "\t" $3}'
+```
+
+可以根据字段的某些条件进行匹配，例如匹配字段小于某个值的那一行数据。
+
+```html
+$ awk '条件类型 1 {动作 1} 条件类型 2 {动作 2} ...' filename
+```
+
+示例：/etc/passwd 文件第三个字段为 UID，对 UID 小于 10 的数据进行处理。
+
+```text
+$ cat /etc/passwd | awk 'BEGIN {FS=":"} $3 < 10 {print $1 "\t " $3}'
+root 0
+bin 1
+daemon 2
+```
+
+awk 变量：
+
+| 变量名称 | 代表意义 |
+| :--: | -- |
+| 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
+```
+
+# 十、进程管理
+
+## 查看进程
+
+### 1. ps
+
+查看某个时间点的进程信息
+
+示例一：查看自己的进程
+
+```sh
+# ps -l
+```
+
+示例二：查看系统所有进程
+
+```sh
+# ps aux
+```
+
+示例三：查看特定的进程
+
+```sh
+# ps aux | grep threadx
+```
+
+### 2. pstree
+
+查看进程树
+
+示例：查看所有进程树
+
+```sh
+# pstree -A
+```
+
+### 3. top
+
+实时显示进程信息
+
+示例：两秒钟刷新一次
+
+```sh
+# top -d 2
+```
+
+### 4. netstat
+
+查看占用端口的进程
+
+示例：查看特定端口的进程
+
+```sh
+# 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) |
+
+
+
+## SIGCHLD
+
+当一个子进程改变了它的状态时（停止运行，继续运行或者退出），有两件事会发生在父进程中：
+
+- 得到 SIGCHLD 信号；
+- waitpid() 或者 wait() 调用会返回。
+
+其中子进程发送的 SIGCHLD 信号包含了子进程的信息，比如进程 ID、进程状态、进程使用 CPU 的时间等。
+
+在子进程退出时，它的进程描述符不会立即释放，这是为了让父进程得到子进程信息，父进程通过 wait() 和 waitpid() 来获得一个已经退出的子进程的信息。
+
+
+
+## wait()
+
+```c
+pid_t wait(int *status)
+```
+
+父进程调用 wait() 会一直阻塞，直到收到一个子进程退出的 SIGCHLD 信号，之后 wait() 函数会销毁子进程并返回。
+
+如果成功，返回被收集的子进程的进程 ID；如果调用进程没有子进程，调用就会失败，此时返回 -1，同时 errno 被置为 ECHILD。
+
+参数 status 用来保存被收集的子进程退出时的一些状态，如果对这个子进程是如何死掉的毫不在意，只想把这个子进程消灭掉，可以设置这个参数为 NULL。
+
+## waitpid()
+
+```c
+pid_t waitpid(pid_t pid, int *status, int options)
+```
+
+作用和 wait() 完全相同，但是多了两个可由用户控制的参数 pid 和 options。
+
+pid 参数指示一个子进程的 ID，表示只关心这个子进程退出的 SIGCHLD 信号。如果 pid=-1 时，那么和 wait() 作用相同，都是关心所有子进程退出的 SIGCHLD 信号。
+
+options 参数主要有 WNOHANG 和 WUNTRACED 两个选项，WNOHANG 可以使 waitpid() 调用变成非阻塞的，也就是说它会立即返回，父进程可以继续执行其它任务。
+
+## 孤儿进程
+
+一个父进程退出，而它的一个或多个子进程还在运行，那么这些子进程将成为孤儿进程。
+
+孤儿进程将被 init 进程（进程号为 1）所收养，并由 init 进程对它们完成状态收集工作。
+
+由于孤儿进程会被 init 进程收养，所以孤儿进程不会对系统造成危害。
+
+## 僵尸进程
+
+一个子进程的进程描述符在子进程退出时不会释放，只有当父进程通过 wait() 或 waitpid() 获取了子进程信息后才会释放。如果子进程退出，而父进程并没有调用 wait() 或 waitpid()，那么子进程的进程描述符仍然保存在系统中，这种进程称之为僵尸进程。
+
+僵尸进程通过 ps 命令显示出来的状态为 Z（zombie）。
+
+系统所能使用的进程号是有限的，如果产生大量僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程。
+
+要消灭系统中大量的僵尸进程，只需要将其父进程杀死，此时僵尸进程就会变成孤儿进程，从而被 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)
+
+
+
+
+🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/notes/MySQL.md b/notes/MySQL.md
new file mode 100644
index 00000000..b920b64b
--- /dev/null
+++ b/notes/MySQL.md
@@ -0,0 +1,429 @@
+
+* [一、索引](#一索引)
+ * [B+ Tree 原理](#b-tree-原理)
+ * [MySQL 索引](#mysql-索引)
+ * [索引优化](#索引优化)
+ * [索引的优点](#索引的优点)
+ * [索引的使用条件](#索引的使用条件)
+* [二、查询性能优化](#二查询性能优化)
+ * [使用 Explain 进行分析](#使用-explain-进行分析)
+ * [优化数据访问](#优化数据访问)
+ * [重构查询方式](#重构查询方式)
+* [三、存储引擎](#三存储引擎)
+ * [InnoDB](#innodb)
+ * [MyISAM](#myisam)
+ * [比较](#比较)
+* [四、数据类型](#四数据类型)
+ * [整型](#整型)
+ * [浮点数](#浮点数)
+ * [字符串](#字符串)
+ * [时间和日期](#时间和日期)
+* [五、切分](#五切分)
+ * [水平切分](#水平切分)
+ * [垂直切分](#垂直切分)
+ * [Sharding 策略](#sharding-策略)
+ * [Sharding 存在的问题](#sharding-存在的问题)
+* [六、复制](#六复制)
+ * [主从复制](#主从复制)
+ * [读写分离](#读写分离)
+* [参考资料](#参考资料)
+
+
+
+# 一、索引
+
+## B+ Tree 原理
+
+### 1. 数据结构
+
+B Tree 指的是 Balance Tree，也就是平衡树。平衡树是一颗查找树，并且所有叶子节点位于同一层。
+
+B+ Tree 是基于 B Tree 和叶子节点顺序访问指针进行实现，它具有 B Tree 的平衡性，并且通过顺序访问指针来提高区间查询的性能。
+
+在 B+ Tree 中，一个节点中的 key 从左到右非递减排列，如果某个指针的左右相邻 key 分别是 keyi 和 keyi+1，且不为 null，则该指针指向节点的所有 key 大于等于 keyi 且小于等于 keyi+1。
+
+
+
+### 2. 操作
+
+进行查找操作时，首先在根节点进行二分查找，找到一个 key 所在的指针，然后递归地在指针所指向的节点进行查找。直到查找到叶子节点，然后在叶子节点上进行二分查找，找出 key 所对应的 data。
+
+插入删除操作会破坏平衡树的平衡性，因此在插入删除操作之后，需要对树进行一个分裂、合并、旋转等操作来维护平衡性。
+
+### 3. 与红黑树的比较
+
+红黑树等平衡树也可以用来实现索引，但是文件系统及数据库系统普遍采用 B+ Tree 作为索引结构，主要有以下两个原因：
+
+（一）更少的查找次数
+
+平衡树查找操作的时间复杂度和树高 h 相关，O(h)=O(logdN)，其中 d 为每个节点的出度。
+
+红黑树的出度为 2，而 B+ Tree 的出度一般都非常大，所以红黑树的树高 h 很明显比 B+ Tree 大非常多，查找的次数也就更多。
+
+（二）利用磁盘预读特性
+
+为了减少磁盘 I/O 操作，磁盘往往不是严格按需读取，而是每次都会预读。预读过程中，磁盘进行顺序读取，顺序读取不需要进行磁盘寻道，并且只需要很短的旋转时间，速度会非常快。
+
+操作系统一般将内存和磁盘分割成固定大小的块，每一块称为一页，内存与磁盘以页为单位交换数据。数据库系统将索引的一个节点的大小设置为页的大小，使得一次 I/O 就能完全载入一个节点。并且可以利用预读特性，相邻的节点也能够被预先载入。
+
+## MySQL 索引
+
+索引是在存储引擎层实现的，而不是在服务器层实现的，所以不同存储引擎具有不同的索引类型和实现。
+
+### 1. B+Tree 索引
+
+是大多数 MySQL 存储引擎的默认索引类型。
+
+因为不再需要进行全表扫描，只需要对树进行搜索即可，所以查找速度快很多。
+
+除了用于查找，还可以用于排序和分组。
+
+可以指定多个列作为索引列，多个索引列共同组成键。
+
+适用于全键值、键值范围和键前缀查找，其中键前缀查找只适用于最左前缀查找。如果不是按照索引列的顺序进行查找，则无法使用索引。
+
+InnoDB 的 B+Tree 索引分为主索引和辅助索引。主索引的叶子节点 data 域记录着完整的数据记录，这种索引方式被称为聚簇索引。因为无法把数据行存放在两个不同的地方，所以一个表只能有一个聚簇索引。
+
+
+
+辅助索引的叶子节点的 data 域记录着主键的值，因此在使用辅助索引进行查找时，需要先查找到主键值，然后再到主索引中进行查找。
+
+
+
+### 2. 哈希索引
+
+哈希索引能以 O(1) 时间进行查找，但是失去了有序性：
+
+- 无法用于排序与分组；
+- 只支持精确查找，无法用于部分查找和范围查找。
+
+InnoDB 存储引擎有一个特殊的功能叫“自适应哈希索引”，当某个索引值被使用的非常频繁时，会在 B+Tree 索引之上再创建一个哈希索引，这样就让 B+Tree 索引具有哈希索引的一些优点，比如快速的哈希查找。
+
+### 3. 全文索引
+
+MyISAM 存储引擎支持全文索引，用于查找文本中的关键词，而不是直接比较是否相等。
+
+查找条件使用 MATCH AGAINST，而不是普通的 WHERE。
+
+全文索引使用倒排索引实现，它记录着关键词到其所在文档的映射。
+
+InnoDB 存储引擎在 MySQL 5.6.4 版本中也开始支持全文索引。
+
+### 4. 空间数据索引
+
+MyISAM 存储引擎支持空间数据索引（R-Tree），可以用于地理数据存储。空间数据索引会从所有维度来索引数据，可以有效地使用任意维度来进行组合查询。
+
+必须使用 GIS 相关的函数来维护数据。
+
+## 索引优化
+
+### 1. 独立的列
+
+在进行查询时，索引列不能是表达式的一部分，也不能是函数的参数，否则无法使用索引。
+
+例如下面的查询不能使用 actor_id 列的索引：
+
+```sql
+SELECT actor_id FROM sakila.actor WHERE actor_id + 1 = 5;
+```
+
+### 2. 多列索引
+
+在需要使用多个列作为条件进行查询时，使用多列索引比使用多个单列索引性能更好。例如下面的语句中，最好把 actor_id 和 film_id 设置为多列索引。
+
+```sql
+SELECT film_id, actor_ id FROM sakila.film_actor
+WHERE actor_id = 1 AND film_id = 1;
+```
+
+### 3. 索引列的顺序
+
+让选择性最强的索引列放在前面。
+
+索引的选择性是指：不重复的索引值和记录总数的比值。最大值为 1，此时每个记录都有唯一的索引与其对应。选择性越高，查询效率也越高。
+
+例如下面显示的结果中 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,
+COUNT(*)
+FROM payment;
+```
+
+```html
+ staff_id_selectivity: 0.0001
+customer_id_selectivity: 0.0373
+ COUNT(*): 16049
+```
+
+### 4. 前缀索引
+
+对于 BLOB、TEXT 和 VARCHAR 类型的列，必须使用前缀索引，只索引开始的部分字符。
+
+对于前缀长度的选取需要根据索引选择性来确定。
+
+### 5. 覆盖索引
+
+索引包含所有需要查询的字段的值。
+
+具有以下优点：
+
+- 索引通常远小于数据行的大小，只读取索引能大大减少数据访问量。
+- 一些存储引擎（例如 MyISAM）在内存中只缓存索引，而数据依赖于操作系统来缓存。因此，只访问索引可以不使用系统调用（通常比较费时）。
+- 对于 InnoDB 引擎，若辅助索引能够覆盖查询，则无需访问主索引。
+
+## 索引的优点
+
+- 大大减少了服务器需要扫描的数据行数。
+
+- 帮助服务器避免进行排序和分组，以及避免创建临时表（B+Tree 索引是有序的，可以用于 ORDER BY 和 GROUP BY 操作。临时表主要是在排序和分组过程中创建，因为不需要排序和分组，也就不需要创建临时表）。
+
+- 将随机 I/O 变为顺序 I/O（B+Tree 索引是有序的，会将相邻的数据都存储在一起）。
+
+## 索引的使用条件
+
+- 对于非常小的表、大部分情况下简单的全表扫描比建立索引更高效；
+
+- 对于中到大型的表，索引就非常有效；
+
+- 但是对于特大型的表，建立和维护索引的代价将会随之增长。这种情况下，需要用到一种技术可以直接区分出需要查询的一组数据，而不是一条记录一条记录地匹配，例如可以使用分区技术。
+
+# 二、查询性能优化
+
+## 使用 Explain 进行分析
+
+Explain 用来分析 SELECT 查询语句，开发人员可以通过分析 Explain 结果来优化查询语句。
+
+比较重要的字段有：
+
+- select_type : 查询类型，有简单查询、联合查询、子查询等
+- key : 使用的索引
+- rows : 扫描的行数
+
+## 优化数据访问
+
+### 1. 减少请求的数据量
+
+- 只返回必要的列：最好不要使用 SELECT * 语句。
+- 只返回必要的行：使用 LIMIT 语句来限制返回的数据。
+- 缓存重复查询的数据：使用缓存可以避免在数据库中进行查询，特别在要查询的数据经常被重复查询时，缓存带来的查询性能提升将会是非常明显的。
+
+### 2. 减少服务器端扫描的行数
+
+最有效的方式是使用索引来覆盖查询。
+
+## 重构查询方式
+
+### 1. 切分大查询
+
+一个大查询如果一次性执行的话，可能一次锁住很多数据、占满整个事务日志、耗尽系统资源、阻塞很多小的但重要的查询。
+
+```sql
+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
+```
+
+### 2. 分解大连接查询
+
+将一个大连接查询分解成对每一个表进行一次单表查询，然后在应用程序中进行关联，这样做的好处有：
+
+- 让缓存更高效。对于连接查询，如果其中一个表发生变化，那么整个查询缓存就无法使用。而分解后的多个查询，即使其中一个表发生变化，对其它表的查询缓存依然可以使用。
+- 分解成多个单表查询，这些单表查询的缓存结果更可能被其它查询使用到，从而减少冗余记录的查询。
+- 减少锁竞争；
+- 在应用层进行连接，可以更容易对数据库进行拆分，从而更容易做到高性能和可伸缩。
+- 查询本身效率也可能会有所提升。例如下面的例子中，使用 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';
+```
+
+```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);
+```
+
+# 三、存储引擎
+
+## InnoDB
+
+是 MySQL 默认的事务型存储引擎，只有在需要它不支持的特性时，才考虑使用其它存储引擎。
+
+实现了四个标准的隔离级别，默认级别是可重复读（REPEATABLE READ）。在可重复读隔离级别下，通过多版本并发控制（MVCC）+ 间隙锁（Next-Key Locking）防止幻影读。
+
+主索引是聚簇索引，在索引中保存了数据，从而避免直接读取磁盘，因此对查询性能有很大的提升。
+
+内部做了很多优化，包括从磁盘读取数据时采用的可预测性读、能够加快读操作并且自动创建的自适应哈希索引、能够加速插入操作的插入缓冲区等。
+
+支持真正的在线热备份。其它存储引擎不支持在线热备份，要获取一致性视图需要停止对所有表的写入，而在读写混合场景中，停止写入可能也意味着停止读取。
+
+## MyISAM
+
+设计简单，数据以紧密格式存储。对于只读数据，或者表比较小、可以容忍修复操作，则依然可以使用它。
+
+提供了大量的特性，包括压缩表、空间数据索引等。
+
+不支持事务。
+
+不支持行级锁，只能对整张表加锁，读取时会对需要读到的所有表加共享锁，写入时则对表加排它锁。但在表有读取操作的同时，也可以往表中插入新的记录，这被称为并发插入（CONCURRENT INSERT）。
+
+可以手工或者自动执行检查和修复操作，但是和事务恢复以及崩溃恢复不同，可能导致一些数据丢失，而且修复操作是非常慢的。
+
+如果指定了 DELAY_KEY_WRITE 选项，在每次修改执行完成时，不会立即将修改的索引数据写入磁盘，而是会写到内存中的键缓冲区，只有在清理键缓冲区或者关闭表的时候才会将对应的索引块写入磁盘。这种方式可以极大的提升写入性能，但是在数据库或者主机崩溃时会造成索引损坏，需要执行修复操作。
+
+## 比较
+
+- 事务：InnoDB 是事务型的，可以使用 Commit 和 Rollback 语句。
+
+- 并发：MyISAM 只支持表级锁，而 InnoDB 还支持行级锁。
+
+- 外键：InnoDB 支持外键。
+
+- 备份：InnoDB 支持在线热备份。
+
+- 崩溃恢复：MyISAM 崩溃后发生损坏的概率比 InnoDB 高很多，而且恢复的速度也更慢。
+
+- 其它特性：MyISAM 支持压缩表和空间数据索引。
+
+# 四、数据类型
+
+## 整型
+
+TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分别使用 8, 16, 24, 32, 64 位存储空间，一般情况下越小的列越好。
+
+INT(11) 中的数字只是规定了交互工具显示字符的个数，对于存储和计算来说是没有意义的。
+
+## 浮点数
+
+FLOAT 和 DOUBLE 为浮点类型，DECIMAL 为高精度小数类型。CPU 原生支持浮点运算，但是不支持 DECIMAl 类型的计算，因此 DECIMAL 的计算比浮点类型需要更高的代价。
+
+FLOAT、DOUBLE 和 DECIMAL 都可以指定列宽，例如 DECIMAL(18, 9) 表示总共 18 位，取 9 位存储小数部分，剩下 9 位存储整数部分。
+
+## 字符串
+
+主要有 CHAR 和 VARCHAR 两种类型，一种是定长的，一种是变长的。
+
+VARCHAR 这种变长类型能够节省空间，因为只需要存储必要的内容。但是在执行 UPDATE 时可能会使行变得比原来长，当超出一个页所能容纳的大小时，就要执行额外的操作。MyISAM 会将行拆成不同的片段存储，而 InnoDB 则需要分裂页来使行放进页内。
+
+在进行存储和检索时，会保留 VARCHAR 末尾的空格，而会删除 CHAR 末尾的空格。
+
+## 时间和日期
+
+MySQL 提供了两种相似的日期时间类型：DATETIME 和 TIMESTAMP。
+
+### 1. DATETIME
+
+能够保存从 1001 年到 9999 年的日期和时间，精度为秒，使用 8 字节的存储空间。
+
+它与时区无关。
+
+默认情况下，MySQL 以一种可排序的、无歧义的格式显示 DATETIME 值，例如“2008-01-16 22:37:08”，这是 ANSI 标准定义的日期和时间表示方法。
+
+### 2. TIMESTAMP
+
+和 UNIX 时间戳相同，保存从 1970 年 1 月 1 日午夜（格林威治时间）以来的秒数，使用 4 个字节，只能表示从 1970 年到 2038 年。
+
+它和时区有关，也就是说一个时间戳在不同的时区所代表的具体时间是不同的。
+
+MySQL 提供了 FROM_UNIXTIME() 函数把 UNIX 时间戳转换为日期，并提供了 UNIX_TIMESTAMP() 函数把日期转换为 UNIX 时间戳。
+
+默认情况下，如果插入时没有指定 TIMESTAMP 列的值，会将这个值设置为当前时间。
+
+应该尽量使用 TIMESTAMP，因为它比 DATETIME 空间效率更高。
+
+# 五、切分
+
+## 水平切分
+
+水平切分又称为 Sharding，它是将同一个表中的记录拆分到多个结构相同的表中。
+
+当一个表的数据不断增多时，Sharding 是必然的选择，它可以将数据分布到集群的不同节点上，从而缓存单个数据库的压力。
+
+
+
+## 垂直切分
+
+垂直切分是将一张表按列切分成多个表，通常是按照列的关系密集程度进行切分，也可以利用垂直切分将经常被使用的列和不经常被使用的列切分到不同的表中。
+
+在数据库的层面使用垂直切分将按数据库中表的密集程度部署到不同的库中，例如将原来的电商数据库垂直切分成商品数据库、用户数据库等。
+
+
+
+## Sharding 策略
+
+- 哈希取模：hash(key) % N；
+- 范围：可以是 ID 范围也可以是时间范围；
+- 映射表：使用单独的一个数据库来存储映射关系。
+
+## Sharding 存在的问题
+
+### 1. 事务问题
+
+使用分布式事务来解决，比如 XA 接口。
+
+### 2. 连接
+
+可以将原来的连接分解成多个单表查询，然后在用户程序中进行连接。
+
+### 3. ID 唯一性
+
+- 使用全局唯一 ID（GUID）
+- 为每个分片指定一个 ID 范围
+- 分布式 ID 生成器 (如 Twitter 的 Snowflake 算法)
+
+# 六、复制
+
+## 主从复制
+
+主要涉及三个线程：binlog 线程、I/O 线程和 SQL 线程。
+
+- **binlog 线程** ：负责将主服务器上的数据更改写入二进制日志（Binary log）中。
+- **I/O 线程** ：负责从主服务器上读取二进制日志，并写入从服务器的中继日志（Relay log）。
+- **SQL 线程** ：负责读取中继日志，解析出主服务器已经执行的数据更改并在从服务器中执行。
+
+
+
+## 读写分离
+
+主服务器处理写操作以及实时性要求比较高的读操作，而从服务器处理读操作。
+
+读写分离能提高性能的原因在于：
+
+- 主从服务器负责各自的读和写，极大程度缓解了锁的争用；
+- 从服务器可以使用 MyISAM，提升查询性能以及节约系统开销；
+- 增加冗余，提高可用性。
+
+读写分离常用代理方式来实现，代理服务器接收应用层传来的读写请求，然后决定转发到哪个服务器。
+
+
+
+# 参考资料
+
+- 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)
+
+
+
+
+🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/notes/Redis.md b/notes/Redis.md
new file mode 100644
index 00000000..452d217c
--- /dev/null
+++ b/notes/Redis.md
@@ -0,0 +1,614 @@
+
+* [一、概述](#一概述)
+* [二、数据类型](#二数据类型)
+ * [STRING](#string)
+ * [LIST](#list)
+ * [SET](#set)
+ * [HASH](#hash)
+ * [ZSET](#zset)
+* [三、数据结构](#三数据结构)
+ * [字典](#字典)
+ * [跳跃表](#跳跃表)
+* [四、使用场景](#四使用场景)
+ * [计数器](#计数器)
+ * [缓存](#缓存)
+ * [查找表](#查找表)
+ * [消息队列](#消息队列)
+ * [会话缓存](#会话缓存)
+ * [分布式锁实现](#分布式锁实现)
+ * [其它](#其它)
+* [五、Redis 与 Memcached](#五redis-与-memcached)
+ * [数据类型](#数据类型)
+ * [数据持久化](#数据持久化)
+ * [分布式](#分布式)
+ * [内存管理机制](#内存管理机制)
+* [六、键的过期时间](#六键的过期时间)
+* [七、数据淘汰策略](#七数据淘汰策略)
+* [八、持久化](#八持久化)
+ * [RDB 持久化](#rdb-持久化)
+ * [AOF 持久化](#aof-持久化)
+* [九、事务](#九事务)
+* [十、事件](#十事件)
+ * [文件事件](#文件事件)
+ * [时间事件](#时间事件)
+ * [事件的调度与执行](#事件的调度与执行)
+* [十一、复制](#十一复制)
+ * [连接过程](#连接过程)
+ * [主从链](#主从链)
+* [十二、Sentinel](#十二sentinel)
+* [十三、分片](#十三分片)
+* [十四、一个简单的论坛系统分析](#十四一个简单的论坛系统分析)
+ * [文章信息](#文章信息)
+ * [点赞功能](#点赞功能)
+ * [对文章进行排序](#对文章进行排序)
+* [参考资料](#参考资料)
+
+
+
+# 一、概述
+
+Redis 是速度非常快的非关系型（NoSQL）内存键值数据库，可以存储键和五种不同类型的值之间的映射。
+
+键的类型只能为字符串，值支持五种数据类型：字符串、列表、集合、散列表、有序集合。
+
+Redis 支持很多特性，例如将内存中的数据持久化到硬盘中，使用复制来扩展读性能，使用分片来扩展写性能。
+
+# 二、数据类型
+
+| 数据类型 | 可以存储的值 | 操作 |
+| :--: | :--: | :--: |
+| STRING | 字符串、整数或者浮点数 | 对整个字符串或者字符串的其中一部分执行操作 对整数和浮点数执行自增或者自减操作 |
+| LIST | 列表 | 从两端压入或者弹出元素 对单个或者多个元素 进行修剪，只保留一个范围内的元素 |
+| SET | 无序集合 | 添加、获取、移除单个元素 检查一个元素是否存在于集合中 计算交集、并集、差集 从集合里面随机获取元素 |
+| HASH | 包含键值对的无序散列表 | 添加、获取、移除单个键值对 获取所有键值对 检查某个键是否存在|
+| ZSET | 有序集合 | 添加、获取、删除元素 根据分值范围或者成员来获取元素 计算一个键的排名 |
+
+> [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
+
+
+
+```html
+> set hello world
+OK
+> get hello
+"world"
+> del hello
+(integer) 1
+> get hello
+(nil)
+```
+
+## LIST
+
+
+
+```html
+> 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"
+
+> lindex list-key 1
+"item2"
+
+> lpop list-key
+"item"
+
+> lrange list-key 0 -1
+1) "item2"
+2) "item"
+```
+
+## SET
+
+
+
+```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
+
+> smembers set-key
+1) "item"
+2) "item2"
+3) "item3"
+
+> sismember set-key item4
+(integer) 0
+> sismember set-key item
+(integer) 1
+
+> srem set-key item2
+(integer) 1
+> srem set-key item2
+(integer) 0
+
+> smembers set-key
+1) "item"
+2) "item3"
+```
+
+## HASH
+
+
+
+```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
+
+> 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
+
+> hget hash-key sub-key1
+"value1"
+
+> hgetall hash-key
+1) "sub-key1"
+2) "value1"
+```
+
+## ZSET
+
+
+
+```html
+> 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"
+
+> zrangebyscore zset-key 0 800 withscores
+1) "member1"
+2) "728"
+
+> zrem zset-key member1
+(integer) 1
+> zrem zset-key member1
+(integer) 0
+
+> zrange zset-key 0 -1 withscores
+1) "member0"
+2) "982"
+```
+
+# 三、数据结构
+
+## 字典
+
+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;
+```
+
+```c
+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 的角色。
+
+```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;
+```
+
+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 期间，每次对字典执行添加、删除、查找或者更新操作时，都会执行一次渐进式 rehash。
+
+采用渐进式 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;
+
+ 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;
+
+ 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;
+ }
+
+ /* More to rehash... */
+ return 1;
+}
+```
+
+## 跳跃表
+
+是有序集合的底层实现之一。
+
+跳跃表是基于多指针有序链表实现的，可以看成多个有序链表。
+
+
+
+在查找时，从上层指针开始查找，找到对应的区间之后再到下一层去查找。下图演示了查找 22 的过程。
+
+
+
+与红黑树等平衡树相比，跳跃表具有以下优点：
+
+- 插入速度非常快速，因为不需要进行旋转等操作来维护平衡性；
+- 更容易实现；
+- 支持无锁操作。
+
+# 四、使用场景
+
+## 计数器
+
+可以对 String 进行自增自减运算，从而实现计数器功能。
+
+Redis 这种内存型数据库的读写性能非常高，很适合存储频繁读写的计数量。
+
+## 缓存
+
+将热点数据放到内存中，设置内存的最大使用量以及淘汰策略来保证缓存的命中率。
+
+## 查找表
+
+例如 DNS 记录就很适合使用 Redis 进行存储。
+
+查找表和缓存类似，也是利用了 Redis 快速的查找特性。但是查找表的内容不能失效，而缓存的内容可以失效，因为缓存不作为可靠的数据来源。
+
+## 消息队列
+
+List 是一个双向链表，可以通过 lpush 和 rpop 写入和读取消息
+
+不过最好使用 Kafka、RabbitMQ 等消息中间件。
+
+## 会话缓存
+
+可以使用 Redis 来统一存储多台应用服务器的会话信息。
+
+当应用服务器不再存储用户的会话信息，也就不再具有状态，一个用户可以请求任意一个应用服务器，从而更容易实现高可用性以及可伸缩性。
+
+## 分布式锁实现
+
+在分布式场景下，无法使用单机环境下的锁来对多个节点上的进程进行同步。
+
+可以使用 Redis 自带的 SETNX 命令实现分布式锁，除此之外，还可以使用官方提供的 RedLock 分布式锁实现。
+
+## 其它
+
+Set 可以实现交集、并集等操作，从而实现共同好友等功能。
+
+ZSet 可以实现有序性操作，从而实现排行榜等功能。
+
+# 五、Redis 与 Memcached
+
+两者都是非关系型内存键值数据库，主要有以下不同：
+
+## 数据类型
+
+Memcached 仅支持字符串类型，而 Redis 支持五种不同的数据类型，可以更灵活地解决问题。
+
+## 数据持久化
+
+Redis 支持两种持久化策略：RDB 快照和 AOF 日志，而 Memcached 不支持持久化。
+
+## 分布式
+
+Memcached 不支持分布式，只能通过在客户端使用一致性哈希来实现分布式存储，这种方式在存储和查询时都需要先在客户端计算一次数据所在的节点。
+
+Redis Cluster 实现了分布式的支持。
+
+## 内存管理机制
+
+- 在 Redis 中，并不是所有数据都一直存储在内存中，可以将一些很久没用的 value 交换到磁盘，而 Memcached 的数据则会一直在内存中。
+
+- Memcached 将内存分割成特定长度的块来存储数据，以完全解决内存碎片的问题。但是这种方式会使得内存的利用率不高，例如块的大小为 128 bytes，只存储 100 bytes 的数据，那么剩下的 28 bytes 就浪费掉了。
+
+# 六、键的过期时间
+
+Redis 可以为每个键设置过期时间，当键过期时，会自动删除该键。
+
+对于散列表这种容器，只能为整个键设置过期时间（整个散列表），而不能为键里面的单个元素设置过期时间。
+
+# 七、数据淘汰策略
+
+可以设置内存最大使用量，当内存使用量超出时，会施行数据淘汰策略。
+
+Redis 具体有 6 种淘汰策略：
+
+| 策略 | 描述 |
+| :--: | :--: |
+| volatile-lru | 从已设置过期时间的数据集中挑选最近最少使用的数据淘汰 |
+| volatile-ttl | 从已设置过期时间的数据集中挑选将要过期的数据淘汰 |
+|volatile-random | 从已设置过期时间的数据集中任意选择数据淘汰 |
+| allkeys-lru | 从所有数据集中挑选最近最少使用的数据淘汰 |
+| allkeys-random | 从所有数据集中任意选择数据进行淘汰 |
+| noeviction | 禁止驱逐数据 |
+
+作为内存数据库，出于对性能和内存消耗的考虑，Redis 的淘汰算法实际实现上并非针对所有 key，而是抽样一小部分并且从中选出被淘汰的 key。
+
+使用 Redis 缓存数据时，为了提高缓存命中率，需要保证缓存数据都是热点数据。可以将内存最大使用量设置为热点数据占用的内存量，然后启用 allkeys-lru 淘汰策略，将最近最少使用的数据淘汰。
+
+Redis 4.0 引入了 volatile-lfu 和 allkeys-lfu 淘汰策略，LFU 策略通过统计访问频率，将访问频率最少的键值对淘汰。
+
+# 八、持久化
+
+Redis 是内存型数据库，为了保证数据在断电后不会丢失，需要将内存中的数据持久化到硬盘上。
+
+## RDB 持久化
+
+将某个时间点的所有数据都存放到硬盘上。
+
+可以将快照复制到其它服务器从而创建具有相同数据的服务器副本。
+
+如果系统发生故障，将会丢失最后一次创建快照之后的数据。
+
+如果数据量很大，保存快照的时间会很长。
+
+## AOF 持久化
+
+将写命令添加到 AOF 文件（Append Only File）的末尾。
+
+使用 AOF 持久化需要设置同步选项，从而确保写命令什么时候会同步到磁盘文件上。这是因为对文件进行写入并不会马上将内容同步到磁盘上，而是先存储到缓冲区，然后由操作系统决定什么时候同步到磁盘。有以下同步选项：
+
+| 选项 | 同步频率 |
+| :--: | :--: |
+| always | 每个写命令都同步 |
+| everysec | 每秒同步一次 |
+| no | 让操作系统来决定何时同步 |
+
+- always 选项会严重减低服务器的性能；
+- everysec 选项比较合适，可以保证系统崩溃时只会丢失一秒左右的数据，并且 Redis 每秒执行一次同步对服务器性能几乎没有任何影响；
+- no 选项并不能给服务器性能带来多大的提升，而且也会增加系统崩溃时数据丢失的数量。
+
+随着服务器写请求的增多，AOF 文件会越来越大。Redis 提供了一种将 AOF 重写的特性，能够去除 AOF 文件中的冗余写命令。
+
+# 九、事务
+
+一个事务包含了多个命令，服务器在执行事务期间，不会改去执行其它客户端的命令请求。
+
+事务中的多个命令被一次性发送给服务器，而不是一条一条发送，这种方式被称为流水线，它可以减少客户端与服务器之间的网络通信次数从而提升性能。
+
+Redis 最简单的事务实现方式是使用 MULTI 和 EXEC 命令将事务操作包围起来。
+
+# 十、事件
+
+Redis 服务器是一个事件驱动程序。
+
+## 文件事件
+
+服务器通过套接字与客户端或者其它服务器进行通信，文件事件就是对套接字操作的抽象。
+
+Redis 基于 Reactor 模式开发了自己的网络事件处理器，使用 I/O 多路复用程序来同时监听多个套接字，并将到达的事件传送给文件事件分派器，分派器会根据套接字产生的事件类型调用相应的事件处理器。
+
+
+
+## 时间事件
+
+服务器有一些操作需要在给定的时间点执行，时间事件是对这类定时操作的抽象。
+
+时间事件又分为：
+
+- 定时事件：是让一段程序在指定的时间之内执行一次；
+- 周期性事件：是让一段程序每隔指定时间就执行一次。
+
+Redis 将所有时间事件都放在一个无序链表中，通过遍历整个链表查找出已到达的时间事件，并调用相应的事件处理器。
+
+## 事件的调度与执行
+
+服务器需要不断监听文件事件的套接字才能得到待处理的文件事件，但是不能一直监听，否则时间事件无法在规定的时间内执行，因此监听时间应该根据距离现在最近的时间事件来决定。
+
+事件调度与执行由 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()
+```
+
+将 aeProcessEvents 函数置于一个循环里面，加上初始化和清理函数，就构成了 Redis 服务器的主函数，伪代码如下：
+
+```python
+def main():
+ # 初始化服务器
+ init_server()
+ # 一直处理事件，直到服务器关闭为止
+ while server_is_not_shutdown():
+ aeProcessEvents()
+ # 服务器关闭，执行清理操作
+ clean_server()
+```
+
+从事件处理的角度来看，服务器运行流程如下：
+
+
+
+# 十一、复制
+
+通过使用 slaveof host port 命令来让一个服务器成为另一个服务器的从服务器。
+
+一个从服务器只能有一个主服务器，并且不支持主主复制。
+
+## 连接过程
+
+1. 主服务器创建快照文件，发送给从服务器，并在发送期间使用缓冲区记录执行的写命令。快照文件发送完毕之后，开始向从服务器发送存储在缓冲区中的写命令；
+
+2. 从服务器丢弃所有旧数据，载入主服务器发来的快照文件，之后从服务器开始接受主服务器发来的写命令；
+
+3. 主服务器每执行一次写命令，就向从服务器发送相同的写命令。
+
+## 主从链
+
+随着负载不断上升，主服务器可能无法很快地更新所有从服务器，或者重新连接和重新同步从服务器将导致系统超载。为了解决这个问题，可以创建一个中间层来分担主服务器的复制工作。中间层的服务器是最上层服务器的从服务器，又是最下层服务器的主服务器。
+
+
+
+# 十二、Sentinel
+
+Sentinel（哨兵）可以监听集群中的服务器，并在主服务器进入下线状态时，自动从从服务器中选举出新的主服务器。
+
+# 十三、分片
+
+分片是将数据划分为多个部分的方法，可以将数据存储到多台机器里面，这种方法在解决某些问题时可以获得线性级别的性能提升。
+
+假设有 4 个 Redis 实例 R0，R1，R2，R3，还有很多表示用户的键 user:1，user:2，... ，有不同的方式来选择一个指定的键存储在哪个实例中。
+
+- 最简单的方式是范围分片，例如用户 id 从 0\~1000 的存储到实例 R0 中，用户 id 从 1001\~2000 的存储到实例 R1 中，等等。但是这样需要维护一张映射范围表，维护操作代价很高。
+- 还有一种方式是哈希分片，使用 CRC32 哈希函数将键转换为一个数字，再对实例数量求模就能知道应该存储的实例。
+
+根据执行分片的位置，可以分为三种分片方式：
+
+- 客户端分片：客户端使用一致性哈希等算法决定键应当分布到哪个节点。
+- 代理分片：将客户端请求发送到代理上，由代理转发请求到正确的节点上。
+- 服务器分片：Redis Cluster。
+
+# 十四、一个简单的论坛系统分析
+
+该论坛系统功能如下：
+
+- 可以发布文章；
+- 可以对文章进行点赞；
+- 在首页可以按文章的发布时间或者文章的点赞数进行排序显示。
+
+## 文章信息
+
+文章包括标题、作者、赞数等信息，在关系型数据库中很容易构建一张表来存储这些信息，在 Redis 中可以使用 HASH 来存储每种信息以及其对应的值的映射。
+
+Redis 没有关系型数据库中的表这一概念来将同种类型的数据存放在一起，而是使用命名空间的方式来实现这一功能。键名的前面部分存储命名空间，后面部分的内容存储 ID，通常使用 : 来进行分隔。例如下面的 HASH 的键名为 article:92617，其中 article 为命名空间，ID 为 92617。
+
+
+
+## 点赞功能
+
+当有用户为一篇文章点赞时，除了要对该文章的 votes 字段进行加 1 操作，还必须记录该用户已经对该文章进行了点赞，防止用户点赞次数超过 1。可以建立文章的已投票用户集合来进行记录。
+
+为了节约内存，规定一篇文章发布满一周之后，就不能再对它进行投票，而文章的已投票集合也会被删除，可以为文章的已投票集合设置一个一周的过期时间就能实现这个规定。
+
+
+
+## 对文章进行排序
+
+为了按发布时间和点赞数进行排序，可以建立一个文章发布时间的有序集合和一个文章点赞数的有序集合。（下图中的 score 就是这里所说的点赞数；下面所示的有序集合分值并不直接是时间和点赞数，而是根据时间和点赞数间接计算出来的）
+
+
+
+# 参考资料
+
+- 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)
+
+
+
+
+🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/notes/Socket.md b/notes/Socket.md
new file mode 100644
index 00000000..a3ff120f
--- /dev/null
+++ b/notes/Socket.md
@@ -0,0 +1,329 @@
+
+* [一、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)
+ * [工作模式](#工作模式)
+ * [应用场景](#应用场景)
+* [参考资料](#参考资料)
+
+
+
+# 一、I/O 模型
+
+一个输入操作通常包括两个阶段：
+
+- 等待数据准备好
+- 从内核向进程复制数据
+
+对于一个套接字上的输入操作，第一步通常涉及等待数据从网络中到达。当所等待数据到达时，它被复制到内核中的某个缓冲区。第二步就是把数据从内核缓冲区复制到应用进程缓冲区。
+
+Unix 有五种 I/O 模型：
+
+- 阻塞式 I/O
+- 非阻塞式 I/O
+- I/O 复用（select 和 poll）
+- 信号驱动式 I/O（SIGIO）
+- 异步 I/O（AIO）
+
+## 阻塞式 I/O
+
+应用进程被阻塞，直到数据从内核缓冲区复制到应用进程缓冲区中才返回。
+
+应该注意到，在阻塞的过程中，其它应用进程还可以执行，因此阻塞不意味着整个操作系统都被阻塞。因为其它应用进程还可以执行，所以不消耗 CPU 时间，这种模型的 CPU 利用率效率会比较高。
+
+下图中，recvfrom() 用于接收 Socket 传来的数据，并复制到应用进程的缓冲区 buf 中。这里把 recvfrom() 当成系统调用。
+
+```c
+ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
+```
+
+
+
+## 非阻塞式 I/O
+
+应用进程执行系统调用之后，内核返回一个错误码。应用进程可以继续执行，但是需要不断的执行系统调用来获知 I/O 是否完成，这种方式称为轮询（polling）。
+
+由于 CPU 要处理更多的系统调用，因此这种模型的 CPU 利用率比较低。
+
+
+
+## I/O 复用
+
+使用 select 或者 poll 等待数据，并且可以等待多个套接字中的任何一个变为可读。这一过程会被阻塞，当某一个套接字可读时返回，之后再使用 recvfrom 把数据从内核复制到进程中。
+
+它可以让单个进程具有处理多个 I/O 事件的能力。又被称为 Event Driven I/O，即事件驱动 I/O。
+
+如果一个 Web 服务器没有 I/O 复用，那么每一个 Socket 连接都需要创建一个线程去处理。如果同时有几万个连接，那么就需要创建相同数量的线程。相比于多进程和多线程技术，I/O 复用不需要进程线程创建和切换的开销，系统开销更小。
+
+
+
+## 信号驱动 I/O
+
+应用进程使用 sigaction 系统调用，内核立即返回，应用进程可以继续执行，也就是说等待数据阶段应用进程是非阻塞的。内核在数据到达时向应用进程发送 SIGIO 信号，应用进程收到之后在信号处理程序中调用 recvfrom 将数据从内核复制到应用进程中。
+
+相比于非阻塞式 I/O 的轮询方式，信号驱动 I/O 的 CPU 利用率更高。
+
+
+
+## 异步 I/O
+
+应用进程执行 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 复用和信号驱动 I/O 都是同步 I/O，它们的主要区别在第一个阶段。
+
+非阻塞式 I/O 、信号驱动 I/O 和异步 I/O 在第一阶段不会阻塞。
+
+
+
+# 二、I/O 复用
+
+select/poll/epoll 都是 I/O 多路复用的具体实现，select 出现的最早，之后是 poll，再是 epoll。
+
+## select
+
+```c
+int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+```
+
+有三种类型的描述符类型：readset、writeset、exceptset，分别对应读、写、异常条件的描述符集合。fd_set 使用数组实现，数组大小使用 FD_SETSIZE 定义。
+
+timeout 为超时参数，调用 select 会一直阻塞直到有描述符的事件到达或者等待的时间超过 timeout。
+
+成功调用返回结果大于 0，出错返回结果为 -1，超时返回结果为 0。
+
+```c
+fd_set fd_in, fd_out;
+struct timeval tv;
+
+// Reset the sets
+FD_ZERO( &fd_in );
+FD_ZERO( &fd_out );
+
+// Monitor sock1 for input events
+FD_SET( sock1, &fd_in );
+
+// 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;
+
+// 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 );
+
+// 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( sock2, &fd_out ) )
+ // output event on sock2
+}
+```
+
+## poll
+
+```c
+int poll(struct pollfd *fds, unsigned int nfds, int timeout);
+```
+
+pollfd 使用链表实现。
+
+```c
+// The structure for two events
+struct pollfd fds[2];
+
+// Monitor sock1 for input
+fds[0].fd = sock1;
+fds[0].events = POLLIN;
+
+// 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
+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 ( fds[1].revents & POLLOUT )
+ fds[1].revents = 0;
+ // output event on sock2
+}
+```
+
+## 比较
+
+### 1. 功能
+
+select 和 poll 的功能基本相同，不过在一些实现细节上有所不同。
+
+- select 会修改描述符，而 poll 不会；
+- select 的描述符类型使用数组实现，FD_SETSIZE 大小默认为 1024，因此默认只能监听 1024 个描述符。如果要监听更多描述符的话，需要修改 FD_SETSIZE 之后重新编译；而 poll 的描述符类型使用链表实现，没有描述符数量的限制；
+- poll 提供了更多的事件类型，并且对描述符的重复利用上比 select 高。
+- 如果一个线程对某个描述符调用了 select 或者 poll，另一个线程关闭了该描述符，会导致调用结果不确定。
+
+### 2. 速度
+
+select 和 poll 速度都比较慢。
+
+- select 和 poll 每次调用都需要将全部描述符从应用进程缓冲区复制到内核缓冲区。
+- select 和 poll 的返回结果中没有声明哪些描述符已经准备好，所以如果返回值大于 0 时，应用进程都需要使用轮询的方式来找到 I/O 完成的描述符。
+
+### 3. 可移植性
+
+几乎所有的系统都支持 select，但是只有比较新的系统支持 poll。
+
+## 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);
+```
+
+epoll_ctl() 用于向内核注册新的描述符或者是改变某个文件描述符的状态。已注册的描述符在内核中会被维护在一棵红黑树上，通过回调函数内核会将 I/O 准备好的描述符加入到一个链表中管理，进程调用 epoll_wait() 便可以得到事件完成的描述符。
+
+从上面的描述可以看出，epoll 只需要将描述符从进程缓冲区向内核缓冲区拷贝一次，并且进程不需要通过轮询来获得事件完成的描述符。
+
+epoll 仅适用于 Linux OS。
+
+epoll 比 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 );
+
+if ( pollingfd < 0 )
+ // report error
+
+// 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;
+
+// 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 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();
+ }
+ }
+}
+```
+
+
+## 工作模式
+
+epoll 的描述符事件有两种触发模式：LT（level trigger）和 ET（edge trigger）。
+
+### 1. LT 模式
+
+当 epoll_wait() 检测到描述符事件到达时，将此事件通知进程，进程可以不立即处理该事件，下次调用 epoll_wait() 会再次通知进程。是默认的一种模式，并且同时支持 Blocking 和 No-Blocking。
+
+### 2. ET 模式
+
+和 LT 模式不同的是，通知之后进程必须立即处理事件，下次再调用 epoll_wait() 时不会再得到事件到达的通知。
+
+很大程度上减少了 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。只支持 No-Blocking，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。
+
+## 应用场景
+
+很容易产生一种错觉认为只要用 epoll 就可以了，select 和 poll 都已经过时了，其实它们都有各自的使用场景。
+
+### 1. select 应用场景
+
+select 的 timeout 参数精度为 1ns，而 poll 和 epoll 为 1ms，因此 select 更加适用于实时性要求比较高的场景，比如核反应堆的控制。
+
+select 可移植性更好，几乎被所有主流平台所支持。
+
+### 2. poll 应用场景
+
+poll 没有最大描述符数量的限制，如果平台支持并且对实时性要求不高，应该使用 poll 而不是 select。
+
+### 3. epoll 应用场景
+
+只需要运行在 Linux 平台上，有大量的描述符需要同时轮询，并且这些连接最好是长连接。
+
+需要同时监控小于 1000 个描述符，就没有必要使用 epoll，因为这个应用场景下并不能体现 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/)
+
+
+
+
+🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+ 
+
+- begin、end 表示访问空间的排除范围，即 end 不包含尾部。
+
+ 
+
+# 四、良好的代码风格
+
+适当的空行和缩进。
+
+排列整齐的注释：
+
+```java
+int a = 1; // 注释
+int b = 11; // 注释
+int c = 111; // 注释
+```
+
+语句顺序不能随意，比如与 html 表单相关联的变量的赋值应该和表单在 html 中的顺序一致。
+
+# 五、为何编写注释
+
+阅读代码首先会注意到注释，如果注释没太大作用，那么就会浪费代码阅读的时间。那些能直接看出含义的代码不需要写注释，特别是并不需要为每个方法都加上注释，比如那些简单的 getter 和 setter 方法，为这些方法写注释反而让代码可读性更差。
+
+不能因为有注释就随便起个名字，而是争取起个好名字而不写注释。
+
+可以用注释来记录采用当前解决办法的思考过程，从而让读者更容易理解代码。
+
+注释用来提醒一些特殊情况。
+
+用 TODO 等做标记：
+
+| 标记 | 用法 |
+|---|---|
+|TODO| 待做 |
+|FIXME| 待修复 |
+|HACK| 粗糙的解决方案 |
+|XXX| 危险！这里有重要的问题 |
+
+# 六、如何编写注释
+
+尽量简洁明了：
+
+```java
+// The first String is student's name
+// The Second Integer is student's score
+Map scoreMap = new HashMap<>();
+```
+
+```java
+// Student's name -> Student's score
+Map scoreMap = new HashMap<>();
+```
+
+添加测试用例来说明：
+
+```java
+// ...
+// Example: add(1, 2), return 3
+int add(int x, int y) {
+ return x + y;
+}
+```
+
+使用专业名词来缩短概念上的解释，比如用设计模式名来说明代码。
+
+# 七、提高控制流的可读性
+
+条件表达式中，左侧是变量，右侧是常数。比如下面第一个语句正确：
+
+```java
+if (len < 10)
+if (10 > len)
+```
+
+只有在逻辑简单的情况下使用 ? : 三目运算符来使代码更紧凑，否则应该拆分成 if / else；
+
+do / while 的条件放在后面，不够简单明了，并且会有一些迷惑的地方，最好使用 while 来代替。
+
+如果只有一个 goto 目标，那么 goto 尚且还能接受，但是过于复杂的 goto 会让代码可读性特别差，应该避免使用 goto。
+
+在嵌套的循环中，用一些 return 语句往往能减少嵌套的层数。
+
+# 八、拆分长表达式
+
+长表达式的可读性很差，可以引入一些解释变量从而拆分表达式：
+
+```python
+if line.split(':')[0].strip() == "root":
+ ...
+```
+```python
+username = line.split(':')[0].strip()
+if username == "root":
+ ...
+```
+
+使用摩根定理简化一些逻辑表达式：
+
+```java
+if (!a && !b) {
+ ...
+}
+```
+```java
+if (!(a || b)) {
+ ...
+}
+```
+
+# 九、变量与可读性
+
+**去除控制流变量** 。在循环中通过使用 break 或者 return 可以减少控制流变量的使用。
+
+```java
+boolean done = false;
+while (/* condition */ && !done) {
+ ...
+ if ( ... ) {
+ done = true;
+ continue;
+ }
+}
+```
+
+```java
+while(/* condition */) {
+ ...
+ if ( ... ) {
+ break;
+ }
+}
+```
+
+**减小变量作用域** 。作用域越小，越容易定位到变量所有使用的地方。
+
+JavaScript 可以用闭包减小作用域。以下代码中 submit_form 是函数变量，submitted 变量控制函数不会被提交两次。第一个实现中 submitted 是全局变量，第二个实现把 submitted 放到匿名函数中，从而限制了起作用域范围。
+
+```js
+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;
+ }
+}()); // () 使得外层匿名函数立即执行
+```
+
+JavaScript 中没有用 var 声明的变量都是全局变量，而全局变量很容易造成迷惑，因此应当总是用 var 来声明变量。
+
+变量定义的位置应当离它使用的位置最近。
+
+**实例解析**
+
+在一个网页中有以下文本输入字段：
+
+```html
+
+
+
+
+```
+
+现在要接受一个字符串并把它放到第一个空的 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;
+}
+```
+
+以上实现有以下问题：
+
+- 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;
+ }
+ }
+};
+```
+
+# 十、抽取函数
+
+工程学就是把大问题拆分成小问题再把这些问题的解决方案放回一起。
+
+首先应该明确一个函数的高层次目标，然后对于不是直接为了这个目标工作的代码，抽取出来放到独立的函数中。
+
+介绍性的代码：
+
+```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;
+}
+```
+
+以上代码中循环部分主要计算距离，这部分不属于代码高层次目标，高层次目标是寻找最小距离的值，因此可以把这部分代替提取到独立的函数中。这样做也带来一个额外的好处有：可以单独进行测试、可以快速找到程序错误并修改。
+
+```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;
+}
+```
+
+并不是函数抽取的越多越好，如果抽取过多，在阅读代码的时候可能需要不断跳来跳去。只有在当前函数不需要去了解某一块代码细节而能够表达其内容时，把这块代码抽取成子函数才是好的。
+
+函数抽取也用于减小代码的冗余。
+
+# 十一、一次只做一件事
+
+只做一件事的代码很容易让人知道其要做的事；
+
+基本流程：列出代码所做的所有任务；把每个任务拆分到不同的函数，或者不同的段落。
+
+# 十二、用自然语言表述代码
+
+先用自然语言书写代码逻辑，也就是伪代码，然后再写代码，这样代码逻辑会更清晰。
+
+# 十三、减少代码量
+
+不要过度设计，编码过程会有很多变化，过度设计的内容到最后往往是无用的。
+
+多用标准库实现。
+
+# 参考资料
+
+- Dustin, Boswell, Trevor, 等. 编写可读代码的艺术 [M]. 机械工业出版社, 2012.
+
+
+
+
+🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/notes/代码风格规范.md b/notes/代码风格规范.md
new file mode 100644
index 00000000..04d6b430
--- /dev/null
+++ b/notes/代码风格规范.md
@@ -0,0 +1,13 @@
+
+
+
+
+- [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)
+
+
+
+
+🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/notes/分布式.md b/notes/分布式.md
new file mode 100644
index 00000000..5ed09dac
--- /dev/null
+++ b/notes/分布式.md
@@ -0,0 +1,349 @@
+
+* [一、分布式锁](#一分布式锁)
+ * [数据库的唯一索引](#数据库的唯一索引)
+ * [Redis 的 SETNX 指令](#redis-的-setnx-指令)
+ * [Redis 的 RedLock 算法](#redis-的-redlock-算法)
+ * [Zookeeper 的有序节点](#zookeeper-的有序节点)
+* [二、分布式事务](#二分布式事务)
+ * [本地消息表](#本地消息表)
+ * [2PC](#2pc)
+* [三、CAP](#三cap)
+ * [一致性](#一致性)
+ * [可用性](#可用性)
+ * [分区容忍性](#分区容忍性)
+ * [权衡](#权衡)
+* [四、BASE](#四base)
+ * [基本可用](#基本可用)
+ * [软状态](#软状态)
+ * [最终一致性](#最终一致性)
+* [五、Paxos](#五paxos)
+ * [执行过程](#执行过程)
+ * [约束条件](#约束条件)
+* [六、Raft](#六raft)
+ * [单个 Candidate 的竞选](#单个-candidate-的竞选)
+ * [多个 Candidate 竞选](#多个-candidate-竞选)
+ * [数据同步](#数据同步)
+* [参考](#参考)
+
+
+
+# 一、分布式锁
+
+在单机场景下，可以使用语言的内置锁来实现进程同步。但是在分布式场景下，需要同步的进程可能位于不同的节点上，那么就需要使用分布式锁。
+
+阻塞锁通常使用互斥量来实现：
+
+- 互斥量为 0 表示有其它进程在使用锁，此时处于锁定状态；
+- 互斥量为 1 表示未锁定状态。
+
+1 和 0 可以用一个整型值表示，也可以用某个数据是否存在表示。
+
+## 数据库的唯一索引
+
+获得锁时向表中插入一条记录，释放锁时删除这条记录。唯一索引可以保证该记录只被插入一次，那么就可以用这个记录是否存在来判断是否存于锁定状态。
+
+存在以下几个问题：
+
+- 锁没有失效时间，解锁失败的话其它进程无法再获得该锁。
+- 只能是非阻塞锁，插入失败直接就报错了，无法重试。
+- 不可重入，已经获得锁的进程也必须重新获取锁。
+
+## Redis 的 SETNX 指令
+
+使用 SETNX（set if not exist）指令插入一个键值对，如果 Key 已经存在，那么会返回 False，否则插入成功并返回 True。
+
+SETNX 指令和数据库的唯一索引类似，保证了只存在一个 Key 的键值对，那么可以用一个 Key 的键值对是否存在来判断是否存于锁定状态。
+
+EXPIRE 指令可以为一个键值对设置一个过期时间，从而避免了数据库唯一索引实现方式中释放锁失败的问题。
+
+## Redis 的 RedLock 算法
+
+使用了多个 Redis 实例来实现分布式锁，这是为了保证在发生单点故障时仍然可用。
+
+- 尝试从 N 个相互独立 Redis 实例获取锁；
+- 计算获取锁消耗的时间，只有当这个时间小于锁的过期时间，并且从大多数（N / 2 + 1）实例上获取了锁，那么就认为锁获取成功了；
+- 如果锁获取失败，就到每个实例上释放锁。
+
+## Zookeeper 的有序节点
+
+### 1. Zookeeper 抽象模型
+
+Zookeeper 提供了一种树形结构级的命名空间，/app1/p_1 节点的父节点为 /app1。
+
+
+
+### 2. 节点类型
+
+- 永久节点：不会因为会话结束或者超时而消失；
+- 临时节点：如果会话结束或者超时就会消失；
+- 有序节点：会在节点名的后面加一个数字后缀，并且是有序的，例如生成的有序节点为 /lock/node-0000000000，它的下一个有序节点则为 /lock/node-0000000001，以此类推。
+
+### 3. 监听器
+
+为一个节点注册监听器，在节点状态发生改变时，会给客户端发送消息。
+
+### 4. 分布式锁实现
+
+- 创建一个锁目录 /lock；
+- 当一个客户端需要获取锁时，在 /lock 下创建临时的且有序的子节点；
+- 客户端获取 /lock 下的子节点列表，判断自己创建的子节点是否为当前子节点列表中序号最小的子节点，如果是则认为获得锁；否则监听自己的前一个子节点，获得子节点的变更通知后重复此步骤直至获得锁；
+- 执行业务代码，完成后，删除对应的子节点。
+
+### 5. 会话超时
+
+如果一个已经获得锁的会话超时了，因为创建的是临时节点，所以该会话对应的临时节点会被删除，其它会话就可以获得锁了。可以看到，Zookeeper 分布式锁不会出现数据库的唯一索引实现的分布式锁释放锁失败问题。
+
+### 6. 羊群效应
+
+一个节点未获得锁，只需要监听自己的前一个子节点，这是因为如果监听所有的子节点，那么任意一个子节点状态改变，其它所有子节点都会收到通知（羊群效应），而我们只希望它的后一个子节点收到通知。
+
+# 二、分布式事务
+
+指事务的操作位于不同的节点上，需要保证事务的 ACID 特性。
+
+例如在下单场景下，库存和订单如果不在同一个节点上，就涉及分布式事务。
+
+## 本地消息表
+
+本地消息表与业务数据表处于同一个数据库中，这样就能利用本地事务来保证在对这两个表的操作满足事务特性，并且使用了消息队列来保证最终一致性。
+
+1. 在分布式事务操作的一方完成写业务数据的操作之后向本地消息表发送一个消息，本地事务能保证这个消息一定会被写入本地消息表中。
+2. 之后将本地消息表中的消息转发到 Kafka 等消息队列中，如果转发成功则将消息从本地消息表中删除，否则继续重新转发。
+3. 在分布式事务操作的另一方从消息队列中读取一个消息，并执行消息中的操作。
+
+
+
+## 2PC
+
+两阶段提交（Two-phase Commit，2PC），通过引入协调者（Coordinator）来协调参与者的行为，并最终决定这些参与者是否要真正执行事务。
+
+### 1. 运行过程
+
+#### 1.1 准备阶段
+
+协调者询问参与者事务是否执行成功，参与者发回事务执行结果。
+
+
+
+#### 1.2 提交阶段
+
+如果事务在每个参与者上都执行成功，事务协调者发送通知让参与者提交事务；否则，协调者发送通知让参与者回滚事务。
+
+需要注意的是，在准备阶段，参与者执行了事务，但是还未提交。只有在提交阶段接收到协调者发来的通知后，才进行提交或者回滚。
+
+
+
+### 2. 存在的问题
+
+#### 2.1 同步阻塞
+
+所有事务参与者在等待其它参与者响应的时候都处于同步阻塞状态，无法进行其它操作。
+
+#### 2.2 单点问题
+
+协调者在 2PC 中起到非常大的作用，发生故障将会造成很大影响。特别是在阶段二发生故障，所有参与者会一直等待，无法完成其它操作。
+
+#### 2.3 数据不一致
+
+在阶段二，如果协调者只发送了部分 Commit 消息，此时网络发生异常，那么只有部分参与者接收到 Commit 消息，也就是说只有部分参与者提交了事务，使得系统数据不一致。
+
+#### 2.4 太过保守
+
+任意一个节点失败就会导致整个事务失败，没有完善的容错机制。
+
+# 三、CAP
+
+分布式系统不可能同时满足一致性（C：Consistency）、可用性（A：Availability）和分区容忍性（P：Partition Tolerance），最多只能同时满足其中两项。
+
+
+
+## 一致性
+
+一致性指的是多个数据副本是否能保持一致的特性，在一致性的条件下，系统在执行数据更新操作之后能够从一致性状态转移到另一个一致性状态。
+
+对系统的一个数据更新成功之后，如果所有用户都能够读取到最新的值，该系统就被认为具有强一致性。
+
+## 可用性
+
+可用性指分布式系统在面对各种异常时可以提供正常服务的能力，可以用系统可用时间占总时间的比值来衡量，4 个 9 的可用性表示系统 99.99% 的时间是可用的。
+
+在可用性条件下，要求系统提供的服务一直处于可用的状态，对于用户的每一个操作请求总是能够在有限的时间内返回结果。
+
+## 分区容忍性
+
+网络分区指分布式系统中的节点被划分为多个区域，每个区域内部可以通信，但是区域之间无法通信。
+
+在分区容忍性条件下，分布式系统在遇到任何网络分区故障的时候，仍然需要能对外提供一致性和可用性的服务，除非是整个网络环境都发生了故障。
+
+## 权衡
+
+在分布式系统中，分区容忍性必不可少，因为需要总是假设网络是不可靠的。因此，CAP 理论实际上是要在可用性和一致性之间做权衡。
+
+可用性和一致性往往是冲突的，很难使它们同时满足。在多个节点之间进行数据同步时，
+
+- 为了保证一致性（CP），不能访问未同步完成的节点，也就失去了部分可用性；
+- 为了保证可用性（AP），允许读取所有节点的数据，但是数据可能不一致。
+
+
+
+# 四、BASE
+
+BASE 是基本可用（Basically Available）、软状态（Soft State）和最终一致性（Eventually Consistent）三个短语的缩写。
+
+BASE 理论是对 CAP 中一致性和可用性权衡的结果，它的核心思想是：即使无法做到强一致性，但每个应用都可以根据自身业务特点，采用适当的方式来使系统达到最终一致性。
+
+
+## 基本可用
+
+指分布式系统在出现故障的时候，保证核心可用，允许损失部分可用性。
+
+例如，电商在做促销时，为了保证购物系统的稳定性，部分消费者可能会被引导到一个降级的页面。
+
+## 软状态
+
+指允许系统中的数据存在中间状态，并认为该中间状态不会影响系统整体可用性，即允许系统不同节点的数据副本之间进行同步的过程存在时延。
+
+## 最终一致性
+
+最终一致性强调的是系统中所有的数据副本，在经过一段时间的同步后，最终能达到一致的状态。
+
+ACID 要求强一致性，通常运用在传统的数据库系统上。而 BASE 要求最终一致性，通过牺牲强一致性来达到可用性，通常运用在大型分布式系统中。
+
+在实际的分布式场景中，不同业务单元和组件对一致性的要求是不同的，因此 ACID 和 BASE 往往会结合在一起使用。
+
+# 五、Paxos
+
+用于达成共识性问题，即对多个节点产生的值，该算法能保证只选出唯一一个值。
+
+主要有三类节点：
+
+- 提议者（Proposer）：提议一个值；
+- 接受者（Acceptor）：对每个提议进行投票；
+- 告知者（Learner）：被告知投票的结果，不参与投票过程。
+
+
+
+## 执行过程
+
+规定一个提议包含两个字段：[n, v]，其中 n 为序号（具有唯一性），v 为提议值。
+
+### 1. Prepare 阶段
+
+下图演示了两个 Proposer 和三个 Acceptor 的系统中运行该算法的初始过程，每个 Proposer 都会向所有 Acceptor 发送 Prepare 请求。
+
+
+
+当 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 接收到一个 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 类似。
+
+
+
+### 2. Accept 阶段
+
+当一个 Proposer 接收到超过一半 Acceptor 的 Prepare 响应时，就可以发送 Accept 请求。
+
+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 请求。
+
+
+
+### 3. Learn 阶段
+
+Acceptor 接收到 Accept 请求时，如果序号大于等于该 Acceptor 承诺的最小序号，那么就发送 Learn 提议给所有的 Learner。当 Learner 发现有大多数的 Acceptor 接收了某个提议，那么该提议的提议值就被 Paxos 选择出来。
+
+
+
+## 约束条件
+
+### 1\. 正确性
+
+指只有一个提议值会生效。
+
+因为 Paxos 协议要求每个生效的提议被多数 Acceptor 接收，并且 Acceptor 不会接受两个不同的提议，因此可以保证正确性。
+
+### 2\. 可终止性
+
+指最后总会有一个提议生效。
+
+Paxos 协议能够让 Proposer 发送的提议朝着能被大多数 Acceptor 接受的那个提议靠拢，因此能够保证可终止性。
+
+# 六、Raft
+
+Raft 也是分布式一致性协议，主要是用来竞选主节点。
+
+## 单个 Candidate 的竞选
+
+有三种节点：Follower、Candidate 和 Leader。Leader 会周期性的发送心跳包给 Follower。每个 Follower 都设置了一个随机的竞选超时时间，一般为 150ms\~300ms，如果在这个时间内没有收到 Leader 的心跳包，就会变成 Candidate，进入竞选阶段。
+
+- 下图展示一个分布式系统的最初阶段，此时只有 Follower 没有 Leader。Node A 等待一个随机的竞选超时时间之后，没收到 Leader 发来的心跳包，因此进入竞选阶段。
+
+
+
+- 此时 Node A 发送投票请求给其它所有节点。
+
+
+
+- 其它节点会对请求进行回复，如果超过一半的节点回复了，那么该 Candidate 就会变成 Leader。
+
+
+
+- 之后 Leader 会周期性地发送心跳包给 Follower，Follower 接收到心跳包，会重新开始计时。
+
+
+
+## 多个 Candidate 竞选
+
+- 如果有多个 Follower 成为 Candidate，并且所获得票数相同，那么就需要重新开始投票。例如下图中 Node B 和 Node D 都获得两票，需要重新开始投票。
+
+
+
+- 由于每个节点设置的随机竞选超时时间不同，因此下一次再次出现多个 Candidate 并获得同样票数的概率很低。
+
+
+
+## 数据同步
+
+- 来自客户端的修改都会被传入 Leader。注意该修改还未被提交，只是写入日志中。
+
+
+
+- Leader 会把修改复制到所有 Follower。
+
+
+
+- Leader 会等待大多数的 Follower 也进行了修改，然后才将修改提交。
+
+
+
+- 此时 Leader 会通知的所有 Follower 让它们也提交修改，此时所有节点的值达成一致。
+
+
+
+# 参考
+
+- 倪超. 从 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/)
+
+
+
+
+
+🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
diff --git a/notes/剑指 Offer 题解 - 10~19.md b/notes/剑指 Offer 题解 - 10~19.md
new file mode 100644
index 00000000..390e2cb4
--- /dev/null
+++ b/notes/剑指 Offer 题解 - 10~19.md
@@ -0,0 +1,659 @@
+
+* [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-正则表达式匹配)
+
+
+
+# 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。
+
+
+
+
+
+## 解题思路
+
+如果使用递归求解，会重复计算一些子问题。例如，计算 f(10) 需要计算 f(9) 和 f(8)，计算 f(9) 需要计算 f(8) 和 f(7)，可以看到 f(8) 被重复计算了。
+
+
+
+
+递归是将一个问题划分成多个子问题求解，动态规划也是如此，但是动态规划会把子问题的解缓存起来，从而避免重复求解子问题。
+
+```java
+public int Fibonacci(int n) {
+ if (n <= 1)
+ return n;
+ int[] fib = new int[n + 1];
+ fib[1] = 1;
+ for (int i = 2; i <= n; i++)
+ fib[i] = fib[i - 1] + fib[i - 2];
+ return fib[n];
+}
+```
+
+考虑到第 i 项只与第 i-1 和第 i-2 项有关，因此只需要存储前两项的值就能求解第 i 项，从而将空间复杂度由 O(N) 降低为 O(1)。
+
+```java
+public int Fibonacci(int n) {
+ if (n <= 1)
+ return n;
+ int pre2 = 0, pre1 = 1;
+ int fib = 0;
+ for (int i = 2; i <= n; i++) {
+ fib = pre2 + pre1;
+ pre2 = pre1;
+ pre1 = fib;
+ }
+ return fib;
+}
+```
+
+由于待求解的 n 小于 40，因此可以将前 40 项的结果先进行计算，之后就能以 O(1) 时间复杂度得到第 n 项的值了。
+
+```java
+public class Solution {
+
+ private int[] fib = new int[40];
+
+ public Solution() {
+ fib[1] = 1;
+ for (int i = 2; i < fib.length; i++)
+ fib[i] = fib[i - 1] + fib[i - 2];
+ }
+
+ public int Fibonacci(int n) {
+ return fib[n];
+ }
+}
+```
+
+# 10.2 矩形覆盖
+
+[NowCoder](https://www.nowcoder.com/practice/72a5a919508a4251859fb2cfb987a0e6?tpId=13&tqId=11163&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
+
+## 题目描述
+
+我们可以用 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;
+}
+```
+
+# 10.3 跳台阶
+
+[NowCoder](https://www.nowcoder.com/practice/8c82a5b80378478f9484d87d1c5f12a4?tpId=13&tqId=11161&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
+
+## 题目描述
+
+一只青蛙一次可以跳上 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;
+}
+```
+
+# 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 级的台阶总共有多少种跳法。
+
+
+
+## 解题思路
+
+### 动态规划
+
+```java
+public int JumpFloorII(int target) {
+ int[] dp = new int[target];
+ Arrays.fill(dp, 1);
+ for (int i = 1; i < target; i++)
+ for (int j = 0; j < i; j++)
+ dp[i] += dp[j];
+ return dp[target - 1];
+}
+```
+
+### 数学推导
+
+跳上 n-1 级台阶，可以从 n-2 级跳 1 级上去，也可以从 n-3 级跳 2 级上去...，那么
+
+```
+f(n-1) = f(n-2) + f(n-3) + ... + f(0)
+```
+
+同样，跳上 n 级台阶，可以从 n-1 级跳 1 级上去，也可以从 n-2 级跳 2 级上去... ，那么
+
+```
+f(n) = f(n-1) + f(n-2) + ... + f(0)
+```
+
+综上可得
+
+```
+f(n) - f(n-1) = f(n-1)
+```
+
+即
+
+```
+f(n) = 2*f(n-1)
+```
+
+所以 f(n) 是一个等比数列
+
+```source-java
+public int JumpFloorII(int target) {
+ return (int) Math.pow(2, target - 1);
+}
+```
+
+
+# 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。
+
+## 解题思路
+
+在一个有序数组中查找一个元素可以用二分查找，二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度都为 O(logN)。
+
+本题可以修改二分查找算法进行求解：
+
+- 当 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];
+}
+```
+
+如果数组元素允许重复的话，那么就会出现一个特殊的情况：nums[l] == nums[m] == nums[h]，那么此时无法确定解在哪个区间，需要切换到顺序查找。例如对于数组 {1,1,1,0,1}，l、m 和 h 指向的数都为 1，此时无法知道最小数字 0 在哪个区间。
+
+```java
+public int minNumberInRotateArray(int[] nums) {
+ if (nums.length == 0)
+ return 0;
+ int l = 0, h = nums.length - 1;
+ while (l < h) {
+ int m = l + (h - l) / 2;
+ if (nums[l] == nums[m] && nums[m] == nums[h])
+ return minNumber(nums, l, h);
+ else if (nums[m] <= nums[h])
+ h = m;
+ else
+ l = m + 1;
+ }
+ return nums[l];
+}
+
+private int minNumber(int[] nums, int l, int h) {
+ for (int i = l; i < h; i++)
+ if (nums[i] > nums[i + 1])
+ return nums[i + 1];
+ return nums[l];
+}
+```
+
+# 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 路径。
+
+
+
+## 解题思路
+
+```java
+private final static int[][] next = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
+private int rows;
+private int cols;
+
+public boolean hasPath(char[] array, int rows, int cols, char[] str) {
+ if (rows == 0 || cols == 0)
+ return false;
+ this.rows = rows;
+ this.cols = cols;
+ boolean[][] marked = new boolean[rows][cols];
+ char[][] matrix = buildMatrix(array);
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ if (backtracking(matrix, str, marked, 0, i, j))
+ return true;
+ return false;
+}
+
+private boolean backtracking(char[][] matrix, char[] str, boolean[][] marked, int pathLen, int r, int c) {
+ if (pathLen == str.length)
+ return true;
+ if (r < 0 || r >= rows || c < 0 || c >= cols || matrix[r][c] != str[pathLen] || marked[r][c])
+ return false;
+ marked[r][c] = true;
+ for (int[] n : next)
+ if (backtracking(matrix, str, marked, pathLen + 1, r + n[0], c + n[1]))
+ return true;
+ marked[r][c] = false;
+ return false;
+}
+
+private char[][] buildMatrix(char[] array) {
+ char[][] matrix = new char[rows][cols];
+ for (int i = 0, idx = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ matrix[i][j] = array[idx++];
+ return matrix;
+}
+```
+
+# 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 的格子。
+
+例如，当 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;
+
+public int movingCount(int threshold, int rows, int cols) {
+ this.rows = rows;
+ this.cols = cols;
+ this.threshold = threshold;
+ initDigitSum();
+ boolean[][] marked = new boolean[rows][cols];
+ dfs(marked, 0, 0);
+ return cnt;
+}
+
+private void dfs(boolean[][] marked, int r, int c) {
+ if (r < 0 || r >= rows || c < 0 || c >= cols || marked[r][c])
+ return;
+ marked[r][c] = true;
+ if (this.digitSum[r][c] > this.threshold)
+ return;
+ cnt++;
+ for (int[] n : next)
+ dfs(marked, r + n[0], c + n[1]);
+}
+
+private void initDigitSum() {
+ int[] digitSumOne = new int[Math.max(rows, cols)];
+ for (int i = 0; i < digitSumOne.length; i++) {
+ int n = i;
+ while (n > 0) {
+ digitSumOne[i] += n % 10;
+ n /= 10;
+ }
+ }
+ this.digitSum = new int[rows][cols];
+ for (int i = 0; i < this.rows; i++)
+ for (int j = 0; j < this.cols; j++)
+ this.digitSum[i][j] = digitSumOne[i] + digitSumOne[j];
+}
+```
+
+# 14. 剪绳子
+
+[Leetcode](https://leetcode.com/problems/integer-break/description/)
+
+## 题目描述
+
+把一根绳子剪成多段，并且使得每段的长度乘积最大。
+
+```html
+n = 2
+return 1 (2 = 1 + 1)
+
+n = 10
+return 36 (10 = 3 + 3 + 4)
+```
+
+## 解题思路
+
+### 贪心
+
+尽可能多剪长度为 3 的绳子，并且不允许有长度为 1 的绳子出现。如果出现了，就从已经切好长度为 3 的绳子中拿出一段与长度为 1 的绳子重新组合，把它们切成两段长度为 2 的绳子。
+
+证明：当 n >= 5 时，3(n - 3) - n = 2n - 9 > 0，且 2(n - 2) - n = n - 4 > 0。因此在 n >= 5 的情况下，将绳子剪成一段为 2 或者 3，得到的乘积会更大。又因为 3(n - 3) - 2(n - 2) = n - 5 >= 0，所以剪成一段长度为 3 比长度为 2 得到的乘积更大。
+
+```java
+public int integerBreak(int n) {
+ if (n < 2)
+ return 0;
+ if (n == 2)
+ return 1;
+ if (n == 3)
+ return 2;
+ int timesOf3 = n / 3;
+ if (n - timesOf3 * 3 == 1)
+ timesOf3--;
+ int timesOf2 = (n - timesOf3 * 3) / 2;
+ return (int) (Math.pow(3, timesOf3)) * (int) (Math.pow(2, timesOf2));
+}
+```
+
+### 动态规划
+
+```java
+public int integerBreak(int n) {
+ int[] dp = new int[n + 1];
+ dp[1] = 1;
+ for (int i = 2; i <= n; i++)
+ for (int j = 1; j < i; j++)
+ dp[i] = Math.max(dp[i], Math.max(j * (i - j), dp[j] * (i - j)));
+ return dp[n];
+}
+```
+
+# 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 的个数。
+
+### n&(n-1)
+
+该位运算去除 n 的位级表示中最低的那一位。
+
+```
+n : 10110100
+n-1 : 10110011
+n&(n-1) : 10110000
+```
+
+时间复杂度：O(M)，其中 M 表示 1 的个数。
+
+
+```java
+public int NumberOf1(int n) {
+ int cnt = 0;
+ while (n != 0) {
+ cnt++;
+ n &= (n - 1);
+ }
+ return cnt;
+}
+```
+
+
+### Integer.bitCount()
+
+```java
+public int NumberOf1(int n) {
+ return Integer.bitCount(n);
+}
+```
+
+# 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 次方。
+
+## 解题思路
+
+下面的讨论中 x 代表 base，n 代表 exponent。
+
+
+
+
+
+
+因为 (x\*x)n/2 可以通过递归求解，并且每次递归 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;
+}
+```
+
+# 17. 打印从 1 到最大的 n 位数
+
+## 题目描述
+
+输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数即 999。
+
+## 解题思路
+
+由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用 char 数组进行存储。
+
+使用回溯法得到所有的数。
+
+```java
+public void print1ToMaxOfNDigits(int n) {
+ if (n <= 0)
+ return;
+ char[] number = new char[n];
+ print1ToMaxOfNDigits(number, 0);
+}
+
+private void print1ToMaxOfNDigits(char[] number, int digit) {
+ if (digit == number.length) {
+ printNumber(number);
+ return;
+ }
+ for (int i = 0; i < 10; i++) {
+ number[digit] = (char) (i + '0');
+ print1ToMaxOfNDigits(number, digit + 1);
+ }
+}
+
+private void printNumber(char[] number) {
+ int index = 0;
+ while (index < number.length && number[index] == '0')
+ index++;
+ while (index < number.length)
+ System.out.print(number[index++]);
+ System.out.println();
+}
+```
+
+# 18.1 在 O(1) 时间内删除链表节点
+
+## 解题思路
+
+① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。
+
+
+
+② 如果链表只有一个节点，那么直接
+
+② 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 O(N)。
+
+
+
+综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个尾节点以 O(N) 的时间复杂度操作节点的总次数。(2N-1)/N \~ 2，因此该算法的平均时间复杂度为 O(1)。
+
+```java
+public ListNode deleteNode(ListNode head, ListNode tobeDelete) {
+ if (head == null || tobeDelete == null)
+ return null;
+ if (tobeDelete.next != null) {
+ // 要删除的节点不是尾节点
+ ListNode next = tobeDelete.next;
+ tobeDelete.val = next.val;
+ tobeDelete.next = next.next;
+ } else {
+ if (head == tobeDelete)
+ // 只有一个节点
+ head = null;
+ else {
+ ListNode cur = head;
+ while (cur.next != tobeDelete)
+ cur = cur.next;
+ cur.next = null;
+ }
+ }
+ return head;
+}
+```
+
+# 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)
+
+## 题目描述
+
+
+
+## 解题描述
+
+```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;
+ }
+}
+```
+
+# 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 次）。
+
+在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串 "aaa" 与模式 "a.a" 和 "ab\*ac\*a" 匹配，但是与 "aa.a" 和 "ab\*a" 均不匹配。
+
+## 解题思路
+
+应该注意到，'.' 是用来当做一个任意字符，而 '\*' 是用来重复前面的字符。这两个的作用不同，不能把 '.' 的作用和 '\*' 进行类比，从而把它当成重复前面字符一次。
+
+```java
+public boolean match(char[] str, char[] pattern) {
+
+ int m = str.length, n = pattern.length;
+ boolean[][] dp = new boolean[m + 1][n + 1];
+
+ dp[0][0] = true;
+ for (int i = 1; i <= n; i++)
+ if (pattern[i - 1] == '*')
+ dp[0][i] = dp[0][i - 2];
+
+ for (int i = 1; i <= m; i++)
+ for (int j = 1; j <= n; j++)
+ if (str[i - 1] == pattern[j - 1] || pattern[j - 1] == '.')
+ dp[i][j] = dp[i - 1][j - 1];
+ else if (pattern[j - 1] == '*')
+ if (pattern[j - 2] == str[i - 1] || pattern[j - 2] == '.') {
+ dp[i][j] |= dp[i][j - 1]; // a* counts as single a
+ dp[i][j] |= dp[i - 1][j]; // a* counts as multiple a
+ dp[i][j] |= dp[i][j - 2]; // a* counts as empty
+ } else
+ dp[i][j] = dp[i][j - 2]; // a* only counts as empty
+
+ return dp[m][n];
+}
+```
+
+
+
+
+🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+ 
+
+## 解题思路
+
+```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;
+ }
+}
+```
+
+# 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 个节点。
+
+ 
+
+```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;
+}
+```
+
+# 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。
+
+在相遇点，slow 要到环的入口点还需要移动 z 个节点，如果让 fast 重新从头开始移动，并且速度变为每次移动一个节点，那么它到环入口点还需要移动 x 个节点。在上面已经推导出 x=z，因此 fast 和 slow 将在环入口点相遇。
+
+ 
+
+```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;
+}
+```
+
+# 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;
+}
+```
+
+### 迭代
+
+```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;
+}
+```
+
+# 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)
+
+## 题目描述
+
+ 
+
+## 解题思路
+
+### 递归
+
+```java
+public ListNode Merge(ListNode list1, ListNode list2) {
+ if (list1 == null)
+ return list2;
+ if (list2 == null)
+ return list1;
+ if (list1.val <= list2.val) {
+ list1.next = Merge(list1.next, list2);
+ return list1;
+ } else {
+ list2.next = Merge(list1, list2.next);
+ return list2;
+ }
+}
+```
+
+### 迭代
+
+```java
+public ListNode Merge(ListNode list1, ListNode list2) {
+ ListNode head = new ListNode(-1);
+ ListNode cur = head;
+ while (list1 != null && list2 != null) {
+ if (list1.val <= list2.val) {
+ cur.next = list1;
+ list1 = list1.next;
+ } else {
+ cur.next = list2;
+ list2 = list2.next;
+ }
+ cur = cur.next;
+ }
+ if (list1 != null)
+ cur.next = list1;
+ if (list2 != null)
+ cur.next = list2;
+ return head.next;
+}
+```
+
+# 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)
+
+## 题目描述
+
+ 
+
+## 解题思路
+
+```java
+public boolean HasSubtree(TreeNode root1, TreeNode root2) {
+ if (root1 == null || root2 == null)
+ return false;
+ return isSubtreeWithRoot(root1, root2) || HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
+}
+
+private boolean isSubtreeWithRoot(TreeNode root1, TreeNode root2) {
+ if (root2 == null)
+ return true;
+ if (root1 == null)
+ return false;
+ if (root1.val != root2.val)
+ return false;
+ return isSubtreeWithRoot(root1.left, root2.left) && isSubtreeWithRoot(root1.right, root2.right);
+}
+```
+
+# 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)
+
+## 题目描述
+
+ 
+
+## 解题思路
+
+```java
+public void Mirror(TreeNode root) {
+ if (root == null)
+ return;
+ swap(root);
+ Mirror(root.left);
+ Mirror(root.right);
+}
+
+private void swap(TreeNode root) {
+ TreeNode t = root.left;
+ root.left = root.right;
+ root.right = t;
+}
+```
+
+# 28 对称的二叉树
+
+[NowCoder](https://www.nowcoder.com/practice/ff05d44dfdb04e1d83bdbdab320efbcb?tpId=13&tqId=11211&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
+
+## 题目描述
+
+
+
+## 解题思路
+
+```java
+boolean isSymmetrical(TreeNode pRoot) {
+ if (pRoot == null)
+ return true;
+ return isSymmetrical(pRoot.left, pRoot.right);
+}
+
+boolean isSymmetrical(TreeNode t1, TreeNode t2) {
+ if (t1 == null && t2 == null)
+ return true;
+ if (t1 == null || t2 == null)
+ return false;
+ if (t1.val != t2.val)
+ return false;
+ return isSymmetrical(t1.left, t2.right) && isSymmetrical(t1.right, t2.left);
+}
+```
+
+# 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
+
+ 
+
+## 解题思路
+
+```java
+public ArrayList printMatrix(int[][] matrix) {
+ ArrayList 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;
+}
+```
+
+
+
+
+🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。
+
+
+## 解题思路
+
+使用队列来进行层次遍历。
+
+不需要使用两个队列分别存储当前层的节点和下一层的节点，因为在开始遍历一层的节点时，当前队列中的节点数就是当前层的节点数，只要控制遍历这么多节点数，就能保证这次遍历的都是当前层的节点。
+
+```java
+public ArrayList PrintFromTopToBottom(TreeNode root) {
+ Queue queue = new LinkedList<>();
+ ArrayList 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 把二叉树打印成多行
+
+[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> Print(TreeNode pRoot) {
+ ArrayList> ret = new ArrayList<>();
+ Queue queue = new LinkedList<>();
+ queue.add(pRoot);
+ while (!queue.isEmpty()) {
+ ArrayList
