整理范式顺序

diguage · diguage · commit 958c3eeae92e · 2024-08-23T16:16:43.000+08:00
diff --git a/docs/0000-00-note.adoc b/docs/0000-00-note.adoc
@@ -24,7 +24,7 @@ image::images/quick-sort-01.gif[{image_attr}]
 
 == 解题范式
 
-. xref:0000-02-two-pointer.adoc[Two Pointer 双指针]
+. xref:0000-06-two-pointer.adoc[Two Pointer 双指针]
 .. Pair with Target Sum (easy)
 .. Find Non-Duplicate Number Instances (easy)
 .. Squaring a Sorted Array (easy)
@@ -36,15 +36,15 @@ image::images/quick-sort-01.gif[{image_attr}]
 .. Problem Challenge 1: Quadruple Sum to Target (medium)
 .. Problem Challenge 2: Comparing Strings containing Backspaces (medium)
 .. Problem Challenge 3: Minimum Window Sort (medium)
-. xref:0000-03-fast-slow-pointers.adoc[Fast & Slow Pointers 快慢指针]
+. xref:0000-07-fast-slow-pointers.adoc[Fast & Slow Pointers 快慢指针]
 .. LinkedList Cycle (easy)
 .. Middle of the LinkedList (easy)
 .. Start of LinkedList Cycle (medium)
 .. Happy Number (medium)
 .. Problem Challenge 1: Palindrome LinkedList (medium)
 .. Problem Challenge 2: Rearrange a LinkedList (medium)
 .. Problem Challenge 3: Cycle in a Circular Array (hard)
-. xref:0000-01-sliding-window.adoc[Sliding Window 滑动窗口]
+. xref:0000-08-sliding-window.adoc[Sliding Window 滑动窗口]
 .. Maximum Sum Subarray of Size K  (easy)
 .. Smallest Subarray With a Greater Sum (easy)
 .. Longest Substring with K Distinct Characters (medium)
@@ -63,7 +63,7 @@ image::images/quick-sort-01.gif[{image_attr}]
 .. Problem Challenge 1: Minimum Meeting Rooms (hard)
 .. Problem Challenge 2: Maximum CPU Load (hard)
 .. Problem Challenge 3: Employee Free Time (hard)
-. xref:0000-05-cyclic-sort.adoc[Cyclic Sort 循环排序]
+. xref:0000-11-cyclic-sort.adoc[Cyclic Sort 循环排序]
 .. Cyclic Sort (easy)
 .. Find the Missing Number (easy)
 .. Find all Missing Numbers (easy)
@@ -72,7 +72,7 @@ image::images/quick-sort-01.gif[{image_attr}]
 .. Problem Challenge 1: Find the Corrupt Pair (easy)
 .. Problem Challenge 2: xref:0041-first-missing-positive.adoc[41. First Missing Positive]
 .. Problem Challenge 3: xref:1539-kth-missing-positive-number.adoc[1539. Kth Missing Positive Number]
-. xref:0000-06-reversed-list.adoc[In-place Reversal of a LinkedList 原地链表翻转]
+. xref:0000-05-reversed-list.adoc[In-place Reversal of a LinkedList 原地链表翻转]
 .. Reverse a LinkedList (easy)
 .. Reverse a Sub-list (medium)
 .. Reverse every K-element Sub-list (medium)
@@ -88,7 +88,7 @@ image::images/quick-sort-01.gif[{image_attr}]
 .. Problem 4: Next Greater Element
 .. Problem 5: Sorting a Stack
 .. Problem 6: Simplify Path
-. xref:0000-23-monotonic-stack.adoc[Monotonic Stack 单调栈]
+. xref:0000-09-monotonic-stack.adoc[Monotonic Stack 单调栈]
 .. Remove Nodes From Linked List (medium)
 .. Remove All Adjacent Duplicates In String (easy)
 .. Next Greater Element (easy)
@@ -103,7 +103,7 @@ image::images/quick-sort-01.gif[{image_attr}]
 .. Problem 3: Maximum Number of Balloons (easy)
 .. Problem 4: Longest Palindrome(easy)
 .. Problem 5: Ransom Note (easy)
