Day 38: implement a heap pt 1

Author: thatguyintech

day38/README.md

@@ -0,0 +1,84 @@
+Today I'm going to implement a min heap.
+
+What is a heap?
+
+From http://www.cprogramming.com/tutorial/computersciencetheory/heap.html:
+
+"A heap is a partially sorted binary tree. Although a heap is not completely
+in order, it conforms to a sorting principle: every node has a value less
+(for the sake of simplicity, we will assume that all orderings are from
+least to greatest) than either of its children. Additionally, a heap is
+a "complete tree" -- a complete tree is one in which there are no gaps
+between leaves. For instance, a tree with a root node that has only one
+child must have its child as the left node. More precisely, a complete tree
+is one that has every level filled in before adding a node to the next level,
+and one that has the nodes in a given level filled in from left to right,
+with no breaks."
+
+Basically, a one-node min heap might look something like this:
+
+```
+7
+```
+
+And a two-node min heap might look something like this:
+
+```
+  7
+ /
+9
+```
+
+three nodes:
+
+```
+   7
+  / \
+ 9   8
+```
+
+four nodes:
+
+```
+    7
+   / \
+  10 18
+ /
+19
+```
+
+and so on.
+
+Here are some specs for my basic min heap that contains `n` integers:
+
+getMin  - takes no arguments, extracts and returns the minimum value in the heap.
+          The rest of the heap is reorganized so that the min value is still at
+          the top. Finishes in `O(n)` time.
+
+peek    - takes no arguments, returns the minimum value in the heap. Should return
+          in `O(1)` time.
+
+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.
+
+size    - takes no arguments and returns the number of integers in the heap `n`
+          in `O(1)` time.
+
+isEmpty - takes no arguments and returns `True` if there are no elements in the
+          heap, and `False` if there ARE elements in the heap in `O(1)` time.
+
+## Code
+
+[Python](./heap.py)
+
+## Follow-up
+
+Why use a heap?
+
+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.

day38/heap.py

@@ -0,0 +1,151 @@
+class MinHeap:
+    def __init__(self, arr=[]):
+        if len(arr) > 0:
+            self.heap = self.heapify(arr)
+        else:
+            self.heap = []
+
+        self.size = 0
+
+    def getMin(self):
+        if self.size > 0
+            ret = self.heap[0] #[1]
+            self.heap[0] = self.heap[-1] #[1]
+            self.heap.pop() #[]
+            self.size -= 1
+            self.bubbleDown() #[]
+            return ret
+
+    def peek(self):
+        if self.size > 0
+            return self.heap[0]
+
+    def push(self, val):
+        self.heap.append(val)
+        self.bubbleUp()
+        self.size += 1
+
+    def heapify(self, arr):
+        heap = []
+        self.size = len(arr)
+        return heap
+
+    def size(self):
+        return self.size
+
+    def isEmpty(self):
+        return self.size == 0
+
+def testPush():
+    heap = MinHeap()
+    heap.push(2)
+    assert heap.root.val == 2
+
+    heap.push(3)
+    assert heap.root.val == 2
+
+    heap.push(1)
+    assert heap.root.val == 1
+
+    heap.push(5)
+    assert heap.root.val == 1
+
+    heap.push(-1)
+    assert heap.root.val == -1
+
+def testHeapify():
+    def isMinHeap(heap):
+        if heap == None:
+            return True
+
+        if heap.root.left:
+            left = heap.root.val < heap.root.left.val
+        else:
+            left = True
+
+        if heap.root.right:
+            right = heap.root.val < heap.root.right.val
+        else:
+            right = True
+
+        return isMinHeap(heap.root.left) and isMinHeap(heap.root.right) and left and right
+
+    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)
+
+def testGetMin():
+    heap = MinHeap([2, 5, 20])
+    assert heap.getMin() == 2
+    assert heap.getMin() == 5
+
+    heap1 = MinHeap([1, 2, 3, 4, 5])
+    assert heap1.getMin() == 1
+    assert heap1.getMin() == 2
+
+    heap2 = MinHeap([5, 4, 3, 2, 1])
+    assert heap2.getMin() == 1
+    assert heap2.getMin() == 2
+
+    heap3 = MinHeap([2, 5, 3, 7, -1])
+    assert heap3.getMin() == -1
+    assert heap3.getMin() == 2
+
+def testPeek():
+    heap = MinHeap([2, 5, 20])
+    assert heap.peek() == 2
+    assert heap.peek() == 2
+
+    heap1 = MinHeap([1, 2, 3, 4, 5])
+    assert heap1.peek() == 1
+    assert heap1.peek() == 1
+
+    heap2 = MinHeap([5, 4, 3, 2, 1])
+    assert heap2.peek() == 1
+    assert heap2.peek() == 1
+
+    heap3 = MinHeap([2, 5, 3, 7, -1])
+    assert heap3.peek() == -1
+    assert heap3.peek() == -1
+
+def testSize():
+    heap = MinHeap()
+    assert heap.size() == 0
+
+    heap2 = MinHeap([1])
+    assert heap.size() == 1
+
+    heap3 = MinHeap([1, 2, 3, 4])
+    assert heap.size() == 4
+
+def testIsEmpty():
+    heap = MinHeap()
+    assert heap.isEmpty()
+
+    heap2 = MinHeap([1])
+    assert not heap.isEmpty()
+
+    heap3 = MinHeap([1, 2, 3])
+    assert not heap.isEmpty()
+
+def testEverything():
+    assert True
+
+def tests():
+    testPush()
+    testHeapify()
+    testGetMin()
+    testPeek()
+    testSize()
+    testIsEmpty()
+    testEverything()
+
+if __name__ == "__main__":
+    tests()