From 5c0493ee29bcebe2c9291b4fc3d2f958ecbe477a Mon Sep 17 00:00:00 2001
From: Yolotzin Dunbar <yltzndnbr@gmail.com>
Date: Wed, 30 Sep 2020 22:12:24 -0700
Subject: [PATCH] Added functions

---
 lib/heap_sort.rb      | 25 +++++++++++++---
 lib/min_heap.rb       | 69 ++++++++++++++++++++++++++++++++++---------
 test/heapsort_test.rb |  8 ++---
 3 files changed, 80 insertions(+), 22 deletions(-)

diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb
index c8a32a4..911ca42 100644
--- a/lib/heap_sort.rb
+++ b/lib/heap_sort.rb
@@ -1,8 +1,25 @@
 
 
 # This method uses a heap to sort an array.
-# Time Complexity:  ?
-# Space Complexity: ?
+# Time Complexity:  O(n log n)
+# Space Complexity: O(n)
 def heap_sort(list)
-  raise NotImplementedError, "Method not implemented yet..."
-end
\ No newline at end of file
+  if list.size < 2
+    return list
+  end
+  heap = MinHeap.new
+  list.each do |element|
+    heap.add(element)
+  end
+  result = []
+  list.size.times do
+    result << heap.remove
+  end
+  return result
+end
+
+# Since you do n additions and adding 1 item to a heap is O(log n), filling up the heap is O(n log n).
+# Then removing all n item is O(n log n) because removing one item from a heap is O(log n).
+# So the total Time Complexity is O(n log n + n log n) = O(n log n)
+
+# you can do HeapSort with O(1) space complexity (using the original array for the heap).
\ No newline at end of file
diff --git a/lib/min_heap.rb b/lib/min_heap.rb
index 6eaa630..e623e22 100644
--- a/lib/min_heap.rb
+++ b/lib/min_heap.rb
@@ -7,25 +7,33 @@ def initialize(key, value)
   end
 end
 
-class MinHeap
+class MinHeap # every node is smaller than or equal to it's children
 
   def initialize
     @store = []
   end
 
   # This method adds a HeapNode instance to the heap
-  # Time Complexity: ?
-  # Space Complexity: ?
+  # Time Complexity: O(log n)
+  # Space Complexity: O(n)
   def add(key, value = key)
-    raise NotImplementedError, "Method not implemented yet..."
+    @store << HeapNode.new(key, value)
+    heap_up(@store.length - 1)
   end
 
   # 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(n)
   def remove()
-    raise NotImplementedError, "Method not implemented yet..."
+    return nil if @store.empty?
+    # swap the root node and last leaf
+    swap(0, @store.length - 1)
+    # delete the last leaf
+    result = @store.pop
+    # start heap_down with the new root
+    heap_down(0) unless @store.empty?
+    return result.value
   end
 
 
@@ -44,10 +52,10 @@ def to_s
   end
 
   # This method returns true if the heap is empty
-  # Time complexity: ?
-  # Space complexity: ?
+  # Time complexity: O(1)
+  # Space complexity: O(1)
   def empty?
-    raise NotImplementedError, "Method not implemented yet..."
+    return @store.size == 0
   end
 
   private
@@ -55,17 +63,50 @@ 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: ?
-  # Space complexity: ?
+  # Time complexity: O(log n)
+  # Space complexity: O(n)
   def heap_up(index)
+    # base case: if we hit root
+    return if index == 0
+    # compare new node with it's parent
+    # if they are out of order swap and heap-up using the parent's index number
+    parent = (index - 1) / 2
+    if @store[index].key < @store[parent].key # if current < parent, swap
+      swap(index, parent)
+      # recursion base case: if we hit root or if parent value < current node value
+      heap_up(parent)
+    end
     
   end
 
   # This helper method takes an index and 
-  #  moves it up the heap if it's smaller
+  #  moves it down the heap if it's larger
   #  than it's parent node.
   def heap_down(index)
-    raise NotImplementedError, "Method not implemented yet..."
+    # base case: until current doesn't have children || max child < array[current]
+    left_child = 2 * index + 1
+    right_child = 2 * index + 2
+    max_child = @store.size
+    return if index == (max_child)
+    if @store[left_child] && @store[right_child] # if both children
+      min_child = [@store[left_child].key, @store[right_child].key].min
+      if min_child == @store[left_child].key # if left to right order, swap left and heap down left
+        swap(left_child, index)
+        heap_down(left_child)
+      else
+        swap(right_child, index)
+        heap_down(right_child)
+      end
+    elsif @store[left_child] # there must be a left child
+      if @store[left_child].key < @store[index].key
+        swap(left_child, index)
+        heap_down(left_child)
+      else
+        swap(right_child, index)
+        heap_down(right_child)
+      end
+    end
+    return
   end
 
   # If you want a swap method... you're welcome
diff --git a/test/heapsort_test.rb b/test/heapsort_test.rb
index 34402ac..76e3fdc 100644
--- a/test/heapsort_test.rb
+++ b/test/heapsort_test.rb
@@ -1,12 +1,12 @@
 require_relative "test_helper"
 
-xdescribe "heapsort" do
+describe "heap_sort" do
   it "sorts an empty array" do
     # Arrange 
     list = []
 
     # Act
-    result = heapsort(list)
+    result = heap_sort(list)
 
     # Assert
     expect(result).must_equal []
@@ -17,7 +17,7 @@
     list = [5]
 
     # Act
-    result = heapsort(list)
+    result = heap_sort(list)
 
     # Assert
     expect(result).must_equal [5]
@@ -28,7 +28,7 @@
     list = [5, 27, 3, 16, -50]
 
     # Act
-    result = heapsort(list)
+    result = heap_sort(list)
 
     # Assert
     expect(result).must_equal [-50, 3, 5, 16, 27]