From ef9211510ea601fd4336dd15e53f36df283006fc Mon Sep 17 00:00:00 2001 From: Sara Nilsen Date: Tue, 29 Sep 2020 20:11:47 -0700 Subject: [PATCH 1/2] min heap --- lib/min_heap.rb | 47 +++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 41 insertions(+), 6 deletions(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 6eaa630..fdb4874 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -17,7 +17,11 @@ def initialize # Time Complexity: ? # Space Complexity: ? def add(key, value = key) - raise NotImplementedError, "Method not implemented yet..." + # if odd is being added to the right + # if even is being added to the left + @store << HeapNode.new(key, value) + + heap_up(@store.length - 1) end # This method removes and returns an element from the heap @@ -25,7 +29,17 @@ def add(key, value = key) # Time Complexity: ? # Space Complexity: ? def remove() - raise NotImplementedError, "Method not implemented yet..." + if @store.empty? + return nil + end + + swap(0, @store.length - 1) + result = @store.pop + + heap_down(0) unless @store.empty? + return result.value + + end @@ -47,7 +61,7 @@ def to_s # Time complexity: ? # Space complexity: ? def empty? - raise NotImplementedError, "Method not implemented yet..." + return @store.empty? end private @@ -57,15 +71,36 @@ def empty? # It could be **very** helpful for the add method. # Time complexity: ? # Space complexity: ? - def heap_up(index) - + def heap_up(index) # last index first time + parent = (index - 1) / 2 + bottom = @store[index] + + if index > 0 && @store[parent].key > bottom.key + swap(index, parent) + 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..." + + max_length = @store.length - 1 + child_left = index * 2 + 1 + child_right = index * 2 + 2 + top = @store[index] + + if index <= max_length + if !@store[child_left].nil? && top.key > @store[child_left].key + heap_down(child_left) + swap(index, child_left) + + elsif !@store[child_right].nil? && top.key > @store[child_right].key + swap(index, child_right) + heap_down(child_left) + end + end end # If you want a swap method... you're welcome From 07226b827d98ddba59f8219da66284cb1ab31b6b Mon Sep 17 00:00:00 2001 From: Sara Nilsen Date: Wed, 30 Sep 2020 18:01:13 -0700 Subject: [PATCH 2/2] heap_sort --- lib/heap_sort.rb | 23 ++++++++-- lib/min_heap.rb | 48 ++++++++++---------- test/{heapsort_test.rb => heap_sort_test.rb} | 8 ++-- 3 files changed, 48 insertions(+), 31 deletions(-) rename test/{heapsort_test.rb => heap_sort_test.rb} (80%) diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb index 6b692e4..d790bf3 100644 --- a/lib/heap_sort.rb +++ b/lib/heap_sort.rb @@ -1,8 +1,23 @@ # This method uses a heap to sort an array. -# Time Complexity: ? -# Space Complexity: ? -def heapsort(list) - raise NotImplementedError, "Method not implemented yet..." +# Time Complexity: O(n log n) +# Space Complexity: O(n) +def heap_sort(list) + heap_list = MinHeap.new + result = [] + + list.each do |num| + heap_list.add(num) + end + + i = 0 + while i < list.length + removed = heap_list.remove() + result[i] = removed + puts "#{result}" + i += 1 + end + + return result end \ No newline at end of file diff --git a/lib/min_heap.rb b/lib/min_heap.rb index fdb4874..b75d723 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -14,8 +14,8 @@ def initialize end # This method adds a HeapNode instance to the heap - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(log n) + # Space Complexity: O(1) def add(key, value = key) # if odd is being added to the right # if even is being added to the left @@ -26,8 +26,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) + # Space Complexity: O(1) def remove() if @store.empty? return nil @@ -58,8 +58,8 @@ 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? return @store.empty? end @@ -69,8 +69,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 complexity: ? - # Space complexity: ? + # Time complexity: O(log n) + # Space complexity: O(log n) def heap_up(index) # last index first time parent = (index - 1) / 2 bottom = @store[index] @@ -85,22 +85,24 @@ def heap_up(index) # last index first time # moves it up the heap if it's smaller # than it's parent node. def heap_down(index) - - max_length = @store.length - 1 - child_left = index * 2 + 1 - child_right = index * 2 + 2 - top = @store[index] - - if index <= max_length - if !@store[child_left].nil? && top.key > @store[child_left].key - heap_down(child_left) - swap(index, child_left) - - elsif !@store[child_right].nil? && top.key > @store[child_right].key - swap(index, child_right) - heap_down(child_left) - end + right_child = 2 * index + 2 + left_child = 2 * index + 1 + max_length = @store.length + smallest = left_child # default for when right_child is nil + if left_child >= max_length #only check the left child + return end + + if @store[right_child] + smallest = @store[left_child].key > @store[right_child].key ? right_child : left_child + end + + if @store[smallest].key < @store[index].key + swap(smallest, index) + heap_down(smallest) + else + return + end end # If you want a swap method... you're welcome diff --git a/test/heapsort_test.rb b/test/heap_sort_test.rb similarity index 80% rename from test/heapsort_test.rb rename to test/heap_sort_test.rb index 34402ac..76e3fdc 100644 --- a/test/heapsort_test.rb +++ b/test/heap_sort_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]