修改了目录结构

youyun · Feb 25, 2020 · 1bc5e8e · 1bc5e8e
1 parent 0ef8e04
commit 1bc5e8e
Show file tree

Hide file tree

Showing 46 changed files with 222 additions and 43 deletions.
diff --git a/README.md b/README.md
@@ -14,27 +14,36 @@
 
 # 二、文章目录
 
+* 第零章、必读系列
+ * [学习算法和刷题的思路指南](算法思维系列/学习数据结构和算法的高效方法.md)
+ * [学习数据结构和算法读什么书](算法思维系列/为什么推荐算法4.md)
+ * [动态规划详解](动态规划系列/动态规划详解进阶.md)
+ * [动态规划答疑篇](动态规划系列/最优子结构.md)
+ * [回溯算法详解](算法思维系列/回溯算法详解修订版.md)
+ * [二分查找详解](算法思维系列/二分查找详解.md)
+ * [双指针技巧总结](算法思维系列/双指针技巧.md)
+ * [滑动窗口技巧](算法思维系列/滑动窗口技巧.md)
+ * [Linux的进程、线程、文件描述符是什么](技术/linux进程.md)
+ * [Git/SQL/正则表达式的在线练习平台](技术/在线练习平台.md)
 * 第一章、动态规划系列
  * [动态规划详解](动态规划系列/动态规划详解进阶.md)
  * [动态规划答疑篇](动态规划系列/最优子结构.md)
  * [动态规划设计：最长递增子序列](动态规划系列/动态规划设计：最长递增子序列.md)
- * [经典动态规划：编辑距离](动态规划系列/编辑距离.md)
- * [经典动态规划：高楼扔鸡蛋](动态规划系列/高楼扔鸡蛋问题.md)
- * [经典动态规划：高楼扔鸡蛋（进阶）](动态规划系列/高楼扔鸡蛋进阶.md)
+ * [编辑距离](动态规划系列/编辑距离.md)
+ * [经典动态规划问题：高楼扔鸡蛋](动态规划系列/高楼扔鸡蛋问题.md)
+ * [经典动态规划问题：高楼扔鸡蛋（进阶）](动态规划系列/高楼扔鸡蛋进阶.md)
  * [动态规划之子序列问题解题模板](动态规划系列/子序列问题模板.md)
  * [动态规划之博弈问题](动态规划系列/动态规划之博弈问题.md)
+ * [贪心算法之区间调度问题](动态规划系列/贪心算法之区间调度问题.md)
  * [动态规划之KMP字符匹配算法](动态规划系列/动态规划之KMP字符匹配算法.md)
  * [团灭 LeetCode 股票买卖问题](动态规划系列/团灭股票问题.md)
  * [团灭 LeetCode 打家劫舍问题](动态规划系列/抢房子.md)
- * [贪心算法之区间调度问题](动态规划系列/贪心算法之区间调度问题.md)
  * [动态规划之四键键盘](动态规划系列/动态规划之四键键盘.md)
  * [动态规划之正则表达](动态规划系列/动态规划之正则表达.md)
  * [最长公共子序列](动态规划系列/最长公共子序列.md)
-
-
 * 第二章、数据结构系列
  * [学习算法和刷题的思路指南](算法思维系列/学习数据结构和算法的高效方法.md)
- * [学习数据结构和算法看什么书](算法思维系列/为什么推荐算法4.md)
+ * [学习数据结构和算法读什么书](算法思维系列/为什么推荐算法4.md)
  * [二叉堆详解实现优先级队列](数据结构系列/二叉堆详解实现优先级队列.md)
  * [LRU算法详解](高频面试系列/LRU算法.md)
  * [二叉搜索树操作集锦](数据结构系列/二叉搜索树操作集锦.md)
@@ -43,8 +52,6 @@
  * [设计Twitter](数据结构系列/设计Twitter.md)
  * [递归反转链表的一部分](数据结构系列/递归反转链表的一部分.md)
  * [队列实现栈\|栈实现队列](数据结构系列/队列实现栈栈实现队列.md)
