From f09bad7a4125167eb319577c264a3481dd504361 Mon Sep 17 00:00:00 2001
From: Courtney <courtneycmassey@gmail.com>
Date: Sat, 8 Jan 2022 13:06:58 -0800
Subject: [PATCH 1/2] heap_sort

---
 heaps/heap_sort.py | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/heaps/heap_sort.py b/heaps/heap_sort.py
index 3b834a5..54da021 100644
--- a/heaps/heap_sort.py
+++ b/heaps/heap_sort.py
@@ -1,8 +1,18 @@
-
+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)
+        Space Complexity: O(1)
     """
-    pass
\ No newline at end of file
+    heap = MinHeap()
+
+    for num in list:
+        heap.add(num)
+    
+    index = 0
+    while not heap.empty():
+        list[index] = heap.remove()
+        index += 1
+    
+    return list
\ No newline at end of file

From 25d0dee1dc68a979a3b1c6bf607f5efce2138e74 Mon Sep 17 00:00:00 2001
From: Courtney <courtneycmassey@gmail.com>
Date: Sat, 8 Jan 2022 13:10:41 -0800
Subject: [PATCH 2/2] passing all tests

---
 heaps/min_heap.py | 63 ++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 49 insertions(+), 14 deletions(-)

diff --git a/heaps/min_heap.py b/heaps/min_heap.py
index a1340e3..e52e00e 100644
--- a/heaps/min_heap.py
+++ b/heaps/min_heap.py
@@ -1,8 +1,11 @@
 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)
 
 
 class MinHeap:
@@ -14,19 +17,30 @@ 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(1)
         """
-        pass
+        if value == None:
+            value = key
+        
+        node = HeapNode(key, value)
+        self.store.append(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: ?
+            Time Complexity: O(log n)
+            Space Complexity: O(1)
         """
-        pass
+        if self.empty():
+            return None
+        
+        self.swap(0, len(self.store) - 1)
+        min = self.store.pop()
+        self.heap_down(0)
 
+        return min.value
 
     
     def __str__(self):
@@ -39,27 +53,48 @@ 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 len(self.store) == 0
 
 
     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(log n)
         """
-        pass
+        if index == 0:
+            return index
+        
+        parent_index = (index - 1) // 2
+
+        if self.store[parent_index].key > self.store[index].key:
+            self.swap(parent_index, index)
+            self.heap_up(parent_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
+        left_child_index = (2 * index) + 1
+        right_child_index = (2 * index) + 2
+
+        if left_child_index < len(self.store):
+            if right_child_index < len(self.store):
+                if self.store[left_child_index].key < self.store[right_child_index].key:
+                    min_child_index = left_child_index
+                else:
+                    min_child_index = right_child_index
+            else:
+                min_child_index = left_child_index
+            
+            if self.store[index].key > self.store[min_child_index].key:
+                self.swap(index, min_child_index)
+                self.heap_down(min_child_index)
 
     
     def swap(self, index_1, index_2):