diff --git a/heaps/heap_sort.py b/heaps/heap_sort.py
index 3b834a5..289df6a 100644
--- a/heaps/heap_sort.py
+++ b/heaps/heap_sort.py
@@ -1,8 +1,19 @@
-
+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
+        Time Complexity:  O log(n)
+        Space Complexity: O (1)    """
+    heap = MinHeap()
+    # adding element in list
+    for elem in list:
+        heap.add(elem)
+
+    sorted_list = []
+    while heap.store:
+        # remove
+        elem = heap.remove()
+        # append sorted element
+        sorted_list.append(elem)
+
+    return sorted_list
\ No newline at end of file
diff --git a/heaps/min_heap.py b/heaps/min_heap.py
index 0095872..0a8b776 100644
--- a/heaps/min_heap.py
+++ b/heaps/min_heap.py
@@ -1,5 +1,4 @@
 class HeapNode:
-  
     def __init__(self, key, value):
         self.key = key
         self.value = value
@@ -7,13 +6,8 @@ def __init__(self, key, value):
     def __str__(self):
         return str(self.value)
 
-    def __repr__(self):
-        return str(self.value)
-
-
 
 class MinHeap:
-
     def __init__(self):
         self.store = []
 
@@ -21,20 +15,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 len(self.store) == 0:
+            return
+        
+        self.swap(0, len(self.store) - 1)
+        min = self.store.pop()
+        self.heap_down(0)
 
+        return min.value
     
     def __str__(self):
         """ This method lets you print the heap, when you're testing your app.
@@ -46,10 +50,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 len(self.store) == 0
 
 
     def heap_up(self, index):
@@ -59,10 +63,16 @@ def heap_up(self, index):
             property is reestablished.
             
             This could be **very** helpful for the add method.
-            Time complexity: ?
-            Space complexity: ?
+            Time complexity: O(1)
+            Space complexity: O(1)
         """
-        pass
+        if index == 0:
+            return 
+        
+        parent = (index -1) // 2
+        if self.store[index].key < self.store[parent].key:
+            self.swap(index, parent)
+            self.heap_up(parent)
 
     def heap_down(self, index):
         """ This helper method takes an index and 
@@ -70,9 +80,17 @@ def heap_down(self, index):
             larger than either of its children and continues until
             the heap property is reestablished.
         """
-        pass
+        min_child_index = 2 * index + 1
+        child2_index = 2 * index + 2
+        if child2_index < len(self.store) and self.store[child2_index].key < self.store[min_child_index].key:
+            min_child_index = child2_index
+
+        if min_child_index >= len(self.store):
+            return None
+        elif self.store[min_child_index].key < self.store[index].key:
+            self.swap(index, min_child_index)
+            self.heap_down(min_child_index)
 
-    
     def swap(self, index_1, index_2):
         """ Swaps two elements in self.store
             at index_1 and index_2
@@ -80,4 +98,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
+        self.store[index_2] = temp
\ No newline at end of file