auto commit

docs/notes/算法 - 排序.md

@@ -58,7 +58,7 @@ public abstract class Sort<T extends Comparable<T>> {
 
 选择排序需要 \~N<sup>2</sup>/2 次比较和 \~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。
 
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/21550397584141.gif"/> </div><br>
+<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/bc6be2d0-ed5e-4def-89e5-3ada9afa811a.gif" width="230px"> </div><br>
 
 ```java
 public class Selection<T extends Comparable<T>> extends Sort<T> {
@@ -85,7 +85,7 @@ public class Selection<T extends Comparable<T>> extends Sort<T> {
 
 在一轮循环中，如果没有发生交换，那么说明数组已经是有序的，此时可以直接退出。
 
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/31550398353573.gif"/> </div><br>
+<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/0f8d178b-52d8-491b-9dfd-41e05a952578.gif" width="200px"> </div><br>
 
 ```java
 public class Bubble<T extends Comparable<T>> extends Sort<T> {
@@ -119,7 +119,7 @@ public class Bubble<T extends Comparable<T>> extends Sort<T> {
 - 最坏的情况下需要 \~N<sup>2</sup>/2 比较以及 \~N<sup>2</sup>/2 次交换，最坏的情况是数组是倒序的；
 - 最好的情况下需要 N-1 次比较和 0 次交换，最好的情况就是数组已经有序了。
 
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/51550399426594.gif"/> </div><br>
+<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/35253fa4-f60a-4e3b-aaec-8fc835aabdac.gif" width="200px"> </div><br>
 
 ```java
 public class Insertion<T extends Comparable<T>> extends Sort<T> {
@@ -142,7 +142,7 @@ public class Insertion<T extends Comparable<T>> extends Sort<T> {
 
 希尔排序使用插入排序对间隔 h 的序列进行排序。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。
 
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/38ce21e9-2075-41a3-862b-f3265a082132_200.png"/> </div><br>
+<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/7818c574-97a8-48db-8e62-8bfb030b02ba.png" width="450px"> </div><br>
 
 ```java
 public class Shell<T extends Comparable<T>> extends Sort<T> {
@@ -176,7 +176,7 @@ public class Shell<T extends Comparable<T>> extends Sort<T> {
 
 归并排序的思想是将数组分成两部分，分别进行排序，然后归并起来。
 
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/2_200.png"/> </div><br>
+<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/ec840967-d127-4da3-b6bb-186996c56746.png" width="300px"> </div><br>
 
 ## 1. 归并方法
 
@@ -241,6 +241,7 @@ public class Up2DownMergeSort<T extends Comparable<T>> extends MergeSort<T> {
 }
 ```
 
+
 ## 3. 自底向上归并排序
 
 先归并那些微型数组，然后成对归并得到的微型数组。
@@ -271,7 +272,7 @@ public class Down2UpMergeSort<T extends Comparable<T>> extends MergeSort<T> {
 - 归并排序将数组分为两个子数组分别排序，并将有序的子数组归并使得整个数组排序；
 - 快速排序通过一个切分元素将数组分为两个子数组，左子数组小于等于切分元素，右子数组大于等于切分元素，将这两个子数组排序也就将整个数组排序了。
 
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/3_200.png"/> </div><br>
+<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/6234eb3d-ccf2-4987-a724-235aef6957b1.png" width="280px"> </div><br>
 
 ```java
 public class QuickSort<T extends Comparable<T>> extends Sort<T> {
@@ -302,7 +303,7 @@ public class QuickSort<T extends Comparable<T>> extends Sort<T> {
 
 取 a[l] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于它的元素，交换这两个元素。不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[l] 和 a[j] 交换位置。
 
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/61550402057509.gif"/> </div><br>
+<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/c4859290-e27d-4f12-becf-e2a5c1f3a275.gif" width="320px"> </div><br>
 
 ```java
 private int partition(T[] nums, int l, int h) {
@@ -406,7 +407,7 @@ public T select(T[] nums, int k) {
 
 堆可以用数组来表示，这是因为堆是完全二叉树，而完全二叉树很容易就存储在数组中。位置 k 的节点的父节点位置为 k/2，而它的两个子节点的位置分别为 2k 和 2k+1。这里不使用数组索引为 0 的位置，是为了更清晰地描述节点的位置关系。
 
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/8_200.png"/> </div><br>
+<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/f48883c8-9d8a-494e-99a4-317d8ddb8552.png" width="170px"> </div><br>
 
 ```java
 public class Heap<T extends Comparable<T>> {
@@ -442,7 +443,7 @@ public class Heap<T extends Comparable<T>> {
 
 在堆中，当一个节点比父节点大，那么需要交换这个两个节点。交换后还可能比它新的父节点大，因此需要不断地进行比较和交换操作，把这种操作称为上浮。
 
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/81550405360028.gif"/> </div><br>
+<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/99d5e84e-fc2a-49a3-8259-8de274617756.gif" width="270px"> </div><br>
 
 ```java
 private void swim(int k) {
@@ -455,7 +456,7 @@ private void swim(int k) {
 
 类似地，当一个节点比子节点来得小，也需要不断地向下进行比较和交换操作，把这种操作称为下沉。一个节点如果有两个子节点，应当与两个子节点中最大那个节点进行交换。
 
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/91550405374894.gif"/> </div><br>
+<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/4bf5e3fb-a285-4138-b3b6-780956eb1df1.gif" width="270px"> </div><br>
 
 ```java
 private void sink(int k) {
@@ -504,13 +505,13 @@ public T delMax() {
 
 无序数组建立堆最直接的方法是从左到右遍历数组进行上浮操作。一个更高效的方法是从右至左进行下沉操作，如果一个节点的两个节点都已经是堆有序，那么进行下沉操作可以使得这个节点为根节点的堆有序。叶子节点不需要进行下沉操作，可以忽略叶子节点的元素，因此只需要遍历一半的元素即可。
 
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/101550406418006.gif"/> </div><br>
+<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/c2ca8dd2-8d00-4a3e-bece-db7849ac9cfd.gif" width="210px"> </div><br>
 
 #### 5.2 交换堆顶元素与最后一个元素
 
 交换之后需要进行下沉操作维持堆的有序状态。
 
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/111550407277293.gif"/> </div><br>
+<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/d156bcda-ac8d-4324-95e0-0c8df41567c9.gif" width="250px"> </div><br>
 
 ```java
 public class HeapSort<T extends Comparable<T>> extends Sort<T> {