From 1389836726e8aabd986e3fac578d27eb067f8dd6 Mon Sep 17 00:00:00 2001 From: Amy Wyatt Date: Sat, 28 Sep 2019 16:16:16 -0700 Subject: [PATCH 1/4] min_heap methods passing --- lib/min_heap.rb | 71 ++++++++++++++++++++++++++++++++----------- test/min_heap_test.rb | 44 +++++++++++++-------------- 2 files changed, 75 insertions(+), 40 deletions(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 6eaa630..f2b87d3 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -8,26 +8,34 @@ def initialize(key, value) end class MinHeap - def initialize @store = [] end # This method adds a HeapNode instance to the heap - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(logn) where n is the length of the heap + # Space Complexity: 0(1) 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(logn) where n is the length of the heap + # Space Complexity: 0(1) def remove() - raise NotImplementedError, "Method not implemented yet..." - end + if @store.empty? + return nil + end + swap(0, @store.length - 1) + result = @store.pop + + heap_down(0) unless @store.empty? + return result.value + end # Used for Testing def to_s @@ -39,15 +47,15 @@ def to_s end output += @store.last.value + "]" - + return output end # This method returns true if the heap is empty - # Time complexity: ? - # Space complexity: ? + # Time complexity: O(n) where n is the length of @store + # Space complexity: O(1) def empty? - raise NotImplementedError, "Method not implemented yet..." + return @store.length == 0 end private @@ -55,17 +63,44 @@ 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(logn) where n is the length of the heap + # Space Complexity: 0(1) def heap_up(index) - + parent_node_index = index.odd? ? (index - 1) / 2 : (index - 2) / 2 + + if @store[index].key >= @store[parent_node_index].key || index == 0 + return + else + swap(index, parent_node_index) + heap_up(parent_node_index) + end end - # This helper method takes an index and + # 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 = 2 * index + 1 + right_child = 2 * index + 2 + + if @store[left_child] == nil + return + end + + if @store[right_child] == nil && store[index].key <= @store[left_child].key + swap(index, left_child) + return + end + + if @store[index].key <= @store[left_child].key && @store[index].key <= @store[right_child].key || index == @store.length - 1 + return + elsif @store[left_child].key > @store[right_child].key + swap(index, right_child) + heap_down(right_child) + else + swap(index, left_child) + heap_down(left_child) + end end # If you want a swap method... you're welcome @@ -74,4 +109,4 @@ def swap(index_1, index_2) @store[index_1] = @store[index_2] @store[index_2] = temp end -end \ No newline at end of file +end diff --git a/test/min_heap_test.rb b/test/min_heap_test.rb index 186d4c2..6b1a05b 100644 --- a/test/min_heap_test.rb +++ b/test/min_heap_test.rb @@ -1,9 +1,9 @@ require_relative "test_helper" describe "Heap" do - let(:heap) {MinHeap.new} + let(:heap) { MinHeap.new } it "can be created" do - + # Assert expect(heap).must_be_instance_of MinHeap end @@ -52,30 +52,30 @@ end it "can remove nodes in the proper order" do - # Arrange - heap.add(3, "Pasta") - heap.add(6, "Soup") - heap.add(1, "Pizza") - heap.add(0, "Donuts") - heap.add(16, "Cookies") - heap.add(57, "Cake") + # Arrange + heap.add(3, "Pasta") + heap.add(6, "Soup") + heap.add(1, "Pizza") + heap.add(0, "Donuts") + heap.add(16, "Cookies") + heap.add(57, "Cake") - # Act - removed = heap.remove + # Act + removed = heap.remove - # Assert - expect(removed).must_equal "Donuts" + # Assert + expect(removed).must_equal "Donuts" - # Another Act - removed = heap.remove + # Another Act + removed = heap.remove - # Another assert - expect(removed).must_equal "Pizza" + # Another assert + expect(removed).must_equal "Pizza" - # Another Act - removed = heap.remove + # Another Act + removed = heap.remove - # Another assert - expect(removed).must_equal "Pasta" + # Another assert + expect(removed).must_equal "Pasta" end -end \ No newline at end of file +end From 0f235738b0b3066f7582e9998e458b1df348d52d Mon Sep 17 00:00:00 2001 From: Amy Wyatt Date: Sat, 28 Sep 2019 16:33:35 -0700 Subject: [PATCH 2/4] simplified heap_down --- lib/min_heap.rb | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index f2b87d3..1c6cd8e 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -85,21 +85,16 @@ def heap_down(index) if @store[left_child] == nil return - end - - if @store[right_child] == nil && store[index].key <= @store[left_child].key + elsif @store[right_child] == nil && @store[index].key > @store[left_child].key swap(index, left_child) return - end - - if @store[index].key <= @store[left_child].key && @store[index].key <= @store[right_child].key || index == @store.length - 1 - return - elsif @store[left_child].key > @store[right_child].key - swap(index, right_child) - heap_down(right_child) else - swap(index, left_child) - heap_down(left_child) + min_child = @store[right_child].key < @store[left_child].key ? right_child : left_child + + if @store[index].key > @store[min_child].key + swap(index, min_child) + heap_down(min_child) + end end end From 09ddae402390bff0c3cfe506a5e6a47dd851cfb1 Mon Sep 17 00:00:00 2001 From: Amy Wyatt Date: Sat, 28 Sep 2019 17:42:47 -0700 Subject: [PATCH 3/4] heap_sort passing tests --- lib/heap_sort.rb | 24 ++++++++++++++++++------ lib/min_heap.rb | 2 ++ test/heapsort_test.rb | 20 ++++++++++---------- 3 files changed, 30 insertions(+), 16 deletions(-) diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb index c8a32a4..40abd5c 100644 --- a/lib/heap_sort.rb +++ b/lib/heap_sort.rb @@ -1,8 +1,20 @@ - - +require_relative "./min_heap.rb" # This method uses a heap to sort an array. -# Time Complexity: ? -# Space Complexity: ? +# Time Complexity: O(n(log(n)) where n is the length of the list +# Space Complexity: O(n) where n is the length of the list def heap_sort(list) - raise NotImplementedError, "Method not implemented yet..." -end \ No newline at end of file + sorted_list = [] + + if list.length < 2 + return list + else + heap = MinHeap.new() + + list.each { |list_item| heap.add(list_item) } + + while !heap.empty? + sorted_list << heap.remove() + end + return sorted_list + end +end diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 1c6cd8e..319d99f 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -88,6 +88,8 @@ def heap_down(index) elsif @store[right_child] == nil && @store[index].key > @store[left_child].key swap(index, left_child) return + elsif @store[right_child] == nil + return else min_child = @store[right_child].key < @store[left_child].key ? right_child : left_child diff --git a/test/heapsort_test.rb b/test/heapsort_test.rb index 34402ac..614a799 100644 --- a/test/heapsort_test.rb +++ b/test/heapsort_test.rb @@ -1,36 +1,36 @@ require_relative "test_helper" -xdescribe "heapsort" do +describe "heap_sort" do it "sorts an empty array" do - # Arrange + # Arrange list = [] # Act - result = heapsort(list) + result = heap_sort(list) # Assert expect(result).must_equal [] end it "can sort a 1-element array" do - # Arrange + # Arrange list = [5] # Act - result = heapsort(list) + result = heap_sort(list) # Assert expect(result).must_equal [5] end - + it "can sort a 5-element array" do - # Arrange + # Arrange list = [5, 27, 3, 16, -50] # Act - result = heapsort(list) + result = heap_sort(list) # Assert expect(result).must_equal [-50, 3, 5, 16, 27] - end -end \ No newline at end of file + end +end From 213ec59b5fc4be6faf45187b71c3196fc9f78dba Mon Sep 17 00:00:00 2001 From: Amy Wyatt Date: Thu, 3 Oct 2019 13:39:48 -0700 Subject: [PATCH 4/4] updated space 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 319d99f..7ea30e7 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -14,7 +14,7 @@ def initialize # This method adds a HeapNode instance to the heap # Time Complexity: O(logn) where n is the length of the heap - # Space Complexity: 0(1) + # Space Complexity: 0(logn) def add(key, value = key) @store << HeapNode.new(key, value) @@ -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(logn) where n is the length of the heap - # Space Complexity: 0(1) + # Space Complexity: 0(logn) def remove() if @store.empty? return nil @@ -64,7 +64,7 @@ def empty? # 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(logn) where n is the length of the heap - # Space Complexity: 0(1) + # Space Complexity: 0(logn) def heap_up(index) parent_node_index = index.odd? ? (index - 1) / 2 : (index - 2) / 2