-
-
 * 第三章、算法思维系列
  * [算法学习之路](算法思维系列/算法学习之路.md)
  * [回溯算法详解](算法思维系列/回溯算法详解修订版.md)
@@ -64,8 +71,6 @@
  * [几个反直觉的概率问题](算法思维系列/几个反直觉的概率问题.md)
  * [洗牌算法](算法思维系列/洗牌算法.md)
  * [递归详解](算法思维系列/递归详解.md)
-
-
 * 第四章、高频面试系列
  * [如何实现LRU算法](高频面试系列/LRU算法.md)
  * [如何高效寻找素数](高频面试系列/打印素数.md)
@@ -82,11 +87,14 @@
  * [如何调度考生的座位](高频面试系列/座位调度.md)
  * [Union-Find算法详解](算法思维系列/UnionFind算法详解.md)
  * [Union-Find算法应用](算法思维系列/UnionFind算法应用.md)
- * [什么是 session 和 cookie](技术/session和cookie.md)
- * [Linux的进程、线程、文件描述符是什么](技术/linux进程.md)
  * [一行代码就能解决的算法题](高频面试系列/一行代码解决的智力题.md)
- * [密码算法的前生今世](技术/密码技术.md)
  * [二分查找高效判定子序列](高频面试系列/二分查找判定子序列.md)
+* 第五章、计算机技术
+ * [Linux的进程、线程、文件描述符是什么](技术/linux进程.md)
+ * [一文看懂 session 和 cookie](技术/session和cookie.md)
+ * [关于 Linux shell 你必须知道的](技术/linuxsell.md)
+ * [加密算法的前身今世](技术/密码技术.md)
+ * [Git/SQL/正则表达式的在线练习平台](技术/在线练习平台.md)
 
 # Donate
 

diff --git a/pictures/table.jpg b/pictures/table.jpg
diff --git a/pictures/tableqr.jpg b/pictures/tableqr.jpg
diff --git a/pictures/开源社区做贡献/已添加作者.png b/pictures/开源社区做贡献/已添加作者.png
diff --git a/pictures/开源社区做贡献/未添加作者.png b/pictures/开源社区做贡献/未添加作者.png
diff --git a/pictures/开源社区做贡献/达克效应.jpg b/pictures/开源社区做贡献/达克效应.jpg
diff --git a/动态规划系列/动态规划之四键键盘.md b/动态规划系列/动态规划之四键键盘.md
@@ -166,4 +166,8 @@ def dp(n, a_num, copy):
 
 回顾第二种解法，我们稍加思考就能想到，最优的序列应该是这种形式：`A,A..C-A,C-C,C-V,C-V..C-A,C-C,C-V..`。
 
