From a7c2439e8f0a70f5d2e197ced5269ad01d1feca9 Mon Sep 17 00:00:00 2001
From: Jansen <v.jansen.martin@gmail.com>
Date: Thu, 19 Sep 2019 16:39:54 -0700
Subject: [PATCH 1/7] Add 'add' and 'heap_up' methods

---
 lib/min_heap.rb | 31 +++++++++++++++++++++++--------
 1 file changed, 23 insertions(+), 8 deletions(-)

diff --git a/lib/min_heap.rb b/lib/min_heap.rb
index 6eaa630..4bc5f9e 100644
--- a/lib/min_heap.rb
+++ b/lib/min_heap.rb
@@ -8,7 +8,6 @@ def initialize(key, value)
 end
 
 class MinHeap
-
   def initialize
     @store = []
   end
@@ -17,7 +16,11 @@ def initialize
   # Time Complexity: ?
   # Space Complexity: ?
   def add(key, value = key)
-    raise NotImplementedError, "Method not implemented yet..."
+    # raise NotImplementedError, "Method not implemented yet..."
+    new_node = HeapNode.new(key, value)
+    @store << new_node
+
+    heap_up(@store.length - 1)
   end
 
   # This method removes and returns an element from the heap
@@ -28,7 +31,6 @@ def remove()
     raise NotImplementedError, "Method not implemented yet..."
   end
 
-
   # Used for Testing
   def to_s
     return "[]" if @store.empty?
@@ -39,7 +41,7 @@ def to_s
     end
 
     output += @store.last.value + "]"
-      
+
     return output
   end
 
@@ -55,13 +57,26 @@ def empty?
   # 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: ?
+  # Time complexit`y: ?
   # Space complexity: ?
   def heap_up(index)
-    
+    parent_index = (index - 1) / 2 # get parent index based on child's position
+
+    # return the array if there's no parent, or parent is less than or equal to child
+    return @store if parent_index < 0 || @store[index].key >= @store[parent_index].key
+
+    # temporarily storing parent
+    parent_temp = @store[parent_index]
+    # child is now in parent's index
+    @store[parent_index] = @store[index]
+    # parent is now in child's former position
+    @store[index] = parent_temp
+
+    # call recursively on child's new position
+    heap_up(parent_index)
   end
 
-  # This helper method takes an index and 
+  # This helper method takes an index and
   #  moves it up the heap if it's smaller
   #  than it's parent node.
   def heap_down(index)
@@ -74,4 +89,4 @@ def swap(index_1, index_2)
     @store[index_1] = @store[index_2]
     @store[index_2] = temp
   end
-end
\ No newline at end of file
+end

From b16591adce9c56c8ab6566bd9fe3d419b1891b36 Mon Sep 17 00:00:00 2001
From: Jansen <v.jansen.martin@gmail.com>
Date: Sun, 22 Sep 2019 14:25:16 -0700
Subject: [PATCH 2/7] Add 'remove' and 'heap-down' methods

---
 lib/min_heap.rb | 39 ++++++++++++++++++++++++++++++++++++---
 1 file changed, 36 insertions(+), 3 deletions(-)

diff --git a/lib/min_heap.rb b/lib/min_heap.rb
index 4bc5f9e..4db571c 100644
--- a/lib/min_heap.rb
+++ b/lib/min_heap.rb
@@ -16,7 +16,6 @@ def initialize
   # Time Complexity: ?
   # Space Complexity: ?
   def add(key, value = key)
-    # raise NotImplementedError, "Method not implemented yet..."
     new_node = HeapNode.new(key, value)
     @store << new_node
 
@@ -28,7 +27,16 @@ def add(key, value = key)
   # Time Complexity: ?
   # Space Complexity: ?
   def remove()
-    raise NotImplementedError, "Method not implemented yet..."
+    root = @store[0]
+    new_root = @store[@store.length - 1]
+
+    @store[0] = new_root
+    @store[@store.length - 1] = root
+
+    removed = @store.pop
+
+    heap_down(0)
+    return removed.value
   end
 
   # Used for Testing
@@ -80,7 +88,32 @@ def heap_up(index)
   #  moves it up the heap if it's smaller
   #  than it's parent node.
   def heap_down(index)
