auto commit

notes/算法.md

@@ -316,7 +316,7 @@ public class Queue<Item> {
 
 用于解决动态连通性问题，能动态连接两个点，并且判断两个点是否连通。
 
-<div align="center"> <img src="../pics//dc752c5b-bb59-4616-bf9c-21276690a24d.png"/> </div><br>
+<div align="center"> <img src="../pics//dc752c5b-bb59-4616-bf9c-21276690a24d.png" width="400"/> </div><br>
 
 <font size=4>  **API**  </font> <br>
 
@@ -354,7 +354,7 @@ public class UF {
 
 但是 union 操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。
 
-<div align="center"> <img src="../pics//0120d24f-58a2-4848-afff-ce2b76d38ffc.png"/> </div><br>
+<div align="center"> <img src="../pics//75bb1eca-25a4-4f0b-b8e3-1bbe15c176cf.png" width="350"/> </div><br>
 
 ```java
     public int find(int p) {
@@ -377,7 +377,7 @@ public class UF {
 
 但是 find 操作开销很大，因为同一个连通分量的节点 id 值不同，id 值只是用来指向另一个节点。因此需要一直向上查找操作，直到找到最上层的节点。
 
-<div align="center"> <img src="../pics//d645d71f-007e-4228-8311-6b1fb61fb232.png"/> </div><br>
+<div align="center"> <img src="../pics//8d905dcf-19de-48ea-bfc2-762093ab5f54.png" width="350"/> </div><br>
 
 ```java
     public int find(int p) {
@@ -395,7 +395,7 @@ public class UF {
 
 这种方法可以快速进行 union 操作，但是 find 操作和树高成正比，最坏的情况下树的高度为触点的数目。
 
-<div align="center"> <img src="../pics//bfbb11e2-d208-4efa-b97b-24cd40467cd8.png"/> </div><br>
+<div align="center"> <img src="../pics//bfbb11e2-d208-4efa-b97b-24cd40467cd8.png" width="150"/> </div><br>
 
 ## 加权 quick-union
 
@@ -403,7 +403,7 @@ public class UF {
 
 理论研究证明，加权 quick-union 算法构造的树深度最多不超过 logN。
 
-<div align="center"> <img src="../pics//095720ee-84b3-42ff-af71-70ceb6a2f4a3.png"/> </div><br>
+<div align="center"> <img src="../pics//095720ee-84b3-42ff-af71-70ceb6a2f4a3.png" width="400"/> </div><br>
 
 ```java
 public class WeightedQuickUnionUF {
@@ -483,7 +483,7 @@ private void exch(Comparable[] a, int i, int j){
 
 找到数组中的最小元素，将它与数组的第一个元素交换位置。再从剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。
 
-<div align="center"> <img src="../pics//aa62b91f-3540-4a28-8ea9-045f62ab3bcc.png" width="600"/> </div><br>
+<div align="center"> <img src="../pics//ae3fc93a-44d5-4beb-b05a-874bd9c0a657.png" width="200"/> </div><br>
 
 ```java
 public class Selection {
@@ -506,7 +506,7 @@ public class Selection {
 
 插入排序从左到右进行，每次都将当前元素插入到左部已经排序的数组中，使得插入之后左部数组依然有序。
 
-<div align="center"> <img src="../pics//a451b523-7e24-4fae-8e35-c46b14beed68.png" width="600"/> </div><br>
+<div align="center"> <img src="../pics//c9a1de44-b1c0-4d13-a654-827d4ef8a723.png" width="200"/> </div><br>
 
 ```java
 public class Insertion {
@@ -533,9 +533,7 @@ public class Insertion {
 
 希尔排序使用插入排序对间隔 h 的序列进行排序，如果 h 很大，那么元素就能很快的移到很远的地方。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。
 
-<div align="center"> <img src="../pics//bed9d745-f971-405d-ba57-bcfa7986c8bd.png" width="500"/> </div><br>
-
-<div align="center"> <img src="../pics//6e8f16d1-7dea-4331-aea0-3dd739db00a4.png" width="600"/> </div><br>
+<div align="center"> <img src="../pics//4bb7ed45-ec14-4d31-9da4-94024d9d3b05.png" width="500"/> </div><br>
 
 ```java
 public class Shell {
@@ -563,9 +561,9 @@ public class Shell {
 
 归并排序的思想是将数组分成两部分，分别进行排序，然后归并起来。
 
-<div align="center"> <img src="../pics//8d13ee52-e881-41eb-ad70-678c411f2718.png" width="600"/> </div><br>
+<div align="center"> <img src="../pics//8dfb4cc9-26da-45e7-b820-4576fa1cbb0e.png" width="350"/> </div><br>
 
-<div align="center"> <img src="../pics//b5fed547-a989-4ead-81d5-ea72660faf99.png" width="800"/> </div><br>
+<div align="center"> <img src="../pics//0c55e11c-d3ce-4cd8-b139-028aea6f40e3.png" width="450"/> </div><br>
 
 ### 1. 归并方法
 
@@ -594,8 +592,6 @@ public class MergeSort {
 
 ### 2. 自顶向下归并排序
 
-<div align="center"> <img src="../pics//c95a18ae-4b97-4fa9-9806-d9ed7b345b42.png" width="800"/> </div><br>
-
 ```java
 public static void sort(Comparable[] a) {
     aux = new Comparable[a.length];
@@ -619,8 +615,6 @@ private static void sort(Comparable[] a, int lo, int hi) {
 
 先归并那些微型数组，然后成对归并得到的子数组。
 
-<div align="center"> <img src="../pics//4e3faf22-fa80-445e-a57d-594c37bb76e7.png" width="800"/> </div><br>
-
 ```java
 public static void busort(Comparable[] a) {
     int N = a.length;
@@ -639,7 +633,7 @@ public static void busort(Comparable[] a) {
 
 归并排序将数组分为两个子数组分别排序，并将有序的子数组归并使得整个数组排序；快速排序通过一个切分元素将数组分为两个子数组，左子数组小于等于切分元素，右子数组大于等于切分元素，将这两个子数组排序也就将整个数组排序了。
 
-<div align="center"> <img src="../pics//202cd47c-ef2f-4c0e-a511-53359553387d.png" width="600"/> </div><br>
+<div align="center"> <img src="../pics//ab77240d-7338-4547-9183-00215e7220ec.png" width="500"/> </div><br>
 
 ```java
 public class QuickSort {
@@ -661,7 +655,7 @@ public class QuickSort {
 
 取 a[lo] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于等于它的元素，交换这两个元素，并不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[lo] 和左子数组最右侧的元素 a[j] 交换然后返回 j 即可。
 
-<div align="center"> <img src="../pics//037f84c6-b470-42e0-a2d9-fd8cd7e96fa8.png" width="400"/> </div><br>
+<div align="center"> <img src="../pics//8af348d0-4d72-4f76-b56c-0a440ed4673d.png" width="400"/> </div><br>
 
 ```java
 private static int partition(Comparable[] a, int lo, int hi) {
@@ -702,8 +696,6 @@ private static int partition(Comparable[] a, int lo, int hi) {
 
 三向切分快速排序对于只有若干不同主键的随机数组可以在线性时间内完成排序。
 
-<div align="center"> <img src="../pics//b43437dd-16b6-4023-bdda-d6f7d6db762e.png" width="400"/> </div><br>
-
 ```java
 public class Quick3Way {
     public static void sort(Comparable[] a, int lo, int hi) {