M. Nguyen - Heaps

heaps/heap_sort.py

@@ -1,8 +1,22 @@
-
+from heaps.min_heap import MinHeap
 
 def heap_sort(list):
     """ This method uses a heap to sort an array.
         Time Complexity:  ?
         Space Complexity: ?
     """
-    pass
+    heap = MinHeap()
+
+    # add every number in the list to the heap
+    for num in list:
+        heap.add(num)
+
+    index = 0
+    # while the heap is not empty, remove each node to create an ordered list
+    while not heap.empty():
+        list[index] = heap.remove()
+        index += 1
+
+    return list
+
+

heaps/min_heap.py

@@ -1,5 +1,5 @@
 class HeapNode:
-  
+
     def __init__(self, key, value):
         self.key = key
         self.value = value
@@ -11,29 +11,53 @@ def __repr__(self):
         return str(self.value)
 
 
-
 class MinHeap:
 
     def __init__(self):
         self.store = []
 
 
     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: ?
         """
-        pass
+        # check for value, if there is no value -> value of the new node should be set to key
+        if value is None:
+            value = key
+
+        # if there is a value
+        # create a node variable and add the node to the heap -> store/storage
+        node = HeapNode(key, value)
+        self.store.append(node)
+
+        # call heap_up (helper method) to ensure all nodes in heap are in the correct position
+        # checking the value of the appended node against it's parent node 
+        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: ?
         """
-        pass
+        # check if the heap is empty (call empty helper) -> if it's empty, there's  nothing to remove
+        if self.empty():
+            return None
+
+        # if the heap isn't empty, swap the root with the last index
+        self.swap(0, len(self.store) - 1)
+        # pop the root node, store this in a variable
+        minimum = self.store.pop()
 
+        # continue heaping down, starting from the root
+        self.heap_down(0)
+
+        # return the value of the var that was popped (the root)
+        return minimum.value
 
 
     def __str__(self):
@@ -43,14 +67,14 @@ def __str__(self):
             return "[]"
         return f"[{', '.join([str(element) for element in self.store])}]"
 
-
     def empty(self):
         """ This method returns true if the heap is empty
             Time complexity: ?
             Space complexity: ?
         """
-        pass
-
+        # this will return a boolean depending on if the length of store/storage is 0
+        # if store == 0 --> the heap is empty 
+        return len(self.store) == 0
 
     def heap_up(self, index):
         """ This helper method takes an index and
@@ -62,16 +86,43 @@ def heap_up(self, index):
             Time complexity: ?
             Space complexity: ?
         """
-        pass
+        if index == 0:
+            return index 
+
+        # find the parent index
+        parent_index = (index - 1) // 2
+
+        # check if the current index's key is larger than it's parent index's key
+        # if it is --> need to initiate a swap b/c the indexes are not in correct position
+        if self.store[parent_index].key > self.store[index].key:
+            # call swap helper method to switch the position's of the parent index and the current index
+            self.swap(parent_index, index)
+            # continue heaping up to ensure that all node's are in the correct position
+            self.heap_up(parent_index)
 
     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.
         """
-        pass
-
+        heap_arr = self.store
+
+        left_child = index * 2 + 1
+        right_child = index * 2 + 2
+
+        if left_child < len(heap_arr):
+            if right_child < len(heap_arr):
+                if heap_arr[left_child].key < heap_arr[right_child].key:
+                    smallest_child = left_child
+                else:
+                    smallest_child = right_child
+            else:
+                smallest_child = left_child
+
+            if heap_arr[index].key > heap_arr[smallest_child].key:
+                self.swap(index, smallest_child)
+                self.heap_down(smallest_child)
 
     def swap(self, index_1, index_2):
         """ Swaps two elements in self.store
@@ -81,3 +132,4 @@ def swap(self, index_1, index_2):
         temp = self.store[index_1]
         self.store[index_1] = self.store[index_2]
         self.store[index_2] = temp
+