-. xref:0000-07-breadth-first-search.adoc[Breadth First Search 广度优先搜索]
+. xref:0000-14-breadth-first-search.adoc[Breadth First Search 广度优先搜索]
 .. Binary Tree Level Order Traversal (easy)
 .. Reverse Level Order Traversal (easy)
 .. Zigzag Traversal (medium)
@@ -113,7 +113,7 @@ image::images/quick-sort-01.gif[{image_attr}]
 .. Connect Level Order Siblings (medium)
 .. Problem Challenge 1: Connect All Level Order Siblings (medium)
 .. Problem Challenge 2: Right View of a Binary Tree (easy)
-. xref:0000-08-depth-first-search.adoc[Depth First Search 深度优先搜索]
+. xref:0000-15-depth-first-search.adoc[Depth First Search 深度优先搜索]
 .. Binary Tree Path Sum (easy)
 .. All Paths for a Sum (medium)
 .. Sum of Path Numbers (medium)
@@ -137,12 +137,12 @@ image::images/quick-sort-01.gif[{image_attr}]
 .. Problem Challenge 1 (easy)
 .. Problem Challenge 2 (medium)
 .. Problem Challenge 3 (medium)
-. xref:0000-09-two-heaps.adoc[Two Heaps 双堆]
+. xref:0000-12-two-heaps.adoc[Two Heaps 双堆]
 .. Find the Median of a Number Stream (medium)
 .. Sliding Window Median (hard)
 .. Maximize Capital (hard)
 .. Problem Challenge 1: Next Interval (hard)
-. xref:0000-10-subsets.adoc[Subsets 子集]
+. xref:0000-24-subsets.adoc[Subsets 子集]
 .. Subsets (easy)
 .. Subsets With Duplicates (easy)
 .. Permutations (medium)
@@ -152,7 +152,7 @@ image::images/quick-sort-01.gif[{image_attr}]
 .. Problem Challenge 1: Evaluate Expression (hard)
 .. Problem Challenge 2: Structurally Unique Binary Search Trees (hard)
 .. Problem Challenge 3: Count of Structurally Unique Binary Search Trees (hard)
-. xref:0000-11-modified-binary-search.adoc[Modified Binary Search 改造过的二分搜索]
+. xref:0000-01-modified-binary-search.adoc[Modified Binary Search 改造过的二分搜索]
 .. Order-agnostic Binary Search (easy)
 .. Ceiling of a Number (medium)
 .. Next Letter (medium)
@@ -168,7 +168,7 @@ image::images/quick-sort-01.gif[{image_attr}]
 .. Two Single Numbers (medium)
 .. Complement of Base 10 Number (medium)
 .. Problem Challenge 1: Flip and Invert an Image (hard)
-. xref:0000-12-top-k-elements.adoc[Top 'K' Elements 顶端 K 元素]
+. xref:0000-10-top-k-elements.adoc[Top 'K' Elements 顶端 K 元素]
 .. Top 'K' Numbers (easy)
 .. Kth Smallest Number (easy)
 .. 'K' Closest Points to the Origin (easy)
@@ -183,41 +183,41 @@ image::images/quick-sort-01.gif[{image_attr}]
 .. Problem Challenge 1: Rearrange String K Distance Apart (hard)
 .. Problem Challenge 2: Scheduling Tasks (hard)
 .. Problem Challenge 3: Frequency Stack (hard)
-. xref:0000-16-greedy.adoc[Greedy Algorithms 贪心算法]
+. xref:0000-25-greedy.adoc[Greedy Algorithms 贪心算法]
 .. Valid Palindrome II (easy)
 .. Maximum Length of Pair Chain (medium)
 .. Minimum Add to Make Parentheses Valid (medium)
 .. Remove Duplicate Letters (medium)
 .. Largest Palindromic Number (medium)
 .. Removing Minimum and Maximum From Array  (medium)
-. xref:0000-21-dynamic-programming.adoc[Dynamic Programming 动态规划]
+. xref:0000-26-dynamic-programming.adoc[Dynamic Programming 动态规划]
 .. 0/1 Knapsack (medium)
 .. Equal Subset Sum Partition (medium)
 .. Subset Sum (medium)
 .. Minimum Subset Sum Difference (hard)
 .. Problem Challenge 1: Count of Subset Sum (hard)
 .. Problem Challenge 2: Target Sum (hard)