-    raise NotImplementedError, "Method not implemented yet..."
+    left_child = 2 * index + 1
+    right_child = 2 * index + 2
+    min_child = nil
+
+    # Return if there's no left child
+    return if left_child > @store.length - 1
+
+    # If there's no RIGHT child AND parent is greater than LEFT child...
+    # swap parent with left child
+    if @store[right_child].nil? && @store[index].key > @store[left_child].key
+      swap(index, left_child)
+      heap_down(index)
+    end
+
+    # Otherwise, which child is min?
+    if @store[right_child].key <= @store[left_child].key
+      min_child = @store.index(@store[right_child])
+    else
+      min_child = @store.index(@store[left_child])
+    end
+
+    # If parent is greater than minimum child, swap them
+    if @store[index].key > @store[min_child].key
+      swap(index, min_child)
+      heap_down(index)
+    end
   end
 
   # If you want a swap method... you're welcome

From f205f081762f2ff1887e45b367185c62b702e303 Mon Sep 17 00:00:00 2001
From: Jansen <v.jansen.martin@gmail.com>
Date: Sun, 22 Sep 2019 14:32:52 -0700
Subject: [PATCH 3/7] Add 'empty?' method

---
 lib/min_heap.rb | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib/min_heap.rb b/lib/min_heap.rb
index 4db571c..6681902 100644
--- a/lib/min_heap.rb
+++ b/lib/min_heap.rb
@@ -30,8 +30,8 @@ def remove()
     root = @store[0]
     new_root = @store[@store.length - 1]
 
-    @store[0] = new_root
     @store[@store.length - 1] = root
+    @store[0] = new_root
 
     removed = @store.pop
 
@@ -57,7 +57,9 @@ def to_s
   # Time complexity: ?
   # Space complexity: ?
   def empty?
-    raise NotImplementedError, "Method not implemented yet..."
+    # raise NotImplementedError, "Method not implemented yet..."
+    return true if @store == []
+    return false
   end
 
   private

From 3a4927f9952b6e85d0c99f68c1aa6622d50ac8fe Mon Sep 17 00:00:00 2001
From: Jansen <v.jansen.martin@gmail.com>
Date: Sun, 22 Sep 2019 14:47:33 -0700
Subject: [PATCH 4/7] Add 'swap' helper method to 'heap_up' method

---
 lib/min_heap.rb | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/lib/min_heap.rb b/lib/min_heap.rb
index 6681902..c10bb15 100644
--- a/lib/min_heap.rb
+++ b/lib/min_heap.rb
@@ -57,7 +57,6 @@ def to_s
   # Time complexity: ?
   # Space complexity: ?
   def empty?
-    # raise NotImplementedError, "Method not implemented yet..."
     return true if @store == []
     return false
   end
@@ -75,12 +74,7 @@ def heap_up(index)
     # return the array if there's no parent, or parent is less than or equal to child
     return @store if parent_index < 0 || @store[index].key >= @store[parent_index].key
 
-    # temporarily storing parent
-    parent_temp = @store[parent_index]
-    # child is now in parent's index
-    @store[parent_index] = @store[index]
-    # parent is now in child's former position
-    @store[index] = parent_temp
+    swap(parent_index, index)
 
     # call recursively on child's new position
     heap_up(parent_index)

From adfa7918f0ee5dcd6a777206915cdc4948538460 Mon Sep 17 00:00:00 2001
From: Jansen <v.jansen.martin@gmail.com>
Date: Sun, 22 Sep 2019 15:16:32 -0700
Subject: [PATCH 5/7] Add time/space complexity

---
 lib/min_heap.rb | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/lib/min_heap.rb b/lib/min_heap.rb
index c10bb15..f6c2c44 100644
--- a/lib/min_heap.rb
+++ b/lib/min_heap.rb
@@ -13,8 +13,8 @@ def initialize
   end
 
   # This method adds a HeapNode instance to the heap
-  # Time Complexity: ?
-  # Space Complexity: ?
+  # Time Complexity: O(log n), where n is the number of levels in the heap
+  # Space Complexity: O(1), because there are no extra variables that change with input size
   def add(key, value = key)
     new_node = HeapNode.new(key, value)
     @store << new_node
@@ -24,8 +24,8 @@ def add(key, value = key)
 
   # This method removes and returns an element from the heap
   #   maintaining the heap structure
-  # Time Complexity: ?
-  # Space Complexity: ?
+  # Time Complexity: O(log n), where n is the number of levels in the heap
+  # Space Complexity: O(1), because there are no extra variables that change with input size
   def remove()
     root = @store[0]
     new_root = @store[@store.length - 1]
