From 78628831d2ebde3e4ef613cc6d35bd181fd37440 Mon Sep 17 00:00:00 2001 From: Sharon Cheung Date: Thu, 24 Sep 2020 19:43:16 -0700 Subject: [PATCH 1/4] finished min_heap --- lib/min_heap.rb | 51 ++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 44 insertions(+), 7 deletions(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 6eaa630..fdc0507 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -17,7 +17,8 @@ def initialize # Time Complexity: ? # Space Complexity: ? 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 @@ -25,7 +26,14 @@ def add(key, value = key) # Time Complexity: ? # Space Complexity: ? def remove() - raise NotImplementedError, "Method not implemented yet..." + # min heap always remove the smallest element + return nil if @store.empty? + # swap it with the last node, so we can just pop off the last node in the heap + swap(0, @store.length - 1) + result = @store.pop + + heap_down(0) unless @store.empty? + return result.value end @@ -47,7 +55,7 @@ def to_s # Time complexity: ? # Space complexity: ? def empty? - raise NotImplementedError, "Method not implemented yet..." + return @store.empty? end private @@ -55,17 +63,46 @@ 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(1) + # Space complexity: O(log n) def heap_up(index) - + return if index == 0 # root node + # compare the new node with its parent + # if out of order, swap + parent = (index - 1) / 2 + if @store[index].key < @store[parent].key + swap(index, parent) + heap_up(parent) + 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..." + # will stop when it reached the leave node + + return if index == @store.length + left_child = 2 * index + 1 + right_child = 2 * index + 2 + # compare to the smallest child for min heap + if right_child < @store.length + if @store[left_child].key > @store[right_child].key + smallest_child = right_child + else + smallest_child = left_child + end + + if @store[index].key > @store[smallest_child].key + swap(index, smallest_child) + heap_down(smallest_child) + end + elsif left_child < @store.length + if @store[index].key > @store[left_child].key + swap(index, left_child) + end + end end # If you want a swap method... you're welcome From 5b8a1c4c955411bc179bec511fa357df75993f74 Mon Sep 17 00:00:00 2001 From: Sharon Cheung Date: Thu, 24 Sep 2020 19:46:07 -0700 Subject: [PATCH 2/4] added complexity answers --- lib/min_heap.rb | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index fdc0507..c8a6cd6 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) @store << HeapNode.new(key, value) heap_up(@store.length - 1) @@ -23,8 +23,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() # min heap always remove the smallest element return nil if @store.empty? @@ -52,8 +52,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 From 610a702af9d9f9ab5397f67abc61d7d679df09ce Mon Sep 17 00:00:00 2001 From: Sharon Cheung Date: Sun, 27 Sep 2020 17:05:08 -0700 Subject: [PATCH 3/4] heap sort test passed --- lib/heap_sort.rb | 21 +++++++++++++++++---- test/heapsort_test.rb | 2 +- 2 files changed, 18 insertions(+), 5 deletions(-) diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb index c8a32a4..931adf1 100644 --- a/lib/heap_sort.rb +++ b/lib/heap_sort.rb @@ -1,8 +1,21 @@ # 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 + + list.each do |num| + heap.add(num) + end + + result = [] + i = 0 + while i < list.length + result << heap.remove() + i += 1 + end + + return result end \ No newline at end of file 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 4175b0c935dfb0a087ad75c833fdae58d61236ab Mon Sep 17 00:00:00 2001 From: Sharon Cheung Date: Sun, 27 Sep 2020 17:12:39 -0700 Subject: [PATCH 4/4] updated complexity --- lib/min_heap.rb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index c8a6cd6..6cb20df 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -15,7 +15,7 @@ def initialize # This method adds a HeapNode instance to the heap # Time Complexity: O(log n) - # Space Complexity: O(1) + # Space Complexity: O(log n) def add(key, value = key) @store << HeapNode.new(key, value) heap_up(@store.length - 1) @@ -24,7 +24,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) - # Space Complexity: O(1) + # Space Complexity: O(log n) def remove() # min heap always remove the smallest element return nil if @store.empty? @@ -63,7 +63,7 @@ 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(1) + # Time complexity: O(log n) # Space complexity: O(log n) def heap_up(index) return if index == 0 # root node