-. xref:0000-15-backtrack.adoc[Backtracking 回溯]
+. xref:0000-23-backtrack.adoc[Backtracking 回溯]
 .. Combination Sum (medium)
 .. Word Search (medium)
 .. Factor Combinations (medium)
 .. Split a String Into the Max Number of Unique Substrings (medium)
 .. Sudoku Solver  (hard)
-. xref:0000-26-trie.adoc[Trie 前缀树]
+. xref:0000-16-trie.adoc[Trie 前缀树]
 .. Implement Trie (Prefix Tree) (medium)
 .. Index Pairs of a String (easy)
 .. Design Add and Search Words Data Structure (medium)
 .. Extra Characters in a String (medium)
 .. Search Suggestions System (medium)
-. xref:0000-14-topological-sort.adoc[Topological Sort (Graph) 拓扑排序]
+. xref:0000-18-topological-sort.adoc[Topological Sort (Graph) 拓扑排序]
 .. Topological Sort (medium)
 .. Tasks Scheduling (medium)
 .. Tasks Scheduling Order (medium)
 .. All Tasks Scheduling Orders (hard)
 .. Alien Dictionary (hard)
 .. Problem Challenge 1: Reconstructing a Sequence (hard)
 .. Problem Challenge 2: Minimum Height Trees (hard)
-. xref:0000-22-union-find-set.adoc[Union Find Set 查并集]
+. xref:0000-17-union-find-set.adoc[Union Find Set 查并集]
 .. Redundant Connection (medium)
 .. Number of Provinces (medium)
 .. Is Graph Bipartite? (medium)
@@ -227,15 +227,15 @@ image::images/quick-sort-01.gif[{image_attr}]
 .. 132 Pattern (medium)
 .. My Calendar I (medium)
 .. Longest Continuous Subarray (medium)
-. xref:0000-25-prefix-sum.adoc[Prefix Sum 前缀和]
+. xref:0000-03-prefix-sum.adoc[Prefix Sum 前缀和]
 .. Find the Middle Index in Array (easy)
 .. Left and Right Sum Differences (easy)
 .. Maximum Size Subarray Sum Equals k (medium)
 .. Binary Subarrays With Sum (medium)
 .. Subarray Sums Divisible by K (medium)
 .. Sum of Absolute Differences in a Sorted Array (medium)
 .. Subarray Sum Equals K (medium)
-. xref:0000-24-difference-array.adoc[Difference Array 差分数组]
+. xref:0000-02-difference-array.adoc[Difference Array 差分数组]
 . Multi-threaded
 .. Same Tree (medium)
 .. Invert Binary Tree (medium)
