auto commit

notes/算法.md

@@ -44,21 +44,21 @@
 
 <div align="center"><img src="https://latex.codecogs.com/gif.latex?log(T(N))=3logN+loga"/></div> <br>
 
-<div align="center"> <img src="../pics//0ed83061-9c1e-4df3-b15b-69aad5bfe9b8.png" width="800"/> </div><br>
+<div align="center"> <img src="../pics//a9098783-c24a-45b2-a226-725a59b6768e.png" width="800"/> </div><br>
 
 ## 数学模型
 
 ### 1. 近似
 
-使用 \~f(N) 来表示所有随着 N 的增大除以 f(N) 的结果趋近于 1 的函数 , 例如 N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 \~ N<sup>3</sup>/6。
+使用 \~f(N) 来表示所有随着 N 的增大除以 f(N) 的结果趋近于 1 的函数，例如 N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 \~ N<sup>3</sup>/6。
 
-<div align="center"> <img src="../pics//8f1e2db5-a59b-4633-8b61-6b8b9505b8ea.png" width="600"/> </div><br>
+<div align="center"> <img src="../pics//81eb9879-40f2-421a-87de-2b953cfe8c32.png" width="1000"/> </div><br>
 
 ### 2. 增长数量级
 
 增长数量级将算法与它的实现隔离开来，一个算法的增长数量级为 N<sup>3</sup> 与它是否用 Java 实现，是否运行于特定计算机上无关。
 
-<div align="center"> <img src="../pics//521969c9-71f6-44a5-9c78-118530e5c135.png" width="700"/> </div><br>
+<div align="center"> <img src="../pics//051760ba-e658-401f-9a1c-15adcb405191.png" width="1000"/> </div><br>
 
 ### 3. 内循环
 
