docs: add linter

.markdownlint.json

@@ -0,0 +1,19 @@
+{
+  "default": true,
+  "MD003": {
+    "style": "atx"
+  },
+  "MD004": {
+    "style": "dash"
+  },
+  "MD013": false,
+  "MD024": {
+    "allow_different_nesting": true
+  },
+  "MD035": {
+    "style": "---"
+  },
+  "MD040": false,
+  "MD046": false,
+  "MD049": false
+}

.markdownlintignore

@@ -0,0 +1,4 @@
+**/node_modules/**
+
+# markdown snippets
+*.snippet.md

.prettierignore

@@ -0,0 +1,15 @@
+# Vuepress Cache
+**/.vuepress/.cache/**
+# Vuepress Temp
+**/.vuepress/.temp/**
+# Vuepress Output
+dist/
+
+# Node modules
+node_modules/
+
+# pnpm lock file
+pnpm-lock.yaml
+
+index.html
+sw.js

docs/.vuepress/navbar.ts

@@ -2,7 +2,11 @@ import { navbar } from "vuepress-theme-hope";
 
 export default navbar([
   { text: "面试指南", icon: "java", link: "/home.md" },
-  { text: "知识星球", icon: "code", link: "/about-the-author/zhishixingqiu-two-years.md" },
+  {
+    text: "知识星球",
+    icon: "code",
+    link: "/about-the-author/zhishixingqiu-two-years.md",
+  },
   { text: "开源项目", icon: "github", link: "/open-source-project/" },
   { text: "技术书籍", icon: "book", link: "/books/" },
   {

docs/cs-basics/algorithms/linkedlist-algorithm-problems.md

@@ -11,7 +11,7 @@ tag:
 
 > Leetcode:给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。
 >
->你可以假设除了数字 0 之外，这两个数字都不会以零开头。
+> 你可以假设除了数字 0 之外，这两个数字都不会以零开头。
 
 示例：
 
@@ -23,11 +23,11 @@ tag:
 
 ### 问题分析
 
-Leetcode官方详细解答地址：
+Leetcode 官方详细解答地址：
 
- https://leetcode-cn.com/problems/add-two-numbers/solution/
+https://leetcode-cn.com/problems/add-two-numbers/solution/
 
-> 要对头结点进行操作时，考虑创建哑节点dummy，使用dummy->next表示真正的头节点。这样可以避免处理头节点为空的边界问题。
+> 要对头结点进行操作时，考虑创建哑节点 dummy，使用 dummy->next 表示真正的头节点。这样可以避免处理头节点为空的边界问题。
 
 我们使用变量来跟踪进位，并从包含最低有效位的表头开始模拟逐
 位相加的过程。
@@ -36,7 +36,7 @@ Leetcode官方详细解答地址：
 
 ### Solution
 
-**我们首先从最低有效位也就是列表 l1和 l2 的表头开始相加。注意需要考虑到进位的情况！**
+**我们首先从最低有效位也就是列表 l1 和 l2 的表头开始相加。注意需要考虑到进位的情况！**
 
 ```java
 /**
@@ -76,8 +76,8 @@ public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
 
 ## 2. 翻转链表
 
-
 ### 题目描述
+
 > 剑指 offer:输入一个链表，反转链表后，输出链表的所有元素。
 
 ![翻转链表](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-9-20/81431871.jpg)
@@ -88,7 +88,6 @@ public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
 
 ### Solution
 
-
 ```java
 public class ListNode {
   int val;
@@ -102,7 +101,7 @@ public class ListNode {
 
 ```java
 /**
- * 
+ *
  * @author Snailclimb
  * @date 2018年9月19日
  * @Description: TODO
@@ -162,18 +161,17 @@ public class Solution {
 1
 ```
 
-## 3. 链表中倒数第k个节点
+## 3. 链表中倒数第 k 个节点
 
 ### 题目描述
 
-> 剑指offer: 输入一个链表，输出该链表中倒数第k个结点。
+> 剑指 offer: 输入一个链表，输出该链表中倒数第 k 个结点。
 
 ### 问题分析
 
-> **链表中倒数第k个节点也就是正数第(L-K+1)个节点，知道了只一点，这一题基本就没问题！**
-
-首先两个节点/指针，一个节点 node1 先开始跑，指针 node1 跑到 k-1 个节点后，另一个节点 node2 开始跑，当 node1 跑到最后时，node2 所指的节点就是倒数第k个节点也就是正数第(L-K+1)个节点。
+> **链表中倒数第 k 个节点也就是正数第(L-K+1)个节点，知道了只一点，这一题基本就没问题！**
 
+首先两个节点/指针，一个节点 node1 先开始跑，指针 node1 跑到 k-1 个节点后，另一个节点 node2 开始跑，当 node1 跑到最后时，node2 所指的节点就是倒数第 k 个节点也就是正数第(L-K+1)个节点。
 
 ### Solution
 
@@ -221,9 +219,7 @@ public class Solution {
 }
 ```
 
-
-## 4. 删除链表的倒数第N个节点
-
+## 4. 删除链表的倒数第 N 个节点
 
 > Leetcode:给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
 
@@ -248,8 +244,7 @@ public class Solution {
 
 ### 问题分析
 
-
-我们注意到这个问题可以容易地简化成另一个问题：删除从列表开头数起的第 (L - n + 1)个结点，其中 L是列表的长度。只要我们找到列表的长度 L，这个问题就很容易解决。
+我们注意到这个问题可以容易地简化成另一个问题：删除从列表开头数起的第 (L - n + 1)个结点，其中 L 是列表的长度。只要我们找到列表的长度 L，这个问题就很容易解决。
 
 ![图 1. 删除列表中的第 L - n + 1 个元素](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-9-20/94354387.jpg)
 
@@ -299,16 +294,13 @@ public class Solution {
 **复杂度分析：**
 
 - **时间复杂度 O(L)** ：该算法对列表进行了两次遍历，首先计算了列表的长度 LL 其次找到第 (L - n)(L−n) 个结点。 操作执行了 2L-n2L−n 步，时间复杂度为 O(L)O(L)。
-- **空间复杂度 O(1)** ：我们只用了常量级的额外空间。 
-
-
+- **空间复杂度 O(1)** ：我们只用了常量级的额外空间。
 
 **进阶——一次遍历法：**
 
+> 链表中倒数第 N 个节点也就是正数第(L-N+1)个节点。
 
-> 链表中倒数第N个节点也就是正数第(L-N+1)个节点。
-
-其实这种方法就和我们上面第四题找“链表中倒数第k个节点”所用的思想是一样的。**基本思路就是：**  定义两个节点 node1、node2;node1 节点先跑，node1节点 跑到第 n+1 个节点的时候,node2 节点开始跑.当node1 节点跑到最后一个节点时，node2 节点所在的位置就是第 （L-n ） 个节点（L代表总链表长度，也就是倒数第 n+1 个节点）
+其实这种方法就和我们上面第四题找“链表中倒数第 k 个节点”所用的思想是一样的。**基本思路就是：** 定义两个节点 node1、node2;node1 节点先跑，node1 节点 跑到第 n+1 个节点的时候,node2 节点开始跑.当 node1 节点跑到最后一个节点时，node2 节点所在的位置就是第 （L-n ） 个节点（L 代表总链表长度，也就是倒数第 n+1 个节点）
 
 ```java
 /**
@@ -345,25 +337,21 @@ public class Solution {
 }
 ```
 
-
-
-
-
 ## 5. 合并两个排序的链表
 
 ### 题目描述
 
-> 剑指offer:输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
+> 剑指 offer:输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
 
 ### 问题分析
 
-我们可以这样分析: 
+我们可以这样分析:
 
-1. 假设我们有两个链表 A,B； 
-2. A的头节点A1的值与B的头结点B1的值比较，假设A1小，则A1为头节点； 
-3. A2再和B1比较，假设B1小,则，A1指向B1； 
-4. A2再和B2比较
-就这样循环往复就行了，应该还算好理解。
+1. 假设我们有两个链表 A,B；
+2. A 的头节点 A1 的值与 B 的头结点 B1 的值比较，假设 A1 小，则 A1 为头节点；
+3. A2 再和 B1 比较，假设 B1 小,则，A1 指向 B1；
+4. A2 再和 B2 比较
+   就这样循环往复就行了，应该还算好理解。
 
 考虑通过递归的方式实现！
 
@@ -396,8 +384,7 @@ public ListNode Merge(ListNode list1,ListNode list2) {
        }else{
            list2.next = Merge(list1, list2.next);
            return list2;
-       }       
+       }
    }
 }
 ```
-