From d655d9953d90a793459eaf8ce73f5ae86b1e94cd Mon Sep 17 00:00:00 2001
From: SterlingSunshine <katrina.kimzey@gmail.com>
Date: Mon, 13 Dec 2021 21:25:38 -0800
Subject: [PATCH] C15 - Katrina K

---
 heaps/heap_sort.py |  8 +++++--
 heaps/min_heap.py  | 54 ++++++++++++++++++++++++++++++++++------------
 2 files changed, 46 insertions(+), 16 deletions(-)

diff --git a/heaps/heap_sort.py b/heaps/heap_sort.py
index 3b834a5..286ac11 100644
--- a/heaps/heap_sort.py
+++ b/heaps/heap_sort.py
@@ -1,8 +1,12 @@
-
+from heaps.min_heap import MinHeap
 
 def heap_sort(list):
     """ This method uses a heap to sort an array.
         Time Complexity:  ?
         Space Complexity: ?
     """
-    pass
\ No newline at end of file
+    hold_heap = MinHeap()
+    for x in list:
+        hold_heap.add(x)
+
+    return [hold_heap.remove() for i in range(len(list))]
diff --git a/heaps/min_heap.py b/heaps/min_heap.py
index 0095872..8c7eb9e 100644
--- a/heaps/min_heap.py
+++ b/heaps/min_heap.py
@@ -1,5 +1,5 @@
 class HeapNode:
-  
+
     def __init__(self, key, value):
         self.key = key
         self.value = value
@@ -21,18 +21,28 @@ 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) *same space is added to the list every time but the behind the scenes buffer might be using more memory than this
         """
-        pass
+        self.store.append(HeapNode(key, (value if value else 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) < 1:
+            return
+        
+        self.swap(0, len(self.store) - 1)
+        ret_node = self.store.pop(len(self.store) - 1)
+        self.heap_down(0)
+
+        print(self.store)
+
+        return ret_node.value
 
 
     
@@ -46,10 +56,13 @@ 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
+        if len(self.store) < 1:
+            return True
+
+        return False
 
 
     def heap_up(self, index):
@@ -59,10 +72,14 @@ 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
+        if index is not 0 and self.store[index].key < self.store[(index - ((index +1) %2)) // 2].key:
+            self.swap(index, ((index - ((index +1) %2)) // 2))
+            self.heap_up((index - ((index +1) %2)) // 2)
+
+        return
 
     def heap_down(self, index):
         """ This helper method takes an index and 
@@ -70,7 +87,16 @@ def heap_down(self, index):
             larger than either of its children and continues until
             the heap property is reestablished.
         """
-        pass
+        if len(self.store) > (index * 2 + 1) and self.store[index].key > self.store[index * 2 + 1].key:
+            self.swap(index, (index * 2 + 1))
+            self.heap_down((index * 2 + 1))
+            self.heap_down(index)
+        elif len(self.store) > (index * 2 + 2) and self.store[index].key > self.store[index * 2 + 2].key:
+            self.swap(index, (index * 2 + 2))
+            self.heap_down((index * 2 + 2))
+            self.heap_down(index)
+
+        return
 
     
     def swap(self, index_1, index_2):