@@ -54,8 +54,8 @@ def to_s
   end
 
   # This method returns true if the heap is empty
-  # Time complexity: ?
-  # Space complexity: ?
+  # Time complexity: O(1), because we're making a straight comparison
+  # Space complexity: O(1), because there are no extra variables that change with input size
   def empty?
     return true if @store == []
     return false
@@ -66,8 +66,8 @@ def empty?
   # 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 complexit`y: ?
-  # Space complexity: ?
+  # Time complexity: O(log n), where n is the number of levels inside the heap
+  # Space complexity: O(1), because there are no extra variables that hinge on input size
   def heap_up(index)
     parent_index = (index - 1) / 2 # get parent index based on child's position
 

From 29793e5dfb12f14292756fbf3449d972fb640072 Mon Sep 17 00:00:00 2001
From: Jansen <v.jansen.martin@gmail.com>
Date: Sat, 5 Oct 2019 13:20:18 -0700
Subject: [PATCH 6/7] Add heapsort.  Correct conditional block bug inside
 heap_down method.  All tests passing

---
 lib/heap_sort.rb      | 28 ++++++++++++++++++++++++----
 lib/min_heap.rb       | 24 ++++++++++++------------
 test/heapsort_test.rb | 14 +++++++-------
 3 files changed, 43 insertions(+), 23 deletions(-)

diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb
index c8a32a4..e4d3ae6 100644
--- a/lib/heap_sort.rb
+++ b/lib/heap_sort.rb
@@ -1,8 +1,28 @@
-
+require_relative "min_heap"
 
 # This method uses a heap to sort an array.
 # Time Complexity:  ?
 # Space Complexity: ?
-def heap_sort(list)
-  raise NotImplementedError, "Method not implemented yet..."
-end
\ No newline at end of file
+def heapsort(list)
+  return list if list == [] || list.length == 1
+
+  # initialize new heap
+  heap = MinHeap.new
+
+  # add each element in list to heap's store
+  list.each do |num|
+    key = num
+    value = num
+
+    heap.add(key, value)
+  end
+
+  sorted_list = []
+  # take each element out of heap's store, keep it in another array
+  list.length.times do
+    removed = heap.remove
+    sorted_list << removed
+  end
+
+  return sorted_list
+end
diff --git a/lib/min_heap.rb b/lib/min_heap.rb
index f6c2c44..e1162eb 100644
--- a/lib/min_heap.rb
+++ b/lib/min_heap.rb
@@ -14,7 +14,7 @@ def initialize
 
   # This method adds a HeapNode instance to the heap
   # Time Complexity: O(log n), where n is the number of levels in the heap
-  # Space Complexity: O(1), because there are no extra variables that change with input size
+  # Space Complexity: O(log n), where n is the number of times `heap_up` is called recursively
   def add(key, value = key)
     new_node = HeapNode.new(key, value)
     @store << new_node
@@ -25,7 +25,7 @@ def add(key, value = key)
   # This method removes and returns an element from the heap
   #   maintaining the heap structure
   # Time Complexity: O(log n), where n is the number of levels in the heap
-  # Space Complexity: O(1), because there are no extra variables that change with input size
+  # Space Complexity: O(log n), where n is the number of times `heap_down` is called recursively
   def remove()
     root = @store[0]
     new_root = @store[@store.length - 1]
@@ -67,9 +67,10 @@ def empty?
   #  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: O(log n), where n is the number of levels inside the heap
-  # Space complexity: O(1), because there are no extra variables that hinge on input size
+  # Space complexity: O(log n), where n is the number of times the method is recursively called
   def heap_up(index)
-    parent_index = (index - 1) / 2 # get parent index based on child's position
+    # get parent index based on child's position
+    parent_index = (index - 1) / 2
 
     # return the array if there's no parent, or parent is less than or equal to child
     return @store if parent_index < 0 || @store[index].key >= @store[parent_index].key
@@ -96,17 +97,16 @@ def heap_down(index)
     if @store[right_child].nil? && @store[index].key > @store[left_child].key
       swap(index, left_child)
       heap_down(index)
