Paper: Heaps Exercise

heaps/heap_sort.py

@@ -1,8 +1,21 @@
-
+from heaps.min_heap import MinHeap
 
 def heap_sort(list):
     """ This method uses a heap to sort an array.
-        Time Complexity:  ?
-        Space Complexity: ?
+        Time Complexity:  O(n log n)
+        Space Complexity: O(1)
     """
-    pass
+    heap = MinHeap()
+
+    for num in list:
+        heap.add(num)
+
+    i = 0
+    while not heap.empty():
+        list[i] = heap.remove()
+        i+=1
+
+    return list
+
+
+

heaps/min_heap.py

@@ -1,9 +1,16 @@
 class HeapNode:
 
-    def initialize(self, key, value):
+    def __init__(self, key, value):
         self.key = key
         self.value = value
 
+    def __str__(self):
+        return str(self.value)
+
+    def __repr__(self):
+        return str(self.value)
+
+
 
 class MinHeap:
 
@@ -14,18 +21,33 @@ def __init__(self):
     def add(self, key, value = None):
         """ This method adds a HeapNode instance to the heap
             If value == None the new node's value should be set to key
-            Time Complexity: ?
-            Space Complexity: ?
+            Time Complexity: O(log n)
+            Space Complexity: O(log n)
         """
-        pass
+        if value == None:
+            value = key 
+
+        node = HeapNode(key, value)
+        self.store.append(node)
+        node_index = len(self.store) -1
+        self.heap_up(node_index)
+
 
     def remove(self):
         """ This method removes and returns an element from the heap
             maintaining the heap structure
-            Time Complexity: ?
-            Space Complexity: ?
+            Time Complexity: O(log n)
+            Space Complexity: O(log n)
         """
-        pass
+        if self.empty():
+            return None 
+
+        node_index = len(self.store) - 1 
+        self.swap(0, node_index)
+        min = self.store.pop()
+        self.heap_down(0)
+
+        return min.value 
 
 
 
@@ -39,27 +61,54 @@ def __str__(self):
 
     def empty(self):
         """ This method returns true if the heap is empty
-            Time complexity: ?
-            Space complexity: ?
+            Time complexity: O(1)
+            Space complexity: O(1)
         """
-        pass
-
+        return self.store == []
 
     def heap_up(self, index):
         """ This helper method takes an index and
             moves it up the heap, if it is less than it's parent node.
             It could be **very** helpful for the add method.
-            Time complexity: ?
-            Space complexity: ?
+            Time complexity: O(log n)
+            Space complexity: O(1)
         """
-        pass
+        if index == 0:
+            return None 
+
+        head_index = ((index - 1) // 2)
+
+        while self.store[head_index].key > self.store[index].key: 
+            self.swap(head_index, index)
+            self.heap_up(head_index)
 
     def heap_down(self, index):
         """ This helper method takes an index and 
             moves it up the heap if it's smaller
             than it's parent node.
         """
-        pass
+        node_index = len(self.store) -1 
+
+        if (index >= node_index):
+            return 
+
+        left = ((2 * index) + 2)
+        right = ((2 * index) + 1)
+
+        if(right > node_index): 
+            return 
+
+        if right < node_index + 1:
+            if left >= node_index + 1: 
+                down = right 
+            elif self.store[right].key < self.store[left].key:
+                down = right 
+            else:
+                down = left 
+
+        if self.store[index].key > self.store[down].key: 
+            self.swap(index, down)
+            self.heap_down(down)
 
 
     def swap(self, index_1, index_2):