auto commit

notes/HTTP.md

@@ -172,7 +172,7 @@ DELETE /file.html HTTP/1.1
 
 > 要求用隧道协议连接代理
 
-要求在于代理服务器通信时建立隧道，使用 SSL（Secure Sokets Layer，安全套接字）和 TLS（Transport Layer Security，传输层安全）协议把通信内容加密后经网络隧道传输。
+要求在于代理服务器通信时建立隧道，使用 SSL（Secure Sockets Layer，安全套接层）和 TLS（Transport Layer Security，传输层安全）协议把通信内容加密后经网络隧道传输。
 
 ```html
 CONNECT www.example.com:443 HTTP/1.1

notes/算法.md

@@ -354,7 +354,7 @@ public class UF {
 
 但是 union 操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。
 
-<div align="center"> <img src="../pics//9764bf07-4840-486c-988f-334acefc3f49.png" width="300"/> </div><br>
+<div align="center"> <img src="../pics//8f0cc500-5994-4c7a-91a9-62885d658662.png" width="300"/> </div><br>
 
 ```java
 public int find(int p) {
@@ -377,7 +377,7 @@ public void union(int p, int q) {
 
 但是 find 操作开销很大，因为同一个连通分量的节点 id 值不同，id 值只是用来指向另一个节点。因此需要一直向上查找操作，直到找到最上层的节点。
 
-<div align="center"> <img src="../pics//61f8292b-eca0-4f46-a1be-f18d1e5c6fa9.png" width="300"/> </div><br>
+<div align="center"> <img src="../pics//5d4a5181-65fb-4bf2-a9c6-899cab534b44.png" width="300"/> </div><br>
 
 ```java
     public int find(int p) {
@@ -654,7 +654,7 @@ public class QuickSort {
 
 ### 2. 切分
 
-取 a[lo] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于等于它的元素，交换这两个元素，并不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[lo] 和左子数组最右侧的元素 a[j] 交换然后返回 j 即可。
+取 a[lo] 作为切分元素，然后从数组的左端向右扫描直到找到第一个大于等于它的元素，再从数组的右端向左扫描找到第一个小于等于它的元素，交换这两个元素，并不断进行这个过程，就可以保证左指针 i 的左侧元素都不大于切分元素，右指针 j 的右侧元素都不小于切分元素。当两个指针相遇时，将切分元素 a[lo] 和 a[j] 交换位置。
 
 <div align="center"> <img src="../pics//8af348d0-4d72-4f76-b56c-0a440ed4673d.png" width="400"/> </div><br>
 
@@ -721,11 +721,12 @@ public class Quick3Way {
 
 ### 1. 堆
 
-定义：一颗二叉树的每个节点都大于等于它的两个子节点。
+堆的某个节点的值总是大于等于子节点的值，并且堆是一颗完全二叉树。
+
 
 堆可以用数组来表示，因为堆是一种完全二叉树，而完全二叉树很容易就存储在数组中。位置 k 的节点的父节点位置为 k/2，而它的两个子节点的位置分别为 2k 和 2k+1。这里我们不使用数组索引为 0 的位置，是为了更清晰地理解节点的关系。
 
-<div align="center"> <img src="../pics//5144a411-0e46-4a84-a179-c9ad3240418f.png" width="400"/> </div><br>
+<div align="center"> <img src="../pics//f3080f83-6239-459b-8e9c-03b6641f7815.png" width="200"/> </div><br>
 
 ```java
 public class MaxPQ<Key extends Comparable<Key> {
@@ -760,7 +761,7 @@ public class MaxPQ<Key extends Comparable<Key> {
 
 在堆中，当一个节点比父节点大，那么需要交换这个两个节点。交换后还可能比它新的父节点大，因此需要不断地进行比较和交换操作。把这种操作称为上浮。
 
-<div align="center"> <img src="../pics//d5659bcf-5ddf-4692-bfe5-f6b480479120.png" width="400"/> </div><br>
+<div align="center"> <img src="../pics//33ac2b23-cb85-4e99-bc41-b7b7199fad1c.png" width="400"/> </div><br>
 
 ```java
 private void swim(int k) {
@@ -773,7 +774,7 @@ private void swim(int k) {
 
 类似地，当一个节点比子节点来得小，也需要不断的向下比较和交换操作，把这种操作称为下沉。一个节点有两个子节点，应当与两个子节点中最大那么节点进行交换。
 
-<div align="center"> <img src="../pics//df648536-a107-48cd-a615-77b7a9b4025f.png" width="350"/> </div><br>
+<div align="center"> <img src="../pics//72f0ff69-138d-4e54-b7ac-ebe025d978dc.png" width="400"/> </div><br>
 
 ```java
 private void sink(int k) {
@@ -816,11 +817,19 @@ public Key delMax() {
 
 由于堆可以很容易得到最大的元素并删除它，不断地进行这种操作可以得到一个递减序列。如果把最大元素和当前堆中数组的最后一个元素交换位置，并且不删除它，那么就可以得到一个从尾到头的递减序列，从正向来看就是一个递增序列。因此很容易使用堆来进行排序，并且堆排序是原地排序，不占用额外空间。
 
-堆排序要分两个阶段，第一个阶段是把无序数组建立一个堆；第二个阶段是交换最大元素和当前堆的数组最后一个元素，并且进行下沉操作维持堆的有序状态。
+**构建堆** 
 
 无序数组建立堆最直接的方法是从左到右遍历数组，然后进行上浮操作。一个更高效的方法是从右至左进行下沉操作，如果一个节点的两个节点都已经是堆有序，那么进行下沉操作可以使得这个节点为根节点的堆有序。叶子节点不需要进行下沉操作，因此可以忽略叶子节点的元素，因此只需要遍历一半的元素即可。
 
-<div align="center"> <img src="../pics//750501be-6b8a-4cb5-a807-371a218ee612.png" width="800"/> </div><br>
+<div align="center"> <img src="../pics//b84ba6fb-312b-4e69-8c77-fb6eb6fb38d4.png" width="300"/> </div><br>
+
+**交换堆顶元素与最后一个元素** 
+
+交换之后需要进行下沉操作维持堆的有序状态。
+
+<div align="center"> <img src="../pics//7a80661f-115e-48e0-8a79-837ef7d436c8.png" width="300"/> </div><br>
+
+<div align="center"> <img src="../pics//a01243f1-f5d7-4bee-b16e-1f921d2f58e8.png" width="300"/> </div><br>
 
 ```java
 public static void sort(Comparable[] a){