From 5987f68aed60bc2c55ba62e7855e996cf693f964 Mon Sep 17 00:00:00 2001 From: "Noor B.A" Date: Thu, 20 May 2021 16:42:08 -0700 Subject: [PATCH 1/2] finalized project --- lib/heap_sort.rb | 17 +++++++++++---- lib/min_heap.rb | 51 +++++++++++++++++++++++++++++++++---------- test/heapsort_test.rb | 2 +- 3 files changed, 53 insertions(+), 17 deletions(-) diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb index c8a32a4..63374ab 100644 --- a/lib/heap_sort.rb +++ b/lib/heap_sort.rb @@ -1,8 +1,17 @@ # This method uses a heap to sort an array. -# Time Complexity: ? -# Space Complexity: ? -def heap_sort(list) - raise NotImplementedError, "Method not implemented yet..." +# Time Complexity: O(n log n) +# Space Complexity: O(n) +def heapsort(list) + heap = MinHeap.new + result = [] + + list.each {|element| heap.add(element)} + + until heap.empty? + result << heap.remove + end + + return result end \ No newline at end of file diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 6eaa630..b87ec61 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -14,18 +14,27 @@ def initialize end # This method adds a HeapNode instance to the heap - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(log n) + # Space Complexity: O(log 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(log n) def remove() - raise NotImplementedError, "Method not implemented yet..." + return nil if @store.empty? + + swap(0, @store.length - 1) + removed = @store.pop + + heap_down(0) unless @store.empty? + + removed.value + end @@ -44,28 +53,46 @@ 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..." + @store.empty? end private # This helper method takes an index and - # moves it up the heap, if it is less than it's parent node. + # moves it up the heap, if it is less than its parent node. # It could be **very** helpful for the add method. # Time complexity: ? # Space complexity: ? def heap_up(index) - + parent = (index - 1 ) / 2 + + if index == 0 + return + elsif @store[index].key < @store[parent].key + swap(parent,index) + heap_up(parent) + end end # 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) - raise NotImplementedError, "Method not implemented yet..." + left_child = (index * 2) + 1 + right_child = (index * 2) + 2 + + if left_child >= @store.length + return + elsif @store[right_child] && @store[right_child].key < @store[left_child].key && @store[right_child].key < @store[index].key + swap(right_child, index) + heap_down(right_child) + elsif @store[left_child].key < @store[index].key + swap(left_child, index) + heap_down(left_child) + end end # If you want a swap method... you're welcome diff --git a/test/heapsort_test.rb b/test/heapsort_test.rb index 34402ac..7ce79b7 100644 --- a/test/heapsort_test.rb +++ b/test/heapsort_test.rb @@ -1,6 +1,6 @@ require_relative "test_helper" -xdescribe "heapsort" do +describe "heapsort" do it "sorts an empty array" do # Arrange list = [] From 15eba3f1cd0aa67aa4dde03d1c6533618c8656b1 Mon Sep 17 00:00:00 2001 From: "Noor B.A" Date: Tue, 26 Oct 2021 09:24:22 -0700 Subject: [PATCH 2/2] cleaned code --- lib/min_heap.rb | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index b87ec61..dfe0204 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -18,17 +18,19 @@ def initialize # Space Complexity: O(log n) def add(key, value = key) @store << HeapNode.new(key, value) - heap_up(@store.length - 1) + heap_up(@store.length - 1) # move the new added node up (swap with parent only) end + #This method removes and returns the smallest keyed value from the heap. # This method removes and returns an element from the heap + #This method removes and returns the smallest keyed value from the heap. # maintaining the heap structure # Time Complexity: O(log n) # Space Complexity: O(log n) - def remove() + def remove() # removing the first return nil if @store.empty? - swap(0, @store.length - 1) + swap(0, @store.length - 1) # swap the last element with the root removed = @store.pop heap_down(0) unless @store.empty? @@ -61,34 +63,40 @@ def empty? private + # down to up # This helper method takes an index and # moves it up the heap, if it is less than its parent node. # It could be **very** helpful for the add method. - # Time complexity: ? - # Space complexity: ? - def heap_up(index) + # Time complexity: O(logn) + # Space complexity: O(1) + def heap_up(index) # move the current index up to the parent and do the needed changes parent = (index - 1 ) / 2 if index == 0 return elsif @store[index].key < @store[parent].key swap(parent,index) - heap_up(parent) + heap_up(parent) # keep pushing the parent up till it's < @store[index].key end end + # up to down + # this method takes the parent(root) and 'heap it down' to it's right place # 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) - left_child = (index * 2) + 1 - right_child = (index * 2) + 2 + left_child = (index * 2) + 1 # odd is left child + right_child = (index * 2) + 2 # even is right child - if left_child >= @store.length + if left_child >= @store.length # reached the limit return + # if right child < parent AND + # if right child < left elsif @store[right_child] && @store[right_child].key < @store[left_child].key && @store[right_child].key < @store[index].key swap(right_child, index) heap_down(right_child) + # if left child < parent elsif @store[left_child].key < @store[index].key swap(left_child, index) heap_down(left_child)