-根据这个事实，我们重新定义了状态，重新寻找了状态转移，从逻辑上减少了无效的子问题个数，从而提高了算法的效率。
+根据这个事实，我们重新定义了状态，重新寻找了状态转移，从逻辑上减少了无效的子问题个数，从而提高了算法的效率。
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/动态规划系列/动态规划设计：最长递增子序列.md b/动态规划系列/动态规划设计：最长递增子序列.md
@@ -180,4 +180,8 @@ public int lengthOfLIS(int[] nums) {
 
 这个解法确实很难想到。首先涉及数学证明，谁能想到按照这些规则执行，就能得到最长递增子序列呢？其次还有二分查找的运用，要是对二分查找的细节不清楚，给了思路也很难写对。
 
-所以，这个方法作为思维拓展好了。但动态规划的设计方法应该完全理解：假设之前的答案已知，利用数学归纳的思想正确进行状态的推演转移，最终得到答案。
+所以，这个方法作为思维拓展好了。但动态规划的设计方法应该完全理解：假设之前的答案已知，利用数学归纳的思想正确进行状态的推演转移，最终得到答案。
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/动态规划系列/抢房子.md b/动态规划系列/抢房子.md
@@ -224,3 +224,8 @@ int[] dp(TreeNode root) {
 
 实际上，这个解法比我们的解法运行时间要快得多，虽然算法分析层面时间复杂度是相同的。原因在于此解法没有使用额外的备忘录，减少了数据操作的复杂性，所以实际运行效率会快。
 
+
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/动态规划系列/最长公共子序列.md b/动态规划系列/最长公共子序列.md
@@ -115,3 +115,8 @@ else:
 
 找状态转移方程的方法是，思考每个状态有哪些「选择」，只要我们能用正确的逻辑做出正确的选择，算法就能够正确运行。
 
+
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/动态规划系列/高楼扔鸡蛋进阶.md b/动态规划系列/高楼扔鸡蛋进阶.md
@@ -261,4 +261,8 @@ while (lo < hi) {
 
 简单总结一下吧，第一个二分优化是利用了 `dp` 函数的单调性，用二分查找技巧快速搜索答案；第二种优化是巧妙地修改了状态转移方程，简化了求解了流程，但相应的，解题逻辑比较难以想到；后续还可以用一些数学方法和二分搜索进一步优化第二种解法，不过看了看镜子中的发量，算了。
 
-本文终，希望对你有一点启发。
+本文终，希望对你有一点启发。
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/技术/linux进程.md b/技术/linux进程.md
@@ -101,4 +101,8 @@ PS：不要忘了，Linux 中一切都被抽象成文件，设备也是文件，
 
 当然，必须要说明的是，只有 Linux 系统将线程看做共享数据的进程，不对其做特殊看待，其他的很多操作系统是对线程和进程区别对待的，线程有其特有的数据结构，我个人认为不如 Linux 的这种设计简洁，增加了系统的复杂度。
 
-在 Linux 中新建线程和进程的效率都是很高的，对于新建进程时内存区域拷贝的问题，Linux 采用了 copy-on-write 的策略优化，也就是并不真正复制父进程的内存空间，而是等到需要写操作时才去复制。**所以 Linux 中新建进程和新建线程都是很迅速的**。
+在 Linux 中新建线程和进程的效率都是很高的，对于新建进程时内存区域拷贝的问题，Linux 采用了 copy-on-write 的策略优化，也就是并不真正复制父进程的内存空间，而是等到需要写操作时才去复制。**所以 Linux 中新建进程和新建线程都是很迅速的**。
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/技术/redis入侵.md b/技术/redis入侵.md
@@ -76,4 +76,8 @@ Redis 监听的默认端口是 6379，我们设置它接收网卡 127.0.0.1 的
 
 2、配置服务器防火墙和 Redis 的 config 文件，尽量不要让 Redis 与外界接触。
 
-3、利用 rename 功能伪装 flushall 这种危险命令，以防被删库，丢失数据。
+3、利用 rename 功能伪装 flushall 这种危险命令，以防被删库，丢失数据。
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/技术/session和cookie.md b/技术/session和cookie.md
@@ -125,4 +125,8 @@ type Provider interface {
 
 https://github.com/alexedwards/scs
 
-https://github.com/astaxie/build-web-application-with-golang
+https://github.com/astaxie/build-web-application-with-golang
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/技术/在线练习平台.md b/技术/在线练习平台.md
@@ -89,3 +89,8 @@ SQLZOO 是一款很好用的 SQL 练习平台，英文不难理解，可以直
 网站地址：
 
 https://sqlzoo.net/
+
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/技术/密码技术.md b/技术/密码技术.md
@@ -172,4 +172,8 @@ RSA 算法作为经典的非对称加密算法，有两种用途：如果用于
 
 HTTPS 协议中的 SSL/TLS 安全层会组合使用以上几种加密方式，**所以说不要安装非正规的浏览器，不要乱安装未知来源的证书**。
 
-密码技术只是安全的一小部分，即便是通过正规机构认证的 HTTPS 站点，也不意味着可信任，只能说明其数据传输是安全的。技术永远不可能真正保护你，最重要的还是得提高个人的安全防范意识，多留心眼儿，谨慎处理敏感数据。
+密码技术只是安全的一小部分，即便是通过正规机构认证的 HTTPS 站点，也不意味着可信任，只能说明其数据传输是安全的。技术永远不可能真正保护你，最重要的还是得提高个人的安全防范意识，多留心眼儿，谨慎处理敏感数据。
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/数据结构系列/二叉搜索树操作集锦.md b/数据结构系列/二叉搜索树操作集锦.md
@@ -270,3 +270,8 @@ void BST(TreeNode root, int target) {
 
 4. 掌握了 BST 的基本操作。
 
+
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/数据结构系列/单调队列.md b/数据结构系列/单调队列.md
@@ -178,4 +178,8 @@ vector<int> maxSlidingWindow(vector<int>& nums, int k) {
 
 单调队列在添加元素的时候靠删除元素保持队列的单调性，相当于抽取出某个函数中单调递增（或递减）的部分；而优先级队列（二叉堆）相当于自动排序，差别大了去了。
 
-赶紧去拿下 LeetCode 第 239 道题吧～
+赶紧去拿下 LeetCode 第 239 道题吧～
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/数据结构系列/设计Twitter.md b/数据结构系列/设计Twitter.md
@@ -270,4 +270,8 @@ public List<Integer> getNewsFeed(int userId) {
 
 最后，Github 上有一个优秀的开源项目，专门收集了很多大型系统设计的案例和解析，而且有中文版本，上面这个图也出自该项目。对系统设计感兴趣的读者可以点击「阅读原文」查看。
 
-PS：本文前两张图片和 GIF 是我第一次尝试用平板的绘图软件制作的，花了很多时间，尤其是 GIF 图，需要一帧一帧制作。如果本文内容对你有帮助，点个赞分个享，鼓励一下我呗！
+PS：本文前两张图片和 GIF 是我第一次尝试用平板的绘图软件制作的，花了很多时间，尤其是 GIF 图，需要一帧一帧制作。如果本文内容对你有帮助，点个赞分个享，鼓励一下我呗！
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/数据结构系列/递归反转链表的一部分.md b/数据结构系列/递归反转链表的一部分.md
@@ -186,4 +186,8 @@ ListNode reverseBetween(ListNode head, int m, int n) {
 
 处理看起来比较困难的问题，可以尝试化整为零，把一些简单的解法进行修改，解决困难的问题。
 
-值得一提的是，递归操作链表并不高效。和迭代解法相比，虽然时间复杂度都是 O(N)，但是迭代解法的空间复杂度是 O(1)，而递归解法需要堆栈，空间复杂度是 O(N)。所以递归操作链表可以作为对递归算法的练习或者拿去和小伙伴装逼，但是考虑效率的话还是使用迭代算法更好。
+值得一提的是，递归操作链表并不高效。和迭代解法相比，虽然时间复杂度都是 O(N)，但是迭代解法的空间复杂度是 O(1)，而递归解法需要堆栈，空间复杂度是 O(N)。所以递归操作链表可以作为对递归算法的练习或者拿去和小伙伴装逼，但是考虑效率的话还是使用迭代算法更好。
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/数据结构系列/队列实现栈栈实现队列.md b/数据结构系列/队列实现栈栈实现队列.md
@@ -196,4 +196,8 @@ public boolean empty() {
 
 从栈 `s1` 搬运元素到 `s2` 之后，元素在 `s2` 中就变成了队列的先进先出顺序，这个特性有点类似「负负得正」，确实不太容易想到。
 
-希望本文对你有帮助。
+希望本文对你有帮助。
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/算法思维系列/FloodFill算法详解及应用.md b/算法思维系列/FloodFill算法详解及应用.md
@@ -214,3 +214,8 @@ int fill(int[][] image, int x, int y,
 
 
 
+
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/算法思维系列/UnionFind算法应用.md b/算法思维系列/UnionFind算法应用.md
@@ -216,3 +216,8 @@ boolean equationsPossible(String[] equations) {
 
 很多更复杂的 DFS 算法问题，都可以利用 Union-Find 算法更漂亮的解决。LeetCode 上 Union-Find 相关的问题也就二十多道，有兴趣的读者可以去做一做。
 
+
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/算法思维系列/twoSum问题的核心思想.md b/算法思维系列/twoSum问题的核心思想.md
@@ -151,3 +151,8 @@ int[] twoSum(int[] nums, int target) {
 }
 ```
 
+
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/算法思维系列/信封嵌套问题.md b/算法思维系列/信封嵌套问题.md
@@ -103,4 +103,8 @@ public int lengthOfLIS(int[] nums) {
 
 实际上，这个思路是错误的。这类问题叫做「偏序问题」，上升到三维会使难度巨幅提升，需要借助一种高级数据结构「树状数组」，有兴趣的读者可以自行搜索。
 
-有很多算法问题都需要排序后进行处理，阿东正在进行整理总结。希望本文对你有帮助。
+有很多算法问题都需要排序后进行处理，阿东正在进行整理总结。希望本文对你有帮助。
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/算法思维系列/几个反直觉的概率问题.md b/算法思维系列/几个反直觉的概率问题.md
@@ -112,4 +112,8 @@ $P(两次能中奖) = P(第一次就中了) + P(第一次没中但第二次中
 
 因为按照刚才「浓缩」概率这个思想，只要进行了排除，都是在进行「浓缩」，均摊下来肯定比你一开始蒙的那个答案概率 1/4 高。比如刚才的例子，C 和 D 的正确概率都是 3/8，而你开始蒙的 A 只有 1/4。
 
-当然，运用此策略蒙题的前提是你真的抓瞎，真的随机乱选答案，这样概率才能作为最后的杀手锏。
+当然，运用此策略蒙题的前提是你真的抓瞎，真的随机乱选答案，这样概率才能作为最后的杀手锏。
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/算法思维系列/前缀和技巧.md b/算法思维系列/前缀和技巧.md
@@ -127,4 +127,8 @@ for (int i = 1; i < count.length; i++)
 
 但是，稍微复杂一些的算法问题，不止考察简单的前缀和技巧。比如本文探讨的这道题目，就需要借助前缀和的思路做进一步的优化，借助哈希表去除不必要的嵌套循环。可见对题目的理解和细节的分析能力对于算法的优化是至关重要的。
 
-希望本文对你有帮助。
+希望本文对你有帮助。
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/算法思维系列/区间交集问题.md b/算法思维系列/区间交集问题.md
@@ -101,4 +101,8 @@ def intervalIntersection(A, B):
 
 总结一下，区间类问题看起来都比较复杂，情况很多难以处理，但实际上通过观察各种不同情况之间的共性可以发现规律，用简洁的代码就能处理。
 
-另外，区间问题没啥特别厉害的奇技淫巧，其操作也朴实无华，但其应用却十分广泛，接之前的几篇文章：
+另外，区间问题没啥特别厉害的奇技淫巧，其操作也朴实无华，但其应用却十分广泛，接之前的几篇文章：
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)
diff --git a/算法思维系列/区间调度问题之区间合并.md b/算法思维系列/区间调度问题之区间合并.md
@@ -59,4 +59,8 @@ def merge(intervals):
 
 至此，区间合并问题就解决了。本文篇幅短小，因为区间合并只是区间问题的一个类型，后续还有一些区间问题。本想把所有问题类型都总结在一篇文章，但有读者反应，长文只会收藏不会看... 所以还是分成小短文吧，读者有什么看法可以在留言板留言交流。
 
-本文终，希望对你有帮助。
+本文终，希望对你有帮助。
+
+坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：
+
+![labuladong](../pictures/labuladong.jpg)