[docs update]Redis持久化的内容单独提取成一篇文章

README.md

@@ -228,7 +228,9 @@ JVM 这部分内容主要参考 [JVM 虚拟机规范-Java8 ](https://docs.oracle
 - [3种常用的缓存读写策略详解](./docs/database/redis/3-commonly-used-cache-read-and-write-strategies.md)
 - [Redis 5 种基本数据结构详解](./docs/database/redis/redis-data-structures-01.md)
 - [Redis 3 种特殊数据结构详解](./docs/database/redis/redis-data-structures-02.md)
+- [Redis 持久化机制详解](./docs/database/redis/redis-persistence.md)
 - [Redis 内存碎片详解](./docs/database/redis/redis-memory-fragmentation.md)
+- [Redis 常见阻塞原因总结](./docs/database/redis/redis-common-blocking-problems-summary.md)
 - [Redis 集群详解](./docs/database/redis/redis-cluster.md)
 
 ### MongoDB

docs/.vuepress/sidebar.ts

@@ -289,6 +289,7 @@ export const sidebarConfig = sidebar({
                 "3-commonly-used-cache-read-and-write-strategies",
                 "redis-data-structures-01",
                 "redis-data-structures-02",
+                "redis-persistence",
                 "redis-memory-fragmentation",
                 "redis-common-blocking-problems-summary",
                 "redis-cluster",

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

@@ -9,32 +9,29 @@ tag:
 >
 > 原文地址:https://www.weiweiblog.cn/13string/
 
-
 ## 1. KMP 算法
 
-谈到字符串问题，不得不提的就是 KMP 算法，它是用来解决字符串查找的问题，可以在一个字符串（S）中查找一个子串（W）出现的位置。KMP 算法把字符匹配的时间复杂度缩小到 O(m+n) ,而空间复杂度也只有O(m)。因为“暴力搜索”的方法会反复回溯主串，导致效率低下，而KMP算法可以利用已经部分匹配这个有效信息，保持主串上的指针不回溯，通过修改子串的指针，让模式串尽量地移动到有效的位置。
+谈到字符串问题，不得不提的就是 KMP 算法，它是用来解决字符串查找的问题，可以在一个字符串（S）中查找一个子串（W）出现的位置。KMP 算法把字符匹配的时间复杂度缩小到 O(m+n) ,而空间复杂度也只有 O(m)。因为“暴力搜索”的方法会反复回溯主串，导致效率低下，而 KMP 算法可以利用已经部分匹配这个有效信息，保持主串上的指针不回溯，通过修改子串的指针，让模式串尽量地移动到有效的位置。
 
 具体算法细节请参考：
 
-- **字符串匹配的KMP算法:** http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html
-- **从头到尾彻底理解KMP:** https://blog.csdn.net/v_july_v/article/details/7041827
-- **如何更好的理解和掌握 KMP 算法?:** https://www.zhihu.com/question/21923021
-- **KMP 算法详细解析:**  https://blog.sengxian.com/algorithms/kmp
-- **图解 KMP 算法:** http://blog.jobbole.com/76611/
-- **汪都能听懂的KMP字符串匹配算法【双语字幕】:** https://www.bilibili.com/video/av3246487/?from=search&seid=17173603269940723925
-- **KMP字符串匹配算法1:** https://www.bilibili.com/video/av11866460?from=search&seid=12730654434238709250
-
-**除此之外，再来了解一下BM算法！**
+- [从头到尾彻底理解 KMP:](https://blog.csdn.net/v_july_v/article/details/7041827)
+- [如何更好的理解和掌握 KMP 算法?](https://www.zhihu.com/question/21923021)
+- [KMP 算法详细解析](https://blog.sengxian.com/algorithms/kmp)
+- [图解 KMP 算法](http://blog.jobbole.com/76611/)
+- [汪都能听懂的 KMP 字符串匹配算法【双语字幕】](https://www.bilibili.com/video/av3246487/?from=search&seid=17173603269940723925)
+- [KMP 字符串匹配算法 1](https://www.bilibili.com/video/av11866460?from=search&seid=12730654434238709250)
 
-> BM算法也是一种精确字符串匹配算法，它采用从右向左比较的方法，同时应用到了两种启发式规则，即坏字符规则 和好后缀规则 ，来决定向右跳跃的距离。基本思路就是从右往左进行字符匹配，遇到不匹配的字符后从坏字符表和好后缀表找一个最大的右移值，将模式串右移继续匹配。
-《字符串匹配的KMP算法》:http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html
+**除此之外，再来了解一下 BM 算法！**
 
+> BM 算法也是一种精确字符串匹配算法，它采用从右向左比较的方法，同时应用到了两种启发式规则，即坏字符规则 和好后缀规则 ，来决定向右跳跃的距离。基本思路就是从右往左进行字符匹配，遇到不匹配的字符后从坏字符表和好后缀表找一个最大的右移值，将模式串右移继续匹配。
+> 《字符串匹配的 KMP 算法》:http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html
 
 ## 2. 替换空格
 
-> 剑指offer：请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
+> 剑指 offer：请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为 We Are Happy.则经过替换之后的字符串为 We%20Are%20Happy。
 
-这里我提供了两种方法：①常规方法；②利用 API 解决。
+这里我提供了两种方法：① 常规方法；② 利用 API 解决。
 
 ```java
 //https://www.weiweiblog.cn/replacespace/
@@ -65,7 +62,7 @@ public class Solution {
    * 第二种方法：利用API替换掉所用空格，一行代码解决问题
    */
   public static String replaceSpace2(StringBuffer str) {
-    
+
     return str.toString().replaceAll("\\s", "%20");
   }
 }
@@ -80,7 +77,7 @@ str.toString().replace(" ","%20");
 
 ## 3. 最长公共前缀
 
-> Leetcode:  编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 ""。
+> Leetcode: 编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 ""。
 
 示例 1:
 
@@ -97,8 +94,7 @@ str.toString().replace(" ","%20");
 解释: 输入不存在公共前缀。
 ```
 
-
-思路很简单！先利用Arrays.sort(strs)为数组排序，再将数组第一个元素和最后一个元素的字符从前往后对比即可！
+思路很简单！先利用 Arrays.sort(strs)为数组排序，再将数组第一个元素和最后一个元素的字符从前往后对比即可！
 
 ```java
 public class Main {
@@ -160,12 +156,10 @@ public class Main {
 
 ### 4.1. 最长回文串
 
-> LeetCode:  给定一个包含大写字母和小写字母的字符串，找到通过这些字母构造成的最长的回文串。在构造过程中，请注意区分大小写。比如`"Aa"`不能当做一个回文字符串。注
-意:假设字符串的长度不会超过 1010。
-
-
+> LeetCode: 给定一个包含大写字母和小写字母的字符串，找到通过这些字母构造成的最长的回文串。在构造过程中，请注意区分大小写。比如`"Aa"`不能当做一个回文字符串。注
+> 意:假设字符串的长度不会超过 1010。
 
-> 回文串：“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。——百度百科  地址：https://baike.baidu.com/item/%E5%9B%9E%E6%96%87%E4%B8%B2/1274921?fr=aladdin
+> 回文串：“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。——百度百科 地址：https://baike.baidu.com/item/%E5%9B%9E%E6%96%87%E4%B8%B2/1274921?fr=aladdin
 
 示例 1:
 
@@ -185,7 +179,7 @@ public class Main {
 - 字符出现次数为双数的组合
 - **字符出现次数为偶数的组合+单个字符中出现次数最多且为奇数次的字符** （参见 **[issue665](https://github.com/Snailclimb/JavaGuide/issues/665)** ）
 
-统计字符出现的次数即可，双数才能构成回文。因为允许中间一个数单独出现，比如“abcba”，所以如果最后有字母落单，总长度可以加 1。首先将字符串转变为字符数组。然后遍历该数组，判断对应字符是否在hashset中，如果不在就加进去，如果在就让count++，然后移除该字符！这样就能找到出现次数为双数的字符个数。
+统计字符出现的次数即可，双数才能构成回文。因为允许中间一个数单独出现，比如“abcba”，所以如果最后有字母落单，总长度可以加 1。首先将字符串转变为字符数组。然后遍历该数组，判断对应字符是否在 hashset 中，如果不在就加进去，如果在就让 count++，然后移除该字符！这样就能找到出现次数为双数的字符个数。
 
 ```java
 //https://leetcode-cn.com/problems/longest-palindrome/description/
@@ -210,7 +204,6 @@ class Solution {
 }
 ```
 
-
 ### 4.2. 验证回文串
 
 > LeetCode: 给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。 说明：本题中，我们将空字符串定义为有效的回文串。
@@ -255,10 +248,9 @@ class Solution {
 }
 ```
 
-
 ### 4.3. 最长回文子串
 
-> Leetcode: LeetCode: 最长回文子串 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。
+> Leetcode: LeetCode: 最长回文子串 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
 
 示例 1：
 
@@ -308,10 +300,10 @@ class Solution {
 ### 4.4. 最长回文子序列
 
 > LeetCode: 最长回文子序列
-给定一个字符串s，找到其中最长的回文子序列。可以假设s的最大长度为1000。
-**最长回文子序列和上一题最长回文子串的区别是，子串是字符串中连续的一个序列，而子序列是字符串中保持相对位置的字符序列，例如，"bbbb"可以是字符串"bbbab"的子序列但不是子串。**
+> 给定一个字符串 s，找到其中最长的回文子序列。可以假设 s 的最大长度为 1000。
+> **最长回文子序列和上一题最长回文子串的区别是，子串是字符串中连续的一个序列，而子序列是字符串中保持相对位置的字符序列，例如，"bbbb"可以是字符串"bbbab"的子序列但不是子串。**
 
-给定一个字符串s，找到其中最长的回文子序列。可以假设s的最大长度为1000。
+给定一个字符串 s，找到其中最长的回文子序列。可以假设 s 的最大长度为 1000。
 
 示例 1:
 
@@ -321,6 +313,7 @@ class Solution {
 输出:
 4
 ```
+
 一个可能的最长回文子序列为 "bbbb"。
 
 示例 2:
@@ -334,7 +327,7 @@ class Solution {
 
 一个可能的最长回文子序列为 "bb"。
 
-**动态规划：**  dp[i][j] = dp[i+1][j-1] + 2 if s.charAt(i) == s.charAt(j) otherwise, dp[i][j] = Math.max(dp[i+1][j], dp[i][j-1])
+**动态规划：** dp[i][j] = dp[i+1][j-1] + 2 if s.charAt(i) == s.charAt(j) otherwise, dp[i][j] = Math.max(dp[i+1][j], dp[i][j-1])
 
 ```java
 class Solution {
@@ -358,19 +351,21 @@ class Solution {
 ## 5. 括号匹配深度
 
 > 爱奇艺 2018 秋招 Java：
->一个合法的括号匹配序列有以下定义:
->1. 空串""是一个合法的括号匹配序列
->2.  如果"X"和"Y"都是合法的括号匹配序列,"XY"也是一个合法的括号匹配序列
->3. 如果"X"是一个合法的括号匹配序列,那么"(X)"也是一个合法的括号匹配序列
->4. 每个合法的括号序列都可以由以上规则生成。
+> 一个合法的括号匹配序列有以下定义:
+>
+> 1. 空串""是一个合法的括号匹配序列
+> 2. 如果"X"和"Y"都是合法的括号匹配序列,"XY"也是一个合法的括号匹配序列
+> 3. 如果"X"是一个合法的括号匹配序列,那么"(X)"也是一个合法的括号匹配序列
+> 4. 每个合法的括号序列都可以由以上规则生成。
 
 > 例如: "","()","()()","((()))"都是合法的括号序列
->对于一个合法的括号序列我们又有以下定义它的深度:
->1. 空串""的深度是0
->2. 如果字符串"X"的深度是x,字符串"Y"的深度是y,那么字符串"XY"的深度为max(x,y)   
->3. 如果"X"的深度是x,那么字符串"(X)"的深度是x+1
+> 对于一个合法的括号序列我们又有以下定义它的深度:
+>
+> 1.  空串""的深度是 0
+> 2.  如果字符串"X"的深度是 x,字符串"Y"的深度是 y,那么字符串"XY"的深度为 max(x,y)
+> 3.  如果"X"的深度是 x,那么字符串"(X)"的深度是 x+1
 
-> 例如: "()()()"的深度是1,"((()))"的深度是3。牛牛现在给你一个合法的括号序列,需要你计算出其深度。 
+> 例如: "()()()"的深度是 1,"((()))"的深度是 3。牛牛现在给你一个合法的括号序列,需要你计算出其深度。
 
 ```
 输入描述:
@@ -396,7 +391,7 @@ import java.util.Scanner;
 
 /**
  * https://www.nowcoder.com/test/8246651/summary
- * 
+ *
  * @author Snailclimb
  * @date 2018年9月6日
  * @Description: TODO 求给定合法括号序列的深度
@@ -422,7 +417,7 @@ public class Main {
 
 ## 6. 把字符串转换成整数
 
-> 剑指offer:  将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
+> 剑指 offer: 将一个字符串转换成一个整数(实现 Integer.valueOf(string)的功能，但是 string 不符合数字要求时返回 0)，要求不能使用字符串转换整数的库函数。 数值为 0 或者字符串不是一个合法的数值则返回 0。
 
 ```java
 //https://www.weiweiblog.cn/strtoint/