heapify

Author: GreyZeng

src/main/java/grey/algorithm/code11_heap/Code_0001_LintCode_0130_Heapify.java

@@ -8,27 +8,26 @@
 //右孩子 2 * i + 2
 //父节点 （i - 1）/ 2
 public class Code_0001_LintCode_0130_Heapify {
-    public void heapify(int[] a) {
-        for (int index = a.length - 1; index >= 0; index--) {
-            int i = index;
-            int leftChildIndex = 2 * i + 1;
-            while (leftChildIndex < a.length) {
-                int minIndex = leftChildIndex + 1 < a.length && a[leftChildIndex] > a[leftChildIndex + 1] ? leftChildIndex + 1 : leftChildIndex;
-                minIndex = a[i] < a[minIndex] ? i : minIndex;
-                if (minIndex == i) {
+
+    public void heapify(int[] arr) {
+        for (int i = arr.length - 1; i >= 0; i--) {
+            int index = i;
+            int left = 2 * index + 1;
+            while (left < arr.length) {
+                int best = left + 1 < arr.length && arr[left + 1] < arr[left] ? left + 1 : left;
+                if (arr[best] >= arr[index]) {
                     break;
                 }
-                swap(a, i, minIndex);
-                i = minIndex;
-                leftChildIndex = 2 * i + 1;
+                swap(arr, best, index);
+                index = best;
+                left = 2 * index + 1;
             }
         }
     }
-    public void swap(int[] arr, int i, int j) {
-        if (i != j && arr != null && arr.length > 1) {
-            arr[i] = arr[i] ^ arr[j];
-            arr[j] = arr[i] ^ arr[j];
-            arr[i] = arr[i] ^ arr[j];
-        }
+
+    public static void swap(int[] arr, int i, int j) {
+        int t = arr[i];
+        arr[i] = arr[j];
+        arr[j] = t;
     }
 }

src/main/java/grey/algorithm/code11_heap/Code_0002_MaxHeap.java

@@ -24,6 +24,7 @@
 // 大根堆：完全二叉树中，每棵树的最大值都是头节点的值
 // heapify和heapInsert都是logN级别的复杂度，因为N个节点的二叉树高度是logN
 public class Code_0002_MaxHeap {
+
     private final int[] heap;
     private int heapSize;
 
@@ -63,7 +64,7 @@ private void heapify() {
             int largest // bigger index
                     = left + 1 < heapSize // right child exist
                     && heap[left + 1] > heap[left] // compare left child and right child
-                    ? left + 1 : left;
+                            ? left + 1 : left;
             largest = heap[largest] > heap[index] ? largest : index;
             if (largest == index) {
                 break;