Cedar - Jessica Carnes

heaps/heap_sort.py

@@ -1,8 +1,20 @@
 
 
+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(n)
     """
-    pass
+    heap = MinHeap()
+
+    for item in list:
+        heap.add(item)
+
+    i = 0
+    while not heap.empty():
+        list[i] = heap.remove()
+        i += 1
+    return list

heaps/min_heap.py

@@ -22,16 +22,26 @@ def add(self, key, value = None):
             Time Complexity: ?
             Space Complexity: ?
         """
-        pass
+        if value != None:
+            self.store.append(HeapNode(key, value))
+        else:
+            self.store.append(HeapNode(key, key))
+
+        self.heap_up(len(self.store) - 1)
+
 
     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(1)
         """
-        pass
-
+        if len(self.store) == 0:
+            return
+        self.swap(len(self.store) - 1, 0)
+        removed_element = self.store.pop()
+        self.heap_down(0)
+        return removed_element.value
 
 
     def __str__(self):
@@ -44,10 +54,10 @@ 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 True if len(self.store) == 0 else False
 
 
     def heap_up(self, index):
@@ -57,19 +67,54 @@ def heap_up(self, index):
             property is reestablished.
 
             This could be **very** helpful for the add method.
-            Time complexity: ?
-            Space complexity: ?
+            Time complexity: O(log n)
+            Space complexity: O(1)
         """
-        pass
+        curr_index = index
+        while curr_index > 0:
+            parent_index = (curr_index - 1) // 2
+            if self.store[curr_index].key < self.store[parent_index].key:
+                self.swap(curr_index, parent_index)
+                curr_index = parent_index
+            else: 
+                return
+        return
+
 
     def heap_down(self, index):
         """ This helper method takes an index and 
             moves the corresponding element down the heap if it's 
             larger than either of its children and continues until
             the heap property is reestablished.
+            Time complexity: O(log n)
+            Space complexity: O(1)
         """
-        pass
 
+        curr_index = index
+        left_child_index = curr_index * 2 + 1
+        right_child_index = curr_index * 2 + 2
+
+        while left_child_index < len(self.store):
+            if right_child_index >= len(self.store):
+                if self.store[curr_index].key > self.store[left_child_index].key:
+                    self.swap(curr_index, left_child_index)
+                return
+            if self.store[left_child_index].key < self.store[right_child_index].key:
+                if self.store[curr_index].key > self.store[left_child_index].key:
+                    self.swap(curr_index, left_child_index)
+                    curr_index = left_child_index
+                else: 
+                    return
+            else:
+                if self.store[curr_index].key > self.store[right_child_index].key:
+                    self.swap(curr_index, right_child_index)
+                    curr_index = right_child_index
+                else:
+                    return
+            left_child_index = curr_index * 2 + 1
+            right_child_index = curr_index * 2 + 2
+        return
+
 
     def swap(self, index_1, index_2):
         """ Swaps two elements in self.store