diff --git a/docs/0000-01-modified-binary-search.adoc b/docs/0000-01-modified-binary-search.adoc
@@ -1,4 +1,4 @@
-[#0000-11-modified-binary-search]
+[#0000-01-modified-binary-search]
 = Modified Binary Search 改造过的二分搜索
 
 当你需要解决的问题的输入是排好序的数组，链表，或是排好序的矩阵，要求咱们寻找某些特定元素。这个时候的不二选择就是二分搜索。这种模式是一种超级牛的用二分来解决问题的方式。
diff --git a/docs/0000-02-difference-array.adoc b/docs/0000-02-difference-array.adoc
@@ -1,4 +1,4 @@
-[#0000-24-difference-array]
+[#0000-02-difference-array]
 = Difference Array 差分数组
 
 
diff --git a/docs/0000-03-prefix-sum.adoc b/docs/0000-03-prefix-sum.adoc
@@ -1,4 +1,4 @@
-[#0000-25-prefix-sum]
+[#0000-03-prefix-sum]
 = Prefix Sum 前缀和
 
 
diff --git a/docs/0000-05-reversed-list.adoc b/docs/0000-05-reversed-list.adoc
@@ -1,4 +1,4 @@
-[#0000-06-reversed-list]
+[#0000-05-reversed-list]
 = In-place Reversal of a LinkedList 原地链表翻转
 
 在众多问题中，题目可能需要你去翻转链表中某一段的节点。通常，要求都是你得原地翻转，就是重复使用这些已经建好的节点，而不使用额外的空间。这个时候，原地翻转模式就要发挥威力了。
diff --git a/docs/0000-06-two-pointer.adoc b/docs/0000-06-two-pointer.adoc
@@ -1,4 +1,4 @@
-[#0000-02-two-pointer]
+[#0000-06-two-pointer]
 = Two Pointer 双指针
 
 双指针是这样的模式：两个指针朝着左右方向移动（双指针分为同向双指针和异向双指针），直到他们有一个或是两个都满足某种条件。双指针通常用在排好序的数组或是链表中寻找对子。比如，你需要去比较数组中每个元素和其他元素的关系时，你就需要用到双指针了。
diff --git a/docs/0000-07-fast-slow-pointers.adoc b/docs/0000-07-fast-slow-pointers.adoc
@@ -1,4 +1,4 @@
-[#0000-03-fast-slow-pointers]
+[#0000-07-fast-slow-pointers]
 = Fast & Slow Pointers 快慢指针
 
 这种模式，有一个非常出门的名字，叫龟兔赛跑。咱们肯定都知道龟兔赛跑啦。但还是再解释一下快慢指针：这种算法的两个指针的在数组上（或是链表上，序列上）的移动速度不一样。还别说，这种方法在解决有环的链表和数组时特别有用。
diff --git a/docs/0000-08-sliding-window.adoc b/docs/0000-08-sliding-window.adoc
@@ -1,4 +1,4 @@
-[#0000-01-sliding-window]
+[#0000-08-sliding-window]
 = Sliding Window 滑动窗口
 
 滑动窗口类型的题目经常是用来执行数组或是链表上某个区间（窗口）上的操作。比如找最长的全为1的子数组长度。滑动窗口一般从第一个元素开始，一直往右边一个一个元素挪动。当然了，根据题目要求，我们可能有固定窗口大小的情况，也有窗口的大小变化的情况。
diff --git a/docs/0000-09-monotonic-stack.adoc b/docs/0000-09-monotonic-stack.adoc
@@ -1,4 +1,4 @@
-[#0000-23-monotonic-stack]
+[#0000-09-monotonic-stack]
 = Monotonic Stack 单调栈
 
 == 基本流程
diff --git a/docs/0000-10-top-k-elements.adoc b/docs/0000-10-top-k-elements.adoc
@@ -1,4 +1,4 @@
-[#0000-12-top-k-elements]
+[#0000-10-top-k-elements]
 = Top 'K' Elements 顶端 K 元素
 
 任何让我们求解最大/最小/最频繁的K个元素的题，都遵循这种模式。
diff --git a/docs/0000-11-cyclic-sort.adoc b/docs/0000-11-cyclic-sort.adoc
@@ -1,4 +1,4 @@
-[#0000-05-cyclic-sort]
+[#0000-11-cyclic-sort]
 = Cyclic Sort 循环排序
 
 这种模式讲述的是一直很好玩的方法：可以用来处理数组中的数值限定在一定的区间的问题。这种模式一个个遍历数组中的元素，如果当前这个数它不在其应该在的位置的话，咱们就把它和它应该在的那个位置上的数交换一下。你可以尝试将该数放到其正确的位置上，但这复杂度就会是O(n^2^)。这样的话，可能就不是最优解了。因此循环排序的优势就体现出来了。
diff --git a/docs/0000-12-two-heaps.adoc b/docs/0000-12-two-heaps.adoc
@@ -1,4 +1,4 @@
-[#0000-09-two-heaps]
+[#0000-12-two-heaps]
 = Two Heaps 双堆
 
 很多问题中，我们被告知，我们拿到一大把可以分成两队的数字。为了解决这个问题，我们感兴趣的是，怎么把数字分成两半？使得：小的数字都放在一起，大的放在另外一半。双堆模式就能高效解决此类问题。
diff --git a/docs/0000-14-breadth-first-search.adoc b/docs/0000-14-breadth-first-search.adoc
@@ -1,4 +1,4 @@
-[#0000-07-breadth-first-search]
+[#0000-14-breadth-first-search]
 = Breadth First Search 广度优先搜索
 
 == Tree Breadth First Search，树上的BFS
diff --git a/docs/0000-15-depth-first-search.adoc b/docs/0000-15-depth-first-search.adoc
@@ -1,4 +1,4 @@
-[#0000-08-depth-first-search]
+[#0000-15-depth-first-search]
 = Depth First Search 深度优先搜索
 
 == Tree Depth First Search，树上的DFS
diff --git a/docs/0000-16-trie.adoc b/docs/0000-16-trie.adoc
@@ -1,4 +1,4 @@
-[#0000-26-trie]
+[#0000-16-trie]
 = Trie 前缀树
 
 
diff --git a/docs/0000-17-union-find-set.adoc b/docs/0000-17-union-find-set.adoc
@@ -1,4 +1,4 @@
-[#0000-22-union-find-set]
+[#0000-17-union-find-set]
 = Union Find Set 查并集
 
 
diff --git a/docs/0000-18-topological-sort.adoc b/docs/0000-18-topological-sort.adoc
@@ -1,4 +1,4 @@
-[#0000-14-topological-sort]
+[#0000-18-topological-sort]
 = Topological Sort (Graph) 拓扑排序
 
 拓扑排序模式用来寻找一种线性的顺序，这些元素之间具有依懒性。比如，如果事件B依赖于事件A，那A在拓扑排序顺序中排在B的前面。
diff --git a/docs/0000-19-brute-force.adoc b/docs/0000-19-brute-force.adoc
@@ -1,4 +1,4 @@
-[#0000-17-brute-force]
-= Brute Force，暴力破解
+[#0000-19-brute-force]
+= Brute Force 暴力破解
 
 选择排序，冒泡排序，在有序数组中的顺序查找等等都属于暴力破解的解法。
diff --git a/docs/0000-20-decrease-and-conquer.adoc b/docs/0000-20-decrease-and-conquer.adoc
@@ -1,3 +1,3 @@
-[#0000-18-decrease-and-conquer]
+[#0000-20-decrease-and-conquer]
 = Decrease and Conquer，减治法
 
diff --git a/docs/0000-21-divide-and-conquer.adoc b/docs/0000-21-divide-and-conquer.adoc
@@ -1,3 +1,3 @@
-[#0000-19-divide-and-conquer]
+[#0000-21-divide-and-conquer]
 = Divide and Conquer，分治法
 
diff --git a/docs/0000-22-transform-and-conquer.adoc b/docs/0000-22-transform-and-conquer.adoc
@@ -1,2 +1,2 @@
-[#0000-20-transform-and-conquer]
+[#0000-22-transform-and-conquer]
 = Transform and Conquer，变知法
diff --git a/docs/0000-23-backtrack.adoc b/docs/0000-23-backtrack.adoc
@@ -1,4 +1,4 @@
-[#0000-15-backtrack]
+[#0000-23-backtrack]
 = Backtracking 回溯
 
 参考 xref:0046-permutations.adoc[46. Permutations] 认真学习一下回溯思想。
diff --git a/docs/0000-24-subsets.adoc b/docs/0000-24-subsets.adoc
@@ -1,4 +1,4 @@
-[#0000-10-subsets]
+[#0000-24-subsets]
 = Subsets 子集
 
 一般都是使用多重DFS
diff --git a/docs/0000-25-greedy.adoc b/docs/0000-25-greedy.adoc
@@ -1,2 +1,2 @@
-[#0000-16-greedy]
+[#0000-25-greedy]
 = Greedy Algorithms 贪心算法
diff --git a/docs/0000-26-dp-1-0-1-knapsack.adoc b/docs/0000-26-dp-1-0-1-knapsack.adoc
@@ -1,4 +1,4 @@
-[#0000-21-dp-1-0-1-knapsack]
+[#0000-26-dp-1-0-1-knapsack]
 = 0/1 Knapsack 0/1 背包
 
 == 经典题目
diff --git a/docs/0000-26-dp-2-unbounded-knapsack.adoc b/docs/0000-26-dp-2-unbounded-knapsack.adoc
@@ -1,4 +1,4 @@
-[#0000-21-dp-2-unbounded-knapsack]
+[#0000-26-dp-2-unbounded-knapsack]
 = Unbounded Knapsack 无限背包
 
 
diff --git a/docs/0000-26-dp-3-fibonacci-numbers.adoc b/docs/0000-26-dp-3-fibonacci-numbers.adoc
@@ -1,4 +1,4 @@
-[#0000-21-dp-3-fibonacci-numbers]
+[#0000-26-dp-3-fibonacci-numbers]
 = Fibonacci Numbers 斐波那契数列
 
 
diff --git a/docs/0000-26-dp-4-palindromic-subsequence.adoc b/docs/0000-26-dp-4-palindromic-subsequence.adoc
@@ -1,4 +1,4 @@
-[#0000-21-dp-4-palindromic-subsequence]
+[#0000-26-dp-4-palindromic-subsequence]
 = Palindromic Subsequence 回文子系列
 
 
diff --git a/docs/0000-26-dp-5-longest-common-substring.adoc b/docs/0000-26-dp-5-longest-common-substring.adoc
@@ -1,4 +1,4 @@
-[#0000-21-dp-5-longest-common-substring]
+[#0000-26-dp-5-longest-common-substring]
 = Longest Common Substring 最长子字符串系列
 
 == 经典题目
diff --git a/docs/0000-26-dynamic-programming.adoc b/docs/0000-26-dynamic-programming.adoc
@@ -1,15 +1,15 @@
-[#0000-21-dynamic-programming]
+[#0000-26-dynamic-programming]
 = Dynamic Programming 动态规划
 
-include::0000-21-dp-1-0-1-knapsack.adoc[leveloffset=+1]
+include::0000-26-dp-1-0-1-knapsack.adoc[leveloffset=+1]
 
-include::0000-21-dp-2-unbounded-knapsack.adoc[leveloffset=+1]
+include::0000-26-dp-2-unbounded-knapsack.adoc[leveloffset=+1]
 
-include::0000-21-dp-3-fibonacci-numbers.adoc[leveloffset=+1]
+include::0000-26-dp-3-fibonacci-numbers.adoc[leveloffset=+1]
 
-include::0000-21-dp-4-palindromic-subsequence.adoc[leveloffset=+1]
+include::0000-26-dp-4-palindromic-subsequence.adoc[leveloffset=+1]
 
-include::0000-21-dp-5-longest-common-substring.adoc[leveloffset=+1]
+include::0000-26-dp-5-longest-common-substring.adoc[leveloffset=+1]
 
 
 [#tree-dp-trick]
diff --git a/docs/0000-data-structure-list.adoc b/docs/0000-data-structure-list.adoc
@@ -5,15 +5,15 @@
 
 === 前缀和
 
-详情见 xref:0000-25-prefix-sum.adoc[Prefix Sum 前缀和]
+详情见 xref:0000-03-prefix-sum.adoc[Prefix Sum 前缀和]
 
 === 差分数组
 
-详情见 xref:0000-24-difference-array.adoc[Difference Array 差分数组]
+详情见 xref:0000-02-difference-array.adoc[Difference Array 差分数组]
 
 === 单调栈
 
-详情见 xref:0000-23-monotonic-stack.adoc[Monotonic Stack 单调栈]
+详情见 xref:0000-09-monotonic-stack.adoc[Monotonic Stack 单调栈]
 
 
 
diff --git a/docs/0110-balanced-binary-tree.adoc b/docs/0110-balanced-binary-tree.adoc
@@ -67,7 +67,7 @@ include::{sourcedir}/_0110_BalancedBinaryTree.java[tag=answer]
 
 == 基于树形 DP 套路解法
 
-这个解法参考了：xref:0000-21-dynamic-programming.adoc[动态规划] 中介绍的 “树形 DP 套路” 解法。
+这个解法参考了：xref:0000-26-dynamic-programming.adoc[动态规划] 中介绍的 “树形 DP 套路” 解法。
 
 [{java_src_attr}]
 ----
diff --git a/docs/index.adoc b/docs/index.adoc
diff --git a/tools/6-add-anchors.sh b/tools/6-add-anchors.sh

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-[#0000-11-modified-binary-search]`
	`1`	`+[#0000-01-modified-binary-search]`
`2`	`2`	`= Modified Binary Search 改造过的二分搜索`
`3`	`3`
`4`	`4`	`当你需要解决的问题的输入是排好序的数组，链表，或是排好序的矩阵，要求咱们寻找某些特定元素。这个时候的不二选择就是二分搜索。这种模式是一种超级牛的用二分来解决问题的方式。`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-[#0000-24-difference-array]`
	`1`	`+[#0000-02-difference-array]`
`2`	`2`	`= Difference Array 差分数组`
`3`	`3`
`4`	`4`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-[#0000-25-prefix-sum]`
	`1`	`+[#0000-03-prefix-sum]`
`2`	`2`	`= Prefix Sum 前缀和`
`3`	`3`
`4`	`4`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-[#0000-06-reversed-list]`
	`1`	`+[#0000-05-reversed-list]`
`2`	`2`	`= In-place Reversal of a LinkedList 原地链表翻转`
`3`	`3`
`4`	`4`	`在众多问题中，题目可能需要你去翻转链表中某一段的节点。通常，要求都是你得原地翻转，就是重复使用这些已经建好的节点，而不使用额外的空间。这个时候，原地翻转模式就要发挥威力了。`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-[#0000-02-two-pointer]`
	`1`	`+[#0000-06-two-pointer]`
`2`	`2`	`= Two Pointer 双指针`
`3`	`3`
`4`	`4`	`双指针是这样的模式：两个指针朝着左右方向移动（双指针分为同向双指针和异向双指针），直到他们有一个或是两个都满足某种条件。双指针通常用在排好序的数组或是链表中寻找对子。比如，你需要去比较数组中每个元素和其他元素的关系时，你就需要用到双指针了。`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-[#0000-03-fast-slow-pointers]`
	`1`	`+[#0000-07-fast-slow-pointers]`
`2`	`2`	`= Fast & Slow Pointers 快慢指针`
`3`	`3`
`4`	`4`	`这种模式，有一个非常出门的名字，叫龟兔赛跑。咱们肯定都知道龟兔赛跑啦。但还是再解释一下快慢指针：这种算法的两个指针的在数组上（或是链表上，序列上）的移动速度不一样。还别说，这种方法在解决有环的链表和数组时特别有用。`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-[#0000-01-sliding-window]`
	`1`	`+[#0000-08-sliding-window]`
`2`	`2`	`= Sliding Window 滑动窗口`
`3`	`3`
`4`	`4`	`滑动窗口类型的题目经常是用来执行数组或是链表上某个区间（窗口）上的操作。比如找最长的全为1的子数组长度。滑动窗口一般从第一个元素开始，一直往右边一个一个元素挪动。当然了，根据题目要求，我们可能有固定窗口大小的情况，也有窗口的大小变化的情况。`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-[#0000-23-monotonic-stack]`
	`1`	`+[#0000-09-monotonic-stack]`
`2`	`2`	`= Monotonic Stack 单调栈`
`3`	`3`
`4`	`4`	`== 基本流程`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-[#0000-12-top-k-elements]`
	`1`	`+[#0000-10-top-k-elements]`
`2`	`2`	`= Top 'K' Elements 顶端 K 元素`
`3`	`3`
`4`	`4`	`任何让我们求解最大/最小/最频繁的K个元素的题，都遵循这种模式。`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-[#0000-05-cyclic-sort]`
	`1`	`+[#0000-11-cyclic-sort]`
`2`	`2`	`= Cyclic Sort 循环排序`
`3`	`3`
`4`	`4`	`这种模式讲述的是一直很好玩的方法：可以用来处理数组中的数值限定在一定的区间的问题。这种模式一个个遍历数组中的元素，如果当前这个数它不在其应该在的位置的话，咱们就把它和它应该在的那个位置上的数交换一下。你可以尝试将该数放到其正确的位置上，但这复杂度就会是O(n^2^)。这样的话，可能就不是最优解了。因此循环排序的优势就体现出来了。`