-    end
-
-    # Otherwise, which child is min?
-    if @store[right_child].key <= @store[left_child].key
-      min_child = @store.index(@store[right_child])
-    else
-      min_child = @store.index(@store[left_child])
+    elsif @store[right_child] #Otherwise, which child is min?
+      if @store[right_child].key <= @store[left_child].key
+        min_child = @store.index(@store[right_child])
+      else
+        min_child = @store.index(@store[left_child])
+      end
     end
 
     # If parent is greater than minimum child, swap them
-    if @store[index].key > @store[min_child].key
+    if min_child && @store[index].key > @store[min_child].key
       swap(index, min_child)
       heap_down(index)
     end
diff --git a/test/heapsort_test.rb b/test/heapsort_test.rb
index 34402ac..9964e33 100644
--- a/test/heapsort_test.rb
+++ b/test/heapsort_test.rb
@@ -1,8 +1,8 @@
 require_relative "test_helper"
 
-xdescribe "heapsort" do
+describe "heapsort" do
   it "sorts an empty array" do
-    # Arrange 
+    # Arrange
     list = []
 
     # Act
@@ -13,7 +13,7 @@
   end
 
   it "can sort a 1-element array" do
-    # Arrange 
+    # Arrange
     list = [5]
 
     # Act
@@ -22,9 +22,9 @@
     # Assert
     expect(result).must_equal [5]
   end
-  
+
   it "can sort a 5-element array" do
-    # Arrange 
+    # Arrange
     list = [5, 27, 3, 16, -50]
 
     # Act
@@ -32,5 +32,5 @@
 
     # Assert
     expect(result).must_equal [-50, 3, 5, 16, 27]
-  end  
-end
\ No newline at end of file
+  end
+end

From 509f0a52af0228d465951c6cf6a6617b57d28f67 Mon Sep 17 00:00:00 2001
From: Jansen <v.jansen.martin@gmail.com>
Date: Sat, 5 Oct 2019 14:21:01 -0700
Subject: [PATCH 7/7] Correct time and space complexities

---
 lib/heap_sort.rb |  4 ++--
 lib/min_heap.rb  | 15 +++++++++------
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb
index e4d3ae6..c26acd4 100644
--- a/lib/heap_sort.rb
+++ b/lib/heap_sort.rb
@@ -1,8 +1,8 @@
 require_relative "min_heap"
 
 # This method uses a heap to sort an array.
-# Time Complexity:  ?
-# Space Complexity: ?
+# Time Complexity:  O(n log n)
+# Space Complexity: O(n) times the number of recursive operations required to finish sorting
 def heapsort(list)
   return list if list == [] || list.length == 1
 
diff --git a/lib/min_heap.rb b/lib/min_heap.rb
index e1162eb..7f022dc 100644
--- a/lib/min_heap.rb
+++ b/lib/min_heap.rb
@@ -13,8 +13,9 @@ def initialize
   end
 
   # This method adds a HeapNode instance to the heap
-  # Time Complexity: O(log n), where n is the number of levels in the heap
-  # Space Complexity: O(log n), where n is the number of times `heap_up` is called recursively
+  # Time Complexity: O(log n), where n is the number of nodes in the heap
+  # Space complexity: O(log n), where n is the number of nodes in the heap.  The reason it's O(log n) (and not O(1)) is
+  # because we're calling this method recursively.
   def add(key, value = key)
     new_node = HeapNode.new(key, value)
     @store << new_node
@@ -24,8 +25,9 @@ def add(key, value = key)
 
   # This method removes and returns an element from the heap
   #   maintaining the heap structure
-  # Time Complexity: O(log n), where n is the number of levels in the heap
-  # Space Complexity: O(log n), where n is the number of times `heap_down` is called recursively
+  # Time Complexity: O(log n), where n is the number of nodes in the heap
+  # Space complexity: O(log n), where n is the number of nodes in the heap.  The reason it's O(log n) (and not O(1)) is
+  # because we're calling this method recursively.
   def remove()
     root = @store[0]
     new_root = @store[@store.length - 1]
@@ -66,8 +68,9 @@ def empty?
   # 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: O(log n), where n is the number of levels inside the heap
-  # Space complexity: O(log n), where n is the number of times the method is recursively called
+  # Time complexity: O(log n), where n is the number of nodes in the heap
+  # Space complexity: O(log n), where n is the number of nodes in the heap.  The reason it's O(log n) (and not O(1)) is
+  # because we're calling this method recursively.
   def heap_up(index)
     # get parent index based on child's position
     parent_index = (index - 1) / 2