Merge branch 'master' into day41

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.
@@ -82,3 +82,83 @@ If some kind of ordering is required, i.e. max or min ordering, a heap is an
 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,
+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]
+
+        4
+       / \
+      5   7 
+     / \ / \
+    3  9 6  1
+
+len = 7
+first parent = 7/2 = 3
+index = 3-1
+arr[index] == 7
+
+7's children: arr[2*index + 1], arr[2*index + 2] aka 6, 1
+1 < 6
+
+        4
+       / \
+      5   1 
+     / \ / \
+    3  9 6  7
+
+next parent -> index -= 1
+arr[index] = 5
+
+5's children: 3, 9
+3 < 9
+
+        4
+       / \
+      3   1 
+     / \ / \
+    5  9 6  7
+
+next parent -> index -= 1
+arr[index] = 4
+
+4's children: 3, 1
+1 < 3
+
+        1
+       / \
+      3   4 
+     / \ / \
+    5  9 6  7
+
+done.
+
+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

@@ -1,47 +1,79 @@
+from collections import deque
+
 class MinHeap:
     def __init__(self, arr=[]):
-        if len(arr) > 0:
-            self.heap = self.heapify(arr)
-        else:
-            self.heap = []
-
+        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
     def getMin(self):
-        if self.size > 0
-            ret = self.heap[0] #[1]
-            self.heap[0] = self.heap[-1] #[1]
-            self.heap.pop() #[]
+        if self.size > 0:
+            ret = self.heap.popleft()
             self.size -= 1
-            self.bubbleDown() #[]
+            if self.size > 0:
+                self.heap.appendleft(self.heap.pop())
+                self.bubbleDown(0)
             return ret
 
+    # runtime: O(1) 
     def peek(self):
-        if self.size > 0
+        if self.size > 0:
             return self.heap[0]
 
+    # runtime: O(logn) aka the height of the heap
     def push(self, val):
+        self.size += 1
         self.heap.append(val)
         self.bubbleUp()
-        self.size += 1
 
+    # runtime: O(nlogn)
     def heapify(self, arr):
-        # TODO
-        return
-
-    def size(self):
-        return self.size
+        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):
-        # TODO
-        return
+    def bubbleDown(self, index):
+        if self.size > 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]):
+                if h[i] > h[2*i + 1] and h[i] > h[2*i + 2]:
+                    if h[2*i + 1] < h[2*i + 2]:
+                        h[i], h[2*i + 1] = h[2*i + 1], h[i]
+                        i = 2*i + 1
+                    else:
+                        h[i], h[2*i + 2] = h[2*i + 2], h[i]
+                        i = 2*i + 2
+                elif h[i] > h[2*i + 1]:
+                    h[i], h[2*i + 1] = h[2*i + 1], h[i]
+                    i = 2*i + 1
+                elif h[i] > h[2*i + 2]:
+                    h[i], h[2*i + 2] = h[2*i + 2], h[i]
+                    i = 2*i + 2
+                withinBounds = 2*i + 2 < self.size
+
+            if 2*i + 1 < self.size and h[i] > h[2*i + 1]:
+                h[i], h[2*i + 1] = h[2*i + 1], h[i]
+            elif 2*i + 2 < self.size and h[i] > h[2*i + 2]:
+                h[i], h[2*i + 2] = h[2*i + 2], h[i]
 
     def bubbleUp(self):
-        # TODO
-        return
+        if self.size > 0:
+            i = self.size-1
+            h = self.heap
+            withinBounds = i/2 >= 0
+            while withinBounds and (h[i] < h[i/2]):
+                h[i/2], h[i] = h[i], h[i/2]
+                i /= 2
+                withinBounds = i/2 >= 0
 
 def testPush():
     h = MinHeap()
@@ -61,34 +93,35 @@ def testPush():
     assert h.heap[0] == -1
 
 def testHeapify():
-    # heap1 = MinHeap([1, 2, 3, 4, 5])
-    # heap2 = MinHeap([])
-    # heap3 = MinHeap([5, 4, 3, 2, 1])
-    # heap4 = MinHeap([3, 1])
-    # heap5 = MinHeap([0, -1, 1, -2, 2])
-    # assert isMinHeap(heap1)
-    # assert isMinHeap(heap2)
-    # assert isMinHeap(heap3)
-    # assert isMinHeap(heap4)
-    # assert isMinHeap(heap5)
+    # TODO
     assert True
 
 def testGetMin():
     heap = MinHeap([2, 5, 20])
     assert heap.getMin() == 2
     assert heap.getMin() == 5
+    assert heap.getMin() == 20
 
     heap1 = MinHeap([1, 2, 3, 4, 5])
     assert heap1.getMin() == 1
     assert heap1.getMin() == 2
+    assert heap1.getMin() == 3
+    assert heap1.getMin() == 4
+    assert heap1.getMin() == 5
 
     heap2 = MinHeap([5, 4, 3, 2, 1])
     assert heap2.getMin() == 1
     assert heap2.getMin() == 2
+    assert heap2.getMin() == 3
+    assert heap2.getMin() == 4
+    assert heap2.getMin() == 5
 
     heap3 = MinHeap([2, 5, 3, 7, -1])
     assert heap3.getMin() == -1
     assert heap3.getMin() == 2
+    assert heap3.getMin() == 3
+    assert heap3.getMin() == 5
+    assert heap3.getMin() == 7
 
 def testPeek():
     heap = MinHeap([2, 5, 20])
@@ -109,26 +142,39 @@ def testPeek():
 
 def testSize():
     heap = MinHeap()
-    assert heap.size() == 0
+    assert heap.size == 0
 
     heap2 = MinHeap([1])
-    assert heap.size() == 1
+    assert heap2.size == 1
 
     heap3 = MinHeap([1, 2, 3, 4])
-    assert heap.size() == 4
+    assert heap3.size == 4
 
 def testIsEmpty():
     heap = MinHeap()
     assert heap.isEmpty()
 
     heap2 = MinHeap([1])
-    assert not heap.isEmpty()
+    assert not heap2.isEmpty()
 
     heap3 = MinHeap([1, 2, 3])
-    assert not heap.isEmpty()
+    assert not heap3.isEmpty()
 
 def testEverything():
-    assert True
+    heap = MinHeap([1, 2, 3, 4, -1, -2, -7, 6, -3, -1 , -1])
+    assert not heap.isEmpty()
+    assert heap.size == 11
+    assert heap.peek() == -7
+    assert heap.getMin() == -7
+    assert heap.getMin() == -3
+
+    heap.push(-10)
+    assert heap.peek() == -10
+    assert heap.size == 10
+    assert heap.getMin() == -10
+    assert heap.getMin() == -2
+    assert heap.getMin() == -1
+    assert heap.getMin() == -1
 
 def tests():
     testPush()