diff --git a/heaps/heap_sort.py b/heaps/heap_sort.py
index 3b834a5..9c38b31 100644
--- a/heaps/heap_sort.py
+++ b/heaps/heap_sort.py
@@ -1,8 +1,19 @@
-
+from heapq import heappush, heappop
 
 def heap_sort(list):
     """ This method uses a heap to sort an array.
         Time Complexity:  ?
         Space Complexity: ?
     """
-    pass
\ No newline at end of file
+    heap = []
+
+    for item in list: 
+        heappush(heap, item)
+
+    ordered = []
+
+    while len(heap) > 0:
+        value = heappop(heap)
+        ordered.append(value)
+
+    return ordered
\ No newline at end of file
diff --git a/heaps/min_heap.py b/heaps/min_heap.py
index f6fe4e0..fde5ec3 100644
--- a/heaps/min_heap.py
+++ b/heaps/min_heap.py
@@ -1,3 +1,5 @@
+
+
 class HeapNode:
   
     def __init__(self, key, value):
@@ -15,25 +17,38 @@ 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: ?
+        """ Adds a HeapNode instance to the heap
+            If value == None the new node's value is set to key
+            Time Complexity: O(log n)
+            Space Complexity: O(n)
         """
-        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
+        """ Removes and returns root 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()
+
+        if not self.empty():
+            self.heap_down(0)
+
+        return min.value
 
-    
     def __str__(self):
         """ This method lets you print the heap, when you're testing your app.
         """
@@ -44,33 +59,51 @@ 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 the corresponding element up the heap, if 
-            it is less than it's parent node until the Heap
+        """ Moves the element identified by index up the heap 
+            If it is less than it's parent node until the Heap
             property is reestablished.
             
-            This could be **very** helpful for the add method.
-            Time complexity: ?
-            Space complexity: ?
+            Time complexity: O(1)
+            Space complexity: O(n)
         """
-        pass
+        if index == 0:
+            return 
+
+        parent = self.store[(index - 1)//2]
+
+        if self.store[index].key < parent.key:
+                self.swap(index, (index - 1)//2)
+                self.heap_up((index - 1)//2)
 
     def heap_down(self, index):
-        """ This helper method takes an index and 
-            moves the corresponding element down the heap if it's 
+        """ moves element at corresponding index down the heap if it's 
             larger than either of its children and continues until
             the heap property is reestablished.
         """
-        pass
+        left_index = (index * 2) + 1
+        right_index = (index * 2) + 2
+        parent = self.store[index]
+
+        if left_index < len(self.store):
+            if right_index < len(self.store):
+                if self.store[left_index].key < self.store[right_index].key:
+                    smaller_child = left_index
+                else:
+                    smaller_child = right_index
+            else: 
+                smaller_child = left_index
+
+            if parent.key > self.store[smaller_child].key:
+                self.swap(index, smaller_child)
+                self.heap_down(smaller_child)
 
-    
     def swap(self, index_1, index_2):
         """ Swaps two elements in self.store
             at index_1 and index_2