From b2c98c0c37ae36027a1c0948dcbee7271b66330c Mon Sep 17 00:00:00 2001 From: Elle Kosling Date: Sat, 21 Sep 2019 15:08:36 -0700 Subject: [PATCH 1/2] Finished add, remove, empty, and helper methods for min_heap. --- lib/heap_sort.rb | 4 +++- lib/min_heap.rb | 51 ++++++++++++++++++++++++++++++++++++++++++------ 2 files changed, 48 insertions(+), 7 deletions(-) diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb index c8a32a4..f5df479 100644 --- a/lib/heap_sort.rb +++ b/lib/heap_sort.rb @@ -4,5 +4,7 @@ # Time Complexity: ? # Space Complexity: ? def heap_sort(list) - raise NotImplementedError, "Method not implemented yet..." + return list if list.length < 2 + + end \ No newline at end of file diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 6eaa630..9899f55 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -17,7 +17,9 @@ def initialize # Time Complexity: ? # Space Complexity: ? def add(key, value = key) - raise NotImplementedError, "Method not implemented yet..." + @store << HeapNode.new(key, value) + index = @store.length-1 + heap_up(index) end # This method removes and returns an element from the heap @@ -25,7 +27,11 @@ def add(key, value = key) # Time Complexity: ? # Space Complexity: ? def remove() - raise NotImplementedError, "Method not implemented yet..." + return nil if empty? + swap(0, @store.length-1) + removed_item = @store.pop + heap_down(0) + return removed_item.value end @@ -47,7 +53,7 @@ def to_s # Time complexity: ? # Space complexity: ? def empty? - raise NotImplementedError, "Method not implemented yet..." + return @store.empty? end private @@ -58,14 +64,32 @@ def empty? # Time complexity: ? # Space complexity: ? def heap_up(index) - + return if index == 0 + parent_index = find_parent_index(index) + if @store[parent_index].key > @store[index].key + swap(parent_index, index) + heap_up(parent_index) + end + return 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..." + def heap_down(parent_index) + left_child_index = find_left_child_index(parent_index) + right_child_index = find_right_child_index(parent_index) + + return if !@store[left_child_index] + + if !@store[right_child_index] || @store[left_child_index].key < @store[right_child_index].key + swap(left_child_index, parent_index) + heap_down(left_child_index) + else + puts "***** here ****" + swap(right_child_index, parent_index) + heap_down(right_child_index) + end end # If you want a swap method... you're welcome @@ -74,4 +98,19 @@ def swap(index_1, index_2) @store[index_1] = @store[index_2] @store[index_2] = temp end + + # These helper methods find the index of the + # current item's parent node, and the indices + # of its left and right children + def find_parent_index(node_index) + return ((node_index-1)/2).floor + end + + def find_left_child_index(node_index) + return node_index * 2 + 1 + end + + def find_right_child_index(node_index) + return node_index * 2 + 2 + end end \ No newline at end of file From 90d9427795afacd6437e189ae9d48cd01a072195 Mon Sep 17 00:00:00 2001 From: Elle Kosling Date: Sat, 28 Sep 2019 17:55:42 -0700 Subject: [PATCH 2/2] Wrote heap sort method, added time and space complexities. --- lib/heap_sort.rb | 28 ++++++++++++++++++++++------ lib/min_heap.rb | 39 ++++++++++++++++++++------------------- test/heapsort_test.rb | 2 +- 3 files changed, 43 insertions(+), 26 deletions(-) diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb index f5df479..b058698 100644 --- a/lib/heap_sort.rb +++ b/lib/heap_sort.rb @@ -1,10 +1,26 @@ - +require_relative "min_heap" +# require 'pry' # This method uses a heap to sort an array. -# Time Complexity: ? -# Space Complexity: ? -def heap_sort(list) +# Time Complexity: O(nlogn),where n is the number of items in the list, +# because the add and remove methods are O(nlogn) +# Space Complexity: O(2n), where n is the number of items in the list +def heapsort(list) return list if list.length < 2 - -end \ No newline at end of file + heap = MinHeap.new + + i = 0 + list.each do + heap.add(list[i]) + i += 1 + end + + i = 0 + until i == list.length + list[i] = heap.remove + i += 1 + end + + return list +end diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 9899f55..50b9564 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -14,23 +14,23 @@ def initialize end # This method adds a HeapNode instance to the heap - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(nlogn) because heap_up is nlogn, where n is the number of nodes in the heap + # Space Complexity: O(1) def add(key, value = key) @store << HeapNode.new(key, value) index = @store.length-1 - heap_up(index) + heap_up(index) if @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(nlogn), where n is the number of nodes in the heap + # Space Complexity: O(1) def remove() return nil if empty? swap(0, @store.length-1) removed_item = @store.pop - heap_down(0) + heap_down(0) if @store.length > 1 return removed_item.value end @@ -50,8 +50,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 @@ -61,16 +61,15 @@ 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(nlogn), where n is the number of nodes in the heap + # Space Complexity: O(1) def heap_up(index) return if index == 0 - parent_index = find_parent_index(index) + parent_index = find_parent_index(index) # O(1) if @store[parent_index].key > @store[index].key - swap(parent_index, index) + swap(parent_index, index) # O(1) heap_up(parent_index) end - return end # This helper method takes an index and @@ -79,16 +78,18 @@ def heap_up(index) def heap_down(parent_index) left_child_index = find_left_child_index(parent_index) right_child_index = find_right_child_index(parent_index) + smallest = 0 return if !@store[left_child_index] - + if !@store[right_child_index] || @store[left_child_index].key < @store[right_child_index].key - swap(left_child_index, parent_index) - heap_down(left_child_index) + smallest = left_child_index else - puts "***** here ****" - swap(right_child_index, parent_index) - heap_down(right_child_index) + smallest = right_child_index + end + + if @store[smallest].key < @store[parent_index].key + swap(smallest, parent_index) end end 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 = []