From 70979f997fbb403bb0149fecc1e23ae98a451d35 Mon Sep 17 00:00:00 2001 From: Evelynn Kaplan Date: Thu, 19 Sep 2019 21:43:41 -0700 Subject: [PATCH 1/6] completed add and heap_up --- lib/min_heap.rb | 23 ++++++++++++++------- test/min_heap_test.rb | 48 +++++++++++++++++++++---------------------- 2 files changed, 40 insertions(+), 31 deletions(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 6eaa630..36f9344 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -8,7 +8,6 @@ def initialize(key, value) end class MinHeap - def initialize @store = [] end @@ -17,7 +16,11 @@ def initialize # Time Complexity: ? # Space Complexity: ? def add(key, value = key) - raise NotImplementedError, "Method not implemented yet..." + new_node = HeapNode.new(key, value) + @store << new_node + + return if @store.length < 2 + heap_up(@store.length - 1) end # This method removes and returns an element from the heap @@ -28,7 +31,6 @@ def remove() raise NotImplementedError, "Method not implemented yet..." end - # Used for Testing def to_s return "[]" if @store.empty? @@ -39,7 +41,7 @@ def to_s end output += @store.last.value + "]" - + return output end @@ -58,10 +60,17 @@ def empty? # Time complexity: ? # Space complexity: ? def heap_up(index) - + return if index == 0 + parent_index = (index - 1) / 2 + if @store[parent_index].key > @store[index].key + swap(parent_index, index) + return heap_up(parent_index) + else + return + 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) @@ -74,4 +83,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..b53de88 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 @@ -51,31 +51,31 @@ expect(output).must_equal "[Donuts, Pizza, Pasta, Soup, Cookies, Cake]" 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") + # 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") - # 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" - end -end \ No newline at end of file + # # Another assert + # expect(removed).must_equal "Pasta" + # end +end From d3399fdf38a7eaca4511c489ffa537467bcaa994 Mon Sep 17 00:00:00 2001 From: Evelynn Kaplan Date: Thu, 19 Sep 2019 21:55:37 -0700 Subject: [PATCH 2/6] completed heap_down, remove, and empty? --- lib/min_heap.rb | 16 +++++++++++++--- test/min_heap_test.rb | 42 +++++++++++++++++++++--------------------- 2 files changed, 34 insertions(+), 24 deletions(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 36f9344..16f3781 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -28,7 +28,11 @@ def add(key, value = key) # Time Complexity: ? # Space Complexity: ? def remove() - raise NotImplementedError, "Method not implemented yet..." + swap(0, @store.length - 1) + root_value = @store.pop.value + + heap_down(0) + return root_value end # Used for Testing @@ -49,7 +53,7 @@ def to_s # Time complexity: ? # Space complexity: ? def empty? - raise NotImplementedError, "Method not implemented yet..." + return @store.length == 0 end private @@ -74,7 +78,13 @@ def heap_up(index) # 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_i = index * 2 + 1 + right_child_i = index * 2 + 2 + return if @store[left_child_i] == nil + + smaller_child_i = @store[left_child_i].key <= @store[right_child_i].key ? left_child_i : right_child_i + swap(index, smaller_child_i) + return heap_down(smaller_child_i) end # If you want a swap method... you're welcome diff --git a/test/min_heap_test.rb b/test/min_heap_test.rb index b53de88..6b1a05b 100644 --- a/test/min_heap_test.rb +++ b/test/min_heap_test.rb @@ -51,31 +51,31 @@ expect(output).must_equal "[Donuts, Pizza, Pasta, Soup, Cookies, Cake]" 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") + 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") - # # 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" - # end + # Another assert + expect(removed).must_equal "Pasta" + end end From 68c3d5f156c7258a3af9165a03a72c92c9a1daa9 Mon Sep 17 00:00:00 2001 From: Evelynn Kaplan Date: Thu, 19 Sep 2019 21:59:15 -0700 Subject: [PATCH 3/6] added space/time complexity --- lib/min_heap.rb | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 16f3781..b249c53 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -13,8 +13,8 @@ def initialize end # This method adds a HeapNode instance to the heap - # Time Complexity: ? - # Space Complexity: ? + # Time Complexity: O(log n) where n is the number of elements in the heap + # Space Complexity: O(1) def add(key, value = key) new_node = HeapNode.new(key, value) @store << new_node @@ -25,8 +25,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) where n is the number of elements in the heap + # Space Complexity: O(1) def remove() swap(0, @store.length - 1) root_value = @store.pop.value @@ -50,8 +50,8 @@ def to_s end # This method returns true if the heap is empty - # Time complexity: ? - # Space complexity: ? + # Time complexity: O(n) where n is the number of elements in the array + # Space complexity: O(1) def empty? return @store.length == 0 end @@ -61,8 +61,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) where n is the number of elements in the heap + # Space complexity: O(1) def heap_up(index) return if index == 0 parent_index = (index - 1) / 2 From 36a859b94951559ad433cd23a2aab82885a5854e Mon Sep 17 00:00:00 2001 From: Evelynn Kaplan Date: Fri, 20 Sep 2019 19:29:53 -0700 Subject: [PATCH 4/6] completed heapsort --- lib/heap_sort.rb | 24 ++++++++++++++++++++---- lib/min_heap.rb | 13 ++++++++++--- test/heapsort_test.rb | 16 +++++++++------- 3 files changed, 39 insertions(+), 14 deletions(-) diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb index c8a32a4..dfd0189 100644 --- a/lib/heap_sort.rb +++ b/lib/heap_sort.rb @@ -1,8 +1,24 @@ - +require_relative "./min_heap" +require "pry" # This method uses a heap to sort an array. # Time Complexity: ? # Space Complexity: ? -def heap_sort(list) - raise NotImplementedError, "Method not implemented yet..." -end \ No newline at end of file +def heapsort(list) + heap = MinHeap.new + counter = list.length + + # Remove each item from array and add to heap + counter.times do + node = list.pop + heap.add(node) + end + + # Remove each item from heap and add back to array + counter.times do + element = heap.remove + list.push(element) + end + + return list +end diff --git a/lib/min_heap.rb b/lib/min_heap.rb index b249c53..743bc2b 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -82,9 +82,16 @@ def heap_down(index) right_child_i = index * 2 + 2 return if @store[left_child_i] == nil - smaller_child_i = @store[left_child_i].key <= @store[right_child_i].key ? left_child_i : right_child_i - swap(index, smaller_child_i) - return heap_down(smaller_child_i) + smaller_child_i = left_child_i + if @store[right_child_i] != nil + smaller_child_i = (@store[left_child_i].key <= @store[right_child_i].key) ? left_child_i : right_child_i + end + if @store[index].key > @store[smaller_child_i].key + swap(index, smaller_child_i) + return heap_down(smaller_child_i) + else + return + 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..85118ca 100644 --- a/test/heapsort_test.rb +++ b/test/heapsort_test.rb @@ -1,8 +1,9 @@ require_relative "test_helper" +require "pry" -xdescribe "heapsort" do +describe "heapsort" do it "sorts an empty array" do - # Arrange + # Arrange list = [] # Act @@ -13,7 +14,7 @@ end it "can sort a 1-element array" do - # Arrange + # Arrange list = [5] # Act @@ -22,15 +23,16 @@ # Assert expect(result).must_equal [5] end - + it "can sort a 5-element array" do - # Arrange + # Arrange list = [5, 27, 3, 16, -50] # Act + # binding.pry result = heapsort(list) # Assert expect(result).must_equal [-50, 3, 5, 16, 27] - end -end \ No newline at end of file + end +end From 7057b70a34ff0394bb35b43028d2cfd02a713998 Mon Sep 17 00:00:00 2001 From: Evelynn Kaplan Date: Mon, 30 Sep 2019 21:40:56 -0700 Subject: [PATCH 5/6] added space/time complexity --- lib/heap_sort.rb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/heap_sort.rb b/lib/heap_sort.rb index dfd0189..5cb3af0 100644 --- a/lib/heap_sort.rb +++ b/lib/heap_sort.rb @@ -2,8 +2,8 @@ require "pry" # This method uses a heap to sort an array. -# Time Complexity: ? -# Space Complexity: ? +# Time Complexity: O (n log n) where n is the number of items in the list. The two loops are O(n) and adding/removing from a heap is O (log n). Inserting/removing from an array is O(n). +# Space Complexity: O(n) where n is the number of items in the list because you are creating a new heap that needs to store n number of items. def heapsort(list) heap = MinHeap.new counter = list.length From 6b0d067fa37e658f9eb8c5e3c50e349d235515fc Mon Sep 17 00:00:00 2001 From: Evelynn Kaplan Date: Thu, 3 Oct 2019 13:40:07 -0700 Subject: [PATCH 6/6] added comment --- lib/min_heap.rb | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lib/min_heap.rb b/lib/min_heap.rb index 743bc2b..2200421 100644 --- a/lib/min_heap.rb +++ b/lib/min_heap.rb @@ -82,10 +82,12 @@ def heap_down(index) right_child_i = index * 2 + 2 return if @store[left_child_i] == nil + # Find smaller child. smaller_child_i = left_child_i if @store[right_child_i] != nil smaller_child_i = (@store[left_child_i].key <= @store[right_child_i].key) ? left_child_i : right_child_i end + if @store[index].key > @store[smaller_child_i].key swap(index, smaller_child_i) return heap_down(smaller_child_i)