update

src/main/java/lintcode/medium/LintCode_0130_Heapify.java

-//130. 堆化
-//给出一个整数数组，堆化操作就是把它变成一个最小堆数组。
+// 130. 堆化
+// 给出一个整数数组，堆化操作就是把它变成一个最小堆数组。
 //
-//对于堆数组A，A[0]是堆的根，并对于每个A[i]，A [i * 2 + 1]是A[i]的左儿子并且A[i * 2 + 2]是A[i]的右儿子。
+// 对于堆数组A，A[0]是堆的根，并对于每个A[i]，A [i * 2 + 1]是A[i]的左儿子并且A[i * 2 + 2]是A[i]的右儿子。
 //
-//样例
-//样例 1
+// 样例
+// 样例 1
 //
-//输入 : [3,2,1,4,5]
-//输出 : [1,2,3,4,5]
-//解释 : 返回任何一个合法的堆数组
-//挑战
-//O(n)的时间复杂度完成堆化
+// 输入 : [3,2,1,4,5]
+// 输出 : [1,2,3,4,5]
+// 解释 : 返回任何一个合法的堆数组
+// 挑战
+// O(n)的时间复杂度完成堆化
 //
-//说明
-//什么是堆？ 什么是堆化？ 如果有很多种堆化的结果？
+// 说明
+// 什么是堆？ 什么是堆化？ 如果有很多种堆化的结果？
 //
-//堆是一种数据结构，它通常有三种方法：push， pop 和 top。其中，“push”添加新的元素进入堆，“pop”删除堆中最小/最大元素，“top”返回堆中最小/最大元素。
-//把一个无序整数数组变成一个堆数组。如果是最小堆，每个元素A[i]，我们将得到A[i * 2 + 1] >= A[i]和A[i * 2 + 2] >= A[i]
-//返回其中任何一个。
+// 堆是一种数据结构，它通常有三种方法：push， pop 和 top。其中，“push”添加新的元素进入堆，“pop”删除堆中最小/最大元素，“top”返回堆中最小/最大元素。
+// 把一个无序整数数组变成一个堆数组。如果是最小堆，每个元素A[i]，我们将得到A[i * 2 + 1] >= A[i]和A[i * 2 + 2] >= A[i]
+// 返回其中任何一个。
 package lintcode.medium;
-
+// 笔记：https://www.cnblogs.com/greyzeng/p/16933830.html
 // https://www.lintcode.com/problem/130/
 public class LintCode_0130_Heapify {
-    public static void heapify(int[] arr) {
-        if (arr == null || arr.length <= 1) {
-            return;
-        }
-        for (int i = arr.length - 1; i >= 0; i--) {
-            heapify(arr, i, arr.length);
-        }
+  public static void heapify(int[] arr) {
+    if (arr == null || arr.length <= 1) {
+      return;
     }
-
-    private static void heapify(int[] arr, int i, int n) {
-        int left = 2 * i + 1;
-        while (left < n) {
-            int min = left + 1 < n && arr[left + 1] < arr[left] ? left + 1 : left;
-            if (arr[i] <= arr[min]) {
-                break;
-            }
-            swap(arr, i, min);
-            i = min;
-            left = 2 * i + 1;
-        }
-
+    for (int i = arr.length - 1; i >= 0; i--) {
+      heapify(arr, i, arr.length);
     }
+  }
 
-    private static void swap(int[] arr, int i, int j) {
-        if (i != j) {
-            arr[i] = arr[i] ^ arr[j];
-            arr[j] = arr[i] ^ arr[j];
-            arr[i] = arr[i] ^ arr[j];
-        }
+  private static void heapify(int[] arr, int i, int n) {
+    int left = 2 * i + 1;
+    while (left < n) {
+      int min = left + 1 < n && arr[left + 1] < arr[left] ? left + 1 : left;
+      if (arr[i] <= arr[min]) {
+        break;
+      }
+      swap(arr, i, min);
+      i = min;
+      left = 2 * i + 1;
     }
+  }
 
+  private static void swap(int[] arr, int i, int j) {
+    if (i != j) {
+      arr[i] = arr[i] ^ arr[j];
+      arr[j] = arr[i] ^ arr[j];
+      arr[i] = arr[i] ^ arr[j];
+    }
+  }
 }

src/main/java/snippet/Code_DistanceLessK.java

@@ -4,6 +4,7 @@ import java.util.Arrays;
 import java.util.PriorityQueue;
 
 /**
+ * 笔记：https://www.cnblogs.com/greyzeng/p/16933830.html
  * 已知一个几乎有序的数组。
  *
  * <p>几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离一定不超过k，并且k相对于数组长度来说是比较小的。

src/main/java/snippet/Code_Heap.java

@@ -3,7 +3,9 @@ package snippet;
 import java.util.PriorityQueue;
 
 /**
- * 笔记： 什么是完全二叉树 如果一个树是满的，它是完全二叉树，即便不是满的，也是从左到右依次变满的
+ * 笔记：https://www.cnblogs.com/greyzeng/p/16933830.html
+ *
+ * <p>什么是完全二叉树 如果一个树是满的，它是完全二叉树，即便不是满的，也是从左到右依次变满的
  *
  * <p>堆结构
  *
@@ -78,10 +80,10 @@ public class Code_Heap {
       return ans;
     }
 
-    private void heapInsert(int[] arr, int index) {
-      while (arr[index] > arr[(index - 1) / 2]) {
-        swap(arr, index, (index - 1) / 2);
-        index = (index - 1) / 2;
+    private void heapInsert(int[] arr, int i) {
+      while (arr[i] > arr[(i - 1) / 2]) {
+        swap(arr, i, (i - 1) / 2);
+        i = (i - 1) / 2;
       }
     }
 

src/main/java/snippet/Code_HeapSort.java

@@ -3,6 +3,7 @@ package snippet;
 import java.util.Arrays;
 import java.util.PriorityQueue;
 
+// 笔记：https://www.cnblogs.com/greyzeng/p/16933830.html
 // 1. 先让整个数组都变成大根堆结构，建立堆的过程:
 //    a. 从上到下的方法，时间复杂度为O(N*logN)
 //    b. 从下到上的方法，时间复杂度为O(N)