@@ -125,9 +125,9 @@ public class ThreeSumFast {
 
 例如对于暴力方法的 ThreeSum 算法，近似时间为 \~N<sup>3</sup>/6。进行如下实验：多次运行该算法，每次取的 N 值为前一次的两倍，统计每次执行的时间，并统计本次运行时间与前一次运行时间的比值，得到如下结果：
 
-<div align="center"> <img src="../pics//cc3d855a-4281-445b-8f83-8f855458de19.png" width=""/> </div><br>
+<div align="center"> <img src="../pics//2093ccfa-e560-44f3-84c7-487d66451708.png" width="300"/> </div><br>
 
-可以看到，T(2N)/T(N)\~2<sup>3</sup>，因此可以确定 T(N) \~ aN<sup>2</sup>logN。
+可以看到，T(2N)/T(N) \~ 2<sup>3</sup>，因此可以确定 T(N) \~ aN<sup>2</sup>logN。
 
 ## 注意事项
 
@@ -157,7 +157,7 @@ public class ThreeSumFast {
 
 first-in-last-out(FILO)
 
-<div align="center"> <img src="../pics//1c237399-e322-4930-b5b4-a582b1ad8bda.png" width="300"/> </div><br>
+<div align="center"> <img src="../pics//cc7bfdeb-452e-4fae-9bc8-323338b0dedb.png" width="500"/> </div><br>
 
 <font size=4> **1. 数组实现** </font></br>
 
@@ -228,7 +228,7 @@ Item[] arr = (Item[]) new Object[N];
 
 <font size=4> **2. 链表实现** </font></br>
 
-需要使用链表的头插法来实现，因为头插法中最后压入栈的元素在链表的开头，它的 next 指针指向前一个压入栈的元素，在弹出元素使就可以让前一个压入栈的元素称为栈顶元素。
+需要使用链表的头插法来实现，因为头插法中最后压入栈的元素在链表的开头，它的 next 指针指向前一个压入栈的元素，在弹出元素使就可以通过 next 指针遍历到前一个压入栈的元素从而让这个元素称为新的栈顶元素。
 
 ```java
 public class Stack<Item> {
@@ -269,11 +269,11 @@ public class Stack<Item> {
 
 first-in-first-out(FIFO)
 
-<div align="center"> <img src="../pics//c64f91e2-f5a8-436b-8663-b8f3fba3e098.png" width="300"/> </div><br>
+<div align="center"> <img src="../pics//d9efd6bd-3f34-497e-911c-16d5ea38ce88.png" width="500"/> </div><br>
 
 下面是队列的链表实现，需要维护 first 和 last 节点指针，分别指向队首和队尾。
 
-这里需要考虑让哪个指针指针链表头部节点，哪个指针指向链表尾部节点。因为出队列操作需要让队首元素的下一个元素成为队首，就需要容易获取下一个元素，而链表的头部节点的 next 指针指向下一个元素，因此让队首指针 first 指针链表的开头。
+这里需要考虑 first 和 last 指针哪个作为链表的开头。因为出队列操作需要让队首元素的下一个元素成为队首，所以需要容易获取下一个元素，而链表的头部节点的 next 指针指向下一个元素，因此可以让 first 指针链表的开头。
 
 ```java
 public class Queue<Item> {
@@ -322,13 +322,13 @@ public class Queue<Item> {
 
 <font size=4>  **概览**  </font> <br>
 
-用于解决动态连通性问题，能动态连接两个点，并且判断两个点是否连接。
+用于解决动态连通性问题，能动态连接两个点，并且判断两个点是否连通。
 
-<div align="center"> <img src="../pics//1dc67ff6-d29b-4864-baac-fd6b23f9b2ac.png" width="200"/> </div><br>
+<div align="center"> <img src="../pics//7e9d0ef2-acd8-44c0-a76b-f0d2f5e76738.png" width="400"/> </div><br>
 
 <font size=4>  **API**  </font> <br>
 
-<div align="center"> <img src="../pics//0e6cf8bd-b84e-4b3c-b79d-40d7dd54e120.png" width="600"/> </div><br>
+<div align="center"> <img src="../pics//867abc3c-8403-43ef-8847-c1fea32996a5.png" width="1000"/> </div><br>
 
 <font size=4>  **基本数据结构**  </font> <br>
 
@@ -352,9 +352,9 @@ public class UF {
 
 ## quick-find
 
-保证在同一连通分量的所有触点的 id 值相等。
+保证在同一连通分量的所有节点的 id 值相等。
 
-这种方法可以快速取得一个触点的 id 值，并且判断两个触点是否连通，但是 union 的操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。
+这种方法可以快速取得一个节点的 id 值，并且判断两个节点是否连通。但是 union 的操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。
 
 ```java
     public int find(int p) {
@@ -373,9 +373,9 @@ public class UF {
 
 ## quick-union
 
-在 union 时只将触点的 id 值指向另一个触点 id 值，不直接用 id 来存储所属的连通分量。这样就构成一个倒置的树形结构，根节点需要指向自己。在进行查找一个节点所属的连通分量时，要一直向上查找直到根节点，并使用根节点的 id 值作为本连通分量的 id 值。
+在 union 时只将节点的 id 值指向另一个节点 id 值，不直接用 id 来存储所属的连通分量。这样就构成一个倒置的树形结构，应该注意的是根节点需要指向自己。查找一个节点所属的连通分量时，要一直向上查找直到根节点，并使用根节点的 id 值作为本连通分量的 id 值。
 
-<div align="center"> <img src="../pics//e1cd89d1-8973-41d0-8ea9-940d94c314d9.jpg" width="500"/> </div><br>
+<div align="center"> <img src="../pics//ae1f3f27-cb47-436d-b8a2-185618851b57.png" width="800"/> </div><br>
 
 ```java
     public int find(int p) {
@@ -393,7 +393,7 @@ public class UF {
 
 这种方法可以快速进行 union 操作，但是 find 操作和树高成正比，最坏的情况下树的高度为触点的数目。
 
-<div align="center"> <img src="../pics//83575315-20b5-44a6-bf58-94460a141ffa.jpg" width="400"/> </div><br>
+<div align="center"> <img src="../pics//dcbd1473-96c3-4ace-8b69-2c9342615e7e.png" width="300"/> </div><br>
 
 ## 加权 quick-union
 
@@ -401,7 +401,7 @@ public class UF {
 
 理论研究证明，加权 quick-union 算法构造的树深度最多不超过 logN。
 
-<div align="center"> <img src="../pics//9a30b932-f69f-40a1-9564-a1354ff8cf29.jpg" width="400"/> </div><br>
+<div align="center"> <img src="../pics//7f9a9342-1491-436d-bdd2-0fa94eb0e4f1.png" width="500"/> </div><br>
 
 ```java
 public class WeightedQuickUnionUF {
@@ -448,7 +448,7 @@ public class WeightedQuickUnionUF {
 
 ## 各种 union-find 算法的比较
 
-<div align="center"> <img src="../pics//c11f5e3a-7a28-4db7-87b1-29ba1a2f2d72.jpg" width="600"/> </div><br>
+<div align="center"> <img src="../pics//cae894a9-2424-4de4-ab41-c15d7054a5e7.png" width="1000"/> </div><br>
 
 # 四、排序