Day 40: implement heapify in time

Author: thatguyintech

day38/README.md

@@ -62,7 +62,7 @@ push    - takes an integer as an argument and adds it into the heap, returning
           nothing. Should complete in `O(logn)` time.
 
 heapify - takes an array of integers and forms a heap out of them. Should run in
-          `O(nlogn)` (?) time.
+          `O(n)` time.
 
 size    - takes no arguments and returns the number of integers in the heap `n`
           in `O(1)` time.
@@ -83,8 +83,20 @@ efficient way to maintain that ordering even when elements are being deleted
 and added. The tree structure of the heap allows you to find elements in
 `O(logn)` time rather than `O(n)` time like in a normal array or linked list.
 
+---
+
 Some more thinking around heapify, aka just cram an unsorted array into
-a binary tree, and then compare and swap unordered parent-children pairs:
+a binary tree, and then compare and swap unordered parent-children pairs,
+from the bottom up:
+
+arr = [7, 6, 5, 4, 3, 2, 1]
+
+        1
+       / \
+      3   2 
+     / \ / \
+    4  6 7  5
+
 
 arr = [4, 5, 7, 3, 9, 6, 1]
 
@@ -134,8 +146,19 @@ arr[index] = 4
 
 done.
 
-Need to do one comparison set for each parent node, and then done. So O(n) time!
+Need to do one bubbleDown each parent node from the bottom up, and then done.  
+On the bottom-most level, `n/2` nodes can move at most 0 levels down.  
+Next level, `n/4` nodes can move at most 1 level down.  
+etc.   
+
+So it's a summation on i from 0 to logn:  
 
+`n/(2**i) * i`
 
+which turns out to be `O(n)` work!
 
+Edit: fix `heapify` code.
 
+For more information:  
+- https://www.cs.umd.edu/~meesh/351/mount/lectures/lect14-heapsort-analysis-part.pdf  
+- https://www.youtube.com/watch?v=MiyLo8adrWw  

day38/heap.py

@@ -5,6 +5,7 @@ def __init__(self, arr=[]):
         self.heap = deque()
         self.size = 0
         if len(arr) > 0:
+            self.size = len(arr)
             self.heapify(arr)
 
     # runtime: O(logn) aka the height of the heap
@@ -14,32 +15,33 @@ def getMin(self):
             self.size -= 1
             if self.size > 0:
                 self.heap.appendleft(self.heap.pop())
-                self.bubbleDown()
+                self.bubbleDown(0)
             return ret
 
     # runtime: O(1) 
     def peek(self):
         if self.size > 0:
             return self.heap[0]
 
-    # runtime: O(logn) aka the height of the tree
+    # runtime: O(logn) aka the height of the heap
     def push(self, val):
         self.size += 1
         self.heap.append(val)
         self.bubbleUp()
 
     # runtime: O(nlogn)
     def heapify(self, arr):
-        for item in arr:
-            self.push(item)
+        self.heap = deque(arr)
+        for i in xrange(self.size-1, -1, -1):
+            self.bubbleDown(i)
 
     # runtime: O(1)
     def isEmpty(self):
         return self.size == 0
 
-    def bubbleDown(self):
+    def bubbleDown(self, index):
         if self.size > 0:
-            i = 0
+            i = index
             h = self.heap
             withinBounds = 2*i + 2 < self.size
             while withinBounds and (h[i] > h[2*i + 1] or h[i] > h[2*i + 2]):